@weapp-tailwindcss/engine 0.1.0

package/dist/v4-BdeIFyye.js

@@ -0,0 +1,3874 @@
+import { createRequire } from "node:module";
+import { promises, realpathSync } from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { pathToFileURL } from "node:url";
+import micromatch from "micromatch";
+import { stat } from "node:fs/promises";
+import postcss from "postcss";
+//#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) => path.resolve(value))));
+}
+function createRequireBase(base) {
+	return path.join(base, "package.json");
+}
+function isRelativeSpecifier(id) {
+	return id.startsWith("./") || id.startsWith("../") || id === "." || id === "..";
+}
+function isAbsoluteSpecifier(id) {
+	return path.isAbsolute(id);
+}
+function isCssSpecifier(id) {
+	return path.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 = createRequire(createRequireBase(base));
+			for (const candidate of createCssResolutionCandidates(id)) try {
+				return requireFromBase.resolve(candidate);
+			} catch {}
+		}
+	};
+}
+async function importResolvedModule(resolved) {
+	return import(pathToFileURL(resolved).href);
+}
+async function importTailwindNodeFromBase(base) {
+	try {
+		return await importResolvedModule(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(path.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 = path.resolve(value);
+		if (!result.includes(resolved)) result.push(resolved);
+	}
+	return result;
+}
+function toPosixPath(value) {
+	return value.replaceAll(path.sep, "/");
+}
+function resolveSourceScanPath(value) {
+	const resolved = path.resolve(value);
+	try {
+		return 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 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 = path.isAbsolute(sourcePath) ? path.resolve(sourcePath) : path.resolve(base, sourcePath);
+	if (await pathExistsAsDirectory(absoluteSource)) return {
+		base: absoluteSource,
+		negated,
+		pattern: normalizeGlobPattern(defaultPattern)
+	};
+	if (path.isAbsolute(sourcePath)) return {
+		base: path.dirname(absoluteSource),
+		negated,
+		pattern: normalizeGlobPattern(path.basename(absoluteSource))
+	};
+	const { prefix, rest } = splitStaticGlobPrefix(sourcePath);
+	if (prefix.length > 0 && rest.length > 0) return {
+		base: path.resolve(base, ...prefix),
+		negated,
+		pattern: normalizeGlobPattern(rest.join("/"))
+	};
+	return {
+		base,
+		negated,
+		pattern: normalizeGlobPattern(sourcePath)
+	};
+}
+async function normalizeTailwindV4SourceEntries(sources, options = {}) {
+	const cwd = options.cwd ? path.resolve(options.cwd) : process.cwd();
+	return Promise.all(sources.map((source) => resolveTailwindV4SourceEntry(source.pattern, source.base ? path.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 = path.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 path.isAbsolute(entry.pattern) ? toPosixPath(path.relative(resolveSourceScanPath(entry.base), entry.pattern)) : normalizeGlobPattern(entry.pattern);
+}
+function isFileMatchedByTailwindV4SourceEntry(file, entry) {
+	const relative = toPosixPath(path.relative(resolveSourceScanPath(entry.base), file));
+	return Boolean(relative) && !relative.startsWith("../") && !path.isAbsolute(relative) && micromatch.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 = path.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(path.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: path.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 path.extname(filename).replace(/^\./, "") || "txt";
+}
+function toRelativeFile(cwd, filename) {
+	const relative = path.relative(cwd, filename).replaceAll(path.sep, "/");
+	return relative === "" ? path.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(process.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 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 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 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.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.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.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.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 : path.isAbsolute(value) ? path.resolve(value) : path.resolve(fallback, value);
+}
+function uniquePaths(values) {
+	const result = [];
+	for (const value of values) {
+		if (!value) continue;
+		const resolved = path.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 promises.access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function resolveCssEntries(entries, projectRoot, base) {
+	const resolvedEntries = entries.map((entry) => ({
+		original: entry,
+		absolute: path.isAbsolute(entry) ? path.resolve(entry) : path.resolve(projectRoot, entry)
+	}));
+	const resolvedBase = base ?? path.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 promises.readFile(entry.absolute, "utf8"));
+			continue;
+		}
+		const importPath = path.isAbsolute(entry.original) ? entry.absolute : path.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 : path.isAbsolute(source.file) ? path.resolve(source.file) : path.resolve(projectRoot, source.file),
+		dependencies: source.dependencies?.map((dependency) => path.isAbsolute(dependency) ? path.resolve(dependency) : path.resolve(projectRoot, dependency)) ?? []
+	}));
+	const firstSource = resolvedSources[0];
+	const resolvedBase = base ?? firstSource?.base ?? (firstSource?.file ? path.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) => path.resolve(dependency))))
+	};
+}
+async function resolveTailwindV4Source(options = {}) {
+	const projectRoot = resolveBase(options.projectRoot, process.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
+export { mergeTailwindV4SourceEntries as A, normalizeTailwindV4ScannerSources as B, getOxideModule as C, groupTailwindV4SourceEntriesByBase as D, expandTailwindV4SourceEntries as E, createTailwindV4CompiledSourceEntries as F, toPosixPath as G, resolveSourceScanPath as H, createTailwindV4DefaultIgnoreSources as I, loadTailwindV4DesignSystem as J, compileTailwindV4Source as K, createTailwindV4RootSources as L, TAILWIND_V4_IGNORED_CONTENT_DIRS as M, TAILWIND_V4_IGNORED_EXTENSIONS as N, isFileExcludedByTailwindV4SourceEntries as O, TAILWIND_V4_IGNORED_FILES as P, expandTailwindV4SourceEntryBraces as R, toExtension as S, createTailwindV4SourceExclusionMatcher as T, resolveTailwindV4SourceBaseCandidates as U, normalizeTailwindV4SourceEntries as V, resolveTailwindV4SourceEntry as W, loadTailwindV4NodeModule as Y, isBareArbitraryValuesEnabled as _, createTailwindGenerationSession as a, buildLineOffsets as b, replaceBareArbitraryValueSelectors as c, extractRawCandidates as d, extractRawCandidatesWithPositions as f, extractBareArbitraryValueSourceCandidatesWithPositions as g, extractBareArbitraryValueSourceCandidates as h, createTailwindV4Engine as i, TAILWIND_V4_AUTO_SOURCE_SCAN_PATTERN as j, isFileMatchedByTailwindV4SourceEntries as k, resolveValidTailwindV4Candidates as l, extractSourceCandidatesWithPositions as m, generateTailwindV4Style as n, collectTailwindStyleCandidates as o, extractSourceCandidates as p, getTailwindV4DesignSystemCacheKey as q, resolveTailwindV4Source as r, canonicalizeBareArbitraryValueCandidates as s, collectTailwindV4StyleCandidates as t, extractTailwindV4InlineSourceCandidates as u, resolveBareArbitraryValueCandidate as v, createTailwindV4SourceEntryMatcher as w, createTokenLocation as x, escapeCssClassName as y, normalizeGlobPattern as z };