@depup/webpack 5.111.1-depup.1 → 5.112.0-depup.0

package/lib/{RuntimeTemplate.js → template/RuntimeTemplate.js}

@@ -6,54 +6,57 @@
 "use strict";
 
 const { CachedSource, ReplaceSource } = require("webpack-sources");
-const APIPlugin = require("./APIPlugin");
 
-const InitFragment = require("./InitFragment");
-const { CSS_TYPE, JAVASCRIPT_TYPE } = require("./ModuleSourceTypeConstants");
-const { WEBASSEMBLY_MODULE_TYPE_ASYNC } = require("./ModuleTypeConstants");
-const RuntimeGlobals = require("./RuntimeGlobals");
-const Template = require("./Template");
 const {
 	getOutgoingAsyncModules
-} = require("./async-modules/AsyncModuleHelpers");
-const HarmonyImportDependency = require("./dependencies/HarmonyImportDependency");
-const ImportDependency = require("./dependencies/ImportDependency");
-const { ImportPhaseUtils } = require("./dependencies/ImportPhase");
-const JavascriptModulesPlugin = require("./javascript/JavascriptModulesPlugin");
-const { InlinedUsedName } = require("./optimize/InlineExports");
+} = require("../async-modules/AsyncModuleHelpers");
+const { ImportPhaseUtils } = require("../dependencies/core/ImportPhase");
+const isDependencyKind = require("../graph/isDependencyKind");
+const APIPlugin = require("../javascript/APIPlugin");
+const JavascriptModulesPlugin = require("../javascript/JavascriptModulesPlugin");
+const {
+	CSS_TYPE,
+	JAVASCRIPT_TYPE
+} = require("../module/ModuleSourceTypeConstants");
+const {
+	WEBASSEMBLY_MODULE_TYPE_ASYNC
+} = require("../module/ModuleTypeConstants");
+const { isInlinedUsedName } = require("../optimize/InlineExports");
 const {
 	getDeferredCycleModuleIds,
 	getDeferredCycleModules,
 	getKnownExportNames,
 	getMakeDeferredNamespaceModeFromExportsType,
 	getOptimizedDeferredModule
-} = require("./runtime/MakeDeferredNamespaceObjectRuntime");
+} = require("../runtime/MakeDeferredNamespaceObjectRuntime");
+const RuntimeGlobals = require("../runtime/RuntimeGlobals");
 const {
 	isAbsoluteBaseUri,
 	isChunkRelativeBaseUri
-} = require("./runtime/baseUri");
-const { equals } = require("./util/ArrayHelpers");
-const { getScheme } = require("./util/URLAbsoluteSpecifier");
-const { compareIds } = require("./util/comparators");
-const compileBooleanMatcher = require("./util/compileBooleanMatcher");
+} = require("../runtime/baseUri");
+const { equals } = require("../util/ArrayHelpers");
+const { getScheme } = require("../util/URLAbsoluteSpecifier");
+const { compareIds } = require("../util/comparators");
+const compileBooleanMatcher = require("../util/compileBooleanMatcher");
 const {
 	RESOLVABLE_SPECIFIER_REGEXP,
 	getUndoPath,
 	toJsStringLiteral
-} = require("./util/identifier");
-const memoize = require("./util/memoize");
-const { propertyAccess, propertyName } = require("./util/property");
+} = require("../util/identifier");
+const memoize = require("../util/memoize");
+const { propertyAccess, propertyName } = require("../util/property");
 const {
 	forEachRuntime,
 	getRuntimeKey,
 	intersectRuntime,
 	subtractRuntime
-} = require("./util/runtime");
+} = require("../util/runtime");
+const InitFragment = require("./InitFragment");
+const Template = require("./Template");
 
-const getCssModulesPlugin = memoize(() => require("./css/CssModulesPlugin"));
+const getCssModulesPlugin = memoize(() => require("../css/CssModulesPlugin"));
 // `Compilation` requires this module, so its stage constants are read lazily.
-const getCompilation = memoize(() => require("./Compilation"));
-const getExternalModule = memoize(() => require("./ExternalModule"));
+const getCompilation = memoize(() => require("../Compilation"));
 
 /**
  * @typedef {object} ChunkAssetNaming
@@ -88,10 +91,8 @@ const CHUNK_ASSET_NAMING = new Map([
 ]);
 const getTemplatedPathPlugin = memoize(() => require("./TemplatedPathPlugin"));
 const getConcatenatedModule = memoize(() =>
-	require("./optimize/ConcatenatedModule")
+	require("../optimize/ConcatenatedModule")
 );
-const getNormalModule = memoize(() => require("./NormalModule"));
-
 /**
  * Whether a hot update can re-run the module a reference is emitted into: the HMR
  * plugin marks every normal module, and a concatenated one is read through its root.
@@ -100,9 +101,8 @@ const getNormalModule = memoize(() => require("./NormalModule"));
  */
 const isHotModule = (module) => {
 	if (module === undefined) return false;
-	const normal =
-		module instanceof getConcatenatedModule() ? module.rootModule : module;
-	return normal instanceof getNormalModule() && normal.hot;
+	const normal = module.getRootModule();
+	return normal.is("normal") && normal.hot;
 };
 
 // Any `[hash]`/`[fullhash]`/`[chunkhash]`/`[contenthash]` token, incl. a `:<length>`
@@ -220,16 +220,16 @@ const HOT_NAME_BAILOUT =
 /**
  * @import {
  * 	OutputNormalizedWithDefaults as OutputOptions
- * } from "./config/defaults"
+ * } from "../config/defaults"
  */
-/** @import { PublicPath, WasmLoading } from "../declarations/WebpackOptions" */
-/** @import ModuleDependency from "./dependencies/ModuleDependency" */
+/** @import { PublicPath, WasmLoading } from "../../declarations/WebpackOptions.d.ts" */
+/** @import ModuleDependency from "../dependencies/core/ModuleDependency" */
 /**
  * @import Module, {
  * 	ReadOnlyRuntimeRequirements,
  * 	BuildMeta,
  * 	RuntimeRequirements
- * } from "./Module"
+ * } from "../module/Module"
  */
 /** @typedef {"import" | "url" | "url-runtime" | "url-inline" | "wasm" | "wasm-relative"} AnalyzableForm */
 /**
@@ -304,18 +304,19 @@ const CHUNK_ASSET_NAMING_BY_STAND_IN = new Map(
 
 const PASS_NAME = "analyzableChunkNaming";
 
-/** @import AsyncDependenciesBlock from "./AsyncDependenciesBlock" */
+/** @import AsyncDependenciesBlock from "../graph/AsyncDependenciesBlock" */
 /** @import { Source } from "webpack-sources" */
-/** @import Compiler from "./Compiler" */
-/** @import Chunk, { ChunkFilenameTemplate, ChunkId } from "./Chunk" */
-/** @import ChunkGraph, { ModuleId } from "./ChunkGraph" */
-/** @import Compilation from "./Compilation" */
-/** @import Dependency from "./Dependency" */
-/** @import ModuleGraph from "./ModuleGraph" */
-/** @import RequestShortener from "./RequestShortener" */
-/** @import Hash from "./util/Hash" */
-/** @import CodeGenerationResults from "./CodeGenerationResults" */
-/** @import { RuntimeSpec } from "./util/runtime" */
+/** @import Compiler from "../Compiler" */
+/** @import Chunk, { ChunkFilenameTemplate, ChunkId } from "../graph/Chunk" */
+/** @import ChunkGraph, { ModuleId } from "../graph/ChunkGraph" */
+/** @import Compilation from "../Compilation" */
+/** @import Dependency from "../graph/Dependency" */
+/** @import ModuleGraph from "../graph/ModuleGraph" */
+/** @import RequestShortener from "../util/RequestShortener" */
+/** @import Hash from "../util/Hash" */
+/** @import CodeGenerationResults from "../module/CodeGenerationResults" */
+/** @import { RuntimeSpec } from "../util/runtime" */
+/** @import { JsonValue } from "../fs/fs" */
 
 /**
  * A stand-in whose every hash reads back as `hash`. Which content hashes a chunk
@@ -428,7 +429,7 @@ function getGlobalObject(definition) {
 // An async external is a promise, not a module record with an evaluating state.
 const isAsyncExternal = (/** @type {Module} */ module) =>
 	Boolean(/** @type {BuildMeta} */ (module.buildMeta).async) &&
-	module instanceof getExternalModule();
+	module.is("external");
 
 // `createFakeNamespaceObject`'s "merge all properties" bit, the only one that
 // changes which names the namespace it builds carries.
@@ -830,6 +831,16 @@ class RuntimeTemplate {
 		return true;
 	}
 
+	/**
+	 * Reports an analyzable-ESM bailout from outside this class.
+	 * @param {Module | undefined} module the module the reference is emitted into
+	 * @param {string} reason why no literal could be baked
+	 * @returns {void}
+	 */
+	analyzableBailout(module, reason) {
+		this._analyzableBailout(module, reason, null);
+	}
+
 	/**
 	 * Records why a reference kept the runtime form, on the module that wrote it —
 	 * the channel `ModuleConcatenationPlugin` already reports through, so it reaches
@@ -1850,6 +1861,28 @@ class RuntimeTemplate {
 		return `${this.comment({ request })}${JSON.stringify(moduleId)}`;
 	}
 
+	/**
+	 * The side-effect annotation for output another build reads back, which is the
+	 * only output it can pay for — elsewhere it is bytes with no consumer.
+	 * @returns {string} the annotation, or an empty string
+	 */
+	sideEffectsAnnotation() {
+		return this.outputOptions.module ? "/*#__PURE__*/" : "";
+	}
+
+	/**
+	 * A module instantiation's side-effect annotation. Write it only where the
+	 * statement ends the call: a minifier reads `f(id)(x)` as one and drops it.
+	 * @param {Module} module the instantiated module
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {string} the annotation, or an empty string when it may have side effects
+	 */
+	moduleSideEffectsAnnotation(module, moduleGraph) {
+		return module.getSideEffectsConnectionState(moduleGraph) === false
+			? this.sideEffectsAnnotation()
+			: "";
+	}
+
 	/**
 	 * Returns the expression.
 	 * @param {object} options options object
@@ -2077,8 +2110,8 @@ class RuntimeTemplate {
 		const exportsType = module.getExportsType(chunkGraph.moduleGraph, strict);
 
 		const isModuleDeferred =
-			(dependency instanceof HarmonyImportDependency ||
-				dependency instanceof ImportDependency) &&
+			(isDependencyKind(dependency, "esm-import") ||
+				isDependencyKind(dependency, "dynamic-import")) &&
 			ImportPhaseUtils.isDefer(dependency.phase) &&
 			!(/** @type {BuildMeta} */ (module.buildMeta).async);
 
@@ -2366,8 +2399,9 @@ class RuntimeTemplate {
 		let importContent;
 
 		const isModuleDeferred =
-			(dependency instanceof HarmonyImportDependency ||
-				dependency instanceof ImportDependency) &&
+			dependency !== undefined &&
+			(isDependencyKind(dependency, "esm-import") ||
+				isDependencyKind(dependency, "dynamic-import")) &&
 			ImportPhaseUtils.isDefer(dependency.phase) &&
 			!isAsyncExternal(module);
 
@@ -2378,7 +2412,7 @@ class RuntimeTemplate {
 			// would deadlock; forcing the namespace throws instead.
 			outgoingAsyncModules.delete(originModule);
 
-			importContent = `/* deferred harmony import */ ${optDeclaration}${importVar} = ${getOptimizedDeferredModule(
+			importContent = `/* deferred harmony import */ ${optDeclaration}${importVar} = ${this.sideEffectsAnnotation()}${getOptimizedDeferredModule(
 				moduleId,
 				exportsType,
 				Array.from(outgoingAsyncModules, (mod) => chunkGraph.getModuleId(mod)),
@@ -2391,7 +2425,10 @@ class RuntimeTemplate {
 
 			return [importContent, ""];
 		}
-		importContent = `/* harmony import */ ${optDeclaration}${importVar} = ${RuntimeGlobals.require}(${moduleId});\n`;
+		importContent = `/* harmony import */ ${optDeclaration}${importVar} = ${this.moduleSideEffectsAnnotation(
+			module,
+			moduleGraph
+		)}${RuntimeGlobals.require}(${moduleId});\n`;
 
 		if (exportsType === "dynamic") {
 			runtimeRequirements.add(RuntimeGlobals.compatGetDefaultExport);
@@ -2458,8 +2495,8 @@ class RuntimeTemplate {
 		);
 
 		const isModuleDeferred =
-			(dependency instanceof HarmonyImportDependency ||
-				dependency instanceof ImportDependency) &&
+			(isDependencyKind(dependency, "esm-import") ||
+				isDependencyKind(dependency, "dynamic-import")) &&
 			ImportPhaseUtils.isDefer(dependency.phase) &&
 			!isAsyncExternal(module);
 
@@ -2476,7 +2513,7 @@ class RuntimeTemplate {
 						);
 						return `${comment} undefined`;
 					}
-					if (used instanceof InlinedUsedName) {
+					if (isInlinedUsedName(used)) {
 						throw new Error(
 							"Can't inline the exports of defer imported module"
 						);
@@ -2585,7 +2622,7 @@ class RuntimeTemplate {
 				);
 				return `${comment} undefined`;
 			}
-			if (used instanceof InlinedUsedName) {
+			if (isInlinedUsedName(used)) {
 				return used.render(
 					Template.toNormalComment(
 						`inlined export ${propertyAccess(exportName)}`
@@ -2702,7 +2739,7 @@ class RuntimeTemplate {
 			if (exportInfo.provided === false) continue;
 			const used = exportsInfo.getUsedName([exportInfo.name], runtime);
 			if (!used) continue;
-			if (used instanceof InlinedUsedName) {
+			if (isInlinedUsedName(used)) {
 				// An inlined export isn't reachable by name on the raw exports object,
 				// so the decoupled object must expose the inlined value directly.
 				mangled = true;
@@ -3650,7 +3687,7 @@ class RuntimeTemplate {
 	/**
 	 * A path built by a function, resolved to the value it will have — or `null` when
 	 * it moves with the compilation hash, which code generation does not know.
-	 * @param {import("./TemplatedPathPlugin").TemplatePathFn<EXPECTED_ANY>} fn the function
+	 * @param {import("./TemplatedPathPlugin").TemplatePathFn} fn the function
 	 * @param {string | undefined} value its answer to the first probe, or `undefined`
 	 * when it answered nothing
 	 * @returns {string | null} the settled value, or `null` when it is hash-dependent
@@ -4264,6 +4301,49 @@ class RuntimeTemplate {
 		return this.returningFunction(factory);
 	}
 
+	/**
+	 * @param {object} options options
+	 * @param {Module} options.module the module the body belongs to
+	 * @param {boolean} options.needModule whether the body reads `module`
+	 * @param {boolean} options.needExports whether the body reads `exports`
+	 * @param {boolean} options.needRequire whether the body reads `__webpack_require__`
+	 * @param {boolean} options.needThisAsExports whether the body reads `this` as exports
+	 * @param {boolean=} options.shorthand render as a method shorthand, without the `function` keyword
+	 * @returns {string} the header, ending with the opening brace
+	 */
+	moduleFactoryFnHeader({
+		module,
+		needModule,
+		needExports,
+		needRequire,
+		needThisAsExports,
+		shorthand = false
+	}) {
+		/** @type {string[]} */
+		const args = [];
+		if (needExports || needRequire || needModule) {
+			args.push(
+				needModule
+					? module.moduleArgument
+					: `__unused_webpack_${module.moduleArgument}`
+			);
+		}
+		if (needExports || needRequire) {
+			args.push(
+				needExports
+					? module.exportsArgument
+					: `__unused_webpack_${module.exportsArgument}`
+			);
+		}
+		if (needRequire) args.push(RuntimeGlobals.require);
+		const parameters = args.join(", ");
+		if (shorthand) return `(${parameters}) {`;
+		if (!needThisAsExports && this.supportsArrowFunction()) {
+			return `(${parameters}) => {`;
+		}
+		return `function(${parameters}) {`;
+	}
+
 	/**
 	 * Define es module flag statement.
 	 * @param {object} options options
@@ -4575,7 +4655,7 @@ class RuntimeTemplate {
 	 * @returns {SpecifierPart[] | null} what it resolves to, or `null` if unreadable
 	 */
 	static _readAnalyzableSpecifier(payload) {
-		/** @type {EXPECTED_ANY} */
+		/** @type {JsonValue} */
 		let decoded;
 		try {
 			decoded = JSON.parse(
@@ -4590,17 +4670,19 @@ class RuntimeTemplate {
 		if (!Array.isArray(decoded)) return null;
 		for (const part of decoded) {
 			if (!Array.isArray(part) || part.length !== 2) return null;
-			if (!SPECIFIER_PART_KINDS.has(part[0])) return null;
+			if (!SPECIFIER_PART_KINDS.has(/** @type {string} */ (part[0]))) {
+				return null;
+			}
 			// Only a chunk id may be a number; the rest are read as text.
 			if (
 				typeof part[1] !== "string" &&
-				(!CHUNK_SPECIFIER_PART_KINDS.has(part[0]) ||
+				(!CHUNK_SPECIFIER_PART_KINDS.has(/** @type {string} */ (part[0])) ||
 					typeof part[1] !== "number")
 			) {
 				return null;
 			}
 		}
-		return decoded;
+		return /** @type {SpecifierPart[]} */ (decoded);
 	}
 }
 

package/lib/{Template.js → template/Template.js}

@@ -6,30 +6,32 @@
 "use strict";
 
 const { ConcatSource, PrefixSource } = require("webpack-sources");
-const { WEBPACK_MODULE_TYPE_RUNTIME } = require("./ModuleTypeConstants");
-const RuntimeGlobals = require("./RuntimeGlobals");
+const {
+	WEBPACK_MODULE_TYPE_RUNTIME
+} = require("../module/ModuleTypeConstants");
+const RuntimeGlobals = require("../runtime/RuntimeGlobals");
 
 /** @import { Source } from "webpack-sources" */
 /**
  * @import {
  * 	OutputNormalizedWithDefaults as OutputOptions
- * } from "./config/defaults"
+ * } from "../config/defaults"
  */
-/** @import Chunk from "./Chunk" */
-/** @import ChunkGraph, { ModuleId } from "./ChunkGraph" */
-/** @import CodeGenerationResults from "./CodeGenerationResults" */
-/** @import { AssetInfo, PathData } from "./Compilation" */
+/** @import Chunk from "../graph/Chunk" */
+/** @import ChunkGraph, { ModuleId } from "../graph/ChunkGraph" */
+/** @import CodeGenerationResults from "../module/CodeGenerationResults" */
+/** @import { AssetInfo, PathData } from "../Compilation" */
 /** @import DependencyTemplates from "./DependencyTemplates" */
-/** @import Module from "./Module" */
-/** @import ModuleGraph from "./ModuleGraph" */
+/** @import Module from "../module/Module" */
+/** @import ModuleGraph from "../graph/ModuleGraph" */
 /** @import ModuleTemplate from "./ModuleTemplate" */
-/** @import RuntimeModule from "./RuntimeModule" */
+/** @import RuntimeModule from "../runtime/RuntimeModule" */
 /** @import RuntimeTemplate from "./RuntimeTemplate" */
 /**
  * @import {
  * 	ChunkRenderContext,
  * 	RenderContext
- * } from "./javascript/JavascriptModulesPlugin"
+ * } from "../javascript/JavascriptModulesPlugin"
  */
 
 const START_LOWERCASE_ALPHABET_CODE = "a".charCodeAt(0);

package/lib/{TemplatedPathPlugin.js → template/TemplatedPathPlugin.js}

@@ -7,23 +7,24 @@
 
 const { basename, extname, posix } = require("path");
 const util = require("util");
-const Chunk = require("./Chunk");
-const Module = require("./Module");
+const PathVariableError = require("../errors/PathVariableError");
+const Chunk = require("../graph/Chunk");
+const Module = require("../module/Module");
 const {
 	decode: decodeBase,
 	encode: encodeBase
-} = require("./util/hash/hash-digest");
+} = require("../util/hash/hash-digest");
 const {
 	ABSOLUTE_PATH_REGEXP,
 	WINDOWS_ABS_PATH_REGEXP,
 	WINDOWS_PATH_SEPARATOR_REGEXP,
 	parseResource
-} = require("./util/identifier");
-const memoize = require("./util/memoize");
+} = require("../util/identifier");
+const memoize = require("../util/memoize");
 
-const getMimeTypes = memoize(() => require("./util/mimeTypes"));
+const getMimeTypes = memoize(() => require("../util/mimeTypes"));
 
-/** @import ChunkGraph, { ModuleId } from "./ChunkGraph" */
+/** @import ChunkGraph, { ModuleId } from "../graph/ChunkGraph" */
 /**
  * @import Compilation, {
  * 	AssetInfo,
@@ -31,9 +32,9 @@ const getMimeTypes = memoize(() => require("./util/mimeTypes"));
  * 	PathData,
  * 	PathDataChunk,
  * 	PathDataModule
- * } from "./Compilation"
+ * } from "../Compilation"
  */
-/** @import Compiler from "./Compiler" */
+/** @import Compiler from "../Compiler" */
 
 const REGEXP = /\[\\*([\w:]+)\\*\]/g;
 
@@ -121,7 +122,7 @@ const toContainedPath = (path) => {
  * @returns {string} source file name for the filename template
  */
 const toTemplateSourceFileName = (sourceFilename, compilation) =>
-	// TODO webpack 6: remove the check, always contain
+	// TODO in the next major release: remove the check, always contain
 	compilation.options.experiments.futureDefaults
 		? toContainedPath(sourceFilename)
 		: sourceFilename;
@@ -330,9 +331,7 @@ const replacer = (value, allowEmpty) => {
 		}
 		if (value === null || value === undefined) {
 			if (!allowEmpty) {
-				throw new Error(
-					`Path variable ${match} not implemented in this context: ${input}`
-				);
+				throw new PathVariableError(match, input);
 			}
 
 			return "";
@@ -344,16 +343,15 @@ const replacer = (value, allowEmpty) => {
 	return fn;
 };
 
-/** @type {Map<string, (...args: EXPECTED_ANY[]) => EXPECTED_ANY>} */
+/** @type {Map<string, () => void>} */
 const deprecationCache = new Map();
 const deprecatedFunction = (() => () => {})();
 /**
  * Returns function with deprecation output.
- * @template {(...args: EXPECTED_ANY[]) => EXPECTED_ANY} T
- * @param {T} fn function
+ * @param {Replacer} fn function
  * @param {string} message message
  * @param {string} code code
- * @returns {T} function with deprecation output
+ * @returns {Replacer} function with deprecation output
  */
 const deprecated = (fn, message, code) => {
 	let d = deprecationCache.get(message);
@@ -361,12 +359,10 @@ const deprecated = (fn, message, code) => {
 		d = util.deprecate(deprecatedFunction, message, code);
 		deprecationCache.set(message, d);
 	}
-	return /** @type {T} */ (
-		(...args) => {
-			d();
-			return fn(...args);
-		}
-	);
+	return (...args) => {
+		d();
+		return fn(...args);
+	};
 };
 
 /**

package/lib/typescript/TypeScriptPlugin.js

@@ -11,8 +11,8 @@ const {
 	JAVASCRIPT_MODULE_TYPE_AUTO,
 	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
 	JAVASCRIPT_MODULE_TYPE_ESM
-} = require("../ModuleTypeConstants");
-const NormalModule = require("../NormalModule");
+} = require("../module/ModuleTypeConstants");
+const NormalModule = require("../module/NormalModule");
 const memoize = require("../util/memoize");
 const { removeBOMFromResult } = require("../util/removeBOM");
 
@@ -22,7 +22,7 @@ const getModuleBuildError = memoize(() =>
 
 /** @import { RawSourceMap } from "webpack-sources" */
 /** @import Compiler from "../Compiler" */
-/** @import NormalModuleType, { Result } from "../NormalModule" */
+/** @import NormalModuleType, { Result } from "../module/NormalModule" */
 /** @import JavascriptParser from "../javascript/JavascriptParser" */
 
 const PLUGIN_NAME = "TypeScriptPlugin";

package/lib/util/RequestShortener.js

@@ -0,0 +1,44 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const { contextify } = require("./identifier");
+
+/** @import { AssociatedObjectForCache } from "./identifier" */
+
+/**
+ * Shortens absolute or verbose request strings so diagnostics and stats output
+ * can be rendered relative to a chosen base directory.
+ */
+class RequestShortener {
+	/**
+	 * Binds a context-aware shortening function to the provided directory and
+	 * optional cache owner.
+	 * @param {string} dir the directory
+	 * @param {AssociatedObjectForCache=} associatedObjectForCache an object to which the cache will be attached
+	 */
+	constructor(dir, associatedObjectForCache) {
+		this.contextify = contextify.bindContextCache(
+			dir,
+			associatedObjectForCache
+		);
+	}
+
+	/**
+	 * Returns a request string rewritten relative to the configured directory
+	 * when one is provided.
+	 * @param {string | undefined | null} request the request to shorten
+	 * @returns {string | undefined | null} the shortened request
+	 */
+	shorten(request) {
+		if (!request) {
+			return request;
+		}
+		return this.contextify(request);
+	}
+}
+
+module.exports = RequestShortener;