pudui 0.0.0

package/dist/vite-plugin.mjs

@@ -0,0 +1,748 @@
+import { C as readNodeArray, D as walkWithScopes, E as walkSkippingNestedFunctions, O as normalizePath, S as readLiteralValue, T as walk, _ as shouldTransformModule, a as transformUseClient, b as parseProgram, d as parseHydrateMarker, f as cleanModuleId, g as relativeToRoot, h as publicAssetPath, i as transformHydrate, k as pathExtname, m as devModulePath, n as shouldTransformHydrate, o as createEntryMarker, p as devBrowserEntryPath, r as shouldTransformUseClient, s as createHydrateMarker, t as replaceHydrateMarkers, u as parseEntryMarker, v as getBody, w as readOptionalNode, x as readIdentifierName, y as isFunctionLike } from "./transforms-DUsCAPAL.mjs";
+import MagicString from "magic-string";
+import "oxc-parser";
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, resolve } from "node:path";
+//#region src/hmr-transform.ts
+const defaultRuntimeModule = "#pudui/hmr-runtime";
+const defaultRuntimeName = "__puduiHmr";
+const defaultRefreshParameterName = "__puduiRefresh";
+const defaultImportMeta = "import.meta";
+/**
+* Rewrites component modules so Vite HMR can refresh component implementations.
+*
+* The transform preserves compatible state cells when a component's captured
+* state shape is unchanged and invalidates when exports change incompatibly.
+*
+* @param code Module source code.
+* @param id Stable module identifier.
+* @param options Transform customization options.
+* @returns Transform result, or `null` when the module has no refreshable components.
+*/
+function transformHmr(code, id, options = {}) {
+	if (!code.includes("Component")) return null;
+	const components = findComponents(parseProgram(code, id));
+	if (components.length === 0) return null;
+	const runtimeName = options.runtimeName ?? defaultRuntimeName;
+	const refreshParameterName = options.refreshParameterName ?? defaultRefreshParameterName;
+	const importMeta = options.importMeta ?? defaultImportMeta;
+	const transformed = new MagicString(code);
+	transformed.prepend(`import * as ${runtimeName} from ${JSON.stringify(options.runtimeModule ?? defaultRuntimeModule)};\n`);
+	for (const component of components) applyComponentTransform(code, transformed, component, refreshParameterName);
+	transformed.append("\n");
+	for (const component of components) {
+		transformed.append(`${exportPrefix(component)}const ${component.localName} = ${runtimeName}.register(${importMeta}, ${JSON.stringify(id)}, ${JSON.stringify(component.exportName)}, ${JSON.stringify(signatureForState(component.state))}, ${component.setupName}, { exported: ${component.exported ? "true" : "false"} });\n`);
+		if (component.exportName === "default") transformed.append(`export default ${component.localName};\n`);
+	}
+	transformed.append(`if (${importMeta}.hot) {\n  ${importMeta}.hot.accept((__puduiHmrModule) => {\n    ${runtimeName}.accept(${importMeta}, __puduiHmrModule);\n  });\n}\n`);
+	return {
+		code: transformed.toString(),
+		components: components.map((component) => ({
+			exportName: component.exportName,
+			localName: component.localName,
+			signature: signatureForState(component.state),
+			state: component.state.map((binding) => binding.name)
+		})),
+		map: null
+	};
+}
+function applyComponentTransform(code, transformed, component, refreshParameterName) {
+	if (component.replacement.removeExportStart !== void 0) transformed.remove(component.replacement.removeExportStart, component.replacement.declaration.start);
+	if (component.exportStart !== void 0 && component.exportEnd !== void 0) transformed.remove(component.exportStart, component.exportEnd);
+	if (component.replacement.kind === "function") replaceFunctionHeader(code, transformed, component.replacement.functionNode, component.setupName, refreshParameterName);
+	else {
+		transformed.update(component.replacement.declaration.start, component.replacement.functionNode.start, `const ${component.setupName} = `);
+		insertRefreshParameter(code, transformed, component.replacement.functionNode, refreshParameterName);
+	}
+	const body = readOptionalNode(component.replacement.functionNode.body);
+	if (body?.type !== "BlockStatement") return;
+	const references = collectReferences(body, new Set(component.state.map((binding) => binding.name)), new Set(component.state.map((binding) => `${binding.id.start}:${binding.id.end}`)));
+	replaceStateDeclarations(code, transformed, component.state, references, refreshParameterName);
+	replaceComponentConstructors(transformed, body, refreshParameterName);
+	appendReferenceValues(transformed, references, component.state);
+}
+function replaceFunctionHeader(code, transformed, functionNode, setupName, refreshParameterName) {
+	const id = readOptionalNode(functionNode.id);
+	const body = readOptionalNode(functionNode.body);
+	if (id?.type !== "Identifier" || body === void 0) throw new Error("Cannot transform anonymous function declaration.");
+	const tail = code.slice(id.end, body.start);
+	transformed.update(functionNode.start, body.start, `function ${setupName}${withRefreshParameter(tail, refreshParameterName)}`);
+}
+function insertRefreshParameter(code, transformed, functionNode, refreshParameterName) {
+	const body = readOptionalNode(functionNode.body);
+	if (body?.type !== "BlockStatement") throw new Error("Fast refresh only supports component factories with block bodies.");
+	if (functionNode.type === "ArrowFunctionExpression") {
+		const params = readNodeArray(functionNode.params);
+		if (params.length === 1 && code[functionNode.start] !== "(") {
+			const param = params[0];
+			transformed.update(param.start, param.end, `(${refreshParameterName}, ${code.slice(param.start, param.end)})`);
+			return;
+		}
+	}
+	transformed.update(functionNode.start, body.start, withRefreshParameter(code.slice(functionNode.start, body.start), refreshParameterName));
+}
+function withRefreshParameter(functionTail, refreshParameterName) {
+	const openParen = functionTail.indexOf("(");
+	if (openParen === -1) throw new Error("Cannot find component factory parameter list.");
+	const closeParen = matchingParen(functionTail, openParen);
+	const beforeParams = functionTail.slice(0, openParen + 1);
+	const params = functionTail.slice(openParen + 1, closeParen);
+	const afterParams = functionTail.slice(closeParen);
+	return `${beforeParams}${refreshParameterName}${params.trim() === "" ? "" : ", "}${params}${afterParams}`;
+}
+function matchingParen(value, openParen) {
+	let depth = 0;
+	for (let index = openParen; index < value.length; index++) {
+		const char = value[index];
+		if (char === "(") depth++;
+		else if (char === ")") {
+			depth--;
+			if (depth === 0) return index;
+		}
+	}
+	throw new Error("Cannot find component factory parameter list.");
+}
+function replaceStateDeclarations(code, transformed, state, references, refreshParameterName) {
+	const byDeclaration = /* @__PURE__ */ new Map();
+	for (const binding of state) byDeclaration.set(binding.declaration, [...byDeclaration.get(binding.declaration) ?? [], binding]);
+	for (const [declaration, bindings] of byDeclaration) {
+		const replacement = bindings.map((binding) => {
+			const initializer = binding.init === void 0 ? "undefined" : rewrittenSegment(code, binding.init.start, binding.init.end, references);
+			return `const ${binding.name} = ${refreshParameterName}.cell(${JSON.stringify(binding.name)}, () => ${initializer});`;
+		}).join("\n");
+		transformed.update(declaration.start, declaration.end, replacement);
+	}
+}
+function replaceComponentConstructors(transformed, body, refreshParameterName) {
+	walk(body, (node) => {
+		if (node.type !== "NewExpression") return;
+		const callee = readOptionalNode(node.callee);
+		if (callee?.type === "Identifier" && readIdentifierName(callee) === "Component") transformed.update(node.start, callee.end, `${refreshParameterName}.component`);
+	});
+}
+function appendReferenceValues(transformed, references, state) {
+	const declarationRanges = state.map((binding) => [binding.declaration.start, binding.declaration.end]);
+	for (const reference of references) {
+		if (declarationRanges.some(([start, end]) => reference.start >= start && reference.end <= end)) continue;
+		if (reference.replacement !== void 0) transformed.update(reference.start, reference.end, reference.replacement);
+		else transformed.appendLeft(reference.end, ".value");
+	}
+}
+function rewrittenSegment(code, start, end, references) {
+	const nestedReferences = references.filter((reference) => reference.start >= start && reference.end <= end).sort((left, right) => right.end - left.end);
+	let output = code.slice(start, end);
+	for (const reference of nestedReferences) {
+		const replacement = reference.replacement ?? `${reference.name}.value`;
+		output = output.slice(0, reference.start - start) + replacement + output.slice(reference.end - start);
+	}
+	return output;
+}
+function findComponents(program) {
+	const topLevelFunctions = /* @__PURE__ */ new Map();
+	const namedExports = /* @__PURE__ */ new Map();
+	const components = [];
+	for (const statement of getBody(program)) if (statement.type === "FunctionDeclaration") {
+		const name = readIdentifierName(statement.id);
+		if (name !== "") topLevelFunctions.set(name, {
+			declaration: statement,
+			functionNode: statement,
+			kind: "function"
+		});
+	} else if (statement.type === "VariableDeclaration") collectTopLevelVariableFunctions(statement, topLevelFunctions);
+	else if (statement.type === "ExportNamedDeclaration") collectExportedDeclaration(statement, topLevelFunctions, namedExports, components);
+	else if (statement.type === "ExportDefaultDeclaration") collectDefaultExportedDeclaration(statement, topLevelFunctions, namedExports, components);
+	for (const [localName, namedExport] of namedExports) {
+		const replacement = topLevelFunctions.get(localName);
+		if (replacement !== void 0) addComponent(components, localName, namedExport.exportName, replacement, {
+			exported: true,
+			exportEnd: namedExport.exportEnd,
+			exportStart: namedExport.exportStart
+		});
+	}
+	const exportedLocals = new Set(components.map((component) => component.localName));
+	for (const [localName, replacement] of topLevelFunctions) if (!exportedLocals.has(localName)) addComponent(components, localName, localName, replacement, { exported: false });
+	return dedupeComponents(components).filter((component) => containsComponentConstructor(component.replacement.functionNode));
+}
+function collectExportedDeclaration(statement, topLevelFunctions, namedExports, components) {
+	const declaration = readOptionalNode(statement.declaration);
+	if (declaration !== void 0) {
+		if (declaration.type === "FunctionDeclaration") {
+			const localName = readIdentifierName(declaration.id);
+			if (localName !== "") addComponent(components, localName, localName, {
+				declaration,
+				functionNode: declaration,
+				kind: "function",
+				removeExportStart: statement.start
+			}, { exported: true });
+		} else if (declaration.type === "VariableDeclaration") collectExportedVariableFunctions(statement, declaration, components, void 0, true);
+		return;
+	}
+	if (statement.source !== null) return;
+	for (const specifier of readNodeArray(statement.specifiers)) if (specifier.type === "ExportSpecifier") namedExports.set(readIdentifierName(specifier.local), { exportName: readIdentifierName(specifier.exported) });
+}
+function collectDefaultExportedDeclaration(statement, topLevelFunctions, namedExports, components) {
+	const declaration = readOptionalNode(statement.declaration);
+	if (declaration === void 0) return;
+	if (declaration.type === "FunctionDeclaration") addComponent(components, readIdentifierName(declaration.id) || "__puduiDefault", "default", {
+		declaration,
+		functionNode: declaration,
+		kind: "function",
+		removeExportStart: statement.start
+	}, { exported: true });
+	else if (declaration.type === "Identifier") namedExports.set(readIdentifierName(declaration), {
+		exportEnd: statement.end,
+		exportName: "default",
+		exportStart: statement.start
+	});
+	else if (declaration.type === "VariableDeclaration") collectExportedVariableFunctions(statement, declaration, components, "default", true);
+}
+function collectTopLevelVariableFunctions(declaration, topLevelFunctions) {
+	for (const declarator of readNodeArray(declaration.declarations)) {
+		const id = readOptionalNode(declarator.id);
+		const init = readOptionalNode(declarator.init);
+		if (id?.type === "Identifier" && init !== void 0 && isBlockFunction(init)) topLevelFunctions.set(readIdentifierName(id), {
+			declaration,
+			functionNode: init,
+			id,
+			kind: "variable"
+		});
+	}
+}
+function collectExportedVariableFunctions(statement, declaration, components, exportName, exported = false) {
+	const declarations = readNodeArray(declaration.declarations);
+	if (declarations.length !== 1) return;
+	const declarator = declarations[0];
+	const id = readOptionalNode(declarator.id);
+	const init = readOptionalNode(declarator.init);
+	if (id?.type !== "Identifier" || init === void 0 || !isBlockFunction(init)) return;
+	const localName = readIdentifierName(id);
+	addComponent(components, localName, exportName ?? localName, {
+		declaration,
+		functionNode: init,
+		id,
+		kind: "variable",
+		removeExportStart: statement.start
+	}, { exported });
+}
+function addComponent(components, localName, exportName, replacement, options = {}) {
+	components.push({
+		exportEnd: options.exportEnd,
+		exported: options.exported ?? false,
+		exportName,
+		exportStart: options.exportStart,
+		localName,
+		node: replacement.functionNode,
+		replacement,
+		setupName: setupName(localName, exportName),
+		state: collectStateBindings(replacement.functionNode)
+	});
+}
+function dedupeComponents(components) {
+	const seen = /* @__PURE__ */ new Set();
+	const deduped = [];
+	for (const component of components) {
+		const key = `${component.localName}:${component.exportName}`;
+		if (!seen.has(key)) {
+			seen.add(key);
+			deduped.push(component);
+		}
+	}
+	return deduped;
+}
+function collectStateBindings(functionNode) {
+	const body = readOptionalNode(functionNode.body);
+	const state = [];
+	if (body?.type !== "BlockStatement") return state;
+	for (const statement of readNodeArray(body.body)) {
+		if (statement.type !== "VariableDeclaration") continue;
+		const declarations = readNodeArray(statement.declarations);
+		if (declarations.length === 0 || declarations.some((declarator) => {
+			const id = readOptionalNode(declarator.id);
+			const init = readOptionalNode(declarator.init);
+			return id?.type !== "Identifier" || isComponentConstructor(init);
+		})) continue;
+		for (const declarator of declarations) {
+			const id = readOptionalNode(declarator.id);
+			state.push({
+				declaration: statement,
+				id,
+				init: readOptionalNode(declarator.init),
+				kind: typeof statement.kind === "string" ? statement.kind : "let",
+				name: readIdentifierName(id)
+			});
+		}
+	}
+	return state;
+}
+function collectReferences(root, names, stateBindingIds) {
+	const references = [];
+	const scopeStack = [];
+	walkWithScopes(root, void 0, {
+		enterScope(node) {
+			scopeStack.push(collectScopeBindings(node, names, stateBindingIds));
+		},
+		leaveScope() {
+			scopeStack.pop();
+		},
+		visit(node, parent) {
+			if (node.type !== "Identifier") return;
+			const name = readIdentifierName(node);
+			if (!names.has(name) || isShadowed(name, scopeStack) || !isReferenceIdentifier(node, parent)) return;
+			references.push({
+				start: node.start,
+				end: node.end,
+				name,
+				replacement: shorthandReplacement(node, parent, name)
+			});
+		}
+	});
+	return references;
+}
+function collectScopeBindings(node, names, stateBindingIds) {
+	const bindings = /* @__PURE__ */ new Set();
+	if (isFunctionLike(node)) for (const param of readNodeArray(node.params)) collectPatternBindings(param, names, stateBindingIds, bindings);
+	const statements = node.type === "BlockStatement" ? readNodeArray(node.body) : isFunctionLike(node) && readOptionalNode(node.body)?.type === "BlockStatement" ? readNodeArray(readOptionalNode(node.body)?.body) : [];
+	for (const statement of statements) {
+		if (statement.type !== "VariableDeclaration") continue;
+		for (const declarator of readNodeArray(statement.declarations)) {
+			const id = readOptionalNode(declarator.id);
+			if (id !== void 0) collectPatternBindings(id, names, stateBindingIds, bindings);
+		}
+	}
+	return bindings;
+}
+function collectPatternBindings(pattern, names, stateBindingIds, bindings) {
+	walk(pattern, (node) => {
+		if (node.type !== "Identifier") return;
+		const name = readIdentifierName(node);
+		if (names.has(name) && !stateBindingIds.has(`${node.start}:${node.end}`)) bindings.add(name);
+	});
+}
+function isShadowed(name, scopeStack) {
+	return scopeStack.some((scope) => scope.has(name));
+}
+function shorthandReplacement(node, parent, name) {
+	if ((parent?.type === "Property" || parent?.type === "ObjectProperty") && parent.value === node && parent.shorthand === true) return `${name}: ${name}.value`;
+}
+function isReferenceIdentifier(node, parent) {
+	if (parent === void 0) return true;
+	if (parent.type === "VariableDeclarator" && parent.id === node) return false;
+	if ((parent.type === "FunctionDeclaration" || parent.type === "FunctionExpression" || parent.type === "ArrowFunctionExpression") && readNodeArray(parent.params).includes(node)) return false;
+	if (parent.type === "MemberExpression" || parent.type === "OptionalMemberExpression") {
+		if (parent.property === node && parent.computed !== true) return false;
+		const property = readOptionalNode(parent.property);
+		if (parent.object === node && property?.type === "Identifier" && readIdentifierName(property) === "value" && parent.computed !== true) return false;
+	}
+	if (parent.type === "Property" || parent.type === "ObjectProperty") {
+		if (parent.key === node && parent.computed !== true) return false;
+	}
+	if (parent.type === "LabeledStatement" || parent.type === "BreakStatement" || parent.type === "ContinueStatement") return false;
+	if (parent.type.startsWith("TS")) return false;
+	return true;
+}
+function containsComponentConstructor(functionNode) {
+	let found = false;
+	walkComponentFactoryBody(functionNode, (node) => {
+		if (isComponentConstructor(node)) found = true;
+	});
+	return found;
+}
+function walkComponentFactoryBody(functionNode, enter) {
+	const body = readOptionalNode(functionNode.body);
+	if (body?.type !== "BlockStatement") return;
+	walkSkippingNestedFunctions(body, enter);
+}
+function isComponentConstructor(node) {
+	if (node?.type !== "NewExpression") return false;
+	const callee = readOptionalNode(node.callee);
+	return callee?.type === "Identifier" && readIdentifierName(callee) === "Component";
+}
+function isBlockFunction(node) {
+	return isFunctionLike(node) && readOptionalNode(node.body)?.type === "BlockStatement";
+}
+function exportPrefix(component) {
+	return component.exported && component.exportName === component.localName && component.exportName !== "default" ? "export " : "";
+}
+function setupName(localName, exportName) {
+	const base = localName === "" ? "__puduiDefault" : localName;
+	return `${base === "default" ? "__puduiDefault" : base}$${exportName === "default" ? "default" : "setup"}`;
+}
+function signatureForState(state) {
+	return state.map((binding) => `${binding.kind}:${binding.name}`).join("|");
+}
+//#endregion
+//#region src/transforms/manifest.ts
+/**
+* Reads the Vite manifest asset from a Rolldown output object.
+*
+* @param output Build output to inspect.
+* @returns Parsed manifest, or `undefined` when no manifest asset exists.
+*/
+function readManifestFromOutput(output) {
+	const manifestAsset = output.output.find((chunk) => chunk.type === "asset" && chunk.fileName === ".vite/manifest.json");
+	if (manifestAsset?.source === void 0) return;
+	return JSON.parse(manifestAsset.source.toString());
+}
+/**
+* Reads the Vite manifest asset from an output bundle.
+*
+* @param bundle Output bundle to inspect.
+* @returns Parsed manifest, or `undefined` when no manifest asset exists.
+*/
+function readManifestFromBundle(bundle) {
+	const manifestAsset = Object.values(bundle).find((chunk) => chunk.type === "asset" && chunk.fileName === ".vite/manifest.json");
+	if (manifestAsset?.source === void 0) return;
+	return JSON.parse(manifestAsset.source.toString());
+}
+/**
+* Finds the manifest chunk for a source module id.
+*
+* @param manifest Manifest to search.
+* @param id Source module id.
+* @param config Vite config used for root-relative matching.
+* @returns Matching manifest chunk, or `undefined`.
+*/
+function findManifestEntry(manifest, id, config) {
+	if (manifest === void 0) return;
+	const normalizedId = normalizePath(id);
+	const rootRelativeId = config === void 0 ? void 0 : relativeToRoot(config.root, id);
+	for (const [key, entry] of Object.entries(manifest)) if (isManifestIdMatch(key, normalizedId, rootRelativeId, config) || entry.src !== void 0 && isManifestIdMatch(entry.src, normalizedId, rootRelativeId, config)) return entry;
+}
+/**
+* Collects imported chunk URLs for a manifest chunk.
+*
+* @param chunk Manifest chunk to inspect.
+* @param manifest Full Vite manifest.
+* @param config Vite config used for public asset paths.
+* @returns Public URLs for transitive imported chunks.
+*/
+function collectManifestImportPaths(chunk, manifest, config) {
+	const imports = /* @__PURE__ */ new Set();
+	collectManifestImports(chunk, manifest, imports);
+	return [...imports].map((fileName) => publicAssetPath(fileName, config));
+}
+/**
+* Collects stylesheet URLs for a manifest chunk and its imports.
+*
+* @param chunk Manifest chunk to inspect.
+* @param manifest Full Vite manifest.
+* @param config Vite config used for public asset paths.
+* @returns Public stylesheet URLs.
+*/
+function collectManifestStyles(chunk, manifest, config) {
+	const styles = /* @__PURE__ */ new Set();
+	collectManifestStyleFiles(chunk, manifest, styles, /* @__PURE__ */ new Set());
+	return [...styles].map((fileName) => publicAssetPath(fileName, config));
+}
+/**
+* Collects stylesheet URLs for an entire Vite environment manifest.
+*
+* @param manifest Manifest to inspect.
+* @param config Vite config used for public asset paths.
+* @returns Public stylesheet URLs.
+*/
+function collectManifestEnvironmentStyles(manifest, config) {
+	if (manifest === void 0) return [];
+	const styles = /* @__PURE__ */ new Set();
+	const chunks = Object.values(manifest);
+	const entryChunks = chunks.filter((chunk) => chunk.isEntry);
+	for (const chunk of entryChunks.length === 0 ? chunks : entryChunks) collectManifestStyleFiles(chunk, manifest, styles, /* @__PURE__ */ new Set());
+	return [...styles].map((fileName) => publicAssetPath(fileName, config));
+}
+/**
+* Collects emitted asset filenames for an entire Vite environment manifest.
+*
+* @param manifest Manifest to inspect.
+* @returns Emitted asset filenames.
+*/
+function collectManifestEnvironmentAssetFiles(manifest) {
+	if (manifest === void 0) return [];
+	const assets = /* @__PURE__ */ new Set();
+	const chunks = Object.values(manifest);
+	const entryChunks = chunks.filter((chunk) => chunk.isEntry);
+	for (const chunk of entryChunks.length === 0 ? chunks : entryChunks) collectManifestAssetFiles(chunk, manifest, assets, /* @__PURE__ */ new Set());
+	return [...assets];
+}
+function isManifestIdMatch(manifestId, normalizedId, rootRelativeId, config) {
+	const normalizedManifestId = normalizePath(manifestId);
+	return normalizedManifestId === normalizedId || normalizedManifestId === rootRelativeId || rootRelativeId !== void 0 && normalizedManifestId === `/${rootRelativeId}` || config !== void 0 && normalizePath(`${config.root}/${normalizedManifestId}`) === normalizedId;
+}
+function collectManifestImports(chunk, manifest, imports) {
+	if (manifest === void 0) return;
+	for (const manifestKey of chunk.imports ?? []) {
+		const importedChunk = manifest[manifestKey];
+		if (importedChunk === void 0 || imports.has(importedChunk.file)) continue;
+		imports.add(importedChunk.file);
+		collectManifestImports(importedChunk, manifest, imports);
+	}
+}
+function collectManifestStyleFiles(chunk, manifest, styles, visited) {
+	if (visited.has(chunk)) return;
+	visited.add(chunk);
+	if (manifest !== void 0) for (const manifestKey of chunk.imports ?? []) {
+		const importedChunk = manifest[manifestKey];
+		if (importedChunk !== void 0) collectManifestStyleFiles(importedChunk, manifest, styles, visited);
+	}
+	for (const fileName of chunk.css ?? []) styles.add(fileName);
+}
+function collectManifestAssetFiles(chunk, manifest, assets, visited) {
+	if (visited.has(chunk)) return;
+	visited.add(chunk);
+	if (manifest !== void 0) for (const manifestKey of chunk.imports ?? []) {
+		const importedChunk = manifest[manifestKey];
+		if (importedChunk !== void 0) collectManifestAssetFiles(importedChunk, manifest, assets, visited);
+	}
+	for (const fileName of chunk.css ?? []) assets.add(fileName);
+	for (const fileName of chunk.assets ?? []) assets.add(fileName);
+}
+//#endregion
+//#region src/vite-plugin.ts
+/**
+* Creates the full Pudui Vite plugin set.
+*
+* The returned plugins transform `"use client"` components, replace
+* `pudui/macros` calls, wire build manifest assets, and enable component HMR in
+* development.
+*
+* @param options Pudui Vite plugin options.
+* @returns Vite plugins required for Pudui applications.
+*
+* @example
+* ```ts
+* import { defineConfig } from "vite";
+* import pudui from "pudui/vite-plugin";
+*
+* export default defineConfig({
+*   plugins: [pudui({ browserEntry: "app/browser.tsx" })],
+* });
+* ```
+*/
+function pudui(options) {
+	return [
+		useClientPlugin(),
+		macrosPlugin(options),
+		hrmPlugin(options)
+	];
+}
+/**
+* Creates the transform that injects hydration macros for `"use client"` modules.
+*
+* Most applications should use the default {@link pudui} plugin set instead of
+* composing this directly.
+*
+* @returns A Vite plugin that scans client modules for exported components.
+*/
+function useClientPlugin() {
+	return {
+		name: "pudui:use-client",
+		enforce: "pre",
+		sharedDuringBuild: true,
+		transform(code, rawId) {
+			const id = cleanModuleId(rawId);
+			if (!shouldTransformModule(id) || !shouldTransformUseClient(code)) return null;
+			return transformUseClient(code, id);
+		}
+	};
+}
+/**
+* Creates the transform and build hooks that resolve Pudui macros.
+*
+* The plugin replaces `hydrate()` and `entry()` macro calls, adds client build
+* entries for hydrated modules, and copies manifest asset metadata between Vite
+* environments.
+*
+* @param options Pudui Vite plugin options.
+* @param options.browserEntry Browser entry module used for hydrated client bundles.
+* @returns A Vite plugin for macro transformation and build metadata.
+*/
+function macrosPlugin(options) {
+	const { browserEntry } = options;
+	let config;
+	const clientEntryIds = /* @__PURE__ */ new Set();
+	let clientManifest;
+	return {
+		name: "pudui:macros",
+		enforce: "pre",
+		sharedDuringBuild: true,
+		configResolved(resolvedConfig) {
+			config = resolvedConfig;
+		},
+		buildApp: {
+			order: "post",
+			async handler(builder) {
+				const { client, ...rest } = builder.environments;
+				await Promise.all(Object.values(rest).map((environment) => builder.build(environment)));
+				if (client !== void 0) {
+					const input = client.config.build.rolldownOptions.input;
+					if (input !== void 0 && !Array.isArray(input)) throw new Error("Pudui builder does not support non-array client input. Use an array of entry points instead.");
+					client.config.build.rolldownOptions.input = Array.from(new Set([
+						...input ?? [],
+						browserEntry,
+						...clientEntryIds
+					]));
+					client.config.build.rolldownOptions.preserveEntrySignatures ??= "exports-only";
+					const manifest = readManifestFromOutput(await builder.build(client));
+					if (manifest === void 0) throw new Error("Failed to find Vite manifest asset in client build output.");
+					clientManifest = manifest;
+				}
+				const outputs = await Promise.all(Object.values(rest).map((environment) => builder.build(environment)));
+				if (client !== void 0) await copyManifestAssetsToClient(outputs, client, config);
+			}
+		},
+		configEnvironment(name) {
+			if (name === "client") return { build: { manifest: true } };
+			return { build: {
+				emitAssets: true,
+				manifest: true
+			} };
+		},
+		async transform(code, rawId) {
+			const id = cleanModuleId(rawId);
+			if (!shouldTransformModule(id)) return null;
+			const build = isBuild(this.environment, config);
+			const clientBuild = build && this.environment?.name === "client";
+			const devServerStyles = build ? [] : await collectDevServerStylePaths(this, code, id, config);
+			const transformed = shouldTransformHydrate(code) ? transformHydrate(code, id, clientBuild ? { mode: "client" } : build ? {
+				browserEntry,
+				mode: "build",
+				createEntryMarker(moduleId) {
+					return createEntryMarker(moduleId);
+				},
+				createHydrateMarker(moduleId, exportName) {
+					return createHydrateMarker(moduleId, exportName);
+				}
+			} : {
+				browserEntry,
+				browserEntryPath: devBrowserEntryPath(browserEntry, config),
+				entryStylesExpression: devServerStylesExpression(),
+				mode: "dev",
+				modulePath: devModulePath(id, config)
+			}) : null;
+			if (transformed === null && devServerStyles.length === 0) return null;
+			if (build && !clientBuild && transformed?.hydrateCalls.length) clientEntryIds.add(id);
+			return {
+				code: `${registerDevServerStyles(devServerStyles)}${transformed?.code ?? code}`,
+				map: null
+			};
+		},
+		generateBundle: {
+			order: "post",
+			handler(_options, _bundle) {
+				const serverStyles = collectManifestEnvironmentStyles(readManifestFromBundle(_bundle), config);
+				for (const chunk of Object.values(_bundle)) {
+					if (chunk.type !== "chunk" || !chunk.code.includes("__PUDUI_HYDRATE__") && !chunk.code.includes("__PUDUI_ENTRY__")) continue;
+					chunk.code = replaceHydrateMarkers(chunk.code, (marker) => {
+						const entryInfo = parseEntryMarker(marker);
+						if (entryInfo !== void 0) {
+							const manifestEntry = findManifestEntry(clientManifest, entryInfo.id, config);
+							if (manifestEntry === void 0) return;
+							return [
+								publicAssetPath(manifestEntry.file, config),
+								collectManifestImportPaths(manifestEntry, clientManifest, config),
+								unique([...collectManifestStyles(manifestEntry, clientManifest, config), ...serverStyles])
+							];
+						}
+						const markerInfo = parseHydrateMarker(marker);
+						if (markerInfo === void 0) return;
+						const manifestEntry = findManifestEntry(clientManifest, markerInfo.id, config);
+						if (manifestEntry === void 0) return;
+						return [
+							publicAssetPath(manifestEntry.file, config),
+							markerInfo.exportName,
+							collectManifestImportPaths(manifestEntry, clientManifest, config),
+							collectManifestStyles(manifestEntry, clientManifest, config)
+						];
+					});
+				}
+			}
+		}
+	};
+}
+/**
+* Creates the Pudui component HMR transform.
+*
+* This is exported for advanced Vite integrations that need to compose Pudui's
+* plugin pieces manually.
+*
+* @param options HMR plugin options.
+* @param options.hmr HMR options, or `false` to disable the transform.
+* @returns A Vite plugin that rewrites components for refresh.
+*/
+function hrmPlugin(options = {}) {
+	const { hmr } = options;
+	let config;
+	return {
+		name: "pudui:hmr",
+		enforce: "pre",
+		sharedDuringBuild: true,
+		configResolved(resolvedConfig) {
+			config = resolvedConfig;
+		},
+		transform(code, rawId) {
+			const id = cleanModuleId(rawId);
+			const build = isBuild(this.environment, config);
+			if (!shouldTransformModule(id) || !shouldTransformHmr(code, build, this.environment) || hmr === false) return null;
+			return transformHmr(code, id, {
+				...hmr,
+				runtimeModule: hmr?.runtimeModule ?? "pudui/hmr-runtime"
+			});
+		}
+	};
+}
+/**
+* Alias for {@link hrmPlugin}.
+*/
+const hmrPlugin = hrmPlugin;
+function unique(values) {
+	return [...new Set(values)];
+}
+async function collectDevServerStylePaths(context, code, id, config) {
+	if (context.environment?.name === void 0 || context.environment.name === "client") return [];
+	const styleSources = collectCssImportSources(code, id);
+	if (styleSources.length === 0) return [];
+	return Promise.all(styleSources.map(async (source) => devModulePath(await resolveStyleId(context, source, id, config), config)));
+}
+function collectCssImportSources(code, id) {
+	const program = parseProgram(code, id);
+	const sources = /* @__PURE__ */ new Set();
+	for (const statement of getBody(program)) {
+		if (statement.type !== "ImportDeclaration") continue;
+		const source = readLiteralValue(statement.source);
+		if (pathExtname(cleanModuleId(source)) === ".css") sources.add(source);
+	}
+	return [...sources];
+}
+async function resolveStyleId(context, source, importer, config) {
+	const resolved = await context.resolve?.(source, importer, { skipSelf: true });
+	if (resolved !== void 0 && resolved !== null) return cleanModuleId(resolved.id);
+	if (source.startsWith(".")) return resolve(dirname(importer), source);
+	if (isAbsolute(source)) return source;
+	return config === void 0 ? source : resolve(config.root, "node_modules", source);
+}
+function registerDevServerStyles(styles) {
+	if (styles.length === 0) return "";
+	return `globalThis.__PUDUI_DEV_STYLES__ ??= new Set();\n${styles.map((href) => `globalThis.__PUDUI_DEV_STYLES__.add(${JSON.stringify(href)});`).join("\n")}\n`;
+}
+function devServerStylesExpression() {
+	return "Array.from(globalThis.__PUDUI_DEV_STYLES__ ?? [])";
+}
+async function copyManifestAssetsToClient(outputs, client, config) {
+	const clientOutDir = resolve(config?.root ?? "", client.config.build.outDir ?? "dist/client");
+	await Promise.all(outputs.flatMap((output) => {
+		const manifest = readManifestFromOutput(output);
+		const assetFiles = new Set(collectManifestEnvironmentAssetFiles(manifest));
+		return output.output.flatMap((chunk) => {
+			if (chunk.type !== "asset" || chunk.source === void 0 || !assetFiles.has(chunk.fileName)) return [];
+			const filePath = resolve(clientOutDir, chunk.fileName);
+			return mkdir(dirname(filePath), { recursive: true }).then(() => writeFile(filePath, chunk.source ?? ""));
+		});
+	}));
+}
+function shouldTransformHmr(code, build, environment) {
+	return !build && (environment?.name === void 0 || environment.name === "client") && code.includes("Component");
+}
+function isBuild(environment, config) {
+	return environment?.mode === "build" || config?.command === "build";
+}
+//#endregion
+export { pudui as default, hmrPlugin, hrmPlugin, macrosPlugin, replaceHydrateMarkers, transformHydrate, transformUseClient, useClientPlugin };