vinext 1.0.0-beta.9 → 1.0.1

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

@@ -1,9 +1,9 @@
 import path, { toSlash } from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { escapeRegExp } from "../utils/regex.js";
+import { DYNAMIC_IMPORT_PRESCAN, SCRIPT_MODULE_ID_RE, scriptParserLanguage, walkAst } from "./ast-utils.js";
 import { isUnknownRecord } from "../utils/record.js";
-import { NODE_MODULES_PATH_RE } from "../utils/path.js";
 import { magicStringTransformResult } from "./transform-result.js";
-import { DYNAMIC_IMPORT_PRESCAN, SCRIPT_MODULE_ID_RE, hasRange, isAstRecord, nodeArray, scriptParserLanguage, walkAst } from "./ast-utils.js";
+import { NODE_MODULES_PATH_RE } from "../utils/path.js";
 import { createTransformCache } from "./transform-cache.js";
 import { createRequire } from "node:module";
 import fs from "node:fs";
@@ -88,12 +88,11 @@ function collectExtensionlessImports(ast, code, config, id) {
 	return imports;
 }
 function parseExtensionlessImport(node, code, config, id) {
-	if (node.type !== "ImportExpression" || !hasRange(node)) return null;
+	if (node.type !== "ImportExpression") 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 (source.type !== "TemplateLiteral" || source.expressions.length === 0) return null;
+	const quasiTexts = source.quasis.map(templateElementText);
 	if (quasiTexts.some((text) => text == null)) return null;
 	const texts = quasiTexts;
 	const first = texts[0];
@@ -427,10 +426,7 @@ function isImportPrefix(value) {
 	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");
+	const { cooked } = value.value;
 	return typeof cooked === "string" ? cooked : null;
 }
 function getModuleExtensions(config) {

package/dist/plugins/fonts.d.ts

@@ -1,7 +1,7 @@
 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;
+export declare const VIRTUAL_GOOGLE_FONTS = "virtual:vinext-google-fonts";
+export 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
@@ -31,7 +31,7 @@ declare const RESOLVED_VIRTUAL_GOOGLE_FONTS: string;
  * filesystem path that may contain regex metacharacters on unusual
  * filesystems.
  */
-declare function _rewriteCachedFontCssToServedUrls(css: string, cacheDir: string, assetsDir?: string): string;
+export 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.
@@ -41,8 +41,8 @@ declare function _rewriteCachedFontCssToServedUrls(css: string, cacheDir: string
  * 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;
+export declare function parseStaticObjectLiteral(objectStr: string): Record<string, unknown> | null;
+export declare function generateGoogleFontsVirtualModule(id: string, fontGoogleShimPath: string): string | null;
 /**
  * Create the `vinext:google-fonts` Vite plugin.
  *
@@ -63,14 +63,14 @@ declare function generateGoogleFontsVirtualModule(id: string, fontGoogleShimPath
  * 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;
+export 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;
+export declare function _findCallEnd(code: string, objEnd: number): number | null;
+export declare function createGoogleFontsPlugin(fontGoogleShimPath: string, shimsDir: string): Plugin;
 /**
  * Create the `vinext:local-fonts` Vite plugin.
  *
@@ -89,6 +89,5 @@ declare function createGoogleFontsPlugin(fontGoogleShimPath: string, shimsDir: s
  *   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 };
+export declare function createLocalFontsPlugin(shimsDir: string): Plugin;
+//#endregion

package/dist/plugins/fonts.js

@@ -1,6 +1,5 @@
 import path, { toSlash } from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { escapeRegExp } from "../utils/regex.js";
-import { ASSET_PREFIX_URL_DIR } from "../utils/asset-prefix.js";
 import { lastSignificantChar } from "../utils/has-trailing-comma.js";
 import { magicStringTransformResult } from "./transform-result.js";
 import { buildFallbackFontFace, getFallbackFontOverrideMetrics } from "../build/google-fonts/fallback-metrics.js";
@@ -8,6 +7,7 @@ import { validateGoogleFontOptions } from "../build/google-fonts/validate.js";
 import { getFontAxes } from "../build/google-fonts/get-axes.js";
 import { buildGoogleFontsUrl } from "../build/google-fonts/build-url.js";
 import { findFontFilesInCss } from "../build/google-fonts/find-font-files-in-css.js";
+import { ASSET_PREFIX_URL_DIR } from "../utils/asset-prefix.js";
 import { CONTENT_TYPES } from "../server/static-file-cache.js";
 import fs from "node:fs";
 import { parseAst } from "vite";
@@ -32,7 +32,7 @@ var GoogleFontsHttpError = class extends Error {
 	}
 };
 const VIRTUAL_GOOGLE_FONTS = "virtual:vinext-google-fonts";
-const RESOLVED_VIRTUAL_GOOGLE_FONTS = "\0virtual:vinext-google-fonts";
+const RESOLVED_VIRTUAL_GOOGLE_FONTS = "\0" + VIRTUAL_GOOGLE_FONTS;
 const GOOGLE_FONT_UTILITY_EXPORTS = /* @__PURE__ */ new Set([
 	"buildGoogleFontsUrl",
 	"getSSRFontLinks",
@@ -536,7 +536,8 @@ function createGoogleFontsPlugin(fontGoogleShimPath, shimsDir) {
 						const message = err instanceof Error ? err.message : String(err);
 						throw new Error(`[vinext:google-fonts] ${id}: ${message}`);
 					}
-					const cssUrl = buildGoogleFontsUrl(family, getFontAxes(family, validated.weights, validated.styles, validated.selectedVariableAxes), validated.display);
+					const axes = getFontAxes(family, validated.weights, validated.styles, validated.selectedVariableAxes);
+					const cssUrl = buildGoogleFontsUrl(family, axes, validated.display);
 					let localCSS = fontCache.get(cssUrl);
 					if (!localCSS) try {
 						localCSS = await fetchAndCacheFont(cssUrl, family, cacheDir);

package/dist/plugins/ignore-dynamic-requests.d.ts

@@ -1,8 +1,18 @@
 import { MagicStringTransformResult } from "./transform-result.js";
 import { Plugin } from "vite";
 //#region src/plugins/ignore-dynamic-requests.d.ts
+/**
+ * Cheap, conservative check run before parsing: whether any `require` or
+ * `import` occurrence could be a request this transform rewrites. Occurrences
+ * that are part of a longer identifier, member properties, static imports,
+ * non-callee positions (`typeof require`, `require,`), and calls with a
+ * single-line string literal argument other than "/" are left unchanged, so a
+ * module containing only those is skipped. Anything else, including escaped
+ * identifiers, falls through to the AST pass.
+ */
+declare function mayContainVeryDynamicRequest(code: string): boolean;
 declare function transformVeryDynamicRequests(code: string, id: string): MagicStringTransformResult | null;
-declare function createIgnoreDynamicRequestsPlugin(getTranspiledPackages?: () => readonly string[]): Plugin;
-declare const _transformVeryDynamicRequests: typeof transformVeryDynamicRequests;
-//#endregion
-export { _transformVeryDynamicRequests, createIgnoreDynamicRequestsPlugin };
+export declare function createIgnoreDynamicRequestsPlugin(getTranspiledPackages?: () => readonly string[]): Plugin;
+export declare const _transformVeryDynamicRequests: typeof transformVeryDynamicRequests;
+export declare const _mayContainVeryDynamicRequest: typeof mayContainVeryDynamicRequest;
+//#endregion

package/dist/plugins/ignore-dynamic-requests.js

@@ -1,22 +1,29 @@
 import path, { toSlash } from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
+import { DYNAMIC_IMPORT_PRESCAN, SCRIPT_MODULE_ID_RE, collectBindingNames, forEachAstChild, isIdentifierNamed, mayContainDynamicImport, scriptParserLanguage, stringLiteralValue, unwrapExpression } from "./ast-utils.js";
+import { magicStringTransformResult, omitUnusedBuildSourcemap } from "./transform-result.js";
 import { stripViteModuleQuery } from "../utils/path.js";
-import { magicStringTransformResult } from "./transform-result.js";
-import { DYNAMIC_IMPORT_PRESCAN, SCRIPT_MODULE_ID_RE, collectBindingNames, forEachAstChild, hasRange, isAstRecord, isIdentifierNamed, mayContainDynamicImport, nodeArray, scriptParserLanguage, stringLiteralValue, unwrapExpression } from "./ast-utils.js";
 import { collectDirectScopeBindings, collectLoopScopeBindings, collectSwitchScopeBindings, collectVarScopeBindings, hasAstBinding, isFunctionNode } from "./ast-scope.js";
 import { createTransformCache } from "./transform-cache.js";
-import { parseAst } from "vite";
 import { fileURLToPath } from "node:url";
+import { parseAst } from "vite";
 import MagicString from "magic-string";
 //#region src/plugins/ignore-dynamic-requests.ts
 const DYNAMIC_REQUEST_ERROR = "Cannot find module as expression is too dynamic";
 const REQUIRE_PRESCAN = /(?:\brequire\b|(?:r|\\u(?:0072|\{0*72\}))(?:e|\\u(?:0065|\{0*65\}))(?:q|\\u(?:0071|\{0*71\}))(?:u|\\u(?:0075|\{0*75\}))(?:i|\\u(?:0069|\{0*69\}))(?:r|\\u(?:0072|\{0*72\}))(?:e|\\u(?:0065|\{0*65\})))/i;
 const DYNAMIC_REQUEST_PRESCAN = new RegExp(String.raw`(?:${REQUIRE_PRESCAN.source}|${DYNAMIC_IMPORT_PRESCAN.source})`, "i");
 const MAX_CONSTANT_BINDING_DEPTH = 1500;
+const REQUIRE_OR_IMPORT_OCCURRENCE = new RegExp(String.raw`${REQUIRE_PRESCAN.source}|\bimport\b`, "gi");
+const IDENTIFIER_CHAR = /[\w$]/;
+const LINE_TERMINATOR = /[\n\r\u2028\u2029]/;
+const WHITESPACE_CHAR = /\s/;
+const UNCHANGED_STRING_ARGUMENT = String.raw`\s*\(\s*(?:"(?!\/")[^"\\\r\n]*"|'(?!\/')[^'\\\r\n]*')\s*`;
+const UNCHANGED_REQUIRE_CALL = new RegExp(String.raw`${UNCHANGED_STRING_ARGUMENT}\)`, "y");
+const UNCHANGED_IMPORT_CALL = new RegExp(String.raw`${UNCHANGED_STRING_ARGUMENT}[,)]`, "y");
+const POSSIBLE_REQUIRE_CALLEE_FOLLOWER = /\s*(?:[(/<]|--!?>|\?\.|!(?!=)|as\b|satisfies\b)/y;
+const CLOSING_PAREN_FOLLOWER = /\s*\)/y;
+const POSSIBLE_IMPORT_EXPRESSION_FOLLOWER = /\s*(?:[(/<]|--!?>|\.(?!\s*meta\b))/y;
 const VINEXT_SOURCE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 const PLUGIN_RSC_PATH = /[\\/]node_modules[\\/](?:\.pnpm[\\/][^/\\]+[\\/]node_modules[\\/])?@vitejs[\\/]plugin-rsc[\\/]/;
-function astNode(value) {
-	return isAstRecord(value) ? value : null;
-}
 function stringFromCharCodeValue(value, scope) {
 	const node = unwrapExpression(value);
 	if (node?.type !== "CallExpression") return null;
@@ -25,7 +32,7 @@ function stringFromCharCodeValue(value, scope) {
 	const property = callee?.type === "MemberExpression" ? unwrapExpression(callee.property) : null;
 	if (callee?.type !== "MemberExpression" || callee.computed === true || !isIdentifierNamed(object, "String") || hasAstBinding(scope, "String") || !isIdentifierNamed(property, "fromCharCode")) return null;
 	let resolved = "";
-	for (const argument of nodeArray(node.arguments)) {
+	for (const argument of node.arguments) {
 		const argumentNode = unwrapExpression(argument);
 		if (argumentNode?.type !== "Literal" || typeof argumentNode.value !== "number" || !Number.isInteger(argumentNode.value) || argumentNode.value < 0 || argumentNode.value > 65535) return null;
 		resolved += String.fromCharCode(argumentNode.value);
@@ -33,17 +40,15 @@ function stringFromCharCodeValue(value, scope) {
 	return resolved;
 }
 function isUnboundNumericGlobal(node, scope) {
-	return node.type === "Identifier" && typeof node.name === "string" && !hasAstBinding(scope, node.name) && (isIdentifierNamed(node, "NaN") || isIdentifierNamed(node, "Infinity"));
+	return node.type === "Identifier" && !hasAstBinding(scope, node.name) && (isIdentifierNamed(node, "NaN") || isIdentifierNamed(node, "Infinity"));
 }
 function evaluateStaticString(value, scope, resolution) {
 	const node = unwrapExpression(value);
 	if (!node) return null;
 	const valueString = stringLiteralValue(node);
 	if (valueString !== null) return valueString;
-	if (node.type === "TemplateLiteral" && nodeArray(node.expressions).length === 0) {
-		const quasiValue = astNode(nodeArray(node.quasis)[0])?.value;
-		const cooked = typeof quasiValue === "object" && quasiValue !== null ? Reflect.get(quasiValue, "cooked") : null;
-		const raw = typeof quasiValue === "object" && quasiValue !== null ? Reflect.get(quasiValue, "raw") : null;
+	if (node.type === "TemplateLiteral" && node.expressions.length === 0) {
+		const { cooked, raw } = node.quasis[0]?.value ?? {};
 		return typeof cooked === "string" ? cooked : typeof raw === "string" ? raw : null;
 	}
 	if (node.type === "BinaryExpression" && node.operator === "+") {
@@ -58,8 +63,8 @@ function evaluateStaticString(value, scope, resolution) {
 		const alternate = evaluateStaticString(node.alternate, scope, resolution);
 		return consequent !== null && consequent === alternate ? consequent : null;
 	}
-	if (node.type === "SequenceExpression") return evaluateStaticString(nodeArray(node.expressions).at(-1), scope, resolution);
-	if (node.type === "Identifier" && typeof node.name === "string") return resolveConstantBinding(scope, node.name, resolution, null, evaluateStaticString);
+	if (node.type === "SequenceExpression") return evaluateStaticString(node.expressions.at(-1), scope, resolution);
+	if (node.type === "Identifier") return resolveConstantBinding(scope, node.name, resolution, null, evaluateStaticString);
 	return null;
 }
 function hasSignificantPathPart(value) {
@@ -79,10 +84,9 @@ function isUnboundStringRawTag(value, scope) {
 	return tag?.type === "MemberExpression" && tag.computed !== true && isIdentifierNamed(object, "String") && !hasAstBinding(scope, "String") && isIdentifierNamed(property, "raw");
 }
 function hasDynamicRequestIgnoreDirective(code, requestNode, argumentNode) {
-	if (!hasRange(requestNode) || !hasRange(argumentNode)) return false;
 	const comments = [];
-	const callee = astNode(requestNode.callee);
-	let index = callee && hasRange(callee) ? callee.end : requestNode.type === "ImportExpression" ? requestNode.start + 6 : requestNode.start;
+	const callee = requestNode.type === "CallExpression" ? requestNode.callee : null;
+	let index = callee ? callee.end : requestNode.type === "ImportExpression" ? requestNode.start + 6 : requestNode.start;
 	while (index < argumentNode.start) {
 		if (/\s/.test(code[index])) {
 			index++;
@@ -141,10 +145,10 @@ function hasDynamicRequestIgnoreDirective(code, requestNode, argumentNode) {
 	return ignore === true;
 }
 function templateHasStaticPart(node, scope, resolution, useRaw = false) {
-	const quasis = nodeArray(node.quasis).filter(isAstRecord);
-	if (nodeArray(node.expressions).length === 0) return templateElementValue(quasis[0], useRaw).replaceAll("\\", "/") !== "/";
+	const quasis = node.quasis;
+	if (node.expressions.length === 0) return templateElementValue(quasis[0], useRaw).replaceAll("\\", "/") !== "/";
 	if (quasis.some((quasi) => hasSignificantPathPart(templateElementValue(quasi, useRaw)))) return true;
-	return nodeArray(node.expressions).some((expression) => {
+	return node.expressions.some((expression) => {
 		const expressionNode = unwrapExpression(expression);
 		if (!expressionNode) return false;
 		return requestHasStaticPart(expressionNode, scope, resolution);
@@ -153,12 +157,10 @@ function templateHasStaticPart(node, scope, resolution, useRaw = false) {
 function stringRawTemplateHasStaticPart(node, scope, resolution) {
 	if (node.type !== "TaggedTemplateExpression") return null;
 	if (!isUnboundStringRawTag(node.tag, scope)) return null;
-	const quasi = astNode(node.quasi);
-	return quasi?.type === "TemplateLiteral" ? templateHasStaticPart(quasi, scope, resolution, true) : null;
+	return templateHasStaticPart(node.quasi, scope, resolution, true);
 }
 function isLiteralExpression(value) {
-	const node = unwrapExpression(value);
-	return node?.type === "Literal" || node?.type === "StringLiteral";
+	return unwrapExpression(value)?.type === "Literal";
 }
 function isNegativeNumericLiteral(value) {
 	const node = unwrapExpression(value);
@@ -167,9 +169,9 @@ function isNegativeNumericLiteral(value) {
 	return argument?.type === "Literal" && typeof argument.value === "number";
 }
 function templateTruthiness(node, scope, resolution, useRaw = false) {
-	if (nodeArray(node.quasis).filter(isAstRecord).some((quasi) => templateElementValue(quasi, useRaw) !== "")) return true;
+	if (node.quasis.some((quasi) => templateElementValue(quasi, useRaw) !== "")) return true;
 	let hasUnknownExpression = false;
-	for (const expression of nodeArray(node.expressions)) {
+	for (const expression of node.expressions) {
 		const string = evaluateStaticString(expression, scope, resolution);
 		if (string !== null) {
 			if (string !== "") return true;
@@ -184,19 +186,16 @@ function templateTruthiness(node, scope, resolution, useRaw = false) {
 function staticTruthiness(value, scope, resolution = createConstantResolution()) {
 	const node = unwrapExpression(value);
 	if (!node) return null;
-	if (node.type === "Literal" || node.type === "StringLiteral") return Boolean(node.value);
+	if (node.type === "Literal") return Boolean(node.value);
 	if (isUnboundNumericGlobal(node, scope)) return true;
 	if (node.type === "TemplateLiteral") return templateTruthiness(node, scope, resolution);
-	if (node.type === "TaggedTemplateExpression" && isUnboundStringRawTag(node.tag, scope)) {
-		const quasi = astNode(node.quasi);
-		return quasi?.type === "TemplateLiteral" ? templateTruthiness(quasi, scope, resolution, true) : null;
-	}
+	if (node.type === "TaggedTemplateExpression" && isUnboundStringRawTag(node.tag, scope)) return templateTruthiness(node.quasi, scope, resolution, true);
 	if (node.type === "BinaryExpression" && node.operator === "+") {
 		const string = evaluateStaticString(node, scope, resolution);
 		return string === null ? null : Boolean(string);
 	}
 	if (isIdentifierNamed(node, "undefined") && !hasAstBinding(scope, "undefined")) return false;
-	if (node.type === "Identifier" && typeof node.name === "string") return resolveConstantBinding(scope, node.name, resolution, null, staticTruthiness);
+	if (node.type === "Identifier") return resolveConstantBinding(scope, node.name, resolution, null, staticTruthiness);
 	if (node.type === "UnaryExpression") {
 		if (node.operator === "void") return isLiteralExpression(node.argument) ? false : null;
 		if (node.operator === "!") {
@@ -210,10 +209,10 @@ function staticTruthiness(value, scope, resolution = createConstantResolution())
 function staticNullishness(value, scope, resolution = createConstantResolution()) {
 	const node = unwrapExpression(value);
 	if (!node) return null;
-	if (node.type === "Literal" || node.type === "StringLiteral") return node.value === null;
+	if (node.type === "Literal") return node.value === null;
 	if (isUnboundNumericGlobal(node, scope)) return false;
 	if (isIdentifierNamed(node, "undefined") && !hasAstBinding(scope, "undefined")) return true;
-	if (node.type === "Identifier" && typeof node.name === "string") return resolveConstantBinding(scope, node.name, resolution, null, staticNullishness);
+	if (node.type === "Identifier") return resolveConstantBinding(scope, node.name, resolution, null, staticNullishness);
 	if (node.type === "UnaryExpression") return node.operator === "void" && isLiteralExpression(node.argument) ? true : null;
 	if (node.type === "ArrayExpression" || node.type === "ObjectExpression" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression" || node.type === "ClassExpression" || node.type === "TemplateLiteral") return false;
 	return null;
@@ -250,7 +249,7 @@ function stringConcatHasStaticPart(node, scope, resolution) {
 	const receiver = unwrapExpression(callee.object);
 	if (!receiver || !isStaticStringExpression(receiver, scope, resolution)) return null;
 	if (requestHasStaticPart(receiver, scope, resolution)) return true;
-	return nodeArray(node.arguments).some((argument) => {
+	return node.arguments.some((argument) => {
 		const argumentNode = unwrapExpression(argument);
 		return argumentNode ? requestHasStaticPart(argumentNode, scope, resolution) : false;
 	});
@@ -259,10 +258,10 @@ function isStaticStringExpression(value, scope, resolution) {
 	const node = unwrapExpression(value);
 	if (!node) return false;
 	if (stringLiteralValue(node) !== null || node.type === "TemplateLiteral") return true;
-	if (node.type === "Identifier" && typeof node.name === "string") return resolveConstantBinding(scope, node.name, resolution, false, isStaticStringExpression);
+	if (node.type === "Identifier") return resolveConstantBinding(scope, node.name, resolution, false, isStaticStringExpression);
 	if (node.type === "BinaryExpression" && node.operator === "+") return additionContainsString(node, scope, resolution);
 	if (node.type === "ConditionalExpression") return isStaticStringExpression(node.consequent, scope, resolution) && isStaticStringExpression(node.alternate, scope, resolution);
-	if (node.type === "SequenceExpression") return isStaticStringExpression(nodeArray(node.expressions).at(-1), scope, resolution);
+	if (node.type === "SequenceExpression") return isStaticStringExpression(node.expressions.at(-1), scope, resolution);
 	if (node.type === "CallExpression") return stringConcatHasStaticPart(node, scope, resolution) !== null;
 	return false;
 }
@@ -270,10 +269,10 @@ function additionContainsString(value, scope, resolution) {
 	const node = unwrapExpression(value);
 	if (!node) return false;
 	if (stringLiteralValue(node) !== null || node.type === "TemplateLiteral") return true;
-	if (node.type === "Identifier" && typeof node.name === "string") return resolveConstantBinding(scope, node.name, resolution, false, additionContainsString);
+	if (node.type === "Identifier") return resolveConstantBinding(scope, node.name, resolution, false, additionContainsString);
 	if (node.type === "BinaryExpression" && node.operator === "+") return additionContainsString(node.left, scope, resolution) || additionContainsString(node.right, scope, resolution);
 	if (node.type === "ConditionalExpression") return additionContainsString(node.consequent, scope, resolution) && additionContainsString(node.alternate, scope, resolution);
-	if (node.type === "SequenceExpression") return additionContainsString(nodeArray(node.expressions).at(-1), scope, resolution);
+	if (node.type === "SequenceExpression") return additionContainsString(node.expressions.at(-1), scope, resolution);
 	return stringConcatHasStaticPart(node, scope, resolution) !== null;
 }
 function requestHasStaticPart(value, scope, resolution = createConstantResolution()) {
@@ -284,12 +283,12 @@ function requestHasStaticPart(value, scope, resolution = createConstantResolutio
 	if (node.type === "Literal") return true;
 	if (isUnboundNumericGlobal(node, scope)) return true;
 	if (node.type === "TemplateLiteral") return templateHasStaticPart(node, scope, resolution);
-	const stringRawHasStaticPart = stringRawTemplateHasStaticPart(node, scope, resolution);
+	const stringRawHasStaticPart = node.type === "TaggedTemplateExpression" ? stringRawTemplateHasStaticPart(node, scope, resolution) : null;
 	if (stringRawHasStaticPart !== null) return stringRawHasStaticPart;
 	const concatHasStaticPart = stringConcatHasStaticPart(node, scope, resolution);
 	if (concatHasStaticPart !== null) return concatHasStaticPart;
 	if (isIdentifierNamed(node, "undefined") && !hasAstBinding(scope, "undefined")) return true;
-	if (node.type === "Identifier" && typeof node.name === "string") return resolveConstantBinding(scope, node.name, resolution, false, requestHasStaticPart);
+	if (node.type === "Identifier") return resolveConstantBinding(scope, node.name, resolution, false, requestHasStaticPart);
 	if (node.type === "UnaryExpression") {
 		if (node.operator === "void") return isLiteralExpression(node.argument);
 		if (isNegativeNumericLiteral(node)) return true;
@@ -318,7 +317,7 @@ function requestHasStaticPart(value, scope, resolution = createConstantResolutio
 		return requestHasStaticPart(node.left, scope, resolution) || requestHasStaticPart(node.right, scope, resolution);
 	}
 	if (node.type === "SequenceExpression") {
-		const expressions = nodeArray(node.expressions);
+		const expressions = node.expressions;
 		if (expressions.length === 0) return false;
 		return expressions.slice(0, -1).every((expression) => !expressionMayHaveSideEffects(expression, scope)) && requestHasStaticPart(expressions.at(-1), scope, resolution);
 	}
@@ -327,38 +326,31 @@ function requestHasStaticPart(value, scope, resolution = createConstantResolutio
 function expressionMayHaveSideEffects(value, scope) {
 	const node = unwrapExpression(value);
 	if (!node) return false;
-	if (node.type === "Literal" || node.type === "StringLiteral" || node.type === "Identifier" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") return false;
-	if (node.type === "TemplateLiteral") return nodeArray(node.expressions).some((expression) => expressionMayHaveSideEffects(expression, scope));
+	if (node.type === "Literal" || node.type === "Identifier" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") return false;
+	if (node.type === "TemplateLiteral") return node.expressions.some((expression) => expressionMayHaveSideEffects(expression, scope));
 	if (node.type === "UnaryExpression") return node.operator === "delete" || expressionMayHaveSideEffects(node.argument, scope);
 	if (node.type === "AwaitExpression") return expressionMayHaveSideEffects(node.argument, scope);
 	if (node.type === "BinaryExpression" || node.type === "LogicalExpression") return expressionMayHaveSideEffects(node.left, scope) || expressionMayHaveSideEffects(node.right, scope);
 	if (node.type === "ConditionalExpression") return expressionMayHaveSideEffects(node.test, scope) || expressionMayHaveSideEffects(node.consequent, scope) || expressionMayHaveSideEffects(node.alternate, scope);
-	if (node.type === "SequenceExpression") return nodeArray(node.expressions).some((expression) => expressionMayHaveSideEffects(expression, scope));
-	if (node.type === "ArrayExpression") return nodeArray(node.elements).some((element) => {
-		const elementNode = astNode(element);
-		return elementNode?.type === "SpreadElement" || expressionMayHaveSideEffects(elementNode, scope);
-	});
-	if (node.type === "ObjectExpression") return nodeArray(node.properties).some((property) => {
-		const propertyNode = astNode(property);
-		if (propertyNode?.type === "SpreadElement") return expressionMayHaveSideEffects(propertyNode.argument, scope);
-		if (propertyNode?.type !== "Property" || propertyNode.kind !== "init" || propertyNode.method === true) return true;
-		return expressionMayHaveSideEffects(propertyNode.computed ? propertyNode.key : null, scope) || expressionMayHaveSideEffects(propertyNode.value, scope);
+	if (node.type === "SequenceExpression") return node.expressions.some((expression) => expressionMayHaveSideEffects(expression, scope));
+	if (node.type === "ArrayExpression") return node.elements.some((element) => element?.type === "SpreadElement" || expressionMayHaveSideEffects(element, scope));
+	if (node.type === "ObjectExpression") return node.properties.some((property) => {
+		if (property.type === "SpreadElement") return expressionMayHaveSideEffects(property.argument, scope);
+		if (property.type !== "Property" || property.kind !== "init" || property.method === true) return true;
+		return expressionMayHaveSideEffects(property.computed ? property.key : null, scope) || expressionMayHaveSideEffects(property.value, scope);
 	});
 	if (node.type === "MemberExpression") return expressionMayHaveSideEffects(node.object, scope) || expressionMayHaveSideEffects(node.computed ? node.property : null, scope);
 	if (node.type === "TaggedTemplateExpression") {
-		if (isUnboundStringRawTag(node.tag, scope)) {
-			const quasi = astNode(node.quasi);
-			return quasi?.type !== "TemplateLiteral" || nodeArray(quasi.expressions).some((expression) => expressionMayHaveSideEffects(expression, scope));
-		}
+		if (isUnboundStringRawTag(node.tag, scope)) return node.quasi.expressions.some((expression) => expressionMayHaveSideEffects(expression, scope));
 		return true;
 	}
 	if (node.type === "MetaProperty") return false;
 	return true;
 }
 function collectConstantBinding(declaration, declarator, scope) {
-	const identifier = astNode(declarator.id);
-	const initializer = astNode(declarator.init);
-	if (declaration.kind === "const" && identifier?.type === "Identifier" && typeof identifier.name === "string" && initializer) scope.constants.set(identifier.name, {
+	const identifier = declarator.id;
+	const initializer = declarator.init;
+	if (declaration.kind === "const" && identifier?.type === "Identifier" && initializer) scope.constants.set(identifier.name, {
 		initializer,
 		scope
 	});
@@ -373,8 +365,48 @@ function dynamicRequireReplacement() {
 function dynamicImportReplacement() {
 	return `Promise.resolve().then(() => { const error = new Error(${JSON.stringify(DYNAMIC_REQUEST_ERROR)}); error.code = "MODULE_NOT_FOUND"; throw error; })`;
 }
+function matchesAt(pattern, code, index) {
+	pattern.lastIndex = index;
+	return pattern.test(code);
+}
+function mayBeWrappedCallee(code, start) {
+	let index = start - 1;
+	while (index >= 0 && WHITESPACE_CHAR.test(code[index])) {
+		if (LINE_TERMINATOR.test(code[index])) return true;
+		index--;
+	}
+	return index < 0 || code[index] === "(" || code[index] === ">" || code[index] === "/";
+}
+/**
+* Cheap, conservative check run before parsing: whether any `require` or
+* `import` occurrence could be a request this transform rewrites. Occurrences
+* that are part of a longer identifier, member properties, static imports,
+* non-callee positions (`typeof require`, `require,`), and calls with a
+* single-line string literal argument other than "/" are left unchanged, so a
+* module containing only those is skipped. Anything else, including escaped
+* identifiers, falls through to the AST pass.
+*/
+function mayContainVeryDynamicRequest(code) {
+	REQUIRE_OR_IMPORT_OCCURRENCE.lastIndex = 0;
+	for (let match; match = REQUIRE_OR_IMPORT_OCCURRENCE.exec(code);) {
+		const text = match[0];
+		const start = match.index;
+		const end = start + text.length;
+		if (text.includes("\\")) return true;
+		if (text !== "require" && text !== "import") continue;
+		if (IDENTIFIER_CHAR.test(code[start - 1] ?? "") || IDENTIFIER_CHAR.test(code[end] ?? "")) continue;
+		if (code[start - 1] === "." && code[start - 2] !== ".") continue;
+		if (text === "import") {
+			if (matchesAt(POSSIBLE_IMPORT_EXPRESSION_FOLLOWER, code, end) && !matchesAt(UNCHANGED_IMPORT_CALL, code, end)) return true;
+		} else if (matchesAt(POSSIBLE_REQUIRE_CALLEE_FOLLOWER, code, end)) {
+			if (!matchesAt(UNCHANGED_REQUIRE_CALL, code, end)) return true;
+		} else if (matchesAt(CLOSING_PAREN_FOLLOWER, code, end) && mayBeWrappedCallee(code, start)) return true;
+	}
+	return false;
+}
 function transformVeryDynamicRequests(code, id) {
 	if (!REQUIRE_PRESCAN.test(code) && !mayContainDynamicImport(code)) return null;
+	if (!mayContainVeryDynamicRequest(code)) return null;
 	const lang = scriptParserLanguage(id) ?? "js";
 	let ast;
 	try {
@@ -384,8 +416,7 @@ function transformVeryDynamicRequests(code, id) {
 	}
 	const output = new MagicString(code);
 	let changed = false;
-	const root = astNode(ast);
-	if (!root) return null;
+	const root = ast;
 	const rootScope = {
 		parent: null,
 		bindings: /* @__PURE__ */ new Set(),
@@ -402,12 +433,9 @@ function transformVeryDynamicRequests(code, id) {
 				constants: /* @__PURE__ */ new Map()
 			};
 			collectBindingNames(node.id, parameterScope.bindings);
-			for (const parameter of nodeArray(node.params)) collectBindingNames(parameter, parameterScope.bindings);
-			for (const parameter of nodeArray(node.params)) {
-				const parameterNode = astNode(parameter);
-				if (parameterNode) visit(parameterNode, parameterScope);
-			}
-			const body = astNode(node.body);
+			for (const parameter of node.params) collectBindingNames(parameter, parameterScope.bindings);
+			for (const parameter of node.params) visit(parameter, parameterScope);
+			const body = node.body;
 			if (body) {
 				const bodyScope = {
 					parent: parameterScope,
@@ -416,28 +444,21 @@ function transformVeryDynamicRequests(code, id) {
 				};
 				collectDirectBindings(body, bodyScope);
 				collectVarScopeBindings(body, bodyScope);
-				if (body.type === "BlockStatement") for (const statement of nodeArray(body.body)) {
-					const statementNode = astNode(statement);
-					if (statementNode) visit(statementNode, bodyScope);
-				}
+				if (body.type === "BlockStatement") for (const statement of body.body) visit(statement, bodyScope);
 				else visit(body, bodyScope);
 			}
 			return;
 		} else if (node.type === "SwitchStatement") {
-			const discriminant = astNode(node.discriminant);
-			if (discriminant) visit(discriminant, parentScope);
+			visit(node.discriminant, parentScope);
 			const switchScope = {
 				parent: parentScope,
 				bindings: /* @__PURE__ */ new Set(),
 				constants: /* @__PURE__ */ new Map()
 			};
 			collectDirectBindings(node, switchScope);
-			for (const switchCase of nodeArray(node.cases)) {
-				const switchCaseNode = astNode(switchCase);
-				if (switchCaseNode) visit(switchCaseNode, switchScope);
-			}
+			for (const switchCase of node.cases) visit(switchCase, switchScope);
 			return;
-		} else if (node.type === "BlockStatement" && node !== root || node.type === "StaticBlock" || node.type === "TSModuleBlock") {
+		} else if (node.type === "BlockStatement" || node.type === "StaticBlock" || node.type === "TSModuleBlock") {
 			scope = {
 				parent: parentScope,
 				bindings: /* @__PURE__ */ new Set(),
@@ -467,32 +488,32 @@ function transformVeryDynamicRequests(code, id) {
 			};
 			collectBindingNames(node.id, scope.bindings);
 		}
-		if (node.type === "CallExpression" && hasRange(node)) {
+		if (node.type === "CallExpression") {
 			const callee = unwrapExpression(node.callee);
-			const argumentsList = nodeArray(node.arguments);
-			if (isIdentifierNamed(callee, "require") && !hasAstBinding(scope, "require") && argumentsList.length === 1 && astNode(argumentsList[0])?.type !== "SpreadElement" && !hasDynamicRequestIgnoreDirective(code, node, argumentsList[0])) {
-				const resolvedRequest = stringFromCharCodeValue(argumentsList[0], scope);
-				const argument = astNode(argumentsList[0]);
-				if (resolvedRequest !== null && resolvedRequest.replaceAll("\\", "/") !== "/" && argument && hasRange(argument)) {
+			const argumentsList = node.arguments;
+			const argument = argumentsList[0];
+			if (isIdentifierNamed(callee, "require") && !hasAstBinding(scope, "require") && argumentsList.length === 1 && argument && argument.type !== "SpreadElement" && !hasDynamicRequestIgnoreDirective(code, node, argument)) {
+				const resolvedRequest = stringFromCharCodeValue(argument, scope);
+				if (resolvedRequest !== null && resolvedRequest.replaceAll("\\", "/") !== "/") {
 					output.overwrite(argument.start, argument.end, JSON.stringify(resolvedRequest));
 					changed = true;
 					return;
 				}
-				if (!requestHasStaticPart(argumentsList[0], scope)) {
+				if (!requestHasStaticPart(argument, scope)) {
 					output.overwrite(node.start, node.end, dynamicRequireReplacement());
 					changed = true;
 					return;
 				}
 			}
 		}
-		if (node.type === "ImportExpression" && hasRange(node) && !hasDynamicRequestIgnoreDirective(code, node, node.source) && !requestHasStaticPart(node.source, scope)) {
+		if (node.type === "ImportExpression" && !hasDynamicRequestIgnoreDirective(code, node, node.source) && !requestHasStaticPart(node.source, scope)) {
 			output.overwrite(node.start, node.end, dynamicImportReplacement());
 			changed = true;
 			return;
 		}
 		forEachAstChild(node, (child) => visit(child, scope));
 	}
-	for (const statement of nodeArray(root.body)) if (isAstRecord(statement)) visit(statement, rootScope);
+	for (const statement of root.body) visit(statement, rootScope);
 	if (!changed) return null;
 	return magicStringTransformResult(output, {
 		hires: "boundary",
@@ -515,7 +536,7 @@ function createIgnoreDynamicRequestsPlugin(getTranspiledPackages = () => []) {
 				if (!shouldTransformVeryDynamicRequests(this.environment, cleanId, getTranspiledPackages())) return null;
 				const absoluteId = path.resolve(cleanId);
 				if (absoluteId === VINEXT_SOURCE_ROOT || absoluteId.startsWith(`${VINEXT_SOURCE_ROOT}/`) || PLUGIN_RSC_PATH.test(absoluteId)) return null;
-				return cached(id, code, void 0, () => transformVeryDynamicRequests(code, id));
+				return omitUnusedBuildSourcemap(this.environment, cached(id, code, void 0, () => transformVeryDynamicRequests(code, id)));
 			}
 		}
 	};
@@ -527,5 +548,6 @@ function shouldTransformVeryDynamicRequests(environment, id, transpiledPackages)
 	return !transpiledPackages.some((packageName) => normalizedId.includes(`/node_modules/${packageName}/`));
 }
 const _transformVeryDynamicRequests = transformVeryDynamicRequests;
+const _mayContainVeryDynamicRequest = mayContainVeryDynamicRequest;
 //#endregion
-export { _transformVeryDynamicRequests, createIgnoreDynamicRequestsPlugin };
+export { _mayContainVeryDynamicRequest, _transformVeryDynamicRequests, createIgnoreDynamicRequestsPlugin };

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

@@ -2,7 +2,7 @@ import { MagicStringTransformResult } from "./transform-result.js";
 import { Plugin, ResolvedConfig } from "vite";
 //#region src/plugins/import-meta-url.d.ts
 type ImportMetaUrlEnvironment = "client" | "server";
-type ImportMetaUrlCapability = {
+export type ImportMetaUrlCapability = {
   /** The Vite app plugin. Owns project, dependency, and emitted-chunk identity. */
   vitePlugin: Plugin;
   /** Thin adapter for Vite's independent dependency-optimizer Rolldown pipeline. */
@@ -10,12 +10,11 @@ type ImportMetaUrlCapability = {
   /** Cached dependency identity/format classifier shared by both plugin pipelines. */
   isBundledCommonJsDependencyId: (id: string) => boolean;
 };
-type EmittedModuleFileNameResolver = (environmentName: string | undefined, fileName: string) => string;
-declare function createImportMetaUrlPlugin(options: {
+export type EmittedModuleFileNameResolver = (environmentName: string | undefined, fileName: string) => string;
+export declare function createImportMetaUrlPlugin(options: {
   getRoot: () => string | undefined;
   createEmittedModuleFileNameResolver?: (config: ResolvedConfig) => EmittedModuleFileNameResolver | undefined;
 }): ImportMetaUrlCapability;
-declare function rewriteImportMetaUrl(code: string, id: string, root: string, environment: ImportMetaUrlEnvironment): MagicStringTransformResult | null;
-declare function rewriteServerCjsGlobals(code: string, id: string, root: string): MagicStringTransformResult | null;
-//#endregion
-export { EmittedModuleFileNameResolver, ImportMetaUrlCapability, createImportMetaUrlPlugin, rewriteImportMetaUrl, rewriteServerCjsGlobals };
+export declare function rewriteImportMetaUrl(code: string, id: string, root: string, environment: ImportMetaUrlEnvironment): MagicStringTransformResult | null;
+export declare function rewriteServerCjsGlobals(code: string, id: string, root: string): MagicStringTransformResult | null;
+//#endregion