vite-userscript-plugin 1.11.0 → 2.1.0

package/dist/index.js

@@ -1,295 +1,1045 @@
-// src/index.ts
-import { readFileSync, writeFileSync } from "node:fs";
-import { createServer } from "node:http";
-import { resolve } from "node:path";
-import getPort from "get-port";
+import { basename, posix, relative, resolve, sep } from "node:path";
+import { build } from "vite";
+import { Buffer } from "node:buffer";
+import { pathToFileURL } from "node:url";
+import { existsSync } from "node:fs";
+import { styleText } from "node:util";
 import openLink from "open";
-import colors from "picocolors";
-import serveHandler from "serve-handler";
-import { createLogger } from "vite";
-import { server } from "websocket";
-
-// src/banner.ts
-var Banner = class {
-  constructor(config) {
-    this.config = config;
-    this.addHomepageMeta();
-    this.maxKeyLength = Math.max(...Object.keys(this.config).map((key) => key.length)) + 1;
-  }
-  header = [];
-  maxKeyLength;
-  addHomepageMeta() {
-    const homePage = this.config.homepage ?? this.config.homepageURL;
-    if (homePage) {
-      this.config.updateURL = new URL(
-        `${this.config.name}.meta.js`,
-        homePage
-      ).href;
-      this.config.downloadURL = new URL(
-        `${this.config.name}.user.js`,
-        homePage
-      ).href;
-    }
-  }
-  addSpaces(str) {
-    return " ".repeat(this.maxKeyLength - str.length);
-  }
-  addMetadata(key, value) {
-    value = Array.isArray(value) ? value.join(" ") : value === true ? "" : value;
-    this.header.push(`// @${key}${this.addSpaces(key)}${value}`);
-  }
-  generate() {
-    for (const [key, value] of Object.entries(this.config)) {
-      if (Array.isArray(value)) {
-        value.forEach((value2) => this.addMetadata(key, value2));
-      } else {
-        if (value === void 0) continue;
-        this.addMetadata(key, value);
-      }
-    }
-    return [
-      "// ==UserScript==",
-      ...this.header,
-      "// ==/UserScript=="
-    ].join("\n");
-  }
+//#region src/names.ts
+function sanitizeFileName(name) {
+	return name.replace(/[<>:"/\\|?*\u0000-\u001F]+/g, "-").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "") || "userscript";
+}
+function toIdentifier(name) {
+	let id = name.replace(/[^\w$]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "");
+	if (/^\d/.test(id)) id = `_${id}`;
+	return id || "userscript";
+}
+//#endregion
+//#region src/header.ts
+function ensureTrailingSlash(url) {
+	return url.endsWith("/") ? url : `${url}/`;
+}
+function resolveHomePage(header) {
+	const homePage = header.homepage ?? header.homepageURL ?? header.website ?? header.source;
+	if (typeof homePage !== "string") return;
+	const trimmed = homePage.trim();
+	return trimmed === "" ? void 0 : trimmed;
+}
+function resolvePublicFileUrl(header, fileName) {
+	const homePage = resolveHomePage(header);
+	if (!homePage) return;
+	try {
+		return new URL(fileName, ensureTrailingSlash(homePage)).href;
+	} catch {}
+}
+function applyAutoMetaUrls(header, fileName) {
+	const updateURL = header.updateURL ?? resolvePublicFileUrl(header, `${fileName}.meta.js`);
+	const downloadURL = header.downloadURL ?? resolvePublicFileUrl(header, `${fileName}.user.js`);
+	if (!updateURL && !downloadURL) return header;
+	return {
+		...header,
+		...updateURL ? { updateURL } : {},
+		...downloadURL ? { downloadURL } : {}
+	};
+}
+function sanitizeMetaText(text) {
+	return text.replace(/[\r\n\u2028\u2029]+/g, " ");
+}
+function formatValue(value) {
+	if (Array.isArray(value)) return sanitizeMetaText(value.join(" "));
+	if (value === true) return "";
+	if (typeof value === "object") return;
+	return sanitizeMetaText(String(value));
+}
+function generateHeader(config, options = {}) {
+	const fileName = options.fileName ?? sanitizeFileName(config.name);
+	const header = options.autoMetaUrls ? applyAutoMetaUrls({ ...config }, fileName) : { ...config };
+	const keys = Object.keys(header).filter((key) => {
+		const value = header[key];
+		return value !== void 0 && value !== null && value !== false;
+	});
+	const align = options.align;
+	const maxKeyLength = align === false ? 0 : Math.max(...keys.map((key) => key.length), 0) + (align ?? 1);
+	const pad = (key) => {
+		if (align === false) return " ";
+		return " ".repeat(Math.max(1, maxKeyLength - key.length));
+	};
+	const lines = [];
+	const addMetadata = (key, value) => {
+		const formatted = formatValue(value);
+		if (formatted === void 0) return;
+		const safeKey = key.replace(/[\r\n\u2028\u2029]+/g, "");
+		if (!safeKey) return;
+		lines.push(`// @${safeKey}${pad(key)}${formatted}`);
+	};
+	for (const key of keys) {
+		const value = header[key];
+		if (Array.isArray(value)) value.forEach((item) => addMetadata(key, item));
+		else addMetadata(key, value);
+	}
+	const userscript = [
+		"// ==UserScript==",
+		...lines,
+		"// ==/UserScript=="
+	].join("\n");
+	if (!options.generate) return userscript;
+	return options.generate({
+		userscript,
+		mode: options.mode ?? "build"
+	});
+}
+var Header = class {
+	config;
+	options;
+	constructor(config, options = {}) {
+		this.config = config;
+		this.options = options;
+	}
+	generate() {
+		return generateHeader(this.config, this.options);
+	}
 };
-
-// src/constants.ts
-import { dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-var pluginDir = dirname(fileURLToPath(import.meta.url));
-var pluginName = "vite-userscript-plugin";
-var regexpScripts = new RegExp(/\.(t|j)sx?$/);
-var GM = [
-  "setValue",
-  "getValue",
-  "deleteValue",
-  "listValues",
-  "setClipboard",
-  "addStyle",
-  "addElement",
-  "addValueChangeListener",
-  "removeValueChangeListener",
-  "registerMenuCommand",
-  "unregisterMenuCommand",
-  "download",
-  "getTab",
-  "getTabs",
-  "saveTab",
-  "openInTab",
-  "notification",
-  "getResourceURL",
-  "getResourceText",
-  "xmlhttpRequest",
-  "log",
-  "info"
+//#endregion
+//#region src/grants/catalog.ts
+const GM = [
+	"setValue",
+	"getValue",
+	"deleteValue",
+	"listValues",
+	"setValues",
+	"getValues",
+	"deleteValues",
+	"setClipboard",
+	"addStyle",
+	"addElement",
+	"addValueChangeListener",
+	"removeValueChangeListener",
+	"registerMenuCommand",
+	"unregisterMenuCommand",
+	"download",
+	"getTab",
+	"getTabs",
+	"saveTab",
+	"openInTab",
+	"notification",
+	"getResourceURL",
+	"getResourceText",
+	"xmlhttpRequest",
+	"webRequest",
+	"cookie",
+	"audio",
+	"log",
+	"info"
 ];
-var GMwindow = [
-  "unsafeWindow",
-  "window.onurlchange",
-  "window.focus",
-  "window.close"
+const GMwindow = [
+	"unsafeWindow",
+	"window.onurlchange",
+	"window.focus",
+	"window.close"
 ];
-var grants = GM.map((grant) => [
-  `GM_${grant}`,
-  `GM.${grant}`
-]).flat();
-grants.push(...GMwindow);
-
-// src/helpers.ts
-import { transformWithEsbuild } from "vite";
+const GM_DOT_ALIASES = ["GM.xmlHttpRequest", "GM.getResourceUrl"];
+const grants = [
+	...GM.flatMap((grant) => [`GM_${grant}`, `GM.${grant}`]),
+	...GMwindow,
+	...GM_DOT_ALIASES
+];
+const gmIdentifiers = [
+	"GM",
+	"unsafeWindow",
+	...GM.map((grant) => `GM_${grant}`)
+];
+//#endregion
+//#region src/grants/scan.ts
+const grantMatchers = grants.map((grant) => ({
+	grant,
+	pattern: new RegExp(`\\b${grant.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`)
+}));
 function removeDuplicates(arr) {
-  return [...new Set(Array.isArray(arr) ? arr : arr ? [arr] : [])];
-}
-async function transform({ minify, file, name, loader }, transformOptions) {
-  const { code } = await transformWithEsbuild(file, name, {
-    minify,
-    loader,
-    sourcemap: false,
-    legalComments: "none",
-    ...transformOptions
-  });
-  return code;
+	if (Array.isArray(arr)) return [...new Set(arr)];
+	return arr ? [arr] : [];
 }
 function defineGrants(code) {
-  const definedGrants = [];
-  for (const grant of grants) {
-    if (code.indexOf(grant) !== -1) {
-      definedGrants.push(grant);
-    }
+	return grantMatchers.filter(({ pattern }) => pattern.test(code)).map(({ grant }) => grant);
+}
+//#endregion
+//#region src/grants/policy.ts
+function withServeGrants(header) {
+	if (header.grant === "none") return header;
+	return {
+		...header,
+		grant: [.../* @__PURE__ */ new Set([...header.grant ?? [], ...grants])]
+	};
+}
+function withBuildGrants(header, code, extraGrants = []) {
+	if (header.grant === "none") return header;
+	return {
+		...header,
+		grant: removeDuplicates([
+			...defineGrants(code),
+			...removeDuplicates(header.grant),
+			...extraGrants
+		])
+	};
+}
+//#endregion
+//#region src/sourcemap.ts
+function countHeaderLines(prefix) {
+	if (!prefix) return 0;
+	return prefix.endsWith("\n") ? prefix.slice(0, -1).split("\n").length : prefix.split("\n").length;
+}
+const VLQ_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function encodeVlq(value) {
+	let vlq = value < 0 ? -value << 1 | 1 : value << 1;
+	let encoded = "";
+	do {
+		let digit = vlq & 31;
+		vlq >>>= 5;
+		if (vlq > 0) digit |= 32;
+		encoded += VLQ_ALPHABET[digit];
+	} while (vlq > 0);
+	return encoded;
+}
+function isTokenBoundary(line, index) {
+	if (index === 0) return true;
+	return /\w/.test(line[index] ?? "") !== /\w/.test(line[index - 1] ?? "");
+}
+function identitySourceMap(code, file) {
+	const lineCount = countHeaderLines(code);
+	const sourceLines = code.split("\n");
+	let previousOriginalLine = 0;
+	let previousOriginalColumn = 0;
+	return {
+		version: 3,
+		file,
+		mappings: Array.from({ length: lineCount }, (_, originalLine) => {
+			const line = sourceLines[originalLine] ?? "";
+			let previousGeneratedColumn = 0;
+			const segments = [];
+			const emit = (column) => {
+				segments.push(encodeVlq(column - previousGeneratedColumn) + encodeVlq(0) + encodeVlq(originalLine - previousOriginalLine) + encodeVlq(column - previousOriginalColumn));
+				previousGeneratedColumn = column;
+				previousOriginalLine = originalLine;
+				previousOriginalColumn = column;
+			};
+			emit(0);
+			for (let column = 1; column < line.length; column++) if (isTokenBoundary(line, column)) emit(column);
+			return segments.join(",");
+		}).join(";"),
+		names: [],
+		sources: file ? [file] : []
+	};
+}
+function offsetSourceMap(map, lineOffset, fileName) {
+	if (lineOffset <= 0) return fileName ? {
+		...map,
+		file: fileName
+	} : map;
+	return {
+		...map,
+		file: fileName ?? map.file,
+		mappings: `${";".repeat(lineOffset)}${map.mappings}`
+	};
+}
+function isAppSource(source) {
+	return !source.includes("node_modules") && !source.includes("\0") && !source.startsWith("virtual:");
+}
+function stripVendorSourcesContent(map) {
+	const sources = map.sources ?? [];
+	return {
+		...map,
+		sourcesContent: sources.map((source, index) => isAppSource(source ?? "") ? map.sourcesContent?.[index] ?? null : null)
+	};
+}
+function toInlineSourceMappingUrl(map) {
+	return `data:application/json;charset=utf-8;base64,${Buffer.from(JSON.stringify(map)).toString("base64")}`;
+}
+//#endregion
+//#region src/build/bundle.ts
+function isChunk(item) {
+	return item.type === "chunk";
+}
+function isAsset(item) {
+	return item.type === "asset";
+}
+//#endregion
+//#region src/build/css.ts
+const defaultCssInjector = `(function (css) {
+  if (typeof GM_addStyle === 'function') {
+    GM_addStyle(css)
+  } else {
+    var style = document.createElement('style')
+    style.textContent = css
+    ;(document.head || document.documentElement).appendChild(style)
   }
-  return definedGrants;
+})`;
+function collectImportedCss(chunk, bundle, seen = /* @__PURE__ */ new Set()) {
+	const files = [...chunk.viteMetadata?.importedCss ?? []];
+	for (const imported of chunk.imports) {
+		if (seen.has(imported)) continue;
+		const dep = bundle[imported];
+		if (!dep || !isChunk(dep) || dep.isEntry) continue;
+		seen.add(imported);
+		files.push(...collectImportedCss(dep, bundle, seen));
+	}
+	return files;
 }
+function collectCss(chunk, bundle) {
+	const files = [...new Set(collectImportedCss(chunk, bundle))];
+	if (!files.length) return {
+		css: "",
+		files
+	};
+	return {
+		css: files.map((file) => {
+			const asset = bundle[file];
+			return asset && isAsset(asset) ? String(asset.source) : "";
+		}).filter(Boolean).join("\n"),
+		files
+	};
+}
+function createCssInject(css, cssInject = "auto") {
+	const payload = JSON.stringify(css);
+	if (cssInject === "auto") return `${defaultCssInjector}(${payload});\n`;
+	if (typeof cssInject === "function") return `(${cssInject.toString()})(${payload});\n`;
+	return `(${cssInject})(${payload});\n`;
+}
+//#endregion
+//#region src/build/iife.ts
+const SOURCE_MAPPING_URL_RE = /\/\/[#@]\s*sourceMappingURL=\S+/g;
+function stripSourceMappingUrl(code) {
+	return code.replace(SOURCE_MAPPING_URL_RE, "");
+}
+function stripImports(code) {
+	return code.replace(/(^|\n)import(?:\s+type)?(?:\s+[\s\S]*?\s+|\s+)from\s*["'][^"']+["']\s*;?/g, "$1").replace(/(^|\n)import\s*["'][^"']+["']\s*;?/g, "$1");
+}
+function stripExports(code) {
+	return code.replace(/^export\s+\{[\s\S]*?\}\s+from\s+["'][^"']+["']\s*;?\s*$/gm, "").replace(/^export\s+\*\s+from\s+["'][^"']+["']\s*;?\s*$/gm, "").replace(/^export\s+\{[\s\S]*?\};?\s*$/gm, "").replace(/^export\s+default\s+/gm, "").replace(/^export\s+async\s+function/gm, "async function").replace(/^export\s+function/gm, "function").replace(/^export\s+class/gm, "class").replace(/^export\s+(const|let|var)/gm, "$1");
+}
+function stripModuleSyntax(code) {
+	return stripExports(stripImports(code));
+}
+function isAlreadyIife(code) {
+	return !/^\s*(?:import|export)\s/m.test(code) && /\(\s*(?:async\s+)?function\b/.test(code);
+}
+function ensureIife(code) {
+	const withoutMap = stripSourceMappingUrl(code);
+	if (isAlreadyIife(withoutMap)) return withoutMap.endsWith("\n") ? withoutMap : `${withoutMap}\n`;
+	const stripped = stripModuleSyntax(withoutMap);
+	return `(${/\bawait\b/.test(stripped) ? "async function" : "function"} () {\n${stripped}\n})();\n`;
+}
+//#endregion
+//#region src/build/proxy.ts
+function toFileRequireUrl(absPath) {
+	return pathToFileURL(absPath).href;
+}
+function toRequireList(value) {
+	if (value == null) return [];
+	return Array.isArray(value) ? value.map(String) : [String(value)];
+}
+function createWatchProxyHeader(script, jsAbsPath) {
+	const header = withServeGrants({ ...script.header });
+	return {
+		...header,
+		require: [...toRequireList(header.require), toFileRequireUrl(jsAbsPath)]
+	};
+}
+function generateWatchProxy(script, jsAbsPath) {
+	return generateHeader(createWatchProxyHeader(script, jsAbsPath), {
+		align: script.align,
+		autoMetaUrls: false,
+		fileName: script.fileName,
+		generate: script.generate,
+		mode: "serve"
+	});
+}
+function toProxyFileName(fileName) {
+	return `${fileName}.proxy.user.js`;
+}
+function toRequireFileName(fileName) {
+	return `${fileName}.js`;
+}
+//#endregion
+//#region src/build/apply.ts
+function importedChunkIds(chunk) {
+	return [...chunk.imports, ...chunk.dynamicImports ?? []];
+}
+function inlineImportedChunks(chunk, bundle, seen = /* @__PURE__ */ new Set()) {
+	let prelude = "";
+	for (const imported of chunk.imports) {
+		if (seen.has(imported)) continue;
+		const dep = bundle[imported];
+		if (!dep || !isChunk(dep) || dep.isEntry) continue;
+		seen.add(imported);
+		prelude += inlineImportedChunks(dep, bundle, seen);
+		prelude += dep.code.endsWith("\n") ? dep.code : `${dep.code}\n`;
+	}
+	return prelude;
+}
+function collectImportedChunks(chunk, bundle) {
+	const files = /* @__PURE__ */ new Set();
+	const walk = (current) => {
+		for (const imported of importedChunkIds(current)) {
+			if (files.has(imported)) continue;
+			const dep = bundle[imported];
+			if (!dep || !isChunk(dep) || dep.isEntry) continue;
+			files.add(imported);
+			walk(dep);
+		}
+	};
+	walk(chunk);
+	return files;
+}
+function collectImportedCssFiles(fileNames, bundle) {
+	const files = /* @__PURE__ */ new Set();
+	for (const fileName of fileNames) {
+		const item = bundle[fileName];
+		if (!item || !isChunk(item)) continue;
+		for (const cssFile of item.viteMetadata?.importedCss ?? []) files.add(cssFile);
+	}
+	return files;
+}
+function withSourceMaps(fileNames) {
+	const files = [];
+	for (const fileName of fileNames) files.push(fileName, `${fileName}.map`);
+	return files;
+}
+function findScriptForChunk(chunk, fileName, scripts) {
+	return scripts.find((script) => chunk.name === script.fileName || fileName === `${script.fileName}.js` || fileName === `${script.fileName}.user.js`);
+}
+function deleteBundleFiles(bundle, fileNames) {
+	for (const fileName of fileNames) delete bundle[fileName];
+}
+function applyUserscriptBundle(bundle, config, context) {
+	const { emitFile } = context;
+	const userscriptEntries = [];
+	const otherEntryFiles = [];
+	for (const [fileName, item] of Object.entries(bundle)) {
+		if (!isChunk(item) || !item.isEntry) continue;
+		const script = findScriptForChunk(item, fileName, config.scripts);
+		if (script) userscriptEntries.push({
+			fileName,
+			chunk: item,
+			script
+		});
+		else otherEntryFiles.push(fileName);
+	}
+	const keptChunks = new Set(otherEntryFiles);
+	for (const fileName of otherEntryFiles) {
+		const chunk = bundle[fileName];
+		if (chunk && isChunk(chunk)) for (const dep of collectImportedChunks(chunk, bundle)) keptChunks.add(dep);
+	}
+	const keptCss = collectImportedCssFiles(keptChunks, bundle);
+	const leftoverChunks = [];
+	const leftoverAssets = [];
+	for (const { fileName, chunk, script } of userscriptEntries) {
+		const inlined = stripSourceMappingUrl(inlineImportedChunks(chunk, bundle));
+		const { css, files: cssFiles } = collectCss(chunk, bundle);
+		for (const cssFile of cssFiles) if (!keptCss.has(cssFile)) leftoverAssets.push(...withSourceMaps([cssFile]));
+		const cssPrelude = css ? createCssInject(css, script.cssInject) : "";
+		const body = `${inlined}${chunk.code}`;
+		const wrapped = ensureIife(body);
+		const extraGrants = css && script.cssInject === "auto" ? ["GM_addStyle"] : [];
+		const code = `${cssPrelude}${wrapped}`;
+		const emitFileProxy = Boolean(context.emitProxy && context.outDir && script.server.file);
+		leftoverAssets.push(`${fileName}.map`);
+		if (emitFileProxy) {
+			const requireName = toRequireFileName(script.fileName);
+			let nextCode = code.endsWith("\n") ? code : `${code}\n`;
+			if (chunk.map) {
+				const wrapOffset = isAlreadyIife(stripSourceMappingUrl(body)) ? 0 : 1;
+				const lineOffset = countHeaderLines(cssPrelude) + wrapOffset + countHeaderLines(inlined);
+				chunk.map = stripVendorSourcesContent(offsetSourceMap(chunk.map, lineOffset, requireName));
+				nextCode = `${stripSourceMappingUrl(nextCode).replace(/\n+$/g, "\n")}//# sourceMappingURL=${toInlineSourceMappingUrl(chunk.map)}\n`;
+			}
+			chunk.code = nextCode;
+			chunk.fileName = requireName;
+			emitFile(toProxyFileName(script.fileName), `${generateWatchProxy(script, resolve(context.outDir, requireName))}\n`);
+			continue;
+		}
+		const headerConfig = withBuildGrants(script.header, wrapped, extraGrants);
+		const prefix = `${generateHeader(headerConfig, {
+			align: script.align,
+			autoMetaUrls: script.autoMetaUrls,
+			fileName: script.fileName,
+			generate: script.generate,
+			mode: "build"
+		})}\n\n`;
+		const nextFileName = `${script.fileName}.user.js`;
+		let nextCode = `${prefix}${code}`;
+		if (chunk.map) {
+			const wrapOffset = isAlreadyIife(stripSourceMappingUrl(body)) ? 0 : 1;
+			const lineOffset = countHeaderLines(prefix) + countHeaderLines(cssPrelude) + wrapOffset + countHeaderLines(inlined);
+			chunk.map = stripVendorSourcesContent(offsetSourceMap(chunk.map, lineOffset, nextFileName));
+			nextCode = `${stripSourceMappingUrl(nextCode).replace(/\n+$/g, "\n")}//# sourceMappingURL=${toInlineSourceMappingUrl(chunk.map)}\n`;
+		}
+		chunk.code = nextCode;
+		chunk.fileName = nextFileName;
+		if (script.metaFile) emitFile(`${script.fileName}.meta.js`, generateHeader(headerConfig, {
+			align: script.align,
+			autoMetaUrls: script.autoMetaUrls,
+			fileName: script.fileName,
+			generate: script.generate,
+			mode: "meta"
+		}));
+	}
+	for (const [fileName, item] of Object.entries(bundle)) if (isChunk(item) && !item.isEntry && !keptChunks.has(fileName)) leftoverChunks.push(fileName);
+	leftoverAssets.push(...withSourceMaps(leftoverChunks));
+	deleteBundleFiles(bundle, leftoverChunks);
+	deleteBundleFiles(bundle, leftoverAssets);
+}
+//#endregion
+//#region src/client.ts
+const VIRTUAL_MODULE_ID = "virtual:vite-userscript-plugin";
+const RESOLVED_VIRTUAL_MODULE_ID = `\0${VIRTUAL_MODULE_ID}`;
+function createClientSnapshot(scripts, command) {
+	return scripts.map((script) => {
+		let suffix = ".dev.user.js";
+		if (command === "build") suffix = ".user.js";
+		else if (script.server.file) suffix = ".proxy.user.js";
+		return {
+			name: script.header.name,
+			version: script.header.version,
+			file: `${script.fileName}${suffix}`
+		};
+	});
+}
+function renderVirtualModule(scripts) {
+	return `export const scripts = ${JSON.stringify(scripts)}\n`;
+}
+//#endregion
+//#region src/constants.ts
+const PLUGIN_NAME = "vite-userscript-plugin";
+const FAQ_URL = "https://github.com/greasify/vite-userscript-plugin#faq";
+const GM_NAMESPACE = "__viteUserscriptGM__";
+const VITE_CLIENT_FLAG = "__viteUserscriptViteClient__";
+const REACT_PREAMBLE_PATH = `/${PLUGIN_NAME}/react-preamble.js`;
+const REACT_BOOTSTRAP_PATH = `/${PLUGIN_NAME}/react-bootstrap.js`;
+const REACT_REFRESH_PLUGIN_NAMES = /* @__PURE__ */ new Set(["vite:react-refresh", "vite:react-virtual-preamble"]);
+//#endregion
+//#region src/html.ts
+function isHtmlPath(file) {
+	return /\.html?$/i.test(file.split("?")[0] ?? file);
+}
+function entryNameFromPath(file) {
+	return basename(file.split("?")[0] ?? file).replace(/\.html?$/i, "") || "index";
+}
+function readUserBuildInput(userConfig) {
+	return userConfig.build?.rolldownOptions?.input ?? userConfig.build?.rollupOptions?.input;
+}
+function normalizeInput(input) {
+	if (input == null) return {};
+	if (typeof input === "string") return { [entryNameFromPath(input)]: input };
+	if (Array.isArray(input)) {
+		const result = {};
+		for (const item of input) if (typeof item === "string") result[entryNameFromPath(item)] = item;
+		return result;
+	}
+	if (typeof input === "object") {
+		const result = {};
+		for (const [key, value] of Object.entries(input)) if (typeof value === "string") result[key] = value;
+		return result;
+	}
+	return {};
+}
+function collectHtmlEntries(root, userInput) {
+	const html = {};
+	for (const [key, value] of Object.entries(userInput)) if (isHtmlPath(value)) html[key] = value;
+	if (!Object.values(html).some((value) => basename(value.split("?")[0] ?? value) === "index.html") && existsSync(resolve(root, "index.html"))) html.index = "index.html";
+	return html;
+}
+function mergePluginInput(scripts, userInput, htmlEntries) {
+	const input = {
+		...userInput,
+		...htmlEntries
+	};
+	for (const script of scripts) {
+		const existing = input[script.fileName];
+		if (existing != null && existing !== script.entry) throw new Error(`[${PLUGIN_NAME}] HTML entry "${script.fileName}" collides with userscript fileName "${script.fileName}". Rename the userscript fileName.`);
+		input[script.fileName] = script.entry;
+	}
+	return input;
+}
+function resolvePluginBuildInput(userConfig, scripts) {
+	const root = resolve(userConfig.root ?? process.cwd());
+	const userInput = normalizeInput(readUserBuildInput(userConfig));
+	const htmlEntries = collectHtmlEntries(root, userInput);
+	return {
+		input: mergePluginInput(scripts, userInput, htmlEntries),
+		hasHtml: Object.keys(htmlEntries).length > 0,
+		root
+	};
+}
+//#endregion
+//#region src/resolve.ts
+function isEmptyHeaderField(value) {
+	if (value == null || value === "") return true;
+	return Array.isArray(value) && value.length === 0;
+}
+function assertHeader(header, label) {
+	for (const field of [
+		"name",
+		"version",
+		"match"
+	]) if (isEmptyHeaderField(header[field])) throw new Error(`[${PLUGIN_NAME}] ${label} is missing required header.${field}`);
+}
+function toResolvedScript(config) {
+	if (!config.entry) throw new Error(`[${PLUGIN_NAME}] Provide an "entry" for each userscript`);
+	assertHeader(config.header ?? {}, config.entry);
+	const fileName = sanitizeFileName(config.fileName ?? config.header.name);
+	return {
+		entry: config.entry,
+		fileName,
+		iifeName: toIdentifier(fileName),
+		header: config.header,
+		server: {
+			open: config.server?.open ?? false,
+			prefix: config.server?.prefix ?? "server:",
+			file: config.server?.file ?? false
+		},
+		cssInject: config.cssInject ?? "auto",
+		align: config.align ?? 1,
+		generate: config.generate,
+		autoMetaUrls: config.autoMetaUrls ?? false,
+		metaFile: config.metaFile ?? true
+	};
+}
+function collectAutoMetaUrlsWarnings(config) {
+	const warnings = [];
+	for (const script of config.scripts) {
+		if (!script.autoMetaUrls) continue;
+		if (!script.metaFile) warnings.push(`[${PLUGIN_NAME}] autoMetaUrls is enabled but metaFile is false for "${script.fileName}" — @updateURL points at a .meta.js that will not be emitted`);
+		if (!resolveHomePage(script.header)) warnings.push(`[${PLUGIN_NAME}] autoMetaUrls is enabled but "${script.fileName}" has no homepage, homepageURL, website, or source`);
+	}
+	return warnings;
+}
+function resolvePluginConfig(config) {
+	const items = Array.isArray(config) ? config : [config];
+	if (!items.length) throw new Error(`[${PLUGIN_NAME}] Provide a userscript config or a non-empty array`);
+	const scripts = items.map((item) => toResolvedScript(item));
+	const names = /* @__PURE__ */ new Set();
+	for (const script of scripts) {
+		if (names.has(script.fileName)) throw new Error(`[${PLUGIN_NAME}] Duplicate fileName "${script.fileName}"`);
+		names.add(script.fileName);
+	}
+	return { scripts };
+}
+//#endregion
+//#region src/serve/gm-shim.ts
+function shouldShimModule(id) {
+	const cleanId = id.split("\0").pop() ?? id;
+	if (cleanId.includes("node_modules")) return false;
+	if (/\.(?:css|scss|sass|less|styl|stylus|pcss)(?:$|\?)/i.test(cleanId)) return false;
+	if (/[?&](?:vue|svelte)&type=style/.test(cleanId)) return false;
+	if (/[?&](?:raw|url)(?:&|$)/.test(cleanId)) return false;
+	if (/\.(?:m|c)?[jt]sx?(?:$|\?)/.test(cleanId)) return true;
+	if (/[?&]vue&type=script/.test(cleanId) || cleanId.endsWith(".vue")) return true;
+	if (/[?&]svelte&type=script/.test(cleanId) || cleanId.endsWith(".svelte")) return true;
+	return false;
+}
+function createGmShimPrelude() {
+	return `const { ${gmIdentifiers.join(", ")} } = globalThis.${GM_NAMESPACE} ?? globalThis;\n`;
+}
+function shimModule(code, id) {
+	const prelude = createGmShimPrelude();
+	return {
+		code: `${prelude}${code}`,
+		map: offsetSourceMap(identitySourceMap(code, id), countHeaderLines(prelude))
+	};
+}
+//#endregion
+//#region src/serve/logger.ts
+function formatInstallLine(installUrl) {
+	const coloredUrl = styleText("cyan", installUrl.replace(/:(\d+)\//, (_match, port) => `:${styleText("bold", port)}/`));
+	return `  ${styleText("green", "➜")}  ${styleText("bold", "Userscript")}: ${coloredUrl}`;
+}
+function formatRebuildLine(elapsedMs) {
+	return `${styleText("green", "Userscript rebuilt")} ${styleText("dim", `(${elapsedMs}ms)`)}`;
+}
+function formatFaqHint() {
+	return `${`  ${styleText("green", "➜")}  ${styleText("bold", "FAQ")}: `}${styleText("cyan", FAQ_URL)}\n`;
+}
+function stripAnsi(text) {
+	return text.replace(/\u001B\[[0-9;]*m/g, "");
+}
+function isViteLocalUrlLine(message) {
+	return /Local:\s/.test(stripAnsi(message));
+}
+function createAfterLocalLogger(info, localCount, onAfterLocal) {
+	let remaining = localCount;
+	let printed = false;
+	const flush = () => {
+		if (printed) return;
+		printed = true;
+		onAfterLocal();
+	};
+	return {
+		info: (msg, options) => {
+			info(msg, options);
+			if (remaining > 0 && isViteLocalUrlLine(String(msg))) {
+				remaining -= 1;
+				if (remaining === 0) flush();
+			}
+		},
+		flush
+	};
+}
+//#endregion
+//#region src/serve/react.ts
+function hasReactRefreshPlugin(plugins) {
+	return plugins.some((plugin) => REACT_REFRESH_PLUGIN_NAMES.has(plugin.name));
+}
+function matchReactPreamble(url) {
+	return (url.split("?")[0] ?? "") === REACT_PREAMBLE_PATH;
+}
+function matchReactBootstrap(url) {
+	return (url.split("?")[0] ?? "") === REACT_BOOTSTRAP_PATH;
+}
+function resolveBootstrapEntry(url) {
+	const query = url.includes("?") ? url.slice(url.indexOf("?") + 1) : "";
+	const entry = new URLSearchParams(query).get("entry");
+	if (!entry?.startsWith("/") || entry.startsWith("//")) return;
+	return entry;
+}
+const REACT_PREAMBLE_MODULE = `import { injectIntoGlobalHook } from "/@react-refresh";
+injectIntoGlobalHook(window);
+window.$RefreshReg$ = () => {};
+window.$RefreshSig$ = () => (type) => type;
+window.__vite_plugin_react_preamble_installed__ = true;
+`;
+function createReactBootstrapModule(entryPath) {
+	return `import "/@vite/client";
+import ${JSON.stringify(REACT_PREAMBLE_PATH)};
+import ${JSON.stringify(entryPath)};
+`;
+}
+//#endregion
+//#region src/serve/wrapper.ts
+function matchDevUserscript(url, fileName) {
+	return (url.split("?")[0] ?? "") === `/${fileName}.dev.user.js`;
+}
+function matchProxyUserscript(url, fileName) {
+	return (url.split("?")[0] ?? "") === `/${toProxyFileName(fileName)}`;
+}
+function toInstallUrl(origin, fileName, file = false) {
+	const name = file ? toProxyFileName(fileName) : `${fileName}.dev.user.js`;
+	return `${origin.replace(/\/$/, "")}/${name}`;
+}
+function toServeEntryPath(root, entry) {
+	const absolute = resolve(root, entry);
+	return `/${relative(root, absolute).split(sep).join(posix.sep)}`;
+}
+function applyServeHeader(header, prefix) {
+	return withServeGrants({
+		...header,
+		name: prefix === false ? header.name : `${prefix}${header.name}`
+	});
+}
+function generateDevWrapper(options) {
+	const clientUrl = `${options.origin}/@vite/client`;
+	const entryUrl = `${options.origin}${options.entryPath}`;
+	const bootstrapUrl = `${options.origin}${REACT_BOOTSTRAP_PATH}?entry=${encodeURIComponent(options.entryPath)}`;
+	const copies = gmIdentifiers.map((id) => `if (typeof ${id} !== 'undefined') gm.${id} = ${id};`).join("\n  ");
+	const injectTarget = options.reactPreamble ? bootstrapUrl : entryUrl;
+	const clientInject = options.reactPreamble ? "" : `
+  if (!root.${VITE_CLIENT_FLAG}) {
+    root.${VITE_CLIENT_FLAG} = true;
+    inject(${JSON.stringify(clientUrl)});
+  }`;
+	return `(function () {
+  var root = typeof unsafeWindow !== 'undefined' ? unsafeWindow : window;
+  var gm = root.${GM_NAMESPACE} || {};
+  ${copies}
+  root.${GM_NAMESPACE} = gm;
 
-// src/index.ts
-function UserscriptPlugin(config) {
-  try {
-    let pluginConfig;
-    let isBuildWatch;
-    let socketConnection = null;
-    const fileName = config.fileName ?? config.header.name;
-    const logger = createLogger("info", {
-      prefix: `[${pluginName}]`,
-      allowClearScreen: true
-    });
-    const httpServer = createServer((req, res) => {
-      return serveHandler(req, res, {
-        public: pluginConfig.build.outDir
-      });
-    });
-    const WebSocketServer = server;
-    const ws = new WebSocketServer({ httpServer });
-    ws.on("request", (request) => {
-      socketConnection = request.accept(null, request.origin);
-    });
-    return {
-      name: pluginName,
-      apply: "build",
-      config() {
-        return {
-          build: {
-            target: "esnext",
-            minify: false,
-            lib: {
-              name: fileName,
-              entry: config.entry,
-              formats: ["iife"],
-              fileName: () => `${fileName}.js`
-            },
-            rollupOptions: {
-              output: {
-                extend: true
-              }
-            }
-          }
-        };
-      },
-      async configResolved(userConfig) {
-        pluginConfig = userConfig;
-        isBuildWatch = userConfig.build.watch ?? false;
-        config.entry = resolve(userConfig.root, config.entry);
-        Array.from([
-          "match",
-          "require",
-          "include",
-          "exclude",
-          "resource",
-          "connect"
-        ]).forEach((key) => {
-          const value = config.header[key];
-          config.header[key] = removeDuplicates(value);
-        });
-        config.server = {
-          port: await getPort(),
-          open: false,
-          ...config.server
-        };
-      },
-      async writeBundle(output, bundle) {
-        const { open, port } = config.server;
-        const sanitizedFilename = output.sanitizeFileName(fileName);
-        const userFilename = `${sanitizedFilename}.user.js`;
-        const proxyFilename = `${sanitizedFilename}.proxy.user.js`;
-        const metaFilename = `${sanitizedFilename}.meta.js`;
-        for (const [fileName2] of Object.entries(bundle)) {
-          if (regexpScripts.test(fileName2)) {
-            const rootDir = pluginConfig.root;
-            const outDir = pluginConfig.build.outDir;
-            const outPath = resolve(rootDir, outDir, fileName2);
-            const userFilePath = resolve(rootDir, outDir, userFilename);
-            const proxyFilePath = resolve(rootDir, outDir, proxyFilename);
-            const metaFilePath = resolve(rootDir, outDir, metaFilename);
-            const wsPath = resolve(pluginDir, `ws-${sanitizedFilename}.js`);
-            try {
-              let source = readFileSync(outPath, "utf8");
-              source = await transform(
-                {
-                  minify: !isBuildWatch,
-                  file: source,
-                  name: fileName2,
-                  loader: "js"
-                },
-                config.esbuildTransformOptions
-              );
-              config.header.grant = removeDuplicates(
-                isBuildWatch ? grants : [...defineGrants(source), ...config.header.grant ?? []]
-              );
-              if (isBuildWatch) {
-                const wsFile = readFileSync(resolve(pluginDir, "ws.js"), "utf8");
-                const wsScript = await transform(
-                  {
-                    minify: !isBuildWatch,
-                    file: wsFile.replace("__WS__", `ws://localhost:${port}`),
-                    name: wsPath,
-                    loader: "js"
-                  },
-                  config.esbuildTransformOptions
-                );
-                writeFileSync(wsPath, wsScript);
-                writeFileSync(
-                  proxyFilePath,
-                  new Banner({
-                    ...config.header,
-                    require: [
-                      ...config.header.require ?? [],
-                      "file://" + wsPath,
-                      "file://" + outPath
-                    ]
-                  }).generate()
-                );
-              }
-              const banner = new Banner(config.header).generate();
-              writeFileSync(outPath, source);
-              writeFileSync(metaFilePath, banner);
-              writeFileSync(userFilePath, `${banner}
-
-${source}`);
-            } catch (err) {
-              console.log(err);
-            }
-          }
-        }
-        if (isBuildWatch && !httpServer.listening) {
-          const link = `http://localhost:${port}`;
-          httpServer.listen(port, () => {
-            logger.clearScreen("info");
-            logger.info(
-              colors.bold(
-                `${colors.cyan(">>> [vite-userscript-plugin]")} ${colors.gray(
-                  link
-                )}`
-              )
-            );
-          });
-          if (open) {
-            await openLink(`${link}/${proxyFilename}`);
-          }
-        } else if (!isBuildWatch) {
-          httpServer.close();
-          process.exit(0);
-        }
-      },
-      buildEnd() {
-        if (isBuildWatch) {
-          logger.clearScreen("info");
-          if (socketConnection) {
-            socketConnection.sendUTF(
-              JSON.stringify({
-                message: "reload"
-              })
-            );
-          }
-        }
-      }
-    };
-  } catch (err) {
-    console.error(err);
-    return {
-      name: pluginName
-    };
+  function inject(src) {
+    var script = document.createElement('script');
+    script.type = 'module';
+    script.src = src;
+    (document.head || document.documentElement).appendChild(script);
   }
+${clientInject}
+  inject(${JSON.stringify(injectTarget)});
+})();
+`;
+}
+function generateDevUserscript(options) {
+	return `${generateHeader(applyServeHeader(options.script.header, options.prefix), {
+		...options.headerOptions,
+		fileName: options.script.fileName,
+		mode: "serve"
+	})}\n\n${generateDevWrapper({
+		origin: options.origin,
+		entryPath: toServeEntryPath(options.root, options.script.entry),
+		reactPreamble: options.reactPreamble
+	})}`;
+}
+function findDevScript(url, scripts) {
+	return scripts.find((script) => !script.server.file && matchDevUserscript(url, script.fileName));
+}
+function findProxyScript(url, scripts) {
+	return scripts.find((script) => script.server.file && matchProxyUserscript(url, script.fileName));
+}
+function createDevUserscript(options) {
+	return generateDevUserscript({
+		script: options.script,
+		origin: options.origin,
+		root: options.root,
+		prefix: options.script.server.prefix,
+		headerOptions: {
+			align: options.script.align,
+			autoMetaUrls: options.script.autoMetaUrls,
+			generate: options.script.generate
+		},
+		reactPreamble: options.reactPreamble
+	});
 }
-export {
-  UserscriptPlugin as default
+//#endregion
+//#region src/serve/middleware.ts
+const DEV_SCRIPT_HEADERS = {
+	"Content-Type": "text/javascript; charset=utf-8",
+	"Cache-Control": "no-store"
 };
+function resolveServerOrigin(urls) {
+	const url = urls?.local[0] ?? urls?.network[0];
+	return url ? url.replace(/\/$/, "") : "http://localhost:5173";
+}
+function writeScript(res, body) {
+	for (const [key, value] of Object.entries(DEV_SCRIPT_HEADERS)) res.setHeader(key, value);
+	res.end(body);
+}
+function configureDevServer(server, resolved, reactPreamble) {
+	server.middlewares.use((req, res, next) => {
+		const url = req.url ?? "";
+		if (matchReactPreamble(url)) {
+			writeScript(res, REACT_PREAMBLE_MODULE);
+			return;
+		}
+		if (matchReactBootstrap(url)) {
+			const entry = resolveBootstrapEntry(url);
+			if (!entry) {
+				res.statusCode = 400;
+				res.end();
+				return;
+			}
+			writeScript(res, createReactBootstrapModule(entry));
+			return;
+		}
+		const proxyScript = findProxyScript(url, resolved.scripts);
+		if (proxyScript) {
+			writeScript(res, `${generateWatchProxy(proxyScript, resolve(server.config.root, server.config.build.outDir, toRequireFileName(proxyScript.fileName)))}\n`);
+			return;
+		}
+		const script = findDevScript(url, resolved.scripts);
+		if (!script) {
+			next();
+			return;
+		}
+		writeScript(res, createDevUserscript({
+			origin: resolveServerOrigin(server.resolvedUrls),
+			root: server.config.root,
+			script,
+			reactPreamble
+		}));
+	});
+	const printUrls = server.printUrls.bind(server);
+	server.printUrls = () => {
+		const urls = server.resolvedUrls;
+		const info = server.config.logger.info.bind(server.config.logger);
+		let origins = [];
+		if (urls) origins = urls.local.length ? urls.local : urls.network;
+		const printInstall = () => {
+			for (const origin of origins) for (const script of resolved.scripts) info(formatInstallLine(toInstallUrl(origin, script.fileName, script.server.file)));
+			info(formatFaqHint());
+		};
+		const logger = createAfterLocalLogger(info, urls?.local.length ?? 0, printInstall);
+		const previousInfo = server.config.logger.info;
+		server.config.logger.info = logger.info;
+		try {
+			printUrls();
+		} finally {
+			server.config.logger.info = previousInfo;
+			logger.flush();
+		}
+	};
+	server.httpServer?.once("listening", () => {
+		const toOpen = resolved.scripts.filter((script) => script.server.open);
+		if (!toOpen.length) return;
+		queueMicrotask(() => {
+			const origin = resolveServerOrigin(server.resolvedUrls);
+			for (const script of toOpen) openLink(toInstallUrl(origin, script.fileName, script.server.file));
+		});
+	});
+}
+//#endregion
+//#region src/plugin.ts
+function absolutizeEntries(config, root) {
+	return { scripts: config.scripts.map((script) => ({
+		...script,
+		entry: resolve(root, script.entry)
+	})) };
+}
+function UserscriptPlugin(config) {
+	let resolved = resolvePluginConfig(config);
+	let reactPreamble = false;
+	let command = "serve";
+	let isWatch = false;
+	let mode = "production";
+	let outDir = "";
+	let fileWatchStarted = false;
+	const shouldEmitProxy = () => {
+		return isWatch || mode === "development";
+	};
+	const startFileWatchBuild = async (server) => {
+		if (command === "build" || fileWatchStarted) return;
+		fileWatchStarted = true;
+		const outDirAbs = resolve(server.config.root, server.config.build.outDir);
+		let firstBuild = true;
+		const run = async () => {
+			const isRebuild = !firstBuild;
+			const started = Date.now();
+			await build({
+				configFile: server.config.configFile ?? false,
+				root: server.config.root,
+				mode: server.config.mode,
+				logLevel: "silent",
+				clearScreen: false,
+				plugins: server.config.configFile ? void 0 : [UserscriptPlugin(config)],
+				build: {
+					outDir: server.config.build.outDir,
+					emptyOutDir: firstBuild,
+					minify: server.config.build.minify,
+					sourcemap: server.config.build.sourcemap,
+					write: true,
+					reportCompressedSize: false
+				}
+			});
+			firstBuild = false;
+			if (isRebuild) server.config.logger.info(formatRebuildLine(Date.now() - started), { timestamp: true });
+		};
+		try {
+			await run();
+		} catch (error) {
+			fileWatchStarted = false;
+			server.config.logger.error(`[${PLUGIN_NAME}] Failed to start file-mode watch build`);
+			server.config.logger.error(String(error));
+			return;
+		}
+		let timer;
+		const onChange = (file) => {
+			if (file.startsWith(outDirAbs)) return;
+			clearTimeout(timer);
+			timer = setTimeout(() => {
+				run().catch((error) => {
+					server.config.logger.error(String(error));
+				});
+			}, 80);
+		};
+		server.watcher.on("change", onChange);
+		server.watcher.on("add", onChange);
+		const closeServer = server.close.bind(server);
+		server.close = async () => {
+			server.watcher.off("change", onChange);
+			server.watcher.off("add", onChange);
+			clearTimeout(timer);
+			return closeServer();
+		};
+	};
+	return [
+		{
+			name: `${PLUGIN_NAME}:config`,
+			config(userConfig) {
+				const { input, hasHtml } = resolvePluginBuildInput(userConfig, resolved.scripts);
+				const scriptNames = new Set(resolved.scripts.map((script) => script.fileName));
+				userConfig.build ??= {};
+				userConfig.build.rolldownOptions ??= {};
+				userConfig.build.rolldownOptions.input = input;
+				const userOutput = userConfig.build.rolldownOptions.output;
+				const userEntryFileNames = userOutput && !Array.isArray(userOutput) ? userOutput.entryFileNames : void 0;
+				return {
+					appType: userConfig.appType ?? (hasHtml ? "spa" : "custom"),
+					optimizeDeps: {
+						entries: Object.values(input),
+						exclude: [VIRTUAL_MODULE_ID]
+					},
+					server: { cors: userConfig.server?.cors ?? true },
+					build: {
+						minify: userConfig.build?.minify ?? false,
+						assetsInlineLimit: userConfig.build?.assetsInlineLimit ?? Number.MAX_SAFE_INTEGER,
+						rolldownOptions: {
+							input,
+							output: {
+								format: "es",
+								entryFileNames: (chunkInfo) => {
+									if (scriptNames.has(chunkInfo.name)) return "[name].js";
+									if (typeof userEntryFileNames === "function") return userEntryFileNames(chunkInfo);
+									if (typeof userEntryFileNames === "string") return userEntryFileNames;
+									return "assets/[name]-[hash].js";
+								}
+							}
+						}
+					}
+				};
+			},
+			configResolved(viteConfig) {
+				command = viteConfig.command;
+				resolved = absolutizeEntries(resolved, viteConfig.root);
+				reactPreamble = hasReactRefreshPlugin(viteConfig.plugins);
+				for (const message of collectAutoMetaUrlsWarnings(resolved)) viteConfig.logger.warn(message);
+			}
+		},
+		{
+			name: `${PLUGIN_NAME}:virtual`,
+			resolveId: (id) => {
+				if (id === "virtual:vite-userscript-plugin") return RESOLVED_VIRTUAL_MODULE_ID;
+			},
+			load: (id) => {
+				if (id === RESOLVED_VIRTUAL_MODULE_ID) return renderVirtualModule(createClientSnapshot(resolved.scripts, command));
+			}
+		},
+		{
+			name: `${PLUGIN_NAME}:serve`,
+			apply: "serve",
+			configureServer(server) {
+				configureDevServer(server, resolved, reactPreamble);
+				if (resolved.scripts.some((script) => script.server.file)) startFileWatchBuild(server);
+			}
+		},
+		{
+			name: `${PLUGIN_NAME}:gm-shim`,
+			apply: "serve",
+			transform: {
+				filter: { id: { exclude: [/node_modules/] } },
+				handler(code, id) {
+					if (!shouldShimModule(id)) return null;
+					return shimModule(code, id);
+				}
+			}
+		},
+		{
+			name: `${PLUGIN_NAME}:build`,
+			apply: "build",
+			enforce: "post",
+			configResolved(viteConfig) {
+				isWatch = Boolean(viteConfig.build.watch);
+				mode = viteConfig.mode;
+				outDir = resolve(viteConfig.root, viteConfig.build.outDir);
+			},
+			generateBundle(_options, bundle) {
+				isWatch = this.meta.watchMode || isWatch;
+				applyUserscriptBundle(bundle, resolved, {
+					emitFile: (fileName, source) => {
+						this.emitFile({
+							type: "asset",
+							fileName,
+							source
+						});
+					},
+					emitProxy: shouldEmitProxy(),
+					outDir
+				});
+			}
+		}
+	];
+}
+//#endregion
+export { Header, UserscriptPlugin as default, generateHeader, resolveHomePage, resolvePublicFileUrl };