xhs-mp-pack 1.1.0-beta.0

package/dist/base/ModuleFilenameHelpers.js

@@ -0,0 +1,314 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchObject = exports.matchPart = exports.replaceDuplicates = exports.createFilename = exports.REGEXP_NAMESPACE = exports.NAMESPACE = exports.REGEXP_HASH = exports.HASH = exports.REGEXP_ID = exports.ID = exports.REGEXP_QUERY = exports.QUERY = exports.REGEXP_LOADERS = exports.LOADERS = exports.REGEXP_ALL_LOADERS = exports.ALL_LOADERS = exports.REGEXP_RESOURCE_PATH = exports.RESOURCE_PATH = exports.REGEXP_ABSOLUTE_RESOURCE_PATH = exports.ABSOLUTE_RESOURCE_PATH = exports.REGEXP_RESOURCE = exports.RESOURCE = exports.REGEXP_LOADERS_RESOURCE = exports.LOADERS_RESOURCE = exports.REGEXP_ALL_LOADERS_RESOURCE = exports.ALL_LOADERS_RESOURCE = void 0;
+const NormalModule_1 = __importDefault(require("@/module/NormalModule"));
+const createHash_1 = __importDefault(require("@/base/createHash"));
+const memoize_1 = __importDefault(require("@/base/memoize"));
+// TODO webpack 6: consider removing these
+exports.ALL_LOADERS_RESOURCE = '[all-loaders][resource]';
+exports.REGEXP_ALL_LOADERS_RESOURCE = /\[all-?loaders\]\[resource\]/gi;
+exports.LOADERS_RESOURCE = '[loaders][resource]';
+exports.REGEXP_LOADERS_RESOURCE = /\[loaders\]\[resource\]/gi;
+exports.RESOURCE = '[resource]';
+exports.REGEXP_RESOURCE = /\[resource\]/gi;
+exports.ABSOLUTE_RESOURCE_PATH = '[absolute-resource-path]';
+// cSpell:words olute
+exports.REGEXP_ABSOLUTE_RESOURCE_PATH = /\[abs(olute)?-?resource-?path\]/gi;
+exports.RESOURCE_PATH = '[resource-path]';
+exports.REGEXP_RESOURCE_PATH = /\[resource-?path\]/gi;
+exports.ALL_LOADERS = '[all-loaders]';
+exports.REGEXP_ALL_LOADERS = /\[all-?loaders\]/gi;
+exports.LOADERS = '[loaders]';
+exports.REGEXP_LOADERS = /\[loaders\]/gi;
+exports.QUERY = '[query]';
+exports.REGEXP_QUERY = /\[query\]/gi;
+exports.ID = '[id]';
+exports.REGEXP_ID = /\[id\]/gi;
+exports.HASH = '[hash]';
+exports.REGEXP_HASH = /\[hash\]/gi;
+exports.NAMESPACE = '[namespace]';
+exports.REGEXP_NAMESPACE = /\[namespace\]/gi;
+/**
+ * Returns a function that returns the part of the string after the token
+ */
+const getAfter = (strFn, token) => () => {
+    const str = strFn();
+    const idx = str.indexOf(token);
+    return idx < 0 ? '' : str.slice(idx);
+};
+/**
+ * Returns a function that returns the part of the string before the token
+ */
+const getBefore = (strFn, token) => () => {
+    const str = strFn();
+    const idx = str.lastIndexOf(token);
+    return idx < 0 ? '' : str.slice(0, idx);
+};
+/**
+ * Returns a function that returns a hash of the string
+ */
+const getHash = (strFn, hashFunction) => () => {
+    const hash = (0, createHash_1.default)(hashFunction);
+    hash.update(strFn());
+    const digest = hash.digest('hex');
+    return digest.slice(0, 4);
+};
+/**
+ * Returns a function that returns the string with the token replaced with the replacement
+ * ```js
+ * const test = asRegExp("test");
+ * test.test("test"); // true
+ *
+ * const test2 = asRegExp(/test/);
+ * test2.test("test"); // true
+ * ```
+ */
+const asRegExp = test => {
+    if (typeof test === 'string') {
+        // Escape special characters in the string to prevent them from being interpreted as special characters in a regular expression. Do this by
+        // adding a backslash before each special character
+        test = new RegExp(`^${test.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&')}`);
+    }
+    return test;
+};
+/**
+ * @template T
+ * Returns a lazy object. The object is lazy in the sense that the properties are
+ * only evaluated when they are accessed. This is only obtained by setting a function as the value for each key.
+ */
+const lazyObject = obj => {
+    const newObj = {};
+    for (const key of Object.keys(obj)) {
+        const fn = obj[key];
+        Object.defineProperty(newObj, key, {
+            get: () => fn(),
+            set: v => {
+                Object.defineProperty(newObj, key, {
+                    value: v,
+                    enumerable: true,
+                    writable: true,
+                });
+            },
+            enumerable: true,
+            configurable: true,
+        });
+    }
+    return newObj;
+};
+const SQUARE_BRACKET_TAG_REGEXP = /\[\\*([\w-]+)\\*\]/gi;
+const createFilename = (module, options, { requestShortener, chunkGraph, hashFunction = 'md4' }) => {
+    const opts = Object.assign({ namespace: '', moduleFilenameTemplate: '' }, (typeof options === 'object'
+        ? options
+        : {
+            moduleFilenameTemplate: options,
+        }));
+    let absoluteResourcePath;
+    let hash;
+    let identifier;
+    let moduleId;
+    let shortIdentifier;
+    if (typeof module === 'string') {
+        shortIdentifier = (0, memoize_1.default)(() => requestShortener.shorten(module));
+        identifier = shortIdentifier;
+        moduleId = () => '';
+        absoluteResourcePath = () => module.split('!').pop();
+        hash = getHash(identifier, hashFunction);
+    }
+    else {
+        shortIdentifier = (0, memoize_1.default)(() => module.readableIdentifier(requestShortener));
+        identifier = (0, memoize_1.default)(() => requestShortener.shorten(module.identifier()));
+        moduleId = () => chunkGraph.getModuleId(module);
+        absoluteResourcePath = () => module instanceof NormalModule_1.default ? module.resource : module.identifier().split('!').pop();
+        hash = getHash(identifier, hashFunction);
+    }
+    const resource = (0, memoize_1.default)(() => shortIdentifier().split('!').pop());
+    const loaders = getBefore(shortIdentifier, '!');
+    const allLoaders = getBefore(identifier, '!');
+    const query = getAfter(resource, '?');
+    const resourcePath = () => {
+        const q = query().length;
+        return q === 0 ? resource() : resource().slice(0, -q);
+    };
+    if (typeof opts.moduleFilenameTemplate === 'function') {
+        return opts.moduleFilenameTemplate(lazyObject({
+            identifier,
+            shortIdentifier,
+            resource,
+            resourcePath: (0, memoize_1.default)(resourcePath),
+            absoluteResourcePath: (0, memoize_1.default)(absoluteResourcePath),
+            loaders: (0, memoize_1.default)(loaders),
+            allLoaders: (0, memoize_1.default)(allLoaders),
+            query: (0, memoize_1.default)(query),
+            moduleId: (0, memoize_1.default)(moduleId),
+            hash: (0, memoize_1.default)(hash),
+            namespace: () => opts.namespace,
+        }));
+    }
+    // TODO webpack 6: consider removing alternatives without dashes
+    const replacements = new Map([
+        ['identifier', identifier],
+        ['short-identifier', shortIdentifier],
+        ['resource', resource],
+        ['resource-path', resourcePath],
+        // cSpell:words resourcepath
+        ['resourcepath', resourcePath],
+        ['absolute-resource-path', absoluteResourcePath],
+        ['abs-resource-path', absoluteResourcePath],
+        // cSpell:words absoluteresource
+        ['absoluteresource-path', absoluteResourcePath],
+        // cSpell:words absresource
+        ['absresource-path', absoluteResourcePath],
+        // cSpell:words resourcepath
+        ['absolute-resourcepath', absoluteResourcePath],
+        // cSpell:words resourcepath
+        ['abs-resourcepath', absoluteResourcePath],
+        // cSpell:words absoluteresourcepath
+        ['absoluteresourcepath', absoluteResourcePath],
+        // cSpell:words absresourcepath
+        ['absresourcepath', absoluteResourcePath],
+        ['all-loaders', allLoaders],
+        // cSpell:words allloaders
+        ['allloaders', allLoaders],
+        ['loaders', loaders],
+        ['query', query],
+        ['id', moduleId],
+        ['hash', hash],
+        ['namespace', () => opts.namespace],
+    ]);
+    // TODO webpack 6: consider removing weird double placeholders
+    return opts.moduleFilenameTemplate
+        .replace(exports.REGEXP_ALL_LOADERS_RESOURCE, '[identifier]')
+        .replace(exports.REGEXP_LOADERS_RESOURCE, '[short-identifier]')
+        .replace(SQUARE_BRACKET_TAG_REGEXP, (match, content) => {
+        if (content.length + 2 === match.length) {
+            const replacement = replacements.get(content.toLowerCase());
+            if (replacement !== undefined) {
+                return replacement();
+            }
+        }
+        else if (match.startsWith('[\\') && match.endsWith('\\]')) {
+            return `[${match.slice(2, -2)}]`;
+        }
+        return match;
+    });
+};
+exports.createFilename = createFilename;
+/**
+ * Replaces duplicate items in an array with new values generated by a callback function.
+ * The callback function is called with the duplicate item, the index of the duplicate item, and the number of times the item has been replaced.
+ * The callback function should return the new value for the duplicate item.
+ *
+ * @template T
+ * @param {T[]} array the array with duplicates to be replaced
+ * @param {(duplicateItem: T, duplicateItemIndex: number, numberOfTimesReplaced: number) => T} fn callback function to generate new values for the duplicate items
+ * @param {(firstElement:T, nextElement:T) => -1 | 0 | 1} [comparator] optional comparator function to sort the duplicate items
+ * @returns {T[]} the array with duplicates replaced
+ *
+ * @example
+ * ```js
+ * const array = ["a", "b", "c", "a", "b", "a"];
+ * const result = replaceDuplicates(array, (item, index, count) => `${item}-${count}`);
+ * // result: ["a-1", "b-1", "c", "a-2", "b-2", "a-3"]
+ * ```
+ */
+const replaceDuplicates = (array, fn, comparator) => {
+    const countMap = Object.create(null);
+    const posMap = Object.create(null);
+    array.forEach((item, idx) => {
+        countMap[item] = countMap[item] || [];
+        countMap[item].push(idx);
+        posMap[item] = 0;
+    });
+    if (comparator) {
+        Object.keys(countMap).forEach(item => {
+            countMap[item].sort(comparator);
+        });
+    }
+    return array.map((item, i) => {
+        if (countMap[item].length > 1) {
+            if (comparator && countMap[item][0] === i)
+                return item;
+            return fn(item, i, posMap[item]++);
+        }
+        return item;
+    });
+};
+exports.replaceDuplicates = replaceDuplicates;
+/**
+ * Tests if a string matches a RegExp or an array of RegExp.
+ *
+ * @param {string} str string to test
+ * @param {Matcher} test value which will be used to match against the string
+ * @returns {boolean} true, when the RegExp matches
+ *
+ * @example
+ * ```js
+ * matchPart("foo.js", "foo"); // true
+ * matchPart("foo.js", "foo.js"); // true
+ * matchPart("foo.js", "foo."); // false
+ * matchPart("foo.js", "foo*"); // false
+ * matchPart("foo.js", "foo.*"); // true
+ * matchPart("foo.js", /^foo/); // true
+ * matchPart("foo.js", [/^foo/, "bar"]); // true
+ * matchPart("foo.js", [/^foo/, "bar"]); // true
+ * matchPart("foo.js", [/^foo/, /^bar/]); // true
+ * matchPart("foo.js", [/^baz/, /^bar/]); // false
+ * ```
+ */
+const matchPart = (str, test) => {
+    if (!test)
+        return true;
+    if (Array.isArray(test)) {
+        return test.map(asRegExp).some(regExp => regExp.test(str));
+    }
+    return asRegExp(test).test(str);
+};
+exports.matchPart = matchPart;
+/**
+ * Tests if a string matches a match object. The match object can have the following properties:
+ * - `test`: a RegExp or an array of RegExp
+ * - `include`: a RegExp or an array of RegExp
+ * - `exclude`: a RegExp or an array of RegExp
+ *
+ * The `test` property is tested first, then `include` and then `exclude`.
+ *
+ * @param {MatchObject} obj a match object to test against the string
+ * @param {string} str string to test against the matching object
+ * @returns {boolean} true, when the object matches
+ * @example
+ * ```js
+ * matchObject({ test: "foo.js" }, "foo.js"); // true
+ * matchObject({ test: /^foo/ }, "foo.js"); // true
+ * matchObject({ test: [/^foo/, "bar"] }, "foo.js"); // true
+ * matchObject({ test: [/^foo/, "bar"] }, "baz.js"); // false
+ * matchObject({ include: "foo.js" }, "foo.js"); // true
+ * matchObject({ include: "foo.js" }, "bar.js"); // false
+ * matchObject({ include: /^foo/ }, "foo.js"); // true
+ * matchObject({ include: [/^foo/, "bar"] }, "foo.js"); // true
+ * matchObject({ include: [/^foo/, "bar"] }, "baz.js"); // false
+ * matchObject({ exclude: "foo.js" }, "foo.js"); // false
+ * matchObject({ exclude: [/^foo/, "bar"] }, "foo.js"); // false
+ * ```
+ */
+const matchObject = (obj, str) => {
+    if (obj.test) {
+        if (!(0, exports.matchPart)(str, obj.test)) {
+            return false;
+        }
+    }
+    if (obj.include) {
+        if (!(0, exports.matchPart)(str, obj.include)) {
+            return false;
+        }
+    }
+    if (obj.exclude) {
+        if ((0, exports.matchPart)(str, obj.exclude)) {
+            return false;
+        }
+    }
+    return true;
+};
+exports.matchObject = matchObject;

package/dist/base/NodeWatchFileSystem.d.ts

@@ -0,0 +1,23 @@
+declare class NodeWatchFileSystem {
+    inputFileSystem: any;
+    watcherOptions: {
+        aggregateTimeout: number;
+    };
+    watcher: any;
+    constructor(inputFileSystem: any);
+    watch(files: any, directories: any, missing: any, startTime: any, options: any, callback: any, callbackUndelayed: any): {
+        close: () => void;
+        pause: () => void;
+        getAggregatedRemovals: () => any;
+        getAggregatedChanges: () => any;
+        getFileTimeInfoEntries: () => Map<any, any>;
+        getContextTimeInfoEntries: () => Map<any, any>;
+        getInfo: () => {
+            changes: any;
+            removals: any;
+            fileTimeInfoEntries: Map<any, any>;
+            contextTimeInfoEntries: Map<any, any>;
+        };
+    };
+}
+export default NodeWatchFileSystem;

package/dist/base/NodeWatchFileSystem.js

@@ -0,0 +1,135 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = __importDefault(require("util"));
+const watchpack_1 = __importDefault(require("watchpack"));
+class NodeWatchFileSystem {
+    constructor(inputFileSystem) {
+        this.inputFileSystem = inputFileSystem;
+        this.watcherOptions = {
+            aggregateTimeout: 0,
+        };
+        this.watcher = new watchpack_1.default(this.watcherOptions);
+    }
+    watch(files, directories, missing, startTime, options, callback, callbackUndelayed) {
+        if (!files || typeof files[Symbol.iterator] !== 'function') {
+            throw new Error("Invalid arguments: 'files'");
+        }
+        if (!directories || typeof directories[Symbol.iterator] !== 'function') {
+            throw new Error("Invalid arguments: 'directories'");
+        }
+        if (!missing || typeof missing[Symbol.iterator] !== 'function') {
+            throw new Error("Invalid arguments: 'missing'");
+        }
+        if (typeof callback !== 'function') {
+            throw new Error("Invalid arguments: 'callback'");
+        }
+        if (typeof startTime !== 'number' && startTime) {
+            throw new Error("Invalid arguments: 'startTime'");
+        }
+        if (typeof options !== 'object') {
+            throw new Error("Invalid arguments: 'options'");
+        }
+        if (typeof callbackUndelayed !== 'function' && callbackUndelayed) {
+            throw new Error("Invalid arguments: 'callbackUndelayed'");
+        }
+        const oldWatcher = this.watcher;
+        this.watcher = new watchpack_1.default(options);
+        if (callbackUndelayed) {
+            this.watcher.once('change', callbackUndelayed);
+        }
+        const fetchTimeInfo = () => {
+            const fileTimeInfoEntries = new Map();
+            const contextTimeInfoEntries = new Map();
+            if (this.watcher) {
+                this.watcher.collectTimeInfoEntries(fileTimeInfoEntries, contextTimeInfoEntries);
+            }
+            return { fileTimeInfoEntries, contextTimeInfoEntries };
+        };
+        this.watcher.once('aggregated', (changes, removals) => {
+            var _a;
+            // pause emitting events (avoids clearing aggregated changes and removals on timeout)
+            this.watcher.pause();
+            if ((_a = this.inputFileSystem) === null || _a === void 0 ? void 0 : _a.purge) {
+                const fs = this.inputFileSystem;
+                for (const item of changes) {
+                    fs.purge(item);
+                }
+                for (const item of removals) {
+                    fs.purge(item);
+                }
+            }
+            const { fileTimeInfoEntries, contextTimeInfoEntries } = fetchTimeInfo();
+            callback(null, fileTimeInfoEntries, contextTimeInfoEntries, changes, removals);
+        });
+        this.watcher.watch({ files, directories, missing, startTime });
+        if (oldWatcher) {
+            oldWatcher.close();
+        }
+        return {
+            close: () => {
+                if (this.watcher) {
+                    this.watcher.close();
+                    this.watcher = null;
+                }
+            },
+            pause: () => {
+                if (this.watcher) {
+                    this.watcher.pause();
+                }
+            },
+            getAggregatedRemovals: util_1.default.deprecate(() => {
+                var _a;
+                const items = (_a = this.watcher) === null || _a === void 0 ? void 0 : _a.aggregatedRemovals;
+                if (items && this.inputFileSystem && this.inputFileSystem.purge) {
+                    const fs = this.inputFileSystem;
+                    for (const item of items) {
+                        fs.purge(item);
+                    }
+                }
+                return items;
+            }, "Watcher.getAggregatedRemovals is deprecated in favor of Watcher.getInfo since that's more performant.", 'DEP_WEBPACK_WATCHER_GET_AGGREGATED_REMOVALS'),
+            getAggregatedChanges: util_1.default.deprecate(() => {
+                var _a;
+                const items = (_a = this.watcher) === null || _a === void 0 ? void 0 : _a.aggregatedChanges;
+                if (items && this.inputFileSystem && this.inputFileSystem.purge) {
+                    const fs = this.inputFileSystem;
+                    for (const item of items) {
+                        fs.purge(item);
+                    }
+                }
+                return items;
+            }, "Watcher.getAggregatedChanges is deprecated in favor of Watcher.getInfo since that's more performant.", 'DEP_WEBPACK_WATCHER_GET_AGGREGATED_CHANGES'),
+            getFileTimeInfoEntries: util_1.default.deprecate(() => fetchTimeInfo().fileTimeInfoEntries, "Watcher.getFileTimeInfoEntries is deprecated in favor of Watcher.getInfo since that's more performant.", 'DEP_WEBPACK_WATCHER_FILE_TIME_INFO_ENTRIES'),
+            getContextTimeInfoEntries: util_1.default.deprecate(() => fetchTimeInfo().contextTimeInfoEntries, "Watcher.getContextTimeInfoEntries is deprecated in favor of Watcher.getInfo since that's more performant.", 'DEP_WEBPACK_WATCHER_CONTEXT_TIME_INFO_ENTRIES'),
+            getInfo: () => {
+                var _a, _b, _c;
+                const removals = (_a = this.watcher) === null || _a === void 0 ? void 0 : _a.aggregatedRemovals;
+                const changes = (_b = this.watcher) === null || _b === void 0 ? void 0 : _b.aggregatedChanges;
+                if ((_c = this.inputFileSystem) === null || _c === void 0 ? void 0 : _c.purge) {
+                    const fs = this.inputFileSystem;
+                    if (removals) {
+                        for (const item of removals) {
+                            fs.purge(item);
+                        }
+                    }
+                    if (changes) {
+                        for (const item of changes) {
+                            fs.purge(item);
+                        }
+                    }
+                }
+                const { fileTimeInfoEntries, contextTimeInfoEntries } = fetchTimeInfo();
+                return {
+                    changes,
+                    removals,
+                    fileTimeInfoEntries,
+                    contextTimeInfoEntries,
+                };
+            },
+        };
+    }
+}
+exports.default = NodeWatchFileSystem;

package/dist/base/ParallelismFactorCalculator.d.ts

@@ -0,0 +1,8 @@
+declare class ParallelismFactorCalculator {
+    _rangePoints: number[];
+    _rangeCallbacks: any[];
+    constructor();
+    range(start: number, end: number, callback: any): any;
+    calculate(): void;
+}
+export default ParallelismFactorCalculator;

package/dist/base/ParallelismFactorCalculator.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const binarySearchBounds_1 = __importDefault(require("@/base/binarySearchBounds"));
+class ParallelismFactorCalculator {
+    constructor() {
+        this._rangePoints = [];
+        this._rangeCallbacks = [];
+    }
+    range(start, end, callback) {
+        if (start === end)
+            return callback(1);
+        this._rangePoints.push(start);
+        this._rangePoints.push(end);
+        this._rangeCallbacks.push(callback);
+    }
+    calculate() {
+        const segments = Array.from(new Set(this._rangePoints)).sort((a, b) => (a < b ? -1 : 1));
+        const parallelism = segments.map(() => 0);
+        const rangeStartIndices = [];
+        for (let i = 0; i < this._rangePoints.length; i += 2) {
+            const start = this._rangePoints[i];
+            const end = this._rangePoints[i + 1];
+            let idx = binarySearchBounds_1.default.eq(segments, start);
+            rangeStartIndices.push(idx);
+            do {
+                parallelism[idx]++;
+                idx++;
+            } while (segments[idx] < end);
+        }
+        for (let i = 0; i < this._rangeCallbacks.length; i++) {
+            const start = this._rangePoints[i * 2];
+            const end = this._rangePoints[i * 2 + 1];
+            let idx = rangeStartIndices[i];
+            let sum = 0;
+            let totalDuration = 0;
+            let current = start;
+            do {
+                const p = parallelism[idx];
+                idx++;
+                const duration = segments[idx] - current;
+                totalDuration += duration;
+                current = segments[idx];
+                sum += p * duration;
+            } while (current < end);
+            this._rangeCallbacks[i](sum / totalDuration);
+        }
+    }
+}
+exports.default = ParallelismFactorCalculator;

package/dist/base/Queue.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @template T
+ */
+declare class Queue {
+    _set: Set<unknown>;
+    _iterator: any;
+    constructor(items?: any);
+    get length(): number;
+    enqueue(item: any): void;
+    dequeue(): any;
+}
+export default Queue;

package/dist/base/Queue.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @template T
+ */
+class Queue {
+    constructor(items) {
+        this._set = new Set(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)
+            return undefined;
+        this._set.delete(result.value);
+        return result.value;
+    }
+}
+exports.default = Queue;

package/dist/base/RequestShortener.d.ts

@@ -0,0 +1,6 @@
+declare class RequestShortener {
+    contextify: (identifier: any) => any;
+    constructor(dir: string, associatedObjectForCache?: object);
+    shorten(request: string | undefined | null): any;
+}
+export default RequestShortener;

package/dist/base/RequestShortener.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const identifier_1 = require("@/base/identifier");
+class RequestShortener {
+    constructor(dir, associatedObjectForCache) {
+        this.contextify = identifier_1.contextify.bindContextCache(dir, associatedObjectForCache);
+    }
+    shorten(request) {
+        if (!request) {
+            return request;
+        }
+        return this.contextify(request);
+    }
+}
+exports.default = RequestShortener;

package/dist/base/Semaphore.d.ts

@@ -0,0 +1,12 @@
+declare class Semaphore {
+    available: any;
+    waiters: any[];
+    /**
+     * Creates an instance of Semaphore.
+     */
+    constructor(available: any);
+    acquire(callback: any): void;
+    release(): void;
+    _continue(): void;
+}
+export default Semaphore;

package/dist/base/Semaphore.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Semaphore {
+    /**
+     * Creates an instance of Semaphore.
+     */
+    constructor(available) {
+        this.available = available;
+        this.waiters = [];
+        this._continue = this._continue.bind(this);
+    }
+    acquire(callback) {
+        if (this.available > 0) {
+            this.available--;
+            callback();
+        }
+        else {
+            this.waiters.push(callback);
+        }
+    }
+    release() {
+        this.available++;
+        if (this.waiters.length > 0) {
+            process.nextTick(this._continue);
+        }
+    }
+    _continue() {
+        if (this.available > 0) {
+            if (this.waiters.length > 0) {
+                this.available--;
+                const callback = this.waiters.pop();
+                callback();
+            }
+        }
+    }
+}
+exports.default = Semaphore;