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

package/dist/util/createHash.js

@@ -8,18 +8,24 @@
  * Copyright (c) JS Foundation and other contributors
  * https://github.com/webpack/webpack/blob/main/LICENSE
  */
-//@ts-nocheck
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createHash = void 0;
-const Hash = require("./hash");
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const hash_1 = __importDefault(require("./hash"));
+const BatchedHash_1 = __importDefault(require("./hash/BatchedHash"));
+const md4_1 = __importDefault(require("./hash/md4"));
+const xxhash64_1 = __importDefault(require("./hash/xxhash64"));
 const BULK_SIZE = 2000;
 // We are using an object instead of a Map as this will stay static during the runtime
 // so access to it can be optimized by v8
 const digestCaches = {};
-class BulkUpdateDecorator extends Hash {
+class BulkUpdateDecorator extends hash_1.default {
     /**
-     * @param {Hash | function(): Hash} hashOrFactory function to create a hash
-     * @param {string=} hashKey key for caching
+     * @param hashOrFactory function to create a hash
+     * @param hashKey key for caching
      */
     constructor(hashOrFactory, hashKey) {
         super();
@@ -36,9 +42,9 @@ class BulkUpdateDecorator extends Hash {
     }
     /**
      * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
-     * @param {string|Buffer} data data
-     * @param {string=} inputEncoding data encoding
-     * @returns {this} updated hash
+     * @param data data
+     * @param inputEncoding data encoding
+     * @returns updated hash
      */
     update(data, inputEncoding) {
         if (inputEncoding !== undefined ||
@@ -65,8 +71,8 @@ class BulkUpdateDecorator extends Hash {
     }
     /**
      * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
-     * @param {string=} encoding encoding of the return value
-     * @returns {string|Buffer} digest
+     * @param encoding encoding of the return value
+     * @returns digest
      */
     digest(encoding) {
         let digestCache;
@@ -95,45 +101,41 @@ class BulkUpdateDecorator extends Hash {
     }
 }
 /* istanbul ignore next */
-class DebugHash extends Hash {
+class DebugHash extends hash_1.default {
     constructor() {
         super();
         this.string = "";
     }
     /**
      * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
-     * @param {string|Buffer} data data
-     * @param {string=} inputEncoding data encoding
-     * @returns {this} updated hash
+     * @param data data
+     * @param _inputEncoding data encoding
+     * @returns updated hash
      */
-    update(data, inputEncoding) {
+    update(data, _inputEncoding) {
         if (typeof data !== "string")
             data = data.toString("utf-8");
         if (data.startsWith("debug-digest-")) {
             data = Buffer.from(data.slice("debug-digest-".length), "hex").toString();
         }
-        this.string += `[${data}](${new Error().stack.split("\n", 3)[2]})\n`;
+        this.string += `[${data}](${new Error().stack?.split("\n", 3)[2]})\n`;
         return this;
     }
     /**
      * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
-     * @param {string=} encoding encoding of the return value
-     * @returns {string|Buffer} digest
+     * @param encoding encoding of the return value
+     * @returns digest
      */
     digest(encoding) {
         return ("debug-digest-" + Buffer.from(this.string).toString(encoding || "hex"));
     }
 }
-let crypto = undefined;
-let createXXHash64 = undefined;
-let createMd4 = undefined;
-let BatchedHash = undefined;
 /**
  * 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
  */
-const createHash = algorithm => {
+const createHash = (algorithm) => {
     if (typeof algorithm === "function") {
         return new BulkUpdateDecorator(() => new algorithm());
     }
@@ -142,29 +144,13 @@ const createHash = algorithm => {
         case "debug":
             return new DebugHash();
         case "xxhash64":
-            if (createXXHash64 === undefined) {
-                createXXHash64 = require("./hash/xxhash64");
-                if (BatchedHash === undefined) {
-                    BatchedHash = require("./hash/BatchedHash");
-                }
-            }
-            return new BatchedHash(createXXHash64());
+            return new BatchedHash_1.default((0, xxhash64_1.default)());
         case "md4":
-            if (createMd4 === undefined) {
-                createMd4 = require("./hash/md4");
-                if (BatchedHash === undefined) {
-                    BatchedHash = require("./hash/BatchedHash");
-                }
-            }
-            return new BatchedHash(createMd4());
+            return new BatchedHash_1.default((0, md4_1.default)());
         case "native-md4":
-            if (crypto === undefined)
-                crypto = require("crypto");
-            return new BulkUpdateDecorator(() => crypto.createHash("md4"), "md4");
+            return new BulkUpdateDecorator(() => node_crypto_1.default.createHash("md4"), "md4");
         default:
-            if (crypto === undefined)
-                crypto = require("crypto");
-            return new BulkUpdateDecorator(() => crypto.createHash(algorithm), algorithm);
+            return new BulkUpdateDecorator(() => node_crypto_1.default.createHash(algorithm), algorithm);
     }
 };
 exports.createHash = createHash;

package/dist/util/fs.js

@@ -13,8 +13,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mkdirp = exports.rmrf = void 0;
-const assert_1 = __importDefault(require("assert"));
-const path_1 = __importDefault(require("path"));
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_path_1 = __importDefault(require("node:path"));
 function rmrf(fs, p, callback) {
     fs.stat(p, (err, stats) => {
         if (err) {
@@ -33,8 +33,8 @@ function rmrf(fs, p, callback) {
                     fs.rmdir(p, callback);
                 }
                 else {
-                    files.forEach(file => {
-                        (0, assert_1.default)(typeof file === "string");
+                    for (const file of files) {
+                        (0, node_assert_1.default)(typeof file === "string");
                         const fullPath = join(fs, p, file);
                         rmrf(fs, fullPath, err => {
                             if (err) {
@@ -45,7 +45,7 @@ function rmrf(fs, p, callback) {
                                 fs.rmdir(p, callback);
                             }
                         });
-                    });
+                    }
                 }
             });
         }
@@ -59,29 +59,25 @@ const join = (fs, rootPath, filename) => {
     if (fs && fs.join) {
         return fs.join(rootPath, filename);
     }
-    else if (path_1.default.posix.isAbsolute(rootPath)) {
-        return path_1.default.posix.join(rootPath, filename);
+    if (node_path_1.default.posix.isAbsolute(rootPath)) {
+        return node_path_1.default.posix.join(rootPath, filename);
     }
-    else if (path_1.default.win32.isAbsolute(rootPath)) {
-        return path_1.default.win32.join(rootPath, filename);
-    }
-    else {
-        throw new Error(`${rootPath} is neither a posix nor a windows path, and there is no 'join' method defined in the file system`);
+    if (node_path_1.default.win32.isAbsolute(rootPath)) {
+        return node_path_1.default.win32.join(rootPath, filename);
     }
+    throw new Error(`${rootPath} is neither a posix nor a windows path, and there is no 'join' method defined in the file system`);
 };
 const dirname = (fs, absPath) => {
     if (fs && fs.dirname) {
         return fs.dirname(absPath);
     }
-    else if (path_1.default.posix.isAbsolute(absPath)) {
-        return path_1.default.posix.dirname(absPath);
-    }
-    else if (path_1.default.win32.isAbsolute(absPath)) {
-        return path_1.default.win32.dirname(absPath);
+    if (node_path_1.default.posix.isAbsolute(absPath)) {
+        return node_path_1.default.posix.dirname(absPath);
     }
-    else {
-        throw new Error(`${absPath} is neither a posix nor a windows path, and there is no 'dirname' method defined in the file system`);
+    if (node_path_1.default.win32.isAbsolute(absPath)) {
+        return node_path_1.default.win32.dirname(absPath);
     }
+    throw new Error(`${absPath} is neither a posix nor a windows path, and there is no 'dirname' method defined in the file system`);
 };
 const mkdirp = (fs, p, callback) => {
     fs.mkdir(p, err => {
@@ -111,7 +107,7 @@ const mkdirp = (fs, p, callback) => {
                 });
                 return;
             }
-            else if (err.code === "EEXIST") {
+            if (err.code === "EEXIST") {
                 callback();
                 return;
             }

package/dist/util/hash/BatchedHash.d.ts

@@ -1,15 +1,30 @@
-export = BatchedHash;
-declare class BatchedHash extends Hash {
-    constructor(hash: any);
+/// <reference types="node" />
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/util/hash/BatchedHash.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+import Hash from ".";
+export default class BatchedHash extends Hash {
     string: string | undefined;
     encoding: string | undefined;
-    hash: any;
+    hash: Hash;
+    constructor(hash: Hash);
     /**
      * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
-     * @param {string|Buffer} data data
-     * @param {string=} inputEncoding data encoding
-     * @returns {this} updated hash
+     * @param data data
+     * @param inputEncoding data encoding
+     * @returns updated hash
      */
-    update(data: string | Buffer, inputEncoding?: string | undefined): this;
+    update(data: string | Buffer, inputEncoding?: string): this;
+    /**
+     * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
+     * @param encoding encoding of the return value
+     * @returns digest
+     */
+    digest(encoding?: string): string | Buffer;
 }
-import Hash = require(".");

package/dist/util/hash/BatchedHash.js

@@ -1,3 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * The following code is modified based on
  * https://github.com/webpack/webpack/blob/4b4ca3b/lib/util/hash/BatchedHash.js
@@ -7,11 +12,9 @@
  * Copyright (c) JS Foundation and other contributors
  * https://github.com/webpack/webpack/blob/main/LICENSE
  */
-"use strict";
-const Hash = require(".");
-const MAX_SHORT_STRING = require("./wasm-hash").MAX_SHORT_STRING;
-class BatchedHash extends Hash {
-    // @ts-expect-error
+const _1 = __importDefault(require("."));
+const wasm_hash_1 = require("./wasm-hash");
+class BatchedHash extends _1.default {
     constructor(hash) {
         super();
         this.string = undefined;
@@ -20,15 +23,15 @@ class BatchedHash extends Hash {
     }
     /**
      * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
-     * @param {string|Buffer} data data
-     * @param {string=} inputEncoding data encoding
-     * @returns {this} updated hash
+     * @param data data
+     * @param inputEncoding data encoding
+     * @returns updated hash
      */
     update(data, inputEncoding) {
         if (this.string !== undefined) {
             if (typeof data === "string" &&
                 inputEncoding === this.encoding &&
-                this.string.length + data.length < MAX_SHORT_STRING) {
+                this.string.length + data.length < wasm_hash_1.MAX_SHORT_STRING) {
                 this.string += data;
                 return this;
             }
@@ -36,7 +39,7 @@ class BatchedHash extends Hash {
             this.string = undefined;
         }
         if (typeof data === "string") {
-            if (data.length < MAX_SHORT_STRING &&
+            if (data.length < wasm_hash_1.MAX_SHORT_STRING &&
                 // base64 encoding is not valid since it may contain padding chars
                 (!inputEncoding || !inputEncoding.startsWith("ba"))) {
                 this.string = data;
@@ -53,8 +56,8 @@ class BatchedHash extends Hash {
     }
     /**
      * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
-     * @param {string=} encoding encoding of the return value
-     * @returns {string|Buffer} digest
+     * @param encoding encoding of the return value
+     * @returns digest
      */
     digest(encoding) {
         if (this.string !== undefined) {
@@ -63,4 +66,4 @@ class BatchedHash extends Hash {
         return this.hash.digest(encoding);
     }
 }
-module.exports = BatchedHash;
+exports.default = BatchedHash;

package/dist/util/hash/index.d.ts

@@ -1,18 +1,18 @@
-export = Hash;
-declare class Hash {
+/// <reference types="node" />
+export default class Hash {
     /**
      * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
      * @abstract
-     * @param {string|Buffer} data data
-     * @param {string=} inputEncoding data encoding
-     * @returns {this} updated hash
+     * @param data data
+     * @param inputEncoding data encoding
+     * @returns updated hash
      */
-    update(data: string | Buffer, inputEncoding?: string | undefined): this;
+    update(data: string | Buffer, inputEncoding?: string): this;
     /**
      * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
      * @abstract
-     * @param {string=} encoding encoding of the return value
-     * @returns {string|Buffer} digest
+     * @param encoding encoding of the return value
+     * @returns  digest
      */
-    digest(encoding?: string | undefined): string | Buffer;
+    digest(encoding?: string): string | Buffer;
 }

package/dist/util/hash/index.js

@@ -1,3 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * The following code is modified based on
  * https://github.com/webpack/webpack/tree/4b4ca3bb53f36a5b8fc6bc1bd976ed7af161bd80/lib/util/hash
@@ -7,30 +12,28 @@
  * Copyright (c) JS Foundation and other contributors
  * https://github.com/webpack/webpack/blob/main/LICENSE
  */
-"use strict";
+const AbstractMethodError_1 = __importDefault(require("../../lib/AbstractMethodError"));
 class Hash {
     /* istanbul ignore next */
     /**
      * Update hash {@link https://nodejs.org/api/crypto.html#crypto_hash_update_data_inputencoding}
      * @abstract
-     * @param {string|Buffer} data data
-     * @param {string=} inputEncoding data encoding
-     * @returns {this} updated hash
+     * @param data data
+     * @param inputEncoding data encoding
+     * @returns updated hash
      */
     update(data, inputEncoding) {
-        const AbstractMethodError = require("../../lib/AbstractMethodError");
-        throw new AbstractMethodError();
+        throw new AbstractMethodError_1.default();
     }
     /* istanbul ignore next */
     /**
      * Calculates the digest {@link https://nodejs.org/api/crypto.html#crypto_hash_digest_encoding}
      * @abstract
-     * @param {string=} encoding encoding of the return value
-     * @returns {string|Buffer} digest
+     * @param encoding encoding of the return value
+     * @returns  digest
      */
     digest(encoding) {
-        const AbstractMethodError = require("../../lib/AbstractMethodError");
-        throw new AbstractMethodError();
+        throw new AbstractMethodError_1.default();
     }
 }
-module.exports = Hash;
+exports.default = Hash;

package/dist/util/hash/md4.d.ts

@@ -1,2 +1,29 @@
-declare const _exports: () => any;
-export = _exports;
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/util/hash/md4.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+/// <reference types="node" />
+declare const _default: () => {
+    exports: WebAssembly.Exports & {
+        init: () => void;
+        update: (b: number) => void;
+        memory: WebAssembly.Memory;
+        final: (b: number) => void;
+    };
+    instancesPool: WebAssembly.Instance[];
+    buffered: number;
+    mem: Buffer;
+    chunkSize: number;
+    digestSize: number;
+    reset(): void;
+    update(data: string | Buffer, encoding?: BufferEncoding | undefined): any;
+    _updateWithShortString(data: string, encoding?: BufferEncoding | undefined): void;
+    _updateWithBuffer(data: Buffer): void;
+    digest(type: BufferEncoding): string | Buffer;
+};
+export default _default;

package/dist/util/hash/md4.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * The following code is modified based on
  * https://github.com/webpack/webpack/blob/4b4ca3b/lib/util/hash/md4.js
@@ -7,11 +8,14 @@
  * Copyright (c) JS Foundation and other contributors
  * https://github.com/webpack/webpack/blob/main/LICENSE
  */
-"use strict";
-const create = require("./wasm-hash");
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const wasm_hash_1 = __importDefault(require("./wasm-hash"));
 //#region wasm code: md4 (../../../assembly/hash/md4.asm.ts) --initialMemory 1
 const md4 = new WebAssembly.Module(Buffer.from(
 // 2156 bytes
 "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", "base64"));
 //#endregion
-module.exports = create.bind(null, md4, [], 64, 32);
+exports.default = wasm_hash_1.default.bind(null, md4, [], 64, 32);

package/dist/util/hash/wasm-hash.d.ts

@@ -1,6 +1,53 @@
-export = create;
-declare function create(wasmModule: any, instancesPool: any, chunkSize: any, digestSize: any): any;
-declare namespace create {
-    export { MAX_SHORT_STRING };
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/util/hash/wasm-hash.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+/// <reference types="node" />
+export declare const MAX_SHORT_STRING: number;
+type Exports = WebAssembly.Instance["exports"] & {
+    init: () => void;
+    update: (b: number) => void;
+    memory: WebAssembly.Memory;
+    final: (b: number) => void;
+};
+declare class WasmHash {
+    exports: Exports;
+    instancesPool: WebAssembly.Instance[];
+    buffered: number;
+    mem: Buffer;
+    chunkSize: number;
+    digestSize: number;
+    /**
+     * @param instance wasm instance
+     * @param instancesPool pool of instances
+     * @param chunkSize size of data chunks passed to wasm
+     * @param digestSize size of digest returned by wasm
+     */
+    constructor(instance: WebAssembly.Instance, instancesPool: WebAssembly.Instance[], chunkSize: number, digestSize: number);
+    reset(): void;
+    /**
+     * @param data data
+     * @param encoding encoding
+     * @returns itself
+     */
+    update(data: Buffer | string, encoding?: BufferEncoding): this;
+    /**
+     * @param {string} data data
+     * @param {BufferEncoding=} encoding encoding
+     * @returns {void}
+     */
+    _updateWithShortString(data: string, encoding?: BufferEncoding): void;
+    /**
+     * @param data data
+     * @returns
+     */
+    _updateWithBuffer(data: Buffer): void;
+    digest(type: BufferEncoding): string | Buffer;
 }
-declare const MAX_SHORT_STRING: number;
+declare const create: (wasmModule: WebAssembly.Module, instancesPool: WasmHash[], chunkSize: number, digestSize: number) => WasmHash;
+export default create;

package/dist/util/hash/wasm-hash.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * The following code is modified based on
  * https://github.com/webpack/webpack/blob/4b4ca3b/lib/util/hash/wasm-hash.js
@@ -7,21 +8,22 @@
  * Copyright (c) JS Foundation and other contributors
  * https://github.com/webpack/webpack/blob/main/LICENSE
  */
-"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_SHORT_STRING = void 0;
 // 65536 is the size of a wasm memory page
 // 64 is the maximum chunk size for every possible wasm hash implementation
 // 4 is the maximum number of bytes per char for string encoding (max is utf-8)
 // ~3 makes sure that it's always a block of 4 chars, so avoid partially encoded bytes for base64
-const MAX_SHORT_STRING = Math.floor((65536 - 64) / 4) & ~3;
+exports.MAX_SHORT_STRING = Math.floor((65536 - 64) / 4) & ~3;
 class WasmHash {
     /**
-     * @param {WebAssembly.Instance} instance wasm instance
-     * @param {WebAssembly.Instance[]} instancesPool pool of instances
-     * @param {number} chunkSize size of data chunks passed to wasm
-     * @param {number} digestSize size of digest returned by wasm
+     * @param instance wasm instance
+     * @param instancesPool pool of instances
+     * @param chunkSize size of data chunks passed to wasm
+     * @param digestSize size of digest returned by wasm
      */
     constructor(instance, instancesPool, chunkSize, digestSize) {
-        const exports = /** @type {any} */ (instance.exports);
+        const exports = instance.exports;
         exports.init();
         this.exports = exports;
         this.mem = Buffer.from(exports.memory.buffer, 0, 65536);
@@ -35,15 +37,15 @@ class WasmHash {
         this.exports.init();
     }
     /**
-     * @param {Buffer | string} data data
-     * @param {BufferEncoding=} encoding encoding
-     * @returns {this} itself
+     * @param data data
+     * @param encoding encoding
+     * @returns itself
      */
     update(data, encoding) {
         if (typeof data === "string") {
-            while (data.length > MAX_SHORT_STRING) {
-                this._updateWithShortString(data.slice(0, MAX_SHORT_STRING), encoding);
-                data = data.slice(MAX_SHORT_STRING);
+            while (data.length > exports.MAX_SHORT_STRING) {
+                this._updateWithShortString(data.slice(0, exports.MAX_SHORT_STRING), encoding);
+                data = data.slice(exports.MAX_SHORT_STRING);
             }
             this._updateWithShortString(data, encoding);
             return this;
@@ -105,8 +107,8 @@ class WasmHash {
         }
     }
     /**
-     * @param {Buffer} data data
-     * @returns {void}
+     * @param data data
+     * @returns
      */
     _updateWithBuffer(data) {
         const { exports, buffered, mem } = this;
@@ -140,7 +142,6 @@ class WasmHash {
                 data.copy(mem, 0, length - newBuffered, length);
         }
     }
-    // @ts-expect-error
     digest(type) {
         const { exports, buffered, mem, digestSize } = this;
         exports.final(buffered);
@@ -153,16 +154,12 @@ class WasmHash {
         return Buffer.from(hex, "hex").toString(type);
     }
 }
-// @ts-expect-error
 const create = (wasmModule, instancesPool, chunkSize, digestSize) => {
     if (instancesPool.length > 0) {
         const old = instancesPool.pop();
         old.reset();
         return old;
     }
-    else {
-        return new WasmHash(new WebAssembly.Instance(wasmModule), instancesPool, chunkSize, digestSize);
-    }
+    return new WasmHash(new WebAssembly.Instance(wasmModule), instancesPool, chunkSize, digestSize);
 };
-module.exports = create;
-module.exports.MAX_SHORT_STRING = MAX_SHORT_STRING;
+exports.default = create;

package/dist/util/hash/xxhash64.d.ts

@@ -1,2 +1,29 @@
-declare const _exports: () => any;
-export = _exports;
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/util/hash/xxhash64.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+/// <reference types="node" />
+declare const _default: () => {
+    exports: WebAssembly.Exports & {
+        init: () => void;
+        update: (b: number) => void;
+        memory: WebAssembly.Memory;
+        final: (b: number) => void;
+    };
+    instancesPool: WebAssembly.Instance[];
+    buffered: number;
+    mem: Buffer;
+    chunkSize: number;
+    digestSize: number;
+    reset(): void;
+    update(data: string | Buffer, encoding?: BufferEncoding | undefined): any;
+    _updateWithShortString(data: string, encoding?: BufferEncoding | undefined): void;
+    _updateWithBuffer(data: Buffer): void;
+    digest(type: BufferEncoding): string | Buffer;
+};
+export default _default;