xhs-mp-pack 1.1.0-beta.0

package/dist/base/numberHash.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * The maximum safe integer value for 32-bit integers.
+ */
+const SAFE_LIMIT = 0x80000000;
+/**
+ * The maximum safe integer value for 32-bit integers minus one. This is used
+ * in the algorithm to ensure that intermediate hash values do not exceed the
+ * 32-bit integer limit.
+ */
+const SAFE_PART = SAFE_LIMIT - 1;
+/**
+ * The number of 32-bit integers used to store intermediate hash values.
+ */
+const COUNT = 4;
+/**
+ * An array used to store intermediate hash values during the calculation.
+ */
+const arr = [0, 0, 0, 0, 0];
+/**
+ * An array of prime numbers used in the hash calculation.
+ */
+const primes = [3, 7, 17, 19];
+/**
+ * Computes a hash value for the given string and range. This hashing algorithm is a modified
+ * version of the [FNV-1a algorithm](https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function).
+ * It is optimized for speed and does **not** generate a cryptographic hash value.
+ *
+ * We use `numberHash` in `lib/ids/IdHelpers.js` to generate hash values for the module identifier. The generated
+ * hash is used as a prefix for the module id's to avoid collisions with other modules.
+ *
+ * ```js
+ * const numberHash = require("mp-compiler/@/base/util/numberHash");
+ * numberHash("hello", 1000); // 57
+ * numberHash("hello world"); // 990
+ * ```
+ *
+ */
+exports.default = (str, range) => {
+    /**
+     * Initialize the array with zeros before it is used
+     * to store intermediate hash values.
+     */
+    arr.fill(0);
+    // For each character in the string
+    for (let i = 0; i < str.length; i++) {
+        // Get the character code.
+        const c = str.charCodeAt(i);
+        // For each 32-bit integer used to store the hash value
+        // add the character code to the current hash value and multiply by the prime number and
+        // add the previous 32-bit integer.
+        arr[0] = (arr[0] + c * primes[0] + arr[3]) & SAFE_PART;
+        arr[1] = (arr[1] + c * primes[1] + arr[0]) & SAFE_PART;
+        arr[2] = (arr[2] + c * primes[2] + arr[1]) & SAFE_PART;
+        arr[3] = (arr[3] + c * primes[3] + arr[2]) & SAFE_PART;
+        // For each 32-bit integer used to store the hash value
+        // XOR the current hash value with the value of the next 32-bit integer.
+        arr[0] ^= (arr[arr[0] % COUNT] >> 1);
+        arr[1] ^= (arr[arr[1] % COUNT] >> 1);
+        arr[2] ^= (arr[arr[2] % COUNT] >> 1);
+        arr[3] ^= (arr[arr[3] % COUNT] >> 1);
+    }
+    if (range <= SAFE_PART) {
+        return (arr[0] + arr[1] + arr[2] + arr[3]) % range;
+    }
+    // Calculate the range extension.
+    const rangeExt = Math.floor(range / SAFE_LIMIT);
+    const sum1 = (arr[0] + arr[2]) & SAFE_PART;
+    const sum2 = (arr[0] + arr[2]) % rangeExt;
+    return (sum2 * SAFE_LIMIT + sum1) % range;
+};

package/dist/base/objectToMap.d.ts

@@ -0,0 +1 @@
+export default function objectToMap(obj: any): Map<string, unknown>;

package/dist/base/objectToMap.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function objectToMap(obj) {
+    return new Map(Object.entries(obj));
+}
+exports.default = objectToMap;

package/dist/base/processAsyncTree.d.ts

@@ -0,0 +1,2 @@
+declare const processAsyncTree: (items: any, concurrency: any, processor: any, callback: any) => any;
+export default processAsyncTree;

package/dist/base/processAsyncTree.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const processAsyncTree = (items, concurrency, processor, callback) => {
+    const queue = Array.from(items);
+    if (queue.length === 0)
+        return callback();
+    let processing = 0;
+    let finished = false;
+    let processScheduled = true;
+    const push = item => {
+        queue.push(item);
+        if (!processScheduled && processing < concurrency) {
+            processScheduled = true;
+            process.nextTick(processQueue);
+        }
+    };
+    const processorCallback = err => {
+        processing--;
+        if (err && !finished) {
+            finished = true;
+            callback(err);
+            return;
+        }
+        if (!processScheduled) {
+            processScheduled = true;
+            process.nextTick(processQueue);
+        }
+    };
+    const processQueue = () => {
+        if (finished)
+            return;
+        while (processing < concurrency && queue.length > 0) {
+            processing++;
+            const item = queue.pop();
+            processor(item, push, processorCallback);
+        }
+        processScheduled = false;
+        if (queue.length === 0 && processing === 0 && !finished) {
+            finished = true;
+            callback();
+        }
+    };
+    processQueue();
+};
+exports.default = processAsyncTree;

package/dist/base/propertyAccess.d.ts

@@ -0,0 +1,2 @@
+declare const propertyAccess: (properties: any, start?: number) => string;
+export default propertyAccess;

package/dist/base/propertyAccess.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const propertyName_1 = require("@/base/propertyName");
+const propertyAccess = (properties, start = 0) => {
+    let str = '';
+    for (let i = start; i < properties.length; i++) {
+        const p = properties[i];
+        if (`${+p}` === p) {
+            str += `[${p}]`;
+        }
+        else if (propertyName_1.SAFE_IDENTIFIER.test(p) && !propertyName_1.RESERVED_IDENTIFIER.has(p)) {
+            str += `.${p}`;
+        }
+        else {
+            str += `[${JSON.stringify(p)}]`;
+        }
+    }
+    return str;
+};
+exports.default = propertyAccess;

package/dist/base/propertyName.d.ts

@@ -0,0 +1,9 @@
+declare const SAFE_IDENTIFIER: RegExp;
+declare const RESERVED_IDENTIFIER: Set<string>;
+/**
+ * @summary Returns a valid JS property name for the given property.
+ * Certain strings like "default", "null", and names with whitespace are not
+ * valid JS property names, so they are returned as strings.
+ */
+declare const propertyName: (prop: string) => string;
+export { SAFE_IDENTIFIER, RESERVED_IDENTIFIER, propertyName };

package/dist/base/propertyName.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.propertyName = exports.RESERVED_IDENTIFIER = exports.SAFE_IDENTIFIER = void 0;
+const SAFE_IDENTIFIER = /^[_a-zA-Z$][_a-zA-Z$0-9]*$/;
+exports.SAFE_IDENTIFIER = SAFE_IDENTIFIER;
+const RESERVED_IDENTIFIER = new Set([
+    'break',
+    'case',
+    'catch',
+    'class',
+    'const',
+    'continue',
+    'debugger',
+    'default',
+    'delete',
+    'do',
+    'else',
+    'export',
+    'extends',
+    'finally',
+    'for',
+    'function',
+    'if',
+    'import',
+    'in',
+    'instanceof',
+    'new',
+    'return',
+    'super',
+    'switch',
+    'this',
+    'throw',
+    'try',
+    'typeof',
+    'var',
+    'void',
+    'while',
+    'with',
+    'enum',
+    // strict mode
+    'implements',
+    'interface',
+    'let',
+    'package',
+    'private',
+    'protected',
+    'public',
+    'static',
+    'yield',
+    'yield',
+    // module code
+    'await',
+    // skip future reserved keywords defined under ES1 till ES3
+    // additional
+    'null',
+    'true',
+    'false',
+]);
+exports.RESERVED_IDENTIFIER = RESERVED_IDENTIFIER;
+/**
+ * @summary Returns a valid JS property name for the given property.
+ * Certain strings like "default", "null", and names with whitespace are not
+ * valid JS property names, so they are returned as strings.
+ */
+const propertyName = (prop) => {
+    if (SAFE_IDENTIFIER.test(prop) && !RESERVED_IDENTIFIER.has(prop)) {
+        return prop;
+    }
+    return JSON.stringify(prop);
+};
+exports.propertyName = propertyName;

package/dist/base/semver.d.ts

@@ -0,0 +1,25 @@
+/** @typedef {(string|number|undefined|[])[]} SemVerRange */
+/**
+ * @param {string} str version string
+ * @returns {(string|number|undefined|[])[]} parsed version
+ */
+declare const parseVersion: (str: any) => any;
+/**
+ * @param {string} a version
+ * @param {string} b version
+ * @returns {boolean} true, iff a < b
+ */
+declare const versionLt: (a: any, b: any) => boolean;
+/**
+ * @param {string} str range string
+ * @returns {SemVerRange} parsed range
+ */
+declare const parseRange: (str: any) => any;
+declare const rangeToString: (range: any) => string;
+declare const satisfy: (range: any, version: string) => boolean;
+declare const stringifyHoley: (json: any) => string;
+declare const parseVersionRuntimeCode: (runtimeTemplate: any) => string;
+declare const versionLtRuntimeCode: (runtimeTemplate: any) => string;
+declare const rangeToStringRuntimeCode: (runtimeTemplate: any) => string;
+declare const satisfyRuntimeCode: (runtimeTemplate: any) => string;
+export { parseVersion, versionLt, parseRange, rangeToString, satisfy, stringifyHoley, parseVersionRuntimeCode, versionLtRuntimeCode, rangeToStringRuntimeCode, satisfyRuntimeCode, };