webpack 5.106.2 → 5.107.1

package/lib/typescript/TypeScriptPlugin.js

@@ -0,0 +1,210 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const mod = require("module");
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
+	JAVASCRIPT_MODULE_TYPE_ESM
+} = require("../ModuleTypeConstants");
+const NormalModule = require("../NormalModule");
+const ModuleBuildError = require("../errors/ModuleBuildError");
+const memoize = require("../util/memoize");
+const removeBOM = require("../util/removeBOM");
+
+/** @typedef {import("webpack-sources").RawSourceMap} RawSourceMap */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../NormalModule")} NormalModuleType */
+/** @typedef {import("../NormalModule").Result} Result */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+
+const getSourceMapSource = memoize(
+	() => require("webpack-sources").SourceMapSource
+);
+
+const PLUGIN_NAME = "TypeScriptPlugin";
+
+/** @type {Set<string>} */
+const JS_MODULE_TYPES = new Set([
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
+	JAVASCRIPT_MODULE_TYPE_ESM
+]);
+
+const TS_RESOURCE_RE = /\.(?:[mc]?tsx?)$/i;
+const TSX_RESOURCE_RE = /\.[mc]?tsx$/i;
+const TS_DATA_URI_RE = /^data:(?:text|application)\/typescript/i;
+
+const TSX_NOT_SUPPORTED =
+	"experiments.typescript does not support .tsx/JSX. " +
+	"Use a TSX-capable loader (e.g. swc-loader, esbuild-loader, ts-loader) for .tsx files.";
+
+const NODE_API_MISSING =
+	"experiments.typescript requires Node.js >= 22.6. " +
+	"`module.stripTypeScriptTypes` is not available on this Node.js version.";
+
+/**
+ * Whether the resource (path or `data:` URI) should go through the TypeScript
+ * transform. Returns true for `.ts`, `.cts`, `.mts`, and the JSX-flavoured
+ * variants (so the `.tsx` branch can throw a friendly error), as well as the
+ * `text/typescript` / `application/typescript` data URIs.
+ * @param {string} resource module resource (without query string)
+ * @returns {boolean} true if the resource should be transformed
+ */
+const isTypeScriptResource = (resource) =>
+	TS_RESOURCE_RE.test(resource) || TS_DATA_URI_RE.test(resource);
+
+/**
+ * Build a line-granularity identity source map for a strip-types output.
+ * `mode: "strip"` replaces type annotations with whitespace, so the stripped
+ * output preserves the original line layout — an identity mapping is correct.
+ * Node's API does not emit a source map in strip mode (`sourceMap: true` is
+ * rejected on Node 22+ and Node 26+), so we construct one by hand.
+ * @param {string} resource module resource path
+ * @param {string} originalSource pre-strip source content
+ * @returns {RawSourceMap} identity source map
+ */
+const createIdentitySourceMap = (resource, originalSource) => {
+	const lineCount = (originalSource.match(/\n/g) || []).length + 1;
+	// Mappings: each line emits a single segment at column 0 mapping to
+	// column 0 of the same line in the source. `AAAA` for line 1, `;AACA`
+	// for each subsequent line (cumulative source-line delta of +1 per line).
+	const mappings = `AAAA${";AACA".repeat(lineCount - 1)}`;
+
+	return {
+		version: 3,
+		file: resource,
+		sources: [resource],
+		sourcesContent: [originalSource],
+		names: [],
+		mappings
+	};
+};
+
+/**
+ * Compose the strip-types source map with an upstream loader source map so the
+ * final map points back to the loader's original input (e.g. a `.vue` /
+ * `.svelte` / custom loader that emits TS code).
+ * @param {string} resource module resource
+ * @param {string} strippedSource post-strip JS
+ * @param {RawSourceMap} stripMap identity map for the strip step
+ * @param {string} preStripSource pre-strip TS (loader output)
+ * @param {string | RawSourceMap} loaderSourceMap upstream loader source map
+ * @returns {RawSourceMap} composed map
+ */
+const composeWithLoaderSourceMap = (
+	resource,
+	strippedSource,
+	stripMap,
+	preStripSource,
+	loaderSourceMap
+) => {
+	const SourceMapSource = getSourceMapSource();
+	const composed = new SourceMapSource(
+		strippedSource,
+		resource,
+		stripMap,
+		preStripSource,
+		loaderSourceMap,
+		true
+	);
+	return /** @type {RawSourceMap} */ (composed.sourceAndMap().map) || stripMap;
+};
+
+/**
+ * Run `module.stripTypeScriptTypes` on the input, wrapping any thrown
+ * `TypeScript ...` errors as `ModuleBuildError` so they surface as
+ * per-module build errors instead of uncaught exceptions.
+ * @param {string} input pre-strip TS source (BOM-free string)
+ * @returns {string} stripped JS
+ */
+const stripTypes = (input) => {
+	try {
+		// Pass only `mode`. `sourceUrl` would emit a `//# sourceURL=…` pragma
+		// into the output (V8 debugger hint), and `sourceMap: true` is
+		// rejected in strip mode — we build the source map by hand instead.
+		// eslint-disable-next-line n/no-unsupported-features/node-builtins
+		return mod.stripTypeScriptTypes(input, { mode: "strip" });
+	} catch (err) {
+		throw new ModuleBuildError(/** @type {Error} */ (err));
+	}
+};
+
+/**
+ * Coerce a Buffer-or-string source to a UTF-8 string, dropping any BOM.
+ * @param {string | Buffer} source raw source from the loader pipeline
+ * @returns {string} UTF-8 string without BOM
+ */
+const toBomFreeString = (source) => {
+	const text = Buffer.isBuffer(source) ? source.toString("utf8") : source;
+	const stripped = removeBOM(text);
+	return typeof stripped === "string" ? stripped : stripped.toString("utf8");
+};
+
+class TypeScriptPlugin {
+	/**
+	 * @param {Compiler} compiler webpack compiler
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+			NormalModule.getCompilationHooks(compilation).processResult.tap(
+				PLUGIN_NAME,
+				(result, module) => this._processResult(result, module)
+			);
+		});
+	}
+
+	/**
+	 * processResult tap body. Returns the input untouched unless this is a
+	 * TypeScript module that needs to be transformed.
+	 * @param {Result} result loader result tuple
+	 * @param {NormalModuleType} module the normal module
+	 * @returns {Result} possibly transformed result
+	 */
+	_processResult(result, module) {
+		if (!JS_MODULE_TYPES.has(module.type)) return result;
+
+		const parser = /** @type {JavascriptParser} */ (module.parser);
+		if (!parser.options.typescript) return result;
+
+		const resource = module.nameForCondition();
+		if (!resource || !isTypeScriptResource(resource)) return result;
+
+		if (TSX_RESOURCE_RE.test(resource)) {
+			throw new ModuleBuildError(new Error(TSX_NOT_SUPPORTED));
+		}
+
+		if (!("stripTypeScriptTypes" in mod)) {
+			throw new ModuleBuildError(new Error(NODE_API_MISSING));
+		}
+
+		const [rawSource, loaderSourceMap, ...rest] = result;
+		const preStripSource = toBomFreeString(rawSource);
+		const strippedSource = stripTypes(preStripSource);
+
+		const needSourceMap = module.useSourceMap || module.useSimpleSourceMap;
+		const stripMap = needSourceMap
+			? createIdentitySourceMap(module.resource, preStripSource)
+			: undefined;
+
+		const outputSourceMap =
+			stripMap && loaderSourceMap
+				? composeWithLoaderSourceMap(
+						module.resource,
+						strippedSource,
+						stripMap,
+						preStripSource,
+						loaderSourceMap
+					)
+				: stripMap || loaderSourceMap;
+
+		return [strippedSource, outputSourceMap, ...rest];
+	}
+}
+
+module.exports = TypeScriptPlugin;

package/lib/url/URLParserPlugin.js

@@ -6,13 +6,13 @@
 "use strict";
 
 const { pathToFileURL } = require("url");
-const CommentCompilationWarning = require("../CommentCompilationWarning");
 const RuntimeGlobals = require("../RuntimeGlobals");
-const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
 const ConstDependency = require("../dependencies/ConstDependency");
 const ContextDependencyHelpers = require("../dependencies/ContextDependencyHelpers");
 const URLContextDependency = require("../dependencies/URLContextDependency");
 const URLDependency = require("../dependencies/URLDependency");
+const CommentCompilationWarning = require("../errors/CommentCompilationWarning");
+const UnsupportedFeatureWarning = require("../errors/UnsupportedFeatureWarning");
 const BasicEvaluatedExpression = require("../javascript/BasicEvaluatedExpression");
 const { approve } = require("../javascript/JavascriptParserHelpers");
 const InnerGraph = require("../optimize/InnerGraph");

package/lib/util/AsyncQueue.js

@@ -6,8 +6,8 @@
 "use strict";
 
 const { AsyncSeriesHook, SyncHook } = require("tapable");
-const { makeWebpackError } = require("../HookWebpackError");
-const WebpackError = require("../WebpackError");
+const { makeWebpackError } = require("../errors/HookWebpackError");
+const WebpackError = require("../errors/WebpackError");
 const ArrayQueue = require("./ArrayQueue");
 
 const QUEUED_STATE = 0;

package/lib/util/Hash.js

@@ -33,7 +33,7 @@ class Hash {
 	 * @returns {Hash} updated hash
 	 */
 	update(data, inputEncoding) {
-		const AbstractMethodError = require("../AbstractMethodError");
+		const AbstractMethodError = require("../errors/AbstractMethodError");
 
 		throw new AbstractMethodError();
 	}
@@ -59,7 +59,7 @@ class Hash {
 	 * @returns {string | Buffer} digest
 	 */
 	digest(encoding) {
-		const AbstractMethodError = require("../AbstractMethodError");
+		const AbstractMethodError = require("../errors/AbstractMethodError");
 
 		throw new AbstractMethodError();
 	}

package/lib/util/LocConverter.js

@@ -0,0 +1,53 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+class LocConverter {
+	/**
+	 * Creates an instance of LocConverter.
+	 * @param {string} input input
+	 */
+	constructor(input) {
+		this._input = input;
+		this.line = 1;
+		this.column = 0;
+		this.pos = 0;
+	}
+
+	/**
+	 * Returns location converter.
+	 * @param {number} pos position
+	 * @returns {LocConverter} location converter
+	 */
+	get(pos) {
+		if (this.pos !== pos) {
+			if (this.pos < pos) {
+				const str = this._input.slice(this.pos, pos);
+				let i = str.lastIndexOf("\n");
+				if (i === -1) {
+					this.column += str.length;
+				} else {
+					this.column = str.length - i - 1;
+					this.line++;
+					while (i > 0 && (i = str.lastIndexOf("\n", i - 1)) !== -1) {
+						this.line++;
+					}
+				}
+			} else {
+				let i = this._input.lastIndexOf("\n", this.pos);
+				while (i >= pos) {
+					this.line--;
+					i = i > 0 ? this._input.lastIndexOf("\n", i - 1) : -1;
+				}
+				this.column = i === -1 ? pos : pos - i - 1;
+			}
+			this.pos = pos;
+		}
+		return this;
+	}
+}
+
+module.exports = LocConverter;

package/lib/util/SortableSet.js

@@ -108,7 +108,7 @@ class SortableSet extends Set {
 
 	/**
 	 * Get data from cache
-	 * @template {EXPECTED_ANY} R
+	 * @template R
 	 * @param {(set: SortableSet<T>) => R} fn function to calculate value
 	 * @returns {R} returns result of fn(this), cached until set changes
 	 */

package/lib/util/cleverMerge.js

@@ -132,10 +132,10 @@ const parseCache = new WeakMap();
  * @returns {ParsedObject<T>} parsed object
  */
 const cachedParseObject = (obj) => {
-	const entry = parseCache.get(/** @type {EXPECTED_OBJECT} */ (obj));
+	const entry = parseCache.get(obj);
 	if (entry !== undefined) return entry;
 	const result = parseObject(obj);
-	parseCache.set(/** @type {EXPECTED_OBJECT} */ (obj), result);
+	parseCache.set(obj, result);
 	return result;
 };
 

package/lib/util/comparators.js

@@ -56,10 +56,10 @@ const { compareRuntime } = require("./runtime");
  * @returns {ParameterizedComparator<TArg, T>} comparator
  */
 const createCachedParameterizedComparator = (fn) => {
-	/** @type {WeakMap<EXPECTED_OBJECT, Comparator<T>>} */
+	/** @type {WeakMap<TArg, Comparator<T>>} */
 	const map = new WeakMap();
 	return (arg) => {
-		const cachedResult = map.get(/** @type {EXPECTED_OBJECT} */ (arg));
+		const cachedResult = map.get(arg);
 		if (cachedResult !== undefined) return cachedResult;
 		/**
 		 * Returns compare result.
@@ -68,7 +68,7 @@ const createCachedParameterizedComparator = (fn) => {
 		 * @returns {-1 | 0 | 1} compare result
 		 */
 		const result = fn.bind(null, arg);
-		map.set(/** @type {EXPECTED_OBJECT} */ (arg), result);
+		map.set(arg, result);
 		return result;
 	};
 };

package/lib/util/concatenate.js

@@ -7,10 +7,10 @@
 
 const Template = require("../Template");
 
-/** @typedef {import("eslint-scope").Scope} Scope */
-/** @typedef {import("eslint-scope").Reference} Reference */
-/** @typedef {import("eslint-scope").Variable} Variable */
 /** @typedef {import("estree").Node} Node */
+/** @typedef {import("../javascript/JavascriptModulesPlugin").Scope} Scope */
+/** @typedef {import("../javascript/JavascriptModulesPlugin").Reference} Reference */
+/** @typedef {import("../javascript/JavascriptModulesPlugin").Variable} Variable */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {Set<string>} UsedNames */
 

package/lib/util/conventions.js

@@ -80,6 +80,26 @@ module.exports.camelCase = (input) => {
 		.replace(/\d+([\p{Alpha}\p{N}_]|$)/gu, (m) => m.toUpperCase());
 };
 
+/**
+ * Safely stringify an arbitrary value for an error message — falls back to
+ * `String(...)` when JSON.stringify would throw (BigInt, circular, etc.).
+ * @param {EXPECTED_ANY} value value to stringify
+ * @returns {string} stringified value
+ */
+const safeStringify = (value) => {
+	try {
+		const json = JSON.stringify(value);
+		if (json !== undefined) return json;
+	} catch (_err) {
+		// fall through to String fallback
+	}
+	try {
+		return String(value);
+	} catch (_err) {
+		return "[value cannot be converted to string]";
+	}
+};
+
 /**
  * Returns results.
  * @param {string} input input
@@ -90,7 +110,28 @@ module.exports.cssExportConvention = (input, convention) => {
 	/** @type {Set<string>} */
 	const set = new Set();
 	if (typeof convention === "function") {
-		set.add(convention(input));
+		const result = convention(input);
+		const validate = (/** @type {string} */ name) => {
+			if (typeof name !== "string" || name.length === 0) {
+				throw new Error(
+					`exportsConvention function must return a non-empty string or an array of non-empty strings, got ${safeStringify(result)}`
+				);
+			}
+		};
+		if (Array.isArray(result)) {
+			if (result.length === 0) {
+				throw new Error(
+					"exportsConvention function returned an empty array; it must return at least one name"
+				);
+			}
+			for (const name of result) {
+				validate(name);
+				set.add(name);
+			}
+		} else {
+			validate(result);
+			set.add(result);
+		}
 	} else {
 		switch (convention) {
 			case "camel-case": {

package/lib/util/createMappings.js

@@ -0,0 +1,118 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+/**
+ * Utilities for building V3 source-map `mappings` strings without pulling in a
+ * full source-map library. The shape of the input is intentionally minimal —
+ * one slot per generated line, each holding zero, one, or many segments — so
+ * call sites that have a "one mapping per line" structure (like the CSS-module
+ * exports emit in `lib/css/CssGenerator.js`) can build mappings directly,
+ * while richer call sites can pass arrays of segments.
+ *
+ * TODO move this encoder into `webpack-sources` and replace the body of this
+ * file with re-exports. The public shape (`encodeVLQ`, `encodeMappings(lines)`,
+ * `MappingSegment`, `LineMappings`) is intended to match what would land
+ * upstream so call sites don't have to change.
+ */
+
+const VLQ_BASE64 =
+	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+/**
+ * Encode a signed integer as a base64 VLQ string per the source-map V3 spec.
+ * @param {number} value signed integer to encode
+ * @returns {string} base64 VLQ encoded value
+ */
+const encodeVLQ = (value) => {
+	let vlq = value < 0 ? (-value << 1) | 1 : value << 1;
+	let result = "";
+	do {
+		let digit = vlq & 0x1f;
+		vlq >>>= 5;
+		if (vlq > 0) digit |= 0x20;
+		result += VLQ_BASE64[digit];
+	} while (vlq > 0);
+	return result;
+};
+
+/**
+ * @typedef {object} MappingSegment
+ * @property {number=} generatedColumn 0-based generated column (defaults to 0)
+ * @property {number=} sourceIndex index into the surrounding source map's `sources` array; omit for a generated-only segment
+ * @property {number=} originalLine 0-based line in the original source (required when `sourceIndex` is set)
+ * @property {number=} originalColumn 0-based column in the original source (required when `sourceIndex` is set)
+ * @property {number=} nameIndex index into the surrounding source map's `names` array
+ */
+
+/** @typedef {null | MappingSegment | MappingSegment[]} LineMappings */
+
+/**
+ * Encode a V3 source-map `mappings` string from a per-generated-line
+ * description of segments.
+ *
+ * Each entry of `lines` describes the mappings for one generated line:
+ *
+ * - `null` (or `undefined`) — the line has no mappings.
+ * - a single `MappingSegment` — convenience for the common "one mapping at
+ * column 0" case.
+ * - `MappingSegment[]` — multiple segments on the same line.
+ *
+ * Lines are joined with `;`, segments within a line with `,`. All numeric
+ * fields are encoded as deltas relative to the previous emitted segment, per
+ * the V3 spec.
+ * @param {LineMappings[]} lines per-generated-line mapping segments
+ * @returns {string} VLQ-encoded V3 mappings string
+ */
+const encodeMappings = (lines) => {
+	let prevSourceIndex = 0;
+	let prevOriginalLine = 0;
+	let prevOriginalColumn = 0;
+	let prevNameIndex = 0;
+
+	const encodedLines = [];
+
+	for (const line of lines) {
+		if (line === null || line === undefined) {
+			encodedLines.push("");
+			continue;
+		}
+
+		const segments = Array.isArray(line) ? line : [line];
+		let prevGeneratedColumn = 0;
+		const encodedSegments = [];
+
+		for (const segment of segments) {
+			const generatedColumn = segment.generatedColumn || 0;
+			let encoded = encodeVLQ(generatedColumn - prevGeneratedColumn);
+			prevGeneratedColumn = generatedColumn;
+
+			if (segment.sourceIndex !== undefined) {
+				const originalLine = /** @type {number} */ (segment.originalLine);
+				const originalColumn = /** @type {number} */ (segment.originalColumn);
+				encoded += encodeVLQ(segment.sourceIndex - prevSourceIndex);
+				encoded += encodeVLQ(originalLine - prevOriginalLine);
+				encoded += encodeVLQ(originalColumn - prevOriginalColumn);
+				prevSourceIndex = segment.sourceIndex;
+				prevOriginalLine = originalLine;
+				prevOriginalColumn = originalColumn;
+
+				if (segment.nameIndex !== undefined) {
+					encoded += encodeVLQ(segment.nameIndex - prevNameIndex);
+					prevNameIndex = segment.nameIndex;
+				}
+			}
+
+			encodedSegments.push(encoded);
+		}
+
+		encodedLines.push(encodedSegments.join(","));
+	}
+
+	return encodedLines.join(";");
+};
+
+module.exports.encodeMappings = encodeMappings;
+module.exports.encodeVLQ = encodeVLQ;

package/lib/{formatLocation.js → util/formatLocation.js}

@@ -5,8 +5,8 @@
 
 "use strict";
 
-/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("./Dependency").SourcePosition} SourcePosition */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../Dependency").SourcePosition} SourcePosition */
 
 /**
  * Returns formatted position.

package/lib/{SizeFormatHelpers.js → util/formatSize.js}

@@ -10,7 +10,7 @@
  * @param {number=} size the size in bytes
  * @returns {string} the formatted size
  */
-module.exports.formatSize = (size) => {
+const formatSize = (size) => {
 	if (typeof size !== "number" || Number.isNaN(size) === true) {
 		return "unknown size";
 	}
@@ -24,3 +24,5 @@ module.exports.formatSize = (size) => {
 
 	return `${Number((size / 1024 ** index).toPrecision(3))} ${abbreviations[index]}`;
 };
+
+module.exports = formatSize;

package/lib/util/fs.js

@@ -244,12 +244,12 @@ const path = require("path");
 /**
  * Describes the stat sync shape.
  * @typedef {{
- * (path: PathLike, options?: undefined): IStats,
+ * (path: PathLike): IStats,
+ * (path: PathLike, options?: StatSyncOptions & { bigint?: false | undefined, throwIfNoEntry?: true | undefined }): IStats,
+ * (path: PathLike, options: StatSyncOptions & { bigint: true, throwIfNoEntry?: true | undefined }): IBigIntStats,
  * (path: PathLike, options?: StatSyncOptions & { bigint?: false | undefined, throwIfNoEntry: false }): IStats | undefined,
  * (path: PathLike, options: StatSyncOptions & { bigint: true, throwIfNoEntry: false }): IBigIntStats | undefined,
- * (path: PathLike, options?: StatSyncOptions & { bigint?: false | undefined }): IStats,
- * (path: PathLike, options: StatSyncOptions & { bigint: true }): IBigIntStats,
- * (path: PathLike, options: StatSyncOptions & { bigint: boolean, throwIfNoEntry?: false | undefined }): IStats | IBigIntStats,
+ * (path: PathLike, options: StatSyncOptions & { bigint: boolean, throwIfNoEntry?: true | undefined }): IStats | IBigIntStats,
  * (path: PathLike, options?: StatSyncOptions): IStats | IBigIntStats | undefined,
  * }} StatSync
  */
@@ -267,12 +267,12 @@ const path = require("path");
 /**
  * Describes the l stat sync shape.
  * @typedef {{
- * (path: PathLike, options?: undefined): IStats,
+ * (path: PathLike): IStats,
+ * (path: PathLike, options?: StatSyncOptions & { bigint?: false | undefined, throwIfNoEntry?: true | undefined }): IStats,
+ * (path: PathLike, options: StatSyncOptions & { bigint: true, throwIfNoEntry?: true | undefined }): IBigIntStats,
  * (path: PathLike, options?: StatSyncOptions & { bigint?: false | undefined, throwIfNoEntry: false }): IStats | undefined,
  * (path: PathLike, options: StatSyncOptions & { bigint: true, throwIfNoEntry: false }): IBigIntStats | undefined,
- * (path: PathLike, options?: StatSyncOptions & { bigint?: false | undefined }): IStats,
- * (path: PathLike, options: StatSyncOptions & { bigint: true }): IBigIntStats,
- * (path: PathLike, options: StatSyncOptions & { bigint: boolean, throwIfNoEntry?: false | undefined }): IStats | IBigIntStats,
+ * (path: PathLike, options: StatSyncOptions & { bigint: boolean, throwIfNoEntry?: true | undefined }): IStats | IBigIntStats,
  * (path: PathLike, options?: StatSyncOptions): IStats | IBigIntStats | undefined,
  * }} LStatSync
  */

package/lib/util/hash/md4.js

@@ -11,7 +11,7 @@ const create = require("./wasm-hash");
 const md4 = new WebAssembly.Module(
 	Buffer.from(
 		// 2150 bytes
-		"AGFzbQEAAAABCAJgAX8AYAAAAwUEAQAAAAUDAQABBhoFfwFBAAt/AUEAC38BQQALfwFBAAt/AUEACwciBARpbml0AAAGdXBkYXRlAAIFZmluYWwAAwZtZW1vcnkCAAqFEAQmAEGBxpS6BiQBQYnXtv5+JAJB/rnrxXkkA0H2qMmBASQEQQAkAAvQCgEZfyMBIQUjAiECIwMhAyMEIQQDQCAAIAFLBEAgASgCBCIOIAQgAyABKAIAIg8gBSAEIAIgAyAEc3FzampBA3ciCCACIANzcXNqakEHdyEJIAEoAgwiBiACIAggASgCCCIQIAMgAiAJIAIgCHNxc2pqQQt3IgogCCAJc3FzampBE3chCyABKAIUIgcgCSAKIAEoAhAiESAIIAkgCyAJIApzcXNqakEDdyIMIAogC3Nxc2pqQQd3IQ0gASgCHCIJIAsgDCABKAIYIgggCiALIA0gCyAMc3FzampBC3ciEiAMIA1zcXNqakETdyETIAEoAiQiFCANIBIgASgCICIVIAwgDSATIA0gEnNxc2pqQQN3IgwgEiATc3FzampBB3chDSABKAIsIgsgEyAMIAEoAigiCiASIBMgDSAMIBNzcXNqakELdyISIAwgDXNxc2pqQRN3IRMgASgCNCIWIA0gEiABKAIwIhcgDCANIBMgDSASc3FzampBA3ciGCASIBNzcXNqakEHdyEZIBggASgCPCINIBMgGCABKAI4IgwgEiATIBkgEyAYc3FzampBC3ciEiAYIBlzcXNqakETdyITIBIgGXJxIBIgGXFyaiAPakGZ84nUBWpBA3ciGCATIBIgGSAYIBIgE3JxIBIgE3FyaiARakGZ84nUBWpBBXciEiATIBhycSATIBhxcmogFWpBmfOJ1AVqQQl3IhMgEiAYcnEgEiAYcXJqIBdqQZnzidQFakENdyIYIBIgE3JxIBIgE3FyaiAOakGZ84nUBWpBA3ciGSAYIBMgEiAZIBMgGHJxIBMgGHFyaiAHakGZ84nUBWpBBXciEiAYIBlycSAYIBlxcmogFGpBmfOJ1AVqQQl3IhMgEiAZcnEgEiAZcXJqIBZqQZnzidQFakENdyIYIBIgE3JxIBIgE3FyaiAQakGZ84nUBWpBA3ciGSAYIBMgEiAZIBMgGHJxIBMgGHFyaiAIakGZ84nUBWpBBXciEiAYIBlycSAYIBlxcmogCmpBmfOJ1AVqQQl3IhMgEiAZcnEgEiAZcXJqIAxqQZnzidQFakENdyIYIBIgE3JxIBIgE3FyaiAGakGZ84nUBWpBA3ciGSAYIBMgEiAZIBMgGHJxIBMgGHFyaiAJakGZ84nUBWpBBXciEiAYIBlycSAYIBlxcmogC2pBmfOJ1AVqQQl3IhMgEiAZcnEgEiAZcXJqIA1qQZnzidQFakENdyIYIBNzIBJzaiAPakGh1+f2BmpBA3ciDyAYIBMgEiAPIBhzIBNzaiAVakGh1+f2BmpBCXciEiAPcyAYc2ogEWpBodfn9gZqQQt3IhEgEnMgD3NqIBdqQaHX5/YGakEPdyIPIBFzIBJzaiAQakGh1+f2BmpBA3ciECAPIBEgEiAPIBBzIBFzaiAKakGh1+f2BmpBCXciCiAQcyAPc2ogCGpBodfn9gZqQQt3IgggCnMgEHNqIAxqQaHX5/YGakEPdyIMIAhzIApzaiAOakGh1+f2BmpBA3ciDiAMIAggCiAMIA5zIAhzaiAUakGh1+f2BmpBCXciCCAOcyAMc2ogB2pBodfn9gZqQQt3IgcgCHMgDnNqIBZqQaHX5/YGakEPdyIKIAdzIAhzaiAGakGh1+f2BmpBA3ciBiAFaiEFIAIgCiAHIAggBiAKcyAHc2ogC2pBodfn9gZqQQl3IgcgBnMgCnNqIAlqQaHX5/YGakELdyIIIAdzIAZzaiANakGh1+f2BmpBD3dqIQIgAyAIaiEDIAQgB2ohBCABQUBrIQEMAQsLIAUkASACJAIgAyQDIAQkBAsNACAAEAEjACAAaiQAC/sEAgN/AX4jACAAaq1CA4YhBCAAQcgAakFAcSICQQhrIAAiAUEBaiEAIAFBgAE6AAADQCAAIAJJQQAgAEEHcRsEQCAAQQA6AAAgAEEBaiEADAELCwNAIAAgAkkEQCAAQgA3AwAgAEEIaiEADAELCyAENwMAIAIQAUEAIwGtIgRC//8DgyAEQoCA/P8Pg0IQhoQiBEL/gYCA8B+DIARCgP6DgIDgP4NCCIaEIgRCj4C8gPCBwAeDQgiGIARC8IHAh4CegPgAg0IEiIQiBEKGjJiw4MCBgwZ8QgSIQoGChIiQoMCAAYNCJ34gBEKw4MCBg4aMmDCEfDcDAEEIIwKtIgRC//8DgyAEQoCA/P8Pg0IQhoQiBEL/gYCA8B+DIARCgP6DgIDgP4NCCIaEIgRCj4C8gPCBwAeDQgiGIARC8IHAh4CegPgAg0IEiIQiBEKGjJiw4MCBgwZ8QgSIQoGChIiQoMCAAYNCJ34gBEKw4MCBg4aMmDCEfDcDAEEQIwOtIgRC//8DgyAEQoCA/P8Pg0IQhoQiBEL/gYCA8B+DIARCgP6DgIDgP4NCCIaEIgRCj4C8gPCBwAeDQgiGIARC8IHAh4CegPgAg0IEiIQiBEKGjJiw4MCBgwZ8QgSIQoGChIiQoMCAAYNCJ34gBEKw4MCBg4aMmDCEfDcDAEEYIwStIgRC//8DgyAEQoCA/P8Pg0IQhoQiBEL/gYCA8B+DIARCgP6DgIDgP4NCCIaEIgRCj4C8gPCBwAeDQgiGIARC8IHAh4CegPgAg0IEiIQiBEKGjJiw4MCBgwZ8QgSIQoGChIiQoMCAAYNCJ34gBEKw4MCBg4aMmDCEfDcDAAs=",
+		"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",
 		"base64"
 	)
 );

package/lib/util/hash/xxhash64.js

@@ -11,7 +11,7 @@ const create = require("./wasm-hash");
 const xxhash64 = new WebAssembly.Module(
 	Buffer.from(
 		// 1160 bytes
-		"AGFzbQEAAAABCAJgAX8AYAAAAwQDAQAABQMBAAEGGgV+AUIAC34BQgALfgFCAAt+AUIAC34BQgALByIEBGluaXQAAAZ1cGRhdGUAAQVmaW5hbAACBm1lbW9yeQIACqgIAzAAQtbrgu7q/Yn14AAkAELP1tO+0ser2UIkAUIAJAJC+erQ0OfJoeThACQDQgAkBAvUAQIBfwR+IABFBEAPCyMEIACtfCQEIwAhAiMBIQMjAiEEIwMhBQNAIAIgASkDAELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiECIAMgASkDCELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiEDIAQgASkDEELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiEEIAUgASkDGELP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fiEFIAFBIGoiASAASQ0ACyACJAAgAyQBIAQkAiAFJAMLngYCAn8CfiMEQgBSBH4jAEIBiSMBQgeJfCMCQgyJfCMDQhKJfCMAQs/W077Sx6vZQn5CH4lCh5Wvr5i23puef36FQoeVr6+Ytt6bnn9+Qp2jteqDsY2K+gB9IwFCz9bTvtLHq9lCfkIfiUKHla+vmLbem55/foVCh5Wvr5i23puef35CnaO16oOxjYr6AH0jAkLP1tO+0ser2UJ+Qh+JQoeVr6+Ytt6bnn9+hUKHla+vmLbem55/fkKdo7Xqg7GNivoAfSMDQs/W077Sx6vZQn5CH4lCh5Wvr5i23puef36FQoeVr6+Ytt6bnn9+Qp2jteqDsY2K+gB9BULFz9my8eW66icLIwQgAK18fCEDA0AgAUEIaiICIABNBEAgAyABKQMAQs/W077Sx6vZQn5CH4lCh5Wvr5i23puef36FQhuJQoeVr6+Ytt6bnn9+Qp2jteqDsY2K+gB9IQMgAiEBDAELCyABQQRqIgIgAE0EQCADIAE1AgBCh5Wvr5i23puef36FQheJQs/W077Sx6vZQn5C+fPd8Zn2masWfCEDIAIhAQsDQCAAIAFHBEAgAyABMQAAQsXP2bLx5brqJ36FQguJQoeVr6+Ytt6bnn9+IQMgAUEBaiEBDAELC0EAIAMgA0IhiIVCz9bTvtLHq9lCfiIDQh2IIAOFQvnz3fGZ9pmrFn4iA0IgiCADhSIDQiCIIgRC//8Dg0IghiAEQoCA/P8Pg0IQiIQiBEL/gYCA8B+DQhCGIARCgP6DgIDgP4NCCIiEIgRCj4C8gPCBwAeDQgiGIARC8IHAh4CegPgAg0IEiIQiBEKGjJiw4MCBgwZ8QgSIQoGChIiQoMCAAYNCJ34gBEKw4MCBg4aMmDCEfDcDAEEIIANC/////w+DIgNC//8Dg0IghiADQoCA/P8Pg0IQiIQiA0L/gYCA8B+DQhCGIANCgP6DgIDgP4NCCIiEIgNCj4C8gPCBwAeDQgiGIANC8IHAh4CegPgAg0IEiIQiA0KGjJiw4MCBgwZ8QgSIQoGChIiQoMCAAYNCJ34gA0Kw4MCBg4aMmDCEfDcDAAs=",
+		"AGFzbQEAAAABCAJgAX8AYAAAAwQDAAEABQMBAAEGGgV+AUIAC34BQgALfgFCAAt+AUIAC34BQgALByIEBGluaXQAAQZ1cGRhdGUAAAVmaW5hbAACBm1lbW9yeQIACqgIA9QBAgF/BH4gAEUEQA8LIwQgAK18JAQjACECIwEhAyMCIQQjAyEFA0AgAiABKQMAQs/W077Sx6vZQn58Qh+JQoeVr6+Ytt6bnn9+IQIgAyABKQMIQs/W077Sx6vZQn58Qh+JQoeVr6+Ytt6bnn9+IQMgBCABKQMQQs/W077Sx6vZQn58Qh+JQoeVr6+Ytt6bnn9+IQQgBSABKQMYQs/W077Sx6vZQn58Qh+JQoeVr6+Ytt6bnn9+IQUgAUEgaiIBIABJDQALIAIkACADJAEgBCQCIAUkAwswAELW64Lu6v2J9eAAJABCz9bTvtLHq9lCJAFCACQCQvnq0NDnyaHk4QAkA0IAJAQLngYCAn8CfiMEQgBSBH4jAEIBiSMBQgeJfCMCQgyJfCMDQhKJfCMAQs/W077Sx6vZQn5CH4lCh5Wvr5i23puef36FQoeVr6+Ytt6bnn9+Qp2jteqDsY2K+gB9IwFCz9bTvtLHq9lCfkIfiUKHla+vmLbem55/foVCh5Wvr5i23puef35CnaO16oOxjYr6AH0jAkLP1tO+0ser2UJ+Qh+JQoeVr6+Ytt6bnn9+hUKHla+vmLbem55/fkKdo7Xqg7GNivoAfSMDQs/W077Sx6vZQn5CH4lCh5Wvr5i23puef36FQoeVr6+Ytt6bnn9+Qp2jteqDsY2K+gB9BULFz9my8eW66icLIwQgAK18fCEDA0AgAUEIaiICIABNBEAgAyABKQMAQs/W077Sx6vZQn5CH4lCh5Wvr5i23puef36FQhuJQoeVr6+Ytt6bnn9+Qp2jteqDsY2K+gB9IQMgAiEBDAELCyABQQRqIgIgAE0EQCADIAE1AgBCh5Wvr5i23puef36FQheJQs/W077Sx6vZQn5C+fPd8Zn2masWfCEDIAIhAQsDQCAAIAFHBEAgAyABMQAAQsXP2bLx5brqJ36FQguJQoeVr6+Ytt6bnn9+IQMgAUEBaiEBDAELC0EAIAMgA0IhiIVCz9bTvtLHq9lCfiIDQh2IIAOFQvnz3fGZ9pmrFn4iA0IgiCADhSIDQiCIIgRC//8Dg0IghiAEQoCA/P8Pg0IQiIQiBEL/gYCA8B+DQhCGIARCgP6DgIDgP4NCCIiEIgRCj4C8gPCBwAeDQgiGIARC8IHAh4CegPgAg0IEiIQiBEKGjJiw4MCBgwZ8QgSIQoGChIiQoMCAAYNCJ34gBEKw4MCBg4aMmDCEfDcDAEEIIANC/////w+DIgNC//8Dg0IghiADQoCA/P8Pg0IQiIQiA0L/gYCA8B+DQhCGIANCgP6DgIDgP4NCCIiEIgNCj4C8gPCBwAeDQgiGIANC8IHAh4CegPgAg0IEiIQiA0KGjJiw4MCBgwZ8QgSIQoGChIiQoMCAAYNCJ34gA0Kw4MCBg4aMmDCEfDcDAAs=",
 		"base64"
 	)
 );