@vitejs/plugin-rsc 0.5.18 → 0.5.20

package/dist/validate-import-DJumtHRw.js

@@ -0,0 +1,498 @@
+import assert from "node:assert";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { exactRegex, prefixRegex } from "@rolldown/pluginutils";
+import * as esModuleLexer from "es-module-lexer";
+import MagicString from "magic-string";
+import { stripLiteral } from "strip-literal";
+import { isFileLoadingAllowed, normalizePath, parseAstAsync } from "vite";
+import { walk } from "estree-walker";
+import { stripVTControlCharacters } from "node:util";
+import { createHash } from "node:crypto";
+
+//#region src/plugins/vite-utils.ts
+const VALID_ID_PREFIX = `/@id/`;
+const NULL_BYTE_PLACEHOLDER = `__x00__`;
+const FS_PREFIX = `/@fs/`;
+function wrapId(id) {
+	return id.startsWith(VALID_ID_PREFIX) ? id : VALID_ID_PREFIX + id.replace("\0", NULL_BYTE_PLACEHOLDER);
+}
+function withTrailingSlash(path) {
+	if (path[path.length - 1] !== "/") return `${path}/`;
+	return path;
+}
+const postfixRE = /[?#].*$/;
+function cleanUrl(url) {
+	return url.replace(postfixRE, "");
+}
+function splitFileAndPostfix(path) {
+	const file = cleanUrl(path);
+	return {
+		file,
+		postfix: path.slice(file.length)
+	};
+}
+const windowsSlashRE = /\\/g;
+function slash(p) {
+	return p.replace(windowsSlashRE, "/");
+}
+const isWindows = typeof process !== "undefined" && process.platform === "win32";
+function injectQuery(url, queryToInject) {
+	const { file, postfix } = splitFileAndPostfix(url);
+	return `${isWindows ? slash(file) : file}?${queryToInject}${postfix[0] === "?" ? `&${postfix.slice(1)}` : postfix}`;
+}
+function normalizeResolvedIdToUrl(environment, url, resolved) {
+	const root = environment.config.root;
+	const depsOptimizer = environment.depsOptimizer;
+	if (resolved.id.startsWith(withTrailingSlash(root))) url = resolved.id.slice(root.length);
+	else if (depsOptimizer?.isOptimizedDepFile(resolved.id) || resolved.id !== "/@react-refresh" && path.isAbsolute(resolved.id) && fs.existsSync(cleanUrl(resolved.id))) url = path.posix.join(FS_PREFIX, resolved.id);
+	else url = resolved.id;
+	if (url[0] !== "." && url[0] !== "/") url = wrapId(resolved.id);
+	return url;
+}
+function normalizeViteImportAnalysisUrl(environment, id) {
+	let url = normalizeResolvedIdToUrl(environment, id, { id });
+	if (environment.config.consumer === "client") {
+		const mod = environment.moduleGraph.getModuleById(id);
+		if (mod && mod.lastHMRTimestamp > 0) url = injectQuery(url, `t=${mod.lastHMRTimestamp}`);
+	}
+	return url;
+}
+function prepareError(err) {
+	return {
+		message: stripVTControlCharacters(err.message),
+		stack: stripVTControlCharacters(cleanStack(err.stack || "")),
+		id: err.id,
+		frame: stripVTControlCharacters(err.frame || ""),
+		plugin: err.plugin,
+		pluginCode: err.pluginCode?.toString(),
+		loc: err.loc
+	};
+}
+function cleanStack(stack) {
+	return stack.split(/\n/).filter((l) => /^\s*at/.test(l)).join("\n");
+}
+function evalValue(rawValue) {
+	return new Function(`
+    var console, exports, global, module, process, require
+    return (\n${rawValue}\n)
+  `)();
+}
+const directRequestRE = /(\?|&)direct=?(?:&|$)/;
+
+//#endregion
+//#region src/plugins/find-source-map-url.ts
+function vitePluginFindSourceMapURL() {
+	return [{
+		name: "rsc:findSourceMapURL",
+		apply: "serve",
+		configureServer(server) {
+			server.middlewares.use(async (req, res, next) => {
+				const url = new URL(req.url, `http://localhost`);
+				if (url.pathname === "/__vite_rsc_findSourceMapURL") {
+					let filename = url.searchParams.get("filename");
+					let environmentName = url.searchParams.get("environmentName");
+					try {
+						const map = await findSourceMapURL(server, filename, environmentName);
+						res.setHeader("content-type", "application/json");
+						if (!map) res.statusCode = 404;
+						res.end(JSON.stringify(map ?? {}));
+					} catch (e) {
+						next(e);
+					}
+					return;
+				}
+				next();
+			});
+		}
+	}];
+}
+async function findSourceMapURL(server, filename, environmentName) {
+	if (filename.startsWith("file://")) {
+		filename = slash(fileURLToPath(filename));
+		if (isFileLoadingAllowed(server.config, filename) && fs.existsSync(filename)) {
+			const content = fs.readFileSync(filename, "utf-8");
+			return {
+				version: 3,
+				sources: [filename],
+				sourcesContent: [content],
+				mappings: "AAAA" + ";AACA".repeat(content.split("\n").length)
+			};
+		}
+		return;
+	}
+	let mod;
+	let map;
+	if (environmentName === "Server") {
+		mod = server.environments.rsc.moduleGraph.getModuleById(filename);
+		map = mod?.transformResult?.map;
+		if (map && map.mappings) map = {
+			...map,
+			mappings: ";;" + map.mappings
+		};
+	}
+	const base = server.config.base.slice(0, -1);
+	if (environmentName === "Client") try {
+		const url = new URL(filename).pathname.slice(base.length);
+		mod = server.environments.client.moduleGraph.urlToModuleMap.get(url);
+		map = mod?.transformResult?.map;
+	} catch (e) {}
+	if (mod && map) return {
+		...map,
+		sources: [base + mod.url]
+	};
+}
+
+//#endregion
+//#region src/plugins/utils.ts
+function sortObject(o) {
+	return Object.fromEntries(Object.entries(o).sort(([a], [b]) => a.localeCompare(b)));
+}
+function withRollupError(ctx, f) {
+	function processError(e) {
+		if (e && typeof e === "object" && typeof e.pos === "number") return ctx.error(e, e.pos);
+		throw e;
+	}
+	return function(...args) {
+		try {
+			const result = f.apply(this, args);
+			if (result instanceof Promise) return result.catch((e) => processError(e));
+			return result;
+		} catch (e) {
+			processError(e);
+		}
+	};
+}
+function createVirtualPlugin(name, load) {
+	const virtualId = "virtual:" + name;
+	const resolvedId = "\0" + virtualId;
+	return {
+		name: `rsc:virtual-${name}`,
+		resolveId: {
+			filter: { id: exactRegex(virtualId) },
+			handler(source) {
+				if (source === virtualId) return resolvedId;
+			}
+		},
+		load: {
+			filter: { id: exactRegex(resolvedId) },
+			handler(id, options) {
+				if (id === resolvedId) return load.apply(this, [id, options]);
+			}
+		}
+	};
+}
+function normalizeRelativePath(s) {
+	s = normalizePath(s);
+	return s[0] === "." ? s : "./" + s;
+}
+function getEntrySource(config, name) {
+	const input = config.build.rollupOptions.input;
+	if (!name) return getFallbackRollupEntry(input).source;
+	if (typeof input === "object" && !Array.isArray(input) && name in input && typeof input[name] === "string") return input[name];
+	throw new Error(`[vite-rsc:getEntrySource] expected 'build.rollupOptions.input' to be an object with a '${name}' property that is a string, but got ${JSON.stringify(input)}`);
+}
+function getFallbackRollupEntry(input = {}) {
+	const inputEntries = Object.entries(normalizeRollupOpitonsInput(input));
+	if (inputEntries.length === 1) {
+		const [name, source] = inputEntries[0];
+		return {
+			name,
+			source
+		};
+	}
+	throw new Error(`[vite-rsc] cannot determine fallback entry name from multiple entries, please specify the entry name explicitly`);
+}
+function normalizeRollupOpitonsInput(input = {}) {
+	if (typeof input === "string") input = [input];
+	if (Array.isArray(input)) return Object.fromEntries(input.map((file) => [path.basename(file).slice(0, -path.extname(file).length), file]));
+	return input;
+}
+function hashString(v) {
+	return createHash("sha256").update(v).digest().toString("hex").slice(0, 12);
+}
+function getFetchHandlerExport(exports) {
+	if ("default" in exports) {
+		const default_ = exports.default;
+		if (default_ && typeof default_ === "object" && "fetch" in default_ && typeof default_.fetch === "function") return default_.fetch;
+		if (typeof default_ === "function") return default_;
+	}
+	throw new Error("Invalid server handler entry");
+}
+
+//#endregion
+//#region src/plugins/import-environment.ts
+const ENV_IMPORTS_MANIFEST_NAME = "__vite_rsc_env_imports_manifest.js";
+const ENV_IMPORTS_MANIFEST_PLACEHOLDER = "virtual:vite-rsc/env-imports-manifest";
+const ENV_IMPORTS_ENTRY_FALLBACK = "virtual:vite-rsc/env-imports-entry-fallback";
+function ensureEnvironmentImportsEntryFallback({ environments }) {
+	for (const [name, config] of Object.entries(environments)) {
+		if (name === "client") continue;
+		const input = normalizeRollupOpitonsInput(config.build?.rollupOptions?.input);
+		if (Object.keys(input).length === 0) {
+			config.build = config.build || {};
+			config.build.rollupOptions = config.build.rollupOptions || {};
+			config.build.rollupOptions.input = { __vite_rsc_env_imports_entry_fallback: ENV_IMPORTS_ENTRY_FALLBACK };
+		}
+	}
+}
+function vitePluginImportEnvironment(manager) {
+	return [{
+		name: "rsc:import-environment",
+		resolveId: {
+			filter: { id: exactRegex(ENV_IMPORTS_MANIFEST_PLACEHOLDER) },
+			handler(source) {
+				if (source === ENV_IMPORTS_MANIFEST_PLACEHOLDER) return {
+					id: ENV_IMPORTS_MANIFEST_PLACEHOLDER,
+					external: true
+				};
+			}
+		},
+		buildStart() {
+			if (this.environment.mode !== "build") return;
+			const emitted = /* @__PURE__ */ new Set();
+			for (const byTargetEnv of Object.values(manager.environmentImportMetaMap)) {
+				const imports = byTargetEnv[this.environment.name];
+				if (!imports) continue;
+				for (const meta of Object.values(imports)) if (!emitted.has(meta.resolvedId)) {
+					emitted.add(meta.resolvedId);
+					this.emitFile({
+						type: "chunk",
+						id: meta.resolvedId
+					});
+				}
+			}
+		},
+		transform: {
+			filter: { code: "import.meta.viteRsc.import" },
+			async handler(code, id) {
+				if (!code.includes("import.meta.viteRsc.import")) return;
+				const { server } = manager;
+				const s = new MagicString(code);
+				for (const match of stripLiteral(code).matchAll(/import\.meta\.viteRsc\.import\s*(<[\s\S]*?>)?\s*\(([\s\S]*?)\)/dg)) {
+					const [argStart, argEnd] = match.indices[2];
+					const [specifier, options] = evalValue(`[${code.slice(argStart, argEnd).trim()}]`);
+					const environmentName = options.environment;
+					let resolvedId;
+					if (this.environment.mode === "dev") {
+						const targetEnv = server.environments[environmentName];
+						assert(targetEnv, `[vite-rsc] unknown environment '${environmentName}'`);
+						const resolved = await targetEnv.pluginContainer.resolveId(specifier, id);
+						assert(resolved, `[vite-rsc] failed to resolve '${specifier}' in environment '${environmentName}'`);
+						resolvedId = resolved.id;
+					} else {
+						const targetEnvConfig = manager.config.environments[environmentName];
+						assert(targetEnvConfig, `[vite-rsc] unknown environment '${environmentName}'`);
+						const resolved = await this.resolve(specifier, id);
+						assert(resolved, `[vite-rsc] failed to resolve '${specifier}' in environment '${environmentName}'`);
+						resolvedId = resolved.id;
+					}
+					const sourceEnv = this.environment.name;
+					const targetEnv = environmentName;
+					manager.environmentImportMetaMap[sourceEnv] ??= {};
+					manager.environmentImportMetaMap[sourceEnv][targetEnv] ??= {};
+					manager.environmentImportMetaMap[sourceEnv][targetEnv][resolvedId] = {
+						resolvedId,
+						targetEnv,
+						sourceEnv,
+						specifier
+					};
+					let replacement;
+					if (this.environment.mode === "dev") replacement = `globalThis.__VITE_ENVIRONMENT_RUNNER_IMPORT__(${JSON.stringify(environmentName)}, ${JSON.stringify(resolvedId)})`;
+					else {
+						const relativeId = manager.toRelativeId(resolvedId);
+						replacement = `(await import(${JSON.stringify(ENV_IMPORTS_MANIFEST_PLACEHOLDER)})).default[${JSON.stringify(relativeId)}]()`;
+					}
+					const [start, end] = match.indices[0];
+					s.overwrite(start, end, replacement);
+				}
+				if (s.hasChanged()) return {
+					code: s.toString(),
+					map: s.generateMap({ hires: "boundary" })
+				};
+			}
+		},
+		renderChunk(code, chunk) {
+			if (code.includes(ENV_IMPORTS_MANIFEST_PLACEHOLDER)) {
+				const replacement = normalizeRelativePath(path.relative(path.join(chunk.fileName, ".."), ENV_IMPORTS_MANIFEST_NAME));
+				code = code.replaceAll(ENV_IMPORTS_MANIFEST_PLACEHOLDER, () => replacement);
+				return { code };
+			}
+		}
+	}, createVirtualPlugin(ENV_IMPORTS_ENTRY_FALLBACK.slice(8), () => {
+		return `export default "__vite_rsc_env_imports_entry_fallback";`;
+	})];
+}
+function writeEnvironmentImportsManifest(manager) {
+	if (Object.keys(manager.environmentImportMetaMap).length === 0) return;
+	for (const [sourceEnv, byTargetEnv] of Object.entries(manager.environmentImportMetaMap)) {
+		const sourceOutDir = manager.config.environments[sourceEnv].build.outDir;
+		const manifestPath = path.join(sourceOutDir, ENV_IMPORTS_MANIFEST_NAME);
+		let code = "export default {\n";
+		for (const [_targetEnv, imports] of Object.entries(byTargetEnv)) for (const [resolvedId, meta] of Object.entries(imports)) {
+			const bundle = manager.bundles[meta.targetEnv];
+			if (!bundle) throw new Error(`[vite-rsc] missing bundle for environment import: ${meta.targetEnv}`);
+			const chunk = Object.values(bundle).find((c) => c.type === "chunk" && c.facadeModuleId === resolvedId);
+			if (!chunk) throw new Error(`[vite-rsc] missing output for environment import: ${resolvedId}`);
+			const targetOutDir = manager.config.environments[meta.targetEnv].build.outDir;
+			const relativePath = normalizeRelativePath(path.relative(sourceOutDir, path.join(targetOutDir, chunk.fileName)));
+			const relativeId = manager.toRelativeId(resolvedId);
+			code += `  ${JSON.stringify(relativeId)}: () => import(${JSON.stringify(relativePath)}),\n`;
+		}
+		code += "}\n";
+		fs.writeFileSync(manifestPath, code);
+	}
+}
+
+//#endregion
+//#region src/plugins/resolved-id-proxy.ts
+const RESOLVED_ID_PROXY_PREFIX = "virtual:vite-rsc/resolved-id/";
+function toResolvedIdProxy(resolvedId) {
+	return RESOLVED_ID_PROXY_PREFIX + encodeURIComponent(resolvedId);
+}
+function withResolvedIdProxy(resolvedId) {
+	return resolvedId.startsWith("\0") ? toResolvedIdProxy(resolvedId) : resolvedId;
+}
+function fromResolvedIdProxy(source) {
+	if (!source.startsWith(RESOLVED_ID_PROXY_PREFIX)) return;
+	const clean = source.split("?")[0];
+	return decodeURIComponent(clean.slice(29));
+}
+/**
+* Vite plugin that resolves proxy import specifiers to the original resolved IDs.
+*/
+function vitePluginResolvedIdProxy() {
+	return {
+		name: "rsc:resolved-id-proxy",
+		resolveId: {
+			filter: { id: prefixRegex(RESOLVED_ID_PROXY_PREFIX) },
+			handler(source) {
+				const originalId = fromResolvedIdProxy(source);
+				if (originalId !== void 0) return originalId;
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/plugins/scan.ts
+function scanBuildStripPlugin({ manager }) {
+	return {
+		name: "rsc:scan-strip",
+		apply: "build",
+		enforce: "post",
+		transform: {
+			filter: { id: { exclude: exactRegex("\0rolldown/runtime.js") } },
+			async handler(code, _id, _options) {
+				if (!manager.isScanBuild) return;
+				return {
+					code: await transformScanBuildStrip(code),
+					map: { mappings: "" }
+				};
+			}
+		}
+	};
+}
+const importGlobRE = /\bimport\.meta\.glob(?:<\w+>)?\s*\(/g;
+async function transformScanBuildStrip(code) {
+	const [imports] = esModuleLexer.parse(code);
+	let output = imports.map((e) => e.n && `import ${JSON.stringify(e.n)};\n`).filter(Boolean).join("");
+	if (importGlobRE.test(code)) {
+		walk(await parseAstAsync(code), { enter(node) {
+			if (node.type === "CallExpression" && node.callee.type === "MemberExpression" && node.callee.object.type === "MetaProperty" && node.callee.object.meta.type === "Identifier" && node.callee.object.meta.name === "import" && node.callee.object.property.type === "Identifier" && node.callee.object.property.name === "meta" && node.callee.property.type === "Identifier" && node.callee.property.name === "glob") {
+				const importMetaGlob = code.slice(node.start, node.end);
+				output += `console.log(${importMetaGlob});\n`;
+			}
+		} });
+		output += "";
+	}
+	return output;
+}
+
+//#endregion
+//#region src/plugins/validate-import.ts
+function validateImportPlugin() {
+	return {
+		name: "rsc:validate-imports",
+		resolveId: {
+			order: "pre",
+			filter: { id: /^(client-only|server-only)$/ },
+			async handler(source, _importer, options) {
+				if ("scan" in options && options.scan) return;
+				if (source === "client-only" || source === "server-only") {
+					if (source === "client-only" && this.environment.name === "rsc" || source === "server-only" && this.environment.name !== "rsc") return {
+						id: `\0virtual:vite-rsc/validate-imports/invalid/${source}`,
+						moduleSideEffects: true
+					};
+					return {
+						id: `\0virtual:vite-rsc/validate-imports/valid/${source}`,
+						moduleSideEffects: false
+					};
+				}
+			}
+		},
+		load: {
+			filter: { id: prefixRegex("\0virtual:vite-rsc/validate-imports/") },
+			handler(id) {
+				if (id.startsWith("\0virtual:vite-rsc/validate-imports/invalid/")) return `throw new Error("invalid import of '${id.slice(id.lastIndexOf("/") + 1)}'")`;
+				if (id.startsWith("\0virtual:vite-rsc/validate-imports/")) return `export {}`;
+			}
+		},
+		transform: {
+			order: "post",
+			filter: { id: prefixRegex("\0virtual:vite-rsc/validate-imports/invalid/") },
+			async handler(_code, id) {
+				if (this.environment.mode === "dev") {
+					if (id.startsWith(`\0virtual:vite-rsc/validate-imports/invalid/`)) validateImportChain(getImportChainDev(this.environment, id), this.environment.name, this.environment.config.root);
+				}
+			}
+		},
+		buildEnd() {
+			if (this.environment.mode === "build") {
+				validateImportChain(getImportChainBuild(this, "\0virtual:vite-rsc/validate-imports/invalid/server-only"), this.environment.name, this.environment.config.root);
+				validateImportChain(getImportChainBuild(this, "\0virtual:vite-rsc/validate-imports/invalid/client-only"), this.environment.name, this.environment.config.root);
+			}
+		}
+	};
+}
+function getImportChainDev(environment, id) {
+	const chain = [];
+	const recurse = (id) => {
+		if (chain.includes(id)) return;
+		const info = environment.moduleGraph.getModuleById(id);
+		if (!info) return;
+		chain.push(id);
+		const next = [...info.importers][0];
+		if (next && next.id) recurse(next.id);
+	};
+	recurse(id);
+	return chain;
+}
+function getImportChainBuild(ctx, id) {
+	const chain = [];
+	const recurse = (id) => {
+		if (chain.includes(id)) return;
+		const info = ctx.getModuleInfo(id);
+		if (!info) return;
+		chain.push(id);
+		const next = info.importers[0];
+		if (next) recurse(next);
+	};
+	recurse(id);
+	return chain;
+}
+function validateImportChain(chain, environmentName, root) {
+	if (chain.length === 0) return;
+	const id = chain[0];
+	const source = id.slice(id.lastIndexOf("/") + 1);
+	let result = `'${source}' cannot be imported in ${source === "server-only" ? "client" : "server"} build ('${environmentName}' environment):\n`;
+	result += chain.slice(1, 6).map((id, i) => " ".repeat(i + 1) + `imported by ${path.relative(root, id).replaceAll("\0", "")}\n`).join("");
+	if (chain.length > 6) result += " ".repeat(7) + "...\n";
+	const error = new Error(result);
+	if (chain[1]) Object.assign(error, { id: chain[1] });
+	throw error;
+}
+
+//#endregion
+export { cleanUrl as _, ensureEnvironmentImportsEntryFallback as a, normalizeViteImportAnalysisUrl as b, createVirtualPlugin as c, getFetchHandlerExport as d, hashString as f, vitePluginFindSourceMapURL as g, withRollupError as h, withResolvedIdProxy as i, getEntrySource as l, sortObject as m, scanBuildStripPlugin as n, vitePluginImportEnvironment as o, normalizeRelativePath as p, vitePluginResolvedIdProxy as r, writeEnvironmentImportsManifest as s, validateImportPlugin as t, getFallbackRollupEntry as u, directRequestRE as v, prepareError as x, evalValue as y };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vitejs/plugin-rsc",
-  "version": "0.5.18",
+  "version": "0.5.20",
   "description": "React Server Components (RSC) support for Vite.",
   "keywords": [
     "react",
@@ -39,23 +39,23 @@
     "prepack": "tsdown"
   },
   "dependencies": {
-    "@rolldown/pluginutils": "1.0.0-rc.2",
+    "@rolldown/pluginutils": "1.0.0-rc.4",
     "es-module-lexer": "^2.0.0",
     "estree-walker": "^3.0.3",
     "magic-string": "^0.30.21",
     "periscopic": "^4.0.2",
-    "srvx": "^0.10.1",
+    "srvx": "^0.11.4",
     "strip-literal": "^3.1.0",
     "turbo-stream": "^3.1.0",
     "vitefu": "^1.1.1"
   },
   "devDependencies": {
     "@hiogawa/utils": "^1.7.0",
-    "@playwright/test": "^1.58.1",
+    "@playwright/test": "^1.58.2",
     "@tsconfig/strictest": "^2.0.8",
     "@types/estree": "^1.0.8",
-    "@types/node": "^24.10.9",
-    "@types/react": "^19.2.10",
+    "@types/node": "^24.10.13",
+    "@types/react": "^19.2.14",
     "@types/react-dom": "^19.2.3",
     "@vitejs/plugin-react": "workspace:*",
     "@vitejs/test-dep-cjs-and-esm": "./test-dep/cjs-and-esm",
@@ -65,7 +65,7 @@
     "react-dom": "^19.2.4",
     "react-server-dom-webpack": "^19.2.4",
     "tinyexec": "^1.0.2",
-    "tsdown": "^0.20.1"
+    "tsdown": "^0.20.3"
   },
   "peerDependencies": {
     "react": "*",

package/dist/browser-s-WcB8A7.d.ts

@@ -1,6 +0,0 @@
-//#region src/core/browser.d.ts
-declare function setRequireModule(options: {
-  load: (id: string) => Promise<unknown>;
-}): void;
-//#endregion
-export { setRequireModule as t };

package/dist/plugin-BGmSmdwL.js

@@ -1,27 +0,0 @@
-//#region src/core/plugin.ts
-function vitePluginRscCore() {
-	return [{
-		name: "rsc:patch-react-server-dom-webpack",
-		transform: {
-			filter: { code: "__webpack_require__" },
-			handler(originalCode, _id, _options) {
-				let code = originalCode;
-				if (code.includes("__webpack_require__.u")) code = code.replaceAll("__webpack_require__.u", "({}).u");
-				if (code.includes("__webpack_require__")) code = code.replaceAll("__webpack_require__", "__vite_rsc_require__");
-				if (code !== originalCode) return {
-					code,
-					map: null
-				};
-			}
-		}
-	}, {
-		name: "rsc:workaround-linked-dep",
-		apply: () => !import.meta.url.includes("/node_modules/"),
-		configEnvironment() {
-			return { build: { commonjsOptions: { include: [/\/node_modules\//, /\/vendor\/react-server-dom\//] } } };
-		}
-	}];
-}
-
-//#endregion
-export { vitePluginRscCore as t };