@depup/webpack 5.109.2-depup.0 → 5.110.1-depup.0

package/lib/util/globUtils.js

@@ -7,9 +7,13 @@
 
 const path = require("path");
 const { join: joinPath } = require("./fs");
+const {
+	ABSOLUTE_PATH_REGEXP,
+	WINDOWS_PATH_SEPARATOR_REGEXP
+} = require("./identifier");
 const memoize = require("./memoize");
 
-// watchpack is only needed at watch time otherwise; load its glob core lazily
+// watchpack's glob-to-regexp core, loaded only when a glob is translated
 const getGlobToRegExpSource = memoize(
 	() =>
 		/** @type {{ util: { globToRegExp: (glob: string) => string } }} */ (
@@ -68,7 +72,9 @@ const normalizePathSeparators = (s) => {
  * @param {string} s string
  * @returns {string} normalized path separators for filesystem paths
  */
-const normalizePathSeparatorsForPath = (s) => s.replace(/\\/g, "/");
+const normalizePathSeparatorsForPath = (s) =>
+	// the scan is cheaper than the replace, and most paths have no `\`
+	s.includes("\\") ? s.replace(WINDOWS_PATH_SEPARATOR_REGEXP, "/") : s;
 
 /**
  * @param {string} s string
@@ -149,9 +155,26 @@ const extractGlobBaseDir = (pattern) => {
  */
 const quoteRegExpChar = (c) => (/[$()*+\-./?[\\\]^{|}]/.test(c) ? `\\${c}` : c);
 
+/**
+ * Skips a character class: a `]` right after the `[`, or after its `!`/`^`, is
+ * a member rather than the terminator.
+ * @param {string} str string
+ * @param {number} start index of the `[`
+ * @returns {number} index of the closing `]`, or `start` when unterminated
+ */
+const skipCharacterClass = (str, start) => {
+	let i = start + 1;
+	if (str[i] === "!" || str[i] === "^") i++;
+	if (str[i] === "]") i++;
+	while (i < str.length && str[i] !== "]") i += str[i] === "\\" ? 2 : 1;
+	return i < str.length ? i : start;
+};
+
 /**
  * Expands `{a,b}` alternations (escape- and class-aware, nested) into
- * brace-free globs; unmatched braces are kept as literal characters.
+ * brace-free globs; unmatched braces are kept as literal characters. A `,`
+ * inside a class is a member, as `braces` and picomatch read it, so
+ * `import.meta.glob` patterns mean here what they mean to fast-glob.
  * @param {string} glob glob
  * @returns {string[]} brace-free globs
  */
@@ -164,10 +187,7 @@ const expandGlobBraces = (glob) => {
 		if (c === "\\") {
 			i++;
 		} else if (c === "[") {
-			while (i + 1 < glob.length && glob[i + 1] !== "]") {
-				i += glob[i + 1] === "\\" ? 2 : 1;
-			}
-			i++;
+			i = skipCharacterClass(glob, i);
 		} else if (c === "{") {
 			if (depth === 0) braceStart = i;
 			depth++;
@@ -199,10 +219,7 @@ const expandGlobBraces = (glob) => {
 		if (c === "\\") {
 			i++;
 		} else if (c === "[") {
-			while (i + 1 < inner.length && inner[i + 1] !== "]") {
-				i += inner[i + 1] === "\\" ? 2 : 1;
-			}
-			i++;
+			i = skipCharacterClass(inner, i);
 		} else if (c === "{") {
 			altDepth++;
 		} else if (c === "}") {
@@ -240,7 +257,6 @@ const fixupGlobRegExpSource = (source) =>
  * @returns {string} regexp source without anchors
  */
 const braceFreeGlobToRegExpSource = (glob) => {
-	const globToRegExpSource = getGlobToRegExpSource();
 	let source = "";
 	let runStart = 0;
 	/**
@@ -249,7 +265,7 @@ const braceFreeGlobToRegExpSource = (glob) => {
 	const flushRun = (end) => {
 		if (runStart < end) {
 			source += fixupGlobRegExpSource(
-				globToRegExpSource(glob.slice(runStart, end))
+				getGlobToRegExpSource()(glob.slice(runStart, end))
 			);
 		}
 	};
@@ -261,18 +277,11 @@ const braceFreeGlobToRegExpSource = (glob) => {
 			i++;
 			runStart = i + 1;
 		} else if (c === "[") {
-			let end = i + 1;
-			let negated = false;
-			if (glob[end] === "!" || glob[end] === "^") {
-				negated = true;
-				end++;
-			}
-			const bodyStart = end;
-			while (end < glob.length && glob[end] !== "]") {
-				end += glob[end] === "\\" ? 2 : 1;
-			}
+			const negated = glob[i + 1] === "!" || glob[i + 1] === "^";
+			const bodyStart = i + (negated ? 2 : 1);
+			const end = skipCharacterClass(glob, i);
 			flushRun(i);
-			if (end >= glob.length) {
+			if (end === i) {
 				// unterminated class: literal `[`
 				source += "\\[";
 				runStart = i + 1;
@@ -326,6 +335,269 @@ const globMatchWithOptions = (pattern, str, options = {}) => {
 	return regexp !== null && regexp.test(str);
 };
 
+// a segment starting with a dot is only reachable by a pattern spelling it out
+const NON_DOT_PREFIX = "(?!\\.)";
+const NON_DOT_SEGMENT = "(?!\\.)[^/]+";
+const CONSECUTIVE_STARS_REGEXP = /\*{2,}/g;
+// a `//` or `/./` the path has to lose before it can be matched
+const UNNORMALIZED_PATH_REGEXP = /\/\/|(?:^|\/)\.(?:\/|$)/;
+
+/**
+ * Drops the `.` and empty segments of a pattern or a path — they always name
+ * the same file. The first and last segment stay, so a leading `./`, a leading
+ * `/` and a trailing `/` keep their meaning. A `..` is left alone: resolving it
+ * textually is what `path.matchesGlob` does, and it is wrong through a symlink,
+ * where `dir/link/../b` is not `dir/b`.
+ * @param {string[]} parts segments
+ * @returns {string[]} normalized segments
+ */
+const optimizeGlobSegments = (parts) => {
+	let changed = false;
+	do {
+		changed = false;
+		for (let i = 1; i < parts.length - 1; i++) {
+			if (parts[i] === "." || parts[i] === "") {
+				parts.splice(i, 1);
+				i--;
+				changed = true;
+			}
+		}
+		if (
+			parts[0] === "." &&
+			parts.length === 2 &&
+			(parts[1] === "." || parts[1] === "")
+		) {
+			parts.pop();
+			changed = true;
+		}
+	} while (changed);
+	return parts.length === 0 ? [""] : parts;
+};
+
+/**
+ * @param {string} segment segment
+ * @param {number} start index of the `(`
+ * @returns {number} index of the matching `)`, -1 when unmatched
+ */
+const findExtendedGlobEnd = (segment, start) => {
+	let depth = 0;
+	for (let i = start; i < segment.length; i++) {
+		const c = segment[i];
+		if (c === "[") {
+			i = skipCharacterClass(segment, i);
+		} else if (c === "(") {
+			depth++;
+		} else if (c === ")" && --depth === 0) {
+			return i;
+		}
+	}
+	return -1;
+};
+
+/**
+ * @param {string} inner group body
+ * @returns {string[]} top-level `|` alternatives
+ */
+const splitExtendedGlobAlternatives = (inner) => {
+	/** @type {string[]} */
+	const alternatives = [];
+	let start = 0;
+	let depth = 0;
+	for (let i = 0; i < inner.length; i++) {
+		const c = inner[i];
+		if (c === "[") {
+			i = skipCharacterClass(inner, i);
+		} else if (c === "(") {
+			depth++;
+		} else if (c === ")") {
+			depth--;
+		} else if (c === "|" && depth === 0) {
+			alternatives.push(inner.slice(start, i));
+			start = i + 1;
+		}
+	}
+	alternatives.push(inner.slice(start));
+	return alternatives;
+};
+
+/**
+ * @param {string} segment segment
+ * @returns {number} index of the first extended glob prefix, -1 when there is none
+ */
+const findExtendedGlobStart = (segment) => {
+	for (let i = 0; i < segment.length - 1; i++) {
+		const c = segment[i];
+		if (c === "[") {
+			i = skipCharacterClass(segment, i);
+		} else if (
+			segment[i + 1] === "(" &&
+			(c === "?" || c === "*" || c === "+" || c === "@" || c === "!")
+		) {
+			return i;
+		}
+	}
+	return -1;
+};
+
+/**
+ * Whether the segment can match a leading dot, which it does when the dot is
+ * literal in the pattern — after an extended glob that matched nothing
+ * included, as `*(a).b` matching `.b`.
+ * @param {string} segment segment without separators
+ * @returns {boolean} segment may match a dot segment
+ */
+const segmentGlobMatchesLeadingDot = (segment) => {
+	if (segment.startsWith(".")) return true;
+	if (findExtendedGlobStart(segment) !== 0) return false;
+	const end = findExtendedGlobEnd(segment, 1);
+	if (end === -1) return false;
+	const type = segment[0];
+	const emptyMatch =
+		type === "*" ||
+		type === "?" ||
+		((type === "@" || type === "+") &&
+			splitExtendedGlobAlternatives(segment.slice(2, end)).includes(""));
+	return emptyMatch && segmentGlobMatchesLeadingDot(segment.slice(end + 1));
+};
+
+/**
+ * Whether the segment matches an empty path segment, which only the extended
+ * globs that quantify their group do — `!(x)/a` matches `/a`, `@(a|)/a` does
+ * not, and neither does a bare `*`.
+ * @param {string} segment segment without separators
+ * @returns {boolean} segment may match nothing
+ */
+const segmentGlobMatchesEmpty = (segment) => {
+	if (segment === "") return true;
+	if (findExtendedGlobStart(segment) !== 0) return false;
+	const type = segment[0];
+	if (type !== "!" && type !== "*" && type !== "?") return false;
+	const end = findExtendedGlobEnd(segment, 1);
+	return end !== -1 && segmentGlobMatchesEmpty(segment.slice(end + 1));
+};
+
+/**
+ * Compiles one path segment, extended globs (`+(a|b)`, `!(a)`, …) included.
+ * `!(a)` is "anything but `a`", so it is a lookahead over what the rest of the
+ * segment matches, not over `a` alone.
+ * @param {string} segment segment without separators
+ * @returns {string} regexp source
+ */
+const segmentGlobToRegExpSource = (segment) => {
+	const start = findExtendedGlobStart(segment);
+	const end = start === -1 ? -1 : findExtendedGlobEnd(segment, start + 1);
+	if (end === -1) {
+		// no extended glob here, and `**` within a segment is a plain `*`
+		return braceFreeGlobToRegExpSource(
+			segment.replace(CONSECUTIVE_STARS_REGEXP, "*")
+		);
+	}
+	const prefix = segmentGlobToRegExpSource(segment.slice(0, start));
+	const rest = segmentGlobToRegExpSource(segment.slice(end + 1));
+	const group = `(?:${splitExtendedGlobAlternatives(
+		segment.slice(start + 2, end)
+	)
+		.map(segmentGlobToRegExpSource)
+		.join("|")})`;
+	switch (segment[start]) {
+		case "?":
+			return `${prefix}${group}?${rest}`;
+		case "*":
+			return `${prefix}${group}*${rest}`;
+		case "+":
+			return `${prefix}${group}+${rest}`;
+		case "@":
+			return `${prefix}${group}${rest}`;
+		default:
+			return `${prefix}(?!${group}${rest}(?:/|$))[^/]*?${rest}`;
+	}
+};
+
+/**
+ * Compiles one brace-free `/`-separated glob to a regexp source with
+ * `path.matchesGlob` semantics: `*`, `?` and classes stay within a segment,
+ * a whole-segment `**` spans segments, and neither crosses a dot segment.
+ * @param {string} glob brace-free glob
+ * @returns {string} regexp source without anchors
+ */
+const braceFreeGlobToPathRegExpSource = (glob) => {
+	const segments = optimizeGlobSegments(glob.split("/"));
+	let source = "";
+	let needSeparator = false;
+	for (let i = 0; i < segments.length; i++) {
+		const segment = segments[i];
+		const isLast = i === segments.length - 1;
+		if (segment === "") {
+			// leading separator (absolute) and trailing one (directory)
+			source += "/";
+			continue;
+		}
+		if (segment === "**") {
+			source += isLast
+				? `${needSeparator ? "/" : ""}(?:${NON_DOT_SEGMENT}(?:/${NON_DOT_SEGMENT})*)?`
+				: needSeparator
+					? `(?:/${NON_DOT_SEGMENT})*`
+					: `/?(?:${NON_DOT_SEGMENT}/)*`;
+			needSeparator = !isLast && needSeparator;
+			continue;
+		}
+		if (needSeparator) source += "/";
+		// a segment matches at least one character
+		if (!segmentGlobMatchesEmpty(segment)) source += "(?=[^/])";
+		if (!segmentGlobMatchesLeadingDot(segment)) source += NON_DOT_PREFIX;
+		source += segmentGlobToRegExpSource(segment);
+		needSeparator = true;
+	}
+	// a pattern without a trailing separator still matches a directory path
+	return glob.endsWith("/") ? source : `${source}/?`;
+};
+
+/**
+ * Compiles a glob into a matcher over OS-independent paths: `\` is a path
+ * separator in both the pattern and the tested path (never an escape, so a
+ * pattern built with `path.resolve` works everywhere; use `[*]` to match a
+ * literal `*`), and a relative pattern matches at any depth. Matching follows
+ * `path.matchesGlob`, except where its minimatch shows through — see the
+ * divergences listed above the corpus in `test/globUtils.unittest.js`.
+ * @param {string} pattern glob pattern
+ * @param {GlobMatchOptions=} options options
+ * @returns {((str: string) => boolean) | null} matcher, null for un-compilable patterns
+ */
+const createPathGlobMatcher = (pattern, options = {}) => {
+	let normalizedPattern = normalizePathSeparatorsForPath(pattern);
+	while (normalizedPattern.startsWith("./")) {
+		normalizedPattern = normalizedPattern.slice(2);
+	}
+	if (
+		!ABSOLUTE_PATH_REGEXP.test(normalizedPattern) &&
+		!normalizedPattern.startsWith("**/")
+	) {
+		normalizedPattern = `**/${normalizedPattern}`;
+	}
+	const sources = expandGlobBraces(normalizedPattern).map(
+		braceFreeGlobToPathRegExpSource
+	);
+	const source = sources.length === 1 ? sources[0] : `(?:${sources.join("|")})`;
+	/** @type {RegExp} */
+	let regexp;
+	try {
+		regexp = new RegExp(
+			`^${source}$`,
+			options.caseSensitive === false ? "i" : ""
+		);
+	} catch (_err) {
+		return null;
+	}
+	return (str) => {
+		const normalizedPath = normalizePathSeparatorsForPath(str);
+		return regexp.test(
+			UNNORMALIZED_PATH_REGEXP.test(normalizedPath)
+				? optimizeGlobSegments(normalizedPath.split("/")).join("/")
+				: normalizedPath
+		);
+	};
+};
+
 /**
  * @param {string} path path
  * @param {string} baseDir base directory
@@ -689,8 +961,10 @@ const globPatternBaseReachesDir = (patterns, dirPath) => {
 
 module.exports = {
 	commonGlobBaseDir,
+	createPathGlobMatcher,
 	escapeGlobPattern,
 	extractGlobBaseDir,
+	getGlobToRegExpSource,
 	globMatchNormalizedWithExplicitDot,
 	globMatchWithExplicitDot,
 	globMatchWithOptions,

package/lib/util/hash/BatchedHash.js

@@ -10,7 +10,11 @@ const { digest, update } = require("./hash-digest");
 /** @type {number} */
 const MAX_SHORT_STRING = require("./wasm-hash").MAX_SHORT_STRING;
 
-/** @typedef {import("../../../declarations/WebpackOptions").HashDigest} Encoding */
+/**
+ * @import {
+ * 	HashDigest as Encoding
+ * } from "../../../declarations/WebpackOptions"
+ */
 
 class BatchedHash extends Hash {
 	/**

package/lib/util/hash/BulkUpdateHash.js

@@ -8,7 +8,11 @@
 const Hash = require("../Hash");
 const { digest, update } = require("./hash-digest");
 
-/** @typedef {import("../../../declarations/WebpackOptions").HashDigest} Encoding */
+/**
+ * @import {
+ * 	HashDigest as Encoding
+ * } from "../../../declarations/WebpackOptions"
+ */
 /** @typedef {() => Hash} HashFactory */
 
 const BULK_SIZE = 3;

package/lib/util/hash/DebugHash.js

@@ -7,7 +7,11 @@
 
 const Hash = require("../Hash");
 
-/** @typedef {import("../../../declarations/WebpackOptions").HashDigest} Encoding */
+/**
+ * @import {
+ * 	HashDigest as Encoding
+ * } from "../../../declarations/WebpackOptions"
+ */
 
 /* istanbul ignore next */
 class DebugHash extends Hash {

package/lib/util/hash/hash-digest.js

@@ -5,8 +5,12 @@
 
 "use strict";
 
-/** @typedef {import("../Hash")} Hash */
-/** @typedef {import("../../../declarations/WebpackOptions").HashDigest} Encoding */
+/** @import Hash from "../Hash" */
+/**
+ * @import {
+ * 	HashDigest as Encoding
+ * } from "../../../declarations/WebpackOptions"
+ */
 
 /** @typedef {"26" | "32" | "36" | "49" | "52" | "58" | "62"} Base */
 

package/lib/util/identifier.js

@@ -14,6 +14,7 @@ const ABSOLUTE_PATH_REGEXP = /^(?:[a-z]:)?[\\/]/i;
 const WINDOWS_ABS_PATH_REGEXP = /^[a-z]:[\\/]/i;
 const SEGMENTS_SPLIT_REGEXP = /([|!])/;
 const WINDOWS_PATH_SEPARATOR_REGEXP = /\\/g;
+const NODE_MODULES_REGEXP = /[\\/]node_modules[\\/]/i;
 
 /**
  * Relative path to request.
@@ -566,7 +567,9 @@ const toJsStringLiteral = (str) =>
 	);
 
 module.exports.ABSOLUTE_PATH_REGEXP = ABSOLUTE_PATH_REGEXP;
+module.exports.NODE_MODULES_REGEXP = NODE_MODULES_REGEXP;
 module.exports.WINDOWS_ABS_PATH_REGEXP = WINDOWS_ABS_PATH_REGEXP;
+module.exports.WINDOWS_PATH_SEPARATOR_REGEXP = WINDOWS_PATH_SEPARATOR_REGEXP;
 module.exports.absolutify = absolutify;
 module.exports.contextify = contextify;
 module.exports.contextifySourceUrl = contextifySourceUrl;
@@ -579,4 +582,5 @@ module.exports.parseResource = makeCacheable(_parseResource);
 module.exports.parseResourceWithoutFragment = makeCacheable(
 	_parseResourceWithoutFragment
 );
+module.exports.relativePathToRequest = relativePathToRequest;
 module.exports.toJsStringLiteral = toJsStringLiteral;

package/lib/util/implicitTypeLoaderFallback.js

@@ -8,7 +8,7 @@
 const { JAVASCRIPT_MODULE_TYPE_AUTO } = require("../ModuleTypeConstants");
 const { parseResource } = require("./identifier");
 
-/** @typedef {import("../NormalModuleFactory")} NormalModuleFactory */
+/** @import NormalModuleFactory from "../NormalModuleFactory" */
 
 /**
  * When a built-in module type is only enabled implicitly (`experiments.css` /

package/lib/util/internalSerializables.js

@@ -43,6 +43,8 @@ module.exports = {
 		require("../dependencies/AMDRequireDependency"),
 	"dependencies/AMDRequireItemDependency": () =>
 		require("../dependencies/AMDRequireItemDependency"),
+	"dependencies/BuildTimeConstDependency": () =>
+		require("../dependencies/BuildTimeConstDependency"),
 	"dependencies/CachedConstDependency": () =>
 		require("../dependencies/CachedConstDependency"),
 	"dependencies/CommonJsExportRequireDependency": () =>
@@ -51,6 +53,8 @@ module.exports = {
 		require("../dependencies/CommonJsExportsDependency"),
 	"dependencies/CommonJsFullRequireDependency": () =>
 		require("../dependencies/CommonJsFullRequireDependency"),
+	"dependencies/CommonJsObjectExportDependency": () =>
+		require("../dependencies/CommonJsObjectExportDependency"),
 	"dependencies/CommonJsRequireContextDependency": () =>
 		require("../dependencies/CommonJsRequireContextDependency"),
 	"dependencies/CommonJsRequireDependency": () =>
@@ -211,6 +215,8 @@ module.exports = {
 		require("../errors/InvalidDependenciesModuleWarning"),
 	"errors/JSONParseError": () => require("../errors/JSONParseError"),
 	"errors/ModuleBuildError": () => require("../errors/ModuleBuildError"),
+	"errors/ModuleDependencyError": () =>
+		require("../errors/ModuleDependencyError"),
 	"errors/ModuleDependencyWarning": () =>
 		require("../errors/ModuleDependencyWarning"),
 	"errors/ModuleError": () => require("../errors/ModuleError"),

package/lib/util/lazyModule.js

@@ -0,0 +1,56 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+/**
+ * Declares a module that loads on first use, in the shape a dynamic `import()`
+ * has: the accessor resolves to the module and the caller awaits it. The thunk
+ * is a `require` until `lib/` moves to ecma modules, which changes that keyword
+ * and nothing else — `Promise.resolve` already passes an `import()` promise
+ * through. It is never called outside the promise, so nothing here needs a
+ * synchronous load.
+ *
+ * `loaded` reads the module back for a consumer with nowhere to await — a
+ * synchronous hook, a dependency template, a generator. It throws until an
+ * awaited call has resolved, so every such consumer must sit behind one
+ * (`NormalModuleFactory`'s `prepareModuleType`, `Compilation`'s pending runtime
+ * modules). A module with no such boundary is required at the top of its file
+ * instead of being declared here.
+ * @template T
+ * @param {() => T | Promise<T>} load loads the module
+ * @returns {LazyModuleAccessor<T>} resolves the module, loading it once
+ */
+const lazyModule = (load) => {
+	/** @type {Promise<T> | undefined} */
+	let promise;
+	/** @type {T | undefined} */
+	let value;
+	const get = () => {
+		if (promise === undefined) {
+			promise = Promise.resolve(load()).then((module) => (value = module));
+			// release the loader and everything it holds
+			/** @type {(() => T | Promise<T>) | undefined} */
+			(load) = undefined;
+		}
+		return promise;
+	};
+	get.loaded = () => {
+		if (value === undefined) {
+			throw new Error(
+				"Lazy module was read before an awaited call resolved it; preload it at the nearest async boundary"
+			);
+		}
+		return value;
+	};
+	return get;
+};
+
+/**
+ * @template T
+ * @typedef {(() => Promise<T>) & { loaded: () => T }} LazyModuleAccessor
+ */
+
+module.exports = lazyModule;

package/lib/util/makeSerializable.js

@@ -6,9 +6,13 @@
 
 const { register } = require("./serialization");
 
-/** @typedef {import("../serialization/ObjectMiddleware").Constructor} Constructor */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/**
+ * @import {
+ * 	Constructor,
+ * 	ObjectDeserializerContext,
+ * 	ObjectSerializerContext
+ * } from "../serialization/ObjectMiddleware"
+ */
 
 /** @typedef {{ serialize: (context: ObjectSerializerContext) => void, deserialize: (context: ObjectDeserializerContext) => void }} SerializableClass */
 /**

package/lib/util/matchAlias.js

@@ -0,0 +1,25 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const SLASH_CHAR_CODE = 47;
+
+/**
+ * Whether a `resolve.alias` name applies to a request. Mirrors `AliasPlugin`:
+ * a name matches the whole request or a leading segment of it, and
+ * `onlyModule` restricts it to the former.
+ * @param {string} request the request as written
+ * @param {string} name the alias name, already normalized by enhanced-resolve
+ * @param {boolean=} onlyModule whether the alias only matches the whole request
+ * @returns {boolean} true when the alias applies to the request
+ */
+const matchAlias = (request, name, onlyModule) => {
+	if (!request.startsWith(name)) return false;
+	if (request.length === name.length) return true;
+	return !onlyModule && request.charCodeAt(name.length) === SLASH_CHAR_CODE;
+};
+
+module.exports = matchAlias;

package/lib/util/mimeTypes.js

@@ -6,6 +6,7 @@
 
 const { extname } = require("path");
 const db = require("mime-db");
+const memoize = require("./memoize");
 
 /**
  * RegExp to match type in RFC 6838
@@ -22,8 +23,6 @@ const db = require("mime-db");
  */
 const TYPE_REGEXP =
 	/^ *(([A-Za-z0-9][A-Za-z0-9!#$&^_-]{0,126})\/([A-Za-z0-9][A-Za-z0-9!#$&^_.+-]{0,126})) *(?:;.*)?$/;
-const extensions = Object.create(null);
-const types = Object.create(null);
 
 // Score RFC facets (see https://tools.ietf.org/html/rfc6838#section-3)
 
@@ -126,7 +125,14 @@ const populate = (extensions, types) => {
 	}
 };
 
-populate(extensions, types);
+// ~2500 mime-db entries scored against each other; only a build that resolves
+// a type pays for the tables
+const getTables = memoize(() => {
+	const extensions = Object.create(null);
+	const types = Object.create(null);
+	populate(extensions, types);
+	return { extensions, types };
+});
 
 /**
  * Get the default extension for a MIME type.
@@ -144,7 +150,7 @@ const extension = (type) => {
 		return;
 	}
 
-	const possibleExtensions = extensions[match[1].toLowerCase()];
+	const possibleExtensions = getTables().extensions[match[1].toLowerCase()];
 
 	if (!possibleExtensions || possibleExtensions.length === 0) {
 		return;
@@ -170,7 +176,7 @@ const lookup = (path) => {
 		return;
 	}
 
-	return types[extension];
+	return getTables().types[extension];
 };
 
 module.exports = { extension, lookup };

package/lib/util/nonNumericOnlyHash.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-/** @typedef {import("./Hash")} Hash */
+/** @import Hash from "./Hash" */
 
 const A_CODE = "a".charCodeAt(0);
 
@@ -47,6 +47,7 @@ const digestNonNumericOnlyWithFull = (hash, hashDigest, hashDigestLength) => {
 	return [nonNumericOnlyHash(full, hashDigestLength), full];
 };
 
+nonNumericOnlyHash.digestNonNumericOnly = digestNonNumericOnly;
+nonNumericOnlyHash.digestNonNumericOnlyWithFull = digestNonNumericOnlyWithFull;
+
 module.exports = nonNumericOnlyHash;
-module.exports.digestNonNumericOnly = digestNonNumericOnly;
-module.exports.digestNonNumericOnlyWithFull = digestNonNumericOnlyWithFull;