oak-domain 4.0.0 → 4.0.2

package/lib/utils/url/whatwg-url/lib/URLSearchParams-impl.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+// @ts-nocheck
+const urlencoded_1 = tslib_1.__importDefault(require("./urlencoded"));
+function stableSortBy(arr, compare) {
+    return arr
+        .map((item, index) => ({ item, index }))
+        .sort((a, b) => compare(a.item, b.item) || a.index - b.index)
+        .map(({ item }) => item);
+}
+const implementation = class URLSearchParamsImpl {
+    constructor(globalObject, constructorArgs, { doNotStripQMark = false }) {
+        let init = constructorArgs[0];
+        this._list = [];
+        this._url = null;
+        if (!doNotStripQMark && typeof init === 'string' && init[0] === '?') {
+            init = init.slice(1);
+        }
+        if (Array.isArray(init)) {
+            for (const pair of init) {
+                if (pair.length !== 2) {
+                    throw new TypeError("Failed to construct 'URLSearchParams': parameter 1 sequence's element does not " +
+                        'contain exactly two elements.');
+                }
+                this._list.push([pair[0], pair[1]]);
+            }
+        }
+        else if (typeof init === 'object' &&
+            Object.getPrototypeOf(init) === null) {
+            for (const name of Object.keys(init)) {
+                const value = init[name];
+                this._list.push([name, value]);
+            }
+        }
+        else {
+            this._list = urlencoded_1.default.parseUrlencoded(init);
+        }
+    }
+    _updateSteps() {
+        if (this._url !== null) {
+            let query = urlencoded_1.default.serializeUrlencoded(this._list);
+            if (query === '') {
+                query = null;
+            }
+            this._url._url.query = query;
+        }
+    }
+    append(name, value) {
+        this._list.push([name, value]);
+        this._updateSteps();
+    }
+    delete(name) {
+        let i = 0;
+        while (i < this._list.length) {
+            if (this._list[i][0] === name) {
+                this._list.splice(i, 1);
+            }
+            else {
+                i++;
+            }
+        }
+        this._updateSteps();
+    }
+    get(name) {
+        for (const tuple of this._list) {
+            if (tuple[0] === name) {
+                return tuple[1];
+            }
+        }
+        return null;
+    }
+    getAll(name) {
+        const output = [];
+        for (const tuple of this._list) {
+            if (tuple[0] === name) {
+                output.push(tuple[1]);
+            }
+        }
+        return output;
+    }
+    has(name) {
+        for (const tuple of this._list) {
+            if (tuple[0] === name) {
+                return true;
+            }
+        }
+        return false;
+    }
+    set(name, value) {
+        let found = false;
+        let i = 0;
+        while (i < this._list.length) {
+            if (this._list[i][0] === name) {
+                if (found) {
+                    this._list.splice(i, 1);
+                }
+                else {
+                    found = true;
+                    this._list[i][1] = value;
+                    i++;
+                }
+            }
+            else {
+                i++;
+            }
+        }
+        if (!found) {
+            this._list.push([name, value]);
+        }
+        this._updateSteps();
+    }
+    sort() {
+        this._list = stableSortBy(this._list, (a, b) => a[0] > b[0]);
+        this._updateSteps();
+    }
+    [Symbol.iterator]() {
+        return this._list[Symbol.iterator]();
+    }
+    toString() {
+        return urlencoded_1.default.serializeUrlencoded(this._list);
+    }
+};
+exports.default = {
+    implementation
+};

package/lib/utils/url/whatwg-url/lib/URLSearchParams.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/utils/url/whatwg-url/lib/URLSearchParams.js

@@ -0,0 +1,426 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+// @ts-nocheck
+const webidl_conversions_1 = tslib_1.__importDefault(require("webidl-conversions"));
+const utils_1 = tslib_1.__importDefault(require("./utils"));
+const impl = utils_1.default.implSymbol;
+const ctorRegistry = utils_1.default.ctorRegistrySymbol;
+const IteratorPrototype = Object.create(utils_1.default.IteratorPrototype, {
+    next: {
+        value: function next() {
+            const internal = this[utils_1.default.iterInternalSymbol];
+            const { target, kind, index } = internal;
+            const values = Array.from(target[impl]);
+            const len = values.length;
+            if (index >= len) {
+                return { value: undefined, done: true };
+            }
+            const pair = values[index];
+            internal.index = index + 1;
+            const [key, value] = pair.map(utils_1.default.tryWrapperForImpl);
+            let result;
+            switch (kind) {
+                case 'key':
+                    result = key;
+                    break;
+                case 'value':
+                    result = value;
+                    break;
+                case 'key+value':
+                    result = [key, value];
+                    break;
+            }
+            return { value: result, done: false };
+        },
+        writable: true,
+        enumerable: true,
+        configurable: true,
+    },
+    [Symbol.toStringTag]: {
+        value: 'URLSearchParams Iterator',
+        configurable: true,
+    },
+});
+const iface = {
+    // When an interface-module that implements this interface as a mixin is loaded, it will append its own `.is()`
+    // method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+    // implementing this mixin interface.
+    _mixedIntoPredicates: [],
+    is(obj) {
+        if (obj) {
+            if (utils_1.default.hasOwn(obj, impl) &&
+                obj[impl] instanceof URLSearchParams_impl_1.default.implementation) {
+                return true;
+            }
+            for (const isMixedInto of module.exports._mixedIntoPredicates) {
+                if (isMixedInto(obj)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    },
+    isImpl(obj) {
+        if (obj) {
+            if (obj instanceof URLSearchParams_impl_1.default.implementation) {
+                return true;
+            }
+            const wrapper = utils_1.default.wrapperForImpl(obj);
+            for (const isMixedInto of module.exports._mixedIntoPredicates) {
+                if (isMixedInto(wrapper)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    },
+    convert(obj, { context = 'The provided value' } = {}) {
+        if (module.exports.is(obj)) {
+            return utils_1.default.implForWrapper(obj);
+        }
+        throw new TypeError(`${context} is not of type 'URLSearchParams'.`);
+    },
+    createDefaultIterator(target, kind) {
+        const iterator = Object.create(IteratorPrototype);
+        Object.defineProperty(iterator, utils_1.default.iterInternalSymbol, {
+            value: { target, kind, index: 0 },
+            configurable: true,
+        });
+        return iterator;
+    },
+    create(globalObject, constructorArgs, privateData) {
+        if (globalObject[ctorRegistry] === undefined) {
+            throw new Error('Internal error: invalid global object');
+        }
+        const ctor = globalObject[ctorRegistry]['URLSearchParams'];
+        if (ctor === undefined) {
+            throw new Error('Internal error: constructor URLSearchParams is not installed on the passed global object');
+        }
+        let obj = Object.create(ctor.prototype);
+        obj = iface.setup(obj, globalObject, constructorArgs, privateData);
+        return obj;
+    },
+    createImpl(globalObject, constructorArgs, privateData) {
+        const obj = iface.create(globalObject, constructorArgs, privateData);
+        return utils_1.default.implForWrapper(obj);
+    },
+    _internalSetup(obj) { },
+    setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+        privateData.wrapper = obj;
+        iface._internalSetup(obj);
+        Object.defineProperty(obj, impl, {
+            value: new URLSearchParams_impl_1.default.implementation(globalObject, constructorArgs, privateData),
+            configurable: true,
+        });
+        obj[impl][utils_1.default.wrapperSymbol] = obj;
+        if (URLSearchParams_impl_1.default.init) {
+            URLSearchParams_impl_1.default.init(obj[impl], privateData);
+        }
+        return obj;
+    },
+    install(globalObject) {
+        class URLSearchParams {
+            constructor() {
+                const args = [];
+                {
+                    let curArg = arguments[0];
+                    if (curArg !== undefined) {
+                        if (utils_1.default.isObject(curArg)) {
+                            if (curArg[Symbol.iterator] !== undefined) {
+                                if (!utils_1.default.isObject(curArg)) {
+                                    throw new TypeError("Failed to construct 'URLSearchParams': parameter 1" +
+                                        ' sequence' +
+                                        ' is not an iterable object.');
+                                }
+                                else {
+                                    const V = [];
+                                    const tmp = curArg;
+                                    for (let nextItem of tmp) {
+                                        if (!utils_1.default.isObject(nextItem)) {
+                                            throw new TypeError("Failed to construct 'URLSearchParams': parameter 1" +
+                                                ' sequence' +
+                                                "'s element" +
+                                                ' is not an iterable object.');
+                                        }
+                                        else {
+                                            const V = [];
+                                            const tmp = nextItem;
+                                            for (let nextItem of tmp) {
+                                                nextItem = webidl_conversions_1.default['USVString'](nextItem, {
+                                                    context: "Failed to construct 'URLSearchParams': parameter 1" +
+                                                        ' sequence' +
+                                                        "'s element" +
+                                                        "'s element",
+                                                });
+                                                V.push(nextItem);
+                                            }
+                                            nextItem = V;
+                                        }
+                                        V.push(nextItem);
+                                    }
+                                    curArg = V;
+                                }
+                            }
+                            else {
+                                if (!utils_1.default.isObject(curArg)) {
+                                    throw new TypeError("Failed to construct 'URLSearchParams': parameter 1" +
+                                        ' record' +
+                                        ' is not an object.');
+                                }
+                                else {
+                                    const result = Object.create(null);
+                                    for (const key of Reflect.ownKeys(curArg)) {
+                                        const desc = Object.getOwnPropertyDescriptor(curArg, key);
+                                        if (desc && desc.enumerable) {
+                                            let typedKey = key;
+                                            typedKey = webidl_conversions_1.default['USVString'](typedKey, {
+                                                context: "Failed to construct 'URLSearchParams': parameter 1" +
+                                                    ' record' +
+                                                    "'s key",
+                                            });
+                                            let typedValue = curArg[key];
+                                            typedValue = webidl_conversions_1.default['USVString'](typedValue, {
+                                                context: "Failed to construct 'URLSearchParams': parameter 1" +
+                                                    ' record' +
+                                                    "'s value",
+                                            });
+                                            result[typedKey] = typedValue;
+                                        }
+                                    }
+                                    curArg = result;
+                                }
+                            }
+                        }
+                        else {
+                            curArg = webidl_conversions_1.default['USVString'](curArg, {
+                                context: "Failed to construct 'URLSearchParams': parameter 1",
+                            });
+                        }
+                    }
+                    else {
+                        curArg = '';
+                    }
+                    args.push(curArg);
+                }
+                return iface.setup(Object.create(this.constructor.prototype), globalObject, args);
+            }
+            append(name, value) {
+                if (!this || !module.exports.is(this)) {
+                    throw new TypeError('Illegal invocation');
+                }
+                if (arguments.length < 2) {
+                    throw new TypeError("Failed to execute 'append' on 'URLSearchParams': 2 arguments required, but only " +
+                        arguments.length +
+                        ' present.');
+                }
+                const args = [];
+                {
+                    let curArg = arguments[0];
+                    curArg = webidl_conversions_1.default['USVString'](curArg, {
+                        context: "Failed to execute 'append' on 'URLSearchParams': parameter 1",
+                    });
+                    args.push(curArg);
+                }
+                {
+                    let curArg = arguments[1];
+                    curArg = webidl_conversions_1.default['USVString'](curArg, {
+                        context: "Failed to execute 'append' on 'URLSearchParams': parameter 2",
+                    });
+                    args.push(curArg);
+                }
+                return this[impl].append(...args);
+            }
+            delete(name) {
+                if (!this || !module.exports.is(this)) {
+                    throw new TypeError('Illegal invocation');
+                }
+                if (arguments.length < 1) {
+                    throw new TypeError("Failed to execute 'delete' on 'URLSearchParams': 1 argument required, but only " +
+                        arguments.length +
+                        ' present.');
+                }
+                const args = [];
+                {
+                    let curArg = arguments[0];
+                    curArg = webidl_conversions_1.default['USVString'](curArg, {
+                        context: "Failed to execute 'delete' on 'URLSearchParams': parameter 1",
+                    });
+                    args.push(curArg);
+                }
+                return this[impl].delete(...args);
+            }
+            get(name) {
+                if (!this || !module.exports.is(this)) {
+                    throw new TypeError('Illegal invocation');
+                }
+                if (arguments.length < 1) {
+                    throw new TypeError("Failed to execute 'get' on 'URLSearchParams': 1 argument required, but only " +
+                        arguments.length +
+                        ' present.');
+                }
+                const args = [];
+                {
+                    let curArg = arguments[0];
+                    curArg = webidl_conversions_1.default['USVString'](curArg, {
+                        context: "Failed to execute 'get' on 'URLSearchParams': parameter 1",
+                    });
+                    args.push(curArg);
+                }
+                return this[impl].get(...args);
+            }
+            getAll(name) {
+                if (!this || !module.exports.is(this)) {
+                    throw new TypeError('Illegal invocation');
+                }
+                if (arguments.length < 1) {
+                    throw new TypeError("Failed to execute 'getAll' on 'URLSearchParams': 1 argument required, but only " +
+                        arguments.length +
+                        ' present.');
+                }
+                const args = [];
+                {
+                    let curArg = arguments[0];
+                    curArg = webidl_conversions_1.default['USVString'](curArg, {
+                        context: "Failed to execute 'getAll' on 'URLSearchParams': parameter 1",
+                    });
+                    args.push(curArg);
+                }
+                return utils_1.default.tryWrapperForImpl(this[impl].getAll(...args));
+            }
+            has(name) {
+                if (!this || !module.exports.is(this)) {
+                    throw new TypeError('Illegal invocation');
+                }
+                if (arguments.length < 1) {
+                    throw new TypeError("Failed to execute 'has' on 'URLSearchParams': 1 argument required, but only " +
+                        arguments.length +
+                        ' present.');
+                }
+                const args = [];
+                {
+                    let curArg = arguments[0];
+                    curArg = webidl_conversions_1.default['USVString'](curArg, {
+                        context: "Failed to execute 'has' on 'URLSearchParams': parameter 1",
+                    });
+                    args.push(curArg);
+                }
+                return this[impl].has(...args);
+            }
+            set(name, value) {
+                if (!this || !module.exports.is(this)) {
+                    throw new TypeError('Illegal invocation');
+                }
+                if (arguments.length < 2) {
+                    throw new TypeError("Failed to execute 'set' on 'URLSearchParams': 2 arguments required, but only " +
+                        arguments.length +
+                        ' present.');
+                }
+                const args = [];
+                {
+                    let curArg = arguments[0];
+                    curArg = webidl_conversions_1.default['USVString'](curArg, {
+                        context: "Failed to execute 'set' on 'URLSearchParams': parameter 1",
+                    });
+                    args.push(curArg);
+                }
+                {
+                    let curArg = arguments[1];
+                    curArg = webidl_conversions_1.default['USVString'](curArg, {
+                        context: "Failed to execute 'set' on 'URLSearchParams': parameter 2",
+                    });
+                    args.push(curArg);
+                }
+                return this[impl].set(...args);
+            }
+            sort() {
+                if (!this || !module.exports.is(this)) {
+                    throw new TypeError('Illegal invocation');
+                }
+                return this[impl].sort();
+            }
+            toString() {
+                if (!this || !module.exports.is(this)) {
+                    throw new TypeError('Illegal invocation');
+                }
+                return this[impl].toString();
+            }
+            keys() {
+                if (!this || !module.exports.is(this)) {
+                    throw new TypeError('Illegal invocation');
+                }
+                return module.exports.createDefaultIterator(this, 'key');
+            }
+            values() {
+                if (!this || !module.exports.is(this)) {
+                    throw new TypeError('Illegal invocation');
+                }
+                return module.exports.createDefaultIterator(this, 'value');
+            }
+            entries() {
+                if (!this || !module.exports.is(this)) {
+                    throw new TypeError('Illegal invocation');
+                }
+                return module.exports.createDefaultIterator(this, 'key+value');
+            }
+            forEach(callback) {
+                if (!this || !module.exports.is(this)) {
+                    throw new TypeError('Illegal invocation');
+                }
+                if (arguments.length < 1) {
+                    throw new TypeError("Failed to execute 'forEach' on 'iterable': 1 argument required, " +
+                        'but only 0 present.');
+                }
+                if (typeof callback !== 'function') {
+                    throw new TypeError("Failed to execute 'forEach' on 'iterable': The callback provided " +
+                        'as parameter 1 is not a function.');
+                }
+                const thisArg = arguments[1];
+                let pairs = Array.from(this[impl]);
+                let i = 0;
+                while (i < pairs.length) {
+                    const [key, value] = pairs[i].map(utils_1.default.tryWrapperForImpl);
+                    callback.call(thisArg, value, key, this);
+                    pairs = Array.from(this[impl]);
+                    i++;
+                }
+            }
+        }
+        Object.defineProperties(URLSearchParams.prototype, {
+            append: { enumerable: true },
+            delete: { enumerable: true },
+            get: { enumerable: true },
+            getAll: { enumerable: true },
+            has: { enumerable: true },
+            set: { enumerable: true },
+            sort: { enumerable: true },
+            toString: { enumerable: true },
+            keys: { enumerable: true },
+            values: { enumerable: true },
+            entries: { enumerable: true },
+            forEach: { enumerable: true },
+            [Symbol.toStringTag]: {
+                value: 'URLSearchParams',
+                configurable: true,
+            },
+            [Symbol.iterator]: {
+                value: URLSearchParams.prototype.entries,
+                configurable: true,
+                writable: true,
+            },
+        });
+        if (globalObject[ctorRegistry] === undefined) {
+            globalObject[ctorRegistry] = Object.create(null);
+        }
+        globalObject[ctorRegistry]['URLSearchParams'] = URLSearchParams;
+        Object.defineProperty(globalObject, 'URLSearchParams', {
+            configurable: true,
+            writable: true,
+            value: URLSearchParams,
+        });
+    },
+};
+// iface
+module.exports = iface;
+// const Impl = require('./URLSearchParams-impl')
+const URLSearchParams_impl_1 = tslib_1.__importDefault(require("./URLSearchParams-impl"));

package/lib/utils/url/whatwg-url/lib/infra.d.ts

@@ -0,0 +1,12 @@
+declare function isASCIIDigit(c: number): boolean;
+declare function isASCIIAlpha(c: number): boolean;
+declare function isASCIIAlphanumeric(c: number): boolean;
+declare function isASCIIHex(c: number): boolean;
+export { isASCIIDigit, isASCIIAlpha, isASCIIAlphanumeric, isASCIIHex, };
+declare const _default: {
+    isASCIIDigit: typeof isASCIIDigit;
+    isASCIIAlpha: typeof isASCIIAlpha;
+    isASCIIAlphanumeric: typeof isASCIIAlphanumeric;
+    isASCIIHex: typeof isASCIIHex;
+};
+export default _default;

package/lib/utils/url/whatwg-url/lib/infra.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isASCIIHex = exports.isASCIIAlphanumeric = exports.isASCIIAlpha = exports.isASCIIDigit = void 0;
+function isASCIIDigit(c) {
+    return c >= 0x30 && c <= 0x39;
+}
+exports.isASCIIDigit = isASCIIDigit;
+function isASCIIAlpha(c) {
+    return (c >= 0x41 && c <= 0x5A) || (c >= 0x61 && c <= 0x7A);
+}
+exports.isASCIIAlpha = isASCIIAlpha;
+function isASCIIAlphanumeric(c) {
+    return isASCIIAlpha(c) || isASCIIDigit(c);
+}
+exports.isASCIIAlphanumeric = isASCIIAlphanumeric;
+function isASCIIHex(c) {
+    return isASCIIDigit(c) || (c >= 0x41 && c <= 0x46) || (c >= 0x61 && c <= 0x66);
+}
+exports.isASCIIHex = isASCIIHex;
+exports.default = {
+    isASCIIDigit,
+    isASCIIAlpha,
+    isASCIIAlphanumeric,
+    isASCIIHex
+};

package/lib/utils/url/whatwg-url/lib/url-state-machine.d.ts

@@ -0,0 +1,24 @@
+declare function serializeHost(host: any): any;
+declare function cannotHaveAUsernamePasswordPort(url: any): any;
+declare function serializeURL(url: any, excludeFragment: any): string;
+export declare const serializeURL: typeof serializeURL;
+export declare const serializeURLOrigin: (url: any) => any;
+export declare const basicURLParse: (input: any, options: any) => any;
+export declare const setTheUsername: (url: any, username: any) => void;
+export declare const setThePassword: (url: any, password: any) => void;
+export declare const serializeHost: typeof serializeHost;
+export declare const cannotHaveAUsernamePasswordPort: typeof cannotHaveAUsernamePasswordPort;
+export declare const serializeInteger: (integer: any) => string;
+export declare const parseURL: (input: any, options: any) => any;
+declare const _default: {
+    parseURL: (input: any, options: any) => any;
+    serializeInteger: (integer: any) => string;
+    serializeHost: typeof serializeHost;
+    cannotHaveAUsernamePasswordPort: typeof cannotHaveAUsernamePasswordPort;
+    setThePassword: (url: any, password: any) => void;
+    setTheUsername: (url: any, username: any) => void;
+    basicURLParse: (input: any, options: any) => any;
+    serializeURLOrigin: (url: any) => any;
+    serializeURL: typeof serializeURL;
+};
+export default _default;