pudui 0.0.0

package/dist/transforms-DUsCAPAL.mjs

@@ -0,0 +1,707 @@
+import MagicString from "magic-string";
+import { parseSync, visitorKeys } from "oxc-parser";
+//#region src/transform/path.ts
+/**
+* Converts path separators to forward slashes.
+*
+* @param path Path to normalize.
+* @returns Path using `/` separators.
+*/
+function normalizePath(path) {
+	return path.replaceAll("\\", "/");
+}
+/**
+* Reads the final path segment.
+*
+* @param path Path to inspect.
+* @param extension Optional extension to trim from the basename.
+* @returns Final path segment.
+*/
+function pathBasename(path, extension) {
+	const normalizedPath = normalizePath(path);
+	const name = normalizedPath.slice(normalizedPath.lastIndexOf("/") + 1);
+	if (extension !== void 0 && extension !== "" && name.endsWith(extension)) return name.slice(0, -extension.length);
+	return name;
+}
+/**
+* Reads the extension from a path.
+*
+* @param path Path to inspect.
+* @returns Extension including the leading `.`, or an empty string.
+*/
+function pathExtname(path) {
+	const name = pathBasename(path);
+	const dotIndex = name.lastIndexOf(".");
+	return dotIndex === -1 ? "" : name.slice(dotIndex);
+}
+//#endregion
+//#region src/transform/ast.ts
+/**
+* Parses source code as an Oxc program.
+*
+* @param code Source code to parse.
+* @param id Module identifier used to infer language mode.
+* @returns Parsed Oxc program.
+*/
+function parseProgram(code, id) {
+	const result = parseSync(id, code, {
+		lang: languageForId(id),
+		range: true,
+		sourceType: "module"
+	});
+	if (result.errors.length > 0) throw new Error(result.errors[0].message);
+	return result.program;
+}
+/**
+* Infers Oxc parser language mode from a module id.
+*
+* @param id Module identifier or path.
+* @returns Parser language mode.
+*/
+function languageForId(id) {
+	const extension = pathExtname(id);
+	if (extension === ".tsx") return "tsx";
+	if (extension === ".ts" || extension === ".mts" || extension === ".cts") return "ts";
+	if (extension === ".jsx") return "jsx";
+	return "js";
+}
+/**
+* Walks an AST depth first.
+*
+* @param node Root node to visit.
+* @param enter Callback run before visiting child nodes.
+* @param leave Callback run after visiting child nodes.
+*/
+function walk(node, enter, leave) {
+	enter(node);
+	for (const key of visitorKeys[node.type] ?? []) {
+		const value = node[key];
+		if (Array.isArray(value)) {
+			for (const child of value) if (isNode(child)) walk(child, enter, leave);
+		} else if (isNode(value)) walk(value, enter, leave);
+	}
+	leave?.(node);
+}
+/**
+* Walks an AST while reporting lexical scope boundaries.
+*
+* @param node Root node to visit.
+* @param parent Parent node for the root.
+* @param callbacks Scope and visit callbacks.
+*/
+function walkWithScopes(node, parent, callbacks) {
+	const createsScope = isFunctionLike(node) || node.type === "BlockStatement";
+	if (createsScope) callbacks.enterScope(node);
+	callbacks.visit(node, parent);
+	for (const key of visitorKeys[node.type] ?? []) {
+		const value = node[key];
+		if (Array.isArray(value)) {
+			for (const child of value) if (isNode(child)) walkWithScopes(child, node, callbacks);
+		} else if (isNode(value)) walkWithScopes(value, node, callbacks);
+	}
+	if (createsScope) callbacks.leaveScope();
+}
+/**
+* Walks an AST without entering nested function bodies.
+*
+* @param node Root node to visit.
+* @param enter Callback run for each visited node.
+*/
+function walkSkippingNestedFunctions(node, enter) {
+	enter(node);
+	for (const key of visitorKeys[node.type] ?? []) {
+		const value = node[key];
+		if (Array.isArray(value)) {
+			for (const child of value) if (isNode(child) && !isFunctionLike(child)) walkSkippingNestedFunctions(child, enter);
+		} else if (isNode(value) && !isFunctionLike(value)) walkSkippingNestedFunctions(value, enter);
+	}
+}
+/**
+* Checks whether a node creates a function scope.
+*
+* @param node Node to inspect.
+* @returns `true` for function declarations, expressions, and arrows.
+*/
+function isFunctionLike(node) {
+	return node.type === "ArrowFunctionExpression" || node.type === "FunctionDeclaration" || node.type === "FunctionExpression";
+}
+/**
+* Checks whether a value has the minimal Oxc node shape.
+*
+* @param value Value to inspect.
+* @returns `true` when the value is an Oxc node.
+*/
+function isNode(value) {
+	return typeof value === "object" && value !== null && typeof value.type === "string" && typeof value.start === "number" && typeof value.end === "number";
+}
+/**
+* Reads only AST nodes from an unknown array-like value.
+*
+* @param value Value to inspect.
+* @returns AST nodes contained in the value.
+*/
+function readNodeArray(value) {
+	return Array.isArray(value) ? value.filter(isNode) : [];
+}
+/**
+* Reads an optional AST node.
+*
+* @param value Value to inspect.
+* @returns The node, or `undefined`.
+*/
+function readOptionalNode(value) {
+	return isNode(value) ? value : void 0;
+}
+/**
+* Reads an identifier name from a node-like value.
+*
+* @param value Value to inspect.
+* @returns Identifier name, or an empty string.
+*/
+function readIdentifierName(value) {
+	const node = readOptionalNode(value);
+	if (node?.type !== "Identifier") return "";
+	return typeof node.name === "string" ? node.name : "";
+}
+/**
+* Reads a string literal value.
+*
+* @param value Value to inspect.
+* @returns Literal string value, or an empty string.
+*/
+function readLiteralValue(value) {
+	const node = readOptionalNode(value);
+	if (node?.type !== "Literal") return "";
+	return typeof node.value === "string" ? node.value : "";
+}
+/**
+* Reads a static string from a literal or no-substitution template.
+*
+* @param value Value to inspect.
+* @returns Static string value, or an empty string.
+*/
+function readStringValue(value) {
+	const node = readOptionalNode(value);
+	if (node?.type === "Literal") return typeof node.value === "string" ? node.value : "";
+	if (node?.type !== "TemplateLiteral" || readNodeArray(node.expressions).length > 0) return "";
+	const quasi = readNodeArray(node.quasis)[0];
+	const cooked = typeof quasi?.value === "object" && quasi.value !== null ? quasi.value.cooked : void 0;
+	return typeof cooked === "string" ? cooked : "";
+}
+/**
+* Reads a required static string.
+*
+* @param value Value to inspect.
+* @returns Static string value.
+*/
+function readStringLiteral(value) {
+	const literal = readStringValue(value);
+	if (literal === "") throw new Error("Invalid hydrate metadata marker.");
+	return literal;
+}
+/**
+* Reads the top-level body nodes from a program.
+*
+* @param program Program to inspect.
+* @returns Top-level statement nodes.
+*/
+function getBody(program) {
+	return readNodeArray(program.body);
+}
+//#endregion
+//#region src/transforms/paths.ts
+const supportedModuleExtensions = new Set([
+	".cjs",
+	".cts",
+	".js",
+	".jsx",
+	".mjs",
+	".mts",
+	".ts",
+	".tsx"
+]);
+/**
+* Removes query and hash suffixes from a module id.
+*
+* @param id Raw module id.
+* @returns Clean module id.
+*/
+function cleanModuleId(id) {
+	const queryIndex = id.indexOf("?");
+	const hashIndex = id.indexOf("#");
+	const end = Math.min(queryIndex === -1 ? id.length : queryIndex, hashIndex === -1 ? id.length : hashIndex);
+	return id.slice(0, end);
+}
+/**
+* Checks whether a module id is eligible for Pudui transforms.
+*
+* @param id Clean module id.
+* @returns `true` when the module is source code outside `node_modules`.
+*/
+function shouldTransformModule(id) {
+	return !id.includes("/node_modules/") && supportedModuleExtensions.has(pathExtname(id));
+}
+/**
+* Resolves the development browser path for the configured browser entry.
+*
+* @param id Browser entry module id.
+* @param config Vite config used for base and root.
+* @returns Browser-served module path.
+*/
+function devBrowserEntryPath(id, config) {
+	if (id === "") return "";
+	if (isAbsolutePath(id)) return devModulePath(id, config);
+	return `${normalizeBase(config?.base)}${stripLeadingSlashes(normalizePath(id))}`;
+}
+/**
+* Resolves a module id to its Vite development module path.
+*
+* @param id Module id.
+* @param config Vite config used for base and root.
+* @returns Browser-served module path.
+*/
+function devModulePath(id, config) {
+	if (config === void 0) return normalizePath(id);
+	const relativePath = relativeToRoot(config.root, id);
+	if (relativePath.startsWith("../")) return `/@fs/${normalizePath(id)}`;
+	return `${normalizeBase(config.base)}${relativePath}`;
+}
+/**
+* Resolves an emitted asset filename to a public URL path.
+*
+* @param fileName Emitted asset filename.
+* @param config Vite config used for base.
+* @returns Public asset path.
+*/
+function publicAssetPath(fileName, config) {
+	return `${normalizeBase(config?.base)}${normalizePath(fileName)}`;
+}
+/**
+* Computes a normalized path from the Vite root to a module id.
+*
+* @param root Vite project root.
+* @param id Module id.
+* @returns Root-relative path, or a `..` path for files outside the root.
+*/
+function relativeToRoot(root, id) {
+	const normalizedRoot = normalizePath(root).replace(/\/$/u, "");
+	const normalizedId = normalizePath(id);
+	if (normalizedId === normalizedRoot) return "";
+	if (normalizedId.startsWith(`${normalizedRoot}/`)) return normalizedId.slice(normalizedRoot.length + 1);
+	return `../${normalizedId}`;
+}
+function normalizeBase(base) {
+	if (base === void 0 || base === "") return "/";
+	return base.endsWith("/") ? base : `${base}/`;
+}
+function isAbsolutePath(path) {
+	return path.startsWith("/") || path.length >= 3 && isAsciiLetter(path[0] ?? "") && path[1] === ":" && (path[2] === "/" || path[2] === "\\");
+}
+function isAsciiLetter(char) {
+	return char >= "A" && char <= "Z" || char >= "a" && char <= "z";
+}
+function stripLeadingSlashes(path) {
+	let start = 0;
+	while (path[start] === "/") start++;
+	return path.slice(start);
+}
+//#endregion
+//#region src/transforms/markers.ts
+/**
+* Build marker function name for entry metadata placeholders.
+*/
+const entryMarkerName = "__PUDUI_ENTRY__";
+/**
+* Build marker function name for hydration metadata placeholders.
+*/
+const hydrateMarkerName = "__PUDUI_HYDRATE__";
+const placeholderScheme = "pudui:";
+/**
+* Creates a serialized marker for a hydrated component export.
+*
+* @param id Module identifier.
+* @param exportName Component export name.
+* @returns Serialized marker string.
+*/
+function createHydrateMarker(id, exportName) {
+	return `${placeholderScheme}${normalizePath(id)}#${exportName}`;
+}
+/**
+* Creates a serialized marker for an entry macro call.
+*
+* @param id Module identifier.
+* @returns Serialized marker string.
+*/
+function createEntryMarker(id) {
+	return `${placeholderScheme}${normalizePath(id)}`;
+}
+/**
+* Parses a hydrated component marker.
+*
+* @param marker Marker string to parse.
+* @returns Parsed marker data, or `undefined` for invalid markers.
+*/
+function parseHydrateMarker(marker) {
+	if (!marker.startsWith(placeholderScheme)) return;
+	const value = marker.slice(6);
+	const exportNameStart = value.lastIndexOf("#");
+	if (exportNameStart === -1) return;
+	return {
+		id: value.slice(0, exportNameStart),
+		exportName: value.slice(exportNameStart + 1)
+	};
+}
+/**
+* Parses an entry marker.
+*
+* @param marker Marker string to parse.
+* @returns Parsed marker data, or `undefined` for invalid markers.
+*/
+function parseEntryMarker(marker) {
+	if (!marker.startsWith(placeholderScheme)) return;
+	const id = marker.slice(6);
+	if (id === "" || id.includes("#")) return;
+	return { id };
+}
+//#endregion
+//#region src/transforms.ts
+const entryName = "entry";
+const hydrateName = "hydrate";
+const macroModuleIds = new Set(["#pudui/macros", "pudui/macros"]);
+const macroNamesByImport = new Map([[entryName, "entry"], [hydrateName, "hydrate"]]);
+/**
+* Injects hydration macros into exported components in a `"use client"` module.
+*
+* The transform looks for exported component factories that create
+* `new Component({ ... })` and appends `hydrate: hydrate()` when needed.
+*
+* @param code Module source code.
+* @param id Stable module identifier used for parsing diagnostics.
+* @returns Transform result, or `null` when the module does not need changes.
+*
+* @example
+* ```ts
+* const result = transformUseClient('"use client"; export function App() {}', "/src/app.tsx");
+* ```
+*/
+function transformUseClient(code, id) {
+	if (!code.includes("Component") || !code.includes("use client")) return null;
+	const program = parseProgram(code, id);
+	const directives = readModuleDirectives(program);
+	if (!directives.hasUseClient) return null;
+	const componentOptions = findUseClientComponents(program);
+	if (componentOptions.length === 0) return null;
+	const hydrateLocalName = uniqueIdentifier(program, hydrateName);
+	const transformed = new MagicString(code);
+	const hydrateImport = hydrateLocalName === hydrateName ? hydrateName : `${hydrateName} as ${hydrateLocalName}`;
+	transformed.appendLeft(directives.end, `\nimport { ${hydrateImport} } from "#pudui/macros";`);
+	for (const options of componentOptions) appendHydrateOption(code, transformed, options, hydrateLocalName);
+	return {
+		code: transformed.toString(),
+		componentOptions,
+		map: null
+	};
+}
+/**
+* Replaces `hydrate()` and `entry()` macro calls with runtime metadata.
+*
+* This is the lower-level transform used by the Vite plugin. Applications
+* usually import the macros from `pudui/macros` and let the plugin call this.
+*
+* @param code Module source code.
+* @param id Stable module identifier used in hydration metadata.
+* @param options Mode-specific transform options.
+* @returns Transform result, or `null` when the module does not use macros.
+*/
+function transformHydrate(code, id, options) {
+	if (!code.includes(hydrateName) && !code.includes(entryName)) return null;
+	const program = parseProgram(code, id);
+	const macroImports = findMacroImports(program);
+	const hydrateNames = new Set(macroImports.filter((macroImport) => macroImport.kind === "hydrate").map((macroImport) => macroImport.localName));
+	const entryNames = new Set(macroImports.filter((macroImport) => macroImport.kind === "entry").map((macroImport) => macroImport.localName));
+	if (hydrateNames.size === 0 && entryNames.size === 0) return null;
+	const hydrateCalls = findHydrateCalls(program, hydrateNames);
+	const entryCalls = findEntryCalls(program, entryNames);
+	if (hydrateCalls.length === 0 && entryCalls.length === 0) return null;
+	const transformed = new MagicString(code);
+	removeMacroImports(transformed, macroImports);
+	for (const call of hydrateCalls) transformed.update(call.start, call.end, replacementForHydrateCall(id, call.exportName, options));
+	for (const call of entryCalls) transformed.update(call.start, call.end, replacementForEntryCall(options));
+	return {
+		code: transformed.toString(),
+		entryCalls,
+		hydrateCalls,
+		map: null
+	};
+}
+/**
+* Replaces build-time hydration marker calls with manifest-derived metadata.
+*
+* @param code Generated bundle code containing marker calls.
+* @param resolveMarker Function that maps marker strings to replacement arrays.
+* @returns Code with resolved marker calls replaced by JSON arrays.
+*/
+function replaceHydrateMarkers(code, resolveMarker) {
+	if (!code.includes("__PUDUI_HYDRATE__") && !code.includes("__PUDUI_ENTRY__")) return code;
+	const program = parseProgram(code, "hydrate-marker.js");
+	const transformed = new MagicString(code);
+	walk(program, (node) => {
+		if (!isMarkerCall(node, "__PUDUI_HYDRATE__") && !isMarkerCall(node, "__PUDUI_ENTRY__")) return;
+		const replacement = resolveMarker(readStringLiteral(readNodeArray(node.arguments)[0]));
+		if (replacement !== void 0) transformed.update(node.start, node.end, JSON.stringify(replacement));
+	});
+	return transformed.toString();
+}
+/**
+* Quickly checks whether source may contain Pudui macro calls.
+*
+* @param code Module source code.
+* @returns `true` when the source should be parsed for `hydrate()` or `entry()` macros.
+*/
+function shouldTransformHydrate(code) {
+	return code.includes("pudui/macros") && (code.includes(hydrateName) || code.includes(entryName));
+}
+/**
+* Quickly checks whether source may contain `"use client"` components.
+*
+* @param code Module source code.
+* @returns `true` when the source should be parsed by {@link transformUseClient}.
+*/
+function shouldTransformUseClient(code) {
+	return code.includes("use client") && code.includes("Component");
+}
+function readModuleDirectives(program) {
+	let end = 0;
+	let hasUseClient = false;
+	for (const statement of getBody(program)) {
+		if (statement.type !== "ExpressionStatement") break;
+		const expression = readOptionalNode(statement.expression);
+		if (expression?.type !== "Literal" || typeof expression.value !== "string") break;
+		end = statement.end;
+		hasUseClient ||= expression.value === "use client";
+	}
+	return {
+		end,
+		hasUseClient
+	};
+}
+function findUseClientComponents(program) {
+	const exportedFunctions = findExportedFunctions(program);
+	const componentOptions = [];
+	for (const statement of getBody(program)) for (const functionNode of collectTopLevelFunctionNodes(statement)) {
+		if (!exportedFunctions.has(functionNode)) continue;
+		componentOptions.push(...collectComponentOptions(functionNode));
+	}
+	return componentOptions;
+}
+function collectTopLevelFunctionNodes(statement) {
+	const declaration = statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration" ? readOptionalNode(statement.declaration) : statement;
+	if (declaration === void 0) return [];
+	if (isFunctionLike(declaration)) return [declaration];
+	if (declaration.type !== "VariableDeclaration") return [];
+	const functions = [];
+	for (const declarator of readNodeArray(declaration.declarations)) {
+		const init = readOptionalNode(declarator.init);
+		if (init !== void 0 && isFunctionLike(init)) functions.push(init);
+	}
+	return functions;
+}
+function collectComponentOptions(functionNode) {
+	const body = readOptionalNode(functionNode.body);
+	if (body?.type !== "BlockStatement") return [];
+	const componentOptions = [];
+	visitComponentFactoryBody(body, (node) => {
+		if (node.type !== "NewExpression") return;
+		const callee = readOptionalNode(node.callee);
+		if (callee?.type !== "Identifier" || readIdentifierName(callee) !== "Component") return;
+		const options = readNodeArray(node.arguments)[0];
+		if (options?.type === "ObjectExpression" && !hasObjectProperty(options, "hydrate")) componentOptions.push(options);
+	});
+	return componentOptions;
+}
+function visitComponentFactoryBody(node, enter) {
+	walkSkippingNestedFunctions(node, enter);
+}
+function hasObjectProperty(object, name) {
+	for (const property of readNodeArray(object.properties)) {
+		if (property.type !== "Property") continue;
+		const key = readOptionalNode(property.key);
+		if (!(property.computed === true) && key?.type === "Identifier" && readIdentifierName(key) === name) return true;
+		if (key?.type === "Literal" && key.value === name) return true;
+	}
+	return false;
+}
+function uniqueIdentifier(program, baseName) {
+	const names = /* @__PURE__ */ new Set();
+	walk(program, (node) => {
+		if (node.type === "Identifier") names.add(readIdentifierName(node));
+	});
+	if (!names.has(baseName)) return baseName;
+	let index = 2;
+	while (names.has(`${baseName}${index}`)) index++;
+	return `${baseName}${index}`;
+}
+function appendHydrateOption(code, transformed, options, hydrateLocalName) {
+	const lastProperty = readNodeArray(options.properties).at(-1);
+	if (lastProperty === void 0) {
+		transformed.appendLeft(options.end - 1, `hydrate: ${hydrateLocalName}()`);
+		return;
+	}
+	const hasTrailingComma = code.slice(lastProperty.end, options.end - 1).includes(",");
+	transformed.appendLeft(options.end - 1, `${hasTrailingComma ? "" : ","} hydrate: ${hydrateLocalName}()`);
+}
+function replacementForHydrateCall(id, exportName, options) {
+	if (options.mode === "client") return "undefined";
+	if (options.mode === "build") return `${hydrateMarkerName}(${JSON.stringify(options.createHydrateMarker(id, exportName))})`;
+	return JSON.stringify([
+		options.modulePath,
+		exportName,
+		[],
+		[]
+	]);
+}
+function replacementForEntryCall(options) {
+	if (options.mode === "client") return "[]";
+	if (options.mode === "build") return `${entryMarkerName}(${JSON.stringify(options.createEntryMarker(options.browserEntry))})`;
+	return `[${JSON.stringify(browserEntryPath(options))},[],${options.entryStylesExpression ?? "[]"}]`;
+}
+function browserEntryPath(options) {
+	if (options.mode !== "dev") return "";
+	return options.browserEntryPath ?? devBrowserEntryPath(options.browserEntry ?? "", void 0);
+}
+function findMacroImports(program) {
+	const imports = [];
+	for (const statement of getBody(program)) {
+		if (statement.type !== "ImportDeclaration" || !macroModuleIds.has(readLiteralValue(statement.source))) continue;
+		let specifierTotal = 0;
+		for (const specifier of readNodeArray(statement.specifiers)) if (specifier.type === "ImportSpecifier") specifierTotal++;
+		for (const specifier of readNodeArray(statement.specifiers)) {
+			if (specifier.type !== "ImportSpecifier" || !macroNamesByImport.has(readIdentifierName(specifier.imported))) continue;
+			imports.push({
+				kind: macroNamesByImport.get(readIdentifierName(specifier.imported)),
+				importEnd: statement.end,
+				importStart: statement.start,
+				localName: readIdentifierName(specifier.local),
+				specifierEnd: specifier.end,
+				specifierStart: specifier.start,
+				specifierTotal
+			});
+		}
+	}
+	return imports;
+}
+function removeMacroImports(code, macroImports) {
+	const importsByDeclaration = /* @__PURE__ */ new Map();
+	for (const macroImport of macroImports) {
+		const key = `${macroImport.importStart}:${macroImport.importEnd}`;
+		importsByDeclaration.set(key, [...importsByDeclaration.get(key) ?? [], macroImport]);
+	}
+	for (const imports of importsByDeclaration.values()) {
+		const firstImport = imports[0];
+		if (imports.length === firstImport.specifierTotal) {
+			code.remove(firstImport.importStart, firstImport.importEnd);
+			continue;
+		}
+		for (const macroImport of imports) code.remove(macroImport.specifierStart, macroImport.specifierEnd);
+	}
+}
+function findHydrateCalls(program, macroNames) {
+	const exportedFunctions = findExportedFunctions(program);
+	const functionStack = [];
+	const calls = [];
+	walk(program, (node) => {
+		if (isFunctionLike(node)) functionStack.push(exportedFunctions.get(node));
+		if (!isHydrateCall(node, macroNames)) return;
+		const exportName = functionStack.at(-1);
+		if (exportName === void 0) throw new Error("hydrate() must be called inside an exported component function.");
+		calls.push({
+			start: node.start,
+			end: node.end,
+			exportName
+		});
+	}, (node) => {
+		if (isFunctionLike(node)) functionStack.pop();
+	});
+	return calls;
+}
+function findEntryCalls(program, macroNames) {
+	const calls = [];
+	walk(program, (node) => {
+		if (!isEntryCall(node, macroNames)) return;
+		calls.push({
+			start: node.start,
+			end: node.end
+		});
+	});
+	return calls;
+}
+function findExportedFunctions(program) {
+	const topLevelFunctions = /* @__PURE__ */ new Map();
+	const namedExports = /* @__PURE__ */ new Map();
+	const exportedFunctions = /* @__PURE__ */ new WeakMap();
+	for (const statement of getBody(program)) if (statement.type === "FunctionDeclaration") topLevelFunctions.set(readIdentifierName(statement.id), statement);
+	else if (statement.type === "VariableDeclaration") collectVariableFunctions(statement, topLevelFunctions);
+	else if (statement.type === "ExportNamedDeclaration") collectNamedExport(statement, topLevelFunctions, namedExports, exportedFunctions);
+	else if (statement.type === "ExportDefaultDeclaration") collectDefaultExport(statement, topLevelFunctions, namedExports, exportedFunctions);
+	for (const [localName, exportName] of namedExports) {
+		const functionNode = topLevelFunctions.get(localName);
+		if (functionNode !== void 0) exportedFunctions.set(functionNode, exportName);
+	}
+	return exportedFunctions;
+}
+function collectNamedExport(statement, topLevelFunctions, namedExports, exportedFunctions) {
+	const declaration = readOptionalNode(statement.declaration);
+	if (declaration !== void 0) {
+		if (declaration.type === "FunctionDeclaration") exportedFunctions.set(declaration, readIdentifierName(declaration.id));
+		else if (declaration.type === "VariableDeclaration") collectVariableFunctions(declaration, topLevelFunctions, exportedFunctions);
+		return;
+	}
+	if (statement.source !== null) return;
+	for (const specifier of readNodeArray(statement.specifiers)) if (specifier.type === "ExportSpecifier") namedExports.set(readIdentifierName(specifier.local), readIdentifierName(specifier.exported));
+}
+function collectDefaultExport(statement, topLevelFunctions, namedExports, exportedFunctions) {
+	const declaration = readOptionalNode(statement.declaration);
+	if (declaration === void 0) return;
+	if (isFunctionLike(declaration)) exportedFunctions.set(declaration, "default");
+	else if (declaration.type === "Identifier") namedExports.set(readIdentifierName(declaration), "default");
+	else if (declaration.type === "VariableDeclaration") collectVariableFunctions(declaration, topLevelFunctions, exportedFunctions, "default");
+}
+function collectVariableFunctions(declaration, topLevelFunctions, exportedFunctions, exportName) {
+	for (const declarator of readNodeArray(declaration.declarations)) {
+		const id = readOptionalNode(declarator.id);
+		const init = readOptionalNode(declarator.init);
+		if (id?.type === "Identifier" && init !== void 0 && isFunctionLike(init)) {
+			const localName = readIdentifierName(id);
+			topLevelFunctions.set(localName, init);
+			exportedFunctions?.set(init, exportName ?? localName);
+		}
+	}
+}
+function isHydrateCall(node, macroNames) {
+	if (node.type !== "CallExpression") return false;
+	if (readNodeArray(node.arguments).length > 0) {
+		const callee = readOptionalNode(node.callee);
+		if (callee?.type === "Identifier" && macroNames.has(readIdentifierName(callee))) throw new Error("hydrate() does not accept arguments.");
+		return false;
+	}
+	const callee = readOptionalNode(node.callee);
+	return callee?.type === "Identifier" && macroNames.has(readIdentifierName(callee));
+}
+function isEntryCall(node, macroNames) {
+	if (node.type !== "CallExpression") return false;
+	if (readNodeArray(node.arguments).length > 0) {
+		const callee = readOptionalNode(node.callee);
+		if (callee?.type === "Identifier" && macroNames.has(readIdentifierName(callee))) throw new Error("entry() does not accept arguments.");
+		return false;
+	}
+	const callee = readOptionalNode(node.callee);
+	return callee?.type === "Identifier" && macroNames.has(readIdentifierName(callee));
+}
+function isMarkerCall(node, name) {
+	if (node.type !== "CallExpression") return false;
+	const callee = readOptionalNode(node.callee);
+	const args = readNodeArray(node.arguments);
+	return callee?.type === "Identifier" && readIdentifierName(callee) === name && args.length === 1;
+}
+//#endregion
+export { readNodeArray as C, walkWithScopes as D, walkSkippingNestedFunctions as E, normalizePath as O, readLiteralValue as S, walk as T, shouldTransformModule as _, transformUseClient as a, parseProgram as b, entryMarkerName as c, parseHydrateMarker as d, cleanModuleId as f, relativeToRoot as g, publicAssetPath as h, transformHydrate as i, pathExtname as k, hydrateMarkerName as l, devModulePath as m, shouldTransformHydrate as n, createEntryMarker as o, devBrowserEntryPath as p, shouldTransformUseClient as r, createHydrateMarker as s, replaceHydrateMarkers as t, parseEntryMarker as u, getBody as v, readOptionalNode as w, readIdentifierName as x, isFunctionLike as y };