@kimuson/claude-code-viewer 0.4.0-beta.1 → 0.4.0-beta.2

package/dist/standalone/node_modules/.pnpm/webpack@5.102.1/node_modules/webpack/lib/css/CssParser.js

@@ -0,0 +1,1624 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const vm = require("vm");
+const CommentCompilationWarning = require("../CommentCompilationWarning");
+const ModuleDependencyWarning = require("../ModuleDependencyWarning");
+const { CSS_MODULE_TYPE_AUTO } = require("../ModuleTypeConstants");
+const Parser = require("../Parser");
+const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
+const WebpackError = require("../WebpackError");
+const ConstDependency = require("../dependencies/ConstDependency");
+const CssIcssExportDependency = require("../dependencies/CssIcssExportDependency");
+const CssIcssImportDependency = require("../dependencies/CssIcssImportDependency");
+const CssIcssSymbolDependency = require("../dependencies/CssIcssSymbolDependency");
+const CssImportDependency = require("../dependencies/CssImportDependency");
+const CssLocalIdentifierDependency = require("../dependencies/CssLocalIdentifierDependency");
+const CssSelfLocalIdentifierDependency = require("../dependencies/CssSelfLocalIdentifierDependency");
+const CssUrlDependency = require("../dependencies/CssUrlDependency");
+const StaticExportsDependency = require("../dependencies/StaticExportsDependency");
+const binarySearchBounds = require("../util/binarySearchBounds");
+const { parseResource } = require("../util/identifier");
+const {
+	createMagicCommentContext,
+	webpackCommentRegExp
+} = require("../util/magicComment");
+const walkCssTokens = require("./walkCssTokens");
+
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
+/** @typedef {import("../Parser").ParserState} ParserState */
+/** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
+/** @typedef {import("./walkCssTokens").CssTokenCallbacks} CssTokenCallbacks */
+
+/** @typedef {[number, number]} Range */
+/** @typedef {{ line: number, column: number }} Position */
+/** @typedef {{ value: string, range: Range, loc: { start: Position, end: Position } }} Comment */
+
+const CC_COLON = ":".charCodeAt(0);
+const CC_SLASH = "/".charCodeAt(0);
+const CC_LEFT_PARENTHESIS = "(".charCodeAt(0);
+const CC_RIGHT_PARENTHESIS = ")".charCodeAt(0);
+const CC_LOWER_F = "f".charCodeAt(0);
+const CC_UPPER_F = "F".charCodeAt(0);
+
+// https://www.w3.org/TR/css-syntax-3/#newline
+// We don't have `preprocessing` stage, so we need specify all of them
+const STRING_MULTILINE = /\\[\n\r\f]/g;
+// https://www.w3.org/TR/css-syntax-3/#whitespace
+const TRIM_WHITE_SPACES = /(^[ \t\n\r\f]*|[ \t\n\r\f]*$)/g;
+const UNESCAPE = /\\([0-9a-fA-F]{1,6}[ \t\n\r\f]?|[\s\S])/g;
+const IMAGE_SET_FUNCTION = /^(-\w+-)?image-set$/i;
+const OPTIONALLY_VENDOR_PREFIXED_KEYFRAMES_AT_RULE = /^@(-\w+-)?keyframes$/;
+const OPTIONALLY_VENDOR_PREFIXED_ANIMATION_PROPERTY =
+	/^(-\w+-)?animation(-name)?$/i;
+const IS_MODULES = /\.module(s)?\.[^.]+$/i;
+const CSS_COMMENT = /\/\*((?!\*\/).*?)\*\//g;
+
+/**
+ * @param {string} str url string
+ * @param {boolean} isString is url wrapped in quotes
+ * @returns {string} normalized url
+ */
+const normalizeUrl = (str, isString) => {
+	// Remove extra spaces and newlines:
+	// `url("im\
+	// g.png")`
+	if (isString) {
+		str = str.replace(STRING_MULTILINE, "");
+	}
+
+	str = str
+		// Remove unnecessary spaces from `url("   img.png	 ")`
+		.replace(TRIM_WHITE_SPACES, "")
+		// Unescape
+		.replace(UNESCAPE, (match) => {
+			if (match.length > 2) {
+				return String.fromCharCode(Number.parseInt(match.slice(1).trim(), 16));
+			}
+			return match[1];
+		});
+
+	if (/^data:/i.test(str)) {
+		return str;
+	}
+
+	if (str.includes("%")) {
+		// Convert `url('%2E/img.png')` -> `url('./img.png')`
+		try {
+			str = decodeURIComponent(str);
+		} catch (_err) {
+			// Ignore
+		}
+	}
+
+	return str;
+};
+
+// eslint-disable-next-line no-useless-escape
+const regexSingleEscape = /[ -,.\/:-@[\]\^`{-~]/;
+const regexExcessiveSpaces =
+	/(^|\\+)?(\\[A-F0-9]{1,6})\u0020(?![a-fA-F0-9\u0020])/g;
+
+/**
+ * @param {string} str string
+ * @returns {string} escaped identifier
+ */
+const escapeIdentifier = (str) => {
+	let output = "";
+	let counter = 0;
+
+	while (counter < str.length) {
+		const character = str.charAt(counter++);
+
+		let value;
+
+		// eslint-disable-next-line no-control-regex
+		if (/[\t\n\f\r\u000B]/.test(character)) {
+			const codePoint = character.charCodeAt(0);
+
+			value = `\\${codePoint.toString(16).toUpperCase()} `;
+		} else if (character === "\\" || regexSingleEscape.test(character)) {
+			value = `\\${character}`;
+		} else {
+			value = character;
+		}
+
+		output += value;
+	}
+
+	const firstChar = str.charAt(0);
+
+	if (/^-[-\d]/.test(output)) {
+		output = `\\-${output.slice(1)}`;
+	} else if (/\d/.test(firstChar)) {
+		output = `\\3${firstChar} ${output.slice(1)}`;
+	}
+
+	// Remove spaces after `\HEX` escapes that are not followed by a hex digit,
+	// since they’re redundant. Note that this is only possible if the escape
+	// sequence isn’t preceded by an odd number of backslashes.
+	output = output.replace(regexExcessiveSpaces, ($0, $1, $2) => {
+		if ($1 && $1.length % 2) {
+			// It’s not safe to remove the space, so don’t.
+			return $0;
+		}
+
+		// Strip the space.
+		return ($1 || "") + $2;
+	});
+
+	return output;
+};
+
+const CONTAINS_ESCAPE = /\\/;
+
+/**
+ * @param {string} str string
+ * @returns {[string, number] | undefined} hex
+ */
+const gobbleHex = (str) => {
+	const lower = str.toLowerCase();
+	let hex = "";
+	let spaceTerminated = false;
+
+	for (let i = 0; i < 6 && lower[i] !== undefined; i++) {
+		const code = lower.charCodeAt(i);
+		// check to see if we are dealing with a valid hex char [a-f|0-9]
+		const valid = (code >= 97 && code <= 102) || (code >= 48 && code <= 57);
+		// https://drafts.csswg.org/css-syntax/#consume-escaped-code-point
+		spaceTerminated = code === 32;
+		if (!valid) break;
+		hex += lower[i];
+	}
+
+	if (hex.length === 0) return undefined;
+
+	const codePoint = Number.parseInt(hex, 16);
+	const isSurrogate = codePoint >= 0xd800 && codePoint <= 0xdfff;
+
+	// Add special case for
+	// "If this number is zero, or is for a surrogate, or is greater than the maximum allowed code point"
+	// https://drafts.csswg.org/css-syntax/#maximum-allowed-code-point
+	if (isSurrogate || codePoint === 0x0000 || codePoint > 0x10ffff) {
+		return ["\uFFFD", hex.length + (spaceTerminated ? 1 : 0)];
+	}
+
+	return [
+		String.fromCodePoint(codePoint),
+		hex.length + (spaceTerminated ? 1 : 0)
+	];
+};
+
+/**
+ * @param {string} str string
+ * @returns {string} unescaped string
+ */
+const unescapeIdentifier = (str) => {
+	const needToProcess = CONTAINS_ESCAPE.test(str);
+	if (!needToProcess) return str;
+	let ret = "";
+	for (let i = 0; i < str.length; i++) {
+		if (str[i] === "\\") {
+			const gobbled = gobbleHex(str.slice(i + 1, i + 7));
+			if (gobbled !== undefined) {
+				ret += gobbled[0];
+				i += gobbled[1];
+				continue;
+			}
+			// Retain a pair of \\ if double escaped `\\\\`
+			// https://github.com/postcss/postcss-selector-parser/commit/268c9a7656fb53f543dc620aa5b73a30ec3ff20e
+			if (str[i + 1] === "\\") {
+				ret += "\\";
+				i += 1;
+				continue;
+			}
+			// if \\ is at the end of the string retain it
+			// https://github.com/postcss/postcss-selector-parser/commit/01a6b346e3612ce1ab20219acc26abdc259ccefb
+			if (str.length === i + 1) {
+				ret += str[i];
+			}
+			continue;
+		}
+		ret += str[i];
+	}
+
+	return ret;
+};
+
+class LocConverter {
+	/**
+	 * @param {string} input input
+	 */
+	constructor(input) {
+		this._input = input;
+		this.line = 1;
+		this.column = 0;
+		this.pos = 0;
+	}
+
+	/**
+	 * @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 = pos - i;
+			}
+			this.pos = pos;
+		}
+		return this;
+	}
+}
+
+const EMPTY_COMMENT_OPTIONS = {
+	options: null,
+	errors: null
+};
+
+const CSS_MODE_TOP_LEVEL = 0;
+const CSS_MODE_IN_BLOCK = 1;
+
+const eatUntilSemi = walkCssTokens.eatUntil(";");
+const eatUntilLeftCurly = walkCssTokens.eatUntil("{");
+const eatSemi = walkCssTokens.eatUntil(";");
+
+/**
+ * @typedef {object} CssParserOptions
+ * @property {boolean=} importOption need handle `@import`
+ * @property {boolean=} url need handle URLs
+ * @property {("pure" | "global" | "local" | "auto")=} defaultMode default mode
+ * @property {boolean=} namedExports is named exports
+ */
+
+class CssParser extends Parser {
+	/**
+	 * @param {CssParserOptions=} options options
+	 */
+	constructor({
+		defaultMode = "pure",
+		importOption = true,
+		url = true,
+		namedExports = true
+	} = {}) {
+		super();
+		this.defaultMode = defaultMode;
+		this.import = importOption;
+		this.url = url;
+		this.namedExports = namedExports;
+		/** @type {Comment[] | undefined} */
+		this.comments = undefined;
+		this.magicCommentContext = createMagicCommentContext();
+	}
+
+	/**
+	 * @param {ParserState} state parser state
+	 * @param {string} message warning message
+	 * @param {LocConverter} locConverter location converter
+	 * @param {number} start start offset
+	 * @param {number} end end offset
+	 */
+	_emitWarning(state, message, locConverter, start, end) {
+		const { line: sl, column: sc } = locConverter.get(start);
+		const { line: el, column: ec } = locConverter.get(end);
+
+		state.current.addWarning(
+			new ModuleDependencyWarning(state.module, new WebpackError(message), {
+				start: { line: sl, column: sc },
+				end: { line: el, column: ec }
+			})
+		);
+	}
+
+	/**
+	 * @param {string | Buffer | PreparsedAst} source the source to parse
+	 * @param {ParserState} state the parser state
+	 * @returns {ParserState} the parser state
+	 */
+	parse(source, state) {
+		if (Buffer.isBuffer(source)) {
+			source = source.toString("utf8");
+		} else if (typeof source === "object") {
+			throw new Error("webpackAst is unexpected for the CssParser");
+		}
+		if (source[0] === "\uFEFF") {
+			source = source.slice(1);
+		}
+
+		let mode = this.defaultMode;
+
+		const module = state.module;
+
+		if (
+			mode === "auto" &&
+			module.type === CSS_MODULE_TYPE_AUTO &&
+			IS_MODULES.test(
+				parseResource(/** @type {string} */ (module.getResource())).path
+			)
+		) {
+			mode = "local";
+		}
+
+		const isModules = mode === "global" || mode === "local";
+
+		/** @type {BuildMeta} */
+		(module.buildMeta).isCSSModule = isModules;
+
+		const locConverter = new LocConverter(source);
+
+		/** @type {number} */
+		let scope = CSS_MODE_TOP_LEVEL;
+		/** @type {boolean} */
+		let allowImportAtRule = true;
+		/** @type {[string, number, number][]} */
+		const balanced = [];
+		let lastTokenEndForComments = 0;
+
+		/** @type {boolean} */
+		let isNextRulePrelude = isModules;
+		/** @type {number} */
+		let blockNestingLevel = 0;
+		/** @type {"local" | "global" | undefined} */
+		let modeData;
+		/** @type {boolean} */
+		let inAnimationProperty = false;
+		/** @type {[number, number, boolean] | undefined} */
+		let lastIdentifier;
+		/** @type {Set<string>} */
+		const declaredCssVariables = new Set();
+		/** @typedef {{ path?: string, value: string }} IcssDefinition */
+		/** @type {Map<string, IcssDefinition>} */
+		const icssDefinitions = new Map();
+
+		/**
+		 * @param {string} input input
+		 * @param {number} pos position
+		 * @returns {boolean} true, when next is nested syntax
+		 */
+		const isNextNestedSyntax = (input, pos) => {
+			pos = walkCssTokens.eatWhitespaceAndComments(input, pos);
+
+			if (input[pos] === "}") {
+				return false;
+			}
+
+			// According spec only identifier can be used as a property name
+			const isIdentifier = walkCssTokens.isIdentStartCodePoint(
+				input.charCodeAt(pos)
+			);
+
+			return !isIdentifier;
+		};
+		/**
+		 * @returns {boolean} true, when in local scope
+		 */
+		const isLocalMode = () =>
+			modeData === "local" || (mode === "local" && modeData === undefined);
+
+		/**
+		 * @param {string} input input
+		 * @param {number} pos start position
+		 * @param {(input: string, pos: number) => number} eater eater
+		 * @returns {[number,string]} new position and text
+		 */
+		const eatText = (input, pos, eater) => {
+			let text = "";
+			for (;;) {
+				if (input.charCodeAt(pos) === CC_SLASH) {
+					const newPos = walkCssTokens.eatComments(input, pos);
+					if (pos !== newPos) {
+						pos = newPos;
+						if (pos === input.length) break;
+					} else {
+						text += "/";
+						pos++;
+						if (pos === input.length) break;
+					}
+				}
+				const newPos = eater(input, pos);
+				if (pos !== newPos) {
+					text += input.slice(pos, newPos);
+					pos = newPos;
+				} else {
+					break;
+				}
+				if (pos === input.length) break;
+			}
+			return [pos, text.trimEnd()];
+		};
+
+		/**
+		 * @param {0 | 1} type import or export
+		 * @param {string} input input
+		 * @param {number} pos start position
+		 * @returns {number} position after parse
+		 */
+		const parseImportOrExport = (type, input, pos) => {
+			pos = walkCssTokens.eatWhitespaceAndComments(input, pos);
+			/** @type {string | undefined} */
+			let importPath;
+			if (type === 0) {
+				let cc = input.charCodeAt(pos);
+				if (cc !== CC_LEFT_PARENTHESIS) {
+					this._emitWarning(
+						state,
+						`Unexpected '${input[pos]}' at ${pos} during parsing of ':import' (expected '(')`,
+						locConverter,
+						pos,
+						pos
+					);
+					return pos;
+				}
+				pos++;
+				const stringStart = pos;
+				const str = walkCssTokens.eatString(input, pos);
+				if (!str) {
+					this._emitWarning(
+						state,
+						`Unexpected '${input[pos]}' at ${pos} during parsing of ':import' (expected string)`,
+						locConverter,
+						stringStart,
+						pos
+					);
+					return pos;
+				}
+				importPath = input.slice(str[0] + 1, str[1] - 1);
+				pos = str[1];
+				pos = walkCssTokens.eatWhitespaceAndComments(input, pos);
+				cc = input.charCodeAt(pos);
+				if (cc !== CC_RIGHT_PARENTHESIS) {
+					this._emitWarning(
+						state,
+						`Unexpected '${input[pos]}' at ${pos} during parsing of ':import' (expected ')')`,
+						locConverter,
+						pos,
+						pos
+					);
+					return pos;
+				}
+				pos++;
+				pos = walkCssTokens.eatWhitespaceAndComments(input, pos);
+			}
+
+			/**
+			 * @param {string} name name
+			 * @param {string} value value
+			 * @param {number} start start of position
+			 * @param {number} end end of position
+			 */
+			const createDep = (name, value, start, end) => {
+				if (type === 0) {
+					icssDefinitions.set(name, {
+						path: /** @type {string} */ (importPath),
+						value
+					});
+				} else if (type === 1) {
+					const dep = new CssIcssExportDependency(name, value);
+					const { line: sl, column: sc } = locConverter.get(start);
+					const { line: el, column: ec } = locConverter.get(end);
+					dep.setLoc(sl, sc, el, ec);
+					module.addDependency(dep);
+				}
+			};
+
+			let needTerminate = false;
+			let balanced = 0;
+			/** @type {undefined | 0 | 1 | 2} */
+			let scope;
+
+			/** @typedef {[number, number]} Name */
+
+			/** @type {Name | undefined} */
+			let name;
+			/** @type {number | undefined} */
+			let value;
+
+			/** @type {CssTokenCallbacks} */
+			const callbacks = {
+				leftCurlyBracket: (_input, _start, end) => {
+					balanced++;
+
+					if (scope === undefined) {
+						scope = 0;
+					}
+
+					return end;
+				},
+				rightCurlyBracket: (_input, _start, end) => {
+					balanced--;
+
+					if (scope === 2) {
+						const [nameStart, nameEnd] = /** @type {Name} */ (name);
+						createDep(
+							input.slice(nameStart, nameEnd),
+							input.slice(value, end - 1).trim(),
+							nameEnd,
+							end - 1
+						);
+						scope = 0;
+					}
+
+					if (balanced === 0 && scope === 0) {
+						needTerminate = true;
+					}
+
+					return end;
+				},
+				identifier: (_input, start, end) => {
+					if (scope === 0) {
+						name = [start, end];
+						scope = 1;
+					}
+
+					return end;
+				},
+				colon: (_input, _start, end) => {
+					if (scope === 1) {
+						scope = 2;
+						value = walkCssTokens.eatWhitespace(input, end);
+						return value;
+					}
+
+					return end;
+				},
+				semicolon: (input, _start, end) => {
+					if (scope === 2) {
+						const [nameStart, nameEnd] = /** @type {Name} */ (name);
+						createDep(
+							input.slice(nameStart, nameEnd),
+							input.slice(value, end - 1),
+							nameEnd,
+							end - 1
+						);
+						scope = 0;
+					}
+
+					return end;
+				},
+				needTerminate: () => needTerminate
+			};
+
+			pos = walkCssTokens(input, pos, callbacks);
+			pos = walkCssTokens.eatWhiteLine(input, pos);
+
+			return pos;
+		};
+		const eatPropertyName = walkCssTokens.eatUntil(":{};");
+		/**
+		 * @param {string} input input
+		 * @param {number} pos name start position
+		 * @param {number} end name end position
+		 * @returns {number} position after handling
+		 */
+		const processLocalDeclaration = (input, pos, end) => {
+			modeData = undefined;
+			pos = walkCssTokens.eatWhitespaceAndComments(input, pos);
+			const propertyNameStart = pos;
+			const [propertyNameEnd, propertyName] = eatText(
+				input,
+				pos,
+				eatPropertyName
+			);
+			if (input.charCodeAt(propertyNameEnd) !== CC_COLON) return end;
+			pos = propertyNameEnd + 1;
+			if (propertyName.startsWith("--") && propertyName.length >= 3) {
+				// CSS Variable
+				const { line: sl, column: sc } = locConverter.get(propertyNameStart);
+				const { line: el, column: ec } = locConverter.get(propertyNameEnd);
+				const name = unescapeIdentifier(propertyName.slice(2));
+				const dep = new CssLocalIdentifierDependency(
+					name,
+					[propertyNameStart, propertyNameEnd],
+					"--"
+				);
+				dep.setLoc(sl, sc, el, ec);
+				module.addDependency(dep);
+				declaredCssVariables.add(name);
+			} else if (
+				OPTIONALLY_VENDOR_PREFIXED_ANIMATION_PROPERTY.test(propertyName)
+			) {
+				inAnimationProperty = true;
+			}
+			return pos;
+		};
+		/**
+		 * @param {string} input input
+		 */
+		const processDeclarationValueDone = (input) => {
+			if (inAnimationProperty && lastIdentifier) {
+				const { line: sl, column: sc } = locConverter.get(lastIdentifier[0]);
+				const { line: el, column: ec } = locConverter.get(lastIdentifier[1]);
+				const name = unescapeIdentifier(
+					lastIdentifier[2]
+						? input.slice(lastIdentifier[0], lastIdentifier[1])
+						: input.slice(lastIdentifier[0] + 1, lastIdentifier[1] - 1)
+				);
+				const dep = new CssSelfLocalIdentifierDependency(name, [
+					lastIdentifier[0],
+					lastIdentifier[1]
+				]);
+				dep.setLoc(sl, sc, el, ec);
+				module.addDependency(dep);
+				lastIdentifier = undefined;
+			}
+		};
+
+		/**
+		 * @param {string} input input
+		 * @param {number} start start
+		 * @param {number} end end
+		 * @returns {number} end
+		 */
+		const comment = (input, start, end) => {
+			if (!this.comments) this.comments = [];
+			const { line: sl, column: sc } = locConverter.get(start);
+			const { line: el, column: ec } = locConverter.get(end);
+
+			/** @type {Comment} */
+			const comment = {
+				value: input.slice(start + 2, end - 2),
+				range: [start, end],
+				loc: {
+					start: { line: sl, column: sc },
+					end: { line: el, column: ec }
+				}
+			};
+			this.comments.push(comment);
+			return end;
+		};
+
+		walkCssTokens(source, 0, {
+			comment,
+			leftCurlyBracket: (input, start, end) => {
+				switch (scope) {
+					case CSS_MODE_TOP_LEVEL: {
+						allowImportAtRule = false;
+						scope = CSS_MODE_IN_BLOCK;
+
+						if (isModules) {
+							blockNestingLevel = 1;
+							isNextRulePrelude = isNextNestedSyntax(input, end);
+						}
+
+						break;
+					}
+					case CSS_MODE_IN_BLOCK: {
+						if (isModules) {
+							blockNestingLevel++;
+							isNextRulePrelude = isNextNestedSyntax(input, end);
+						}
+						break;
+					}
+				}
+				return end;
+			},
+			rightCurlyBracket: (input, start, end) => {
+				switch (scope) {
+					case CSS_MODE_IN_BLOCK: {
+						if (--blockNestingLevel === 0) {
+							scope = CSS_MODE_TOP_LEVEL;
+
+							if (isModules) {
+								isNextRulePrelude = true;
+								modeData = undefined;
+							}
+						} else if (isModules) {
+							if (isLocalMode()) {
+								processDeclarationValueDone(input);
+								inAnimationProperty = false;
+							}
+
+							isNextRulePrelude = isNextNestedSyntax(input, end);
+						}
+						break;
+					}
+				}
+				return end;
+			},
+			url: (input, start, end, contentStart, contentEnd) => {
+				if (!this.url) {
+					return end;
+				}
+
+				const { options, errors: commentErrors } = this.parseCommentOptions([
+					lastTokenEndForComments,
+					end
+				]);
+				if (commentErrors) {
+					for (const e of commentErrors) {
+						const { comment } = e;
+						state.module.addWarning(
+							new CommentCompilationWarning(
+								`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
+								comment.loc
+							)
+						);
+					}
+				}
+				if (options && options.webpackIgnore !== undefined) {
+					if (typeof options.webpackIgnore !== "boolean") {
+						const { line: sl, column: sc } = locConverter.get(
+							lastTokenEndForComments
+						);
+						const { line: el, column: ec } = locConverter.get(end);
+
+						state.module.addWarning(
+							new UnsupportedFeatureWarning(
+								`\`webpackIgnore\` expected a boolean, but received: ${options.webpackIgnore}.`,
+								{
+									start: { line: sl, column: sc },
+									end: { line: el, column: ec }
+								}
+							)
+						);
+					} else if (options.webpackIgnore) {
+						return end;
+					}
+				}
+				const value = normalizeUrl(
+					input.slice(contentStart, contentEnd),
+					false
+				);
+				// Ignore `url()`, `url('')` and `url("")`, they are valid by spec
+				if (value.length === 0) return end;
+				const dep = new CssUrlDependency(value, [start, end], "url");
+				const { line: sl, column: sc } = locConverter.get(start);
+				const { line: el, column: ec } = locConverter.get(end);
+				dep.setLoc(sl, sc, el, ec);
+				module.addDependency(dep);
+				module.addCodeGenerationDependency(dep);
+				return end;
+			},
+			string: (_input, start, end) => {
+				switch (scope) {
+					case CSS_MODE_IN_BLOCK: {
+						if (inAnimationProperty && balanced.length === 0) {
+							lastIdentifier = [start, end, false];
+						}
+					}
+				}
+				return end;
+			},
+			atKeyword: (input, start, end) => {
+				const name = input.slice(start, end).toLowerCase();
+
+				switch (name) {
+					case "@namespace": {
+						this._emitWarning(
+							state,
+							"'@namespace' is not supported in bundled CSS",
+							locConverter,
+							start,
+							end
+						);
+
+						return eatUntilSemi(input, start);
+					}
+					case "@import": {
+						if (!this.import) {
+							return eatSemi(input, end);
+						}
+
+						if (!allowImportAtRule) {
+							this._emitWarning(
+								state,
+								"Any '@import' rules must precede all other rules",
+								locConverter,
+								start,
+								end
+							);
+							return end;
+						}
+
+						const tokens = walkCssTokens.eatImportTokens(input, end, {
+							comment
+						});
+						if (!tokens[3]) return end;
+						const semi = tokens[3][1];
+						if (!tokens[0]) {
+							this._emitWarning(
+								state,
+								`Expected URL in '${input.slice(start, semi)}'`,
+								locConverter,
+								start,
+								semi
+							);
+							return end;
+						}
+
+						const urlToken = tokens[0];
+						const url = normalizeUrl(
+							input.slice(urlToken[2], urlToken[3]),
+							true
+						);
+						const newline = walkCssTokens.eatWhiteLine(input, semi);
+						const { options, errors: commentErrors } = this.parseCommentOptions(
+							[end, urlToken[1]]
+						);
+						if (commentErrors) {
+							for (const e of commentErrors) {
+								const { comment } = e;
+								state.module.addWarning(
+									new CommentCompilationWarning(
+										`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
+										comment.loc
+									)
+								);
+							}
+						}
+						if (options && options.webpackIgnore !== undefined) {
+							if (typeof options.webpackIgnore !== "boolean") {
+								const { line: sl, column: sc } = locConverter.get(start);
+								const { line: el, column: ec } = locConverter.get(newline);
+
+								state.module.addWarning(
+									new UnsupportedFeatureWarning(
+										`\`webpackIgnore\` expected a boolean, but received: ${options.webpackIgnore}.`,
+										{
+											start: { line: sl, column: sc },
+											end: { line: el, column: ec }
+										}
+									)
+								);
+							} else if (options.webpackIgnore) {
+								return newline;
+							}
+						}
+						if (url.length === 0) {
+							const { line: sl, column: sc } = locConverter.get(start);
+							const { line: el, column: ec } = locConverter.get(newline);
+							const dep = new ConstDependency("", [start, newline]);
+							module.addPresentationalDependency(dep);
+							dep.setLoc(sl, sc, el, ec);
+
+							return newline;
+						}
+
+						let layer;
+
+						if (tokens[1]) {
+							layer = input.slice(tokens[1][0] + 6, tokens[1][1] - 1).trim();
+						}
+
+						let supports;
+
+						if (tokens[2]) {
+							supports = input.slice(tokens[2][0] + 9, tokens[2][1] - 1).trim();
+						}
+
+						const last = tokens[2] || tokens[1] || tokens[0];
+						const mediaStart = walkCssTokens.eatWhitespaceAndComments(
+							input,
+							last[1]
+						);
+
+						let media;
+
+						if (mediaStart !== semi - 1) {
+							media = input.slice(mediaStart, semi - 1).trim();
+						}
+
+						const { line: sl, column: sc } = locConverter.get(start);
+						const { line: el, column: ec } = locConverter.get(newline);
+						const dep = new CssImportDependency(
+							url,
+							[start, newline],
+							layer,
+							supports && supports.length > 0 ? supports : undefined,
+							media && media.length > 0 ? media : undefined
+						);
+						dep.setLoc(sl, sc, el, ec);
+						module.addDependency(dep);
+
+						return newline;
+					}
+					default: {
+						if (isModules) {
+							if (name === "@value") {
+								const semi = eatUntilSemi(input, end);
+								const atRuleEnd = semi + 1;
+								const params = input.slice(end, semi);
+								let [alias, from] = params.split(/\s*from\s*/);
+
+								if (from) {
+									const aliases = alias
+										.replace(CSS_COMMENT, " ")
+										.trim()
+										.replace(/^\(|\)$/g, "")
+										.split(/\s*,\s*/);
+
+									from = from.replace(CSS_COMMENT, "").trim();
+
+									const isExplicitImport = from[0] === "'" || from[0] === '"';
+
+									if (isExplicitImport) {
+										from = from.slice(1, -1);
+									}
+
+									for (const alias of aliases) {
+										const [name, aliasName] = alias.split(/\s*as\s*/);
+
+										icssDefinitions.set(aliasName || name, {
+											value: name,
+											path: from
+										});
+									}
+								} else {
+									const ident = walkCssTokens.eatIdentSequence(alias, 0);
+
+									if (!ident) {
+										this._emitWarning(
+											state,
+											`Broken '@value' at-rule: ${input.slice(
+												start,
+												atRuleEnd
+											)}'`,
+											locConverter,
+											start,
+											atRuleEnd
+										);
+
+										const dep = new ConstDependency("", [start, atRuleEnd]);
+										module.addPresentationalDependency(dep);
+										return atRuleEnd;
+									}
+
+									const pos = walkCssTokens.eatWhitespaceAndComments(
+										alias,
+										ident[1]
+									);
+
+									const name = alias.slice(ident[0], ident[1]);
+									let value =
+										alias.charCodeAt(pos) === CC_COLON
+											? alias.slice(pos + 1)
+											: alias.slice(ident[1]);
+
+									if (value && !/^\s+$/.test(value)) {
+										value = value.trim();
+									}
+
+									if (icssDefinitions.has(value)) {
+										const def =
+											/** @type {IcssDefinition} */
+											(icssDefinitions.get(value));
+
+										value = def.value;
+									}
+
+									icssDefinitions.set(name, { value });
+
+									const dep = new CssIcssExportDependency(name, value);
+									const { line: sl, column: sc } = locConverter.get(start);
+									const { line: el, column: ec } = locConverter.get(end);
+									dep.setLoc(sl, sc, el, ec);
+									module.addDependency(dep);
+								}
+
+								const dep = new ConstDependency("", [start, atRuleEnd]);
+								module.addPresentationalDependency(dep);
+								return atRuleEnd;
+							} else if (
+								OPTIONALLY_VENDOR_PREFIXED_KEYFRAMES_AT_RULE.test(name) &&
+								isLocalMode()
+							) {
+								const ident = walkCssTokens.eatIdentSequenceOrString(
+									input,
+									end
+								);
+								if (!ident) return end;
+								const name = unescapeIdentifier(
+									ident[2] === true
+										? input.slice(ident[0], ident[1])
+										: input.slice(ident[0] + 1, ident[1] - 1)
+								);
+								const { line: sl, column: sc } = locConverter.get(ident[0]);
+								const { line: el, column: ec } = locConverter.get(ident[1]);
+								const dep = new CssLocalIdentifierDependency(name, [
+									ident[0],
+									ident[1]
+								]);
+								dep.setLoc(sl, sc, el, ec);
+								module.addDependency(dep);
+								return ident[1];
+							} else if (name === "@property" && isLocalMode()) {
+								const ident = walkCssTokens.eatIdentSequence(input, end);
+								if (!ident) return end;
+								let name = input.slice(ident[0], ident[1]);
+								if (!name.startsWith("--") || name.length < 3) return end;
+								name = unescapeIdentifier(name.slice(2));
+								declaredCssVariables.add(name);
+								const { line: sl, column: sc } = locConverter.get(ident[0]);
+								const { line: el, column: ec } = locConverter.get(ident[1]);
+								const dep = new CssLocalIdentifierDependency(
+									name,
+									[ident[0], ident[1]],
+									"--"
+								);
+								dep.setLoc(sl, sc, el, ec);
+								module.addDependency(dep);
+								return ident[1];
+							} else if (name === "@scope") {
+								isNextRulePrelude = true;
+								return end;
+							}
+
+							isNextRulePrelude = false;
+						}
+					}
+				}
+
+				return end;
+			},
+			semicolon: (input, start, end) => {
+				if (isModules && scope === CSS_MODE_IN_BLOCK) {
+					if (isLocalMode()) {
+						processDeclarationValueDone(input);
+						inAnimationProperty = false;
+					}
+
+					isNextRulePrelude = isNextNestedSyntax(input, end);
+				}
+				return end;
+			},
+			identifier: (input, start, end) => {
+				if (isModules) {
+					const name = input.slice(start, end);
+
+					if (icssDefinitions.has(name)) {
+						let { path, value } =
+							/** @type {IcssDefinition} */
+							(icssDefinitions.get(name));
+
+						if (path) {
+							if (icssDefinitions.has(path)) {
+								const definition =
+									/** @type {IcssDefinition} */
+									(icssDefinitions.get(path));
+
+								path = definition.value.slice(1, -1);
+							}
+
+							const dep = new CssIcssImportDependency(path, value, [
+								start,
+								end - 1
+							]);
+							const { line: sl, column: sc } = locConverter.get(start);
+							const { line: el, column: ec } = locConverter.get(end - 1);
+							dep.setLoc(sl, sc, el, ec);
+							module.addDependency(dep);
+						} else {
+							const { line: sl, column: sc } = locConverter.get(start);
+							const { line: el, column: ec } = locConverter.get(end);
+							const dep = new CssIcssSymbolDependency(name, value, [
+								start,
+								end
+							]);
+							dep.setLoc(sl, sc, el, ec);
+							module.addDependency(dep);
+						}
+
+						return end;
+					}
+
+					switch (scope) {
+						case CSS_MODE_IN_BLOCK: {
+							if (isLocalMode()) {
+								// Handle only top level values and not inside functions
+								if (inAnimationProperty && balanced.length === 0) {
+									lastIdentifier = [start, end, true];
+								} else {
+									return processLocalDeclaration(input, start, end);
+								}
+							}
+							break;
+						}
+					}
+				}
+
+				return end;
+			},
+			delim: (input, start, end) => {
+				if (isNextRulePrelude && isLocalMode()) {
+					const ident = walkCssTokens.skipCommentsAndEatIdentSequence(
+						input,
+						end
+					);
+					if (!ident) return end;
+					const name = unescapeIdentifier(input.slice(ident[0], ident[1]));
+					const dep = new CssLocalIdentifierDependency(name, [
+						ident[0],
+						ident[1]
+					]);
+					const { line: sl, column: sc } = locConverter.get(ident[0]);
+					const { line: el, column: ec } = locConverter.get(ident[1]);
+					dep.setLoc(sl, sc, el, ec);
+					module.addDependency(dep);
+					return ident[1];
+				}
+
+				return end;
+			},
+			hash: (input, start, end, isID) => {
+				if (isNextRulePrelude && isLocalMode() && isID) {
+					const valueStart = start + 1;
+					const name = unescapeIdentifier(input.slice(valueStart, end));
+					const dep = new CssLocalIdentifierDependency(name, [valueStart, end]);
+					const { line: sl, column: sc } = locConverter.get(start);
+					const { line: el, column: ec } = locConverter.get(end);
+					dep.setLoc(sl, sc, el, ec);
+					module.addDependency(dep);
+				}
+
+				return end;
+			},
+			colon: (input, start, end) => {
+				if (isModules) {
+					const ident = walkCssTokens.skipCommentsAndEatIdentSequence(
+						input,
+						end
+					);
+					if (!ident) return end;
+					const name = input.slice(ident[0], ident[1]).toLowerCase();
+
+					switch (scope) {
+						case CSS_MODE_TOP_LEVEL: {
+							if (name === "import") {
+								const pos = parseImportOrExport(0, input, ident[1]);
+								const dep = new ConstDependency("", [start, pos]);
+								module.addPresentationalDependency(dep);
+								return pos;
+							} else if (name === "export") {
+								const pos = parseImportOrExport(1, input, ident[1]);
+								const dep = new ConstDependency("", [start, pos]);
+								module.addPresentationalDependency(dep);
+								return pos;
+							}
+						}
+						// falls through
+						default: {
+							if (isNextRulePrelude) {
+								const isFn = input.charCodeAt(ident[1]) === CC_LEFT_PARENTHESIS;
+
+								if (isFn && name === "local") {
+									const end = ident[1] + 1;
+									modeData = "local";
+									const dep = new ConstDependency("", [start, end]);
+									module.addPresentationalDependency(dep);
+									balanced.push([":local", start, end]);
+									return end;
+								} else if (name === "local") {
+									modeData = "local";
+									// Eat extra whitespace
+									end = walkCssTokens.eatWhitespace(input, ident[1]);
+
+									if (ident[1] === end) {
+										this._emitWarning(
+											state,
+											`Missing whitespace after ':local' in '${input.slice(
+												start,
+												eatUntilLeftCurly(input, end) + 1
+											)}'`,
+											locConverter,
+											start,
+											end
+										);
+									}
+
+									const dep = new ConstDependency("", [start, end]);
+									module.addPresentationalDependency(dep);
+									return end;
+								} else if (isFn && name === "global") {
+									const end = ident[1] + 1;
+									modeData = "global";
+									const dep = new ConstDependency("", [start, end]);
+									module.addPresentationalDependency(dep);
+									balanced.push([":global", start, end]);
+									return end;
+								} else if (name === "global") {
+									modeData = "global";
+									// Eat extra whitespace
+									end = walkCssTokens.eatWhitespace(input, ident[1]);
+
+									if (ident[1] === end) {
+										this._emitWarning(
+											state,
+											`Missing whitespace after ':global' in '${input.slice(
+												start,
+												eatUntilLeftCurly(input, end) + 1
+											)}'`,
+											locConverter,
+											start,
+											end
+										);
+									}
+
+									const dep = new ConstDependency("", [start, end]);
+									module.addPresentationalDependency(dep);
+									return end;
+								}
+							}
+						}
+					}
+				}
+
+				lastTokenEndForComments = end;
+
+				return end;
+			},
+			function: (input, start, end) => {
+				const name = input
+					.slice(start, end - 1)
+					.replace(/\\/g, "")
+					.toLowerCase();
+
+				balanced.push([name, start, end]);
+
+				switch (name) {
+					case "src":
+					case "url": {
+						if (!this.url) {
+							return end;
+						}
+
+						const string = walkCssTokens.eatString(input, end);
+						if (!string) return end;
+						const { options, errors: commentErrors } = this.parseCommentOptions(
+							[lastTokenEndForComments, end]
+						);
+						if (commentErrors) {
+							for (const e of commentErrors) {
+								const { comment } = e;
+								state.module.addWarning(
+									new CommentCompilationWarning(
+										`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
+										comment.loc
+									)
+								);
+							}
+						}
+						if (options && options.webpackIgnore !== undefined) {
+							if (typeof options.webpackIgnore !== "boolean") {
+								const { line: sl, column: sc } = locConverter.get(string[0]);
+								const { line: el, column: ec } = locConverter.get(string[1]);
+
+								state.module.addWarning(
+									new UnsupportedFeatureWarning(
+										`\`webpackIgnore\` expected a boolean, but received: ${options.webpackIgnore}.`,
+										{
+											start: { line: sl, column: sc },
+											end: { line: el, column: ec }
+										}
+									)
+								);
+							} else if (options.webpackIgnore) {
+								return end;
+							}
+						}
+						const value = normalizeUrl(
+							input.slice(string[0] + 1, string[1] - 1),
+							true
+						);
+						// Ignore `url()`, `url('')` and `url("")`, they are valid by spec
+						if (value.length === 0) return end;
+						const isUrl = name === "url" || name === "src";
+						const dep = new CssUrlDependency(
+							value,
+							[string[0], string[1]],
+							isUrl ? "string" : "url"
+						);
+						const { line: sl, column: sc } = locConverter.get(string[0]);
+						const { line: el, column: ec } = locConverter.get(string[1]);
+						dep.setLoc(sl, sc, el, ec);
+						module.addDependency(dep);
+						module.addCodeGenerationDependency(dep);
+						return string[1];
+					}
+					default: {
+						if (this.url && IMAGE_SET_FUNCTION.test(name)) {
+							lastTokenEndForComments = end;
+							const values = walkCssTokens.eatImageSetStrings(input, end, {
+								comment
+							});
+							if (values.length === 0) return end;
+							for (const [index, string] of values.entries()) {
+								const value = normalizeUrl(
+									input.slice(string[0] + 1, string[1] - 1),
+									true
+								);
+								if (value.length === 0) return end;
+								const { options, errors: commentErrors } =
+									this.parseCommentOptions([
+										index === 0 ? start : values[index - 1][1],
+										string[1]
+									]);
+								if (commentErrors) {
+									for (const e of commentErrors) {
+										const { comment } = e;
+										state.module.addWarning(
+											new CommentCompilationWarning(
+												`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
+												comment.loc
+											)
+										);
+									}
+								}
+								if (options && options.webpackIgnore !== undefined) {
+									if (typeof options.webpackIgnore !== "boolean") {
+										const { line: sl, column: sc } = locConverter.get(
+											string[0]
+										);
+										const { line: el, column: ec } = locConverter.get(
+											string[1]
+										);
+
+										state.module.addWarning(
+											new UnsupportedFeatureWarning(
+												`\`webpackIgnore\` expected a boolean, but received: ${options.webpackIgnore}.`,
+												{
+													start: { line: sl, column: sc },
+													end: { line: el, column: ec }
+												}
+											)
+										);
+									} else if (options.webpackIgnore) {
+										continue;
+									}
+								}
+								const dep = new CssUrlDependency(
+									value,
+									[string[0], string[1]],
+									"url"
+								);
+								const { line: sl, column: sc } = locConverter.get(string[0]);
+								const { line: el, column: ec } = locConverter.get(string[1]);
+								dep.setLoc(sl, sc, el, ec);
+								module.addDependency(dep);
+								module.addCodeGenerationDependency(dep);
+							}
+							// Can contain `url()` inside, so let's return end to allow parse them
+							return end;
+						} else if (isLocalMode()) {
+							// Don't rename animation name when we have `var()` function
+							if (inAnimationProperty && balanced.length === 1) {
+								lastIdentifier = undefined;
+							}
+
+							if (name === "var") {
+								const customIdent = walkCssTokens.eatIdentSequence(input, end);
+								if (!customIdent) return end;
+								let name = input.slice(customIdent[0], customIdent[1]);
+								// A custom property is any property whose name starts with two dashes (U+002D HYPHEN-MINUS), like --foo.
+								// The <custom-property-name> production corresponds to this:
+								// it’s defined as any <dashed-ident> (a valid identifier that starts with two dashes),
+								// except -- itself, which is reserved for future use by CSS.
+								if (!name.startsWith("--") || name.length < 3) return end;
+								name = unescapeIdentifier(
+									input.slice(customIdent[0] + 2, customIdent[1])
+								);
+								const afterCustomIdent = walkCssTokens.eatWhitespaceAndComments(
+									input,
+									customIdent[1]
+								);
+								if (
+									input.charCodeAt(afterCustomIdent) === CC_LOWER_F ||
+									input.charCodeAt(afterCustomIdent) === CC_UPPER_F
+								) {
+									const fromWord = walkCssTokens.eatIdentSequence(
+										input,
+										afterCustomIdent
+									);
+									if (
+										!fromWord ||
+										input.slice(fromWord[0], fromWord[1]).toLowerCase() !==
+											"from"
+									) {
+										return end;
+									}
+									const from = walkCssTokens.eatIdentSequenceOrString(
+										input,
+										walkCssTokens.eatWhitespaceAndComments(input, fromWord[1])
+									);
+									if (!from) {
+										return end;
+									}
+									const path = input.slice(from[0], from[1]);
+									if (from[2] === true && path === "global") {
+										const dep = new ConstDependency("", [
+											customIdent[1],
+											from[1]
+										]);
+										module.addPresentationalDependency(dep);
+										return end;
+									} else if (from[2] === false) {
+										const dep = new CssIcssImportDependency(
+											path.slice(1, -1),
+											name,
+											[customIdent[0], from[1] - 1]
+										);
+										const { line: sl, column: sc } = locConverter.get(
+											customIdent[0]
+										);
+										const { line: el, column: ec } = locConverter.get(
+											from[1] - 1
+										);
+										dep.setLoc(sl, sc, el, ec);
+										module.addDependency(dep);
+									}
+								} else {
+									const { line: sl, column: sc } = locConverter.get(
+										customIdent[0]
+									);
+									const { line: el, column: ec } = locConverter.get(
+										customIdent[1]
+									);
+									const dep = new CssSelfLocalIdentifierDependency(
+										name,
+										[customIdent[0], customIdent[1]],
+										"--",
+										declaredCssVariables
+									);
+									dep.setLoc(sl, sc, el, ec);
+									module.addDependency(dep);
+									return end;
+								}
+							}
+						}
+					}
+				}
+
+				return end;
+			},
+			leftParenthesis: (input, start, end) => {
+				balanced.push(["(", start, end]);
+
+				return end;
+			},
+			rightParenthesis: (input, start, end) => {
+				const popped = balanced.pop();
+
+				if (
+					isModules &&
+					popped &&
+					(popped[0] === ":local" || popped[0] === ":global")
+				) {
+					modeData = balanced[balanced.length - 1]
+						? /** @type {"local" | "global"} */
+							(balanced[balanced.length - 1][0])
+						: undefined;
+					const dep = new ConstDependency("", [start, end]);
+					module.addPresentationalDependency(dep);
+				}
+
+				return end;
+			},
+			comma: (input, start, end) => {
+				if (isModules) {
+					// Reset stack for `:global .class :local .class-other` selector after
+					modeData = undefined;
+
+					if (scope === CSS_MODE_IN_BLOCK && isLocalMode()) {
+						processDeclarationValueDone(input);
+					}
+				}
+
+				lastTokenEndForComments = start;
+
+				return end;
+			}
+		});
+
+		/** @type {BuildInfo} */
+		(module.buildInfo).strict = true;
+		/** @type {BuildMeta} */
+		(module.buildMeta).exportsType = this.namedExports
+			? "namespace"
+			: "default";
+
+		if (!this.namedExports) {
+			/** @type {BuildMeta} */
+			(module.buildMeta).defaultObject = "redirect";
+		}
+
+		module.addDependency(new StaticExportsDependency([], true));
+		return state;
+	}
+
+	/**
+	 * @param {Range} range range
+	 * @returns {Comment[]} comments in the range
+	 */
+	getComments(range) {
+		if (!this.comments) return [];
+		const [rangeStart, rangeEnd] = range;
+		/**
+		 * @param {Comment} comment comment
+		 * @param {number} needle needle
+		 * @returns {number} compared
+		 */
+		const compare = (comment, needle) =>
+			/** @type {Range} */ (comment.range)[0] - needle;
+		const comments = /** @type {Comment[]} */ (this.comments);
+		let idx = binarySearchBounds.ge(comments, rangeStart, compare);
+		/** @type {Comment[]} */
+		const commentsInRange = [];
+		while (
+			comments[idx] &&
+			/** @type {Range} */ (comments[idx].range)[1] <= rangeEnd
+		) {
+			commentsInRange.push(comments[idx]);
+			idx++;
+		}
+
+		return commentsInRange;
+	}
+
+	/**
+	 * @param {Range} range range of the comment
+	 * @returns {{ options: Record<string, EXPECTED_ANY> | null, errors: (Error & { comment: Comment })[] | null }} result
+	 */
+	parseCommentOptions(range) {
+		const comments = this.getComments(range);
+		if (comments.length === 0) {
+			return EMPTY_COMMENT_OPTIONS;
+		}
+		/** @type {Record<string, EXPECTED_ANY> } */
+		const options = {};
+		/** @type {(Error & { comment: Comment })[]} */
+		const errors = [];
+		for (const comment of comments) {
+			const { value } = comment;
+			if (value && webpackCommentRegExp.test(value)) {
+				// try compile only if webpack options comment is present
+				try {
+					for (let [key, val] of Object.entries(
+						vm.runInContext(
+							`(function(){return {${value}};})()`,
+							this.magicCommentContext
+						)
+					)) {
+						if (typeof val === "object" && val !== null) {
+							val =
+								val.constructor.name === "RegExp"
+									? new RegExp(val)
+									: JSON.parse(JSON.stringify(val));
+						}
+						options[key] = val;
+					}
+				} catch (err) {
+					const newErr = new Error(String(/** @type {Error} */ (err).message));
+					newErr.stack = String(/** @type {Error} */ (err).stack);
+					Object.assign(newErr, { comment });
+					errors.push(/** @type {(Error & { comment: Comment })} */ (newErr));
+				}
+			}
+		}
+		return { options, errors };
+	}
+}
+
+module.exports = CssParser;
+module.exports.escapeIdentifier = escapeIdentifier;
+module.exports.unescapeIdentifier = unescapeIdentifier;