@vrowzer/vite-plugin 0.0.0 → 0.1.0

package/dist/ide/{tsMode-BKTkt1bt.js → tsMode-D6r_-_rM.js}

@@ -1,6 +1,6 @@
-import { a as e, c as t, i as n, n as r, o as i, r as a } from "./toggleHighContrast-DI4ZeqFk.js";
-import { t as o } from "./monaco.contribution-DVj8eGe_.js";
-import { t as s } from "./workers-IG_hD8Jy.js";
+import { a as e, c as t, i as n, n as r, o as i, r as a } from "./toggleHighContrast-DzGcs4Kw.js";
+import { t as o } from "./monaco.contribution-4V6BrQ5P.js";
+import { t as s } from "./workers-DRkYqOHL.js";
 //#region ../../node_modules/.pnpm/monaco-editor@0.55.1/node_modules/monaco-editor/esm/vs/language/typescript/workerManager.js
 var c = class {
 	constructor(e, t) {
@@ -22,7 +22,7 @@ var c = class {
 			moduleId: "vs/language/typescript/tsWorker",
 			createWorker: () => new Worker(new URL(
 				/* @vite-ignore */
-				"/assets/ts.worker-BFpNHPy5.js",
+				"/assets/ts.worker-CEDDf2SQ.js",
 				"" + import.meta.url
 			), { type: "module" }),
 			label: this._modeId,
@@ -75,7 +75,7 @@ var f = class {
 		this._worker = e, this._libFiles = {}, this._hasFetchedLibFiles = !1, this._fetchLibFilesPromise = null;
 	}
 	isLibFile(e) {
-		return e && e.path.indexOf("/lib.") === 0 ? !!l[e.path.slice(1)] : !1;
+		return e ? e.path.indexOf("/lib.") === 0 && !!l[e.path.slice(1)] : !1;
 	}
 	getOrCreateModel(t) {
 		let n = e.parse(t), r = i.getModel(n);

package/dist/ide/{typescript-CHC4VYBW.js → typescript-DM2pFj0X.js}

@@ -1,4 +1,4 @@
-import { c as e } from "./toggleHighContrast-DI4ZeqFk.js";
+import { c as e } from "./toggleHighContrast-DzGcs4Kw.js";
 //#region ../../node_modules/.pnpm/monaco-editor@0.55.1/node_modules/monaco-editor/esm/vs/basic-languages/typescript/typescript.js
 var t = {
 	wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,

package/dist/ide/{workers-IG_hD8Jy.js → workers-DRkYqOHL.js}

@@ -1,4 +1,4 @@
-import { o as e } from "./toggleHighContrast-DI4ZeqFk.js";
+import { o as e } from "./toggleHighContrast-DzGcs4Kw.js";
 //#region ../../node_modules/.pnpm/monaco-editor@0.55.1/node_modules/monaco-editor/esm/vs/common/workers.js
 function t(e, t) {
 	let n = globalThis.MonacoEnvironment;

package/dist/ide/{xml-C0QFzMaz.js → xml-DrNRTdma.js}

@@ -1,4 +1,4 @@
-import { c as e } from "./toggleHighContrast-DI4ZeqFk.js";
+import { c as e } from "./toggleHighContrast-DzGcs4Kw.js";
 //#region ../../node_modules/.pnpm/monaco-editor@0.55.1/node_modules/monaco-editor/esm/vs/basic-languages/xml/xml.js
 var t = {
 	comments: { blockComment: ["<!--", "-->"] },
@@ -32,11 +32,11 @@ var t = {
 		}
 	],
 	onEnterRules: [{
-		beforeText: RegExp("<([_:\\w][_:\\w-.\\d]*)([^/>]*(?!/)>)[^<]*$", "i"),
+		beforeText: /* @__PURE__ */ RegExp("<([_:\\w][_:\\w-.\\d]*)([^/>]*(?!/)>)[^<]*$", "i"),
 		afterText: /^<\/([_:\w][_:\w-.\d]*)\s*>$/i,
 		action: { indentAction: e.IndentAction.IndentOutdent }
 	}, {
-		beforeText: RegExp("<(\\w[\\w\\d]*)([^/>]*(?!/)>)[^<]*$", "i"),
+		beforeText: /* @__PURE__ */ RegExp("<(\\w[\\w\\d]*)([^/>]*(?!/)>)[^<]*$", "i"),
 		action: { indentAction: e.IndentAction.Indent }
 	}]
 }, n = {

package/dist/ide/{yaml-o-RP7lYY.js → yaml-ck2FlP6B.js}

@@ -1,4 +1,4 @@
-import { c as e } from "./toggleHighContrast-DI4ZeqFk.js";
+import { c as e } from "./toggleHighContrast-DzGcs4Kw.js";
 //#region ../../node_modules/.pnpm/monaco-editor@0.55.1/node_modules/monaco-editor/esm/vs/basic-languages/yaml/yaml.js
 var t = {
 	comments: { lineComment: "#" },

package/dist/index.d.mts

@@ -1,8 +1,6 @@
 import { GenerateManifestLog, GenerateManifestOptions, ManifestResult, generateManifest } from "./manifest-generate.mjs";
 import { Plugin } from "vite";
-
 //#region src/options.d.ts
-
 /**
  * vite-plugin-vrowzer options
  *

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/options.ts","../src/manifest.ts","../src/index.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AAaA;AAKiB,UALA,KAAA,CAKA;EAwBA,IAAA,EAAA,MAAA,GA5BA,MA4BiB;EAQjB,WAAA,EAAA,MAAA;AAqBjB;AAkBa,UAvEI,sBAAA,CAuEJ;EAuCS;;;;;;ACxFtB;;;;ECRgB;;;;;;;;;;;;UFUC,iBAAA;;;;;;;UAQA,0BAAA;;;;;;;;;kBASC;;;;;;;;;;;UAYD,cAAA;;;;;;;;;;;;;;;;;;aAkBJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAuCS;;;;;iBAIL;;;;AAA0B,iBC5F3B,eAAA,CAAA,CD4F2B,EC5FR,MD4FQ;;;AAlF1B,iBElBD,OAAA,CFkBC,OASC,CATyB,EElBV,cF2Bf,CAAA,EE3BqC,MF2BpB,EAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/options.ts","../src/manifest.ts","../src/index.ts"],"mappings":";;;;;;;;UAaiB;EACf,eAAe;EACf;;UAGe;;;;;;;;;;EAUf;;;;;EAKA;;;;;;EAMA;;UAGe;;;;;EAKf;;UAGe;;;;;;;;;EASf,gBAAgB;;;;;;;;;EAShB;;UAGe;;;;;;;;;;;;;;EAcf;;;;EAIA,WAAW;;;;;;EAMX;;;;;;EAMA;;;;;;EAMA;;;;;;;;;;;;EAYA;;;;;;;;;EASA;IAAY,QAAQ;;;;;EAIpB,eAAe;;;;iBC5FD,mBAAmB;;;iBCJnB,QAAQ,UAAS,iBAAsB"}

package/dist/index.mjs

@@ -3,17 +3,15 @@ import { createRequire } from "node:module";
 import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
 import path, { dirname, extname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import inject from "@rollup/plugin-inject";
+import * as injectModule from "@rollup/plugin-inject";
 import ServiceWorker from "@vrowzer/unplugin-service-worker/vite";
 import { createDebug } from "obug";
-import { minifySync, parseSync } from "rolldown/experimental";
+import { minifySync, parseSync } from "rolldown/utils";
 import { rolldown } from "rolldown";
 import { createBirpc } from "birpc";
 import { WebSocketServer } from "ws";
-
-//#region rolldown:runtime
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-
+//#region \0rolldown/runtime.js
+var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
 //#endregion
 //#region src/auto-manifest.ts
 /**
@@ -32,7 +30,7 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 */
 const debug$8 = createDebug("vite-plugin-vrowzer:auto-manifest");
 const VIRTUAL_MODULE_ID = "virtual:vrowzer-manifest";
-const RESOLVED_VIRTUAL_MODULE_ID = "\0" + VIRTUAL_MODULE_ID;
+const RESOLVED_VIRTUAL_MODULE_ID = "\0virtual:vrowzer-manifest";
 const CACHE_DIR_NAME = ".vrowzer-manifest";
 const MANIFEST_FILENAME = "manifest.json";
 const HASH_FILENAME = "_hash";
@@ -42,7 +40,7 @@ const LOCKFILE_NAMES = [
 	"yarn.lock",
 	"bun.lock"
 ];
-const MINIFIABLE_EXTENSIONS$1 = new Set([
+const MINIFIABLE_EXTENSIONS$1 = /* @__PURE__ */ new Set([
 	".js",
 	".mjs",
 	".cjs"
@@ -190,7 +188,6 @@ function autoManifestPlugin(manifestOptions) {
 		}
 	};
 }
-
 //#endregion
 //#region src/alias.ts
 /**
@@ -241,7 +238,6 @@ function resolveAliases(extra) {
 	if (extra) Object.assign(aliases, extra);
 	return aliases;
 }
-
 //#endregion
 //#region src/env.ts
 /**
@@ -255,7 +251,7 @@ function resolveAliases(extra) {
 * @license MIT
 */
 const debug$7 = createDebug("vite-plugin-vrowzer:env");
-const picocolorsBrowser = resolve(dirname(createRequire(import.meta.url).resolve("picocolors")), "picocolors.browser.js");
+const picocolorsBrowser = resolve(dirname(fileURLToPath(import.meta.resolve("picocolors"))), "picocolors.browser.js");
 function envPlugin(_options) {
 	return {
 		name: "vrowzer:env",
@@ -291,7 +287,6 @@ function envPlugin(_options) {
 		}
 	};
 }
-
 //#endregion
 //#region src/ide.ts
 /**
@@ -363,12 +358,12 @@ function generateIdeHtml(base, cssFile) {
 </html>`;
 }
 function findAvailablePort(preferredPort) {
-	return new Promise((resolve$1, reject) => {
+	return new Promise((resolve, reject) => {
 		const { createServer } = __require("node:net");
 		const server = createServer();
 		const port = preferredPort ?? 7900;
 		server.listen(port, () => {
-			server.close(() => resolve$1(port));
+			server.close(() => resolve(port));
 		});
 		server.on("error", () => {
 			server.close();
@@ -376,7 +371,7 @@ function findAvailablePort(preferredPort) {
 			next.listen(0, () => {
 				const addr = next.address();
 				const p = typeof addr === "object" && addr ? addr.port : 0;
-				next.close(() => resolve$1(p));
+				next.close(() => resolve(p));
 			});
 			next.on("error", reject);
 		});
@@ -434,8 +429,8 @@ function idePlugin(options) {
 			debug$6("birpc WebSocket server listening on port", rpcPort);
 			wss.on("connection", (ws) => {
 				debug$6("IDE client connected");
-				const rpc = createBirpc({ async writeFile(path$1, content) {
-					const absPath = resolve(sourceDir, path$1.startsWith("/") ? path$1.slice(1) : path$1);
+				const rpc = createBirpc({ async writeFile(path, content) {
+					const absPath = resolve(sourceDir, path.startsWith("/") ? path.slice(1) : path);
 					debug$6("writeFile:", absPath);
 					writeFileSync(absPath, content, "utf-8");
 				} }, {
@@ -490,7 +485,8 @@ function idePlugin(options) {
 					const assetName = url.slice(`${IDE_BASE}/dist/`.length);
 					const assetPath = join(ideDistDir, assetName);
 					if (existsSync(assetPath)) {
-						const mime = MIME_TYPES[extname(assetName)] || "application/octet-stream";
+						const ext = extname(assetName);
+						const mime = MIME_TYPES[ext] || "application/octet-stream";
 						debug$6("serving IDE asset:", assetName);
 						res.writeHead(200, {
 							"Content-Type": mime,
@@ -507,7 +503,6 @@ function idePlugin(options) {
 		}
 	};
 }
-
 //#endregion
 //#region src/extract.ts
 /**
@@ -555,7 +550,7 @@ function isViteImport(source) {
 * 5. Remove Vrowzer() calls
 * 6. Generate Worker config source
 */
-function extractWorkerConfig(source, configPath, _options = {}) {
+function extractWorkerConfig(source, configPath, options = {}) {
 	const unsupported = [];
 	const ast = parseSync(configPath, source).program;
 	const imports = collectImports(ast);
@@ -591,7 +586,6 @@ function extractWorkerConfig(source, configPath, _options = {}) {
 		} else if (expr.type === "ConditionalExpression" || expr.type === "LogicalExpression") unsupported.push(`conditional plugin: ${source.slice(expr.start, expr.end)}`);
 		else unsupported.push(`non-call plugin: ${source.slice(expr.start, expr.end)}`);
 	}
-	if (unsupported.length > 0) debug$5("unsupported patterns", unsupported);
 	const workerPlugins = pluginCalls.filter((p) => {
 		if (!p.importSource) return true;
 		return !isWorkerExcludedImport(p.importSource);
@@ -652,11 +646,123 @@ function extractWorkerConfig(source, configPath, _options = {}) {
 			}
 		}
 	}
+	const forwardedProps = extractForwardedProperties(source, configObj);
+	extractInputProperties(source, configObj, forwardedProps, unsupported);
+	const forwardedServerProps = [];
+	if (options.serverOrigin !== void 0) forwardedServerProps.push(`origin: ${JSON.stringify(options.serverOrigin)}`);
+	if (options.serverForwardConsole !== void 0) forwardedServerProps.push(`forwardConsole: ${JSON.stringify(options.serverForwardConsole)}`);
+	if (forwardedServerProps.length > 0) forwardedProps.set("server", `{ ${forwardedServerProps.join(", ")} }`);
+	if (unsupported.length > 0) debug$5("unsupported patterns", unsupported);
 	return {
-		code: generateWorkerSource(source, ast, imports, workerPlugins, neededImportSources, neededLocalNames),
+		code: generateWorkerSource(source, ast, imports, workerPlugins, neededImportSources, neededLocalNames, forwardedProps),
 		unsupported
 	};
 }
+/**
+* Config properties that should be forwarded to Worker config.
+* These are extracted as raw source code from the config object.
+*/
+const FORWARDED_PROPERTIES = ["define", "html"];
+function extractForwardedProperties(source, configObj) {
+	const props = /* @__PURE__ */ new Map();
+	for (const p of configObj.properties) {
+		if (p.type !== "Property") continue;
+		const key = p.key.type === "Identifier" ? p.key.name : null;
+		if (key && FORWARDED_PROPERTIES.includes(key)) props.set(key, source.slice(p.value.start, p.value.end));
+	}
+	return props;
+}
+function extractInputProperties(source, configObj, forwardedProps, unsupported) {
+	let hasUnknownTopLevelInput = false;
+	for (const property of configObj.properties) if (property.type === "SpreadElement") {
+		unsupported.push(`config spread element: ${source.slice(property.start, property.end)}`);
+		hasUnknownTopLevelInput = true;
+	} else if (property.type === "Property" && property.computed) {
+		unsupported.push(`computed config key: ${source.slice(property.start, property.end)}`);
+		hasUnknownTopLevelInput = true;
+	}
+	if (hasUnknownTopLevelInput) return;
+	const inputProp = findObjectProperty(configObj, "input");
+	if (inputProp) if (isStaticInputOption(inputProp.value)) forwardedProps.set("input", source.slice(inputProp.value.start, inputProp.value.end));
+	else unsupported.push(`input is not an inline string, array, or record: ${source.slice(inputProp.value.start, inputProp.value.end)}`);
+	const environmentsProp = findObjectProperty(configObj, "environments");
+	if (!environmentsProp) return;
+	const environmentsValue = unwrapStaticExpression(environmentsProp.value);
+	if (environmentsValue.type !== "ObjectExpression") {
+		unsupported.push(`environments is not an inline object: ${source.slice(environmentsProp.value.start, environmentsProp.value.end)}`);
+		return;
+	}
+	const entries = [];
+	let hasUnknownEnvironment = false;
+	for (const environmentProp of environmentsValue.properties) {
+		if (environmentProp.type === "SpreadElement") {
+			unsupported.push(`environment spread element: ${source.slice(environmentProp.start, environmentProp.end)}`);
+			hasUnknownEnvironment = true;
+			continue;
+		}
+		if (environmentProp.type !== "Property") continue;
+		const environmentName = getStaticPropertyName(environmentProp);
+		if (environmentName === null) {
+			unsupported.push(`computed environment key: ${source.slice(environmentProp.start, environmentProp.end)}`);
+			hasUnknownEnvironment = true;
+			continue;
+		}
+		const environmentValue = unwrapStaticExpression(environmentProp.value);
+		if (environmentValue.type !== "ObjectExpression") {
+			unsupported.push(`environment ${JSON.stringify(environmentName)} is not an inline object: ${source.slice(environmentProp.value.start, environmentProp.value.end)}`);
+			continue;
+		}
+		let hasUnknownEnvironmentInput = false;
+		for (const property of environmentValue.properties) if (property.type === "SpreadElement") {
+			unsupported.push(`environment ${JSON.stringify(environmentName)} spread element: ${source.slice(property.start, property.end)}`);
+			hasUnknownEnvironmentInput = true;
+		} else if (property.type === "Property" && property.computed) {
+			unsupported.push(`environment ${JSON.stringify(environmentName)} has a computed key: ${source.slice(property.start, property.end)}`);
+			hasUnknownEnvironmentInput = true;
+		}
+		if (hasUnknownEnvironmentInput) continue;
+		const input = findObjectProperty(environmentValue, "input");
+		if (!input) continue;
+		if (!isStaticInputOption(input.value)) {
+			unsupported.push(`environment ${JSON.stringify(environmentName)} input is not an inline string, array, or record: ${source.slice(input.value.start, input.value.end)}`);
+			continue;
+		}
+		entries.push(`${JSON.stringify(environmentName)}: { input: ${source.slice(input.value.start, input.value.end)} }`);
+	}
+	if (entries.length > 0 && !hasUnknownEnvironment) forwardedProps.set("environments", `{ ${entries.join(", ")} }`);
+}
+function findObjectProperty(object, name) {
+	for (let index = object.properties.length - 1; index >= 0; index--) {
+		const property = object.properties[index];
+		if (!property || property.type !== "Property") continue;
+		if (!property.computed && getPropertyName(property) === name) return property;
+	}
+}
+function getStaticPropertyName(property) {
+	if (property.computed) return null;
+	return getPropertyName(property);
+}
+function getPropertyName(property) {
+	if (property.key.type === "Identifier") return property.key.name;
+	if (property.key.type === "Literal" && typeof property.key.value === "string") return property.key.value;
+	return null;
+}
+function unwrapStaticExpression(expression) {
+	let current = expression;
+	while (current.expression && (current.type === "ParenthesizedExpression" || current.type === "TSAsExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSNonNullExpression")) current = current.expression;
+	return current;
+}
+function isStaticInputOption(expression) {
+	const value = unwrapStaticExpression(expression);
+	if (isStaticString(value)) return true;
+	if (value.type === "ArrayExpression") return value.elements.every((element) => element !== null && element.type !== "SpreadElement" && isStaticString(element));
+	if (value.type === "ObjectExpression") return value.properties.every((property) => property.type === "Property" && !property.computed && isStaticString(property.value));
+	return false;
+}
+function isStaticString(expression) {
+	const value = unwrapStaticExpression(expression);
+	return value.type === "Literal" && typeof value.value === "string" || value.type === "TemplateLiteral" && value.expressions.length === 0;
+}
 function collectImports(ast) {
 	const imports = [];
 	for (const node of ast.body) {
@@ -714,7 +820,7 @@ function analyzeCallExpression(call, imports) {
 		hasArgs: call.arguments.length > 0
 	};
 }
-function generateWorkerSource(source, ast, imports, plugins, neededImportSources, neededLocalNames) {
+function generateWorkerSource(source, ast, imports, plugins, neededImportSources, neededLocalNames, forwardedProps = /* @__PURE__ */ new Map()) {
 	const lines = [];
 	const emittedSources = /* @__PURE__ */ new Set();
 	for (const imp of imports) {
@@ -785,14 +891,14 @@ function generateWorkerSource(source, ast, imports, plugins, neededImportSources
 		const callSource = source.slice(plugin.start, plugin.end);
 		lines.push(`    ${callSource},`);
 	}
-	lines.push("  ]");
+	lines.push("  ],");
+	for (const [key, value] of forwardedProps) lines.push(`  ${key}: ${value},`);
 	lines.push("}");
 	return lines.join("\n");
 }
 function generateFallbackCode() {
 	return "export default { plugins: [] }";
 }
-
 //#endregion
 //#region src/options.ts
 /**
@@ -828,7 +934,6 @@ function resolveOptions(options) {
 		resolve: options.resolve
 	};
 }
-
 //#endregion
 //#region src/prebundle.ts
 /**
@@ -1028,7 +1133,6 @@ function inlineCreateRequirePlugin() {
 		}
 	};
 }
-
 //#endregion
 //#region src/rolldown.ts
 /**
@@ -1050,6 +1154,10 @@ function rolldownPlugin(_options) {
 		configResolved(config) {
 			resolvedOutDir = path.resolve(config.root, config.build.outDir);
 		},
+		/**
+		* Copy rolldown WASM binary and sub-worker for production builds.
+		* Both the chunk and WASM/worker files end up in dist/assets/.
+		*/
 		writeBundle() {
 			const assetsDir = path.resolve(resolvedOutDir, "assets");
 			debug$3("copy-rolldown-wasm: assetsDir ", assetsDir);
@@ -1062,7 +1170,6 @@ function rolldownPlugin(_options) {
 		}
 	};
 }
-
 //#endregion
 //#region src/server.ts
 /**
@@ -1115,19 +1222,21 @@ function normalizeBasePath(basePath) {
 	if (basePath.endsWith("/")) return basePath.slice(0, -1);
 	else return basePath;
 }
-
 //#endregion
 //#region src/virtual.ts
-function generateWebWorkerEntry(configPath, resolve$1) {
+/**
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
+function generateWebWorkerEntry(configPath, resolve) {
 	return `
 import { initWebWorker } from 'vrowzer/web-worker-core'
 import config from '${configPath}'
 const resolved = config.default ?? config
-${resolve$1 ? `\nconst workerResolve = ${JSON.stringify(resolve$1)}\nObject.assign(resolved, { resolve: workerResolve })` : ""}
+${resolve ? `\nconst workerResolve = ${JSON.stringify(resolve)}\nObject.assign(resolved, { resolve: workerResolve })` : ""}
 initWebWorker(resolved)
 `;
 }
-
 //#endregion
 //#region src/manifest.ts
 /**
@@ -1145,7 +1254,7 @@ initWebWorker(resolved)
 * @author kazuya kawaguchi (a.k.a. kazupon)
 * @license MIT
 */
-const MINIFIABLE_EXTENSIONS = new Set([
+const MINIFIABLE_EXTENSIONS = /* @__PURE__ */ new Set([
 	".js",
 	".mjs",
 	".cjs"
@@ -1187,8 +1296,8 @@ function VrowzerManifest() {
 				for (const [virtualPath, relPath] of Object.entries(files)) try {
 					let content = readFileSync(resolve(manifestDir, relPath), "utf-8");
 					if (minify && MINIFIABLE_EXTENSIONS.has(extname(virtualPath))) {
-						const result$1 = minifySync(virtualPath, content);
-						if (result$1.code) content = result$1.code;
+						const result = minifySync(virtualPath, content);
+						if (result.code) content = result.code;
 					}
 					resolved[virtualPath] = content;
 				} catch (e) {
@@ -1212,7 +1321,6 @@ function VrowzerManifest() {
 		}
 	};
 }
-
 //#endregion
 //#region src/index.ts
 /**
@@ -1225,6 +1333,7 @@ function VrowzerManifest() {
 * @license MIT
 */
 const debug = createDebug("vite-plugin-vrowzer:index");
+const inject = injectModule.default;
 function Vrowzer(options = {}) {
 	const resolvedOptions = resolveOptions(options);
 	const root = process.cwd();
@@ -1238,98 +1347,104 @@ function Vrowzer(options = {}) {
 			map: null
 		};
 	}
-	const plugins = [
-		{
-			name: "vrowzer:config",
-			resolveId(id) {
-				if (id.startsWith("@vrowzer/")) try {
-					return fileURLToPath(import.meta.resolve(id));
-				} catch {}
-			},
-			config() {
-				const workerPlugins = [
-					{
-						name: "vrowzer:worker-resolve",
-						resolveId(id) {
-							if (id.startsWith("@vrowzer/")) try {
-								return fileURLToPath(import.meta.resolve(id));
-							} catch {}
-						}
-					},
-					{
-						name: "vrowzer:worker-process-inject",
-						options(inputOptions) {
-							inputOptions.transform ??= {};
-							inputOptions.transform.inject = {
-								...inputOptions.transform.inject,
-								process: "@vrowzer/node-polyfill/process"
-							};
-						}
-					},
-					{
-						name: "vrowzer:web-worker-config-inject",
-						transform: workerEntryTransform
+	const vrowzerConfigPlugin = {
+		name: "vrowzer:config",
+		resolveId(id) {
+			if (id.startsWith("@vrowzer/")) try {
+				return fileURLToPath(import.meta.resolve(id));
+			} catch {}
+		},
+		config() {
+			const workerPlugins = [
+				{
+					name: "vrowzer:worker-resolve",
+					resolveId(id) {
+						if (id.startsWith("@vrowzer/")) try {
+							return fileURLToPath(import.meta.resolve(id));
+						} catch {}
 					}
-				];
-				return {
-					resolve: { alias: [{
-						find: /^vite$/,
-						replacement: "@vrowzer/vite-dev-server/vite"
-					}] },
-					worker: { plugins: () => workerPlugins }
-				};
-			},
-			async configResolved(config) {
-				isBuild = config.command === "build";
-				const viteConfigPath = config.configFile;
-				if (!viteConfigPath) {
-					debug("no vite.config.ts found, skipping extraction");
-					return;
-				}
-				debug("extracting worker config from:", viteConfigPath);
-				cleanOutputDir(config.root);
-				const configDir = dirname(viteConfigPath);
-				const { code: workerSource, unsupported } = extractWorkerConfig(readFileSync(viteConfigPath, "utf-8"), viteConfigPath);
-				if (unsupported.length > 0) debug("unsupported patterns found:", unsupported);
-				debug("generated worker source:\n", workerSource);
-				bundledConfigPath = await prebundleWorkerConfig({
-					workerSource,
-					root: config.root,
-					configDir
-				});
-				debug("bundled config path:", bundledConfigPath);
-			},
-			closeBundle() {
-				if (isBuild && bundledConfigPath) {
-					cleanOutputDir(root);
-					debug("cleaned up prebundle output after build");
+				},
+				{
+					name: "vrowzer:worker-process-inject",
+					options(inputOptions) {
+						inputOptions.transform ??= {};
+						inputOptions.transform.inject = {
+							...inputOptions.transform.inject,
+							process: "@vrowzer/node-polyfill/process"
+						};
+					}
+				},
+				{
+					name: "vrowzer:web-worker-config-inject",
+					transform: workerEntryTransform
 				}
-			},
-			transform(code, id) {
-				return workerEntryTransform(code, id);
+			];
+			return {
+				resolve: { alias: [{
+					find: /^vite$/,
+					replacement: "@vrowzer/vite-dev-server/vite"
+				}] },
+				worker: { plugins: () => workerPlugins }
+			};
+		},
+		async configResolved(config) {
+			isBuild = config.command === "build";
+			const viteConfigPath = config.configFile;
+			if (!viteConfigPath) {
+				debug("no vite.config.ts found, skipping extraction");
+				return;
 			}
+			debug("extracting worker config from:", viteConfigPath);
+			cleanOutputDir(config.root);
+			const configDir = dirname(viteConfigPath);
+			const { code: workerSource, unsupported } = extractWorkerConfig(readFileSync(viteConfigPath, "utf-8"), viteConfigPath, {
+				serverOrigin: config.server.origin,
+				serverForwardConsole: config.server.forwardConsole
+			});
+			if (unsupported.length > 0) debug("unsupported patterns found:", unsupported);
+			debug("generated worker source:\n", workerSource);
+			bundledConfigPath = await prebundleWorkerConfig({
+				workerSource,
+				root: config.root,
+				configDir
+			});
+			debug("bundled config path:", bundledConfigPath);
 		},
-		serverMiddlewarePlugin(resolvedOptions),
-		{
-			...inject({
-				process: "@vrowzer/node-polyfill/process",
-				exclude: [/node_modules\/\.vite\//, /node_modules\/\.vrowzer\//]
-			}),
-			apply: "serve"
+		closeBundle() {
+			if (isBuild && bundledConfigPath) {
+				cleanOutputDir(root);
+				debug("cleaned up prebundle output after build");
+			}
 		},
+		transform(code, id) {
+			return workerEntryTransform(code, id);
+		}
+	};
+	const processInjectPlugin = {
+		...inject({
+			process: "@vrowzer/node-polyfill/process",
+			exclude: [/node_modules\/\.vite\//, /node_modules\/\.vrowzer\//]
+		}),
+		apply: "serve"
+	};
+	const serviceWorkerPlugin = ServiceWorker({
+		serviceWorkerAllowed: "/",
+		format: "esm",
+		...resolvedOptions.serviceWorkerEntry ? { entry: resolvedOptions.serviceWorkerEntry } : {}
+	});
+	const plugins = [
+		vrowzerConfigPlugin,
+		serverMiddlewarePlugin(resolvedOptions),
+		processInjectPlugin,
 		envPlugin(resolvedOptions),
 		rolldownPlugin(resolvedOptions),
-		ServiceWorker({
-			serviceWorkerAllowed: "/",
-			format: "esm",
-			...resolvedOptions.serviceWorkerEntry ? { entry: resolvedOptions.serviceWorkerEntry } : {}
-		})
+		serviceWorkerPlugin
 	];
 	if (resolvedOptions.auto) plugins.unshift(autoManifestPlugin(resolvedOptions.manifest));
 	if (resolvedOptions.ide.enabled) plugins.push(idePlugin(resolvedOptions));
 	return plugins;
 }
-
 //#endregion
 export { Vrowzer, VrowzerManifest, generateManifest };
+
 //# sourceMappingURL=index.mjs.map