xhs-mp-pack 1.1.0-beta.0

package/dist/base/StringXor.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * StringXor class provides methods for performing
+ * [XOR operations](https://en.wikipedia.org/wiki/Exclusive_or) on strings. In this context
+ * we operating on the character codes of two strings, which are represented as
+ * [Buffer](https://nodejs.org/api/buffer.html) objects.
+ *
+ * We use [StringXor in webpack](https://github.com/webpack/webpack/commit/41a8e2ea483a544c4ccd3e6217bdfb80daffca39)
+ * to create a hash of the current state of the compilation. By XOR'ing the Module hashes, it
+ * doesn't matter if the Module hashes are sorted or not. This is useful because it allows us to avoid sorting the
+ * Module hashes.
+ *
+ * @example
+ * ```js
+ * const xor = new StringXor();
+ * xor.add('hello');
+ * xor.add('world');
+ * console.log(xor.toString());
+ * ```
+ *
+ * @example
+ * ```js
+ * const xor = new StringXor();
+ * xor.add('foo');
+ * xor.add('bar');
+ * const hash = createHash('sha256');
+ * hash.update(xor.toString());
+ * console.log(hash.digest('hex'));
+ * ```
+ */
+class StringXor {
+    constructor() {
+        this._value = undefined;
+    }
+    /**
+     * Adds a string to the current StringXor object.
+     */
+    add(str) {
+        const len = str.length;
+        const value = this._value;
+        if (value === undefined) {
+            /**
+             * We are choosing to use Buffer.allocUnsafe() because it is often faster than Buffer.alloc() because
+             * it allocates a new buffer of the specified size without initializing the memory.
+             */
+            const newValue = (this._value = Buffer.allocUnsafe(len));
+            for (let i = 0; i < len; i++) {
+                newValue[i] = str.charCodeAt(i);
+            }
+            return;
+        }
+        const valueLen = value.length;
+        if (valueLen < len) {
+            const newValue = (this._value = Buffer.allocUnsafe(len));
+            let i;
+            for (i = 0; i < valueLen; i++) {
+                newValue[i] = value[i] ^ str.charCodeAt(i);
+            }
+            for (; i < len; i++) {
+                newValue[i] = str.charCodeAt(i);
+            }
+        }
+        else {
+            for (let i = 0; i < len; i++) {
+                // eslint-disable-next-line operator-assignment
+                value[i] = value[i] ^ str.charCodeAt(i);
+            }
+        }
+    }
+    /**
+     * Returns a string that represents the current state of the StringXor object. We chose to use "latin1" encoding
+     * here because "latin1" encoding is a single-byte encoding that can represent all characters in the
+     * [ISO-8859-1 character set](https://en.wikipedia.org/wiki/ISO/IEC_8859-1). This is useful when working
+     * with binary data that needs to be represented as a string.
+     *
+     * @returns {string} Returns a string that represents the current state of the StringXor object.
+     */
+    toString() {
+        const value = this._value;
+        return value === undefined ? '' : value.toString('latin1');
+    }
+    /**
+     * Updates the hash with the current state of the StringXor object.
+     *
+     * @param {Hash} hash Hash instance
+     */
+    updateHash(hash) {
+        const value = this._value;
+        if (value !== undefined)
+            hash.update(value);
+    }
+}
+exports.default = StringXor;

package/dist/base/TupleQueue.d.ts

@@ -0,0 +1,10 @@
+import TupleSet from './TupleSet';
+declare class TupleQueue {
+    _set: TupleSet;
+    _iterator: any;
+    constructor(items?: never[]);
+    get length(): number;
+    enqueue(...item: any[]): void;
+    dequeue(): any;
+}
+export default TupleQueue;

package/dist/base/TupleQueue.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const TupleSet_1 = __importDefault(require("./TupleSet"));
+class TupleQueue {
+    constructor(items = []) {
+        this._set = new TupleSet_1.default(items);
+        this._iterator = this._set[Symbol.iterator]();
+    }
+    get length() {
+        return this._set.size;
+    }
+    enqueue(...item) {
+        this._set.add(...item);
+    }
+    dequeue() {
+        const result = this._iterator.next();
+        if (result.done) {
+            if (this._set.size > 0) {
+                this._iterator = this._set[Symbol.iterator]();
+                const value = this._iterator.next().value;
+                this._set.delete(...value);
+                return value;
+            }
+            return undefined;
+        }
+        this._set.delete(...result.value);
+        return result.value;
+    }
+}
+exports.default = TupleQueue;

package/dist/base/TupleSet.d.ts

@@ -0,0 +1,18 @@
+declare class TupleSet {
+    _map: Map<any, any>;
+    size: number;
+    constructor(init: any);
+    add(...args: any[]): void;
+    has(...args: any[]): any;
+    delete(...args: any[]): void;
+    [Symbol.iterator](): {
+        next(): {
+            done: boolean;
+            value: any[];
+        } | {
+            done: boolean;
+            value: undefined;
+        };
+    };
+}
+export default TupleSet;

package/dist/base/TupleSet.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class TupleSet {
+    constructor(init) {
+        this._map = new Map();
+        this.size = 0;
+        if (init) {
+            for (const tuple of init) {
+                this.add(...tuple);
+            }
+        }
+    }
+    add(...args) {
+        let map = this._map;
+        for (let i = 0; i < args.length - 2; i++) {
+            const arg = args[i];
+            const innerMap = map.get(arg);
+            if (innerMap === undefined) {
+                map.set(arg, (map = new Map()));
+            }
+            else {
+                map = innerMap;
+            }
+        }
+        const beforeLast = args[args.length - 2];
+        let set = map.get(beforeLast);
+        if (set === undefined) {
+            map.set(beforeLast, (set = new Set()));
+        }
+        const last = args[args.length - 1];
+        this.size -= set.size;
+        set.add(last);
+        this.size += set.size;
+    }
+    has(...args) {
+        let map = this._map;
+        for (let i = 0; i < args.length - 2; i++) {
+            const arg = args[i];
+            map = map.get(arg);
+            if (map === undefined) {
+                return false;
+            }
+        }
+        const beforeLast = args[args.length - 2];
+        const set = map.get(beforeLast);
+        if (set === undefined) {
+            return false;
+        }
+        const last = args[args.length - 1];
+        return set.has(last);
+    }
+    delete(...args) {
+        let map = this._map;
+        for (let i = 0; i < args.length - 2; i++) {
+            const arg = args[i];
+            map = map.get(arg);
+            if (map === undefined) {
+                return;
+            }
+        }
+        const beforeLast = args[args.length - 2];
+        const set = map.get(beforeLast);
+        if (set === undefined) {
+            return;
+        }
+        const last = args[args.length - 1];
+        this.size -= set.size;
+        set.delete(last);
+        this.size += set.size;
+    }
+    [Symbol.iterator]() {
+        const iteratorStack = [];
+        const tuple = [];
+        let currentSetIterator;
+        const next = it => {
+            const result = it.next();
+            if (result.done) {
+                if (iteratorStack.length === 0)
+                    return false;
+                tuple.pop();
+                return next(iteratorStack.pop());
+            }
+            const [key, value] = result.value;
+            iteratorStack.push(it);
+            tuple.push(key);
+            if (value instanceof Set) {
+                currentSetIterator = value[Symbol.iterator]();
+                return true;
+            }
+            return next(value[Symbol.iterator]());
+        };
+        next(this._map[Symbol.iterator]());
+        return {
+            next() {
+                while (currentSetIterator) {
+                    const result = currentSetIterator.next();
+                    if (result.done) {
+                        tuple.pop();
+                        if (!next(iteratorStack.pop())) {
+                            currentSetIterator = undefined;
+                        }
+                    }
+                    else {
+                        return {
+                            done: false,
+                            value: tuple.concat(result.value),
+                        };
+                    }
+                }
+                return { done: true, value: undefined };
+            },
+        };
+    }
+}
+exports.default = TupleSet;

package/dist/base/URLAbsoluteSpecifier.d.ts

@@ -0,0 +1,3 @@
+declare function getScheme(specifier: string): string | undefined;
+declare function getProtocol(specifier: string): string | undefined;
+export { getScheme, getProtocol };

package/dist/base/URLAbsoluteSpecifier.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProtocol = exports.getScheme = void 0;
+const backSlashCharCode = '\\'.charCodeAt(0);
+const slashCharCode = '/'.charCodeAt(0);
+const aLowerCaseCharCode = 'a'.charCodeAt(0);
+const zLowerCaseCharCode = 'z'.charCodeAt(0);
+const aUpperCaseCharCode = 'A'.charCodeAt(0);
+const zUpperCaseCharCode = 'Z'.charCodeAt(0);
+const _0CharCode = '0'.charCodeAt(0);
+const _9CharCode = '9'.charCodeAt(0);
+const plusCharCode = '+'.charCodeAt(0);
+const hyphenCharCode = '-'.charCodeAt(0);
+const colonCharCode = ':'.charCodeAt(0);
+const hashCharCode = '#'.charCodeAt(0);
+const queryCharCode = '?'.charCodeAt(0);
+function getScheme(specifier) {
+    const start = specifier.charCodeAt(0);
+    // First char maybe only a letter
+    if ((start < aLowerCaseCharCode || start > zLowerCaseCharCode) &&
+        (start < aUpperCaseCharCode || start > zUpperCaseCharCode)) {
+        return undefined;
+    }
+    let i = 1;
+    let ch = specifier.charCodeAt(i);
+    while ((ch >= aLowerCaseCharCode && ch <= zLowerCaseCharCode) ||
+        (ch >= aUpperCaseCharCode && ch <= zUpperCaseCharCode) ||
+        (ch >= _0CharCode && ch <= _9CharCode) ||
+        ch === plusCharCode ||
+        ch === hyphenCharCode) {
+        if (++i === specifier.length)
+            return undefined;
+        ch = specifier.charCodeAt(i);
+    }
+    // Scheme must end with colon
+    if (ch !== colonCharCode)
+        return undefined;
+    // Check for Windows absolute path
+    // https://url.spec.whatwg.org/#url-miscellaneous
+    if (i === 1) {
+        const nextChar = i + 1 < specifier.length ? specifier.charCodeAt(i + 1) : 0;
+        if (nextChar === 0 ||
+            nextChar === backSlashCharCode ||
+            nextChar === slashCharCode ||
+            nextChar === hashCharCode ||
+            nextChar === queryCharCode) {
+            return undefined;
+        }
+    }
+    return specifier.slice(0, i).toLowerCase();
+}
+exports.getScheme = getScheme;
+function getProtocol(specifier) {
+    const scheme = getScheme(specifier);
+    return scheme === undefined ? undefined : `${scheme}:`;
+}
+exports.getProtocol = getProtocol;

package/dist/base/WeakTupleMap.d.ts

@@ -0,0 +1,20 @@
+declare class WeakTupleMap {
+    f: number;
+    v: any;
+    m: any;
+    w: any;
+    constructor();
+    set(...args: any[]): void;
+    has(...args: any[]): boolean;
+    get(...args: any[]): any;
+    provide(...args: any[]): any;
+    delete(...args: any[]): void;
+    clear(): void;
+    _getValue(): any;
+    _hasValue(): boolean;
+    _setValue(v: any): void;
+    _deleteValue(): void;
+    _peek(thing: any): any;
+    _get(thing: any): any;
+}
+export default WeakTupleMap;

package/dist/base/WeakTupleMap.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const isWeakKey = thing => typeof thing === 'object' && thing !== null;
+class WeakTupleMap {
+    constructor() {
+        /** @private */
+        this.f = 0;
+        /** @private @type {any} */
+        this.v = undefined;
+        /** @private @type {Map<object, WeakTupleMap<T, V>> | undefined} */
+        this.m = undefined;
+        /** @private @type {WeakMap<object, WeakTupleMap<T, V>> | undefined} */
+        this.w = undefined;
+    }
+    set(...args) {
+        let node = this;
+        for (let i = 0; i < args.length - 1; i++) {
+            node = node._get(args[i]);
+        }
+        node._setValue(args[args.length - 1]);
+    }
+    has(...args) {
+        let node = this;
+        for (let i = 0; i < args.length; i++) {
+            node = node._peek(args[i]);
+            if (node === undefined)
+                return false;
+        }
+        return node._hasValue();
+    }
+    get(...args) {
+        let node = this;
+        for (let i = 0; i < args.length; i++) {
+            node = node._peek(args[i]);
+            if (node === undefined)
+                return undefined;
+        }
+        return node._getValue();
+    }
+    provide(...args) {
+        let node = this;
+        for (let i = 0; i < args.length - 1; i++) {
+            node = node._get(args[i]);
+        }
+        if (node._hasValue())
+            return node._getValue();
+        const fn = args[args.length - 1];
+        const newValue = fn(...args.slice(0, -1));
+        node._setValue(newValue);
+        return newValue;
+    }
+    delete(...args) {
+        let node = this;
+        for (let i = 0; i < args.length; i++) {
+            node = node._peek(args[i]);
+            if (node === undefined)
+                return;
+        }
+        node._deleteValue();
+    }
+    clear() {
+        this.f = 0;
+        this.v = undefined;
+        this.w = undefined;
+        this.m = undefined;
+    }
+    _getValue() {
+        return this.v;
+    }
+    _hasValue() {
+        return (this.f & 1) === 1;
+    }
+    _setValue(v) {
+        this.f |= 1;
+        this.v = v;
+    }
+    _deleteValue() {
+        this.f &= 6;
+        this.v = undefined;
+    }
+    _peek(thing) {
+        if (isWeakKey(thing)) {
+            if ((this.f & 4) !== 4)
+                return undefined;
+            return this.w.get(thing);
+        }
+        if ((this.f & 2) !== 2)
+            return undefined;
+        return this.m.get(thing);
+    }
+    _get(thing) {
+        if (isWeakKey(thing)) {
+            if ((this.f & 4) !== 4) {
+                const newMap = new WeakMap();
+                this.f |= 4;
+                const newNode = new WeakTupleMap();
+                (this.w = newMap).set(thing, newNode);
+                return newNode;
+            }
+            const entry = this.w.get(thing);
+            if (entry !== undefined) {
+                return entry;
+            }
+            const newNode = new WeakTupleMap();
+            this.w.set(thing, newNode);
+            return newNode;
+        }
+        if ((this.f & 2) !== 2) {
+            const newMap = new Map();
+            this.f |= 2;
+            const newNode = new WeakTupleMap();
+            (this.m = newMap).set(thing, newNode);
+            return newNode;
+        }
+        const entry = this.m.get(thing);
+        if (entry !== undefined) {
+            return entry;
+        }
+        const newNode = new WeakTupleMap();
+        this.m.set(thing, newNode);
+        return newNode;
+    }
+}
+exports.default = WeakTupleMap;

package/dist/base/binarySearchBounds.d.ts

@@ -0,0 +1,23 @@
+/**
+ * These functions are used to perform binary searches on arrays.
+ *
+ * @example
+ * ```js
+ * const { gt, le} = require("./binarySearchBounds");
+ * const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+ *
+ * // Find the index of the first element greater than 5
+ * const index1 = gt(arr, 5); // index1 === 3
+ *
+ * // Find the index of the first element less than or equal to 5
+ * const index2 = le(arr, 5); // index2 === 4
+ * ```
+ */
+declare const _default: {
+    ge: any;
+    gt: any;
+    lt: any;
+    le: any;
+    eq: any;
+};
+export default _default;

package/dist/base/binarySearchBounds.js

@@ -0,0 +1,105 @@
+"use strict";
+/* cspell:disable-next-line */
+// Refactor: Peter Somogyvari @petermetz
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Helper function for compiling binary search functions.
+ *
+ * The generated code uses a while loop to repeatedly divide the search interval
+ * in half until the desired element is found, or the search interval is empty.
+ *
+ * The following is an example of a generated function for calling `compileSearch("P", "c(x,y)<=0", true, ["y", "c"], false)`:
+ *
+ * ```js
+ * function P(a,l,h,y,c){var i=l-1;while(l<=h){var m=(l+h)>>>1,x=a[m];if(c(x,y)<=0){i=m;l=m+1}else{h=m-1}}return i};
+ * ```
+ *
+ * @param {string} funcName The name of the function to be compiled.
+ * @param {string} predicate The predicate / comparison operator to be used in the binary search.
+ * @param {boolean} reversed Whether the search should be reversed.
+ * @param {string[]} extraArgs Extra arguments to be passed to the function.
+ * @param {boolean=} earlyOut Whether the search should return as soon as a match is found.
+ * @returns {string} The compiled binary search function.
+ */
+const compileSearch = (funcName, predicate, reversed, extraArgs, earlyOut) => {
+    const code = [
+        'function ',
+        funcName,
+        '(a,l,h,',
+        extraArgs.join(','),
+        '){',
+        earlyOut ? '' : 'var i=',
+        reversed ? 'l-1' : 'h+1',
+        ';while(l<=h){var m=(l+h)>>>1,x=a[m]',
+    ];
+    if (earlyOut) {
+        if (predicate.indexOf('c') < 0) {
+            code.push(';if(x===y){return m}else if(x<=y){');
+        }
+        else {
+            code.push(';var p=c(x,y);if(p===0){return m}else if(p<=0){');
+        }
+    }
+    else {
+        code.push(';if(', predicate, '){i=m;');
+    }
+    if (reversed) {
+        code.push('l=m+1}else{h=m-1}');
+    }
+    else {
+        code.push('h=m-1}else{l=m+1}');
+    }
+    code.push('}');
+    if (earlyOut) {
+        code.push('return -1};');
+    }
+    else {
+        code.push('return i};');
+    }
+    return code.join('');
+};
+/**
+ * This helper functions generate code for two binary search functions:
+ * A(): Performs a binary search on an array using the comparison operator specified.
+ * P(): Performs a binary search on an array using a _custom comparison function_
+ * `c(x,y)` **and** comparison operator specified by `predicate`.
+ */
+const compileBoundsSearch = (predicate, reversed, suffix, earlyOut) => {
+    const arg1 = compileSearch('A', `x${predicate}y`, reversed, ['y'], earlyOut);
+    const arg2 = compileSearch('P', `c(x,y)${predicate}0`, reversed, ['y', 'c'], earlyOut);
+    const fnHeader = 'function dispatchBinarySearch';
+    const fnBody = `(a,y,c,l,h){\
+if(typeof(c)==='function'){\
+return P(a,(l===void 0)?0:l|0,(h===void 0)?a.length-1:h|0,y,c)\
+}else{\
+return A(a,(c===void 0)?0:c|0,(l===void 0)?a.length-1:l|0,y)\
+}}\
+return dispatchBinarySearch`;
+    const fnArgList = [arg1, arg2, fnHeader, suffix, fnBody, suffix];
+    const fnSource = fnArgList.join('');
+    // eslint-disable-next-line no-new-func
+    const result = new Function(fnSource);
+    return result();
+};
+/**
+ * These functions are used to perform binary searches on arrays.
+ *
+ * @example
+ * ```js
+ * const { gt, le} = require("./binarySearchBounds");
+ * const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+ *
+ * // Find the index of the first element greater than 5
+ * const index1 = gt(arr, 5); // index1 === 3
+ *
+ * // Find the index of the first element less than or equal to 5
+ * const index2 = le(arr, 5); // index2 === 4
+ * ```
+ */
+exports.default = {
+    ge: compileBoundsSearch('>=', false, 'GE'),
+    gt: compileBoundsSearch('>', false, 'GT'),
+    lt: compileBoundsSearch('<', true, 'LT'),
+    le: compileBoundsSearch('<=', true, 'LE'),
+    eq: compileBoundsSearch('-', true, 'EQ', true),
+};

package/dist/base/cleverMerge.d.ts

@@ -0,0 +1,27 @@
+declare const DELETE: unique symbol;
+/**
+ * Merges two given objects and caches the result to avoid computation if same objects passed as arguments again.
+ * @template T
+ * @template O
+ * @example
+ * // performs cleverMerge(first, second), stores the result in WeakMap and returns result
+ * cachedCleverMerge({a: 1}, {a: 2})
+ * {a: 2}
+ *  // when same arguments passed, gets the result from WeakMap and returns it.
+ * cachedCleverMerge({a: 1}, {a: 2})
+ * {a: 2}
+ * @param {T} first first object
+ * @param {O} second second object
+ * @returns {T & O | T | O} merged object of first and second object
+ */
+declare const cachedCleverMerge: (first: any, second: any) => any;
+declare const cachedSetProperty: (obj: any, property: any, value: any) => any;
+/**
+ * Merges two objects. Objects are deeply clever merged.
+ * Arrays might reference the old value with "...".
+ * Non-object values take preference over object values.
+ */
+declare const cleverMerge: (first: any, second: any) => any;
+declare const removeOperations: (obj: any) => {};
+declare const resolveByProperty: (obj: any, byProperty: any, ...values: any[]) => any;
+export { DELETE, cachedCleverMerge, cachedSetProperty, cleverMerge, removeOperations, resolveByProperty, };