Add `@astrojs/webapi` package (#2729)@astrojs/webapi@0.11.0

* chore: add @astrojs/webapi

* chore: update package.json

* fix: update file case

* fix: remove lowercase file

* chore: update tests to use mocha

* chore: update LICENSE

1 files changed, 9465 insertions, 0 deletions

diff --git a/packages/webapi/mod.js b/packages/webapi/mod.js
new file mode 100644
index 000000000..785fb7663
--- /dev/null
+++ b/packages/webapi/mod.js
@@ -0,0 +1,9465 @@
+import { setTimeout as setTimeout$1, clearTimeout as clearTimeout$1 } from 'node:timers';
+import http from 'node:http';
+import https from 'node:https';
+import zlib from 'node:zlib';
+import Stream, { PassThrough, pipeline as pipeline$1 } from 'node:stream';
+import { promisify, deprecate, types } from 'node:util';
+import { format as format$1 } from 'node:url';
+import { isIP } from 'node:net';
+import { performance } from 'node:perf_hooks';
+
+/** Returns the function bound to the given object. */
+const __function_bind = Function.bind.bind(Function.call);
+/** Returns the function called with the specified values. */
+Function.call.bind(Function.call);
+/** Returns whether an object has a property with the specified name. */
+const __object_hasOwnProperty = Function.call.bind(Object.prototype.hasOwnProperty);
+/** Returns a string representation of an object. */
+Function.call.bind(Object.prototype.toString);
+/** Returns whether the object prototype exists in another object. */
+const __object_isPrototypeOf = Function.call.bind(Object.prototype.isPrototypeOf);
+/** Current high resolution millisecond timestamp. */
+const __performance_now = performance.now;
+/** Returns the string escaped for use inside regular expressions. */
+const __string_escapeRegExp = (value) => value.replace(/[\\^$*+?.()|[\]{}]/g, '\\$&');
+// @ts-ignore
+const INTERNALS$3 = new WeakMap();
+const internalsOf = (target, className, propName) => {
+    const internals = INTERNALS$3.get(target);
+    if (!internals)
+        throw new TypeError(`${className}.${propName} can only be used on instances of ${className}`);
+    return internals;
+};
+const allowStringTag = (value) => value.prototype[Symbol.toStringTag] = value.name;
+/** Returns any kind of path as a posix path. */
+const pathToPosix = (pathname) => String(pathname == null ? '' : pathname).replace(
+// convert slashes
+/\\+/g, '/').replace(
+// prefix a slash to drive letters
+/^(?=[A-Za-z]:\/)/, '/').replace(
+// encode path characters
+/%/g, '%25').replace(/\n/g, '%0A').replace(/\r/g, '%0D').replace(/\t/g, '%09');
+
+class DOMException extends Error {
+    constructor(message = '', name = 'Error') {
+        super(message);
+        this.code = 0;
+        this.name = name;
+    }
+}
+DOMException.INDEX_SIZE_ERR = 1;
+DOMException.DOMSTRING_SIZE_ERR = 2;
+DOMException.HIERARCHY_REQUEST_ERR = 3;
+DOMException.WRONG_DOCUMENT_ERR = 4;
+DOMException.INVALID_CHARACTER_ERR = 5;
+DOMException.NO_DATA_ALLOWED_ERR = 6;
+DOMException.NO_MODIFICATION_ALLOWED_ERR = 7;
+DOMException.NOT_FOUND_ERR = 8;
+DOMException.NOT_SUPPORTED_ERR = 9;
+DOMException.INUSE_ATTRIBUTE_ERR = 10;
+DOMException.INVALID_STATE_ERR = 11;
+DOMException.SYNTAX_ERR = 12;
+DOMException.INVALID_MODIFICATION_ERR = 13;
+DOMException.NAMESPACE_ERR = 14;
+DOMException.INVALID_ACCESS_ERR = 15;
+DOMException.VALIDATION_ERR = 16;
+DOMException.TYPE_MISMATCH_ERR = 17;
+DOMException.SECURITY_ERR = 18;
+DOMException.NETWORK_ERR = 19;
+DOMException.ABORT_ERR = 20;
+DOMException.URL_MISMATCH_ERR = 21;
+DOMException.QUOTA_EXCEEDED_ERR = 22;
+DOMException.TIMEOUT_ERR = 23;
+DOMException.INVALID_NODE_TYPE_ERR = 24;
+DOMException.DATA_CLONE_ERR = 25;
+allowStringTag(DOMException);
+
+/**
+ * Assert a condition.
+ * @param condition The condition that it should satisfy.
+ * @param message The error message.
+ * @param args The arguments for replacing placeholders in the message.
+ */
+function assertType(condition, message, ...args) {
+    if (!condition) {
+        throw new TypeError(format(message, args));
+    }
+}
+/**
+ * Convert a text and arguments to one string.
+ * @param message The formating text
+ * @param args The arguments.
+ */
+function format(message, args) {
+    let i = 0;
+    return message.replace(/%[os]/gu, () => anyToString(args[i++]));
+}
+/**
+ * Convert a value to a string representation.
+ * @param x The value to get the string representation.
+ */
+function anyToString(x) {
+    if (typeof x !== "object" || x === null) {
+        return String(x);
+    }
+    return Object.prototype.toString.call(x);
+}
+
+let currentErrorHandler;
+/**
+ * Print a error message.
+ * @param maybeError The error object.
+ */
+function reportError(maybeError) {
+    try {
+        const error = maybeError instanceof Error
+            ? maybeError
+            : new Error(anyToString(maybeError));
+        // Call the user-defined error handler if exists.
+        if (currentErrorHandler) ;
+        // Dispatch an `error` event if this is on a browser.
+        if (typeof dispatchEvent === "function" &&
+            typeof ErrorEvent === "function") {
+            dispatchEvent(new ErrorEvent("error", { error, message: error.message }));
+        }
+        // Emit an `uncaughtException` event if this is on Node.js.
+        //istanbul ignore else
+        else if (typeof process !== "undefined" &&
+            typeof process.emit === "function") {
+            process.emit("uncaughtException", error);
+            return;
+        }
+        // Otherwise, print the error.
+        console.error(error);
+    }
+    catch (_a) {
+        // ignore.
+    }
+}
+
+let currentWarnHandler;
+/**
+ * The warning information.
+ */
+class Warning {
+    constructor(code, message) {
+        this.code = code;
+        this.message = message;
+    }
+    /**
+     * Report this warning.
+     * @param args The arguments of the warning.
+     */
+    warn(...args) {
+        var _a;
+        try {
+            // Call the user-defined warning handler if exists.
+            if (currentWarnHandler) ;
+            // Otherwise, print the warning.
+            const stack = ((_a = new Error().stack) !== null && _a !== void 0 ? _a : "").replace(/^(?:.+?\n){2}/gu, "\n");
+            console.warn(this.message, ...args, stack);
+        }
+        catch (_b) {
+            // Ignore.
+        }
+    }
+}
+
+const InitEventWasCalledWhileDispatching = new Warning("W01", "Unable to initialize event under dispatching.");
+const FalsyWasAssignedToCancelBubble = new Warning("W02", "Assigning any falsy value to 'cancelBubble' property has no effect.");
+const TruthyWasAssignedToReturnValue = new Warning("W03", "Assigning any truthy value to 'returnValue' property has no effect.");
+const NonCancelableEventWasCanceled = new Warning("W04", "Unable to preventDefault on non-cancelable events.");
+const CanceledInPassiveListener = new Warning("W05", "Unable to preventDefault inside passive event listener invocation.");
+const EventListenerWasDuplicated = new Warning("W06", "An event listener wasn't added because it has been added already: %o, %o");
+const OptionWasIgnored = new Warning("W07", "The %o option value was abandoned because the event listener wasn't added as duplicated.");
+const InvalidEventListener = new Warning("W08", "The 'callback' argument must be a function or an object that has 'handleEvent' method: %o");
+const InvalidAttributeHandler = new Warning("W09", "Event attribute handler must be a function: %o");
+
+/*eslint-disable class-methods-use-this */
+/**
+ * An implementation of `Event` interface, that wraps a given event object.
+ * `EventTarget` shim can control the internal state of this `Event` objects.
+ * @see https://dom.spec.whatwg.org/#event
+ */
+class Event {
+    /**
+     * @see https://dom.spec.whatwg.org/#dom-event-none
+     */
+    static get NONE() {
+        return NONE;
+    }
+    /**
+     * @see https://dom.spec.whatwg.org/#dom-event-capturing_phase
+     */
+    static get CAPTURING_PHASE() {
+        return CAPTURING_PHASE;
+    }
+    /**
+     * @see https://dom.spec.whatwg.org/#dom-event-at_target
+     */
+    static get AT_TARGET() {
+        return AT_TARGET;
+    }
+    /**
+     * @see https://dom.spec.whatwg.org/#dom-event-bubbling_phase
+     */
+    static get BUBBLING_PHASE() {
+        return BUBBLING_PHASE;
+    }
+    /**
+     * Initialize this event instance.
+     * @param type The type of this event.
+     * @param eventInitDict Options to initialize.
+     * @see https://dom.spec.whatwg.org/#dom-event-event
+     */
+    constructor(type, eventInitDict) {
+        Object.defineProperty(this, "isTrusted", {
+            value: false,
+            enumerable: true,
+        });
+        const opts = eventInitDict !== null && eventInitDict !== void 0 ? eventInitDict : {};
+        internalDataMap.set(this, {
+            type: String(type),
+            bubbles: Boolean(opts.bubbles),
+            cancelable: Boolean(opts.cancelable),
+            composed: Boolean(opts.composed),
+            target: null,
+            currentTarget: null,
+            stopPropagationFlag: false,
+            stopImmediatePropagationFlag: false,
+            canceledFlag: false,
+            inPassiveListenerFlag: false,
+            dispatchFlag: false,
+            timeStamp: Date.now(),
+        });
+    }
+    /**
+     * The type of this event.
+     * @see https://dom.spec.whatwg.org/#dom-event-type
+     */
+    get type() {
+        return $(this).type;
+    }
+    /**
+     * The event target of the current dispatching.
+     * @see https://dom.spec.whatwg.org/#dom-event-target
+     */
+    get target() {
+        return $(this).target;
+    }
+    /**
+     * The event target of the current dispatching.
+     * @deprecated Use the `target` property instead.
+     * @see https://dom.spec.whatwg.org/#dom-event-srcelement
+     */
+    get srcElement() {
+        return $(this).target;
+    }
+    /**
+     * The event target of the current dispatching.
+     * @see https://dom.spec.whatwg.org/#dom-event-currenttarget
+     */
+    get currentTarget() {
+        return $(this).currentTarget;
+    }
+    /**
+     * The event target of the current dispatching.
+     * This doesn't support node tree.
+     * @see https://dom.spec.whatwg.org/#dom-event-composedpath
+     */
+    composedPath() {
+        const currentTarget = $(this).currentTarget;
+        if (currentTarget) {
+            return [currentTarget];
+        }
+        return [];
+    }
+    /**
+     * @see https://dom.spec.whatwg.org/#dom-event-none
+     */
+    get NONE() {
+        return NONE;
+    }
+    /**
+     * @see https://dom.spec.whatwg.org/#dom-event-capturing_phase
+     */
+    get CAPTURING_PHASE() {
+        return CAPTURING_PHASE;
+    }
+    /**
+     * @see https://dom.spec.whatwg.org/#dom-event-at_target
+     */
+    get AT_TARGET() {
+        return AT_TARGET;
+    }
+    /**
+     * @see https://dom.spec.whatwg.org/#dom-event-bubbling_phase
+     */
+    get BUBBLING_PHASE() {
+        return BUBBLING_PHASE;
+    }
+    /**
+     * The current event phase.
+     * @see https://dom.spec.whatwg.org/#dom-event-eventphase
+     */
+    get eventPhase() {
+        return $(this).dispatchFlag ? 2 : 0;
+    }
+    /**
+     * Stop event bubbling.
+     * Because this shim doesn't support node tree, this merely changes the `cancelBubble` property value.
+     * @see https://dom.spec.whatwg.org/#dom-event-stoppropagation
+     */
+    stopPropagation() {
+        $(this).stopPropagationFlag = true;
+    }
+    /**
+     * `true` if event bubbling was stopped.
+     * @deprecated
+     * @see https://dom.spec.whatwg.org/#dom-event-cancelbubble
+     */
+    get cancelBubble() {
+        return $(this).stopPropagationFlag;
+    }
+    /**
+     * Stop event bubbling if `true` is set.
+     * @deprecated Use the `stopPropagation()` method instead.
+     * @see https://dom.spec.whatwg.org/#dom-event-cancelbubble
+     */
+    set cancelBubble(value) {
+        if (value) {
+            $(this).stopPropagationFlag = true;
+        }
+        else {
+            FalsyWasAssignedToCancelBubble.warn();
+        }
+    }
+    /**
+     * Stop event bubbling and subsequent event listener callings.
+     * @see https://dom.spec.whatwg.org/#dom-event-stopimmediatepropagation
+     */
+    stopImmediatePropagation() {
+        const data = $(this);
+        data.stopPropagationFlag = data.stopImmediatePropagationFlag = true;
+    }
+    /**
+     * `true` if this event will bubble.
+     * @see https://dom.spec.whatwg.org/#dom-event-bubbles
+     */
+    get bubbles() {
+        return $(this).bubbles;
+    }
+    /**
+     * `true` if this event can be canceled by the `preventDefault()` method.
+     * @see https://dom.spec.whatwg.org/#dom-event-cancelable
+     */
+    get cancelable() {
+        return $(this).cancelable;
+    }
+    /**
+     * `true` if the default behavior will act.
+     * @deprecated Use the `defaultPrevented` proeprty instead.
+     * @see https://dom.spec.whatwg.org/#dom-event-returnvalue
+     */
+    get returnValue() {
+        return !$(this).canceledFlag;
+    }
+    /**
+     * Cancel the default behavior if `false` is set.
+     * @deprecated Use the `preventDefault()` method instead.
+     * @see https://dom.spec.whatwg.org/#dom-event-returnvalue
+     */
+    set returnValue(value) {
+        if (!value) {
+            setCancelFlag($(this));
+        }
+        else {
+            TruthyWasAssignedToReturnValue.warn();
+        }
+    }
+    /**
+     * Cancel the default behavior.
+     * @see https://dom.spec.whatwg.org/#dom-event-preventdefault
+     */
+    preventDefault() {
+        setCancelFlag($(this));
+    }
+    /**
+     * `true` if the default behavior was canceled.
+     * @see https://dom.spec.whatwg.org/#dom-event-defaultprevented
+     */
+    get defaultPrevented() {
+        return $(this).canceledFlag;
+    }
+    /**
+     * @see https://dom.spec.whatwg.org/#dom-event-composed
+     */
+    get composed() {
+        return $(this).composed;
+    }
+    /**
+     * @see https://dom.spec.whatwg.org/#dom-event-istrusted
+     */
+    //istanbul ignore next
+    get isTrusted() {
+        return false;
+    }
+    /**
+     * @see https://dom.spec.whatwg.org/#dom-event-timestamp
+     */
+    get timeStamp() {
+        return $(this).timeStamp;
+    }
+    /**
+     * @deprecated Don't use this method. The constructor did initialization.
+     */
+    initEvent(type, bubbles = false, cancelable = false) {
+        const data = $(this);
+        if (data.dispatchFlag) {
+            InitEventWasCalledWhileDispatching.warn();
+            return;
+        }
+        internalDataMap.set(this, {
+            ...data,
+            type: String(type),
+            bubbles: Boolean(bubbles),
+            cancelable: Boolean(cancelable),
+            target: null,
+            currentTarget: null,
+            stopPropagationFlag: false,
+            stopImmediatePropagationFlag: false,
+            canceledFlag: false,
+        });
+    }
+}
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+const NONE = 0;
+const CAPTURING_PHASE = 1;
+const AT_TARGET = 2;
+const BUBBLING_PHASE = 3;
+/**
+ * Private data for event wrappers.
+ */
+const internalDataMap = new WeakMap();
+/**
+ * Get private data.
+ * @param event The event object to get private data.
+ * @param name The variable name to report.
+ * @returns The private data of the event.
+ */
+function $(event, name = "this") {
+    const retv = internalDataMap.get(event);
+    assertType(retv != null, "'%s' must be an object that Event constructor created, but got another one: %o", name, event);
+    return retv;
+}
+/**
+ * https://dom.spec.whatwg.org/#set-the-canceled-flag
+ * @param data private data.
+ */
+function setCancelFlag(data) {
+    if (data.inPassiveListenerFlag) {
+        CanceledInPassiveListener.warn();
+        return;
+    }
+    if (!data.cancelable) {
+        NonCancelableEventWasCanceled.warn();
+        return;
+    }
+    data.canceledFlag = true;
+}
+// Set enumerable
+Object.defineProperty(Event, "NONE", { enumerable: true });
+Object.defineProperty(Event, "CAPTURING_PHASE", { enumerable: true });
+Object.defineProperty(Event, "AT_TARGET", { enumerable: true });
+Object.defineProperty(Event, "BUBBLING_PHASE", { enumerable: true });
+const keys$1 = Object.getOwnPropertyNames(Event.prototype);
+for (let i = 0; i < keys$1.length; ++i) {
+    if (keys$1[i] === "constructor") {
+        continue;
+    }
+    Object.defineProperty(Event.prototype, keys$1[i], { enumerable: true });
+}
+
+/**
+ * An implementation of `Event` interface, that wraps a given event object.
+ * This class controls the internal state of `Event`.
+ * @see https://dom.spec.whatwg.org/#interface-event
+ */
+class EventWrapper extends Event {
+    /**
+     * Wrap a given event object to control states.
+     * @param event The event-like object to wrap.
+     */
+    static wrap(event) {
+        return new (getWrapperClassOf(event))(event);
+    }
+    constructor(event) {
+        super(event.type, {
+            bubbles: event.bubbles,
+            cancelable: event.cancelable,
+            composed: event.composed,
+        });
+        if (event.cancelBubble) {
+            super.stopPropagation();
+        }
+        if (event.defaultPrevented) {
+            super.preventDefault();
+        }
+        internalDataMap$1.set(this, { original: event });
+        // Define accessors
+        const keys = Object.keys(event);
+        for (let i = 0; i < keys.length; ++i) {
+            const key = keys[i];
+            if (!(key in this)) {
+                Object.defineProperty(this, key, defineRedirectDescriptor(event, key));
+            }
+        }
+    }
+    stopPropagation() {
+        super.stopPropagation();
+        const { original } = $$1(this);
+        if ("stopPropagation" in original) {
+            original.stopPropagation();
+        }
+    }
+    get cancelBubble() {
+        return super.cancelBubble;
+    }
+    set cancelBubble(value) {
+        super.cancelBubble = value;
+        const { original } = $$1(this);
+        if ("cancelBubble" in original) {
+            original.cancelBubble = value;
+        }
+    }
+    stopImmediatePropagation() {
+        super.stopImmediatePropagation();
+        const { original } = $$1(this);
+        if ("stopImmediatePropagation" in original) {
+            original.stopImmediatePropagation();
+        }
+    }
+    get returnValue() {
+        return super.returnValue;
+    }
+    set returnValue(value) {
+        super.returnValue = value;
+        const { original } = $$1(this);
+        if ("returnValue" in original) {
+            original.returnValue = value;
+        }
+    }
+    preventDefault() {
+        super.preventDefault();
+        const { original } = $$1(this);
+        if ("preventDefault" in original) {
+            original.preventDefault();
+        }
+    }
+    get timeStamp() {
+        const { original } = $$1(this);
+        if ("timeStamp" in original) {
+            return original.timeStamp;
+        }
+        return super.timeStamp;
+    }
+}
+/**
+ * Private data for event wrappers.
+ */
+const internalDataMap$1 = new WeakMap();
+/**
+ * Get private data.
+ * @param event The event object to get private data.
+ * @returns The private data of the event.
+ */
+function $$1(event) {
+    const retv = internalDataMap$1.get(event);
+    assertType(retv != null, "'this' is expected an Event object, but got", event);
+    return retv;
+}
+/**
+ * Cache for wrapper classes.
+ * @type {WeakMap<Object, Function>}
+ * @private
+ */
+const wrapperClassCache = new WeakMap();
+// Make association for wrappers.
+wrapperClassCache.set(Object.prototype, EventWrapper);
+/**
+ * Get the wrapper class of a given prototype.
+ * @param originalEvent The event object to wrap.
+ */
+function getWrapperClassOf(originalEvent) {
+    const prototype = Object.getPrototypeOf(originalEvent);
+    if (prototype == null) {
+        return EventWrapper;
+    }
+    let wrapper = wrapperClassCache.get(prototype);
+    if (wrapper == null) {
+        wrapper = defineWrapper(getWrapperClassOf(prototype), prototype);
+        wrapperClassCache.set(prototype, wrapper);
+    }
+    return wrapper;
+}
+/**
+ * Define new wrapper class.
+ * @param BaseEventWrapper The base wrapper class.
+ * @param originalPrototype The prototype of the original event.
+ */
+function defineWrapper(BaseEventWrapper, originalPrototype) {
+    class CustomEventWrapper extends BaseEventWrapper {
+    }
+    const keys = Object.keys(originalPrototype);
+    for (let i = 0; i < keys.length; ++i) {
+        Object.defineProperty(CustomEventWrapper.prototype, keys[i], defineRedirectDescriptor(originalPrototype, keys[i]));
+    }
+    return CustomEventWrapper;
+}
+/**
+ * Get the property descriptor to redirect a given property.
+ */
+function defineRedirectDescriptor(obj, key) {
+    const d = Object.getOwnPropertyDescriptor(obj, key);
+    return {
+        get() {
+            const original = $$1(this).original;
+            const value = original[key];
+            if (typeof value === "function") {
+                return value.bind(original);
+            }
+            return value;
+        },
+        set(value) {
+            const original = $$1(this).original;
+            original[key] = value;
+        },
+        configurable: d.configurable,
+        enumerable: d.enumerable,
+    };
+}
+
+/**
+ * Create a new listener.
+ * @param callback The callback function.
+ * @param capture The capture flag.
+ * @param passive The passive flag.
+ * @param once The once flag.
+ * @param signal The abort signal.
+ * @param signalListener The abort event listener for the abort signal.
+ */
+function createListener(callback, capture, passive, once, signal, signalListener) {
+    return {
+        callback,
+        flags: (capture ? 1 /* Capture */ : 0) |
+            (passive ? 2 /* Passive */ : 0) |
+            (once ? 4 /* Once */ : 0),
+        signal,
+        signalListener,
+    };
+}
+/**
+ * Set the `removed` flag to the given listener.
+ * @param listener The listener to check.
+ */
+function setRemoved(listener) {
+    listener.flags |= 8 /* Removed */;
+}
+/**
+ * Check if the given listener has the `capture` flag or not.
+ * @param listener The listener to check.
+ */
+function isCapture(listener) {
+    return (listener.flags & 1 /* Capture */) === 1 /* Capture */;
+}
+/**
+ * Check if the given listener has the `passive` flag or not.
+ * @param listener The listener to check.
+ */
+function isPassive(listener) {
+    return (listener.flags & 2 /* Passive */) === 2 /* Passive */;
+}
+/**
+ * Check if the given listener has the `once` flag or not.
+ * @param listener The listener to check.
+ */
+function isOnce(listener) {
+    return (listener.flags & 4 /* Once */) === 4 /* Once */;
+}
+/**
+ * Check if the given listener has the `removed` flag or not.
+ * @param listener The listener to check.
+ */
+function isRemoved(listener) {
+    return (listener.flags & 8 /* Removed */) === 8 /* Removed */;
+}
+/**
+ * Call an event listener.
+ * @param listener The listener to call.
+ * @param target The event target object for `thisArg`.
+ * @param event The event object for the first argument.
+ * @param attribute `true` if this callback is an event attribute handler.
+ */
+function invokeCallback({ callback }, target, event) {
+    try {
+        if (typeof callback === "function") {
+            callback.call(target, event);
+        }
+        else if (typeof callback.handleEvent === "function") {
+            callback.handleEvent(event);
+        }
+    }
+    catch (thrownError) {
+        reportError(thrownError);
+    }
+}
+
+/**
+ * Find the index of given listener.
+ * This returns `-1` if not found.
+ * @param list The listener list.
+ * @param callback The callback function to find.
+ * @param capture The capture flag to find.
+ */
+function findIndexOfListener({ listeners }, callback, capture) {
+    for (let i = 0; i < listeners.length; ++i) {
+        if (listeners[i].callback === callback &&
+            isCapture(listeners[i]) === capture) {
+            return i;
+        }
+    }
+    return -1;
+}
+/**
+ * Add the given listener.
+ * Does copy-on-write if needed.
+ * @param list The listener list.
+ * @param callback The callback function.
+ * @param capture The capture flag.
+ * @param passive The passive flag.
+ * @param once The once flag.
+ * @param signal The abort signal.
+ */
+function addListener(list, callback, capture, passive, once, signal) {
+    let signalListener;
+    if (signal) {
+        signalListener = removeListener.bind(null, list, callback, capture);
+        signal.addEventListener("abort", signalListener);
+    }
+    const listener = createListener(callback, capture, passive, once, signal, signalListener);
+    if (list.cow) {
+        list.cow = false;
+        list.listeners = [...list.listeners, listener];
+    }
+    else {
+        list.listeners.push(listener);
+    }
+    return listener;
+}
+/**
+ * Remove a listener.
+ * @param list The listener list.
+ * @param callback The callback function to find.
+ * @param capture The capture flag to find.
+ * @returns `true` if it mutated the list directly.
+ */
+function removeListener(list, callback, capture) {
+    const index = findIndexOfListener(list, callback, capture);
+    if (index !== -1) {
+        return removeListenerAt(list, index);
+    }
+    return false;
+}
+/**
+ * Remove a listener.
+ * @param list The listener list.
+ * @param index The index of the target listener.
+ * @param disableCow Disable copy-on-write if true.
+ * @returns `true` if it mutated the `listeners` array directly.
+ */
+function removeListenerAt(list, index, disableCow = false) {
+    const listener = list.listeners[index];
+    // Set the removed flag.
+    setRemoved(listener);
+    // Dispose the abort signal listener if exists.
+    if (listener.signal) {
+        listener.signal.removeEventListener("abort", listener.signalListener);
+    }
+    // Remove it from the array.
+    if (list.cow && !disableCow) {
+        list.cow = false;
+        list.listeners = list.listeners.filter((_, i) => i !== index);
+        return false;
+    }
+    list.listeners.splice(index, 1);
+    return true;
+}
+
+/**
+ * Create a new `ListenerListMap` object.
+ */
+function createListenerListMap() {
+    return Object.create(null);
+}
+/**
+ * Get the listener list of the given type.
+ * If the listener list has not been initialized, initialize and return it.
+ * @param listenerMap The listener list map.
+ * @param type The event type to get.
+ */
+function ensureListenerList(listenerMap, type) {
+    var _a;
+    return ((_a = listenerMap[type]) !== null && _a !== void 0 ? _a : (listenerMap[type] = {
+        attrCallback: undefined,
+        attrListener: undefined,
+        cow: false,
+        listeners: [],
+    }));
+}
+
+/**
+ * An implementation of the `EventTarget` interface.
+ * @see https://dom.spec.whatwg.org/#eventtarget
+ */
+class EventTarget {
+    /**
+     * Initialize this instance.
+     */
+    constructor() {
+        internalDataMap$2.set(this, createListenerListMap());
+    }
+    // Implementation
+    addEventListener(type0, callback0, options0) {
+        const listenerMap = $$2(this);
+        const { callback, capture, once, passive, signal, type, } = normalizeAddOptions(type0, callback0, options0);
+        if (callback == null || (signal === null || signal === void 0 ? void 0 : signal.aborted)) {
+            return;
+        }
+        const list = ensureListenerList(listenerMap, type);
+        // Find existing listener.
+        const i = findIndexOfListener(list, callback, capture);
+        if (i !== -1) {
+            warnDuplicate(list.listeners[i], passive, once, signal);
+            return;
+        }
+        // Add the new listener.
+        addListener(list, callback, capture, passive, once, signal);
+    }
+    // Implementation
+    removeEventListener(type0, callback0, options0) {
+        const listenerMap = $$2(this);
+        const { callback, capture, type } = normalizeOptions(type0, callback0, options0);
+        const list = listenerMap[type];
+        if (callback != null && list) {
+            removeListener(list, callback, capture);
+        }
+    }
+    // Implementation
+    dispatchEvent(e) {
+        const list = $$2(this)[String(e.type)];
+        if (list == null) {
+            return true;
+        }
+        const event = e instanceof Event ? e : EventWrapper.wrap(e);
+        const eventData = $(event, "event");
+        if (eventData.dispatchFlag) {
+           throw new DOMException("This event has been in dispatching.");
+        }
+        eventData.dispatchFlag = true;
+        eventData.target = eventData.currentTarget = this;
+        if (!eventData.stopPropagationFlag) {
+            const { cow, listeners } = list;
+            // Set copy-on-write flag.
+            list.cow = true;
+            // Call listeners.
+            for (let i = 0; i < listeners.length; ++i) {
+                const listener = listeners[i];
+                // Skip if removed.
+                if (isRemoved(listener)) {
+                    continue;
+                }
+                // Remove this listener if has the `once` flag.
+                if (isOnce(listener) && removeListenerAt(list, i, !cow)) {
+                    // Because this listener was removed, the next index is the
+                    // same as the current value.
+                    i -= 1;
+                }
+                // Call this listener with the `passive` flag.
+                eventData.inPassiveListenerFlag = isPassive(listener);
+                invokeCallback(listener, this, event);
+                eventData.inPassiveListenerFlag = false;
+                // Stop if the `event.stopImmediatePropagation()` method was called.
+                if (eventData.stopImmediatePropagationFlag) {
+                    break;
+                }
+            }
+            // Restore copy-on-write flag.
+            if (!cow) {
+                list.cow = false;
+            }
+        }
+        eventData.target = null;
+        eventData.currentTarget = null;
+        eventData.stopImmediatePropagationFlag = false;
+        eventData.stopPropagationFlag = false;
+        eventData.dispatchFlag = false;
+        return !eventData.canceledFlag;
+    }
+}
+/**
+ * Internal data.
+ */
+const internalDataMap$2 = new WeakMap();
+/**
+ * Get private data.
+ * @param target The event target object to get private data.
+ * @param name The variable name to report.
+ * @returns The private data of the event.
+ */
+function $$2(target, name = "this") {
+    const retv = internalDataMap$2.get(target);
+    assertType(retv != null, "'%s' must be an object that EventTarget constructor created, but got another one: %o", name, target);
+    return retv;
+}
+/**
+ * Normalize options.
+ * @param options The options to normalize.
+ */
+function normalizeAddOptions(type, callback, options) {
+    var _a;
+    assertCallback(callback);
+    if (typeof options === "object" && options !== null) {
+        return {
+            type: String(type),
+            callback: callback !== null && callback !== void 0 ? callback : undefined,
+            capture: Boolean(options.capture),
+            passive: Boolean(options.passive),
+            once: Boolean(options.once),
+            signal: (_a = options.signal) !== null && _a !== void 0 ? _a : undefined,
+        };
+    }
+    return {
+        type: String(type),
+        callback: callback !== null && callback !== void 0 ? callback : undefined,
+        capture: Boolean(options),
+        passive: false,
+        once: false,
+        signal: undefined,
+    };
+}
+/**
+ * Normalize options.
+ * @param options The options to normalize.
+ */
+function normalizeOptions(type, callback, options) {
+    assertCallback(callback);
+    if (typeof options === "object" && options !== null) {
+        return {
+            type: String(type),
+            callback: callback !== null && callback !== void 0 ? callback : undefined,
+            capture: Boolean(options.capture),
+        };
+    }
+    return {
+        type: String(type),
+        callback: callback !== null && callback !== void 0 ? callback : undefined,
+        capture: Boolean(options),
+    };
+}
+/**
+ * Assert the type of 'callback' argument.
+ * @param callback The callback to check.
+ */
+function assertCallback(callback) {
+    if (typeof callback === "function" ||
+        (typeof callback === "object" &&
+            callback !== null &&
+            typeof callback.handleEvent === "function")) {
+        return;
+    }
+    if (callback == null || typeof callback === "object") {
+        InvalidEventListener.warn(callback);
+        return;
+    }
+    throw new TypeError(format(InvalidEventListener.message, [callback]));
+}
+/**
+ * Print warning for duplicated.
+ * @param listener The current listener that is duplicated.
+ * @param passive The passive flag of the new duplicated listener.
+ * @param once The once flag of the new duplicated listener.
+ * @param signal The signal object of the new duplicated listener.
+ */
+function warnDuplicate(listener, passive, once, signal) {
+    EventListenerWasDuplicated.warn(isCapture(listener) ? "capture" : "bubble", listener.callback);
+    if (isPassive(listener) !== passive) {
+        OptionWasIgnored.warn("passive");
+    }
+    if (isOnce(listener) !== once) {
+        OptionWasIgnored.warn("once");
+    }
+    if (listener.signal !== signal) {
+        OptionWasIgnored.warn("signal");
+    }
+}
+// Set enumerable
+const keys$1$1 = Object.getOwnPropertyNames(EventTarget.prototype);
+for (let i = 0; i < keys$1$1.length; ++i) {
+    if (keys$1$1[i] === "constructor") {
+        continue;
+    }
+    Object.defineProperty(EventTarget.prototype, keys$1$1[i], { enumerable: true });
+}
+// Ensure `eventTarget instanceof window.EventTarget` is `true`.
+
+/**
+ * Get the current value of a given event attribute.
+ * @param target The `EventTarget` object to get.
+ * @param type The event type.
+ */
+function getEventAttributeValue(target, type) {
+    var _a, _b;
+    const listMap = $$2(target, "target");
+    return (_b = (_a = listMap[type]) === null || _a === void 0 ? void 0 : _a.attrCallback) !== null && _b !== void 0 ? _b : null;
+}
+/**
+ * Set an event listener to a given event attribute.
+ * @param target The `EventTarget` object to set.
+ * @param type The event type.
+ * @param callback The event listener.
+ */
+function setEventAttributeValue(target, type, callback) {
+    if (callback != null && typeof callback !== "function") {
+        InvalidAttributeHandler.warn(callback);
+    }
+    if (typeof callback === "function" ||
+        (typeof callback === "object" && callback !== null)) {
+        upsertEventAttributeListener(target, type, callback);
+    }
+    else {
+        removeEventAttributeListener(target, type);
+    }
+}
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+/**
+ * Update or insert the given event attribute handler.
+ * @param target The `EventTarget` object to set.
+ * @param type The event type.
+ * @param callback The event listener.
+ */
+function upsertEventAttributeListener(target, type, callback) {
+    const list = ensureListenerList($$2(target, "target"), String(type));
+    list.attrCallback = callback;
+    if (list.attrListener == null) {
+        list.attrListener = addListener(list, defineEventAttributeCallback(list), false, false, false, undefined);
+    }
+}
+/**
+ * Remove the given event attribute handler.
+ * @param target The `EventTarget` object to remove.
+ * @param type The event type.
+ * @param callback The event listener.
+ */
+function removeEventAttributeListener(target, type) {
+    const listMap = $$2(target, "target");
+    const list = listMap[String(type)];
+    if (list && list.attrListener) {
+        removeListener(list, list.attrListener.callback, false);
+        list.attrCallback = list.attrListener = undefined;
+    }
+}
+/**
+ * Define the callback function for the given listener list object.
+ * It calls `attrCallback` property if the property value is a function.
+ * @param list The `ListenerList` object.
+ */
+function defineEventAttributeCallback(list) {
+    return function (event) {
+        const callback = list.attrCallback;
+        if (typeof callback === "function") {
+            callback.call(this, event);
+        }
+    };
+}
+/**
+ * Define an event attribute.
+ * @param target The `EventTarget` object to define an event attribute.
+ * @param type The event type to define.
+ * @param _eventClass Unused, but to infer `Event` class type.
+ * @deprecated Use `getEventAttributeValue`/`setEventAttributeValue` pair on your derived class instead because of static analysis friendly.
+ */
+function defineEventAttribute(target, type, _eventClass) {
+    Object.defineProperty(target, `on${type}`, {
+        get() {
+            return getEventAttributeValue(this, type);
+        },
+        set(value) {
+            setEventAttributeValue(this, type, value);
+        },
+        configurable: true,
+        enumerable: true,
+    });
+}
+
+/**
+ * @author Toru Nagashima <https://github.com/mysticatea>
+ * See LICENSE file in root directory for full license.
+ */
+
+/**
+ * The signal class.
+ * @see https://dom.spec.whatwg.org/#abortsignal
+ */
+class AbortSignal extends EventTarget {
+    /**
+     * AbortSignal cannot be constructed directly.
+     */
+    constructor() {
+        super();
+        throw new TypeError("AbortSignal cannot be constructed directly");
+    }
+    /**
+     * Returns `true` if this `AbortSignal`'s `AbortController` has signaled to abort, and `false` otherwise.
+     */
+    get aborted() {
+        const aborted = abortedFlags.get(this);
+        if (typeof aborted !== "boolean") {
+            throw new TypeError(`Expected 'this' to be an 'AbortSignal' object, but got ${this === null ? "null" : typeof this}`);
+        }
+        return aborted;
+    }
+}
+defineEventAttribute(AbortSignal.prototype, "abort");
+/**
+ * Create an AbortSignal object.
+ */
+function createAbortSignal() {
+    const signal = Object.create(AbortSignal.prototype);
+    EventTarget.call(signal);
+    abortedFlags.set(signal, false);
+    return signal;
+}
+/**
+ * Abort a given signal.
+ */
+function abortSignal(signal) {
+    if (abortedFlags.get(signal) !== false) {
+        return;
+    }
+    abortedFlags.set(signal, true);
+    signal.dispatchEvent({ type: "abort" });
+}
+/**
+ * Aborted flag for each instances.
+ */
+const abortedFlags = new WeakMap();
+// Properties should be enumerable.
+Object.defineProperties(AbortSignal.prototype, {
+    aborted: { enumerable: true },
+});
+// `toString()` should return `"[object AbortSignal]"`
+if (typeof Symbol === "function" && typeof Symbol.toStringTag === "symbol") {
+    Object.defineProperty(AbortSignal.prototype, Symbol.toStringTag, {
+        configurable: true,
+        value: "AbortSignal",
+    });
+}
+
+/**
+ * The AbortController.
+ * @see https://dom.spec.whatwg.org/#abortcontroller
+ */
+class AbortController {
+    /**
+     * Initialize this controller.
+     */
+    constructor() {
+        signals.set(this, createAbortSignal());
+    }
+    /**
+     * Returns the `AbortSignal` object associated with this object.
+     */
+    get signal() {
+        return getSignal(this);
+    }
+    /**
+     * Abort and signal to any observers that the associated activity is to be aborted.
+     */
+    abort() {
+        abortSignal(getSignal(this));
+    }
+}
+/**
+ * Associated signals.
+ */
+const signals = new WeakMap();
+/**
+ * Get the associated signal of a given controller.
+ */
+function getSignal(controller) {
+    const signal = signals.get(controller);
+    if (signal == null) {
+        throw new TypeError(`Expected 'this' to be an 'AbortController' object, but got ${controller === null ? "null" : typeof controller}`);
+    }
+    return signal;
+}
+// Properties should be enumerable.
+Object.defineProperties(AbortController.prototype, {
+    signal: { enumerable: true },
+    abort: { enumerable: true },
+});
+if (typeof Symbol === "function" && typeof Symbol.toStringTag === "symbol") {
+    Object.defineProperty(AbortController.prototype, Symbol.toStringTag, {
+        configurable: true,
+        value: "AbortController",
+    });
+}
+
+const INTERNAL$2 = { tick: 0, pool: new Map };
+function requestAnimationFrame(callback) {
+    if (!INTERNAL$2.pool.size) {
+        setTimeout$1(() => {
+            const next = __performance_now();
+            for (const func of INTERNAL$2.pool.values()) {
+                func(next);
+            }
+            INTERNAL$2.pool.clear();
+        }, 1000 / 16);
+    }
+    const func = __function_bind(callback, undefined);
+    const tick = ++INTERNAL$2.tick;
+    INTERNAL$2.pool.set(tick, func);
+    return tick;
+}
+function cancelAnimationFrame(requestId) {
+    const timeout = INTERNAL$2.pool.get(requestId);
+    if (timeout) {
+        clearTimeout$1(timeout);
+        INTERNAL$2.pool.delete(requestId);
+    }
+}
+
+function atob(data) {
+    return Buffer.from(data, 'base64').toString('binary');
+}
+function btoa(data) {
+    return Buffer.from(data, 'binary').toString('base64');
+}
+
+class Node extends EventTarget {
+    append(...nodesOrDOMStrings) {
+    }
+    appendChild(childNode) {
+        return childNode;
+    }
+    after(...nodesOrDOMStrings) {
+    }
+    before(...nodesOrDOMStrings) {
+    }
+    prepend(...nodesOrDOMStrings) {
+    }
+    replaceChild(newChild, oldChild) {
+        return oldChild;
+    }
+    removeChild(childNode) {
+        return childNode;
+    }
+    get attributes() {
+        return {};
+    }
+    get childNodes() {
+        return [];
+    }
+    get children() {
+        return [];
+    }
+    get ownerDocument() {
+        return null;
+    }
+    get nodeValue() {
+        return '';
+    }
+    set nodeValue(value) {
+    }
+    get textContent() {
+        return '';
+    }
+    set textContent(value) {
+    }
+    get previousElementSibling() {
+        return null;
+    }
+    get nextElementSibling() {
+        return null;
+    }
+    [Symbol.for('nodejs.util.inspect.custom')](depth, options) {
+        return `${this.constructor.name}`;
+    }
+}
+class DocumentFragment extends Node {
+}
+class ShadowRoot extends DocumentFragment {
+    get innerHTML() {
+        return '';
+    }
+    set innerHTML(value) {
+    }
+}
+const NodeFilter$1 = Object.assign({
+    NodeFilter() {
+        throw new TypeError('Illegal constructor');
+    }
+}.NodeFilter, {
+    FILTER_ACCEPT: 1,
+    FILTER_REJECT: 2,
+    FILTER_SKIP: 3,
+    SHOW_ALL: 4294967295,
+    SHOW_ELEMENT: 1,
+    SHOW_ATTRIBUTE: 2,
+    SHOW_TEXT: 4,
+    SHOW_CDATA_SECTION: 8,
+    SHOW_ENTITY_REFERENCE: 16,
+    SHOW_ENTITY: 32,
+    SHOW_PROCESSING_INSTRUCTION: 64,
+    SHOW_COMMENT: 128,
+    SHOW_DOCUMENT: 256,
+    SHOW_DOCUMENT_TYPE: 512,
+    SHOW_DOCUMENT_FRAGMENT: 1024,
+    SHOW_NOTATION: 2048,
+});
+class NodeIterator$1 {
+    nextNode() {
+        return null;
+    }
+    previousNode() {
+        return null;
+    }
+    get filter() {
+        const internals = internalsOf(this, 'NodeIterator', 'filter');
+        return internals.filter;
+    }
+    get pointerBeforeReferenceNode() {
+        const internals = internalsOf(this, 'NodeIterator', 'pointerBeforeReferenceNode');
+        return internals.pointerBeforeReferenceNode;
+    }
+    get referenceNode() {
+        const internals = internalsOf(this, 'NodeIterator', 'referenceNode');
+        return internals.referenceNode;
+    }
+    get root() {
+        const internals = internalsOf(this, 'NodeIterator', 'root');
+        return internals.root;
+    }
+    get whatToShow() {
+        const internals = internalsOf(this, 'NodeIterator', 'whatToShow');
+        return internals.whatToShow;
+    }
+}
+allowStringTag(Node);
+allowStringTag(NodeIterator$1);
+allowStringTag(DocumentFragment);
+allowStringTag(ShadowRoot);
+
+class CharacterData extends Node {
+    constructor(data) {
+        INTERNALS$3.set(super(), {
+            data: String(data),
+        });
+    }
+    get data() {
+        return internalsOf(this, 'CharacterData', 'data').data;
+    }
+    get textContent() {
+        return internalsOf(this, 'CharacterData', 'textContent').data;
+    }
+}
+class Comment extends CharacterData {
+}
+class Text extends CharacterData {
+    get assignedSlot() {
+        return null;
+    }
+    get wholeText() {
+        return internalsOf(this, 'CharacterData', 'textContent').data;
+    }
+}
+allowStringTag(CharacterData);
+allowStringTag(Text);
+allowStringTag(Comment);
+
+/**
+ * web-streams-polyfill v3.2.0
+ */
+/// <reference lib="es2015.symbol" />
+const SymbolPolyfill = Symbol;
+
+/// <reference lib="dom" />
+function noop$1() {
+    return undefined;
+}
+
+function typeIsObject(x) {
+    return (typeof x === 'object' && x !== null) || typeof x === 'function';
+}
+const rethrowAssertionErrorRejection = noop$1;
+
+const originalPromise = Promise;
+const originalPromiseThen = Promise.prototype.then;
+const originalPromiseResolve = Promise.resolve.bind(originalPromise);
+const originalPromiseReject = Promise.reject.bind(originalPromise);
+function newPromise(executor) {
+    return new originalPromise(executor);
+}
+function promiseResolvedWith(value) {
+    return originalPromiseResolve(value);
+}
+function promiseRejectedWith(reason) {
+    return originalPromiseReject(reason);
+}
+function PerformPromiseThen(promise, onFulfilled, onRejected) {
+    // There doesn't appear to be any way to correctly emulate the behaviour from JavaScript, so this is just an
+    // approximation.
+    return originalPromiseThen.call(promise, onFulfilled, onRejected);
+}
+function uponPromise(promise, onFulfilled, onRejected) {
+    PerformPromiseThen(PerformPromiseThen(promise, onFulfilled, onRejected), undefined, rethrowAssertionErrorRejection);
+}
+function uponFulfillment(promise, onFulfilled) {
+    uponPromise(promise, onFulfilled);
+}
+function uponRejection(promise, onRejected) {
+    uponPromise(promise, undefined, onRejected);
+}
+function transformPromiseWith(promise, fulfillmentHandler, rejectionHandler) {
+    return PerformPromiseThen(promise, fulfillmentHandler, rejectionHandler);
+}
+function setPromiseIsHandledToTrue(promise) {
+    PerformPromiseThen(promise, undefined, rethrowAssertionErrorRejection);
+}
+function reflectCall(F, V, args) {
+    if (typeof F !== 'function') {
+        throw new TypeError('Argument is not a function');
+    }
+    return Function.prototype.apply.call(F, V, args);
+}
+function promiseCall(F, V, args) {
+    try {
+        return promiseResolvedWith(reflectCall(F, V, args));
+    }
+    catch (value) {
+        return promiseRejectedWith(value);
+    }
+}
+
+// Original from Chromium
+// https://chromium.googlesource.com/chromium/src/+/0aee4434a4dba42a42abaea9bfbc0cd196a63bc1/third_party/blink/renderer/core/streams/SimpleQueue.js
+const QUEUE_MAX_ARRAY_SIZE = 16384;
+/**
+ * Simple queue structure.
+ *
+ * Avoids scalability issues with using a packed array directly by using
+ * multiple arrays in a linked list and keeping the array size bounded.
+ */
+class SimpleQueue {
+    constructor() {
+        this._cursor = 0;
+        this._size = 0;
+        // _front and _back are always defined.
+        this._front = {
+            _elements: [],
+            _next: undefined
+        };
+        this._back = this._front;
+        // The cursor is used to avoid calling Array.shift().
+        // It contains the index of the front element of the array inside the
+        // front-most node. It is always in the range [0, QUEUE_MAX_ARRAY_SIZE).
+        this._cursor = 0;
+        // When there is only one node, size === elements.length - cursor.
+        this._size = 0;
+    }
+    get length() {
+        return this._size;
+    }
+    // For exception safety, this method is structured in order:
+    // 1. Read state
+    // 2. Calculate required state mutations
+    // 3. Perform state mutations
+    push(element) {
+        const oldBack = this._back;
+        let newBack = oldBack;
+        if (oldBack._elements.length === QUEUE_MAX_ARRAY_SIZE - 1) {
+            newBack = {
+                _elements: [],
+                _next: undefined
+            };
+        }
+        // push() is the mutation most likely to throw an exception, so it
+        // goes first.
+        oldBack._elements.push(element);
+        if (newBack !== oldBack) {
+            this._back = newBack;
+            oldBack._next = newBack;
+        }
+        ++this._size;
+    }
+    // Like push(), shift() follows the read -> calculate -> mutate pattern for
+    // exception safety.
+    shift() { // must not be called on an empty queue
+        const oldFront = this._front;
+        let newFront = oldFront;
+        const oldCursor = this._cursor;
+        let newCursor = oldCursor + 1;
+        const elements = oldFront._elements;
+        const element = elements[oldCursor];
+        if (newCursor === QUEUE_MAX_ARRAY_SIZE) {
+            newFront = oldFront._next;
+            newCursor = 0;
+        }
+        // No mutations before this point.
+        --this._size;
+        this._cursor = newCursor;
+        if (oldFront !== newFront) {
+            this._front = newFront;
+        }
+        // Permit shifted element to be garbage collected.
+        elements[oldCursor] = undefined;
+        return element;
+    }
+    // The tricky thing about forEach() is that it can be called
+    // re-entrantly. The queue may be mutated inside the callback. It is easy to
+    // see that push() within the callback has no negative effects since the end
+    // of the queue is checked for on every iteration. If shift() is called
+    // repeatedly within the callback then the next iteration may return an
+    // element that has been removed. In this case the callback will be called
+    // with undefined values until we either "catch up" with elements that still
+    // exist or reach the back of the queue.
+    forEach(callback) {
+        let i = this._cursor;
+        let node = this._front;
+        let elements = node._elements;
+        while (i !== elements.length || node._next !== undefined) {
+            if (i === elements.length) {
+                node = node._next;
+                elements = node._elements;
+                i = 0;
+                if (elements.length === 0) {
+                    break;
+                }
+            }
+            callback(elements[i]);
+            ++i;
+        }
+    }
+    // Return the element that would be returned if shift() was called now,
+    // without modifying the queue.
+    peek() { // must not be called on an empty queue
+        const front = this._front;
+        const cursor = this._cursor;
+        return front._elements[cursor];
+    }
+}
+
+function ReadableStreamReaderGenericInitialize(reader, stream) {
+    reader._ownerReadableStream = stream;
+    stream._reader = reader;
+    if (stream._state === 'readable') {
+        defaultReaderClosedPromiseInitialize(reader);
+    }
+    else if (stream._state === 'closed') {
+        defaultReaderClosedPromiseInitializeAsResolved(reader);
+    }
+    else {
+        defaultReaderClosedPromiseInitializeAsRejected(reader, stream._storedError);
+    }
+}
+// A client of ReadableStreamDefaultReader and ReadableStreamBYOBReader may use these functions directly to bypass state
+// check.
+function ReadableStreamReaderGenericCancel(reader, reason) {
+    const stream = reader._ownerReadableStream;
+    return ReadableStreamCancel(stream, reason);
+}
+function ReadableStreamReaderGenericRelease(reader) {
+    if (reader._ownerReadableStream._state === 'readable') {
+        defaultReaderClosedPromiseReject(reader, new TypeError(`Reader was released and can no longer be used to monitor the stream's closedness`));
+    }
+    else {
+        defaultReaderClosedPromiseResetToRejected(reader, new TypeError(`Reader was released and can no longer be used to monitor the stream's closedness`));
+    }
+    reader._ownerReadableStream._reader = undefined;
+    reader._ownerReadableStream = undefined;
+}
+// Helper functions for the readers.
+function readerLockException(name) {
+    return new TypeError('Cannot ' + name + ' a stream using a released reader');
+}
+// Helper functions for the ReadableStreamDefaultReader.
+function defaultReaderClosedPromiseInitialize(reader) {
+    reader._closedPromise = newPromise((resolve, reject) => {
+        reader._closedPromise_resolve = resolve;
+        reader._closedPromise_reject = reject;
+    });
+}
+function defaultReaderClosedPromiseInitializeAsRejected(reader, reason) {
+    defaultReaderClosedPromiseInitialize(reader);
+    defaultReaderClosedPromiseReject(reader, reason);
+}
+function defaultReaderClosedPromiseInitializeAsResolved(reader) {
+    defaultReaderClosedPromiseInitialize(reader);
+    defaultReaderClosedPromiseResolve(reader);
+}
+function defaultReaderClosedPromiseReject(reader, reason) {
+    if (reader._closedPromise_reject === undefined) {
+        return;
+    }
+    setPromiseIsHandledToTrue(reader._closedPromise);
+    reader._closedPromise_reject(reason);
+    reader._closedPromise_resolve = undefined;
+    reader._closedPromise_reject = undefined;
+}
+function defaultReaderClosedPromiseResetToRejected(reader, reason) {
+    defaultReaderClosedPromiseInitializeAsRejected(reader, reason);
+}
+function defaultReaderClosedPromiseResolve(reader) {
+    if (reader._closedPromise_resolve === undefined) {
+        return;
+    }
+    reader._closedPromise_resolve(undefined);
+    reader._closedPromise_resolve = undefined;
+    reader._closedPromise_reject = undefined;
+}
+
+const AbortSteps = SymbolPolyfill('[[AbortSteps]]');
+const ErrorSteps = SymbolPolyfill('[[ErrorSteps]]');
+const CancelSteps = SymbolPolyfill('[[CancelSteps]]');
+const PullSteps = SymbolPolyfill('[[PullSteps]]');
+
+/// <reference lib="es2015.core" />
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isFinite#Polyfill
+const NumberIsFinite = Number.isFinite || function (x) {
+    return typeof x === 'number' && isFinite(x);
+};
+
+/// <reference lib="es2015.core" />
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/trunc#Polyfill
+const MathTrunc = Math.trunc || function (v) {
+    return v < 0 ? Math.ceil(v) : Math.floor(v);
+};
+
+// https://heycam.github.io/webidl/#idl-dictionaries
+function isDictionary(x) {
+    return typeof x === 'object' || typeof x === 'function';
+}
+function assertDictionary(obj, context) {
+    if (obj !== undefined && !isDictionary(obj)) {
+        throw new TypeError(`${context} is not an object.`);
+    }
+}
+// https://heycam.github.io/webidl/#idl-callback-functions
+function assertFunction(x, context) {
+    if (typeof x !== 'function') {
+        throw new TypeError(`${context} is not a function.`);
+    }
+}
+// https://heycam.github.io/webidl/#idl-object
+function isObject(x) {
+    return (typeof x === 'object' && x !== null) || typeof x === 'function';
+}
+function assertObject(x, context) {
+    if (!isObject(x)) {
+        throw new TypeError(`${context} is not an object.`);
+    }
+}
+function assertRequiredArgument(x, position, context) {
+    if (x === undefined) {
+        throw new TypeError(`Parameter ${position} is required in '${context}'.`);
+    }
+}
+function assertRequiredField(x, field, context) {
+    if (x === undefined) {
+        throw new TypeError(`${field} is required in '${context}'.`);
+    }
+}
+// https://heycam.github.io/webidl/#idl-unrestricted-double
+function convertUnrestrictedDouble(value) {
+    return Number(value);
+}
+function censorNegativeZero(x) {
+    return x === 0 ? 0 : x;
+}
+function integerPart(x) {
+    return censorNegativeZero(MathTrunc(x));
+}
+// https://heycam.github.io/webidl/#idl-unsigned-long-long
+function convertUnsignedLongLongWithEnforceRange(value, context) {
+    const lowerBound = 0;
+    const upperBound = Number.MAX_SAFE_INTEGER;
+    let x = Number(value);
+    x = censorNegativeZero(x);
+    if (!NumberIsFinite(x)) {
+        throw new TypeError(`${context} is not a finite number`);
+    }
+    x = integerPart(x);
+    if (x < lowerBound || x > upperBound) {
+        throw new TypeError(`${context} is outside the accepted range of ${lowerBound} to ${upperBound}, inclusive`);
+    }
+    if (!NumberIsFinite(x) || x === 0) {
+        return 0;
+    }
+    // TODO Use BigInt if supported?
+    // let xBigInt = BigInt(integerPart(x));
+    // xBigInt = BigInt.asUintN(64, xBigInt);
+    // return Number(xBigInt);
+    return x;
+}
+
+function assertReadableStream(x, context) {
+    if (!IsReadableStream(x)) {
+        throw new TypeError(`${context} is not a ReadableStream.`);
+    }
+}
+
+// Abstract operations for the ReadableStream.
+function AcquireReadableStreamDefaultReader(stream) {
+    return new ReadableStreamDefaultReader(stream);
+}
+// ReadableStream API exposed for controllers.
+function ReadableStreamAddReadRequest(stream, readRequest) {
+    stream._reader._readRequests.push(readRequest);
+}
+function ReadableStreamFulfillReadRequest(stream, chunk, done) {
+    const reader = stream._reader;
+    const readRequest = reader._readRequests.shift();
+    if (done) {
+        readRequest._closeSteps();
+    }
+    else {
+        readRequest._chunkSteps(chunk);
+    }
+}
+function ReadableStreamGetNumReadRequests(stream) {
+    return stream._reader._readRequests.length;
+}
+function ReadableStreamHasDefaultReader(stream) {
+    const reader = stream._reader;
+    if (reader === undefined) {
+        return false;
+    }
+    if (!IsReadableStreamDefaultReader(reader)) {
+        return false;
+    }
+    return true;
+}
+/**
+ * A default reader vended by a {@link ReadableStream}.
+ *
+ * @public
+ */
+class ReadableStreamDefaultReader {
+    constructor(stream) {
+        assertRequiredArgument(stream, 1, 'ReadableStreamDefaultReader');
+        assertReadableStream(stream, 'First parameter');
+        if (IsReadableStreamLocked(stream)) {
+            throw new TypeError('This stream has already been locked for exclusive reading by another reader');
+        }
+        ReadableStreamReaderGenericInitialize(this, stream);
+        this._readRequests = new SimpleQueue();
+    }
+    /**
+     * Returns a promise that will be fulfilled when the stream becomes closed,
+     * or rejected if the stream ever errors or the reader's lock is released before the stream finishes closing.
+     */
+    get closed() {
+        if (!IsReadableStreamDefaultReader(this)) {
+            return promiseRejectedWith(defaultReaderBrandCheckException('closed'));
+        }
+        return this._closedPromise;
+    }
+    /**
+     * If the reader is active, behaves the same as {@link ReadableStream.cancel | stream.cancel(reason)}.
+     */
+    cancel(reason = undefined) {
+        if (!IsReadableStreamDefaultReader(this)) {
+            return promiseRejectedWith(defaultReaderBrandCheckException('cancel'));
+        }
+        if (this._ownerReadableStream === undefined) {
+            return promiseRejectedWith(readerLockException('cancel'));
+        }
+        return ReadableStreamReaderGenericCancel(this, reason);
+    }
+    /**
+     * Returns a promise that allows access to the next chunk from the stream's internal queue, if available.
+     *
+     * If reading a chunk causes the queue to become empty, more data will be pulled from the underlying source.
+     */
+    read() {
+        if (!IsReadableStreamDefaultReader(this)) {
+            return promiseRejectedWith(defaultReaderBrandCheckException('read'));
+        }
+        if (this._ownerReadableStream === undefined) {
+            return promiseRejectedWith(readerLockException('read from'));
+        }
+        let resolvePromise;
+        let rejectPromise;
+        const promise = newPromise((resolve, reject) => {
+            resolvePromise = resolve;
+            rejectPromise = reject;
+        });
+        const readRequest = {
+            _chunkSteps: chunk => resolvePromise({ value: chunk, done: false }),
+            _closeSteps: () => resolvePromise({ value: undefined, done: true }),
+            _errorSteps: e => rejectPromise(e)
+        };
+        ReadableStreamDefaultReaderRead(this, readRequest);
+        return promise;
+    }
+    /**
+     * Releases the reader's lock on the corresponding stream. After the lock is released, the reader is no longer active.
+     * If the associated stream is errored when the lock is released, the reader will appear errored in the same way
+     * from now on; otherwise, the reader will appear closed.
+     *
+     * A reader's lock cannot be released while it still has a pending read request, i.e., if a promise returned by
+     * the reader's {@link ReadableStreamDefaultReader.read | read()} method has not yet been settled. Attempting to
+     * do so will throw a `TypeError` and leave the reader locked to the stream.
+     */
+    releaseLock() {
+        if (!IsReadableStreamDefaultReader(this)) {
+            throw defaultReaderBrandCheckException('releaseLock');
+        }
+        if (this._ownerReadableStream === undefined) {
+            return;
+        }
+        if (this._readRequests.length > 0) {
+            throw new TypeError('Tried to release a reader lock when that reader has pending read() calls un-settled');
+        }
+        ReadableStreamReaderGenericRelease(this);
+    }
+}
+Object.defineProperties(ReadableStreamDefaultReader.prototype, {
+    cancel: { enumerable: true },
+    read: { enumerable: true },
+    releaseLock: { enumerable: true },
+    closed: { enumerable: true }
+});
+// Abstract operations for the readers.
+function IsReadableStreamDefaultReader(x) {
+    if (!typeIsObject(x)) {
+        return false;
+    }
+    if (!Object.prototype.hasOwnProperty.call(x, '_readRequests')) {
+        return false;
+    }
+    return x instanceof ReadableStreamDefaultReader;
+}
+function ReadableStreamDefaultReaderRead(reader, readRequest) {
+    const stream = reader._ownerReadableStream;
+    stream._disturbed = true;
+    if (stream._state === 'closed') {
+        readRequest._closeSteps();
+    }
+    else if (stream._state === 'errored') {
+        readRequest._errorSteps(stream._storedError);
+    }
+    else {
+        stream._readableStreamController[PullSteps](readRequest);
+    }
+}
+// Helper functions for the ReadableStreamDefaultReader.
+function defaultReaderBrandCheckException(name) {
+    return new TypeError(`ReadableStreamDefaultReader.prototype.${name} can only be used on a ReadableStreamDefaultReader`);
+}
+
+/// <reference lib="es2018.asynciterable" />
+class ReadableStreamAsyncIteratorImpl {
+    constructor(reader, preventCancel) {
+        this._ongoingPromise = undefined;
+        this._isFinished = false;
+        this._reader = reader;
+        this._preventCancel = preventCancel;
+    }
+    next() {
+        const nextSteps = () => this._nextSteps();
+        this._ongoingPromise = this._ongoingPromise ?
+            transformPromiseWith(this._ongoingPromise, nextSteps, nextSteps) :
+            nextSteps();
+        return this._ongoingPromise;
+    }
+    return(value) {
+        const returnSteps = () => this._returnSteps(value);
+        return this._ongoingPromise ?
+            transformPromiseWith(this._ongoingPromise, returnSteps, returnSteps) :
+            returnSteps();
+    }
+    _nextSteps() {
+        if (this._isFinished) {
+            return Promise.resolve({ value: undefined, done: true });
+        }
+        const reader = this._reader;
+        if (reader._ownerReadableStream === undefined) {
+            return promiseRejectedWith(readerLockException('iterate'));
+        }
+        let resolvePromise;
+        let rejectPromise;
+        const promise = newPromise((resolve, reject) => {
+            resolvePromise = resolve;
+            rejectPromise = reject;
+        });
+        const readRequest = {
+            _chunkSteps: chunk => {
+                this._ongoingPromise = undefined;
+                // This needs to be delayed by one microtask, otherwise we stop pulling too early which breaks a test.
+                // FIXME Is this a bug in the specification, or in the test?
+                queueMicrotask(() => resolvePromise({ value: chunk, done: false }));
+            },
+            _closeSteps: () => {
+                this._ongoingPromise = undefined;
+                this._isFinished = true;
+                ReadableStreamReaderGenericRelease(reader);
+                resolvePromise({ value: undefined, done: true });
+            },
+            _errorSteps: reason => {
+                this._ongoingPromise = undefined;
+                this._isFinished = true;
+                ReadableStreamReaderGenericRelease(reader);
+                rejectPromise(reason);
+            }
+        };
+        ReadableStreamDefaultReaderRead(reader, readRequest);
+        return promise;
+    }
+    _returnSteps(value) {
+        if (this._isFinished) {
+            return Promise.resolve({ value, done: true });
+        }
+        this._isFinished = true;
+        const reader = this._reader;
+        if (reader._ownerReadableStream === undefined) {
+            return promiseRejectedWith(readerLockException('finish iterating'));
+        }
+        if (!this._preventCancel) {
+            const result = ReadableStreamReaderGenericCancel(reader, value);
+            ReadableStreamReaderGenericRelease(reader);
+            return transformPromiseWith(result, () => ({ value, done: true }));
+        }
+        ReadableStreamReaderGenericRelease(reader);
+        return promiseResolvedWith({ value, done: true });
+    }
+}
+const ReadableStreamAsyncIteratorPrototype = {
+    next() {
+        if (!IsReadableStreamAsyncIterator(this)) {
+            return promiseRejectedWith(streamAsyncIteratorBrandCheckException('next'));
+        }
+        return this._asyncIteratorImpl.next();
+    },
+    return(value) {
+        if (!IsReadableStreamAsyncIterator(this)) {
+            return promiseRejectedWith(streamAsyncIteratorBrandCheckException('return'));
+        }
+        return this._asyncIteratorImpl.return(value);
+    }
+};
+// Abstract operations for the ReadableStream.
+function AcquireReadableStreamAsyncIterator(stream, preventCancel) {
+    const reader = AcquireReadableStreamDefaultReader(stream);
+    const impl = new ReadableStreamAsyncIteratorImpl(reader, preventCancel);
+    const iterator = Object.create(ReadableStreamAsyncIteratorPrototype);
+    iterator._asyncIteratorImpl = impl;
+    return iterator;
+}
+function IsReadableStreamAsyncIterator(x) {
+    if (!typeIsObject(x)) {
+        return false;
+    }
+    if (!Object.prototype.hasOwnProperty.call(x, '_asyncIteratorImpl')) {
+        return false;
+    }
+    try {
+        // noinspection SuspiciousTypeOfGuard
+        return x._asyncIteratorImpl instanceof
+            ReadableStreamAsyncIteratorImpl;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+// Helper functions for the ReadableStream.
+function streamAsyncIteratorBrandCheckException(name) {
+    return new TypeError(`ReadableStreamAsyncIterator.${name} can only be used on a ReadableSteamAsyncIterator`);
+}
+
+/// <reference lib="es2015.core" />
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isNaN#Polyfill
+const NumberIsNaN = Number.isNaN || function (x) {
+    // eslint-disable-next-line no-self-compare
+    return x !== x;
+};
+
+function CreateArrayFromList(elements) {
+    // We use arrays to represent lists, so this is basically a no-op.
+    // Do a slice though just in case we happen to depend on the unique-ness.
+    return elements.slice();
+}
+function CopyDataBlockBytes(dest, destOffset, src, srcOffset, n) {
+    new Uint8Array(dest).set(new Uint8Array(src, srcOffset, n), destOffset);
+}
+// Not implemented correctly
+function TransferArrayBuffer(O) {
+    return O;
+}
+// Not implemented correctly
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function IsDetachedBuffer(O) {
+    return false;
+}
+function ArrayBufferSlice(buffer, begin, end) {
+    // ArrayBuffer.prototype.slice is not available on IE10
+    // https://www.caniuse.com/mdn-javascript_builtins_arraybuffer_slice
+    if (buffer.slice) {
+        return buffer.slice(begin, end);
+    }
+    const length = end - begin;
+    const slice = new ArrayBuffer(length);
+    CopyDataBlockBytes(slice, 0, buffer, begin, length);
+    return slice;
+}
+
+function IsNonNegativeNumber(v) {
+    if (typeof v !== 'number') {
+        return false;
+    }
+    if (NumberIsNaN(v)) {
+        return false;
+    }
+    if (v < 0) {
+        return false;
+    }
+    return true;
+}
+function CloneAsUint8Array(O) {
+    const buffer = ArrayBufferSlice(O.buffer, O.byteOffset, O.byteOffset + O.byteLength);
+    return new Uint8Array(buffer);
+}
+
+function DequeueValue(container) {
+    const pair = container._queue.shift();
+    container._queueTotalSize -= pair.size;
+    if (container._queueTotalSize < 0) {
+        container._queueTotalSize = 0;
+    }
+    return pair.value;
+}
+function EnqueueValueWithSize(container, value, size) {
+    if (!IsNonNegativeNumber(size) || size === Infinity) {
+        throw new RangeError('Size must be a finite, non-NaN, non-negative number.');
+    }
+    container._queue.push({ value, size });
+    container._queueTotalSize += size;
+}
+function PeekQueueValue(container) {
+    const pair = container._queue.peek();
+    return pair.value;
+}
+function ResetQueue(container) {
+    container._queue = new SimpleQueue();
+    container._queueTotalSize = 0;
+}
+
+/**
+ * A pull-into request in a {@link ReadableByteStreamController}.
+ *
+ * @public
+ */
+class ReadableStreamBYOBRequest {
+    constructor() {
+        throw new TypeError('Illegal constructor');
+    }
+    /**
+     * Returns the view for writing in to, or `null` if the BYOB request has already been responded to.
+     */
+    get view() {
+        if (!IsReadableStreamBYOBRequest(this)) {
+            throw byobRequestBrandCheckException('view');
+        }
+        return this._view;
+    }
+    respond(bytesWritten) {
+        if (!IsReadableStreamBYOBRequest(this)) {
+            throw byobRequestBrandCheckException('respond');
+        }
+        assertRequiredArgument(bytesWritten, 1, 'respond');
+        bytesWritten = convertUnsignedLongLongWithEnforceRange(bytesWritten, 'First parameter');
+        if (this._associatedReadableByteStreamController === undefined) {
+            throw new TypeError('This BYOB request has been invalidated');
+        }
+        if (IsDetachedBuffer(this._view.buffer)) ;
+        ReadableByteStreamControllerRespond(this._associatedReadableByteStreamController, bytesWritten);
+    }
+    respondWithNewView(view) {
+        if (!IsReadableStreamBYOBRequest(this)) {
+            throw byobRequestBrandCheckException('respondWithNewView');
+        }
+        assertRequiredArgument(view, 1, 'respondWithNewView');
+        if (!ArrayBuffer.isView(view)) {
+            throw new TypeError('You can only respond with array buffer views');
+        }
+        if (this._associatedReadableByteStreamController === undefined) {
+            throw new TypeError('This BYOB request has been invalidated');
+        }
+        if (IsDetachedBuffer(view.buffer)) ;
+        ReadableByteStreamControllerRespondWithNewView(this._associatedReadableByteStreamController, view);
+    }
+}
+Object.defineProperties(ReadableStreamBYOBRequest.prototype, {
+    respond: { enumerable: true },
+    respondWithNewView: { enumerable: true },
+    view: { enumerable: true }
+});
+/**
+ * Allows control of a {@link ReadableStream | readable byte stream}'s state and internal queue.
+ *
+ * @public
+ */
+class ReadableByteStreamController {
+    constructor() {
+        throw new TypeError('Illegal constructor');
+    }
+    /**
+     * Returns the current BYOB pull request, or `null` if there isn't one.
+     */
+    get byobRequest() {
+        if (!IsReadableByteStreamController(this)) {
+            throw byteStreamControllerBrandCheckException('byobRequest');
+        }
+        return ReadableByteStreamControllerGetBYOBRequest(this);
+    }
+    /**
+     * Returns the desired size to fill the controlled stream's internal queue. It can be negative, if the queue is
+     * over-full. An underlying byte source ought to use this information to determine when and how to apply backpressure.
+     */
+    get desiredSize() {
+        if (!IsReadableByteStreamController(this)) {
+            throw byteStreamControllerBrandCheckException('desiredSize');
+        }
+        return ReadableByteStreamControllerGetDesiredSize(this);
+    }
+    /**
+     * Closes the controlled readable stream. Consumers will still be able to read any previously-enqueued chunks from
+     * the stream, but once those are read, the stream will become closed.
+     */
+    close() {
+        if (!IsReadableByteStreamController(this)) {
+            throw byteStreamControllerBrandCheckException('close');
+        }
+        if (this._closeRequested) {
+            throw new TypeError('The stream has already been closed; do not close it again!');
+        }
+        const state = this._controlledReadableByteStream._state;
+        if (state !== 'readable') {
+            throw new TypeError(`The stream (in ${state} state) is not in the readable state and cannot be closed`);
+        }
+        ReadableByteStreamControllerClose(this);
+    }
+    enqueue(chunk) {
+        if (!IsReadableByteStreamController(this)) {
+            throw byteStreamControllerBrandCheckException('enqueue');
+        }
+        assertRequiredArgument(chunk, 1, 'enqueue');
+        if (!ArrayBuffer.isView(chunk)) {
+            throw new TypeError('chunk must be an array buffer view');
+        }
+        if (chunk.byteLength === 0) {
+            throw new TypeError('chunk must have non-zero byteLength');
+        }
+        if (chunk.buffer.byteLength === 0) {
+            throw new TypeError(`chunk's buffer must have non-zero byteLength`);
+        }
+        if (this._closeRequested) {
+            throw new TypeError('stream is closed or draining');
+        }
+        const state = this._controlledReadableByteStream._state;
+        if (state !== 'readable') {
+            throw new TypeError(`The stream (in ${state} state) is not in the readable state and cannot be enqueued to`);
+        }
+        ReadableByteStreamControllerEnqueue(this, chunk);
+    }
+    /**
+     * Errors the controlled readable stream, making all future interactions with it fail with the given error `e`.
+     */
+    error(e = undefined) {
+        if (!IsReadableByteStreamController(this)) {
+            throw byteStreamControllerBrandCheckException('error');
+        }
+        ReadableByteStreamControllerError(this, e);
+    }
+    /** @internal */
+    [CancelSteps](reason) {
+        ReadableByteStreamControllerClearPendingPullIntos(this);
+        ResetQueue(this);
+        const result = this._cancelAlgorithm(reason);
+        ReadableByteStreamControllerClearAlgorithms(this);
+        return result;
+    }
+    /** @internal */
+    [PullSteps](readRequest) {
+        const stream = this._controlledReadableByteStream;
+        if (this._queueTotalSize > 0) {
+            const entry = this._queue.shift();
+            this._queueTotalSize -= entry.byteLength;
+            ReadableByteStreamControllerHandleQueueDrain(this);
+            const view = new Uint8Array(entry.buffer, entry.byteOffset, entry.byteLength);
+            readRequest._chunkSteps(view);
+            return;
+        }
+        const autoAllocateChunkSize = this._autoAllocateChunkSize;
+        if (autoAllocateChunkSize !== undefined) {
+            let buffer;
+            try {
+                buffer = new ArrayBuffer(autoAllocateChunkSize);
+            }
+            catch (bufferE) {
+                readRequest._errorSteps(bufferE);
+                return;
+            }
+            const pullIntoDescriptor = {
+                buffer,
+                bufferByteLength: autoAllocateChunkSize,
+                byteOffset: 0,
+                byteLength: autoAllocateChunkSize,
+                bytesFilled: 0,
+                elementSize: 1,
+                viewConstructor: Uint8Array,
+                readerType: 'default'
+            };
+            this._pendingPullIntos.push(pullIntoDescriptor);
+        }
+        ReadableStreamAddReadRequest(stream, readRequest);
+        ReadableByteStreamControllerCallPullIfNeeded(this);
+    }
+}
+Object.defineProperties(ReadableByteStreamController.prototype, {
+    close: { enumerable: true },
+    enqueue: { enumerable: true },
+    error: { enumerable: true },
+    byobRequest: { enumerable: true },
+    desiredSize: { enumerable: true }
+});
+// Abstract operations for the ReadableByteStreamController.
+function IsReadableByteStreamController(x) {
+    if (!typeIsObject(x)) {
+        return false;
+    }
+    if (!Object.prototype.hasOwnProperty.call(x, '_controlledReadableByteStream')) {
+        return false;
+    }
+    return x instanceof ReadableByteStreamController;
+}
+function IsReadableStreamBYOBRequest(x) {
+    if (!typeIsObject(x)) {
+        return false;
+    }
+    if (!Object.prototype.hasOwnProperty.call(x, '_associatedReadableByteStreamController')) {
+        return false;
+    }
+    return x instanceof ReadableStreamBYOBRequest;
+}
+function ReadableByteStreamControllerCallPullIfNeeded(controller) {
+    const shouldPull = ReadableByteStreamControllerShouldCallPull(controller);
+    if (!shouldPull) {
+        return;
+    }
+    if (controller._pulling) {
+        controller._pullAgain = true;
+        return;
+    }
+    controller._pulling = true;
+    // TODO: Test controller argument
+    const pullPromise = controller._pullAlgorithm();
+    uponPromise(pullPromise, () => {
+        controller._pulling = false;
+        if (controller._pullAgain) {
+            controller._pullAgain = false;
+            ReadableByteStreamControllerCallPullIfNeeded(controller);
+        }
+    }, e => {
+        ReadableByteStreamControllerError(controller, e);
+    });
+}
+function ReadableByteStreamControllerClearPendingPullIntos(controller) {
+    ReadableByteStreamControllerInvalidateBYOBRequest(controller);
+    controller._pendingPullIntos = new SimpleQueue();
+}
+function ReadableByteStreamControllerCommitPullIntoDescriptor(stream, pullIntoDescriptor) {
+    let done = false;
+    if (stream._state === 'closed') {
+        done = true;
+    }
+    const filledView = ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor);
+    if (pullIntoDescriptor.readerType === 'default') {
+        ReadableStreamFulfillReadRequest(stream, filledView, done);
+    }
+    else {
+        ReadableStreamFulfillReadIntoRequest(stream, filledView, done);
+    }
+}
+function ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor) {
+    const bytesFilled = pullIntoDescriptor.bytesFilled;
+    const elementSize = pullIntoDescriptor.elementSize;
+    return new pullIntoDescriptor.viewConstructor(pullIntoDescriptor.buffer, pullIntoDescriptor.byteOffset, bytesFilled / elementSize);
+}
+function ReadableByteStreamControllerEnqueueChunkToQueue(controller, buffer, byteOffset, byteLength) {
+    controller._queue.push({ buffer, byteOffset, byteLength });
+    controller._queueTotalSize += byteLength;
+}
+function ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) {
+    const elementSize = pullIntoDescriptor.elementSize;
+    const currentAlignedBytes = pullIntoDescriptor.bytesFilled - pullIntoDescriptor.bytesFilled % elementSize;
+    const maxBytesToCopy = Math.min(controller._queueTotalSize, pullIntoDescriptor.byteLength - pullIntoDescriptor.bytesFilled);
+    const maxBytesFilled = pullIntoDescriptor.bytesFilled + maxBytesToCopy;
+    const maxAlignedBytes = maxBytesFilled - maxBytesFilled % elementSize;
+    let totalBytesToCopyRemaining = maxBytesToCopy;
+    let ready = false;
+    if (maxAlignedBytes > currentAlignedBytes) {
+        totalBytesToCopyRemaining = maxAlignedBytes - pullIntoDescriptor.bytesFilled;
+        ready = true;
+    }
+    const queue = controller._queue;
+    while (totalBytesToCopyRemaining > 0) {
+        const headOfQueue = queue.peek();
+        const bytesToCopy = Math.min(totalBytesToCopyRemaining, headOfQueue.byteLength);
+        const destStart = pullIntoDescriptor.byteOffset + pullIntoDescriptor.bytesFilled;
+        CopyDataBlockBytes(pullIntoDescriptor.buffer, destStart, headOfQueue.buffer, headOfQueue.byteOffset, bytesToCopy);
+        if (headOfQueue.byteLength === bytesToCopy) {
+            queue.shift();
+        }
+        else {
+            headOfQueue.byteOffset += bytesToCopy;
+            headOfQueue.byteLength -= bytesToCopy;
+        }
+        controller._queueTotalSize -= bytesToCopy;
+        ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesToCopy, pullIntoDescriptor);
+        totalBytesToCopyRemaining -= bytesToCopy;
+    }
+    return ready;
+}
+function ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, size, pullIntoDescriptor) {
+    pullIntoDescriptor.bytesFilled += size;
+}
+function ReadableByteStreamControllerHandleQueueDrain(controller) {
+    if (controller._queueTotalSize === 0 && controller._closeRequested) {
+        ReadableByteStreamControllerClearAlgorithms(controller);
+        ReadableStreamClose(controller._controlledReadableByteStream);
+    }
+    else {
+        ReadableByteStreamControllerCallPullIfNeeded(controller);
+    }
+}
+function ReadableByteStreamControllerInvalidateBYOBRequest(controller) {
+    if (controller._byobRequest === null) {
+        return;
+    }
+    controller._byobRequest._associatedReadableByteStreamController = undefined;
+    controller._byobRequest._view = null;
+    controller._byobRequest = null;
+}
+function ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller) {
+    while (controller._pendingPullIntos.length > 0) {
+        if (controller._queueTotalSize === 0) {
+            return;
+        }
+        const pullIntoDescriptor = controller._pendingPullIntos.peek();
+        if (ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor)) {
+            ReadableByteStreamControllerShiftPendingPullInto(controller);
+            ReadableByteStreamControllerCommitPullIntoDescriptor(controller._controlledReadableByteStream, pullIntoDescriptor);
+        }
+    }
+}
+function ReadableByteStreamControllerPullInto(controller, view, readIntoRequest) {
+    const stream = controller._controlledReadableByteStream;
+    let elementSize = 1;
+    if (view.constructor !== DataView) {
+        elementSize = view.constructor.BYTES_PER_ELEMENT;
+    }
+    const ctor = view.constructor;
+    // try {
+    const buffer = TransferArrayBuffer(view.buffer);
+    // } catch (e) {
+    //   readIntoRequest._errorSteps(e);
+    //   return;
+    // }
+    const pullIntoDescriptor = {
+        buffer,
+        bufferByteLength: buffer.byteLength,
+        byteOffset: view.byteOffset,
+        byteLength: view.byteLength,
+        bytesFilled: 0,
+        elementSize,
+        viewConstructor: ctor,
+        readerType: 'byob'
+    };
+    if (controller._pendingPullIntos.length > 0) {
+        controller._pendingPullIntos.push(pullIntoDescriptor);
+        // No ReadableByteStreamControllerCallPullIfNeeded() call since:
+        // - No change happens on desiredSize
+        // - The source has already been notified of that there's at least 1 pending read(view)
+        ReadableStreamAddReadIntoRequest(stream, readIntoRequest);
+        return;
+    }
+    if (stream._state === 'closed') {
+        const emptyView = new ctor(pullIntoDescriptor.buffer, pullIntoDescriptor.byteOffset, 0);
+        readIntoRequest._closeSteps(emptyView);
+        return;
+    }
+    if (controller._queueTotalSize > 0) {
+        if (ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor)) {
+            const filledView = ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor);
+            ReadableByteStreamControllerHandleQueueDrain(controller);
+            readIntoRequest._chunkSteps(filledView);
+            return;
+        }
+        if (controller._closeRequested) {
+            const e = new TypeError('Insufficient bytes to fill elements in the given buffer');
+            ReadableByteStreamControllerError(controller, e);
+            readIntoRequest._errorSteps(e);
+            return;
+        }
+    }
+    controller._pendingPullIntos.push(pullIntoDescriptor);
+    ReadableStreamAddReadIntoRequest(stream, readIntoRequest);
+    ReadableByteStreamControllerCallPullIfNeeded(controller);
+}
+function ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor) {
+    const stream = controller._controlledReadableByteStream;
+    if (ReadableStreamHasBYOBReader(stream)) {
+        while (ReadableStreamGetNumReadIntoRequests(stream) > 0) {
+            const pullIntoDescriptor = ReadableByteStreamControllerShiftPendingPullInto(controller);
+            ReadableByteStreamControllerCommitPullIntoDescriptor(stream, pullIntoDescriptor);
+        }
+    }
+}
+function ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, pullIntoDescriptor) {
+    ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesWritten, pullIntoDescriptor);
+    if (pullIntoDescriptor.bytesFilled < pullIntoDescriptor.elementSize) {
+        return;
+    }
+    ReadableByteStreamControllerShiftPendingPullInto(controller);
+    const remainderSize = pullIntoDescriptor.bytesFilled % pullIntoDescriptor.elementSize;
+    if (remainderSize > 0) {
+        const end = pullIntoDescriptor.byteOffset + pullIntoDescriptor.bytesFilled;
+        const remainder = ArrayBufferSlice(pullIntoDescriptor.buffer, end - remainderSize, end);
+        ReadableByteStreamControllerEnqueueChunkToQueue(controller, remainder, 0, remainder.byteLength);
+    }
+    pullIntoDescriptor.bytesFilled -= remainderSize;
+    ReadableByteStreamControllerCommitPullIntoDescriptor(controller._controlledReadableByteStream, pullIntoDescriptor);
+    ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller);
+}
+function ReadableByteStreamControllerRespondInternal(controller, bytesWritten) {
+    const firstDescriptor = controller._pendingPullIntos.peek();
+    ReadableByteStreamControllerInvalidateBYOBRequest(controller);
+    const state = controller._controlledReadableByteStream._state;
+    if (state === 'closed') {
+        ReadableByteStreamControllerRespondInClosedState(controller);
+    }
+    else {
+        ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, firstDescriptor);
+    }
+    ReadableByteStreamControllerCallPullIfNeeded(controller);
+}
+function ReadableByteStreamControllerShiftPendingPullInto(controller) {
+    const descriptor = controller._pendingPullIntos.shift();
+    return descriptor;
+}
+function ReadableByteStreamControllerShouldCallPull(controller) {
+    const stream = controller._controlledReadableByteStream;
+    if (stream._state !== 'readable') {
+        return false;
+    }
+    if (controller._closeRequested) {
+        return false;
+    }
+    if (!controller._started) {
+        return false;
+    }
+    if (ReadableStreamHasDefaultReader(stream) && ReadableStreamGetNumReadRequests(stream) > 0) {
+        return true;
+    }
+    if (ReadableStreamHasBYOBReader(stream) && ReadableStreamGetNumReadIntoRequests(stream) > 0) {
+        return true;
+    }
+    const desiredSize = ReadableByteStreamControllerGetDesiredSize(controller);
+    if (desiredSize > 0) {
+        return true;
+    }
+    return false;
+}
+function ReadableByteStreamControllerClearAlgorithms(controller) {
+    controller._pullAlgorithm = undefined;
+    controller._cancelAlgorithm = undefined;
+}
+// A client of ReadableByteStreamController may use these functions directly to bypass state check.
+function ReadableByteStreamControllerClose(controller) {
+    const stream = controller._controlledReadableByteStream;
+    if (controller._closeRequested || stream._state !== 'readable') {
+        return;
+    }
+    if (controller._queueTotalSize > 0) {
+        controller._closeRequested = true;
+        return;
+    }
+    if (controller._pendingPullIntos.length > 0) {
+        const firstPendingPullInto = controller._pendingPullIntos.peek();
+        if (firstPendingPullInto.bytesFilled > 0) {
+            const e = new TypeError('Insufficient bytes to fill elements in the given buffer');
+            ReadableByteStreamControllerError(controller, e);
+            throw e;
+        }
+    }
+    ReadableByteStreamControllerClearAlgorithms(controller);
+    ReadableStreamClose(stream);
+}
+function ReadableByteStreamControllerEnqueue(controller, chunk) {
+    const stream = controller._controlledReadableByteStream;
+    if (controller._closeRequested || stream._state !== 'readable') {
+        return;
+    }
+    const buffer = chunk.buffer;
+    const byteOffset = chunk.byteOffset;
+    const byteLength = chunk.byteLength;
+    const transferredBuffer = TransferArrayBuffer(buffer);
+    if (controller._pendingPullIntos.length > 0) {
+        const firstPendingPullInto = controller._pendingPullIntos.peek();
+        if (IsDetachedBuffer(firstPendingPullInto.buffer)) ;
+        firstPendingPullInto.buffer = TransferArrayBuffer(firstPendingPullInto.buffer);
+    }
+    ReadableByteStreamControllerInvalidateBYOBRequest(controller);
+    if (ReadableStreamHasDefaultReader(stream)) {
+        if (ReadableStreamGetNumReadRequests(stream) === 0) {
+            ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);
+        }
+        else {
+            if (controller._pendingPullIntos.length > 0) {
+                ReadableByteStreamControllerShiftPendingPullInto(controller);
+            }
+            const transferredView = new Uint8Array(transferredBuffer, byteOffset, byteLength);
+            ReadableStreamFulfillReadRequest(stream, transferredView, false);
+        }
+    }
+    else if (ReadableStreamHasBYOBReader(stream)) {
+        // TODO: Ideally in this branch detaching should happen only if the buffer is not consumed fully.
+        ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);
+        ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller);
+    }
+    else {
+        ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);
+    }
+    ReadableByteStreamControllerCallPullIfNeeded(controller);
+}
+function ReadableByteStreamControllerError(controller, e) {
+    const stream = controller._controlledReadableByteStream;
+    if (stream._state !== 'readable') {
+        return;
+    }
+    ReadableByteStreamControllerClearPendingPullIntos(controller);
+    ResetQueue(controller);
+    ReadableByteStreamControllerClearAlgorithms(controller);
+    ReadableStreamError(stream, e);
+}
+function ReadableByteStreamControllerGetBYOBRequest(controller) {
+    if (controller._byobRequest === null && controller._pendingPullIntos.length > 0) {
+        const firstDescriptor = controller._pendingPullIntos.peek();
+        const view = new Uint8Array(firstDescriptor.buffer, firstDescriptor.byteOffset + firstDescriptor.bytesFilled, firstDescriptor.byteLength - firstDescriptor.bytesFilled);
+        const byobRequest = Object.create(ReadableStreamBYOBRequest.prototype);
+        SetUpReadableStreamBYOBRequest(byobRequest, controller, view);
+        controller._byobRequest = byobRequest;
+    }
+    return controller._byobRequest;
+}
+function ReadableByteStreamControllerGetDesiredSize(controller) {
+    const state = controller._controlledReadableByteStream._state;
+    if (state === 'errored') {
+        return null;
+    }
+    if (state === 'closed') {
+        return 0;
+    }
+    return controller._strategyHWM - controller._queueTotalSize;
+}
+function ReadableByteStreamControllerRespond(controller, bytesWritten) {
+    const firstDescriptor = controller._pendingPullIntos.peek();
+    const state = controller._controlledReadableByteStream._state;
+    if (state === 'closed') {
+        if (bytesWritten !== 0) {
+            throw new TypeError('bytesWritten must be 0 when calling respond() on a closed stream');
+        }
+    }
+    else {
+        if (bytesWritten === 0) {
+            throw new TypeError('bytesWritten must be greater than 0 when calling respond() on a readable stream');
+        }
+        if (firstDescriptor.bytesFilled + bytesWritten > firstDescriptor.byteLength) {
+            throw new RangeError('bytesWritten out of range');
+        }
+    }
+    firstDescriptor.buffer = TransferArrayBuffer(firstDescriptor.buffer);
+    ReadableByteStreamControllerRespondInternal(controller, bytesWritten);
+}
+function ReadableByteStreamControllerRespondWithNewView(controller, view) {
+    const firstDescriptor = controller._pendingPullIntos.peek();
+    const state = controller._controlledReadableByteStream._state;
+    if (state === 'closed') {
+        if (view.byteLength !== 0) {
+            throw new TypeError('The view\'s length must be 0 when calling respondWithNewView() on a closed stream');
+        }
+    }
+    else {
+        if (view.byteLength === 0) {
+            throw new TypeError('The view\'s length must be greater than 0 when calling respondWithNewView() on a readable stream');
+        }
+    }
+    if (firstDescriptor.byteOffset + firstDescriptor.bytesFilled !== view.byteOffset) {
+        throw new RangeError('The region specified by view does not match byobRequest');
+    }
+    if (firstDescriptor.bufferByteLength !== view.buffer.byteLength) {
+        throw new RangeError('The buffer of view has different capacity than byobRequest');
+    }
+    if (firstDescriptor.bytesFilled + view.byteLength > firstDescriptor.byteLength) {
+        throw new RangeError('The region specified by view is larger than byobRequest');
+    }
+    const viewByteLength = view.byteLength;
+    firstDescriptor.buffer = TransferArrayBuffer(view.buffer);
+    ReadableByteStreamControllerRespondInternal(controller, viewByteLength);
+}
+function SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, autoAllocateChunkSize) {
+    controller._controlledReadableByteStream = stream;
+    controller._pullAgain = false;
+    controller._pulling = false;
+    controller._byobRequest = null;
+    // Need to set the slots so that the assert doesn't fire. In the spec the slots already exist implicitly.
+    controller._queue = controller._queueTotalSize = undefined;
+    ResetQueue(controller);
+    controller._closeRequested = false;
+    controller._started = false;
+    controller._strategyHWM = highWaterMark;
+    controller._pullAlgorithm = pullAlgorithm;
+    controller._cancelAlgorithm = cancelAlgorithm;
+    controller._autoAllocateChunkSize = autoAllocateChunkSize;
+    controller._pendingPullIntos = new SimpleQueue();
+    stream._readableStreamController = controller;
+    const startResult = startAlgorithm();
+    uponPromise(promiseResolvedWith(startResult), () => {
+        controller._started = true;
+        ReadableByteStreamControllerCallPullIfNeeded(controller);
+    }, r => {
+        ReadableByteStreamControllerError(controller, r);
+    });
+}
+function SetUpReadableByteStreamControllerFromUnderlyingSource(stream, underlyingByteSource, highWaterMark) {
+    const controller = Object.create(ReadableByteStreamController.prototype);
+    let startAlgorithm = () => undefined;
+    let pullAlgorithm = () => promiseResolvedWith(undefined);
+    let cancelAlgorithm = () => promiseResolvedWith(undefined);
+    if (underlyingByteSource.start !== undefined) {
+        startAlgorithm = () => underlyingByteSource.start(controller);
+    }
+    if (underlyingByteSource.pull !== undefined) {
+        pullAlgorithm = () => underlyingByteSource.pull(controller);
+    }
+    if (underlyingByteSource.cancel !== undefined) {
+        cancelAlgorithm = reason => underlyingByteSource.cancel(reason);
+    }
+    const autoAllocateChunkSize = underlyingByteSource.autoAllocateChunkSize;
+    if (autoAllocateChunkSize === 0) {
+        throw new TypeError('autoAllocateChunkSize must be greater than 0');
+    }
+    SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, autoAllocateChunkSize);
+}
+function SetUpReadableStreamBYOBRequest(request, controller, view) {
+    request._associatedReadableByteStreamController = controller;
+    request._view = view;
+}
+// Helper functions for the ReadableStreamBYOBRequest.
+function byobRequestBrandCheckException(name) {
+    return new TypeError(`ReadableStreamBYOBRequest.prototype.${name} can only be used on a ReadableStreamBYOBRequest`);
+}
+// Helper functions for the ReadableByteStreamController.
+function byteStreamControllerBrandCheckException(name) {
+    return new TypeError(`ReadableByteStreamController.prototype.${name} can only be used on a ReadableByteStreamController`);
+}
+
+// Abstract operations for the ReadableStream.
+function AcquireReadableStreamBYOBReader(stream) {
+    return new ReadableStreamBYOBReader(stream);
+}
+// ReadableStream API exposed for controllers.
+function ReadableStreamAddReadIntoRequest(stream, readIntoRequest) {
+    stream._reader._readIntoRequests.push(readIntoRequest);
+}
+function ReadableStreamFulfillReadIntoRequest(stream, chunk, done) {
+    const reader = stream._reader;
+    const readIntoRequest = reader._readIntoRequests.shift();
+    if (done) {
+        readIntoRequest._closeSteps(chunk);
+    }
+    else {
+        readIntoRequest._chunkSteps(chunk);
+    }
+}
+function ReadableStreamGetNumReadIntoRequests(stream) {
+    return stream._reader._readIntoRequests.length;
+}
+function ReadableStreamHasBYOBReader(stream) {
+    const reader = stream._reader;
+    if (reader === undefined) {
+        return false;
+    }
+    if (!IsReadableStreamBYOBReader(reader)) {
+        return false;
+    }
+    return true;
+}
+/**
+ * A BYOB reader vended by a {@link ReadableStream}.
+ *
+ * @public
+ */
+class ReadableStreamBYOBReader {
+    constructor(stream) {
+        assertRequiredArgument(stream, 1, 'ReadableStreamBYOBReader');
+        assertReadableStream(stream, 'First parameter');
+        if (IsReadableStreamLocked(stream)) {
+            throw new TypeError('This stream has already been locked for exclusive reading by another reader');
+        }
+        if (!IsReadableByteStreamController(stream._readableStreamController)) {
+            throw new TypeError('Cannot construct a ReadableStreamBYOBReader for a stream not constructed with a byte ' +
+                'source');
+        }
+        ReadableStreamReaderGenericInitialize(this, stream);
+        this._readIntoRequests = new SimpleQueue();
+    }
+    /**
+     * Returns a promise that will be fulfilled when the stream becomes closed, or rejected if the stream ever errors or
+     * the reader's lock is released before the stream finishes closing.
+     */
+    get closed() {
+        if (!IsReadableStreamBYOBReader(this)) {
+            return promiseRejectedWith(byobReaderBrandCheckException('closed'));
+        }
+        return this._closedPromise;
+    }
+    /**
+     * If the reader is active, behaves the same as {@link ReadableStream.cancel | stream.cancel(reason)}.
+     */
+    cancel(reason = undefined) {
+        if (!IsReadableStreamBYOBReader(this)) {
+            return promiseRejectedWith(byobReaderBrandCheckException('cancel'));
+        }
+        if (this._ownerReadableStream === undefined) {
+            return promiseRejectedWith(readerLockException('cancel'));
+        }
+        return ReadableStreamReaderGenericCancel(this, reason);
+    }
+    /**
+     * Attempts to reads bytes into view, and returns a promise resolved with the result.
+     *
+     * If reading a chunk causes the queue to become empty, more data will be pulled from the underlying source.
+     */
+    read(view) {
+        if (!IsReadableStreamBYOBReader(this)) {
+            return promiseRejectedWith(byobReaderBrandCheckException('read'));
+        }
+        if (!ArrayBuffer.isView(view)) {
+            return promiseRejectedWith(new TypeError('view must be an array buffer view'));
+        }
+        if (view.byteLength === 0) {
+            return promiseRejectedWith(new TypeError('view must have non-zero byteLength'));
+        }
+        if (view.buffer.byteLength === 0) {
+            return promiseRejectedWith(new TypeError(`view's buffer must have non-zero byteLength`));
+        }
+        if (IsDetachedBuffer(view.buffer)) ;
+        if (this._ownerReadableStream === undefined) {
+            return promiseRejectedWith(readerLockException('read from'));
+        }
+        let resolvePromise;
+        let rejectPromise;
+        const promise = newPromise((resolve, reject) => {
+            resolvePromise = resolve;
+            rejectPromise = reject;
+        });
+        const readIntoRequest = {
+            _chunkSteps: chunk => resolvePromise({ value: chunk, done: false }),
+            _closeSteps: chunk => resolvePromise({ value: chunk, done: true }),
+            _errorSteps: e => rejectPromise(e)
+        };
+        ReadableStreamBYOBReaderRead(this, view, readIntoRequest);
+        return promise;
+    }
+    /**
+     * Releases the reader's lock on the corresponding stream. After the lock is released, the reader is no longer active.
+     * If the associated stream is errored when the lock is released, the reader will appear errored in the same way
+     * from now on; otherwise, the reader will appear closed.
+     *
+     * A reader's lock cannot be released while it still has a pending read request, i.e., if a promise returned by
+     * the reader's {@link ReadableStreamBYOBReader.read | read()} method has not yet been settled. Attempting to
+     * do so will throw a `TypeError` and leave the reader locked to the stream.
+     */
+    releaseLock() {
+        if (!IsReadableStreamBYOBReader(this)) {
+            throw byobReaderBrandCheckException('releaseLock');
+        }
+        if (this._ownerReadableStream === undefined) {
+            return;
+        }
+        if (this._readIntoRequests.length > 0) {
+            throw new TypeError('Tried to release a reader lock when that reader has pending read() calls un-settled');
+        }
+        ReadableStreamReaderGenericRelease(this);
+    }
+}
+Object.defineProperties(ReadableStreamBYOBReader.prototype, {
+    cancel: { enumerable: true },
+    read: { enumerable: true },
+    releaseLock: { enumerable: true },
+    closed: { enumerable: true }
+});
+// Abstract operations for the readers.
+function IsReadableStreamBYOBReader(x) {
+    if (!typeIsObject(x)) {
+        return false;
+    }
+    if (!Object.prototype.hasOwnProperty.call(x, '_readIntoRequests')) {
+        return false;
+    }
+    return x instanceof ReadableStreamBYOBReader;
+}
+function ReadableStreamBYOBReaderRead(reader, view, readIntoRequest) {
+    const stream = reader._ownerReadableStream;
+    stream._disturbed = true;
+    if (stream._state === 'errored') {
+        readIntoRequest._errorSteps(stream._storedError);
+    }
+    else {
+        ReadableByteStreamControllerPullInto(stream._readableStreamController, view, readIntoRequest);
+    }
+}
+// Helper functions for the ReadableStreamBYOBReader.
+function byobReaderBrandCheckException(name) {
+    return new TypeError(`ReadableStreamBYOBReader.prototype.${name} can only be used on a ReadableStreamBYOBReader`);
+}
+
+function ExtractHighWaterMark(strategy, defaultHWM) {
+    const { highWaterMark } = strategy;
+    if (highWaterMark === undefined) {
+        return defaultHWM;
+    }
+    if (NumberIsNaN(highWaterMark) || highWaterMark < 0) {
+        throw new RangeError('Invalid highWaterMark');
+    }
+    return highWaterMark;
+}
+function ExtractSizeAlgorithm(strategy) {
+    const { size } = strategy;
+    if (!size) {
+        return () => 1;
+    }
+    return size;
+}
+
+function convertQueuingStrategy(init, context) {
+    assertDictionary(init, context);
+    const highWaterMark = init === null || init === void 0 ? void 0 : init.highWaterMark;
+    const size = init === null || init === void 0 ? void 0 : init.size;
+    return {
+        highWaterMark: highWaterMark === undefined ? undefined : convertUnrestrictedDouble(highWaterMark),
+        size: size === undefined ? undefined : convertQueuingStrategySize(size, `${context} has member 'size' that`)
+    };
+}
+function convertQueuingStrategySize(fn, context) {
+    assertFunction(fn, context);
+    return chunk => convertUnrestrictedDouble(fn(chunk));
+}
+
+function convertUnderlyingSink(original, context) {
+    assertDictionary(original, context);
+    const abort = original === null || original === void 0 ? void 0 : original.abort;
+    const close = original === null || original === void 0 ? void 0 : original.close;
+    const start = original === null || original === void 0 ? void 0 : original.start;
+    const type = original === null || original === void 0 ? void 0 : original.type;
+    const write = original === null || original === void 0 ? void 0 : original.write;
+    return {
+        abort: abort === undefined ?
+            undefined :
+            convertUnderlyingSinkAbortCallback(abort, original, `${context} has member 'abort' that`),
+        close: close === undefined ?
+            undefined :
+            convertUnderlyingSinkCloseCallback(close, original, `${context} has member 'close' that`),
+        start: start === undefined ?
+            undefined :
+            convertUnderlyingSinkStartCallback(start, original, `${context} has member 'start' that`),
+        write: write === undefined ?
+            undefined :
+            convertUnderlyingSinkWriteCallback(write, original, `${context} has member 'write' that`),
+        type
+    };
+}
+function convertUnderlyingSinkAbortCallback(fn, original, context) {
+    assertFunction(fn, context);
+    return (reason) => promiseCall(fn, original, [reason]);
+}
+function convertUnderlyingSinkCloseCallback(fn, original, context) {
+    assertFunction(fn, context);
+    return () => promiseCall(fn, original, []);
+}
+function convertUnderlyingSinkStartCallback(fn, original, context) {
+    assertFunction(fn, context);
+    return (controller) => reflectCall(fn, original, [controller]);
+}
+function convertUnderlyingSinkWriteCallback(fn, original, context) {
+    assertFunction(fn, context);
+    return (chunk, controller) => promiseCall(fn, original, [chunk, controller]);
+}
+
+function assertWritableStream(x, context) {
+    if (!IsWritableStream(x)) {
+        throw new TypeError(`${context} is not a WritableStream.`);
+    }
+}
+
+function isAbortSignal$1(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    try {
+        return typeof value.aborted === 'boolean';
+    }
+    catch (_a) {
+        // AbortSignal.prototype.aborted throws if its brand check fails
+        return false;
+    }
+}
+
+/**
+ * A writable stream represents a destination for data, into which you can write.
+ *
+ * @public
+ */
+class WritableStream {
+    constructor(rawUnderlyingSink = {}, rawStrategy = {}) {
+        if (rawUnderlyingSink === undefined) {
+            rawUnderlyingSink = null;
+        }
+        else {
+            assertObject(rawUnderlyingSink, 'First parameter');
+        }
+        const strategy = convertQueuingStrategy(rawStrategy, 'Second parameter');
+        const underlyingSink = convertUnderlyingSink(rawUnderlyingSink, 'First parameter');
+        InitializeWritableStream(this);
+        const type = underlyingSink.type;
+        if (type !== undefined) {
+            throw new RangeError('Invalid type is specified');
+        }
+        const sizeAlgorithm = ExtractSizeAlgorithm(strategy);
+        const highWaterMark = ExtractHighWaterMark(strategy, 1);
+        SetUpWritableStreamDefaultControllerFromUnderlyingSink(this, underlyingSink, highWaterMark, sizeAlgorithm);
+    }
+    /**
+     * Returns whether or not the writable stream is locked to a writer.
+     */
+    get locked() {
+        if (!IsWritableStream(this)) {
+            throw streamBrandCheckException$2('locked');
+        }
+        return IsWritableStreamLocked(this);
+    }
+    /**
+     * Aborts the stream, signaling that the producer can no longer successfully write to the stream and it is to be
+     * immediately moved to an errored state, with any queued-up writes discarded. This will also execute any abort
+     * mechanism of the underlying sink.
+     *
+     * The returned promise will fulfill if the stream shuts down successfully, or reject if the underlying sink signaled
+     * that there was an error doing so. Additionally, it will reject with a `TypeError` (without attempting to cancel
+     * the stream) if the stream is currently locked.
+     */
+    abort(reason = undefined) {
+        if (!IsWritableStream(this)) {
+            return promiseRejectedWith(streamBrandCheckException$2('abort'));
+        }
+        if (IsWritableStreamLocked(this)) {
+            return promiseRejectedWith(new TypeError('Cannot abort a stream that already has a writer'));
+        }
+        return WritableStreamAbort(this, reason);
+    }
+    /**
+     * Closes the stream. The underlying sink will finish processing any previously-written chunks, before invoking its
+     * close behavior. During this time any further attempts to write will fail (without erroring the stream).
+     *
+     * The method returns a promise that will fulfill if all remaining chunks are successfully written and the stream
+     * successfully closes, or rejects if an error is encountered during this process. Additionally, it will reject with
+     * a `TypeError` (without attempting to cancel the stream) if the stream is currently locked.
+     */
+    close() {
+        if (!IsWritableStream(this)) {
+            return promiseRejectedWith(streamBrandCheckException$2('close'));
+        }
+        if (IsWritableStreamLocked(this)) {
+            return promiseRejectedWith(new TypeError('Cannot close a stream that already has a writer'));
+        }
+        if (WritableStreamCloseQueuedOrInFlight(this)) {
+            return promiseRejectedWith(new TypeError('Cannot close an already-closing stream'));
+        }
+        return WritableStreamClose(this);
+    }
+    /**
+     * Creates a {@link WritableStreamDefaultWriter | writer} and locks the stream to the new writer. While the stream
+     * is locked, no other writer can be acquired until this one is released.
+     *
+     * This functionality is especially useful for creating abstractions that desire the ability to write to a stream
+     * without interruption or interleaving. By getting a writer for the stream, you can ensure nobody else can write at
+     * the same time, which would cause the resulting written data to be unpredictable and probably useless.
+     */
+    getWriter() {
+        if (!IsWritableStream(this)) {
+            throw streamBrandCheckException$2('getWriter');
+        }
+        return AcquireWritableStreamDefaultWriter(this);
+    }
+}
+Object.defineProperties(WritableStream.prototype, {
+    abort: { enumerable: true },
+    close: { enumerable: true },
+    getWriter: { enumerable: true },
+    locked: { enumerable: true }
+});
+// Abstract operations for the WritableStream.
+function AcquireWritableStreamDefaultWriter(stream) {
+    return new WritableStreamDefaultWriter(stream);
+}
+// Throws if and only if startAlgorithm throws.
+function CreateWritableStream(startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark = 1, sizeAlgorithm = () => 1) {
+    const stream = Object.create(WritableStream.prototype);
+    InitializeWritableStream(stream);
+    const controller = Object.create(WritableStreamDefaultController.prototype);
+    SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm);
+    return stream;
+}
+function InitializeWritableStream(stream) {
+    stream._state = 'writable';
+    // The error that will be reported by new method calls once the state becomes errored. Only set when [[state]] is
+    // 'erroring' or 'errored'. May be set to an undefined value.
+    stream._storedError = undefined;
+    stream._writer = undefined;
+    // Initialize to undefined first because the constructor of the controller checks this
+    // variable to validate the caller.
+    stream._writableStreamController = undefined;
+    // This queue is placed here instead of the writer class in order to allow for passing a writer to the next data
+    // producer without waiting for the queued writes to finish.
+    stream._writeRequests = new SimpleQueue();
+    // Write requests are removed from _writeRequests when write() is called on the underlying sink. This prevents
+    // them from being erroneously rejected on error. If a write() call is in-flight, the request is stored here.
+    stream._inFlightWriteRequest = undefined;
+    // The promise that was returned from writer.close(). Stored here because it may be fulfilled after the writer
+    // has been detached.
+    stream._closeRequest = undefined;
+    // Close request is removed from _closeRequest when close() is called on the underlying sink. This prevents it
+    // from being erroneously rejected on error. If a close() call is in-flight, the request is stored here.
+    stream._inFlightCloseRequest = undefined;
+    // The promise that was returned from writer.abort(). This may also be fulfilled after the writer has detached.
+    stream._pendingAbortRequest = undefined;
+    // The backpressure signal set by the controller.
+    stream._backpressure = false;
+}
+function IsWritableStream(x) {
+    if (!typeIsObject(x)) {
+        return false;
+    }
+    if (!Object.prototype.hasOwnProperty.call(x, '_writableStreamController')) {
+        return false;
+    }
+    return x instanceof WritableStream;
+}
+function IsWritableStreamLocked(stream) {
+    if (stream._writer === undefined) {
+        return false;
+    }
+    return true;
+}
+function WritableStreamAbort(stream, reason) {
+    var _a;
+    if (stream._state === 'closed' || stream._state === 'errored') {
+        return promiseResolvedWith(undefined);
+    }
+    stream._writableStreamController._abortReason = reason;
+    (_a = stream._writableStreamController._abortController) === null || _a === void 0 ? void 0 : _a.abort();
+    // TypeScript narrows the type of `stream._state` down to 'writable' | 'erroring',
+    // but it doesn't know that signaling abort runs author code that might have changed the state.
+    // Widen the type again by casting to WritableStreamState.
+    const state = stream._state;
+    if (state === 'closed' || state === 'errored') {
+        return promiseResolvedWith(undefined);
+    }
+    if (stream._pendingAbortRequest !== undefined) {
+        return stream._pendingAbortRequest._promise;
+    }
+    let wasAlreadyErroring = false;
+    if (state === 'erroring') {
+        wasAlreadyErroring = true;
+        // reason will not be used, so don't keep a reference to it.
+        reason = undefined;
+    }
+    const promise = newPromise((resolve, reject) => {
+        stream._pendingAbortRequest = {
+            _promise: undefined,
+            _resolve: resolve,
+            _reject: reject,
+            _reason: reason,
+            _wasAlreadyErroring: wasAlreadyErroring
+        };
+    });
+    stream._pendingAbortRequest._promise = promise;
+    if (!wasAlreadyErroring) {
+        WritableStreamStartErroring(stream, reason);
+    }
+    return promise;
+}
+function WritableStreamClose(stream) {
+    const state = stream._state;
+    if (state === 'closed' || state === 'errored') {
+        return promiseRejectedWith(new TypeError(`The stream (in ${state} state) is not in the writable state and cannot be closed`));
+    }
+    const promise = newPromise((resolve, reject) => {
+        const closeRequest = {
+            _resolve: resolve,
+            _reject: reject
+        };
+        stream._closeRequest = closeRequest;
+    });
+    const writer = stream._writer;
+    if (writer !== undefined && stream._backpressure && state === 'writable') {
+        defaultWriterReadyPromiseResolve(writer);
+    }
+    WritableStreamDefaultControllerClose(stream._writableStreamController);
+    return promise;
+}
+// WritableStream API exposed for controllers.
+function WritableStreamAddWriteRequest(stream) {
+    const promise = newPromise((resolve, reject) => {
+        const writeRequest = {
+            _resolve: resolve,
+            _reject: reject
+        };
+        stream._writeRequests.push(writeRequest);
+    });
+    return promise;
+}
+function WritableStreamDealWithRejection(stream, error) {
+    const state = stream._state;
+    if (state === 'writable') {
+        WritableStreamStartErroring(stream, error);
+        return;
+    }
+    WritableStreamFinishErroring(stream);
+}
+function WritableStreamStartErroring(stream, reason) {
+    const controller = stream._writableStreamController;
+    stream._state = 'erroring';
+    stream._storedError = reason;
+    const writer = stream._writer;
+    if (writer !== undefined) {
+        WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, reason);
+    }
+    if (!WritableStreamHasOperationMarkedInFlight(stream) && controller._started) {
+        WritableStreamFinishErroring(stream);
+    }
+}
+function WritableStreamFinishErroring(stream) {
+    stream._state = 'errored';
+    stream._writableStreamController[ErrorSteps]();
+    const storedError = stream._storedError;
+    stream._writeRequests.forEach(writeRequest => {
+        writeRequest._reject(storedError);
+    });
+    stream._writeRequests = new SimpleQueue();
+    if (stream._pendingAbortRequest === undefined) {
+        WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
+        return;
+    }
+    const abortRequest = stream._pendingAbortRequest;
+    stream._pendingAbortRequest = undefined;
+    if (abortRequest._wasAlreadyErroring) {
+        abortRequest._reject(storedError);
+        WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
+        return;
+    }
+    const promise = stream._writableStreamController[AbortSteps](abortRequest._reason);
+    uponPromise(promise, () => {
+        abortRequest._resolve();
+        WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
+    }, (reason) => {
+        abortRequest._reject(reason);
+        WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
+    });
+}
+function WritableStreamFinishInFlightWrite(stream) {
+    stream._inFlightWriteRequest._resolve(undefined);
+    stream._inFlightWriteRequest = undefined;
+}
+function WritableStreamFinishInFlightWriteWithError(stream, error) {
+    stream._inFlightWriteRequest._reject(error);
+    stream._inFlightWriteRequest = undefined;
+    WritableStreamDealWithRejection(stream, error);
+}
+function WritableStreamFinishInFlightClose(stream) {
+    stream._inFlightCloseRequest._resolve(undefined);
+    stream._inFlightCloseRequest = undefined;
+    const state = stream._state;
+    if (state === 'erroring') {
+        // The error was too late to do anything, so it is ignored.
+        stream._storedError = undefined;
+        if (stream._pendingAbortRequest !== undefined) {
+            stream._pendingAbortRequest._resolve();
+            stream._pendingAbortRequest = undefined;
+        }
+    }
+    stream._state = 'closed';
+    const writer = stream._writer;
+    if (writer !== undefined) {
+        defaultWriterClosedPromiseResolve(writer);
+    }
+}
+function WritableStreamFinishInFlightCloseWithError(stream, error) {
+    stream._inFlightCloseRequest._reject(error);
+    stream._inFlightCloseRequest = undefined;
+    // Never execute sink abort() after sink close().
+    if (stream._pendingAbortRequest !== undefined) {
+        stream._pendingAbortRequest._reject(error);
+        stream._pendingAbortRequest = undefined;
+    }
+    WritableStreamDealWithRejection(stream, error);
+}
+// TODO(ricea): Fix alphabetical order.
+function WritableStreamCloseQueuedOrInFlight(stream) {
+    if (stream._closeRequest === undefined && stream._inFlightCloseRequest === undefined) {
+        return false;
+    }
+    return true;
+}
+function WritableStreamHasOperationMarkedInFlight(stream) {
+    if (stream._inFlightWriteRequest === undefined && stream._inFlightCloseRequest === undefined) {
+        return false;
+    }
+    return true;
+}
+function WritableStreamMarkCloseRequestInFlight(stream) {
+    stream._inFlightCloseRequest = stream._closeRequest;
+    stream._closeRequest = undefined;
+}
+function WritableStreamMarkFirstWriteRequestInFlight(stream) {
+    stream._inFlightWriteRequest = stream._writeRequests.shift();
+}
+function WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream) {
+    if (stream._closeRequest !== undefined) {
+        stream._closeRequest._reject(stream._storedError);
+        stream._closeRequest = undefined;
+    }
+    const writer = stream._writer;
+    if (writer !== undefined) {
+        defaultWriterClosedPromiseReject(writer, stream._storedError);
+    }
+}
+function WritableStreamUpdateBackpressure(stream, backpressure) {
+    const writer = stream._writer;
+    if (writer !== undefined && backpressure !== stream._backpressure) {
+        if (backpressure) {
+            defaultWriterReadyPromiseReset(writer);
+        }
+        else {
+            defaultWriterReadyPromiseResolve(writer);
+        }
+    }
+    stream._backpressure = backpressure;
+}
+/**
+ * A default writer vended by a {@link WritableStream}.
+ *
+ * @public
+ */
+class WritableStreamDefaultWriter {
+    constructor(stream) {
+        assertRequiredArgument(stream, 1, 'WritableStreamDefaultWriter');
+        assertWritableStream(stream, 'First parameter');
+        if (IsWritableStreamLocked(stream)) {
+            throw new TypeError('This stream has already been locked for exclusive writing by another writer');
+        }
+        this._ownerWritableStream = stream;
+        stream._writer = this;
+        const state = stream._state;
+        if (state === 'writable') {
+            if (!WritableStreamCloseQueuedOrInFlight(stream) && stream._backpressure) {
+                defaultWriterReadyPromiseInitialize(this);
+            }
+            else {
+                defaultWriterReadyPromiseInitializeAsResolved(this);
+            }
+            defaultWriterClosedPromiseInitialize(this);
+        }
+        else if (state === 'erroring') {
+            defaultWriterReadyPromiseInitializeAsRejected(this, stream._storedError);
+            defaultWriterClosedPromiseInitialize(this);
+        }
+        else if (state === 'closed') {
+            defaultWriterReadyPromiseInitializeAsResolved(this);
+            defaultWriterClosedPromiseInitializeAsResolved(this);
+        }
+        else {
+            const storedError = stream._storedError;
+            defaultWriterReadyPromiseInitializeAsRejected(this, storedError);
+            defaultWriterClosedPromiseInitializeAsRejected(this, storedError);
+        }
+    }
+    /**
+     * Returns a promise that will be fulfilled when the stream becomes closed, or rejected if the stream ever errors or
+     * the writer’s lock is released before the stream finishes closing.
+     */
+    get closed() {
+        if (!IsWritableStreamDefaultWriter(this)) {
+            return promiseRejectedWith(defaultWriterBrandCheckException('closed'));
+        }
+        return this._closedPromise;
+    }
+    /**
+     * Returns the desired size to fill the stream’s internal queue. It can be negative, if the queue is over-full.
+     * A producer can use this information to determine the right amount of data to write.
+     *
+     * It will be `null` if the stream cannot be successfully written to (due to either being errored, or having an abort
+     * queued up). It will return zero if the stream is closed. And the getter will throw an exception if invoked when
+     * the writer’s lock is released.
+     */
+    get desiredSize() {
+        if (!IsWritableStreamDefaultWriter(this)) {
+            throw defaultWriterBrandCheckException('desiredSize');
+        }
+        if (this._ownerWritableStream === undefined) {
+            throw defaultWriterLockException('desiredSize');
+        }
+        return WritableStreamDefaultWriterGetDesiredSize(this);
+    }
+    /**
+     * Returns a promise that will be fulfilled when the desired size to fill the stream’s internal queue transitions
+     * from non-positive to positive, signaling that it is no longer applying backpressure. Once the desired size dips
+     * back to zero or below, the getter will return a new promise that stays pending until the next transition.
+     *
+     * If the stream becomes errored or aborted, or the writer’s lock is released, the returned promise will become
+     * rejected.
+     */
+    get ready() {
+        if (!IsWritableStreamDefaultWriter(this)) {
+            return promiseRejectedWith(defaultWriterBrandCheckException('ready'));
+        }
+        return this._readyPromise;
+    }
+    /**
+     * If the reader is active, behaves the same as {@link WritableStream.abort | stream.abort(reason)}.
+     */
+    abort(reason = undefined) {
+        if (!IsWritableStreamDefaultWriter(this)) {
+            return promiseRejectedWith(defaultWriterBrandCheckException('abort'));
+        }
+        if (this._ownerWritableStream === undefined) {
+            return promiseRejectedWith(defaultWriterLockException('abort'));
+        }
+        return WritableStreamDefaultWriterAbort(this, reason);
+    }
+    /**
+     * If the reader is active, behaves the same as {@link WritableStream.close | stream.close()}.
+     */
+    close() {
+        if (!IsWritableStreamDefaultWriter(this)) {
+            return promiseRejectedWith(defaultWriterBrandCheckException('close'));
+        }
+        const stream = this._ownerWritableStream;
+        if (stream === undefined) {
+            return promiseRejectedWith(defaultWriterLockException('close'));
+        }
+        if (WritableStreamCloseQueuedOrInFlight(stream)) {
+            return promiseRejectedWith(new TypeError('Cannot close an already-closing stream'));
+        }
+        return WritableStreamDefaultWriterClose(this);
+    }
+    /**
+     * Releases the writer’s lock on the corresponding stream. After the lock is released, the writer is no longer active.
+     * If the associated stream is errored when the lock is released, the writer will appear errored in the same way from
+     * now on; otherwise, the writer will appear closed.
+     *
+     * Note that the lock can still be released even if some ongoing writes have not yet finished (i.e. even if the
+     * promises returned from previous calls to {@link WritableStreamDefaultWriter.write | write()} have not yet settled).
+     * It’s not necessary to hold the lock on the writer for the duration of the write; the lock instead simply prevents
+     * other producers from writing in an interleaved manner.
+     */
+    releaseLock() {
+        if (!IsWritableStreamDefaultWriter(this)) {
+            throw defaultWriterBrandCheckException('releaseLock');
+        }
+        const stream = this._ownerWritableStream;
+        if (stream === undefined) {
+            return;
+        }
+        WritableStreamDefaultWriterRelease(this);
+    }
+    write(chunk = undefined) {
+        if (!IsWritableStreamDefaultWriter(this)) {
+            return promiseRejectedWith(defaultWriterBrandCheckException('write'));
+        }
+        if (this._ownerWritableStream === undefined) {
+            return promiseRejectedWith(defaultWriterLockException('write to'));
+        }
+        return WritableStreamDefaultWriterWrite(this, chunk);
+    }
+}
+Object.defineProperties(WritableStreamDefaultWriter.prototype, {
+    abort: { enumerable: true },
+    close: { enumerable: true },
+    releaseLock: { enumerable: true },
+    write: { enumerable: true },
+    closed: { enumerable: true },
+    desiredSize: { enumerable: true },
+    ready: { enumerable: true }
+});
+// Abstract operations for the WritableStreamDefaultWriter.
+function IsWritableStreamDefaultWriter(x) {
+    if (!typeIsObject(x)) {
+        return false;
+    }
+    if (!Object.prototype.hasOwnProperty.call(x, '_ownerWritableStream')) {
+        return false;
+    }
+    return x instanceof WritableStreamDefaultWriter;
+}
+// A client of WritableStreamDefaultWriter may use these functions directly to bypass state check.
+function WritableStreamDefaultWriterAbort(writer, reason) {
+    const stream = writer._ownerWritableStream;
+    return WritableStreamAbort(stream, reason);
+}
+function WritableStreamDefaultWriterClose(writer) {
+    const stream = writer._ownerWritableStream;
+    return WritableStreamClose(stream);
+}
+function WritableStreamDefaultWriterCloseWithErrorPropagation(writer) {
+    const stream = writer._ownerWritableStream;
+    const state = stream._state;
+    if (WritableStreamCloseQueuedOrInFlight(stream) || state === 'closed') {
+        return promiseResolvedWith(undefined);
+    }
+    if (state === 'errored') {
+        return promiseRejectedWith(stream._storedError);
+    }
+    return WritableStreamDefaultWriterClose(writer);
+}
+function WritableStreamDefaultWriterEnsureClosedPromiseRejected(writer, error) {
+    if (writer._closedPromiseState === 'pending') {
+        defaultWriterClosedPromiseReject(writer, error);
+    }
+    else {
+        defaultWriterClosedPromiseResetToRejected(writer, error);
+    }
+}
+function WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, error) {
+    if (writer._readyPromiseState === 'pending') {
+        defaultWriterReadyPromiseReject(writer, error);
+    }
+    else {
+        defaultWriterReadyPromiseResetToRejected(writer, error);
+    }
+}
+function WritableStreamDefaultWriterGetDesiredSize(writer) {
+    const stream = writer._ownerWritableStream;
+    const state = stream._state;
+    if (state === 'errored' || state === 'erroring') {
+        return null;
+    }
+    if (state === 'closed') {
+        return 0;
+    }
+    return WritableStreamDefaultControllerGetDesiredSize(stream._writableStreamController);
+}
+function WritableStreamDefaultWriterRelease(writer) {
+    const stream = writer._ownerWritableStream;
+    const releasedError = new TypeError(`Writer was released and can no longer be used to monitor the stream's closedness`);
+    WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, releasedError);
+    // The state transitions to "errored" before the sink abort() method runs, but the writer.closed promise is not
+    // rejected until afterwards. This means that simply testing state will not work.
+    WritableStreamDefaultWriterEnsureClosedPromiseRejected(writer, releasedError);
+    stream._writer = undefined;
+    writer._ownerWritableStream = undefined;
+}
+function WritableStreamDefaultWriterWrite(writer, chunk) {
+    const stream = writer._ownerWritableStream;
+    const controller = stream._writableStreamController;
+    const chunkSize = WritableStreamDefaultControllerGetChunkSize(controller, chunk);
+    if (stream !== writer._ownerWritableStream) {
+        return promiseRejectedWith(defaultWriterLockException('write to'));
+    }
+    const state = stream._state;
+    if (state === 'errored') {
+        return promiseRejectedWith(stream._storedError);
+    }
+    if (WritableStreamCloseQueuedOrInFlight(stream) || state === 'closed') {
+        return promiseRejectedWith(new TypeError('The stream is closing or closed and cannot be written to'));
+    }
+    if (state === 'erroring') {
+        return promiseRejectedWith(stream._storedError);
+    }
+    const promise = WritableStreamAddWriteRequest(stream);
+    WritableStreamDefaultControllerWrite(controller, chunk, chunkSize);
+    return promise;
+}
+const closeSentinel = {};
+/**
+ * Allows control of a {@link WritableStream | writable stream}'s state and internal queue.
+ *
+ * @public
+ */
+class WritableStreamDefaultController {
+    constructor() {
+        throw new TypeError('Illegal constructor');
+    }
+    /**
+     * The reason which was passed to `WritableStream.abort(reason)` when the stream was aborted.
+     *
+     * @deprecated
+     *  This property has been removed from the specification, see https://github.com/whatwg/streams/pull/1177.
+     *  Use {@link WritableStreamDefaultController.signal}'s `reason` instead.
+     */
+    get abortReason() {
+        if (!IsWritableStreamDefaultController(this)) {
+            throw defaultControllerBrandCheckException$2('abortReason');
+        }
+        return this._abortReason;
+    }
+    /**
+     * An `AbortSignal` that can be used to abort the pending write or close operation when the stream is aborted.
+     */
+    get signal() {
+        if (!IsWritableStreamDefaultController(this)) {
+            throw defaultControllerBrandCheckException$2('signal');
+        }
+        if (this._abortController === undefined) {
+            // Older browsers or older Node versions may not support `AbortController` or `AbortSignal`.
+            // We don't want to bundle and ship an `AbortController` polyfill together with our polyfill,
+            // so instead we only implement support for `signal` if we find a global `AbortController` constructor.
+            throw new TypeError('WritableStreamDefaultController.prototype.signal is not supported');
+        }
+        return this._abortController.signal;
+    }
+    /**
+     * Closes the controlled writable stream, making all future interactions with it fail with the given error `e`.
+     *
+     * This method is rarely used, since usually it suffices to return a rejected promise from one of the underlying
+     * sink's methods. However, it can be useful for suddenly shutting down a stream in response to an event outside the
+     * normal lifecycle of interactions with the underlying sink.
+     */
+    error(e = undefined) {
+        if (!IsWritableStreamDefaultController(this)) {
+            throw defaultControllerBrandCheckException$2('error');
+        }
+        const state = this._controlledWritableStream._state;
+        if (state !== 'writable') {
+            // The stream is closed, errored or will be soon. The sink can't do anything useful if it gets an error here, so
+            // just treat it as a no-op.
+            return;
+        }
+        WritableStreamDefaultControllerError(this, e);
+    }
+    /** @internal */
+    [AbortSteps](reason) {
+        const result = this._abortAlgorithm(reason);
+        WritableStreamDefaultControllerClearAlgorithms(this);
+        return result;
+    }
+    /** @internal */
+    [ErrorSteps]() {
+        ResetQueue(this);
+    }
+}
+Object.defineProperties(WritableStreamDefaultController.prototype, {
+    abortReason: { enumerable: true },
+    signal: { enumerable: true },
+    error: { enumerable: true }
+});
+// Abstract operations implementing interface required by the WritableStream.
+function IsWritableStreamDefaultController(x) {
+    if (!typeIsObject(x)) {
+        return false;
+    }
+    if (!Object.prototype.hasOwnProperty.call(x, '_controlledWritableStream')) {
+        return false;
+    }
+    return x instanceof WritableStreamDefaultController;
+}
+function SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm) {
+    controller._controlledWritableStream = stream;
+    stream._writableStreamController = controller;
+    // Need to set the slots so that the assert doesn't fire. In the spec the slots already exist implicitly.
+    controller._queue = undefined;
+    controller._queueTotalSize = undefined;
+    ResetQueue(controller);
+    controller._abortReason = undefined;
+    controller._abortController = new AbortController();
+    controller._started = false;
+    controller._strategySizeAlgorithm = sizeAlgorithm;
+    controller._strategyHWM = highWaterMark;
+    controller._writeAlgorithm = writeAlgorithm;
+    controller._closeAlgorithm = closeAlgorithm;
+    controller._abortAlgorithm = abortAlgorithm;
+    const backpressure = WritableStreamDefaultControllerGetBackpressure(controller);
+    WritableStreamUpdateBackpressure(stream, backpressure);
+    const startResult = startAlgorithm();
+    const startPromise = promiseResolvedWith(startResult);
+    uponPromise(startPromise, () => {
+        controller._started = true;
+        WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
+    }, r => {
+        controller._started = true;
+        WritableStreamDealWithRejection(stream, r);
+    });
+}
+function SetUpWritableStreamDefaultControllerFromUnderlyingSink(stream, underlyingSink, highWaterMark, sizeAlgorithm) {
+    const controller = Object.create(WritableStreamDefaultController.prototype);
+    let startAlgorithm = () => undefined;
+    let writeAlgorithm = () => promiseResolvedWith(undefined);
+    let closeAlgorithm = () => promiseResolvedWith(undefined);
+    let abortAlgorithm = () => promiseResolvedWith(undefined);
+    if (underlyingSink.start !== undefined) {
+        startAlgorithm = () => underlyingSink.start(controller);
+    }
+    if (underlyingSink.write !== undefined) {
+        writeAlgorithm = chunk => underlyingSink.write(chunk, controller);
+    }
+    if (underlyingSink.close !== undefined) {
+        closeAlgorithm = () => underlyingSink.close();
+    }
+    if (underlyingSink.abort !== undefined) {
+        abortAlgorithm = reason => underlyingSink.abort(reason);
+    }
+    SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm);
+}
+// ClearAlgorithms may be called twice. Erroring the same stream in multiple ways will often result in redundant calls.
+function WritableStreamDefaultControllerClearAlgorithms(controller) {
+    controller._writeAlgorithm = undefined;
+    controller._closeAlgorithm = undefined;
+    controller._abortAlgorithm = undefined;
+    controller._strategySizeAlgorithm = undefined;
+}
+function WritableStreamDefaultControllerClose(controller) {
+    EnqueueValueWithSize(controller, closeSentinel, 0);
+    WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
+}
+function WritableStreamDefaultControllerGetChunkSize(controller, chunk) {
+    try {
+        return controller._strategySizeAlgorithm(chunk);
+    }
+    catch (chunkSizeE) {
+        WritableStreamDefaultControllerErrorIfNeeded(controller, chunkSizeE);
+        return 1;
+    }
+}
+function WritableStreamDefaultControllerGetDesiredSize(controller) {
+    return controller._strategyHWM - controller._queueTotalSize;
+}
+function WritableStreamDefaultControllerWrite(controller, chunk, chunkSize) {
+    try {
+        EnqueueValueWithSize(controller, chunk, chunkSize);
+    }
+    catch (enqueueE) {
+        WritableStreamDefaultControllerErrorIfNeeded(controller, enqueueE);
+        return;
+    }
+    const stream = controller._controlledWritableStream;
+    if (!WritableStreamCloseQueuedOrInFlight(stream) && stream._state === 'writable') {
+        const backpressure = WritableStreamDefaultControllerGetBackpressure(controller);
+        WritableStreamUpdateBackpressure(stream, backpressure);
+    }
+    WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
+}
+// Abstract operations for the WritableStreamDefaultController.
+function WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller) {
+    const stream = controller._controlledWritableStream;
+    if (!controller._started) {
+        return;
+    }
+    if (stream._inFlightWriteRequest !== undefined) {
+        return;
+    }
+    const state = stream._state;
+    if (state === 'erroring') {
+        WritableStreamFinishErroring(stream);
+        return;
+    }
+    if (controller._queue.length === 0) {
+        return;
+    }
+    const value = PeekQueueValue(controller);
+    if (value === closeSentinel) {
+        WritableStreamDefaultControllerProcessClose(controller);
+    }
+    else {
+        WritableStreamDefaultControllerProcessWrite(controller, value);
+    }
+}
+function WritableStreamDefaultControllerErrorIfNeeded(controller, error) {
+    if (controller._controlledWritableStream._state === 'writable') {
+        WritableStreamDefaultControllerError(controller, error);
+    }
+}
+function WritableStreamDefaultControllerProcessClose(controller) {
+    const stream = controller._controlledWritableStream;
+    WritableStreamMarkCloseRequestInFlight(stream);
+    DequeueValue(controller);
+    const sinkClosePromise = controller._closeAlgorithm();
+    WritableStreamDefaultControllerClearAlgorithms(controller);
+    uponPromise(sinkClosePromise, () => {
+        WritableStreamFinishInFlightClose(stream);
+    }, reason => {
+        WritableStreamFinishInFlightCloseWithError(stream, reason);
+    });
+}
+function WritableStreamDefaultControllerProcessWrite(controller, chunk) {
+    const stream = controller._controlledWritableStream;
+    WritableStreamMarkFirstWriteRequestInFlight(stream);
+    const sinkWritePromise = controller._writeAlgorithm(chunk);
+    uponPromise(sinkWritePromise, () => {
+        WritableStreamFinishInFlightWrite(stream);
+        const state = stream._state;
+        DequeueValue(controller);
+        if (!WritableStreamCloseQueuedOrInFlight(stream) && state === 'writable') {
+            const backpressure = WritableStreamDefaultControllerGetBackpressure(controller);
+            WritableStreamUpdateBackpressure(stream, backpressure);
+        }
+        WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
+    }, reason => {
+        if (stream._state === 'writable') {
+            WritableStreamDefaultControllerClearAlgorithms(controller);
+        }
+        WritableStreamFinishInFlightWriteWithError(stream, reason);
+    });
+}
+function WritableStreamDefaultControllerGetBackpressure(controller) {
+    const desiredSize = WritableStreamDefaultControllerGetDesiredSize(controller);
+    return desiredSize <= 0;
+}
+// A client of WritableStreamDefaultController may use these functions directly to bypass state check.
+function WritableStreamDefaultControllerError(controller, error) {
+    const stream = controller._controlledWritableStream;
+    WritableStreamDefaultControllerClearAlgorithms(controller);
+    WritableStreamStartErroring(stream, error);
+}
+// Helper functions for the WritableStream.
+function streamBrandCheckException$2(name) {
+    return new TypeError(`WritableStream.prototype.${name} can only be used on a WritableStream`);
+}
+// Helper functions for the WritableStreamDefaultController.
+function defaultControllerBrandCheckException$2(name) {
+    return new TypeError(`WritableStreamDefaultController.prototype.${name} can only be used on a WritableStreamDefaultController`);
+}
+// Helper functions for the WritableStreamDefaultWriter.
+function defaultWriterBrandCheckException(name) {
+    return new TypeError(`WritableStreamDefaultWriter.prototype.${name} can only be used on a WritableStreamDefaultWriter`);
+}
+function defaultWriterLockException(name) {
+    return new TypeError('Cannot ' + name + ' a stream using a released writer');
+}
+function defaultWriterClosedPromiseInitialize(writer) {
+    writer._closedPromise = newPromise((resolve, reject) => {
+        writer._closedPromise_resolve = resolve;
+        writer._closedPromise_reject = reject;
+        writer._closedPromiseState = 'pending';
+    });
+}
+function defaultWriterClosedPromiseInitializeAsRejected(writer, reason) {
+    defaultWriterClosedPromiseInitialize(writer);
+    defaultWriterClosedPromiseReject(writer, reason);
+}
+function defaultWriterClosedPromiseInitializeAsResolved(writer) {
+    defaultWriterClosedPromiseInitialize(writer);
+    defaultWriterClosedPromiseResolve(writer);
+}
+function defaultWriterClosedPromiseReject(writer, reason) {
+    if (writer._closedPromise_reject === undefined) {
+        return;
+    }
+    setPromiseIsHandledToTrue(writer._closedPromise);
+    writer._closedPromise_reject(reason);
+    writer._closedPromise_resolve = undefined;
+    writer._closedPromise_reject = undefined;
+    writer._closedPromiseState = 'rejected';
+}
+function defaultWriterClosedPromiseResetToRejected(writer, reason) {
+    defaultWriterClosedPromiseInitializeAsRejected(writer, reason);
+}
+function defaultWriterClosedPromiseResolve(writer) {
+    if (writer._closedPromise_resolve === undefined) {
+        return;
+    }
+    writer._closedPromise_resolve(undefined);
+    writer._closedPromise_resolve = undefined;
+    writer._closedPromise_reject = undefined;
+    writer._closedPromiseState = 'resolved';
+}
+function defaultWriterReadyPromiseInitialize(writer) {
+    writer._readyPromise = newPromise((resolve, reject) => {
+        writer._readyPromise_resolve = resolve;
+        writer._readyPromise_reject = reject;
+    });
+    writer._readyPromiseState = 'pending';
+}
+function defaultWriterReadyPromiseInitializeAsRejected(writer, reason) {
+    defaultWriterReadyPromiseInitialize(writer);
+    defaultWriterReadyPromiseReject(writer, reason);
+}
+function defaultWriterReadyPromiseInitializeAsResolved(writer) {
+    defaultWriterReadyPromiseInitialize(writer);
+    defaultWriterReadyPromiseResolve(writer);
+}
+function defaultWriterReadyPromiseReject(writer, reason) {
+    if (writer._readyPromise_reject === undefined) {
+        return;
+    }
+    setPromiseIsHandledToTrue(writer._readyPromise);
+    writer._readyPromise_reject(reason);
+    writer._readyPromise_resolve = undefined;
+    writer._readyPromise_reject = undefined;
+    writer._readyPromiseState = 'rejected';
+}
+function defaultWriterReadyPromiseReset(writer) {
+    defaultWriterReadyPromiseInitialize(writer);
+}
+function defaultWriterReadyPromiseResetToRejected(writer, reason) {
+    defaultWriterReadyPromiseInitializeAsRejected(writer, reason);
+}
+function defaultWriterReadyPromiseResolve(writer) {
+    if (writer._readyPromise_resolve === undefined) {
+        return;
+    }
+    writer._readyPromise_resolve(undefined);
+    writer._readyPromise_resolve = undefined;
+    writer._readyPromise_reject = undefined;
+    writer._readyPromiseState = 'fulfilled';
+}
+// eslint-disable-next-line no-redeclarelet DOMException$1=DOMException
+
+function ReadableStreamPipeTo(source, dest, preventClose, preventAbort, preventCancel, signal) {
+    const reader = AcquireReadableStreamDefaultReader(source);
+    const writer = AcquireWritableStreamDefaultWriter(dest);
+    source._disturbed = true;
+    let shuttingDown = false;
+    // This is used to keep track of the spec's requirement that we wait for ongoing writes during shutdown.
+    let currentWrite = promiseResolvedWith(undefined);
+    return newPromise((resolve, reject) => {
+        let abortAlgorithm;
+        if (signal !== undefined) {
+            abortAlgorithm = () => {
+                const error =new DOMException('Aborted', 'AbortError');
+                const actions = [];
+                if (!preventAbort) {
+                    actions.push(() => {
+                        if (dest._state === 'writable') {
+                            return WritableStreamAbort(dest, error);
+                        }
+                        return promiseResolvedWith(undefined);
+                    });
+                }
+                if (!preventCancel) {
+                    actions.push(() => {
+                        if (source._state === 'readable') {
+                            return ReadableStreamCancel(source, error);
+                        }
+                        return promiseResolvedWith(undefined);
+                    });
+                }
+                shutdownWithAction(() => Promise.all(actions.map(action => action())), true, error);
+            };
+            if (signal.aborted) {
+                abortAlgorithm();
+                return;
+            }
+            signal.addEventListener('abort', abortAlgorithm);
+        }
+        // Using reader and writer, read all chunks from this and write them to dest
+        // - Backpressure must be enforced
+        // - Shutdown must stop all activity
+        function pipeLoop() {
+            return newPromise((resolveLoop, rejectLoop) => {
+                function next(done) {
+                    if (done) {
+                        resolveLoop();
+                    }
+                    else {
+                        // Use `PerformPromiseThen` instead of `uponPromise` to avoid
+                        // adding unnecessary `.catch(rethrowAssertionErrorRejection)` handlers
+                        PerformPromiseThen(pipeStep(), next, rejectLoop);
+                    }
+                }
+                next(false);
+            });
+        }
+        function pipeStep() {
+            if (shuttingDown) {
+                return promiseResolvedWith(true);
+            }
+            return PerformPromiseThen(writer._readyPromise, () => {
+                return newPromise((resolveRead, rejectRead) => {
+                    ReadableStreamDefaultReaderRead(reader, {
+                        _chunkSteps: chunk => {
+                            currentWrite = PerformPromiseThen(WritableStreamDefaultWriterWrite(writer, chunk), undefined, noop$1);
+                            resolveRead(false);
+                        },
+                        _closeSteps: () => resolveRead(true),
+                        _errorSteps: rejectRead
+                    });
+                });
+            });
+        }
+        // Errors must be propagated forward
+        isOrBecomesErrored(source, reader._closedPromise, storedError => {
+            if (!preventAbort) {
+                shutdownWithAction(() => WritableStreamAbort(dest, storedError), true, storedError);
+            }
+            else {
+                shutdown(true, storedError);
+            }
+        });
+        // Errors must be propagated backward
+        isOrBecomesErrored(dest, writer._closedPromise, storedError => {
+            if (!preventCancel) {
+                shutdownWithAction(() => ReadableStreamCancel(source, storedError), true, storedError);
+            }
+            else {
+                shutdown(true, storedError);
+            }
+        });
+        // Closing must be propagated forward
+        isOrBecomesClosed(source, reader._closedPromise, () => {
+            if (!preventClose) {
+                shutdownWithAction(() => WritableStreamDefaultWriterCloseWithErrorPropagation(writer));
+            }
+            else {
+                shutdown();
+            }
+        });
+        // Closing must be propagated backward
+        if (WritableStreamCloseQueuedOrInFlight(dest) || dest._state === 'closed') {
+            const destClosed = new TypeError('the destination writable stream closed before all data could be piped to it');
+            if (!preventCancel) {
+                shutdownWithAction(() => ReadableStreamCancel(source, destClosed), true, destClosed);
+            }
+            else {
+                shutdown(true, destClosed);
+            }
+        }
+        setPromiseIsHandledToTrue(pipeLoop());
+        function waitForWritesToFinish() {
+            // Another write may have started while we were waiting on this currentWrite, so we have to be sure to wait
+            // for that too.
+            const oldCurrentWrite = currentWrite;
+            return PerformPromiseThen(currentWrite, () => oldCurrentWrite !== currentWrite ? waitForWritesToFinish() : undefined);
+        }
+        function isOrBecomesErrored(stream, promise, action) {
+            if (stream._state === 'errored') {
+                action(stream._storedError);
+            }
+            else {
+                uponRejection(promise, action);
+            }
+        }
+        function isOrBecomesClosed(stream, promise, action) {
+            if (stream._state === 'closed') {
+                action();
+            }
+            else {
+                uponFulfillment(promise, action);
+            }
+        }
+        function shutdownWithAction(action, originalIsError, originalError) {
+            if (shuttingDown) {
+                return;
+            }
+            shuttingDown = true;
+            if (dest._state === 'writable' && !WritableStreamCloseQueuedOrInFlight(dest)) {
+                uponFulfillment(waitForWritesToFinish(), doTheRest);
+            }
+            else {
+                doTheRest();
+            }
+            function doTheRest() {
+                uponPromise(action(), () => finalize(originalIsError, originalError), newError => finalize(true, newError));
+            }
+        }
+        function shutdown(isError, error) {
+            if (shuttingDown) {
+                return;
+            }
+            shuttingDown = true;
+            if (dest._state === 'writable' && !WritableStreamCloseQueuedOrInFlight(dest)) {
+                uponFulfillment(waitForWritesToFinish(), () => finalize(isError, error));
+            }
+            else {
+                finalize(isError, error);
+            }
+        }
+        function finalize(isError, error) {
+            WritableStreamDefaultWriterRelease(writer);
+            ReadableStreamReaderGenericRelease(reader);
+            if (signal !== undefined) {
+                signal.removeEventListener('abort', abortAlgorithm);
+            }
+            if (isError) {
+                reject(error);
+            }
+            else {
+                resolve(undefined);
+            }
+        }
+    });
+}
+
+/**
+ * Allows control of a {@link ReadableStream | readable stream}'s state and internal queue.
+ *
+ * @public
+ */
+class ReadableStreamDefaultController {
+    constructor() {
+        throw new TypeError('Illegal constructor');
+    }
+    /**
+     * Returns the desired size to fill the controlled stream's internal queue. It can be negative, if the queue is
+     * over-full. An underlying source ought to use this information to determine when and how to apply backpressure.
+     */
+    get desiredSize() {
+        if (!IsReadableStreamDefaultController(this)) {
+            throw defaultControllerBrandCheckException$1('desiredSize');
+        }
+        return ReadableStreamDefaultControllerGetDesiredSize(this);
+    }
+    /**
+     * Closes the controlled readable stream. Consumers will still be able to read any previously-enqueued chunks from
+     * the stream, but once those are read, the stream will become closed.
+     */
+    close() {
+        if (!IsReadableStreamDefaultController(this)) {
+            throw defaultControllerBrandCheckException$1('close');
+        }
+        if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(this)) {
+            throw new TypeError('The stream is not in a state that permits close');
+        }
+        ReadableStreamDefaultControllerClose(this);
+    }
+    enqueue(chunk = undefined) {
+        if (!IsReadableStreamDefaultController(this)) {
+            throw defaultControllerBrandCheckException$1('enqueue');
+        }
+        if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(this)) {
+            throw new TypeError('The stream is not in a state that permits enqueue');
+        }
+        return ReadableStreamDefaultControllerEnqueue(this, chunk);
+    }
+    /**
+     * Errors the controlled readable stream, making all future interactions with it fail with the given error `e`.
+     */
+    error(e = undefined) {
+        if (!IsReadableStreamDefaultController(this)) {
+            throw defaultControllerBrandCheckException$1('error');
+        }
+        ReadableStreamDefaultControllerError(this, e);
+    }
+    /** @internal */
+    [CancelSteps](reason) {
+        ResetQueue(this);
+        const result = this._cancelAlgorithm(reason);
+        ReadableStreamDefaultControllerClearAlgorithms(this);
+        return result;
+    }
+    /** @internal */
+    [PullSteps](readRequest) {
+        const stream = this._controlledReadableStream;
+        if (this._queue.length > 0) {
+            const chunk = DequeueValue(this);
+            if (this._closeRequested && this._queue.length === 0) {
+                ReadableStreamDefaultControllerClearAlgorithms(this);
+                ReadableStreamClose(stream);
+            }
+            else {
+                ReadableStreamDefaultControllerCallPullIfNeeded(this);
+            }
+            readRequest._chunkSteps(chunk);
+        }
+        else {
+            ReadableStreamAddReadRequest(stream, readRequest);
+            ReadableStreamDefaultControllerCallPullIfNeeded(this);
+        }
+    }
+}
+Object.defineProperties(ReadableStreamDefaultController.prototype, {
+    close: { enumerable: true },
+    enqueue: { enumerable: true },
+    error: { enumerable: true },
+    desiredSize: { enumerable: true }
+});
+// Abstract operations for the ReadableStreamDefaultController.
+function IsReadableStreamDefaultController(x) {
+    if (!typeIsObject(x)) {
+        return false;
+    }
+    if (!Object.prototype.hasOwnProperty.call(x, '_controlledReadableStream')) {
+        return false;
+    }
+    return x instanceof ReadableStreamDefaultController;
+}
+function ReadableStreamDefaultControllerCallPullIfNeeded(controller) {
+    const shouldPull = ReadableStreamDefaultControllerShouldCallPull(controller);
+    if (!shouldPull) {
+        return;
+    }
+    if (controller._pulling) {
+        controller._pullAgain = true;
+        return;
+    }
+    controller._pulling = true;
+    const pullPromise = controller._pullAlgorithm();
+    uponPromise(pullPromise, () => {
+        controller._pulling = false;
+        if (controller._pullAgain) {
+            controller._pullAgain = false;
+            ReadableStreamDefaultControllerCallPullIfNeeded(controller);
+        }
+    }, e => {
+        ReadableStreamDefaultControllerError(controller, e);
+    });
+}
+function ReadableStreamDefaultControllerShouldCallPull(controller) {
+    const stream = controller._controlledReadableStream;
+    if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(controller)) {
+        return false;
+    }
+    if (!controller._started) {
+        return false;
+    }
+    if (IsReadableStreamLocked(stream) && ReadableStreamGetNumReadRequests(stream) > 0) {
+        return true;
+    }
+    const desiredSize = ReadableStreamDefaultControllerGetDesiredSize(controller);
+    if (desiredSize > 0) {
+        return true;
+    }
+    return false;
+}
+function ReadableStreamDefaultControllerClearAlgorithms(controller) {
+    controller._pullAlgorithm = undefined;
+    controller._cancelAlgorithm = undefined;
+    controller._strategySizeAlgorithm = undefined;
+}
+// A client of ReadableStreamDefaultController may use these functions directly to bypass state check.
+function ReadableStreamDefaultControllerClose(controller) {
+    if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(controller)) {
+        return;
+    }
+    const stream = controller._controlledReadableStream;
+    controller._closeRequested = true;
+    if (controller._queue.length === 0) {
+        ReadableStreamDefaultControllerClearAlgorithms(controller);
+        ReadableStreamClose(stream);
+    }
+}
+function ReadableStreamDefaultControllerEnqueue(controller, chunk) {
+    if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(controller)) {
+        return;
+    }
+    const stream = controller._controlledReadableStream;
+    if (IsReadableStreamLocked(stream) && ReadableStreamGetNumReadRequests(stream) > 0) {
+        ReadableStreamFulfillReadRequest(stream, chunk, false);
+    }
+    else {
+        let chunkSize;
+        try {
+            chunkSize = controller._strategySizeAlgorithm(chunk);
+        }
+        catch (chunkSizeE) {
+            ReadableStreamDefaultControllerError(controller, chunkSizeE);
+            throw chunkSizeE;
+        }
+        try {
+            EnqueueValueWithSize(controller, chunk, chunkSize);
+        }
+        catch (enqueueE) {
+            ReadableStreamDefaultControllerError(controller, enqueueE);
+            throw enqueueE;
+        }
+    }
+    ReadableStreamDefaultControllerCallPullIfNeeded(controller);
+}
+function ReadableStreamDefaultControllerError(controller, e) {
+    const stream = controller._controlledReadableStream;
+    if (stream._state !== 'readable') {
+        return;
+    }
+    ResetQueue(controller);
+    ReadableStreamDefaultControllerClearAlgorithms(controller);
+    ReadableStreamError(stream, e);
+}
+function ReadableStreamDefaultControllerGetDesiredSize(controller) {
+    const state = controller._controlledReadableStream._state;
+    if (state === 'errored') {
+        return null;
+    }
+    if (state === 'closed') {
+        return 0;
+    }
+    return controller._strategyHWM - controller._queueTotalSize;
+}
+// This is used in the implementation of TransformStream.
+function ReadableStreamDefaultControllerHasBackpressure(controller) {
+    if (ReadableStreamDefaultControllerShouldCallPull(controller)) {
+        return false;
+    }
+    return true;
+}
+function ReadableStreamDefaultControllerCanCloseOrEnqueue(controller) {
+    const state = controller._controlledReadableStream._state;
+    if (!controller._closeRequested && state === 'readable') {
+        return true;
+    }
+    return false;
+}
+function SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm) {
+    controller._controlledReadableStream = stream;
+    controller._queue = undefined;
+    controller._queueTotalSize = undefined;
+    ResetQueue(controller);
+    controller._started = false;
+    controller._closeRequested = false;
+    controller._pullAgain = false;
+    controller._pulling = false;
+    controller._strategySizeAlgorithm = sizeAlgorithm;
+    controller._strategyHWM = highWaterMark;
+    controller._pullAlgorithm = pullAlgorithm;
+    controller._cancelAlgorithm = cancelAlgorithm;
+    stream._readableStreamController = controller;
+    const startResult = startAlgorithm();
+    uponPromise(promiseResolvedWith(startResult), () => {
+        controller._started = true;
+        ReadableStreamDefaultControllerCallPullIfNeeded(controller);
+    }, r => {
+        ReadableStreamDefaultControllerError(controller, r);
+    });
+}
+function SetUpReadableStreamDefaultControllerFromUnderlyingSource(stream, underlyingSource, highWaterMark, sizeAlgorithm) {
+    const controller = Object.create(ReadableStreamDefaultController.prototype);
+    let startAlgorithm = () => undefined;
+    let pullAlgorithm = () => promiseResolvedWith(undefined);
+    let cancelAlgorithm = () => promiseResolvedWith(undefined);
+    if (underlyingSource.start !== undefined) {
+        startAlgorithm = () => underlyingSource.start(controller);
+    }
+    if (underlyingSource.pull !== undefined) {
+        pullAlgorithm = () => underlyingSource.pull(controller);
+    }
+    if (underlyingSource.cancel !== undefined) {
+        cancelAlgorithm = reason => underlyingSource.cancel(reason);
+    }
+    SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm);
+}
+// Helper functions for the ReadableStreamDefaultController.
+function defaultControllerBrandCheckException$1(name) {
+    return new TypeError(`ReadableStreamDefaultController.prototype.${name} can only be used on a ReadableStreamDefaultController`);
+}
+
+function ReadableStreamTee(stream, cloneForBranch2) {
+    if (IsReadableByteStreamController(stream._readableStreamController)) {
+        return ReadableByteStreamTee(stream);
+    }
+    return ReadableStreamDefaultTee(stream);
+}
+function ReadableStreamDefaultTee(stream, cloneForBranch2) {
+    const reader = AcquireReadableStreamDefaultReader(stream);
+    let reading = false;
+    let readAgain = false;
+    let canceled1 = false;
+    let canceled2 = false;
+    let reason1;
+    let reason2;
+    let branch1;
+    let branch2;
+    let resolveCancelPromise;
+    const cancelPromise = newPromise(resolve => {
+        resolveCancelPromise = resolve;
+    });
+    function pullAlgorithm() {
+        if (reading) {
+            readAgain = true;
+            return promiseResolvedWith(undefined);
+        }
+        reading = true;
+        const readRequest = {
+            _chunkSteps: chunk => {
+                // This needs to be delayed a microtask because it takes at least a microtask to detect errors (using
+                // reader._closedPromise below), and we want errors in stream to error both branches immediately. We cannot let
+                // successful synchronously-available reads get ahead of asynchronously-available errors.
+                queueMicrotask(() => {
+                    readAgain = false;
+                    const chunk1 = chunk;
+                    const chunk2 = chunk;
+                    // There is no way to access the cloning code right now in the reference implementation.
+                    // If we add one then we'll need an implementation for serializable objects.
+                    // if (!canceled2 && cloneForBranch2) {
+                    //   chunk2 = StructuredDeserialize(StructuredSerialize(chunk2));
+                    // }
+                    if (!canceled1) {
+                        ReadableStreamDefaultControllerEnqueue(branch1._readableStreamController, chunk1);
+                    }
+                    if (!canceled2) {
+                        ReadableStreamDefaultControllerEnqueue(branch2._readableStreamController, chunk2);
+                    }
+                    reading = false;
+                    if (readAgain) {
+                        pullAlgorithm();
+                    }
+                });
+            },
+            _closeSteps: () => {
+                reading = false;
+                if (!canceled1) {
+                    ReadableStreamDefaultControllerClose(branch1._readableStreamController);
+                }
+                if (!canceled2) {
+                    ReadableStreamDefaultControllerClose(branch2._readableStreamController);
+                }
+                if (!canceled1 || !canceled2) {
+                    resolveCancelPromise(undefined);
+                }
+            },
+            _errorSteps: () => {
+                reading = false;
+            }
+        };
+        ReadableStreamDefaultReaderRead(reader, readRequest);
+        return promiseResolvedWith(undefined);
+    }
+    function cancel1Algorithm(reason) {
+        canceled1 = true;
+        reason1 = reason;
+        if (canceled2) {
+            const compositeReason = CreateArrayFromList([reason1, reason2]);
+            const cancelResult = ReadableStreamCancel(stream, compositeReason);
+            resolveCancelPromise(cancelResult);
+        }
+        return cancelPromise;
+    }
+    function cancel2Algorithm(reason) {
+        canceled2 = true;
+        reason2 = reason;
+        if (canceled1) {
+            const compositeReason = CreateArrayFromList([reason1, reason2]);
+            const cancelResult = ReadableStreamCancel(stream, compositeReason);
+            resolveCancelPromise(cancelResult);
+        }
+        return cancelPromise;
+    }
+    function startAlgorithm() {
+        // do nothing
+    }
+    branch1 = CreateReadableStream(startAlgorithm, pullAlgorithm, cancel1Algorithm);
+    branch2 = CreateReadableStream(startAlgorithm, pullAlgorithm, cancel2Algorithm);
+    uponRejection(reader._closedPromise, (r) => {
+        ReadableStreamDefaultControllerError(branch1._readableStreamController, r);
+        ReadableStreamDefaultControllerError(branch2._readableStreamController, r);
+        if (!canceled1 || !canceled2) {
+            resolveCancelPromise(undefined);
+        }
+    });
+    return [branch1, branch2];
+}
+function ReadableByteStreamTee(stream) {
+    let reader = AcquireReadableStreamDefaultReader(stream);
+    let reading = false;
+    let readAgainForBranch1 = false;
+    let readAgainForBranch2 = false;
+    let canceled1 = false;
+    let canceled2 = false;
+    let reason1;
+    let reason2;
+    let branch1;
+    let branch2;
+    let resolveCancelPromise;
+    const cancelPromise = newPromise(resolve => {
+        resolveCancelPromise = resolve;
+    });
+    function forwardReaderError(thisReader) {
+        uponRejection(thisReader._closedPromise, r => {
+            if (thisReader !== reader) {
+                return;
+            }
+            ReadableByteStreamControllerError(branch1._readableStreamController, r);
+            ReadableByteStreamControllerError(branch2._readableStreamController, r);
+            if (!canceled1 || !canceled2) {
+                resolveCancelPromise(undefined);
+            }
+        });
+    }
+    function pullWithDefaultReader() {
+        if (IsReadableStreamBYOBReader(reader)) {
+            ReadableStreamReaderGenericRelease(reader);
+            reader = AcquireReadableStreamDefaultReader(stream);
+            forwardReaderError(reader);
+        }
+        const readRequest = {
+            _chunkSteps: chunk => {
+                // This needs to be delayed a microtask because it takes at least a microtask to detect errors (using
+                // reader._closedPromise below), and we want errors in stream to error both branches immediately. We cannot let
+                // successful synchronously-available reads get ahead of asynchronously-available errors.
+                queueMicrotask(() => {
+                    readAgainForBranch1 = false;
+                    readAgainForBranch2 = false;
+                    const chunk1 = chunk;
+                    let chunk2 = chunk;
+                    if (!canceled1 && !canceled2) {
+                        try {
+                            chunk2 = CloneAsUint8Array(chunk);
+                        }
+                        catch (cloneE) {
+                            ReadableByteStreamControllerError(branch1._readableStreamController, cloneE);
+                            ReadableByteStreamControllerError(branch2._readableStreamController, cloneE);
+                            resolveCancelPromise(ReadableStreamCancel(stream, cloneE));
+                            return;
+                        }
+                    }
+                    if (!canceled1) {
+                        ReadableByteStreamControllerEnqueue(branch1._readableStreamController, chunk1);
+                    }
+                    if (!canceled2) {
+                        ReadableByteStreamControllerEnqueue(branch2._readableStreamController, chunk2);
+                    }
+                    reading = false;
+                    if (readAgainForBranch1) {
+                        pull1Algorithm();
+                    }
+                    else if (readAgainForBranch2) {
+                        pull2Algorithm();
+                    }
+                });
+            },
+            _closeSteps: () => {
+                reading = false;
+                if (!canceled1) {
+                    ReadableByteStreamControllerClose(branch1._readableStreamController);
+                }
+                if (!canceled2) {
+                    ReadableByteStreamControllerClose(branch2._readableStreamController);
+                }
+                if (branch1._readableStreamController._pendingPullIntos.length > 0) {
+                    ReadableByteStreamControllerRespond(branch1._readableStreamController, 0);
+                }
+                if (branch2._readableStreamController._pendingPullIntos.length > 0) {
+                    ReadableByteStreamControllerRespond(branch2._readableStreamController, 0);
+                }
+                if (!canceled1 || !canceled2) {
+                    resolveCancelPromise(undefined);
+                }
+            },
+            _errorSteps: () => {
+                reading = false;
+            }
+        };
+        ReadableStreamDefaultReaderRead(reader, readRequest);
+    }
+    function pullWithBYOBReader(view, forBranch2) {
+        if (IsReadableStreamDefaultReader(reader)) {
+            ReadableStreamReaderGenericRelease(reader);
+            reader = AcquireReadableStreamBYOBReader(stream);
+            forwardReaderError(reader);
+        }
+        const byobBranch = forBranch2 ? branch2 : branch1;
+        const otherBranch = forBranch2 ? branch1 : branch2;
+        const readIntoRequest = {
+            _chunkSteps: chunk => {
+                // This needs to be delayed a microtask because it takes at least a microtask to detect errors (using
+                // reader._closedPromise below), and we want errors in stream to error both branches immediately. We cannot let
+                // successful synchronously-available reads get ahead of asynchronously-available errors.
+                queueMicrotask(() => {
+                    readAgainForBranch1 = false;
+                    readAgainForBranch2 = false;
+                    const byobCanceled = forBranch2 ? canceled2 : canceled1;
+                    const otherCanceled = forBranch2 ? canceled1 : canceled2;
+                    if (!otherCanceled) {
+                        let clonedChunk;
+                        try {
+                            clonedChunk = CloneAsUint8Array(chunk);
+                        }
+                        catch (cloneE) {
+                            ReadableByteStreamControllerError(byobBranch._readableStreamController, cloneE);
+                            ReadableByteStreamControllerError(otherBranch._readableStreamController, cloneE);
+                            resolveCancelPromise(ReadableStreamCancel(stream, cloneE));
+                            return;
+                        }
+                        if (!byobCanceled) {
+                            ReadableByteStreamControllerRespondWithNewView(byobBranch._readableStreamController, chunk);
+                        }
+                        ReadableByteStreamControllerEnqueue(otherBranch._readableStreamController, clonedChunk);
+                    }
+                    else if (!byobCanceled) {
+                        ReadableByteStreamControllerRespondWithNewView(byobBranch._readableStreamController, chunk);
+                    }
+                    reading = false;
+                    if (readAgainForBranch1) {
+                        pull1Algorithm();
+                    }
+                    else if (readAgainForBranch2) {
+                        pull2Algorithm();
+                    }
+                });
+            },
+            _closeSteps: chunk => {
+                reading = false;
+                const byobCanceled = forBranch2 ? canceled2 : canceled1;
+                const otherCanceled = forBranch2 ? canceled1 : canceled2;
+                if (!byobCanceled) {
+                    ReadableByteStreamControllerClose(byobBranch._readableStreamController);
+                }
+                if (!otherCanceled) {
+                    ReadableByteStreamControllerClose(otherBranch._readableStreamController);
+                }
+                if (chunk !== undefined) {
+                    if (!byobCanceled) {
+                        ReadableByteStreamControllerRespondWithNewView(byobBranch._readableStreamController, chunk);
+                    }
+                    if (!otherCanceled && otherBranch._readableStreamController._pendingPullIntos.length > 0) {
+                        ReadableByteStreamControllerRespond(otherBranch._readableStreamController, 0);
+                    }
+                }
+                if (!byobCanceled || !otherCanceled) {
+                    resolveCancelPromise(undefined);
+                }
+            },
+            _errorSteps: () => {
+                reading = false;
+            }
+        };
+        ReadableStreamBYOBReaderRead(reader, view, readIntoRequest);
+    }
+    function pull1Algorithm() {
+        if (reading) {
+            readAgainForBranch1 = true;
+            return promiseResolvedWith(undefined);
+        }
+        reading = true;
+        const byobRequest = ReadableByteStreamControllerGetBYOBRequest(branch1._readableStreamController);
+        if (byobRequest === null) {
+            pullWithDefaultReader();
+        }
+        else {
+            pullWithBYOBReader(byobRequest._view, false);
+        }
+        return promiseResolvedWith(undefined);
+    }
+    function pull2Algorithm() {
+        if (reading) {
+            readAgainForBranch2 = true;
+            return promiseResolvedWith(undefined);
+        }
+        reading = true;
+        const byobRequest = ReadableByteStreamControllerGetBYOBRequest(branch2._readableStreamController);
+        if (byobRequest === null) {
+            pullWithDefaultReader();
+        }
+        else {
+            pullWithBYOBReader(byobRequest._view, true);
+        }
+        return promiseResolvedWith(undefined);
+    }
+    function cancel1Algorithm(reason) {
+        canceled1 = true;
+        reason1 = reason;
+        if (canceled2) {
+            const compositeReason = CreateArrayFromList([reason1, reason2]);
+            const cancelResult = ReadableStreamCancel(stream, compositeReason);
+            resolveCancelPromise(cancelResult);
+        }
+        return cancelPromise;
+    }
+    function cancel2Algorithm(reason) {
+        canceled2 = true;
+        reason2 = reason;
+        if (canceled1) {
+            const compositeReason = CreateArrayFromList([reason1, reason2]);
+            const cancelResult = ReadableStreamCancel(stream, compositeReason);
+            resolveCancelPromise(cancelResult);
+        }
+        return cancelPromise;
+    }
+    function startAlgorithm() {
+        return;
+    }
+    branch1 = CreateReadableByteStream(startAlgorithm, pull1Algorithm, cancel1Algorithm);
+    branch2 = CreateReadableByteStream(startAlgorithm, pull2Algorithm, cancel2Algorithm);
+    forwardReaderError(reader);
+    return [branch1, branch2];
+}
+
+function convertUnderlyingDefaultOrByteSource(source, context) {
+    assertDictionary(source, context);
+    const original = source;
+    const autoAllocateChunkSize = original === null || original === void 0 ? void 0 : original.autoAllocateChunkSize;
+    const cancel = original === null || original === void 0 ? void 0 : original.cancel;
+    const pull = original === null || original === void 0 ? void 0 : original.pull;
+    const start = original === null || original === void 0 ? void 0 : original.start;
+    const type = original === null || original === void 0 ? void 0 : original.type;
+    return {
+        autoAllocateChunkSize: autoAllocateChunkSize === undefined ?
+            undefined :
+            convertUnsignedLongLongWithEnforceRange(autoAllocateChunkSize, `${context} has member 'autoAllocateChunkSize' that`),
+        cancel: cancel === undefined ?
+            undefined :
+            convertUnderlyingSourceCancelCallback(cancel, original, `${context} has member 'cancel' that`),
+        pull: pull === undefined ?
+            undefined :
+            convertUnderlyingSourcePullCallback(pull, original, `${context} has member 'pull' that`),
+        start: start === undefined ?
+            undefined :
+            convertUnderlyingSourceStartCallback(start, original, `${context} has member 'start' that`),
+        type: type === undefined ? undefined : convertReadableStreamType(type, `${context} has member 'type' that`)
+    };
+}
+function convertUnderlyingSourceCancelCallback(fn, original, context) {
+    assertFunction(fn, context);
+    return (reason) => promiseCall(fn, original, [reason]);
+}
+function convertUnderlyingSourcePullCallback(fn, original, context) {
+    assertFunction(fn, context);
+    return (controller) => promiseCall(fn, original, [controller]);
+}
+function convertUnderlyingSourceStartCallback(fn, original, context) {
+    assertFunction(fn, context);
+    return (controller) => reflectCall(fn, original, [controller]);
+}
+function convertReadableStreamType(type, context) {
+    type = `${type}`;
+    if (type !== 'bytes') {
+        throw new TypeError(`${context} '${type}' is not a valid enumeration value for ReadableStreamType`);
+    }
+    return type;
+}
+
+function convertReaderOptions(options, context) {
+    assertDictionary(options, context);
+    const mode = options === null || options === void 0 ? void 0 : options.mode;
+    return {
+        mode: mode === undefined ? undefined : convertReadableStreamReaderMode(mode, `${context} has member 'mode' that`)
+    };
+}
+function convertReadableStreamReaderMode(mode, context) {
+    mode = `${mode}`;
+    if (mode !== 'byob') {
+        throw new TypeError(`${context} '${mode}' is not a valid enumeration value for ReadableStreamReaderMode`);
+    }
+    return mode;
+}
+
+function convertIteratorOptions(options, context) {
+    assertDictionary(options, context);
+    const preventCancel = options === null || options === void 0 ? void 0 : options.preventCancel;
+    return { preventCancel: Boolean(preventCancel) };
+}
+
+function convertPipeOptions(options, context) {
+    assertDictionary(options, context);
+    const preventAbort = options === null || options === void 0 ? void 0 : options.preventAbort;
+    const preventCancel = options === null || options === void 0 ? void 0 : options.preventCancel;
+    const preventClose = options === null || options === void 0 ? void 0 : options.preventClose;
+    const signal = options === null || options === void 0 ? void 0 : options.signal;
+    if (signal !== undefined) {
+        assertAbortSignal(signal, `${context} has member 'signal' that`);
+    }
+    return {
+        preventAbort: Boolean(preventAbort),
+        preventCancel: Boolean(preventCancel),
+        preventClose: Boolean(preventClose),
+        signal
+    };
+}
+function assertAbortSignal(signal, context) {
+    if (!isAbortSignal$1(signal)) {
+        throw new TypeError(`${context} is not an AbortSignal.`);
+    }
+}
+
+function convertReadableWritablePair(pair, context) {
+    assertDictionary(pair, context);
+    const readable = pair === null || pair === void 0 ? void 0 : pair.readable;
+    assertRequiredField(readable, 'readable', 'ReadableWritablePair');
+    assertReadableStream(readable, `${context} has member 'readable' that`);
+    const writable = pair === null || pair === void 0 ? void 0 : pair.writable;
+    assertRequiredField(writable, 'writable', 'ReadableWritablePair');
+    assertWritableStream(writable, `${context} has member 'writable' that`);
+    return { readable, writable };
+}
+
+/**
+ * A readable stream represents a source of data, from which you can read.
+ *
+ * @public
+ */
+class ReadableStream {
+    constructor(rawUnderlyingSource = {}, rawStrategy = {}) {
+        if (rawUnderlyingSource === undefined) {
+            rawUnderlyingSource = null;
+        }
+        else {
+            assertObject(rawUnderlyingSource, 'First parameter');
+        }
+        const strategy = convertQueuingStrategy(rawStrategy, 'Second parameter');
+        const underlyingSource = convertUnderlyingDefaultOrByteSource(rawUnderlyingSource, 'First parameter');
+        InitializeReadableStream(this);
+        if (underlyingSource.type === 'bytes') {
+            if (strategy.size !== undefined) {
+                throw new RangeError('The strategy for a byte stream cannot have a size function');
+            }
+            const highWaterMark = ExtractHighWaterMark(strategy, 0);
+            SetUpReadableByteStreamControllerFromUnderlyingSource(this, underlyingSource, highWaterMark);
+        }
+        else {
+            const sizeAlgorithm = ExtractSizeAlgorithm(strategy);
+            const highWaterMark = ExtractHighWaterMark(strategy, 1);
+            SetUpReadableStreamDefaultControllerFromUnderlyingSource(this, underlyingSource, highWaterMark, sizeAlgorithm);
+        }
+    }
+    /**
+     * Whether or not the readable stream is locked to a {@link ReadableStreamDefaultReader | reader}.
+     */
+    get locked() {
+        if (!IsReadableStream(this)) {
+            throw streamBrandCheckException$1('locked');
+        }
+        return IsReadableStreamLocked(this);
+    }
+    /**
+     * Cancels the stream, signaling a loss of interest in the stream by a consumer.
+     *
+     * The supplied `reason` argument will be given to the underlying source's {@link UnderlyingSource.cancel | cancel()}
+     * method, which might or might not use it.
+     */
+    cancel(reason = undefined) {
+        if (!IsReadableStream(this)) {
+            return promiseRejectedWith(streamBrandCheckException$1('cancel'));
+        }
+        if (IsReadableStreamLocked(this)) {
+            return promiseRejectedWith(new TypeError('Cannot cancel a stream that already has a reader'));
+        }
+        return ReadableStreamCancel(this, reason);
+    }
+    getReader(rawOptions = undefined) {
+        if (!IsReadableStream(this)) {
+            throw streamBrandCheckException$1('getReader');
+        }
+        const options = convertReaderOptions(rawOptions, 'First parameter');
+        if (options.mode === undefined) {
+            return AcquireReadableStreamDefaultReader(this);
+        }
+        return AcquireReadableStreamBYOBReader(this);
+    }
+    pipeThrough(rawTransform, rawOptions = {}) {
+        if (!IsReadableStream(this)) {
+            throw streamBrandCheckException$1('pipeThrough');
+        }
+        assertRequiredArgument(rawTransform, 1, 'pipeThrough');
+        const transform = convertReadableWritablePair(rawTransform, 'First parameter');
+        const options = convertPipeOptions(rawOptions, 'Second parameter');
+        if (IsReadableStreamLocked(this)) {
+            throw new TypeError('ReadableStream.prototype.pipeThrough cannot be used on a locked ReadableStream');
+        }
+        if (IsWritableStreamLocked(transform.writable)) {
+            throw new TypeError('ReadableStream.prototype.pipeThrough cannot be used on a locked WritableStream');
+        }
+        const promise = ReadableStreamPipeTo(this, transform.writable, options.preventClose, options.preventAbort, options.preventCancel, options.signal);
+        setPromiseIsHandledToTrue(promise);
+        return transform.readable;
+    }
+    pipeTo(destination, rawOptions = {}) {
+        if (!IsReadableStream(this)) {
+            return promiseRejectedWith(streamBrandCheckException$1('pipeTo'));
+        }
+        if (destination === undefined) {
+            return promiseRejectedWith(`Parameter 1 is required in 'pipeTo'.`);
+        }
+        if (!IsWritableStream(destination)) {
+            return promiseRejectedWith(new TypeError(`ReadableStream.prototype.pipeTo's first argument must be a WritableStream`));
+        }
+        let options;
+        try {
+            options = convertPipeOptions(rawOptions, 'Second parameter');
+        }
+        catch (e) {
+            return promiseRejectedWith(e);
+        }
+        if (IsReadableStreamLocked(this)) {
+            return promiseRejectedWith(new TypeError('ReadableStream.prototype.pipeTo cannot be used on a locked ReadableStream'));
+        }
+        if (IsWritableStreamLocked(destination)) {
+            return promiseRejectedWith(new TypeError('ReadableStream.prototype.pipeTo cannot be used on a locked WritableStream'));
+        }
+        return ReadableStreamPipeTo(this, destination, options.preventClose, options.preventAbort, options.preventCancel, options.signal);
+    }
+    /**
+     * Tees this readable stream, returning a two-element array containing the two resulting branches as
+     * new {@link ReadableStream} instances.
+     *
+     * Teeing a stream will lock it, preventing any other consumer from acquiring a reader.
+     * To cancel the stream, cancel both of the resulting branches; a composite cancellation reason will then be
+     * propagated to the stream's underlying source.
+     *
+     * Note that the chunks seen in each branch will be the same object. If the chunks are not immutable,
+     * this could allow interference between the two branches.
+     */
+    tee() {
+        if (!IsReadableStream(this)) {
+            throw streamBrandCheckException$1('tee');
+        }
+        const branches = ReadableStreamTee(this);
+        return CreateArrayFromList(branches);
+    }
+    values(rawOptions = undefined) {
+        if (!IsReadableStream(this)) {
+            throw streamBrandCheckException$1('values');
+        }
+        const options = convertIteratorOptions(rawOptions, 'First parameter');
+        return AcquireReadableStreamAsyncIterator(this, options.preventCancel);
+    }
+}
+Object.defineProperties(ReadableStream.prototype, {
+    cancel: { enumerable: true },
+    getReader: { enumerable: true },
+    pipeThrough: { enumerable: true },
+    pipeTo: { enumerable: true },
+    tee: { enumerable: true },
+    values: { enumerable: true },
+    locked: { enumerable: true }
+});
+// Abstract operations for the ReadableStream.
+// Throws if and only if startAlgorithm throws.
+function CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark = 1, sizeAlgorithm = () => 1) {
+    const stream = Object.create(ReadableStream.prototype);
+    InitializeReadableStream(stream);
+    const controller = Object.create(ReadableStreamDefaultController.prototype);
+    SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm);
+    return stream;
+}
+// Throws if and only if startAlgorithm throws.
+function CreateReadableByteStream(startAlgorithm, pullAlgorithm, cancelAlgorithm) {
+    const stream = Object.create(ReadableStream.prototype);
+    InitializeReadableStream(stream);
+    const controller = Object.create(ReadableByteStreamController.prototype);
+    SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, 0, undefined);
+    return stream;
+}
+function InitializeReadableStream(stream) {
+    stream._state = 'readable';
+    stream._reader = undefined;
+    stream._storedError = undefined;
+    stream._disturbed = false;
+}
+function IsReadableStream(x) {
+    if (!typeIsObject(x)) {
+        return false;
+    }
+    if (!Object.prototype.hasOwnProperty.call(x, '_readableStreamController')) {
+        return false;
+    }
+    return x instanceof ReadableStream;
+}
+function IsReadableStreamLocked(stream) {
+    if (stream._reader === undefined) {
+        return false;
+    }
+    return true;
+}
+// ReadableStream API exposed for controllers.
+function ReadableStreamCancel(stream, reason) {
+    stream._disturbed = true;
+    if (stream._state === 'closed') {
+        return promiseResolvedWith(undefined);
+    }
+    if (stream._state === 'errored') {
+        return promiseRejectedWith(stream._storedError);
+    }
+    ReadableStreamClose(stream);
+    const reader = stream._reader;
+    if (reader !== undefined && IsReadableStreamBYOBReader(reader)) {
+        reader._readIntoRequests.forEach(readIntoRequest => {
+            readIntoRequest._closeSteps(undefined);
+        });
+        reader._readIntoRequests = new SimpleQueue();
+    }
+    const sourceCancelPromise = stream._readableStreamController[CancelSteps](reason);
+    return transformPromiseWith(sourceCancelPromise, noop$1);
+}
+function ReadableStreamClose(stream) {
+    stream._state = 'closed';
+    const reader = stream._reader;
+    if (reader === undefined) {
+        return;
+    }
+    defaultReaderClosedPromiseResolve(reader);
+    if (IsReadableStreamDefaultReader(reader)) {
+        reader._readRequests.forEach(readRequest => {
+            readRequest._closeSteps();
+        });
+        reader._readRequests = new SimpleQueue();
+    }
+}
+function ReadableStreamError(stream, e) {
+    stream._state = 'errored';
+    stream._storedError = e;
+    const reader = stream._reader;
+    if (reader === undefined) {
+        return;
+    }
+    defaultReaderClosedPromiseReject(reader, e);
+    if (IsReadableStreamDefaultReader(reader)) {
+        reader._readRequests.forEach(readRequest => {
+            readRequest._errorSteps(e);
+        });
+        reader._readRequests = new SimpleQueue();
+    }
+    else {
+        reader._readIntoRequests.forEach(readIntoRequest => {
+            readIntoRequest._errorSteps(e);
+        });
+        reader._readIntoRequests = new SimpleQueue();
+    }
+}
+// Helper functions for the ReadableStream.
+function streamBrandCheckException$1(name) {
+    return new TypeError(`ReadableStream.prototype.${name} can only be used on a ReadableStream`);
+}
+
+function convertQueuingStrategyInit(init, context) {
+    assertDictionary(init, context);
+    const highWaterMark = init === null || init === void 0 ? void 0 : init.highWaterMark;
+    assertRequiredField(highWaterMark, 'highWaterMark', 'QueuingStrategyInit');
+    return {
+        highWaterMark: convertUnrestrictedDouble(highWaterMark)
+    };
+}
+
+// The size function must not have a prototype property nor be a constructor
+const byteLengthSizeFunction = (chunk) => {
+    return chunk.byteLength;
+};
+Object.defineProperty(byteLengthSizeFunction, 'name', {
+    value: 'size',
+    configurable: true
+});
+/**
+ * A queuing strategy that counts the number of bytes in each chunk.
+ *
+ * @public
+ */
+class ByteLengthQueuingStrategy {
+    constructor(options) {
+        assertRequiredArgument(options, 1, 'ByteLengthQueuingStrategy');
+        options = convertQueuingStrategyInit(options, 'First parameter');
+        this._byteLengthQueuingStrategyHighWaterMark = options.highWaterMark;
+    }
+    /**
+     * Returns the high water mark provided to the constructor.
+     */
+    get highWaterMark() {
+        if (!IsByteLengthQueuingStrategy(this)) {
+            throw byteLengthBrandCheckException('highWaterMark');
+        }
+        return this._byteLengthQueuingStrategyHighWaterMark;
+    }
+    /**
+     * Measures the size of `chunk` by returning the value of its `byteLength` property.
+     */
+    get size() {
+        if (!IsByteLengthQueuingStrategy(this)) {
+            throw byteLengthBrandCheckException('size');
+        }
+        return byteLengthSizeFunction;
+    }
+}
+Object.defineProperties(ByteLengthQueuingStrategy.prototype, {
+    highWaterMark: { enumerable: true },
+    size: { enumerable: true }
+});
+// Helper functions for the ByteLengthQueuingStrategy.
+function byteLengthBrandCheckException(name) {
+    return new TypeError(`ByteLengthQueuingStrategy.prototype.${name} can only be used on a ByteLengthQueuingStrategy`);
+}
+function IsByteLengthQueuingStrategy(x) {
+    if (!typeIsObject(x)) {
+        return false;
+    }
+    if (!Object.prototype.hasOwnProperty.call(x, '_byteLengthQueuingStrategyHighWaterMark')) {
+        return false;
+    }
+    return x instanceof ByteLengthQueuingStrategy;
+}
+
+// The size function must not have a prototype property nor be a constructor
+const countSizeFunction = () => {
+    return 1;
+};
+Object.defineProperty(countSizeFunction, 'name', {
+    value: 'size',
+    configurable: true
+});
+/**
+ * A queuing strategy that counts the number of chunks.
+ *
+ * @public
+ */
+class CountQueuingStrategy {
+    constructor(options) {
+        assertRequiredArgument(options, 1, 'CountQueuingStrategy');
+        options = convertQueuingStrategyInit(options, 'First parameter');
+        this._countQueuingStrategyHighWaterMark = options.highWaterMark;
+    }
+    /**
+     * Returns the high water mark provided to the constructor.
+     */
+    get highWaterMark() {
+        if (!IsCountQueuingStrategy(this)) {
+            throw countBrandCheckException('highWaterMark');
+        }
+        return this._countQueuingStrategyHighWaterMark;
+    }
+    /**
+     * Measures the size of `chunk` by always returning 1.
+     * This ensures that the total queue size is a count of the number of chunks in the queue.
+     */
+    get size() {
+        if (!IsCountQueuingStrategy(this)) {
+            throw countBrandCheckException('size');
+        }
+        return countSizeFunction;
+    }
+}
+Object.defineProperties(CountQueuingStrategy.prototype, {
+    highWaterMark: { enumerable: true },
+    size: { enumerable: true }
+});
+// Helper functions for the CountQueuingStrategy.
+function countBrandCheckException(name) {
+    return new TypeError(`CountQueuingStrategy.prototype.${name} can only be used on a CountQueuingStrategy`);
+}
+function IsCountQueuingStrategy(x) {
+    if (!typeIsObject(x)) {
+        return false;
+    }
+    if (!Object.prototype.hasOwnProperty.call(x, '_countQueuingStrategyHighWaterMark')) {
+        return false;
+    }
+    return x instanceof CountQueuingStrategy;
+}
+
+function convertTransformer(original, context) {
+    assertDictionary(original, context);
+    const flush = original === null || original === void 0 ? void 0 : original.flush;
+    const readableType = original === null || original === void 0 ? void 0 : original.readableType;
+    const start = original === null || original === void 0 ? void 0 : original.start;
+    const transform = original === null || original === void 0 ? void 0 : original.transform;
+    const writableType = original === null || original === void 0 ? void 0 : original.writableType;
+    return {
+        flush: flush === undefined ?
+            undefined :
+            convertTransformerFlushCallback(flush, original, `${context} has member 'flush' that`),
+        readableType,
+        start: start === undefined ?
+            undefined :
+            convertTransformerStartCallback(start, original, `${context} has member 'start' that`),
+        transform: transform === undefined ?
+            undefined :
+            convertTransformerTransformCallback(transform, original, `${context} has member 'transform' that`),
+        writableType
+    };
+}
+function convertTransformerFlushCallback(fn, original, context) {
+    assertFunction(fn, context);
+    return (controller) => promiseCall(fn, original, [controller]);
+}
+function convertTransformerStartCallback(fn, original, context) {
+    assertFunction(fn, context);
+    return (controller) => reflectCall(fn, original, [controller]);
+}
+function convertTransformerTransformCallback(fn, original, context) {
+    assertFunction(fn, context);
+    return (chunk, controller) => promiseCall(fn, original, [chunk, controller]);
+}
+
+// Class TransformStream
+/**
+ * A transform stream consists of a pair of streams: a {@link WritableStream | writable stream},
+ * known as its writable side, and a {@link ReadableStream | readable stream}, known as its readable side.
+ * In a manner specific to the transform stream in question, writes to the writable side result in new data being
+ * made available for reading from the readable side.
+ *
+ * @public
+ */
+class TransformStream {
+    constructor(rawTransformer = {}, rawWritableStrategy = {}, rawReadableStrategy = {}) {
+        if (rawTransformer === undefined) {
+            rawTransformer = null;
+        }
+        const writableStrategy = convertQueuingStrategy(rawWritableStrategy, 'Second parameter');
+        const readableStrategy = convertQueuingStrategy(rawReadableStrategy, 'Third parameter');
+        const transformer = convertTransformer(rawTransformer, 'First parameter');
+        if (transformer.readableType !== undefined) {
+            throw new RangeError('Invalid readableType specified');
+        }
+        if (transformer.writableType !== undefined) {
+            throw new RangeError('Invalid writableType specified');
+        }
+        const readableHighWaterMark = ExtractHighWaterMark(readableStrategy, 0);
+        const readableSizeAlgorithm = ExtractSizeAlgorithm(readableStrategy);
+        const writableHighWaterMark = ExtractHighWaterMark(writableStrategy, 1);
+        const writableSizeAlgorithm = ExtractSizeAlgorithm(writableStrategy);
+        let startPromise_resolve;
+        const startPromise = newPromise(resolve => {
+            startPromise_resolve = resolve;
+        });
+        InitializeTransformStream(this, startPromise, writableHighWaterMark, writableSizeAlgorithm, readableHighWaterMark, readableSizeAlgorithm);
+        SetUpTransformStreamDefaultControllerFromTransformer(this, transformer);
+        if (transformer.start !== undefined) {
+            startPromise_resolve(transformer.start(this._transformStreamController));
+        }
+        else {
+            startPromise_resolve(undefined);
+        }
+    }
+    /**
+     * The readable side of the transform stream.
+     */
+    get readable() {
+        if (!IsTransformStream(this)) {
+            throw streamBrandCheckException('readable');
+        }
+        return this._readable;
+    }
+    /**
+     * The writable side of the transform stream.
+     */
+    get writable() {
+        if (!IsTransformStream(this)) {
+            throw streamBrandCheckException('writable');
+        }
+        return this._writable;
+    }
+}
+Object.defineProperties(TransformStream.prototype, {
+    readable: { enumerable: true },
+    writable: { enumerable: true }
+});
+function InitializeTransformStream(stream, startPromise, writableHighWaterMark, writableSizeAlgorithm, readableHighWaterMark, readableSizeAlgorithm) {
+    function startAlgorithm() {
+        return startPromise;
+    }
+    function writeAlgorithm(chunk) {
+        return TransformStreamDefaultSinkWriteAlgorithm(stream, chunk);
+    }
+    function abortAlgorithm(reason) {
+        return TransformStreamDefaultSinkAbortAlgorithm(stream, reason);
+    }
+    function closeAlgorithm() {
+        return TransformStreamDefaultSinkCloseAlgorithm(stream);
+    }
+    stream._writable = CreateWritableStream(startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, writableHighWaterMark, writableSizeAlgorithm);
+    function pullAlgorithm() {
+        return TransformStreamDefaultSourcePullAlgorithm(stream);
+    }
+    function cancelAlgorithm(reason) {
+        TransformStreamErrorWritableAndUnblockWrite(stream, reason);
+        return promiseResolvedWith(undefined);
+    }
+    stream._readable = CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, readableHighWaterMark, readableSizeAlgorithm);
+    // The [[backpressure]] slot is set to undefined so that it can be initialised by TransformStreamSetBackpressure.
+    stream._backpressure = undefined;
+    stream._backpressureChangePromise = undefined;
+    stream._backpressureChangePromise_resolve = undefined;
+    TransformStreamSetBackpressure(stream, true);
+    stream._transformStreamController = undefined;
+}
+function IsTransformStream(x) {
+    if (!typeIsObject(x)) {
+        return false;
+    }
+    if (!Object.prototype.hasOwnProperty.call(x, '_transformStreamController')) {
+        return false;
+    }
+    return x instanceof TransformStream;
+}
+// This is a no-op if both sides are already errored.
+function TransformStreamError(stream, e) {
+    ReadableStreamDefaultControllerError(stream._readable._readableStreamController, e);
+    TransformStreamErrorWritableAndUnblockWrite(stream, e);
+}
+function TransformStreamErrorWritableAndUnblockWrite(stream, e) {
+    TransformStreamDefaultControllerClearAlgorithms(stream._transformStreamController);
+    WritableStreamDefaultControllerErrorIfNeeded(stream._writable._writableStreamController, e);
+    if (stream._backpressure) {
+        // Pretend that pull() was called to permit any pending write() calls to complete. TransformStreamSetBackpressure()
+        // cannot be called from enqueue() or pull() once the ReadableStream is errored, so this will will be the final time
+        // _backpressure is set.
+        TransformStreamSetBackpressure(stream, false);
+    }
+}
+function TransformStreamSetBackpressure(stream, backpressure) {
+    // Passes also when called during construction.
+    if (stream._backpressureChangePromise !== undefined) {
+        stream._backpressureChangePromise_resolve();
+    }
+    stream._backpressureChangePromise = newPromise(resolve => {
+        stream._backpressureChangePromise_resolve = resolve;
+    });
+    stream._backpressure = backpressure;
+}
+// Class TransformStreamDefaultController
+/**
+ * Allows control of the {@link ReadableStream} and {@link WritableStream} of the associated {@link TransformStream}.
+ *
+ * @public
+ */
+class TransformStreamDefaultController {
+    constructor() {
+        throw new TypeError('Illegal constructor');
+    }
+    /**
+     * Returns the desired size to fill the readable side’s internal queue. It can be negative, if the queue is over-full.
+     */
+    get desiredSize() {
+        if (!IsTransformStreamDefaultController(this)) {
+            throw defaultControllerBrandCheckException('desiredSize');
+        }
+        const readableController = this._controlledTransformStream._readable._readableStreamController;
+        return ReadableStreamDefaultControllerGetDesiredSize(readableController);
+    }
+    enqueue(chunk = undefined) {
+        if (!IsTransformStreamDefaultController(this)) {
+            throw defaultControllerBrandCheckException('enqueue');
+        }
+        TransformStreamDefaultControllerEnqueue(this, chunk);
+    }
+    /**
+     * Errors both the readable side and the writable side of the controlled transform stream, making all future
+     * interactions with it fail with the given error `e`. Any chunks queued for transformation will be discarded.
+     */
+    error(reason = undefined) {
+        if (!IsTransformStreamDefaultController(this)) {
+            throw defaultControllerBrandCheckException('error');
+        }
+        TransformStreamDefaultControllerError(this, reason);
+    }
+    /**
+     * Closes the readable side and errors the writable side of the controlled transform stream. This is useful when the
+     * transformer only needs to consume a portion of the chunks written to the writable side.
+     */
+    terminate() {
+        if (!IsTransformStreamDefaultController(this)) {
+            throw defaultControllerBrandCheckException('terminate');
+        }
+        TransformStreamDefaultControllerTerminate(this);
+    }
+}
+Object.defineProperties(TransformStreamDefaultController.prototype, {
+    enqueue: { enumerable: true },
+    error: { enumerable: true },
+    terminate: { enumerable: true },
+    desiredSize: { enumerable: true }
+});
+// Transform Stream Default Controller Abstract Operations
+function IsTransformStreamDefaultController(x) {
+    if (!typeIsObject(x)) {
+        return false;
+    }
+    if (!Object.prototype.hasOwnProperty.call(x, '_controlledTransformStream')) {
+        return false;
+    }
+    return x instanceof TransformStreamDefaultController;
+}
+function SetUpTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm) {
+    controller._controlledTransformStream = stream;
+    stream._transformStreamController = controller;
+    controller._transformAlgorithm = transformAlgorithm;
+    controller._flushAlgorithm = flushAlgorithm;
+}
+function SetUpTransformStreamDefaultControllerFromTransformer(stream, transformer) {
+    const controller = Object.create(TransformStreamDefaultController.prototype);
+    let transformAlgorithm = (chunk) => {
+        try {
+            TransformStreamDefaultControllerEnqueue(controller, chunk);
+            return promiseResolvedWith(undefined);
+        }
+        catch (transformResultE) {
+            return promiseRejectedWith(transformResultE);
+        }
+    };
+    let flushAlgorithm = () => promiseResolvedWith(undefined);
+    if (transformer.transform !== undefined) {
+        transformAlgorithm = chunk => transformer.transform(chunk, controller);
+    }
+    if (transformer.flush !== undefined) {
+        flushAlgorithm = () => transformer.flush(controller);
+    }
+    SetUpTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm);
+}
+function TransformStreamDefaultControllerClearAlgorithms(controller) {
+    controller._transformAlgorithm = undefined;
+    controller._flushAlgorithm = undefined;
+}
+function TransformStreamDefaultControllerEnqueue(controller, chunk) {
+    const stream = controller._controlledTransformStream;
+    const readableController = stream._readable._readableStreamController;
+    if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(readableController)) {
+        throw new TypeError('Readable side is not in a state that permits enqueue');
+    }
+    // We throttle transform invocations based on the backpressure of the ReadableStream, but we still
+    // accept TransformStreamDefaultControllerEnqueue() calls.
+    try {
+        ReadableStreamDefaultControllerEnqueue(readableController, chunk);
+    }
+    catch (e) {
+        // This happens when readableStrategy.size() throws.
+        TransformStreamErrorWritableAndUnblockWrite(stream, e);
+        throw stream._readable._storedError;
+    }
+    const backpressure = ReadableStreamDefaultControllerHasBackpressure(readableController);
+    if (backpressure !== stream._backpressure) {
+        TransformStreamSetBackpressure(stream, true);
+    }
+}
+function TransformStreamDefaultControllerError(controller, e) {
+    TransformStreamError(controller._controlledTransformStream, e);
+}
+function TransformStreamDefaultControllerPerformTransform(controller, chunk) {
+    const transformPromise = controller._transformAlgorithm(chunk);
+    return transformPromiseWith(transformPromise, undefined, r => {
+        TransformStreamError(controller._controlledTransformStream, r);
+        throw r;
+    });
+}
+function TransformStreamDefaultControllerTerminate(controller) {
+    const stream = controller._controlledTransformStream;
+    const readableController = stream._readable._readableStreamController;
+    ReadableStreamDefaultControllerClose(readableController);
+    const error = new TypeError('TransformStream terminated');
+    TransformStreamErrorWritableAndUnblockWrite(stream, error);
+}
+// TransformStreamDefaultSink Algorithms
+function TransformStreamDefaultSinkWriteAlgorithm(stream, chunk) {
+    const controller = stream._transformStreamController;
+    if (stream._backpressure) {
+        const backpressureChangePromise = stream._backpressureChangePromise;
+        return transformPromiseWith(backpressureChangePromise, () => {
+            const writable = stream._writable;
+            const state = writable._state;
+            if (state === 'erroring') {
+                throw writable._storedError;
+            }
+            return TransformStreamDefaultControllerPerformTransform(controller, chunk);
+        });
+    }
+    return TransformStreamDefaultControllerPerformTransform(controller, chunk);
+}
+function TransformStreamDefaultSinkAbortAlgorithm(stream, reason) {
+    // abort() is not called synchronously, so it is possible for abort() to be called when the stream is already
+    // errored.
+    TransformStreamError(stream, reason);
+    return promiseResolvedWith(undefined);
+}
+function TransformStreamDefaultSinkCloseAlgorithm(stream) {
+    // stream._readable cannot change after construction, so caching it across a call to user code is safe.
+    const readable = stream._readable;
+    const controller = stream._transformStreamController;
+    const flushPromise = controller._flushAlgorithm();
+    TransformStreamDefaultControllerClearAlgorithms(controller);
+    // Return a promise that is fulfilled with undefined on success.
+    return transformPromiseWith(flushPromise, () => {
+        if (readable._state === 'errored') {
+            throw readable._storedError;
+        }
+        ReadableStreamDefaultControllerClose(readable._readableStreamController);
+    }, r => {
+        TransformStreamError(stream, r);
+        throw readable._storedError;
+    });
+}
+// TransformStreamDefaultSource Algorithms
+function TransformStreamDefaultSourcePullAlgorithm(stream) {
+    // Invariant. Enforced by the promises returned by start() and pull().
+    TransformStreamSetBackpressure(stream, false);
+    // Prevent the next pull() call until there is backpressure.
+    return stream._backpressureChangePromise;
+}
+// Helper functions for the TransformStreamDefaultController.
+function defaultControllerBrandCheckException(name) {
+    return new TypeError(`TransformStreamDefaultController.prototype.${name} can only be used on a TransformStreamDefaultController`);
+}
+// Helper functions for the TransformStream.
+function streamBrandCheckException(name) {
+    return new TypeError(`TransformStream.prototype.${name} can only be used on a TransformStream`);
+}
+
+/* c8 ignore start */
+// 64 KiB (same size chrome slice theirs blob into Uint8array's)
+const POOL_SIZE$1 = 65536;
+
+
+try {
+  // Don't use node: prefix for this, require+node: is not supported until node v14.14
+  // Only `import()` can use prefix in 12.20 and later
+  const { Blob } = require('buffer');
+  if (Blob && !Blob.prototype.stream) {
+    Blob.prototype.stream = function name (params) {
+      let position = 0;
+      const blob = this;
+
+      return new ReadableStream({
+        type: 'bytes',
+        async pull (ctrl) {
+          const chunk = blob.slice(position, Math.min(blob.size, position + POOL_SIZE$1));
+          const buffer = await chunk.arrayBuffer();
+          position += buffer.byteLength;
+          ctrl.enqueue(new Uint8Array(buffer));
+
+          if (position === blob.size) {
+            ctrl.close();
+          }
+        }
+      })
+    };
+  }
+} catch (error) {}
+/* c8 ignore end */
+
+// 64 KiB (same size chrome slice theirs blob into Uint8array's)
+const POOL_SIZE = 65536;
+
+/** @param {(Blob | Uint8Array)[]} parts */
+async function * toIterator (parts, clone = true) {
+  for (const part of parts) {
+    if ('stream' in part) {
+      yield * (/** @type {AsyncIterableIterator<Uint8Array>} */ (part.stream()));
+    } else if (ArrayBuffer.isView(part)) {
+      if (clone) {
+        let position = part.byteOffset;
+        const end = part.byteOffset + part.byteLength;
+        while (position !== end) {
+          const size = Math.min(end - position, POOL_SIZE);
+          const chunk = part.buffer.slice(position, position + size);
+          position += chunk.byteLength;
+          yield new Uint8Array(chunk);
+        }
+      } else {
+        yield part;
+      }
+    /* c8 ignore next 10 */
+    } else {
+      // For blobs that have arrayBuffer but no stream method (nodes buffer.Blob)
+      let position = 0, b = (/** @type {Blob} */ (part));
+      while (position !== b.size) {
+        const chunk = b.slice(position, Math.min(b.size, position + POOL_SIZE));
+        const buffer = await chunk.arrayBuffer();
+        position += buffer.byteLength;
+        yield new Uint8Array(buffer);
+      }
+    }
+  }
+}
+
+const _Blob = class Blob {
+  /** @type {Array.<(Blob|Uint8Array)>} */
+  #parts = []
+  #type = ''
+  #size = 0
+  #endings = 'transparent'
+
+  /**
+   * The Blob() constructor returns a new Blob object. The content
+   * of the blob consists of the concatenation of the values given
+   * in the parameter array.
+   *
+   * @param {*} blobParts
+   * @param {{ type?: string, endings?: string }} [options]
+   */
+  constructor (blobParts = [], options = {}) {
+    if (typeof blobParts !== 'object' || blobParts === null) {
+      throw new TypeError('Failed to construct \'Blob\': The provided value cannot be converted to a sequence.')
+    }
+
+    if (typeof blobParts[Symbol.iterator] !== 'function') {
+      throw new TypeError('Failed to construct \'Blob\': The object must have a callable @@iterator property.')
+    }
+
+    if (typeof options !== 'object' && typeof options !== 'function') {
+      throw new TypeError('Failed to construct \'Blob\': parameter 2 cannot convert to dictionary.')
+    }
+
+    if (options === null) options = {};
+
+    const encoder = new TextEncoder();
+    for (const element of blobParts) {
+      let part;
+      if (ArrayBuffer.isView(element)) {
+        part = new Uint8Array(element.buffer.slice(element.byteOffset, element.byteOffset + element.byteLength));
+      } else if (element instanceof ArrayBuffer) {
+        part = new Uint8Array(element.slice(0));
+      } else if (element instanceof Blob) {
+        part = element;
+      } else {
+        part = encoder.encode(`${element}`);
+      }
+
+      this.#size += ArrayBuffer.isView(part) ? part.byteLength : part.size;
+      this.#parts.push(part);
+    }
+
+    this.#endings = `${options.endings === undefined ? 'transparent' : options.endings}`;
+    const type = options.type === undefined ? '' : String(options.type);
+    this.#type = /^[\x20-\x7E]*$/.test(type) ? type : '';
+  }
+
+  /**
+   * The Blob interface's size property returns the
+   * size of the Blob in bytes.
+   */
+  get size () {
+    return this.#size
+  }
+
+  /**
+   * The type property of a Blob object returns the MIME type of the file.
+   */
+  get type () {
+    return this.#type
+  }
+
+  /**
+   * The text() method in the Blob interface returns a Promise
+   * that resolves with a string containing the contents of
+   * the blob, interpreted as UTF-8.
+   *
+   * @return {Promise<string>}
+   */
+  async text () {
+    // More optimized than using this.arrayBuffer()
+    // that requires twice as much ram
+    const decoder = new TextDecoder();
+    let str = '';
+    for await (const part of toIterator(this.#parts, false)) {
+      str += decoder.decode(part, { stream: true });
+    }
+    // Remaining
+    str += decoder.decode();
+    return str
+  }
+
+  /**
+   * The arrayBuffer() method in the Blob interface returns a
+   * Promise that resolves with the contents of the blob as
+   * binary data contained in an ArrayBuffer.
+   *
+   * @return {Promise<ArrayBuffer>}
+   */
+  async arrayBuffer () {
+    // Easier way... Just a unnecessary overhead
+    // const view = new Uint8Array(this.size);
+    // await this.stream().getReader({mode: 'byob'}).read(view);
+    // return view.buffer;
+
+    const data = new Uint8Array(this.size);
+    let offset = 0;
+    for await (const chunk of toIterator(this.#parts, false)) {
+      data.set(chunk, offset);
+      offset += chunk.length;
+    }
+
+    return data.buffer
+  }
+
+  stream () {
+    const it = toIterator(this.#parts, true);
+
+    return new ReadableStream({
+      // @ts-ignore
+      type: 'bytes',
+      async pull (ctrl) {
+        const chunk = await it.next();
+        chunk.done ? ctrl.close() : ctrl.enqueue(chunk.value);
+      },
+
+      async cancel () {
+        await it.return();
+      }
+    })
+  }
+
+  /**
+   * The Blob interface's slice() method creates and returns a
+   * new Blob object which contains data from a subset of the
+   * blob on which it's called.
+   *
+   * @param {number} [start]
+   * @param {number} [end]
+   * @param {string} [type]
+   */
+  slice (start = 0, end = this.size, type = '') {
+    const { size } = this;
+
+    let relativeStart = start < 0 ? Math.max(size + start, 0) : Math.min(start, size);
+    let relativeEnd = end < 0 ? Math.max(size + end, 0) : Math.min(end, size);
+
+    const span = Math.max(relativeEnd - relativeStart, 0);
+    const parts = this.#parts;
+    const blobParts = [];
+    let added = 0;
+
+    for (const part of parts) {
+      // don't add the overflow to new blobParts
+      if (added >= span) {
+        break
+      }
+
+      const size = ArrayBuffer.isView(part) ? part.byteLength : part.size;
+      if (relativeStart && size <= relativeStart) {
+        // Skip the beginning and change the relative
+        // start & end position as we skip the unwanted parts
+        relativeStart -= size;
+        relativeEnd -= size;
+      } else {
+        let chunk;
+        if (ArrayBuffer.isView(part)) {
+          chunk = part.subarray(relativeStart, Math.min(size, relativeEnd));
+          added += chunk.byteLength;
+        } else {
+          chunk = part.slice(relativeStart, Math.min(size, relativeEnd));
+          added += chunk.size;
+        }
+        relativeEnd -= size;
+        blobParts.push(chunk);
+        relativeStart = 0; // All next sequential parts should start at 0
+      }
+    }
+
+    const blob = new Blob([], { type: String(type).toLowerCase() });
+    blob.#size = span;
+    blob.#parts = blobParts;
+
+    return blob
+  }
+
+  get [Symbol.toStringTag] () {
+    return 'Blob'
+  }
+
+  static [Symbol.hasInstance] (object) {
+    return (
+      object &&
+      typeof object === 'object' &&
+      typeof object.constructor === 'function' &&
+      (
+        typeof object.stream === 'function' ||
+        typeof object.arrayBuffer === 'function'
+      ) &&
+      /^(Blob|File)$/.test(object[Symbol.toStringTag])
+    )
+  }
+};
+
+Object.defineProperties(_Blob.prototype, {
+  size: { enumerable: true },
+  type: { enumerable: true },
+  slice: { enumerable: true }
+});
+
+/** @type {typeof globalThis.Blob} */
+const Blob = _Blob;
+
+const _File = class File extends Blob {
+  #lastModified = 0
+  #name = ''
+
+  /**
+   * @param {*[]} fileBits
+   * @param {string} fileName
+   * @param {{lastModified?: number, type?: string}} options
+   */// @ts-ignore
+  constructor (fileBits, fileName, options = {}) {
+    if (arguments.length < 2) {
+      throw new TypeError(`Failed to construct 'File': 2 arguments required, but only ${arguments.length} present.`)
+    }
+    super(fileBits, options);
+
+    if (options === null) options = {};
+
+    // Simulate WebIDL type casting for NaN value in lastModified option.
+    const lastModified = options.lastModified === undefined ? Date.now() : Number(options.lastModified);
+    if (!Number.isNaN(lastModified)) {
+      this.#lastModified = lastModified;
+    }
+
+    this.#name = String(fileName);
+  }
+
+  get name () {
+    return this.#name
+  }
+
+  get lastModified () {
+    return this.#lastModified
+  }
+
+  get [Symbol.toStringTag] () {
+    return 'File'
+  }
+
+  static [Symbol.hasInstance] (object) {
+    return !!object && object instanceof Blob &&
+      /^(File)$/.test(object[Symbol.toStringTag])
+  }
+};
+
+/** @type {typeof globalThis.File} */// @ts-ignore
+const File = _File;
+
+class CustomEvent extends Event {
+    constructor(type, params) {
+        params = Object(params);
+        super(type, params);
+        if ('detail' in params)
+            this.detail = params.detail;
+    }
+}
+allowStringTag(CustomEvent);
+
+class TreeWalker {
+    parentNode() {
+        return null;
+    }
+    firstChild() {
+        return null;
+    }
+    lastChild() {
+        return null;
+    }
+    previousSibling() {
+        return null;
+    }
+    nextSibling() {
+        return null;
+    }
+    previousNode() {
+        return null;
+    }
+    nextNode() {
+        return null;
+    }
+    get currentNode() {
+        const internals = internalsOf(this, 'TreeWalker', 'currentNode');
+        return internals.currentNode;
+    }
+    get root() {
+        const internals = internalsOf(this, 'TreeWalker', 'root');
+        return internals.root;
+    }
+    get whatToShow() {
+        const internals = internalsOf(this, 'TreeWalker', 'whatToShow');
+        return internals.whatToShow;
+    }
+}
+allowStringTag(TreeWalker);
+
+const INTERNAL$1 = { tick: 0, pool: new Map };
+function requestIdleCallback(callback) {
+    if (!INTERNAL$1.pool.size) {
+        setTimeout$1(() => {
+            const next = __performance_now();
+            for (const func of INTERNAL$1.pool.values()) {
+                func(next);
+            }
+            INTERNAL$1.pool.clear();
+        }, 1000 / 16);
+    }
+    const func = __function_bind(callback, undefined);
+    const tick = ++INTERNAL$1.tick;
+    INTERNAL$1.pool.set(tick, func);
+    return tick;
+}
+function cancelIdleCallback(requestId) {
+    const timeout = INTERNAL$1.pool.get(requestId);
+    if (timeout) {
+        clearTimeout$1(timeout);
+        INTERNAL$1.pool.delete(requestId);
+    }
+}
+
+/**
+ * Returns a `Buffer` instance from the given data URI `uri`.
+ *
+ * @param {String} uri Data URI to turn into a Buffer instance
+ * @returns {Buffer} Buffer instance from Data URI
+ * @api public
+ */
+function dataUriToBuffer(uri) {
+    if (!/^data:/i.test(uri)) {
+        throw new TypeError('`uri` does not appear to be a Data URI (must begin with "data:")');
+    }
+    // strip newlines
+    uri = uri.replace(/\r?\n/g, '');
+    // split the URI up into the "metadata" and the "data" portions
+    const firstComma = uri.indexOf(',');
+    if (firstComma === -1 || firstComma <= 4) {
+        throw new TypeError('malformed data: URI');
+    }
+    // remove the "data:" scheme and parse the metadata
+    const meta = uri.substring(5, firstComma).split(';');
+    let charset = '';
+    let base64 = false;
+    const type = meta[0] || 'text/plain';
+    let typeFull = type;
+    for (let i = 1; i < meta.length; i++) {
+        if (meta[i] === 'base64') {
+            base64 = true;
+        }
+        else {
+            typeFull += `;${meta[i]}`;
+            if (meta[i].indexOf('charset=') === 0) {
+                charset = meta[i].substring(8);
+            }
+        }
+    }
+    // defaults to US-ASCII only if type is not provided
+    if (!meta[0] && !charset.length) {
+        typeFull += ';charset=US-ASCII';
+        charset = 'US-ASCII';
+    }
+    // get the encoded data portion and decode URI-encoded chars
+    const encoding = base64 ? 'base64' : 'ascii';
+    const data = unescape(uri.substring(firstComma + 1));
+    const buffer = Buffer.from(data, encoding);
+    // set `.type` and `.typeFull` properties to MIME type
+    buffer.type = type;
+    buffer.typeFull = typeFull;
+    // set the `.charset` property
+    buffer.charset = charset;
+    return buffer;
+}
+
+/*! formdata-polyfill. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> */
+
+var {toStringTag:t$1,iterator:i$1,hasInstance:h$1}=Symbol,
+r$1=Math.random,
+m$1='append,set,get,getAll,delete,keys,values,entries,forEach,constructor'.split(','),
+f$2=(a,b,c)=>(a+='',/^(Blob|File)$/.test(b && b[t$1])?[(c=c!==void 0?c+'':b[t$1]=='File'?b.name:'blob',a),b.name!==c||b[t$1]=='blob'?new File([b],c,b):b]:[a,b+'']),
+e$1=(c,f)=>(f?c:c.replace(/\r?\n|\r/g,'\r\n')).replace(/\n/g,'%0A').replace(/\r/g,'%0D').replace(/"/g,'%22'),
+x$1=(n, a, e)=>{if(a.length<e){throw new TypeError(`Failed to execute '${n}' on 'FormData': ${e} arguments required, but only ${a.length} present.`)}};
+
+/** @type {typeof globalThis.FormData} */
+const FormData = class FormData {
+#d=[];
+constructor(...a){if(a.length)throw new TypeError(`Failed to construct 'FormData': parameter 1 is not of type 'HTMLFormElement'.`)}
+get [t$1]() {return 'FormData'}
+[i$1](){return this.entries()}
+static [h$1](o) {return o&&typeof o==='object'&&o[t$1]==='FormData'&&!m$1.some(m=>typeof o[m]!='function')}
+append(...a){x$1('append',arguments,2);this.#d.push(f$2(...a));}
+delete(a){x$1('delete',arguments,1);a+='';this.#d=this.#d.filter(([b])=>b!==a);}
+get(a){x$1('get',arguments,1);a+='';for(var b=this.#d,l=b.length,c=0;c<l;c++)if(b[c][0]===a)return b[c][1];return null}
+getAll(a,b){x$1('getAll',arguments,1);b=[];a+='';this.#d.forEach(c=>c[0]===a&&b.push(c[1]));return b}
+has(a){x$1('has',arguments,1);a+='';return this.#d.some(b=>b[0]===a)}
+forEach(a,b){x$1('forEach',arguments,1);for(var [c,d]of this)a.call(b,d,c,this);}
+set(...a){x$1('set',arguments,2);var b=[],c=!0;a=f$2(...a);this.#d.forEach(d=>{d[0]===a[0]?c&&(c=!b.push(a)):b.push(d);});c&&b.push(a);this.#d=b;}
+*entries(){yield*this.#d;}
+*keys(){for(var[a]of this)yield a;}
+*values(){for(var[,a]of this)yield a;}};
+
+/** @param {FormData} F */
+function formDataToBlob (F,B=Blob){
+var b=`${r$1()}${r$1()}`.replace(/\./g, '').slice(-28).padStart(32, '-'),c=[],p=`--${b}\r\nContent-Disposition: form-data; name="`;
+F.forEach((v,n)=>typeof v=='string'
+?c.push(p+e$1(n)+`"\r\n\r\n${v.replace(/\r(?!\n)|(?<!\r)\n/g, '\r\n')}\r\n`)
+:c.push(p+e$1(n)+`"; filename="${e$1(v.name, 1)}"\r\nContent-Type: ${v.type||"application/octet-stream"}\r\n\r\n`, v, '\r\n'));
+c.push(`--${b}--`);
+return new B(c,{type:"multipart/form-data; boundary="+b})}
+
+class FetchBaseError extends Error {
+	constructor(message, type) {
+		super(message);
+		// Hide custom error implementation details from end-users
+		Error.captureStackTrace(this, this.constructor);
+
+		this.type = type;
+	}
+
+	get name() {
+		return this.constructor.name;
+	}
+
+	get [Symbol.toStringTag]() {
+		return this.constructor.name;
+	}
+}
+
+/**
+ * @typedef {{ address?: string, code: string, dest?: string, errno: number, info?: object, message: string, path?: string, port?: number, syscall: string}} SystemError
+*/
+
+/**
+ * FetchError interface for operational errors
+ */
+class FetchError extends FetchBaseError {
+	/**
+	 * @param  {string} message -      Error message for human
+	 * @param  {string} [type] -        Error type for machine
+	 * @param  {SystemError} [systemError] - For Node.js system error
+	 */
+	constructor(message, type, systemError) {
+		super(message, type);
+		// When err.type is `system`, err.erroredSysCall contains system error and err.code contains system error code
+		if (systemError) {
+			// eslint-disable-next-line no-multi-assign
+			this.code = this.errno = systemError.code;
+			this.erroredSysCall = systemError.syscall;
+		}
+	}
+}
+
+/**
+ * Is.js
+ *
+ * Object type checks.
+ */
+
+const NAME = Symbol.toStringTag;
+
+/**
+ * Check if `obj` is a URLSearchParams object
+ * ref: https://github.com/node-fetch/node-fetch/issues/296#issuecomment-307598143
+ * @param {*} object - Object to check for
+ * @return {boolean}
+ */
+const isURLSearchParameters = object => {
+	return (
+		typeof object === 'object' &&
+		typeof object.append === 'function' &&
+		typeof object.delete === 'function' &&
+		typeof object.get === 'function' &&
+		typeof object.getAll === 'function' &&
+		typeof object.has === 'function' &&
+		typeof object.set === 'function' &&
+		typeof object.sort === 'function' &&
+		object[NAME] === 'URLSearchParams'
+	);
+};
+
+/**
+ * Check if `object` is a W3C `Blob` object (which `File` inherits from)
+ * @param {*} object - Object to check for
+ * @return {boolean}
+ */
+const isBlob = object => {
+	return (
+		object &&
+		typeof object === 'object' &&
+		typeof object.arrayBuffer === 'function' &&
+		typeof object.type === 'string' &&
+		typeof object.stream === 'function' &&
+		typeof object.constructor === 'function' &&
+		/^(Blob|File)$/.test(object[NAME])
+	);
+};
+
+/**
+ * Check if `obj` is an instance of AbortSignal.
+ * @param {*} object - Object to check for
+ * @return {boolean}
+ */
+const isAbortSignal = object => {
+	return (
+		typeof object === 'object' && (
+			object[NAME] === 'AbortSignal' ||
+			object[NAME] === 'EventTarget'
+		)
+	);
+};
+
+/**
+ * isDomainOrSubdomain reports whether sub is a subdomain (or exact match) of
+ * the parent domain.
+ *
+ * Both domains must already be in canonical form.
+ * @param {string|URL} original
+ * @param {string|URL} destination
+ */
+const isDomainOrSubdomain = (destination, original) => {
+	const orig = new URL(original).hostname;
+	const dest = new URL(destination).hostname;
+
+	return orig === dest || orig.endsWith(`.${dest}`);
+};
+
+const pipeline = promisify(Stream.pipeline);
+const INTERNALS$2 = Symbol('Body internals');
+
+/**
+ * Body mixin
+ *
+ * Ref: https://fetch.spec.whatwg.org/#body
+ *
+ * @param   Stream  body  Readable stream
+ * @param   Object  opts  Response options
+ * @return  Void
+ */
+class Body {
+	constructor(body, {
+		size = 0
+	} = {}) {
+		let boundary = null;
+
+		if (body === null) {
+			// Body is undefined or null
+			body = null;
+		} else if (isURLSearchParameters(body)) {
+			// Body is a URLSearchParams
+			body = Buffer.from(body.toString());
+		} else if (isBlob(body)) ; else if (Buffer.isBuffer(body)) ; else if (types.isAnyArrayBuffer(body)) {
+			// Body is ArrayBuffer
+			body = Buffer.from(body);
+		} else if (ArrayBuffer.isView(body)) {
+			// Body is ArrayBufferView
+			body = Buffer.from(body.buffer, body.byteOffset, body.byteLength);
+		} else if (body instanceof Stream) ; else if (body instanceof FormData) {
+			// Body is FormData
+			body = formDataToBlob(body);
+			boundary = body.type.split('=')[1];
+		} else {
+			// None of the above
+			// coerce to string then buffer
+			body = Buffer.from(String(body));
+		}
+
+		let stream = body;
+
+		if (Buffer.isBuffer(body)) {
+			stream = Stream.Readable.from(body);
+		} else if (isBlob(body)) {
+			stream = Stream.Readable.from(body.stream());
+		}
+
+		this[INTERNALS$2] = {
+			body,
+			stream,
+			boundary,
+			disturbed: false,
+			error: null
+		};
+		this.size = size;
+
+		if (body instanceof Stream) {
+			body.on('error', error_ => {
+				const error = error_ instanceof FetchBaseError ?
+					error_ :
+					new FetchError(`Invalid response body while trying to fetch ${this.url}: ${error_.message}`, 'system', error_);
+				this[INTERNALS$2].error = error;
+			});
+		}
+	}
+
+	get body() {
+		return this[INTERNALS$2].stream;
+	}
+
+	get bodyUsed() {
+		return this[INTERNALS$2].disturbed;
+	}
+
+	/**
+	 * Decode response as ArrayBuffer
+	 *
+	 * @return  Promise
+	 */
+	async arrayBuffer() {
+		const {buffer, byteOffset, byteLength} = await consumeBody(this);
+		return buffer.slice(byteOffset, byteOffset + byteLength);
+	}
+
+	async formData() {
+		const ct = this.headers.get('content-type');
+
+		if (ct.startsWith('application/x-www-form-urlencoded')) {
+			const formData = new FormData();
+			const parameters = new URLSearchParams(await this.text());
+
+			for (const [name, value] of parameters) {
+				formData.append(name, value);
+			}
+
+			return formData;
+		}
+
+		const {toFormData} = await Promise.resolve().then(function () { return multipartParser; });
+		return toFormData(this.body, ct);
+	}
+
+	/**
+	 * Return raw response as Blob
+	 *
+	 * @return Promise
+	 */
+	async blob() {
+		const ct = (this.headers && this.headers.get('content-type')) || (this[INTERNALS$2].body && this[INTERNALS$2].body.type) || '';
+		const buf = await this.arrayBuffer();
+
+		return new Blob([buf], {
+			type: ct
+		});
+	}
+
+	/**
+	 * Decode response as json
+	 *
+	 * @return  Promise
+	 */
+	async json() {
+		const buffer = await consumeBody(this);
+		return JSON.parse(buffer.toString());
+	}
+
+	/**
+	 * Decode response as text
+	 *
+	 * @return  Promise
+	 */
+	async text() {
+		const buffer = await consumeBody(this);
+		return buffer.toString();
+	}
+
+	/**
+	 * Decode response as buffer (non-spec api)
+	 *
+	 * @return  Promise
+	 */
+	buffer() {
+		return consumeBody(this);
+	}
+}
+
+
+// In browsers, all properties are enumerable.
+Object.defineProperties(Body.prototype, {
+	body: {enumerable: true},
+	bodyUsed: {enumerable: true},
+	arrayBuffer: {enumerable: true},
+	blob: {enumerable: true},
+	json: {enumerable: true},
+	text: {enumerable: true},
+});
+
+/**
+ * Consume and convert an entire Body to a Buffer.
+ *
+ * Ref: https://fetch.spec.whatwg.org/#concept-body-consume-body
+ *
+ * @return Promise
+ */
+async function consumeBody(data) {
+	if (data[INTERNALS$2].disturbed) {
+		throw new TypeError(`body used already for: ${data.url}`);
+	}
+
+	data[INTERNALS$2].disturbed = true;
+
+	if (data[INTERNALS$2].error) {
+		throw data[INTERNALS$2].error;
+	}
+
+	const {body} = data;
+
+	// Body is null
+	if (body === null) {
+		return Buffer.alloc(0);
+	}
+
+	/* c8 ignore next 3 */
+	if (!(body instanceof Stream)) {
+		return Buffer.alloc(0);
+	}
+
+	// Body is stream
+	// get ready to actually consume the body
+	const accum = [];
+	let accumBytes = 0;
+
+	try {
+		for await (const chunk of body) {
+			if (data.size > 0 && accumBytes + chunk.length > data.size) {
+				const error = new FetchError(`content size at ${data.url} over limit: ${data.size}`, 'max-size');
+				body.destroy(error);
+				throw error;
+			}
+
+			accumBytes += chunk.length;
+			accum.push(chunk);
+		}
+	} catch (error) {
+		const error_ = error instanceof FetchBaseError ? error : new FetchError(`Invalid response body while trying to fetch ${data.url}: ${error.message}`, 'system', error);
+		throw error_;
+	}
+
+	if (body.readableEnded === true || body._readableState.ended === true) {
+		try {
+			if (accum.every(c => typeof c === 'string')) {
+				return Buffer.from(accum.join(''));
+			}
+
+			return Buffer.concat(accum, accumBytes);
+		} catch (error) {
+			throw new FetchError(`Could not create Buffer from response body for ${data.url}: ${error.message}`, 'system', error);
+		}
+	} else {
+		throw new FetchError(`Premature close of server response while trying to fetch ${data.url}`);
+	}
+}
+
+/**
+ * Clone body given Res/Req instance
+ *
+ * @param   Mixed   instance       Response or Request instance
+ * @param   String  highWaterMark  highWaterMark for both PassThrough body streams
+ * @return  Mixed
+ */
+const clone = (instance, highWaterMark) => {
+	let p1;
+	let p2;
+	let {body} = instance[INTERNALS$2];
+
+	// Don't allow cloning a used body
+	if (instance.bodyUsed) {
+		throw new Error('cannot clone body after it is used');
+	}
+
+	// Check that body is a stream and not form-data object
+	// note: we can't clone the form-data object without having it as a dependency
+	if ((body instanceof Stream) && (typeof body.getBoundary !== 'function')) {
+		// Tee instance body
+		p1 = new PassThrough({highWaterMark});
+		p2 = new PassThrough({highWaterMark});
+		body.pipe(p1);
+		body.pipe(p2);
+		// Set instance body to teed body and return the other teed body
+		instance[INTERNALS$2].stream = p1;
+		body = p2;
+	}
+
+	return body;
+};
+
+const getNonSpecFormDataBoundary = deprecate(
+	body => body.getBoundary(),
+	'form-data doesn\'t follow the spec and requires special treatment. Use alternative package',
+	'https://github.com/node-fetch/node-fetch/issues/1167'
+);
+
+/**
+ * Performs the operation "extract a `Content-Type` value from |object|" as
+ * specified in the specification:
+ * https://fetch.spec.whatwg.org/#concept-bodyinit-extract
+ *
+ * This function assumes that instance.body is present.
+ *
+ * @param {any} body Any options.body input
+ * @returns {string | null}
+ */
+const extractContentType = (body, request) => {
+	// Body is null or undefined
+	if (body === null) {
+		return null;
+	}
+
+	// Body is string
+	if (typeof body === 'string') {
+		return 'text/plain;charset=UTF-8';
+	}
+
+	// Body is a URLSearchParams
+	if (isURLSearchParameters(body)) {
+		return 'application/x-www-form-urlencoded;charset=UTF-8';
+	}
+
+	// Body is blob
+	if (isBlob(body)) {
+		return body.type || null;
+	}
+
+	// Body is a Buffer (Buffer, ArrayBuffer or ArrayBufferView)
+	if (Buffer.isBuffer(body) || types.isAnyArrayBuffer(body) || ArrayBuffer.isView(body)) {
+		return null;
+	}
+
+	if (body instanceof FormData) {
+		return `multipart/form-data; boundary=${request[INTERNALS$2].boundary}`;
+	}
+
+	// Detect form data input from form-data module
+	if (body && typeof body.getBoundary === 'function') {
+		return `multipart/form-data;boundary=${getNonSpecFormDataBoundary(body)}`;
+	}
+
+	// Body is stream - can't really do much about this
+	if (body instanceof Stream) {
+		return null;
+	}
+
+	// Body constructor defaults other things to string
+	return 'text/plain;charset=UTF-8';
+};
+
+/**
+ * The Fetch Standard treats this as if "total bytes" is a property on the body.
+ * For us, we have to explicitly get it with a function.
+ *
+ * ref: https://fetch.spec.whatwg.org/#concept-body-total-bytes
+ *
+ * @param {any} obj.body Body object from the Body instance.
+ * @returns {number | null}
+ */
+const getTotalBytes = request => {
+	const {body} = request[INTERNALS$2];
+
+	// Body is null or undefined
+	if (body === null) {
+		return 0;
+	}
+
+	// Body is Blob
+	if (isBlob(body)) {
+		return body.size;
+	}
+
+	// Body is Buffer
+	if (Buffer.isBuffer(body)) {
+		return body.length;
+	}
+
+	// Detect form data input from form-data module
+	if (body && typeof body.getLengthSync === 'function') {
+		return body.hasKnownLength && body.hasKnownLength() ? body.getLengthSync() : null;
+	}
+
+	// Body is stream
+	return null;
+};
+
+/**
+ * Write a Body to a Node.js WritableStream (e.g. http.Request) object.
+ *
+ * @param {Stream.Writable} dest The stream to write to.
+ * @param obj.body Body object from the Body instance.
+ * @returns {Promise<void>}
+ */
+const writeToStream = async (dest, {body}) => {
+	if (body === null) {
+		// Body is null
+		dest.end();
+	} else {
+		// Body is stream
+		await pipeline(body, dest);
+	}
+};
+
+/**
+ * Headers.js
+ *
+ * Headers class offers convenient helpers
+ */
+
+/* c8 ignore next 9 */
+const validateHeaderName = typeof http.validateHeaderName === 'function' ?
+	http.validateHeaderName :
+	name => {
+		if (!/^[\^`\-\w!#$%&'*+.|~]+$/.test(name)) {
+			const error = new TypeError(`Header name must be a valid HTTP token [${name}]`);
+			Object.defineProperty(error, 'code', {value: 'ERR_INVALID_HTTP_TOKEN'});
+			throw error;
+		}
+	};
+
+/* c8 ignore next 9 */
+const validateHeaderValue = typeof http.validateHeaderValue === 'function' ?
+	http.validateHeaderValue :
+	(name, value) => {
+		if (/[^\t\u0020-\u007E\u0080-\u00FF]/.test(value)) {
+			const error = new TypeError(`Invalid character in header content ["${name}"]`);
+			Object.defineProperty(error, 'code', {value: 'ERR_INVALID_CHAR'});
+			throw error;
+		}
+	};
+
+/**
+ * @typedef {Headers | Record<string, string> | Iterable<readonly [string, string]> | Iterable<Iterable<string>>} HeadersInit
+ */
+
+/**
+ * This Fetch API interface allows you to perform various actions on HTTP request and response headers.
+ * These actions include retrieving, setting, adding to, and removing.
+ * A Headers object has an associated header list, which is initially empty and consists of zero or more name and value pairs.
+ * You can add to this using methods like append() (see Examples.)
+ * In all methods of this interface, header names are matched by case-insensitive byte sequence.
+ *
+ */
+class Headers extends URLSearchParams {
+	/**
+	 * Headers class
+	 *
+	 * @constructor
+	 * @param {HeadersInit} [init] - Response headers
+	 */
+	constructor(init) {
+		// Validate and normalize init object in [name, value(s)][]
+		/** @type {string[][]} */
+		let result = [];
+		if (init instanceof Headers) {
+			const raw = init.raw();
+			for (const [name, values] of Object.entries(raw)) {
+				result.push(...values.map(value => [name, value]));
+			}
+		} else if (init == null) ; else if (typeof init === 'object' && !types.isBoxedPrimitive(init)) {
+			const method = init[Symbol.iterator];
+			// eslint-disable-next-line no-eq-null, eqeqeq
+			if (method == null) {
+				// Record<ByteString, ByteString>
+				result.push(...Object.entries(init));
+			} else {
+				if (typeof method !== 'function') {
+					throw new TypeError('Header pairs must be iterable');
+				}
+
+				// Sequence<sequence<ByteString>>
+				// Note: per spec we have to first exhaust the lists then process them
+				result = [...init]
+					.map(pair => {
+						if (
+							typeof pair !== 'object' || types.isBoxedPrimitive(pair)
+						) {
+							throw new TypeError('Each header pair must be an iterable object');
+						}
+
+						return [...pair];
+					}).map(pair => {
+						if (pair.length !== 2) {
+							throw new TypeError('Each header pair must be a name/value tuple');
+						}
+
+						return [...pair];
+					});
+			}
+		} else {
+			throw new TypeError('Failed to construct \'Headers\': The provided value is not of type \'(sequence<sequence<ByteString>> or record<ByteString, ByteString>)');
+		}
+
+		// Validate and lowercase
+		result =
+			result.length > 0 ?
+				result.map(([name, value]) => {
+					validateHeaderName(name);
+					validateHeaderValue(name, String(value));
+					return [String(name).toLowerCase(), String(value)];
+				}) :
+				undefined;
+
+		super(result);
+
+		// Returning a Proxy that will lowercase key names, validate parameters and sort keys
+		// eslint-disable-next-line no-constructor-return
+		return new Proxy(this, {
+			get(target, p, receiver) {
+				switch (p) {
+					case 'append':
+					case 'set':
+						return (name, value) => {
+							validateHeaderName(name);
+							validateHeaderValue(name, String(value));
+							return URLSearchParams.prototype[p].call(
+								target,
+								String(name).toLowerCase(),
+								String(value)
+							);
+						};
+
+					case 'delete':
+					case 'has':
+					case 'getAll':
+						return name => {
+							validateHeaderName(name);
+							return URLSearchParams.prototype[p].call(
+								target,
+								String(name).toLowerCase()
+							);
+						};
+
+					case 'keys':
+						return () => {
+							target.sort();
+							return new Set(URLSearchParams.prototype.keys.call(target)).keys();
+						};
+
+					default:
+						return Reflect.get(target, p, receiver);
+				}
+			}
+		});
+		/* c8 ignore next */
+	}
+
+	get [Symbol.toStringTag]() {
+		return this.constructor.name;
+	}
+
+	toString() {
+		return Object.prototype.toString.call(this);
+	}
+
+	get(name) {
+		const values = this.getAll(name);
+		if (values.length === 0) {
+			return null;
+		}
+
+		let value = values.join(', ');
+		if (/^content-encoding$/i.test(name)) {
+			value = value.toLowerCase();
+		}
+
+		return value;
+	}
+
+	forEach(callback, thisArg = undefined) {
+		for (const name of this.keys()) {
+			Reflect.apply(callback, thisArg, [this.get(name), name, this]);
+		}
+	}
+
+	* values() {
+		for (const name of this.keys()) {
+			yield this.get(name);
+		}
+	}
+
+	/**
+	 * @type {() => IterableIterator<[string, string]>}
+	 */
+	* entries() {
+		for (const name of this.keys()) {
+			yield [name, this.get(name)];
+		}
+	}
+
+	[Symbol.iterator]() {
+		return this.entries();
+	}
+
+	/**
+	 * Node-fetch non-spec method
+	 * returning all headers and their values as array
+	 * @returns {Record<string, string[]>}
+	 */
+	raw() {
+		return [...this.keys()].reduce((result, key) => {
+			result[key] = this.getAll(key);
+			return result;
+		}, {});
+	}
+
+	/**
+	 * For better console.log(headers) and also to convert Headers into Node.js Request compatible format
+	 */
+	[Symbol.for('nodejs.util.inspect.custom')]() {
+		return [...this.keys()].reduce((result, key) => {
+			const values = this.getAll(key);
+			// Http.request() only supports string as Host header.
+			// This hack makes specifying custom Host header possible.
+			if (key === 'host') {
+				result[key] = values[0];
+			} else {
+				result[key] = values.length > 1 ? values : values[0];
+			}
+
+			return result;
+		}, {});
+	}
+}
+
+/**
+ * Re-shaping object for Web IDL tests
+ * Only need to do it for overridden methods
+ */
+Object.defineProperties(
+	Headers.prototype,
+	['get', 'entries', 'forEach', 'values'].reduce((result, property) => {
+		result[property] = {enumerable: true};
+		return result;
+	}, {})
+);
+
+/**
+ * Create a Headers object from an http.IncomingMessage.rawHeaders, ignoring those that do
+ * not conform to HTTP grammar productions.
+ * @param {import('http').IncomingMessage['rawHeaders']} headers
+ */
+function fromRawHeaders(headers = []) {
+	return new Headers(
+		headers
+			// Split into pairs
+			.reduce((result, value, index, array) => {
+				if (index % 2 === 0) {
+					result.push(array.slice(index, index + 2));
+				}
+
+				return result;
+			}, [])
+			.filter(([name, value]) => {
+				try {
+					validateHeaderName(name);
+					validateHeaderValue(name, String(value));
+					return true;
+				} catch {
+					return false;
+				}
+			})
+
+	);
+}
+
+const redirectStatus = new Set([301, 302, 303, 307, 308]);
+
+/**
+ * Redirect code matching
+ *
+ * @param {number} code - Status code
+ * @return {boolean}
+ */
+const isRedirect = code => {
+	return redirectStatus.has(code);
+};
+
+/**
+ * Response.js
+ *
+ * Response class provides content decoding
+ */
+
+const INTERNALS$1 = Symbol('Response internals');
+
+/**
+ * Response class
+ *
+ * Ref: https://fetch.spec.whatwg.org/#response-class
+ *
+ * @param   Stream  body  Readable stream
+ * @param   Object  opts  Response options
+ * @return  Void
+ */
+class Response extends Body {
+	constructor(body = null, options = {}) {
+		super(body, options);
+
+		// eslint-disable-next-line no-eq-null, eqeqeq, no-negated-condition
+		const status = options.status != null ? options.status : 200;
+
+		const headers = new Headers(options.headers);
+
+		if (body !== null && !headers.has('Content-Type')) {
+			const contentType = extractContentType(body, this);
+			if (contentType) {
+				headers.append('Content-Type', contentType);
+			}
+		}
+
+		this[INTERNALS$1] = {
+			type: 'default',
+			url: options.url,
+			status,
+			statusText: options.statusText || '',
+			headers,
+			counter: options.counter,
+			highWaterMark: options.highWaterMark
+		};
+	}
+
+	get type() {
+		return this[INTERNALS$1].type;
+	}
+
+	get url() {
+		return this[INTERNALS$1].url || '';
+	}
+
+	get status() {
+		return this[INTERNALS$1].status;
+	}
+
+	/**
+	 * Convenience property representing if the request ended normally
+	 */
+	get ok() {
+		return this[INTERNALS$1].status >= 200 && this[INTERNALS$1].status < 300;
+	}
+
+	get redirected() {
+		return this[INTERNALS$1].counter > 0;
+	}
+
+	get statusText() {
+		return this[INTERNALS$1].statusText;
+	}
+
+	get headers() {
+		return this[INTERNALS$1].headers;
+	}
+
+	get highWaterMark() {
+		return this[INTERNALS$1].highWaterMark;
+	}
+
+	/**
+	 * Clone this response
+	 *
+	 * @return  Response
+	 */
+	clone() {
+		return new Response(clone(this, this.highWaterMark), {
+			type: this.type,
+			url: this.url,
+			status: this.status,
+			statusText: this.statusText,
+			headers: this.headers,
+			ok: this.ok,
+			redirected: this.redirected,
+			size: this.size,
+			highWaterMark: this.highWaterMark
+		});
+	}
+
+	/**
+	 * @param {string} url    The URL that the new response is to originate from.
+	 * @param {number} status An optional status code for the response (e.g., 302.)
+	 * @returns {Response}    A Response object.
+	 */
+	static redirect(url, status = 302) {
+		if (!isRedirect(status)) {
+			throw new RangeError('Failed to execute "redirect" on "response": Invalid status code');
+		}
+
+		return new Response(null, {
+			headers: {
+				location: new URL(url).toString()
+			},
+			status
+		});
+	}
+
+	static error() {
+		const response = new Response(null, {status: 0, statusText: ''});
+		response[INTERNALS$1].type = 'error';
+		return response;
+	}
+
+	get [Symbol.toStringTag]() {
+		return 'Response';
+	}
+}
+
+Object.defineProperties(Response.prototype, {
+	type: {enumerable: true},
+	url: {enumerable: true},
+	status: {enumerable: true},
+	ok: {enumerable: true},
+	redirected: {enumerable: true},
+	statusText: {enumerable: true},
+	headers: {enumerable: true},
+	clone: {enumerable: true}
+});
+
+const getSearch = parsedURL => {
+	if (parsedURL.search) {
+		return parsedURL.search;
+	}
+
+	const lastOffset = parsedURL.href.length - 1;
+	const hash = parsedURL.hash || (parsedURL.href[lastOffset] === '#' ? '#' : '');
+	return parsedURL.href[lastOffset - hash.length] === '?' ? '?' : '';
+};
+
+/**
+ * @external URL
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/URL|URL}
+ */
+
+/**
+ * @module utils/referrer
+ * @private
+ */
+
+/**
+ * @see {@link https://w3c.github.io/webappsec-referrer-policy/#strip-url|Referrer Policy §8.4. Strip url for use as a referrer}
+ * @param {string} URL
+ * @param {boolean} [originOnly=false]
+ */
+function stripURLForUseAsAReferrer(url, originOnly = false) {
+	// 1. If url is null, return no referrer.
+	if (url == null) { // eslint-disable-line no-eq-null, eqeqeq
+		return 'no-referrer';
+	}
+
+	url = new URL(url);
+
+	// 2. If url's scheme is a local scheme, then return no referrer.
+	if (/^(about|blob|data):$/.test(url.protocol)) {
+		return 'no-referrer';
+	}
+
+	// 3. Set url's username to the empty string.
+	url.username = '';
+
+	// 4. Set url's password to null.
+	// Note: `null` appears to be a mistake as this actually results in the password being `"null"`.
+	url.password = '';
+
+	// 5. Set url's fragment to null.
+	// Note: `null` appears to be a mistake as this actually results in the fragment being `"#null"`.
+	url.hash = '';
+
+	// 6. If the origin-only flag is true, then:
+	if (originOnly) {
+		// 6.1. Set url's path to null.
+		// Note: `null` appears to be a mistake as this actually results in the path being `"/null"`.
+		url.pathname = '';
+
+		// 6.2. Set url's query to null.
+		// Note: `null` appears to be a mistake as this actually results in the query being `"?null"`.
+		url.search = '';
+	}
+
+	// 7. Return url.
+	return url;
+}
+
+/**
+ * @see {@link https://w3c.github.io/webappsec-referrer-policy/#enumdef-referrerpolicy|enum ReferrerPolicy}
+ */
+const ReferrerPolicy = new Set([
+	'',
+	'no-referrer',
+	'no-referrer-when-downgrade',
+	'same-origin',
+	'origin',
+	'strict-origin',
+	'origin-when-cross-origin',
+	'strict-origin-when-cross-origin',
+	'unsafe-url'
+]);
+
+/**
+ * @see {@link https://w3c.github.io/webappsec-referrer-policy/#default-referrer-policy|default referrer policy}
+ */
+const DEFAULT_REFERRER_POLICY = 'strict-origin-when-cross-origin';
+
+/**
+ * @see {@link https://w3c.github.io/webappsec-referrer-policy/#referrer-policies|Referrer Policy §3. Referrer Policies}
+ * @param {string} referrerPolicy
+ * @returns {string} referrerPolicy
+ */
+function validateReferrerPolicy(referrerPolicy) {
+	if (!ReferrerPolicy.has(referrerPolicy)) {
+		throw new TypeError(`Invalid referrerPolicy: ${referrerPolicy}`);
+	}
+
+	return referrerPolicy;
+}
+
+/**
+ * @see {@link https://w3c.github.io/webappsec-secure-contexts/#is-origin-trustworthy|Referrer Policy §3.2. Is origin potentially trustworthy?}
+ * @param {external:URL} url
+ * @returns `true`: "Potentially Trustworthy", `false`: "Not Trustworthy"
+ */
+function isOriginPotentiallyTrustworthy(url) {
+	// 1. If origin is an opaque origin, return "Not Trustworthy".
+	// Not applicable
+
+	// 2. Assert: origin is a tuple origin.
+	// Not for implementations
+
+	// 3. If origin's scheme is either "https" or "wss", return "Potentially Trustworthy".
+	if (/^(http|ws)s:$/.test(url.protocol)) {
+		return true;
+	}
+
+	// 4. If origin's host component matches one of the CIDR notations 127.0.0.0/8 or ::1/128 [RFC4632], return "Potentially Trustworthy".
+	const hostIp = url.host.replace(/(^\[)|(]$)/g, '');
+	const hostIPVersion = isIP(hostIp);
+
+	if (hostIPVersion === 4 && /^127\./.test(hostIp)) {
+		return true;
+	}
+
+	if (hostIPVersion === 6 && /^(((0+:){7})|(::(0+:){0,6}))0*1$/.test(hostIp)) {
+		return true;
+	}
+
+	// 5. If origin's host component is "localhost" or falls within ".localhost", and the user agent conforms to the name resolution rules in [let-localhost-be-localhost], return "Potentially Trustworthy".
+	// We are returning FALSE here because we cannot ensure conformance to
+	// let-localhost-be-loalhost (https://tools.ietf.org/html/draft-west-let-localhost-be-localhost)
+	if (/^(.+\.)*localhost$/.test(url.host)) {
+		return false;
+	}
+
+	// 6. If origin's scheme component is file, return "Potentially Trustworthy".
+	if (url.protocol === 'file:') {
+		return true;
+	}
+
+	// 7. If origin's scheme component is one which the user agent considers to be authenticated, return "Potentially Trustworthy".
+	// Not supported
+
+	// 8. If origin has been configured as a trustworthy origin, return "Potentially Trustworthy".
+	// Not supported
+
+	// 9. Return "Not Trustworthy".
+	return false;
+}
+
+/**
+ * @see {@link https://w3c.github.io/webappsec-secure-contexts/#is-url-trustworthy|Referrer Policy §3.3. Is url potentially trustworthy?}
+ * @param {external:URL} url
+ * @returns `true`: "Potentially Trustworthy", `false`: "Not Trustworthy"
+ */
+function isUrlPotentiallyTrustworthy(url) {
+	// 1. If url is "about:blank" or "about:srcdoc", return "Potentially Trustworthy".
+	if (/^about:(blank|srcdoc)$/.test(url)) {
+		return true;
+	}
+
+	// 2. If url's scheme is "data", return "Potentially Trustworthy".
+	if (url.protocol === 'data:') {
+		return true;
+	}
+
+	// Note: The origin of blob: and filesystem: URLs is the origin of the context in which they were
+	// created. Therefore, blobs created in a trustworthy origin will themselves be potentially
+	// trustworthy.
+	if (/^(blob|filesystem):$/.test(url.protocol)) {
+		return true;
+	}
+
+	// 3. Return the result of executing §3.2 Is origin potentially trustworthy? on url's origin.
+	return isOriginPotentiallyTrustworthy(url);
+}
+
+/**
+ * Modifies the referrerURL to enforce any extra security policy considerations.
+ * @see {@link https://w3c.github.io/webappsec-referrer-policy/#determine-requests-referrer|Referrer Policy §8.3. Determine request's Referrer}, step 7
+ * @callback module:utils/referrer~referrerURLCallback
+ * @param {external:URL} referrerURL
+ * @returns {external:URL} modified referrerURL
+ */
+
+/**
+ * Modifies the referrerOrigin to enforce any extra security policy considerations.
+ * @see {@link https://w3c.github.io/webappsec-referrer-policy/#determine-requests-referrer|Referrer Policy §8.3. Determine request's Referrer}, step 7
+ * @callback module:utils/referrer~referrerOriginCallback
+ * @param {external:URL} referrerOrigin
+ * @returns {external:URL} modified referrerOrigin
+ */
+
+/**
+ * @see {@link https://w3c.github.io/webappsec-referrer-policy/#determine-requests-referrer|Referrer Policy §8.3. Determine request's Referrer}
+ * @param {Request} request
+ * @param {object} o
+ * @param {module:utils/referrer~referrerURLCallback} o.referrerURLCallback
+ * @param {module:utils/referrer~referrerOriginCallback} o.referrerOriginCallback
+ * @returns {external:URL} Request's referrer
+ */
+function determineRequestsReferrer(request, {referrerURLCallback, referrerOriginCallback} = {}) {
+	// There are 2 notes in the specification about invalid pre-conditions.  We return null, here, for
+	// these cases:
+	// > Note: If request's referrer is "no-referrer", Fetch will not call into this algorithm.
+	// > Note: If request's referrer policy is the empty string, Fetch will not call into this
+	// > algorithm.
+	if (request.referrer === 'no-referrer' || request.referrerPolicy === '') {
+		return null;
+	}
+
+	// 1. Let policy be request's associated referrer policy.
+	const policy = request.referrerPolicy;
+
+	// 2. Let environment be request's client.
+	// not applicable to node.js
+
+	// 3. Switch on request's referrer:
+	if (request.referrer === 'about:client') {
+		return 'no-referrer';
+	}
+
+	// "a URL": Let referrerSource be request's referrer.
+	const referrerSource = request.referrer;
+
+	// 4. Let request's referrerURL be the result of stripping referrerSource for use as a referrer.
+	let referrerURL = stripURLForUseAsAReferrer(referrerSource);
+
+	// 5. Let referrerOrigin be the result of stripping referrerSource for use as a referrer, with the
+	//    origin-only flag set to true.
+	let referrerOrigin = stripURLForUseAsAReferrer(referrerSource, true);
+
+	// 6. If the result of serializing referrerURL is a string whose length is greater than 4096, set
+	//    referrerURL to referrerOrigin.
+	if (referrerURL.toString().length > 4096) {
+		referrerURL = referrerOrigin;
+	}
+
+	// 7. The user agent MAY alter referrerURL or referrerOrigin at this point to enforce arbitrary
+	//    policy considerations in the interests of minimizing data leakage. For example, the user
+	//    agent could strip the URL down to an origin, modify its host, replace it with an empty
+	//    string, etc.
+	if (referrerURLCallback) {
+		referrerURL = referrerURLCallback(referrerURL);
+	}
+
+	if (referrerOriginCallback) {
+		referrerOrigin = referrerOriginCallback(referrerOrigin);
+	}
+
+	// 8.Execute the statements corresponding to the value of policy:
+	const currentURL = new URL(request.url);
+
+	switch (policy) {
+		case 'no-referrer':
+			return 'no-referrer';
+
+		case 'origin':
+			return referrerOrigin;
+
+		case 'unsafe-url':
+			return referrerURL;
+
+		case 'strict-origin':
+			// 1. If referrerURL is a potentially trustworthy URL and request's current URL is not a
+			//    potentially trustworthy URL, then return no referrer.
+			if (isUrlPotentiallyTrustworthy(referrerURL) && !isUrlPotentiallyTrustworthy(currentURL)) {
+				return 'no-referrer';
+			}
+
+			// 2. Return referrerOrigin.
+			return referrerOrigin.toString();
+
+		case 'strict-origin-when-cross-origin':
+			// 1. If the origin of referrerURL and the origin of request's current URL are the same, then
+			//    return referrerURL.
+			if (referrerURL.origin === currentURL.origin) {
+				return referrerURL;
+			}
+
+			// 2. If referrerURL is a potentially trustworthy URL and request's current URL is not a
+			//    potentially trustworthy URL, then return no referrer.
+			if (isUrlPotentiallyTrustworthy(referrerURL) && !isUrlPotentiallyTrustworthy(currentURL)) {
+				return 'no-referrer';
+			}
+
+			// 3. Return referrerOrigin.
+			return referrerOrigin;
+
+		case 'same-origin':
+			// 1. If the origin of referrerURL and the origin of request's current URL are the same, then
+			//    return referrerURL.
+			if (referrerURL.origin === currentURL.origin) {
+				return referrerURL;
+			}
+
+			// 2. Return no referrer.
+			return 'no-referrer';
+
+		case 'origin-when-cross-origin':
+			// 1. If the origin of referrerURL and the origin of request's current URL are the same, then
+			//    return referrerURL.
+			if (referrerURL.origin === currentURL.origin) {
+				return referrerURL;
+			}
+
+			// Return referrerOrigin.
+			return referrerOrigin;
+
+		case 'no-referrer-when-downgrade':
+			// 1. If referrerURL is a potentially trustworthy URL and request's current URL is not a
+			//    potentially trustworthy URL, then return no referrer.
+			if (isUrlPotentiallyTrustworthy(referrerURL) && !isUrlPotentiallyTrustworthy(currentURL)) {
+				return 'no-referrer';
+			}
+
+			// 2. Return referrerURL.
+			return referrerURL;
+
+		default:
+			throw new TypeError(`Invalid referrerPolicy: ${policy}`);
+	}
+}
+
+/**
+ * @see {@link https://w3c.github.io/webappsec-referrer-policy/#parse-referrer-policy-from-header|Referrer Policy §8.1. Parse a referrer policy from a Referrer-Policy header}
+ * @param {Headers} headers Response headers
+ * @returns {string} policy
+ */
+function parseReferrerPolicyFromHeader(headers) {
+	// 1. Let policy-tokens be the result of extracting header list values given `Referrer-Policy`
+	//    and response’s header list.
+	const policyTokens = (headers.get('referrer-policy') || '').split(/[,\s]+/);
+
+	// 2. Let policy be the empty string.
+	let policy = '';
+
+	// 3. For each token in policy-tokens, if token is a referrer policy and token is not the empty
+	//    string, then set policy to token.
+	// Note: This algorithm loops over multiple policy values to allow deployment of new policy
+	// values with fallbacks for older user agents, as described in § 11.1 Unknown Policy Values.
+	for (const token of policyTokens) {
+		if (token && ReferrerPolicy.has(token)) {
+			policy = token;
+		}
+	}
+
+	// 4. Return policy.
+	return policy;
+}
+
+/**
+ * Request.js
+ *
+ * Request class contains server only options
+ *
+ * All spec algorithm step numbers are based on https://fetch.spec.whatwg.org/commit-snapshots/ae716822cb3a61843226cd090eefc6589446c1d2/.
+ */
+
+const INTERNALS = Symbol('Request internals');
+
+/**
+ * Check if `obj` is an instance of Request.
+ *
+ * @param  {*} object
+ * @return {boolean}
+ */
+const isRequest = object => {
+	return (
+		typeof object === 'object' &&
+		typeof object[INTERNALS] === 'object'
+	);
+};
+
+const doBadDataWarn = deprecate(() => {},
+	'.data is not a valid RequestInit property, use .body instead',
+	'https://github.com/node-fetch/node-fetch/issues/1000 (request)');
+
+/**
+ * Request class
+ *
+ * Ref: https://fetch.spec.whatwg.org/#request-class
+ *
+ * @param   Mixed   input  Url or Request instance
+ * @param   Object  init   Custom options
+ * @return  Void
+ */
+class Request extends Body {
+	constructor(input, init = {}) {
+		let parsedURL;
+
+		// Normalize input and force URL to be encoded as UTF-8 (https://github.com/node-fetch/node-fetch/issues/245)
+		if (isRequest(input)) {
+			parsedURL = new URL(input.url);
+		} else {
+			parsedURL = new URL(input);
+			input = {};
+		}
+
+		if (parsedURL.username !== '' || parsedURL.password !== '') {
+			throw new TypeError(`${parsedURL} is an url with embedded credentials.`);
+		}
+
+		let method = init.method || input.method || 'GET';
+		method = method.toUpperCase();
+
+		if ('data' in init) {
+			doBadDataWarn();
+		}
+
+		// eslint-disable-next-line no-eq-null, eqeqeq
+		if ((init.body != null || (isRequest(input) && input.body !== null)) &&
+			(method === 'GET' || method === 'HEAD')) {
+			throw new TypeError('Request with GET/HEAD method cannot have body');
+		}
+
+		const inputBody = init.body ?
+			init.body :
+			(isRequest(input) && input.body !== null ?
+				clone(input) :
+				null);
+
+		super(inputBody, {
+			size: init.size || input.size || 0
+		});
+
+		const headers = new Headers(init.headers || input.headers || {});
+
+		if (inputBody !== null && !headers.has('Content-Type')) {
+			const contentType = extractContentType(inputBody, this);
+			if (contentType) {
+				headers.set('Content-Type', contentType);
+			}
+		}
+
+		let signal = isRequest(input) ?
+			input.signal :
+			null;
+		if ('signal' in init) {
+			signal = init.signal;
+		}
+
+		// eslint-disable-next-line no-eq-null, eqeqeq
+		if (signal != null && !isAbortSignal(signal)) {
+			throw new TypeError('Expected signal to be an instanceof AbortSignal or EventTarget');
+		}
+
+		// §5.4, Request constructor steps, step 15.1
+		// eslint-disable-next-line no-eq-null, eqeqeq
+		let referrer = init.referrer == null ? input.referrer : init.referrer;
+		if (referrer === '') {
+			// §5.4, Request constructor steps, step 15.2
+			referrer = 'no-referrer';
+		} else if (referrer) {
+			// §5.4, Request constructor steps, step 15.3.1, 15.3.2
+			const parsedReferrer = new URL(referrer);
+			// §5.4, Request constructor steps, step 15.3.3, 15.3.4
+			referrer = /^about:(\/\/)?client$/.test(parsedReferrer) ? 'client' : parsedReferrer;
+		} else {
+			referrer = undefined;
+		}
+
+		this[INTERNALS] = {
+			method,
+			redirect: init.redirect || input.redirect || 'follow',
+			headers,
+			parsedURL,
+			signal,
+			referrer
+		};
+
+		// Node-fetch-only options
+		this.follow = init.follow === undefined ? (input.follow === undefined ? 20 : input.follow) : init.follow;
+		this.compress = init.compress === undefined ? (input.compress === undefined ? true : input.compress) : init.compress;
+		this.counter = init.counter || input.counter || 0;
+		this.agent = init.agent || input.agent;
+		this.highWaterMark = init.highWaterMark || input.highWaterMark || 16384;
+		this.insecureHTTPParser = init.insecureHTTPParser || input.insecureHTTPParser || false;
+
+		// §5.4, Request constructor steps, step 16.
+		// Default is empty string per https://fetch.spec.whatwg.org/#concept-request-referrer-policy
+		this.referrerPolicy = init.referrerPolicy || input.referrerPolicy || '';
+	}
+
+	/** @returns {string} */
+	get method() {
+		return this[INTERNALS].method;
+	}
+
+	/** @returns {string} */
+	get url() {
+		return format$1(this[INTERNALS].parsedURL);
+	}
+
+	/** @returns {Headers} */
+	get headers() {
+		return this[INTERNALS].headers;
+	}
+
+	get redirect() {
+		return this[INTERNALS].redirect;
+	}
+
+	/** @returns {AbortSignal} */
+	get signal() {
+		return this[INTERNALS].signal;
+	}
+
+	// https://fetch.spec.whatwg.org/#dom-request-referrer
+	get referrer() {
+		if (this[INTERNALS].referrer === 'no-referrer') {
+			return '';
+		}
+
+		if (this[INTERNALS].referrer === 'client') {
+			return 'about:client';
+		}
+
+		if (this[INTERNALS].referrer) {
+			return this[INTERNALS].referrer.toString();
+		}
+
+		return undefined;
+	}
+
+	get referrerPolicy() {
+		return this[INTERNALS].referrerPolicy;
+	}
+
+	set referrerPolicy(referrerPolicy) {
+		this[INTERNALS].referrerPolicy = validateReferrerPolicy(referrerPolicy);
+	}
+
+	/**
+	 * Clone this request
+	 *
+	 * @return  Request
+	 */
+	clone() {
+		return new Request(this);
+	}
+
+	get [Symbol.toStringTag]() {
+		return 'Request';
+	}
+}
+
+Object.defineProperties(Request.prototype, {
+	method: {enumerable: true},
+	url: {enumerable: true},
+	headers: {enumerable: true},
+	redirect: {enumerable: true},
+	clone: {enumerable: true},
+	signal: {enumerable: true},
+	referrer: {enumerable: true},
+	referrerPolicy: {enumerable: true}
+});
+
+/**
+ * Convert a Request to Node.js http request options.
+ *
+ * @param {Request} request - A Request instance
+ * @return The options object to be passed to http.request
+ */
+const getNodeRequestOptions = request => {
+	const {parsedURL} = request[INTERNALS];
+	const headers = new Headers(request[INTERNALS].headers);
+
+	// Fetch step 1.3
+	if (!headers.has('Accept')) {
+		headers.set('Accept', '*/*');
+	}
+
+	// HTTP-network-or-cache fetch steps 2.4-2.7
+	let contentLengthValue = null;
+	if (request.body === null && /^(post|put)$/i.test(request.method)) {
+		contentLengthValue = '0';
+	}
+
+	if (request.body !== null) {
+		const totalBytes = getTotalBytes(request);
+		// Set Content-Length if totalBytes is a number (that is not NaN)
+		if (typeof totalBytes === 'number' && !Number.isNaN(totalBytes)) {
+			contentLengthValue = String(totalBytes);
+		}
+	}
+
+	if (contentLengthValue) {
+		headers.set('Content-Length', contentLengthValue);
+	}
+
+	// 4.1. Main fetch, step 2.6
+	// > If request's referrer policy is the empty string, then set request's referrer policy to the
+	// > default referrer policy.
+	if (request.referrerPolicy === '') {
+		request.referrerPolicy = DEFAULT_REFERRER_POLICY;
+	}
+
+	// 4.1. Main fetch, step 2.7
+	// > If request's referrer is not "no-referrer", set request's referrer to the result of invoking
+	// > determine request's referrer.
+	if (request.referrer && request.referrer !== 'no-referrer') {
+		request[INTERNALS].referrer = determineRequestsReferrer(request);
+	} else {
+		request[INTERNALS].referrer = 'no-referrer';
+	}
+
+	// 4.5. HTTP-network-or-cache fetch, step 6.9
+	// > If httpRequest's referrer is a URL, then append `Referer`/httpRequest's referrer, serialized
+	// >  and isomorphic encoded, to httpRequest's header list.
+	if (request[INTERNALS].referrer instanceof URL) {
+		headers.set('Referer', request.referrer);
+	}
+
+	// HTTP-network-or-cache fetch step 2.11
+	if (!headers.has('User-Agent')) {
+		headers.set('User-Agent', 'node-fetch');
+	}
+
+	// HTTP-network-or-cache fetch step 2.15
+	if (request.compress && !headers.has('Accept-Encoding')) {
+		headers.set('Accept-Encoding', 'gzip,deflate,br');
+	}
+
+	let {agent} = request;
+	if (typeof agent === 'function') {
+		agent = agent(parsedURL);
+	}
+
+	if (!headers.has('Connection') && !agent) {
+		headers.set('Connection', 'close');
+	}
+
+	// HTTP-network fetch step 4.2
+	// chunked encoding is handled by Node.js
+
+	const search = getSearch(parsedURL);
+
+	// Pass the full URL directly to request(), but overwrite the following
+	// options:
+	const options = {
+		// Overwrite search to retain trailing ? (issue #776)
+		path: parsedURL.pathname + search,
+		// The following options are not expressed in the URL
+		method: request.method,
+		headers: headers[Symbol.for('nodejs.util.inspect.custom')](),
+		insecureHTTPParser: request.insecureHTTPParser,
+		agent
+	};
+
+	return {
+		/** @type {URL} */
+		parsedURL,
+		options
+	};
+};
+
+/**
+ * AbortError interface for cancelled requests
+ */
+class AbortError extends FetchBaseError {
+	constructor(message, type = 'aborted') {
+		super(message, type);
+	}
+}
+
+/**
+ * Index.js
+ *
+ * a request API compatible with window.fetch
+ *
+ * All spec algorithm step numbers are based on https://fetch.spec.whatwg.org/commit-snapshots/ae716822cb3a61843226cd090eefc6589446c1d2/.
+ */
+
+const supportedSchemas = new Set(['data:', 'http:', 'https:']);
+
+/**
+ * Fetch function
+ *
+ * @param   {string | URL | import('./request').default} url - Absolute url or Request instance
+ * @param   {*} [options_] - Fetch options
+ * @return  {Promise<import('./response').default>}
+ */
+async function fetch$1(url, options_) {
+	return new Promise((resolve, reject) => {
+		// Build request object
+		const request = new Request(url, options_);
+		const {parsedURL, options} = getNodeRequestOptions(request);
+		if (!supportedSchemas.has(parsedURL.protocol)) {
+			throw new TypeError(`node-fetch cannot load ${url}. URL scheme "${parsedURL.protocol.replace(/:$/, '')}" is not supported.`);
+		}
+
+		if (parsedURL.protocol === 'data:') {
+			const data = dataUriToBuffer(request.url);
+			const response = new Response(data, {headers: {'Content-Type': data.typeFull}});
+			resolve(response);
+			return;
+		}
+
+		// Wrap http.request into fetch
+		const send = (parsedURL.protocol === 'https:' ? https : http).request;
+		const {signal} = request;
+		let response = null;
+
+		const abort = () => {
+			const error = new AbortError('The operation was aborted.');
+			reject(error);
+			if (request.body && request.body instanceof Stream.Readable) {
+				request.body.destroy(error);
+			}
+
+			if (!response || !response.body) {
+				return;
+			}
+
+			response.body.emit('error', error);
+		};
+
+		if (signal && signal.aborted) {
+			abort();
+			return;
+		}
+
+		const abortAndFinalize = () => {
+			abort();
+			finalize();
+		};
+
+		// Send request
+		const request_ = send(parsedURL.toString(), options);
+
+		if (signal) {
+			signal.addEventListener('abort', abortAndFinalize);
+		}
+
+		const finalize = () => {
+			request_.abort();
+			if (signal) {
+				signal.removeEventListener('abort', abortAndFinalize);
+			}
+		};
+
+		request_.on('error', error => {
+			reject(new FetchError(`request to ${request.url} failed, reason: ${error.message}`, 'system', error));
+			finalize();
+		});
+
+		fixResponseChunkedTransferBadEnding(request_, error => {
+			response.body.destroy(error);
+		});
+
+		/* c8 ignore next 18 */
+		if (process.version < 'v14') {
+			// Before Node.js 14, pipeline() does not fully support async iterators and does not always
+			// properly handle when the socket close/end events are out of order.
+			request_.on('socket', s => {
+				let endedWithEventsCount;
+				s.prependListener('end', () => {
+					endedWithEventsCount = s._eventsCount;
+				});
+				s.prependListener('close', hadError => {
+					// if end happened before close but the socket didn't emit an error, do it now
+					if (response && endedWithEventsCount < s._eventsCount && !hadError) {
+						const error = new Error('Premature close');
+						error.code = 'ERR_STREAM_PREMATURE_CLOSE';
+						response.body.emit('error', error);
+					}
+				});
+			});
+		}
+
+		request_.on('response', response_ => {
+			request_.setTimeout(0);
+			const headers = fromRawHeaders(response_.rawHeaders);
+
+			// HTTP fetch step 5
+			if (isRedirect(response_.statusCode)) {
+				// HTTP fetch step 5.2
+				const location = headers.get('Location');
+
+				// HTTP fetch step 5.3
+				let locationURL = null;
+				try {
+					locationURL = location === null ? null : new URL(location, request.url);
+				} catch {
+					// error here can only be invalid URL in Location: header
+					// do not throw when options.redirect == manual
+					// let the user extract the errorneous redirect URL
+					if (request.redirect !== 'manual') {
+						reject(new FetchError(`uri requested responds with an invalid redirect URL: ${location}`, 'invalid-redirect'));
+						finalize();
+						return;
+					}
+				}
+
+				// HTTP fetch step 5.5
+				switch (request.redirect) {
+					case 'error':
+						reject(new FetchError(`uri requested responds with a redirect, redirect mode is set to error: ${request.url}`, 'no-redirect'));
+						finalize();
+						return;
+					case 'manual':
+						// Nothing to do
+						break;
+					case 'follow': {
+						// HTTP-redirect fetch step 2
+						if (locationURL === null) {
+							break;
+						}
+
+						// HTTP-redirect fetch step 5
+						if (request.counter >= request.follow) {
+							reject(new FetchError(`maximum redirect reached at: ${request.url}`, 'max-redirect'));
+							finalize();
+							return;
+						}
+
+						// HTTP-redirect fetch step 6 (counter increment)
+						// Create a new Request object.
+						const requestOptions = {
+							headers: new Headers(request.headers),
+							follow: request.follow,
+							counter: request.counter + 1,
+							agent: request.agent,
+							compress: request.compress,
+							method: request.method,
+							body: clone(request),
+							signal: request.signal,
+							size: request.size,
+							referrer: request.referrer,
+							referrerPolicy: request.referrerPolicy
+						};
+
+						// when forwarding sensitive headers like "Authorization",
+						// "WWW-Authenticate", and "Cookie" to untrusted targets,
+						// headers will be ignored when following a redirect to a domain
+						// that is not a subdomain match or exact match of the initial domain.
+						// For example, a redirect from "foo.com" to either "foo.com" or "sub.foo.com"
+						// will forward the sensitive headers, but a redirect to "bar.com" will not.
+						if (!isDomainOrSubdomain(request.url, locationURL)) {
+							for (const name of ['authorization', 'www-authenticate', 'cookie', 'cookie2']) {
+								requestOptions.headers.delete(name);
+							}
+						}
+
+						// HTTP-redirect fetch step 9
+						if (response_.statusCode !== 303 && request.body && options_.body instanceof Stream.Readable) {
+							reject(new FetchError('Cannot follow redirect with body being a readable stream', 'unsupported-redirect'));
+							finalize();
+							return;
+						}
+
+						// HTTP-redirect fetch step 11
+						if (response_.statusCode === 303 || ((response_.statusCode === 301 || response_.statusCode === 302) && request.method === 'POST')) {
+							requestOptions.method = 'GET';
+							requestOptions.body = undefined;
+							requestOptions.headers.delete('content-length');
+						}
+
+						// HTTP-redirect fetch step 14
+						const responseReferrerPolicy = parseReferrerPolicyFromHeader(headers);
+						if (responseReferrerPolicy) {
+							requestOptions.referrerPolicy = responseReferrerPolicy;
+						}
+
+						// HTTP-redirect fetch step 15
+						resolve(fetch$1(new Request(locationURL, requestOptions)));
+						finalize();
+						return;
+					}
+
+					default:
+						return reject(new TypeError(`Redirect option '${request.redirect}' is not a valid value of RequestRedirect`));
+				}
+			}
+
+			// Prepare response
+			if (signal) {
+				response_.once('end', () => {
+					signal.removeEventListener('abort', abortAndFinalize);
+				});
+			}
+
+			let body = pipeline$1(response_, new PassThrough(), error => {
+				if (error) {
+					reject(error);
+				}
+			});
+			// see https://github.com/nodejs/node/pull/29376
+			/* c8 ignore next 3 */
+			if (process.version < 'v12.10') {
+				response_.on('aborted', abortAndFinalize);
+			}
+
+			const responseOptions = {
+				url: request.url,
+				status: response_.statusCode,
+				statusText: response_.statusMessage,
+				headers,
+				size: request.size,
+				counter: request.counter,
+				highWaterMark: request.highWaterMark
+			};
+
+			// HTTP-network fetch step 12.1.1.3
+			const codings = headers.get('Content-Encoding');
+
+			// HTTP-network fetch step 12.1.1.4: handle content codings
+
+			// in following scenarios we ignore compression support
+			// 1. compression support is disabled
+			// 2. HEAD request
+			// 3. no Content-Encoding header
+			// 4. no content response (204)
+			// 5. content not modified response (304)
+			if (!request.compress || request.method === 'HEAD' || codings === null || response_.statusCode === 204 || response_.statusCode === 304) {
+				response = new Response(body, responseOptions);
+				resolve(response);
+				return;
+			}
+
+			// For Node v6+
+			// Be less strict when decoding compressed responses, since sometimes
+			// servers send slightly invalid responses that are still accepted
+			// by common browsers.
+			// Always using Z_SYNC_FLUSH is what cURL does.
+			const zlibOptions = {
+				flush: zlib.Z_SYNC_FLUSH,
+				finishFlush: zlib.Z_SYNC_FLUSH
+			};
+
+			// For gzip
+			if (codings === 'gzip' || codings === 'x-gzip') {
+				body = pipeline$1(body, zlib.createGunzip(zlibOptions), error => {
+					if (error) {
+						reject(error);
+					}
+				});
+				response = new Response(body, responseOptions);
+				resolve(response);
+				return;
+			}
+
+			// For deflate
+			if (codings === 'deflate' || codings === 'x-deflate') {
+				// Handle the infamous raw deflate response from old servers
+				// a hack for old IIS and Apache servers
+				const raw = pipeline$1(response_, new PassThrough(), error => {
+					if (error) {
+						reject(error);
+					}
+				});
+				raw.once('data', chunk => {
+					// See http://stackoverflow.com/questions/37519828
+					if ((chunk[0] & 0x0F) === 0x08) {
+						body = pipeline$1(body, zlib.createInflate(), error => {
+							if (error) {
+								reject(error);
+							}
+						});
+					} else {
+						body = pipeline$1(body, zlib.createInflateRaw(), error => {
+							if (error) {
+								reject(error);
+							}
+						});
+					}
+
+					response = new Response(body, responseOptions);
+					resolve(response);
+				});
+				raw.once('end', () => {
+					// Some old IIS servers return zero-length OK deflate responses, so
+					// 'data' is never emitted. See https://github.com/node-fetch/node-fetch/pull/903
+					if (!response) {
+						response = new Response(body, responseOptions);
+						resolve(response);
+					}
+				});
+				return;
+			}
+
+			// For br
+			if (codings === 'br') {
+				body = pipeline$1(body, zlib.createBrotliDecompress(), error => {
+					if (error) {
+						reject(error);
+					}
+				});
+				response = new Response(body, responseOptions);
+				resolve(response);
+				return;
+			}
+
+			// Otherwise, use response as-is
+			response = new Response(body, responseOptions);
+			resolve(response);
+		});
+
+		// eslint-disable-next-line promise/prefer-await-to-then
+		writeToStream(request_, request).catch(reject);
+	});
+}
+
+function fixResponseChunkedTransferBadEnding(request, errorCallback) {
+	const LAST_CHUNK = Buffer.from('0\r\n\r\n');
+
+	let isChunkedTransfer = false;
+	let properLastChunkReceived = false;
+	let previousChunk;
+
+	request.on('response', response => {
+		const {headers} = response;
+		isChunkedTransfer = headers['transfer-encoding'] === 'chunked' && !headers['content-length'];
+	});
+
+	request.on('socket', socket => {
+		const onSocketClose = () => {
+			if (isChunkedTransfer && !properLastChunkReceived) {
+				const error = new Error('Premature close');
+				error.code = 'ERR_STREAM_PREMATURE_CLOSE';
+				errorCallback(error);
+			}
+		};
+
+		socket.prependListener('close', onSocketClose);
+
+		request.on('abort', () => {
+			socket.removeListener('close', onSocketClose);
+		});
+
+		socket.on('data', buf => {
+			properLastChunkReceived = Buffer.compare(buf.slice(-5), LAST_CHUNK) === 0;
+
+			// Sometimes final 0-length chunk and end of message code are in separate packets
+			if (!properLastChunkReceived && previousChunk) {
+				properLastChunkReceived = (
+					Buffer.compare(previousChunk.slice(-3), LAST_CHUNK.slice(0, 3)) === 0 &&
+					Buffer.compare(buf.slice(-2), LAST_CHUNK.slice(3)) === 0
+				);
+			}
+
+			previousChunk = buf;
+		});
+	});
+}
+
+const fetch = {
+    fetch(resource, init) {
+        const resourceURL = new URL(__object_isPrototypeOf(Request.prototype, resource)
+            ? resource.url
+            : pathToPosix(resource), typeof Object(globalThis.process).cwd === 'function' ? 'file:' + pathToPosix(process.cwd()) + '/' : 'file:');
+        if (resourceURL.protocol.toLowerCase() === 'file:') {
+            return import('node:fs').then(fs => {
+                try {
+                    const stats = fs.statSync(resourceURL);
+                    const body = fs.createReadStream(resourceURL);
+                    return new Response(body, {
+                        status: 200,
+                        statusText: '',
+                        headers: {
+                            'content-length': String(stats.size),
+                            'date': new Date().toUTCString(),
+                            'last-modified': new Date(stats.mtimeMs).toUTCString(),
+                        }
+                    });
+                }
+                catch (error) {
+                    const body = new Stream.Readable();
+                    body._read = () => { };
+                    body.push(null);
+                    return new Response(body, {
+                        status: 404,
+                        statusText: '',
+                        headers: {
+                            'date': new Date().toUTCString(),
+                        }
+                    });
+                }
+            });
+        }
+        else {
+            return fetch$1(resource, init);
+        }
+    }
+}.fetch;
+
+function u(u,D){for(var t=0;t<D.length;t++){var F=D[t];F.enumerable=F.enumerable||!1,F.configurable=!0,"value"in F&&(F.writable=!0),Object.defineProperty(u,F.key,F);}}function D(D,t,F){return t&&u(D.prototype,t),F&&u(D,F),D}function t(u,D){(null==D||D>u.length)&&(D=u.length);for(var t=0,F=new Array(D);t<D;t++)F[t]=u[t];return F}function F$1(u,D){var F="undefined"!=typeof Symbol&&u[Symbol.iterator]||u["@@iterator"];if(F)return (F=F.call(u)).next.bind(F);if(Array.isArray(u)||(F=function(u,D){if(u){if("string"==typeof u)return t(u,D);var F=Object.prototype.toString.call(u).slice(8,-1);return "Object"===F&&u.constructor&&(F=u.constructor.name),"Map"===F||"Set"===F?Array.from(u):"Arguments"===F||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(F)?t(u,D):void 0}}(u))||D&&u&&"number"==typeof u.length){F&&(u=F);var e=0;return function(){return e>=u.length?{done:!0}:{done:!1,value:u[e++]}}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}var e=/(?:[\$A-Z_a-z\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0560-\u0588\u05D0-\u05EA\u05EF-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u0860-\u086A\u08A0-\u08B4\u08B6-\u08C7\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u09FC\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C60\u0C61\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D04-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E86-\u0E8A\u0E8C-\u0EA3\u0EA5\u0EA7-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1878\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1C80-\u1C88\u1C90-\u1CBA\u1CBD-\u1CBF\u1CE9-\u1CEC\u1CEE-\u1CF3\u1CF5\u1CF6\u1CFA\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2118-\u211D\u2124\u2126\u2128\u212A-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309B-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312F\u3131-\u318E\u31A0-\u31BF\u31F0-\u31FF\u3400-\u4DBF\u4E00-\u9FFC\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA7BF\uA7C2-\uA7CA\uA7F5-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA8FE\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB69\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDE80-\uDE9C\uDEA0-\uDED0\uDF00-\uDF1F\uDF2D-\uDF4A\uDF50-\uDF75\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCB0-\uDCD3\uDCD8-\uDCFB\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00\uDE10-\uDE13\uDE15-\uDE17\uDE19-\uDE35\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE4\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2\uDD00-\uDD23\uDE80-\uDEA9\uDEB0\uDEB1\uDF00-\uDF1C\uDF27\uDF30-\uDF45\uDFB0-\uDFC4\uDFE0-\uDFF6]|\uD804[\uDC03-\uDC37\uDC83-\uDCAF\uDCD0-\uDCE8\uDD03-\uDD26\uDD44\uDD47\uDD50-\uDD72\uDD76\uDD83-\uDDB2\uDDC1-\uDDC4\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE2B\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEDE\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3D\uDF50\uDF5D-\uDF61]|\uD805[\uDC00-\uDC34\uDC47-\uDC4A\uDC5F-\uDC61\uDC80-\uDCAF\uDCC4\uDCC5\uDCC7\uDD80-\uDDAE\uDDD8-\uDDDB\uDE00-\uDE2F\uDE44\uDE80-\uDEAA\uDEB8\uDF00-\uDF1A]|\uD806[\uDC00-\uDC2B\uDCA0-\uDCDF\uDCFF-\uDD06\uDD09\uDD0C-\uDD13\uDD15\uDD16\uDD18-\uDD2F\uDD3F\uDD41\uDDA0-\uDDA7\uDDAA-\uDDD0\uDDE1\uDDE3\uDE00\uDE0B-\uDE32\uDE3A\uDE50\uDE5C-\uDE89\uDE9D\uDEC0-\uDEF8]|\uD807[\uDC00-\uDC08\uDC0A-\uDC2E\uDC40\uDC72-\uDC8F\uDD00-\uDD06\uDD08\uDD09\uDD0B-\uDD30\uDD46\uDD60-\uDD65\uDD67\uDD68\uDD6A-\uDD89\uDD98\uDEE0-\uDEF2\uDFB0]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD81C-\uD820\uD822\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872\uD874-\uD879\uD880-\uD883][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDED0-\uDEED\uDF00-\uDF2F\uDF40-\uDF43\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDE40-\uDE7F\uDF00-\uDF4A\uDF50\uDF93-\uDF9F\uDFE0\uDFE1\uDFE3]|\uD821[\uDC00-\uDFF7]|\uD823[\uDC00-\uDCD5\uDD00-\uDD08]|\uD82C[\uDC00-\uDD1E\uDD50-\uDD52\uDD64-\uDD67\uDD70-\uDEFB]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB]|\uD838[\uDD00-\uDD2C\uDD37-\uDD3D\uDD4E\uDEC0-\uDEEB]|\uD83A[\uDC00-\uDCC4\uDD00-\uDD43\uDD4B]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDEDD\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1\uDEB0-\uDFFF]|\uD87A[\uDC00-\uDFE0]|\uD87E[\uDC00-\uDE1D]|\uD884[\uDC00-\uDF4A])/,C=/(?:[\$0-9A-Z_a-z\xAA\xB5\xB7\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u0483-\u0487\u048A-\u052F\u0531-\u0556\u0559\u0560-\u0588\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u05D0-\u05EA\u05EF-\u05F2\u0610-\u061A\u0620-\u0669\u066E-\u06D3\u06D5-\u06DC\u06DF-\u06E8\u06EA-\u06FC\u06FF\u0710-\u074A\u074D-\u07B1\u07C0-\u07F5\u07FA\u07FD\u0800-\u082D\u0840-\u085B\u0860-\u086A\u08A0-\u08B4\u08B6-\u08C7\u08D3-\u08E1\u08E3-\u0963\u0966-\u096F\u0971-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BC-\u09C4\u09C7\u09C8\u09CB-\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09E6-\u09F1\u09FC\u09FE\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A59-\u0A5C\u0A5E\u0A66-\u0A75\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABC-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AD0\u0AE0-\u0AE3\u0AE6-\u0AEF\u0AF9-\u0AFF\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3C-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B55-\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B66-\u0B6F\u0B71\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD0\u0BD7\u0BE6-\u0BEF\u0C00-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58-\u0C5A\u0C60-\u0C63\u0C66-\u0C6F\u0C80-\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBC-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CDE\u0CE0-\u0CE3\u0CE6-\u0CEF\u0CF1\u0CF2\u0D00-\u0D0C\u0D0E-\u0D10\u0D12-\u0D44\u0D46-\u0D48\u0D4A-\u0D4E\u0D54-\u0D57\u0D5F-\u0D63\u0D66-\u0D6F\u0D7A-\u0D7F\u0D81-\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E01-\u0E3A\u0E40-\u0E4E\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E86-\u0E8A\u0E8C-\u0EA3\u0EA5\u0EA7-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECD\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E-\u0F47\u0F49-\u0F6C\u0F71-\u0F84\u0F86-\u0F97\u0F99-\u0FBC\u0FC6\u1000-\u1049\u1050-\u109D\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u135D-\u135F\u1369-\u1371\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176C\u176E-\u1770\u1772\u1773\u1780-\u17D3\u17D7\u17DC\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u1820-\u1878\u1880-\u18AA\u18B0-\u18F5\u1900-\u191E\u1920-\u192B\u1930-\u193B\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19DA\u1A00-\u1A1B\u1A20-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA7\u1AB0-\u1ABD\u1ABF\u1AC0\u1B00-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1BF3\u1C00-\u1C37\u1C40-\u1C49\u1C4D-\u1C7D\u1C80-\u1C88\u1C90-\u1CBA\u1CBD-\u1CBF\u1CD0-\u1CD2\u1CD4-\u1CFA\u1D00-\u1DF9\u1DFB-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u200C\u200D\u203F\u2040\u2054\u2071\u207F\u2090-\u209C\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2102\u2107\u210A-\u2113\u2115\u2118-\u211D\u2124\u2126\u2128\u212A-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D7F-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2DE0-\u2DFF\u3005-\u3007\u3021-\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u3099-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312F\u3131-\u318E\u31A0-\u31BF\u31F0-\u31FF\u3400-\u4DBF\u4E00-\u9FFC\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66F\uA674-\uA67D\uA67F-\uA6F1\uA717-\uA71F\uA722-\uA788\uA78B-\uA7BF\uA7C2-\uA7CA\uA7F5-\uA827\uA82C\uA840-\uA873\uA880-\uA8C5\uA8D0-\uA8D9\uA8E0-\uA8F7\uA8FB\uA8FD-\uA92D\uA930-\uA953\uA960-\uA97C\uA980-\uA9C0\uA9CF-\uA9D9\uA9E0-\uA9FE\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA60-\uAA76\uAA7A-\uAAC2\uAADB-\uAADD\uAAE0-\uAAEF\uAAF2-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB69\uAB70-\uABEA\uABEC\uABED\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE00-\uFE0F\uFE20-\uFE2F\uFE33\uFE34\uFE4D-\uFE4F\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF3F\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDDFD\uDE80-\uDE9C\uDEA0-\uDED0\uDEE0\uDF00-\uDF1F\uDF2D-\uDF4A\uDF50-\uDF7A\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCA0-\uDCA9\uDCB0-\uDCD3\uDCD8-\uDCFB\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00-\uDE03\uDE05\uDE06\uDE0C-\uDE13\uDE15-\uDE17\uDE19-\uDE35\uDE38-\uDE3A\uDE3F\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE6\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2\uDD00-\uDD27\uDD30-\uDD39\uDE80-\uDEA9\uDEAB\uDEAC\uDEB0\uDEB1\uDF00-\uDF1C\uDF27\uDF30-\uDF50\uDFB0-\uDFC4\uDFE0-\uDFF6]|\uD804[\uDC00-\uDC46\uDC66-\uDC6F\uDC7F-\uDCBA\uDCD0-\uDCE8\uDCF0-\uDCF9\uDD00-\uDD34\uDD36-\uDD3F\uDD44-\uDD47\uDD50-\uDD73\uDD76\uDD80-\uDDC4\uDDC9-\uDDCC\uDDCE-\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE37\uDE3E\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEEA\uDEF0-\uDEF9\uDF00-\uDF03\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3B-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF50\uDF57\uDF5D-\uDF63\uDF66-\uDF6C\uDF70-\uDF74]|\uD805[\uDC00-\uDC4A\uDC50-\uDC59\uDC5E-\uDC61\uDC80-\uDCC5\uDCC7\uDCD0-\uDCD9\uDD80-\uDDB5\uDDB8-\uDDC0\uDDD8-\uDDDD\uDE00-\uDE40\uDE44\uDE50-\uDE59\uDE80-\uDEB8\uDEC0-\uDEC9\uDF00-\uDF1A\uDF1D-\uDF2B\uDF30-\uDF39]|\uD806[\uDC00-\uDC3A\uDCA0-\uDCE9\uDCFF-\uDD06\uDD09\uDD0C-\uDD13\uDD15\uDD16\uDD18-\uDD35\uDD37\uDD38\uDD3B-\uDD43\uDD50-\uDD59\uDDA0-\uDDA7\uDDAA-\uDDD7\uDDDA-\uDDE1\uDDE3\uDDE4\uDE00-\uDE3E\uDE47\uDE50-\uDE99\uDE9D\uDEC0-\uDEF8]|\uD807[\uDC00-\uDC08\uDC0A-\uDC36\uDC38-\uDC40\uDC50-\uDC59\uDC72-\uDC8F\uDC92-\uDCA7\uDCA9-\uDCB6\uDD00-\uDD06\uDD08\uDD09\uDD0B-\uDD36\uDD3A\uDD3C\uDD3D\uDD3F-\uDD47\uDD50-\uDD59\uDD60-\uDD65\uDD67\uDD68\uDD6A-\uDD8E\uDD90\uDD91\uDD93-\uDD98\uDDA0-\uDDA9\uDEE0-\uDEF6\uDFB0]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD81C-\uD820\uD822\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872\uD874-\uD879\uD880-\uD883][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDE60-\uDE69\uDED0-\uDEED\uDEF0-\uDEF4\uDF00-\uDF36\uDF40-\uDF43\uDF50-\uDF59\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDE40-\uDE7F\uDF00-\uDF4A\uDF4F-\uDF87\uDF8F-\uDF9F\uDFE0\uDFE1\uDFE3\uDFE4\uDFF0\uDFF1]|\uD821[\uDC00-\uDFF7]|\uD823[\uDC00-\uDCD5\uDD00-\uDD08]|\uD82C[\uDC00-\uDD1E\uDD50-\uDD52\uDD64-\uDD67\uDD70-\uDEFB]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99\uDC9D\uDC9E]|\uD834[\uDD65-\uDD69\uDD6D-\uDD72\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB\uDFCE-\uDFFF]|\uD836[\uDE00-\uDE36\uDE3B-\uDE6C\uDE75\uDE84\uDE9B-\uDE9F\uDEA1-\uDEAF]|\uD838[\uDC00-\uDC06\uDC08-\uDC18\uDC1B-\uDC21\uDC23\uDC24\uDC26-\uDC2A\uDD00-\uDD2C\uDD30-\uDD3D\uDD40-\uDD49\uDD4E\uDEC0-\uDEF9]|\uD83A[\uDC00-\uDCC4\uDCD0-\uDCD6\uDD00-\uDD4B\uDD50-\uDD59]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD83E[\uDFF0-\uDFF9]|\uD869[\uDC00-\uDEDD\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1\uDEB0-\uDFFF]|\uD87A[\uDC00-\uDFE0]|\uD87E[\uDC00-\uDE1D]|\uD884[\uDC00-\uDF4A]|\uDB40[\uDD00-\uDDEF])/;function A$1(u,D){return (D?/^[\x00-\xFF]*$/:/^[\x00-\x7F]*$/).test(u)}function E(u,D){void 0===D&&(D=!1);for(var t=[],F=0;F<u.length;){var E=u[F],n=function(e){if(!D)throw new TypeError(e);t.push({type:"INVALID_CHAR",index:F,value:u[F++]});};if("*"!==E)if("+"!==E&&"?"!==E)if("\\"!==E)if("{"!==E)if("}"!==E)if(":"!==E)if("("!==E)t.push({type:"CHAR",index:F,value:u[F++]});else {var r=1,i="",s=F+1,a=!1;if("?"===u[s]){n('Pattern cannot start with "?" at '+s);continue}for(;s<u.length;){if(!A$1(u[s],!1)){n("Invalid character '"+u[s]+"' at "+s+"."),a=!0;break}if("\\"!==u[s]){if(")"===u[s]){if(0==--r){s++;break}}else if("("===u[s]&&(r++,"?"!==u[s+1])){n("Capturing groups are not allowed at "+s),a=!0;break}i+=u[s++];}else i+=u[s++]+u[s++];}if(a)continue;if(r){n("Unbalanced pattern at "+F);continue}if(!i){n("Missing pattern at "+F);continue}t.push({type:"PATTERN",index:F,value:i}),F=s;}else {for(var B="",o=F+1;o<u.length;){var h=u.substr(o,1);if(!(o===F+1&&e.test(h)||o!==F+1&&C.test(h)))break;B+=u[o++];}if(!B){n("Missing parameter name at "+F);continue}t.push({type:"NAME",index:F,value:B}),F=o;}else t.push({type:"CLOSE",index:F,value:u[F++]});else t.push({type:"OPEN",index:F,value:u[F++]});else t.push({type:"ESCAPED_CHAR",index:F++,value:u[F++]});else t.push({type:"MODIFIER",index:F,value:u[F++]});else t.push({type:"ASTERISK",index:F,value:u[F++]});}return t.push({type:"END",index:F,value:""}),t}function n(u,D){void 0===D&&(D={});for(var t=E(u),F=D.prefixes,e=void 0===F?"./":F,C="[^"+r(D.delimiter||"/#?")+"]+?",A=[],n=0,i=0,s="",a=new Set,B=function(u){if(i<t.length&&t[i].type===u)return t[i++].value},o=function(){return B("MODIFIER")||B("ASTERISK")},h=function(u){var D=B(u);if(void 0!==D)return D;var F=t[i];throw new TypeError("Unexpected "+F.type+" at "+F.index+", expected "+u)},p=function(){for(var u,D="";u=B("CHAR")||B("ESCAPED_CHAR");)D+=u;return D},c=D.encodePart||function(u){return u};i<t.length;){var f=B("CHAR"),l=B("NAME"),m=B("PATTERN");if(l||m||!B("ASTERISK")||(m=".*"),l||m){var d=f||"";-1===e.indexOf(d)&&(s+=d,d=""),s&&(A.push(c(s)),s="");var g=l||n++;if(a.has(g))throw new TypeError("Duplicate name '"+g+"'.");a.add(g),A.push({name:g,prefix:c(d),suffix:"",pattern:m||C,modifier:o()||""});}else {var x=f||B("ESCAPED_CHAR");if(x)s+=x;else if(B("OPEN")){var S=p(),v=B("NAME")||"",y=B("PATTERN")||"";v||y||!B("ASTERISK")||(y=".*");var R=p();h("CLOSE");var k=o()||"";if(!v&&!y&&!k){s+=S;continue}if(!v&&!y&&!S)continue;s&&(A.push(c(s)),s=""),A.push({name:v||(y?n++:""),pattern:v&&!y?C:y,prefix:c(S),suffix:c(R),modifier:k});}else s&&(A.push(c(s)),s=""),h("END");}}return A}function r(u){return u.replace(/([.+*?^${}()[\]|/\\])/g,"\\$1")}function i(u){return u&&u.sensitive?"u":"ui"}function s$1(u,D,t){void 0===t&&(t={});for(var e,C=t.strict,A=void 0!==C&&C,E=t.start,n=void 0===E||E,s=t.end,a=void 0===s||s,B=t.encode,o=void 0===B?function(u){return u}:B,h="["+r(t.endsWith||"")+"]|$",p="["+r(t.delimiter||"/#?")+"]",c=n?"^":"",f=F$1(u);!(e=f()).done;){var l=e.value;if("string"==typeof l)c+=r(o(l));else {var m=r(o(l.prefix)),d=r(o(l.suffix));l.pattern?(D&&D.push(l),c+=m||d?"+"===l.modifier||"*"===l.modifier?"(?:"+m+"((?:"+l.pattern+")(?:"+d+m+"(?:"+l.pattern+"))*)"+d+")"+("*"===l.modifier?"?":""):"(?:"+m+"("+l.pattern+")"+d+")"+l.modifier:"+"===l.modifier||"*"===l.modifier?"((?:"+l.pattern+")"+l.modifier+")":"("+l.pattern+")"+l.modifier):c+="(?:"+m+d+")"+l.modifier;}}if(a)A||(c+=p+"?"),c+=t.endsWith?"(?="+h+")":"$";else {var g=u[u.length-1],x="string"==typeof g?p.indexOf(g[g.length-1])>-1:void 0===g;A||(c+="(?:"+p+"(?="+h+"))?"),x||(c+="(?="+p+"|"+h+")");}return new RegExp(c,i(t))}function a(u,D,t){return u instanceof RegExp?function(u,D){if(!D)return u;for(var t=/\((?:\?<(.*?)>)?(?!\?)/g,F=0,e=t.exec(u.source);e;)D.push({name:e[1]||F++,prefix:"",suffix:"",modifier:"",pattern:""}),e=t.exec(u.source);return u}(u,D):Array.isArray(u)?function(u,D,t){var F=u.map(function(u){return a(u,D,t).source});return new RegExp("(?:"+F.join("|")+")",i(t))}(u,D,t):function(u,D,t){return s$1(n(u,t),D,t)}(u,D,t)}var B={delimiter:"",prefixes:"",sensitive:!0,strict:!0},o={delimiter:".",prefixes:"",sensitive:!0,strict:!0},h={delimiter:"/",prefixes:"/",sensitive:!0,strict:!0};function p(u,D){return u.startsWith(D)?u.substring(D.length,u.length):u}function c(u){return !(!u||u.length<2||"["!==u[0]&&("\\"!==u[0]&&"{"!==u[0]||"["!==u[1]))}var f$1,l=["ftp","file","http","https","ws","wss"];function m(u){if(!u)return !0;for(var D,t=F$1(l);!(D=t()).done;)if(u.test(D.value))return !0;return !1}function d(u){switch(u){case"ws":case"http":return "80";case"wws":case"https":return "443";case"ftp":return "21";default:return ""}}function g(u){if(""===u)return u;if(/^[-+.A-Za-z0-9]*$/.test(u))return u.toLowerCase();throw new TypeError("Invalid protocol '"+u+"'.")}function x(u){if(""===u)return u;var D=new URL("https://example.com");return D.username=u,D.username}function S$1(u){if(""===u)return u;var D=new URL("https://example.com");return D.password=u,D.password}function v(u){if(""===u)return u;if(/[\t\n\r #%/:<>?@[\]^\\|]/g.test(u))throw new TypeError("Invalid hostname '"+u+"'");var D=new URL("https://example.com");return D.hostname=u,D.hostname}function y(u){if(""===u)return u;if(/[^0-9a-fA-F[\]:]/g.test(u))throw new TypeError("Invalid IPv6 hostname '"+u+"'");return u.toLowerCase()}function R(u){if(""===u)return u;if(/^[0-9]*$/.test(u)&&parseInt(u)<=65535)return u;throw new TypeError("Invalid port '"+u+"'.")}function k(u){if(""===u)return u;var D=new URL("https://example.com");return D.pathname="/"!==u[0]?"/-"+u:u,"/"!==u[0]?D.pathname.substring(2,D.pathname.length):D.pathname}function w(u){return ""===u?u:new URL("data:"+u).pathname}function P(u){if(""===u)return u;var D=new URL("https://example.com");return D.search=u,D.search.substring(1,D.search.length)}function T(u){if(""===u)return u;var D=new URL("https://example.com");return D.hash=u,D.hash.substring(1,D.hash.length)}!function(u){u[u.INIT=0]="INIT",u[u.PROTOCOL=1]="PROTOCOL",u[u.AUTHORITY=2]="AUTHORITY",u[u.USERNAME=3]="USERNAME",u[u.PASSWORD=4]="PASSWORD",u[u.HOSTNAME=5]="HOSTNAME",u[u.PORT=6]="PORT",u[u.PATHNAME=7]="PATHNAME",u[u.SEARCH=8]="SEARCH",u[u.HASH=9]="HASH",u[u.DONE=10]="DONE";}(f$1||(f$1={}));var b=function(){function u(u){this.input=void 0,this.tokenList=[],this.internalResult={},this.tokenIndex=0,this.tokenIncrement=1,this.componentStart=0,this.state=f$1.INIT,this.groupDepth=0,this.hostnameIPv6BracketDepth=0,this.shouldTreatAsStandardURL=!1,this.input=u;}var t=u.prototype;return t.parse=function(){for(this.tokenList=E(this.input,!0);this.tokenIndex<this.tokenList.length;this.tokenIndex+=this.tokenIncrement){if(this.tokenIncrement=1,"END"===this.tokenList[this.tokenIndex].type){if(this.state===f$1.INIT){this.rewind(),this.isHashPrefix()?this.changeState(f$1.HASH,1):this.isSearchPrefix()?(this.changeState(f$1.SEARCH,1),this.internalResult.hash=""):(this.changeState(f$1.PATHNAME,0),this.internalResult.search="",this.internalResult.hash="");continue}if(this.state===f$1.AUTHORITY){this.rewindAndSetState(f$1.HOSTNAME);continue}this.changeState(f$1.DONE,0);break}if(this.groupDepth>0){if(!this.isGroupClose())continue;this.groupDepth-=1;}if(this.isGroupOpen())this.groupDepth+=1;else switch(this.state){case f$1.INIT:this.isProtocolSuffix()&&(this.internalResult.username="",this.internalResult.password="",this.internalResult.hostname="",this.internalResult.port="",this.internalResult.pathname="",this.internalResult.search="",this.internalResult.hash="",this.rewindAndSetState(f$1.PROTOCOL));break;case f$1.PROTOCOL:if(this.isProtocolSuffix()){this.computeShouldTreatAsStandardURL();var u=f$1.PATHNAME,D=1;this.shouldTreatAsStandardURL&&(this.internalResult.pathname="/"),this.nextIsAuthoritySlashes()?(u=f$1.AUTHORITY,D=3):this.shouldTreatAsStandardURL&&(u=f$1.AUTHORITY),this.changeState(u,D);}break;case f$1.AUTHORITY:this.isIdentityTerminator()?this.rewindAndSetState(f$1.USERNAME):(this.isPathnameStart()||this.isSearchPrefix()||this.isHashPrefix())&&this.rewindAndSetState(f$1.HOSTNAME);break;case f$1.USERNAME:this.isPasswordPrefix()?this.changeState(f$1.PASSWORD,1):this.isIdentityTerminator()&&this.changeState(f$1.HOSTNAME,1);break;case f$1.PASSWORD:this.isIdentityTerminator()&&this.changeState(f$1.HOSTNAME,1);break;case f$1.HOSTNAME:this.isIPv6Open()?this.hostnameIPv6BracketDepth+=1:this.isIPv6Close()&&(this.hostnameIPv6BracketDepth-=1),this.isPortPrefix()&&!this.hostnameIPv6BracketDepth?this.changeState(f$1.PORT,1):this.isPathnameStart()?this.changeState(f$1.PATHNAME,0):this.isSearchPrefix()?this.changeState(f$1.SEARCH,1):this.isHashPrefix()&&this.changeState(f$1.HASH,1);break;case f$1.PORT:this.isPathnameStart()?this.changeState(f$1.PATHNAME,0):this.isSearchPrefix()?this.changeState(f$1.SEARCH,1):this.isHashPrefix()&&this.changeState(f$1.HASH,1);break;case f$1.PATHNAME:this.isSearchPrefix()?this.changeState(f$1.SEARCH,1):this.isHashPrefix()&&this.changeState(f$1.HASH,1);break;case f$1.SEARCH:this.isHashPrefix()&&this.changeState(f$1.HASH,1);}}},t.changeState=function(u,D){switch(this.state){case f$1.INIT:break;case f$1.PROTOCOL:this.internalResult.protocol=this.makeComponentString();break;case f$1.AUTHORITY:break;case f$1.USERNAME:this.internalResult.username=this.makeComponentString();break;case f$1.PASSWORD:this.internalResult.password=this.makeComponentString();break;case f$1.HOSTNAME:this.internalResult.hostname=this.makeComponentString();break;case f$1.PORT:this.internalResult.port=this.makeComponentString();break;case f$1.PATHNAME:this.internalResult.pathname=this.makeComponentString();break;case f$1.SEARCH:this.internalResult.search=this.makeComponentString();break;case f$1.HASH:this.internalResult.hash=this.makeComponentString();}this.changeStateWithoutSettingComponent(u,D);},t.changeStateWithoutSettingComponent=function(u,D){this.state=u,this.componentStart=this.tokenIndex+D,this.tokenIndex+=D,this.tokenIncrement=0;},t.rewind=function(){this.tokenIndex=this.componentStart,this.tokenIncrement=0;},t.rewindAndSetState=function(u){this.rewind(),this.state=u;},t.safeToken=function(u){return u<0&&(u=this.tokenList.length-u),u<this.tokenList.length?this.tokenList[u]:this.tokenList[this.tokenList.length-1]},t.isNonSpecialPatternChar=function(u,D){var t=this.safeToken(u);return t.value===D&&("CHAR"===t.type||"ESCAPED_CHAR"===t.type||"INVALID_CHAR"===t.type)},t.isProtocolSuffix=function(){return this.isNonSpecialPatternChar(this.tokenIndex,":")},t.nextIsAuthoritySlashes=function(){return this.isNonSpecialPatternChar(this.tokenIndex+1,"/")&&this.isNonSpecialPatternChar(this.tokenIndex+2,"/")},t.isIdentityTerminator=function(){return this.isNonSpecialPatternChar(this.tokenIndex,"@")},t.isPasswordPrefix=function(){return this.isNonSpecialPatternChar(this.tokenIndex,":")},t.isPortPrefix=function(){return this.isNonSpecialPatternChar(this.tokenIndex,":")},t.isPathnameStart=function(){return this.isNonSpecialPatternChar(this.tokenIndex,"/")},t.isSearchPrefix=function(){if(this.isNonSpecialPatternChar(this.tokenIndex,"?"))return !0;if("?"!==this.tokenList[this.tokenIndex].value)return !1;var u=this.safeToken(this.tokenIndex-1);return "NAME"!==u.type&&"PATTERN"!==u.type&&"CLOSE"!==u.type&&"ASTERISK"!==u.type},t.isHashPrefix=function(){return this.isNonSpecialPatternChar(this.tokenIndex,"#")},t.isGroupOpen=function(){return "OPEN"==this.tokenList[this.tokenIndex].type},t.isGroupClose=function(){return "CLOSE"==this.tokenList[this.tokenIndex].type},t.isIPv6Open=function(){return this.isNonSpecialPatternChar(this.tokenIndex,"[")},t.isIPv6Close=function(){return this.isNonSpecialPatternChar(this.tokenIndex,"]")},t.makeComponentString=function(){var u=this.tokenList[this.tokenIndex],D=this.safeToken(this.componentStart).index;return this.input.substring(D,u.index)},t.computeShouldTreatAsStandardURL=function(){var u={};Object.assign(u,B),u.encodePart=g;var D=a(this.makeComponentString(),void 0,u);this.shouldTreatAsStandardURL=m(D);},D(u,[{key:"result",get:function(){return this.internalResult}}]),u}(),I=["protocol","username","password","hostname","port","pathname","search","hash"];function O(u,D){if("string"!=typeof u)throw new TypeError("parameter 1 is not of type 'string'.");var t=new URL(u,D);return {protocol:t.protocol.substring(0,t.protocol.length-1),username:t.username,password:t.password,hostname:t.hostname,port:t.port,pathname:t.pathname,search:""!=t.search?t.search.substring(1,t.search.length):void 0,hash:""!=t.hash?t.hash.substring(1,t.hash.length):void 0}}function H(u,D,t){var F;if("string"==typeof D.baseURL)try{F=new URL(D.baseURL),u.protocol=F.protocol?F.protocol.substring(0,F.protocol.length-1):"",u.username=F.username,u.password=F.password,u.hostname=F.hostname,u.port=F.port,u.pathname=F.pathname,u.search=F.search?F.search.substring(1,F.search.length):"",u.hash=F.hash?F.hash.substring(1,F.hash.length):"";}catch(u){throw new TypeError("invalid baseURL '"+D.baseURL+"'.")}if("string"==typeof D.protocol&&(u.protocol=function(u,D){var t;return u=(t=u).endsWith(":")?t.substr(0,t.length-":".length):t,D||""===u?u:g(u)}(D.protocol,t)),"string"==typeof D.username&&(u.username=function(u,D){if(D||""===u)return u;var t=new URL("https://example.com");return t.username=u,t.username}(D.username,t)),"string"==typeof D.password&&(u.password=function(u,D){if(D||""===u)return u;var t=new URL("https://example.com");return t.password=u,t.password}(D.password,t)),"string"==typeof D.hostname&&(u.hostname=function(u,D){return D||""===u?u:c(u)?y(u):v(u)}(D.hostname,t)),"string"==typeof D.port&&(u.port=function(u,D,t){return d(D)===u&&(u=""),t||""===u?u:R(u)}(D.port,u.protocol,t)),"string"==typeof D.pathname){if(u.pathname=D.pathname,F&&!function(u,D){return !(!u.length||"/"!==u[0]&&(!D||u.length<2||"\\"!=u[0]&&"{"!=u[0]||"/"!=u[1]))}(u.pathname,t)){var e=F.pathname.lastIndexOf("/");e>=0&&(u.pathname=F.pathname.substring(0,e+1)+u.pathname);}u.pathname=function(u,D,t){if(t||""===u)return u;if(D&&!l.includes(D))return new URL(D+":"+u).pathname;var F="/"==u[0];return u=new URL(F?u:"/-"+u,"https://example.com").pathname,F||(u=u.substring(2,u.length)),u}(u.pathname,u.protocol,t);}return "string"==typeof D.search&&(u.search=function(u,D){if(u=p(u,"?"),D||""===u)return u;var t=new URL("https://example.com");return t.search=u,t.search?t.search.substring(1,t.search.length):""}(D.search,t)),"string"==typeof D.hash&&(u.hash=function(u,D){if(u=p(u,"#"),D||""===u)return u;var t=new URL("https://example.com");return t.hash=u,t.hash?t.hash.substring(1,t.hash.length):""}(D.hash,t)),u}function N(u){return u.replace(/([+*?:{}()\\])/g,"\\$1")}function L(u,D){for(var t="[^"+(D.delimiter||"/#?").replace(/([.+*?^${}()[\]|/\\])/g,"\\$1")+"]+?",F=/(?:[\$0-9A-Z_a-z\xAA\xB5\xB7\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u0483-\u0487\u048A-\u052F\u0531-\u0556\u0559\u0560-\u0588\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u05D0-\u05EA\u05EF-\u05F2\u0610-\u061A\u0620-\u0669\u066E-\u06D3\u06D5-\u06DC\u06DF-\u06E8\u06EA-\u06FC\u06FF\u0710-\u074A\u074D-\u07B1\u07C0-\u07F5\u07FA\u07FD\u0800-\u082D\u0840-\u085B\u0860-\u086A\u08A0-\u08B4\u08B6-\u08C7\u08D3-\u08E1\u08E3-\u0963\u0966-\u096F\u0971-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BC-\u09C4\u09C7\u09C8\u09CB-\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09E6-\u09F1\u09FC\u09FE\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A59-\u0A5C\u0A5E\u0A66-\u0A75\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABC-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AD0\u0AE0-\u0AE3\u0AE6-\u0AEF\u0AF9-\u0AFF\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3C-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B55-\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B66-\u0B6F\u0B71\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD0\u0BD7\u0BE6-\u0BEF\u0C00-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58-\u0C5A\u0C60-\u0C63\u0C66-\u0C6F\u0C80-\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBC-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CDE\u0CE0-\u0CE3\u0CE6-\u0CEF\u0CF1\u0CF2\u0D00-\u0D0C\u0D0E-\u0D10\u0D12-\u0D44\u0D46-\u0D48\u0D4A-\u0D4E\u0D54-\u0D57\u0D5F-\u0D63\u0D66-\u0D6F\u0D7A-\u0D7F\u0D81-\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E01-\u0E3A\u0E40-\u0E4E\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E86-\u0E8A\u0E8C-\u0EA3\u0EA5\u0EA7-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECD\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E-\u0F47\u0F49-\u0F6C\u0F71-\u0F84\u0F86-\u0F97\u0F99-\u0FBC\u0FC6\u1000-\u1049\u1050-\u109D\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u135D-\u135F\u1369-\u1371\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176C\u176E-\u1770\u1772\u1773\u1780-\u17D3\u17D7\u17DC\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u1820-\u1878\u1880-\u18AA\u18B0-\u18F5\u1900-\u191E\u1920-\u192B\u1930-\u193B\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19DA\u1A00-\u1A1B\u1A20-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA7\u1AB0-\u1ABD\u1ABF\u1AC0\u1B00-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1BF3\u1C00-\u1C37\u1C40-\u1C49\u1C4D-\u1C7D\u1C80-\u1C88\u1C90-\u1CBA\u1CBD-\u1CBF\u1CD0-\u1CD2\u1CD4-\u1CFA\u1D00-\u1DF9\u1DFB-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u200C\u200D\u203F\u2040\u2054\u2071\u207F\u2090-\u209C\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2102\u2107\u210A-\u2113\u2115\u2118-\u211D\u2124\u2126\u2128\u212A-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D7F-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2DE0-\u2DFF\u3005-\u3007\u3021-\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u3099-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312F\u3131-\u318E\u31A0-\u31BF\u31F0-\u31FF\u3400-\u4DBF\u4E00-\u9FFC\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66F\uA674-\uA67D\uA67F-\uA6F1\uA717-\uA71F\uA722-\uA788\uA78B-\uA7BF\uA7C2-\uA7CA\uA7F5-\uA827\uA82C\uA840-\uA873\uA880-\uA8C5\uA8D0-\uA8D9\uA8E0-\uA8F7\uA8FB\uA8FD-\uA92D\uA930-\uA953\uA960-\uA97C\uA980-\uA9C0\uA9CF-\uA9D9\uA9E0-\uA9FE\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA60-\uAA76\uAA7A-\uAAC2\uAADB-\uAADD\uAAE0-\uAAEF\uAAF2-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB69\uAB70-\uABEA\uABEC\uABED\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE00-\uFE0F\uFE20-\uFE2F\uFE33\uFE34\uFE4D-\uFE4F\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF3F\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDD40-\uDD74\uDDFD\uDE80-\uDE9C\uDEA0-\uDED0\uDEE0\uDF00-\uDF1F\uDF2D-\uDF4A\uDF50-\uDF7A\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF\uDFD1-\uDFD5]|\uD801[\uDC00-\uDC9D\uDCA0-\uDCA9\uDCB0-\uDCD3\uDCD8-\uDCFB\uDD00-\uDD27\uDD30-\uDD63\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00-\uDE03\uDE05\uDE06\uDE0C-\uDE13\uDE15-\uDE17\uDE19-\uDE35\uDE38-\uDE3A\uDE3F\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE6\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2\uDD00-\uDD27\uDD30-\uDD39\uDE80-\uDEA9\uDEAB\uDEAC\uDEB0\uDEB1\uDF00-\uDF1C\uDF27\uDF30-\uDF50\uDFB0-\uDFC4\uDFE0-\uDFF6]|\uD804[\uDC00-\uDC46\uDC66-\uDC6F\uDC7F-\uDCBA\uDCD0-\uDCE8\uDCF0-\uDCF9\uDD00-\uDD34\uDD36-\uDD3F\uDD44-\uDD47\uDD50-\uDD73\uDD76\uDD80-\uDDC4\uDDC9-\uDDCC\uDDCE-\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE37\uDE3E\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEEA\uDEF0-\uDEF9\uDF00-\uDF03\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3B-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF50\uDF57\uDF5D-\uDF63\uDF66-\uDF6C\uDF70-\uDF74]|\uD805[\uDC00-\uDC4A\uDC50-\uDC59\uDC5E-\uDC61\uDC80-\uDCC5\uDCC7\uDCD0-\uDCD9\uDD80-\uDDB5\uDDB8-\uDDC0\uDDD8-\uDDDD\uDE00-\uDE40\uDE44\uDE50-\uDE59\uDE80-\uDEB8\uDEC0-\uDEC9\uDF00-\uDF1A\uDF1D-\uDF2B\uDF30-\uDF39]|\uD806[\uDC00-\uDC3A\uDCA0-\uDCE9\uDCFF-\uDD06\uDD09\uDD0C-\uDD13\uDD15\uDD16\uDD18-\uDD35\uDD37\uDD38\uDD3B-\uDD43\uDD50-\uDD59\uDDA0-\uDDA7\uDDAA-\uDDD7\uDDDA-\uDDE1\uDDE3\uDDE4\uDE00-\uDE3E\uDE47\uDE50-\uDE99\uDE9D\uDEC0-\uDEF8]|\uD807[\uDC00-\uDC08\uDC0A-\uDC36\uDC38-\uDC40\uDC50-\uDC59\uDC72-\uDC8F\uDC92-\uDCA7\uDCA9-\uDCB6\uDD00-\uDD06\uDD08\uDD09\uDD0B-\uDD36\uDD3A\uDD3C\uDD3D\uDD3F-\uDD47\uDD50-\uDD59\uDD60-\uDD65\uDD67\uDD68\uDD6A-\uDD8E\uDD90\uDD91\uDD93-\uDD98\uDDA0-\uDDA9\uDEE0-\uDEF6\uDFB0]|\uD808[\uDC00-\uDF99]|\uD809[\uDC00-\uDC6E\uDC80-\uDD43]|[\uD80C\uD81C-\uD820\uD822\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872\uD874-\uD879\uD880-\uD883][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDE60-\uDE69\uDED0-\uDEED\uDEF0-\uDEF4\uDF00-\uDF36\uDF40-\uDF43\uDF50-\uDF59\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDE40-\uDE7F\uDF00-\uDF4A\uDF4F-\uDF87\uDF8F-\uDF9F\uDFE0\uDFE1\uDFE3\uDFE4\uDFF0\uDFF1]|\uD821[\uDC00-\uDFF7]|\uD823[\uDC00-\uDCD5\uDD00-\uDD08]|\uD82C[\uDC00-\uDD1E\uDD50-\uDD52\uDD64-\uDD67\uDD70-\uDEFB]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99\uDC9D\uDC9E]|\uD834[\uDD65-\uDD69\uDD6D-\uDD72\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB\uDFCE-\uDFFF]|\uD836[\uDE00-\uDE36\uDE3B-\uDE6C\uDE75\uDE84\uDE9B-\uDE9F\uDEA1-\uDEAF]|\uD838[\uDC00-\uDC06\uDC08-\uDC18\uDC1B-\uDC21\uDC23\uDC24\uDC26-\uDC2A\uDD00-\uDD2C\uDD30-\uDD3D\uDD40-\uDD49\uDD4E\uDEC0-\uDEF9]|\uD83A[\uDC00-\uDCC4\uDCD0-\uDCD6\uDD00-\uDD4B\uDD50-\uDD59]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD83E[\uDFF0-\uDFF9]|\uD869[\uDC00-\uDEDD\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF34\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1\uDEB0-\uDFFF]|\uD87A[\uDC00-\uDFE0]|\uD87E[\uDC00-\uDE1D]|\uD884[\uDC00-\uDF4A]|\uDB40[\uDD00-\uDDEF])/,e="",C=0;C<u.length;++C){var A=u[C],E=C>0?u[C-1]:null,n=C<u.length-1?u[C+1]:null;if("string"!=typeof A)if(""!==A.pattern){var r="number"!=typeof A.name,i=void 0!==D.prefixes?D.prefixes:"./",s=""!==A.suffix||""!==A.prefix&&(1!==A.prefix.length||!i.includes(A.prefix));s||!r||A.pattern!==t||""!==A.modifier||!n||n.prefix||n.suffix||(s="string"==typeof n?F.test(n.length>0?n[0]:""):"number"==typeof n.name),!s&&""===A.prefix&&E&&"string"==typeof E&&E.length>0&&(s=i.includes(E[E.length-1])),s&&(e+="{"),e+=N(A.prefix),r&&(e+=":"+A.name),".*"===A.pattern?e+=r||E&&"string"!=typeof E&&!E.modifier&&!s&&""===A.prefix?"(.*)":"*":A.pattern===t?r||(e+="("+t+")"):e+="("+A.pattern+")",A.pattern===t&&r&&""!==A.suffix&&F.test(A.suffix[0])&&(e+="\\"),e+=N(A.suffix),s&&(e+="}"),e+=A.modifier;}else {if(""===A.modifier){e+=N(A.prefix);continue}e+="{"+N(A.prefix)+"}"+A.modifier;}else e+=N(A);}return e}var U=function(){function u(u,D){void 0===u&&(u={}),this.pattern=void 0,this.regexp={},this.keys={},this.component_pattern={};try{if("string"==typeof u){var t=new b(u);if(t.parse(),u=t.result,D){if("string"!=typeof D)throw new TypeError("'baseURL' parameter is not of type 'string'.");u.baseURL=D;}else if("string"!=typeof u.protocol)throw new TypeError("A base URL must be provided for a relative constructor string.")}else if(D)throw new TypeError("parameter 1 is not of type 'string'.");if(!u||"object"!=typeof u)throw new TypeError("parameter 1 is not of type 'string' and cannot convert to dictionary.");var e;this.pattern=H({pathname:"*",protocol:"*",username:"*",password:"*",hostname:"*",port:"*",search:"*",hash:"*"},u,!0),d(this.pattern.protocol)===this.pattern.port&&(this.pattern.port="");for(var C,A=F$1(I);!(C=A()).done;)if((e=C.value)in this.pattern){var E={},r=this.pattern[e];switch(this.keys[e]=[],e){case"protocol":Object.assign(E,B),E.encodePart=g;break;case"username":Object.assign(E,B),E.encodePart=x;break;case"password":Object.assign(E,B),E.encodePart=S$1;break;case"hostname":Object.assign(E,o),E.encodePart=c(r)?y:v;break;case"port":Object.assign(E,B),E.encodePart=R;break;case"pathname":m(this.regexp.protocol)?(Object.assign(E,h),E.encodePart=k):(Object.assign(E,B),E.encodePart=w);break;case"search":Object.assign(E,B),E.encodePart=P;break;case"hash":Object.assign(E,B),E.encodePart=T;}try{var i=n(r,E);this.regexp[e]=s$1(i,this.keys[e],E),this.component_pattern[e]=L(i,E);}catch(u){throw new TypeError("invalid "+e+" pattern '"+this.pattern[e]+"'.")}}}catch(u){throw new TypeError("Failed to construct 'URLPattern': "+u.message)}}var t=u.prototype;return t.test=function(u,D){void 0===u&&(u={});var t,F={pathname:"",protocol:"",username:"",password:"",hostname:"",port:"",search:"",hash:""};if("string"!=typeof u&&D)throw new TypeError("parameter 1 is not of type 'string'.");if(void 0===u)return !1;try{F=H(F,"object"==typeof u?u:O(u,D),!1);}catch(u){return !1}for(t in this.pattern)if(!this.regexp[t].exec(F[t]))return !1;return !0},t.exec=function(u,D){void 0===u&&(u={});var t={pathname:"",protocol:"",username:"",password:"",hostname:"",port:"",search:"",hash:""};if("string"!=typeof u&&D)throw new TypeError("parameter 1 is not of type 'string'.");if(void 0!==u){try{t=H(t,"object"==typeof u?u:O(u,D),!1);}catch(u){return null}var e,C={};for(e in C.inputs=D?[u,D]:[u],this.pattern){var A=this.regexp[e].exec(t[e]);if(!A)return null;for(var E,n={},r=F$1(this.keys[e].entries());!(E=r()).done;){var i=E.value,s=i[1];"string"!=typeof s.name&&"number"!=typeof s.name||(n[s.name]=A[i[0]+1]||"");}C[e]={input:t[e]||"",groups:n};}return C}},D(u,[{key:"protocol",get:function(){return this.component_pattern.protocol}},{key:"username",get:function(){return this.component_pattern.username}},{key:"password",get:function(){return this.component_pattern.password}},{key:"hostname",get:function(){return this.component_pattern.hostname}},{key:"port",get:function(){return this.component_pattern.port}},{key:"pathname",get:function(){return this.component_pattern.pathname}},{key:"search",get:function(){return this.component_pattern.search}},{key:"hash",get:function(){return this.component_pattern.hash}}]),u}();
+
+const INTERNAL = { tick: 0, pool: new Map };
+function setTimeout(callback, delay = 0, ...args) {
+    const func = __function_bind(callback, globalThis);
+    const tick = ++INTERNAL.tick;
+    const timeout = setTimeout$1(func, delay, ...args);
+    INTERNAL.pool.set(tick, timeout);
+    return tick;
+}
+function clearTimeout(timeoutId) {
+    const timeout = INTERNAL.pool.get(timeoutId);
+    if (timeout) {
+        clearTimeout$1(timeout);
+        INTERNAL.pool.delete(timeoutId);
+    }
+}
+
+const PRIMITIVE  = 0;
+const ARRAY      = 1;
+const OBJECT     = 2;
+const DATE       = 3;
+const REGEXP     = 4;
+const MAP        = 5;
+const SET        = 6;
+const ERROR      = 7;
+const BIGINT     = 8;
+// export const SYMBOL = 9;
+
+const env = typeof self === 'object' ? self : globalThis;
+
+const deserializer = ($, _) => {
+  const as = (out, index) => {
+    $.set(index, out);
+    return out;
+  };
+
+  const unpair = index => {
+    if ($.has(index))
+      return $.get(index);
+
+    const [type, value] = _[index];
+    switch (type) {
+      case PRIMITIVE:
+        return as(value, index);
+      case ARRAY: {
+        const arr = as([], index);
+        for (const index of value)
+          arr.push(unpair(index));
+        return arr;
+      }
+      case OBJECT: {
+        const object = as({}, index);
+        for (const [key, index] of value)
+          object[unpair(key)] = unpair(index);
+        return object;
+      }
+      case DATE:
+        return as(new Date(value), index);
+      case REGEXP: {
+        const {source, flags} = value;
+        return as(new RegExp(source, flags), index);
+      }
+      case MAP: {
+        const map = as(new Map, index);
+        for (const [key, index] of value)
+          map.set(unpair(key), unpair(index));
+        return map;
+      }
+      case SET: {
+        const set = as(new Set, index);
+        for (const index of value)
+          set.add(unpair(index));
+        return set;
+      }
+      case ERROR: {
+        const {name, message} = value;
+        return as(new env[name](message), index);
+      }
+      case BIGINT:
+        return as(BigInt(value), index);
+      case 'BigInt':
+        return as(Object(BigInt(value)), index);
+    }
+    return as(new env[type](value), index);
+  };
+
+  return unpair;
+};
+
+/**
+ * @typedef {Array<string,any>} Record a type representation
+ */
+
+/**
+ * Returns a deserialized value from a serialized array of Records.
+ * @param {Record[]} serialized a previously serialized value.
+ * @returns {any}
+ */
+const deserialize = serialized => deserializer(new Map, serialized)(0);
+
+const EMPTY = '';
+
+const {toString} = {};
+const {keys} = Object;
+
+const typeOf = value => {
+  const type = typeof value;
+  if (type !== 'object' || !value)
+    return [PRIMITIVE, type];
+
+  const asString = toString.call(value).slice(8, -1);
+  switch (asString) {
+    case 'Array':
+      return [ARRAY, EMPTY];
+    case 'Object':
+      return [OBJECT, EMPTY];
+    case 'Date':
+      return [DATE, EMPTY];
+    case 'RegExp':
+      return [REGEXP, EMPTY];
+    case 'Map':
+      return [MAP, EMPTY];
+    case 'Set':
+      return [SET, EMPTY];
+  }
+
+  if (asString.includes('Array'))
+    return [ARRAY, asString];
+
+  if (asString.includes('Error'))
+    return [ERROR, asString];
+
+  return [OBJECT, asString];
+};
+
+const shouldSkip = ([TYPE, type]) => (
+  TYPE === PRIMITIVE &&
+  (type === 'function' || type === 'symbol')
+);
+
+const serializer = (strict, json, $, _) => {
+
+  const as = (out, value) => {
+    const index = _.push(out) - 1;
+    $.set(value, index);
+    return index;
+  };
+
+  const pair = value => {
+    if ($.has(value))
+      return $.get(value);
+
+    let [TYPE, type] = typeOf(value);
+    switch (TYPE) {
+      case PRIMITIVE: {
+        let entry = value;
+        switch (type) {
+          case 'bigint':
+            TYPE = BIGINT;
+            entry = value.toString();
+            break;
+          case 'function':
+          case 'symbol':
+            if (strict)
+              throw new TypeError('unable to serialize ' + type);
+            entry = null;
+            break;
+        }
+        return as([TYPE, entry], value);
+      }
+      case ARRAY: {
+        if (type)
+          return as([type, [...value]], value);
+  
+        const arr = [];
+        const index = as([TYPE, arr], value);
+        for (const entry of value)
+          arr.push(pair(entry));
+        return index;
+      }
+      case OBJECT: {
+        if (type) {
+          switch (type) {
+            case 'BigInt':
+              return as([type, value.toString()], value);
+            case 'Boolean':
+            case 'Number':
+            case 'String':
+              return as([type, value.valueOf()], value);
+          }
+        }
+
+        if (json && ('toJSON' in value))
+          return pair(value.toJSON());
+
+        const entries = [];
+        const index = as([TYPE, entries], value);
+        for (const key of keys(value)) {
+          if (strict || !shouldSkip(typeOf(value[key])))
+            entries.push([pair(key), pair(value[key])]);
+        }
+        return index;
+      }
+      case DATE:
+        return as([TYPE, value.toISOString()], value);
+      case REGEXP: {
+        const {source, flags} = value;
+        return as([TYPE, {source, flags}], value);
+      }
+      case MAP: {
+        const entries = [];
+        const index = as([TYPE, entries], value);
+        for (const [key, entry] of value) {
+          if (strict || !(shouldSkip(typeOf(key)) || shouldSkip(typeOf(entry))))
+            entries.push([pair(key), pair(entry)]);
+        }
+        return index;
+      }
+      case SET: {
+        const entries = [];
+        const index = as([TYPE, entries], value);
+        for (const entry of value) {
+          if (strict || !shouldSkip(typeOf(entry)))
+            entries.push(pair(entry));
+        }
+        return index;
+      }
+    }
+
+    const {message} = value;
+    return as([TYPE, {name: type, message}], value);
+  };
+
+  return pair;
+};
+
+/**
+ * @typedef {Array<string,any>} Record a type representation
+ */
+
+/**
+ * Returns an array of serialized Records.
+ * @param {any} value a serializable value.
+ * @param {{lossy?: boolean}?} options an object with a `lossy` property that,
+ *  if `true`, will not throw errors on incompatible types, and behave more
+ *  like JSON stringify would behave. Symbol and Function will be discarded.
+ * @returns {Record[]}
+ */
+ const serialize = (value, {json, lossy} = {}) => {
+  const _ = [];
+  return serializer(!(json || lossy), !!json, new Map, _)(value), _;
+};
+
+var structuredClone = (any, options) => deserialize(serialize(any, options));
+
+class ImageData {
+    constructor(arg0, arg1, ...args) {
+        if (arguments.length < 2)
+            throw new TypeError(`Failed to construct 'ImageData': 2 arguments required.`);
+        /** Whether Uint8ClampedArray data is provided. */
+        const hasData = __object_isPrototypeOf(Uint8ClampedArray.prototype, arg0);
+        /** Image data, either provided or calculated. */
+        const d = hasData ? arg0 : new Uint8ClampedArray(asNumber(arg0, 'width') * asNumber(arg1, 'height') * 4);
+        /** Image width. */
+        const w = asNumber(hasData ? arg1 : arg0, 'width');
+        /** Image height. */
+        const h = d.length / w / 4;
+        /** Image color space. */
+        const c = String(Object(hasData ? args[1] : args[0]).colorSpace || 'srgb');
+        // throw if a provided height does not match the calculated height
+        if (args.length && asNumber(args[0], 'height') !== h)
+            throw new DOMException('height is not equal to (4 * width * height)', 'IndexSizeError');
+        // throw if a provided colorspace does not match a known colorspace
+        if (c !== 'srgb' && c !== 'rec2020' && c !== 'display-p3')
+            throw new TypeError('colorSpace is not known value');
+        Object.defineProperty(this, 'data', { configurable: true, enumerable: true, value: d });
+        INTERNALS$3.set(this, { width: w, height: h, colorSpace: c });
+    }
+    get data() {
+        internalsOf(this, 'ImageData', 'data');
+        return Object.getOwnPropertyDescriptor(this, 'data').value;
+    }
+    get width() {
+        return internalsOf(this, 'ImageData', 'width').width;
+    }
+    get height() {
+        return internalsOf(this, 'ImageData', 'height').height;
+    }
+}
+allowStringTag(ImageData);
+/** Returns a coerced number, optionally throwing if the number is zero-ish. */
+const asNumber = (value, axis) => {
+    value = Number(value) || 0;
+    if (value === 0)
+        throw new TypeError(`The source ${axis} is zero or not a number.`);
+    return value;
+};
+
+class CanvasRenderingContext2D {
+    get canvas() {
+        return internalsOf(this, 'CanvasRenderingContext2D', 'canvas').canvas;
+    }
+    get direction() {
+        return internalsOf(this, 'CanvasRenderingContext2D', 'direction').direction;
+    }
+    get fillStyle() {
+        return internalsOf(this, 'CanvasRenderingContext2D', 'fillStyle').fillStyle;
+    }
+    get filter() {
+        return internalsOf(this, 'CanvasRenderingContext2D', 'filter').filter;
+    }
+    get globalAlpha() {
+        return internalsOf(this, 'CanvasRenderingContext2D', 'globalAlpha').globalAlpha;
+    }
+    get globalCompositeOperation() {
+        return internalsOf(this, 'CanvasRenderingContext2D', 'globalCompositeOperation').globalCompositeOperation;
+    }
+    get font() {
+        return internalsOf(this, 'CanvasRenderingContext2D', 'font').font;
+    }
+    get imageSmoothingEnabled() {
+        return internalsOf(this, 'CanvasRenderingContext2D', 'imageSmoothingEnabled').imageSmoothingEnabled;
+    }
+    get imageSmoothingQuality() {
+        return internalsOf(this, 'CanvasRenderingContext2D', 'imageSmoothingQuality').imageSmoothingQuality;
+    }
+    get lineCap() {
+        return internalsOf(this, 'CanvasRenderingContext2D', 'lineCap').lineCap;
+    }
+    get lineDashOffset() {
+        return internalsOf(this, 'CanvasRenderingContext2D', 'lineDashOffset').lineDashOffset;
+    }
+    get lineJoin() {
+        return internalsOf(this, 'CanvasRenderingContext2D', 'lineJoin').lineJoin;
+    }
+    get lineWidth() {
+        return internalsOf(this, 'CanvasRenderingContext2D', 'lineWidth').lineWidth;
+    }
+    get miterLimit() {
+        return internalsOf(this, 'CanvasRenderingContext2D', 'miterLimit').miterLimit;
+    }
+    get strokeStyle() {
+        return internalsOf(this, 'CanvasRenderingContext2D', 'strokeStyle').strokeStyle;
+    }
+    get shadowOffsetX() {
+        return internalsOf(this, 'CanvasRenderingContext2D', 'shadowOffsetX').shadowOffsetX;
+    }
+    get shadowOffsetY() {
+        return internalsOf(this, 'CanvasRenderingContext2D', 'shadowOffsetY').shadowOffsetY;
+    }
+    get shadowBlur() {
+        return internalsOf(this, 'CanvasRenderingContext2D', 'shadowBlur').shadowBlur;
+    }
+    get shadowColor() {
+        return internalsOf(this, 'CanvasRenderingContext2D', 'shadowColor').shadowColor;
+    }
+    get textAlign() {
+        return internalsOf(this, 'CanvasRenderingContext2D', 'textAlign').textAlign;
+    }
+    get textBaseline() {
+        return internalsOf(this, 'CanvasRenderingContext2D', 'textBaseline').textBaseline;
+    }
+    arc() { }
+    arcTo() { }
+    beginPath() { }
+    bezierCurveTo() { }
+    clearRect() { }
+    clip() { }
+    closePath() { }
+    createImageData(arg0, arg1) {
+        /** Whether ImageData is provided. */
+        const hasData = __object_isPrototypeOf(ImageData.prototype, arg0);
+        const w = hasData ? arg0.width : arg0;
+        const h = hasData ? arg0.height : arg1;
+        const d = hasData ? arg0.data : new Uint8ClampedArray(w * h * 4);
+        return new ImageData(d, w, h);
+    }
+    createLinearGradient() { }
+    createPattern() { }
+    createRadialGradient() { }
+    drawFocusIfNeeded() { }
+    drawImage() { }
+    ellipse() { }
+    fill() { }
+    fillRect() { }
+    fillText() { }
+    getContextAttributes() { }
+    getImageData() { }
+    getLineDash() { }
+    getTransform() { }
+    isPointInPath() { }
+    isPointInStroke() { }
+    lineTo() { }
+    measureText() { }
+    moveTo() { }
+    putImageData() { }
+    quadraticCurveTo() { }
+    rect() { }
+    resetTransform() { }
+    restore() { }
+    rotate() { }
+    save() { }
+    scale() { }
+    setLineDash() { }
+    setTransform() { }
+    stroke() { }
+    strokeRect() { }
+    strokeText() { }
+    transform() { }
+    translate() { }
+}
+allowStringTag(CanvasRenderingContext2D);
+const __createCanvasRenderingContext2D = (canvas) => {
+    const renderingContext2D = Object.create(CanvasRenderingContext2D.prototype);
+    INTERNALS$3.set(renderingContext2D, {
+        canvas,
+        direction: 'inherit',
+        fillStyle: '#000',
+        filter: 'none',
+        font: '10px sans-serif',
+        globalAlpha: 0,
+        globalCompositeOperation: 'source-over',
+        imageSmoothingEnabled: false,
+        imageSmoothingQuality: 'high',
+        lineCap: 'butt',
+        lineDashOffset: 0.0,
+        lineJoin: 'miter',
+        lineWidth: 1.0,
+        miterLimit: 10.0,
+        shadowBlur: 0,
+        shadowColor: '#000',
+        shadowOffsetX: 0,
+        shadowOffsetY: 0,
+        strokeStyle: '#000',
+        textAlign: 'start',
+        textBaseline: 'alphabetic',
+    });
+    return renderingContext2D;
+};
+
+class StyleSheet {
+}
+class CSSStyleSheet extends StyleSheet {
+    async replace(text) {
+        return new CSSStyleSheet();
+    }
+    replaceSync(text) {
+        return new CSSStyleSheet();
+    }
+    get cssRules() {
+        return [];
+    }
+}
+allowStringTag(StyleSheet);
+allowStringTag(CSSStyleSheet);
+
+class CustomElementRegistry {
+    /** Defines a new custom element using the given tag name and HTMLElement constructor. */
+    define(name, constructor, options) {
+        const internals = internalsOf(this, 'CustomElementRegistry', 'define');
+        name = String(name);
+        if (/[A-Z]/.test(name))
+            throw new SyntaxError('Custom element name cannot contain an uppercase ASCII letter');
+        if (!/^[a-z]/.test(name))
+            throw new SyntaxError('Custom element name must have a lowercase ASCII letter as its first character');
+        if (!/-/.test(name))
+            throw new SyntaxError('Custom element name must contain a hyphen');
+        internals.constructorByName.set(name, constructor);
+        internals.nameByConstructor.set(constructor, name);
+    }
+    /** Returns the constructor associated with the given tag name. */
+    get(name) {
+        const internals = internalsOf(this, 'CustomElementRegistry', 'get');
+        name = String(name).toLowerCase();
+        return internals.constructorByName.get(name);
+    }
+    getName(constructor) {
+        const internals = internalsOf(this, 'CustomElementRegistry', 'getName');
+        return internals.nameByConstructor.get(constructor);
+    }
+}
+allowStringTag(CustomElementRegistry);
+const initCustomElementRegistry = (target, exclude) => {
+    if (exclude.has('customElements'))
+        return;
+    const CustomElementRegistry = target.CustomElementRegistry || globalThis.CustomElementRegistry;
+    const customElements = target.customElements = Object.create(CustomElementRegistry.prototype);
+    INTERNALS$3.set(customElements, {
+        constructorByName: new Map,
+        nameByConstructor: new Map,
+    });
+};
+
+class Element extends Node {
+    hasAttribute(name) {
+        return false;
+    }
+    getAttribute(name) {
+        return null;
+    }
+    setAttribute(name, value) {
+    }
+    removeAttribute(name) {
+    }
+    attachShadow(init) {
+        if (arguments.length < 1)
+            throw new TypeError(`Failed to execute 'attachShadow' on 'Element': 1 argument required, but only 0 present.`);
+        if (init !== Object(init))
+            throw new TypeError(`Failed to execute 'attachShadow' on 'Element': The provided value is not of type 'ShadowRootInit'.`);
+        if (init.mode !== 'open' && init.mode !== 'closed')
+            throw new TypeError(`Failed to execute 'attachShadow' on 'Element': Failed to read the 'mode' property from 'ShadowRootInit': The provided value '${init.mode}' is not a valid enum value of type ShadowRootMode.`);
+        const internals = internalsOf(this, 'Element', 'attachShadow');
+        if (internals.shadowRoot)
+            throw new Error('The operation is not supported.');
+        internals.shadowInit = internals.shadowInit || {
+            mode: init.mode,
+            delegatesFocus: Boolean(init.delegatesFocus),
+        };
+        internals.shadowRoot = internals.shadowRoot || (/^open$/.test(internals.shadowInit.mode) ? Object.setPrototypeOf(new EventTarget(), ShadowRoot.prototype) : null);
+        return internals.shadowRoot;
+    }
+    get assignedSlot() {
+        return null;
+    }
+    get innerHTML() {
+        internalsOf(this, 'Element', 'innerHTML');
+        return '';
+    }
+    set innerHTML(value) {
+        internalsOf(this, 'Element', 'innerHTML');
+    }
+    get shadowRoot() {
+        const internals = internalsOf(this, 'Element', 'shadowRoot');
+        return Object(internals.shadowInit).mode === 'open' ? internals.shadowRoot : null;
+    }
+    get localName() {
+        return internalsOf(this, 'Element', 'localName').localName;
+    }
+    get nodeName() {
+        return internalsOf(this, 'Element', 'nodeName').localName.toUpperCase();
+    }
+    get tagName() {
+        return internalsOf(this, 'Element', 'tagName').localName.toUpperCase();
+    }
+}
+class HTMLElement extends Element {
+}
+class HTMLBodyElement extends HTMLElement {
+}
+class HTMLDivElement extends HTMLElement {
+}
+class HTMLHeadElement extends HTMLElement {
+}
+class HTMLHtmlElement extends HTMLElement {
+}
+class HTMLSpanElement extends HTMLElement {
+}
+class HTMLStyleElement extends HTMLElement {
+}
+class HTMLTemplateElement extends HTMLElement {
+}
+class HTMLUnknownElement extends HTMLElement {
+}
+allowStringTag(Element);
+allowStringTag(HTMLElement);
+allowStringTag(HTMLBodyElement);
+allowStringTag(HTMLDivElement);
+allowStringTag(HTMLHeadElement);
+allowStringTag(HTMLHtmlElement);
+allowStringTag(HTMLSpanElement);
+allowStringTag(HTMLStyleElement);
+allowStringTag(HTMLTemplateElement);
+allowStringTag(HTMLUnknownElement);
+
+class Document extends Node {
+    createElement(name) {
+        const internals = internalsOf(this, 'Document', 'createElement');
+        const customElementInternals = INTERNALS$3.get(internals.target.customElements);
+        name = String(name).toLowerCase();
+        const TypeOfHTMLElement = internals.constructorByName.get(name) || (customElementInternals && customElementInternals.constructorByName.get(name)) || HTMLUnknownElement;
+        const element = Object.setPrototypeOf(new EventTarget(), TypeOfHTMLElement.prototype);
+        INTERNALS$3.set(element, {
+            attributes: {},
+            localName: name,
+            ownerDocument: this,
+            shadowInit: null,
+            shadowRoot: null,
+        });
+        return element;
+    }
+    createNodeIterator(root, whatToShow = NodeFilter.SHOW_ALL, filter) {
+        const target = Object.create(NodeIterator.prototype);
+        INTERNALS$3.set(target, { filter, pointerBeforeReferenceNode: false, referenceNode: root, root, whatToShow });
+        return target;
+    }
+    createTextNode(data) {
+        return new Text(data);
+    }
+    createTreeWalker(root, whatToShow = NodeFilter.SHOW_ALL, filter, expandEntityReferences) {
+        const target = Object.create(TreeWalker.prototype);
+        INTERNALS$3.set(target, { filter, currentNode: root, root, whatToShow });
+        return target;
+    }
+    get adoptedStyleSheets() {
+        return [];
+    }
+    get styleSheets() {
+        return [];
+    }
+}
+class HTMLDocument extends Document {
+}
+allowStringTag(Document);
+allowStringTag(HTMLDocument);
+const initDocument = (target, exclude) => {
+    if (exclude.has('document'))
+        return;
+    const EventTarget = target.EventTarget || globalThis.EventTarget;
+    const HTMLDocument = target.HTMLDocument || globalThis.HTMLDocument;
+    const document = target.document = Object.setPrototypeOf(new EventTarget(), HTMLDocument.prototype);
+    INTERNALS$3.set(document, {
+        target,
+        constructorByName: new Map([
+            ['body', target.HTMLBodyElement],
+            ['canvas', target.HTMLCanvasElement],
+            ['div', target.HTMLDivElement],
+            ['head', target.HTMLHeadElement],
+            ['html', target.HTMLHtmlElement],
+            ['img', target.HTMLImageElement],
+            ['span', target.HTMLSpanElement],
+            ['style', target.HTMLStyleElement],
+        ]),
+        nameByConstructor: new Map,
+    });
+    const initElement = (name, Class) => {
+        const target = Object.setPrototypeOf(new EventTarget(), Class.prototype);
+        INTERNALS$3.set(target, {
+            attributes: {},
+            localName: name,
+            ownerDocument: document,
+            shadowRoot: null,
+            shadowInit: null,
+        });
+        return target;
+    };
+    document.body = initElement('body', target.HTMLBodyElement);
+    document.head = initElement('head', target.HTMLHeadElement);
+    document.documentElement = initElement('html', target.HTMLHtmlElement);
+};
+
+class HTMLCanvasElement extends HTMLElement {
+    get height() {
+        return internalsOf(this, 'HTMLCanvasElement', 'height').height;
+    }
+    set height(value) {
+        internalsOf(this, 'HTMLCanvasElement', 'height').height = Number(value) || 0;
+    }
+    get width() {
+        return internalsOf(this, 'HTMLCanvasElement', 'width').width;
+    }
+    set width(value) {
+        internalsOf(this, 'HTMLCanvasElement', 'width').width = Number(value) || 0;
+    }
+    captureStream() {
+        return null;
+    }
+    getContext(contextType) {
+        const internals = internalsOf(this, 'HTMLCanvasElement', 'getContext');
+        switch (contextType) {
+            case '2d':
+                if (internals.renderingContext2D)
+                    return internals.renderingContext2D;
+                internals.renderingContext2D = __createCanvasRenderingContext2D(this);
+                return internals.renderingContext2D;
+            default:
+                return null;
+        }
+    }
+    toBlob() { }
+    toDataURL() { }
+    transferControlToOffscreen() { }
+}
+allowStringTag(HTMLCanvasElement);
+
+class HTMLImageElement extends HTMLElement {
+    get src() {
+        return internalsOf(this, 'HTMLImageElement', 'src').src;
+    }
+    set src(value) {
+        const internals = internalsOf(this, 'HTMLImageElement', 'src');
+        internals.src = String(value);
+    }
+}
+allowStringTag(HTMLImageElement);
+
+function Image() {
+    // @ts-ignore
+    INTERNALS$3.set(this, {
+        attributes: {},
+        localName: 'img',
+        innerHTML: '',
+        shadowRoot: null,
+        shadowInit: null,
+    });
+}
+Image.prototype = HTMLImageElement.prototype;
+
+class IntersectionObserver {
+    disconnect() { }
+    observe() { }
+    takeRecords() {
+        return [];
+    }
+    unobserve() { }
+}
+class MutationObserver {
+    disconnect() { }
+    observe() { }
+    takeRecords() {
+        return [];
+    }
+    unobserve() { }
+}
+class ResizeObserver {
+    disconnect() { }
+    observe() { }
+    takeRecords() {
+        return [];
+    }
+    unobserve() { }
+}
+allowStringTag(MutationObserver);
+allowStringTag(IntersectionObserver);
+allowStringTag(ResizeObserver);
+
+class MediaQueryList extends EventTarget {
+    get matches() {
+        return internalsOf(this, 'MediaQueryList', 'matches').matches;
+    }
+    get media() {
+        return internalsOf(this, 'MediaQueryList', 'media').media;
+    }
+}
+allowStringTag(MediaQueryList);
+const initMediaQueryList = (target, exclude) => {
+    if (exclude.has('MediaQueryList') || exclude.has('matchMedia'))
+        return;
+    const EventTarget = target.EventTarget || globalThis.EventTarget;
+    const MediaQueryList = target.MediaQueryList || globalThis.MediaQueryList;
+    target.matchMedia = function matchMedia(media) {
+        const mql = Object.setPrototypeOf(new EventTarget(), MediaQueryList.prototype);
+        INTERNALS$3.set(mql, {
+            matches: false,
+            media,
+        });
+        return mql;
+    };
+};
+
+class OffscreenCanvas extends EventTarget {
+    constructor(width, height) {
+        super();
+        if (arguments.length < 2)
+            throw new TypeError(`Failed to construct 'OffscreenCanvas': 2 arguments required.`);
+        width = Number(width) || 0;
+        height = Number(height) || 0;
+        INTERNALS$3.set(this, { width, height });
+    }
+    get height() {
+        return internalsOf(this, 'OffscreenCanvas', 'height').height;
+    }
+    set height(value) {
+        internalsOf(this, 'OffscreenCanvas', 'height').height = Number(value) || 0;
+    }
+    get width() {
+        return internalsOf(this, 'OffscreenCanvas', 'width').width;
+    }
+    set width(value) {
+        internalsOf(this, 'OffscreenCanvas', 'width').width = Number(value) || 0;
+    }
+    getContext(contextType) {
+        const internals = internalsOf(this, 'HTMLCanvasElement', 'getContext');
+        switch (contextType) {
+            case '2d':
+                if (internals.renderingContext2D)
+                    return internals.renderingContext2D;
+                internals.renderingContext2D = __createCanvasRenderingContext2D(this);
+                return internals.renderingContext2D;
+            default:
+                return null;
+        }
+    }
+    convertToBlob(options) {
+        options = Object(options);
+        Number(options.quality) || 0;
+        const type = getImageType(String(options.type).trim().toLowerCase());
+        return Promise.resolve(new Blob([], { type }));
+    }
+}
+allowStringTag(OffscreenCanvas);
+const getImageType = (type) => type === 'image/avif' || type === 'image/jpeg' || type === 'image/png' || type === 'image/webp' ? type : 'image/png';
+
+class Storage {
+    clear() {
+        internalsOf(this, 'Storage', 'clear').storage.clear();
+    }
+    getItem(key) {
+        return getStringOrNull(internalsOf(this, 'Storage', 'getItem').storage.get(String(key)));
+    }
+    key(index) {
+        return getStringOrNull([...internalsOf(this, 'Storage', 'key').storage.keys()][Number(index) || 0]);
+    }
+    removeItem(key) {
+        internalsOf(this, 'Storage', 'getItem').storage.delete(String(key));
+    }
+    setItem(key, value) {
+        internalsOf(this, 'Storage', 'getItem').storage.set(String(key), String(value));
+    }
+    get length() {
+        return internalsOf(this, 'Storage', 'size').storage.size;
+    }
+}
+const getStringOrNull = (value) => typeof value === 'string' ? value : null;
+const initStorage = (target, exclude) => {
+    if (exclude.has('Storage') || exclude.has('localStorage'))
+        return;
+    target.localStorage = Object.create(Storage.prototype);
+    const storageInternals = new Map();
+    INTERNALS$3.set(target.localStorage, {
+        storage: storageInternals
+    });
+};
+
+class Window extends EventTarget {
+    get self() {
+        return this;
+    }
+    get top() {
+        return this;
+    }
+    get window() {
+        return this;
+    }
+    get innerHeight() {
+        return 0;
+    }
+    get innerWidth() {
+        return 0;
+    }
+    get scrollX() {
+        return 0;
+    }
+    get scrollY() {
+        return 0;
+    }
+}
+allowStringTag(Window);
+const initWindow = (target, exclude) => {
+    if (exclude.has('Window') || exclude.has('window'))
+        return;
+    target.window = target;
+};
+
+function alert(...messages) {
+    console.log(...messages);
+}
+
+const hasOwn = {
+    hasOwn(instance, property) {
+        return __object_hasOwnProperty(instance, property);
+    }
+}.hasOwn;
+const initObject = (target, exclude) => {
+    if (exclude.has('Object') || exclude.has('object') || exclude.has('hasOwn'))
+        return;
+    const Class = target.Object || globalThis.Object;
+    Object.defineProperty(Class, 'hasOwn', {
+        value: hasOwn,
+        writable: true,
+        enumerable: false,
+        configurable: true
+    });
+};
+
+const any = {
+    async any(iterable) {
+        return Promise.all([...iterable].map(promise => {
+            return new Promise((resolve, reject) => Promise.resolve(promise).then(reject, resolve));
+        })).then(errors => Promise.reject(errors), value => Promise.resolve(value));
+    }
+}.any;
+const initPromise = (target, exclude) => {
+    if (exclude.has('Promise') || exclude.has('any'))
+        return;
+    const Class = target.Promise || globalThis.Promise;
+    if (!Class.any)
+        Object.defineProperty(Class, 'any', {
+            value: any,
+            writable: true,
+            enumerable: false,
+            configurable: true
+        });
+};
+
+const at = {
+    at(index) {
+        index = Math.trunc(index) || 0;
+        if (index < 0)
+            index += this.length;
+        if (index < 0 || index >= this.length)
+            return undefined;
+        return this[index];
+    }
+}.at;
+const initRelativeIndexingMethod = (target, exclude) => {
+    if (exclude.has('at'))
+        return;
+    const Classes = [];
+    if (!exclude.has('TypedArray'))
+        Classes.push(Object.getPrototypeOf(target.Int8Array || globalThis.Int8Array));
+    if (!exclude.has('Array'))
+        Classes.push(target.Array || globalThis.Array);
+    if (!exclude.has('String'))
+        Classes.push(target.String || globalThis.String);
+    for (const Class of Classes) {
+        if (!Class.prototype.at)
+            Object.defineProperty(Class.prototype, 'at', {
+                value: at,
+                writable: true,
+                enumerable: false,
+                configurable: true
+            });
+    }
+};
+
+const replaceAll = {
+    replaceAll(searchValue, replaceValue) {
+        return __object_isPrototypeOf(RegExp.prototype, searchValue)
+            ? this.replace(searchValue, replaceValue)
+            : this.replace(new RegExp(__string_escapeRegExp(searchValue), 'g'), replaceValue);
+    }
+}.replaceAll;
+const initString = (target, exclude) => {
+    if (exclude.has('String') || exclude.has('replaceAll'))
+        return;
+    const Class = target.String || globalThis.String;
+    if (!Class.prototype.replaceAll)
+        Object.defineProperty(Class.prototype, 'replaceAll', {
+            value: replaceAll,
+            writable: true,
+            enumerable: false,
+            configurable: true
+        });
+};
+
+const exclusionsForHTMLElement = ['CustomElementsRegistry', 'HTMLElement', 'HTMLBodyElement', 'HTMLCanvasElement', 'HTMLDivElement', 'HTMLHeadElement', 'HTMLHtmlElement', 'HTMLImageElement', 'HTMLStyleElement', 'HTMLTemplateElement', 'HTMLUnknownElement', 'Image'];
+const exclusionsForElement = ['Element', ...exclusionsForHTMLElement];
+const exclusionsForDocument = ['CustomElementsRegistry', 'Document', 'HTMLDocument', 'document', 'customElements'];
+const exclusionsForNode = ['Node', 'DocumentFragment', 'ShadowRoot', ...exclusionsForDocument, ...exclusionsForElement];
+const exclusionsForEventTarget = ['AbortSignal', 'Event', 'CustomEvent', 'EventTarget', 'OffscreenCanvas', 'MediaQueryList', 'Window', ...exclusionsForNode];
+const exclusionsForEvent = ['AbortSignal', 'Event', 'CustomEvent', 'EventTarget', 'MediaQueryList', 'OffscreenCanvas', 'Window', ...exclusionsForNode];
+const exclusions = {
+    'Blob+': ['Blob', 'File'],
+    'Document+': exclusionsForDocument,
+    'Element+': exclusionsForElement,
+    'Event+': exclusionsForEvent,
+    'EventTarget+': exclusionsForEventTarget,
+    'HTMLElement+': exclusionsForHTMLElement,
+    'Node+': exclusionsForNode,
+    'StyleSheet+': ['StyleSheet', 'CSSStyleSheet'],
+};
+
+const inheritence = {
+    CSSStyleSheet: 'StyleSheet',
+    CustomEvent: 'Event',
+    DOMException: 'Error',
+    Document: 'Node',
+    DocumentFragment: 'Node',
+    Element: 'Node',
+    File: 'Blob',
+    HTMLDocument: 'Document',
+    HTMLElement: 'Element',
+    HTMLBodyElement: 'HTMLElement',
+    HTMLCanvasElement: 'HTMLElement',
+    HTMLDivElement: 'HTMLElement',
+    HTMLHeadElement: 'HTMLElement',
+    HTMLHtmlElement: 'HTMLElement',
+    HTMLImageElement: 'HTMLElement',
+    HTMLSpanElement: 'HTMLElement',
+    HTMLStyleElement: 'HTMLElement',
+    HTMLTemplateElement: 'HTMLElement',
+    HTMLUnknownElement: 'HTMLElement',
+    Image: 'HTMLElement',
+    MediaQueryList: 'EventTarget',
+    Node: 'EventTarget',
+    OffscreenCanvas: 'EventTarget',
+    ShadowRoot: 'DocumentFragment',
+    Window: 'EventTarget',
+};
+
+const polyfill = (target, options) => {
+    const webAPIs = {
+        AbortController,
+        AbortSignal,
+        Blob,
+        ByteLengthQueuingStrategy,
+        CanvasRenderingContext2D,
+        CharacterData,
+        Comment,
+        CountQueuingStrategy,
+        CSSStyleSheet,
+        CustomElementRegistry,
+        CustomEvent,
+        Document,
+        DocumentFragment,
+        DOMException,
+        Element,
+        Event,
+        EventTarget,
+        File,
+        FormData,
+        HTMLDocument,
+        HTMLElement,
+        HTMLBodyElement,
+        HTMLCanvasElement,
+        HTMLDivElement,
+        HTMLHeadElement,
+        HTMLHtmlElement,
+        HTMLImageElement,
+        HTMLSpanElement,
+        HTMLStyleElement,
+        HTMLTemplateElement,
+        HTMLUnknownElement,
+        Headers,
+        IntersectionObserver,
+        Image,
+        ImageData,
+        MediaQueryList,
+        MutationObserver,
+        Node,
+        NodeFilter: NodeFilter$1,
+        NodeIterator: NodeIterator$1,
+        OffscreenCanvas,
+        ReadableByteStreamController,
+        ReadableStream,
+        ReadableStreamBYOBReader,
+        ReadableStreamBYOBRequest,
+        ReadableStreamDefaultController,
+        ReadableStreamDefaultReader,
+        Request,
+        ResizeObserver,
+        Response,
+        ShadowRoot,
+        Storage,
+        StyleSheet,
+        Text,
+        TransformStream,
+        TreeWalker,
+        URLPattern: U,
+        WritableStream,
+        WritableStreamDefaultController,
+        WritableStreamDefaultWriter,
+        Window,
+        alert,
+        atob,
+        btoa,
+        cancelAnimationFrame,
+        cancelIdleCallback,
+        clearTimeout,
+        fetch,
+        requestAnimationFrame,
+        requestIdleCallback,
+        setTimeout,
+        structuredClone,
+    };
+    // initialize exclude options
+    const excludeOptions = new Set(typeof Object(options).exclude === 'string'
+        ? String(Object(options).exclude).trim().split(/\s+/)
+        : Array.isArray(Object(options).exclude)
+            ? Object(options).exclude.reduce((array, entry) => array.splice(array.length, 0, ...(typeof entry === 'string' ? entry.trim().split(/\s+/) : [])) && array, [])
+            : []);
+    // expand exclude options using exclusion shorthands
+    for (const excludeOption of excludeOptions) {
+        if (excludeOption in exclusions) {
+            for (const exclusion of exclusions[excludeOption]) {
+                excludeOptions.add(exclusion);
+            }
+        }
+    }
+    // apply each WebAPI
+    for (const name of Object.keys(webAPIs)) {
+        // skip WebAPIs that are excluded
+        if (excludeOptions.has(name))
+            continue;
+        // skip WebAPIs that are built-in 
+        if (Object.hasOwnProperty.call(target, name))
+            continue;
+        // define WebAPIs on the target
+        Object.defineProperty(target, name, { configurable: true, enumerable: true, writable: true, value: webAPIs[name] });
+    }
+    // ensure WebAPIs correctly inherit other WebAPIs
+    for (const name of Object.keys(webAPIs)) {
+        // skip WebAPIs that are excluded
+        if (excludeOptions.has(name))
+            continue;
+        // skip WebAPIs that do not extend other WebAPIs
+        if (!Object.hasOwnProperty.call(inheritence, name))
+            continue;
+        const Class = target[name];
+        const Super = target[inheritence[name]];
+        // skip WebAPIs that are not available
+        if (!Class || !Super)
+            continue;
+        // skip WebAPIs that are already inherited correctly 
+        if (Object.getPrototypeOf(Class.prototype) === Super.prototype)
+            continue;
+        // define WebAPIs inheritence
+        Object.setPrototypeOf(Class.prototype, Super.prototype);
+    }
+    if (!excludeOptions.has('HTMLDocument') && !excludeOptions.has('HTMLElement')) {
+        initDocument(target, excludeOptions);
+        if (!excludeOptions.has('CustomElementRegistry')) {
+            initCustomElementRegistry(target, excludeOptions);
+        }
+    }
+    initObject(target, excludeOptions);
+    initMediaQueryList(target, excludeOptions);
+    initPromise(target, excludeOptions);
+    initRelativeIndexingMethod(target, excludeOptions);
+    initStorage(target, excludeOptions);
+    initString(target, excludeOptions);
+    initWindow(target, excludeOptions);
+    return target;
+};
+polyfill.internals = (target, name) => {
+    const init = {
+        CustomElementRegistry: initCustomElementRegistry,
+        Document: initDocument,
+        MediaQueryList: initMediaQueryList,
+        Object: initObject,
+        Promise: initPromise,
+        RelativeIndexingMethod: initRelativeIndexingMethod,
+        Storage: initStorage,
+        String: initString,
+        Window: initWindow,
+    };
+    init[name](target, new Set());
+    return target;
+};
+
+let s = 0;
+const S = {
+	START_BOUNDARY: s++,
+	HEADER_FIELD_START: s++,
+	HEADER_FIELD: s++,
+	HEADER_VALUE_START: s++,
+	HEADER_VALUE: s++,
+	HEADER_VALUE_ALMOST_DONE: s++,
+	HEADERS_ALMOST_DONE: s++,
+	PART_DATA_START: s++,
+	PART_DATA: s++,
+	END: s++
+};
+
+let f = 1;
+const F = {
+	PART_BOUNDARY: f,
+	LAST_BOUNDARY: f *= 2
+};
+
+const LF = 10;
+const CR = 13;
+const SPACE = 32;
+const HYPHEN = 45;
+const COLON = 58;
+const A = 97;
+const Z = 122;
+
+const lower = c => c | 0x20;
+
+const noop = () => {};
+
+class MultipartParser {
+	/**
+	 * @param {string} boundary
+	 */
+	constructor(boundary) {
+		this.index = 0;
+		this.flags = 0;
+
+		this.onHeaderEnd = noop;
+		this.onHeaderField = noop;
+		this.onHeadersEnd = noop;
+		this.onHeaderValue = noop;
+		this.onPartBegin = noop;
+		this.onPartData = noop;
+		this.onPartEnd = noop;
+
+		this.boundaryChars = {};
+
+		boundary = '\r\n--' + boundary;
+		const ui8a = new Uint8Array(boundary.length);
+		for (let i = 0; i < boundary.length; i++) {
+			ui8a[i] = boundary.charCodeAt(i);
+			this.boundaryChars[ui8a[i]] = true;
+		}
+
+		this.boundary = ui8a;
+		this.lookbehind = new Uint8Array(this.boundary.length + 8);
+		this.state = S.START_BOUNDARY;
+	}
+
+	/**
+	 * @param {Uint8Array} data
+	 */
+	write(data) {
+		let i = 0;
+		const length_ = data.length;
+		let previousIndex = this.index;
+		let {lookbehind, boundary, boundaryChars, index, state, flags} = this;
+		const boundaryLength = this.boundary.length;
+		const boundaryEnd = boundaryLength - 1;
+		const bufferLength = data.length;
+		let c;
+		let cl;
+
+		const mark = name => {
+			this[name + 'Mark'] = i;
+		};
+
+		const clear = name => {
+			delete this[name + 'Mark'];
+		};
+
+		const callback = (callbackSymbol, start, end, ui8a) => {
+			if (start === undefined || start !== end) {
+				this[callbackSymbol](ui8a && ui8a.subarray(start, end));
+			}
+		};
+
+		const dataCallback = (name, clear) => {
+			const markSymbol = name + 'Mark';
+			if (!(markSymbol in this)) {
+				return;
+			}
+
+			if (clear) {
+				callback(name, this[markSymbol], i, data);
+				delete this[markSymbol];
+			} else {
+				callback(name, this[markSymbol], data.length, data);
+				this[markSymbol] = 0;
+			}
+		};
+
+		for (i = 0; i < length_; i++) {
+			c = data[i];
+
+			switch (state) {
+				case S.START_BOUNDARY:
+					if (index === boundary.length - 2) {
+						if (c === HYPHEN) {
+							flags |= F.LAST_BOUNDARY;
+						} else if (c !== CR) {
+							return;
+						}
+
+						index++;
+						break;
+					} else if (index - 1 === boundary.length - 2) {
+						if (flags & F.LAST_BOUNDARY && c === HYPHEN) {
+							state = S.END;
+							flags = 0;
+						} else if (!(flags & F.LAST_BOUNDARY) && c === LF) {
+							index = 0;
+							callback('onPartBegin');
+							state = S.HEADER_FIELD_START;
+						} else {
+							return;
+						}
+
+						break;
+					}
+
+					if (c !== boundary[index + 2]) {
+						index = -2;
+					}
+
+					if (c === boundary[index + 2]) {
+						index++;
+					}
+
+					break;
+				case S.HEADER_FIELD_START:
+					state = S.HEADER_FIELD;
+					mark('onHeaderField');
+					index = 0;
+					// falls through
+				case S.HEADER_FIELD:
+					if (c === CR) {
+						clear('onHeaderField');
+						state = S.HEADERS_ALMOST_DONE;
+						break;
+					}
+
+					index++;
+					if (c === HYPHEN) {
+						break;
+					}
+
+					if (c === COLON) {
+						if (index === 1) {
+							// empty header field
+							return;
+						}
+
+						dataCallback('onHeaderField', true);
+						state = S.HEADER_VALUE_START;
+						break;
+					}
+
+					cl = lower(c);
+					if (cl < A || cl > Z) {
+						return;
+					}
+
+					break;
+				case S.HEADER_VALUE_START:
+					if (c === SPACE) {
+						break;
+					}
+
+					mark('onHeaderValue');
+					state = S.HEADER_VALUE;
+					// falls through
+				case S.HEADER_VALUE:
+					if (c === CR) {
+						dataCallback('onHeaderValue', true);
+						callback('onHeaderEnd');
+						state = S.HEADER_VALUE_ALMOST_DONE;
+					}
+
+					break;
+				case S.HEADER_VALUE_ALMOST_DONE:
+					if (c !== LF) {
+						return;
+					}
+
+					state = S.HEADER_FIELD_START;
+					break;
+				case S.HEADERS_ALMOST_DONE:
+					if (c !== LF) {
+						return;
+					}
+
+					callback('onHeadersEnd');
+					state = S.PART_DATA_START;
+					break;
+				case S.PART_DATA_START:
+					state = S.PART_DATA;
+					mark('onPartData');
+					// falls through
+				case S.PART_DATA:
+					previousIndex = index;
+
+					if (index === 0) {
+						// boyer-moore derrived algorithm to safely skip non-boundary data
+						i += boundaryEnd;
+						while (i < bufferLength && !(data[i] in boundaryChars)) {
+							i += boundaryLength;
+						}
+
+						i -= boundaryEnd;
+						c = data[i];
+					}
+
+					if (index < boundary.length) {
+						if (boundary[index] === c) {
+							if (index === 0) {
+								dataCallback('onPartData', true);
+							}
+
+							index++;
+						} else {
+							index = 0;
+						}
+					} else if (index === boundary.length) {
+						index++;
+						if (c === CR) {
+							// CR = part boundary
+							flags |= F.PART_BOUNDARY;
+						} else if (c === HYPHEN) {
+							// HYPHEN = end boundary
+							flags |= F.LAST_BOUNDARY;
+						} else {
+							index = 0;
+						}
+					} else if (index - 1 === boundary.length) {
+						if (flags & F.PART_BOUNDARY) {
+							index = 0;
+							if (c === LF) {
+								// unset the PART_BOUNDARY flag
+								flags &= ~F.PART_BOUNDARY;
+								callback('onPartEnd');
+								callback('onPartBegin');
+								state = S.HEADER_FIELD_START;
+								break;
+							}
+						} else if (flags & F.LAST_BOUNDARY) {
+							if (c === HYPHEN) {
+								callback('onPartEnd');
+								state = S.END;
+								flags = 0;
+							} else {
+								index = 0;
+							}
+						} else {
+							index = 0;
+						}
+					}
+
+					if (index > 0) {
+						// when matching a possible boundary, keep a lookbehind reference
+						// in case it turns out to be a false lead
+						lookbehind[index - 1] = c;
+					} else if (previousIndex > 0) {
+						// if our boundary turned out to be rubbish, the captured lookbehind
+						// belongs to partData
+						const _lookbehind = new Uint8Array(lookbehind.buffer, lookbehind.byteOffset, lookbehind.byteLength);
+						callback('onPartData', 0, previousIndex, _lookbehind);
+						previousIndex = 0;
+						mark('onPartData');
+
+						// reconsider the current character even so it interrupted the sequence
+						// it could be the beginning of a new sequence
+						i--;
+					}
+
+					break;
+				case S.END:
+					break;
+				default:
+					throw new Error(`Unexpected state entered: ${state}`);
+			}
+		}
+
+		dataCallback('onHeaderField');
+		dataCallback('onHeaderValue');
+		dataCallback('onPartData');
+
+		// Update properties for the next call
+		this.index = index;
+		this.state = state;
+		this.flags = flags;
+	}
+
+	end() {
+		if ((this.state === S.HEADER_FIELD_START && this.index === 0) ||
+			(this.state === S.PART_DATA && this.index === this.boundary.length)) {
+			this.onPartEnd();
+		} else if (this.state !== S.END) {
+			throw new Error('MultipartParser.end(): stream ended unexpectedly');
+		}
+	}
+}
+
+function _fileName(headerValue) {
+	// matches either a quoted-string or a token (RFC 2616 section 19.5.1)
+	const m = headerValue.match(/\bfilename=("(.*?)"|([^()<>@,;:\\"/[\]?={}\s\t]+))($|;\s)/i);
+	if (!m) {
+		return;
+	}
+
+	const match = m[2] || m[3] || '';
+	let filename = match.slice(match.lastIndexOf('\\') + 1);
+	filename = filename.replace(/%22/g, '"');
+	filename = filename.replace(/&#(\d{4});/g, (m, code) => {
+		return String.fromCharCode(code);
+	});
+	return filename;
+}
+
+async function toFormData(Body, ct) {
+	if (!/multipart/i.test(ct)) {
+		throw new TypeError('Failed to fetch');
+	}
+
+	const m = ct.match(/boundary=(?:"([^"]+)"|([^;]+))/i);
+
+	if (!m) {
+		throw new TypeError('no or bad content-type header, no multipart boundary');
+	}
+
+	const parser = new MultipartParser(m[1] || m[2]);
+
+	let headerField;
+	let headerValue;
+	let entryValue;
+	let entryName;
+	let contentType;
+	let filename;
+	const entryChunks = [];
+	const formData = new FormData();
+
+	const onPartData = ui8a => {
+		entryValue += decoder.decode(ui8a, {stream: true});
+	};
+
+	const appendToFile = ui8a => {
+		entryChunks.push(ui8a);
+	};
+
+	const appendFileToFormData = () => {
+		const file = new File(entryChunks, filename, {type: contentType});
+		formData.append(entryName, file);
+	};
+
+	const appendEntryToFormData = () => {
+		formData.append(entryName, entryValue);
+	};
+
+	const decoder = new TextDecoder('utf-8');
+	decoder.decode();
+
+	parser.onPartBegin = function () {
+		parser.onPartData = onPartData;
+		parser.onPartEnd = appendEntryToFormData;
+
+		headerField = '';
+		headerValue = '';
+		entryValue = '';
+		entryName = '';
+		contentType = '';
+		filename = null;
+		entryChunks.length = 0;
+	};
+
+	parser.onHeaderField = function (ui8a) {
+		headerField += decoder.decode(ui8a, {stream: true});
+	};
+
+	parser.onHeaderValue = function (ui8a) {
+		headerValue += decoder.decode(ui8a, {stream: true});
+	};
+
+	parser.onHeaderEnd = function () {
+		headerValue += decoder.decode();
+		headerField = headerField.toLowerCase();
+
+		if (headerField === 'content-disposition') {
+			// matches either a quoted-string or a token (RFC 2616 section 19.5.1)
+			const m = headerValue.match(/\bname=("([^"]*)"|([^()<>@,;:\\"/[\]?={}\s\t]+))/i);
+
+			if (m) {
+				entryName = m[2] || m[3] || '';
+			}
+
+			filename = _fileName(headerValue);
+
+			if (filename) {
+				parser.onPartData = appendToFile;
+				parser.onPartEnd = appendFileToFormData;
+			}
+		} else if (headerField === 'content-type') {
+			contentType = headerValue;
+		}
+
+		headerValue = '';
+		headerField = '';
+	};
+
+	for await (const chunk of Body) {
+		parser.write(chunk);
+	}
+
+	parser.end();
+
+	return formData;
+}
+
+var multipartParser = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    toFormData: toFormData
+});
+
+export { AbortController, AbortSignal, Blob, ByteLengthQueuingStrategy, CSSStyleSheet, CanvasRenderingContext2D, CharacterData, Comment, CountQueuingStrategy, CustomElementRegistry, CustomEvent, DOMException, Document, DocumentFragment, Element, Event, EventTarget, File, FormData, HTMLBodyElement, HTMLCanvasElement, HTMLDivElement, HTMLDocument, HTMLElement, HTMLHeadElement, HTMLHtmlElement, HTMLImageElement, HTMLSpanElement, HTMLStyleElement, HTMLTemplateElement, HTMLUnknownElement, Headers, Image, ImageData, IntersectionObserver, MediaQueryList, MutationObserver, Node, NodeFilter$1 as NodeFilter, NodeIterator$1 as NodeIterator, OffscreenCanvas, ReadableByteStreamController, ReadableStream, ReadableStreamBYOBReader, ReadableStreamBYOBRequest, ReadableStreamDefaultController, ReadableStreamDefaultReader, Request, ResizeObserver, Response, ShadowRoot, StyleSheet, Text, TransformStream, TreeWalker, U as URLPattern, Window, WritableStream, WritableStreamDefaultController, WritableStreamDefaultWriter, alert, atob, btoa, cancelAnimationFrame, cancelIdleCallback, clearTimeout, fetch, pathToPosix, polyfill, requestAnimationFrame, requestIdleCallback, setTimeout, structuredClone };
+//# sourceMappingURL=mod.js.map