utils-lib-js 1.7.10 → 1.7.13

package/dist/umd/index.js

@@ -1,8 +1,8 @@
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('http'), require('https'), require('url')) :
-    typeof define === 'function' && define.amd ? define(['exports', 'http', 'https', 'url'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.UtilsLib = {}, global.http, global.https, global.url));
-})(this, (function (exports, http, https, url) { 'use strict';
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.UtilsLib = {}));
+})(this, (function (exports) { 'use strict';
 
     /******************************************************************************
     Copyright (c) Microsoft Corporation.
@@ -217,6 +217,9 @@
             return "";
         }
     };
+    var isWindow = function (win) {
+        return win && win === win.window;
+    };
     var object = {
         getValue: getValue,
         setValue: setValue,
@@ -231,6 +234,7 @@
         classDecorator: classDecorator,
         stringToJson: stringToJson,
         jsonToString: jsonToString,
+        isWindow: isWindow,
     };
 
     var randomNum = function (min, max, bool) {
@@ -326,8 +330,11 @@
             }, time);
         };
     };
-    var defer = function () {
+    var defer = function (timer) {
+        if (timer === void 0) { timer = 0; }
         var resolve, reject;
+        if (timer > 0)
+            setTimeout(reject, timer);
         return {
             promise: new Promise(function (_resolve, _reject) {
                 resolve = _resolve;
@@ -373,979 +380,21 @@
     })(exports.types || (exports.types = {}));
     var __static = { types: exports.types };
 
-    /**
-     * @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
-     */
-    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",
-        });
-    }
-
+    var httpRequest, httpsRequest, parse, CustomAbortController;
+    if (typeof require !== "undefined") {
+        CustomAbortController = require("abort-controller");
+        httpRequest = require("http").request;
+        httpsRequest = require("https").request;
+        parse = require("url").parse;
+    }
+    else if (typeof AbortController !== "undefined") {
+        CustomAbortController = AbortController;
+    }
+    else {
+        CustomAbortController = function () {
+            throw new Error('AbortController is not defined');
+        };
+    }
     var Interceptors = (function () {
         function Interceptors() {
         }
@@ -1454,7 +503,7 @@
             var _this = _super.call(this, origin) || this;
             _this.initDefaultParams = function (url, _a) {
                 var _b, _c;
-                var _d = _a.method, method = _d === void 0 ? "GET" : _d, _e = _a.query, query = _e === void 0 ? {} : _e, _f = _a.headers, headers = _f === void 0 ? {} : _f, _g = _a.body, body = _g === void 0 ? null : _g, _h = _a.timeout, timeout = _h === void 0 ? 30 * 1000 : _h, _j = _a.controller, controller = _j === void 0 ? new AbortController() : _j, _k = _a.type, type = _k === void 0 ? "json" : _k, others = __rest(_a, ["method", "query", "headers", "body", "timeout", "controller", "type"]);
+                var _d = _a.method, method = _d === void 0 ? "GET" : _d, _e = _a.query, query = _e === void 0 ? {} : _e, _f = _a.headers, headers = _f === void 0 ? {} : _f, _g = _a.body, body = _g === void 0 ? null : _g, _h = _a.timeout, timeout = _h === void 0 ? 30 * 1000 : _h, _j = _a.controller, controller = _j === void 0 ? new CustomAbortController() : _j, _k = _a.type, type = _k === void 0 ? "json" : _k, others = __rest(_a, ["method", "query", "headers", "body", "timeout", "controller", "type"]);
                 var __params = __assign$1({ url: url, method: method, query: query, headers: headers, body: method === "GET" ? null : jsonToString(body), timeout: timeout, signal: controller === null || controller === void 0 ? void 0 : controller.signal, controller: controller, type: type, timer: null }, others);
                 var params = (_c = (_b = _this.reqFn) === null || _b === void 0 ? void 0 : _b.call(_this, __params)) !== null && _c !== void 0 ? _c : __params;
                 params.url = urlJoin(_this.fixOrigin(url), __params.query);
@@ -1464,9 +513,9 @@
                 var _temp = _this.initAbort(_this.initDefaultParams(url, opts));
                 return _temp;
             };
-            _this.initHttpParams = function (url$1, opts) {
-                var _temp = _this.initAbort(_this.initDefaultParams(url$1, opts));
-                var options = url.parse(_temp.url, true);
+            _this.initHttpParams = function (url, opts) {
+                var _temp = _this.initAbort(_this.initDefaultParams(url, opts));
+                var options = parse(_temp.url, true);
                 return __assign$1(__assign$1({}, _temp), options);
             };
             return _this;
@@ -1496,7 +545,7 @@
                 var params = _this.initHttpParams(_url, _opts);
                 var signal = params.signal, url = params.url;
                 promise.finally(function () { return _this.clearTimer(params); });
-                var request = _this.checkIsHttps(url) ? https.request : http.request;
+                var request = _this.checkIsHttps(url) ? httpsRequest : httpRequest;
                 var req = request(params, function (response) {
                     if ((response === null || response === void 0 ? void 0 : response.statusCode) >= 200 && (response === null || response === void 0 ? void 0 : response.statusCode) < 300) {
                         var data_1 = "";
@@ -2000,6 +1049,7 @@
     exports.getValue = getValue;
     exports.inherit = inherit;
     exports.isNotObject = isNotObject;
+    exports.isWindow = isWindow;
     exports.jsonToString = jsonToString;
     exports.logLoop = logLoop;
     exports.logOneLine = logOneLine;