@rspack/core 1.0.0-alpha.4 → 1.0.0-beta.0

package/dist/util/cleverMerge.d.ts

@@ -1,42 +1,16 @@
-export type ObjectParsedPropertyEntry = {
-    /**
-     * base value
-     */
-    base: any | undefined;
-    /**
-     * the name of the selector property
-     */
-    byProperty: string | undefined;
-    /**
-     * value depending on selector property, merged with base
-     */
-    byValues: Map<string, any>;
-};
-export type ParsedObject = {
-    /**
-     * static properties (key is property name)
-     */
-    static: Map<string, ObjectParsedPropertyEntry>;
-    /**
-     * dynamic part
-     */
-    dynamic: {
-        byProperty: string;
-        fn: Function;
-    } | undefined;
-};
 /**
- * @template T
- * @param {Partial<T>} obj object
- * @param {string} property property
- * @param {string|number|boolean} value assignment value
- * @returns {T} new object
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/util/cleverMerge.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
  */
-export function cachedSetProperty<T>(obj: Partial<T>, property: string, value: string | number | boolean): T;
+type Obj = Record<PropertyKey, any>;
+export 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})
@@ -44,35 +18,37 @@ export function cachedSetProperty<T>(obj: Partial<T>, property: string, value: s
  *  // 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
+ * @param first first object
+ * @param second second object
+ * @returns  merged object of first and second object
  */
-export function cachedCleverMerge<T, O>(first: T, second: O): T | O | (T & O);
+export declare const cachedCleverMerge: <First, Second>(first: First, second: Second) => First | Second | (First & Second);
+/**
+ * @param obj object
+ * @param property property
+ * @param value assignment value
+ * @returns new object
+ */
+export declare const cachedSetProperty: (obj: Obj, property: string, value: string | number | boolean) => Obj;
 /**
  * Merges two objects. Objects are deeply clever merged.
  * Arrays might reference the old value with "...".
  * Non-object values take preference over object values.
- * @template T
- * @template O
- * @param {T} first first object
- * @param {O} second second object
- * @returns {T & O | T | O} merged object of first and second object
+ * @param first first object
+ * @param second second object
+ * @returns merged object of first and second object
  */
-export function cleverMerge<T, O>(first: T, second: O): T | O | (T & O);
+export declare const cleverMerge: <First, Second>(first: First, second: Second) => First | Second | (First & Second);
 /**
- * @template T
- * @template {string} P
- * @param {T} obj the object
- * @param {P} byProperty the by description
- * @param  {...any} values values
- * @returns {Omit<T, P>|undefined} object with merged byProperty
+ * @param obj the object
+ * @returns the object without operations like "..." or DELETE
  */
-export function resolveByProperty<T, P extends string>(obj: T, byProperty: P, ...values: any[]): Omit<T, P> | undefined;
+export declare const removeOperations: <O extends Obj>(obj: O) => O;
 /**
- * @template T
- * @param {T} obj the object
- * @returns {T} the object without operations like "..." or DELETE
+ * @param obj the object
+ * @param byProperty the by description
+ * @param values values
+ * @returns object with merged byProperty
  */
-export function removeOperations<T>(obj: T): T;
-export const DELETE: unique symbol;
+export declare const resolveByProperty: <O extends Obj | null, P extends PropertyKey>(obj: O, byProperty: P, ...values: any[]) => Omit<O, P> | undefined;
+export {};

package/dist/util/cleverMerge.js

@@ -1,23 +1,12 @@
-/**
- * The following code is modified based on
- * https://github.com/webpack/webpack/blob/4b4ca3b/lib/util/cleverMerge.js
- *
- * MIT Licensed
- * Author Tobias Koppers @sokra
- * Copyright (c) JS Foundation and other contributors
- * https://github.com/webpack/webpack/blob/main/LICENSE
- */
 "use strict";
-/** @type {WeakMap<object, WeakMap<object, object>>} */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveByProperty = exports.removeOperations = exports.cleverMerge = exports.cachedSetProperty = exports.cachedCleverMerge = exports.DELETE = void 0;
 const mergeCache = new WeakMap();
-/** @type {WeakMap<object, Map<string, Map<string|number|boolean, object>>>} */
 const setPropertyCache = new WeakMap();
-const DELETE = Symbol("DELETE");
+exports.DELETE = Symbol("DELETE");
 const DYNAMIC_INFO = Symbol("cleverMerge dynamic info");
 /**
  * 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})
@@ -25,9 +14,9 @@ const DYNAMIC_INFO = Symbol("cleverMerge dynamic info");
  *  // 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
+ * @param first first object
+ * @param second second object
+ * @returns  merged object of first and second object
  */
 const cachedCleverMerge = (first, second) => {
     if (second === undefined)
@@ -44,20 +33,18 @@ const cachedCleverMerge = (first, second) => {
         mergeCache.set(first, innerCache);
     }
     const prevMerge = innerCache.get(second);
-    // @ts-expect-error
     if (prevMerge !== undefined)
         return prevMerge;
     const newMerge = _cleverMerge(first, second, true);
     innerCache.set(second, newMerge);
-    // @ts-expect-error
     return newMerge;
 };
+exports.cachedCleverMerge = cachedCleverMerge;
 /**
- * @template T
- * @param {Partial<T>} obj object
- * @param {string} property property
- * @param {string|number|boolean} value assignment value
- * @returns {T} new object
+ * @param obj object
+ * @param property property
+ * @param value assignment value
+ * @returns new object
  */
 const cachedSetProperty = (obj, property, value) => {
     let mapByProperty = setPropertyCache.get(obj);
@@ -71,7 +58,6 @@ const cachedSetProperty = (obj, property, value) => {
         mapByProperty.set(property, mapByValue);
     }
     let result = mapByValue.get(value);
-    // @ts-expect-error
     if (result)
         return result;
     result = {
@@ -79,27 +65,15 @@ const cachedSetProperty = (obj, property, value) => {
         [property]: value
     };
     mapByValue.set(value, result);
-    // @ts-expect-error
     return result;
 };
-/**
- * @typedef {Object} ObjectParsedPropertyEntry
- * @property {any | undefined} base base value
- * @property {string | undefined} byProperty the name of the selector property
- * @property {Map<string, any>} byValues value depending on selector property, merged with base
- */
-/**
- * @typedef {Object} ParsedObject
- * @property {Map<string, ObjectParsedPropertyEntry>} static static properties (key is property name)
- * @property {{ byProperty: string, fn: Function } | undefined} dynamic dynamic part
- */
-/** @type {WeakMap<object, ParsedObject>} */
+exports.cachedSetProperty = cachedSetProperty;
 const parseCache = new WeakMap();
 /**
- * @param {object} obj the object
- * @returns {ParsedObject} parsed object
+ * @param obj the object
+ * @returns parsed object
  */
-const cachedParseObject = obj => {
+const cachedParseObject = (obj) => {
     const entry = parseCache.get(obj);
     if (entry !== undefined)
         return entry;
@@ -111,18 +85,17 @@ const cachedParseObject = obj => {
  * @param {object} obj the object
  * @returns {ParsedObject} parsed object
  */
-const parseObject = obj => {
+const parseObject = (obj) => {
     const info = new Map();
     let dynamicInfo;
-    // @ts-expect-error
-    const getInfo = p => {
+    const getInfo = (p) => {
         const entry = info.get(p);
         if (entry !== undefined)
             return entry;
         const newEntry = {
             base: undefined,
             byProperty: undefined,
-            byValues: undefined
+            byValues: new Map()
         };
         info.set(p, newEntry);
         return newEntry;
@@ -130,7 +103,6 @@ const parseObject = obj => {
     for (const key of Object.keys(obj)) {
         if (key.startsWith("by")) {
             const byProperty = key;
-            // @ts-expect-error
             const byObj = obj[byProperty];
             if (typeof byObj === "object") {
                 for (const byValue of Object.keys(byObj)) {
@@ -139,7 +111,6 @@ const parseObject = obj => {
                         const entry = getInfo(key);
                         if (entry.byProperty === undefined) {
                             entry.byProperty = byProperty;
-                            entry.byValues = new Map();
                         }
                         else if (entry.byProperty !== byProperty) {
                             throw new Error(`${byProperty} and ${entry.byProperty} for a single property is not supported`);
@@ -167,13 +138,11 @@ const parseObject = obj => {
             }
             else {
                 const entry = getInfo(key);
-                // @ts-expect-error
                 entry.base = obj[key];
             }
         }
         else {
             const entry = getInfo(key);
-            // @ts-expect-error
             entry.base = obj[key];
         }
     }
@@ -183,16 +152,15 @@ const parseObject = obj => {
     };
 };
 /**
- * @param {Map<string, ObjectParsedPropertyEntry>} info static properties (key is property name)
- * @param {{ byProperty: string, fn: Function } | undefined} dynamicInfo dynamic part
- * @returns {object} the object
+ * @param info static properties (key is property name)
+ * @param dynamicInfo dynamic part
+ * @returns the object
  */
 const serializeObject = (info, dynamicInfo) => {
     const obj = {};
     // Setup byProperty structure
     for (const entry of info.values()) {
         if (entry.byProperty !== undefined) {
-            // @ts-expect-error
             const byObj = (obj[entry.byProperty] = obj[entry.byProperty] || {});
             for (const byValue of entry.byValues.keys()) {
                 byObj[byValue] = byObj[byValue] || {};
@@ -201,12 +169,10 @@ const serializeObject = (info, dynamicInfo) => {
     }
     for (const [key, entry] of info) {
         if (entry.base !== undefined) {
-            // @ts-expect-error
             obj[key] = entry.base;
         }
         // Fill byProperty structure
         if (entry.byProperty !== undefined) {
-            // @ts-expect-error
             const byObj = (obj[entry.byProperty] = obj[entry.byProperty] || {});
             for (const byValue of Object.keys(byObj)) {
                 const value = getFromByValues(entry.byValues, byValue);
@@ -216,7 +182,6 @@ const serializeObject = (info, dynamicInfo) => {
         }
     }
     if (dynamicInfo !== undefined) {
-        // @ts-expect-error
         obj[dynamicInfo.byProperty] = dynamicInfo.fn;
     }
     return obj;
@@ -227,22 +192,22 @@ const VALUE_TYPE_ARRAY_EXTEND = 2;
 const VALUE_TYPE_OBJECT = 3;
 const VALUE_TYPE_DELETE = 4;
 /**
- * @param {any} value a single value
+ * @param value a single value
  * @returns {VALUE_TYPE_UNDEFINED | VALUE_TYPE_ATOM | VALUE_TYPE_ARRAY_EXTEND | VALUE_TYPE_OBJECT | VALUE_TYPE_DELETE} value type
  */
-const getValueType = value => {
+const getValueType = (value) => {
     if (value === undefined) {
         return VALUE_TYPE_UNDEFINED;
     }
-    else if (value === DELETE) {
+    if (value === exports.DELETE) {
         return VALUE_TYPE_DELETE;
     }
-    else if (Array.isArray(value)) {
+    if (Array.isArray(value)) {
         if (value.lastIndexOf("...") !== -1)
             return VALUE_TYPE_ARRAY_EXTEND;
         return VALUE_TYPE_ATOM;
     }
-    else if (typeof value === "object" &&
+    if (typeof value === "object" &&
         value !== null &&
         (!value.constructor || value.constructor === Object)) {
         return VALUE_TYPE_OBJECT;
@@ -253,11 +218,9 @@ const getValueType = value => {
  * Merges two objects. Objects are deeply clever merged.
  * Arrays might reference the old value with "...".
  * Non-object values take preference over object values.
- * @template T
- * @template O
- * @param {T} first first object
- * @param {O} second second object
- * @returns {T & O | T | O} merged object of first and second object
+ * @param first first object
+ * @param second second object
+ * @returns merged object of first and second object
  */
 const cleverMerge = (first, second) => {
     if (second === undefined)
@@ -268,15 +231,15 @@ const cleverMerge = (first, second) => {
         return second;
     if (typeof first !== "object" || first === null)
         return first;
-    // @ts-expect-error
     return _cleverMerge(first, second, false);
 };
+exports.cleverMerge = cleverMerge;
 /**
  * Merges two objects. Objects are deeply clever merged.
- * @param {object} first first object
- * @param {object} second second object
- * @param {boolean} internalCaching should parsing of objects and nested merges be cached
- * @returns {object} merged object of first and second object
+ * @param first first object
+ * @param second second object
+ * @param internalCaching should parsing of objects and nested merges be cached
+ * @returns merged object of first and second object
  */
 const _cleverMerge = (first, second, internalCaching = false) => {
     const firstObject = internalCaching
@@ -286,22 +249,19 @@ const _cleverMerge = (first, second, internalCaching = false) => {
     // If the first argument has a dynamic part we modify the dynamic part to merge the second argument
     if (firstDynamicInfo !== undefined) {
         let { byProperty, fn } = firstDynamicInfo;
-        // @ts-expect-error
         const fnInfo = fn[DYNAMIC_INFO];
         if (fnInfo) {
             second = internalCaching
-                ? cachedCleverMerge(fnInfo[1], second)
-                : cleverMerge(fnInfo[1], second);
+                ? (0, exports.cachedCleverMerge)(fnInfo[1], second)
+                : (0, exports.cleverMerge)(fnInfo[1], second);
             fn = fnInfo[0];
         }
-        // @ts-expect-error
         const newFn = (...args) => {
             const fnResult = fn(...args);
             return internalCaching
-                ? cachedCleverMerge(fnResult, second)
-                : cleverMerge(fnResult, second);
+                ? (0, exports.cachedCleverMerge)(fnResult, second)
+                : (0, exports.cleverMerge)(fnResult, second);
         };
-        // @ts-expect-error
         newFn[DYNAMIC_INFO] = [fn, second];
         return serializeObject(firstObject.static, { byProperty, fn: newFn });
     }
@@ -310,7 +270,6 @@ const _cleverMerge = (first, second, internalCaching = false) => {
         ? cachedParseObject(second)
         : parseObject(second);
     const { static: secondInfo, dynamic: secondDynamicInfo } = secondObject;
-    /** @type {Map<string, ObjectParsedPropertyEntry>} */
     const resultInfo = new Map();
     for (const [key, firstEntry] of firstInfo) {
         const secondEntry = secondInfo.get(key);
@@ -327,10 +286,10 @@ const _cleverMerge = (first, second, internalCaching = false) => {
     return serializeObject(resultInfo, secondDynamicInfo);
 };
 /**
- * @param {ObjectParsedPropertyEntry} firstEntry a
- * @param {ObjectParsedPropertyEntry} secondEntry b
- * @param {boolean} internalCaching should parsing of objects and nested merges be cached
- * @returns {ObjectParsedPropertyEntry} new entry
+ * @param firstEntry a
+ * @param secondEntry b
+ * @param internalCaching should parsing of objects and nested merges be cached
+ * @returns new entry
  */
 const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
     switch (getValueType(secondEntry.base)) {
@@ -349,23 +308,21 @@ const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
                     byValues: secondEntry.byValues
                 };
             }
-            else if (firstEntry.byProperty !== secondEntry.byProperty) {
+            if (firstEntry.byProperty !== secondEntry.byProperty) {
                 throw new Error(`${firstEntry.byProperty} and ${secondEntry.byProperty} for a single property is not supported`);
             }
-            else {
-                // = first.base + (first.byProperty + second.byProperty)
-                // need to merge first and second byValues
-                const newByValues = new Map(firstEntry.byValues);
-                for (const [key, value] of secondEntry.byValues) {
-                    const firstValue = getFromByValues(firstEntry.byValues, key);
-                    newByValues.set(key, mergeSingleValue(firstValue, value, internalCaching));
-                }
-                return {
-                    base: firstEntry.base,
-                    byProperty: firstEntry.byProperty,
-                    byValues: newByValues
-                };
+            // = first.base + (first.byProperty + second.byProperty)
+            // need to merge first and second byValues
+            const newByValues = new Map(firstEntry.byValues);
+            for (const [key, value] of secondEntry.byValues) {
+                const firstValue = getFromByValues(firstEntry.byValues, key);
+                newByValues.set(key, mergeSingleValue(firstValue, value, internalCaching));
             }
+            return {
+                base: firstEntry.base,
+                byProperty: firstEntry.byProperty,
+                byValues: newByValues
+            };
         default: {
             if (!firstEntry.byProperty) {
                 // The simple case
@@ -402,7 +359,7 @@ const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
                     byValues: intermediateByValues
                 };
             }
-            else if (firstEntry.byProperty !== secondEntry.byProperty) {
+            if (firstEntry.byProperty !== secondEntry.byProperty) {
                 throw new Error(`${firstEntry.byProperty} and ${secondEntry.byProperty} for a single property is not supported`);
             }
             const newByValues = new Map(intermediateByValues);
@@ -419,9 +376,9 @@ const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
     }
 };
 /**
- * @param {Map<string, any>} byValues all values
- * @param {string} key value of the selector
- * @returns {any | undefined} value
+ * @param byValues all values
+ * @param key value of the selector
+ * @returns value
  */
 const getFromByValues = (byValues, key) => {
     if (key !== "default" && byValues.has(key)) {
@@ -430,10 +387,10 @@ const getFromByValues = (byValues, key) => {
     return byValues.get("default");
 };
 /**
- * @param {any} a value
- * @param {any} b value
- * @param {boolean} internalCaching should parsing of objects and nested merges be cached
- * @returns {any} value
+ * @param a value
+ * @param b value
+ * @param internalCaching should parsing of objects and nested merges be cached
+ * @returns value
  */
 const mergeSingleValue = (a, b, internalCaching) => {
     const bType = getValueType(b);
@@ -446,8 +403,8 @@ const mergeSingleValue = (a, b, internalCaching) => {
             return aType !== VALUE_TYPE_OBJECT
                 ? b
                 : internalCaching
-                    ? cachedCleverMerge(a, b)
-                    : cleverMerge(a, b);
+                    ? (0, exports.cachedCleverMerge)(a, b)
+                    : (0, exports.cleverMerge)(a, b);
         }
         case VALUE_TYPE_UNDEFINED:
             return a;
@@ -460,8 +417,7 @@ const mergeSingleValue = (a, b, internalCaching) => {
                 case VALUE_TYPE_UNDEFINED:
                     return b;
                 case VALUE_TYPE_DELETE:
-                    // @ts-expect-error
-                    return b.filter(item => item !== "...");
+                    return b.filter((item) => item !== "...");
                 case VALUE_TYPE_ARRAY_EXTEND: {
                     const newArray = [];
                     for (const item of b) {
@@ -477,8 +433,7 @@ const mergeSingleValue = (a, b, internalCaching) => {
                     return newArray;
                 }
                 case VALUE_TYPE_OBJECT:
-                    // @ts-expect-error
-                    return b.map(item => (item === "..." ? a : item));
+                    return b.map((item) => (item === "..." ? a : item));
                 default:
                     throw new Error("Not implemented");
             }
@@ -487,15 +442,12 @@ const mergeSingleValue = (a, b, internalCaching) => {
     }
 };
 /**
- * @template T
- * @param {T} obj the object
- * @returns {T} the object without operations like "..." or DELETE
+ * @param obj the object
+ * @returns the object without operations like "..." or DELETE
  */
-const removeOperations = obj => {
-    const newObj = /** @type {T} */ ({});
-    // @ts-expect-error
+const removeOperations = (obj) => {
+    const newObj = {};
     for (const key of Object.keys(obj)) {
-        // @ts-expect-error
         const value = obj[key];
         const type = getValueType(value);
         switch (type) {
@@ -503,56 +455,48 @@ const removeOperations = obj => {
             case VALUE_TYPE_DELETE:
                 break;
             case VALUE_TYPE_OBJECT:
-                // @ts-expect-error
-                newObj[key] = removeOperations(value);
+                newObj[key] = (0, exports.removeOperations)(value);
                 break;
             case VALUE_TYPE_ARRAY_EXTEND:
-                // @ts-expect-error
                 newObj[key] = value.filter(i => i !== "...");
                 break;
             default:
-                // @ts-expect-error
                 newObj[key] = value;
                 break;
         }
     }
     return newObj;
 };
+exports.removeOperations = removeOperations;
 /**
- * @template T
- * @template {string} P
- * @param {T} obj the object
- * @param {P} byProperty the by description
- * @param  {...any} values values
- * @returns {Omit<T, P>|undefined} object with merged byProperty
+ * @param obj the object
+ * @param byProperty the by description
+ * @param values values
+ * @returns object with merged byProperty
  */
 const resolveByProperty = (obj, byProperty, ...values) => {
-    if (typeof obj !== "object" || obj === null || !(byProperty in obj)) {
+    if (!isPropertyInObject(obj, byProperty)) {
         return obj;
     }
-    const { [byProperty]: _byValue, ..._remaining } = /** @type {object} */ (obj);
-    const remaining = /** @type {T} */ (_remaining);
-    const byValue = /** @type {Record<string, T> | function(...any[]): T} */ (_byValue);
+    const { [byProperty]: _byValue, ..._remaining } = obj;
+    const remaining = _remaining;
+    const byValue = _byValue;
     if (typeof byValue === "object") {
         const key = values[0];
         if (key in byValue) {
-            return cachedCleverMerge(remaining, byValue[key]);
-        }
-        else if ("default" in byValue) {
-            return cachedCleverMerge(remaining, byValue.default);
+            return (0, exports.cachedCleverMerge)(remaining, byValue[key]);
         }
-        else {
-            return /** @type {T} */ (remaining);
+        if ("default" in byValue) {
+            return (0, exports.cachedCleverMerge)(remaining, byValue.default);
         }
+        return remaining;
     }
-    else if (typeof byValue === "function") {
+    if (typeof byValue === "function") {
         const result = byValue.apply(null, values);
-        return cachedCleverMerge(remaining, resolveByProperty(result, byProperty, ...values));
+        return (0, exports.cachedCleverMerge)(remaining, (0, exports.resolveByProperty)(result, byProperty, ...values));
     }
 };
-exports.cachedSetProperty = cachedSetProperty;
-exports.cachedCleverMerge = cachedCleverMerge;
-exports.cleverMerge = cleverMerge;
 exports.resolveByProperty = resolveByProperty;
-exports.removeOperations = removeOperations;
-exports.DELETE = DELETE;
+function isPropertyInObject(obj, property) {
+    return typeof obj === "object" && obj !== null && property in obj;
+}

package/dist/util/comparators.js

@@ -86,12 +86,10 @@ const compareSelect = (getter, comparator) => {
             }
             return -1;
         }
-        else {
-            if (bValue !== undefined && bValue !== null) {
-                return 1;
-            }
-            return 0;
+        if (bValue !== undefined && bValue !== null) {
+            return 1;
         }
+        return 0;
     };
     compareSelectCache.set(getter, comparator, result);
     return result;

package/dist/util/createHash.d.ts

@@ -7,9 +7,10 @@
  * Copyright (c) JS Foundation and other contributors
  * https://github.com/webpack/webpack/blob/main/LICENSE
  */
+import Hash from "./hash";
 /**
  * Creates a hash by name or function
- * @param {string | typeof Hash} algorithm the algorithm name or a constructor creating a hash
- * @returns {Hash} the hash
+ * @param algorithm the algorithm name or a constructor creating a hash
+ * @returns the hash
  */
-export declare const createHash: (algorithm: any) => any;
+export declare const createHash: (algorithm: "debug" | "xxhash64" | "md4" | "native-md4" | (string & {}) | (new () => Hash)) => Hash;