@master/css-vite 0.0.0-site.1793659883.g69c9aebcf628

package/dist/plugins/build-stylesheet-recovery.js

@@ -0,0 +1,26 @@
+import { acknowledgeFailedDependencyChange, configureBuildDependencyReconciliation } from "../utils/failed-dependency-reconciliation.js";
+import { closeBuildStylesheetRecovery, prepareBuildStylesheetRecovery } from "../utils/build-watch-recovery.js";
+// src/plugins/build-stylesheet-recovery.ts
+/** Recover failed watch builds without changing authored files or dependency data. */
+function BuildStylesheetRecoveryPlugin(context) {
+	return {
+		name: "master-css:build-stylesheet-recovery",
+		apply: "build",
+		enforce: "pre",
+		configResolved(config) {
+			if (config.build?.watch) prepareBuildStylesheetRecovery(context, config.root, config.cacheDir, config.build.watch);
+		},
+		buildStart() {
+			if (!context.config?.build?.watch) return;
+			prepareBuildStylesheetRecovery(context, context.config.root, context.config.cacheDir, context.config.build.watch, this.environment ?? context);
+			configureBuildDependencyReconciliation(context, context.config.build.watch);
+		},
+		watchChange(id) {
+			acknowledgeFailedDependencyChange(context, id);
+		},
+		closeWatcher() {
+			closeBuildStylesheetRecovery(context, this.environment ?? context);
+		}
+	};
+}
+export { BuildStylesheetRecoveryPlugin as default };

package/dist/plugins/context.d.ts

@@ -0,0 +1,5 @@
+import { Plugin } from "vite";
+import { ResolvedMasterCSSVitePluginOptions } from "../options.js";
+import { MasterCSSVitePluginContext } from "../core.js";
+declare function ContextPlugin(options: ResolvedMasterCSSVitePluginOptions, context: MasterCSSVitePluginContext): Plugin;
+export { ContextPlugin as default };

package/dist/plugins/context.js

@@ -0,0 +1,12 @@
+// src/plugins/context.ts
+function ContextPlugin(options, context) {
+	return {
+		name: "master-css:context",
+		enforce: "pre",
+		configResolved(config) {
+			context.config = config;
+			if (process.env.DEBUG) console.log(`[@master/css-vite] mode: ${options.mode}`);
+		}
+	};
+}
+export { ContextPlugin as default };

package/dist/plugins/dev-stylesheet.d.ts

@@ -0,0 +1,4 @@
+import { Plugin } from "vite";
+import { MasterCSSVitePluginContext } from "../core.js";
+declare function DevStylesheetPlugin(context: MasterCSSVitePluginContext): Plugin;
+export { DevStylesheetPlugin as default };

package/dist/plugins/dev-stylesheet.js

@@ -0,0 +1,63 @@
+import { normalizeFilePath } from "../utils/path.js";
+import { releaseScannerEnvironment } from "../utils/scanner-context.js";
+import { toAssetHref } from "../utils/html.js";
+import { clearDevStylesheets, devStylesheetState } from "../utils/dev-stylesheet-delivery.js";
+import { relative } from "node:path";
+import { isFileLoadingAllowed, normalizePath } from "vite";
+import MagicString from "magic-string";
+// src/plugins/dev-stylesheet.ts
+function DevStylesheetPlugin(context) {
+	return {
+		name: "master-css:dev-stylesheet",
+		apply: "serve",
+		enforce: "post",
+		configureServer(server) {
+			server.middlewares.use((request, response, next) => {
+				const state = devStylesheetState(context);
+				const url = new URL(request.url ?? "/", "http://localhost");
+				if (!url.pathname.startsWith(state.prefix)) return next();
+				const css = state.stylesheets.get(url.pathname);
+				if (css !== void 0) {
+					response.setHeader("Content-Type", "text/css");
+					response.setHeader("Cache-Control", "no-store");
+					response.end(css);
+					return;
+				}
+				const resource = state.resources.get(url.pathname);
+				if (resource) {
+					const source = normalizeFilePath(resource.source);
+					if (!server.config.server.fs.allow.includes(source)) server.config.server.fs.allow.push(source);
+					if (!isFileLoadingAllowed(server.config, source)) {
+						response.statusCode = 403;
+						response.end("Development resource access denied");
+						return;
+					}
+					const file = normalizePath(resource.file);
+					if (!server.config.server.fs.allow.includes(file)) server.config.server.fs.allow.push(file);
+					const path = normalizePath(relative(normalizeFilePath(server.config.root), file));
+					const encodedPath = encodeURI(path).replace(/[?#]/g, encodeURIComponent);
+					request.url = toAssetHref(encodedPath, server.config.base) + url.search;
+					next();
+					return;
+				}
+				response.statusCode = 404;
+				response.end("Unknown development stylesheet asset");
+			});
+		},
+		transform(code) {
+			const { origin } = devStylesheetState(context);
+			if (!code.includes(origin)) return;
+			const output = new MagicString(code);
+			for (const match of code.matchAll(new RegExp(origin.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"))) output.remove(match.index, match.index + origin.length);
+			return {
+				code: output.toString(),
+				map: output.generateMap({ hires: true })
+			};
+		},
+		closeBundle() {
+			const config = this.environment?.getTopLevelConfig() ?? context.config;
+			if (releaseScannerEnvironment(context, config, this.environment)) clearDevStylesheets(context);
+		}
+	};
+}
+export { DevStylesheetPlugin as default };

package/dist/plugins/emitted-globals-virtual-module.d.ts

@@ -0,0 +1,14 @@
+import { Environment, Plugin } from "vite";
+import { MasterCSSEmittedGlobals } from "@master/css-schema/emitted-globals";
+import { MasterCSSVitePluginContext } from "../core.js";
+/**
+ * The plugin's `api`, shared by every configuration that one plugin instance
+ * resolves. Adapters whose build links one environment's stylesheets on pages
+ * that load another environment's bundle set `finalize`.
+ */
+interface EmittedGlobalsPluginAPI {
+  /** Receives each build environment's emitted globals as its output renders and returns the ones that output carries. */
+  finalize?: (environment: Environment, emittedGlobals: Required<MasterCSSEmittedGlobals>) => MasterCSSEmittedGlobals;
+}
+declare function EmittedGlobalsVirtualModulePlugin(context: MasterCSSVitePluginContext, api?: EmittedGlobalsPluginAPI): Plugin;
+export { EmittedGlobalsPluginAPI, EmittedGlobalsVirtualModulePlugin as default };

package/dist/plugins/emitted-globals-virtual-module.js

@@ -0,0 +1,167 @@
+import { normalizeEmittedGlobals, toEmittedGlobalsModule } from "../internal/src/emitted-globals-module.js";
+import { RESOLVED_VIRTUAL_EMITTED_GLOBALS_ID, VIRTUAL_EMITTED_GLOBALS_ID } from "../common.js";
+import { getExtractedCSSResult } from "../utils/extracted-css.js";
+import { registerStylesheetSource } from "../utils/register-style-source.js";
+import { refreshGeneratedModule } from "../utils/dev-module-refresh.js";
+import { createCoalescedTask } from "../utils/coalesced-task.js";
+import { discoverManifestEntries } from "@master/css-compiler/project";
+import { readFile } from "node:fs/promises";
+import MagicString from "magic-string";
+// src/plugins/emitted-globals-virtual-module.ts
+function toServerDevEmittedGlobalsModule(emittedGlobals) {
+	return [
+		"const emittedGlobals = import.meta.hot?.data.emittedGlobals ?? {};",
+		"for (const key of Object.keys(emittedGlobals)) delete emittedGlobals[key];",
+		`Object.assign(emittedGlobals, ${JSON.stringify(normalizeEmittedGlobals(emittedGlobals))});`,
+		"if (import.meta.hot) {",
+		"  import.meta.hot.data.emittedGlobals = emittedGlobals;",
+		"  import.meta.hot.accept();",
+		"}",
+		"export default emittedGlobals;"
+	].join("\n");
+}
+function EmittedGlobalsVirtualModulePlugin(context, api = {}) {
+	const placeholder = "__MASTER_CSS_FINAL_EMITTED_GLOBALS__";
+	let finalGlobals;
+	let dev;
+	const signature = (value) => JSON.stringify(normalizeEmittedGlobals(value), (_key, item) => {
+		if (!item || typeof item !== "object" || Array.isArray(item)) return item;
+		return Object.fromEntries(Object.entries(item).sort(([a], [b]) => a.localeCompare(b)));
+	});
+	return {
+		name: "master-css:virtual-module:emitted-globals",
+		enforce: "pre",
+		api,
+		configureServer(server) {
+			if (dev) for (const environment of dev.lifetimes.keys()) dev.closeEnvironment(environment);
+			const config = server.config;
+			let closed = false;
+			const served = /* @__PURE__ */ new Map();
+			const loading = /* @__PURE__ */ new Set();
+			const lifetimes = /* @__PURE__ */ new Map();
+			const closedEnvironments = /* @__PURE__ */ new WeakSet();
+			const active = () => !closed && dev === state && server.config === config;
+			const onError = (error) => {
+				if (active()) server.config.logger.error(String(error));
+			};
+			const publish = createCoalescedTask(async () => {
+				if (!active() || !context.emittedGlobals) return;
+				const next = signature(context.emittedGlobals);
+				const previous = /* @__PURE__ */ new Map();
+				try {
+					await refreshGeneratedModule(server, RESOLVED_VIRTUAL_EMITTED_GLOBALS_ID, (environment) => {
+						if (loading.has(environment) || !served.has(environment) || served.get(environment) === next) return false;
+						previous.set(environment, served.get(environment));
+						served.set(environment, next);
+						return true;
+					});
+				} catch (error) {
+					for (const [environment, signature] of previous) if (served.get(environment) === next) served.set(environment, signature);
+					throw error;
+				}
+			}, onError);
+			const state = dev = {
+				active,
+				served,
+				loading,
+				lifetimes,
+				closedEnvironments,
+				publish,
+				closeEnvironment(environment) {
+					served.delete(environment);
+					loading.delete(environment);
+					closedEnvironments.add(environment);
+					lifetimes.get(environment)?.close();
+					lifetimes.delete(environment);
+				}
+			};
+			context.onEmittedGlobalsChange = () => {
+				publish();
+			};
+			context.refreshEmittedGlobals = createCoalescedTask(async () => {
+				if (!active() || !served.size) return;
+				await Promise.all(Object.values(server.environments).filter((environment) => served.has(environment)).map((environment) => Promise.race([environment.waitForRequestsIdle(), lifetimes.get(environment).promise])));
+				if (!active() || !served.size) return;
+				await getExtractedCSSResult(context);
+				await publish();
+			}, onError);
+			server.httpServer?.once("close", () => {
+				closed = true;
+				for (const environment of lifetimes.keys()) state.closeEnvironment(environment);
+			});
+		},
+		async resolveId(id) {
+			if (id === VIRTUAL_EMITTED_GLOBALS_ID) return RESOLVED_VIRTUAL_EMITTED_GLOBALS_ID;
+		},
+		async load(id) {
+			if (id !== RESOLVED_VIRTUAL_EMITTED_GLOBALS_ID) return;
+			if (context.config?.command === "build") return `export default JSON.parse(${JSON.stringify(placeholder)});`;
+			const environment = this.environment;
+			const state = context.config?.command === "serve" && dev?.active() && !dev.closedEnvironments.has(environment) ? dev : void 0;
+			let lifetime;
+			if (state) {
+				lifetime = state.lifetimes.get(environment);
+				if (!lifetime) {
+					let close;
+					lifetime = {
+						promise: new Promise((resolve) => {
+							close = resolve;
+						}),
+						close
+					};
+					state.lifetimes.set(environment, lifetime);
+				}
+				state.loading.add(environment);
+			}
+			try {
+				if (state) {
+					state.initialStylesheets ??= (async () => {
+						const entries = await discoverManifestEntries({ root: context.config?.root });
+						for (const entry of entries) {
+							if (context.stylesheets?.snapshot().sourceIds.includes(entry)) continue;
+							await registerStylesheetSource(context, entry, await readFile(entry, "utf8"));
+						}
+					})().catch((error) => {
+						state.initialStylesheets = void 0;
+						throw error;
+					});
+					await state.initialStylesheets;
+				}
+				const result = await getExtractedCSSResult(context);
+				const globals = context.emittedGlobals ?? result.emittedGlobals;
+				if (state?.active() && state.lifetimes.get(environment) === lifetime) state.served.set(environment, signature(globals));
+				if (state && environment.config.consumer === "server") return toServerDevEmittedGlobalsModule(globals);
+				return toEmittedGlobalsModule(globals);
+			} finally {
+				if (state && state.lifetimes.get(environment) === lifetime) {
+					state.loading.delete(environment);
+					state.publish();
+				}
+			}
+		},
+		closeBundle() {
+			dev?.closeEnvironment(this.environment);
+		},
+		shouldTransformCachedModule({ id }) {
+			return id === RESOLVED_VIRTUAL_EMITTED_GLOBALS_ID;
+		},
+		renderStart: {
+			order: "post",
+			async handler() {
+				if (context.config?.command !== "build") return;
+				const { emittedGlobals } = await getExtractedCSSResult(context);
+				finalGlobals = JSON.stringify(api.finalize ? normalizeEmittedGlobals(api.finalize(this.environment, emittedGlobals)) : emittedGlobals);
+			}
+		},
+		renderChunk(code) {
+			if (finalGlobals === void 0 || !code.includes(placeholder)) return;
+			const output = new MagicString(code);
+			for (const match of code.matchAll(new RegExp(`(["'])${placeholder}\\1`, "g"))) output.overwrite(match.index, match.index + match[0].length, JSON.stringify(finalGlobals));
+			return {
+				code: output.toString(),
+				map: output.generateMap({ hires: true })
+			};
+		}
+	};
+}
+export { EmittedGlobalsVirtualModulePlugin as default };

package/dist/plugins/inject-runtime.d.ts

@@ -0,0 +1,5 @@
+import { Plugin } from "vite";
+import { ResolvedMasterCSSVitePluginOptions } from "../options.js";
+declare function InjectRuntimePlugin(_options: ResolvedMasterCSSVitePluginOptions): Plugin;
+declare function InjectRuntimeServePlugin(_options: ResolvedMasterCSSVitePluginOptions): Plugin;
+export { InjectRuntimeServePlugin, InjectRuntimePlugin as default };

package/dist/plugins/inject-runtime.js

@@ -0,0 +1,51 @@
+import { DEV_RUNTIME_ENTRY_ID, RUNTIME_ENTRY_ID } from "../common.js";
+import { toAssetHref } from "../utils/html.js";
+// src/plugins/inject-runtime.ts
+function InjectRuntimePlugin(_options) {
+	return {
+		name: "master-css:inject-runtime",
+		enforce: "pre",
+		apply: "build",
+		transformIndexHtml: {
+			order: "pre",
+			handler(html) {
+				if (html.includes(RUNTIME_ENTRY_ID) || html.includes(DEV_RUNTIME_ENTRY_ID)) return;
+				return {
+					html,
+					tags: [{
+						tag: "script",
+						attrs: {
+							type: "module",
+							src: RUNTIME_ENTRY_ID
+						},
+						injectTo: "body"
+					}]
+				};
+			}
+		}
+	};
+}
+function InjectRuntimeServePlugin(_options) {
+	return {
+		name: "master-css:inject-runtime:serve",
+		apply: "serve",
+		transformIndexHtml: {
+			order: "post",
+			handler(html, htmlContext) {
+				if (html.includes(RUNTIME_ENTRY_ID) || html.includes(DEV_RUNTIME_ENTRY_ID)) return;
+				return {
+					html,
+					tags: [{
+						tag: "script",
+						attrs: {
+							type: "module",
+							src: toAssetHref(DEV_RUNTIME_ENTRY_ID, htmlContext.server?.config?.base, htmlContext.path)
+						},
+						injectTo: "body"
+					}]
+				};
+			}
+		}
+	};
+}
+export { InjectRuntimeServePlugin, InjectRuntimePlugin as default };

package/dist/plugins/inline-stylesheet.d.ts

@@ -0,0 +1,5 @@
+import { Plugin } from "vite";
+import { MasterCSSVitePluginContext } from "../core.js";
+/** Export managed CSS as a string without registering an automatic stylesheet. */
+declare function InlineStylesheetPlugin(context: MasterCSSVitePluginContext): Plugin;
+export { InlineStylesheetPlugin as default };

package/dist/plugins/inline-stylesheet.js

@@ -0,0 +1,197 @@
+import { withSassDiagnostics } from "../utils/sass-diagnostics.js";
+import { getScanner } from "../utils/scanner-context.js";
+import { INLINE_URL_BASE, disposeInlineStylesheets, inlineBuiltURL, inlineDelivery, inlineDigest, inlineStylesheets, inlineURLReferences, isInlineStylesheet, rewriteInlineURLs } from "../utils/inline-stylesheet.js";
+import { readFileSync } from "node:fs";
+import { posix } from "node:path";
+import { createCompilerSync } from "@master/css-compiler/node";
+import MagicString from "magic-string";
+// src/plugins/inline-stylesheet.ts
+const configuredBaseKey = Symbol("master-css:configured-inline-divider");
+/** Export managed CSS as a string without registering an automatic stylesheet. */
+function InlineStylesheetPlugin(context) {
+	const pending = /* @__PURE__ */ new Map();
+	const used = /* @__PURE__ */ new Set();
+	return {
+		name: "master-css:inline-stylesheet",
+		enforce: "post",
+		apply: "build",
+		config: {
+			order: "post",
+			handler(config) {
+				Reflect.set(config, configuredBaseKey, config.base);
+			}
+		},
+		shouldTransformCachedModule({ id }) {
+			if (isInlineStylesheet(id) && /\.(?:css|scss|sass)(?:[?#].*)?$/i.test(id)) return true;
+		},
+		transform(_code, id) {
+			const entry = inlineStylesheets(context).get(id);
+			if (!entry) return;
+			entry.reference = this.emitFile({
+				type: "asset",
+				name: "master-css-inline-divider.css",
+				source: "/* Master CSS inline asset base. */"
+			});
+			if (this.environment.config.consumer === "server") return {
+				code: `export default ${JSON.stringify(entry.token)}`,
+				map: null
+			};
+			return {
+				code: `export default ${JSON.stringify(entry.token)}.replaceAll(${JSON.stringify(entry.token + "_URL")}, new URL('.', import.meta.ROLLUP_FILE_URL_${entry.reference}).href)`,
+				map: null
+			};
+		},
+		resolveFileUrl({ referenceId, relativePath, format }) {
+			if (![...inlineStylesheets(context).values()].some((entry) => entry.reference === referenceId)) return;
+			if (format === "iife" || format === "umd") return `new URL(${JSON.stringify(relativePath)}, (typeof document === "undefined" ? (typeof location === "undefined" ? require("node:url").pathToFileURL(__filename).href : location.href) : document.currentScript?.src || document.baseURI)).href`;
+			if (format === "cjs") return `new URL(${JSON.stringify(relativePath)}, require("node:url").pathToFileURL(__filename).href).href`;
+		},
+		async renderStart() {
+			pending.clear();
+			used.clear();
+			const scanner = getScanner(context);
+			using compiler = createCompilerSync();
+			for (const entry of inlineStylesheets(context).values()) {
+				if (!entry.reference) continue;
+				const result = entry.local ? {
+					...entry.local,
+					css: entry.local.code
+				} : await withSassDiagnostics(context, () => entry.collection.compose({
+					scanner,
+					baseManifest: scanner.css.manifest,
+					projectDir: context.config?.root,
+					pruneNativeCSS: context.pruneNativeCSS,
+					includeGeneratedCSS: context.includeGeneratedCSS,
+					delivery: inlineDelivery(context)
+				}));
+				const managed = {
+					entry: "inline-managed",
+					stylesheets: [{
+						id: "inline-managed",
+						href: INLINE_URL_BASE + "entry.css",
+						css: result.css
+					}, ...result.stylesheets ?? []]
+				};
+				const bundle = compiler.prepareStylesheetBundle({
+					source: scanner.slotCSSRule,
+					from: entry.token,
+					slotCSSRule: scanner.slotCSSRule,
+					managed
+				});
+				const hash = inlineDigest(JSON.stringify(bundle));
+				const urls = Object.fromEntries(bundle.graph.stylesheets.map((node, i) => [node.id, `${INLINE_URL_BASE}master-css-inline-${hash}-${i}.css`]));
+				const assets = compiler.renderStylesheetBundle({
+					bundle,
+					urls,
+					inlineImports: true
+				});
+				const ownedURLs = /* @__PURE__ */ new Set([...Object.values(urls), ...(result.resources ?? []).map((resource) => resource.href)]);
+				const css = assets.find((asset) => asset.id === bundle.graph.entry).css;
+				const byURL = new Map(assets.map((asset) => [asset.href, asset]));
+				const reachable = /* @__PURE__ */ new Set();
+				const queue = [css];
+				for (const source of queue) for (const reference of inlineURLReferences(compiler, source)) {
+					const url = reference.url.split(/[?#]/)[0];
+					if (!ownedURLs.has(url) || reachable.has(url)) continue;
+					reachable.add(url);
+					const asset = byURL.get(url);
+					if (asset) queue.push(asset.css);
+				}
+				entry.urlMarker = entry.token + "_BASE";
+				while (css.includes(entry.urlMarker)) entry.urlMarker += "_";
+				const directory = posix.dirname(this.getFileName(entry.reference));
+				entry.css = css;
+				const files = new Map([...ownedURLs].map((url) => [url, posix.join(directory, url.slice(INLINE_URL_BASE.length))]));
+				entry.files = files;
+				const publication = [];
+				const linked = assets.filter((asset) => asset.id !== bundle.graph.entry && reachable.has(asset.href));
+				const renderLinked = () => linked.map((asset) => {
+					const fileName = files.get(asset.href);
+					return {
+						fileName,
+						source: rewriteInlineURLs(compiler, asset.css, (url) => {
+							const bare = url.split(/[?#]/)[0], file = entry.files.get(bare), suffix = url.slice(bare.length), target = file + suffix;
+							const configuredBase = Reflect.get(this.environment.getTopLevelConfig(), configuredBaseKey);
+							const config = configuredBase === "./" || configuredBase === "" ? {
+								base: configuredBase,
+								experimental: this.environment.config.experimental
+							} : this.environment.config;
+							const result = inlineBuiltURL(config, this.environment.config.consumer === "server", target, fileName, "css");
+							return "url" in result ? result.url : posix.relative(directory, file) + suffix;
+						}, ownedURLs)
+					};
+				});
+				if (linked.length) {
+					const urlHash = inlineDigest(JSON.stringify(renderLinked()));
+					for (const asset of linked) {
+						const fileName = files.get(asset.href);
+						files.set(asset.href, fileName.slice(0, -4) + `-${urlHash}.css`);
+					}
+					publication.push(...renderLinked());
+				}
+				for (const resource of result.resources ?? []) if (reachable.has(resource.href)) publication.push({
+					fileName: posix.join(directory, resource.href.slice(INLINE_URL_BASE.length)),
+					source: readFileSync(resource.file)
+				});
+				pending.set(entry.token, publication);
+			}
+		},
+		renderChunk(code, chunk) {
+			const output = new MagicString(code);
+			using compiler = createCompilerSync();
+			for (const entry of inlineStylesheets(context).values()) {
+				if (entry.css === void 0 || !entry.files) continue;
+				const pattern = new RegExp(`(["'])${entry.token}\\1`, "g");
+				const matches = [...code.matchAll(pattern)];
+				if (!matches.length) continue;
+				const runtime = [];
+				const css = rewriteInlineURLs(compiler, entry.css, (url) => {
+					const bare = url.split(/[?#]/)[0], file = entry.files.get(bare), suffix = url.slice(bare.length), target = file + suffix;
+					const result = inlineBuiltURL(this.environment.config, this.environment.config.consumer === "server", target, chunk.fileName, "js");
+					if ("url" in result) return result.url;
+					if ("runtime" in result) {
+						const marker = `${entry.urlMarker}_RUNTIME_${runtime.length}__`;
+						runtime.push({
+							marker,
+							expression: result.runtime
+						});
+						return marker;
+					}
+					return entry.urlMarker + posix.relative(posix.dirname(this.getFileName(entry.reference)), file) + suffix;
+				}, new Set(entry.files.keys()));
+				let expression = JSON.stringify(css);
+				for (const item of runtime) expression += `.replaceAll(${JSON.stringify(item.marker)}, encodeURI(String(${item.expression})).replaceAll("%25", "%"))`;
+				for (const match of matches) {
+					used.add(entry.token);
+					output.overwrite(match.index, match.index + match[0].length, expression);
+				}
+				const urlPattern = new RegExp(`(["'])${entry.token}_URL\\1`, "g");
+				for (const match of code.matchAll(urlPattern)) output.overwrite(match.index, match.index + match[0].length, JSON.stringify(entry.urlMarker));
+			}
+			if (!output.hasChanged()) return;
+			return {
+				code: output.toString(),
+				map: output.generateMap({ hires: true })
+			};
+		},
+		generateBundle(_options, bundle) {
+			if (!this.environment.config.build.emitAssets) return;
+			const entries = [...inlineStylesheets(context).values()];
+			const anchors = new Set(entries.filter((entry) => used.has(entry.token) && entry.reference).map((entry) => this.getFileName(entry.reference)));
+			for (const entry of entries) if (used.has(entry.token)) for (const asset of pending.get(entry.token) ?? []) this.emitFile({
+				type: "asset",
+				...asset
+			});
+			else if (entry.reference) {
+				const fileName = this.getFileName(entry.reference);
+				if (!anchors.has(fileName)) delete bundle[fileName];
+			}
+		},
+		closeBundle() {
+			pending.clear();
+			used.clear();
+			disposeInlineStylesheets(context);
+		}
+	};
+}
+export { InlineStylesheetPlugin as default };

package/dist/plugins/local-styles.d.ts

@@ -0,0 +1,5 @@
+import { Plugin } from "vite";
+import { ResolvedMasterCSSVitePluginOptions } from "../options.js";
+import { MasterCSSVitePluginContext } from "../core.js";
+declare function LocalStylesPlugin(options: ResolvedMasterCSSVitePluginOptions, context: MasterCSSVitePluginContext): Plugin;
+export { LocalStylesPlugin as default };