vinext 0.0.54 → 0.1.0

package/dist/init.d.ts

@@ -65,5 +65,4 @@ declare function getReactUpgradeDeps(root: string): string[];
 declare function updateGitignore(root: string): boolean;
 declare function init(options: InitOptions): Promise<InitResult>;
 //#endregion
-export { InitOptions, addScripts, generateViteConfig, getInitDeps, getReactUpgradeDeps, init, isDepInstalled, updateGitignore };
-//# sourceMappingURL=init.d.ts.map
+export { InitOptions, addScripts, generateViteConfig, getInitDeps, getReactUpgradeDeps, init, isDepInstalled, updateGitignore };

package/dist/init.js

@@ -153,7 +153,7 @@ function updateGitignore(root) {
 		if (lines.includes(exactEntry) || lines.includes("dist/") || lines.includes("dist")) return false;
 	}
 	const separator = content.length > 0 && !content.endsWith("\n") ? "\n" : "";
-	fs.writeFileSync(gitignorePath, content + separator + exactEntry + "\n", "utf-8");
+	fs.writeFileSync(gitignorePath, content + separator + "/dist/\n", "utf-8");
 	return true;
 }
 async function init(options) {
@@ -232,5 +232,3 @@ async function init(options) {
 }
 //#endregion
 export { addScripts, generateViteConfig, getInitDeps, getReactUpgradeDeps, init, isDepInstalled, updateGitignore };
-
-//# sourceMappingURL=init.js.map

package/dist/plugins/ast-utils.d.ts

@@ -0,0 +1,20 @@
+//#region src/plugins/ast-utils.d.ts
+type AstRecord = {
+  type: string;
+  start?: number;
+  end?: number;
+  [key: string]: unknown;
+};
+type AstRange = AstRecord & {
+  start: number;
+  end: number;
+};
+declare function isAstRecord(value: unknown): value is AstRecord;
+declare function nodeArray(value: unknown): unknown[];
+declare function hasRange(node: AstRecord | null): node is AstRange;
+declare function isIdentifierNamed(value: unknown, name: string): boolean;
+declare function getAstName(value: unknown): string | null;
+declare function forEachAstChild(node: AstRecord, callback: (child: AstRecord) => void): void;
+declare function collectBindingNames(pattern: unknown, target: Set<string>): void;
+//#endregion
+export { AstRange, AstRecord, collectBindingNames, forEachAstChild, getAstName, hasRange, isAstRecord, isIdentifierNamed, nodeArray };

package/dist/plugins/ast-utils.js

@@ -0,0 +1,78 @@
+//#region src/plugins/ast-utils.ts
+const SKIP_CHILD_KEYS = new Set([
+	"type",
+	"parent",
+	"loc",
+	"start",
+	"end"
+]);
+function getObjectProperty(value, key) {
+	if (typeof value !== "object" || value === null) return null;
+	return Reflect.get(value, key);
+}
+function isAstRecord(value) {
+	return typeof getObjectProperty(value, "type") === "string";
+}
+function toAstRecord(value) {
+	return isAstRecord(value) ? value : null;
+}
+function nodeArray(value) {
+	return Array.isArray(value) ? value : [];
+}
+function hasRange(node) {
+	return node !== null && typeof node.start === "number" && typeof node.end === "number";
+}
+function isIdentifierNamed(value, name) {
+	return isAstRecord(value) && value.type === "Identifier" && value.name === name;
+}
+function getAstName(value) {
+	const node = toAstRecord(value);
+	if (!node) return null;
+	if (node.type === "Identifier" && typeof node.name === "string") return node.name;
+	if (typeof node.value === "string") return node.value;
+	return null;
+}
+function forEachAstChild(node, callback) {
+	for (const [key, value] of Object.entries(node)) {
+		if (SKIP_CHILD_KEYS.has(key)) continue;
+		const child = toAstRecord(value);
+		if (child) {
+			callback(child);
+			continue;
+		}
+		if (Array.isArray(value)) for (const item of value) {
+			const itemNode = toAstRecord(item);
+			if (itemNode) callback(itemNode);
+		}
+	}
+}
+function collectBindingNames(pattern, target) {
+	const node = toAstRecord(pattern);
+	if (!node) return;
+	switch (node.type) {
+		case "Identifier":
+			if (typeof node.name === "string") target.add(node.name);
+			return;
+		case "RestElement":
+			collectBindingNames(node.argument, target);
+			return;
+		case "AssignmentPattern":
+			collectBindingNames(node.left, target);
+			return;
+		case "ArrayPattern":
+			for (const element of nodeArray(node.elements)) collectBindingNames(element, target);
+			return;
+		case "ObjectPattern":
+			for (const property of nodeArray(node.properties)) {
+				const propertyNode = toAstRecord(property);
+				if (!propertyNode) continue;
+				collectBindingNames(propertyNode.type === "Property" ? propertyNode.value : propertyNode.argument, target);
+			}
+			return;
+		case "Property":
+			collectBindingNames(node.value, target);
+			return;
+	}
+}
+//#endregion
+export { collectBindingNames, forEachAstChild, getAstName, hasRange, isAstRecord, isIdentifierNamed, nodeArray };

package/dist/plugins/async-hooks-stub.d.ts

@@ -15,5 +15,4 @@ import { Plugin } from "vite";
  */
 declare const asyncHooksStubPlugin: Plugin;
 //#endregion
-export { asyncHooksStubPlugin };
-//# sourceMappingURL=async-hooks-stub.d.ts.map
+export { asyncHooksStubPlugin };

package/dist/plugins/async-hooks-stub.js

@@ -38,5 +38,3 @@ const asyncHooksStubPlugin = {
 };
 //#endregion
 export { asyncHooksStubPlugin };
-
-//# sourceMappingURL=async-hooks-stub.js.map

package/dist/plugins/client-reference-dedup.d.ts

@@ -32,5 +32,4 @@ declare function extractPackageImportSpecifier(absolutePath: string, readPackage
  */
 declare function clientReferenceDedupPlugin(options?: ClientReferenceDedupOptions): Plugin;
 //#endregion
-export { clientReferenceDedupPlugin, extractPackageImportSpecifier, extractPackageName };
-//# sourceMappingURL=client-reference-dedup.d.ts.map
+export { clientReferenceDedupPlugin, extractPackageImportSpecifier, extractPackageName };

package/dist/plugins/client-reference-dedup.js

@@ -1,8 +1,6 @@
+import { isUnknownRecord } from "../utils/record.js";
 import { readFile } from "node:fs/promises";
 //#region src/plugins/client-reference-dedup.ts
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 function defaultReadPackageJson(path) {
 	return readFile(path, "utf8");
 }
@@ -51,11 +49,11 @@ function exportKeyToSpecifier(packageName, exportKey, wildcardMatch) {
 function collectExportTargets(value) {
 	if (typeof value === "string") return [value];
 	if (Array.isArray(value)) return value.flatMap((entry) => collectExportTargets(entry));
-	if (!isRecord(value)) return [];
+	if (!isUnknownRecord(value)) return [];
 	return Object.values(value).flatMap((entry) => collectExportTargets(entry));
 }
 function findExportSpecifier(packageName, exportsValue, relativePath) {
-	if (!isRecord(exportsValue)) {
+	if (!isUnknownRecord(exportsValue)) {
 		for (const target of collectExportTargets(exportsValue)) {
 			const wildcardMatch = matchExportTarget(target, relativePath);
 			if (wildcardMatch !== null) return exportKeyToSpecifier(packageName, ".", wildcardMatch);
@@ -112,7 +110,7 @@ async function extractPackageImportSpecifier(absolutePath, readPackageJson = def
 	try {
 		const rawPackageJson = await readPackageJson(`${packageRoot}/package.json`);
 		const parsedPackageJson = JSON.parse(rawPackageJson);
-		packageJson = isRecord(parsedPackageJson) ? parsedPackageJson : null;
+		packageJson = isUnknownRecord(parsedPackageJson) ? parsedPackageJson : null;
 	} catch {
 		packageJson = null;
 	}
@@ -189,5 +187,3 @@ function clientReferenceDedupPlugin(options = {}) {
 }
 //#endregion
 export { clientReferenceDedupPlugin, extractPackageImportSpecifier, extractPackageName };
-
-//# sourceMappingURL=client-reference-dedup.js.map

package/dist/plugins/css-data-url.d.ts

@@ -3,5 +3,4 @@ import { Plugin } from "vite";
 //#region src/plugins/css-data-url.d.ts
 declare function dataUrlCssPlugin(): Plugin;
 //#endregion
-export { dataUrlCssPlugin };
-//# sourceMappingURL=css-data-url.d.ts.map
+export { dataUrlCssPlugin };

package/dist/plugins/css-data-url.js

@@ -77,5 +77,3 @@ function dataUrlCssPlugin() {
 }
 //#endregion
 export { dataUrlCssPlugin };
-
-//# sourceMappingURL=css-data-url.js.map

package/dist/plugins/fonts.d.ts

@@ -78,8 +78,18 @@ declare function createGoogleFontsPlugin(fontGoogleShimPath: string, shimsDir: s
  * 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(): Plugin;
+declare function createLocalFontsPlugin(shimsDir: string): Plugin;
 //#endregion
-export { RESOLVED_VIRTUAL_GOOGLE_FONTS, VIRTUAL_GOOGLE_FONTS, _findBalancedObject, _findCallEnd, _rewriteCachedFontCssToServedUrls, createGoogleFontsPlugin, createLocalFontsPlugin, generateGoogleFontsVirtualModule, parseStaticObjectLiteral };
-//# sourceMappingURL=fonts.d.ts.map
+export { RESOLVED_VIRTUAL_GOOGLE_FONTS, VIRTUAL_GOOGLE_FONTS, _findBalancedObject, _findCallEnd, _rewriteCachedFontCssToServedUrls, createGoogleFontsPlugin, createLocalFontsPlugin, generateGoogleFontsVirtualModule, parseStaticObjectLiteral };

package/dist/plugins/fonts.js

@@ -1,3 +1,4 @@
+import { escapeRegExp } from "../utils/regex.js";
 import { buildFallbackFontFace, getFallbackFontOverrideMetrics } from "../build/google-fonts/fallback-metrics.js";
 import { validateGoogleFontOptions } from "../build/google-fonts/validate.js";
 import { getFontAxes } from "../build/google-fonts/get-axes.js";
@@ -16,6 +17,9 @@ import MagicString from "magic-string";
 * the runtime CDN path.
 */
 var GoogleFontsHttpError = class extends Error {
+	url;
+	status;
+	responseBody;
 	constructor(url, status, responseBody) {
 		super(`Google Fonts returned HTTP ${status} for ${url}`);
 		this.url = url;
@@ -25,7 +29,7 @@ var GoogleFontsHttpError = class extends Error {
 	}
 };
 const VIRTUAL_GOOGLE_FONTS = "virtual:vinext-google-fonts";
-const RESOLVED_VIRTUAL_GOOGLE_FONTS = "\0" + VIRTUAL_GOOGLE_FONTS;
+const RESOLVED_VIRTUAL_GOOGLE_FONTS = "\0virtual:vinext-google-fonts";
 const GOOGLE_FONT_UTILITY_EXPORTS = new Set([
 	"buildGoogleFontsUrl",
 	"getSSRFontLinks",
@@ -264,9 +268,6 @@ function parseGoogleFontImportClause(clause) {
 function propertyNameToGoogleFontFamily(prop) {
 	return prop.replace(/_/g, " ").replace(/([a-z])([A-Z])/g, "$1 $2");
 }
-function escapeRegExp(value) {
-	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
 /**
 * Fetch Google Fonts CSS, download .woff2 files, cache locally, and return
 * @font-face CSS with local file references.
@@ -631,25 +632,32 @@ function createGoogleFontsPlugin(fontGoogleShimPath, shimsDir) {
 * 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.
 */
-function createLocalFontsPlugin() {
+function createLocalFontsPlugin(shimsDir) {
 	return {
 		name: "vinext:local-fonts",
 		enforce: "pre",
 		transform: {
 			filter: {
-				id: {
-					include: /\.(tsx?|jsx?|mjs)$/,
-					exclude: /node_modules/
-				},
+				id: { include: /\.(tsx?|jsx?|mjs)$/ },
 				code: "next/font/local"
 			},
 			handler(code, id) {
-				if (id.includes("node_modules")) return null;
 				if (id.startsWith("\0")) return null;
 				if (!id.match(/\.(tsx?|jsx?|mjs)$/)) return null;
 				if (!code.includes("next/font/local")) return null;
-				if (id.includes("font-local")) return null;
+				if (id.startsWith(shimsDir)) return null;
 				const importMatch = /\bimport\s+([A-Za-z_$][A-Za-z0-9_$]*)\s+from\s*(['"])next\/font\/local\2/.exec(code);
 				if (!importMatch) return null;
 				const localFontIdentifier = importMatch[1];
@@ -698,5 +706,3 @@ function createLocalFontsPlugin() {
 }
 //#endregion
 export { RESOLVED_VIRTUAL_GOOGLE_FONTS, VIRTUAL_GOOGLE_FONTS, _findBalancedObject, _findCallEnd, _rewriteCachedFontCssToServedUrls, createGoogleFontsPlugin, createLocalFontsPlugin, generateGoogleFontsVirtualModule, parseStaticObjectLiteral };
-
-//# sourceMappingURL=fonts.js.map

package/dist/plugins/import-meta-url.d.ts

@@ -0,0 +1,16 @@
+import { Plugin } from "vite";
+import MagicString from "magic-string";
+
+//#region src/plugins/import-meta-url.d.ts
+type ImportMetaUrlEnvironment = "client" | "server";
+type RewriteResult = {
+  code: string;
+  map: ReturnType<MagicString["generateMap"]>;
+};
+declare function createImportMetaUrlPlugin(options: {
+  getRoot: () => string | undefined;
+}): Plugin;
+declare function rewriteImportMetaUrl(code: string, id: string, root: string, environment: ImportMetaUrlEnvironment): RewriteResult | null;
+declare function rewriteServerCjsGlobals(code: string, id: string, root: string): RewriteResult | null;
+//#endregion
+export { createImportMetaUrlPlugin, rewriteImportMetaUrl, rewriteServerCjsGlobals };

package/dist/plugins/import-meta-url.js

@@ -0,0 +1,347 @@
+import { collectBindingNames, forEachAstChild, hasRange, isAstRecord, isIdentifierNamed, nodeArray } from "./ast-utils.js";
+import { tryRealpathSync } from "../build/ssr-manifest.js";
+import path from "node:path";
+import { normalizePath, parseAst } from "vite";
+import { pathToFileURL } from "node:url";
+import MagicString from "magic-string";
+//#region src/plugins/import-meta-url.ts
+const TRANSFORMABLE_SCRIPT_EXTENSIONS = new Set([
+	".cjs",
+	".cts",
+	".js",
+	".jsx",
+	".mjs",
+	".mts",
+	".ts",
+	".tsx"
+]);
+function createImportMetaUrlPlugin(options) {
+	let rootPaths;
+	let outputDirs = [];
+	function getRootPaths() {
+		const root = options.getRoot();
+		if (!root) return rootPaths;
+		if (!rootPaths || rootPaths.root !== root) rootPaths = createRootPaths(root, { outputDirs });
+		return rootPaths;
+	}
+	return {
+		name: "vinext:import-meta-url",
+		enforce: "post",
+		configResolved(config) {
+			const root = options.getRoot() ?? config.root;
+			outputDirs = [config.build.outDir];
+			rootPaths = createRootPaths(root, { outputDirs });
+		},
+		transform(code, id) {
+			if (!mayContainSourceIdentityToken(code)) return null;
+			const paths = getRootPaths();
+			if (!paths) return null;
+			const canonicalId = transformableModuleCanonicalId(cleanModuleId(id), paths);
+			if (!canonicalId) return null;
+			const rewritten = rewriteCanonicalSourceIdentity(code, canonicalId, paths, this.environment?.name === "client" ? "client" : "server");
+			if (!rewritten) return null;
+			return {
+				code: rewritten.code,
+				map: rewritten.map
+			};
+		}
+	};
+}
+function rewriteImportMetaUrl(code, id, root, environment) {
+	if (!mayContainImportMetaUrl(code)) return null;
+	return rewriteCanonicalSourceIdentity(code, canonicalizePath(id), createRootPaths(root), environment);
+}
+function rewriteServerCjsGlobals(code, id, root) {
+	if (!mayContainServerCjsGlobal(code)) return null;
+	const rootPaths = createRootPaths(root);
+	const canonicalId = transformableModuleCanonicalId(id, rootPaths);
+	if (!canonicalId) return null;
+	return rewriteCanonicalSourceIdentity(code, canonicalId, rootPaths, "server");
+}
+function rewriteCanonicalSourceIdentity(code, canonicalId, rootPaths, environment) {
+	let ast;
+	try {
+		ast = parseAst(code);
+	} catch {
+		return null;
+	}
+	const output = new MagicString(code);
+	let changed = false;
+	if (mayContainImportMetaUrl(code)) {
+		const importMetaRanges = collectImportMetaUrlRanges(ast);
+		if (importMetaRanges.length > 0) {
+			const replacement = JSON.stringify(importMetaUrlValue(canonicalId, rootPaths, environment));
+			for (const range of importMetaRanges) {
+				output.overwrite(range.start, range.end, replacement);
+				changed = true;
+			}
+		}
+	}
+	if (environment === "server" && mayContainServerCjsGlobal(code)) {
+		const injected = injectServerCjsGlobals(ast, canonicalId);
+		if (injected) {
+			output.appendLeft(findDirectivePrologueEnd(ast), `\n${injected}`);
+			changed = true;
+		}
+	}
+	if (!changed) return null;
+	return {
+		code: output.toString(),
+		map: output.generateMap({ hires: "boundary" })
+	};
+}
+function cleanModuleId(id) {
+	return id.split("?", 1)[0];
+}
+function createRootPaths(root, options = {}) {
+	const canonicalRoot = canonicalizePath(root);
+	const normalizedRoot = normalizePath(canonicalRoot);
+	return {
+		root,
+		canonicalRoot,
+		normalizedRoot,
+		excludedRelativePrefixes: excludedRelativePrefixes(canonicalRoot, normalizedRoot, options)
+	};
+}
+function transformableModuleCanonicalId(id, rootPaths) {
+	if (!id || id.startsWith("\0")) return null;
+	if (!path.isAbsolute(id)) return null;
+	const normalizedInputId = normalizePath(id);
+	if (normalizedInputId.includes("/node_modules/")) return null;
+	if (!TRANSFORMABLE_SCRIPT_EXTENSIONS.has(path.extname(normalizedInputId))) return null;
+	const canonicalId = canonicalizePath(id);
+	if (!isPathWithin(normalizePath(canonicalId), rootPaths.normalizedRoot)) return null;
+	if (isExcludedRelativePath(normalizePath(path.relative(rootPaths.canonicalRoot, canonicalId)), rootPaths.excludedRelativePrefixes)) return null;
+	return canonicalId;
+}
+function mayContainImportMetaUrl(code) {
+	return code.includes("import.meta.url") || code.includes("import.meta?.url");
+}
+function mayContainServerCjsGlobal(code) {
+	return code.includes("__filename") || code.includes("__dirname");
+}
+function mayContainSourceIdentityToken(code) {
+	return mayContainImportMetaUrl(code) || mayContainServerCjsGlobal(code);
+}
+function excludedRelativePrefixes(canonicalRoot, normalizedRoot, options) {
+	const prefixes = new Set([
+		".next",
+		".vinext",
+		".vinext-local-package",
+		"dist",
+		"out"
+	]);
+	for (const outputDir of options.outputDirs ?? []) {
+		const canonicalOutputDir = canonicalizePath(path.isAbsolute(outputDir) ? outputDir : path.resolve(canonicalRoot, outputDir));
+		if (!isPathWithin(normalizePath(canonicalOutputDir), normalizedRoot)) continue;
+		const relativePath = normalizePath(path.relative(canonicalRoot, canonicalOutputDir));
+		if (relativePath && relativePath !== ".") prefixes.add(relativePath);
+	}
+	return [...prefixes];
+}
+function isExcludedRelativePath(relativePath, prefixes) {
+	return prefixes.some((prefix) => relativePath === prefix || relativePath.startsWith(`${prefix}/`));
+}
+function isPathWithin(candidate, root) {
+	return candidate === root || candidate.startsWith(root.endsWith("/") ? root : `${root}/`);
+}
+function importMetaUrlValue(canonicalId, rootPaths, environment) {
+	if (environment === "client") return `file:///ROOT/${normalizePath(path.relative(rootPaths.canonicalRoot, canonicalId))}`;
+	return pathToFileURL(canonicalId).href;
+}
+function canonicalizePath(value) {
+	return tryRealpathSync(value) ?? path.resolve(value);
+}
+function collectImportMetaUrlRanges(ast) {
+	const ranges = [];
+	function visit(value) {
+		if (!isAstRecord(value)) return;
+		if (isImportMetaUrlNode(value)) {
+			ranges.push({
+				start: value.start,
+				end: value.end
+			});
+			return;
+		}
+		if (isChainExpressionWrappingImportMetaUrl(value)) {
+			ranges.push({
+				start: value.start,
+				end: value.end
+			});
+			return;
+		}
+		if (isNewUrlExpression(value)) {
+			const args = nodeArray(value.arguments);
+			for (let index = 0; index < args.length; index += 1) {
+				if (index === 1 && isImportMetaUrlOrChainedNode(args[index])) continue;
+				visit(args[index]);
+			}
+			return;
+		}
+		forEachAstChild(value, visit);
+	}
+	visit(ast);
+	return ranges;
+}
+const CJS_GLOBALS = ["__filename", "__dirname"];
+function isCjsGlobalName(name) {
+	return name === "__filename" || name === "__dirname";
+}
+function injectServerCjsGlobals(ast, canonicalId) {
+	const analysis = analyzeServerCjsGlobals(ast);
+	const values = {
+		__filename: canonicalId,
+		__dirname: path.dirname(canonicalId)
+	};
+	const parts = CJS_GLOBALS.filter((name) => analysis.reads.has(name) && !analysis.moduleBindings.has(name)).map((name) => `var ${name} = ${JSON.stringify(values[name])};`);
+	return parts.length ? parts.join("") : null;
+}
+function analyzeServerCjsGlobals(ast) {
+	const reads = /* @__PURE__ */ new Set();
+	const moduleBindings = /* @__PURE__ */ new Set();
+	function recordBinding(pattern) {
+		const names = /* @__PURE__ */ new Set();
+		collectBindingNames(pattern, names);
+		for (const name of names) if (isCjsGlobalName(name)) moduleBindings.add(name);
+	}
+	function recordDirectTopLevelBindings(statement) {
+		switch (statement.type) {
+			case "ImportDeclaration":
+				for (const specifier of nodeArray(statement.specifiers)) {
+					if (!isAstRecord(specifier)) continue;
+					recordBinding(specifier.local);
+				}
+				return;
+			case "VariableDeclaration":
+				if (statement.kind === "var") return;
+				for (const declarator of nodeArray(statement.declarations)) {
+					if (!isAstRecord(declarator) || declarator.type !== "VariableDeclarator") continue;
+					recordBinding(declarator.id);
+				}
+				return;
+			case "FunctionDeclaration":
+			case "ClassDeclaration":
+				recordBinding(statement.id);
+				return;
+			case "ExportNamedDeclaration":
+			case "ExportDefaultDeclaration":
+				if (isAstRecord(statement.declaration)) recordDirectTopLevelBindings(statement.declaration);
+				return;
+		}
+	}
+	function recordModuleScopedVarBindings(node) {
+		if (!isAstRecord(node)) return;
+		switch (node.type) {
+			case "Program":
+				for (const statement of nodeArray(node.body)) {
+					if (!isAstRecord(statement)) continue;
+					recordDirectTopLevelBindings(statement);
+					recordModuleScopedVarBindings(statement);
+				}
+				return;
+			case "VariableDeclaration":
+				if (node.kind !== "var") return;
+				for (const declarator of nodeArray(node.declarations)) {
+					if (!isAstRecord(declarator) || declarator.type !== "VariableDeclarator") continue;
+					recordBinding(declarator.id);
+				}
+				return;
+			case "FunctionDeclaration":
+			case "FunctionExpression":
+			case "ArrowFunctionExpression":
+			case "ClassDeclaration":
+			case "ClassExpression": return;
+			default: for (const child of moduleScopeChildren(node)) recordModuleScopedVarBindings(child);
+		}
+	}
+	function moduleScopeChildren(node) {
+		switch (node.type) {
+			case "BlockStatement": return nodeArray(node.body);
+			case "IfStatement": return [node.consequent, node.alternate];
+			case "SwitchStatement": return nodeArray(node.cases);
+			case "SwitchCase": return nodeArray(node.consequent);
+			case "TryStatement": return [
+				node.block,
+				node.handler,
+				node.finalizer
+			];
+			case "CatchClause": return [node.body];
+			case "LabeledStatement": return [node.body];
+			case "ForStatement": return [node.init, node.body];
+			case "ForInStatement":
+			case "ForOfStatement": return [node.left, node.body];
+			case "WhileStatement":
+			case "DoWhileStatement":
+			case "WithStatement": return [node.body];
+			case "ExportNamedDeclaration":
+			case "ExportDefaultDeclaration": return [node.declaration];
+			default: return [];
+		}
+	}
+	function recordReads(value) {
+		if (!isAstRecord(value)) return;
+		switch (value.type) {
+			case "Identifier":
+				if (isCjsGlobalName(value.name)) reads.add(value.name);
+				return;
+			case "MemberExpression":
+				recordReads(value.object);
+				if (value.computed) recordReads(value.property);
+				return;
+			case "Property":
+				if (value.computed) recordReads(value.key);
+				recordReads(value.value);
+				return;
+			case "MethodDefinition":
+			case "PropertyDefinition":
+				if (value.computed) recordReads(value.key);
+				recordReads(value.value);
+				return;
+			case "ImportDeclaration": return;
+			case "ExportAllDeclaration": return;
+			case "ExportNamedDeclaration":
+				if (isAstRecord(value.declaration)) recordReads(value.declaration);
+				else if (!value.source) {
+					for (const specifier of nodeArray(value.specifiers)) if (isAstRecord(specifier)) recordReads(specifier.local);
+				}
+				return;
+			default: forEachAstChild(value, recordReads);
+		}
+	}
+	if (isAstRecord(ast) && ast.type === "Program") recordModuleScopedVarBindings(ast);
+	recordReads(ast);
+	return {
+		reads,
+		moduleBindings
+	};
+}
+function isImportMetaNode(value) {
+	return isAstRecord(value) && value.type === "MetaProperty" && isIdentifierNamed(value.meta, "import") && isIdentifierNamed(value.property, "meta");
+}
+function isImportMetaUrlNode(value) {
+	return isAstRecord(value) && value.type === "MemberExpression" && hasRange(value) && isImportMetaNode(value.object) && isIdentifierNamed(value.property, "url");
+}
+function isImportMetaUrlOrChainedNode(value) {
+	if (isImportMetaUrlNode(value)) return true;
+	return isAstRecord(value) && value.type === "ChainExpression" && isImportMetaUrlNode(value.expression);
+}
+function isChainExpressionWrappingImportMetaUrl(value) {
+	return isAstRecord(value) && value.type === "ChainExpression" && hasRange(value) && isImportMetaUrlNode(value.expression);
+}
+function isNewUrlExpression(value) {
+	return value.type === "NewExpression" && isIdentifierNamed(value.callee, "URL");
+}
+function findDirectivePrologueEnd(ast) {
+	if (!isAstRecord(ast) || ast.type !== "Program") return 0;
+	let end = 0;
+	const hashbang = ast.hashbang;
+	const hashbangEnd = typeof hashbang === "object" && hashbang !== null ? Reflect.get(hashbang, "end") : null;
+	if (typeof hashbangEnd === "number") end = hashbangEnd;
+	for (const statement of nodeArray(ast.body)) {
+		if (!isAstRecord(statement) || statement.type !== "ExpressionStatement" || !isAstRecord(statement.expression) || statement.expression.type !== "Literal" || typeof statement.expression.value !== "string" || typeof statement.end !== "number") break;
+		end = statement.end;
+	}
+	return end;
+}
+//#endregion
+export { createImportMetaUrlPlugin, rewriteImportMetaUrl, rewriteServerCjsGlobals };

package/dist/plugins/instrumentation-client.d.ts

@@ -3,5 +3,4 @@ import { Plugin } from "vite";
 //#region src/plugins/instrumentation-client.d.ts
 declare function createInstrumentationClientTransformPlugin(getInstrumentationClientPath: () => string | null): Plugin;
 //#endregion
-export { createInstrumentationClientTransformPlugin };
-//# sourceMappingURL=instrumentation-client.d.ts.map
+export { createInstrumentationClientTransformPlugin };