@markless/bundler 0.8.0 → 0.10.0

package/dist/lazy-module-facades-qZajWDD8.js

@@ -0,0 +1,2691 @@
+import { S as withoutMachinePaths, d as startupPackOfLazy, g as rootRelativeId, l as packOfPiece, m as warmPacksSuffix } from "./route-pack-groups-ByQmKKom.js";
+import { _ as spansAnyOffset, a as chunkLocalExportSpecifiers, c as knowsChunkDynamicImports, d as prefetchChunkParses, f as readChunkDynamicImports, g as renderedChunkCount, h as rememberChunkLocalExportSpecifiers, i as chunkDynamicImports, l as mayContainDynamicImport, m as rememberChunkDynamicImports, o as clearChunkFactCaches, p as readChunkLocalExportSpecifiers, r as calleeOffsets, u as parseChunkCode, v as textOffsets } from "./chunk-ast-pN_P5wIo.js";
+import { deserialize } from "node:v8";
+import { Worker } from "node:worker_threads";
+import { callsImportedOrFreeName, parseJavaScriptModule } from "@markless/compiler";
+import { basename, dirname, join, normalize, relative } from "pathe";
+import { RolldownMagicString } from "rolldown";
+import { availableParallelism } from "node:os";
+//#region src/build/async-import-wrappers.ts
+/**
+* Vite rewrites `(await import(x)).a` and `const {a} = await import(x)` into
+* `(async()=>{let{a:e}=await import(x);return{a:e}})()` so it can preload
+* around it. Once the preload call is stripped, that wrapper is only a detour:
+* a reader that takes named keys off the awaited wrapper reads them off
+* `await import(x)` instead, and any other reader gets
+* `import(x).then(m=>({a:m.a}))`, which resolves to the same snapshot object.
+*/
+async function unwrapAsyncImportWrappers(bundle) {
+	const chunks = Object.values(bundle).filter((output) => isChunk(output) && output.code.includes("async()=>{"));
+	const unwrapped = await Promise.all(chunks.map((chunk) => runChunkTask("unwrappedAsyncImports", chunk.fileName ?? "chunk.js", chunk.code)));
+	for (const [index, chunk] of chunks.entries()) chunk.code = unwrapped[index];
+}
+const GAP = String.raw`(?:\s|/\*[\s\S]*?\*/|//[^\n]*\n)*`;
+const WRAPPER_OPENING = new RegExp(`async${GAP}\\(${GAP}\\)${GAP}=>${GAP}\\{${GAP}(?:let|const)${GAP}\\{`);
+function unwrapAsyncImportWrappersInCode(code) {
+	if (!WRAPPER_OPENING.test(code)) return code;
+	let program;
+	try {
+		const parsed = parseChunkCode("chunk.js", code);
+		if (parsed.errors.length) return code;
+		program = parsed.program;
+	} catch {
+		return code;
+	}
+	const edits = [];
+	walk$3(program, [], textOffsets(code, "async"), (node, parents) => {
+		const wrapper = asyncImportWrapper(node);
+		if (!wrapper) return true;
+		const source = code.slice(wrapper.awaited.start, wrapper.awaited.end);
+		const readerEdits = keyReaderEdits(node, parents, wrapper.keys);
+		if (readerEdits) edits.push({
+			start: node.start,
+			end: node.end,
+			text: source
+		}, ...readerEdits);
+		else {
+			const entries = [...wrapper.keys].map(([key, imported]) => `${propertyKey(key)}:${member(imported)}`);
+			edits.push({
+				start: node.start,
+				end: node.end,
+				text: `${source}.then(m=>({${entries.join(",")}}))`
+			});
+		}
+		return false;
+	});
+	let next = code;
+	for (const edit of edits.sort((a, b) => b.start - a.start)) next = next.slice(0, edit.start) + edit.text + next.slice(edit.end);
+	return next;
+}
+function asyncImportWrapper(call) {
+	if (call.type !== "CallExpression" || call.arguments.length > 0 || call.optional) return void 0;
+	let callee = call.callee;
+	while (callee.type === "ParenthesizedExpression") callee = callee.expression;
+	if (callee.type !== "ArrowFunctionExpression" || callee.async !== true || callee.params.length > 0) return void 0;
+	const body = callee.body;
+	const statements = body.type === "BlockStatement" ? body.body : [];
+	const [declaration, returned] = statements;
+	if (statements.length !== 2 || declaration?.type !== "VariableDeclaration" || declaration.kind === "var" || declaration.declarations.length !== 1 || returned?.type !== "ReturnStatement") return void 0;
+	const declarator = declaration.declarations[0];
+	const pattern = declarator.id;
+	const awaited = declarator.init;
+	const object = returned.argument;
+	if (pattern.type !== "ObjectPattern" || awaited?.type !== "AwaitExpression" || object?.type !== "ObjectExpression") return void 0;
+	const bound = /* @__PURE__ */ new Map();
+	for (const property of pattern.properties) {
+		const key = plainKey(property);
+		const value = property.value;
+		if (key === void 0 || value.type !== "Identifier") return void 0;
+		bound.set(value.name, key);
+	}
+	const keys = /* @__PURE__ */ new Map();
+	for (const property of object.properties) {
+		const key = plainKey(property);
+		const value = property.value;
+		if (key === void 0 || property.method || value.type !== "Identifier" || keys.has(key)) return void 0;
+		const imported = bound.get(value.name);
+		if (imported === void 0) return void 0;
+		keys.set(key, imported);
+	}
+	return {
+		awaited: awaited.argument,
+		keys
+	};
+}
+function keyReaderEdits(call, parents, keys) {
+	let index = parents.length - 1;
+	while (parents[index]?.type === "ParenthesizedExpression") index--;
+	if (parents[index]?.type !== "AwaitExpression") return void 0;
+	index--;
+	while (parents[index]?.type === "ParenthesizedExpression") index--;
+	const reader = parents[index];
+	const called = parents[index - 1]?.type === "CallExpression" && parents[index - 1].callee === reader;
+	if (reader?.type === "MemberExpression" && !reader.computed && !reader.optional && !called) {
+		const property = reader.property;
+		const imported = keys.get(property.name);
+		return imported !== void 0 && IDENTIFIER.test(imported) ? [{
+			start: property.start,
+			end: property.end,
+			text: imported
+		}] : void 0;
+	}
+	const pattern = reader?.type === "VariableDeclarator" ? reader.id : void 0;
+	if (pattern?.type !== "ObjectPattern") return void 0;
+	const edits = [];
+	for (const property of pattern.properties) {
+		const key = plainKey(property);
+		const imported = key === void 0 ? void 0 : keys.get(key);
+		if (imported === void 0) return void 0;
+		const node = property.key;
+		edits.push(property.shorthand ? {
+			start: node.start,
+			end: node.start,
+			text: `${propertyKey(imported)}:`
+		} : {
+			start: node.start,
+			end: node.end,
+			text: propertyKey(imported)
+		});
+	}
+	return edits;
+}
+const IDENTIFIER = /^[$A-Z_a-z][$\w]*$/;
+function member(name) {
+	return IDENTIFIER.test(name) ? `m.${name}` : `m[${JSON.stringify(name)}]`;
+}
+function propertyKey(name) {
+	return IDENTIFIER.test(name) ? name : JSON.stringify(name);
+}
+function plainKey(property) {
+	if (property.type !== "Property" || property.computed || property.kind !== "init") return void 0;
+	const key = property.key;
+	if (key.type === "Identifier") return key.name;
+	if (key.type === "Literal" && typeof key.value === "string") return key.value;
+}
+function walk$3(node, parents, offsets, visit) {
+	if (!visit(node, parents)) return;
+	parents.push(node);
+	const descend = (child) => {
+		if (isSyntax(child) && spansAnyOffset(offsets, child)) walk$3(child, parents, offsets, visit);
+	};
+	for (const key in node) {
+		const value = node[key];
+		if (key === "parent") continue;
+		if (Array.isArray(value)) for (const item of value) descend(item);
+		else descend(value);
+	}
+	parents.pop();
+}
+function isSyntax(value) {
+	return typeof value === "object" && value !== null && typeof value.type === "string";
+}
+function isChunk(value) {
+	return typeof value === "object" && value !== null && value.type === "chunk" && typeof value.code === "string";
+}
+//#endregion
+//#region src/build/pack-top-level.ts
+const NAMESPACE_HELPER = "__exportAll";
+function lazyNamespaceObjects(fileName, code) {
+	if (!code.includes(NAMESPACE_HELPER)) return [];
+	const parsed = parseChunkCode(fileName, code);
+	if (parsed.errors.length) return [];
+	const body = parsed.program.body;
+	const helpers = /* @__PURE__ */ new Set();
+	const exported = /* @__PURE__ */ new Set();
+	for (const node of body) if (node.type === "ImportDeclaration") for (const specifier of node.specifiers) {
+		const imported = specifier.imported;
+		if (specifier.type === "ImportSpecifier" && (imported?.name ?? imported?.value) === NAMESPACE_HELPER) helpers.add(specifier.local.name);
+	}
+	else if (node.type === "ExportNamedDeclaration") {
+		const declaration = node.declaration;
+		if (declaration?.type === "VariableDeclaration") for (const declarator of declaration.declarations) exported.add(declarator.id.name ?? "");
+		else if (declaration) exported.add(declaration.id?.name ?? "");
+		for (const specifier of node.specifiers) exported.add(specifier.local.name ?? specifier.local.value);
+	} else if (node.type === "ExportDefaultDeclaration" || node.type === "ExportAllDeclaration") return [];
+	for (const node of body) for (const declarator of declaratorsOf(node)) if (declarator.id.name === NAMESPACE_HELPER && declarator.init?.type === "ArrowFunctionExpression") helpers.add(NAMESPACE_HELPER);
+	if (!helpers.size) return [];
+	const candidates = /* @__PURE__ */ new Map();
+	for (const node of body) {
+		if (node.type !== "VariableDeclaration" || node.kind !== "var") continue;
+		const declarations = node.declarations;
+		if (declarations.length !== 1) continue;
+		const declarator = declarations[0];
+		const id = declarator.id;
+		const init = declarator.init;
+		if (id.type !== "Identifier" || init?.type !== "CallExpression" || init.callee.type !== "Identifier" || !helpers.has(init.callee.name) || exported.has(id.name)) continue;
+		candidates.set(id.name, node);
+	}
+	if (!candidates.size) return [];
+	const bindings = /* @__PURE__ */ new Map();
+	const references = /* @__PURE__ */ new Map();
+	const names = /* @__PURE__ */ new Set();
+	const written = /* @__PURE__ */ new Set();
+	walk$2(parsed.program, (node, parent, grandparent) => {
+		if (node.type !== "Identifier") return;
+		const name = node.name;
+		names.add(name);
+		if (!candidates.has(name)) return;
+		if (isWrite(node, parent, grandparent)) written.add(name);
+		else if (isBinding(node, parent)) bindings.set(name, (bindings.get(name) ?? 0) + 1);
+		else if (isReference$1(node, parent)) {
+			const list = references.get(name) ?? [];
+			list.push({
+				node,
+				...parent?.type === "Property" && parent.shorthand ? { shorthand: parent } : {}
+			});
+			references.set(name, list);
+		}
+	});
+	const getters = /* @__PURE__ */ new Map();
+	for (const name of candidates.keys()) {
+		if (bindings.get(name) !== 1 || written.has(name)) continue;
+		let getter = `${name}$namespace`;
+		for (let attempt = 1; names.has(getter); attempt++) getter = `${name}$namespace${attempt}`;
+		names.add(getter);
+		getters.set(name, getter);
+	}
+	const referenceEdits = [...getters].flatMap(([name, getter]) => (references.get(name) ?? []).map((reference) => reference.shorthand ? {
+		start: reference.shorthand.start,
+		end: reference.shorthand.end,
+		source: `${name}:${getter}()`
+	} : {
+		start: reference.node.start,
+		end: reference.node.end,
+		source: `${getter}()`
+	}));
+	const edits = [];
+	const folded = /* @__PURE__ */ new Set();
+	for (const [name, getter] of getters) {
+		const declaration = candidates.get(name);
+		const init = declaration.declarations[0].init;
+		const inner = referenceEdits.filter((edit) => edit.start >= init.start && edit.end <= init.end).sort((a, b) => b.start - a.start);
+		let value = code.slice(init.start, init.end);
+		for (const edit of inner) {
+			value = value.slice(0, edit.start - init.start) + edit.source + value.slice(edit.end - init.start);
+			folded.add(edit);
+		}
+		edits.push({
+			start: declaration.start,
+			end: declaration.end,
+			source: `function ${getter}(){return ${getter}.value||(${getter}.value=${value})}`
+		});
+	}
+	for (const edit of referenceEdits) if (!folded.has(edit)) edits.push(edit);
+	return edits;
+}
+function mergedBareVarDeclarations(fileName, code) {
+	if (!hasTwoBareVarStatements(code)) return [];
+	const parsed = parseChunkCode(fileName, code);
+	if (parsed.errors.length) return [];
+	const bare = parsed.program.body.filter((node) => node.type === "VariableDeclaration" && node.kind === "var" && node.declarations.every((item) => item.init === null && item.id.type === "Identifier"));
+	if (bare.length < 2) return [];
+	const names = bare.flatMap((node) => node.declarations.map((item) => item.id.name));
+	return bare.map((node, index) => ({
+		start: node.start,
+		end: node.end,
+		source: index === 0 ? `var ${names.join(",")};` : ""
+	}));
+}
+const BARE_VAR_TEXT = /\bvar\s+[^\s,;=(){}[\]]+\s*(?:[,;\n\r}]|$)/g;
+function hasTwoBareVarStatements(code) {
+	BARE_VAR_TEXT.lastIndex = 0;
+	return BARE_VAR_TEXT.test(code) && BARE_VAR_TEXT.test(code);
+}
+function packTopLevelEdits(fileName, code) {
+	return [...lazyNamespaceObjects(fileName, code), ...mergedBareVarDeclarations(fileName, code)];
+}
+function packTopLevelPlugin() {
+	return {
+		name: "markless-pack-top-level",
+		async renderChunk(code, chunk, options) {
+			if (!code.includes(NAMESPACE_HELPER) && !hasTwoBareVarStatements(code)) return null;
+			const edits = await runChunkTask("packTopLevelEdits", chunk.fileName, code);
+			if (!edits.length) return null;
+			const source = new RolldownMagicString(code);
+			for (const edit of edits) if (edit.source) source.overwrite(edit.start, edit.end, edit.source);
+			else source.remove(edit.start, edit.end);
+			return {
+				code: source.toString(),
+				map: options.sourcemap ? source.generateMap({ hires: true }).toString() : null
+			};
+		}
+	};
+}
+function declaratorsOf(node) {
+	return node.type === "VariableDeclaration" ? node.declarations : [];
+}
+function walk$2(root, visit) {
+	const pending = [[
+		root,
+		void 0,
+		void 0
+	]];
+	while (pending.length) {
+		const [item, parent, grandparent] = pending.pop();
+		if (!item || typeof item !== "object") continue;
+		if (Array.isArray(item)) {
+			for (const child of item) pending.push([
+				child,
+				parent,
+				grandparent
+			]);
+			continue;
+		}
+		const node = item;
+		const typed = typeof node.type === "string";
+		if (typed) visit(node, parent, grandparent);
+		for (const key in node) {
+			const value = node[key];
+			if (key !== "type" && value && typeof value === "object") pending.push(typed ? [
+				value,
+				node,
+				parent
+			] : [
+				value,
+				parent,
+				grandparent
+			]);
+		}
+	}
+}
+function isBinding(node, parent) {
+	if (!parent) return false;
+	switch (parent.type) {
+		case "VariableDeclarator": return parent.id === node;
+		case "FunctionDeclaration":
+		case "FunctionExpression":
+		case "ArrowFunctionExpression": return parent.id === node || parent.params.includes(node);
+		case "ClassDeclaration":
+		case "ClassExpression": return parent.id === node;
+		case "CatchClause": return parent.param === node;
+		case "ImportSpecifier":
+		case "ImportDefaultSpecifier":
+		case "ImportNamespaceSpecifier": return parent.local === node;
+		default: return false;
+	}
+}
+function isWrite(node, parent, grandparent) {
+	switch (parent?.type) {
+		case "ArrayPattern":
+		case "RestElement": return true;
+		case "AssignmentPattern": return parent.left === node;
+		case "Property": return parent.value === node && grandparent?.type === "ObjectPattern";
+		case "AssignmentExpression": return parent.left === node;
+		case "UpdateExpression": return true;
+		case "ForInStatement":
+		case "ForOfStatement": return parent.left === node;
+		default: return false;
+	}
+}
+function isReference$1(node, parent) {
+	if (!parent) return true;
+	switch (parent.type) {
+		case "MemberExpression": return parent.object === node || !!parent.computed;
+		case "Property": return parent.value === node || !!parent.computed && parent.key === node;
+		case "MethodDefinition":
+		case "PropertyDefinition": return !!parent.computed && parent.key === node;
+		case "ExportSpecifier":
+		case "ImportSpecifier":
+		case "LabeledStatement":
+		case "BreakStatement":
+		case "ContinueStatement": return false;
+		default: return true;
+	}
+}
+//#endregion
+//#region src/build/preload-helper-removal.ts
+async function stripUnusedVitePreloadHelperFromBundle(chunks) {
+	for (const helperChunk of chunks) {
+		if (!helperChunk.code.includes("vite:preloadError")) continue;
+		const rewrites = await planHelperRemoval(helperChunk, chunks);
+		if (!rewrites) continue;
+		for (const [chunk, rewrite] of rewrites) {
+			chunk.code = rewrite.code;
+			if (rewrite.droppedImport && Array.isArray(chunk.imports)) chunk.imports = chunk.imports.filter((fileName) => fileName !== helperChunk.fileName);
+		}
+	}
+}
+async function planHelperRemoval(helperChunk, chunks) {
+	const code = helperChunk.code;
+	const program = parse(code);
+	if (!program) return void 0;
+	const helper = findHelperModule(program, code, code.indexOf("vite:preloadError"));
+	if (!helper) return void 0;
+	const edits = [...helper.removals];
+	const exported = /* @__PURE__ */ new Map();
+	const removedLocals = /* @__PURE__ */ new Set([helper.initName, ...helper.helperVars]);
+	for (const statement of asNodes$1(program.body)) {
+		if (statement.type !== "ExportNamedDeclaration") continue;
+		if (statement.source) return void 0;
+		if (statement.declaration) {
+			const declared = /* @__PURE__ */ new Set();
+			collectBindingNames$1(statement.declaration.id, declared);
+			for (const declarator of asNodes$1(statement.declaration.declarations)) collectBindingNames$1(declarator.id, declared);
+			if ([...declared].some((name) => removedLocals.has(name))) return void 0;
+			continue;
+		}
+		const specifiers = asNodes$1(statement.specifiers);
+		const removed = /* @__PURE__ */ new Set();
+		for (const specifier of specifiers) {
+			const local = moduleExportName(specifier.local);
+			if (local === void 0 || !removedLocals.has(local)) continue;
+			if (local !== helper.initName && local !== helper.preloadName) return void 0;
+			exported.set(moduleExportName(specifier.exported), local === helper.initName ? "init" : "preload");
+			removed.add(specifier);
+		}
+		edits.push(...listRemoval(code, statement, specifiers, removed));
+	}
+	const initCalls = [];
+	for (const [name, found] of freeReferences(program, removedLocals)) for (const reference of found) {
+		if (insideAny(reference.node, helper.removals)) continue;
+		if (reference.parents.at(-1)?.type === "ExportSpecifier") continue;
+		if (name !== helper.initName) return void 0;
+		initCalls.push(reference);
+	}
+	const callEdits = initCallRemovals(initCalls);
+	if (!callEdits) return void 0;
+	const helperCode = applyEdits(code, [...edits, ...callEdits]);
+	if (helperCode === void 0) return void 0;
+	const rewrites = /* @__PURE__ */ new Map();
+	rewrites.set(helperChunk, {
+		code: helperCode,
+		droppedImport: false
+	});
+	if (exported.size === 0) return rewrites;
+	const helperBase = basename(helperChunk.fileName);
+	const importers = chunks.filter((chunk) => chunk !== helperChunk && chunk.code.includes(helperBase));
+	const context = {
+		helperFileName: helperChunk.fileName,
+		exported
+	};
+	const pending = [];
+	const launch = (index) => {
+		const chunk = importers[index];
+		const rewrite = runChunkTask("helperImporterRewrite", chunk.fileName, chunk.code, context);
+		rewrite.catch(() => {});
+		pending[index] = rewrite;
+	};
+	let next = 0;
+	for (; next < Math.min(IMPORTER_WINDOW, importers.length); next++) launch(next);
+	for (const [index, chunk] of importers.entries()) {
+		const rewrite = await pending[index];
+		if (rewrite === false) return void 0;
+		if (next < importers.length) launch(next++);
+		if (rewrite) rewrites.set(chunk, rewrite);
+	}
+	return rewrites;
+}
+const IMPORTER_WINDOW = 16;
+function helperImporterRewrite(fileName, code, context) {
+	return rewriteImporter({
+		fileName,
+		code
+	}, context.helperFileName, context.exported);
+}
+function findHelperModule(program, code, marker) {
+	let found;
+	walk$1(program, [], (node, parents) => {
+		if (found || node.type !== "AssignmentExpression") return;
+		const right = node.right;
+		if (right?.type !== "FunctionExpression" || marker < right.start || marker > right.end) return;
+		if (node.left.type !== "Identifier") return;
+		found = {
+			assignment: node,
+			parents: [...parents]
+		};
+	});
+	if (!found) return void 0;
+	const parents = [...found.parents];
+	let cursor = parents.pop();
+	const assignments = cursor?.type === "SequenceExpression" ? asNodes$1(cursor.expressions) : [found.assignment];
+	if (cursor?.type === "SequenceExpression") cursor = parents.pop();
+	if (cursor?.type !== "ExpressionStatement") return void 0;
+	const block = parents.pop();
+	if (block?.type !== "BlockStatement" || asNodes$1(block.body).length !== 1) return void 0;
+	const arrow = parents.pop();
+	if (arrow?.type !== "ArrowFunctionExpression" || asNodes$1(arrow.params).length > 0) return void 0;
+	const call = skipParens(parents);
+	if (call?.type !== "CallExpression" || asNodes$1(call.arguments).length !== 1) return void 0;
+	const helperVars = [];
+	for (const assignment of assignments) {
+		const name = assignment.type === "AssignmentExpression" && assignment.operator === "=" ? identifierName$1(assignment.left) : void 0;
+		if (!name) return void 0;
+		helperVars.push(name);
+	}
+	const preloadName = identifierName$1(found.assignment.left);
+	const owner = skipParens(parents);
+	let initName;
+	let initDeclarator;
+	const removals = [];
+	if (owner?.type === "AssignmentExpression") {
+		initName = identifierName$1(owner.left);
+		const invoke = skipParens(parents);
+		const returned = parents.pop();
+		const body = parents.pop();
+		const declaration = parents.pop();
+		if (invoke?.type !== "CallExpression" || asNodes$1(invoke.arguments).length > 0 || returned?.type !== "ReturnStatement" || body?.type !== "BlockStatement" || asNodes$1(body.body).length !== 1 || declaration?.type !== "FunctionDeclaration" || asNodes$1(declaration.params).length > 0 || identifierName$1(declaration.id) !== initName || parents.at(-1)?.type !== "Program") return void 0;
+		removals.push({
+			start: declaration.start,
+			end: declaration.end,
+			text: ""
+		});
+	} else if (owner?.type === "VariableDeclarator") {
+		initName = identifierName$1(owner.id);
+		initDeclarator = owner;
+		if (parents.pop()?.type !== "VariableDeclaration" || parents.at(-1)?.type !== "Program") return void 0;
+	}
+	if (!initName) return void 0;
+	const declared = /* @__PURE__ */ new Set();
+	for (const statement of asNodes$1(program.body)) {
+		if (statement.type !== "VariableDeclaration") continue;
+		const declarators = asNodes$1(statement.declarations);
+		const removed = /* @__PURE__ */ new Set();
+		for (const declarator of declarators) {
+			const name = identifierName$1(declarator.id);
+			if (declarator === initDeclarator) removed.add(declarator);
+			else if (name !== void 0 && helperVars.includes(name) && !declarator.init) {
+				removed.add(declarator);
+				declared.add(name);
+			}
+		}
+		removals.push(...listRemoval(code, statement, declarators, removed));
+	}
+	if (helperVars.some((name) => !declared.has(name))) return void 0;
+	return {
+		initName,
+		preloadName,
+		helperVars,
+		removals
+	};
+}
+function rewriteImporter(chunk, helperFileName, exported) {
+	const program = parse(chunk.code);
+	if (!program) return false;
+	const helperBase = basename(helperFileName);
+	const resolvesToHelper = (source) => {
+		const specifier = source?.type === "Literal" ? source.value : void 0;
+		if (typeof specifier !== "string" || basename(specifier) !== helperBase) return false;
+		if (!specifier.startsWith(".")) return void 0;
+		return join(dirname(chunk.fileName), specifier) === helperFileName;
+	};
+	const edits = [];
+	const locals = /* @__PURE__ */ new Map();
+	let droppedImport = false;
+	for (const statement of asNodes$1(program.body)) {
+		if (statement.type === "ExportAllDeclaration" || statement.type === "ExportNamedDeclaration") {
+			if (resolvesToHelper(statement.source) !== false) return false;
+			continue;
+		}
+		if (statement.type !== "ImportDeclaration") continue;
+		const target = resolvesToHelper(statement.source);
+		if (target === void 0) return false;
+		if (!target) continue;
+		const specifiers = asNodes$1(statement.specifiers);
+		const removed = /* @__PURE__ */ new Set();
+		for (const specifier of specifiers) {
+			if (specifier.type !== "ImportSpecifier") return false;
+			const role = exported.get(moduleExportName(specifier.imported) ?? "");
+			if (!role) continue;
+			locals.set(identifierName$1(specifier.local), role);
+			removed.add(specifier);
+		}
+		if (removed.size > 0 && removed.size === specifiers.length) droppedImport = true;
+		edits.push(...listRemoval(chunk.code, statement, specifiers, removed));
+	}
+	let unsafeDynamicImport = false;
+	walk$1(program, [], (node, parents) => {
+		if (node.type !== "ImportExpression" || unsafeDynamicImport) return;
+		const target = resolvesToHelper(node.source);
+		if (target === false) return;
+		unsafeDynamicImport = target === void 0 || readsRemovedExport(parents, exported);
+	});
+	if (unsafeDynamicImport) return false;
+	if (locals.size === 0) return void 0;
+	const initCalls = [];
+	for (const [name, found] of freeReferences(program, new Set(locals.keys()))) {
+		if (found.length > 0 && locals.get(name) !== "init") return false;
+		initCalls.push(...found);
+	}
+	const callEdits = initCallRemovals(initCalls);
+	if (!callEdits) return false;
+	const next = applyEdits(chunk.code, [...edits, ...callEdits]);
+	return next === void 0 ? false : {
+		code: next,
+		droppedImport
+	};
+}
+function readsRemovedExport(parents, exported) {
+	const member = parents.at(-1);
+	const call = parents.at(-2);
+	if (member?.type !== "MemberExpression" || member.computed || identifierName$1(member.property) !== "then" || call?.type !== "CallExpression" || call.callee !== member) return true;
+	const callback = asNodes$1(call.arguments)[0];
+	const params = asNodes$1(callback?.params);
+	if (callback?.type !== "ArrowFunctionExpression" || params.length !== 1) return true;
+	const namespace = identifierName$1(params[0]);
+	if (!namespace) return true;
+	for (const [, found] of freeReferences(callback.body, /* @__PURE__ */ new Set([namespace]))) for (const reference of found) {
+		const parent = reference.parents.at(-1);
+		const property = parent?.type === "MemberExpression" && !parent.computed && parent.object === reference.node ? identifierName$1(parent.property) : void 0;
+		if (property === void 0 || exported.has(property)) return true;
+	}
+	return false;
+}
+function initCallRemovals(references) {
+	const bySequence = /* @__PURE__ */ new Map();
+	const edits = [];
+	for (const reference of references) {
+		const parents = [...reference.parents];
+		const call = parents.pop();
+		if (call?.type !== "CallExpression" || call.callee !== reference.node || call.optional || asNodes$1(call.arguments).length > 0) return void 0;
+		const parent = parents.pop();
+		if (parent?.type === "SequenceExpression") {
+			const entry = bySequence.get(parent) ?? {
+				statement: [...parents],
+				calls: /* @__PURE__ */ new Set()
+			};
+			entry.calls.add(call);
+			bySequence.set(parent, entry);
+			continue;
+		}
+		if (parent?.type !== "ExpressionStatement") return void 0;
+		const removal = statementRemoval(parent, parents.at(-1));
+		if (!removal) return void 0;
+		edits.push(removal);
+	}
+	for (const [sequence, { statement, calls }] of bySequence) {
+		const expressions = asNodes$1(sequence.expressions);
+		if (calls.size < expressions.length) {
+			edits.push(...commaListRemovals(expressions, calls));
+			continue;
+		}
+		const holder = statement.at(-1);
+		if (holder?.type !== "ExpressionStatement") return void 0;
+		const removal = statementRemoval(holder, statement.at(-2));
+		if (!removal) return void 0;
+		edits.push(removal);
+	}
+	return edits;
+}
+function statementRemoval(statement, container) {
+	if (container?.type !== "BlockStatement" && container?.type !== "Program") return void 0;
+	return {
+		start: statement.start,
+		end: statement.end,
+		text: ""
+	};
+}
+function listRemoval(code, statement, items, removed) {
+	if (removed.size === 0) return [];
+	if (removed.size < items.length) return commaListRemovals(items, removed);
+	const end = code[statement.end] === ";" ? statement.end + 1 : statement.end;
+	return [{
+		start: statement.start,
+		end,
+		text: ""
+	}];
+}
+function commaListRemovals(items, removed) {
+	const edits = [];
+	for (let index = 0; index < items.length; index++) {
+		if (!removed.has(items[index])) continue;
+		let last = index;
+		while (last + 1 < items.length && removed.has(items[last + 1])) last++;
+		edits.push(last + 1 < items.length ? {
+			start: items[index].start,
+			end: items[last + 1].start,
+			text: ""
+		} : {
+			start: items[index - 1].end,
+			end: items[last].end,
+			text: ""
+		});
+		index = last;
+	}
+	return edits;
+}
+function applyEdits(code, edits) {
+	const ordered = [...edits].sort((left, right) => right.start - left.start);
+	let next = code;
+	let floor = Number.POSITIVE_INFINITY;
+	for (const edit of ordered) {
+		if (edit.end > floor) return void 0;
+		next = next.slice(0, edit.start) + edit.text + next.slice(edit.end);
+		floor = edit.start;
+	}
+	return parse(next) ? next : void 0;
+}
+function insideAny(node, ranges) {
+	return ranges.some((range) => node.start >= range.start && node.end <= range.end);
+}
+function skipParens(parents) {
+	let node = parents.pop();
+	while (node?.type === "ParenthesizedExpression") node = parents.pop();
+	return node;
+}
+function freeReferences(root, names) {
+	const found = /* @__PURE__ */ new Map();
+	const scopes = [];
+	const visit = (node, parents) => {
+		const scope = declaredIn(node);
+		if (scope) scopes.push(scope);
+		if (node.type === "Identifier") {
+			const name = node.name;
+			if (names.has(name) && isReference(node, parents.at(-1)) && !scopes.some((declared) => declared.has(name))) {
+				const list = found.get(name) ?? [];
+				list.push({
+					node,
+					parents: [...parents]
+				});
+				found.set(name, list);
+			}
+		}
+		parents.push(node);
+		for (const child of childNodes$1(node)) if (isBindingSlot(node, child)) visitPattern(child, parents);
+		else visit(child, parents);
+		parents.pop();
+		if (scope) scopes.pop();
+	};
+	const visitPattern = (pattern, parents) => {
+		parents.push(pattern);
+		if (pattern.type === "AssignmentPattern") {
+			visitPattern(pattern.left, parents);
+			visit(pattern.right, parents);
+		} else if (pattern.type === "ArrayPattern") for (const element of asNodes$1(pattern.elements)) visitPattern(element, parents);
+		else if (pattern.type === "ObjectPattern") for (const property of asNodes$1(pattern.properties)) {
+			if (property.type === "RestElement") {
+				visitPattern(property.argument, parents);
+				continue;
+			}
+			if (property.computed) visit(property.key, parents);
+			visitPattern(property.value, parents);
+		}
+		else if (pattern.type === "RestElement") visitPattern(pattern.argument, parents);
+		else if (pattern.type !== "Identifier") {
+			parents.pop();
+			visit(pattern, parents);
+			return;
+		}
+		parents.pop();
+	};
+	visit(root, []);
+	return found;
+}
+function isBindingSlot(node, child) {
+	switch (node.type) {
+		case "VariableDeclarator": return child === node.id;
+		case "FunctionDeclaration":
+		case "FunctionExpression":
+		case "ArrowFunctionExpression": return child === node.id || asNodes$1(node.params).includes(child);
+		case "ClassDeclaration":
+		case "ClassExpression": return child === node.id;
+		case "CatchClause": return child === node.param;
+		default: return false;
+	}
+}
+function isReference(node, parent) {
+	if (!parent) return true;
+	switch (parent.type) {
+		case "MemberExpression": return parent.object === node || parent.computed === true;
+		case "Property":
+		case "MethodDefinition":
+		case "PropertyDefinition": return parent.key !== node || parent.computed === true;
+		case "LabeledStatement":
+		case "BreakStatement":
+		case "ContinueStatement": return false;
+		case "ExportSpecifier": return parent.local === node;
+		case "ImportSpecifier":
+		case "ImportDefaultSpecifier":
+		case "ImportNamespaceSpecifier": return false;
+		default: return true;
+	}
+}
+function declaredIn(node) {
+	switch (node.type) {
+		case "FunctionDeclaration":
+		case "FunctionExpression":
+		case "ArrowFunctionExpression": {
+			const names = /* @__PURE__ */ new Set();
+			if (node.type === "FunctionExpression") collectBindingNames$1(node.id, names);
+			for (const param of asNodes$1(node.params)) collectBindingNames$1(param, names);
+			collectVarNames(node.body, names);
+			return names;
+		}
+		case "ClassExpression": {
+			const names = /* @__PURE__ */ new Set();
+			collectBindingNames$1(node.id, names);
+			return names;
+		}
+		case "BlockStatement":
+		case "StaticBlock": return lexicalNames(asNodes$1(node.body));
+		case "SwitchStatement": return lexicalNames(asNodes$1(node.cases).flatMap((item) => asNodes$1(item.consequent)));
+		case "ForStatement":
+		case "ForInStatement":
+		case "ForOfStatement": {
+			const head = node.type === "ForStatement" ? node.init : node.left;
+			return head?.type === "VariableDeclaration" ? lexicalNames([head]) : void 0;
+		}
+		case "CatchClause": {
+			const names = /* @__PURE__ */ new Set();
+			collectBindingNames$1(node.param, names);
+			return names;
+		}
+		default: return;
+	}
+}
+function lexicalNames(statements) {
+	const names = /* @__PURE__ */ new Set();
+	for (const statement of statements) if (statement.type === "VariableDeclaration" && statement.kind !== "var") for (const declarator of asNodes$1(statement.declarations)) collectBindingNames$1(declarator.id, names);
+	else if (statement.type === "FunctionDeclaration" || statement.type === "ClassDeclaration") collectBindingNames$1(statement.id, names);
+	return names;
+}
+function collectVarNames(node, names) {
+	if (!node) return;
+	if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") return;
+	if (node.type === "VariableDeclaration" && node.kind === "var") for (const declarator of asNodes$1(node.declarations)) collectBindingNames$1(declarator.id, names);
+	for (const child of childNodes$1(node)) collectVarNames(child, names);
+}
+function collectBindingNames$1(pattern, names) {
+	if (!pattern) return;
+	switch (pattern.type) {
+		case "Identifier":
+			names.add(pattern.name);
+			return;
+		case "AssignmentPattern":
+			collectBindingNames$1(pattern.left, names);
+			return;
+		case "RestElement":
+			collectBindingNames$1(pattern.argument, names);
+			return;
+		case "ArrayPattern":
+			for (const element of asNodes$1(pattern.elements)) collectBindingNames$1(element, names);
+			return;
+		case "ObjectPattern":
+			for (const property of asNodes$1(pattern.properties)) collectBindingNames$1(property.type === "RestElement" ? property.argument : property.value, names);
+			return;
+	}
+}
+function walk$1(node, parents, visit) {
+	visit(node, parents);
+	parents.push(node);
+	for (const child of childNodes$1(node)) walk$1(child, parents, visit);
+	parents.pop();
+}
+function parse(code) {
+	try {
+		const parsed = parseChunkCode("chunk.js", code);
+		if (parsed.errors.length) return void 0;
+		return parsed.program;
+	} catch {
+		return;
+	}
+}
+function childNodes$1(node) {
+	const children = [];
+	for (const key in node) {
+		const value = node[key];
+		if (key === "parent") continue;
+		if (Array.isArray(value)) {
+			for (const item of value) if (isNode(item)) children.push(item);
+		} else if (isNode(value)) children.push(value);
+	}
+	return children;
+}
+function asNodes$1(value) {
+	return Array.isArray(value) ? value.filter(isNode) : [];
+}
+function isNode(value) {
+	return typeof value === "object" && value !== null && typeof value.type === "string";
+}
+function identifierName$1(node) {
+	return node?.type === "Identifier" && typeof node.name === "string" ? node.name : void 0;
+}
+function moduleExportName(node) {
+	if (node?.type === "Literal" && typeof node.value === "string") return node.value;
+	return identifierName$1(node);
+}
+//#endregion
+//#region src/build/pack-loader-names.ts
+const PACK_LOAD = "__marklessPackLoad";
+//#endregion
+//#region src/build/preload-cleanup.ts
+function stripEmptyVitePreloadWrappers(code) {
+	return stripImportedVitePreloadHelper(stripEmptyVitePreloadWrapperCalls(code));
+}
+function stripEmptyVitePreloadWrapperCalls(code) {
+	return stripUnusedVitePreloadHelper(stripAsyncEmptyPreloadWrappers(stripDirectEmptyPreloadWrappers(code)));
+}
+const PRELOADED_IMPORT_BODIES = [
+	"import(",
+	"Promise.resolve().then(",
+	"(async()=>"
+];
+const PACK_LOAD_BODY_RE = new RegExp(`[$A-Z_a-z][$\\w]*\\(\\s*(["'\`])[^"'\`]+\\1\\s*,\\s*(["'\`])${"$ml".replaceAll("$", "\\$")}[$\\w]+\\2\\s*,\\s*\\(\\)\\s*=>\\s*import\\(`, "y");
+function startsWithPackLoad(code, start) {
+	PACK_LOAD_BODY_RE.lastIndex = start;
+	return PACK_LOAD_BODY_RE.test(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 (!PRELOADED_IMPORT_BODIES.some((body) => code.startsWith(body, bodyStart)) && !startsWithPackLoad(code, 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.startsWith("void 0", cursor)) cursor = skipSpaces(code, cursor + 6);
+	else if (code[cursor] === "[" && code[cursor + 1] === "]") cursor = skipSpaces(code, cursor + 2);
+	else return void 0;
+	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) + helper.keptImport + code.slice(helper.importEnd);
+	if (preloadStillCalled(code, withoutImport, helper)) return code;
+	const initCall = `${escapeRegExp(helper.initFunction)}\\(\\)`;
+	return withoutInitStatements(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"), "{}"), helper.initFunction) ?? code;
+}
+function withoutInitStatements(code, name) {
+	const offsets = calleeOffsets(code, name);
+	if (offsets.length === 0) return code;
+	const program = tryParseJavaScriptModule(code);
+	if (!program) return void 0;
+	const statements = [];
+	walkReferenceScopes(program, [], {
+		removedImports: /* @__PURE__ */ new Set(),
+		offsets
+	}, (node, scopes) => {
+		const call = node.type === "ExpressionStatement" ? node.expression : void 0;
+		if (call?.type !== "CallExpression" || identifierName(call.callee) !== name || asNodes(call.arguments).length > 0 || isDeclaredInScope(name, scopes)) return;
+		statements.push(node);
+	});
+	let next = code;
+	for (const { start, end } of statements.sort((left, right) => right.start - left.start)) {
+		const before = next.slice(0, start).trimEnd();
+		const own = before === "" || /[;{]$/.test(before);
+		next = next.slice(0, start) + (own ? "" : ";") + next.slice(end);
+	}
+	const after = tryParseJavaScriptModule(next);
+	return after && !callsFreeName(next, after, name, /* @__PURE__ */ new Set()) ? next : void 0;
+}
+function findImportedVitePreloadHelper(code) {
+	if (!code.includes("__vitePreload") || !code.includes("init_preload_helper")) return void 0;
+	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;
+		const kept = [];
+		const keptSpecifiers = /* @__PURE__ */ new Set();
+		for (const [index, specifier] of asNodes(declaration.specifiers).entries()) {
+			if (specifier.type !== "ImportSpecifier") return void 0;
+			const imported = identifierName(specifier.imported);
+			const local = identifierName(specifier.local);
+			if (!imported || !local) continue;
+			if (imported === "__vitePreload") preloadFunction = local;
+			else if (imported === "init_preload_helper") initFunction = local;
+			else {
+				kept.push(sourceText(statement, specifier));
+				keptSpecifiers.add(index);
+			}
+		}
+		const source = declaration.source;
+		if (preloadFunction && initFunction) return {
+			importStart,
+			importEnd: importStart + statement.length,
+			keptImport: kept.length && source ? `import{${kept.join(",")}}from${sourceText(statement, source)};` : "",
+			preloadFunction,
+			initFunction,
+			keptSpecifiers
+		};
+	}
+}
+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(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(entryVariable)}\\(\\)`), "").replace(new RegExp(`${escapeRegExp(entryVariable)}\\(\\),`), "").replace(new RegExp(`\\{${escapeRegExp(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(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function preloadStillCalled(code, withoutImport, helper) {
+	if (calleeOffsets(code, helper.preloadFunction).length === 0 && calleeOffsets(withoutImport, helper.preloadFunction).length === 0 && parsesCleanly(code) && parsesCleanly(withoutImport)) return false;
+	if (parsesCleanly(code) && importIsWholeStatement(code, helper)) {
+		const called = callsImportedOrFreeName(code, helper.preloadFunction);
+		if (called !== void 0) return called;
+	}
+	const program = tryParseChunk(code);
+	const body = asNodes(program?.body);
+	const index = body.findIndex((node) => node.start === helper.importStart && node.end === helper.importEnd);
+	const declaration = body[index];
+	const previous = body[index - 1];
+	if (!program || declaration?.type !== "ImportDeclaration" || previous !== void 0 && code[(previous.end ?? 0) - 1] !== ";") return hasCallableReference(withoutImport, helper.preloadFunction);
+	const specifiers = asNodes(declaration.specifiers);
+	const removed = new Set(specifiers.filter((_, index) => helper.keptImport === "" || !helper.keptSpecifiers.has(index)));
+	return callsFreeName(code, program, helper.preloadFunction, removed);
+}
+function importIsWholeStatement(code, helper) {
+	if (!parseChunkCode("chunk.js", code).module.staticImports.some((entry) => entry.start === helper.importStart && entry.end === helper.importEnd)) return false;
+	const lines = code.slice(0, helper.importStart).split("\n");
+	let last = "";
+	while (lines.length && (last === "" || last.startsWith("//"))) last = lines.pop().trim();
+	if (last === "" || last.startsWith("//")) return true;
+	return last.endsWith(";") && !last.includes("//") && !last.includes("/*");
+}
+function parsesCleanly(code) {
+	try {
+		return parseChunkCode("chunk.js", code).errors.length === 0;
+	} catch {
+		return false;
+	}
+}
+function tryParseChunk(code) {
+	try {
+		const parsed = parseChunkCode("chunk.js", code);
+		return parsed.errors.length ? void 0 : parsed.program;
+	} catch {
+		return;
+	}
+}
+function hasCallableReference(code, name) {
+	const ast = tryParseJavaScriptModule(code);
+	return ast ? callsFreeName(code, ast, name, /* @__PURE__ */ new Set()) : true;
+}
+function callsFreeName(code, ast, name, removedImports) {
+	let found = false;
+	walkReferenceScopes(ast, [], {
+		removedImports,
+		offsets: calleeOffsets(code, name)
+	}, (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, scan, visit) {
+	if (!node || typeof node !== "object") return;
+	if (node.type === "Program") {
+		const scope = collectScopeDeclarations(asNodes(node.body), scan.removedImports);
+		visit(node, [scope]);
+		for (const child of asNodes(node.body)) if (spansAnyOffset(scan.offsets, child)) walkReferenceScopes(child, [scope], scan, 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, scan, 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)) if (spansAnyOffset(scan.offsets, child)) walkReferenceScopes(child, nextScopes, scan, visit);
+		return;
+	}
+	visit(node, scopes);
+	for (const child of childNodes(node)) if (spansAnyOffset(scan.offsets, child)) walkReferenceScopes(child, scopes, scan, visit);
+}
+function collectScopeDeclarations(nodes, removedImports = /* @__PURE__ */ new Set()) {
+	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)) {
+				if (removedImports.has(specifier)) continue;
+				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 sourceText(code, node) {
+	const { start, end } = node;
+	return code.slice(start, end);
+}
+function tryParseJavaScriptModule(code) {
+	try {
+		return parseJavaScriptModule(code, "chunk.js");
+	} catch {
+		return;
+	}
+}
+function childNodes(node) {
+	const children = [];
+	for (const key in node) {
+		const value = node[key];
+		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 = /* @__PURE__ */ new Set([
+	"closingElement",
+	"id",
+	"leadingComments",
+	"loc",
+	"metadata",
+	"openingElement",
+	"parent",
+	"range",
+	"trailingComments"
+]);
+//#endregion
+//#region src/build/short-export-names.ts
+const MIN_LENGTH = 2;
+const READ_BY_LATER_PASSES = /^(?:__vitePreload|init_preload_helper)$/;
+const SYMBOL_INIT = /^init__virtual_markless_symbol/;
+const START = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_$";
+const PART = `${START}0123456789`;
+const WORD = /[A-Za-z_$][\w$]*/g;
+const RESERVED = new Set("await break case catch class const continue debugger default delete do else enum eval export extends false finally for function if implements import in instanceof interface let new null package private protected public return static super switch then this throw true try typeof undefined var void while with yield arguments".split(" "));
+function shortNameChunkFacts(fileName, code) {
+	const parsed = parseChunkCode(fileName, code);
+	if (parsed.errors.length) return { errors: true };
+	const imports = [];
+	const exports = [];
+	const pins = [];
+	for (const node of parsed.program.body) {
+		if (node.type === "ImportDeclaration" || node.type === "ExportAllDeclaration") {
+			imports.push({
+				source: sourceOf(node),
+				exportAll: node.type === "ExportAllDeclaration",
+				specifiers: node.type === "ExportAllDeclaration" ? [] : (node.specifiers ?? []).map((specifier) => {
+					if (specifier.type !== "ImportSpecifier") return void 0;
+					const imported = specifier.imported;
+					return {
+						name: nameOf(imported),
+						start: imported.start,
+						end: imported.end,
+						shorthand: imported.start === specifier.local.start
+					};
+				})
+			});
+			continue;
+		}
+		if (node.type === "ExportDefaultDeclaration") {
+			pins.push("default");
+			continue;
+		}
+		if (node.type !== "ExportNamedDeclaration") continue;
+		if (node.declaration) {
+			pins.push(...declaredNames(node.declaration));
+			continue;
+		}
+		exports.push({
+			source: node.source ? sourceOf(node) : void 0,
+			reExport: !!node.source,
+			clause: {
+				start: node.start,
+				end: node.end
+			},
+			specifiers: node.specifiers.map((specifier) => {
+				const local = specifier.local;
+				const exported = specifier.exported;
+				return {
+					local: {
+						name: nameOf(local),
+						start: local.start,
+						end: local.end
+					},
+					exported: {
+						name: nameOf(exported),
+						start: exported.start,
+						end: exported.end
+					},
+					shorthand: local.start === exported.start
+				};
+			})
+		});
+	}
+	const words = /* @__PURE__ */ new Set();
+	const strings = [];
+	const dynamicImports = [];
+	scanReads(parsed.program, words, (source, members) => {
+		dynamicImports.push({
+			source,
+			members: members?.map((node) => ({
+				name: node.name,
+				start: node.start,
+				end: node.end
+			}))
+		});
+	}, strings);
+	return {
+		errors: false,
+		imports,
+		pins,
+		exports,
+		dynamicImports,
+		words: [...words],
+		strings
+	};
+}
+function planShortExportNames(chunks, factsOf = (chunk) => shortNameChunkFacts(chunk.fileName, chunk.code)) {
+	const byName = new Map(chunks.map((chunk) => [chunk.fileName, chunk]));
+	const references = [];
+	const own = /* @__PURE__ */ new Map();
+	const pinned = /* @__PURE__ */ new Map();
+	const opaque = /* @__PURE__ */ new Set();
+	const words = /* @__PURE__ */ new Set();
+	const escaping = /* @__PURE__ */ new Set();
+	const strings = [];
+	const pin = (fileName, name) => {
+		const set = pinned.get(fileName) ?? /* @__PURE__ */ new Set();
+		set.add(name);
+		pinned.set(fileName, set);
+	};
+	for (const chunk of chunks) {
+		const facts = factsOf(chunk);
+		if (facts.errors) return {
+			renames: /* @__PURE__ */ new Map(),
+			edits: /* @__PURE__ */ new Map(),
+			pruned: /* @__PURE__ */ new Map(),
+			exports: /* @__PURE__ */ new Map()
+		};
+		const removed = !!chunk.removed;
+		const exports = [];
+		for (const item of facts.imports) {
+			const target = targetOf(chunk.fileName, item.source, byName);
+			if (!target) continue;
+			if (item.exportAll) {
+				opaque.add(target);
+				continue;
+			}
+			for (const specifier of item.specifiers) {
+				if (!specifier) {
+					opaque.add(target);
+					continue;
+				}
+				references.push({
+					chunk: chunk.fileName,
+					target,
+					name: specifier.name,
+					node: specifier,
+					shorthand: specifier.shorthand,
+					removed
+				});
+			}
+		}
+		for (const name of facts.pins) pin(chunk.fileName, name);
+		for (const item of facts.exports) {
+			const target = item.reExport ? targetOf(chunk.fileName, item.source, byName) : void 0;
+			for (const specifier of item.specifiers) {
+				const { local, exported, shorthand } = specifier;
+				if (item.reExport) {
+					if (target) references.push({
+						chunk: chunk.fileName,
+						target,
+						name: local.name,
+						node: local,
+						shorthand,
+						removed
+					});
+					if (shorthand && target) pin(chunk.fileName, exported.name);
+					else exports.push({
+						name: exported.name,
+						node: exported,
+						local,
+						shorthand: false,
+						clause: void 0
+					});
+				} else exports.push({
+					name: exported.name,
+					node: exported,
+					local,
+					shorthand,
+					clause: item.clause
+				});
+			}
+		}
+		own.set(chunk.fileName, exports);
+		for (const word of facts.words) words.add(word);
+		for (const { source, members } of facts.dynamicImports) {
+			const target = resolveChunk(chunk.fileName, source, byName);
+			if (!target) {
+				strings.push(source);
+				continue;
+			}
+			if (!members) {
+				escaping.add(target);
+				continue;
+			}
+			for (const node of members) references.push({
+				chunk: chunk.fileName,
+				target,
+				name: node.name,
+				node,
+				shorthand: false,
+				removed
+			});
+		}
+		strings.push(...facts.strings);
+	}
+	for (const fileName of namedInStrings(strings, chunks.map((chunk) => chunk.fileName))) escaping.add(fileName);
+	const renames = /* @__PURE__ */ new Map();
+	const pruned = /* @__PURE__ */ new Map();
+	const finalNames = /* @__PURE__ */ new Map();
+	const survivingReads = new Set(references.filter((item) => !item.removed).map((item) => `${item.target}\0${item.name}`));
+	for (const chunk of chunks) {
+		if (opaque.has(chunk.fileName) || chunk.removed) continue;
+		const keep = new Set(pinned.get(chunk.fileName));
+		if (chunk.isEntry || chunk.isDynamicEntry) {
+			if (!chunk.signature) continue;
+			for (const name of chunk.signature) keep.add(name);
+		}
+		const candidates = [];
+		const ownNames = /* @__PURE__ */ new Set([...(own.get(chunk.fileName) ?? []).map((item) => item.name), ...pinned.get(chunk.fileName) ?? []]);
+		for (const name of ownNames) if (keep.has(name) || READ_BY_LATER_PASSES.test(name) || escaping.has(chunk.fileName) && (words.has(name) || SYMBOL_INIT.test(name))) keep.add(name);
+		else candidates.push(name);
+		const names = shortNames(candidates, keep);
+		if (names.size) renames.set(chunk.fileName, names);
+		finalNames.set(chunk.fileName, [...ownNames]);
+		if (escaping.has(chunk.fileName)) continue;
+		const unused = new Set([...ownNames].filter((name) => !keep.has(name) && !survivingReads.has(`${chunk.fileName}\0${name}`)));
+		if (unused.size) pruned.set(chunk.fileName, unused);
+	}
+	const code = new Map(chunks.map((chunk) => [chunk.fileName, chunk.code]));
+	const edits = /* @__PURE__ */ new Map();
+	const edit = (fileName, item) => {
+		const list = edits.get(fileName) ?? [];
+		list.push(item);
+		edits.set(fileName, list);
+	};
+	for (const reference of references) {
+		const next = renames.get(reference.target)?.get(reference.name);
+		if (!next || reference.removed) continue;
+		edit(reference.chunk, {
+			start: reference.node.start,
+			end: reference.node.end,
+			source: reference.shorthand ? `${next} as ${reference.name}` : next
+		});
+	}
+	for (const [fileName, exports] of own) {
+		const names = renames.get(fileName) ?? /* @__PURE__ */ new Map();
+		const unused = pruned.get(fileName);
+		const rewritten = /* @__PURE__ */ new Set();
+		for (const item of exports) {
+			if (!item.clause || !unused?.has(item.name) || rewritten.has(item.clause)) continue;
+			rewritten.add(item.clause);
+			const kept = exports.filter((other) => other.clause === item.clause && !unused.has(other.name)).map((other) => {
+				const local = code.get(fileName).slice(other.local.start, other.local.end);
+				const name = names.get(other.name) ?? other.name;
+				const exported = /^[A-Za-z_$][\w$]*$/.test(name) ? name : JSON.stringify(name);
+				return local === exported ? local : `${local} as ${exported}`;
+			});
+			edit(fileName, {
+				start: item.clause.start,
+				end: item.clause.end,
+				source: kept.length ? `export{${kept.join(",")}};` : ""
+			});
+		}
+		for (const item of exports) {
+			const next = names.get(item.name);
+			if (!next || item.clause && rewritten.has(item.clause)) continue;
+			edit(fileName, {
+				start: item.node.start,
+				end: item.node.end,
+				source: item.shorthand ? `${item.name} as ${next}` : next
+			});
+		}
+	}
+	return {
+		renames,
+		edits,
+		pruned,
+		exports: new Map([...finalNames].map(([fileName, list]) => [fileName, list.filter((name) => !pruned.get(fileName)?.has(name)).map((name) => renames.get(fileName)?.get(name) ?? name)]))
+	};
+}
+function namedInStrings(strings, fileNames) {
+	const baseOf = (fileName) => fileName.slice(fileName.lastIndexOf("/") + 1);
+	const byExtension = /* @__PURE__ */ new Map();
+	const bare = [];
+	for (const fileName of fileNames) {
+		const base = baseOf(fileName);
+		if (!base.includes(".")) {
+			bare.push(base);
+			continue;
+		}
+		const extension = base.slice(base.lastIndexOf("."));
+		const bases = byExtension.get(extension) ?? /* @__PURE__ */ new Set();
+		bases.add(base);
+		byExtension.set(extension, bases);
+	}
+	const found = /* @__PURE__ */ new Set();
+	for (const [extension, bases] of byExtension) {
+		const lengths = [...new Set([...bases].map((base) => base.length))];
+		for (const value of strings) for (let at = value.indexOf(extension); at !== -1; at = value.indexOf(extension, at + 1)) {
+			const end = at + extension.length;
+			for (const length of lengths) {
+				if (length > end) continue;
+				const candidate = value.slice(end - length, end);
+				if (bases.has(candidate)) found.add(candidate);
+			}
+		}
+	}
+	if (bare.length) {
+		const text = strings.join("\n");
+		for (const base of bare) if (text.includes(base)) found.add(base);
+	}
+	return fileNames.filter((fileName) => found.has(baseOf(fileName)));
+}
+/** Deterministic: each name is the shortest prefix of its own hash that no other name in the set shares. */
+function shortNames(names, taken = /* @__PURE__ */ new Set()) {
+	const hashes = [...new Set(names)].map((name) => [name, identifierHash(name)]);
+	hashes.sort(([, a], [, b]) => a < b ? -1 : a > b ? 1 : 0);
+	const result = /* @__PURE__ */ new Map();
+	for (let index = 0; index < hashes.length; index++) {
+		const [name, hash] = hashes[index];
+		const shared = Math.max(commonPrefix(hash, hashes[index - 1]?.[1] ?? ""), commonPrefix(hash, hashes[index + 1]?.[1] ?? ""));
+		let length = Math.max(MIN_LENGTH, shared + 1);
+		while (length < hash.length && (RESERVED.has(hash.slice(0, length)) || taken.has(hash.slice(0, length)))) length++;
+		const next = hash.slice(0, length);
+		if (taken.has(next) || RESERVED.has(next) || hash.length === shared) throw new Error(`Markless could not give cross-chunk export ${name} a unique short name.`);
+		result.set(name, next);
+	}
+	return result;
+}
+function shortExportNamesPlugin(removedChunks = () => /* @__PURE__ */ new Set()) {
+	let pending = /* @__PURE__ */ new Map();
+	let exports = /* @__PURE__ */ new Map();
+	const planWhenAnalyzed = async (batch, options) => {
+		pending = /* @__PURE__ */ new Map();
+		try {
+			const facts = /* @__PURE__ */ new Map();
+			for (const [fileName, item] of batch) facts.set(fileName, await item.facts);
+			const plan = planShortExportNames([...batch.values()].map((item) => item.chunk), (chunk) => facts.get(chunk.fileName));
+			exports = new Map(plan.exports);
+			for (const [fileName, item] of batch) {
+				const list = plan.edits.get(fileName);
+				if (!list?.length) {
+					item.resolve(null);
+					continue;
+				}
+				const source = new RolldownMagicString(item.chunk.code);
+				for (const change of list) source.overwrite(change.start, change.end, change.source);
+				item.resolve({
+					code: source.toString(),
+					map: options.sourcemap ? source.generateMap({ hires: true }).toString() : null
+				});
+			}
+		} catch (error) {
+			for (const item of batch.values()) item.reject(error);
+		}
+	};
+	return {
+		name: "markless-short-export-names",
+		renderStart() {
+			pending = /* @__PURE__ */ new Map();
+			exports = /* @__PURE__ */ new Map();
+		},
+		renderChunk(code, chunk, options, meta) {
+			const facade = chunk.facadeModuleId ? this.getModuleInfo(chunk.facadeModuleId) : null;
+			return new Promise((resolve, reject) => {
+				pending.set(chunk.fileName, {
+					chunk: {
+						fileName: chunk.fileName,
+						code,
+						exports: [...chunk.exports],
+						isEntry: chunk.isEntry,
+						isDynamicEntry: chunk.isDynamicEntry,
+						signature: facade?.exports,
+						removed: removedChunks().has(chunk.fileName)
+					},
+					facts: handled(runChunkTask("shortNameChunkFacts", chunk.fileName, code)),
+					resolve,
+					reject
+				});
+				if (pending.size !== renderedChunkCount(meta.chunks)) return;
+				planWhenAnalyzed(pending, options);
+			});
+		},
+		renderError(error) {
+			for (const item of pending.values()) item.reject(error);
+			pending.clear();
+		},
+		generateBundle: {
+			order: "pre",
+			handler(_, bundle) {
+				for (const output of Object.values(bundle)) {
+					if (output.type !== "chunk") continue;
+					const final = exports.get(output.preliminaryFileName);
+					if (final) output.exports = [...final];
+				}
+			}
+		}
+	};
+}
+function targetOf(importer, source, chunks) {
+	return source === void 0 ? void 0 : resolveChunk(importer, source, chunks);
+}
+function sourceOf(node) {
+	const value = node.source?.value;
+	return typeof value === "string" ? value : void 0;
+}
+function resolveChunk(importer, specifier, chunks) {
+	if (!specifier.startsWith(".")) return void 0;
+	const target = normalize(join(dirname(importer), specifier));
+	return chunks.has(target) ? target : void 0;
+}
+function nameOf(node) {
+	return node.type === "Identifier" ? node.name : String(node.value);
+}
+function declaredNames(declaration) {
+	if (declaration.type === "VariableDeclaration") return declaration.declarations.flatMap((item) => bindingNames(item.id));
+	const id = declaration.id;
+	return id ? [id.name] : [];
+}
+function bindingNames(pattern) {
+	if (pattern.type === "Identifier") return [pattern.name];
+	if (pattern.type === "ObjectPattern") return pattern.properties.flatMap((property) => bindingNames(property.type === "RestElement" ? property.argument : property.value));
+	if (pattern.type === "ArrayPattern") return pattern.elements.flatMap((element) => element ? bindingNames(element) : []);
+	if (pattern.type === "AssignmentPattern") return bindingNames(pattern.left);
+	if (pattern.type === "RestElement") return bindingNames(pattern.argument);
+	return [];
+}
+function scanReads(root, words, imports, strings) {
+	const pending = [[
+		root,
+		void 0,
+		void 0
+	]];
+	while (pending.length) {
+		const [item, parent, grandparent] = pending.pop();
+		if (!item || typeof item !== "object") continue;
+		if (Array.isArray(item)) {
+			for (const child of item) pending.push([
+				child,
+				parent,
+				grandparent
+			]);
+			continue;
+		}
+		const syntax = item;
+		if (typeof syntax.type !== "string") continue;
+		switch (syntax.type) {
+			case "ImportDeclaration":
+			case "ExportAllDeclaration": continue;
+			case "ExportNamedDeclaration":
+				pending.push([
+					syntax.declaration,
+					syntax,
+					parent
+				]);
+				continue;
+			case "ImportExpression": {
+				const source = syntax.source;
+				const value = source.type === "Literal" ? source.value : source.type === "TemplateLiteral" && !source.expressions.length ? (source.quasis[0]?.value)?.cooked : void 0;
+				if (typeof value === "string" && !packerImport(syntax, parent, grandparent)) imports(value, namespaceReads(syntax, parent, grandparent));
+				if (typeof value !== "string") pending.push([
+					source,
+					syntax,
+					parent
+				]);
+				pending.push([
+					syntax.options,
+					syntax,
+					parent
+				]);
+				continue;
+			}
+			case "CallExpression":
+				if (syntax.callee.type === "Identifier" && syntax.callee.name === "__marklessPackLoad") {
+					pending.push([
+						syntax.arguments[2],
+						syntax,
+						parent
+					]);
+					continue;
+				}
+				break;
+			case "MemberExpression":
+			case "Property":
+			case "MethodDefinition":
+			case "PropertyDefinition":
+			case "AccessorProperty": {
+				const key = syntax.property ?? syntax.key;
+				if (key?.type === "Identifier" && !syntax.computed) words.add(key.name);
+				break;
+			}
+			case "Literal":
+				if (typeof syntax.value === "string") {
+					collectWords(syntax.value, words);
+					strings.push(syntax.value);
+				}
+				continue;
+			case "TemplateElement": {
+				const text = String(syntax.value.raw ?? "");
+				collectWords(text, words);
+				strings.push(text);
+				continue;
+			}
+		}
+		for (const key in syntax) {
+			const value = syntax[key];
+			if (key !== "type" && value && typeof value === "object") pending.push([
+				value,
+				syntax,
+				parent
+			]);
+		}
+	}
+}
+function namespaceReads(node, parent, grandparent) {
+	if (parent?.type !== "MemberExpression" || parent.object !== node || parent.computed || parent.property.name !== "then" || grandparent?.type !== "CallExpression" || grandparent.callee !== parent || grandparent.arguments.length !== 1) return void 0;
+	const callback = grandparent.arguments[0];
+	const params = callback.params;
+	if (callback.type !== "ArrowFunctionExpression" || params?.length !== 1 || params[0].type !== "Identifier") return void 0;
+	const namespace = params[0].name;
+	let body = callback.body;
+	while (body.type === "ParenthesizedExpression") body = body.expression;
+	const reads = [];
+	for (const expression of body.type === "SequenceExpression" ? body.expressions : [body]) {
+		const member = expression.type === "CallExpression" && !expression.arguments.length ? expression.callee : expression;
+		if (member.type !== "MemberExpression" || member.computed || member.object.type !== "Identifier" || member.object.name !== namespace) return void 0;
+		reads.push(member.property);
+	}
+	return reads;
+}
+function packerImport(node, parent, grandparent) {
+	if (parent?.type === "ArrowFunctionExpression" && grandparent?.type === "CallExpression" && grandparent.callee.type === "Identifier" && grandparent.callee.name === "__marklessPackLoad") return true;
+	if (parent?.type === "MemberExpression" && parent.object === node && parent.property.name === "then" && grandparent?.type === "CallExpression") {
+		const callback = grandparent.arguments[0];
+		const call = callback?.type === "ArrowFunctionExpression" ? callback.body : void 0;
+		const callee = call?.type === "CallExpression" ? call.callee : void 0;
+		return grandparent.arguments.length === 1 && callee?.type === "MemberExpression" && !callee.computed && String(callee.property.name).startsWith("$ml");
+	}
+	if (parent?.type === "ArrayExpression" && grandparent?.type === "ForOfStatement") {
+		const body = grandparent.body;
+		const call = body.type === "ExpressionStatement" ? body.expression : void 0;
+		const callee = call?.type === "CallExpression" ? call.callee : void 0;
+		return callee?.type === "MemberExpression" && callee.property.name === "catch" && callee.object.type === "Identifier";
+	}
+	return false;
+}
+function collectWords(text, words) {
+	for (const match of text.matchAll(WORD)) words.add(match[0]);
+}
+function commonPrefix(a, b) {
+	let index = 0;
+	while (index < a.length && a[index] === b[index]) index++;
+	return index;
+}
+function identifierHash(text) {
+	let hash = 14695981039346656037n;
+	for (let index = 0; index < text.length; index++) {
+		hash ^= BigInt(text.charCodeAt(index));
+		hash = hash * 1099511628211n & 18446744073709551615n;
+	}
+	let name = START[Number(hash % BigInt(54))];
+	hash /= BigInt(54);
+	while (hash > 0n) {
+		name += PART[Number(hash % BigInt(PART.length))];
+		hash /= BigInt(PART.length);
+	}
+	return name;
+}
+function handled(promise) {
+	promise.catch(() => {});
+	return promise;
+}
+//#endregion
+//#region src/build/chunk-tasks.ts
+const CHUNK_TASKS = {
+	packTopLevelEdits,
+	shortNameChunkFacts,
+	chunkDynamicImports: readChunkDynamicImports,
+	facadeChunkFacts,
+	strippedPreloadHelper: (_fileName, code) => stripEmptyVitePreloadWrappers(code),
+	unwrappedAsyncImports: (_fileName, code) => unwrapAsyncImportWrappersInCode(code),
+	helperImporterRewrite
+};
+function runChunkTaskInline(task, fileName, code, context) {
+	return CHUNK_TASKS[task](fileName, code, context);
+}
+//#endregion
+//#region src/build-workers.ts
+const workers = [];
+const queue = [];
+let size = 0;
+let unavailable = false;
+let nextId = 0;
+function workerUrl() {
+	return new URL(import.meta.url.endsWith(".ts") ? "./build-worker.ts" : "./build-worker.js", import.meta.url);
+}
+function addWorker() {
+	if (unavailable || workers.length >= size) return;
+	let worker;
+	try {
+		worker = new Worker(workerUrl());
+	} catch {
+		if (!workers.length) {
+			unavailable = true;
+			for (const queued of queue.splice(0)) giveBack(queued);
+		}
+		return;
+	}
+	const entry = {
+		worker,
+		writes: /* @__PURE__ */ new Map(),
+		job: void 0,
+		online: false
+	};
+	workers.push(entry);
+	worker.unref();
+	worker.once("online", () => {
+		entry.online = true;
+		addWorker();
+		dispatch();
+	});
+	worker.on("message", (message) => {
+		if (message.written) {
+			entry.writes.get(message.id)?.();
+			entry.writes.delete(message.id);
+			return;
+		}
+		const job = entry.job;
+		entry.job = void 0;
+		if (job?.kind === "chunk") {
+			if (message.error !== void 0) job.reject(new Error(message.error));
+			else job.resolve(message.result);
+		} else if (job && (message.failed || !message.buffer)) job.resolve(void 0);
+		else if (job) {
+			if (job.store) job.written(new Promise((resolve) => entry.writes.set(job.id, resolve)));
+			job.resolve(deserialize(new Uint8Array(message.buffer, message.offset, message.length)));
+		}
+		dispatch();
+	});
+	const retire = () => {
+		const index = workers.indexOf(entry);
+		if (index === -1) return;
+		workers.splice(index, 1);
+		const job = entry.job;
+		entry.job = void 0;
+		if (job) giveBack(job);
+		for (const written of entry.writes.values()) written();
+		entry.writes.clear();
+		if (!workers.some((item) => item.online)) for (const queued of queue.splice(0)) giveBack(queued);
+		dispatch();
+	};
+	worker.on("error", retire);
+	worker.on("exit", retire);
+}
+function dispatch() {
+	for (const entry of workers) {
+		if (!entry.online || entry.job) continue;
+		const job = queue.shift();
+		if (!job) break;
+		entry.job = job;
+		entry.worker.ref();
+		try {
+			entry.worker.postMessage(job.kind === "chunk" ? {
+				kind: "chunk",
+				id: job.id,
+				task: job.task,
+				fileName: job.fileName,
+				code: job.code,
+				context: job.context
+			} : {
+				kind: "compile",
+				id: job.id,
+				input: job.input,
+				key: job.key,
+				store: job.store
+			});
+		} catch {
+			entry.job = void 0;
+			giveBack(job);
+		}
+	}
+	for (const entry of workers) if (!entry.job) entry.worker.unref();
+}
+function giveBack(job) {
+	if (job.kind === "compile") {
+		job.resolve(void 0);
+		return;
+	}
+	try {
+		job.resolve(runChunkTaskInline(job.task, job.fileName, job.code, job.context));
+	} catch (error) {
+		job.reject(error);
+	}
+}
+/** How many build workers a process starts: one per core but one, at most seven, or `MARKLESS_COMPILE_WORKERS`. */
+function buildWorkerCount() {
+	const configured = Number(process.env.MARKLESS_COMPILE_WORKERS);
+	if (Number.isInteger(configured) && configured >= 0) return configured;
+	return Math.max(0, Math.min(availableParallelism() - 1, 7));
+}
+/** Runs a chunk read on a build worker, or on the calling thread when the process starts none. */
+function runChunkJob(task, fileName, code, context) {
+	size = Math.max(size, buildWorkerCount());
+	if (unavailable || size === 0) try {
+		return Promise.resolve(runChunkTaskInline(task, fileName, code, context));
+	} catch (error) {
+		return Promise.reject(error);
+	}
+	if (!workers.length || workers.length < size && workers.every((entry) => entry.online)) addWorker();
+	return new Promise((resolve, reject) => {
+		queue.push({
+			kind: "chunk",
+			id: nextId++,
+			task,
+			fileName,
+			code,
+			context,
+			resolve,
+			reject
+		});
+		dispatch();
+	});
+}
+/** Compiles on worker threads; a compile no worker can take yet runs on the calling thread. */
+function createCompileWorkerPool(options) {
+	size = Math.max(size, options.size);
+	const store = options.store && {
+		directory: options.store.directory,
+		fingerprint: options.store.fingerprint
+	};
+	const writes = /* @__PURE__ */ new Set();
+	const runs = /* @__PURE__ */ new Set();
+	let closed = false;
+	return {
+		run(input, key) {
+			if (closed || options.size === 0) return void 0;
+			if (!workers.length || workers.length < size && workers.every((entry) => entry.online)) addWorker();
+			if (!workers.some((entry) => entry.online)) return void 0;
+			const run = new Promise((resolve) => {
+				queue.push({
+					kind: "compile",
+					id: nextId++,
+					input,
+					key,
+					store,
+					resolve,
+					written: (write) => {
+						writes.add(write);
+						write.finally(() => writes.delete(write));
+						options.store?.cache.track(write);
+					}
+				});
+				dispatch();
+			});
+			runs.add(run);
+			run.finally(() => runs.delete(run));
+			return run;
+		},
+		async close() {
+			closed = true;
+			while (runs.size || writes.size) await Promise.all([...runs, ...writes]);
+		}
+	};
+}
+//#endregion
+//#region src/build/chunk-workers.ts
+const CHUNK_WORKER_MIN_CODE_LENGTH = 32768;
+/** Runs a chunk analysis on a build worker when the chunk is large enough to pay for the trip. */
+function runChunkTask(task, fileName, code, context) {
+	if (code.length >= 32768) return runChunkJob(task, fileName, code, context);
+	try {
+		return Promise.resolve(runChunkTaskInline(task, fileName, code, context));
+	} catch (error) {
+		return Promise.reject(error);
+	}
+}
+/** Reads the dynamic imports of every large chunk on the workers, so later passes find them cached. */
+async function prefetchChunkDynamicImports(chunks) {
+	await Promise.all([...chunks].filter((chunk) => chunk.code.length >= 32768 && mayContainDynamicImport(chunk.code) && !knowsChunkDynamicImports(chunk.fileName, chunk.code)).map((chunk) => runChunkTask("chunkDynamicImports", chunk.fileName, chunk.code).then((found) => rememberChunkDynamicImports(chunk.fileName, chunk.code, found), () => {})));
+}
+//#endregion
+//#region src/build/lazy-module-facades.ts
+function lazyModuleFacadesPlugin(root = () => "", packOf, packRoutes, eagerLazyRoutes) {
+	let chunks = {};
+	let removed = /* @__PURE__ */ new Set();
+	let pending = /* @__PURE__ */ new Map();
+	const reset = () => {
+		chunks = {};
+		removed = /* @__PURE__ */ new Set();
+		pending = /* @__PURE__ */ new Map();
+	};
+	return {
+		name: "markless-lazy-module-facades",
+		api: { removedChunks: () => removed },
+		renderStart: reset,
+		renderChunk(code, chunk, options, meta) {
+			chunks[chunk.fileName] = {
+				type: "chunk",
+				fileName: chunk.fileName,
+				isEntry: chunk.isEntry,
+				facadeModuleId: chunk.facadeModuleId,
+				code,
+				imports: [...chunk.imports],
+				dynamicImports: [...chunk.dynamicImports],
+				moduleIds: [...chunk.moduleIds],
+				exports: [...chunk.exports]
+			};
+			return new Promise((resolve, reject) => {
+				pending.set(chunk.fileName, {
+					resolve,
+					reject
+				});
+				if (pending.size !== renderedChunkCount(meta.chunks)) return;
+				const collapse = () => {
+					try {
+						const results = /* @__PURE__ */ new Map();
+						chunks = Object.fromEntries(Object.entries(chunks).sort(([a], [b]) => localeOrder(a, b)));
+						const originals = new Map(Object.values(chunks).map((item) => [item.fileName, item.code]));
+						const edits = /* @__PURE__ */ new Map();
+						removed = new Set(collapseLazyModuleFacades(chunks, (chunk, replacements, suffix) => edits.set(chunk.fileName, {
+							replacements,
+							suffix
+						}), {
+							root: root(),
+							packOf,
+							packRoutes,
+							eagerLazyRoutes
+						}).removed);
+						const prefixes = buildPathIdentifierPrefixes(root());
+						const strip = (text) => prefixes.reduce((result, prefix) => result.replaceAll(prefix, ""), text);
+						for (const [fileName, original] of originals) {
+							if (removed.has(fileName)) continue;
+							const edit = edits.get(fileName);
+							const replacements = edit?.replacements ?? [];
+							const rootless = [];
+							for (const prefix of prefixes) for (let start = original.indexOf(prefix); start !== -1; start = original.indexOf(prefix, start + prefix.length)) {
+								const end = start + prefix.length;
+								if (![...replacements, ...rootless].some((item) => start < item.end && item.start < end)) rootless.push({
+									start,
+									end,
+									source: ""
+								});
+							}
+							if (!edit && rootless.length === 0) continue;
+							const source = new RolldownMagicString(original);
+							for (const replacement of replacements) source.overwrite(replacement.start, replacement.end, strip(replacement.source));
+							for (const range of rootless) source.remove(range.start, range.end);
+							source.append(strip(edit?.suffix ?? ""));
+							results.set(fileName, {
+								code: source.toString(),
+								map: options.sourcemap ? source.generateMap({ hires: true }).toString() : null
+							});
+						}
+						for (const [name, wait] of pending) wait.resolve(results.get(name) ?? null);
+						pending.clear();
+					} catch (error) {
+						for (const wait of pending.values()) wait.reject(error);
+						pending.clear();
+					}
+				};
+				Promise.all([prefetchChunkParses(Object.values(chunks).filter((item) => !item.moduleIds.length || mayContainDynamicImport(item.code))), prefetchFacadeChunkFacts(Object.values(chunks))]).then(() => {
+					collapse();
+					clearFacadeChunkFacts();
+					clearChunkFactCaches();
+				});
+			});
+		},
+		renderError(error) {
+			for (const wait of pending.values()) wait.reject(error);
+			reset();
+		},
+		generateBundle: {
+			order: "pre",
+			handler(_, bundle) {
+				const filenames = new Map(Object.values(bundle).filter((chunk) => chunk.type === "chunk").map((chunk) => [chunk.preliminaryFileName, chunk.fileName]));
+				for (const [name, chunk] of Object.entries(bundle)) {
+					if (chunk.type !== "chunk") continue;
+					if (removed.has(chunk.preliminaryFileName)) {
+						delete bundle[name];
+						if (chunk.sourcemapFileName) delete bundle[chunk.sourcemapFileName];
+						continue;
+					}
+					const updated = chunks[chunk.preliminaryFileName];
+					if (!updated) continue;
+					chunk.dynamicImports = updated.dynamicImports.map((name) => filenames.get(name) ?? name);
+					chunk.imports = updated.imports.map((name) => filenames.get(name) ?? name);
+					chunk.exports = updated.exports;
+					chunk.moduleIds = updated.moduleIds;
+				}
+			}
+		}
+	};
+}
+const localeOrder = new Intl.Collator().compare;
+function buildPathIdentifierPrefixes(root) {
+	const segments = root.split("/").filter(Boolean);
+	const prefixes = [];
+	for (let length = segments.length; length >= 2; length--) prefixes.push(encodeURIComponent(`/${segments.slice(0, length).join("/")}/`).replace(/[^\w$]/g, "_"));
+	return prefixes;
+}
+function collapseLazyModuleFacades(bundle, onEdit, options = {}) {
+	const chunks = new Map(Object.values(bundle).filter((item) => !!item && typeof item === "object" && item.type === "chunk").map((chunk) => [chunk.fileName, chunk]));
+	const packs = new Map([...chunks.values()].map((chunk) => [chunk.fileName, chunkPack(chunk, options.packOf)]));
+	const staticallyImported = new Set([...chunks.values()].flatMap((chunk) => chunk.imports));
+	const inert = /* @__PURE__ */ new Map();
+	const renderedCode = new Map([...chunks.values()].map((chunk) => [chunk.fileName, chunk.code]));
+	const inertClosure = (fileName, seen = /* @__PURE__ */ new Set()) => {
+		if (seen.has(fileName)) return true;
+		seen.add(fileName);
+		const chunk = chunks.get(fileName);
+		if (!chunk) return false;
+		let own = inert.get(fileName);
+		if (own === void 0) {
+			const facts = chunkInertness(chunk.fileName, renderedCode.get(fileName));
+			own = facts.inert && facts.leafSources.every((source) => {
+				const from = chunks.get(resolve$1(fileName, source));
+				return !!from && !from.imports.length && inertClosure(from.fileName, /* @__PURE__ */ new Set());
+			});
+			inert.set(fileName, own);
+		}
+		return own && chunk.imports.every((name) => inertClosure(name, seen));
+	};
+	const referenced = /* @__PURE__ */ new Set();
+	const unsupported = /* @__PURE__ */ new Set();
+	const imports = /* @__PURE__ */ new Map();
+	const awaitChecked = /* @__PURE__ */ new Map();
+	const awaiting = { has(fileName) {
+		let result = awaitChecked.get(fileName);
+		if (result === void 0) {
+			const code = renderedCode.get(fileName);
+			result = code !== void 0 && chunkTopLevelAwait(fileName, code);
+			awaitChecked.set(fileName, result);
+		}
+		return result;
+	} };
+	for (const chunk of chunks.values()) {
+		const expressions = mayContainDynamicImport(chunk.code) ? chunkDynamicImports(chunk.fileName, chunk.code) ?? dynamicImportsFromTree(chunk) : [];
+		imports.set(chunk.fileName, expressions);
+		const resolved = /* @__PURE__ */ new Set();
+		for (const expression of expressions) {
+			const value = expression.specifier;
+			if (value === void 0) continue;
+			const target = resolve$1(chunk.fileName, value);
+			resolved.add(target);
+			referenced.add(target);
+			if (!expression.plain) unsupported.add(target);
+		}
+		for (const target of chunk.dynamicImports) if (!resolved.has(target)) unsupported.add(target);
+	}
+	const facades = /* @__PURE__ */ new Map();
+	const exportBindings = /* @__PURE__ */ new Map();
+	const pending = [];
+	for (const chunk of chunks.values()) {
+		if (chunk.isEntry || chunk.moduleIds.length || !referenced.has(chunk.fileName) || unsupported.has(chunk.fileName) || chunk.exports.includes("then") || staticallyImported.has(chunk.fileName)) continue;
+		const candidates = chunk.imports.filter((name) => chunk.imports.every((other) => other === name || !!chunks.get(name)?.imports.includes(other)));
+		if (candidates.length !== 1) continue;
+		const target = chunks.get(candidates[0]);
+		if (!target || target === chunk || target.exports.includes("then") || !target.moduleIds.length && !target.exports.length) continue;
+		const parsed = parseChunkCode(chunk.fileName, chunk.code);
+		if (parsed.errors.length) continue;
+		const bindings = /* @__PURE__ */ new Map();
+		const calls = [];
+		const exports = [];
+		let supported = true;
+		for (const node of parsed.program.body) {
+			const from = node.type === "ImportDeclaration" ? resolve$1(chunk.fileName, node.source.value) : "";
+			if (node.type === "ImportDeclaration" && !node.attributes?.length && (from === target.fileName || target.imports.includes(from))) for (const specifier of node.specifiers) {
+				if (specifier.type !== "ImportSpecifier") {
+					supported = false;
+					break;
+				}
+				bindings.set(specifier.local.name, {
+					from,
+					name: specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value
+				});
+			}
+			else if (node.type === "ExpressionStatement" && node.expression.type === "CallExpression" && node.expression.callee.type === "Identifier" && node.expression.arguments.length === 0) {
+				const imported = bindings.get(node.expression.callee.name);
+				if (!imported) {
+					supported = false;
+					break;
+				}
+				calls.push(imported);
+			} else if (node.type === "ExportNamedDeclaration" && !node.declaration && !node.source) for (const specifier of node.specifiers) {
+				const local = specifier.local.type === "Identifier" ? specifier.local.name : specifier.local.value;
+				const imported = bindings.get(local);
+				if (!imported) {
+					supported = false;
+					break;
+				}
+				exports.push([specifier.exported.type === "Identifier" ? specifier.exported.name : specifier.exported.value, imported]);
+			}
+			else if (node.type !== "EmptyStatement") {
+				supported = false;
+				break;
+			}
+		}
+		if (!supported || !exports.length || exports.some(([name]) => name === "then" || /^(0|[1-9]\d*)$/.test(name))) continue;
+		exports.sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+		let targetBindings = exportBindings.get(target.fileName);
+		if (!targetBindings) {
+			targetBindings = chunkLocalExportSpecifiers(target.fileName, target.code) ?? exportSpecifiersFromTree(target);
+			exportBindings.set(target.fileName, targetBindings);
+		}
+		if ([...calls, ...exports.map(([, imported]) => imported)].some(({ from, name }) => from === target.fileName ? !targetBindings.has(name) : !chunks.get(from)?.exports.includes(name))) continue;
+		pending.push({
+			fileName: chunk.fileName,
+			target,
+			targetBindings,
+			calls,
+			exports,
+			identity: facadeIdentity(chunk, exports, calls, options.root)
+		});
+	}
+	pending.sort((a, b) => compareText(a.target.fileName, b.target.fileName) || compareText(a.identity, b.identity));
+	const reservedNames = /* @__PURE__ */ new Map();
+	const reserve = (target, base) => {
+		let reserved = reservedNames.get(target.fileName);
+		if (!reserved) {
+			reserved = [...new Set(target.code.match(PACKED_NAME_PATTERN) ?? [])];
+			reservedNames.set(target.fileName, reserved);
+		}
+		let name = base;
+		for (let attempt = 1; reserved.some((taken) => taken.startsWith(name)); attempt++) name = `${base}_${attempt}`;
+		reserved.push(name);
+		return name;
+	};
+	const namespaces = /* @__PURE__ */ new Map();
+	for (const facade of pending) {
+		if (!namespaces.has(facade.target.fileName)) namespaces.set(facade.target.fileName, reserve(facade.target, "__marklessNamespace"));
+		const loader = reserve(facade.target, `\$ml${shortHash(facade.identity)}`);
+		const imports = [];
+		const local = ({ from, name }) => {
+			if (from === facade.target.fileName) return facade.targetBindings.get(name);
+			let entry = imports.find((item) => item.from === from && item.name === name);
+			if (!entry) imports.push(entry = {
+				from,
+				name,
+				alias: `${loader}Import${imports.length}`
+			});
+			return entry.alias;
+		};
+		facades.set(facade.fileName, {
+			target: facade.target,
+			calls: facade.calls.map(local),
+			exports: facade.exports.map(([name, imported]) => [name, local(imported)]),
+			loader,
+			imports
+		});
+	}
+	const additions = /* @__PURE__ */ new Map();
+	const usesRegistry = (chunk) => !chunk.isEntry && !chunk.code.includes("__marklessPackLoad");
+	const registered = /* @__PURE__ */ new Map();
+	for (const chunk of chunks.values()) {
+		if (facades.has(chunk.fileName) || !usesRegistry(chunk)) continue;
+		for (const node of imports.get(chunk.fileName) ?? []) {
+			const value = node.specifier;
+			const facade = typeof value === "string" && facades.get(resolve$1(chunk.fileName, value));
+			if (!facade || facade.target === chunk && !awaiting.has(chunk.fileName)) continue;
+			const loaders = registered.get(facade.target.fileName) ?? /* @__PURE__ */ new Set();
+			loaders.add(facade.loader);
+			registered.set(facade.target.fileName, loaders);
+		}
+	}
+	for (const [fileName, facade] of facades) {
+		const namespace = namespaces.get(facade.target.fileName);
+		const declarations = additions.get(facade.target.fileName) ?? [`const ${namespace}=(${createPackedNamespace.toString()});`];
+		const { loader } = facade;
+		for (const { from, name, alias } of facade.imports) {
+			const path = relative(dirname(facade.target.fileName), from);
+			declarations.push(`import{${/^[A-Za-z_$][\w$]*$/.test(name) ? name : JSON.stringify(name)} as ${alias}}from${JSON.stringify(path.startsWith(".") ? path : `./${path}`)};`);
+		}
+		declarations.push(`export function ${loader}(){const state=${loader}.state;if(state){if(state.failed)throw state.error;return state.value}try{${facade.calls.map((name) => `${name}();`).join("")}return(${loader}.state={value:${namespace}({__proto__:null,${facade.exports.map(([name, local]) => `get ${JSON.stringify(name)}(){return ${local}}`).join(",")}})}).value}catch(error){throw(${loader}.state={failed:true,error}).error}}`);
+		additions.set(facade.target.fileName, declarations);
+		facade.target.exports.push(loader);
+		const original = chunks.get(fileName);
+		if (original.facadeModuleId && !facade.target.moduleIds.includes(original.facadeModuleId)) facade.target.moduleIds.push(original.facadeModuleId);
+	}
+	const routeChunks = /* @__PURE__ */ new Map();
+	for (const chunk of chunks.values()) {
+		const pack = packs.get(chunk.fileName);
+		if (pack?.startsWith("route:") && !facades.has(chunk.fileName)) routeChunks.set(pack.slice(6), [...routeChunks.get(pack.slice(6)) ?? [], chunk]);
+	}
+	const evaluatedByRoute = /* @__PURE__ */ new Map();
+	for (const chunk of chunks.values()) {
+		if (facades.has(chunk.fileName) || !usesRegistry(chunk)) continue;
+		for (const node of imports.get(chunk.fileName) ?? []) {
+			const value = node.specifier;
+			const facade = typeof value === "string" && facades.get(resolve$1(chunk.fileName, value));
+			if (!facade || facade.target === chunk || awaiting.has(facade.target.fileName) || evaluatesWith(chunk, facade.target, packs, awaiting, options.packRoutes) || !inertClosure(facade.target.fileName)) continue;
+			const to = packs.get(facade.target.fileName);
+			const toRoutes = to?.startsWith("shared:") ? options.packRoutes?.(to) : void 0;
+			for (const route of toRoutes ?? []) for (const evaluator of routeChunks.get(route) ?? []) if (evaluator !== facade.target) evaluatedByRoute.set(evaluator.fileName, /* @__PURE__ */ new Set([...evaluatedByRoute.get(evaluator.fileName) ?? [], facade.target]));
+		}
+	}
+	const eagerImports = /* @__PURE__ */ new Map();
+	for (const target of chunks.values()) {
+		const name = options.eagerLazyRoutes && ownPack(target, options.packOf);
+		if (!name || startupPackOfLazy(name) === name || facades.has(target.fileName)) continue;
+		const routes = options.eagerLazyRoutes(name);
+		if (!routes?.length || !inertClosure(target.fileName)) continue;
+		for (const route of routes) for (const evaluator of routeChunks.get(route) ?? []) {
+			const own = ownPack(evaluator, options.packOf);
+			if (evaluator === target || !own || startupPackOfLazy(own) !== own) continue;
+			eagerImports.set(evaluator.fileName, [...eagerImports.get(evaluator.fileName) ?? [], target]);
+		}
+	}
+	for (const [fileName, loaders] of registered) additions.get(fileName).push(`${PACK_REGISTRATION}={${[...loaders].join(",")}};`);
+	for (const chunk of chunks.values()) {
+		if (facades.has(chunk.fileName)) continue;
+		const replacements = [];
+		const lookup = usesRegistry(chunk);
+		const evaluated = new Set(evaluatedByRoute.get(chunk.fileName));
+		for (const node of imports.get(chunk.fileName) ?? []) {
+			const value = node.specifier;
+			if (typeof value !== "string") continue;
+			const facade = facades.get(resolve$1(chunk.fileName, value));
+			if (!facade) continue;
+			const path = relative(dirname(chunk.fileName), facade.target.fileName);
+			const specifier = JSON.stringify(path.startsWith(".") ? path : `./${path}`);
+			if (lookup && evaluatesWith(chunk, facade.target, packs, awaiting, options.packRoutes) && inertClosure(facade.target.fileName)) evaluated.add(facade.target);
+			replacements.push({
+				start: node.start,
+				end: node.end,
+				source: facade.target === chunk && !awaiting.has(chunk.fileName) ? `(async()=>{await 0;return ${facade.loader}()})()` : lookup ? `${PACK_LOAD}(${specifier},"${facade.loader}",()=>import(${specifier}))` : `import(${specifier}).then(module=>module.${facade.loader}())`
+			});
+		}
+		const eager = eagerImports.get(chunk.fileName) ?? [];
+		for (const target of eager) {
+			evaluated.delete(target);
+			if (!chunk.imports.includes(target.fileName)) chunk.imports.push(target.fileName);
+		}
+		const suffix = [
+			...eager.map((target) => {
+				const path = relative(dirname(chunk.fileName), target.fileName);
+				return `import${JSON.stringify(path.startsWith(".") ? path : `./${path}`)};`;
+			}),
+			...additions.get(chunk.fileName) ?? [],
+			...lookup && replacements.some(({ source }) => source.startsWith("__marklessPackLoad")) ? [PACK_LOAD_SOURCE] : [],
+			...evaluated.size ? [warmPacksSuffix([...evaluated].map((target) => {
+				const path = relative(dirname(chunk.fileName), target.fileName);
+				return path.startsWith(".") ? path : `./${path}`;
+			}))] : []
+		].join("\n");
+		if (replacements.length || suffix) onEdit?.(chunk, replacements, suffix);
+		const pieces = [];
+		let cursor = 0;
+		for (const replacement of replacements.sort((a, b) => a.start - b.start)) {
+			pieces.push(chunk.code.slice(cursor, replacement.start), replacement.source);
+			cursor = replacement.end;
+		}
+		pieces.push(chunk.code.slice(cursor), suffix);
+		chunk.code = pieces.join("");
+		chunk.dynamicImports = [...new Set(chunk.dynamicImports.flatMap((id) => {
+			const facade = facades.get(id);
+			return facade?.target === chunk && !awaiting.has(chunk.fileName) ? [] : [facade?.target.fileName ?? id];
+		}))];
+	}
+	for (const [key, value] of Object.entries(bundle)) if (facades.has(value?.fileName)) delete bundle[key];
+	return { removed: [...facades.keys()] };
+}
+const PACK_REGISTRY = "__marklessPacks";
+const PACK_REGISTRATION = `(globalThis.${PACK_REGISTRY}??={})[import.meta.url]`;
+const PACKED_NAME_PATTERN = /\$ml[\w$]*|__marklessNamespace[\w$]*/g;
+const PACK_LOAD_SOURCE = `function ${PACK_LOAD}(specifier,loader,load){const pack=globalThis.${PACK_REGISTRY}?.[import.meta.resolve?.(specifier)];return pack?Promise.resolve().then(pack[loader]):load().then(module=>module[loader]())}`;
+function evaluatesWith(importer, target, packs, awaiting, packRoutes) {
+	const from = packs.get(importer.fileName);
+	const to = packs.get(target.fileName);
+	const routes = (pack) => pack.startsWith("route:") ? [pack.slice(6)] : packRoutes?.(pack);
+	const toRoutes = to && routes(to);
+	return !!from && !!to && (to === "shared" || to === from || from !== "shared" && !!toRoutes && !!routes(from)?.every((route) => toRoutes.includes(route))) && target !== importer && !awaiting.has(target.fileName);
+}
+function chunkPack(chunk, packOf) {
+	const names = new Set(chunk.moduleIds.map((id) => startupPackOfLazy(packOf?.(id) ?? "")));
+	const [name] = names;
+	return names.size === 1 ? /^(route:.+|shared(?::[0-9a-z]+)?)$/.exec(packOfPiece(name ?? ""))?.[1] : void 0;
+}
+function ownPack(chunk, packOf) {
+	const names = new Set(chunk.moduleIds.map((id) => {
+		const pack = packOf?.(id);
+		return pack === void 0 ? void 0 : packOfPiece(pack);
+	}));
+	const [name] = names;
+	return names.size === 1 ? name : void 0;
+}
+const inertnessByCode = /* @__PURE__ */ new Map();
+const topLevelAwaitByCode = /* @__PURE__ */ new Map();
+function chunkInertness(fileName, code) {
+	return inertnessByCode.get(code) ?? readChunkInertness(fileName, code);
+}
+function chunkTopLevelAwait(fileName, code) {
+	return topLevelAwaitByCode.get(code) ?? readChunkTopLevelAwait(fileName, code);
+}
+function readChunkInertness(fileName, code) {
+	const parsed = parseChunkCode(fileName, code);
+	if (parsed.errors.length) return { inert: false };
+	const body = parsed.program.body;
+	const leafSources = /* @__PURE__ */ new Set();
+	const scope = topLevelScope(body, leafSources);
+	return body.every((node) => inertStatement(node, scope)) ? {
+		inert: true,
+		leafSources: [...leafSources]
+	} : { inert: false };
+}
+function readChunkTopLevelAwait(fileName, code) {
+	return code.includes("await") && mayContainDynamicImport(code) && hasTopLevelAwait(parseChunkCode(fileName, code).program);
+}
+/** Everything the facade collapse reads from one chunk's code, from a single parse. */
+function facadeChunkFacts(fileName, code) {
+	return {
+		dynamicImports: mayContainDynamicImport(code) ? readChunkDynamicImports(fileName, code) : void 0,
+		localExportSpecifiers: readChunkLocalExportSpecifiers(fileName, code),
+		inertness: readChunkInertness(fileName, code),
+		topLevelAwait: readChunkTopLevelAwait(fileName, code)
+	};
+}
+/** Reads every large chunk's facade facts on the chunk workers, so the collapse finds them cached. */
+async function prefetchFacadeChunkFacts(chunks) {
+	await Promise.all([...chunks].filter((chunk) => chunk.code.length >= CHUNK_WORKER_MIN_CODE_LENGTH).map((chunk) => runChunkTask("facadeChunkFacts", chunk.fileName, chunk.code).then((facts) => {
+		if (facts.dynamicImports !== void 0 || mayContainDynamicImport(chunk.code)) rememberChunkDynamicImports(chunk.fileName, chunk.code, facts.dynamicImports);
+		rememberChunkLocalExportSpecifiers(chunk.fileName, chunk.code, facts.localExportSpecifiers);
+		inertnessByCode.set(chunk.code, facts.inertness);
+		topLevelAwaitByCode.set(chunk.code, facts.topLevelAwait);
+	}, () => {})));
+}
+function clearFacadeChunkFacts() {
+	inertnessByCode.clear();
+	topLevelAwaitByCode.clear();
+}
+function topLevelScope(body, leafSources) {
+	const declared = /* @__PURE__ */ new Set();
+	const importSources = /* @__PURE__ */ new Map();
+	for (const node of body) {
+		const declaration = node.type === "ExportNamedDeclaration" ? node.declaration : node;
+		if (node.type === "ImportDeclaration") {
+			const source = node.source.value;
+			for (const specifier of node.specifiers) {
+				declared.add(specifier.local.name);
+				importSources.set(specifier.local.name, source);
+			}
+		} else if (declaration?.type === "FunctionDeclaration" || declaration?.type === "ClassDeclaration") declared.add(declaration.id.name);
+		else if (declaration?.type === "VariableDeclaration") {
+			for (const declarator of declaration.declarations) if (declarator.id.type === "Identifier") declared.add(declarator.id.name);
+		}
+	}
+	return {
+		declared,
+		leafImports: { has(name) {
+			const source = importSources.get(name);
+			if (source === void 0) return false;
+			leafSources.add(source);
+			return true;
+		} }
+	};
+}
+function inertStatement(node, scope) {
+	switch (node.type) {
+		case "ImportDeclaration":
+		case "ExportAllDeclaration":
+		case "FunctionDeclaration":
+		case "EmptyStatement": return true;
+		case "ExportNamedDeclaration": return !node.declaration || inertStatement(node.declaration, scope);
+		case "VariableDeclaration": return node.declarations.every((declarator) => declarator.id.type === "Identifier" && (!declarator.init || inertValue(declarator.init, scope)));
+		case "ExpressionStatement": return typeof node.directive === "string";
+		default: return false;
+	}
+}
+function inertValue(node, scope) {
+	switch (node.type) {
+		case "Literal":
+		case "FunctionExpression":
+		case "ArrowFunctionExpression": return true;
+		case "TemplateLiteral": return !node.expressions.length;
+		case "ParenthesizedExpression": return inertValue(node.expression, scope);
+		case "MemberExpression": {
+			let object = node;
+			while (object.type === "MemberExpression" && !object.computed) object = object.object;
+			return object.type === "Identifier" && !scope.declared.has(object.name);
+		}
+		case "ObjectExpression": return node.properties.every((property) => property.type === "Property" && !property.computed && inertValue(property.value, scope));
+		case "CallExpression": return node.callee.type === "Identifier" && scope.leafImports.has(node.callee.name) && node.arguments.every((argument) => inertValue(argument, scope));
+		default: return false;
+	}
+}
+function createPackedNamespace(bindings) {
+	const keys = Object.keys(bindings).sort();
+	const target = Object.create(null);
+	for (const key of keys) Object.defineProperty(target, key, {
+		writable: true,
+		enumerable: true,
+		configurable: false
+	});
+	Object.defineProperty(target, Symbol.toStringTag, { value: "Module" });
+	Object.preventExtensions(target);
+	return new Proxy(target, {
+		get(target, key) {
+			return key in bindings ? Reflect.get(bindings, key) : Reflect.get(target, key);
+		},
+		getOwnPropertyDescriptor(target, key) {
+			const descriptor = Reflect.getOwnPropertyDescriptor(target, key);
+			if (descriptor && typeof key === "string") descriptor.value = Reflect.get(bindings, key);
+			return descriptor;
+		},
+		defineProperty(target, key, descriptor) {
+			if (!(key in bindings)) return Reflect.defineProperty(target, key, descriptor);
+			return descriptor.configurable !== true && descriptor.enumerable !== false && descriptor.writable !== false && !("get" in descriptor) && !("set" in descriptor) && (!("value" in descriptor) || Object.is(descriptor.value, Reflect.get(bindings, key)));
+		},
+		set() {
+			return false;
+		},
+		ownKeys() {
+			return [...keys, Symbol.toStringTag];
+		}
+	});
+}
+function facadeIdentity(chunk, exports, calls, root) {
+	const module = chunk.facadeModuleId ? rootRelativeId(chunk.facadeModuleId, root) : "";
+	return withoutMachinePaths([
+		module,
+		exports.map(([name, binding]) => `${name}=${binding.name}`).join(","),
+		calls.map((binding) => binding.name).join(",")
+	].join("\0"), root);
+}
+function shortHash(text) {
+	let hash = 2166136261;
+	for (let index = 0; index < text.length; index++) {
+		hash ^= text.charCodeAt(index);
+		hash = Math.imul(hash, 16777619);
+	}
+	hash >>>= 0;
+	let name = "";
+	for (let index = 0; index < 4; index++) {
+		name += HASH_ALPHABET[hash % HASH_ALPHABET.length];
+		hash = Math.floor(hash / HASH_ALPHABET.length);
+	}
+	return name;
+}
+const HASH_ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+function compareText(a, b) {
+	return a < b ? -1 : a > b ? 1 : 0;
+}
+function dynamicImportsFromTree(chunk) {
+	const expressions = [];
+	const program = parseChunkCode(chunk.fileName, chunk.code).program;
+	walk(program, textOffsets(chunk.code, "import"), (node) => {
+		if (node.type !== "ImportExpression") return;
+		const value = importSource(node);
+		expressions.push({
+			start: node.start,
+			end: node.end,
+			specifier: typeof value === "string" ? value : void 0,
+			plain: !(node.options || node.phase && node.phase !== "evaluation")
+		});
+	});
+	return expressions;
+}
+function exportSpecifiersFromTree(chunk) {
+	const bindings = /* @__PURE__ */ new Map();
+	for (const node of parseChunkCode(chunk.fileName, chunk.code).program.body) {
+		if (node.type !== "ExportNamedDeclaration" || node.source) continue;
+		for (const specifier of node.specifiers) {
+			if (specifier.local.type !== "Identifier") continue;
+			bindings.set(specifier.exported.type === "Identifier" ? specifier.exported.name : specifier.exported.value, specifier.local.name);
+		}
+	}
+	return bindings;
+}
+function importSource(node) {
+	const source = node.source;
+	return source.type === "Literal" ? source.value : source.type === "TemplateLiteral" && source.expressions.length === 0 ? (source.quasis[0]?.value)?.cooked : void 0;
+}
+function resolve$1(importer, source) {
+	return source.startsWith(".") ? normalize(join(dirname(importer), source)) : source;
+}
+function hasTopLevelAwait(value) {
+	if (!value || typeof value !== "object") return false;
+	if (Array.isArray(value)) return value.some(hasTopLevelAwait);
+	const node = value;
+	if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") return false;
+	if (node.type === "AwaitExpression" || node.type === "ForOfStatement" && node.await) return true;
+	return Object.values(node).some(hasTopLevelAwait);
+}
+function walk(value, offsets, visit) {
+	if (!value || typeof value !== "object") return;
+	if (Array.isArray(value)) {
+		for (const item of value) if (mayHold(offsets, item)) walk(item, offsets, visit);
+		return;
+	}
+	const node = value;
+	visit(node);
+	for (const item of Object.values(node)) if (mayHold(offsets, item)) walk(item, offsets, visit);
+}
+function mayHold(offsets, value) {
+	return !value || typeof value !== "object" || Array.isArray(value) || spansAnyOffset(offsets, value);
+}
+//#endregion
+export { createCompileWorkerPool as a, stripUnusedVitePreloadHelperFromBundle as c, buildWorkerCount as i, packTopLevelPlugin as l, prefetchChunkDynamicImports as n, runChunkTaskInline as o, runChunkTask as r, shortExportNamesPlugin as s, lazyModuleFacadesPlugin as t, unwrapAsyncImportWrappers as u };