utils-lib-js 2.0.4 → 2.0.6

package/dist/umd/index.js

@@ -1723,6 +1723,979 @@
 
     __assign$1(__assign$1(__assign$1(__assign$1(__assign$1(__assign$1(__assign$1(__assign$1(__assign$1(__assign$1(__assign$1({}, object), base), array), __function), element), __static), event), storage), log), animate), { eventMessageCenter: MessageCenter, taskQueueLib: TaskQueue });
 
+    /**
+     * @author Toru Nagashima <https://github.com/mysticatea>
+     * @copyright 2015 Toru Nagashima. All rights reserved.
+     * See LICENSE file in root directory for full license.
+     */
+    /**
+     * @typedef {object} PrivateData
+     * @property {EventTarget} eventTarget The event target.
+     * @property {{type:string}} event The original event object.
+     * @property {number} eventPhase The current event phase.
+     * @property {EventTarget|null} currentTarget The current event target.
+     * @property {boolean} canceled The flag to prevent default.
+     * @property {boolean} stopped The flag to stop propagation.
+     * @property {boolean} immediateStopped The flag to stop propagation immediately.
+     * @property {Function|null} passiveListener The listener if the current listener is passive. Otherwise this is null.
+     * @property {number} timeStamp The unix time.
+     * @private
+     */
+
+    /**
+     * Private data for event wrappers.
+     * @type {WeakMap<Event, PrivateData>}
+     * @private
+     */
+    const privateData = new WeakMap();
+
+    /**
+     * Cache for wrapper classes.
+     * @type {WeakMap<Object, Function>}
+     * @private
+     */
+    const wrappers = new WeakMap();
+
+    /**
+     * Get private data.
+     * @param {Event} event The event object to get private data.
+     * @returns {PrivateData} The private data of the event.
+     * @private
+     */
+    function pd(event) {
+        const retv = privateData.get(event);
+        console.assert(
+            retv != null,
+            "'this' is expected an Event object, but got",
+            event
+        );
+        return retv
+    }
+
+    /**
+     * https://dom.spec.whatwg.org/#set-the-canceled-flag
+     * @param data {PrivateData} private data.
+     */
+    function setCancelFlag(data) {
+        if (data.passiveListener != null) {
+            if (
+                typeof console !== "undefined" &&
+                typeof console.error === "function"
+            ) {
+                console.error(
+                    "Unable to preventDefault inside passive event listener invocation.",
+                    data.passiveListener
+                );
+            }
+            return
+        }
+        if (!data.event.cancelable) {
+            return
+        }
+
+        data.canceled = true;
+        if (typeof data.event.preventDefault === "function") {
+            data.event.preventDefault();
+        }
+    }
+
+    /**
+     * @see https://dom.spec.whatwg.org/#interface-event
+     * @private
+     */
+    /**
+     * The event wrapper.
+     * @constructor
+     * @param {EventTarget} eventTarget The event target of this dispatching.
+     * @param {Event|{type:string}} event The original event to wrap.
+     */
+    function Event$1(eventTarget, event) {
+        privateData.set(this, {
+            eventTarget,
+            event,
+            eventPhase: 2,
+            currentTarget: eventTarget,
+            canceled: false,
+            stopped: false,
+            immediateStopped: false,
+            passiveListener: null,
+            timeStamp: event.timeStamp || Date.now(),
+        });
+
+        // https://heycam.github.io/webidl/#Unforgeable
+        Object.defineProperty(this, "isTrusted", { value: false, enumerable: true });
+
+        // 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(key));
+            }
+        }
+    }
+
+    // Should be enumerable, but class methods are not enumerable.
+    Event$1.prototype = {
+        /**
+         * The type of this event.
+         * @type {string}
+         */
+        get type() {
+            return pd(this).event.type
+        },
+
+        /**
+         * The target of this event.
+         * @type {EventTarget}
+         */
+        get target() {
+            return pd(this).eventTarget
+        },
+
+        /**
+         * The target of this event.
+         * @type {EventTarget}
+         */
+        get currentTarget() {
+            return pd(this).currentTarget
+        },
+
+        /**
+         * @returns {EventTarget[]} The composed path of this event.
+         */
+        composedPath() {
+            const currentTarget = pd(this).currentTarget;
+            if (currentTarget == null) {
+                return []
+            }
+            return [currentTarget]
+        },
+
+        /**
+         * Constant of NONE.
+         * @type {number}
+         */
+        get NONE() {
+            return 0
+        },
+
+        /**
+         * Constant of CAPTURING_PHASE.
+         * @type {number}
+         */
+        get CAPTURING_PHASE() {
+            return 1
+        },
+
+        /**
+         * Constant of AT_TARGET.
+         * @type {number}
+         */
+        get AT_TARGET() {
+            return 2
+        },
+
+        /**
+         * Constant of BUBBLING_PHASE.
+         * @type {number}
+         */
+        get BUBBLING_PHASE() {
+            return 3
+        },
+
+        /**
+         * The target of this event.
+         * @type {number}
+         */
+        get eventPhase() {
+            return pd(this).eventPhase
+        },
+
+        /**
+         * Stop event bubbling.
+         * @returns {void}
+         */
+        stopPropagation() {
+            const data = pd(this);
+
+            data.stopped = true;
+            if (typeof data.event.stopPropagation === "function") {
+                data.event.stopPropagation();
+            }
+        },
+
+        /**
+         * Stop event bubbling.
+         * @returns {void}
+         */
+        stopImmediatePropagation() {
+            const data = pd(this);
+
+            data.stopped = true;
+            data.immediateStopped = true;
+            if (typeof data.event.stopImmediatePropagation === "function") {
+                data.event.stopImmediatePropagation();
+            }
+        },
+
+        /**
+         * The flag to be bubbling.
+         * @type {boolean}
+         */
+        get bubbles() {
+            return Boolean(pd(this).event.bubbles)
+        },
+
+        /**
+         * The flag to be cancelable.
+         * @type {boolean}
+         */
+        get cancelable() {
+            return Boolean(pd(this).event.cancelable)
+        },
+
+        /**
+         * Cancel this event.
+         * @returns {void}
+         */
+        preventDefault() {
+            setCancelFlag(pd(this));
+        },
+
+        /**
+         * The flag to indicate cancellation state.
+         * @type {boolean}
+         */
+        get defaultPrevented() {
+            return pd(this).canceled
+        },
+
+        /**
+         * The flag to be composed.
+         * @type {boolean}
+         */
+        get composed() {
+            return Boolean(pd(this).event.composed)
+        },
+
+        /**
+         * The unix time of this event.
+         * @type {number}
+         */
+        get timeStamp() {
+            return pd(this).timeStamp
+        },
+
+        /**
+         * The target of this event.
+         * @type {EventTarget}
+         * @deprecated
+         */
+        get srcElement() {
+            return pd(this).eventTarget
+        },
+
+        /**
+         * The flag to stop event bubbling.
+         * @type {boolean}
+         * @deprecated
+         */
+        get cancelBubble() {
+            return pd(this).stopped
+        },
+        set cancelBubble(value) {
+            if (!value) {
+                return
+            }
+            const data = pd(this);
+
+            data.stopped = true;
+            if (typeof data.event.cancelBubble === "boolean") {
+                data.event.cancelBubble = true;
+            }
+        },
+
+        /**
+         * The flag to indicate cancellation state.
+         * @type {boolean}
+         * @deprecated
+         */
+        get returnValue() {
+            return !pd(this).canceled
+        },
+        set returnValue(value) {
+            if (!value) {
+                setCancelFlag(pd(this));
+            }
+        },
+
+        /**
+         * Initialize this event object. But do nothing under event dispatching.
+         * @param {string} type The event type.
+         * @param {boolean} [bubbles=false] The flag to be possible to bubble up.
+         * @param {boolean} [cancelable=false] The flag to be possible to cancel.
+         * @deprecated
+         */
+        initEvent() {
+            // Do nothing.
+        },
+    };
+
+    // `constructor` is not enumerable.
+    Object.defineProperty(Event$1.prototype, "constructor", {
+        value: Event$1,
+        configurable: true,
+        writable: true,
+    });
+
+    // Ensure `event instanceof window.Event` is `true`.
+    if (typeof window !== "undefined" && typeof window.Event !== "undefined") {
+        Object.setPrototypeOf(Event$1.prototype, window.Event.prototype);
+
+        // Make association for wrappers.
+        wrappers.set(window.Event.prototype, Event$1);
+    }
+
+    /**
+     * Get the property descriptor to redirect a given property.
+     * @param {string} key Property name to define property descriptor.
+     * @returns {PropertyDescriptor} The property descriptor to redirect the property.
+     * @private
+     */
+    function defineRedirectDescriptor(key) {
+        return {
+            get() {
+                return pd(this).event[key]
+            },
+            set(value) {
+                pd(this).event[key] = value;
+            },
+            configurable: true,
+            enumerable: true,
+        }
+    }
+
+    /**
+     * Get the property descriptor to call a given method property.
+     * @param {string} key Property name to define property descriptor.
+     * @returns {PropertyDescriptor} The property descriptor to call the method property.
+     * @private
+     */
+    function defineCallDescriptor(key) {
+        return {
+            value() {
+                const event = pd(this).event;
+                return event[key].apply(event, arguments)
+            },
+            configurable: true,
+            enumerable: true,
+        }
+    }
+
+    /**
+     * Define new wrapper class.
+     * @param {Function} BaseEvent The base wrapper class.
+     * @param {Object} proto The prototype of the original event.
+     * @returns {Function} The defined wrapper class.
+     * @private
+     */
+    function defineWrapper(BaseEvent, proto) {
+        const keys = Object.keys(proto);
+        if (keys.length === 0) {
+            return BaseEvent
+        }
+
+        /** CustomEvent */
+        function CustomEvent(eventTarget, event) {
+            BaseEvent.call(this, eventTarget, event);
+        }
+
+        CustomEvent.prototype = Object.create(BaseEvent.prototype, {
+            constructor: { value: CustomEvent, configurable: true, writable: true },
+        });
+
+        // Define accessors.
+        for (let i = 0; i < keys.length; ++i) {
+            const key = keys[i];
+            if (!(key in BaseEvent.prototype)) {
+                const descriptor = Object.getOwnPropertyDescriptor(proto, key);
+                const isFunc = typeof descriptor.value === "function";
+                Object.defineProperty(
+                    CustomEvent.prototype,
+                    key,
+                    isFunc
+                        ? defineCallDescriptor(key)
+                        : defineRedirectDescriptor(key)
+                );
+            }
+        }
+
+        return CustomEvent
+    }
+
+    /**
+     * Get the wrapper class of a given prototype.
+     * @param {Object} proto The prototype of the original event to get its wrapper.
+     * @returns {Function} The wrapper class.
+     * @private
+     */
+    function getWrapper(proto) {
+        if (proto == null || proto === Object.prototype) {
+            return Event$1
+        }
+
+        let wrapper = wrappers.get(proto);
+        if (wrapper == null) {
+            wrapper = defineWrapper(getWrapper(Object.getPrototypeOf(proto)), proto);
+            wrappers.set(proto, wrapper);
+        }
+        return wrapper
+    }
+
+    /**
+     * Wrap a given event to management a dispatching.
+     * @param {EventTarget} eventTarget The event target of this dispatching.
+     * @param {Object} event The event to wrap.
+     * @returns {Event} The wrapper instance.
+     * @private
+     */
+    function wrapEvent(eventTarget, event) {
+        const Wrapper = getWrapper(Object.getPrototypeOf(event));
+        return new Wrapper(eventTarget, event)
+    }
+
+    /**
+     * Get the immediateStopped flag of a given event.
+     * @param {Event} event The event to get.
+     * @returns {boolean} The flag to stop propagation immediately.
+     * @private
+     */
+    function isStopped(event) {
+        return pd(event).immediateStopped
+    }
+
+    /**
+     * Set the current event phase of a given event.
+     * @param {Event} event The event to set current target.
+     * @param {number} eventPhase New event phase.
+     * @returns {void}
+     * @private
+     */
+    function setEventPhase(event, eventPhase) {
+        pd(event).eventPhase = eventPhase;
+    }
+
+    /**
+     * Set the current target of a given event.
+     * @param {Event} event The event to set current target.
+     * @param {EventTarget|null} currentTarget New current target.
+     * @returns {void}
+     * @private
+     */
+    function setCurrentTarget(event, currentTarget) {
+        pd(event).currentTarget = currentTarget;
+    }
+
+    /**
+     * Set a passive listener of a given event.
+     * @param {Event} event The event to set current target.
+     * @param {Function|null} passiveListener New passive listener.
+     * @returns {void}
+     * @private
+     */
+    function setPassiveListener(event, passiveListener) {
+        pd(event).passiveListener = passiveListener;
+    }
+
+    /**
+     * @typedef {object} ListenerNode
+     * @property {Function} listener
+     * @property {1|2|3} listenerType
+     * @property {boolean} passive
+     * @property {boolean} once
+     * @property {ListenerNode|null} next
+     * @private
+     */
+
+    /**
+     * @type {WeakMap<object, Map<string, ListenerNode>>}
+     * @private
+     */
+    const listenersMap = new WeakMap();
+
+    // Listener types
+    const CAPTURE = 1;
+    const BUBBLE = 2;
+    const ATTRIBUTE = 3;
+
+    /**
+     * Check whether a given value is an object or not.
+     * @param {any} x The value to check.
+     * @returns {boolean} `true` if the value is an object.
+     */
+    function isObject(x) {
+        return x !== null && typeof x === "object" //eslint-disable-line no-restricted-syntax
+    }
+
+    /**
+     * Get listeners.
+     * @param {EventTarget} eventTarget The event target to get.
+     * @returns {Map<string, ListenerNode>} The listeners.
+     * @private
+     */
+    function getListeners(eventTarget) {
+        const listeners = listenersMap.get(eventTarget);
+        if (listeners == null) {
+            throw new TypeError(
+                "'this' is expected an EventTarget object, but got another value."
+            )
+        }
+        return listeners
+    }
+
+    /**
+     * Get the property descriptor for the event attribute of a given event.
+     * @param {string} eventName The event name to get property descriptor.
+     * @returns {PropertyDescriptor} The property descriptor.
+     * @private
+     */
+    function defineEventAttributeDescriptor(eventName) {
+        return {
+            get() {
+                const listeners = getListeners(this);
+                let node = listeners.get(eventName);
+                while (node != null) {
+                    if (node.listenerType === ATTRIBUTE) {
+                        return node.listener
+                    }
+                    node = node.next;
+                }
+                return null
+            },
+
+            set(listener) {
+                if (typeof listener !== "function" && !isObject(listener)) {
+                    listener = null; // eslint-disable-line no-param-reassign
+                }
+                const listeners = getListeners(this);
+
+                // Traverse to the tail while removing old value.
+                let prev = null;
+                let node = listeners.get(eventName);
+                while (node != null) {
+                    if (node.listenerType === ATTRIBUTE) {
+                        // Remove old value.
+                        if (prev !== null) {
+                            prev.next = node.next;
+                        } else if (node.next !== null) {
+                            listeners.set(eventName, node.next);
+                        } else {
+                            listeners.delete(eventName);
+                        }
+                    } else {
+                        prev = node;
+                    }
+
+                    node = node.next;
+                }
+
+                // Add new value.
+                if (listener !== null) {
+                    const newNode = {
+                        listener,
+                        listenerType: ATTRIBUTE,
+                        passive: false,
+                        once: false,
+                        next: null,
+                    };
+                    if (prev === null) {
+                        listeners.set(eventName, newNode);
+                    } else {
+                        prev.next = newNode;
+                    }
+                }
+            },
+            configurable: true,
+            enumerable: true,
+        }
+    }
+
+    /**
+     * Define an event attribute (e.g. `eventTarget.onclick`).
+     * @param {Object} eventTargetPrototype The event target prototype to define an event attrbite.
+     * @param {string} eventName The event name to define.
+     * @returns {void}
+     */
+    function defineEventAttribute(eventTargetPrototype, eventName) {
+        Object.defineProperty(
+            eventTargetPrototype,
+            `on${eventName}`,
+            defineEventAttributeDescriptor(eventName)
+        );
+    }
+
+    /**
+     * Define a custom EventTarget with event attributes.
+     * @param {string[]} eventNames Event names for event attributes.
+     * @returns {EventTarget} The custom EventTarget.
+     * @private
+     */
+    function defineCustomEventTarget(eventNames) {
+        /** CustomEventTarget */
+        function CustomEventTarget() {
+            EventTarget.call(this);
+        }
+
+        CustomEventTarget.prototype = Object.create(EventTarget.prototype, {
+            constructor: {
+                value: CustomEventTarget,
+                configurable: true,
+                writable: true,
+            },
+        });
+
+        for (let i = 0; i < eventNames.length; ++i) {
+            defineEventAttribute(CustomEventTarget.prototype, eventNames[i]);
+        }
+
+        return CustomEventTarget
+    }
+
+    /**
+     * EventTarget.
+     *
+     * - This is constructor if no arguments.
+     * - This is a function which returns a CustomEventTarget constructor if there are arguments.
+     *
+     * For example:
+     *
+     *     class A extends EventTarget {}
+     *     class B extends EventTarget("message") {}
+     *     class C extends EventTarget("message", "error") {}
+     *     class D extends EventTarget(["message", "error"]) {}
+     */
+    function EventTarget() {
+        /*eslint-disable consistent-return */
+        if (this instanceof EventTarget) {
+            listenersMap.set(this, new Map());
+            return
+        }
+        if (arguments.length === 1 && Array.isArray(arguments[0])) {
+            return defineCustomEventTarget(arguments[0])
+        }
+        if (arguments.length > 0) {
+            const types = new Array(arguments.length);
+            for (let i = 0; i < arguments.length; ++i) {
+                types[i] = arguments[i];
+            }
+            return defineCustomEventTarget(types)
+        }
+        throw new TypeError("Cannot call a class as a function")
+        /*eslint-enable consistent-return */
+    }
+
+    // Should be enumerable, but class methods are not enumerable.
+    EventTarget.prototype = {
+        /**
+         * Add a given listener to this event target.
+         * @param {string} eventName The event name to add.
+         * @param {Function} listener The listener to add.
+         * @param {boolean|{capture?:boolean,passive?:boolean,once?:boolean}} [options] The options for this listener.
+         * @returns {void}
+         */
+        addEventListener(eventName, listener, options) {
+            if (listener == null) {
+                return
+            }
+            if (typeof listener !== "function" && !isObject(listener)) {
+                throw new TypeError("'listener' should be a function or an object.")
+            }
+
+            const listeners = getListeners(this);
+            const optionsIsObj = isObject(options);
+            const capture = optionsIsObj
+                ? Boolean(options.capture)
+                : Boolean(options);
+            const listenerType = capture ? CAPTURE : BUBBLE;
+            const newNode = {
+                listener,
+                listenerType,
+                passive: optionsIsObj && Boolean(options.passive),
+                once: optionsIsObj && Boolean(options.once),
+                next: null,
+            };
+
+            // Set it as the first node if the first node is null.
+            let node = listeners.get(eventName);
+            if (node === undefined) {
+                listeners.set(eventName, newNode);
+                return
+            }
+
+            // Traverse to the tail while checking duplication..
+            let prev = null;
+            while (node != null) {
+                if (
+                    node.listener === listener &&
+                    node.listenerType === listenerType
+                ) {
+                    // Should ignore duplication.
+                    return
+                }
+                prev = node;
+                node = node.next;
+            }
+
+            // Add it.
+            prev.next = newNode;
+        },
+
+        /**
+         * Remove a given listener from this event target.
+         * @param {string} eventName The event name to remove.
+         * @param {Function} listener The listener to remove.
+         * @param {boolean|{capture?:boolean,passive?:boolean,once?:boolean}} [options] The options for this listener.
+         * @returns {void}
+         */
+        removeEventListener(eventName, listener, options) {
+            if (listener == null) {
+                return
+            }
+
+            const listeners = getListeners(this);
+            const capture = isObject(options)
+                ? Boolean(options.capture)
+                : Boolean(options);
+            const listenerType = capture ? CAPTURE : BUBBLE;
+
+            let prev = null;
+            let node = listeners.get(eventName);
+            while (node != null) {
+                if (
+                    node.listener === listener &&
+                    node.listenerType === listenerType
+                ) {
+                    if (prev !== null) {
+                        prev.next = node.next;
+                    } else if (node.next !== null) {
+                        listeners.set(eventName, node.next);
+                    } else {
+                        listeners.delete(eventName);
+                    }
+                    return
+                }
+
+                prev = node;
+                node = node.next;
+            }
+        },
+
+        /**
+         * Dispatch a given event.
+         * @param {Event|{type:string}} event The event to dispatch.
+         * @returns {boolean} `false` if canceled.
+         */
+        dispatchEvent(event) {
+            if (event == null || typeof event.type !== "string") {
+                throw new TypeError('"event.type" should be a string.')
+            }
+
+            // If listeners aren't registered, terminate.
+            const listeners = getListeners(this);
+            const eventName = event.type;
+            let node = listeners.get(eventName);
+            if (node == null) {
+                return true
+            }
+
+            // Since we cannot rewrite several properties, so wrap object.
+            const wrappedEvent = wrapEvent(this, event);
+
+            // This doesn't process capturing phase and bubbling phase.
+            // This isn't participating in a tree.
+            let prev = null;
+            while (node != null) {
+                // Remove this listener if it's once
+                if (node.once) {
+                    if (prev !== null) {
+                        prev.next = node.next;
+                    } else if (node.next !== null) {
+                        listeners.set(eventName, node.next);
+                    } else {
+                        listeners.delete(eventName);
+                    }
+                } else {
+                    prev = node;
+                }
+
+                // Call this listener
+                setPassiveListener(
+                    wrappedEvent,
+                    node.passive ? node.listener : null
+                );
+                if (typeof node.listener === "function") {
+                    try {
+                        node.listener.call(this, wrappedEvent);
+                    } catch (err) {
+                        if (
+                            typeof console !== "undefined" &&
+                            typeof console.error === "function"
+                        ) {
+                            console.error(err);
+                        }
+                    }
+                } else if (
+                    node.listenerType !== ATTRIBUTE &&
+                    typeof node.listener.handleEvent === "function"
+                ) {
+                    node.listener.handleEvent(wrappedEvent);
+                }
+
+                // Break if `event.stopImmediatePropagation` was called.
+                if (isStopped(wrappedEvent)) {
+                    break
+                }
+
+                node = node.next;
+            }
+            setPassiveListener(wrappedEvent, null);
+            setEventPhase(wrappedEvent, 0);
+            setCurrentTarget(wrappedEvent, null);
+
+            return !wrappedEvent.defaultPrevented
+        },
+    };
+
+    // `constructor` is not enumerable.
+    Object.defineProperty(EventTarget.prototype, "constructor", {
+        value: EventTarget,
+        configurable: true,
+        writable: true,
+    });
+
+    // Ensure `eventTarget instanceof window.EventTarget` is `true`.
+    if (
+        typeof window !== "undefined" &&
+        typeof window.EventTarget !== "undefined"
+    ) {
+        Object.setPrototypeOf(EventTarget.prototype, window.EventTarget.prototype);
+    }
+
+    /**
+     * @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
+     */
+    let AbortController$1 = 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$1.prototype, {
+        signal: { enumerable: true },
+        abort: { enumerable: true },
+    });
+    if (typeof Symbol === "function" && typeof Symbol.toStringTag === "symbol") {
+        Object.defineProperty(AbortController$1.prototype, Symbol.toStringTag, {
+            configurable: true,
+            value: "AbortController",
+        });
+    }
+
     /******************************************************************************
     Copyright (c) Microsoft Corporation.
 
@@ -1786,20 +2759,21 @@
     var httpRequest;
     var httpsRequest;
     var parse;
-    if (typeof window !== 'undefined') {
-        CustomAbortController = AbortController;
+    var hasAbort = typeof AbortController !== "undefined";
+    if (typeof window !== 'undefined' || hasAbort) {
+        CustomAbortController = globalThis.AbortController;
     }
     else if (typeof require !== "undefined") {
-        CustomAbortController = require("abort-controller");
         httpRequest = require("http").request;
         httpsRequest = require("https").request;
         parse = require("url").parse;
+        CustomAbortController = require('abort-controller');
     }
     else if (typeof globalThis === "object") {
         httpRequest = http.request;
         httpsRequest = https.request;
         parse = url.parse;
-        CustomAbortController = globalThis.AbortController;
+        CustomAbortController = AbortController$1;
     }
     else {
         CustomAbortController = function () {