@weapp-tailwindcss/engine 0.1.0

package/dist/v4-CUw9Iuc5.cjs

@@ -0,0 +1,4199 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+node_path = __toESM(node_path, 1);
+let node_process = require("node:process");
+node_process = __toESM(node_process, 1);
+let node_module = require("node:module");
+let node_url = require("node:url");
+let micromatch = require("micromatch");
+micromatch = __toESM(micromatch, 1);
+let node_fs_promises = require("node:fs/promises");
+let postcss = require("postcss");
+postcss = __toESM(postcss, 1);
+//#region src/v4/node-adapter.ts
+const nodeModulePromiseCache = /* @__PURE__ */ new Map();
+const designSystemPromiseCache = /* @__PURE__ */ new Map();
+function unique(values) {
+	return Array.from(new Set(Array.from(values).filter(Boolean).map((value) => node_path.default.resolve(value))));
+}
+function createRequireBase(base) {
+	return node_path.default.join(base, "package.json");
+}
+function isRelativeSpecifier(id) {
+	return id.startsWith("./") || id.startsWith("../") || id === "." || id === "..";
+}
+function isAbsoluteSpecifier(id) {
+	return node_path.default.isAbsolute(id);
+}
+function isCssSpecifier(id) {
+	return node_path.default.extname(id) === ".css";
+}
+function createCssResolutionCandidates(id) {
+	if (isCssSpecifier(id)) return [id];
+	return [`${id}/index.css`, id];
+}
+function createFallbackCssResolver(baseCandidates) {
+	const bases = unique(baseCandidates);
+	return async (id) => {
+		if (isRelativeSpecifier(id) || isAbsoluteSpecifier(id)) return;
+		for (const base of bases) {
+			const requireFromBase = (0, node_module.createRequire)(createRequireBase(base));
+			for (const candidate of createCssResolutionCandidates(id)) try {
+				return requireFromBase.resolve(candidate);
+			} catch {}
+		}
+	};
+}
+async function importResolvedModule(resolved) {
+	return import((0, node_url.pathToFileURL)(resolved).href);
+}
+async function importTailwindNodeFromBase(base) {
+	try {
+		return await importResolvedModule((0, node_module.createRequire)(createRequireBase(base)).resolve("@tailwindcss/node"));
+	} catch {
+		return;
+	}
+}
+async function importFallbackTailwindNode() {
+	return import("@tailwindcss/node");
+}
+async function loadTailwindV4NodeModule(baseCandidates) {
+	const bases = unique(baseCandidates);
+	const cacheKey = JSON.stringify(bases);
+	const cached = nodeModulePromiseCache.get(cacheKey);
+	if (cached) return cached;
+	const promise = (async () => {
+		for (const base of bases) {
+			const loaded = await importTailwindNodeFromBase(base);
+			if (loaded) return loaded;
+		}
+		return importFallbackTailwindNode();
+	})();
+	nodeModulePromiseCache.set(cacheKey, promise);
+	promise.catch(() => {
+		if (nodeModulePromiseCache.get(cacheKey) === promise) nodeModulePromiseCache.delete(cacheKey);
+	});
+	return promise;
+}
+function createDesignSystemCacheKey(css, bases) {
+	return JSON.stringify({
+		css,
+		bases: unique(bases)
+	});
+}
+function getTailwindV4DesignSystemCacheKey(source) {
+	return createDesignSystemCacheKey(source.css, [source.base, ...source.baseFallbacks]);
+}
+async function createTailwindV4DesignSystem(source) {
+	const bases = unique([source.base, ...source.baseFallbacks]);
+	if (bases.length === 0) throw new Error("No base directories provided for Tailwind CSS v4 design system.");
+	const node = await loadTailwindV4NodeModule([source.projectRoot, ...bases]);
+	let lastError;
+	for (const base of bases) try {
+		return await node.__unstable__loadDesignSystem(source.css, { base });
+	} catch (error) {
+		lastError = error;
+	}
+	if (lastError instanceof Error) throw lastError;
+	throw new Error("Failed to load Tailwind CSS v4 design system.");
+}
+async function loadTailwindV4DesignSystem(source, options) {
+	if (options?.cache === false) return createTailwindV4DesignSystem(source);
+	const cacheKey = getTailwindV4DesignSystemCacheKey(source);
+	const cached = designSystemPromiseCache.get(cacheKey);
+	if (cached) return cached;
+	const promise = createTailwindV4DesignSystem(source);
+	designSystemPromiseCache.set(cacheKey, promise);
+	promise.catch(() => {
+		if (designSystemPromiseCache.get(cacheKey) === promise) designSystemPromiseCache.delete(cacheKey);
+	});
+	return promise;
+}
+async function compileTailwindV4Source(source) {
+	const bases = unique([source.base, ...source.baseFallbacks]);
+	if (bases.length === 0) throw new Error("No base directories provided for Tailwind CSS v4 compiler.");
+	const node = await loadTailwindV4NodeModule([source.projectRoot, ...bases]);
+	let lastError;
+	for (const base of bases) {
+		const dependencies = new Set(source.dependencies);
+		try {
+			return {
+				compiled: await node.compile(source.css, {
+					base,
+					customCssResolver: createFallbackCssResolver([source.projectRoot, ...bases]),
+					onDependency(dependency) {
+						dependencies.add(node_path.default.resolve(dependency));
+					}
+				}),
+				dependencies
+			};
+		} catch (error) {
+			lastError = error;
+		}
+	}
+	if (lastError instanceof Error) throw lastError;
+	throw new Error("Failed to compile Tailwind CSS v4 source.");
+}
+//#endregion
+//#region src/v4/source-scan/sources.ts
+const TAILWIND_V4_IGNORED_CONTENT_DIRS = [
+	".git",
+	".hg",
+	".jj",
+	".next",
+	".parcel-cache",
+	".pnpm-store",
+	".svelte-kit",
+	".svn",
+	".turbo",
+	".venv",
+	".vercel",
+	".yarn",
+	"__pycache__",
+	"node_modules",
+	"venv"
+];
+const TAILWIND_V4_IGNORED_EXTENSIONS = [
+	"less",
+	"lock",
+	"sass",
+	"scss",
+	"styl",
+	"log"
+];
+const TAILWIND_V4_IGNORED_FILES = [
+	"package-lock.json",
+	"pnpm-lock.yaml",
+	"bun.lockb",
+	".gitignore",
+	".env",
+	".env.*"
+];
+const TAILWIND_V4_AUTO_SOURCE_SCAN_PATTERN = "**/*";
+function uniqueResolvedPaths(values) {
+	const result = [];
+	for (const value of values) {
+		if (!value) continue;
+		const resolved = node_path.default.resolve(value);
+		if (!result.includes(resolved)) result.push(resolved);
+	}
+	return result;
+}
+function toPosixPath(value) {
+	return value.replaceAll(node_path.default.sep, "/");
+}
+function resolveSourceScanPath(value) {
+	const resolved = node_path.default.resolve(value);
+	try {
+		return node_fs.realpathSync.native(resolved);
+	} catch {
+		return resolved;
+	}
+}
+function normalizeGlobPattern(pattern) {
+	return pattern.startsWith("./") ? pattern.slice(2) : pattern;
+}
+function hasGlobMagic(value) {
+	return /[*?[\]{}()!+@]/.test(value);
+}
+function splitStaticGlobPrefix(pattern) {
+	const segments = normalizeGlobPattern(pattern).split(/[\\/]+/);
+	const prefix = [];
+	const rest = [];
+	let reachedGlob = false;
+	for (const segment of segments) {
+		if (!reachedGlob && segment && !hasGlobMagic(segment)) {
+			prefix.push(segment);
+			continue;
+		}
+		reachedGlob = true;
+		rest.push(segment);
+	}
+	return {
+		prefix,
+		rest
+	};
+}
+async function pathExistsAsDirectory(file) {
+	try {
+		return (await (0, node_fs_promises.stat)(file)).isDirectory();
+	} catch {
+		return false;
+	}
+}
+function createTailwindV4DefaultIgnoreSources(base) {
+	return [
+		...TAILWIND_V4_IGNORED_CONTENT_DIRS.map((pattern) => ({
+			base,
+			pattern: `**/${pattern}/**`,
+			negated: true
+		})),
+		...TAILWIND_V4_IGNORED_EXTENSIONS.map((extension) => ({
+			base,
+			pattern: `**/*.${extension}`,
+			negated: true
+		})),
+		...TAILWIND_V4_IGNORED_FILES.map((pattern) => ({
+			base,
+			pattern: `**/${pattern}`,
+			negated: true
+		}))
+	];
+}
+function createTailwindV4RootSources(root, fallbackBase) {
+	if (root === "none") return [];
+	if (root === null) return [{
+		base: fallbackBase,
+		pattern: TAILWIND_V4_AUTO_SOURCE_SCAN_PATTERN,
+		negated: false
+	}];
+	return [{
+		...root,
+		negated: false
+	}];
+}
+function createTailwindV4CompiledSourceEntries(root, sources, fallbackBase) {
+	return [...createTailwindV4RootSources(root, fallbackBase), ...sources];
+}
+async function resolveTailwindV4SourceEntry(sourcePath, base, negated, defaultPattern = TAILWIND_V4_AUTO_SOURCE_SCAN_PATTERN) {
+	const absoluteSource = node_path.default.isAbsolute(sourcePath) ? node_path.default.resolve(sourcePath) : node_path.default.resolve(base, sourcePath);
+	if (await pathExistsAsDirectory(absoluteSource)) return {
+		base: absoluteSource,
+		negated,
+		pattern: normalizeGlobPattern(defaultPattern)
+	};
+	if (node_path.default.isAbsolute(sourcePath)) return {
+		base: node_path.default.dirname(absoluteSource),
+		negated,
+		pattern: normalizeGlobPattern(node_path.default.basename(absoluteSource))
+	};
+	const { prefix, rest } = splitStaticGlobPrefix(sourcePath);
+	if (prefix.length > 0 && rest.length > 0) return {
+		base: node_path.default.resolve(base, ...prefix),
+		negated,
+		pattern: normalizeGlobPattern(rest.join("/"))
+	};
+	return {
+		base,
+		negated,
+		pattern: normalizeGlobPattern(sourcePath)
+	};
+}
+async function normalizeTailwindV4SourceEntries(sources, options = {}) {
+	const cwd = options.cwd ? node_path.default.resolve(options.cwd) : node_process.default.cwd();
+	return Promise.all(sources.map((source) => resolveTailwindV4SourceEntry(source.pattern, source.base ? node_path.default.resolve(source.base) : cwd, source.negated, options.defaultPattern)));
+}
+function expandBracePattern(pattern) {
+	const index = pattern.indexOf("{");
+	if (index === -1) return [pattern];
+	const rest = pattern.slice(index);
+	let depth = 0;
+	let endIndex = -1;
+	for (let i = 0; i < rest.length; i++) {
+		const char = rest[i];
+		if (char === "\\") {
+			i += 1;
+			continue;
+		}
+		if (char === "{") {
+			depth += 1;
+			continue;
+		}
+		if (char === "}") {
+			depth -= 1;
+			if (depth === 0) {
+				endIndex = i;
+				break;
+			}
+		}
+	}
+	if (endIndex === -1) return [pattern];
+	const prefix = pattern.slice(0, index);
+	const inner = rest.slice(1, endIndex);
+	const suffix = rest.slice(endIndex + 1);
+	const parts = [];
+	const stack = [];
+	let lastPos = 0;
+	for (let i = 0; i < inner.length; i++) {
+		const char = inner[i];
+		if (char === "\\") {
+			i += 1;
+			continue;
+		}
+		if (char === "{") {
+			stack.push("}");
+			continue;
+		}
+		if (char === "}" && stack[stack.length - 1] === "}") {
+			stack.pop();
+			continue;
+		}
+		if (char === "," && stack.length === 0) {
+			parts.push(inner.slice(lastPos, i));
+			lastPos = i + 1;
+		}
+	}
+	parts.push(inner.slice(lastPos));
+	return parts.flatMap((part) => expandBracePattern(`${prefix}${part}${suffix}`));
+}
+function expandTailwindV4SourceEntryBraces(sources) {
+	return sources.flatMap((source) => {
+		const base = node_path.default.resolve(source.base);
+		return expandBracePattern(source.pattern).map((pattern) => ({
+			base,
+			pattern,
+			negated: source.negated
+		}));
+	});
+}
+function normalizeTailwindV4ScannerSources(sources, cwd, ignoredSources = []) {
+	return expandTailwindV4SourceEntryBraces([...sources?.length ? sources : [{
+		base: cwd,
+		pattern: TAILWIND_V4_AUTO_SOURCE_SCAN_PATTERN,
+		negated: false
+	}], ...ignoredSources]);
+}
+function resolveTailwindV4SourceBaseCandidates(projectRoot, base, baseFallbacks) {
+	return uniqueResolvedPaths([
+		base,
+		projectRoot,
+		...baseFallbacks
+	]);
+}
+//#endregion
+//#region src/v4/source-scan/matcher.ts
+function normalizeEntryPattern(entry) {
+	return node_path.default.isAbsolute(entry.pattern) ? toPosixPath(node_path.default.relative(resolveSourceScanPath(entry.base), entry.pattern)) : normalizeGlobPattern(entry.pattern);
+}
+function isFileMatchedByTailwindV4SourceEntry(file, entry) {
+	const relative = toPosixPath(node_path.default.relative(resolveSourceScanPath(entry.base), file));
+	return Boolean(relative) && !relative.startsWith("../") && !node_path.default.isAbsolute(relative) && micromatch.default.isMatch(relative, normalizeEntryPattern(entry));
+}
+function isFileExcludedByTailwindV4SourceEntries(file, entries) {
+	if (!entries?.length) return false;
+	const resolvedFile = resolveSourceScanPath(file);
+	return entries.some((entry) => entry.negated && isFileMatchedByTailwindV4SourceEntry(resolvedFile, entry));
+}
+function isFileMatchedByTailwindV4SourceEntries(file, entries) {
+	if (!entries?.length) return true;
+	const positiveEntries = entries.filter((entry) => !entry.negated);
+	const negativeEntries = entries.filter((entry) => entry.negated);
+	if (positiveEntries.length === 0) return false;
+	const resolvedFile = resolveSourceScanPath(file);
+	if (!positiveEntries.some((entry) => isFileMatchedByTailwindV4SourceEntry(resolvedFile, entry))) return false;
+	return !negativeEntries.some((entry) => isFileMatchedByTailwindV4SourceEntry(resolvedFile, entry));
+}
+function createTailwindV4SourceEntryMatcher(entries) {
+	if (!entries?.length) return;
+	return (file) => isFileMatchedByTailwindV4SourceEntries(file, entries);
+}
+function createTailwindV4SourceExclusionMatcher(entries) {
+	if (!entries?.length) return;
+	return (file) => isFileExcludedByTailwindV4SourceEntries(file, entries);
+}
+function groupTailwindV4SourceEntriesByBase(entries) {
+	const entriesByBase = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const base = node_path.default.resolve(entry.base);
+		const group = entriesByBase.get(base) ?? [];
+		group.push({
+			...entry,
+			base,
+			pattern: normalizeGlobPattern(entry.pattern)
+		});
+		entriesByBase.set(base, group);
+	}
+	return entriesByBase;
+}
+async function expandTailwindV4SourceEntries(entries, resolveFiles) {
+	if (entries.length === 0) return [];
+	const files = /* @__PURE__ */ new Set();
+	await Promise.all([...groupTailwindV4SourceEntriesByBase(entries).entries()].map(async ([base, group]) => {
+		const matched = await resolveFiles({
+			cwd: base,
+			sources: group
+		});
+		for (const file of matched) files.add(node_path.default.resolve(file));
+	}));
+	return [...files].filter((file) => !isFileExcludedByTailwindV4SourceEntries(file, entries));
+}
+function mergeTailwindV4SourceEntries(...entries) {
+	const result = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const group of entries) for (const entry of group ?? []) {
+		const normalized = {
+			base: node_path.default.resolve(entry.base),
+			pattern: normalizeGlobPattern(entry.pattern),
+			negated: entry.negated
+		};
+		const key = JSON.stringify(normalized);
+		if (seen.has(key)) continue;
+		seen.add(key);
+		result.push(normalized);
+	}
+	return result;
+}
+//#endregion
+//#region src/extraction/oxide.ts
+let oxideImportPromise;
+function createOxideRuntimeDependencyError(cause) {
+	return new Error([
+		"@weapp-tailwindcss/engine could not load @tailwindcss/oxide, which is required for source candidate scanning.",
+		"This dependency should be installed automatically by @weapp-tailwindcss/engine.",
+		"Reinstall dependencies without disabling optional dependencies, or install @tailwindcss/oxide@^4.3.3 manually if your package manager omitted it."
+	].join(" "), { cause });
+}
+async function importOxide() {
+	try {
+		return await import("@tailwindcss/oxide");
+	} catch (error) {
+		throw createOxideRuntimeDependencyError(error);
+	}
+}
+function getOxideModule() {
+	oxideImportPromise ??= importOxide();
+	oxideImportPromise.catch(() => {
+		oxideImportPromise = void 0;
+	});
+	return oxideImportPromise;
+}
+//#endregion
+//#region src/extraction/project-report.ts
+function buildLineOffsets(content) {
+	const offsets = [0];
+	for (let i = 0; i < content.length; i++) if (content[i] === "\n") offsets.push(i + 1);
+	if (offsets[offsets.length - 1] !== content.length) offsets.push(content.length);
+	return offsets;
+}
+function resolveLineMeta(content, offsets, index) {
+	let low = 0;
+	let high = offsets.length - 1;
+	while (low <= high) {
+		const mid = Math.floor((low + high) / 2);
+		const start = offsets[mid];
+		if (start === void 0) break;
+		const nextStart = offsets[mid + 1] ?? content.length;
+		if (index < start) {
+			high = mid - 1;
+			continue;
+		}
+		if (index >= nextStart) {
+			low = mid + 1;
+			continue;
+		}
+		const line = mid + 1;
+		const column = index - start + 1;
+		const lineEnd = content.indexOf("\n", start);
+		return {
+			line,
+			column,
+			lineText: content.slice(start, lineEnd === -1 ? content.length : lineEnd)
+		};
+	}
+	const lastStart = offsets[offsets.length - 2] ?? 0;
+	return {
+		line: offsets.length - 1,
+		column: index - lastStart + 1,
+		lineText: content.slice(lastStart)
+	};
+}
+function toExtension(filename) {
+	return node_path.default.extname(filename).replace(/^\./, "") || "txt";
+}
+function toRelativeFile(cwd, filename) {
+	const relative = node_path.default.relative(cwd, filename).replaceAll(node_path.default.sep, "/");
+	return relative === "" ? node_path.default.basename(filename) : relative;
+}
+function createTokenLocation(input) {
+	const info = resolveLineMeta(input.content, input.offsets, input.position);
+	const relativeFile = toRelativeFile(input.cwd, input.file);
+	return {
+		rawCandidate: input.candidate,
+		file: input.file,
+		relativeFile,
+		extension: input.extension,
+		start: input.position,
+		end: input.position + input.candidate.length,
+		length: input.candidate.length,
+		line: info.line,
+		column: info.column,
+		lineText: info.lineText
+	};
+}
+//#endregion
+//#region src/v4/bare-arbitrary-values/escape.ts
+function escapeCssClassName(value) {
+	let result = "";
+	for (let index = 0; index < value.length; index++) {
+		const codeUnit = value.charCodeAt(index);
+		const character = value.charAt(index);
+		if (codeUnit === 0) {
+			result += "�";
+			continue;
+		}
+		if (codeUnit >= 1 && codeUnit <= 31 || codeUnit === 127 || index === 0 && codeUnit >= 48 && codeUnit <= 57 || index === 1 && codeUnit >= 48 && codeUnit <= 57 && value.charCodeAt(0) === 45) {
+			result += `\\${codeUnit.toString(16)} `;
+			continue;
+		}
+		if (codeUnit >= 128 || codeUnit === 45 || codeUnit === 95 || codeUnit >= 48 && codeUnit <= 57 || codeUnit >= 65 && codeUnit <= 90 || codeUnit >= 97 && codeUnit <= 122) {
+			result += character;
+			continue;
+		}
+		result += `\\${character}`;
+	}
+	return result;
+}
+//#endregion
+//#region src/v4/bare-arbitrary-values/syntax.ts
+const HEX_ESCAPE_RE = /^[\da-f]$/i;
+function splitVariantPrefix(candidate) {
+	let depth = 0;
+	let quote;
+	let lastSeparator = -1;
+	for (let index = 0; index < candidate.length; index++) {
+		const character = candidate[index];
+		if (character === "\\") {
+			index++;
+			continue;
+		}
+		if (quote) {
+			if (character === quote) quote = void 0;
+			continue;
+		}
+		if (character === "\"" || character === "'") {
+			quote = character;
+			continue;
+		}
+		if (character === "[" || character === "(" || character === "{") {
+			depth++;
+			continue;
+		}
+		if (character === "]" || character === ")" || character === "}") {
+			depth = Math.max(0, depth - 1);
+			continue;
+		}
+		if (depth === 0 && character === ":") lastSeparator = index;
+	}
+	if (lastSeparator === -1) return {
+		prefix: "",
+		body: candidate
+	};
+	return {
+		prefix: candidate.slice(0, lastSeparator + 1),
+		body: candidate.slice(lastSeparator + 1)
+	};
+}
+function isBalancedFunctionValue(value) {
+	let depth = 0;
+	let quote;
+	for (let index = 0; index < value.length; index++) {
+		const character = value[index];
+		if (character === "\\") {
+			index++;
+			continue;
+		}
+		if (quote) {
+			if (character === quote) quote = void 0;
+			continue;
+		}
+		if (character === "\"" || character === "'") {
+			quote = character;
+			continue;
+		}
+		if (character === "(") {
+			depth++;
+			continue;
+		}
+		if (character === ")") {
+			depth--;
+			if (depth < 0) return false;
+		}
+	}
+	return depth === 0 && quote === void 0;
+}
+function isEscapedAt(value, index) {
+	let slashCount = 0;
+	for (let slashIndex = index - 1; slashIndex >= 0 && value[slashIndex] === "\\"; slashIndex--) slashCount++;
+	return slashCount % 2 === 1;
+}
+function isBalancedBareArbitraryBody(value) {
+	let depth = 0;
+	let quote;
+	for (let index = 0; index < value.length; index++) {
+		const character = value[index];
+		if (isEscapedAt(value, index)) continue;
+		if (quote) {
+			if (character === quote) quote = void 0;
+			continue;
+		}
+		if (character === "\"" || character === "'") {
+			quote = character;
+			continue;
+		}
+		if (character === "(" || character === "{") {
+			depth++;
+			continue;
+		}
+		if (character === ")" || character === "}") {
+			depth--;
+			if (depth < 0) return false;
+		}
+	}
+	return depth === 0 && quote === void 0;
+}
+function isHexColorValue(value) {
+	return /^#(?:[0-9a-f]{3,4}|[0-9a-f]{6,8})$/i.test(value);
+}
+function isQuotedValue(value) {
+	const quote = value[0];
+	if (quote !== "\"" && quote !== "'" || value[value.length - 1] !== quote) return false;
+	let escaped = false;
+	for (let index = 1; index < value.length - 1; index++) {
+		const character = value[index];
+		if (escaped) {
+			escaped = false;
+			continue;
+		}
+		if (character === "\\") escaped = true;
+	}
+	return !escaped;
+}
+function normalizeEscapedValue(value) {
+	let result = "";
+	for (let index = 0; index < value.length; index++) {
+		const character = value[index];
+		if (character !== "\\") {
+			result += character;
+			continue;
+		}
+		const nextCharacter = value[index + 1];
+		if (nextCharacter === void 0) {
+			result += character;
+			continue;
+		}
+		if (HEX_ESCAPE_RE.test(nextCharacter)) {
+			let hex = "";
+			let nextIndex = index + 1;
+			while (nextIndex < value.length && hex.length < 6) {
+				const hexCharacter = value[nextIndex];
+				if (hexCharacter === void 0 || !HEX_ESCAPE_RE.test(hexCharacter)) break;
+				hex += hexCharacter;
+				nextIndex++;
+			}
+			if (/[\t\n\f\r ]/.test(value[nextIndex] ?? "")) nextIndex++;
+			const decoded = String.fromCodePoint(Number.parseInt(hex, 16));
+			result += decoded === "_" ? "\\_" : decoded;
+			index = nextIndex - 1;
+			continue;
+		}
+		result += nextCharacter === "_" ? "\\_" : nextCharacter;
+		index++;
+	}
+	return result;
+}
+//#endregion
+//#region src/v4/bare-arbitrary-values/resolve.ts
+const DEFAULT_BARE_ARBITRARY_VALUE_UNITS = [
+	"%",
+	"px",
+	"rpx",
+	"rem",
+	"em",
+	"vw",
+	"vh",
+	"vmin",
+	"vmax",
+	"dvw",
+	"dvh",
+	"svw",
+	"svh",
+	"lvw",
+	"lvh",
+	"ch",
+	"ex",
+	"lh",
+	"rlh",
+	"fr",
+	"deg",
+	"rad",
+	"turn",
+	"s",
+	"ms"
+];
+const NUMBER_RE = /^-?(?:\d+|\d*\.\d+)$/;
+const FUNCTION_VALUE_RE = /^[a-z_-][\w-]*\(/i;
+const ASPECT_RATIO_RE = /^\d+\/\d+$/;
+function normalizeBareArbitraryValueOptions(options) {
+	if (options === false || options === void 0 || options === null) return;
+	const units = options === true ? DEFAULT_BARE_ARBITRARY_VALUE_UNITS : options.units ?? DEFAULT_BARE_ARBITRARY_VALUE_UNITS;
+	const normalizedUnits = [...new Set(units.filter((unit) => typeof unit === "string" && unit.length > 0))];
+	if (normalizedUnits.length === 0) return;
+	return { units: normalizedUnits.sort((a, b) => b.length - a.length) };
+}
+function isBareArbitraryValuesEnabled(options) {
+	return normalizeBareArbitraryValueOptions(options) !== void 0;
+}
+function resolveValueWithUnit(body, units) {
+	const value = normalizeEscapedValue(body);
+	for (const unit of units) {
+		if (!value.endsWith(unit)) continue;
+		const numberPart = value.slice(0, -unit.length);
+		if (NUMBER_RE.test(numberPart)) return `${numberPart}${unit}`;
+	}
+}
+function resolveArbitraryValue(utility, body, units) {
+	const value = normalizeEscapedValue(body);
+	const withUnit = resolveValueWithUnit(value, units);
+	if (withUnit) return withUnit;
+	if (utility === "aspect" && ASPECT_RATIO_RE.test(value)) return value;
+	if (isHexColorValue(value)) return value;
+	if (isQuotedValue(value)) return value;
+	if (FUNCTION_VALUE_RE.test(value) && value.endsWith(")") && isBalancedFunctionValue(value)) {
+		if (utility === "text" && /^var\(/i.test(value)) return `color:${value}`;
+		return value;
+	}
+}
+function resolveUtilityAndValue(body, units) {
+	let depth = 0;
+	let quote;
+	for (let index = body.length - 1; index > 0; index--) {
+		const character = body[index];
+		if (isEscapedAt(body, index)) continue;
+		if (quote) {
+			if (character === quote) quote = void 0;
+			continue;
+		}
+		if (character === "\"" || character === "'") {
+			quote = character;
+			continue;
+		}
+		if (character === ")" || character === "}") {
+			depth++;
+			continue;
+		}
+		if (character === "(" || character === "{") {
+			depth = Math.max(0, depth - 1);
+			continue;
+		}
+		if (depth > 0 || character !== "-") continue;
+		const utility = body.slice(0, index);
+		const rawValue = body.slice(index + 1);
+		if (!utility || !rawValue) continue;
+		const value = resolveArbitraryValue(utility, rawValue, units);
+		if (value) return {
+			utility,
+			value
+		};
+	}
+}
+function resolveBareArbitraryValueCandidate(candidate, options) {
+	const normalizedOptions = normalizeBareArbitraryValueOptions(options);
+	if (!normalizedOptions || !candidate || candidate.includes("[") || candidate.includes("]")) return;
+	const { prefix, body } = splitVariantPrefix(candidate);
+	const important = body.startsWith("!") ? "!" : "";
+	let normalizedBody = important ? body.slice(1) : body;
+	const negative = normalizedBody.startsWith("-") ? "-" : "";
+	if (negative) normalizedBody = normalizedBody.slice(1);
+	if (!isBalancedBareArbitraryBody(normalizedBody)) return;
+	const resolved = resolveUtilityAndValue(normalizedBody, normalizedOptions.units);
+	if (!resolved) return;
+	return {
+		candidate,
+		canonicalCandidate: `${prefix}${important}${negative}${resolved.utility}-[${resolved.value}]`
+	};
+}
+//#endregion
+//#region src/v4/bare-arbitrary-values/extract.ts
+const ESCAPED_WHITESPACE_RE = /\\[nrt]/g;
+function isBareArbitrarySourceSplitter(char) {
+	return /\s/.test(char);
+}
+function isQuoteBoundary(content, start, index) {
+	const tokenPrefix = content.slice(start, index);
+	return tokenPrefix.length === 0 || !tokenPrefix.endsWith("-");
+}
+function trimBareArbitrarySourceToken(token, start) {
+	let nextToken = token;
+	let nextStart = start;
+	while (nextToken.length > 0 && /^[<{([]$/.test(nextToken[0])) {
+		nextToken = nextToken.slice(1);
+		nextStart++;
+	}
+	while (nextToken.length > 0 && /^[>\],;]$/.test(nextToken[nextToken.length - 1])) nextToken = nextToken.slice(0, -1);
+	return {
+		token: nextToken,
+		start: nextStart
+	};
+}
+function pushBareArbitrarySourceCandidate(result, token, start, options) {
+	const trimmed = trimBareArbitrarySourceToken(token, start);
+	if (!trimmed.token || trimmed.token.includes("=") || trimmed.token.includes("[") || trimmed.token.includes("]")) return;
+	if (!resolveBareArbitraryValueCandidate(trimmed.token, options)) return;
+	result.push({
+		rawCandidate: trimmed.token,
+		start: trimmed.start,
+		end: trimmed.start + trimmed.token.length
+	});
+}
+function extractBareArbitraryValueSourceCandidatesWithPositions(content, options) {
+	if (!isBareArbitraryValuesEnabled(options)) return [];
+	const normalized = content.includes("\\") ? content.replace(ESCAPED_WHITESPACE_RE, " ") : content;
+	const result = [];
+	let depth = 0;
+	let quote;
+	let start = 0;
+	for (let index = 0; index < normalized.length; index++) {
+		const char = normalized[index];
+		if (char === void 0) continue;
+		if (char === "\\") {
+			index++;
+			continue;
+		}
+		if (quote) {
+			if (char === quote) quote = void 0;
+		} else if ((char === "\"" || char === "'" || char === "`") && !isQuoteBoundary(normalized, start, index)) quote = char;
+		else if (char === "(" || char === "{" || char === "[") depth++;
+		else if (char === ")" || char === "}" || char === "]") depth = Math.max(0, depth - 1);
+		if (!isBareArbitrarySourceSplitter(char) && !((char === "\"" || char === "'" || char === "`") && depth === 0 && isQuoteBoundary(normalized, start, index))) continue;
+		pushBareArbitrarySourceCandidate(result, normalized.slice(start, index), start, options);
+		start = index + 1;
+	}
+	pushBareArbitrarySourceCandidate(result, normalized.slice(start), start, options);
+	return result;
+}
+function extractBareArbitraryValueSourceCandidates(content, options) {
+	return [...new Set(extractBareArbitraryValueSourceCandidatesWithPositions(content, options).map((candidate) => candidate.rawCandidate))];
+}
+//#endregion
+//#region src/extraction/segments.ts
+function createBareArbitraryValueCandidateContexts(content, extension, offset, options) {
+	return extractBareArbitraryValueSourceCandidatesWithPositions(content, options?.bareArbitraryValues).map((candidate) => ({
+		content,
+		extension,
+		localStart: candidate.start,
+		rawCandidate: candidate.rawCandidate,
+		start: candidate.start + offset,
+		end: candidate.end + offset
+	}));
+}
+function joinSourceSegments(segments) {
+	const joinedSegments = [];
+	const parts = [];
+	let joinedStart = 0;
+	for (const segment of segments) {
+		if (parts.length > 0) {
+			parts.push("\n");
+			joinedStart++;
+		}
+		parts.push(segment.content);
+		joinedSegments.push({
+			...segment,
+			joinedStart
+		});
+		joinedStart += segment.content.length;
+	}
+	return {
+		content: parts.join(""),
+		segments: joinedSegments
+	};
+}
+function findJoinedSourceSegment(segments, start) {
+	let low = 0;
+	let high = segments.length - 1;
+	while (low <= high) {
+		const mid = Math.floor((low + high) / 2);
+		const segment = segments[mid];
+		if (segment === void 0) break;
+		if (start < segment.joinedStart) {
+			high = mid - 1;
+			continue;
+		}
+		if (start >= segment.joinedStart + segment.content.length) {
+			low = mid + 1;
+			continue;
+		}
+		return segment;
+	}
+}
+async function extractBatchedSourceSegmentCandidates(segments, extension, extractRawCandidatesWithPositions, options) {
+	if (segments.length === 0) return [];
+	const joined = joinSourceSegments(segments);
+	const rawCandidates = await extractRawCandidatesWithPositions(joined.content, extension, options);
+	const candidates = [];
+	for (const candidate of rawCandidates) {
+		const segment = findJoinedSourceSegment(joined.segments, candidate.start);
+		if (segment === void 0 || candidate.end > segment.joinedStart + segment.content.length) continue;
+		const segmentOffset = candidate.start - segment.joinedStart;
+		candidates.push({
+			content: joined.content,
+			extension,
+			localStart: candidate.start,
+			rawCandidate: candidate.rawCandidate,
+			skipHtmlContextChecks: true,
+			start: segment.start + segmentOffset,
+			end: segment.start + segmentOffset + candidate.rawCandidate.length
+		});
+	}
+	return candidates;
+}
+//#endregion
+//#region src/extraction/css.ts
+const CSS_APPLY_RE = /@apply\s+([^;{}]+)/g;
+async function extractCssApplyCandidates(content, extension, extractRawCandidatesWithPositions, options) {
+	const candidates = [];
+	CSS_APPLY_RE.lastIndex = 0;
+	let match = CSS_APPLY_RE.exec(content);
+	while (match !== null) {
+		const applyParams = match[1] ?? "";
+		const applyParamsStart = match.index + match[0].indexOf(applyParams);
+		const applyCandidates = await extractRawCandidatesWithPositions(applyParams, extension);
+		candidates.push(...applyCandidates.map((candidate) => ({
+			content: applyParams,
+			extension: "html",
+			localStart: candidate.start,
+			rawCandidate: candidate.rawCandidate,
+			skipHtmlContextChecks: true,
+			start: candidate.start + applyParamsStart,
+			end: candidate.end + applyParamsStart
+		})));
+		candidates.push(...createBareArbitraryValueCandidateContexts(applyParams, "html", applyParamsStart, options));
+		match = CSS_APPLY_RE.exec(content);
+	}
+	return candidates;
+}
+//#endregion
+//#region src/extraction/js-string-ranges.ts
+function skipQuotedJsContent(content, index, quote) {
+	index++;
+	while (index < content.length) {
+		const char = content[index];
+		if (char === "\\") {
+			index += 2;
+			continue;
+		}
+		if (char === quote) return index + 1;
+		index++;
+	}
+	return index;
+}
+function createJsStringStaticRanges(content) {
+	const ranges = [];
+	let quote;
+	let stringStart = -1;
+	let templateExpressionDepth = 0;
+	for (let index = 0; index < content.length; index++) {
+		const char = content[index];
+		const next = content[index + 1];
+		if (quote && char === "\\") {
+			index++;
+			continue;
+		}
+		if (quote === "`" && templateExpressionDepth > 0) {
+			if (char === "\"" || char === "'") {
+				index = skipQuotedJsContent(content, index, char) - 1;
+				continue;
+			}
+			if (char === "`") {
+				index = skipQuotedJsContent(content, index, "`") - 1;
+				continue;
+			}
+			if (char === "{") {
+				templateExpressionDepth++;
+				continue;
+			}
+			if (char === "}") {
+				templateExpressionDepth--;
+				continue;
+			}
+			continue;
+		}
+		if (quote) {
+			if (quote === "`" && char === "$" && next === "{") {
+				ranges.push({
+					start: stringStart,
+					end: index
+				});
+				templateExpressionDepth = 1;
+				index++;
+				continue;
+			}
+			if (char === quote) {
+				ranges.push({
+					start: stringStart,
+					end: index
+				});
+				quote = void 0;
+				stringStart = -1;
+			}
+			continue;
+		}
+		if (char === "\"" || char === "'" || char === "`") {
+			quote = char;
+			stringStart = index + 1;
+		}
+	}
+	if (quote !== void 0 && templateExpressionDepth === 0) ranges.push({
+		start: stringStart,
+		end: content.length
+	});
+	return ranges;
+}
+function isCandidateInsideJsStringStaticRanges(ranges, start) {
+	let low = 0;
+	let high = ranges.length - 1;
+	while (low <= high) {
+		const mid = Math.floor((low + high) / 2);
+		const range = ranges[mid];
+		if (range === void 0) break;
+		if (start < range.start) {
+			high = mid - 1;
+			continue;
+		}
+		if (start >= range.end) {
+			low = mid + 1;
+			continue;
+		}
+		return true;
+	}
+	return false;
+}
+function createJsStringSourceSegments(content, offset) {
+	return createJsStringStaticRanges(content).filter((range) => range.end > range.start).map((range) => ({
+		content: content.slice(range.start, range.end),
+		start: offset + range.start
+	}));
+}
+//#endregion
+//#region src/extraction/raw-candidate-cache.ts
+const DEFAULT_RAW_CANDIDATE_CACHE_LIMIT = 64;
+function resolveRawCandidateCacheLimit(rawLimit) {
+	if (rawLimit === void 0) return DEFAULT_RAW_CANDIDATE_CACHE_LIMIT;
+	const limit = Number.parseInt(rawLimit, 10);
+	return Number.isFinite(limit) && limit > 0 ? limit : DEFAULT_RAW_CANDIDATE_CACHE_LIMIT;
+}
+const RAW_CANDIDATE_CACHE_LIMIT = resolveRawCandidateCacheLimit(node_process.default.env["TWM_ENGINE_RAW_CANDIDATE_CACHE_LIMIT"]);
+const rawCandidateCache = /* @__PURE__ */ new Map();
+function createRawCandidateCacheKey(sources, options) {
+	return JSON.stringify({
+		sources: sources ?? null,
+		bareArbitraryValues: options?.bareArbitraryValues ?? null
+	});
+}
+async function createRawCandidateFileFingerprint(files) {
+	if (!files?.length) return "";
+	return (await Promise.all(files.map(async (file) => {
+		try {
+			const stats = await node_fs.promises.stat(file);
+			return `${file}:${stats.size}:${stats.mtimeMs}`;
+		} catch {
+			return `${file}:missing`;
+		}
+	}))).sort().join("|");
+}
+function getRawCandidateCacheEntry(cacheKey, fingerprint) {
+	const cached = rawCandidateCache.get(cacheKey);
+	if (cached?.fingerprint !== fingerprint) return;
+	rawCandidateCache.delete(cacheKey);
+	rawCandidateCache.set(cacheKey, cached);
+	return cached;
+}
+function setRawCandidateCacheEntry(cacheKey, fingerprint, candidates) {
+	rawCandidateCache.set(cacheKey, {
+		fingerprint,
+		candidates
+	});
+	while (rawCandidateCache.size > RAW_CANDIDATE_CACHE_LIMIT) {
+		const oldestKey = rawCandidateCache.keys().next().value;
+		if (oldestKey === void 0) break;
+		rawCandidateCache.delete(oldestKey);
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/entities@8.0.0/node_modules/entities/dist/decode-codepoint.js
+const decodeMap = /* @__PURE__ */ new Map([
+	[0, 65533],
+	[128, 8364],
+	[130, 8218],
+	[131, 402],
+	[132, 8222],
+	[133, 8230],
+	[134, 8224],
+	[135, 8225],
+	[136, 710],
+	[137, 8240],
+	[138, 352],
+	[139, 8249],
+	[140, 338],
+	[142, 381],
+	[145, 8216],
+	[146, 8217],
+	[147, 8220],
+	[148, 8221],
+	[149, 8226],
+	[150, 8211],
+	[151, 8212],
+	[152, 732],
+	[153, 8482],
+	[154, 353],
+	[155, 8250],
+	[156, 339],
+	[158, 382],
+	[159, 376]
+]);
+/**
+* Replace the given code point with a replacement character if it is a
+* surrogate or is outside the valid range. Otherwise return the code
+* point unchanged.
+* @param codePoint Unicode code point to convert.
+*/
+function replaceCodePoint(codePoint) {
+	if (codePoint >= 55296 && codePoint <= 57343 || codePoint > 1114111) return 65533;
+	return decodeMap.get(codePoint) ?? codePoint;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/entities@8.0.0/node_modules/entities/dist/internal/decode-shared.js
+/**
+* Shared base64 decode helper for generated decode data.
+* Assumes global atob is available.
+* @param input Input string to encode or decode.
+*/
+function decodeBase64(input) {
+	const binary = atob(input);
+	const evenLength = binary.length & -2;
+	const out = new Uint16Array(evenLength / 2);
+	for (let index = 0, outIndex = 0; index < evenLength; index += 2) {
+		const lo = binary.charCodeAt(index);
+		const hi = binary.charCodeAt(index + 1);
+		out[outIndex++] = lo | hi << 8;
+	}
+	return out;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/entities@8.0.0/node_modules/entities/dist/generated/decode-data-html.js
+/** Packed HTML decode trie data. */
+const htmlDecodeTree = /* #__PURE__ */ decodeBase64("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");
+//#endregion
+//#region ../../node_modules/.pnpm/entities@8.0.0/node_modules/entities/dist/generated/decode-data-xml.js
+/** Packed XML decode trie data. */
+const xmlDecodeTree = /* #__PURE__ */ decodeBase64("AAJhZ2xxBwARABMAFQBtAg0AAAAAAA8AcAAmYG8AcwAnYHQAPmB0ADxg9SFvdCJg");
+//#endregion
+//#region ../../node_modules/.pnpm/entities@8.0.0/node_modules/entities/dist/internal/bin-trie-flags.js
+/**
+* Bit flags & masks for the binary trie encoding used for entity decoding.
+*
+* Bit layout (16 bits total):
+* 15..14 VALUE_LENGTH   (+1 encoding; 0 => no value)
+* 13     FLAG13.        If valueLength>0: semicolon required flag (implicit ';').
+*                       If valueLength==0: compact run flag.
+* 12..7  BRANCH_LENGTH  Branch length (0 => single branch in 6..0 if jumpOffset==char) OR run length (when compact run)
+* 6..0   JUMP_TABLE     Jump offset (jump table) OR single-branch char code OR first run char
+*/
+var BinTrieFlags;
+(function(BinTrieFlags) {
+	BinTrieFlags[BinTrieFlags["VALUE_LENGTH"] = 49152] = "VALUE_LENGTH";
+	BinTrieFlags[BinTrieFlags["FLAG13"] = 8192] = "FLAG13";
+	BinTrieFlags[BinTrieFlags["BRANCH_LENGTH"] = 8064] = "BRANCH_LENGTH";
+	BinTrieFlags[BinTrieFlags["JUMP_TABLE"] = 127] = "JUMP_TABLE";
+})(BinTrieFlags || (BinTrieFlags = {}));
+//#endregion
+//#region ../../node_modules/.pnpm/entities@8.0.0/node_modules/entities/dist/decode.js
+var CharCodes$1;
+(function(CharCodes) {
+	CharCodes[CharCodes["NUM"] = 35] = "NUM";
+	CharCodes[CharCodes["SEMI"] = 59] = "SEMI";
+	CharCodes[CharCodes["EQUALS"] = 61] = "EQUALS";
+	CharCodes[CharCodes["ZERO"] = 48] = "ZERO";
+	CharCodes[CharCodes["NINE"] = 57] = "NINE";
+	CharCodes[CharCodes["LOWER_A"] = 97] = "LOWER_A";
+	CharCodes[CharCodes["LOWER_F"] = 102] = "LOWER_F";
+	CharCodes[CharCodes["LOWER_X"] = 120] = "LOWER_X";
+	CharCodes[CharCodes["LOWER_Z"] = 122] = "LOWER_Z";
+	CharCodes[CharCodes["UPPER_A"] = 65] = "UPPER_A";
+	CharCodes[CharCodes["UPPER_F"] = 70] = "UPPER_F";
+	CharCodes[CharCodes["UPPER_Z"] = 90] = "UPPER_Z";
+})(CharCodes$1 || (CharCodes$1 = {}));
+/** Bit that needs to be set to convert an upper case ASCII character to lower case */
+const TO_LOWER_BIT = 32;
+function isNumber(code) {
+	return code >= CharCodes$1.ZERO && code <= CharCodes$1.NINE;
+}
+function isHexadecimalCharacter(code) {
+	return code >= CharCodes$1.UPPER_A && code <= CharCodes$1.UPPER_F || code >= CharCodes$1.LOWER_A && code <= CharCodes$1.LOWER_F;
+}
+function isAsciiAlphaNumeric(code) {
+	return code >= CharCodes$1.UPPER_A && code <= CharCodes$1.UPPER_Z || code >= CharCodes$1.LOWER_A && code <= CharCodes$1.LOWER_Z || isNumber(code);
+}
+/**
+* Checks if the given character is a valid end character for an entity in an attribute.
+*
+* Attribute values that aren't terminated properly aren't parsed, and shouldn't lead to a parser error.
+* See the example in https://html.spec.whatwg.org/multipage/parsing.html#named-character-reference-state
+* @param code Code point to decode.
+*/
+function isEntityInAttributeInvalidEnd(code) {
+	return code === CharCodes$1.EQUALS || isAsciiAlphaNumeric(code);
+}
+var EntityDecoderState;
+(function(EntityDecoderState) {
+	EntityDecoderState[EntityDecoderState["EntityStart"] = 0] = "EntityStart";
+	EntityDecoderState[EntityDecoderState["NumericStart"] = 1] = "NumericStart";
+	EntityDecoderState[EntityDecoderState["NumericDecimal"] = 2] = "NumericDecimal";
+	EntityDecoderState[EntityDecoderState["NumericHex"] = 3] = "NumericHex";
+	EntityDecoderState[EntityDecoderState["NamedEntity"] = 4] = "NamedEntity";
+})(EntityDecoderState || (EntityDecoderState = {}));
+/**
+* Decoding mode for named entities.
+*/
+var DecodingMode;
+(function(DecodingMode) {
+	/** Entities in text nodes that can end with any character. */
+	DecodingMode[DecodingMode["Legacy"] = 0] = "Legacy";
+	/** Only allow entities terminated with a semicolon. */
+	DecodingMode[DecodingMode["Strict"] = 1] = "Strict";
+	/** Entities in attributes have limitations on ending characters. */
+	DecodingMode[DecodingMode["Attribute"] = 2] = "Attribute";
+})(DecodingMode || (DecodingMode = {}));
+/**
+* Token decoder with support of writing partial entities.
+*/
+var EntityDecoder = class {
+	decodeTree;
+	emitCodePoint;
+	errors;
+	constructor(decodeTree, emitCodePoint, errors) {
+		this.decodeTree = decodeTree;
+		this.emitCodePoint = emitCodePoint;
+		this.errors = errors;
+	}
+	/** The current state of the decoder. */
+	state = EntityDecoderState.EntityStart;
+	/** Characters that were consumed while parsing an entity. */
+	consumed = 1;
+	/**
+	* The result of the entity.
+	*
+	* Either the result index of a numeric entity, or the codepoint of a
+	* numeric entity.
+	*/
+	result = 0;
+	/** The current index in the decode tree. */
+	treeIndex = 0;
+	/** The number of characters that were consumed in excess. */
+	excess = 1;
+	/** The mode in which the decoder is operating. */
+	decodeMode = DecodingMode.Strict;
+	/** The number of characters that have been consumed in the current run. */
+	runConsumed = 0;
+	/**
+	* Resets the instance to make it reusable.
+	* @param decodeMode Entity decoding mode to use.
+	*/
+	startEntity(decodeMode) {
+		this.decodeMode = decodeMode;
+		this.state = EntityDecoderState.EntityStart;
+		this.result = 0;
+		this.treeIndex = 0;
+		this.excess = 1;
+		this.consumed = 1;
+		this.runConsumed = 0;
+	}
+	/**
+	* Write an entity to the decoder. This can be called multiple times with partial entities.
+	* If the entity is incomplete, the decoder will return -1.
+	*
+	* Mirrors the implementation of `getDecoder`, but with the ability to stop decoding if the
+	* entity is incomplete, and resume when the next string is written.
+	* @param input The string containing the entity (or a continuation of the entity).
+	* @param offset The offset at which the entity begins. Should be 0 if this is not the first call.
+	* @returns The number of characters that were consumed, or -1 if the entity is incomplete.
+	*/
+	write(input, offset) {
+		switch (this.state) {
+			case EntityDecoderState.EntityStart:
+				if (input.charCodeAt(offset) === CharCodes$1.NUM) {
+					this.state = EntityDecoderState.NumericStart;
+					this.consumed += 1;
+					return this.stateNumericStart(input, offset + 1);
+				}
+				this.state = EntityDecoderState.NamedEntity;
+				return this.stateNamedEntity(input, offset);
+			case EntityDecoderState.NumericStart: return this.stateNumericStart(input, offset);
+			case EntityDecoderState.NumericDecimal: return this.stateNumericDecimal(input, offset);
+			case EntityDecoderState.NumericHex: return this.stateNumericHex(input, offset);
+			case EntityDecoderState.NamedEntity: return this.stateNamedEntity(input, offset);
+		}
+	}
+	/**
+	* Switches between the numeric decimal and hexadecimal states.
+	*
+	* Equivalent to the `Numeric character reference state` in the HTML spec.
+	* @param input The string containing the entity (or a continuation of the entity).
+	* @param offset The current offset.
+	* @returns The number of characters that were consumed, or -1 if the entity is incomplete.
+	*/
+	stateNumericStart(input, offset) {
+		if (offset >= input.length) return -1;
+		if ((input.charCodeAt(offset) | TO_LOWER_BIT) === CharCodes$1.LOWER_X) {
+			this.state = EntityDecoderState.NumericHex;
+			this.consumed += 1;
+			return this.stateNumericHex(input, offset + 1);
+		}
+		this.state = EntityDecoderState.NumericDecimal;
+		return this.stateNumericDecimal(input, offset);
+	}
+	/**
+	* Parses a hexadecimal numeric entity.
+	*
+	* Equivalent to the `Hexademical character reference state` in the HTML spec.
+	* @param input The string containing the entity (or a continuation of the entity).
+	* @param offset The current offset.
+	* @returns The number of characters that were consumed, or -1 if the entity is incomplete.
+	*/
+	stateNumericHex(input, offset) {
+		while (offset < input.length) {
+			const char = input.charCodeAt(offset);
+			if (isNumber(char) || isHexadecimalCharacter(char)) {
+				const digit = char <= CharCodes$1.NINE ? char - CharCodes$1.ZERO : (char | TO_LOWER_BIT) - CharCodes$1.LOWER_A + 10;
+				this.result = this.result * 16 + digit;
+				this.consumed++;
+				offset++;
+			} else return this.emitNumericEntity(char, 3);
+		}
+		return -1;
+	}
+	/**
+	* Parses a decimal numeric entity.
+	*
+	* Equivalent to the `Decimal character reference state` in the HTML spec.
+	* @param input The string containing the entity (or a continuation of the entity).
+	* @param offset The current offset.
+	* @returns The number of characters that were consumed, or -1 if the entity is incomplete.
+	*/
+	stateNumericDecimal(input, offset) {
+		while (offset < input.length) {
+			const char = input.charCodeAt(offset);
+			if (isNumber(char)) {
+				this.result = this.result * 10 + (char - CharCodes$1.ZERO);
+				this.consumed++;
+				offset++;
+			} else return this.emitNumericEntity(char, 2);
+		}
+		return -1;
+	}
+	/**
+	* Validate and emit a numeric entity.
+	*
+	* Implements the logic from the `Hexademical character reference start
+	* state` and `Numeric character reference end state` in the HTML spec.
+	* @param lastCp The last code point of the entity. Used to see if the
+	*               entity was terminated with a semicolon.
+	* @param expectedLength The minimum number of characters that should be
+	*                       consumed. Used to validate that at least one digit
+	*                       was consumed.
+	* @returns The number of characters that were consumed.
+	*/
+	emitNumericEntity(lastCp, expectedLength) {
+		if (this.consumed <= expectedLength) {
+			this.errors?.absenceOfDigitsInNumericCharacterReference(this.consumed);
+			return 0;
+		}
+		if (lastCp === CharCodes$1.SEMI) this.consumed += 1;
+		else if (this.decodeMode === DecodingMode.Strict) return 0;
+		this.emitCodePoint(replaceCodePoint(this.result), this.consumed);
+		if (this.errors) {
+			if (lastCp !== CharCodes$1.SEMI) this.errors.missingSemicolonAfterCharacterReference();
+			this.errors.validateNumericCharacterReference(this.result);
+		}
+		return this.consumed;
+	}
+	/**
+	* Parses a named entity.
+	*
+	* Equivalent to the `Named character reference state` in the HTML spec.
+	* @param input The string containing the entity (or a continuation of the entity).
+	* @param offset The current offset.
+	* @returns The number of characters that were consumed, or -1 if the entity is incomplete.
+	*/
+	stateNamedEntity(input, offset) {
+		const { decodeTree } = this;
+		let current = decodeTree[this.treeIndex];
+		let valueLength = (current & BinTrieFlags.VALUE_LENGTH) >> 14;
+		while (offset < input.length) {
+			if (valueLength === 0 && (current & BinTrieFlags.FLAG13) !== 0) {
+				const runLength = (current & BinTrieFlags.BRANCH_LENGTH) >> 7;
+				if (this.runConsumed === 0) {
+					const firstChar = current & BinTrieFlags.JUMP_TABLE;
+					if (input.charCodeAt(offset) !== firstChar) return this.result === 0 ? 0 : this.emitNotTerminatedNamedEntity();
+					offset++;
+					this.excess++;
+					this.runConsumed++;
+				}
+				while (this.runConsumed < runLength) {
+					if (offset >= input.length) return -1;
+					const charIndexInPacked = this.runConsumed - 1;
+					const packedWord = decodeTree[this.treeIndex + 1 + (charIndexInPacked >> 1)];
+					const expectedChar = charIndexInPacked % 2 === 0 ? packedWord & 255 : packedWord >> 8 & 255;
+					if (input.charCodeAt(offset) !== expectedChar) {
+						this.runConsumed = 0;
+						return this.result === 0 ? 0 : this.emitNotTerminatedNamedEntity();
+					}
+					offset++;
+					this.excess++;
+					this.runConsumed++;
+				}
+				this.runConsumed = 0;
+				this.treeIndex += 1 + (runLength >> 1);
+				current = decodeTree[this.treeIndex];
+				valueLength = (current & BinTrieFlags.VALUE_LENGTH) >> 14;
+			}
+			if (offset >= input.length) break;
+			const char = input.charCodeAt(offset);
+			if (char === CharCodes$1.SEMI && valueLength !== 0 && (current & BinTrieFlags.FLAG13) !== 0) return this.emitNamedEntityData(this.treeIndex, valueLength, this.consumed + this.excess);
+			this.treeIndex = determineBranch(decodeTree, current, this.treeIndex + Math.max(1, valueLength), char);
+			if (this.treeIndex < 0) return this.result === 0 || this.decodeMode === DecodingMode.Attribute && (valueLength === 0 || isEntityInAttributeInvalidEnd(char)) ? 0 : this.emitNotTerminatedNamedEntity();
+			current = decodeTree[this.treeIndex];
+			valueLength = (current & BinTrieFlags.VALUE_LENGTH) >> 14;
+			if (valueLength !== 0) {
+				if (char === CharCodes$1.SEMI) return this.emitNamedEntityData(this.treeIndex, valueLength, this.consumed + this.excess);
+				if (this.decodeMode !== DecodingMode.Strict && (current & BinTrieFlags.FLAG13) === 0) {
+					this.result = this.treeIndex;
+					this.consumed += this.excess;
+					this.excess = 0;
+				}
+			}
+			offset++;
+			this.excess++;
+		}
+		return -1;
+	}
+	/**
+	* Emit a named entity that was not terminated with a semicolon.
+	* @returns The number of characters consumed.
+	*/
+	emitNotTerminatedNamedEntity() {
+		const { result, decodeTree } = this;
+		const valueLength = (decodeTree[result] & BinTrieFlags.VALUE_LENGTH) >> 14;
+		this.emitNamedEntityData(result, valueLength, this.consumed);
+		this.errors?.missingSemicolonAfterCharacterReference();
+		return this.consumed;
+	}
+	/**
+	* Emit a named entity.
+	* @param result The index of the entity in the decode tree.
+	* @param valueLength The number of bytes in the entity.
+	* @param consumed The number of characters consumed.
+	* @returns The number of characters consumed.
+	*/
+	emitNamedEntityData(result, valueLength, consumed) {
+		const { decodeTree } = this;
+		this.emitCodePoint(valueLength === 1 ? decodeTree[result] & ~(BinTrieFlags.VALUE_LENGTH | BinTrieFlags.FLAG13) : decodeTree[result + 1], consumed);
+		if (valueLength === 3) this.emitCodePoint(decodeTree[result + 2], consumed);
+		return consumed;
+	}
+	/**
+	* Signal to the parser that the end of the input was reached.
+	*
+	* Remaining data will be emitted and relevant errors will be produced.
+	* @returns The number of characters consumed.
+	*/
+	end() {
+		switch (this.state) {
+			case EntityDecoderState.NamedEntity: return this.result !== 0 && (this.decodeMode !== DecodingMode.Attribute || this.result === this.treeIndex) ? this.emitNotTerminatedNamedEntity() : 0;
+			case EntityDecoderState.NumericDecimal: return this.emitNumericEntity(0, 2);
+			case EntityDecoderState.NumericHex: return this.emitNumericEntity(0, 3);
+			case EntityDecoderState.NumericStart:
+				this.errors?.absenceOfDigitsInNumericCharacterReference(this.consumed);
+				return 0;
+			case EntityDecoderState.EntityStart: return 0;
+		}
+	}
+};
+/**
+* Determines the branch of the current node that is taken given the current
+* character. This function is used to traverse the trie.
+* @param decodeTree The trie.
+* @param current The current node.
+* @param nodeIndex Index immediately after the current node header.
+* @param char The current character.
+* @returns The index of the next node, or -1 if no branch is taken.
+*/
+function determineBranch(decodeTree, current, nodeIndex, char) {
+	const branchCount = (current & BinTrieFlags.BRANCH_LENGTH) >> 7;
+	const jumpOffset = current & BinTrieFlags.JUMP_TABLE;
+	if (branchCount === 0) return jumpOffset !== 0 && char === jumpOffset ? nodeIndex : -1;
+	if (jumpOffset) {
+		const value = char - jumpOffset;
+		return value < 0 || value >= branchCount ? -1 : decodeTree[nodeIndex + value] - 1;
+	}
+	const packedKeySlots = branchCount + 1 >> 1;
+	let lo = 0;
+	let hi = branchCount - 1;
+	while (lo <= hi) {
+		const mid = lo + hi >>> 1;
+		const midKey = decodeTree[nodeIndex + (mid >> 1)] >> (mid & 1) * 8 & 255;
+		if (midKey < char) lo = mid + 1;
+		else if (midKey > char) hi = mid - 1;
+		else return decodeTree[nodeIndex + packedKeySlots + mid];
+	}
+	return -1;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/htmlparser2@12.0.0/node_modules/htmlparser2/dist/Tokenizer.js
+var CharCodes;
+(function(CharCodes) {
+	CharCodes[CharCodes["Tab"] = 9] = "Tab";
+	CharCodes[CharCodes["NewLine"] = 10] = "NewLine";
+	CharCodes[CharCodes["FormFeed"] = 12] = "FormFeed";
+	CharCodes[CharCodes["CarriageReturn"] = 13] = "CarriageReturn";
+	CharCodes[CharCodes["Space"] = 32] = "Space";
+	CharCodes[CharCodes["ExclamationMark"] = 33] = "ExclamationMark";
+	CharCodes[CharCodes["Number"] = 35] = "Number";
+	CharCodes[CharCodes["Amp"] = 38] = "Amp";
+	CharCodes[CharCodes["SingleQuote"] = 39] = "SingleQuote";
+	CharCodes[CharCodes["DoubleQuote"] = 34] = "DoubleQuote";
+	CharCodes[CharCodes["Dash"] = 45] = "Dash";
+	CharCodes[CharCodes["Slash"] = 47] = "Slash";
+	CharCodes[CharCodes["Zero"] = 48] = "Zero";
+	CharCodes[CharCodes["Nine"] = 57] = "Nine";
+	CharCodes[CharCodes["Semi"] = 59] = "Semi";
+	CharCodes[CharCodes["Lt"] = 60] = "Lt";
+	CharCodes[CharCodes["Eq"] = 61] = "Eq";
+	CharCodes[CharCodes["Gt"] = 62] = "Gt";
+	CharCodes[CharCodes["Questionmark"] = 63] = "Questionmark";
+	CharCodes[CharCodes["UpperA"] = 65] = "UpperA";
+	CharCodes[CharCodes["LowerA"] = 97] = "LowerA";
+	CharCodes[CharCodes["UpperF"] = 70] = "UpperF";
+	CharCodes[CharCodes["LowerF"] = 102] = "LowerF";
+	CharCodes[CharCodes["UpperZ"] = 90] = "UpperZ";
+	CharCodes[CharCodes["LowerZ"] = 122] = "LowerZ";
+	CharCodes[CharCodes["LowerX"] = 120] = "LowerX";
+	CharCodes[CharCodes["OpeningSquareBracket"] = 91] = "OpeningSquareBracket";
+})(CharCodes || (CharCodes = {}));
+/** All the states the tokenizer can be in. */
+var State;
+(function(State) {
+	State[State["Text"] = 1] = "Text";
+	State[State["BeforeTagName"] = 2] = "BeforeTagName";
+	State[State["InTagName"] = 3] = "InTagName";
+	State[State["InSelfClosingTag"] = 4] = "InSelfClosingTag";
+	State[State["BeforeClosingTagName"] = 5] = "BeforeClosingTagName";
+	State[State["InClosingTagName"] = 6] = "InClosingTagName";
+	State[State["AfterClosingTagName"] = 7] = "AfterClosingTagName";
+	State[State["BeforeAttributeName"] = 8] = "BeforeAttributeName";
+	State[State["InAttributeName"] = 9] = "InAttributeName";
+	State[State["AfterAttributeName"] = 10] = "AfterAttributeName";
+	State[State["BeforeAttributeValue"] = 11] = "BeforeAttributeValue";
+	State[State["InAttributeValueDq"] = 12] = "InAttributeValueDq";
+	State[State["InAttributeValueSq"] = 13] = "InAttributeValueSq";
+	State[State["InAttributeValueNq"] = 14] = "InAttributeValueNq";
+	State[State["BeforeDeclaration"] = 15] = "BeforeDeclaration";
+	State[State["InDeclaration"] = 16] = "InDeclaration";
+	State[State["InProcessingInstruction"] = 17] = "InProcessingInstruction";
+	State[State["BeforeComment"] = 18] = "BeforeComment";
+	State[State["CDATASequence"] = 19] = "CDATASequence";
+	State[State["DeclarationSequence"] = 20] = "DeclarationSequence";
+	State[State["InSpecialComment"] = 21] = "InSpecialComment";
+	State[State["InCommentLike"] = 22] = "InCommentLike";
+	State[State["SpecialStartSequence"] = 23] = "SpecialStartSequence";
+	State[State["InSpecialTag"] = 24] = "InSpecialTag";
+	State[State["InPlainText"] = 25] = "InPlainText";
+	State[State["InEntity"] = 26] = "InEntity";
+})(State || (State = {}));
+function isWhitespace$1(c) {
+	return c === CharCodes.Space || c === CharCodes.NewLine || c === CharCodes.Tab || c === CharCodes.FormFeed || c === CharCodes.CarriageReturn;
+}
+function isEndOfTagSection(c) {
+	return c === CharCodes.Slash || c === CharCodes.Gt || isWhitespace$1(c);
+}
+function isASCIIAlpha(c) {
+	return c >= CharCodes.LowerA && c <= CharCodes.LowerZ || c >= CharCodes.UpperA && c <= CharCodes.UpperZ;
+}
+/**
+* Quote style used for parsed attributes.
+*/
+var QuoteType;
+(function(QuoteType) {
+	QuoteType[QuoteType["NoValue"] = 0] = "NoValue";
+	QuoteType[QuoteType["Unquoted"] = 1] = "Unquoted";
+	QuoteType[QuoteType["Single"] = 2] = "Single";
+	QuoteType[QuoteType["Double"] = 3] = "Double";
+})(QuoteType || (QuoteType = {}));
+/**
+* Sequences used to match longer strings.
+*
+* We don't have `Script`, `Style`, or `Title` here. Instead, we re-use the *End
+* sequences with an increased offset.
+*/
+const Sequences = {
+	Empty: /* @__PURE__ */ new Uint8Array(0),
+	Cdata: new Uint8Array([
+		67,
+		68,
+		65,
+		84,
+		65,
+		91
+	]),
+	CdataEnd: new Uint8Array([
+		93,
+		93,
+		62
+	]),
+	CommentEnd: new Uint8Array([
+		45,
+		45,
+		33,
+		62
+	]),
+	Doctype: new Uint8Array([
+		100,
+		111,
+		99,
+		116,
+		121,
+		112,
+		101
+	]),
+	IframeEnd: new Uint8Array([
+		60,
+		47,
+		105,
+		102,
+		114,
+		97,
+		109,
+		101
+	]),
+	NoembedEnd: new Uint8Array([
+		60,
+		47,
+		110,
+		111,
+		101,
+		109,
+		98,
+		101,
+		100
+	]),
+	NoframesEnd: new Uint8Array([
+		60,
+		47,
+		110,
+		111,
+		102,
+		114,
+		97,
+		109,
+		101,
+		115
+	]),
+	Plaintext: new Uint8Array([
+		60,
+		47,
+		112,
+		108,
+		97,
+		105,
+		110,
+		116,
+		101,
+		120,
+		116
+	]),
+	ScriptEnd: new Uint8Array([
+		60,
+		47,
+		115,
+		99,
+		114,
+		105,
+		112,
+		116
+	]),
+	StyleEnd: new Uint8Array([
+		60,
+		47,
+		115,
+		116,
+		121,
+		108,
+		101
+	]),
+	TitleEnd: new Uint8Array([
+		60,
+		47,
+		116,
+		105,
+		116,
+		108,
+		101
+	]),
+	TextareaEnd: new Uint8Array([
+		60,
+		47,
+		116,
+		101,
+		120,
+		116,
+		97,
+		114,
+		101,
+		97
+	]),
+	XmpEnd: new Uint8Array([
+		60,
+		47,
+		120,
+		109,
+		112
+	])
+};
+/**
+* Maps the first lowercase character of an HTML tag name to the sequence
+* used for special-tag detection.  All sequences share a common layout
+* where index 2 is the first tag-name character, so matching always
+* continues from offset 3.
+*/
+const specialStartSequences = /* @__PURE__ */ new Map([
+	[Sequences.IframeEnd[2], Sequences.IframeEnd],
+	[Sequences.NoembedEnd[2], Sequences.NoembedEnd],
+	[Sequences.Plaintext[2], Sequences.Plaintext],
+	[Sequences.ScriptEnd[2], Sequences.ScriptEnd],
+	[Sequences.TitleEnd[2], Sequences.TitleEnd],
+	[Sequences.XmpEnd[2], Sequences.XmpEnd]
+]);
+/**
+* Tokenizer implementation used by `Parser`.
+*/
+var Tokenizer = class {
+	cbs;
+	/** The current state the tokenizer is in. */
+	state = State.Text;
+	/** The read buffer. */
+	buffer = "";
+	/** The beginning of the section that is currently being read. */
+	sectionStart = 0;
+	/** The index within the buffer that we are currently looking at. */
+	index = 0;
+	/** The start of the last entity. */
+	entityStart = 0;
+	/** Some behavior, eg. when decoding entities, is done while we are in another state. This keeps track of the other state type. */
+	baseState = State.Text;
+	/** For special parsing behavior inside of script and style tags. */
+	isSpecial = false;
+	/** Indicates whether the tokenizer has been paused. */
+	running = true;
+	/** The offset of the current buffer. */
+	offset = 0;
+	xmlMode;
+	decodeEntities;
+	recognizeSelfClosing;
+	entityDecoder;
+	constructor({ xmlMode = false, decodeEntities = true, recognizeSelfClosing = xmlMode }, cbs) {
+		this.cbs = cbs;
+		this.xmlMode = xmlMode;
+		this.decodeEntities = decodeEntities;
+		this.recognizeSelfClosing = recognizeSelfClosing;
+		this.entityDecoder = new EntityDecoder(xmlMode ? xmlDecodeTree : htmlDecodeTree, (cp, consumed) => this.emitCodePoint(cp, consumed));
+	}
+	reset() {
+		this.state = State.Text;
+		this.buffer = "";
+		this.sectionStart = 0;
+		this.index = 0;
+		this.baseState = State.Text;
+		this.isSpecial = false;
+		this.currentSequence = Sequences.Empty;
+		this.sequenceIndex = 0;
+		this.running = true;
+		this.offset = 0;
+	}
+	write(chunk) {
+		this.offset += this.buffer.length;
+		this.buffer = chunk;
+		this.parse();
+	}
+	end() {
+		if (this.running) this.finish();
+	}
+	pause() {
+		this.running = false;
+	}
+	resume() {
+		this.running = true;
+		if (this.index < this.buffer.length + this.offset) this.parse();
+	}
+	stateText(c) {
+		if (c === CharCodes.Lt || !this.decodeEntities && this.fastForwardTo(CharCodes.Lt)) {
+			if (this.index > this.sectionStart) this.cbs.ontext(this.sectionStart, this.index);
+			this.state = State.BeforeTagName;
+			this.sectionStart = this.index;
+		} else if (this.decodeEntities && c === CharCodes.Amp) this.startEntity();
+	}
+	currentSequence = Sequences.Empty;
+	sequenceIndex = 0;
+	enterTagBody() {
+		if (this.currentSequence === Sequences.Plaintext) {
+			this.currentSequence = Sequences.Empty;
+			this.state = State.InPlainText;
+		} else if (this.isSpecial) {
+			this.state = State.InSpecialTag;
+			this.sequenceIndex = 0;
+		} else this.state = State.Text;
+	}
+	/**
+	* Match the opening tag name against an HTML text-only tag sequence.
+	*
+	* Some tags share an initial prefix (`script`/`style`, `title`/`textarea`,
+	* `noembed`/`noframes`), so we may switch to an alternate sequence at the
+	* first distinguishing byte.  On a successful full match we fall back to
+	* the normal tag-name state; a later `>` will enter raw-text, RCDATA, or
+	* plaintext mode based on `currentSequence` / `isSpecial`.
+	* @param c Current character code point.
+	*/
+	stateSpecialStartSequence(c) {
+		const lower = c | 32;
+		if (this.sequenceIndex < this.currentSequence.length) {
+			if (lower === this.currentSequence[this.sequenceIndex]) {
+				this.sequenceIndex++;
+				return;
+			}
+			if (this.sequenceIndex === 3) {
+				if (this.currentSequence === Sequences.ScriptEnd && lower === Sequences.StyleEnd[3]) {
+					this.currentSequence = Sequences.StyleEnd;
+					this.sequenceIndex = 4;
+					return;
+				}
+				if (this.currentSequence === Sequences.TitleEnd && lower === Sequences.TextareaEnd[3]) {
+					this.currentSequence = Sequences.TextareaEnd;
+					this.sequenceIndex = 4;
+					return;
+				}
+			} else if (this.sequenceIndex === 4 && this.currentSequence === Sequences.NoembedEnd && lower === Sequences.NoframesEnd[4]) {
+				this.currentSequence = Sequences.NoframesEnd;
+				this.sequenceIndex = 5;
+				return;
+			}
+		} else if (isEndOfTagSection(c)) {
+			this.sequenceIndex = 0;
+			this.state = State.InTagName;
+			this.stateInTagName(c);
+			return;
+		}
+		this.isSpecial = false;
+		this.currentSequence = Sequences.Empty;
+		this.sequenceIndex = 0;
+		this.state = State.InTagName;
+		this.stateInTagName(c);
+	}
+	stateCDATASequence(c) {
+		if (c === Sequences.Cdata[this.sequenceIndex]) {
+			if (++this.sequenceIndex === Sequences.Cdata.length) {
+				this.state = State.InCommentLike;
+				this.currentSequence = Sequences.CdataEnd;
+				this.sequenceIndex = 0;
+				this.sectionStart = this.index + 1;
+			}
+		} else {
+			this.sequenceIndex = 0;
+			if (this.xmlMode) {
+				this.state = State.InDeclaration;
+				this.stateInDeclaration(c);
+			} else {
+				this.state = State.InSpecialComment;
+				this.stateInSpecialComment(c);
+			}
+		}
+	}
+	/**
+	* When we wait for one specific character, we can speed things up
+	* by skipping through the buffer until we find it.
+	* @param c Current character code point.
+	* @returns Whether the character was found.
+	*/
+	fastForwardTo(c) {
+		while (++this.index < this.buffer.length + this.offset) if (this.buffer.charCodeAt(this.index - this.offset) === c) return true;
+		this.index = this.buffer.length + this.offset - 1;
+		return false;
+	}
+	/**
+	* Emit a comment token and return to the text state.
+	* @param offset Number of characters in the end sequence that have already been matched.
+	*/
+	emitComment(offset) {
+		this.cbs.oncomment(this.sectionStart, this.index, offset);
+		this.sequenceIndex = 0;
+		this.sectionStart = this.index + 1;
+		this.state = State.Text;
+	}
+	/**
+	* Comments and CDATA end with `-->` and `]]>`.
+	*
+	* Their common qualities are:
+	* - Their end sequences have a distinct character they start with.
+	* - That character is then repeated, so we have to check multiple repeats.
+	* - All characters but the start character of the sequence can be skipped.
+	* @param c Current character code point.
+	*/
+	stateInCommentLike(c) {
+		if (!this.xmlMode && this.currentSequence === Sequences.CommentEnd && this.sequenceIndex <= 1 && this.index === this.sectionStart + this.sequenceIndex && c === CharCodes.Gt) this.emitComment(this.sequenceIndex);
+		else if (this.currentSequence === Sequences.CommentEnd && this.sequenceIndex === 2 && c === CharCodes.Gt) this.emitComment(2);
+		else if (this.currentSequence === Sequences.CommentEnd && this.sequenceIndex === this.currentSequence.length - 1 && c !== CharCodes.Gt) this.sequenceIndex = Number(c === CharCodes.Dash);
+		else if (c === this.currentSequence[this.sequenceIndex]) {
+			if (++this.sequenceIndex === this.currentSequence.length) {
+				if (this.currentSequence === Sequences.CdataEnd) this.cbs.oncdata(this.sectionStart, this.index, 2);
+				else this.cbs.oncomment(this.sectionStart, this.index, 3);
+				this.sequenceIndex = 0;
+				this.sectionStart = this.index + 1;
+				this.state = State.Text;
+			}
+		} else if (this.sequenceIndex === 0) {
+			if (this.fastForwardTo(this.currentSequence[0])) this.sequenceIndex = 1;
+		} else if (c !== this.currentSequence[this.sequenceIndex - 1]) this.sequenceIndex = 0;
+	}
+	/**
+	* HTML only allows ASCII alpha characters (a-z and A-Z) at the beginning of a tag name.
+	*
+	* XML allows a lot more characters here (@see https://www.w3.org/TR/REC-xml/#NT-NameStartChar).
+	* We allow anything that wouldn't end the tag.
+	* @param c Current character code point.
+	*/
+	isTagStartChar(c) {
+		return this.xmlMode ? !isEndOfTagSection(c) : isASCIIAlpha(c);
+	}
+	/**
+	* Scan raw-text / RCDATA content for the matching end tag.
+	*
+	* For RCDATA tags (`<title>`, `<textarea>`) entities are decoded inline.
+	* For raw-text tags (`<script>`, `<style>`, etc.) we fast-forward to `<`.
+	* @param c Current character code point.
+	*/
+	stateInSpecialTag(c) {
+		if (this.sequenceIndex === this.currentSequence.length) {
+			if (isEndOfTagSection(c)) {
+				const endOfText = this.index - this.currentSequence.length;
+				if (this.sectionStart < endOfText) {
+					const actualIndex = this.index;
+					this.index = endOfText;
+					this.cbs.ontext(this.sectionStart, endOfText);
+					this.index = actualIndex;
+				}
+				this.isSpecial = false;
+				this.sectionStart = endOfText + 2;
+				this.stateInClosingTagName(c);
+				return;
+			}
+			this.sequenceIndex = 0;
+		}
+		if ((c | 32) === this.currentSequence[this.sequenceIndex]) this.sequenceIndex += 1;
+		else if (this.sequenceIndex === 0) {
+			if (this.currentSequence === Sequences.TitleEnd || this.currentSequence === Sequences.TextareaEnd) {
+				if (this.decodeEntities && c === CharCodes.Amp) this.startEntity();
+			} else if (this.fastForwardTo(CharCodes.Lt)) this.sequenceIndex = 1;
+		} else this.sequenceIndex = Number(c === CharCodes.Lt);
+	}
+	stateBeforeTagName(c) {
+		if (c === CharCodes.ExclamationMark) {
+			this.state = State.BeforeDeclaration;
+			this.sectionStart = this.index + 1;
+		} else if (c === CharCodes.Questionmark) {
+			if (this.xmlMode) {
+				this.state = State.InProcessingInstruction;
+				this.sequenceIndex = 0;
+				this.sectionStart = this.index + 1;
+			} else {
+				this.state = State.InSpecialComment;
+				this.sectionStart = this.index;
+			}
+		} else if (this.isTagStartChar(c)) {
+			this.sectionStart = this.index;
+			const special = this.xmlMode || this.cbs.isInForeignContext?.() ? void 0 : specialStartSequences.get(c | 32);
+			if (special === void 0) this.state = State.InTagName;
+			else {
+				this.isSpecial = true;
+				this.currentSequence = special;
+				this.sequenceIndex = 3;
+				this.state = State.SpecialStartSequence;
+			}
+		} else if (c === CharCodes.Slash) this.state = State.BeforeClosingTagName;
+		else {
+			this.state = State.Text;
+			this.stateText(c);
+		}
+	}
+	stateInTagName(c) {
+		if (isEndOfTagSection(c)) {
+			this.cbs.onopentagname(this.sectionStart, this.index);
+			this.sectionStart = -1;
+			this.state = State.BeforeAttributeName;
+			this.stateBeforeAttributeName(c);
+		}
+	}
+	stateBeforeClosingTagName(c) {
+		if (isWhitespace$1(c)) {
+			if (this.xmlMode) {} else {
+				this.state = State.InSpecialComment;
+				this.sectionStart = this.index;
+			}
+		} else if (c === CharCodes.Gt) {
+			this.state = State.Text;
+			if (!this.xmlMode) this.sectionStart = this.index + 1;
+		} else {
+			this.state = this.isTagStartChar(c) ? State.InClosingTagName : State.InSpecialComment;
+			this.sectionStart = this.index;
+		}
+	}
+	stateInClosingTagName(c) {
+		if (isEndOfTagSection(c)) {
+			this.cbs.onclosetag(this.sectionStart, this.index);
+			this.sectionStart = -1;
+			this.state = State.AfterClosingTagName;
+			this.stateAfterClosingTagName(c);
+		}
+	}
+	stateAfterClosingTagName(c) {
+		if (c === CharCodes.Gt || this.fastForwardTo(CharCodes.Gt)) {
+			this.state = State.Text;
+			this.sectionStart = this.index + 1;
+		}
+	}
+	stateBeforeAttributeName(c) {
+		if (c === CharCodes.Gt) {
+			this.cbs.onopentagend(this.index);
+			this.enterTagBody();
+			this.sectionStart = this.index + 1;
+		} else if (c === CharCodes.Slash) this.state = State.InSelfClosingTag;
+		else if (!isWhitespace$1(c)) {
+			this.state = State.InAttributeName;
+			this.sectionStart = this.index;
+		}
+	}
+	/**
+	* Handle `/` before `>` in an opening tag.
+	*
+	* In HTML mode, text-only tags ignore the self-closing flag and still enter
+	* their raw-text/RCDATA/plaintext state unless self-closing tags are being
+	* recognized. In XML mode, or for ordinary tags, the tokenizer returns to
+	* regular text parsing after emitting the self-closing callback.
+	* @param c Current character code point.
+	*/
+	stateInSelfClosingTag(c) {
+		if (c === CharCodes.Gt) {
+			this.cbs.onselfclosingtag(this.index);
+			this.sectionStart = this.index + 1;
+			if (!this.recognizeSelfClosing) {
+				this.enterTagBody();
+				return;
+			}
+			this.state = State.Text;
+			this.isSpecial = false;
+			this.currentSequence = Sequences.Empty;
+		} else if (!isWhitespace$1(c)) {
+			this.state = State.BeforeAttributeName;
+			this.stateBeforeAttributeName(c);
+		}
+	}
+	stateInAttributeName(c) {
+		if (c === CharCodes.Eq || isEndOfTagSection(c)) {
+			this.cbs.onattribname(this.sectionStart, this.index);
+			this.sectionStart = this.index;
+			this.state = State.AfterAttributeName;
+			this.stateAfterAttributeName(c);
+		}
+	}
+	stateAfterAttributeName(c) {
+		if (c === CharCodes.Eq) this.state = State.BeforeAttributeValue;
+		else if (c === CharCodes.Slash || c === CharCodes.Gt) {
+			this.cbs.onattribend(QuoteType.NoValue, this.sectionStart);
+			this.sectionStart = -1;
+			this.state = State.BeforeAttributeName;
+			this.stateBeforeAttributeName(c);
+		} else if (!isWhitespace$1(c)) {
+			this.cbs.onattribend(QuoteType.NoValue, this.sectionStart);
+			this.state = State.InAttributeName;
+			this.sectionStart = this.index;
+		}
+	}
+	stateBeforeAttributeValue(c) {
+		if (c === CharCodes.DoubleQuote) {
+			this.state = State.InAttributeValueDq;
+			this.sectionStart = this.index + 1;
+		} else if (c === CharCodes.SingleQuote) {
+			this.state = State.InAttributeValueSq;
+			this.sectionStart = this.index + 1;
+		} else if (!isWhitespace$1(c)) {
+			this.sectionStart = this.index;
+			this.state = State.InAttributeValueNq;
+			this.stateInAttributeValueNoQuotes(c);
+		}
+	}
+	handleInAttributeValue(c, quote) {
+		if (c === quote || !this.decodeEntities && this.fastForwardTo(quote)) {
+			this.cbs.onattribdata(this.sectionStart, this.index);
+			this.sectionStart = -1;
+			this.cbs.onattribend(quote === CharCodes.DoubleQuote ? QuoteType.Double : QuoteType.Single, this.index + 1);
+			this.state = State.BeforeAttributeName;
+		} else if (this.decodeEntities && c === CharCodes.Amp) this.startEntity();
+	}
+	stateInAttributeValueDoubleQuotes(c) {
+		this.handleInAttributeValue(c, CharCodes.DoubleQuote);
+	}
+	stateInAttributeValueSingleQuotes(c) {
+		this.handleInAttributeValue(c, CharCodes.SingleQuote);
+	}
+	stateInAttributeValueNoQuotes(c) {
+		if (isWhitespace$1(c) || c === CharCodes.Gt) {
+			this.cbs.onattribdata(this.sectionStart, this.index);
+			this.sectionStart = -1;
+			this.cbs.onattribend(QuoteType.Unquoted, this.index);
+			this.state = State.BeforeAttributeName;
+			this.stateBeforeAttributeName(c);
+		} else if (this.decodeEntities && c === CharCodes.Amp) this.startEntity();
+	}
+	/**
+	* Distinguish between CDATA, declarations, HTML comments, and HTML bogus
+	* comments after `<!`.
+	*
+	* In HTML mode, only real comments and doctypes stay on declaration paths;
+	* everything else becomes a bogus comment terminated by the next `>`.
+	* @param c Current character code point.
+	*/
+	stateBeforeDeclaration(c) {
+		if (c === CharCodes.OpeningSquareBracket) {
+			this.state = State.CDATASequence;
+			this.sequenceIndex = 0;
+		} else if (this.xmlMode) this.state = c === CharCodes.Dash ? State.BeforeComment : State.InDeclaration;
+		else if ((c | 32) === Sequences.Doctype[0]) {
+			this.state = State.DeclarationSequence;
+			this.currentSequence = Sequences.Doctype;
+			this.sequenceIndex = 1;
+		} else if (c === CharCodes.Gt) {
+			this.cbs.oncomment(this.sectionStart, this.index, 0);
+			this.state = State.Text;
+			this.sectionStart = this.index + 1;
+		} else if (c === CharCodes.Dash) this.state = State.BeforeComment;
+		else this.state = State.InSpecialComment;
+	}
+	/**
+	* Continue matching `doctype` after `<!d`.
+	*
+	* A full `doctype` match stays on the declaration path; any other name falls
+	* back to an HTML bogus comment, which matches browser behavior for
+	* non-doctype `<!...>` constructs.
+	* @param c Current character code point.
+	*/
+	stateDeclarationSequence(c) {
+		if (this.sequenceIndex === this.currentSequence.length) {
+			this.state = State.InDeclaration;
+			this.stateInDeclaration(c);
+		} else if ((c | 32) === this.currentSequence[this.sequenceIndex]) this.sequenceIndex += 1;
+		else if (c === CharCodes.Gt) {
+			this.cbs.oncomment(this.sectionStart, this.index, 0);
+			this.state = State.Text;
+			this.sectionStart = this.index + 1;
+		} else this.state = State.InSpecialComment;
+	}
+	stateInDeclaration(c) {
+		if (c === CharCodes.Gt || this.fastForwardTo(CharCodes.Gt)) {
+			this.cbs.ondeclaration(this.sectionStart, this.index);
+			this.state = State.Text;
+			this.sectionStart = this.index + 1;
+		}
+	}
+	/**
+	* XML processing instructions (`<?...?>`).
+	*
+	* In HTML mode `<?` is routed to `InSpecialComment` instead, so this
+	* state is only reachable in XML mode.
+	* @param c Current character code point.
+	*/
+	stateInProcessingInstruction(c) {
+		if (c === CharCodes.Questionmark) this.sequenceIndex = 1;
+		else if (c === CharCodes.Gt && this.sequenceIndex === 1) {
+			this.cbs.onprocessinginstruction(this.sectionStart, this.index - 1);
+			this.sequenceIndex = 0;
+			this.state = State.Text;
+			this.sectionStart = this.index + 1;
+		} else this.sequenceIndex = Number(this.fastForwardTo(CharCodes.Questionmark));
+	}
+	stateBeforeComment(c) {
+		if (c === CharCodes.Dash) {
+			this.state = State.InCommentLike;
+			this.currentSequence = Sequences.CommentEnd;
+			this.sequenceIndex = 0;
+			this.sectionStart = this.index + 1;
+		} else if (this.xmlMode) this.state = State.InDeclaration;
+		else if (c === CharCodes.Gt) {
+			this.cbs.oncomment(this.sectionStart, this.index, 0);
+			this.state = State.Text;
+			this.sectionStart = this.index + 1;
+		} else this.state = State.InSpecialComment;
+	}
+	stateInSpecialComment(c) {
+		if (c === CharCodes.Gt || this.fastForwardTo(CharCodes.Gt)) {
+			this.cbs.oncomment(this.sectionStart, this.index, 0);
+			this.state = State.Text;
+			this.sectionStart = this.index + 1;
+		}
+	}
+	startEntity() {
+		this.baseState = this.state;
+		this.state = State.InEntity;
+		this.entityStart = this.index;
+		this.entityDecoder.startEntity(this.xmlMode ? DecodingMode.Strict : this.baseState === State.Text || this.baseState === State.InSpecialTag ? DecodingMode.Legacy : DecodingMode.Attribute);
+	}
+	stateInEntity() {
+		const indexInBuffer = this.index - this.offset;
+		const length = this.entityDecoder.write(this.buffer, indexInBuffer);
+		if (length >= 0) {
+			this.state = this.baseState;
+			if (length === 0) this.index -= 1;
+		} else {
+			if (indexInBuffer < this.buffer.length && this.buffer.charCodeAt(indexInBuffer) === CharCodes.Amp) {
+				this.state = this.baseState;
+				this.index -= 1;
+				return;
+			}
+			this.index = this.offset + this.buffer.length - 1;
+		}
+	}
+	/**
+	* Remove data that has already been consumed from the buffer.
+	*/
+	cleanup() {
+		if (this.running && this.sectionStart !== this.index) {
+			if (this.state === State.Text || this.state === State.InPlainText || this.state === State.InSpecialTag && this.sequenceIndex === 0) {
+				this.cbs.ontext(this.sectionStart, this.index);
+				this.sectionStart = this.index;
+			} else if (this.state === State.InAttributeValueDq || this.state === State.InAttributeValueSq || this.state === State.InAttributeValueNq) {
+				this.cbs.onattribdata(this.sectionStart, this.index);
+				this.sectionStart = this.index;
+			}
+		}
+	}
+	shouldContinue() {
+		return this.index < this.buffer.length + this.offset && this.running;
+	}
+	/**
+	* Iterates through the buffer, calling the function corresponding to the current state.
+	*
+	* States that are more likely to be hit are higher up, as a performance improvement.
+	*/
+	parse() {
+		while (this.shouldContinue()) {
+			const c = this.buffer.charCodeAt(this.index - this.offset);
+			switch (this.state) {
+				case State.Text:
+					this.stateText(c);
+					break;
+				case State.InPlainText:
+					this.index = this.buffer.length + this.offset - 1;
+					break;
+				case State.SpecialStartSequence:
+					this.stateSpecialStartSequence(c);
+					break;
+				case State.InSpecialTag:
+					this.stateInSpecialTag(c);
+					break;
+				case State.CDATASequence:
+					this.stateCDATASequence(c);
+					break;
+				case State.DeclarationSequence:
+					this.stateDeclarationSequence(c);
+					break;
+				case State.InAttributeValueDq:
+					this.stateInAttributeValueDoubleQuotes(c);
+					break;
+				case State.InAttributeName:
+					this.stateInAttributeName(c);
+					break;
+				case State.InCommentLike:
+					this.stateInCommentLike(c);
+					break;
+				case State.InSpecialComment:
+					this.stateInSpecialComment(c);
+					break;
+				case State.BeforeAttributeName:
+					this.stateBeforeAttributeName(c);
+					break;
+				case State.InTagName:
+					this.stateInTagName(c);
+					break;
+				case State.InClosingTagName:
+					this.stateInClosingTagName(c);
+					break;
+				case State.BeforeTagName:
+					this.stateBeforeTagName(c);
+					break;
+				case State.AfterAttributeName:
+					this.stateAfterAttributeName(c);
+					break;
+				case State.InAttributeValueSq:
+					this.stateInAttributeValueSingleQuotes(c);
+					break;
+				case State.BeforeAttributeValue:
+					this.stateBeforeAttributeValue(c);
+					break;
+				case State.BeforeClosingTagName:
+					this.stateBeforeClosingTagName(c);
+					break;
+				case State.AfterClosingTagName:
+					this.stateAfterClosingTagName(c);
+					break;
+				case State.InAttributeValueNq:
+					this.stateInAttributeValueNoQuotes(c);
+					break;
+				case State.InSelfClosingTag:
+					this.stateInSelfClosingTag(c);
+					break;
+				case State.InDeclaration:
+					this.stateInDeclaration(c);
+					break;
+				case State.BeforeDeclaration:
+					this.stateBeforeDeclaration(c);
+					break;
+				case State.BeforeComment:
+					this.stateBeforeComment(c);
+					break;
+				case State.InProcessingInstruction:
+					this.stateInProcessingInstruction(c);
+					break;
+				case State.InEntity: this.stateInEntity();
+			}
+			this.index++;
+		}
+		this.cleanup();
+	}
+	finish() {
+		if (this.state === State.InEntity) {
+			this.entityDecoder.end();
+			this.state = this.baseState;
+		}
+		this.handleTrailingData();
+		this.cbs.onend();
+	}
+	handleTrailingCommentLikeData(endIndex) {
+		if (this.state !== State.InCommentLike) return false;
+		if (this.currentSequence === Sequences.CdataEnd) {
+			if (this.xmlMode) {
+				if (this.sectionStart < endIndex) this.cbs.oncdata(this.sectionStart, endIndex, 0);
+			} else {
+				const cdataStart = this.sectionStart - Sequences.Cdata.length - 1;
+				this.cbs.oncomment(cdataStart, endIndex, 0);
+			}
+		} else {
+			const offset = this.xmlMode ? 0 : Math.min(this.sequenceIndex, Sequences.CommentEnd.length - 1);
+			this.cbs.oncomment(this.sectionStart, endIndex, offset);
+		}
+		return true;
+	}
+	handleTrailingMarkupDeclaration(endIndex) {
+		if (this.xmlMode) switch (this.state) {
+			case State.InSpecialComment:
+			case State.BeforeComment:
+			case State.CDATASequence:
+			case State.DeclarationSequence:
+			case State.InDeclaration:
+				this.cbs.ontext(this.sectionStart, endIndex);
+				return true;
+			default: return false;
+		}
+		switch (this.state) {
+			case State.BeforeDeclaration:
+			case State.InSpecialComment:
+			case State.BeforeComment:
+			case State.CDATASequence:
+				this.cbs.oncomment(this.sectionStart, endIndex, 0);
+				return true;
+			case State.DeclarationSequence:
+				if (this.sequenceIndex !== Sequences.Doctype.length) this.cbs.oncomment(this.sectionStart, endIndex, 0);
+				return true;
+			case State.InDeclaration: return true;
+			default: return false;
+		}
+	}
+	/** Handle any trailing data. */
+	handleTrailingData() {
+		const endIndex = this.buffer.length + this.offset;
+		if (this.handleTrailingCommentLikeData(endIndex) || this.handleTrailingMarkupDeclaration(endIndex)) return;
+		if (this.sectionStart >= endIndex) return;
+		switch (this.state) {
+			case State.InTagName:
+			case State.BeforeAttributeName:
+			case State.BeforeAttributeValue:
+			case State.AfterAttributeName:
+			case State.InAttributeName:
+			case State.InAttributeValueSq:
+			case State.InAttributeValueDq:
+			case State.InAttributeValueNq:
+			case State.InClosingTagName: break;
+			default: this.cbs.ontext(this.sectionStart, endIndex);
+		}
+	}
+	emitCodePoint(cp, consumed) {
+		if (this.baseState !== State.Text && this.baseState !== State.InSpecialTag) {
+			if (this.sectionStart < this.entityStart) this.cbs.onattribdata(this.sectionStart, this.entityStart);
+			this.sectionStart = this.entityStart + consumed;
+			this.index = this.sectionStart - 1;
+			this.cbs.onattribentity(cp);
+		} else {
+			if (this.sectionStart < this.entityStart) this.cbs.ontext(this.sectionStart, this.entityStart);
+			this.sectionStart = this.entityStart + consumed;
+			this.index = this.sectionStart - 1;
+			this.cbs.ontextentity(cp, this.sectionStart);
+		}
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/htmlparser2@12.0.0/node_modules/htmlparser2/dist/Parser.js
+const { fromCodePoint } = String;
+const formTags = /* @__PURE__ */ new Set([
+	"input",
+	"option",
+	"optgroup",
+	"select",
+	"button",
+	"datalist",
+	"textarea"
+]);
+const pTag = /* @__PURE__ */ new Set(["p"]);
+const headingTags = /* @__PURE__ */ new Set([
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"h5",
+	"h6",
+	"p"
+]);
+const tableSectionTags = /* @__PURE__ */ new Set(["thead", "tbody"]);
+const ddtTags = /* @__PURE__ */ new Set(["dd", "dt"]);
+const rtpTags = /* @__PURE__ */ new Set(["rt", "rp"]);
+const openImpliesClose = /* @__PURE__ */ new Map([
+	["tr", /* @__PURE__ */ new Set([
+		"tr",
+		"th",
+		"td"
+	])],
+	["th", /* @__PURE__ */ new Set(["th"])],
+	["td", /* @__PURE__ */ new Set([
+		"thead",
+		"th",
+		"td"
+	])],
+	["body", /* @__PURE__ */ new Set([
+		"head",
+		"link",
+		"script"
+	])],
+	["a", /* @__PURE__ */ new Set(["a"])],
+	["li", /* @__PURE__ */ new Set(["li"])],
+	["p", pTag],
+	["h1", headingTags],
+	["h2", headingTags],
+	["h3", headingTags],
+	["h4", headingTags],
+	["h5", headingTags],
+	["h6", headingTags],
+	["select", formTags],
+	["input", formTags],
+	["output", formTags],
+	["button", formTags],
+	["datalist", formTags],
+	["textarea", formTags],
+	["option", /* @__PURE__ */ new Set(["option"])],
+	["optgroup", /* @__PURE__ */ new Set(["optgroup", "option"])],
+	["dd", ddtTags],
+	["dt", ddtTags],
+	["address", pTag],
+	["article", pTag],
+	["aside", pTag],
+	["blockquote", pTag],
+	["details", pTag],
+	["div", pTag],
+	["dl", pTag],
+	["fieldset", pTag],
+	["figcaption", pTag],
+	["figure", pTag],
+	["footer", pTag],
+	["form", pTag],
+	["header", pTag],
+	["hr", pTag],
+	["main", pTag],
+	["nav", pTag],
+	["ol", pTag],
+	["pre", pTag],
+	["section", pTag],
+	["table", pTag],
+	["ul", pTag],
+	["rt", rtpTags],
+	["rp", rtpTags],
+	["tbody", tableSectionTags],
+	["tfoot", tableSectionTags]
+]);
+const DOCUMENT_TYPE = "doctype";
+const voidElements = /* @__PURE__ */ new Set([
+	"area",
+	"base",
+	"basefont",
+	"br",
+	"col",
+	"command",
+	"embed",
+	"frame",
+	"hr",
+	"img",
+	"input",
+	"isindex",
+	"keygen",
+	"link",
+	"meta",
+	"param",
+	"source",
+	"track",
+	"wbr"
+]);
+const foreignContextElements = /* @__PURE__ */ new Set(["math", "svg"]);
+/**
+* Elements that can be used to integrate HTML content within foreign namespaces (e.g., SVG or MathML).
+*
+* Entries must use the SVG-adjusted casing (e.g. "foreignObject" not
+* "foreignobject") since they are compared against adjusted tag names.
+*/
+const htmlIntegrationElements = /* @__PURE__ */ new Set([
+	"mi",
+	"mo",
+	"mn",
+	"ms",
+	"mtext",
+	"annotation-xml",
+	"foreignObject",
+	"desc",
+	"title"
+]);
+const svgTagNameAdjustments = /* @__PURE__ */ new Map([
+	["altglyph", "altGlyph"],
+	["altglyphdef", "altGlyphDef"],
+	["altglyphitem", "altGlyphItem"],
+	["animatecolor", "animateColor"],
+	["animatemotion", "animateMotion"],
+	["animatetransform", "animateTransform"],
+	["clippath", "clipPath"],
+	["feblend", "feBlend"],
+	["fecolormatrix", "feColorMatrix"],
+	["fecomponenttransfer", "feComponentTransfer"],
+	["fecomposite", "feComposite"],
+	["feconvolvematrix", "feConvolveMatrix"],
+	["fediffuselighting", "feDiffuseLighting"],
+	["fedisplacementmap", "feDisplacementMap"],
+	["fedistantlight", "feDistantLight"],
+	["fedropshadow", "feDropShadow"],
+	["feflood", "feFlood"],
+	["fefunca", "feFuncA"],
+	["fefuncb", "feFuncB"],
+	["fefuncg", "feFuncG"],
+	["fefuncr", "feFuncR"],
+	["fegaussianblur", "feGaussianBlur"],
+	["feimage", "feImage"],
+	["femerge", "feMerge"],
+	["femergenode", "feMergeNode"],
+	["femorphology", "feMorphology"],
+	["feoffset", "feOffset"],
+	["fepointlight", "fePointLight"],
+	["fespecularlighting", "feSpecularLighting"],
+	["fespotlight", "feSpotLight"],
+	["fetile", "feTile"],
+	["feturbulence", "feTurbulence"],
+	["foreignobject", "foreignObject"],
+	["glyphref", "glyphRef"],
+	["lineargradient", "linearGradient"],
+	["radialgradient", "radialGradient"],
+	["textpath", "textPath"]
+]);
+var ForeignContext;
+(function(ForeignContext) {
+	ForeignContext[ForeignContext["None"] = 0] = "None";
+	ForeignContext[ForeignContext["Svg"] = 1] = "Svg";
+	ForeignContext[ForeignContext["MathML"] = 2] = "MathML";
+})(ForeignContext || (ForeignContext = {}));
+const reNameEnd = /\s|\//;
+/**
+* Incremental parser implementation.
+*/
+var Parser = class {
+	options;
+	/** The start index of the last event. */
+	startIndex = 0;
+	/** The end index of the last event. */
+	endIndex = 0;
+	/**
+	* Store the start index of the current open tag,
+	* so we can update the start index for attributes.
+	*/
+	openTagStart = 0;
+	tagname = "";
+	attribname = "";
+	attribvalue = "";
+	attribs = null;
+	stack = [];
+	foreignContext;
+	cbs;
+	lowerCaseTagNames;
+	lowerCaseAttributeNames;
+	recognizeSelfClosing;
+	/** We are parsing HTML. Inverse of the `xmlMode` option. */
+	htmlMode;
+	tokenizer;
+	buffers = [];
+	bufferOffset = 0;
+	/** The index of the last written buffer. Used when resuming after a `pause()`. */
+	writeIndex = 0;
+	/** Indicates whether the parser has finished running / `.end` has been called. */
+	ended = false;
+	constructor(cbs, options = {}) {
+		this.options = options;
+		this.cbs = cbs ?? {};
+		this.htmlMode = !this.options.xmlMode;
+		this.lowerCaseTagNames = options.lowerCaseTags ?? this.htmlMode;
+		this.lowerCaseAttributeNames = options.lowerCaseAttributeNames ?? this.htmlMode;
+		this.recognizeSelfClosing = options.recognizeSelfClosing ?? !this.htmlMode;
+		this.tokenizer = new (options.Tokenizer ?? Tokenizer)(this.options, this);
+		this.foreignContext = [ForeignContext.None];
+		this.cbs.onparserinit?.(this);
+	}
+	/**
+	* @param start Start index for the current parser event.
+	* @param endIndex End index for the current parser event.
+	* @internal
+	*/
+	ontext(start, endIndex) {
+		const data = this.getSlice(start, endIndex);
+		this.endIndex = endIndex - 1;
+		this.cbs.ontext?.(data);
+		this.startIndex = endIndex;
+	}
+	/**
+	* @param cp Current Unicode code point.
+	* @param endIndex End index for the current parser event.
+	* @internal
+	*/
+	ontextentity(cp, endIndex) {
+		this.endIndex = endIndex - 1;
+		this.cbs.ontext?.(fromCodePoint(cp));
+		this.startIndex = endIndex;
+	}
+	/** @internal */
+	isInForeignContext() {
+		return this.foreignContext[0] !== ForeignContext.None;
+	}
+	/**
+	* Checks if the current tag is a void element. Override this if you want
+	* to specify your own additional void elements.
+	* @param name Name of the pseudo selector.
+	*/
+	isVoidElement(name) {
+		return this.htmlMode && voidElements.has(name);
+	}
+	/**
+	* Read a tag name from the buffer.
+	*
+	* When `lowerCaseTagNames` is enabled (the default in HTML mode), the name
+	* is lowercased and may be adjusted for SVG casing or the `image` → `img`
+	* alias.
+	* @param start Start index of the tag name in the buffer.
+	* @param endIndex End index of the tag name in the buffer.
+	*/
+	readTagName(start, endIndex) {
+		const name = this.lowerCaseTagNames ? this.getSlice(start, endIndex).toLowerCase() : this.getSlice(start, endIndex);
+		if (!(this.lowerCaseTagNames && this.htmlMode)) return name;
+		if (this.foreignContext[0] === ForeignContext.Svg) return svgTagNameAdjustments.get(name) ?? name;
+		if (this.foreignContext.length > 1) {
+			const adjusted = svgTagNameAdjustments.get(name);
+			if (adjusted !== void 0 && this.stack.includes(adjusted)) return adjusted;
+		}
+		if (!this.isInForeignContext()) return name === "image" ? "img" : name;
+		return name;
+	}
+	/**
+	* @param start Start index for the current parser event.
+	* @param endIndex End index for the current parser event.
+	* @internal
+	*/
+	onopentagname(start, endIndex) {
+		this.endIndex = endIndex;
+		this.emitOpenTag(this.readTagName(start, endIndex));
+	}
+	emitOpenTag(name) {
+		this.openTagStart = this.startIndex;
+		this.tagname = name;
+		if (this.htmlMode && name === "form" && this.stack.includes("form")) {
+			this.tagname = "";
+			return;
+		}
+		const impliesClose = this.htmlMode && openImpliesClose.get(name);
+		if (impliesClose) while (this.stack.length > 0 && impliesClose.has(this.stack[0])) this.popElement(true);
+		if (!this.isVoidElement(name)) {
+			this.stack.unshift(name);
+			if (this.htmlMode) {
+				if (name === "svg") this.foreignContext.unshift(ForeignContext.Svg);
+				else if (name === "math") this.foreignContext.unshift(ForeignContext.MathML);
+				else if (htmlIntegrationElements.has(name)) this.foreignContext.unshift(ForeignContext.None);
+			}
+		}
+		this.cbs.onopentagname?.(name);
+		if (this.cbs.onopentag) this.attribs = {};
+	}
+	endOpenTag(isImplied) {
+		this.startIndex = this.openTagStart;
+		if (this.attribs) {
+			this.cbs.onopentag?.(this.tagname, this.attribs, isImplied);
+			this.attribs = null;
+		}
+		if (this.cbs.onclosetag && this.isVoidElement(this.tagname)) this.cbs.onclosetag(this.tagname, true);
+		this.tagname = "";
+	}
+	/**
+	* @param endIndex End index for the current parser event.
+	* @internal
+	*/
+	onopentagend(endIndex) {
+		this.endIndex = endIndex;
+		this.endOpenTag(false);
+		this.startIndex = endIndex + 1;
+	}
+	/**
+	* @param start Start index for the current parser event.
+	* @param endIndex End index for the current parser event.
+	* @internal
+	*/
+	onclosetag(start, endIndex) {
+		this.endIndex = endIndex;
+		const name = this.readTagName(start, endIndex);
+		if (!this.isVoidElement(name)) {
+			const pos = this.stack.indexOf(name);
+			if (pos !== -1) {
+				for (let index = 0; index < pos; index++) this.popElement(true);
+				this.popElement(false);
+			} else if (this.htmlMode && name === "p") {
+				this.emitOpenTag("p");
+				this.closeCurrentTag(true);
+			}
+		} else if (this.htmlMode && name === "br") {
+			this.cbs.onopentagname?.("br");
+			this.cbs.onopentag?.("br", {}, true);
+			this.cbs.onclosetag?.("br", false);
+		}
+		this.startIndex = endIndex + 1;
+	}
+	/**
+	* @param endIndex End index for the current parser event.
+	* @internal
+	*/
+	onselfclosingtag(endIndex) {
+		this.endIndex = endIndex;
+		if (this.recognizeSelfClosing || this.isInForeignContext()) {
+			this.closeCurrentTag(false);
+			this.startIndex = endIndex + 1;
+		} else this.onopentagend(endIndex);
+	}
+	/**
+	* Pop the top element off the stack, emit a close event, and maintain
+	* the foreign context stack.
+	* @param implied Whether this close is implied (not from an explicit end tag).
+	*/
+	popElement(implied) {
+		const element = this.stack.shift();
+		if (this.htmlMode && (foreignContextElements.has(element) || htmlIntegrationElements.has(element))) this.foreignContext.shift();
+		this.cbs.onclosetag?.(element, implied);
+	}
+	closeCurrentTag(isOpenImplied) {
+		const name = this.tagname;
+		this.endOpenTag(isOpenImplied);
+		if (this.stack[0] === name) this.popElement(!isOpenImplied);
+	}
+	/**
+	* @param start Start index for the current parser event.
+	* @param endIndex End index for the current parser event.
+	* @internal
+	*/
+	onattribname(start, endIndex) {
+		this.startIndex = start;
+		const name = this.getSlice(start, endIndex);
+		this.attribname = this.lowerCaseAttributeNames ? name.toLowerCase() : name;
+	}
+	/**
+	* @param start Start index for the current parser event.
+	* @param endIndex End index for the current parser event.
+	* @internal
+	*/
+	onattribdata(start, endIndex) {
+		this.attribvalue += this.getSlice(start, endIndex);
+	}
+	/**
+	* @param cp Current Unicode code point.
+	* @internal
+	*/
+	onattribentity(cp) {
+		this.attribvalue += fromCodePoint(cp);
+	}
+	/**
+	* @param quote Quote type used for the current attribute.
+	* @param endIndex End index for the current parser event.
+	* @internal
+	*/
+	onattribend(quote, endIndex) {
+		this.endIndex = endIndex;
+		this.cbs.onattribute?.(this.attribname, this.attribvalue, quote === QuoteType.Double ? "\"" : quote === QuoteType.Single ? "'" : quote === QuoteType.NoValue ? void 0 : null);
+		if (this.attribs && !Object.hasOwn(this.attribs, this.attribname)) this.attribs[this.attribname] = this.attribvalue;
+		this.attribvalue = "";
+	}
+	getInstructionName(value) {
+		const index = value.search(reNameEnd);
+		let name = index < 0 ? value : value.substr(0, index);
+		if (this.lowerCaseTagNames) name = name.toLowerCase();
+		return name;
+	}
+	/**
+	* @param start Start index for the current parser event.
+	* @param endIndex End index for the current parser event.
+	* @internal
+	*/
+	ondeclaration(start, endIndex) {
+		this.endIndex = endIndex;
+		const value = this.getSlice(start, endIndex);
+		if (this.cbs.onprocessinginstruction) {
+			const name = this.htmlMode ? this.lowerCaseTagNames ? DOCUMENT_TYPE : value.slice(0, 7) : this.getInstructionName(value);
+			this.cbs.onprocessinginstruction(`!${name}`, `!${value}`);
+		}
+		this.startIndex = endIndex + 1;
+	}
+	/**
+	* @param start Start index for the current parser event.
+	* @param endIndex End index for the current parser event.
+	* @internal
+	*/
+	onprocessinginstruction(start, endIndex) {
+		this.endIndex = endIndex;
+		const value = this.getSlice(start, endIndex);
+		if (this.cbs.onprocessinginstruction) {
+			const name = this.getInstructionName(value);
+			this.cbs.onprocessinginstruction(`?${name}`, `?${value}`);
+		}
+		this.startIndex = endIndex + 1;
+	}
+	/**
+	* @param start Start index for the current parser event.
+	* @param endIndex End index for the current parser event.
+	* @param offset Offset applied when computing parser indices.
+	* @internal
+	*/
+	oncomment(start, endIndex, offset) {
+		this.endIndex = endIndex;
+		this.cbs.oncomment?.(this.getSlice(start, endIndex - offset));
+		this.cbs.oncommentend?.();
+		this.startIndex = endIndex + 1;
+	}
+	/**
+	* @param start Start index for the current parser event.
+	* @param endIndex End index for the current parser event.
+	* @param offset Offset applied when computing parser indices.
+	* @internal
+	*/
+	oncdata(start, endIndex, offset) {
+		this.endIndex = endIndex;
+		const value = this.getSlice(start, endIndex - offset);
+		if (!this.htmlMode || this.options.recognizeCDATA) {
+			this.cbs.oncdatastart?.();
+			this.cbs.ontext?.(value);
+			this.cbs.oncdataend?.();
+		} else if (this.isInForeignContext()) this.cbs.ontext?.(value);
+		else {
+			this.cbs.oncomment?.(`[CDATA[${value}]]`);
+			this.cbs.oncommentend?.();
+		}
+		this.startIndex = endIndex + 1;
+	}
+	/** @internal */
+	onend() {
+		if (this.cbs.onclosetag) {
+			this.endIndex = this.startIndex;
+			for (let index = 0; index < this.stack.length; index++) this.cbs.onclosetag(this.stack[index], true);
+		}
+		this.cbs.onend?.();
+	}
+	/**
+	* Resets the parser to a blank state, ready to parse a new HTML document
+	*/
+	reset() {
+		this.cbs.onreset?.();
+		this.tokenizer.reset();
+		this.tagname = "";
+		this.attribname = "";
+		this.attribvalue = "";
+		this.attribs = null;
+		this.stack.length = 0;
+		this.startIndex = 0;
+		this.endIndex = 0;
+		this.cbs.onparserinit?.(this);
+		this.buffers.length = 0;
+		this.foreignContext.length = 0;
+		this.foreignContext.unshift(ForeignContext.None);
+		this.bufferOffset = 0;
+		this.writeIndex = 0;
+		this.ended = false;
+	}
+	/**
+	* Resets the parser, then parses a complete document and
+	* pushes it to the handler.
+	* @param data Document to parse.
+	*/
+	parseComplete(data) {
+		this.reset();
+		this.end(data);
+	}
+	getSlice(start, end) {
+		if (start === end) return "";
+		while (start - this.bufferOffset >= this.buffers[0].length) this.shiftBuffer();
+		let slice = this.buffers[0].slice(start - this.bufferOffset, end - this.bufferOffset);
+		while (end - this.bufferOffset > this.buffers[0].length) {
+			this.shiftBuffer();
+			slice += this.buffers[0].slice(0, end - this.bufferOffset);
+		}
+		return slice;
+	}
+	shiftBuffer() {
+		this.bufferOffset += this.buffers[0].length;
+		this.writeIndex--;
+		this.buffers.shift();
+	}
+	/**
+	* Parses a chunk of data and calls the corresponding callbacks.
+	* @param chunk Chunk to parse.
+	*/
+	write(chunk) {
+		if (this.ended) {
+			this.cbs.onerror?.(/* @__PURE__ */ new Error(".write() after done!"));
+			return;
+		}
+		this.buffers.push(chunk);
+		if (this.tokenizer.running) {
+			this.tokenizer.write(chunk);
+			this.writeIndex++;
+		}
+	}
+	/**
+	* Parses the end of the buffer and clears the stack, calls onend.
+	* @param chunk Optional final chunk to parse.
+	*/
+	end(chunk) {
+		if (this.ended) {
+			this.cbs.onerror?.(/* @__PURE__ */ new Error(".end() after done!"));
+			return;
+		}
+		if (chunk) this.write(chunk);
+		this.ended = true;
+		this.tokenizer.end();
+	}
+	/**
+	* Pauses parsing. The parser won't emit events until `resume` is called.
+	*/
+	pause() {
+		this.tokenizer.pause();
+	}
+	/**
+	* Resumes parsing after `pause` was called.
+	*/
+	resume() {
+		this.tokenizer.resume();
+		while (this.tokenizer.running && this.writeIndex < this.buffers.length) this.tokenizer.write(this.buffers[this.writeIndex++]);
+		if (this.ended) this.tokenizer.end();
+	}
+};
+//#endregion
+//#region src/extraction/source-filters.ts
+const HTML_ATTRIBUTE_NAME_CANDIDATE_RE$1 = /^(?:class|className|hover-class|hoverClass)$/;
+const CSS_DIRECTIVE_CANDIDATE_RE = /^@(?:apply|tailwind|source|config|plugin|theme|utility|custom-variant|variant)$/;
+const CSS_APPLY_IMPORTANT = "!important";
+const CLASS_LIKE_CANDIDATE_RE = /[:![\]#/%._\-\d]/;
+const JS_LIKE_SOURCE_EXTENSION_RE = /^[cm]?[jt]sx?$/;
+const MIXED_TEMPLATE_SOURCE_EXTENSION_RE = /^(?:vue|uvue|nvue|svelte|mpx)$/;
+const VUE_LIKE_SOURCE_EXTENSION_RE = /^(?:vue|uvue|nvue)$/;
+const CSS_LIKE_SOURCE_EXTENSION_RE = /^(?:css|wxss|acss|jxss|ttss|qss|tyss|scss|sass|less|styl|stylus)$/;
+function isWhitespace(value) {
+	return value === " " || value === "\n" || value === "\r" || value === "	" || value === "\f";
+}
+function isHtmlAttributeNameCandidate(content, candidate) {
+	if (!HTML_ATTRIBUTE_NAME_CANDIDATE_RE$1.test(candidate.rawCandidate)) return false;
+	let index = candidate.end;
+	while (isWhitespace(content[index])) index++;
+	return content[index] === "=";
+}
+function isInsideHtmlTagText(content, candidate) {
+	if (content.lastIndexOf("<", candidate.start) > content.lastIndexOf(">", candidate.start)) return false;
+	const nextOpen = content.indexOf("<", candidate.end);
+	return nextOpen !== -1 && (nextOpen < content.indexOf(">", candidate.end) || !content.includes(">", candidate.end));
+}
+function isCssDirectiveCandidate(candidate) {
+	return candidate === CSS_APPLY_IMPORTANT || CSS_DIRECTIVE_CANDIDATE_RE.test(candidate);
+}
+function isClassLikeCandidate(candidate) {
+	return CLASS_LIKE_CANDIDATE_RE.test(candidate);
+}
+function isCandidateInCssApplyParams(content, candidate) {
+	const apply = content.lastIndexOf("@apply", candidate.start);
+	if (apply === -1) return false;
+	const boundary = content.slice(apply + 6, candidate.start);
+	return !/[;{}]/.test(boundary);
+}
+function shouldKeepSourceCandidate(content, extension, candidate, jsStringStaticRanges, skipHtmlContextChecks = false) {
+	if (!candidate.rawCandidate || isCssDirectiveCandidate(candidate.rawCandidate)) return false;
+	if (CSS_LIKE_SOURCE_EXTENSION_RE.test(extension) && !isCandidateInCssApplyParams(content, candidate)) return false;
+	if (!skipHtmlContextChecks) {
+		if (isHtmlAttributeNameCandidate(content, candidate)) return false;
+		if (isInsideHtmlTagText(content, candidate)) return false;
+	}
+	if (JS_LIKE_SOURCE_EXTENSION_RE.test(extension) && !isCandidateInsideJsStringStaticRanges(jsStringStaticRanges ?? createJsStringStaticRanges(content), candidate.start)) return false;
+	return true;
+}
+function createLocalCandidate(candidate) {
+	return {
+		rawCandidate: candidate.rawCandidate,
+		start: candidate.localStart,
+		end: candidate.localStart + candidate.rawCandidate.length
+	};
+}
+function dedupeCandidatesWithPositions(candidates) {
+	const seen = /* @__PURE__ */ new Set();
+	return candidates.filter((candidate) => {
+		const key = `${candidate.start}:${candidate.end}:${candidate.rawCandidate}`;
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	});
+}
+//#endregion
+//#region src/extraction/sfc.ts
+const HTML_ATTRIBUTE_NAME_CANDIDATE_RE = /^(?:class|className|hover-class|hoverClass)$/;
+const HTML_BOUND_ATTRIBUTE_PREFIX_RE = /^(?::|v-bind:|bind:)/;
+const VUE_HTML_TEMPLATE_LANG_RE = /^(?:html)?$/i;
+const SFC_SCRIPT_BLOCK_RE = /<script\b[^>]*>([\s\S]*?)<\/script>/gi;
+const SFC_STYLE_BLOCK_RE = /<style\b[^>]*>([\s\S]*?)<\/style>/gi;
+const SFC_TEMPLATE_BLOCK_RE = /<template\b([^>]*)>([\s\S]*?)<\/template>/gi;
+const SFC_LANG_ATTRIBUTE_RE = /\blang\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+))/i;
+function normalizeVueBoundAttributeName(name) {
+	return name.replace(HTML_BOUND_ATTRIBUTE_PREFIX_RE, "");
+}
+function isVueClassAttributeNameCandidate(name) {
+	return HTML_ATTRIBUTE_NAME_CANDIDATE_RE.test(normalizeVueBoundAttributeName(name));
+}
+function isVueBoundAttributeName(name) {
+	return HTML_BOUND_ATTRIBUTE_PREFIX_RE.test(name);
+}
+function normalizeVueTemplateLang(lang) {
+	return lang?.trim().toLowerCase() ?? "";
+}
+function getSfcBlockLang(attributes) {
+	const match = SFC_LANG_ATTRIBUTE_RE.exec(attributes);
+	return normalizeVueTemplateLang(match?.[1] ?? match?.[2] ?? match?.[3]);
+}
+function isVueHtmlTemplateLang(lang) {
+	return VUE_HTML_TEMPLATE_LANG_RE.test(lang);
+}
+function findAttributeValueStart(attributeSource, value) {
+	const equalIndex = attributeSource.indexOf("=");
+	if (equalIndex === -1) return -1;
+	let valueStart = equalIndex + 1;
+	while (isWhitespace(attributeSource[valueStart])) valueStart++;
+	const quote = attributeSource[valueStart];
+	if (quote === "\"" || quote === "'") valueStart++;
+	const valueIndex = attributeSource.indexOf(value, valueStart);
+	return valueIndex === -1 ? valueStart : valueIndex;
+}
+async function extractJsStringSourceCandidates(content, offset, extractRawCandidatesWithPositions, options) {
+	return extractBatchedSourceSegmentCandidates(createJsStringSourceSegments(content, offset), "html", extractRawCandidatesWithPositions, options);
+}
+async function extractMixedSourceScriptCandidates(content, extractRawCandidatesWithPositions, options) {
+	const candidates = [];
+	SFC_SCRIPT_BLOCK_RE.lastIndex = 0;
+	let match = SFC_SCRIPT_BLOCK_RE.exec(content);
+	while (match !== null) {
+		const scriptContent = match[1] ?? "";
+		const scriptStart = match.index + match[0].indexOf(scriptContent);
+		candidates.push(...await extractJsStringSourceCandidates(scriptContent, scriptStart, extractRawCandidatesWithPositions, options));
+		match = SFC_SCRIPT_BLOCK_RE.exec(content);
+	}
+	return candidates;
+}
+async function extractMixedSourceStyleCandidates(content, extractRawCandidatesWithPositions, options) {
+	const candidates = [];
+	SFC_STYLE_BLOCK_RE.lastIndex = 0;
+	let match = SFC_STYLE_BLOCK_RE.exec(content);
+	while (match !== null) {
+		const styleContent = match[1] ?? "";
+		const styleStart = match.index + match[0].indexOf(styleContent);
+		const styleCandidates = await extractCssApplyCandidates(styleContent, "css", extractRawCandidatesWithPositions, options);
+		candidates.push(...styleCandidates.map((candidate) => ({
+			content: candidate.content,
+			extension: candidate.extension,
+			localStart: candidate.localStart,
+			rawCandidate: candidate.rawCandidate,
+			start: candidate.start + styleStart,
+			end: candidate.end + styleStart
+		})));
+		match = SFC_STYLE_BLOCK_RE.exec(content);
+	}
+	return candidates;
+}
+async function extractVueTemplateAttributeCandidates(content, extractRawCandidatesWithPositions, options) {
+	const htmlSegments = [];
+	const jsSegments = [];
+	const parser = new Parser({ onattribute(name, value) {
+		if (!value || !isVueClassAttributeNameCandidate(name)) return;
+		const attributeStart = parser.startIndex;
+		const valueStartInAttribute = findAttributeValueStart(content.slice(attributeStart, parser.endIndex + 1), value);
+		if (valueStartInAttribute === -1) return;
+		const extension = isVueBoundAttributeName(name) ? "js" : "html";
+		const valueStart = attributeStart + valueStartInAttribute;
+		(extension === "js" ? jsSegments : htmlSegments).push({
+			content: value,
+			start: valueStart
+		});
+	} }, { lowerCaseAttributeNames: false });
+	parser.write(content);
+	parser.end();
+	const jsStringSegments = jsSegments.flatMap((segment) => createJsStringSourceSegments(segment.content, segment.start));
+	const [htmlCandidates, jsCandidates] = await Promise.all([extractBatchedSourceSegmentCandidates(htmlSegments, "html", extractRawCandidatesWithPositions, options), extractBatchedSourceSegmentCandidates(jsStringSegments, "html", extractRawCandidatesWithPositions, options)]);
+	return [...htmlCandidates, ...jsCandidates];
+}
+async function extractVueNonHtmlTemplateCandidates(content, extractRawCandidatesWithPositions, options) {
+	const candidates = [];
+	SFC_TEMPLATE_BLOCK_RE.lastIndex = 0;
+	let match = SFC_TEMPLATE_BLOCK_RE.exec(content);
+	while (match !== null) {
+		const attributes = match[1] ?? "";
+		const templateContent = match[2] ?? "";
+		const lang = getSfcBlockLang(attributes);
+		if (isVueHtmlTemplateLang(lang)) {
+			match = SFC_TEMPLATE_BLOCK_RE.exec(content);
+			continue;
+		}
+		const templateStart = match.index + match[0].indexOf(templateContent);
+		const templateCandidates = await extractRawCandidatesWithPositions(templateContent, lang, options);
+		candidates.push(...templateCandidates.map((candidate) => ({
+			content: templateContent,
+			extension: lang,
+			localStart: candidate.start,
+			rawCandidate: candidate.rawCandidate,
+			skipHtmlContextChecks: true,
+			start: candidate.start + templateStart,
+			end: candidate.end + templateStart
+		})).filter((candidate) => isClassLikeCandidate(candidate.rawCandidate)));
+		match = SFC_TEMPLATE_BLOCK_RE.exec(content);
+	}
+	return candidates;
+}
+async function extractVueLikeSourceCandidates(content, extractRawCandidatesWithPositions, options) {
+	const [templateCandidates, preprocessedTemplateCandidates, scriptCandidates, styleCandidates] = await Promise.all([
+		extractVueTemplateAttributeCandidates(content, extractRawCandidatesWithPositions, options),
+		extractVueNonHtmlTemplateCandidates(content, extractRawCandidatesWithPositions, options),
+		extractMixedSourceScriptCandidates(content, extractRawCandidatesWithPositions, options),
+		extractMixedSourceStyleCandidates(content, extractRawCandidatesWithPositions, options)
+	]);
+	return [
+		...templateCandidates,
+		...preprocessedTemplateCandidates,
+		...scriptCandidates,
+		...styleCandidates
+	];
+}
+//#endregion
+//#region src/extraction/candidate-extractor/raw.ts
+async function extractRawCandidatesWithPositions(content, extension = "html", options) {
+	const { Scanner } = await getOxideModule();
+	const candidates = new Scanner({}).getCandidatesWithPositions({
+		content,
+		extension
+	}).map(({ candidate, position }) => ({
+		rawCandidate: candidate,
+		start: position,
+		end: position + candidate.length
+	}));
+	candidates.push(...extractBareArbitraryValueSourceCandidatesWithPositions(content, options?.bareArbitraryValues));
+	return dedupeCandidatesWithPositions(candidates);
+}
+async function extractSourceCandidatesWithPositions(content, extension = "html", options) {
+	const normalizedExtension = extension.replace(/^\./, "");
+	const candidates = VUE_LIKE_SOURCE_EXTENSION_RE.test(normalizedExtension) ? await extractVueLikeSourceCandidates(content, extractRawCandidatesWithPositions, options) : CSS_LIKE_SOURCE_EXTENSION_RE.test(normalizedExtension) ? await extractCssApplyCandidates(content, normalizedExtension, extractRawCandidatesWithPositions, options) : (await extractRawCandidatesWithPositions(content, normalizedExtension, options)).map((candidate) => ({
+		...candidate,
+		content,
+		extension: normalizedExtension,
+		localStart: candidate.start
+	}));
+	if (!VUE_LIKE_SOURCE_EXTENSION_RE.test(normalizedExtension) && MIXED_TEMPLATE_SOURCE_EXTENSION_RE.test(normalizedExtension)) candidates.push(...await extractMixedSourceScriptCandidates(content, extractRawCandidatesWithPositions, options));
+	const jsStringStaticRangesByContent = /* @__PURE__ */ new Map();
+	function getJsStringStaticRanges(candidate) {
+		if (!JS_LIKE_SOURCE_EXTENSION_RE.test(candidate.extension)) return;
+		const cached = jsStringStaticRangesByContent.get(candidate.content);
+		if (cached) return cached;
+		const ranges = createJsStringStaticRanges(candidate.content);
+		jsStringStaticRangesByContent.set(candidate.content, ranges);
+		return ranges;
+	}
+	const seen = /* @__PURE__ */ new Set();
+	return candidates.filter((candidate) => {
+		if (!shouldKeepSourceCandidate(candidate.content, candidate.extension, createLocalCandidate(candidate), getJsStringStaticRanges(candidate), candidate.skipHtmlContextChecks)) return false;
+		const key = `${candidate.start}:${candidate.end}:${candidate.rawCandidate}`;
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	}).map(({ rawCandidate, start, end }) => ({
+		rawCandidate,
+		start,
+		end
+	}));
+}
+async function extractSourceCandidates(content, extension = "html", options) {
+	const candidates = await extractSourceCandidatesWithPositions(content, extension, options);
+	return [...new Set(candidates.map((candidate) => candidate.rawCandidate))];
+}
+async function extractRawCandidates(sources, options) {
+	const { Scanner } = await getOxideModule();
+	const scanner = new Scanner(sources === void 0 ? {} : { sources });
+	const files = scanner.files ?? [];
+	const cacheKey = createRawCandidateCacheKey(sources, options);
+	const fingerprint = await createRawCandidateFileFingerprint(files);
+	const cached = getRawCandidateCacheEntry(cacheKey, fingerprint);
+	if (cached) return [...cached.candidates];
+	const scannedCandidates = scanner.scan();
+	if (scannedCandidates.length === 0 && files.length > 0) {
+		const changedContents = (await Promise.all(files.map(async (file) => {
+			try {
+				return {
+					content: await node_fs.promises.readFile(file, "utf8"),
+					extension: toExtension(file)
+				};
+			} catch {
+				return;
+			}
+		}))).filter((entry) => entry !== void 0);
+		scannedCandidates.push(...scanner.scanFiles(changedContents));
+	}
+	const candidates = new Set(scannedCandidates);
+	if (options?.bareArbitraryValues !== void 0 && options.bareArbitraryValues !== false) await Promise.all(files.map(async (file) => {
+		try {
+			const content = await node_fs.promises.readFile(file, "utf8");
+			const extension = toExtension(file);
+			const jsStringStaticRanges = JS_LIKE_SOURCE_EXTENSION_RE.test(extension) ? createJsStringStaticRanges(content) : void 0;
+			for (const candidate of extractBareArbitraryValueSourceCandidatesWithPositions(content, options.bareArbitraryValues)) if (shouldKeepSourceCandidate(content, extension, candidate, jsStringStaticRanges)) candidates.add(candidate.rawCandidate);
+		} catch {}
+	}));
+	const result = [...candidates];
+	setRawCandidateCacheEntry(cacheKey, fingerprint, result);
+	return [...result];
+}
+//#endregion
+//#region src/v4/candidates/inline-source.ts
+function splitTopLevel(value, separator, options) {
+	const result = [];
+	let start = 0;
+	let depth = 0;
+	let quote;
+	for (let index = 0; index < value.length; index++) {
+		const character = value[index];
+		if (character === "\\") {
+			index++;
+			continue;
+		}
+		if (quote) {
+			if (character === quote) quote = void 0;
+			continue;
+		}
+		if (character === "\"" || character === "'") {
+			quote = character;
+			continue;
+		}
+		if (character === "(" || character === "[" || character === "{") {
+			depth++;
+			continue;
+		}
+		if (character === ")" || character === "]" || character === "}") {
+			depth = Math.max(0, depth - 1);
+			continue;
+		}
+		if (depth === 0 && character === separator) {
+			const item = value.slice(start, index).trim();
+			if (item || options?.keepEmpty) result.push(item);
+			start = index + 1;
+		}
+	}
+	const item = value.slice(start).trim();
+	if (item || options?.keepEmpty) result.push(item);
+	return result;
+}
+const sequencePattern = /^(-?\d+)\.\.(-?\d+)(?:\.\.(-?\d+))?$/;
+function expandSequence(value) {
+	const match = value.match(sequencePattern);
+	if (!match) return [value];
+	const [, startValue, endValue, stepValue] = match;
+	if (startValue === void 0 || endValue === void 0) return [value];
+	const start = Number.parseInt(startValue, 10);
+	const end = Number.parseInt(endValue, 10);
+	let step = stepValue === void 0 ? start <= end ? 1 : -1 : Number.parseInt(stepValue, 10);
+	if (step === 0) throw new Error("Step cannot be zero in Tailwind CSS v4 inline source sequence.");
+	const ascending = start < end;
+	if (ascending && step < 0) step = -step;
+	if (!ascending && step > 0) step = -step;
+	const result = [];
+	for (let current = start; ascending ? current <= end : current >= end; current += step) result.push(current.toString());
+	return result;
+}
+function expandInlinePattern(pattern) {
+	const openIndex = pattern.indexOf("{");
+	if (openIndex === -1) return [pattern];
+	const prefix = pattern.slice(0, openIndex);
+	const rest = pattern.slice(openIndex);
+	let depth = 0;
+	let closeIndex = -1;
+	for (let index = 0; index < rest.length; index++) {
+		const character = rest[index];
+		if (character === "{") depth++;
+		else if (character === "}") {
+			depth--;
+			if (depth === 0) {
+				closeIndex = index;
+				break;
+			}
+		}
+	}
+	if (closeIndex === -1) throw new Error(`The Tailwind CSS v4 inline source pattern "${pattern}" is not balanced.`);
+	const body = rest.slice(1, closeIndex);
+	const suffix = rest.slice(closeIndex + 1);
+	const parts = sequencePattern.test(body) ? expandSequence(body) : splitTopLevel(body, ",", { keepEmpty: true }).flatMap((part) => expandInlinePattern(part));
+	const suffixes = expandInlinePattern(suffix);
+	const result = [];
+	for (const part of parts) for (const expandedSuffix of suffixes) result.push(`${prefix}${part}${expandedSuffix}`);
+	return result;
+}
+function unquoteCssString(value) {
+	const quote = value[0];
+	if (quote !== "\"" && quote !== "'" || value[value.length - 1] !== quote) return;
+	let result = "";
+	for (let index = 1; index < value.length - 1; index++) {
+		const character = value[index];
+		if (character === "\\") {
+			index++;
+			result += value[index] ?? "";
+			continue;
+		}
+		result += character;
+	}
+	return result;
+}
+function extractTailwindV4InlineSourceCandidates(css) {
+	const included = /* @__PURE__ */ new Set();
+	const excluded = /* @__PURE__ */ new Set();
+	postcss.default.parse(css).walkAtRules("source", (rule) => {
+		let params = rule.params.trim();
+		if (!params) return;
+		let negated = false;
+		if (params.startsWith("not ")) {
+			negated = true;
+			params = params.slice(4).trim();
+		}
+		if (!params.startsWith("inline(") || !params.endsWith(")")) return;
+		const inlineValue = unquoteCssString(params.slice(7, -1).trim());
+		if (inlineValue === void 0) return;
+		const target = negated ? excluded : included;
+		for (const part of splitTopLevel(inlineValue, " ")) for (const candidate of expandInlinePattern(part)) target.add(candidate);
+	});
+	return {
+		included,
+		excluded
+	};
+}
+//#endregion
+//#region src/v4/candidates.ts
+function resolveValidTailwindV4Candidates(designSystem, candidates, options) {
+	const validCandidates = /* @__PURE__ */ new Set();
+	const parsedCandidates = [];
+	const originalCandidatesByCanonical = /* @__PURE__ */ new Map();
+	for (const candidate of candidates) {
+		if (!candidate) continue;
+		const bareArbitrary = resolveBareArbitraryValueCandidate(candidate, options?.bareArbitraryValues);
+		const candidateToCheck = bareArbitrary?.canonicalCandidate ?? candidate;
+		if (bareArbitrary) {
+			const originalCandidates = originalCandidatesByCanonical.get(candidateToCheck) ?? /* @__PURE__ */ new Set();
+			originalCandidates.add(candidate);
+			originalCandidatesByCanonical.set(candidateToCheck, originalCandidates);
+		}
+		if (parsedCandidates.includes(candidateToCheck)) continue;
+		if (designSystem.parseCandidate(candidateToCheck).length > 0) parsedCandidates.push(candidateToCheck);
+	}
+	if (parsedCandidates.length === 0) return validCandidates;
+	const cssByCandidate = designSystem.candidatesToCss(parsedCandidates);
+	for (let index = 0; index < parsedCandidates.length; index++) {
+		const candidate = parsedCandidates[index];
+		const candidateCss = cssByCandidate[index];
+		if (candidate && typeof candidateCss === "string" && candidateCss.trim().length > 0) {
+			const originalCandidates = originalCandidatesByCanonical.get(candidate);
+			if (originalCandidates) {
+				for (const originalCandidate of originalCandidates) validCandidates.add(originalCandidate);
+				continue;
+			}
+			validCandidates.add(candidate);
+		}
+	}
+	return validCandidates;
+}
+function createSelectorAliasMap(candidates, options) {
+	const aliases = /* @__PURE__ */ new Map();
+	for (const candidate of candidates) {
+		const bareArbitrary = resolveBareArbitraryValueCandidate(candidate, options);
+		if (!bareArbitrary) continue;
+		const canonicalSelector = escapeCssClassName(bareArbitrary.canonicalCandidate);
+		const bareSelectors = aliases.get(canonicalSelector) ?? /* @__PURE__ */ new Set();
+		bareSelectors.add(escapeCssClassName(bareArbitrary.candidate));
+		aliases.set(canonicalSelector, bareSelectors);
+	}
+	return aliases;
+}
+function replaceBareArbitraryValueSelectors(css, candidates, options) {
+	const aliases = createSelectorAliasMap(candidates, options);
+	if (aliases.size === 0) return css;
+	if (Array.from(aliases.values()).every((bareSelectors) => bareSelectors.size === 1)) {
+		let result = css;
+		for (const [canonicalSelector, bareSelectors] of aliases) {
+			const bareSelector = Array.from(bareSelectors)[0];
+			if (bareSelector !== void 0) result = result.replaceAll(canonicalSelector, bareSelector);
+		}
+		return result;
+	}
+	const root = postcss.default.parse(css);
+	root.walkRules((rule) => {
+		let selectors = rule.selectors;
+		for (const [canonicalSelector, bareSelectors] of aliases) selectors = selectors.flatMap((selector) => {
+			if (!selector.includes(canonicalSelector)) return selector;
+			return Array.from(bareSelectors, (bareSelector) => selector.replaceAll(canonicalSelector, bareSelector));
+		});
+		rule.selectors = selectors;
+	});
+	return root.toString();
+}
+function canonicalizeBareArbitraryValueCandidates(candidates, options) {
+	return Array.from(candidates, (candidate) => {
+		return resolveBareArbitraryValueCandidate(candidate, options)?.canonicalCandidate ?? candidate;
+	});
+}
+//#endregion
+//#region src/style-candidates.ts
+async function collectTailwindStyleCandidates(options = {}) {
+	const candidates = /* @__PURE__ */ new Set();
+	for (const candidate of options.candidates ?? []) candidates.add(candidate);
+	const extractOptions = options.bareArbitraryValues === void 0 ? {} : { bareArbitraryValues: options.bareArbitraryValues };
+	for (const source of options.sources ?? []) {
+		const sourceCandidates = await extractSourceCandidates(source.content, source.extension, extractOptions);
+		for (const candidate of sourceCandidates) candidates.add(candidate);
+	}
+	return candidates;
+}
+//#endregion
+//#region src/v4/generation-artifact.ts
+function cloneSourceEntry(sourceEntry) {
+	return {
+		id: sourceEntry.id,
+		content: sourceEntry.content,
+		...sourceEntry.extension === void 0 ? {} : { extension: sourceEntry.extension }
+	};
+}
+function cloneTailwindGenerationArtifact(artifact) {
+	return {
+		fragments: artifact.fragments.map((fragment) => ({
+			...fragment,
+			root: fragment.root.clone()
+		})),
+		classSet: new Set(artifact.classSet),
+		rawCandidates: new Set(artifact.rawCandidates),
+		dependencies: [...artifact.dependencies],
+		sourceEntries: artifact.sourceEntries.map(cloneSourceEntry)
+	};
+}
+function createTailwindGenerationArtifact(css, source, request, classSet, rawCandidates, dependencies) {
+	const sourceId = source.dependencies[0] ?? source.base;
+	return {
+		fragments: [{
+			id: `${sourceId}:tailwind`,
+			kind: "tailwind",
+			root: postcss.default.parse(css, { from: sourceId }),
+			sourceId,
+			order: 0
+		}],
+		classSet: new Set(classSet),
+		rawCandidates: new Set(rawCandidates),
+		dependencies: [...dependencies],
+		sourceEntries: (request.sourceEntries ?? []).map(cloneSourceEntry)
+	};
+}
+//#endregion
+//#region src/v4/generation-request.ts
+function toGenerationRequest(options) {
+	return {
+		...options?.candidates === void 0 ? {} : { candidates: options.candidates },
+		...options?.sources === void 0 ? {} : { sourceEntries: options.sources.map((sourceEntry, index) => ({
+			id: `source:${index}`,
+			...sourceEntry
+		})) },
+		...options?.bareArbitraryValues === void 0 ? {} : { bareArbitraryValues: options.bareArbitraryValues },
+		...options?.scanSources === void 0 ? {} : { scanSources: options.scanSources }
+	};
+}
+function toGenerateOptions(request) {
+	return {
+		...request.candidates === void 0 ? {} : { candidates: request.candidates },
+		...request.sourceEntries === void 0 ? {} : { sources: request.sourceEntries },
+		...request.bareArbitraryValues === void 0 ? {} : { bareArbitraryValues: request.bareArbitraryValues },
+		...request.scanSources === void 0 ? {} : { scanSources: request.scanSources }
+	};
+}
+function resolveScanSources(options, source, compiledRoot, compiledSources) {
+	if (Array.isArray(options?.scanSources)) return options.scanSources;
+	if (options?.scanSources === true) return createTailwindV4CompiledSourceEntries(compiledRoot, compiledSources, source.base);
+	return [];
+}
+function shouldCompileSourceEntries(options) {
+	return options?.scanSources === true;
+}
+function stripCompiledSourceEntries(source) {
+	if (!source.css.includes("@source") && !source.css.includes("source(")) return source;
+	try {
+		const root = postcss.default.parse(source.css);
+		let changed = false;
+		root.walkAtRules((rule) => {
+			if (rule.name === "source") {
+				rule.remove();
+				changed = true;
+				return;
+			}
+			if (rule.name === "import" && /\bsource\(/.test(rule.params)) {
+				rule.params = rule.params.replace(/\s+source\((?:[^()]|\([^()]*\))*\)/g, "");
+				changed = true;
+			}
+		});
+		return changed ? {
+			...source,
+			css: root.toString()
+		} : source;
+	} catch {
+		return source;
+	}
+}
+async function collectRawCandidates(source, options, compiledRoot, compiledSources = []) {
+	const rawCandidates = /* @__PURE__ */ new Set();
+	const extractOptions = options?.bareArbitraryValues === void 0 ? void 0 : { bareArbitraryValues: options.bareArbitraryValues };
+	for (const candidate of options?.candidates ?? []) rawCandidates.add(candidate);
+	for (const candidateSource of options?.sources ?? []) {
+		const candidates = await extractRawCandidatesWithPositions(candidateSource.content, candidateSource.extension, extractOptions);
+		for (const candidate of candidates) rawCandidates.add(candidate.rawCandidate);
+	}
+	const filesystemSources = resolveScanSources(options, source, compiledRoot, compiledSources);
+	if (filesystemSources.length > 0) for (const candidate of await extractRawCandidates(filesystemSources, extractOptions)) rawCandidates.add(candidate);
+	const inlineSources = extractTailwindV4InlineSourceCandidates(source.css);
+	for (const candidate of inlineSources.included) rawCandidates.add(candidate);
+	for (const candidate of inlineSources.excluded) rawCandidates.delete(candidate);
+	return rawCandidates;
+}
+//#endregion
+//#region src/v4/generation-session.ts
+var TailwindGenerationSessionImpl = class {
+	currentSource;
+	runtimes = /* @__PURE__ */ new Map();
+	designSystemPromise;
+	disposed = false;
+	constructor(source) {
+		this.currentSource = source;
+	}
+	get source() {
+		return this.currentSource;
+	}
+	async generate(request = {}) {
+		const generated = await this.generateInternal(request);
+		return cloneTailwindGenerationArtifact(createTailwindGenerationArtifact(generated.css, this.currentSource, request, generated.classSet, generated.rawCandidates, generated.dependencies));
+	}
+	async generateLegacy(options) {
+		const generated = await this.generateInternal(toGenerationRequest(options));
+		return {
+			css: generated.css,
+			classSet: generated.classSet,
+			rawCandidates: generated.rawCandidates,
+			dependencies: generated.dependencies,
+			sources: generated.sources,
+			root: generated.root
+		};
+	}
+	loadDesignSystem() {
+		this.assertActive();
+		this.designSystemPromise ??= loadTailwindV4DesignSystem(this.currentSource, { cache: false });
+		return this.designSystemPromise;
+	}
+	async validateCandidates(candidates) {
+		return resolveValidTailwindV4Candidates(await this.loadDesignSystem(), candidates);
+	}
+	invalidate(change) {
+		if (this.disposed) return;
+		if (change.type === "source") this.currentSource = change.source;
+		this.runtimes.clear();
+		this.designSystemPromise = void 0;
+	}
+	dispose() {
+		this.runtimes.clear();
+		this.designSystemPromise = void 0;
+		this.disposed = true;
+	}
+	assertActive() {
+		if (this.disposed) throw new Error("Tailwind generation session has been disposed.");
+	}
+	getRuntime(compileSourceEntries) {
+		this.assertActive();
+		const cached = this.runtimes.get(compileSourceEntries);
+		if (cached) return cached;
+		const source = compileSourceEntries ? this.currentSource : stripCompiledSourceEntries(this.currentSource);
+		const promise = Promise.all([compileTailwindV4Source(source), loadTailwindV4DesignSystem(source, { cache: false })]).then(([compiledSource, designSystem]) => ({
+			compiled: compiledSource.compiled,
+			dependencies: compiledSource.dependencies,
+			designSystem,
+			builtCandidates: /* @__PURE__ */ new Set()
+		}));
+		this.runtimes.set(compileSourceEntries, promise);
+		promise.catch(() => {
+			if (this.runtimes.get(compileSourceEntries) === promise) this.runtimes.delete(compileSourceEntries);
+		});
+		return promise;
+	}
+	async resetRuntime(compileSourceEntries) {
+		this.runtimes.delete(compileSourceEntries);
+		return this.getRuntime(compileSourceEntries);
+	}
+	async generateInternal(request) {
+		this.assertActive();
+		const options = toGenerateOptions(request);
+		const compileSourceEntries = shouldCompileSourceEntries(options);
+		let runtime = await this.getRuntime(compileSourceEntries);
+		const rawCandidates = await collectRawCandidates(this.currentSource, options, runtime.compiled.root, runtime.compiled.sources);
+		const classSet = resolveValidTailwindV4Candidates(runtime.designSystem, rawCandidates, { ...options.bareArbitraryValues === void 0 ? {} : { bareArbitraryValues: options.bareArbitraryValues } });
+		const inlineSources = extractTailwindV4InlineSourceCandidates(this.currentSource.css);
+		for (const candidate of inlineSources.excluded) classSet.delete(candidate);
+		const buildCandidates = new Set(canonicalizeBareArbitraryValueCandidates(classSet, options.bareArbitraryValues));
+		if ([...runtime.builtCandidates].some((candidate) => !buildCandidates.has(candidate))) runtime = await this.resetRuntime(compileSourceEntries);
+		const css = replaceBareArbitraryValueSelectors(runtime.compiled.build([...buildCandidates]), classSet, options.bareArbitraryValues);
+		runtime.builtCandidates = new Set(buildCandidates);
+		return {
+			css,
+			classSet,
+			rawCandidates,
+			dependencies: Array.from(runtime.dependencies),
+			sources: runtime.compiled.sources,
+			root: runtime.compiled.root
+		};
+	}
+};
+function createTailwindGenerationSession(source) {
+	return new TailwindGenerationSessionImpl(source);
+}
+function createTailwindV4EngineGenerationSession(source) {
+	return new TailwindGenerationSessionImpl(source);
+}
+//#endregion
+//#region src/v4/engine.ts
+function createTailwindV4Engine(source) {
+	const session = createTailwindV4EngineGenerationSession(source);
+	return {
+		source,
+		loadDesignSystem() {
+			return session.loadDesignSystem();
+		},
+		async validateCandidates(candidates) {
+			return session.validateCandidates(candidates);
+		},
+		generate(options) {
+			return session.generateLegacy(options);
+		}
+	};
+}
+//#endregion
+//#region src/v4/source.ts
+function resolveBase(value, fallback) {
+	return value === void 0 ? fallback : node_path.default.isAbsolute(value) ? node_path.default.resolve(value) : node_path.default.resolve(fallback, value);
+}
+function uniquePaths(values) {
+	const result = [];
+	for (const value of values) {
+		if (!value) continue;
+		const resolved = node_path.default.resolve(value);
+		if (!result.includes(resolved)) result.push(resolved);
+	}
+	return result;
+}
+function toCssImportPath(value) {
+	return value.replaceAll("\\", "/");
+}
+function quoteCssImport(value) {
+	return value.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"");
+}
+function isPostcssPluginSpecifier(packageName) {
+	return packageName === "@tailwindcss/postcss" || /(?:^|[/\\])@tailwindcss[/\\]postcss(?:[/\\]|$)/.test(packageName) || /(?:^|[/\\])postcss(?:[/\\]|$)/i.test(packageName) || /postcss\.config\.[cm]?[jt]s$/i.test(packageName);
+}
+function createDefaultCss(packageName) {
+	return `@import "${quoteCssImport(toCssImportPath(packageName && !isPostcssPluginSpecifier(packageName) ? packageName : "tailwindcss"))}";`;
+}
+async function pathExists(filePath) {
+	try {
+		await node_fs.promises.access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function resolveCssEntries(entries, projectRoot, base) {
+	const resolvedEntries = entries.map((entry) => ({
+		original: entry,
+		absolute: node_path.default.isAbsolute(entry) ? node_path.default.resolve(entry) : node_path.default.resolve(projectRoot, entry)
+	}));
+	const resolvedBase = base ?? node_path.default.dirname(resolvedEntries[0]?.absolute ?? projectRoot);
+	const dependencies = resolvedEntries.map((entry) => entry.absolute);
+	const cssParts = [];
+	for (const entry of resolvedEntries) {
+		if (await pathExists(entry.absolute)) {
+			cssParts.push(await node_fs.promises.readFile(entry.absolute, "utf8"));
+			continue;
+		}
+		const importPath = node_path.default.isAbsolute(entry.original) ? entry.absolute : node_path.default.relative(resolvedBase, entry.absolute);
+		cssParts.push(`@import "${quoteCssImport(toCssImportPath(importPath))}";`);
+	}
+	return {
+		base: resolvedBase,
+		css: cssParts.join("\n"),
+		dependencies
+	};
+}
+function resolveCssSources(sources, projectRoot, base) {
+	const resolvedSources = sources.map((source) => ({
+		...source,
+		base: source.base === void 0 ? void 0 : resolveBase(source.base, projectRoot),
+		file: source.file === void 0 ? void 0 : node_path.default.isAbsolute(source.file) ? node_path.default.resolve(source.file) : node_path.default.resolve(projectRoot, source.file),
+		dependencies: source.dependencies?.map((dependency) => node_path.default.isAbsolute(dependency) ? node_path.default.resolve(dependency) : node_path.default.resolve(projectRoot, dependency)) ?? []
+	}));
+	const firstSource = resolvedSources[0];
+	const resolvedBase = base ?? firstSource?.base ?? (firstSource?.file ? node_path.default.dirname(firstSource.file) : projectRoot);
+	const dependencies = resolvedSources.flatMap((source) => [source.file, ...source.dependencies]).filter((dependency) => Boolean(dependency));
+	return {
+		base: resolvedBase,
+		css: resolvedSources.map((source) => source.css).join("\n"),
+		dependencies
+	};
+}
+function normalizeResolvedSource(source) {
+	const baseFallbacks = uniquePaths([
+		...source.baseFallbacks,
+		source.projectRoot,
+		source.cwd
+	]).filter((base) => base !== source.base);
+	return {
+		projectRoot: source.projectRoot,
+		base: source.base,
+		baseFallbacks,
+		css: source.css,
+		dependencies: Array.from(new Set(source.dependencies.map((dependency) => node_path.default.resolve(dependency))))
+	};
+}
+async function resolveTailwindV4Source(options = {}) {
+	const projectRoot = resolveBase(options.projectRoot, node_process.default.cwd());
+	const cwd = resolveBase(options.cwd, projectRoot);
+	const configuredBase = options.base === void 0 ? void 0 : resolveBase(options.base, projectRoot);
+	const baseFallbacks = uniquePaths(options.baseFallbacks?.map((base) => resolveBase(base, projectRoot)) ?? []);
+	if (options.css !== void 0) return normalizeResolvedSource({
+		projectRoot,
+		cwd,
+		base: configuredBase ?? cwd,
+		baseFallbacks,
+		css: options.css,
+		dependencies: []
+	});
+	if (options.cssEntries?.length || options.cssSources?.length) {
+		const entries = options.cssEntries?.length ? await resolveCssEntries(options.cssEntries, projectRoot, configuredBase) : void 0;
+		const sources = options.cssSources?.length ? resolveCssSources(options.cssSources, projectRoot, configuredBase) : void 0;
+		const css = [entries?.css, sources?.css].filter(Boolean).join("\n");
+		return normalizeResolvedSource({
+			projectRoot,
+			cwd,
+			base: configuredBase ?? entries?.base ?? sources?.base ?? cwd,
+			baseFallbacks,
+			css,
+			dependencies: [...entries?.dependencies ?? [], ...sources?.dependencies ?? []]
+		});
+	}
+	return normalizeResolvedSource({
+		projectRoot,
+		cwd,
+		base: configuredBase ?? cwd,
+		baseFallbacks,
+		css: createDefaultCss(options.packageName),
+		dependencies: []
+	});
+}
+//#endregion
+//#region src/v4/style-generator.ts
+function createSourceOptions(options) {
+	return {
+		...options.projectRoot === void 0 ? {} : { projectRoot: options.projectRoot },
+		...options.cwd === void 0 ? {} : { cwd: options.cwd },
+		...options.base === void 0 ? {} : { base: options.base },
+		...options.baseFallbacks === void 0 ? {} : { baseFallbacks: options.baseFallbacks },
+		...options.css === void 0 ? {} : { css: options.css },
+		...options.cssSources === void 0 ? {} : { cssSources: options.cssSources },
+		...options.cssEntries === void 0 ? {} : { cssEntries: options.cssEntries },
+		...options.packageName === void 0 ? {} : { packageName: options.packageName }
+	};
+}
+async function collectTailwindV4StyleCandidates(options) {
+	return collectTailwindStyleCandidates({
+		...options.bareArbitraryValues === void 0 ? {} : { bareArbitraryValues: options.bareArbitraryValues },
+		...options.candidates === void 0 ? {} : { candidates: options.candidates },
+		...options.sources === void 0 ? {} : { sources: options.sources }
+	});
+}
+async function generateTailwindV4Style(options = {}) {
+	const source = options.source ?? await resolveTailwindV4Source(createSourceOptions(options));
+	const candidates = await collectTailwindV4StyleCandidates(options);
+	const result = await createTailwindV4Engine(source).generate({
+		candidates,
+		...options.bareArbitraryValues === void 0 ? {} : { bareArbitraryValues: options.bareArbitraryValues },
+		...options.scanSources === void 0 ? {} : { scanSources: options.scanSources }
+	});
+	return {
+		...result,
+		tokens: result.rawCandidates,
+		source
+	};
+}
+//#endregion
+Object.defineProperty(exports, "TAILWIND_V4_AUTO_SOURCE_SCAN_PATTERN", {
+	enumerable: true,
+	get: function() {
+		return TAILWIND_V4_AUTO_SOURCE_SCAN_PATTERN;
+	}
+});
+Object.defineProperty(exports, "TAILWIND_V4_IGNORED_CONTENT_DIRS", {
+	enumerable: true,
+	get: function() {
+		return TAILWIND_V4_IGNORED_CONTENT_DIRS;
+	}
+});
+Object.defineProperty(exports, "TAILWIND_V4_IGNORED_EXTENSIONS", {
+	enumerable: true,
+	get: function() {
+		return TAILWIND_V4_IGNORED_EXTENSIONS;
+	}
+});
+Object.defineProperty(exports, "TAILWIND_V4_IGNORED_FILES", {
+	enumerable: true,
+	get: function() {
+		return TAILWIND_V4_IGNORED_FILES;
+	}
+});
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});
+Object.defineProperty(exports, "buildLineOffsets", {
+	enumerable: true,
+	get: function() {
+		return buildLineOffsets;
+	}
+});
+Object.defineProperty(exports, "canonicalizeBareArbitraryValueCandidates", {
+	enumerable: true,
+	get: function() {
+		return canonicalizeBareArbitraryValueCandidates;
+	}
+});
+Object.defineProperty(exports, "collectTailwindStyleCandidates", {
+	enumerable: true,
+	get: function() {
+		return collectTailwindStyleCandidates;
+	}
+});
+Object.defineProperty(exports, "collectTailwindV4StyleCandidates", {
+	enumerable: true,
+	get: function() {
+		return collectTailwindV4StyleCandidates;
+	}
+});
+Object.defineProperty(exports, "compileTailwindV4Source", {
+	enumerable: true,
+	get: function() {
+		return compileTailwindV4Source;
+	}
+});
+Object.defineProperty(exports, "createTailwindGenerationSession", {
+	enumerable: true,
+	get: function() {
+		return createTailwindGenerationSession;
+	}
+});
+Object.defineProperty(exports, "createTailwindV4CompiledSourceEntries", {
+	enumerable: true,
+	get: function() {
+		return createTailwindV4CompiledSourceEntries;
+	}
+});
+Object.defineProperty(exports, "createTailwindV4DefaultIgnoreSources", {
+	enumerable: true,
+	get: function() {
+		return createTailwindV4DefaultIgnoreSources;
+	}
+});
+Object.defineProperty(exports, "createTailwindV4Engine", {
+	enumerable: true,
+	get: function() {
+		return createTailwindV4Engine;
+	}
+});
+Object.defineProperty(exports, "createTailwindV4RootSources", {
+	enumerable: true,
+	get: function() {
+		return createTailwindV4RootSources;
+	}
+});
+Object.defineProperty(exports, "createTailwindV4SourceEntryMatcher", {
+	enumerable: true,
+	get: function() {
+		return createTailwindV4SourceEntryMatcher;
+	}
+});
+Object.defineProperty(exports, "createTailwindV4SourceExclusionMatcher", {
+	enumerable: true,
+	get: function() {
+		return createTailwindV4SourceExclusionMatcher;
+	}
+});
+Object.defineProperty(exports, "createTokenLocation", {
+	enumerable: true,
+	get: function() {
+		return createTokenLocation;
+	}
+});
+Object.defineProperty(exports, "escapeCssClassName", {
+	enumerable: true,
+	get: function() {
+		return escapeCssClassName;
+	}
+});
+Object.defineProperty(exports, "expandTailwindV4SourceEntries", {
+	enumerable: true,
+	get: function() {
+		return expandTailwindV4SourceEntries;
+	}
+});
+Object.defineProperty(exports, "expandTailwindV4SourceEntryBraces", {
+	enumerable: true,
+	get: function() {
+		return expandTailwindV4SourceEntryBraces;
+	}
+});
+Object.defineProperty(exports, "extractBareArbitraryValueSourceCandidates", {
+	enumerable: true,
+	get: function() {
+		return extractBareArbitraryValueSourceCandidates;
+	}
+});
+Object.defineProperty(exports, "extractBareArbitraryValueSourceCandidatesWithPositions", {
+	enumerable: true,
+	get: function() {
+		return extractBareArbitraryValueSourceCandidatesWithPositions;
+	}
+});
+Object.defineProperty(exports, "extractRawCandidates", {
+	enumerable: true,
+	get: function() {
+		return extractRawCandidates;
+	}
+});
+Object.defineProperty(exports, "extractRawCandidatesWithPositions", {
+	enumerable: true,
+	get: function() {
+		return extractRawCandidatesWithPositions;
+	}
+});
+Object.defineProperty(exports, "extractSourceCandidates", {
+	enumerable: true,
+	get: function() {
+		return extractSourceCandidates;
+	}
+});
+Object.defineProperty(exports, "extractSourceCandidatesWithPositions", {
+	enumerable: true,
+	get: function() {
+		return extractSourceCandidatesWithPositions;
+	}
+});
+Object.defineProperty(exports, "extractTailwindV4InlineSourceCandidates", {
+	enumerable: true,
+	get: function() {
+		return extractTailwindV4InlineSourceCandidates;
+	}
+});
+Object.defineProperty(exports, "generateTailwindV4Style", {
+	enumerable: true,
+	get: function() {
+		return generateTailwindV4Style;
+	}
+});
+Object.defineProperty(exports, "getOxideModule", {
+	enumerable: true,
+	get: function() {
+		return getOxideModule;
+	}
+});
+Object.defineProperty(exports, "getTailwindV4DesignSystemCacheKey", {
+	enumerable: true,
+	get: function() {
+		return getTailwindV4DesignSystemCacheKey;
+	}
+});
+Object.defineProperty(exports, "groupTailwindV4SourceEntriesByBase", {
+	enumerable: true,
+	get: function() {
+		return groupTailwindV4SourceEntriesByBase;
+	}
+});
+Object.defineProperty(exports, "isBareArbitraryValuesEnabled", {
+	enumerable: true,
+	get: function() {
+		return isBareArbitraryValuesEnabled;
+	}
+});
+Object.defineProperty(exports, "isFileExcludedByTailwindV4SourceEntries", {
+	enumerable: true,
+	get: function() {
+		return isFileExcludedByTailwindV4SourceEntries;
+	}
+});
+Object.defineProperty(exports, "isFileMatchedByTailwindV4SourceEntries", {
+	enumerable: true,
+	get: function() {
+		return isFileMatchedByTailwindV4SourceEntries;
+	}
+});
+Object.defineProperty(exports, "loadTailwindV4DesignSystem", {
+	enumerable: true,
+	get: function() {
+		return loadTailwindV4DesignSystem;
+	}
+});
+Object.defineProperty(exports, "loadTailwindV4NodeModule", {
+	enumerable: true,
+	get: function() {
+		return loadTailwindV4NodeModule;
+	}
+});
+Object.defineProperty(exports, "mergeTailwindV4SourceEntries", {
+	enumerable: true,
+	get: function() {
+		return mergeTailwindV4SourceEntries;
+	}
+});
+Object.defineProperty(exports, "normalizeGlobPattern", {
+	enumerable: true,
+	get: function() {
+		return normalizeGlobPattern;
+	}
+});
+Object.defineProperty(exports, "normalizeTailwindV4ScannerSources", {
+	enumerable: true,
+	get: function() {
+		return normalizeTailwindV4ScannerSources;
+	}
+});
+Object.defineProperty(exports, "normalizeTailwindV4SourceEntries", {
+	enumerable: true,
+	get: function() {
+		return normalizeTailwindV4SourceEntries;
+	}
+});
+Object.defineProperty(exports, "replaceBareArbitraryValueSelectors", {
+	enumerable: true,
+	get: function() {
+		return replaceBareArbitraryValueSelectors;
+	}
+});
+Object.defineProperty(exports, "resolveBareArbitraryValueCandidate", {
+	enumerable: true,
+	get: function() {
+		return resolveBareArbitraryValueCandidate;
+	}
+});
+Object.defineProperty(exports, "resolveSourceScanPath", {
+	enumerable: true,
+	get: function() {
+		return resolveSourceScanPath;
+	}
+});
+Object.defineProperty(exports, "resolveTailwindV4Source", {
+	enumerable: true,
+	get: function() {
+		return resolveTailwindV4Source;
+	}
+});
+Object.defineProperty(exports, "resolveTailwindV4SourceBaseCandidates", {
+	enumerable: true,
+	get: function() {
+		return resolveTailwindV4SourceBaseCandidates;
+	}
+});
+Object.defineProperty(exports, "resolveTailwindV4SourceEntry", {
+	enumerable: true,
+	get: function() {
+		return resolveTailwindV4SourceEntry;
+	}
+});
+Object.defineProperty(exports, "resolveValidTailwindV4Candidates", {
+	enumerable: true,
+	get: function() {
+		return resolveValidTailwindV4Candidates;
+	}
+});
+Object.defineProperty(exports, "toExtension", {
+	enumerable: true,
+	get: function() {
+		return toExtension;
+	}
+});
+Object.defineProperty(exports, "toPosixPath", {
+	enumerable: true,
+	get: function() {
+		return toPosixPath;
+	}
+});