@qzsy/vinext 0.1.7

package/dist/plugins/dynamic-preload-metadata.js

@@ -0,0 +1,413 @@
+import { isUnknownRecord } from "../utils/record.js";
+import { hasTrailingComma } from "../utils/has-trailing-comma.js";
+import { relativeWithinRoot, tryRealpathSync } from "../build/ssr-manifest.js";
+import path from "node:path";
+import { parseAst } from "vite";
+import MagicString from "magic-string";
+//#region src/plugins/dynamic-preload-metadata.ts
+function getString(node, key) {
+	const value = node[key];
+	return typeof value === "string" ? value : null;
+}
+function getNumber(node, key) {
+	const value = node[key];
+	return typeof value === "number" ? value : null;
+}
+function getArray(node, key) {
+	const value = node[key];
+	return Array.isArray(value) ? value : [];
+}
+function getBoolean(node, key) {
+	return node[key] === true;
+}
+function nodeName(node) {
+	if (!isUnknownRecord(node)) return null;
+	const name = node.name;
+	if (typeof name === "string") return name;
+	const value = node.value;
+	return typeof value === "string" ? value : null;
+}
+function nodeStringValue(node) {
+	if (!isUnknownRecord(node)) return null;
+	const value = node.value;
+	return typeof value === "string" ? value : null;
+}
+function walkAst(value, visitor) {
+	if (!isUnknownRecord(value)) return;
+	visitor(value);
+	for (const [key, child] of Object.entries(value)) {
+		if (key === "parent") continue;
+		if (Array.isArray(child)) for (const item of child) walkAst(item, visitor);
+		else if (isUnknownRecord(child)) walkAst(child, visitor);
+	}
+}
+function importSource(node) {
+	const source = node.source;
+	if (!isUnknownRecord(source)) return null;
+	return nodeStringValue(source);
+}
+function isNextDynamicSource(source) {
+	return source === "next/dynamic" || source === "next/dynamic.js";
+}
+function collectDynamicImportLocals(ast) {
+	const locals = /* @__PURE__ */ new Set();
+	if (!isUnknownRecord(ast)) return locals;
+	for (const node of getArray(ast, "body")) {
+		if (!isUnknownRecord(node)) continue;
+		if (getString(node, "type") !== "ImportDeclaration") continue;
+		if (!isNextDynamicSource(importSource(node))) continue;
+		for (const specifier of getArray(node, "specifiers")) {
+			if (!isUnknownRecord(specifier)) continue;
+			if (getString(specifier, "type") !== "ImportDefaultSpecifier") continue;
+			const local = nodeName(specifier.local);
+			if (local) locals.add(local);
+		}
+	}
+	return locals;
+}
+function isIdentifierNameInSet(node, names) {
+	if (!isUnknownRecord(node)) return false;
+	return getString(node, "type") === "Identifier" && names.has(getString(node, "name") ?? "");
+}
+function isDynamicCall(node, dynamicLocals) {
+	if (getString(node, "type") !== "CallExpression") return false;
+	return isIdentifierNameInSet(node.callee, dynamicLocals);
+}
+function addBindingName(pattern, names) {
+	if (!isUnknownRecord(pattern)) return;
+	const type = getString(pattern, "type");
+	if (type === null) return;
+	switch (type) {
+		case "Identifier": {
+			const name = getString(pattern, "name");
+			if (name) names.add(name);
+			return;
+		}
+		case "AssignmentPattern":
+			addBindingName(pattern.left, names);
+			return;
+		case "RestElement":
+			addBindingName(pattern.argument, names);
+			return;
+		case "ArrayPattern":
+			for (const element of getArray(pattern, "elements")) addBindingName(element, names);
+			return;
+		case "ObjectPattern":
+			for (const property of getArray(pattern, "properties")) {
+				if (!isUnknownRecord(property)) continue;
+				if (getString(property, "type") === "RestElement") {
+					addBindingName(property.argument, names);
+					continue;
+				}
+				addBindingName(property.value, names);
+			}
+			return;
+		default: return;
+	}
+}
+function addVariableDeclarationBindingNames(node, names) {
+	if (!isUnknownRecord(node) || getString(node, "type") !== "VariableDeclaration") return;
+	for (const declaration of getArray(node, "declarations")) if (isUnknownRecord(declaration)) addBindingName(declaration.id, names);
+}
+function collectBlockScopedBindingNames(body) {
+	const names = /* @__PURE__ */ new Set();
+	for (const statement of body) {
+		if (!isUnknownRecord(statement)) continue;
+		const type = getString(statement, "type");
+		if (type === "VariableDeclaration") {
+			if (getString(statement, "kind") !== "var") addVariableDeclarationBindingNames(statement, names);
+			continue;
+		}
+		if (type === "FunctionDeclaration" || type === "ClassDeclaration") {
+			const name = nodeName(statement.id);
+			if (name) names.add(name);
+		}
+	}
+	return names;
+}
+function collectSwitchScopedBindingNames(node) {
+	const names = /* @__PURE__ */ new Set();
+	for (const switchCase of getArray(node, "cases")) {
+		if (!isUnknownRecord(switchCase)) continue;
+		for (const statement of getArray(switchCase, "consequent")) for (const name of collectBlockScopedBindingNames([statement])) names.add(name);
+	}
+	return names;
+}
+function collectVarBindingNames(value, names) {
+	if (!isUnknownRecord(value)) return;
+	const type = getString(value, "type");
+	if (type === "FunctionDeclaration" || type === "FunctionExpression" || type === "ArrowFunctionExpression") return;
+	if (type === "VariableDeclaration" && getString(value, "kind") === "var") addVariableDeclarationBindingNames(value, names);
+	for (const [key, child] of Object.entries(value)) {
+		if (key === "parent") continue;
+		if (Array.isArray(child)) for (const item of child) collectVarBindingNames(item, names);
+		else if (isUnknownRecord(child)) collectVarBindingNames(child, names);
+	}
+}
+function collectFunctionScopeBindingNames(node) {
+	const names = /* @__PURE__ */ new Set();
+	if (getString(node, "type") === "FunctionExpression") {
+		const name = nodeName(node.id);
+		if (name) names.add(name);
+	}
+	for (const param of getArray(node, "params")) addBindingName(param, names);
+	collectVarBindingNames(node.body, names);
+	return names;
+}
+function collectForBindingNames(node) {
+	const names = /* @__PURE__ */ new Set();
+	addVariableDeclarationBindingNames(node.init, names);
+	addVariableDeclarationBindingNames(node.left, names);
+	return names;
+}
+function withoutBindings(activeNames, localNames) {
+	if (activeNames.size === 0 || localNames.size === 0) return activeNames;
+	let scoped = null;
+	for (const name of localNames) {
+		if (!activeNames.has(name)) continue;
+		scoped ??= new Set(activeNames);
+		scoped.delete(name);
+	}
+	return scoped ?? activeNames;
+}
+function visitChildren(node, dynamicLocals, visitor) {
+	for (const [key, child] of Object.entries(node)) {
+		if (key === "parent") continue;
+		if (Array.isArray(child)) for (const item of child) visitDynamicCalls(item, dynamicLocals, visitor);
+		else if (isUnknownRecord(child)) visitDynamicCalls(child, dynamicLocals, visitor);
+	}
+}
+function visitDynamicCalls(value, dynamicLocals, visitor) {
+	if (!isUnknownRecord(value) || dynamicLocals.size === 0) return;
+	const type = getString(value, "type");
+	if (type === "Program") {
+		const scoped = withoutBindings(dynamicLocals, collectBlockScopedBindingNames(getArray(value, "body")));
+		for (const statement of getArray(value, "body")) visitDynamicCalls(statement, scoped, visitor);
+		return;
+	}
+	if (type === "BlockStatement") {
+		const scoped = withoutBindings(dynamicLocals, collectBlockScopedBindingNames(getArray(value, "body")));
+		for (const statement of getArray(value, "body")) visitDynamicCalls(statement, scoped, visitor);
+		return;
+	}
+	if (type === "SwitchStatement") {
+		visitDynamicCalls(value.discriminant, dynamicLocals, visitor);
+		const scoped = withoutBindings(dynamicLocals, collectSwitchScopedBindingNames(value));
+		for (const switchCase of getArray(value, "cases")) visitDynamicCalls(switchCase, scoped, visitor);
+		return;
+	}
+	if (type === "FunctionDeclaration" || type === "FunctionExpression" || type === "ArrowFunctionExpression") {
+		visitChildren(value, withoutBindings(dynamicLocals, collectFunctionScopeBindingNames(value)), visitor);
+		return;
+	}
+	if (type === "ClassDeclaration" || type === "ClassExpression") {
+		const names = /* @__PURE__ */ new Set();
+		const name = nodeName(value.id);
+		if (name) names.add(name);
+		visitChildren(value, withoutBindings(dynamicLocals, names), visitor);
+		return;
+	}
+	if (type === "ForStatement" || type === "ForInStatement" || type === "ForOfStatement") {
+		visitChildren(value, withoutBindings(dynamicLocals, collectForBindingNames(value)), visitor);
+		return;
+	}
+	if (type === "CatchClause") {
+		const names = /* @__PURE__ */ new Set();
+		addBindingName(value.param, names);
+		visitChildren(value, withoutBindings(dynamicLocals, names), visitor);
+		return;
+	}
+	if (isDynamicCall(value, dynamicLocals)) visitor(value);
+	visitChildren(value, dynamicLocals, visitor);
+}
+function collectImportSpecifiers(node) {
+	const specifiers = [];
+	const seen = /* @__PURE__ */ new Set();
+	walkAst(node, (item) => {
+		if (getString(item, "type") === "ImportExpression") {
+			const specifier = nodeStringValue(item.source);
+			if (specifier && !seen.has(specifier)) {
+				seen.add(specifier);
+				specifiers.push(specifier);
+			}
+			return;
+		}
+		if (getString(item, "type") !== "CallExpression") return;
+		const callee = item.callee;
+		if (!isUnknownRecord(callee) || getString(callee, "type") !== "Import") return;
+		const firstArg = getArray(item, "arguments")[0];
+		const specifier = nodeStringValue(firstArg);
+		if (specifier && !seen.has(specifier)) {
+			seen.add(specifier);
+			specifiers.push(specifier);
+		}
+	});
+	return specifiers;
+}
+function propertyKeyName(property) {
+	if (!isUnknownRecord(property)) return null;
+	if (getBoolean(property, "computed")) return null;
+	return nodeName(property.key);
+}
+function objectProperties(node) {
+	if (!isUnknownRecord(node) || getString(node, "type") !== "ObjectExpression") return [];
+	return getArray(node, "properties").filter(isUnknownRecord);
+}
+function hasObjectProperty(node, name) {
+	return objectProperties(node).some((property) => propertyKeyName(property) === name);
+}
+function findObjectProperty(node, name) {
+	return objectProperties(node).find((property) => propertyKeyName(property) === name) ?? null;
+}
+function dynamicLoaderNode(firstArg) {
+	if (!isUnknownRecord(firstArg) || getString(firstArg, "type") !== "ObjectExpression") return firstArg;
+	return (findObjectProperty(firstArg, "loader") ?? findObjectProperty(firstArg, "modules"))?.value;
+}
+function findLastEndedProperty(node) {
+	const properties = objectProperties(node);
+	for (let index = properties.length - 1; index >= 0; index -= 1) if (getNumber(properties[index], "end") !== null) return properties[index];
+	return null;
+}
+function appendObjectProperty(output, objectNode, property) {
+	const start = getNumber(objectNode, "start");
+	const end = getNumber(objectNode, "end");
+	if (start === null || end === null) return false;
+	const lastProperty = findLastEndedProperty(objectNode);
+	if (!lastProperty) {
+		output.appendLeft(start + 1, property);
+		return true;
+	}
+	const propertyEnd = getNumber(lastProperty, "end");
+	if (propertyEnd === null) return false;
+	output.appendLeft(propertyEnd, `, ${property}`);
+	return true;
+}
+function insertSecondOptionsArgument(output, code, callNode, firstArg, optionsLiteral) {
+	const callEnd = getNumber(callNode, "end");
+	const firstArgEnd = getNumber(firstArg, "end");
+	if (callEnd === null || firstArgEnd === null) return false;
+	const closeParen = callEnd - 1;
+	const separator = hasTrailingComma(code.slice(firstArgEnd, closeParen)) ? " " : ", ";
+	output.appendLeft(closeParen, `${separator}${optionsLiteral}`);
+	return true;
+}
+function cleanResolvedId(id) {
+	let start = 0;
+	while (start < id.length && id.charCodeAt(start) === 0) start += 1;
+	return id.slice(start).replace(/^\/@fs\//, "/").split("?")[0].replace(/\\/g, "/");
+}
+const rootRealpathCache = /* @__PURE__ */ new Map();
+function cachedRootRealpath(root) {
+	if (!rootRealpathCache.has(root)) rootRealpathCache.set(root, tryRealpathSync(root));
+	return rootRealpathCache.get(root) ?? null;
+}
+/** `code` offset -> human `:line:column` (1-based), for build error messages. */
+function formatNodeLocation(code, node) {
+	const start = getNumber(node, "start");
+	if (start === null) return "";
+	const before = code.slice(0, start);
+	return `:${before.split("\n").length}:${start - before.lastIndexOf("\n")}`;
+}
+function toManifestModuleId(root, resolvedId) {
+	const cleaned = cleanResolvedId(resolvedId);
+	if (!path.isAbsolute(cleaned)) return cleaned.replace(/^\/+/, "");
+	const rootCandidates = new Set([root]);
+	const realRoot = cachedRootRealpath(root);
+	if (realRoot) rootCandidates.add(realRoot);
+	const moduleCandidates = new Set([cleaned]);
+	const realCleaned = tryRealpathSync(cleaned);
+	if (realCleaned) moduleCandidates.add(realCleaned.replace(/\\/g, "/"));
+	for (const rootCandidate of rootCandidates) for (const moduleCandidate of moduleCandidates) {
+		const relative = relativeWithinRoot(rootCandidate, moduleCandidate);
+		if (relative) return relative;
+	}
+	return null;
+}
+async function resolveManifestModuleIds(specifiers, importer, root, resolveDynamicImport) {
+	const resolvedIds = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const specifier of specifiers) {
+		const resolved = await resolveDynamicImport(specifier, importer);
+		const moduleId = resolved ? toManifestModuleId(root, resolved) : null;
+		if (!moduleId || seen.has(moduleId)) continue;
+		seen.add(moduleId);
+		resolvedIds.push(moduleId);
+	}
+	return resolvedIds;
+}
+function shouldSkipCall(firstArg, secondArg) {
+	if (hasObjectProperty(firstArg, "loadableGenerated")) return true;
+	return hasObjectProperty(secondArg, "loadableGenerated");
+}
+function applyLoadableGenerated(output, code, callNode, moduleIds) {
+	const args = getArray(callNode, "arguments");
+	const firstArg = args[0];
+	const secondArg = args[1];
+	if (!isUnknownRecord(firstArg)) return false;
+	if (shouldSkipCall(firstArg, secondArg)) return false;
+	const property = `loadableGenerated: { modules: ${JSON.stringify(moduleIds)} }`;
+	if (getString(firstArg, "type") === "ObjectExpression") return appendObjectProperty(output, firstArg, property);
+	if (secondArg === void 0) return insertSecondOptionsArgument(output, code, callNode, firstArg, `{ ${property} }`);
+	if (isUnknownRecord(secondArg) && getString(secondArg, "type") === "ObjectExpression") return appendObjectProperty(output, secondArg, property);
+	return false;
+}
+async function transformNextDynamicPreloadMetadata(code, id, root, resolveDynamicImport) {
+	if (!code.includes("next/dynamic")) return null;
+	let ast;
+	try {
+		ast = parseAst(code);
+	} catch (error) {
+		if (typeof process !== "undefined" && process.env?.DEBUG?.includes("vinext")) console.debug(`[vinext] dynamic-preload-metadata: failed to parse ${id}:`, error);
+		return null;
+	}
+	const dynamicLocals = collectDynamicImportLocals(ast);
+	if (dynamicLocals.size === 0) return null;
+	const output = new MagicString(code);
+	let changed = false;
+	const pending = [];
+	visitDynamicCalls(ast, dynamicLocals, (node) => {
+		const args = getArray(node, "arguments");
+		if (args.length > 2) throw new Error(`next/dynamic only accepts 2 arguments (${id}${formatNodeLocation(code, node)})`);
+		const specifiers = collectImportSpecifiers(dynamicLoaderNode(args[0]));
+		if (specifiers.length === 0) return;
+		pending.push(resolveManifestModuleIds(specifiers, id, root, resolveDynamicImport).then((moduleIds) => {
+			if (moduleIds.length === 0) return;
+			if (applyLoadableGenerated(output, code, node, moduleIds)) changed = true;
+		}));
+	});
+	await Promise.all(pending);
+	if (!changed) return null;
+	return {
+		code: output.toString(),
+		map: output.generateMap({ hires: "boundary" })
+	};
+}
+function createDynamicPreloadMetadataPlugin() {
+	let root = process.cwd();
+	return {
+		name: "vinext:dynamic-preload-metadata",
+		configResolved(config) {
+			root = config.root;
+		},
+		transform: {
+			filter: {
+				id: {
+					include: /\.(tsx?|jsx?|mjs)$/,
+					exclude: /node_modules/
+				},
+				code: "next/dynamic"
+			},
+			async handler(code, id) {
+				if (id.includes("node_modules") || id.startsWith("\0")) return null;
+				if (!/\.(tsx?|jsx?|mjs)$/.test(id)) return null;
+				const result = await transformNextDynamicPreloadMetadata(code, id, root, async (specifier, importer) => {
+					return (await this.resolve(specifier, importer, { skipSelf: true }))?.id ?? null;
+				});
+				if (!result) return null;
+				return result;
+			}
+		}
+	};
+}
+//#endregion
+export { createDynamicPreloadMetadataPlugin, transformNextDynamicPreloadMetadata };

package/dist/plugins/extensionless-dynamic-import.d.ts

@@ -0,0 +1,6 @@
+import { Plugin } from "vite";
+
+//#region src/plugins/extensionless-dynamic-import.d.ts
+declare function createExtensionlessDynamicImportPlugin(): Plugin;
+//#endregion
+export { createExtensionlessDynamicImportPlugin };

package/dist/plugins/extensionless-dynamic-import.js

@@ -0,0 +1,155 @@
+import { forEachAstChild, hasRange, isAstRecord, nodeArray } from "./ast-utils.js";
+import { parseAst } from "vite";
+import MagicString from "magic-string";
+//#region src/plugins/extensionless-dynamic-import.ts
+const MODULE_EXTENSIONS = [
+	".mjs",
+	".js",
+	".mts",
+	".ts",
+	".jsx",
+	".tsx",
+	".json"
+];
+const TRANSFORMABLE_EXTENSIONS = new Set([
+	".mjs",
+	".js",
+	".mts",
+	".ts",
+	".jsx",
+	".tsx",
+	".cjs",
+	".cts"
+]);
+function createExtensionlessDynamicImportPlugin() {
+	let moduleExtensions = MODULE_EXTENSIONS;
+	return {
+		name: "vinext:extensionless-dynamic-import",
+		enforce: "pre",
+		configResolved(config) {
+			moduleExtensions = getModuleExtensions(config);
+		},
+		transform: {
+			filter: {
+				id: {
+					include: /\.(?:[cm]?[jt]s|[jt]sx)(?:\?.*)?$/i,
+					exclude: /[\\/]node_modules[\\/]/
+				},
+				code: /\bimport\s*\(/
+			},
+			handler(code, id) {
+				const lang = langForId(id);
+				let ast;
+				try {
+					ast = parseAst(code, { lang });
+				} catch {
+					return null;
+				}
+				const imports = collectExtensionlessImports(ast, code, moduleExtensions);
+				if (imports.length === 0) return null;
+				const output = new MagicString(code);
+				for (const dynamicImport of imports) {
+					const source = code.slice(dynamicImport.sourceStart, dynamicImport.sourceEnd);
+					output.overwrite(dynamicImport.start, dynamicImport.end, buildReplacement(source, dynamicImport.globPattern, dynamicImport.moduleExtensions));
+				}
+				return {
+					code: output.toString(),
+					map: output.generateMap({ hires: "boundary" })
+				};
+			}
+		}
+	};
+}
+function langForId(id) {
+	const clean = id.split("?", 1)[0];
+	const dot = clean.lastIndexOf(".");
+	if (dot < 0) return null;
+	const ext = clean.slice(dot).toLowerCase();
+	if (!TRANSFORMABLE_EXTENSIONS.has(ext)) return null;
+	if (ext === ".ts" || ext === ".mts" || ext === ".cts") return "ts";
+	if (ext === ".tsx") return "tsx";
+	return "jsx";
+}
+function collectExtensionlessImports(ast, code, moduleExtensions) {
+	const imports = [];
+	function visit(value) {
+		if (!isAstRecord(value)) return;
+		const parsed = parseExtensionlessImport(value, code, moduleExtensions);
+		if (parsed) {
+			imports.push(parsed);
+			return;
+		}
+		forEachAstChild(value, visit);
+	}
+	visit(ast);
+	return imports;
+}
+function parseExtensionlessImport(node, code, moduleExtensions) {
+	if (node.type !== "ImportExpression" || !hasRange(node)) return null;
+	if (node.options != null) return null;
+	const source = node.source;
+	if (!isAstRecord(source) || source.type !== "TemplateLiteral" || !hasRange(source)) return null;
+	if (nodeArray(source.expressions).length === 0) return null;
+	const quasiTexts = nodeArray(source.quasis).map(templateElementText);
+	if (quasiTexts.some((text) => text == null)) return null;
+	const texts = quasiTexts;
+	const first = texts[0];
+	if (!isImportPrefix(code.slice(node.start, source.start))) return null;
+	if (!(first.startsWith("./") || first.startsWith("../"))) return null;
+	if (texts.some((text) => /[*?[\]{}()!?#]/.test(text))) return null;
+	if (texts.slice(1).some((text) => text.includes("."))) return null;
+	const directoryEnd = first.lastIndexOf("/") + 1;
+	const directory = first.slice(0, directoryEnd);
+	const filenamePrefix = first.slice(directoryEnd);
+	if (filenamePrefix.includes(".")) return null;
+	return {
+		start: node.start,
+		end: node.end,
+		sourceStart: source.start,
+		sourceEnd: source.end,
+		globPattern: filenamePrefix.length > 0 ? [`${first}*`, `${first}*/**/*`] : `${directory}**/*`,
+		moduleExtensions
+	};
+}
+function isImportPrefix(value) {
+	const prefix = value.match(/^import\s*\(/)?.[0];
+	if (!prefix) return false;
+	let index = prefix.length;
+	while (index < value.length) {
+		const char = value[index];
+		if (/\s/.test(char)) {
+			index += 1;
+			continue;
+		}
+		if (value.startsWith("/*", index)) {
+			const commentEnd = value.indexOf("*/", index + 2);
+			if (commentEnd < 0) return false;
+			index = commentEnd + 2;
+			continue;
+		}
+		if (value.startsWith("//", index)) {
+			const lineEnd = value.indexOf("\n", index + 2);
+			if (lineEnd < 0) return true;
+			index = lineEnd + 1;
+			continue;
+		}
+		return false;
+	}
+	return true;
+}
+function templateElementText(value) {
+	if (!isAstRecord(value) || value.type !== "TemplateElement") return null;
+	const templateValue = value.value;
+	if (typeof templateValue !== "object" || templateValue === null) return null;
+	const cooked = Reflect.get(templateValue, "cooked");
+	return typeof cooked === "string" ? cooked : null;
+}
+function getModuleExtensions(config) {
+	return config.resolve.extensions.filter((extension) => extension !== ".node");
+}
+function buildReplacement(source, globPattern, moduleExtensions) {
+	const extensions = JSON.stringify(moduleExtensions);
+	return `((__vinextPath, __vinextModules = import.meta.glob(${JSON.stringify(globPattern)}), __vinextExtensions = ${extensions}) => { const __vinextLoader = __vinextModules[__vinextPath] ?? __vinextExtensions.map((__vinextExtension) => __vinextModules[__vinextPath + __vinextExtension]).find(Boolean) ?? __vinextExtensions.map((__vinextExtension) => __vinextModules[__vinextPath + "/index" + __vinextExtension]).find(Boolean); return __vinextLoader ? __vinextLoader() : Promise.reject(new Error("Cannot find module '" + __vinextPath + "'")); })(${source})`;
+}
+//#endregion
+export { createExtensionlessDynamicImportPlugin };

package/dist/plugins/fonts.d.ts

@@ -0,0 +1,95 @@
+import { Plugin } from "vite";
+
+//#region src/plugins/fonts.d.ts
+declare const VIRTUAL_GOOGLE_FONTS = "virtual:vinext-google-fonts";
+declare const RESOLVED_VIRTUAL_GOOGLE_FONTS: string;
+/**
+ * Rewrite absolute filesystem paths in cached Google Fonts CSS so the
+ * `@font-face { src: url(...) }` references point at the served URL the
+ * plugin's `writeBundle` hook copies the font files to.
+ *
+ * This is called once per transform, before the CSS string is embedded in
+ * the bundle as `_vinext.font.selfHostedCSS`. Every downstream consumer reads
+ * from the same rewritten CSS: the injected `<style data-vinext-fonts>` block, the
+ * HTML body's `<link rel="preload">` tags (via `collectFontPreloadsFromCSS`
+ * in `shims/font-google-base.ts`), and the HTTP `Link:` response header
+ * (via `buildAppPageFontLinkHeader` in `server/app-page-execution.ts`).
+ *
+ * Without this rewrite, all three emit the dev-machine filesystem path
+ * (e.g. `/home/user/project/.vinext/fonts/geist-<hash>/geist-<hash>.woff2`)
+ * and any production request fetches `<origin>/home/user/...` → 404.
+ *
+ * `assetsDir` must match whatever Vite has resolved for
+ * `build.assetsDir` on the client environment — otherwise the embedded
+ * CSS URLs and the files emitted by the `writeBundle` hook would diverge
+ * and a user who customizes `build.assetsDir` (e.g. to `"static"`) would
+ * see 404s on every preload. The call site in `injectSelfHostedCss`
+ * passes the resolved value through from plugin state. The default is
+ * kept only so the exported helper can be driven directly from unit
+ * tests without synthesizing a full plugin context.
+ *
+ * Uses split/join rather than regex because `cacheDir` is an absolute
+ * filesystem path that may contain regex metacharacters on unusual
+ * filesystems.
+ */
+declare function _rewriteCachedFontCssToServedUrls(css: string, cacheDir: string, assetsDir?: string): string;
+/**
+ * Safely parse a static JS object literal string into a plain object.
+ * Uses Vite's parseAst (Rollup/acorn) so no code is ever evaluated.
+ * Returns null if the expression contains anything dynamic (function calls,
+ * template literals, identifiers, computed properties, etc.).
+ *
+ * Supports: string literals, numeric literals, boolean literals,
+ * arrays of the above, and nested object literals.
+ */
+declare function parseStaticObjectLiteral(objectStr: string): Record<string, unknown> | null;
+declare function generateGoogleFontsVirtualModule(id: string, fontGoogleShimPath: string): string | null;
+/**
+ * Create the `vinext:google-fonts` Vite plugin.
+ *
+ * @param fontGoogleShimPath - Absolute path to the font-google shim module
+ *   (either `.ts` in source or `.js` in built packages). Resolved by the caller
+ *   so the plugin file has no dependency on `__dirname`.
+ * @param shimsDir - Absolute path to the shims directory. Used to skip shim
+ *   files from transform (they contain `next/font/google` references that must
+ *   not be rewritten).
+ */
+/**
+ * Scan `code` forward from `searchStart` for a `{...}` object literal that
+ * may contain arbitrarily nested braces.  Returns `[objStart, objEnd]` where
+ * `code[objStart] === '{'` and `code[objEnd - 1] === '}'`, or `null` if no
+ * balanced object is found.
+ *
+ * String literals (single-quoted, double-quoted, and backtick template
+ * literals including `${...}` interpolations) are fully skipped so that brace
+ * characters inside string values do not affect the depth count.
+ */
+declare function _findBalancedObject(code: string, searchStart: number): [number, number] | null;
+/**
+ * Given the index just past the closing `}` of an options object, skip
+ * optional whitespace and return the index after the closing `)`.
+ * Returns `null` if the next non-whitespace character is not `)`.
+ */
+declare function _findCallEnd(code: string, objEnd: number): number | null;
+declare function createGoogleFontsPlugin(fontGoogleShimPath: string, shimsDir: string): Plugin;
+/**
+ * Create the `vinext:local-fonts` Vite plugin.
+ *
+ * Rewrites relative font file paths in `next/font/local` calls into Vite
+ * asset import references so that both dev (/@fs/...) and prod
+ * (/assets/font-xxx.woff2) URLs resolve correctly.
+ *
+ * @param shimsDir - Absolute path to the shims directory (with trailing
+ *   separator). Used to skip vinext's own shim files from transform — they
+ *   contain example `next/font/local` paths in comments that must not be
+ *   rewritten. A precise prefix check is required (rather than a loose
+ *   substring match) because, now that `node_modules` is no longer excluded,
+ *   the guard runs against arbitrary third-party package paths — some of
+ *   which may legitimately contain the substring `font-local` (e.g. a
+ *   package named `font-local-loader`) and must still be transformed. This
+ *   mirrors `createGoogleFontsPlugin`, which takes `shimsDir` for the same
+ *   reason.
+ */
+declare function createLocalFontsPlugin(shimsDir: string): Plugin;
+//#endregion
+export { RESOLVED_VIRTUAL_GOOGLE_FONTS, VIRTUAL_GOOGLE_FONTS, _findBalancedObject, _findCallEnd, _rewriteCachedFontCssToServedUrls, createGoogleFontsPlugin, createLocalFontsPlugin, generateGoogleFontsVirtualModule, parseStaticObjectLiteral };