@markless/bundler 0.1.0

package/dist/rolldown-Czh1duwk.js

@@ -0,0 +1,1802 @@
+import { S as planModulePreloads, _ as requalifyExecutionLogModuleHook, a as resumeVirtualModuleId, b as outputDefaults, c as symbolVirtualModuleId, d as MARKLESS_EXECUTION_SIZES, f as createExecutionSizesAsset, g as normalizeExecutionLogMode, h as injectExecutionLogModuleHook, i as payloadModule, l as symbolVirtualModuleSourceFile, m as executionLogVirtualModuleSource, n as emitResumeModule, o as rewriteSymbolModuleExport, p as executionLogActivationInjection, r as emitSourceModule, s as scopedSymbolExportName, t as MARKLESS_VIRTUAL_PREFIX, u as MARKLESS_EXECUTION_LOG_MODULE_ID, v as MARKLESS_BUILD_PREFIX, y as MARKLESS_BUNDLE_GRAPH } from "./source-module-CSRzW4Ny.js";
+import { joinURL, parsePath, withLeadingSlash, withQuery, withoutLeadingSlash } from "ufo";
+import { dirname, isAbsolute, join, normalize, relative, resolve } from "pathe";
+import { defDGraph } from "@thi.ng/dgraph";
+import { compileTsrxModule, emitSymbolResolverModule, parseJavaScriptModule } from "@markless/compiler";
+//#region src/build/bundle-graph.ts
+const SLOW_BUNDLE_TOTAL = 300 * 1024 / 8 * .5;
+const SMALL_BUNDLE_TOTAL = 1e3;
+function convertManifestToBundleGraph(manifest, bundleGraphAdders) {
+	const graph = bundleGraphRecords(manifest, bundleGraphAdders);
+	const dag = defDGraph(bundleGraphEdges(graph));
+	const reduced = dag.copy();
+	for (const name of dag.nodes()) for (const dep of dag.immediateDependencies(name)) for (const transitive of dag.transitiveDependencies(dep)) reduced.removeEdge(name, transitive);
+	const nodes = Object.keys(graph).sort().map((name) => {
+		const bundle = graph[name];
+		const dynamicImports = (bundle?.dynamicImports ?? []).map((dep) => [dep, dynamicImportMarker(bundle, graph[dep])]).sort((a, b) => a[1] - b[1] || a[0].localeCompare(b[0]));
+		const deps = [...reduced.immediateDependencies(name)].sort();
+		let lastMarker;
+		for (const [dep, marker] of dynamicImports) {
+			if (marker !== lastMarker) {
+				deps.push(marker);
+				lastMarker = marker;
+			}
+			deps.push(dep);
+		}
+		return [name, deps];
+	});
+	const indexes = /* @__PURE__ */ new Map();
+	let index = 0;
+	for (const [name, deps] of nodes) {
+		indexes.set(name, index);
+		index += 1 + deps.length;
+	}
+	return nodes.flatMap(([name, deps]) => [name, ...deps.map((dep) => {
+		if (typeof dep === "number") return dep;
+		return indexes.get(dep);
+	})]);
+}
+function createPreloadGraphAdder(addEntries) {
+	return (manifest) => addEntries({
+		manifest,
+		hasBundle: (bundleName) => !!manifest.bundles[bundleName],
+		bundlesForOrigins: (origins) => bundlesForOrigins(manifest, origins)
+	});
+}
+function bundlesForOrigins(manifest, origins) {
+	const normalizedOrigins = new Set(origins.map(normalizeManifestOrigin));
+	const bundles = [];
+	for (const [bundleName, bundle] of Object.entries(manifest.bundles)) if (bundle.origins?.some((origin) => normalizedOrigins.has(normalizeManifestOrigin(origin)))) bundles.push(bundleName);
+	return bundles.sort();
+}
+function bundleGraphRecords(manifest, bundleGraphAdders) {
+	const graph = { ...manifest.bundles };
+	const runtimeBundles = runtimeBundleNamesByModuleId(manifest);
+	for (const module of manifest.modules) {
+		const runtimeModuleIdsBySymbolId = new Map((module.runtimeDemandMap?.symbols ?? []).map((symbol) => [symbol.symbolId, symbol.runtimeModuleIds]));
+		for (const symbol of module.symbols) {
+			if (!symbol.fileName) continue;
+			const imports = [...manifest.bundles[symbol.fileName]?.imports ?? [], ...module.resolver.fileName ? [module.resolver.fileName] : []];
+			const runtimeDemandBundles = (runtimeModuleIdsBySymbolId.get(symbol.symbolId) ?? []).flatMap((id) => runtimeBundles.get(id) ?? []);
+			const symbolBundle = {
+				size: 0,
+				total: 0,
+				dynamicImports: [...new Set([symbol.fileName, ...runtimeDemandBundles])]
+			};
+			if (imports.length > 0) symbolBundle.imports = imports;
+			graph[symbol.symbolId] = symbolBundle;
+		}
+	}
+	for (const [bundleName, bundle] of Object.entries(graph)) for (const symbolId of bundle.symbols ?? []) {
+		if (symbolId === bundleName) continue;
+		graph[symbolId] = appendDynamicImport(graph[symbolId] ?? {
+			size: 0,
+			total: 0
+		}, bundleName);
+	}
+	if (bundleGraphAdders) {
+		const combined = {
+			...manifest,
+			bundles: graph
+		};
+		for (const add of bundleGraphAdders) Object.assign(graph, add(combined));
+	}
+	for (const bundleName of Object.keys(graph)) {
+		const bundle = graph[bundleName];
+		if (!bundle) continue;
+		graph[bundleName] = {
+			...bundle,
+			imports: bundle.imports?.filter((dep) => graph[dep]) ?? [],
+			dynamicImports: bundle.dynamicImports?.filter((dep) => graph[dep]) ?? []
+		};
+	}
+	const used = /* @__PURE__ */ new Set();
+	for (const bundle of Object.values(graph)) {
+		for (const dep of bundle.imports ?? []) used.add(dep);
+		for (const dep of bundle.dynamicImports ?? []) used.add(dep);
+	}
+	for (const [bundleName, bundle] of Object.entries(graph)) if (!used.has(bundleName) && !bundle.imports?.length && !bundle.dynamicImports?.length) delete graph[bundleName];
+	return graph;
+}
+function appendDynamicImport(bundle, dependency) {
+	if (bundle.dynamicImports?.includes(dependency)) return bundle;
+	return {
+		...bundle,
+		dynamicImports: [...bundle.dynamicImports ?? [], dependency]
+	};
+}
+function runtimeBundleNamesByModuleId(manifest) {
+	const entries = /* @__PURE__ */ new Map();
+	for (const [bundleName, bundle] of Object.entries(manifest.bundles)) for (const origin of bundle.origins ?? []) {
+		const runtimeModuleId = runtimeModuleIdFromOrigin(origin);
+		if (!runtimeModuleId) continue;
+		entries.set(runtimeModuleId, [...entries.get(runtimeModuleId) ?? [], bundleName]);
+	}
+	for (const [id, names] of entries) entries.set(id, names.sort());
+	return entries;
+}
+function runtimeModuleIdFromOrigin(origin) {
+	const normalized = normalizeManifestOrigin(origin);
+	for (const [prefix, marker] of [["web", "packages/web/src/"], ["core", "packages/core/src/"]]) {
+		const index = normalized.lastIndexOf(marker);
+		if (index === -1 || !normalized.endsWith(".ts")) continue;
+		return `${prefix}/${normalized.slice(index + marker.length, -3)}`;
+	}
+}
+function dynamicImportMarker(bundle, dependency) {
+	let probability = .5;
+	if (hasRelatedOrigin(bundle, dependency)) probability += .25;
+	if ((dependency?.total ?? 0) > SLOW_BUNDLE_TOTAL) if (probability > .5) probability += .02;
+	else probability -= .02;
+	if ((dependency?.total ?? 0) < SMALL_BUNDLE_TOTAL) probability += .15;
+	probability = Math.min(probability, .99);
+	return -Math.round(probability * 10);
+}
+function hasRelatedOrigin(bundle, dependency) {
+	return !!bundle?.origins?.some((origin) => dependency?.origins?.some((depOrigin) => depOrigin.startsWith(origin)));
+}
+function* bundleGraphEdges(graph) {
+	for (const [bundleName, bundle] of Object.entries(graph)) {
+		yield [bundleName, null];
+		for (const dep of bundle.imports ?? []) yield [bundleName, dep];
+	}
+}
+function normalizeManifestOrigin(origin) {
+	return withoutLeadingSlash(normalize(origin));
+}
+//#endregion
+//#region src/build/dynamic-import-scan.ts
+function scanEmittedDynamicImports(code, chunkFileName) {
+	if (!code.includes("import(")) return [];
+	let ast;
+	try {
+		ast = parseJavaScriptModule(code);
+	} catch {
+		return [];
+	}
+	const specifiers = /* @__PURE__ */ new Set();
+	const visit = (node) => {
+		if (!node || typeof node !== "object") return;
+		if (node.type === "ImportExpression") {
+			const specifier = staticSpecifier(node.source ?? node.arguments);
+			if (specifier?.startsWith(".")) specifiers.add(join(dirname(chunkFileName), specifier));
+		}
+		for (const child of childNodes$1(node)) visit(child);
+	};
+	visit(ast);
+	return [...specifiers];
+}
+function staticSpecifier(source) {
+	const node = Array.isArray(source) ? source[0] : source;
+	if (!node || typeof node !== "object") return void 0;
+	const astNode = node;
+	if (astNode.type === "Literal" || astNode.type === "StringLiteral") return typeof astNode.value === "string" ? astNode.value : void 0;
+	if (astNode.type === "TemplateLiteral" && (astNode.expressions ?? []).length === 0) {
+		const quasi = astNode.quasis?.[0];
+		return quasi?.value?.cooked ?? quasi?.cooked;
+	}
+}
+function childNodes$1(node) {
+	const children = [];
+	for (const [key, value] of Object.entries(node)) {
+		if (key === "loc" || key === "span" || key === "range") continue;
+		if (Array.isArray(value)) {
+			for (const item of value) if (isAstNode$1(item)) children.push(item);
+			continue;
+		}
+		if (isAstNode$1(value)) children.push(value);
+	}
+	return children;
+}
+function isAstNode$1(value) {
+	return !!value && typeof value === "object" && "type" in value;
+}
+//#endregion
+//#region src/build/head-links.ts
+const STYLESHEET_ASSET_RE = /\.css$/;
+function collectHeadLinkInjections(bundle, options = {}) {
+	const publicPath = options.publicPath ?? ((fileName) => fileName);
+	const stylesheetFiles = stylesheetFilesFromViteMetadata(bundle);
+	if (stylesheetFiles.size === 0) {
+		for (const item of Object.values(bundle)) if (item.type === "asset" && STYLESHEET_ASSET_RE.test(item.fileName)) stylesheetFiles.add(item.fileName);
+	}
+	return [...stylesheetFiles].sort().map((fileName) => stylesheetInjection(publicPath(fileName)));
+}
+function stylesheetFilesFromViteMetadata(bundle) {
+	const stylesheetFiles = /* @__PURE__ */ new Set();
+	for (const item of Object.values(bundle)) {
+		if (item.type !== "chunk") continue;
+		for (const fileName of item.viteMetadata?.importedCss ?? []) stylesheetFiles.add(fileName);
+	}
+	return stylesheetFiles;
+}
+function collectModulePreloadInjections(preloadSource, options = {}) {
+	const buildMetadata = isBuildMetadata(preloadSource) ? preloadSource : void 0;
+	const bundleGraph = buildMetadata ? buildMetadata.bundleGraph : preloadSource;
+	const roots = [...buildMetadata ? symbolRootsFromBuildMetadata(buildMetadata) : (bundleGraph ?? []).filter((name) => typeof name === "string" && name.startsWith("symbol:")).map((name) => ({
+		name,
+		priority: "high"
+	})), ...(options.entryChunks ?? []).map((name) => ({
+		name,
+		priority: "auto",
+		edges: "dynamic-only"
+	}))];
+	return planModulePreloads({
+		base: options.publicPath ? options.publicPath(MARKLESS_BUILD_PREFIX) : joinURL("/", MARKLESS_BUILD_PREFIX),
+		bundleGraph,
+		roots
+	}).map(modulePreloadInjection);
+}
+function symbolRootsFromBuildMetadata(metadata) {
+	const roots = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const module of metadata.modules) for (const symbol of module.symbols) {
+		if (!symbol.fileName || seen.has(symbol.symbolId)) continue;
+		seen.add(symbol.symbolId);
+		roots.push({
+			name: symbol.symbolId,
+			priority: "high"
+		});
+	}
+	return roots;
+}
+function isBuildMetadata(value) {
+	return !!value && typeof value === "object" && !Array.isArray(value) && Array.isArray(value.modules);
+}
+function injectHeadLinks(bundle, injections) {
+	if (injections.length === 0) return;
+	const links = injections.map(headLinkTag).join("");
+	for (const output of Object.values(bundle)) {
+		if (!isHtmlAssetWithSource(output)) continue;
+		output.source = output.source.includes("</head>") ? output.source.replace("</head>", `${links}</head>`) : `${links}${output.source}`;
+	}
+}
+function headLinkTag(injection) {
+	const attributes = Object.entries(injection.attributes ?? {}).map(([name, value]) => `${name}="${value.replaceAll("\"", "&quot;")}"`);
+	const open = attributes.length > 0 ? `<${injection.tag} ${attributes.join(" ")}>` : `<${injection.tag}>`;
+	return injection.children === void 0 ? open : `${open}${injection.children}</${injection.tag}>`;
+}
+function isHtmlAssetWithSource(output) {
+	if (!output || typeof output !== "object") return false;
+	const asset = output;
+	return asset.type === "asset" && typeof asset.fileName === "string" && asset.fileName.endsWith(".html") && typeof asset.source === "string";
+}
+function modulePreloadInjection(preload) {
+	const attributes = {
+		rel: "modulepreload",
+		href: preload.href,
+		crossorigin: "anonymous"
+	};
+	if (preload.fetchPriority && preload.fetchPriority !== "auto") attributes.fetchpriority = preload.fetchPriority;
+	return {
+		tag: "link",
+		location: "head",
+		attributes
+	};
+}
+function stylesheetInjection(href) {
+	return {
+		tag: "link",
+		location: "head",
+		attributes: {
+			rel: "stylesheet",
+			href
+		}
+	};
+}
+//#endregion
+//#region src/build/build-metadata.ts
+function createBuildMetadata(bundle, transformManifests, root, options = {}) {
+	const canonPath = options.canonPath ?? ((fileName) => fileName);
+	const publicPath = options.publicPath ?? ((fileName) => fileName);
+	const modules = [...transformManifests].map(cloneTransformManifest);
+	const metadata = {
+		version: 1,
+		modules,
+		bundles: {},
+		assets: {},
+		injections: [...options.injections ?? [], ...collectHeadLinkInjections(bundle, { publicPath })]
+	};
+	for (const item of Object.values(bundle)) {
+		if (item.type === "asset") {
+			if (item.fileName.endsWith(".js.map")) continue;
+			metadata.assets[item.fileName] = assetInfo(item);
+			continue;
+		}
+		const bundleFileName = canonPath(item.fileName);
+		const origins = getOrigins(item, root);
+		const asyncBundle = {
+			size: item.code.length,
+			total: item.code.length
+		};
+		const imports = mapBundleNames(bundle, item.imports, canonPath);
+		if (imports.length > 0) asyncBundle.imports = imports;
+		const dynamicImports = [...new Set([...mapBundleNames(bundle, item.dynamicImports, canonPath), ...mapBundleNames(bundle, scanEmittedDynamicImports(item.code, item.fileName), canonPath)])];
+		if (dynamicImports.length > 0) asyncBundle.dynamicImports = dynamicImports;
+		if (origins.length > 0) asyncBundle.origins = origins;
+		finalizeVirtualModuleReferences(modules, item, bundleFileName);
+		const symbols = modules.flatMap((module) => module.symbols.filter((symbol) => symbol.fileName === bundleFileName).map((symbol) => symbol.symbolId));
+		if (symbols.length > 0) asyncBundle.symbols = symbols;
+		metadata.bundles[bundleFileName] = asyncBundle;
+	}
+	computeTotals(metadata.bundles);
+	sortBuildMetadata(metadata);
+	if (options.bundleGraphAsset) {
+		metadata.bundleGraph = convertManifestToBundleGraph(metadata, options.bundleGraphAdders);
+		metadata.bundleGraphAsset = options.bundleGraphAsset;
+		metadata.assets[options.bundleGraphAsset] = {
+			name: "bundle-graph.json",
+			size: JSON.stringify(metadata.bundleGraph).length
+		};
+	}
+	return metadata;
+}
+function cloneTransformManifest(manifest) {
+	return {
+		source: manifest.source,
+		payload: { ...manifest.payload },
+		resolver: { ...manifest.resolver },
+		symbols: manifest.symbols.map((symbol) => ({ ...symbol })),
+		runtimeDemandMap: manifest.runtimeDemandMap
+	};
+}
+function finalizeVirtualModuleReferences(modules, item, bundleFileName) {
+	const ids = new Set([item.facadeModuleId ?? void 0, ...item.moduleIds].filter((id) => !!id).map(normalizeVirtualModuleId));
+	for (const module of modules) {
+		for (const reference of [module.payload, module.resolver]) if (ids.has(normalizeVirtualModuleId(reference.virtualModuleId))) reference.fileName = bundleFileName;
+		for (const symbol of module.symbols) if (ids.has(normalizeVirtualModuleId(symbol.virtualModuleId))) symbol.fileName = bundleFileName;
+	}
+}
+function normalizeVirtualModuleId(id) {
+	if (id.startsWith("\0")) return id.slice(1);
+	return id;
+}
+function assetInfo(item) {
+	return {
+		name: item.names?.[0] ?? item.name,
+		size: item.source.length
+	};
+}
+function mapBundleNames(bundle, names, canonPath) {
+	return names.flatMap((name) => {
+		const item = bundle[name];
+		if (item) return [canonPath(item.fileName)];
+		return [canonPath(name)];
+	});
+}
+function getOrigins(item, root) {
+	return item.moduleIds.filter((id) => !id.startsWith("\0")).map((id) => {
+		if (root) return relative(root, id);
+		return id;
+	}).sort();
+}
+function computeTotals(bundles) {
+	const collect = (name, seen) => {
+		const bundle = bundles[name];
+		if (!bundle || seen.has(name)) return;
+		seen.add(name);
+		for (const dep of bundle.imports ?? []) collect(dep, seen);
+	};
+	for (const name of Object.keys(bundles)) {
+		const seen = /* @__PURE__ */ new Set();
+		collect(name, seen);
+		bundles[name].total = [...seen].reduce((sum, dep) => sum + (bundles[dep]?.size ?? 0), 0);
+	}
+}
+function sortBuildMetadata(metadata) {
+	metadata.modules = metadata.modules.sort((a, b) => a.source.localeCompare(b.source));
+	metadata.bundles = sortRecord(metadata.bundles);
+	metadata.assets = sortRecord(metadata.assets ?? {});
+	metadata.injections?.sort((a, b) => injectionKey(a).localeCompare(injectionKey(b)));
+	for (const bundle of Object.values(metadata.bundles)) {
+		bundle.imports?.sort();
+		bundle.dynamicImports?.sort();
+		bundle.origins?.sort();
+		bundle.symbols?.sort();
+	}
+	for (const module of metadata.modules) module.symbols.sort((a, b) => a.symbolId.localeCompare(b.symbolId));
+}
+function sortRecord(record) {
+	const next = {};
+	for (const key of Object.keys(record).sort()) {
+		const value = record[key];
+		if (value !== void 0) next[key] = value;
+	}
+	return next;
+}
+function injectionKey(injection) {
+	return `${injection.location}:${injection.tag}:${injection.attributes?.href ?? ""}`;
+}
+//#endregion
+//#region src/build/preload-cleanup.ts
+function stripEmptyVitePreloadWrappers(code) {
+	return stripImportedVitePreloadHelper(stripUnusedVitePreloadHelper(stripAsyncEmptyPreloadWrappers(stripDirectEmptyPreloadWrappers(code))));
+}
+const IMPORT_DECLARATION_CANDIDATE_RE = /\bimport\s*\{[\s\S]*?\}\s*from\s*["'][^"']+["'];?/g;
+function stripDirectEmptyPreloadWrappers(code) {
+	let next = "";
+	let cursor = 0;
+	let changed = false;
+	const wrapperRE = /\b[$A-Z_a-z][$\w]*\(\(\)\s*=>\s*/g;
+	for (let match = wrapperRE.exec(code); match; match = wrapperRE.exec(code)) {
+		const callStart = match.index;
+		const bodyStart = match.index + match[0].length;
+		if (!code.startsWith("import(", bodyStart)) continue;
+		const wrapper = findEmptyPreloadWrapper(code, callStart, bodyStart);
+		if (!wrapper) continue;
+		next += code.slice(cursor, callStart);
+		next += code.slice(bodyStart, wrapper.firstArgumentEnd);
+		cursor = wrapper.callEnd + 1;
+		wrapperRE.lastIndex = cursor;
+		changed = true;
+	}
+	if (!changed) return code;
+	return next + code.slice(cursor);
+}
+function stripAsyncEmptyPreloadWrappers(code) {
+	let next = "";
+	let cursor = 0;
+	let changed = false;
+	const wrapperRE = /\b[$A-Z_a-z][$\w]*\(\s*async\s*\(\)\s*=>\s*\{/g;
+	for (let match = wrapperRE.exec(code); match; match = wrapperRE.exec(code)) {
+		const callStart = match.index;
+		const callOpen = code.indexOf("(", callStart);
+		if (callOpen < 0) continue;
+		const firstArgumentEnd = findTopLevelComma(code, callOpen + 1);
+		if (firstArgumentEnd < 0) continue;
+		const wrapper = findEmptyPreloadWrapper(code, callStart, callOpen + 1);
+		if (!wrapper) continue;
+		const loader = code.slice(callOpen + 1, firstArgumentEnd);
+		next += code.slice(cursor, callStart);
+		next += `(${loader})()`;
+		cursor = wrapper.callEnd + 1;
+		wrapperRE.lastIndex = cursor;
+		changed = true;
+	}
+	if (!changed) return code;
+	return next + code.slice(cursor);
+}
+function findEmptyPreloadWrapper(code, callStart, bodyStart) {
+	const callOpen = code.indexOf("(", callStart);
+	if (callOpen < 0 || callOpen >= bodyStart) return void 0;
+	const firstArgumentEnd = findTopLevelComma(code, callOpen + 1);
+	if (firstArgumentEnd < 0) return void 0;
+	let cursor = skipSpaces(code, firstArgumentEnd + 1);
+	if (code[cursor] !== "[" || code[cursor + 1] !== "]") return void 0;
+	cursor = skipSpaces(code, cursor + 2);
+	if (code[cursor] === ")") return {
+		firstArgumentEnd,
+		callEnd: cursor
+	};
+	if (code[cursor] !== ",") return void 0;
+	cursor = skipSpaces(code, cursor + 1);
+	if (!code.startsWith("import.meta.url", cursor)) return void 0;
+	cursor = skipSpaces(code, cursor + 15);
+	if (code[cursor] !== ")") return void 0;
+	return {
+		firstArgumentEnd,
+		callEnd: cursor
+	};
+}
+function findTopLevelComma(code, start) {
+	let depth = 1;
+	let quote = null;
+	let escaped = false;
+	for (let index = start; index < code.length; index++) {
+		const char = code[index];
+		if (quote) {
+			if (escaped) {
+				escaped = false;
+				continue;
+			}
+			if (char === "\\") {
+				escaped = true;
+				continue;
+			}
+			if (char === quote) quote = null;
+			continue;
+		}
+		if (char === "\"" || char === "'" || char === "`") {
+			quote = char;
+			continue;
+		}
+		if (char === "(" || char === "[" || char === "{") {
+			depth++;
+			continue;
+		}
+		if (char === ")" || char === "]" || char === "}") {
+			depth--;
+			if (depth === 0) return -1;
+			continue;
+		}
+		if (char === "," && depth === 1) return index;
+	}
+	return -1;
+}
+function skipSpaces(code, start) {
+	let cursor = start;
+	while (/\s/.test(code[cursor] ?? "")) cursor++;
+	return cursor;
+}
+function stripImportedVitePreloadHelper(code) {
+	const helper = findImportedVitePreloadHelper(code);
+	if (!helper) return code;
+	const withoutImport = code.slice(0, helper.importStart) + code.slice(helper.importEnd);
+	if (hasCallableReference(withoutImport, helper.preloadFunction)) return code;
+	const initCall = `${escapeRegExp$1(helper.initFunction)}\\(\\)`;
+	return withoutImport.replace(new RegExp(String.raw`,${initCall},`, "g"), ",").replace(new RegExp(String.raw`\{${initCall},`, "g"), "{").replace(new RegExp(String.raw`,${initCall},`, "g"), ",").replace(new RegExp(String.raw`,${initCall}\}`, "g"), "}").replace(new RegExp(String.raw`\{${initCall}\}`, "g"), "{}");
+}
+function findImportedVitePreloadHelper(code) {
+	for (const match of code.matchAll(IMPORT_DECLARATION_CANDIDATE_RE)) {
+		const importStart = match.index ?? -1;
+		if (importStart < 0) continue;
+		const statement = match[0];
+		const declaration = asNodes(tryParseJavaScriptModule(statement)?.body).find((node) => node.type === "ImportDeclaration");
+		if (!declaration) continue;
+		let preloadFunction;
+		let initFunction;
+		for (const specifier of asNodes(declaration.specifiers)) {
+			if (specifier.type !== "ImportSpecifier") continue;
+			const imported = identifierName(specifier.imported);
+			const local = identifierName(specifier.local);
+			if (!imported || !local) continue;
+			if (imported === "__vitePreload") preloadFunction = local;
+			if (imported === "init_preload_helper") initFunction = local;
+		}
+		if (preloadFunction && initFunction) return {
+			importStart,
+			importEnd: importStart + statement.length,
+			preloadFunction,
+			initFunction
+		};
+	}
+}
+function stripUnusedVitePreloadHelper(code) {
+	const marker = code.indexOf("vite:preloadError");
+	if (marker < 0) return code;
+	const helper = findVitePreloadHelperModule(code, marker);
+	if (!helper) return code;
+	const statementEnd = code[helper.removeStart] === "," && code[helper.removeEnd - 1] === ";" ? ";" : "";
+	const outsideHelper = code.slice(0, helper.removeStart) + statementEnd + code.slice(helper.removeEnd);
+	if (hasCallableReference(outsideHelper, helper.preloadFunction)) return code;
+	let withoutHelper = outsideHelper;
+	const chain = findVitePreloadHelperInitChain(withoutHelper, helper.moduleVariable);
+	if (chain) withoutHelper = removeInitCall(withoutHelper.slice(0, chain.removeStart) + withoutHelper.slice(chain.removeEnd), chain.entryVariable);
+	return removeInitCall(withoutHelper, helper.moduleVariable);
+}
+function findVitePreloadHelperModule(code, marker) {
+	const initStart = code.lastIndexOf("=e((()=>{", marker);
+	if (initStart < 0) return void 0;
+	const moduleVariable = readIdentifierBefore(code, initStart);
+	if (!moduleVariable) return void 0;
+	const bodyStart = initStart + 9;
+	const bodyEnd = findModuleInitEnd(code, initStart);
+	if (bodyEnd < 0) return void 0;
+	const helperBody = code.slice(bodyStart, bodyEnd);
+	const preloadFunction = helperBody.match(/,([$A-Z_a-z][$\w]*)=function\([^)]*\)\{let\s+[$A-Z_a-z][$\w]*=Promise\.resolve\(\)/)?.[1];
+	if (!preloadFunction) return void 0;
+	const firstHelperVariable = helperBody.match(/^([$A-Z_a-z][$\w]*)=/)?.[1];
+	if (!firstHelperVariable) return void 0;
+	const removeStart = findHelperDeclarationStart(code, initStart, firstHelperVariable);
+	if (removeStart < 0) return void 0;
+	return {
+		moduleVariable,
+		preloadFunction,
+		removeStart,
+		removeEnd: bodyEnd + 4
+	};
+}
+function findVitePreloadHelperInitChain(code, moduleVariable) {
+	const match = new RegExp(`var\\s+([$A-Z_a-z][$\\w]*)=e\\(\\(\\(\\)=>\\{${escapeRegExp$1(moduleVariable)}\\(\\)\\}\\)\\),([$A-Z_a-z][$\\w]*)=e\\(\\(\\(\\)=>\\{\\1\\(\\)\\}\\)\\);`).exec(code);
+	if (!match) return void 0;
+	return {
+		entryVariable: match[2],
+		removeStart: match.index,
+		removeEnd: match.index + match[0].length
+	};
+}
+function removeInitCall(code, entryVariable) {
+	return code.replace(new RegExp(`,${escapeRegExp$1(entryVariable)}\\(\\)`), "").replace(new RegExp(`${escapeRegExp$1(entryVariable)}\\(\\),`), "").replace(new RegExp(`\\{${escapeRegExp$1(entryVariable)}\\(\\)\\}`), "{}");
+}
+function readIdentifierBefore(code, index) {
+	let end = index;
+	while (/\s/.test(code[end - 1] ?? "")) end--;
+	let start = end;
+	while (/[$\w]/.test(code[start - 1] ?? "")) start--;
+	const value = code.slice(start, end);
+	return /^[$A-Z_a-z][$\w]*$/.test(value) ? value : void 0;
+}
+function findModuleInitEnd(code, initStart) {
+	return code.indexOf("}));", initStart);
+}
+function findHelperDeclarationStart(code, initStart, firstHelperVariable) {
+	const commaStart = code.lastIndexOf(`,${firstHelperVariable},`, initStart);
+	if (commaStart >= 0) return commaStart;
+	const varStart = code.lastIndexOf(`var ${firstHelperVariable},`, initStart);
+	if (varStart >= 0) return varStart;
+	return -1;
+}
+function escapeRegExp$1(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function hasCallableReference(code, name) {
+	const ast = tryParseJavaScriptModule(code);
+	if (!ast) return true;
+	let found = false;
+	walkReferenceScopes(ast, [], (node, scopes) => {
+		if (node.type !== "CallExpression") return;
+		const callee = node.callee;
+		if (identifierName(callee) !== name) return;
+		if (isDeclaredInScope(name, scopes)) return;
+		found = true;
+	});
+	return found;
+}
+function walkReferenceScopes(node, scopes, visit) {
+	if (!node || typeof node !== "object") return;
+	if (node.type === "Program") {
+		const scope = collectScopeDeclarations(asNodes(node.body));
+		visit(node, [scope]);
+		for (const child of asNodes(node.body)) walkReferenceScopes(child, [scope], visit);
+		return;
+	}
+	if (isFunctionNode(node)) {
+		const scope = /* @__PURE__ */ new Set();
+		collectBindingNames(node.id, scope);
+		for (const parameter of asNodes(node.params)) collectBindingNames(parameter, scope);
+		const nextScopes = [...scopes, scope];
+		visit(node, nextScopes);
+		walkReferenceScopes(node.body, nextScopes, visit);
+		return;
+	}
+	if (node.type === "BlockStatement") {
+		const scope = collectScopeDeclarations(asNodes(node.body));
+		const nextScopes = [...scopes, scope];
+		visit(node, nextScopes);
+		for (const child of asNodes(node.body)) walkReferenceScopes(child, nextScopes, visit);
+		return;
+	}
+	visit(node, scopes);
+	for (const child of childNodes(node)) walkReferenceScopes(child, scopes, visit);
+}
+function collectScopeDeclarations(nodes) {
+	const declarations = /* @__PURE__ */ new Set();
+	for (const node of nodes) {
+		if (node.type === "FunctionDeclaration" || node.type === "ClassDeclaration") {
+			collectBindingNames(node.id, declarations);
+			continue;
+		}
+		if (node.type === "ImportDeclaration") {
+			for (const specifier of asNodes(node.specifiers)) collectBindingNames(specifier.local, declarations);
+			continue;
+		}
+		if (node.type === "VariableDeclaration") for (const declaration of asNodes(node.declarations)) collectBindingNames(declaration.id, declarations);
+	}
+	return declarations;
+}
+function collectBindingNames(node, names) {
+	if (!node) return;
+	const name = identifierName(node);
+	if (name) {
+		names.add(name);
+		return;
+	}
+	for (const child of childNodes(node)) collectBindingNames(child, names);
+}
+function isDeclaredInScope(name, scopes) {
+	return scopes.some((scope) => scope.has(name));
+}
+function isFunctionNode(node) {
+	return node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression";
+}
+function tryParseJavaScriptModule(code) {
+	try {
+		return parseJavaScriptModule(code);
+	} catch {
+		return;
+	}
+}
+function childNodes(node) {
+	const children = [];
+	for (const [key, value] of Object.entries(node)) {
+		if (ignoredAstKeys.has(key)) continue;
+		if (Array.isArray(value)) {
+			for (const item of value) if (isAstNode(item)) children.push(item);
+			continue;
+		}
+		if (isAstNode(value)) children.push(value);
+	}
+	return children;
+}
+function asNodes(value) {
+	return Array.isArray(value) ? value.filter(isAstNode) : [];
+}
+function isAstNode(value) {
+	return typeof value === "object" && value !== null && typeof value.type === "string";
+}
+function identifierName(node) {
+	return node?.type === "Identifier" && typeof node.name === "string" ? node.name : void 0;
+}
+const ignoredAstKeys = new Set([
+	"closingElement",
+	"id",
+	"leadingComments",
+	"loc",
+	"metadata",
+	"openingElement",
+	"parent",
+	"range",
+	"trailingComments"
+]);
+//#endregion
+//#region src/build/symbol-facade-cleanup.ts
+const TSRX_SOURCE_FILE$1 = /\.tsrx(?:[?#].*)?$/;
+const SYMBOL_INIT_EXPORT_PREFIX = "init__virtual_markless_symbol";
+const STRING_LITERAL_SOURCE = String.raw`(?:"[^"\\]*(?:\\.[^"\\]*)*"|'[^'\\]*(?:\\.[^'\\]*)*'|` + "`[^`\\\\]*(?:\\\\.[^`\\\\]*)*`)";
+const FUNCTION_DECLARATION_RE = /\bfunction\s+([$A-Z_a-z][$\w]*)\s*\(\s*([$A-Z_a-z][$\w]*)\s*\)\s*\{/g;
+const LOCAL_DYNAMIC_IMPORT_HELPER_RE = /import\(\s*(["'`])([^"'`]+)\1\s*\)\.then\(\s*\(?\s*([$A-Z_a-z][$\w]*)\s*\)?\s*=>\s*([$A-Z_a-z][$\w]*)\(\s*\3\s*,\s*(["'`])([^"'`]*)\5\s*\)\s*\)/g;
+const LOCAL_DYNAMIC_IMPORT_RE = /import\(\s*(["'`])([^"'`]+)\1\s*\)(?:\.then\(\s*\(?\s*([$A-Z_a-z][$\w]*)\s*\)?\s*=>\s*\3\.([$A-Z_a-z][$\w]*)\s*\))?/g;
+function rewriteGeneratedSymbolFacadeImports(bundle) {
+	const chunks = collectChunks$1(bundle);
+	const rewrites = findSymbolFacadeRewrites(chunks);
+	const removedFacades = /* @__PURE__ */ new Set();
+	if (rewrites.size === 0) return removedFacades;
+	for (const chunk of chunks.values()) {
+		if (!isGeneratedAsyncChunk(chunk)) continue;
+		const result = rewriteDynamicImportSpecifiers(chunk, rewrites);
+		chunk.code = result.code;
+		chunk.dynamicImports = unique(chunk.dynamicImports.map((fileName) => result.rewrittenFacades.has(fileName) ? rewrites.get(fileName)?.target.fileName ?? fileName : fileName));
+	}
+	for (const rewrite of rewrites.values()) {
+		const facadeId = rewrite.facade.facadeModuleId;
+		if (facadeId && !rewrite.target.moduleIds.includes(facadeId)) rewrite.target.moduleIds = [...rewrite.target.moduleIds, facadeId];
+	}
+	for (const rewrite of rewrites.values()) {
+		deleteBundleChunk(bundle, rewrite.facade.fileName);
+		chunks.delete(rewrite.facade.fileName);
+		removedFacades.add(rewrite.facade.fileName);
+	}
+	return removedFacades;
+}
+function rewriteGeneratedSymbolInitExports(bundle) {
+	const chunks = collectChunks$1(bundle);
+	const rewrites = findSymbolInitExportRewrites(chunks);
+	if (rewrites.length === 0) return { renamed: 0 };
+	const replacements = /* @__PURE__ */ new Map();
+	for (const rewrite of rewrites) {
+		rewrite.chunk.exports = rewrite.collapsed ? [...rewrite.collapsed.exports] : rewrite.chunk.exports.map((name) => rewrite.names.get(name) ?? name);
+		if (rewrite.collapsed) rewrite.chunk.code = rewrite.collapsed.code;
+		for (const [from, to] of rewrite.names) replacements.set(from, to);
+	}
+	for (const chunk of chunks.values()) {
+		if (!isGeneratedAsyncChunk(chunk)) continue;
+		chunk.code = replaceIdentifierNames(chunk.code, replacements);
+	}
+	return { renamed: replacements.size };
+}
+function compactGeneratedDirectSymbolLoaders(bundle) {
+	let compacted = 0;
+	for (const chunk of collectChunks$1(bundle).values()) {
+		if (!isGeneratedAsyncChunk(chunk)) continue;
+		if (!chunk.code.includes("?import(")) continue;
+		const result = compactDirectSymbolLoadersInCode(chunk.code);
+		if (result.compacted === 0) continue;
+		chunk.code = result.code;
+		compacted += result.compacted;
+	}
+	return { compacted };
+}
+function collectChunks$1(bundle) {
+	const chunks = /* @__PURE__ */ new Map();
+	for (const output of Object.values(bundle)) if (isGeneratedChunk$1(output)) chunks.set(output.fileName, output);
+	return chunks;
+}
+function findSymbolFacadeRewrites(chunks) {
+	const rewrites = /* @__PURE__ */ new Map();
+	for (const chunk of chunks.values()) {
+		const rewrite = findSymbolFacadeRewrite(chunk, chunks);
+		if (rewrite) rewrites.set(chunk.fileName, rewrite);
+	}
+	return rewrites;
+}
+function findSymbolInitExportRewrites(chunks) {
+	const rewrites = [];
+	for (const chunk of chunks.values()) {
+		const rewrite = findSymbolInitExportRewrite(chunk);
+		if (rewrite) rewrites.push(rewrite);
+	}
+	return rewrites;
+}
+function findSymbolInitExportRewrite(chunk) {
+	if (!isGeneratedAsyncChunk(chunk)) return void 0;
+	const initExports = chunk.exports.filter(isGeneratedSymbolInitExport);
+	if (initExports.length === 0) return void 0;
+	const names = /* @__PURE__ */ new Map();
+	const used = new Set(chunk.exports.filter((name) => !isGeneratedSymbolInitExport(name)));
+	const collapsed = collapseGeneratedSymbolInitExports(chunk.code, initExports);
+	if (collapsed) {
+		for (const name of initExports) if (name !== SYMBOL_INIT_EXPORT_PREFIX) names.set(name, SYMBOL_INIT_EXPORT_PREFIX);
+		return {
+			chunk,
+			names,
+			collapsed
+		};
+	}
+	for (const name of initExports) {
+		const next = compactSymbolInitExportName(name, used);
+		used.add(next);
+		if (next !== name) names.set(name, next);
+	}
+	return names.size > 0 ? {
+		chunk,
+		names
+	} : void 0;
+}
+function findSymbolFacadeRewrite(chunk, chunks) {
+	if (!isGeneratedSymbolFacade(chunk)) return void 0;
+	if (chunk.imports.length !== 1 || chunk.dynamicImports.length > 0) return void 0;
+	const parsed = parseSymbolFacade(chunk.code);
+	if (!parsed) return void 0;
+	const target = chunks.get(chunk.imports[0]);
+	if (!target) return void 0;
+	const targetExports = new Set(target.exports);
+	if (!chunk.exports.every((name) => targetExports.has(name))) return void 0;
+	if (!parsed.initExports.every((name) => targetExports.has(name))) return void 0;
+	return {
+		facade: chunk,
+		target,
+		initExports: parsed.initExports
+	};
+}
+function isGeneratedSymbolFacade(chunk) {
+	return (chunk.facadeModuleId ? normalizeVirtualId$2(chunk.facadeModuleId) : "").startsWith(`${MARKLESS_VIRTUAL_PREFIX}symbol:`);
+}
+function isGeneratedSymbolInitExport(name) {
+	return name === SYMBOL_INIT_EXPORT_PREFIX || name.startsWith(`${SYMBOL_INIT_EXPORT_PREFIX}_`) || /^\$\d+$/.test(name.slice(29));
+}
+function compactSymbolInitExportName(name, used) {
+	const suffix = name.match(/\$(\d+)$/)?.[1];
+	let candidate = suffix ? `${SYMBOL_INIT_EXPORT_PREFIX}$${suffix}` : SYMBOL_INIT_EXPORT_PREFIX;
+	let nextSuffix = suffix ? Number(suffix) : 0;
+	while (used.has(candidate)) {
+		nextSuffix++;
+		candidate = `${SYMBOL_INIT_EXPORT_PREFIX}$${nextSuffix}`;
+	}
+	return candidate;
+}
+function collapseGeneratedSymbolInitExports(code, initExports) {
+	if (initExports.length < 2) return void 0;
+	const match = code.match(/export\s*\{\s*([^}]*)\s*\}\s*;?\s*$/);
+	if (!match || match.index === void 0) return void 0;
+	const specifiers = parseExportSpecifiers(match[1]);
+	if (!specifiers) return void 0;
+	if (specifiers.some((specifier) => !isIdentifier(specifier.local))) return void 0;
+	const initExportSet = new Set(initExports);
+	const initLocals = unique(specifiers.filter((specifier) => initExportSet.has(specifier.exported)).map((specifier) => specifier.local));
+	if (initLocals.length < 2) return void 0;
+	const nonInitSpecifiers = specifiers.filter((specifier) => !initExportSet.has(specifier.exported));
+	if (nonInitSpecifiers.some((specifier) => specifier.exported === SYMBOL_INIT_EXPORT_PREFIX)) return;
+	const initLocal = uniqueIdentifier("$i", code);
+	return {
+		code: `${code.slice(0, match.index)}function ${initLocal}(){${initLocals.map((local) => `${local}()`).join(";")}}export{${[`${initLocal} as ${SYMBOL_INIT_EXPORT_PREFIX}`, ...nonInitSpecifiers.map(formatExportSpecifier)].join(",")}};`,
+		exports: [SYMBOL_INIT_EXPORT_PREFIX, ...nonInitSpecifiers.map((specifier) => specifier.exported)]
+	};
+}
+function rewriteDynamicImportSpecifiers(chunk, rewrites) {
+	const rewrittenFacades = /* @__PURE__ */ new Set();
+	return {
+		code: chunk.code.replace(LOCAL_DYNAMIC_IMPORT_HELPER_RE, (match, quote, specifier, parameter, helperName, exportQuote, exportName) => {
+			if (!isLocalSpecifier(specifier)) return match;
+			const importedFileName = resolveChunkSpecifier(chunk.fileName, specifier);
+			const rewrite = rewrites.get(importedFileName);
+			if (!rewrite) return match;
+			if (!rewrite.target.exports.includes(exportName)) return match;
+			const nextSpecifier = relativeChunkSpecifier$1(chunk.fileName, rewrite.target.fileName);
+			rewrittenFacades.add(importedFileName);
+			return `import(${quote}${nextSpecifier}${quote}).then(${parameter}=>${helperName}(${parameter},${exportQuote}${exportName}${exportQuote}))`;
+		}).replace(LOCAL_DYNAMIC_IMPORT_RE, (match, quote, specifier, parameter, exportName) => {
+			if (!isLocalSpecifier(specifier)) return match;
+			const importedFileName = resolveChunkSpecifier(chunk.fileName, specifier);
+			const rewrite = rewrites.get(importedFileName);
+			if (!rewrite) return match;
+			if (rewrite.initExports.length > 0 && (!parameter || !exportName)) return match;
+			const nextSpecifier = relativeChunkSpecifier$1(chunk.fileName, rewrite.target.fileName);
+			rewrittenFacades.add(importedFileName);
+			const nextImport = `import(${quote}${nextSpecifier}${quote})`;
+			if (!parameter || !exportName || rewrite.initExports.length === 0) return nextImport;
+			return `${nextImport}.then(${parameter}=>(${[...rewrite.initExports.map((name) => `${parameter}.${name}()`), `${parameter}.${exportName}`].join(",")}))`;
+		}),
+		rewrittenFacades
+	};
+}
+function compactDirectSymbolLoadersInCode(code) {
+	let next = "";
+	let cursor = 0;
+	let compacted = 0;
+	for (let match = FUNCTION_DECLARATION_RE.exec(code); match; match = FUNCTION_DECLARATION_RE.exec(code)) {
+		const functionStart = match.index;
+		const bodyStart = FUNCTION_DECLARATION_RE.lastIndex;
+		const bodyEnd = findBlockEnd(code, bodyStart - 1);
+		if (bodyEnd < 0) continue;
+		const body = code.slice(bodyStart, bodyEnd);
+		const mapName = uniqueIdentifier("$s", `${code}${next}`);
+		const moduleCacheName = uniqueIdentifier("$m", `${code}${next}${mapName}`);
+		const replacement = compactDirectSymbolLoaderFunction({
+			functionName: match[1],
+			parameterName: match[2],
+			body,
+			mapName,
+			moduleCacheName
+		});
+		if (!replacement) {
+			FUNCTION_DECLARATION_RE.lastIndex = bodyEnd + 1;
+			continue;
+		}
+		next += code.slice(cursor, functionStart);
+		next += replacement;
+		cursor = bodyEnd + 1;
+		compacted++;
+		FUNCTION_DECLARATION_RE.lastIndex = cursor;
+	}
+	if (compacted === 0) return {
+		code,
+		compacted
+	};
+	return {
+		code: next + code.slice(cursor),
+		compacted
+	};
+}
+function compactDirectSymbolLoaderFunction(input) {
+	const returnSource = input.body.trim();
+	if (!returnSource.startsWith("return ")) return void 0;
+	const parsed = parseDirectSymbolLoaderBranches(returnSource.slice(7), input.parameterName);
+	if (!parsed) return void 0;
+	const first = parsed.branches[0];
+	if (parsed.branches.some((branch) => branch.importSpecifier !== first.importSpecifier || branch.helperName !== first.helperName)) return;
+	const generatedCount = generatedSymbolRangeCount(parsed.branches);
+	if (generatedCount !== void 0) return [
+		`let ${input.moduleCacheName};`,
+		`function ${input.functionName}(${input.parameterName}){`,
+		`let t=+${input.parameterName}.slice(7);`,
+		`if(${input.parameterName}===\`symbol:\${t}\`&&t>=0&&t<${generatedCount}){`,
+		`if(${input.moduleCacheName})return ${first.helperName}(${input.moduleCacheName},\`symbol_\${t}\`);`,
+		`return import(${JSON.stringify(first.importSpecifier)})`,
+		`.then(${first.moduleParameter}=>(${input.moduleCacheName}=${first.moduleParameter},${first.helperName}(${first.moduleParameter},\`symbol_\${t}\`)))`,
+		`}`,
+		`return ${parsed.fallback}`,
+		"}"
+	].join("");
+	const exportVariable = input.parameterName === "t" ? "n" : "t";
+	const mapEntries = parsed.branches.map((branch) => `${JSON.stringify(branch.symbolId)}:${JSON.stringify(branch.exportName)}`).join(",");
+	return [
+		`const ${input.mapName}={${mapEntries}};`,
+		`let ${input.moduleCacheName};`,
+		`function ${input.functionName}(${input.parameterName}){`,
+		`let ${exportVariable}=${input.mapName}[${input.parameterName}];`,
+		`if(${exportVariable}){`,
+		`if(${input.moduleCacheName})return ${first.helperName}(${input.moduleCacheName},${exportVariable});`,
+		`return import(${JSON.stringify(first.importSpecifier)})`,
+		`.then(${first.moduleParameter}=>(${input.moduleCacheName}=${first.moduleParameter},${first.helperName}(${first.moduleParameter},${exportVariable})))`,
+		`}`,
+		`return ${parsed.fallback}`,
+		"}"
+	].join("");
+}
+function parseDirectSymbolLoaderBranches(source, parameterName) {
+	const branches = [];
+	const branchRE = directSymbolLoaderBranchRE(parameterName);
+	let cursor = 0;
+	while (cursor < source.length) {
+		const match = source.slice(cursor).match(branchRE);
+		if (!match) break;
+		const symbolId = simpleStringLiteralValue(match[1]);
+		const importSpecifier = simpleStringLiteralValue(match[2]);
+		const moduleParameter = match[3];
+		const helperName = match[4];
+		const helperArgument = match[5];
+		const exportName = simpleStringLiteralValue(match[6]);
+		if (symbolId === void 0 || importSpecifier === void 0 || exportName === void 0 || moduleParameter !== helperArgument) return;
+		branches.push({
+			symbolId,
+			importSpecifier,
+			moduleParameter,
+			helperName,
+			exportName
+		});
+		cursor += match[0].length;
+	}
+	const fallback = source.slice(cursor);
+	if (branches.length < 2 || !fallback.startsWith("Promise.reject(")) return void 0;
+	return {
+		branches,
+		fallback
+	};
+}
+function generatedSymbolRangeCount(branches) {
+	for (const [index, branch] of branches.entries()) if (branch.symbolId !== `symbol:${index}` || branch.exportName !== `symbol_${index}`) return;
+	return branches.length;
+}
+function directSymbolLoaderBranchRE(parameterName) {
+	return new RegExp(`^${escapeRegExp(parameterName)}\\s*===\\s*(${STRING_LITERAL_SOURCE})\\s*\\?\\s*import\\(\\s*(${STRING_LITERAL_SOURCE})\\s*\\)\\.then\\(\\s*\\(?\\s*([$A-Z_a-z][$\\w]*)\\s*\\)?\\s*=>\\s*([$A-Z_a-z][$\\w]*)\\(\\s*([$A-Z_a-z][$\\w]*)\\s*,\\s*(${STRING_LITERAL_SOURCE})\\s*\\)\\s*\\)\\s*:`);
+}
+function simpleStringLiteralValue(source) {
+	const quote = source[0];
+	if (quote !== "\"" && quote !== "'" && quote !== "`" || source[source.length - 1] !== quote) return;
+	return source.slice(1, -1);
+}
+function findBlockEnd(code, open) {
+	let depth = 0;
+	let quote = null;
+	let escaped = false;
+	for (let index = open; index < code.length; index++) {
+		const char = code[index];
+		if (quote) {
+			if (escaped) {
+				escaped = false;
+				continue;
+			}
+			if (char === "\\") {
+				escaped = true;
+				continue;
+			}
+			if (char === quote) quote = null;
+			continue;
+		}
+		if (char === "\"" || char === "'" || char === "`") {
+			quote = char;
+			continue;
+		}
+		if (char === "{") {
+			depth++;
+			continue;
+		}
+		if (char === "}") {
+			depth--;
+			if (depth === 0) return index;
+		}
+	}
+	return -1;
+}
+function resolveChunkSpecifier(importerFileName, specifier) {
+	return normalize(join(dirname(importerFileName), specifier));
+}
+function relativeChunkSpecifier$1(importerFileName, targetFileName) {
+	const value = relative(dirname(importerFileName), targetFileName).replaceAll("\\", "/");
+	return value.startsWith(".") ? value : `./${value}`;
+}
+function isGeneratedAsyncChunk(chunk) {
+	return chunk.moduleIds.some((id) => {
+		return normalizeVirtualId$2(id).startsWith("virtual:markless:") || TSRX_SOURCE_FILE$1.test(id);
+	});
+}
+function deleteBundleChunk(bundle, fileName) {
+	for (const [key, output] of Object.entries(bundle)) if (isGeneratedChunk$1(output) && output.fileName === fileName) delete bundle[key];
+}
+function isGeneratedChunk$1(value) {
+	if (!value || typeof value !== "object") return false;
+	const chunk = value;
+	return chunk.type === "chunk" && typeof chunk.fileName === "string" && typeof chunk.code === "string" && Array.isArray(chunk.exports) && Array.isArray(chunk.imports) && Array.isArray(chunk.dynamicImports) && Array.isArray(chunk.moduleIds);
+}
+function unique(values) {
+	return [...new Set(values)];
+}
+function replaceIdentifierNames(code, replacements) {
+	const names = [...replacements.keys()].sort((a, b) => b.length - a.length);
+	let next = code;
+	for (const name of names) next = next.replace(identifierNameRE(name), replacements.get(name));
+	return next;
+}
+function identifierNameRE(name) {
+	return new RegExp(`(?<![$\\w])${escapeRegExp(name)}(?![$\\w])`, "g");
+}
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function isLocalSpecifier(specifier) {
+	return specifier.startsWith("./") || specifier.startsWith("../");
+}
+function parseSymbolFacade(code) {
+	const match = code.trim().match(/^import\s*\{\s*([^}]*)\s*\}\s*from\s*(["'`])([^"'`]+)\2\s*;\s*([\s\S]*?)\s*export\s*\{\s*([^}]*)\s*\}\s*;?\s*$/);
+	if (!match) return void 0;
+	const imports = parseImportSpecifiers(match[1]);
+	const exportLocals = parseExportLocalNames(match[5]);
+	if (!imports || !exportLocals) return void 0;
+	const body = match[4].trim();
+	const initLocals = body ? body.split(";").map((statement) => statement.trim()).filter(Boolean).map((statement) => statement.match(/^([$A-Z_a-z][$\w]*)\(\)$/)?.[1]) : [];
+	if (initLocals.some((name) => !name)) return void 0;
+	for (const local of exportLocals) if (!imports.has(local)) return void 0;
+	return { initExports: unique(initLocals.filter((local) => !!local).map((local) => imports.get(local)).filter((name) => !!name)) };
+}
+function parseImportSpecifiers(value) {
+	const imports = /* @__PURE__ */ new Map();
+	for (const part of value.split(",")) {
+		const specifier = part.trim();
+		if (!specifier) continue;
+		const aliased = specifier.match(/^(.+?)\s+as\s+(.+)$/);
+		const imported = (aliased?.[1] ?? specifier).trim();
+		const local = (aliased?.[2] ?? specifier).trim();
+		if (!isIdentifier(imported) || !isIdentifier(local)) return void 0;
+		imports.set(local, imported);
+	}
+	return imports;
+}
+function parseExportLocalNames(value) {
+	const locals = [];
+	for (const part of value.split(",")) {
+		const specifier = part.trim();
+		if (!specifier) continue;
+		const aliased = specifier.match(/^(.+?)\s+as\s+(.+)$/);
+		const local = (aliased?.[1] ?? specifier).trim();
+		const exported = (aliased?.[2] ?? specifier).trim();
+		if (!isIdentifier(local) || !isIdentifier(exported)) return void 0;
+		locals.push(local);
+	}
+	return locals;
+}
+function parseExportSpecifiers(value) {
+	const specifiers = [];
+	for (const part of value.split(",")) {
+		const specifier = part.trim();
+		if (!specifier) continue;
+		const aliased = specifier.match(/^(.+?)\s+as\s+(.+)$/);
+		const local = (aliased?.[1] ?? specifier).trim();
+		const exported = (aliased?.[2] ?? specifier).trim();
+		if (!isIdentifier(local) || !isIdentifier(exported)) return void 0;
+		specifiers.push({
+			local,
+			exported
+		});
+	}
+	return specifiers;
+}
+function formatExportSpecifier(specifier) {
+	return specifier.local === specifier.exported ? specifier.local : `${specifier.local} as ${specifier.exported}`;
+}
+function uniqueIdentifier(base, code) {
+	let candidate = base;
+	let index = 0;
+	while (identifierNameRE(candidate).test(code)) {
+		index++;
+		candidate = `${base}${index}`;
+	}
+	return candidate;
+}
+function isIdentifier(value) {
+	return /^[$A-Z_a-z][$\w]*$/.test(value);
+}
+function normalizeVirtualId$2(id) {
+	return id.startsWith("\0") ? id.slice(1) : id;
+}
+//#endregion
+//#region src/transform.ts
+let oxcTransformSyncPromise;
+function loadOxcTransformSync() {
+	oxcTransformSyncPromise ??= import("rolldown/experimental").then((mod) => mod.transformSync, () => void 0);
+	return oxcTransformSyncPromise;
+}
+async function stripEmittedTypes(code) {
+	const oxcTransformSync = await loadOxcTransformSync();
+	if (!oxcTransformSync) return code;
+	try {
+		const out = oxcTransformSync("markless-emitted.ts", code);
+		if (!out.code || (out.errors?.length ?? 0) > 0) return code;
+		return out.code;
+	} catch {
+		return code;
+	}
+}
+async function transformTsrxModule(input) {
+	const encodedFilename = encodeURIComponent(input.filename);
+	const payloadId = `${MARKLESS_VIRTUAL_PREFIX}payload:${encodedFilename}`;
+	const resolverId = `${MARKLESS_VIRTUAL_PREFIX}resolver:${encodedFilename}`;
+	const resumeId = resumeVirtualModuleId(input.filename);
+	const compiled = await compileTsrxModule({
+		filename: input.filename,
+		source: input.source,
+		buildId: input.buildId,
+		resolverId,
+		symbols: []
+	});
+	const symbolRows = compiled.symbolModules.modules.map((module) => ({
+		id: module.symbolId,
+		chunk: symbolVirtualModuleId(input.filename, module.symbolId),
+		exportName: scopedSymbolExportName(input.filename, module.exportName)
+	}));
+	const resolverSource = emitSymbolResolverModule({
+		buildId: input.buildId,
+		symbols: symbolRows
+	});
+	const symbolRoutes = compiled.semanticGraph.componentEdges.flatMap((edge, index) => edge.importSource ? [{
+		prefix: `c${index}:`,
+		importSource: edge.importSource
+	}] : []);
+	const executionLogModuleHookMode = input.executionLogModuleHooks === false ? "never" : input.executionLog;
+	const manifest = {
+		source: input.filename,
+		payload: { virtualModuleId: payloadId },
+		resolver: { virtualModuleId: resolverId },
+		symbols: compiled.symbolModules.modules.map((module, index) => ({
+			symbolId: module.symbolId,
+			kind: module.kind,
+			exportName: symbolRows[index].exportName,
+			virtualModuleId: symbolVirtualModuleId(input.filename, module.symbolId)
+		})),
+		runtimeDemandMap: compiled.runtimeDemandMap
+	};
+	const styleScope = compiled.publicRenderPlan.styleScopes[0];
+	const styleId = styleScope ? `${MARKLESS_VIRTUAL_PREFIX}style:${encodedFilename}.css` : null;
+	const virtualModules = [
+		...styleScope && styleId ? [{
+			id: styleId,
+			type: "style",
+			source: styleScope.cssText
+		}] : [],
+		{
+			id: payloadId,
+			type: "payload",
+			source: payloadModule({
+				...compiled.payloadScripts,
+				runtimeDemandMap: compiled.runtimeDemandMap
+			})
+		},
+		{
+			id: resolverId,
+			type: "resolver",
+			source: resolverSource
+		},
+		{
+			id: resumeId,
+			type: "resume",
+			source: emitResumeModule({
+				payloadId,
+				resolverId,
+				payloadState: compiled.payloadScripts.state,
+				payloadView: containerScopedResumeView(compiled.payloadScripts.view),
+				runtimeDemandMap: compiled.runtimeDemandMap,
+				executionLog: input.executionLog,
+				needsFullResume: needsFullResume(compiled.protocolView, compiled.runtimeDemandMap),
+				symbols: symbolRows,
+				symbolRoutes
+			})
+		},
+		...await Promise.all(compiled.symbolModules.modules.map(async (module, index) => ({
+			id: symbolVirtualModuleId(input.filename, module.symbolId),
+			type: "symbol",
+			symbolId: module.symbolId,
+			exportName: symbolRows[index].exportName,
+			source: injectExecutionLogModuleHook(await stripEmittedTypes(rewriteSymbolModuleExport(module.source, module.exportName, symbolRows[index].exportName)), `symbol:${module.symbolId}`, executionLogModuleHookMode)
+		})))
+	];
+	return {
+		code: (styleId ? `import ${JSON.stringify(styleId)};\n` : "") + await stripEmittedTypes(emitSourceModule({
+			filename: input.filename,
+			payloadId,
+			resolverId,
+			environment: input.environment ?? "lib",
+			clientOutput: input.clientOutput ?? "full",
+			executionLog: input.executionLog,
+			headInjections: input.headInjections,
+			devResumeReexport: input.devResumeReexport === true,
+			needsFullResume: needsFullResume(compiled.protocolView, compiled.runtimeDemandMap),
+			resumeModuleUrl: input.resumeModuleUrl,
+			publicRenderModuleSource: compiled.publicRenderModule.moduleSource,
+			publicRenderRootExportName: compiled.publicRenderModule.rootExportName,
+			publicCsrModuleSource: compiled.publicRenderModule.csrModuleSource,
+			publicRenderCsrExportName: compiled.publicRenderModule.csrExportName,
+			publicSsrModuleSource: compiled.publicRenderModule.ssrModuleSource,
+			publicRenderSsrExportName: compiled.publicRenderModule.ssrExportName,
+			symbols: symbolRows,
+			symbolRoutes
+		})),
+		map: null,
+		virtualModules,
+		manifest
+	};
+}
+function containerScopedResumeView(view) {
+	return {
+		...view,
+		locators: (view.locators ?? []).map((locator) => ({
+			...locator,
+			index: locator.index + 1
+		}))
+	};
+}
+function needsFullResume(view, runtimeDemandMap) {
+	if ((view.branches?.length ?? 0) > 0) return true;
+	if ((view.elementHandles?.length ?? 0) > 0) return true;
+	if ((view.asyncBoundaries?.length ?? 0) > 0) return true;
+	if ((view.keyedRepeats?.length ?? 0) === 0) return false;
+	return !recordKindReplaced(runtimeDemandMap, "keyed-repeat");
+}
+function recordKindReplaced(runtimeDemandMap, kind) {
+	return runtimeDemandMap.recordKinds.some((record) => record.kind === kind && record.replaced === true);
+}
+//#endregion
+//#region src/build/symbol-table.ts
+const SYMBOL_VIRTUAL_PREFIX = `${MARKLESS_VIRTUAL_PREFIX}symbol:`;
+const SYMBOL_VIRTUAL_STRING_RE$1 = /(["'`])((?:virtual:markless:symbol:)[^"'`]+)\1/g;
+const SYMBOL_MANIFEST_TUPLE_RE = /(\[1,(?:null|["'`][^"'`]*["'`]),(?:null|["'`][^"'`]*["'`]),)(\[[^\]]*\]),(\[[^\]]*\]),(\{[^}]*\})(\])/g;
+const STRING_LITERAL_RE = /(["'`])([^"'`]*)\1/g;
+const SYMBOL_ROW_RE = /((?:["'`][^"'`]*["'`])\s*:\s*\[)(\d+)(,\s*\d+\])/g;
+function rewriteGeneratedSymbolTableUrls(bundle) {
+	const chunks = collectChunks(bundle);
+	const symbolFiles = collectGeneratedSymbolFiles(chunks);
+	let rewritten = 0;
+	const unresolved = /* @__PURE__ */ new Set();
+	for (const chunk of chunks.values()) {
+		if (!chunk.code.includes(SYMBOL_VIRTUAL_PREFIX)) continue;
+		const result = rewriteSymbolVirtualStrings(chunk, symbolFiles);
+		chunk.code = result.code;
+		rewritten += result.rewritten;
+		for (const id of result.unresolved) unresolved.add(id);
+	}
+	return {
+		rewritten,
+		unresolved: [...unresolved].sort()
+	};
+}
+function collectChunks(bundle) {
+	const chunks = /* @__PURE__ */ new Map();
+	for (const output of Object.values(bundle)) if (isGeneratedChunk(output)) chunks.set(output.fileName, output);
+	return chunks;
+}
+function collectGeneratedSymbolFiles(chunks) {
+	const symbolFiles = /* @__PURE__ */ new Map();
+	for (const chunk of chunks.values()) for (const id of virtualIds(chunk)) if (id.startsWith(SYMBOL_VIRTUAL_PREFIX)) symbolFiles.set(id, chunk.fileName);
+	return symbolFiles;
+}
+function virtualIds(chunk) {
+	return [chunk.facadeModuleId ?? void 0, ...chunk.moduleIds].filter((id) => !!id).map(normalizeVirtualId$1);
+}
+function rewriteSymbolVirtualStrings(chunk, symbolFiles) {
+	let rewritten = 0;
+	const unresolved = /* @__PURE__ */ new Set();
+	return {
+		code: compactSymbolManifestTables(chunk.code.replace(SYMBOL_VIRTUAL_STRING_RE$1, (match, _quote, virtualId) => {
+			const fileName = symbolFiles.get(virtualId);
+			if (!fileName) {
+				unresolved.add(virtualId);
+				return match;
+			}
+			rewritten++;
+			return JSON.stringify(relativeChunkSpecifier(chunk.fileName, fileName));
+		})),
+		rewritten,
+		unresolved: [...unresolved]
+	};
+}
+function compactSymbolManifestTables(code) {
+	return code.replace(SYMBOL_MANIFEST_TUPLE_RE, (match, prefix, moduleUrlsSource, exportNamesSource, symbolRowsSource, suffix) => {
+		const moduleUrls = parseStringArray(moduleUrlsSource);
+		if (!moduleUrls) return match;
+		const nextModuleUrls = [];
+		const moduleIndexMap = /* @__PURE__ */ new Map();
+		const seen = /* @__PURE__ */ new Map();
+		for (const [index, moduleUrl] of moduleUrls.entries()) {
+			let nextIndex = seen.get(moduleUrl);
+			if (nextIndex === void 0) {
+				nextIndex = nextModuleUrls.length;
+				seen.set(moduleUrl, nextIndex);
+				nextModuleUrls.push(moduleUrl);
+			}
+			moduleIndexMap.set(index, nextIndex);
+		}
+		if (nextModuleUrls.length === moduleUrls.length) return match;
+		const nextSymbolRows = symbolRowsSource.replace(SYMBOL_ROW_RE, (rowMatch, rowPrefix, moduleIndexSource, rowSuffix) => {
+			const moduleIndex = Number(moduleIndexSource);
+			const nextModuleIndex = moduleIndexMap.get(moduleIndex);
+			if (nextModuleIndex === void 0) return rowMatch;
+			return `${rowPrefix}${nextModuleIndex}${rowSuffix}`;
+		});
+		return `${prefix}${JSON.stringify(nextModuleUrls)},${exportNamesSource},${nextSymbolRows}${suffix}`;
+	});
+}
+function parseStringArray(source) {
+	const values = [];
+	let end = 1;
+	for (const match of source.matchAll(STRING_LITERAL_RE)) {
+		values.push(match[2]);
+		end = (match.index ?? 0) + match[0].length;
+	}
+	if (source.slice(end).trim() !== "]") return void 0;
+	return values;
+}
+function relativeChunkSpecifier(importerFileName, targetFileName) {
+	const value = relative(dirname(importerFileName), targetFileName).replaceAll("\\", "/");
+	return value.startsWith(".") ? value : `./${value}`;
+}
+function isGeneratedChunk(value) {
+	if (!value || typeof value !== "object") return false;
+	const chunk = value;
+	return chunk.type === "chunk" && typeof chunk.fileName === "string" && typeof chunk.code === "string" && Array.isArray(chunk.moduleIds);
+}
+function normalizeVirtualId$1(id) {
+	return id.startsWith("\0") ? id.slice(1) : id;
+}
+//#endregion
+//#region src/dev.ts
+function createMarklessDevGraph() {
+	const parentModules = /* @__PURE__ */ new Map();
+	return {
+		record(parent, ids, environment) {
+			const entries = [...ids];
+			for (const path of parentKeys(parent)) {
+				const key = parentKey(environment, path);
+				const existing = parentModules.get(key) ?? /* @__PURE__ */ new Set();
+				for (const id of entries) existing.add(id);
+				parentModules.set(key, existing);
+			}
+		},
+		clear(parent, environment) {
+			const deleted = [];
+			for (const currentEnvironment of targetEnvironments(environment)) for (const path of parentKeys(parent)) {
+				const key = parentKey(currentEnvironment, path);
+				const ids = parentModules.get(key);
+				if (!ids) continue;
+				deleted.push(...ids);
+				parentModules.delete(key);
+			}
+			return [...new Set(deleted)];
+		},
+		reset() {
+			parentModules.clear();
+		}
+	};
+}
+function targetEnvironments(environment) {
+	if (environment) return [environment];
+	return allEnvironments;
+}
+const allEnvironments = [
+	"client",
+	"server",
+	"lib"
+];
+function parentKeys(parent) {
+	const path = pathname$1(parent);
+	const normalized = normalize(path);
+	const leadingPath = withLeadingSlash(normalized);
+	const barePath = leadingPath.slice(1);
+	return new Set([
+		path,
+		normalized,
+		leadingPath,
+		barePath
+	]);
+}
+function parentKey(environment, parent) {
+	return `${environment}:${parent}`;
+}
+function pathname$1(id) {
+	return parsePath(id).pathname;
+}
+//#endregion
+//#region src/rolldown.ts
+const TSRX_SOURCE_FILE = /\.tsrx(?:[?#].*)?$/;
+const MARKLESS_SYMBOL_SOURCE_QUERY_RE = /[?&]markless-symbols(?:[&#]|$)/;
+const MARKLESS_RESUME_SOURCE_QUERY_RE = /[?&]markless-resume(?:[&#]|$)/;
+const RESUME_VIRTUAL_ID_RE = /^virtual:markless:resume:([^:]+)$/;
+const SYMBOL_VIRTUAL_STRING_RE = /(["'`])((?:virtual:markless:symbol:)[^"'`]+)\1/g;
+const marklessClient = (options = {}) => createMarklessRolldownPlugin({
+	environment: "client",
+	options
+});
+const marklessServer = (options = {}) => createMarklessRolldownPlugin({
+	environment: "server",
+	options
+});
+const marklessLib = (options = {}) => createMarklessRolldownPlugin({
+	environment: "lib",
+	options
+});
+function createMarklessRolldownPlugin(input) {
+	const environment = input.environment;
+	const internalOptions = input.options ?? {};
+	const virtualModules = /* @__PURE__ */ new Map();
+	const transformManifests = /* @__PURE__ */ new Map();
+	const sourceVirtualModules = /* @__PURE__ */ new Map();
+	const clientSymbolEntrySources = /* @__PURE__ */ new Set();
+	const executionLogEstimatedSizes = /* @__PURE__ */ new Map();
+	const dev = createMarklessDevGraph();
+	let root = internalOptions.rootDir;
+	const name = pluginName(environment);
+	function getEnvironment(context) {
+		if (typeof environment === "function") return environment(context);
+		return environment;
+	}
+	function getRoot() {
+		return root ?? internalOptions.rootDir;
+	}
+	return {
+		api: { invalidateGeneratedModules(parent, currentEnvironment) {
+			const ids = dev.clear(parent, currentEnvironment);
+			for (const id of ids) virtualModules.delete(id);
+			return ids.map(resolveVirtualId);
+		} },
+		name,
+		options(input) {
+			if (getEnvironment(this) !== "client") return input;
+			return {
+				...input,
+				preserveEntrySignatures: input.preserveEntrySignatures ?? "allow-extension"
+			};
+		},
+		async buildStart(input) {
+			if (!root) root = internalOptions.rootDir ?? input.cwd;
+			clientSymbolEntrySources.clear();
+			virtualModules.clear();
+			transformManifests.clear();
+			sourceVirtualModules.clear();
+			executionLogEstimatedSizes.clear();
+			dev.reset();
+			const currentRoot = getRoot();
+			if (getEnvironment(this) === "client") for (const source of clientSymbolEntries(input.input, currentRoot)) clientSymbolEntrySources.add(source);
+		},
+		outputOptions(output) {
+			return outputDefaults(output, getEnvironment(this));
+		},
+		async resolveId(source, importer) {
+			if (source.startsWith("@markless/web/fns/")) {
+				const resolved = import.meta.resolve(source);
+				if (resolved?.startsWith("file://")) return { id: decodeURIComponent(resolved.slice(7)) };
+			}
+			if (source.startsWith("@markless/web/inline/")) {
+				const resolvedRoot = import.meta.resolve("@markless/web");
+				if (resolvedRoot?.startsWith("file://") && resolvedRoot.endsWith("/index.ts")) {
+					const helperPath = source.slice(14);
+					return { id: decodeURIComponent(resolvedRoot.slice(7, -8) + `${helperPath}.ts`) };
+				}
+			}
+			const normalized = normalizeVirtualId(source);
+			if (normalized === "virtual:markless:dev-log") return {
+				id: resolveVirtualId(MARKLESS_EXECUTION_LOG_MODULE_ID),
+				moduleSideEffects: true
+			};
+			if (virtualModules.has(normalized)) return {
+				id: resolveVirtualId(normalized),
+				moduleSideEffects: true
+			};
+			const symbolSource = sourceForSymbolVirtualImporter(importer);
+			if (symbolSource && isRelativeImport(source)) return await this.resolve(source, symbolSource, { skipSelf: true });
+			const resumeSource = sourceForResumeVirtualImporter(importer);
+			if (resumeSource && isRelativeImport(source)) return await this.resolve(source, resumeSource, { skipSelf: true });
+			return null;
+		},
+		load(id) {
+			if (normalizeVirtualId(id) === "virtual:markless:dev-log") return executionLogVirtualModuleSource({
+				moduleSizes: internalOptions.dev === true && getEnvironment(this) === "client" ? executionLogEstimatedSizes : void 0,
+				sizesUrl: internalOptions.dev === true ? void 0 : internalOptions.publicPath?.(MARKLESS_EXECUTION_SIZES) ?? `/${MARKLESS_EXECUTION_SIZES}`
+			});
+			const module = virtualModules.get(normalizeVirtualId(id));
+			if (module) return virtualModuleSourceForLoad(module, {
+				dev: internalOptions.dev === true && getEnvironment(this) === "client",
+				publicPath: internalOptions.publicPath
+			});
+			return null;
+		},
+		async transform(code, id) {
+			const currentEnvironment = getEnvironment(this);
+			const virtualId = normalizeVirtualId(id);
+			if (!TSRX_SOURCE_FILE.test(id)) {
+				if (currentEnvironment === "client" && internalOptions.dev === true && normalizeExecutionLogMode(internalOptions.executionLog) !== "never" && isMarklessRuntimeModule(id)) {
+					executionLogEstimatedSizes.set(executionLogRuntimeModuleId(id), code.length);
+					return {
+						code: injectExecutionLogModuleHook(code, executionLogRuntimeModuleId(id), internalOptions.executionLog),
+						map: null
+					};
+				}
+				return null;
+			}
+			if (virtualId.startsWith("virtual:markless:")) return null;
+			const source = pathname(id);
+			clearSourceVirtualModules(source, virtualModules, sourceVirtualModules);
+			const transformed = await transformTsrxModule({
+				filename: source,
+				source: code,
+				buildId: internalOptions.buildId,
+				executionLog: normalizeExecutionLogMode(internalOptions.executionLog),
+				executionLogModuleHooks: internalOptions.dev === true && currentEnvironment === "client",
+				environment: currentEnvironment,
+				clientOutput: currentEnvironment === "client" && (clientSymbolEntrySources.has(source) || isSymbolOnlySourceRequest(id)) ? "symbols-only" : void 0,
+				resumeModuleUrl: internalOptions.dev === true && currentEnvironment === "server" ? devBrowserSourceModuleUrl(source, getRoot(), internalOptions.publicPath) : void 0,
+				headInjections: internalOptions.dev === true && currentEnvironment === "server" ? internalOptions.devInjections : void 0,
+				devResumeReexport: internalOptions.dev === true && currentEnvironment === "client"
+			});
+			registerTransformArtifacts({
+				source,
+				result: transformed,
+				virtualModules,
+				transformManifests,
+				sourceVirtualModules,
+				executionLogEstimatedSizes,
+				dev,
+				environment: currentEnvironment
+			});
+			if (currentEnvironment === "client" && isResumeSourceRequest(id)) {
+				const resumeModule = transformed.virtualModules.find((module) => module.type === "resume");
+				if (resumeModule) return {
+					code: resumeModule.source,
+					map: null
+				};
+			}
+			if (currentEnvironment === "client" && !internalOptions.dev) for (const module of transformed.virtualModules.filter((item) => item.type === "symbol" || item.type === "resume" && internalOptions.emitResumeModules === true && clientSymbolEntrySources.has(source))) this.emitFile({
+				type: "chunk",
+				id: module.id,
+				preserveSignature: "strict"
+			});
+			return transformed;
+		},
+		generateBundle: {
+			order: "post",
+			async handler(_, bundle) {
+				if (getEnvironment(this) !== "client") return;
+				stripEmptyPreloadWrappersFromChunks(bundle);
+				const removedSymbolFacades = rewriteGeneratedSymbolFacadeImports(bundle);
+				rewriteGeneratedSymbolInitExports(bundle);
+				compactGeneratedDirectSymbolLoaders(bundle);
+				const manifestBundle = bundleWithoutRemovedChunks(bundle, removedSymbolFacades);
+				const tableRewrite = rewriteGeneratedSymbolTableUrls(manifestBundle);
+				if (tableRewrite.unresolved.length > 0) this.error(`Markless symbol resolver table contains unresolved generated symbol chunks: ${tableRewrite.unresolved.join(", ")}`);
+				const clientManifest = createBuildMetadata(manifestBundle, transformManifests.values(), getRoot(), {
+					bundleGraphAsset: MARKLESS_BUNDLE_GRAPH,
+					bundleGraphAdders: internalOptions.bundleGraphAdders,
+					canonPath: stripBuildPrefix,
+					publicPath: internalOptions.publicPath,
+					injections: internalOptions.devInjections
+				});
+				const executionLogInjection = executionLogActivationInjection(internalOptions.executionLog);
+				if (executionLogInjection) injectHeadLinks(bundle, [executionLogInjection]);
+				injectHeadLinks(bundle, collectModulePreloadInjections(clientManifest, {
+					publicPath: internalOptions.publicPath,
+					entryChunks: Object.values(bundle).filter((output) => !!output && typeof output === "object" && output.type === "chunk" && output.isEntry === true).map((chunk) => stripBuildPrefix(chunk.fileName))
+				}));
+				this.emitFile({
+					type: "asset",
+					fileName: MARKLESS_BUNDLE_GRAPH,
+					source: JSON.stringify(clientManifest.bundleGraph)
+				});
+				this.emitFile(await createExecutionSizesAsset(manifestBundle, clientManifest, stripBuildPrefix));
+				this.emitFile({
+					type: "asset",
+					fileName: `${MARKLESS_BUILD_PREFIX}execution-demand.json`,
+					source: JSON.stringify(Object.fromEntries(clientManifest.modules.filter((module) => module.runtimeDemandMap).map((module) => [module.source, module.runtimeDemandMap])))
+				});
+			}
+		}
+	};
+}
+function bundleWithoutRemovedChunks(bundle, removedFileNames) {
+	if (removedFileNames.size === 0) return bundle;
+	const next = {};
+	for (const [key, output] of Object.entries(bundle)) {
+		if (isChunkFile(output) && removedFileNames.has(output.fileName)) continue;
+		next[key] = output;
+	}
+	return next;
+}
+function stripEmptyPreloadWrappersFromChunks(bundle) {
+	for (const output of Object.values(bundle)) {
+		if (!isChunkWithCode(output)) continue;
+		const nextCode = stripEmptyVitePreloadWrappers(output.code);
+		if (nextCode !== output.code) output.code = nextCode;
+	}
+}
+function isChunkFile(output) {
+	if (!output || typeof output !== "object") return false;
+	const chunk = output;
+	return chunk.type === "chunk" && typeof chunk.fileName === "string";
+}
+function isChunkWithCode(output) {
+	if (!output || typeof output !== "object") return false;
+	const chunk = output;
+	return chunk.type === "chunk" && typeof chunk.code === "string";
+}
+function pluginName(environment) {
+	if (typeof environment === "function") return "markless:rolldown";
+	return `markless:rolldown:${environment}`;
+}
+function registerTransformArtifacts(input) {
+	const ids = /* @__PURE__ */ new Set();
+	for (const module of input.result.virtualModules) {
+		const isClientSymbol = input.environment === "client" && module.type === "symbol";
+		const stored = isClientSymbol ? {
+			...module,
+			source: requalifyExecutionLogModuleHook(module.source, module.id)
+		} : module;
+		input.virtualModules.set(module.id, stored);
+		ids.add(module.id);
+		if (isClientSymbol) input.executionLogEstimatedSizes.set(module.id, stored.source.length);
+	}
+	input.transformManifests.set(input.source, input.result.manifest);
+	input.sourceVirtualModules.set(input.source, ids);
+	input.dev.record(input.source, ids, input.environment);
+}
+function clearSourceVirtualModules(source, virtualModules, sourceVirtualModules) {
+	const stale = sourceVirtualModules.get(source);
+	if (!stale) return;
+	for (const id of stale) virtualModules.delete(id);
+	sourceVirtualModules.delete(source);
+}
+function stripBuildPrefix(fileName) {
+	return fileName.startsWith(MARKLESS_BUILD_PREFIX) ? fileName.slice(MARKLESS_BUILD_PREFIX.length) : fileName;
+}
+function virtualModuleSourceForLoad(module, options) {
+	if (!options.dev || module.type !== "resolver") return module.source;
+	if (!module.source.includes("moduleUrls[row[0]]")) return module.source;
+	return module.source.replace(SYMBOL_VIRTUAL_STRING_RE, (_match, _quote, virtualId) => JSON.stringify(devBrowserVirtualModuleUrl(virtualId, options.publicPath)));
+}
+function devBrowserSourceModuleUrl(source, _root, publicPath) {
+	const path = withQuery(joinURL("@fs", withoutLeadingSlash(source)), { import: null });
+	return publicPath ? publicPath(path) : joinURL("/", path);
+}
+function devBrowserVirtualModuleUrl(virtualId, publicPath) {
+	const path = joinURL("@id", resolveVirtualId(virtualId).replace("\0", "__x00__"));
+	return publicPath ? publicPath(path) : joinURL("/", path);
+}
+function clientSymbolEntries(input, root) {
+	if (!input || typeof input !== "object" || Array.isArray(input)) return [];
+	const sources = [];
+	for (const [name, value] of Object.entries(input)) {
+		if (!/symbol/i.test(name)) continue;
+		for (const entry of inputEntryValues(value)) if (typeof entry === "string" && TSRX_SOURCE_FILE.test(entry)) sources.push(normalizeInputSource(entry, root));
+	}
+	return sources;
+}
+function inputEntryValues(value) {
+	return Array.isArray(value) ? value.flatMap(inputEntryValues) : [value];
+}
+function normalizeInputSource(source, root) {
+	const path = pathname(source);
+	if (isAbsolute(path)) return path;
+	return pathname(resolve(root ?? "", path));
+}
+function isSymbolOnlySourceRequest(id) {
+	return MARKLESS_SYMBOL_SOURCE_QUERY_RE.test(id);
+}
+function isResumeSourceRequest(id) {
+	return MARKLESS_RESUME_SOURCE_QUERY_RE.test(id);
+}
+function sourceForSymbolVirtualImporter(importer) {
+	if (!importer) return null;
+	return symbolVirtualModuleSourceFile(normalizeVirtualId(importer));
+}
+function sourceForResumeVirtualImporter(importer) {
+	if (!importer) return null;
+	const match = normalizeVirtualId(importer).match(RESUME_VIRTUAL_ID_RE);
+	return match?.[1] ? decodeURIComponent(match[1]) : null;
+}
+function isRelativeImport(source) {
+	return source.startsWith("./") || source.startsWith("../");
+}
+function isMarklessRuntimeModule(id) {
+	const path = pathname(id);
+	return /[/\\](?:web|runtime|serializer)[/\\]src[/\\].+\.ts$/.test(path);
+}
+function executionLogRuntimeModuleId(id) {
+	const path = pathname(id);
+	const match = path.match(/[/\\](web|runtime|serializer)[/\\]src[/\\]([^?#]+)\.ts$/);
+	return match ? `${match[1]}:${match[2].replace(/[/\\]/g, "/")}` : path;
+}
+function normalizeVirtualId(id) {
+	const bare = id.startsWith("\0") ? id.slice(1) : id;
+	if (!bare.startsWith("virtual:markless:")) return bare;
+	const queryIndex = bare.indexOf("?");
+	return `${MARKLESS_VIRTUAL_PREFIX}${(queryIndex === -1 ? bare : bare.slice(0, queryIndex)).slice(MARKLESS_VIRTUAL_PREFIX.length).split(":").map((segment) => {
+		try {
+			return encodeURIComponent(decodeURIComponent(segment));
+		} catch {
+			return segment;
+		}
+	}).join(":")}`;
+}
+function resolveVirtualId(id) {
+	if (id.startsWith("\0")) return id;
+	return `\0${id}`;
+}
+function pathname(id) {
+	return parsePath(id).pathname;
+}
+//#endregion
+export { transformTsrxModule as a, convertManifestToBundleGraph as c, marklessServer as i, createPreloadGraphAdder as l, marklessClient as n, createBuildMetadata as o, marklessLib as r, collectHeadLinkInjections as s, createMarklessRolldownPlugin as t };