webpack 5.111.1 → 5.112.1

package/lib/util/concatenate.js

@@ -5,9 +5,9 @@
 
 "use strict";
 
-const Template = require("../Template");
+const Template = require("../template/Template");
 
-/** @import { Identifier, Node } from "estree" */
+/** @import { Identifier } from "estree" */
 /** @import { Optimization } from "../../declarations/WebpackOptions" */
 /**
  * @import {
@@ -16,9 +16,6 @@ const Template = require("../Template");
  * 	Variable
  * } from "../javascript/JavascriptModulesPlugin"
  */
-/** @import { Range } from "../javascript/JavascriptParser" */
-/** @typedef {Node & { start?: number, end?: number }} PositionedNode */
-/** @typedef {Exclude<keyof Node, "range" | "loc" | "leadingComments" | "trailingComments">} ChildKey */
 /** @typedef {Set<string>} UsedNames */
 
 const DEFAULT_EXPORT = "__WEBPACK_DEFAULT_EXPORT__";
@@ -90,146 +87,6 @@ const getAllReferences = (variable) => {
 	return set;
 };
 
-/**
- * Tests whether a node covers the searched range. `start`/`end` are read before
- * `range`, because webpack's parser serves `range` from a lazy getter that
- * allocates an array and transitions the node's shape on first access — reading
- * it while walking would pay that for most nodes of the ast.
- * @param {PositionedNode} node node
- * @param {number} start start of the searched range
- * @param {number} end end of the searched range
- * @returns {boolean} whether the node covers the range
- */
-const coversRange = (node, start, end) => {
-	const nodeStart = node.start;
-	if (typeof nodeStart === "number") {
-		return nodeStart <= start && /** @type {number} */ (node.end) >= end;
-	}
-	const range = node.range;
-	return range !== undefined && range[0] <= start && range[1] >= end;
-};
-
-/**
- * Returns the single sibling covering the searched range.
- * @param {Node[]} items sibling nodes
- * @param {number} start start of the searched range
- * @param {number} end end of the searched range
- * @returns {Node | undefined} covering sibling
- */
-const findCoveringItem = (items, start, end) => {
-	// sibling ranges are ordered and disjoint; binary search the container
-	let low = 0;
-	let high = items.length - 1;
-	while (low <= high) {
-		const middle = (low + high) >> 1;
-		const item = /** @type {PositionedNode} */ (items[middle]);
-		/** @type {number | undefined} */
-		let itemStart;
-		/** @type {number | undefined} */
-		let itemEnd;
-		if (item) {
-			itemStart = item.start;
-			if (typeof itemStart === "number") {
-				itemEnd = item.end;
-			} else {
-				const range = item.range;
-				if (range === undefined) {
-					itemStart = undefined;
-				} else {
-					itemStart = range[0];
-					itemEnd = range[1];
-				}
-			}
-		}
-		if (itemStart === undefined) {
-			// holes or range-less nodes: scan the remaining window linearly
-			for (let i = low; i <= high; i++) {
-				const candidate = items[i];
-				if (candidate && coversRange(candidate, start, end)) return candidate;
-			}
-			return undefined;
-		}
-		if (itemStart > start) {
-			high = middle - 1;
-		} else if (start >= /** @type {number} */ (itemEnd)) {
-			low = middle + 1;
-		} else {
-			return /** @type {number} */ (itemEnd) >= end ? item : undefined;
-		}
-	}
-	return undefined;
-};
-
-/**
- * Collects the ancestors of `node` below `parent`, innermost first.
- * Keeps scanning after a covering child turns out not to contain `node`:
- * a shorthand `{ a }` holds two distinct identifiers with the same range.
- * @param {Node} parent node to search in
- * @param {number} start start of the searched range
- * @param {number} end end of the searched range
- * @param {Node} node node to find
- * @param {Node[]} path collected ancestors
- * @returns {boolean} whether the node was found
- */
-const collectPathInNode = (parent, start, end, node, path) => {
-	for (const key in parent) {
-		// sit in front of the child keys on every node and never hold one, so
-		// skipping them by name is what keeps the per-level scan short
-		if (key === "type" || key === "start" || key === "end") continue;
-		const value = parent[/** @type {ChildKey} */ (key)];
-		if (value === null || typeof value !== "object") continue;
-		/** @type {Node | undefined} */
-		let child;
-		if (Array.isArray(value)) {
-			// `range` is a number pair on parsers that own the property
-			if (key === "range") continue;
-			child = findCoveringItem(value, start, end);
-		} else if (coversRange(value, start, end)) {
-			child = value;
-		}
-		if (
-			child !== undefined &&
-			(child === node || collectPathInNode(child, start, end, node, path))
-		) {
-			path.push(child);
-			return true;
-		}
-	}
-	return false;
-};
-
-/**
- * Returns the ancestors of `node` up to (but excluding) `ast`, innermost first.
- * @param {Node | Node[]} ast ast
- * @param {Node} node node
- * @returns {undefined | Node[]} result
- */
-const getPathInAst = (ast, node) => {
-	if (ast === node) {
-		return [];
-	}
-
-	const nodeRange = /** @type {Range} */ (node.range);
-	const start = nodeRange[0];
-	const end = nodeRange[1];
-	/** @type {Node[]} */
-	const path = [];
-
-	if (Array.isArray(ast)) {
-		const item = findCoveringItem(ast, start, end);
-		if (item === undefined) return undefined;
-		if (item !== node && !collectPathInNode(item, start, end, node, path)) {
-			return undefined;
-		}
-		path.push(item);
-		return path;
-	}
-
-	if (!ast || typeof ast !== "object") return undefined;
-
-	return collectPathInNode(ast, start, end, node, path) ? path : undefined;
-};
-
 /** @type {Map<string, string[]>} */
 const splittedInfoCache = new Map();
 
@@ -302,6 +159,30 @@ function findNewName(oldName, usedNamed1, usedNamed2, extraInfo) {
 	return nameWithNumber;
 }
 
+// A string literal, kept whole, or an identifier that is not a property name;
+const IDENTIFIER_OR_STRING_REGEXP =
+	/"(?:[^"\\]|\\.)*"|(?<![.\w$])[A-Za-z_$][\w$]*/g;
+
+/**
+ * Renames every identifier of a printed expression that the map names, keeping
+ * property names and string contents as they are.
+ * @param {string} expression the expression as printed
+ * @param {Map<string, string>} renames original to new name
+ * @returns {string} the expression over the new names
+ * @example
+ * const renames = new Map([["store", "entry_store"], ["x", "entry_x"]]);
+ * renameIdentifiers("store.x", renames) === "entry_store.x"
+ * renameIdentifiers('store["a-b"]', renames) === 'entry_store["a-b"]'
+ * renameIdentifiers("store/* .x *\/.c", renames) === "entry_store/* .x *\/.c"
+ * renameIdentifiers("(store_default())", renames) === "(store_default())"
+ * renameIdentifiers("/* reads x *\/ x", renames) === "/* reads entry_x *\/ entry_x"
+ */
+const renameIdentifiers = (expression, renames) =>
+	expression.replace(IDENTIFIER_OR_STRING_REGEXP, (token) => {
+		const renamed = renames.get(token);
+		return renamed === undefined ? token : renamed;
+	});
+
 /** @typedef {Set<Scope>} ScopeSet */
 
 /**
@@ -408,7 +289,7 @@ module.exports = {
 	addScopeSymbols,
 	findNewName,
 	getAllReferences,
-	getPathInAst,
 	getUsedNamesInScopeInfo,
-	isCommonJsConcatenationEnabled
+	isCommonJsConcatenationEnabled,
+	renameIdentifiers
 };

package/lib/util/createMappings.js

@@ -135,6 +135,117 @@ const encodeMappings = (lines) => {
 	return encodedLines.join(";");
 };
 
+/** @typedef {[number] | [number, number, number, number] | [number, number, number, number, number]} DecodedSegment generated column, then source index, original line and column, then name index, all 0-based */
+
+/**
+ * Decode a V3 `mappings` string into one array of segments per generated line,
+ * each sorted by generated column.
+ * @param {string} mappings a VLQ encoded `mappings` string
+ * @returns {DecodedSegment[][]} the segments of each generated line
+ */
+const decodeMappings = (mappings) => {
+	const { length } = mappings;
+	/** @type {DecodedSegment[][]} */
+	const lines = [];
+	let position = 0;
+	let sourceIndex = 0;
+	let originalLine = 0;
+	let originalColumn = 0;
+	let nameIndex = 0;
+
+	/**
+	 * @returns {number} the value at `position`, which moves past it
+	 */
+	const read = () => {
+		const { value, end } = decodeVLQ(mappings, position);
+		// An invalid character reads as 0 and is skipped, so decoding ends.
+		position = end === position ? position + 1 : end;
+		// `B`, a negative zero, reads as -2^31 as source-map readers decode it,
+		// which sorts it before every column on its line.
+		return Object.is(value, -0) ? -2147483648 : value;
+	};
+
+	do {
+		let lineEnd = mappings.indexOf(";", position);
+		if (lineEnd === -1) lineEnd = length;
+		/** @type {DecodedSegment[]} */
+		const line = [];
+		let sorted = true;
+		let generatedColumn = 0;
+		while (position < lineEnd) {
+			const previousColumn = generatedColumn;
+			generatedColumn += read();
+			if (generatedColumn < previousColumn) sorted = false;
+			if (position < lineEnd && mappings[position] !== ",") {
+				sourceIndex += read();
+				originalLine += read();
+				originalColumn += read();
+				if (position < lineEnd && mappings[position] !== ",") {
+					nameIndex += read();
+					line.push([
+						generatedColumn,
+						sourceIndex,
+						originalLine,
+						originalColumn,
+						nameIndex
+					]);
+				} else {
+					line.push([
+						generatedColumn,
+						sourceIndex,
+						originalLine,
+						originalColumn
+					]);
+				}
+			} else {
+				line.push([generatedColumn]);
+			}
+			position++;
+		}
+		if (!sorted) line.sort((a, b) => a[0] - b[0]);
+		lines.push(line);
+		position = lineEnd + 1;
+	} while (position <= length);
+	return lines;
+};
+
+/**
+ * Encode the segments `decodeMappings` reads back into a V3 `mappings` string.
+ * @param {DecodedSegment[][]} lines the segments of each generated line
+ * @returns {string} VLQ-encoded V3 mappings string
+ */
+const encodeDecodedMappings = (lines) => {
+	let sourceIndex = 0;
+	let originalLine = 0;
+	let originalColumn = 0;
+	let nameIndex = 0;
+	let result = "";
+	for (let i = 0; i < lines.length; i++) {
+		if (i > 0) result += ";";
+		const line = lines[i];
+		let generatedColumn = 0;
+		for (let j = 0; j < line.length; j++) {
+			const segment = line[j];
+			if (j > 0) result += ",";
+			result += encodeVLQ(segment[0] - generatedColumn);
+			generatedColumn = segment[0];
+			if (segment.length === 1) continue;
+			result += encodeVLQ(segment[1] - sourceIndex);
+			result += encodeVLQ(segment[2] - originalLine);
+			result += encodeVLQ(segment[3] - originalColumn);
+			sourceIndex = segment[1];
+			originalLine = segment[2];
+			originalColumn = segment[3];
+			if (segment.length === 4) continue;
+			result += encodeVLQ(segment[4] - nameIndex);
+			nameIndex = segment[4];
+		}
+	}
+	return result;
+};
+
+module.exports.decodeMappings = decodeMappings;
 module.exports.decodeVLQ = decodeVLQ;
+module.exports.encodeDecodedMappings = encodeDecodedMappings;
 module.exports.encodeMappings = encodeMappings;
 module.exports.encodeVLQ = encodeVLQ;

package/lib/util/dataURL.js

@@ -39,8 +39,9 @@ const decodeDataURI = (uri) => {
 
 /**
  * A `data:` URI split into the parts a caller has to put back together.
- * `payload` is the text after the comma, still in the form it was written.
- * @typedef {{ mediaType: string, base64: boolean, payload: string }} ParsedDataURI
+ * `parameters` is every `;…` after the media type (`;base64` included) and
+ * `payload` the text after the comma, both in the form they were written.
+ * @typedef {{ mediaType: string, parameters: string, base64: boolean, payload: string }} ParsedDataURI
  */
 
 // `URIRegEx`'s `.` stops at a newline, which a raw `<svg>` payload carries, and
@@ -119,22 +120,56 @@ const parseDataURI = (uri) => {
 	if (match === null) return null;
 	return {
 		mediaType: match[1],
+		parameters: match[2],
 		base64: /;base64$/i.test(match[2]),
 		payload: match[3]
 	};
 };
 
+// A charset other than UTF-8 names bytes this cannot read back as text.
+const FOREIGN_CHARSET_REGEXP = /;charset=(?!(?:utf-?8|us-ascii)(?:;|$))/i;
+
+/**
+ * Decode a payload's percent-escapes the way the URL parser does: a `%` and two
+ * hex digits is the byte they name, and any other `%` is itself.
+ * @param {string} payload the payload as written
+ * @returns {Buffer} the bytes it names
+ */
+const percentDecode = (payload) => {
+	const input = Buffer.from(payload, "utf8");
+	const output = Buffer.allocUnsafe(input.length);
+	let length = 0;
+	for (let i = 0; i < input.length; i++) {
+		const byte = input[i];
+		if (byte === 0x25 && i + 2 < input.length) {
+			const digits = String.fromCharCode(input[i + 1], input[i + 2]);
+			if (/^[0-9a-f]{2}$/i.test(digits)) {
+				output[length++] = Number.parseInt(digits, 16);
+				i += 2;
+				continue;
+			}
+		}
+		output[length++] = byte;
+	}
+	return output.subarray(0, length);
+};
+
 /**
- * The payload as text, or `null` when reading it would not round-trip. A
- * percent-escaped payload is declined rather than decoded: how much of it the
- * author escaped is not recorded anywhere in the URI, so re-escaping would
- * rewrite bytes nothing asked to change.
+ * The payload as text, or `null` when reading it would not round-trip. A raw
+ * `#` is read as content, as webpack's own `data:` modules read it, so a
+ * rebuilt URI escapes it rather than cutting the payload short.
  * @param {ParsedDataURI} parsed the split URI
  * @returns {string | null} the payload as text
  */
 const decodeDataURIPayload = (parsed) => {
 	if (!parsed.base64) {
-		return parsed.payload.includes("%") ? null : parsed.payload;
+		const { payload } = parsed;
+		if (!payload.includes("%")) return payload;
+		if (FOREIGN_CHARSET_REGEXP.test(parsed.parameters)) return null;
+		const bytes = percentDecode(payload);
+		const text = bytes.toString("utf8");
+		// Bytes that are no UTF-8 text are not written back as the same bytes.
+		return Buffer.from(text, "utf8").equals(bytes) ? text : null;
 	}
 	// Decoding is lenient rather than throwing, so garbage decodes to something
 	// that does not round-trip, which is the same answer: leave it alone.
@@ -144,6 +179,51 @@ const decodeDataURIPayload = (parsed) => {
 		: null;
 };
 
+/**
+ * A `data:` URI's payload as text, for a caller that will render it, with the
+ * language its media type names. `null` when there is nothing to offer: not a
+ * `data:` URI, a media type naming no language, a payload that would not
+ * round-trip, or a raw `#`, where a browser reads the rest as a fragment.
+ * @param {string} uri the URI, unquoted and unescaped
+ * @returns {{ parsed: ParsedDataURI, type: string, payload: string } | null} what it holds, or null
+ */
+const readEmbeddedDataURI = (uri) => {
+	if (uri.includes("#")) return null;
+	const parsed = parseDataURI(uri);
+	if (parsed === null) return null;
+	const type = languageOfMediaType(parsed.mediaType);
+	if (type === undefined) return null;
+	const payload = decodeDataURIPayload(parsed);
+	if (payload === null || payload === "") return null;
+	return { parsed, type, payload };
+};
+
+/**
+ * Escape a payload for a `data:` URI written without `base64`, touching only
+ * what would change what the URI means. The host's own quoting is the caller's.
+ * @param {string} text the payload as text
+ * @returns {string} the escaped payload
+ */
+const encodeDataURIPayload = (text) => {
+	// WHY: `%` starts an escape and `#` a fragment. The URL parser drops every
+	// tab and newline and strips C0 controls and spaces off the end, so those
+	// are escaped too, or the payload read back is not the one written.
+	let trailing = text.length;
+	while (trailing > 0 && text.charCodeAt(trailing - 1) === 0x20) trailing--;
+	let out = "";
+	let start = 0;
+	for (let i = 0; i < text.length; i++) {
+		const c = text.charCodeAt(i);
+		if (c > 0x20 && c !== 0x7f && c !== 0x25 && c !== 0x23) continue;
+		if (c === 0x20 && i < trailing) continue;
+		out += `${text.slice(start, i)}%${c < 0x10 ? "0" : ""}${c
+			.toString(16)
+			.toUpperCase()}`;
+		start = i + 1;
+	}
+	return start === 0 ? text : out + text.slice(start);
+};
+
 /**
  * Rebuild a `data:` URI around a new payload, in the form it was written in.
  * @param {ParsedDataURI} parsed the split URI
@@ -151,14 +231,12 @@ const decodeDataURIPayload = (parsed) => {
  * @returns {string} the rebuilt URI
  */
 const buildDataURI = (parsed, text) => {
-	const head = `data:${parsed.mediaType}${parsed.base64 ? ";base64" : ""},`;
+	// A `;charset=` names how the payload decodes, so it is kept as written.
+	const head = `data:${parsed.mediaType}${parsed.parameters},`;
 	if (parsed.base64) {
 		return head + Buffer.from(text, "utf8").toString("base64");
 	}
-	// Only the two that would change what the URI means: `%` starts an escape and
-	// `#` starts a fragment. Everything else stays as the renderer wrote it, and
-	// the url token's own quoting is the caller's to apply.
-	return head + text.replace(/%/g, "%25").replace(/#/g, "%23");
+	return head + encodeDataURIPayload(text);
 };
 
 /**
@@ -208,8 +286,7 @@ const collectEmbeddedDiagnostics = (reported) => {
 
 /**
  * What a renderer made of one embedded body: the minified text, and anything it
- * has to report about it. A bare string is the text alone, `undefined` a
- * renderer that declined.
+ * has to report about it. A bare string is the text alone.
  * @typedef {{ code?: string, warnings?: (Error | string)[], errors?: (Error | string)[] }} EmbeddedSourceResult
  */
 
@@ -250,6 +327,8 @@ const askEmbeddedRenderer = async (render, hole, reported) => {
 
 module.exports = {
 	EMBEDDED_LANGUAGES,
+	JSON_TYPE,
+	SVG_TYPE,
 	URIRegEx,
 	askEmbeddedRenderer,
 	buildDataURI,
@@ -257,7 +336,9 @@ module.exports = {
 	decodeDataURI,
 	decodeDataURIPayload,
 	embeddedText,
+	encodeDataURIPayload,
 	languageOfFilename,
 	languageOfMediaType,
-	parseDataURI
+	parseDataURI,
+	readEmbeddedDataURI
 };

package/lib/util/deprecation.js

@@ -96,7 +96,7 @@ module.exports.arrayToSetDeprecation = (set, name) => {
 			`${name} was changed from Array to Set (using Array method '${method}' is deprecated)`,
 			"ARRAY_TO_SET"
 		);
-		/** @type {EXPECTED_ANY} */
+		/** @type {Set<T> & Record<COPY_METHODS_NAMES, (this: Set<T>) => void>} */
 		(set)[method] =
 			// eslint-disable-next-line func-names
 			function () {
@@ -203,7 +203,7 @@ module.exports.arrayToSetDeprecation = (set, name) => {
  * Returns } SetDeprecatedArray.
  * @template T
  * @param {string} name name
- * @returns {{ new <T = EXPECTED_ANY>(values?: ReadonlyArray<T> | null): SetDeprecatedArray<T> }} SetDeprecatedArray
+ * @returns {{ new <T>(values?: ReadonlyArray<T> | null): SetDeprecatedArray<T> }} SetDeprecatedArray
  */
 module.exports.createArrayToSetDeprecationSet = (name) => {
 	let initialized = false;
@@ -318,10 +318,11 @@ module.exports.soonFrozenObjectDeprecation = (obj, name, code, note = "") => {
 			set: util.deprecate(
 				/**
 				 * Handles the callback logic for this hook.
+				 * @template V
 				 * @param {object} target target
 				 * @param {string | symbol} property property
-				 * @param {EXPECTED_ANY} value value
-				 * @param {EXPECTED_ANY} receiver receiver
+				 * @param {V} value value
+				 * @param {T} receiver receiver
 				 * @returns {boolean} result
 				 */
 				(target, property, value, receiver) =>

package/lib/util/extractComments.js

@@ -0,0 +1,118 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author sheo13666q @sheo13666q
+*/
+
+"use strict";
+
+/**
+ * A condition in the minimizer plugin's `extractComments`. A function's arguments
+ * are each minimizer's own, so these minifiers hand it what `MinimizeExtractCommentsCondition` names.
+ * @typedef {boolean | string | RegExp | ((...args: never[]) => boolean)} PluginExtractCommentsCondition
+ */
+/**
+ * The minimizer plugin's `extractComments`, as far as these minifiers read it: a
+ * condition, or an object holding one.
+ * @typedef {PluginExtractCommentsCondition | { condition?: PluginExtractCommentsCondition }} PluginExtractComments
+ */
+/** @typedef {import("../../declarations/WebpackOptions").OptimizationMinimizeExtractComments} MinimizeExtractComments */
+/** @typedef {import("../../declarations/WebpackOptions").OptimizationMinimizeExtractCommentsCondition} MinimizeExtractCommentsCondition */
+/** @typedef {boolean | string | RegExp | ((comment: string) => boolean)} CommentsOption */
+/** @typedef {(comment: string, line: number, column: number) => boolean} CommentPredicate */
+
+/**
+ * How one language writes a comment, and which it keeps where nothing is extracted.
+ * @typedef {object} CommentSyntax
+ * @property {string} open what opens a comment, e.g. `/*`
+ * @property {string} close what closes it
+ * @property {(comment: string) => boolean} some what the `comments: "some"` level keeps
+ * @property {(comment: string) => boolean} unstated what is kept when `comments` is unset
+ */
+
+/**
+ * A `comments` value as the predicate over a comment's text it stands for.
+ * @param {CommentsOption} comments as configured
+ * @param {(comment: string) => boolean} some what `"some"` keeps
+ * @returns {(comment: string) => boolean} whether a comment is kept
+ */
+const keepCondition = (comments, some) => {
+	if (typeof comments === "function") return comments;
+	if (comments === true || comments === "all") return () => true;
+	if (comments === false) return () => false;
+	if (comments === "some") return some;
+	const pattern = comments instanceof RegExp ? comments : new RegExp(comments);
+	return (comment) => pattern.test(comment);
+};
+
+/**
+ * Which comments `extractComments` takes out, read as terser-webpack-plugin
+ * reads it: `true`, `"some"` or an object without a condition is terser's `some`
+ * bar IE's `@cc_on`, which marks conditional compilation rather than a license.
+ * @param {PluginExtractComments | MinimizeExtractComments | undefined} option as configured
+ * @returns {CommentPredicate | undefined} the condition, or undefined when nothing is extracted
+ */
+const extractCondition = (option) => {
+	if (option === undefined || option === false) return undefined;
+	/** @type {PluginExtractComments | MinimizeExtractComments} */
+	let condition = option;
+	if (typeof option === "object" && !(option instanceof RegExp)) {
+		// Extracting with a condition nothing meets still drops what is not kept.
+		condition = option.condition === undefined ? true : option.condition;
+		if (condition === false) return () => false;
+	}
+	if (condition === true || condition === "some") {
+		return (comment) => /@preserve|@lic|^\**!/i.test(comment);
+	}
+	if (typeof condition === "function") {
+		// No node to hand it, nor a second kind of comment: the predicate is asked
+		// about the comment alone, its text and place.
+		const predicate = /** @type {MinimizeExtractCommentsCondition} */ (
+			condition
+		);
+		return (comment, line, col) =>
+			predicate({ value: comment, line, col }) === true;
+	}
+	// an object option was unwrapped to its condition above
+	const keep = keepCondition(
+		/** @type {string | RegExp} */ (condition),
+		() => false
+	);
+	return (comment) => keep(comment);
+};
+
+/**
+ * The `comments` predicate a print takes to extract comments, and the list
+ * they are collected into, deduplicated and written with their delimiters.
+ * @param {PluginExtractComments | MinimizeExtractComments | undefined} option `extractComments` as configured
+ * @param {CommentsOption | undefined} comments the language's `comments` option
+ * @param {CommentSyntax} syntax how the language writes and keeps comments
+ * @returns {{ comments: CommentPredicate, extracted: string[] } | undefined} undefined when nothing is extracted
+ */
+const extractComments = (option, comments, syntax) => {
+	const extract = extractCondition(option);
+	if (extract === undefined) return undefined;
+	// As terser does: where the comments kept are not stated, extracting leaves
+	// only what the language must keep.
+	const keep =
+		comments === undefined
+			? syntax.unstated
+			: keepCondition(comments, syntax.some);
+	/** @type {string[]} */
+	const extracted = [];
+	const seen = new Set();
+	return {
+		comments: (comment, line, column) => {
+			if (!extract(comment, line, column)) return keep(comment);
+			const text = `${syntax.open}${comment}${syntax.close}`;
+			if (!seen.has(text)) {
+				seen.add(text);
+				extracted.push(text);
+			}
+			return false;
+		},
+		extracted
+	};
+};
+
+module.exports.extractComments = extractComments;
+module.exports.keepCondition = keepCondition;

package/lib/util/formatLocation.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-/** @import { DependencyLocation, SourcePosition } from "../Dependency" */
+/** @import { DependencyLocation, SourcePosition } from "../graph/Dependency" */
 
 /**
  * Returns formatted position.