@qzsy/vinext 0.1.12 → 0.1.81

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

@@ -0,0 +1,530 @@
+import { collectBindingNames, forEachAstChild, hasRange, isAstRecord, isIdentifierNamed, nodeArray } from "./ast-utils.js";
+import { collectDirectScopeBindings, collectLoopScopeBindings, collectSwitchScopeBindings, collectVarScopeBindings, hasAstBinding, isFunctionNode } from "./ast-scope.js";
+import path from "node:path";
+import { parseAst } from "vite";
+import { fileURLToPath } from "node:url";
+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 MAX_CONSTANT_BINDING_DEPTH = 1500;
+const VINEXT_SOURCE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const PLUGIN_RSC_PATH = /[\\/]node_modules[\\/](?:\.pnpm[\\/][^/\\]+[\\/]node_modules[\\/])?@vitejs[\\/]plugin-rsc[\\/]/;
+const TRANSFORMABLE_EXTENSIONS = new Set([
+	".js",
+	".jsx",
+	".mjs",
+	".cjs",
+	".ts",
+	".tsx",
+	".mts",
+	".cts"
+]);
+const TRANSPARENT_EXPRESSIONS = new Set([
+	"ChainExpression",
+	"ParenthesizedExpression",
+	"TSAsExpression",
+	"TSInstantiationExpression",
+	"TSNonNullExpression",
+	"TSSatisfiesExpression",
+	"TSTypeAssertion"
+]);
+function astNode(value) {
+	return isAstRecord(value) ? value : null;
+}
+function unwrapExpression(value) {
+	const node = astNode(value);
+	if (!node || !TRANSPARENT_EXPRESSIONS.has(node.type)) return node;
+	return unwrapExpression(node.expression);
+}
+function stringValue(node) {
+	if ((node.type === "Literal" || node.type === "StringLiteral") && typeof node.value === "string") return node.value;
+	return null;
+}
+function isUnboundNumericGlobal(node, scope) {
+	return node.type === "Identifier" && typeof node.name === "string" && !hasAstBinding(scope, node.name) && (isIdentifierNamed(node, "NaN") || isIdentifierNamed(node, "Infinity"));
+}
+function staticStringValue(value, scope, resolution) {
+	const node = unwrapExpression(value);
+	if (!node) return null;
+	const valueString = stringValue(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;
+		return typeof cooked === "string" ? cooked : typeof raw === "string" ? raw : null;
+	}
+	if (node.type === "BinaryExpression" && node.operator === "+") {
+		const left = staticStringValue(node.left, scope, resolution);
+		const right = staticStringValue(node.right, scope, resolution);
+		return left === null || right === null ? null : left + right;
+	}
+	if (node.type === "ConditionalExpression") {
+		const truthiness = staticTruthiness(node.test, scope, resolution);
+		if (truthiness !== null) return staticStringValue(truthiness ? node.consequent : node.alternate, scope, resolution);
+		const consequent = staticStringValue(node.consequent, scope, resolution);
+		const alternate = staticStringValue(node.alternate, scope, resolution);
+		return consequent !== null && consequent === alternate ? consequent : null;
+	}
+	if (node.type === "SequenceExpression") return staticStringValue(nodeArray(node.expressions).at(-1), scope, resolution);
+	if (node.type === "Identifier" && typeof node.name === "string") return resolveConstantBinding(scope, node.name, resolution, null, staticStringValue);
+	return null;
+}
+function hasSignificantPathPart(value) {
+	const normalized = value.replaceAll("\\", "/");
+	return normalized !== "" && normalized !== "/";
+}
+function templateElementValue(quasi, raw) {
+	const value = quasi?.value;
+	if (typeof value !== "object" || value === null) return "";
+	const elementValue = Reflect.get(value, raw ? "raw" : "cooked");
+	return typeof elementValue === "string" ? elementValue : "";
+}
+function isUnboundStringRawTag(value, scope) {
+	const tag = unwrapExpression(value);
+	const object = tag?.type === "MemberExpression" ? unwrapExpression(tag.object) : null;
+	const property = tag?.type === "MemberExpression" ? unwrapExpression(tag.property) : null;
+	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;
+	while (index < argumentNode.start) {
+		if (/\s/.test(code[index])) {
+			index++;
+			continue;
+		}
+		if (code.startsWith("/*", index)) {
+			const end = code.indexOf("*/", index + 2);
+			if (end === -1 || end + 2 > argumentNode.start) return false;
+			index = end + 2;
+			continue;
+		}
+		if (code.startsWith("//", index)) {
+			while (index < argumentNode.start && code[index] !== "\n" && code[index] !== "\r") index++;
+			continue;
+		}
+		break;
+	}
+	if (code[index] !== "(") return false;
+	index++;
+	while (index < argumentNode.start) {
+		if (/\s/.test(code[index])) {
+			index++;
+			continue;
+		}
+		if (code.startsWith("/*", index)) {
+			const end = code.indexOf("*/", index + 2);
+			if (end === -1 || end + 2 > argumentNode.start) return false;
+			comments.push(code.slice(index + 2, end));
+			index = end + 2;
+			continue;
+		}
+		if (code.startsWith("//", index)) {
+			let end = index + 2;
+			while (end < argumentNode.start && code[end] !== "\n" && code[end] !== "\r") end++;
+			comments.push(code.slice(index + 2, end));
+			index = end;
+			continue;
+		}
+		return false;
+	}
+	let ignore;
+	for (const comment of comments) {
+		const text = comment.trim();
+		if (text === "@vite-ignore" && requestNode.type === "ImportExpression") {
+			ignore = true;
+			continue;
+		}
+		const separator = text.indexOf(":");
+		if (separator === -1) continue;
+		const directive = text.slice(0, separator).trim();
+		if (directive !== "webpackIgnore" && directive !== "turbopackIgnore") continue;
+		const value = text.slice(separator + 1).trim();
+		if (value === "true") ignore = true;
+		else if (value === "false") ignore = false;
+	}
+	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("\\", "/") !== "/";
+	if (quasis.some((quasi) => hasSignificantPathPart(templateElementValue(quasi, useRaw)))) return true;
+	return nodeArray(node.expressions).some((expression) => {
+		const expressionNode = unwrapExpression(expression);
+		if (!expressionNode) return false;
+		return requestHasStaticPart(expressionNode, scope, resolution);
+	});
+}
+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;
+}
+function isLiteralExpression(value) {
+	const node = unwrapExpression(value);
+	return node?.type === "Literal" || node?.type === "StringLiteral";
+}
+function isNegativeNumericLiteral(value) {
+	const node = unwrapExpression(value);
+	if (node?.type !== "UnaryExpression" || node.operator !== "-") return false;
+	const argument = unwrapExpression(node.argument);
+	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;
+	let hasUnknownExpression = false;
+	for (const expression of nodeArray(node.expressions)) {
+		const string = staticStringValue(expression, scope, resolution);
+		if (string !== null) {
+			if (string !== "") return true;
+			continue;
+		}
+		const expressionNode = unwrapExpression(expression);
+		if (isNegativeNumericLiteral(expressionNode) || staticTruthiness(expressionNode, scope, resolution) !== null) return true;
+		hasUnknownExpression = true;
+	}
+	return hasUnknownExpression ? null : 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 (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 === "BinaryExpression" && node.operator === "+") {
+		const string = staticStringValue(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 === "UnaryExpression") {
+		if (node.operator === "void") return isLiteralExpression(node.argument) ? false : null;
+		if (node.operator === "!") {
+			const argumentTruthiness = staticTruthiness(node.argument, scope, resolution);
+			return argumentTruthiness === null ? null : !argumentTruthiness;
+		}
+	}
+	if (node.type === "ArrayExpression" || node.type === "ObjectExpression" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression" || node.type === "ClassExpression") return true;
+	return null;
+}
+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 (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 === "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;
+}
+function findConstantBinding(scope, name) {
+	for (let current = scope; current; current = current.parent) {
+		if (!current.bindings.has(name)) continue;
+		return current.constants.get(name) ?? null;
+	}
+	return null;
+}
+function createConstantResolution() {
+	return {
+		active: /* @__PURE__ */ new Set(),
+		steps: 0
+	};
+}
+function resolveConstantBinding(scope, name, resolution, fallback, evaluate) {
+	const binding = findConstantBinding(scope, name);
+	if (!binding || resolution.steps >= MAX_CONSTANT_BINDING_DEPTH || resolution.active.has(binding)) return fallback;
+	resolution.steps++;
+	resolution.active.add(binding);
+	try {
+		return evaluate(binding.initializer, binding.scope, resolution);
+	} finally {
+		resolution.active.delete(binding);
+	}
+}
+function stringConcatHasStaticPart(node, scope, resolution) {
+	if (node.type !== "CallExpression") return null;
+	const callee = unwrapExpression(node.callee);
+	const property = callee?.type === "MemberExpression" ? unwrapExpression(callee.property) : null;
+	if (callee?.type !== "MemberExpression" || (callee.computed === true ? property === null || staticStringValue(property, scope, resolution) !== "concat" : !isIdentifierNamed(property, "concat"))) return null;
+	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) => {
+		const argumentNode = unwrapExpression(argument);
+		return argumentNode ? requestHasStaticPart(argumentNode, scope, resolution) : false;
+	});
+}
+function isStaticStringExpression(value, scope, resolution) {
+	const node = unwrapExpression(value);
+	if (!node) return false;
+	if (stringValue(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 === "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 === "CallExpression") return stringConcatHasStaticPart(node, scope, resolution) !== null;
+	return false;
+}
+function additionContainsString(value, scope, resolution) {
+	const node = unwrapExpression(value);
+	if (!node) return false;
+	if (stringValue(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 === "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);
+	return stringConcatHasStaticPart(node, scope, resolution) !== null;
+}
+function requestHasStaticPart(value, scope, resolution = createConstantResolution()) {
+	const node = unwrapExpression(value);
+	if (!node) return false;
+	const constantString = stringValue(node);
+	if (constantString !== null) return constantString.replaceAll("\\", "/") !== "/";
+	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);
+	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 === "UnaryExpression") {
+		if (node.operator === "void") return isLiteralExpression(node.argument);
+		if (isNegativeNumericLiteral(node)) return true;
+		return staticTruthiness(node, scope, resolution) !== null;
+	}
+	if (node.type === "BinaryExpression" && node.operator === "+") {
+		if (!additionContainsString(node, scope, resolution)) return false;
+		const left = unwrapExpression(node.left);
+		const right = unwrapExpression(node.right);
+		const leftString = left ? stringValue(left) : null;
+		const rightString = right ? stringValue(right) : null;
+		return leftString !== null && hasSignificantPathPart(leftString) || rightString !== null && hasSignificantPathPart(rightString) || leftString === null && requestHasStaticPart(left, scope, resolution) || rightString === null && requestHasStaticPart(right, scope, resolution);
+	}
+	if (node.type === "ConditionalExpression") {
+		const truthiness = staticTruthiness(node.test, scope, resolution);
+		return truthiness === null ? requestHasStaticPart(node.consequent, scope, resolution) || requestHasStaticPart(node.alternate, scope, resolution) : requestHasStaticPart(truthiness ? node.consequent : node.alternate, scope, resolution);
+	}
+	if (node.type === "LogicalExpression") {
+		const truthiness = staticTruthiness(node.left, scope, resolution);
+		if (node.operator === "&&" && truthiness !== null) return requestHasStaticPart(truthiness ? node.right : node.left, scope, resolution);
+		if (node.operator === "||" && truthiness !== null) return requestHasStaticPart(truthiness ? node.left : node.right, scope, resolution);
+		if (node.operator === "??") {
+			const nullishness = staticNullishness(node.left, scope, resolution);
+			if (nullishness !== null) return requestHasStaticPart(nullishness ? node.right : node.left, scope, resolution);
+		}
+		return requestHasStaticPart(node.left, scope, resolution) || requestHasStaticPart(node.right, scope, resolution);
+	}
+	if (node.type === "SequenceExpression") {
+		const expressions = nodeArray(node.expressions);
+		if (expressions.length === 0) return false;
+		return expressions.slice(0, -1).every((expression) => !expressionMayHaveSideEffects(expression, scope)) && requestHasStaticPart(expressions.at(-1), scope, resolution);
+	}
+	return false;
+}
+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 === "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 === "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));
+		}
+		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, {
+		initializer,
+		scope
+	});
+}
+function collectDirectBindings(node, scope) {
+	collectDirectScopeBindings(node, scope, (declaration, declarator) => collectConstantBinding(declaration, declarator, scope));
+	if (node.type === "SwitchStatement") collectSwitchScopeBindings(node, scope, (declaration, declarator) => collectConstantBinding(declaration, declarator, scope));
+}
+function dynamicRequireReplacement() {
+	return `(() => { const error = new Error(${JSON.stringify(DYNAMIC_REQUEST_ERROR)}); error.code = "MODULE_NOT_FOUND"; throw error; })()`;
+}
+function dynamicImportReplacement() {
+	return `Promise.resolve().then(() => { const error = new Error(${JSON.stringify(DYNAMIC_REQUEST_ERROR)}); error.code = "MODULE_NOT_FOUND"; throw error; })`;
+}
+function transformVeryDynamicRequests(code, id) {
+	if (!code.includes("require") && !code.includes("import")) return null;
+	const extension = path.extname(id.split("?", 1)[0]);
+	const lang = extension === ".ts" || extension === ".mts" || extension === ".cts" ? "ts" : extension === ".tsx" ? "tsx" : extension === ".jsx" ? "jsx" : "js";
+	let ast;
+	try {
+		ast = parseAst(code, { lang });
+	} catch {
+		return null;
+	}
+	const output = new MagicString(code);
+	let changed = false;
+	const root = astNode(ast);
+	if (!root) return null;
+	const rootScope = {
+		parent: null,
+		bindings: /* @__PURE__ */ new Set(),
+		constants: /* @__PURE__ */ new Map()
+	};
+	collectDirectBindings(root, rootScope);
+	collectVarScopeBindings(root, rootScope);
+	function visit(node, parentScope) {
+		let scope = parentScope;
+		if (isFunctionNode(node)) {
+			const parameterScope = {
+				parent: parentScope,
+				bindings: /* @__PURE__ */ new Set(),
+				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);
+			if (body) {
+				const bodyScope = {
+					parent: parameterScope,
+					bindings: /* @__PURE__ */ new Set(),
+					constants: /* @__PURE__ */ new Map()
+				};
+				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);
+				}
+				else visit(body, bodyScope);
+			}
+			return;
+		} else if (node.type === "SwitchStatement") {
+			const discriminant = astNode(node.discriminant);
+			if (discriminant) visit(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);
+			}
+			return;
+		} else if (node.type === "BlockStatement" && node !== root || node.type === "StaticBlock" || node.type === "TSModuleBlock") {
+			scope = {
+				parent: parentScope,
+				bindings: /* @__PURE__ */ new Set(),
+				constants: /* @__PURE__ */ new Map()
+			};
+			collectDirectBindings(node, scope);
+			if (node.type === "StaticBlock" || node.type === "TSModuleBlock") collectVarScopeBindings(node, scope);
+		} else if (node.type === "CatchClause") {
+			scope = {
+				parent: parentScope,
+				bindings: /* @__PURE__ */ new Set(),
+				constants: /* @__PURE__ */ new Map()
+			};
+			collectBindingNames(node.param, scope.bindings);
+		} else if (node.type === "ForStatement" || node.type === "ForInStatement" || node.type === "ForOfStatement") {
+			scope = {
+				parent: parentScope,
+				bindings: /* @__PURE__ */ new Set(),
+				constants: /* @__PURE__ */ new Map()
+			};
+			collectLoopScopeBindings(node, scope, (declaration, declarator) => collectConstantBinding(declaration, declarator, scope));
+		} else if (node.type === "ClassExpression" && node.id) {
+			scope = {
+				parent: parentScope,
+				bindings: /* @__PURE__ */ new Set(),
+				constants: /* @__PURE__ */ new Map()
+			};
+			collectBindingNames(node.id, scope.bindings);
+		}
+		if (node.type === "CallExpression" && hasRange(node)) {
+			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]) && !requestHasStaticPart(argumentsList[0], 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)) {
+			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);
+	if (!changed) return null;
+	return {
+		code: output.toString(),
+		map: output.generateMap({
+			hires: "boundary",
+			source: id
+		})
+	};
+}
+function createIgnoreDynamicRequestsPlugin(getTranspiledPackages = () => []) {
+	return {
+		name: "vinext:ignore-dynamic-requests",
+		enforce: "pre",
+		transform: {
+			filter: { id: { include: /\.(?:[cm]?[jt]s|[jt]sx)(?:\?.*)?$/ } },
+			handler(code, id) {
+				const cleanId = id.split("?", 1)[0];
+				if (!TRANSFORMABLE_EXTENSIONS.has(path.extname(cleanId))) return null;
+				if (!shouldTransformVeryDynamicRequests(this.environment, cleanId, getTranspiledPackages())) return null;
+				const absoluteId = path.resolve(cleanId);
+				if (absoluteId === VINEXT_SOURCE_ROOT || absoluteId.startsWith(`${VINEXT_SOURCE_ROOT}${path.sep}`) || PLUGIN_RSC_PATH.test(absoluteId)) return null;
+				return transformVeryDynamicRequests(code, id);
+			}
+		}
+	};
+}
+function shouldTransformVeryDynamicRequests(environment, id, transpiledPackages) {
+	if (environment.config.consumer === "server") return true;
+	const normalizedId = id.replaceAll("\\", "/");
+	if (!normalizedId.includes("/node_modules/")) return false;
+	return !transpiledPackages.some((packageName) => normalizedId.includes(`/node_modules/${packageName}/`));
+}
+const _transformVeryDynamicRequests = transformVeryDynamicRequests;
+//#endregion
+export { _transformVeryDynamicRequests, createIgnoreDynamicRequestsPlugin };

package/dist/plugins/middleware-server-only.d.ts

@@ -2,8 +2,8 @@ import { Plugin } from "vite";
 
 //#region src/plugins/middleware-server-only.d.ts
 /**
- * Allow `import 'server-only'` from middleware (and any module reachable
- * from middleware) in the SSR environment.
+ * Allow `import 'server-only'` from neutral server targets (and any module
+ * reachable from them) in the SSR environment.
  *
  * Background: middleware runs server-side, so importing `server-only` is
  * semantically correct. However, vinext bundles middleware into the SSR
@@ -13,9 +13,9 @@ import { Plugin } from "vite";
  *
  *   'server-only' cannot be imported in client build ('ssr' environment)
  *
- * Next.js solves this with webpack `issuerLayer` rules: middleware (and
- * `instrumentation`) sit in the `neutralTarget` layer where `server-only`
- * is aliased to a no-op while `client-only` still errors. See
+ * Next.js solves this with webpack `issuerLayer` rules: middleware,
+ * instrumentation, and Pages API routes sit in server-only or neutral layers
+ * where `server-only` is aliased to a no-op while `client-only` still errors. See
  *   packages/next/src/build/webpack-config.ts ("Alias server-only and
  *   client-only to proper exports based on bundling layers")
  *
@@ -23,7 +23,8 @@ import { Plugin } from "vite";
  * the behavior with import-chain taint tracking:
  *
  *   1. Seed a `tainted` set with the middleware entry path (and its
- *      canonical realpath).
+ *      canonical realpath), and recognize other neutral server entry modules
+ *      such as Pages API routes through `isNeutralServerModule`.
  *   2. For every resolveId call from a tainted importer, resolve the import
  *      via `this.resolve(..., { skipSelf: true })` and add the resolved id
  *      to the tainted set. This propagates the taint along the import graph
@@ -47,6 +48,7 @@ import { Plugin } from "vite";
 declare function createMiddlewareServerOnlyPlugin(options: {
   getMiddlewarePath: () => string | null;
   getCanonicalMiddlewarePath: () => string | null;
+  isNeutralServerModule?: (id: string) => boolean;
   serverOnlyShimPath: string;
 }): Plugin;
 //#endregion

package/dist/plugins/middleware-server-only.js

@@ -1,8 +1,8 @@
 import { normalizePathSeparators } from "../utils/path.js";
 //#region src/plugins/middleware-server-only.ts
 /**
-* Allow `import 'server-only'` from middleware (and any module reachable
-* from middleware) in the SSR environment.
+* Allow `import 'server-only'` from neutral server targets (and any module
+* reachable from them) in the SSR environment.
 *
 * Background: middleware runs server-side, so importing `server-only` is
 * semantically correct. However, vinext bundles middleware into the SSR
@@ -12,9 +12,9 @@ import { normalizePathSeparators } from "../utils/path.js";
 *
 *   'server-only' cannot be imported in client build ('ssr' environment)
 *
-* Next.js solves this with webpack `issuerLayer` rules: middleware (and
-* `instrumentation`) sit in the `neutralTarget` layer where `server-only`
-* is aliased to a no-op while `client-only` still errors. See
+* Next.js solves this with webpack `issuerLayer` rules: middleware,
+* instrumentation, and Pages API routes sit in server-only or neutral layers
+* where `server-only` is aliased to a no-op while `client-only` still errors. See
 *   packages/next/src/build/webpack-config.ts ("Alias server-only and
 *   client-only to proper exports based on bundling layers")
 *
@@ -22,7 +22,8 @@ import { normalizePathSeparators } from "../utils/path.js";
 * the behavior with import-chain taint tracking:
 *
 *   1. Seed a `tainted` set with the middleware entry path (and its
-*      canonical realpath).
+*      canonical realpath), and recognize other neutral server entry modules
+*      such as Pages API routes through `isNeutralServerModule`.
 *   2. For every resolveId call from a tainted importer, resolve the import
 *      via `this.resolve(..., { skipSelf: true })` and add the resolved id
 *      to the tainted set. This propagates the taint along the import graph
@@ -72,7 +73,7 @@ function createMiddlewareServerOnlyPlugin(options) {
 			async handler(id, importer, opts) {
 				if (this.environment?.name === "rsc") return;
 				if (!importer) return;
-				if (!isTainted(importer)) return;
+				if (!isTainted(importer) && !options.isNeutralServerModule?.(canonicalizeId(importer))) return;
 				if (id === "server-only") return {
 					id: options.serverOnlyShimPath,
 					moduleSideEffects: false

package/dist/plugins/optimize-imports.js

@@ -1,5 +1,5 @@
-import { normalizePathSeparators } from "../utils/path.js";
 import { escapeRegExp } from "../utils/regex.js";
+import { normalizePathSeparators } from "../utils/path.js";
 import { VIRTUAL_MODULE_ID_RE } from "../utils/virtual-module.js";
 import { getAstName } from "./ast-utils.js";
 import { createRequire } from "node:module";

package/dist/plugins/typeof-window.d.ts

@@ -6,7 +6,7 @@ type EnvironmentLike = {
   };
 };
 declare function getTypeofWindowReplacement(environment: EnvironmentLike): WindowType;
-declare function replaceTypeofWindow(code: string, replacement: WindowType): {
+declare function replaceTypeofWindow(code: string, replacement: WindowType, id?: string): {
   code: string;
   map: import("magic-string").SourceMap;
 } | null;