@qzsy/vinext 0.1.7

package/dist/plugins/strip-server-exports.js

@@ -0,0 +1,519 @@
+import { parseAst } from "vite";
+import MagicString from "magic-string";
+//#region src/plugins/strip-server-exports.ts
+const SERVER_EXPORTS = new Set([
+	"getServerSideProps",
+	"getStaticProps",
+	"getStaticPaths",
+	"unstable_getServerProps",
+	"unstable_getServerSideProps",
+	"unstable_getStaticProps",
+	"unstable_getStaticPaths"
+]);
+const SERVER_PROPS_SSG_CONFLICT = "You can not use getStaticProps or getStaticPaths with getServerSideProps. To use SSG, please remove getServerSideProps";
+const EXPORT_ALL_IN_PAGE_ERROR = "Using `export * from '...'` in a page is disallowed. Please use `export { default } from '...'` instead.\nRead more: https://nextjs.org/docs/messages/export-all-in-page";
+function hasServerExportCandidate(code) {
+	for (const name of SERVER_EXPORTS) if (code.includes(name)) return true;
+	return false;
+}
+function hasExportAllCandidate(code) {
+	let searchFrom = 0;
+	while (searchFrom < code.length) {
+		const exportStart = code.indexOf("export", searchFrom);
+		if (exportStart === -1) return false;
+		searchFrom = exportStart + 6;
+		const previous = code.charCodeAt(exportStart - 1);
+		const next = code.charCodeAt(searchFrom);
+		if (previous >= 48 && previous <= 57 || previous >= 65 && previous <= 90 || previous === 95 || previous >= 97 && previous <= 122 || next >= 48 && next <= 57 || next >= 65 && next <= 90 || next === 95 || next >= 97 && next <= 122) continue;
+		let position = searchFrom;
+		while (position < code.length) {
+			const char = code[position];
+			if (/\s/.test(char)) {
+				position++;
+				continue;
+			}
+			if (char === "/" && code[position + 1] === "*") {
+				const commentEnd = code.indexOf("*/", position + 2);
+				if (commentEnd === -1) break;
+				position = commentEnd + 2;
+				continue;
+			}
+			if (char === "/" && code[position + 1] === "/") {
+				const lineEnd = code.indexOf("\n", position + 2);
+				position = lineEnd === -1 ? code.length : lineEnd + 1;
+				continue;
+			}
+			if (char === "*") return true;
+			break;
+		}
+	}
+	return false;
+}
+function nodeName(node) {
+	if (!node || typeof node !== "object") return void 0;
+	const value = node;
+	return value.name ?? value.value;
+}
+function isInsideRanges(position, ranges) {
+	return ranges.some((range) => position >= range.start && position < range.end);
+}
+function bindingNames(pattern) {
+	if (!pattern) return [];
+	if (pattern.type === "Identifier") return [pattern.name];
+	if (pattern.type === "RestElement") return bindingNames(pattern.argument);
+	if (pattern.type === "AssignmentPattern") return bindingNames(pattern.left);
+	if (pattern.type === "ArrayPattern") return pattern.elements.flatMap((element) => bindingNames(element));
+	if (pattern.type === "ObjectPattern") return pattern.properties.flatMap((property) => {
+		if (property.type === "RestElement") return bindingNames(property.argument);
+		return bindingNames(property.value);
+	});
+	return [];
+}
+function bindingIdentifiers(pattern) {
+	if (!pattern) return [];
+	if (pattern.type === "Identifier") return [pattern];
+	if (pattern.type === "RestElement") return bindingIdentifiers(pattern.argument);
+	if (pattern.type === "AssignmentPattern") return bindingIdentifiers(pattern.left);
+	if (pattern.type === "ArrayPattern") return pattern.elements.flatMap((element) => bindingIdentifiers(element));
+	if (pattern.type === "ObjectPattern") return pattern.properties.flatMap((property) => {
+		if (property.type === "RestElement") return bindingIdentifiers(property.argument);
+		return bindingIdentifiers(property.value);
+	});
+	return [];
+}
+function isReferenceIdentifier(node, parent) {
+	if (node.type !== "Identifier" || !parent) return false;
+	if ((parent.type === "FunctionDeclaration" || parent.type === "FunctionExpression" || parent.type === "ClassDeclaration" || parent.type === "ClassExpression") && parent.id === node) return false;
+	if (parent.type === "VariableDeclarator" && parent.id === node) return false;
+	if (parent.type === "ImportSpecifier" || parent.type === "ImportDefaultSpecifier" || parent.type === "ImportNamespaceSpecifier") return false;
+	if (parent.type === "ExportSpecifier") return false;
+	if (parent.type === "MemberExpression" && parent.property === node && !parent.computed) return false;
+	if ((parent.type === "Property" || parent.type === "MethodDefinition") && parent.key === node && !parent.computed && !(parent.type === "Property" && parent.shorthand)) return false;
+	if ((parent.type === "LabeledStatement" || parent.type === "BreakStatement" || parent.type === "ContinueStatement") && parent.label === node) return false;
+	const parameters = "params" in parent ? parent.params : void 0;
+	if (Array.isArray(parameters) && parameters.includes(node)) return false;
+	if (parent.type === "CatchClause" && parent.param === node) return false;
+	return true;
+}
+function walkAst(node, visit, parent, ancestors = []) {
+	if (!node || typeof node !== "object") return;
+	if (Array.isArray(node)) {
+		for (const child of node) walkAst(child, visit, parent, ancestors);
+		return;
+	}
+	const current = node;
+	if (typeof current.type !== "string") return;
+	visit(current, parent, ancestors);
+	const childAncestors = [...ancestors, current];
+	for (const [key, value] of Object.entries(current)) {
+		if (key === "parent" || key === "loc" || key === "start" || key === "end") continue;
+		if (Array.isArray(value)) for (const child of value) walkAst(child, visit, current, childAncestors);
+		else if (value && typeof value === "object") walkAst(value, visit, current, childAncestors);
+	}
+}
+function renderImportDeclaration(code, statement, removed) {
+	const kept = statement.specifiers.filter((specifier) => !removed.has(specifier));
+	if (kept.length === 0) return "";
+	const defaultSpecifier = kept.find((specifier) => specifier.type === "ImportDefaultSpecifier");
+	const namespaceSpecifier = kept.find((specifier) => specifier.type === "ImportNamespaceSpecifier");
+	const namedSpecifiers = kept.filter((specifier) => specifier.type === "ImportSpecifier");
+	const clauses = [];
+	if (defaultSpecifier) clauses.push(code.slice(defaultSpecifier.start, defaultSpecifier.end));
+	if (namespaceSpecifier) clauses.push(code.slice(namespaceSpecifier.start, namespaceSpecifier.end));
+	if (namedSpecifiers.length > 0) clauses.push(`{ ${namedSpecifiers.map((specifier) => code.slice(specifier.start, specifier.end)).join(", ")} }`);
+	return `import ${clauses.join(", ")} from ${code.slice(statement.source.start, statement.end)}`;
+}
+function renderExportDeclaration(code, statement, removed) {
+	const kept = statement.specifiers.filter((specifier) => !removed.has(specifier));
+	if (kept.length === 0) return "";
+	return `export { ${kept.map((specifier) => code.slice(specifier.start, specifier.end)).join(", ")} }${statement.source ? ` from ${code.slice(statement.source.start, statement.end)}` : ";"}`;
+}
+function renderBindingPattern(code, pattern, removedNames) {
+	if (pattern.type === "Identifier") return removedNames.has(pattern.name) ? null : pattern.name;
+	if (pattern.type === "RestElement") {
+		const argument = renderBindingPattern(code, pattern.argument, removedNames);
+		return argument ? `...${argument}` : null;
+	}
+	if (pattern.type === "AssignmentPattern") {
+		const left = renderBindingPattern(code, pattern.left, removedNames);
+		return left ? `${left} = ${code.slice(pattern.right.start, pattern.right.end)}` : null;
+	}
+	if (pattern.type === "ObjectPattern") {
+		const properties = pattern.properties.flatMap((property) => {
+			if (property.type === "RestElement") {
+				const rendered = renderBindingPattern(code, property, removedNames);
+				return rendered ? [rendered] : [];
+			}
+			const value = renderBindingPattern(code, property.value, removedNames);
+			if (!value) return [];
+			if (property.shorthand && property.value.type === "Identifier") return [value];
+			const key = code.slice(property.key.start, property.key.end);
+			return [`${property.computed ? `[${key}]` : key}: ${value}`];
+		});
+		return properties.length > 0 ? `{ ${properties.join(", ")} }` : null;
+	}
+	if (pattern.type === "ArrayPattern") {
+		const elements = pattern.elements.map((element) => element ? renderBindingPattern(code, element, removedNames) : null);
+		while (elements.length > 0 && elements.at(-1) === null) elements.pop();
+		return elements.length > 0 ? `[${elements.map((element) => element ?? "").join(", ")}]` : null;
+	}
+	return code.slice(pattern.start, pattern.end);
+}
+function assignmentRootName(node) {
+	if (node.type === "Identifier") return node.name;
+	if (node.type === "MemberExpression") return assignmentRootName(node.object);
+}
+function assignmentBindingNames(node) {
+	if (node.type === "ArrayPattern" || node.type === "ObjectPattern") return bindingNames(node);
+	const rootName = assignmentRootName(node);
+	return rootName ? [rootName] : [];
+}
+function isAssignmentTargetIdentifier(node, left) {
+	if (left.type === "Identifier") return node.start === left.start;
+	if (left.type === "ArrayPattern" || left.type === "ObjectPattern") return bindingIdentifiers(left).some((identifier) => identifier.start === node.start);
+	if (left.type === "MemberExpression") {
+		let object = left.object;
+		while (object.type === "MemberExpression") object = object.object;
+		return object.type === "Identifier" && object.start === node.start;
+	}
+	return false;
+}
+function findLexicalScope(ancestors) {
+	return [...ancestors].reverse().find((ancestor) => [
+		"BlockStatement",
+		"SwitchStatement",
+		"ForStatement",
+		"ForInStatement",
+		"ForOfStatement"
+	].includes(ancestor.type));
+}
+function validatePageExports(code) {
+	if (!hasExportAllCandidate(code)) return;
+	let ast;
+	try {
+		ast = parseAst(code);
+	} catch {
+		return;
+	}
+	if (ast.body.some((statement) => statement.type === "ExportAllDeclaration")) throw new Error(EXPORT_ALL_IN_PAGE_ERROR);
+}
+/**
+* Strip server-only Pages Router data-fetching exports and their unique
+* dependency graph from browser bundles.
+*
+* Ported from Next.js:
+* - test/unit/babel-plugin-next-ssg-transform.test.ts
+* - crates/next-custom-transforms/src/transforms/strip_page_exports.rs
+*/
+function stripServerExports(code) {
+	if (!hasServerExportCandidate(code) && !hasExportAllCandidate(code)) return null;
+	let ast;
+	try {
+		ast = parseAst(code);
+	} catch {
+		return null;
+	}
+	const statements = ast.body;
+	validatePageExports(code);
+	const edits = [];
+	const deadRanges = [];
+	const deadRangeKeys = /* @__PURE__ */ new Set();
+	const addDeadRange = (range) => {
+		const key = `${range.start}:${range.end}`;
+		if (deadRangeKeys.has(key)) return false;
+		deadRangeKeys.add(key);
+		deadRanges.push(range);
+		return true;
+	};
+	const forcedBindings = /* @__PURE__ */ new Set();
+	const candidateBindings = /* @__PURE__ */ new Set();
+	const bindings = /* @__PURE__ */ new Map();
+	const bindingPositions = /* @__PURE__ */ new Set();
+	const references = /* @__PURE__ */ new Map();
+	const shadowRanges = /* @__PURE__ */ new Map();
+	const exportSpecifierRemovals = /* @__PURE__ */ new Map();
+	const variableRemovals = /* @__PURE__ */ new Map();
+	const importRemovals = /* @__PURE__ */ new Map();
+	const assignmentStatements = [];
+	const removedAssignments = /* @__PURE__ */ new Set();
+	for (const statement of statements) {
+		const declaration = statement.type === "ExportNamedDeclaration" ? statement.declaration : statement;
+		if (declaration?.type === "FunctionDeclaration" && declaration.id) {
+			bindingPositions.add(declaration.id.start);
+			bindings.set(declaration.id.name, {
+				name: declaration.id.name,
+				node: declaration,
+				parent: statement,
+				kind: "function",
+				implementation: declaration,
+				declaredNames: [declaration.id.name]
+			});
+		} else if (declaration?.type === "ClassDeclaration" && declaration.id) {
+			bindingPositions.add(declaration.id.start);
+			bindings.set(declaration.id.name, {
+				name: declaration.id.name,
+				node: declaration,
+				parent: statement,
+				kind: "class",
+				implementation: declaration,
+				declaredNames: [declaration.id.name]
+			});
+		} else if (declaration?.type === "VariableDeclaration") for (const declarator of declaration.declarations) {
+			const declaredNames = bindingNames(declarator.id);
+			for (const identifier of bindingIdentifiers(declarator.id)) bindingPositions.add(identifier.start);
+			for (const name of declaredNames) bindings.set(name, {
+				name,
+				node: declarator,
+				parent: declaration,
+				kind: "variable",
+				implementation: declarator.init ?? declarator,
+				declaredNames
+			});
+		}
+		else if (statement.type === "ImportDeclaration") for (const specifier of statement.specifiers) {
+			const name = nodeName(specifier.local);
+			if (!name) continue;
+			bindingPositions.add(specifier.local.start);
+			bindings.set(name, {
+				name,
+				node: specifier,
+				parent: statement,
+				kind: "import",
+				implementation: specifier,
+				declaredNames: [name]
+			});
+		}
+		else if (statement.type === "ExpressionStatement") {
+			const expression = statement.expression;
+			if (expression.type === "AssignmentExpression") {
+				const left = expression.left;
+				const names = assignmentBindingNames(left);
+				if (names.length > 0) assignmentStatements.push({
+					statement,
+					left,
+					bindingNames: names
+				});
+			}
+		}
+	}
+	const addShadowRange = (name, range) => {
+		if (!range || range.type === "Program") return;
+		const ranges = shadowRanges.get(name) ?? [];
+		ranges.push(range);
+		shadowRanges.set(name, ranges);
+	};
+	walkAst(ast.body, (node, parent, ancestors = []) => {
+		if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") {
+			for (const parameter of node.params) for (const name of bindingNames(parameter)) addShadowRange(name, node);
+			if (node.type === "FunctionDeclaration" && node.id) addShadowRange(node.id.name, findLexicalScope(ancestors));
+			else if (node.type === "FunctionExpression" && node.id) addShadowRange(node.id.name, node);
+		} else if (node.type === "ClassDeclaration" && node.id) addShadowRange(node.id.name, findLexicalScope(ancestors));
+		else if (node.type === "ClassExpression" && node.id) addShadowRange(node.id.name, node);
+		else if (node.type === "CatchClause" && node.param) for (const name of bindingNames(node.param)) addShadowRange(name, node.body);
+		else if (node.type === "VariableDeclarator" && parent?.type === "VariableDeclaration") {
+			const scope = parent.kind === "var" ? [...ancestors].reverse().find((ancestor) => [
+				"FunctionDeclaration",
+				"FunctionExpression",
+				"ArrowFunctionExpression"
+			].includes(ancestor.type)) : findLexicalScope(ancestors);
+			for (const name of bindingNames(node.id)) addShadowRange(name, scope);
+		}
+	});
+	walkAst(ast.body, (node, parent, ancestors = []) => {
+		if (!isReferenceIdentifier(node, parent)) return;
+		if (bindingPositions.has(node.start)) return;
+		if (isInsideRanges(node.start, shadowRanges.get(node.name) ?? [])) return;
+		const assignment = [...ancestors].reverse().find((ancestor) => ancestor.type === "AssignmentExpression");
+		if (assignment && isAssignmentTargetIdentifier(node, assignment.left)) return;
+		const positions = references.get(node.name) ?? [];
+		positions.push(node.start);
+		references.set(node.name, positions);
+	});
+	let hasServerProps = false;
+	let hasStaticProps = false;
+	const noteDataExport = (name) => {
+		if (name === "getServerSideProps") hasServerProps = true;
+		else hasStaticProps = true;
+		if (hasServerProps && hasStaticProps) throw new Error(SERVER_PROPS_SSG_CONFLICT);
+	};
+	for (const statement of statements) {
+		if (statement.type !== "ExportNamedDeclaration") continue;
+		if (statement.declaration?.type === "FunctionDeclaration" && statement.declaration.id) {
+			const name = statement.declaration.id.name;
+			if (SERVER_EXPORTS.has(name)) {
+				noteDataExport(name);
+				forcedBindings.add(name);
+				addDeadRange(statement.declaration);
+				edits.push({
+					start: statement.start,
+					end: statement.end,
+					replacement: ""
+				});
+			}
+			continue;
+		}
+		if (statement.declaration?.type === "VariableDeclaration") {
+			for (const declarator of statement.declaration.declarations) for (const name of bindingNames(declarator.id)) {
+				if (!SERVER_EXPORTS.has(name)) continue;
+				noteDataExport(name);
+				forcedBindings.add(name);
+				if (declarator.init) addDeadRange(declarator.init);
+				const removals = variableRemovals.get(statement.declaration) ?? /* @__PURE__ */ new Set();
+				removals.add(declarator);
+				variableRemovals.set(statement.declaration, removals);
+			}
+			continue;
+		}
+		const removed = /* @__PURE__ */ new Set();
+		for (const specifier of statement.specifiers) {
+			const exportedName = nodeName(specifier.exported);
+			if (exportedName && SERVER_EXPORTS.has(exportedName)) {
+				noteDataExport(exportedName);
+				removed.add(specifier);
+				if (!statement.source) {
+					const localName = nodeName(specifier.local);
+					if (localName) candidateBindings.add(localName);
+				}
+			} else if (!statement.source) {
+				const localName = nodeName(specifier.local);
+				if (localName) {
+					const positions = references.get(localName) ?? [];
+					positions.push(specifier.local.start);
+					references.set(localName, positions);
+				}
+			}
+		}
+		if (removed.size > 0) exportSpecifierRemovals.set(statement, removed);
+	}
+	const deadBindings = /* @__PURE__ */ new Set();
+	let changed = true;
+	while (changed) {
+		changed = false;
+		for (const { statement, left, bindingNames: names } of assignmentStatements) {
+			const removableNames = new Set(names.filter((name) => forcedBindings.has(name) || deadBindings.has(name)));
+			if (removableNames.size === 0) continue;
+			if (removedAssignments.has(statement)) continue;
+			const expression = statement.expression;
+			const renderedLeft = left.type === "ArrayPattern" || left.type === "ObjectPattern" ? renderBindingPattern(code, left, removableNames) : null;
+			removedAssignments.add(statement);
+			edits.push({
+				start: statement.start,
+				end: statement.end,
+				replacement: renderedLeft ? `${left.type === "ObjectPattern" ? `(${renderedLeft} ${expression.operator} ${code.slice(expression.right.start, expression.right.end)})` : `${renderedLeft} ${expression.operator} ${code.slice(expression.right.start, expression.right.end)}`};` : ""
+			});
+			if (!renderedLeft && addDeadRange(statement)) changed = true;
+		}
+		const removableBindings = /* @__PURE__ */ new Set();
+		for (const [name] of bindings) if (forcedBindings.has(name) || candidateBindings.has(name) || (references.get(name) ?? []).some((position) => isInsideRanges(position, deadRanges))) removableBindings.add(name);
+		let closureChanged = true;
+		while (closureChanged) {
+			closureChanged = false;
+			const implementations = [...removableBindings].map((name) => bindings.get(name)?.implementation).filter((implementation) => Boolean(implementation));
+			for (const [name] of bindings) {
+				if (removableBindings.has(name)) continue;
+				if ((references.get(name) ?? []).some((position) => isInsideRanges(position, implementations))) {
+					removableBindings.add(name);
+					closureChanged = true;
+				}
+			}
+		}
+		let pruneChanged = true;
+		while (pruneChanged) {
+			pruneChanged = false;
+			const implementations = [...removableBindings].map((name) => bindings.get(name)?.implementation).filter((implementation) => Boolean(implementation));
+			for (const name of removableBindings) {
+				if (forcedBindings.has(name)) continue;
+				if ((references.get(name) ?? []).some((position) => !isInsideRanges(position, deadRanges) && !isInsideRanges(position, implementations))) {
+					removableBindings.delete(name);
+					pruneChanged = true;
+				}
+			}
+		}
+		for (const name of removableBindings) {
+			if (deadBindings.has(name)) continue;
+			const binding = bindings.get(name);
+			if (!binding) continue;
+			deadBindings.add(name);
+			changed = true;
+			if (binding.kind === "function" || binding.kind === "class") addDeadRange(binding.implementation);
+		}
+		for (const binding of new Set(bindings.values())) {
+			if (binding.kind !== "variable") continue;
+			if (!binding.declaredNames.every((name) => deadBindings.has(name))) continue;
+			if (addDeadRange(binding.implementation)) changed = true;
+		}
+	}
+	for (const name of deadBindings) {
+		const binding = bindings.get(name);
+		if (!binding) continue;
+		if (forcedBindings.has(name)) {
+			if ((binding.kind === "function" || binding.kind === "class") && binding.parent.type !== "ExportNamedDeclaration") edits.push({
+				start: binding.node.start,
+				end: binding.node.end,
+				replacement: binding.kind === "function" ? `function ${name}() {}` : `class ${name} {}`
+			});
+			else if (binding.kind === "variable" && binding.parent.type !== "ExportNamedDeclaration") {
+				const removals = variableRemovals.get(binding.parent) ?? /* @__PURE__ */ new Set();
+				removals.add(binding.node);
+				variableRemovals.set(binding.parent, removals);
+			} else if (binding.kind === "import") {
+				const removals = importRemovals.get(binding.parent) ?? /* @__PURE__ */ new Set();
+				removals.add(binding.node);
+				importRemovals.set(binding.parent, removals);
+			}
+			continue;
+		}
+		if (binding.kind === "import") {
+			const removals = importRemovals.get(binding.parent) ?? /* @__PURE__ */ new Set();
+			removals.add(binding.node);
+			importRemovals.set(binding.parent, removals);
+		} else if (binding.kind === "variable") {
+			const removals = variableRemovals.get(binding.parent) ?? /* @__PURE__ */ new Set();
+			removals.add(binding.node);
+			variableRemovals.set(binding.parent, removals);
+		} else edits.push({
+			start: binding.parent.start,
+			end: binding.parent.end,
+			replacement: ""
+		});
+	}
+	for (const [statement, removed] of exportSpecifierRemovals) edits.push({
+		start: statement.start,
+		end: statement.end,
+		replacement: renderExportDeclaration(code, statement, removed)
+	});
+	for (const [declaration, removed] of variableRemovals) {
+		const rendered = declaration.declarations.flatMap((declarator) => {
+			if (!removed.has(declarator)) return [code.slice(declarator.start, declarator.end)];
+			const pattern = renderBindingPattern(code, declarator.id, deadBindings);
+			if (!pattern) return [];
+			return [`${pattern}${declarator.init ? ` = ${code.slice(declarator.init.start, declarator.init.end)}` : ""}`];
+		});
+		const exportStatement = statements.find((statement) => statement.type === "ExportNamedDeclaration" && statement.declaration === declaration);
+		edits.push({
+			start: exportStatement?.start ?? declaration.start,
+			end: declaration.end,
+			replacement: rendered.length > 0 ? `${exportStatement ? "export " : ""}${declaration.kind} ${rendered.join(", ")};` : ""
+		});
+	}
+	for (const [statement, removed] of importRemovals) edits.push({
+		start: statement.start,
+		end: statement.end,
+		replacement: renderImportDeclaration(code, statement, removed)
+	});
+	if (edits.length === 0) return null;
+	const string = new MagicString(code);
+	const uniqueEdits = [...new Map(edits.map((edit) => [`${edit.start}:${edit.end}`, edit])).values()].sort((left, right) => right.start - left.start || right.end - left.end);
+	let lastStart = Number.POSITIVE_INFINITY;
+	for (const edit of uniqueEdits) {
+		if (edit.end > lastStart) continue;
+		string.overwrite(edit.start, edit.end, edit.replacement);
+		lastStart = edit.start;
+	}
+	return {
+		code: string.toString(),
+		map: string.generateMap({ hires: "boundary" })
+	};
+}
+//#endregion
+export { hasExportAllCandidate, hasServerExportCandidate, stripServerExports, validatePageExports };

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

@@ -0,0 +1,14 @@
+//#region src/plugins/typeof-window.d.ts
+type WindowType = "object" | "undefined";
+type EnvironmentLike = {
+  config: {
+    consumer: "client" | "server";
+  };
+};
+declare function getTypeofWindowReplacement(environment: EnvironmentLike): WindowType;
+declare function replaceTypeofWindow(code: string, replacement: WindowType): {
+  code: string;
+  map: import("magic-string").SourceMap;
+} | null;
+//#endregion
+export { getTypeofWindowReplacement, replaceTypeofWindow };

package/dist/plugins/typeof-window.js

@@ -0,0 +1,150 @@
+import { collectBindingNames, forEachAstChild, hasRange, isAstRecord, isIdentifierNamed, nodeArray } from "./ast-utils.js";
+import { parseAst } from "vite";
+import MagicString from "magic-string";
+//#region src/plugins/typeof-window.ts
+function createScope(parent) {
+	return {
+		parent,
+		bindings: /* @__PURE__ */ new Set()
+	};
+}
+function hasBinding(scope, name) {
+	for (let current = scope; current; current = current.parent) if (current.bindings.has(name)) return true;
+	return false;
+}
+function collectScopeBindings(node, scope) {
+	forEachAstChild(node, (child) => {
+		if (child.type === "ExportNamedDeclaration" || child.type === "ExportDefaultDeclaration") {
+			if (isAstRecord(child.declaration)) collectScopeBindings(child, scope);
+			return;
+		}
+		if (child.type === "FunctionDeclaration" || child.type === "ClassDeclaration") {
+			collectBindingNames(child.id, scope.bindings);
+			return;
+		}
+		if (child.type === "VariableDeclaration") {
+			for (const declaration of nodeArray(child.declarations)) if (isAstRecord(declaration)) collectBindingNames(declaration.id, scope.bindings);
+			return;
+		}
+		if (child.type === "ImportDeclaration") {
+			for (const specifier of nodeArray(child.specifiers)) if (isAstRecord(specifier)) collectBindingNames(specifier.local, scope.bindings);
+		}
+	});
+}
+function collectVarBindings(node, scope, isRoot = true) {
+	if (!isRoot && (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression")) return;
+	if (node.type === "VariableDeclaration" && node.kind === "var") {
+		for (const declaration of nodeArray(node.declarations)) if (isAstRecord(declaration)) collectBindingNames(declaration.id, scope.bindings);
+	}
+	forEachAstChild(node, (child) => collectVarBindings(child, scope, false));
+}
+function isFunctionNode(node) {
+	return node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression";
+}
+function createChildScope(node, parent) {
+	if (node.type !== "Program" && node.type !== "BlockStatement" && node.type !== "StaticBlock" && node.type !== "SwitchStatement" && node.type !== "CatchClause" && node.type !== "ForStatement" && node.type !== "ForInStatement" && node.type !== "ForOfStatement" && node.type !== "ClassDeclaration" && node.type !== "ClassExpression") return null;
+	const scope = createScope(parent);
+	if (node.type === "ClassDeclaration" || node.type === "ClassExpression") collectBindingNames(node.id, scope.bindings);
+	else if (node.type === "CatchClause") collectBindingNames(node.param, scope.bindings);
+	collectScopeBindings(node, scope);
+	if (node.type === "SwitchStatement") {
+		for (const switchCase of nodeArray(node.cases)) if (isAstRecord(switchCase)) collectScopeBindings(switchCase, scope);
+	}
+	return scope;
+}
+function getTypeofWindowReplacement(environment) {
+	return environment.config.consumer === "client" ? "object" : "undefined";
+}
+function stringLiteralValue(node) {
+	if (!isAstRecord(node)) return null;
+	if (node.type === "Literal" && typeof node.value === "string") return node.value;
+	return null;
+}
+function evaluateTypeofWindowComparison(node, replacement, scope) {
+	if (!isAstRecord(node) || node.type !== "BinaryExpression") return null;
+	if (![
+		"==",
+		"===",
+		"!=",
+		"!=="
+	].includes(String(node.operator))) return null;
+	const left = isAstRecord(node.left) ? node.left : null;
+	const right = isAstRecord(node.right) ? node.right : null;
+	const leftIsTypeofWindow = left?.type === "UnaryExpression" && left.operator === "typeof" && isIdentifierNamed(left.argument, "window") && !hasBinding(scope, "window");
+	const rightIsTypeofWindow = right?.type === "UnaryExpression" && right.operator === "typeof" && isIdentifierNamed(right.argument, "window") && !hasBinding(scope, "window");
+	const comparedValue = leftIsTypeofWindow ? stringLiteralValue(right) : rightIsTypeofWindow ? stringLiteralValue(left) : null;
+	if (comparedValue === null) return null;
+	const equal = replacement === comparedValue;
+	return node.operator === "==" || node.operator === "===" ? equal : !equal;
+}
+function replaceTypeofWindow(code, replacement) {
+	if (!/typeof\s+window/.test(code)) return null;
+	let ast;
+	try {
+		ast = parseAst(code);
+	} catch {
+		return null;
+	}
+	const output = new MagicString(code);
+	let changed = false;
+	if (!isAstRecord(ast)) return null;
+	const rootScope = createScope(null);
+	collectScopeBindings(ast, rootScope);
+	collectVarBindings(ast, rootScope);
+	function visit(node, parentScope) {
+		if (isFunctionNode(node)) {
+			const parameterScope = createScope(parentScope);
+			collectBindingNames(node.id, parameterScope.bindings);
+			for (const parameter of nodeArray(node.params)) {
+				collectBindingNames(parameter, parameterScope.bindings);
+				if (isAstRecord(parameter)) visit(parameter, parameterScope);
+			}
+			if (isAstRecord(node.body)) if (node.body.type === "BlockStatement") {
+				const bodyScope = createScope(parameterScope);
+				collectVarBindings(node.body, bodyScope);
+				visit(node.body, bodyScope);
+			} else visit(node.body, parameterScope);
+			return;
+		}
+		const scope = createChildScope(node, parentScope) ?? parentScope;
+		if (node.type === "IfStatement" && hasRange(node)) {
+			const result = evaluateTypeofWindowComparison(node.test, replacement, scope);
+			if (result !== null) {
+				const selected = result ? node.consequent : node.alternate;
+				if (isAstRecord(selected) && hasRange(selected)) {
+					output.remove(node.start, selected.start);
+					output.remove(selected.end, node.end);
+					visit(selected, scope);
+				} else output.overwrite(node.start, node.end, ";");
+				changed = true;
+				return;
+			}
+		}
+		if (node.type === "ConditionalExpression" && hasRange(node)) {
+			const result = evaluateTypeofWindowComparison(node.test, replacement, scope);
+			const selected = result ? node.consequent : node.alternate;
+			if (result !== null && isAstRecord(selected) && hasRange(selected)) {
+				output.overwrite(node.start, selected.start, "(");
+				if (selected.end < node.end) output.overwrite(selected.end, node.end, ")");
+				else output.appendLeft(selected.end, ")");
+				visit(selected, scope);
+				changed = true;
+				return;
+			}
+		}
+		if (node.type === "UnaryExpression" && node.operator === "typeof" && isIdentifierNamed(node.argument, "window") && !hasBinding(scope, "window") && hasRange(node)) {
+			output.overwrite(node.start, node.end, JSON.stringify(replacement));
+			changed = true;
+			return;
+		}
+		forEachAstChild(node, (child) => visit(child, scope));
+	}
+	for (const node of ast.body) if (isAstRecord(node)) visit(node, rootScope);
+	if (!changed) return null;
+	return {
+		code: output.toString(),
+		map: output.generateMap({ hires: "boundary" })
+	};
+}
+//#endregion
+export { getTypeofWindowReplacement, replaceTypeofWindow };