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

package/dist/utils/coalesced-task.js

@@ -0,0 +1,25 @@
+// src/utils/coalesced-task.ts
+/** Keep one active operation and collapse pending events into its latest follow-up. */
+function createCoalescedTask(work, onError) {
+	let running;
+	let dirty = false;
+	return function schedule() {
+		dirty = true;
+		if (!running) running = Promise.resolve().then(async () => {
+			try {
+				while (dirty) {
+					dirty = false;
+					try {
+						await work();
+					} catch (error) {
+						onError(error);
+					}
+				}
+			} finally {
+				running = void 0;
+			}
+		});
+		return running;
+	};
+}
+export { createCoalescedTask };

package/dist/utils/dev-module-refresh.d.ts

@@ -0,0 +1,9 @@
+import { DevEnvironment, ViteDevServer } from "vite";
+/**
+ * Refresh a module whose generated content changed without a source edit.
+ * Browsers take an HMR update. A server module that cannot accept the update is
+ * only invalidated, so its runner refetches it on the next import: a program
+ * reload would restart the runner under requests that are still rendering.
+ */
+declare function refreshGeneratedModule(server: ViteDevServer, id: string, accepts?: (environment: DevEnvironment) => boolean): Promise<void>;
+export { refreshGeneratedModule };

package/dist/utils/dev-module-refresh.js

@@ -0,0 +1,17 @@
+// src/utils/dev-module-refresh.ts
+/**
+* Refresh a module whose generated content changed without a source edit.
+* Browsers take an HMR update. A server module that cannot accept the update is
+* only invalidated, so its runner refetches it on the next import: a program
+* reload would restart the runner under requests that are still rendering.
+*/
+async function refreshGeneratedModule(server, id, accepts = () => true) {
+	await Promise.all(Object.values(server.environments).map(async (environment) => {
+		if (!accepts(environment)) return;
+		const module = environment.moduleGraph.getModuleById(id);
+		if (!module) return;
+		if (environment.config.consumer === "client" || module.isSelfAccepting) return environment.reloadModule(module);
+		for (const each of module.file && environment.moduleGraph.getModulesByFile(module.file) || [module]) environment.moduleGraph.invalidateModule(each);
+	}));
+}
+export { refreshGeneratedModule };

package/dist/utils/dev-stylesheet-delivery.d.ts

@@ -0,0 +1,21 @@
+import { MasterCSSStylesheetComposition, MasterCSSStylesheetDeliveryOptions } from "@master/css-compiler/stylesheet";
+import { MasterCSSVitePluginContext } from "../core.js";
+interface DevStylesheetState {
+  delivery?: MasterCSSStylesheetDeliveryOptions;
+  origin: string;
+  prefix: string;
+  stylesheets: Map<string, string>;
+  resources: Map<string, {
+    file: string;
+    source: string;
+  }>;
+  resourceDir?: string;
+}
+declare function devStylesheetState(context: MasterCSSVitePluginContext): DevStylesheetState;
+declare function clearDevStylesheets(context: MasterCSSVitePluginContext): void;
+/** A separate import keeps generated selectors and keyframes outside SFC scoping. */
+declare function publishDevGlobalStylesheet(context: MasterCSSVitePluginContext, css: string): string;
+/** Give Vite external URLs while its CSS pipeline runs; the post hook makes them same-origin. */
+declare function getDevStylesheetDelivery(context: MasterCSSVitePluginContext): MasterCSSStylesheetDeliveryOptions | undefined;
+declare function publishDevStylesheets(context: MasterCSSVitePluginContext, result: MasterCSSStylesheetComposition, slotCSSRule: string): string;
+export { clearDevStylesheets, devStylesheetState, getDevStylesheetDelivery, publishDevGlobalStylesheet, publishDevStylesheets };

package/dist/utils/dev-stylesheet-delivery.js

@@ -0,0 +1,98 @@
+import { toAssetHref } from "./html.js";
+import { createHash, randomUUID } from "node:crypto";
+import { mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { basename, join } from "node:path";
+import { createCompilerSync } from "@master/css-compiler/node";
+// src/utils/dev-stylesheet-delivery.ts
+const states = /* @__PURE__ */ new WeakMap();
+function digest(source) {
+	return createHash("sha256").update(source).digest("hex").slice(0, 20);
+}
+function devStylesheetState(context) {
+	let state = states.get(context);
+	if (!state) {
+		const token = randomUUID();
+		state = {
+			origin: `https://master-css-dev-${token}.invalid`,
+			prefix: toAssetHref(`_master-css/dev/${token}/`, context.config?.base),
+			stylesheets: /* @__PURE__ */ new Map(),
+			resources: /* @__PURE__ */ new Map()
+		};
+		states.set(context, state);
+	}
+	return state;
+}
+function clearDevStylesheets(context) {
+	const directory = states.get(context)?.resourceDir;
+	if (directory) rmSync(directory, {
+		recursive: true,
+		force: true
+	});
+	states.delete(context);
+}
+/** A separate import keeps generated selectors and keyframes outside SFC scoping. */
+function publishDevGlobalStylesheet(context, css) {
+	const state = devStylesheetState(context);
+	const path = state.prefix + `globals-${digest(css)}.css`;
+	state.stylesheets.set(path, css.replaceAll(state.origin, ""));
+	return `@import ${JSON.stringify(state.origin + path)};`;
+}
+/** Give Vite external URLs while its CSS pipeline runs; the post hook makes them same-origin. */
+function getDevStylesheetDelivery(context) {
+	if (context.config?.command !== "serve") return;
+	const state = devStylesheetState(context), base = state.origin + state.prefix;
+	return state.delivery ??= {
+		entryURL: base + "entry.css",
+		stylesheetURL: (file, variant) => base + `source-${digest(variant ?? file)}.css`,
+		resourceURL: (source) => {
+			const content = readFileSync(source);
+			const href = base + `resource/${digest(source + "\0" + digest(content))}/${encodeURIComponent(basename(source))}`;
+			const key = new URL(href).pathname;
+			if (!state.resources.has(key)) {
+				if (!state.resourceDir) {
+					const cache = join(context.config.root, "node_modules", ".master-css");
+					mkdirSync(cache, { recursive: true });
+					state.resourceDir = realpathSync.native(mkdtempSync(join(cache, "master-css-vite-resources-")));
+				}
+				const file = join(state.resourceDir, digest(href) + "-" + basename(source).replace(/[^a-zA-Z0-9._-]/g, "_"));
+				writeFileSync(file, content);
+				state.resources.set(key, {
+					file,
+					source
+				});
+			}
+			return href;
+		},
+		resolveNodePackageImports: true
+	};
+}
+function publishDevStylesheets(context, result, slotCSSRule) {
+	const delivery = getDevStylesheetDelivery(context);
+	const state = devStylesheetState(context);
+	using compiler = createCompilerSync();
+	const bundle = compiler.prepareStylesheetBundle({
+		source: slotCSSRule,
+		from: "master-css-dev",
+		slotCSSRule,
+		managed: {
+			entry: "master-css-managed",
+			stylesheets: [{
+				id: "master-css-managed",
+				href: delivery.entryURL,
+				css: result.css
+			}, ...result.stylesheets ?? []]
+		}
+	});
+	const version = digest(JSON.stringify(bundle));
+	const urls = Object.fromEntries(bundle.graph.stylesheets.map((node) => [node.id, state.origin + state.prefix + `sheet-${digest(node.id)}-${version}.css`]));
+	const assets = compiler.renderStylesheetBundle({
+		bundle,
+		urls,
+		inlineImports: true
+	});
+	for (const asset of assets) state.stylesheets.set(new URL(asset.href).pathname, asset.css.replaceAll(state.origin, ""));
+	const root = assets.find((asset) => asset.id === bundle.graph.entry);
+	if (!root) throw new Error("Development stylesheet graph is missing its entry");
+	return root.css;
+}
+export { clearDevStylesheets, devStylesheetState, getDevStylesheetDelivery, publishDevGlobalStylesheet, publishDevStylesheets };

package/dist/utils/environment-closing.d.ts

@@ -0,0 +1,3 @@
+/** closeBundle runs after pending hooks; cancel adapter work when close begins. */
+declare function onEnvironmentClosing(environment: object, callback: () => void): void;
+export { onEnvironmentClosing };

package/dist/utils/environment-closing.js

@@ -0,0 +1,28 @@
+// src/utils/environment-closing.ts
+const states = /* @__PURE__ */ new WeakMap();
+/** closeBundle runs after pending hooks; cancel adapter work when close begins. */
+function onEnvironmentClosing(environment, callback) {
+	let state = states.get(environment);
+	if (!state) {
+		const owner = environment;
+		if (typeof owner.close !== "function") return;
+		const close = owner.close;
+		state = {
+			closing: false,
+			callbacks: /* @__PURE__ */ new Set()
+		};
+		states.set(environment, state);
+		const tracked = state;
+		owner.close = function() {
+			if (!tracked.closing) {
+				tracked.closing = true;
+				for (const cancel of tracked.callbacks) cancel();
+				tracked.callbacks.clear();
+			}
+			return close.call(this);
+		};
+	}
+	if (state.closing) callback();
+	else state.callbacks.add(callback);
+}
+export { onEnvironmentClosing };

package/dist/utils/extracted-css.d.ts

@@ -0,0 +1,4 @@
+import { MasterCSSVitePluginContext } from "../core.js";
+declare function getExtractedCSSResult(context: MasterCSSVitePluginContext): Promise<import("@master/css-compiler/stylesheet").MasterCSSStylesheetComposition>;
+declare function getExtractedCSS(context: MasterCSSVitePluginContext): Promise<string>;
+export { getExtractedCSS as default, getExtractedCSSResult };

package/dist/utils/extracted-css.js

@@ -0,0 +1,34 @@
+import { withSassDiagnostics } from "./sass-diagnostics.js";
+import { getScanner } from "./scanner-context.js";
+import { getBuildStylesheetDelivery } from "./build-stylesheet-delivery.js";
+import { getDevStylesheetDelivery, publishDevStylesheets } from "./dev-stylesheet-delivery.js";
+// src/utils/extracted-css.ts
+const revisions = /* @__PURE__ */ new WeakMap();
+async function getExtractedCSSResult(context) {
+	const revision = (revisions.get(context) ?? 0) + 1;
+	revisions.set(context, revision);
+	const scanner = getScanner(context);
+	if (!context.stylesheets) {
+		const { createStylesheetCollection } = await import("@master/css-compiler/stylesheet");
+		context.stylesheets = createStylesheetCollection();
+	}
+	const result = await withSassDiagnostics(context, () => context.stylesheets.compose({
+		scanner,
+		baseManifest: scanner.css.manifest,
+		projectDir: context.config?.root,
+		pruneNativeCSS: context.pruneNativeCSS,
+		includeGeneratedCSS: context.includeGeneratedCSS,
+		delivery: getBuildStylesheetDelivery(context) ?? getDevStylesheetDelivery(context)
+	}));
+	if (revisions.get(context) === revision && context.scanner === scanner) {
+		const changed = JSON.stringify(context.emittedGlobals) !== JSON.stringify(result.emittedGlobals);
+		context.emittedGlobals = result.emittedGlobals;
+		if (changed) context.onEmittedGlobalsChange?.();
+	}
+	return result;
+}
+async function getExtractedCSS(context) {
+	const result = await getExtractedCSSResult(context);
+	return context.config?.command === "serve" ? publishDevStylesheets(context, result, getScanner(context).slotCSSRule) : result.css;
+}
+export { getExtractedCSS as default, getExtractedCSSResult };

package/dist/utils/failed-dependency-reconciliation.d.ts

@@ -0,0 +1,15 @@
+import { ResolvedConfig, ViteDevServer } from "vite";
+import { MasterCSSVitePluginContext } from "../core.js";
+type FailedDependencyRecovery = (environment: object, id: string, changed: string[], active: () => boolean) => Promise<void>;
+/** Recheck only failed operations; successful stylesheets continue to use Vite HMR. */
+declare function configureFailedDependencyReconciliation(context: MasterCSSVitePluginContext, server: ViteDevServer, recover: FailedDependencyRecovery): void;
+/** Failed build transforms need a watched existing file to trigger another run. */
+declare function configureBuildDependencyReconciliation(context: MasterCSSVitePluginContext, watch: NonNullable<ResolvedConfig['build']['watch']>): void;
+/** A real host event already schedules compilation; avoid a duplicate fallback. */
+declare function acknowledgeFailedDependencyChange(context: MasterCSSVitePluginContext, file: string): void;
+/** Capture before the compiler reads a dependency, including its missing state. */
+declare function failedDependencyVersion(context: MasterCSSVitePluginContext, file: string): string | undefined;
+declare function trackFailedDependencyReconciliation(context: MasterCSSVitePluginContext, environment: object, key: string, id: string, versions: Map<string, string>, recover?: FailedDependencyRecovery): void;
+declare function forgetFailedDependencyReconciliation(context: MasterCSSVitePluginContext, environment: object, key: string): void;
+declare function clearFailedDependencyReconciliation(context: MasterCSSVitePluginContext, environment?: object): void;
+export { FailedDependencyRecovery, acknowledgeFailedDependencyChange, clearFailedDependencyReconciliation, configureBuildDependencyReconciliation, configureFailedDependencyReconciliation, failedDependencyVersion, forgetFailedDependencyReconciliation, trackFailedDependencyReconciliation };

package/dist/utils/failed-dependency-reconciliation.js

@@ -0,0 +1,150 @@
+import { normalizeFilePath } from "./path.js";
+import { statSync } from "node:fs";
+import { isAbsolute } from "node:path";
+import { createFilter } from "vite";
+import { stat } from "node:fs/promises";
+// src/utils/failed-dependency-reconciliation.ts
+const states = /* @__PURE__ */ new WeakMap();
+function version(stats) {
+	return `${stats.dev}:${stats.ino}:${stats.size}:${stats.mtimeMs}:${stats.ctimeMs}`;
+}
+function missing(error) {
+	return `error:${error.code ?? "unknown"}`;
+}
+/** Recheck only failed operations; successful stylesheets continue to use Vite HMR. */
+function configureFailedDependencyReconciliation(context, server, recover) {
+	clearFailedDependencyReconciliation(context);
+	const ignored = server.watcher.options.ignored;
+	const matchers = ignored === void 0 ? [] : Array.isArray(ignored) ? ignored : [ignored];
+	const filter = createFilter(void 0, matchers.filter((matcher) => typeof matcher !== "function"), { resolve: false });
+	states.set(context, {
+		pending: /* @__PURE__ */ new Map(),
+		closed: /* @__PURE__ */ new WeakSet(),
+		recover,
+		running: false,
+		accepts: (file, stats) => server.config.server.watch !== null && isAbsolute(file) && filter(file) && !matchers.some((matcher) => typeof matcher === "function" && matcher(file, stats))
+	});
+}
+/** Failed build transforms need a watched existing file to trigger another run. */
+function configureBuildDependencyReconciliation(context, watch) {
+	if (states.has(context)) return;
+	const accepts = createFilter(watch.include, watch.exclude, { resolve: false });
+	states.set(context, {
+		pending: /* @__PURE__ */ new Map(),
+		closed: /* @__PURE__ */ new WeakSet(),
+		running: false,
+		recover: async () => {},
+		accepts: (file) => isAbsolute(file) && accepts(file)
+	});
+}
+/** A real host event already schedules compilation; avoid a duplicate fallback. */
+function acknowledgeFailedDependencyChange(context, file) {
+	file = normalizeFilePath(file);
+	const state = states.get(context);
+	if (!state) return;
+	const value = failedDependencyVersion(context, file);
+	if (value === void 0) return;
+	for (const jobs of state.pending.values()) for (const entry of jobs.values()) if (entry.versions.has(file)) entry.versions.set(file, value);
+}
+/** Capture before the compiler reads a dependency, including its missing state. */
+function failedDependencyVersion(context, file) {
+	const state = states.get(context);
+	if (!state || !isAbsolute(file)) return;
+	let stats, value;
+	try {
+		stats = statSync(file);
+		value = version(stats);
+	} catch (error) {
+		value = missing(error);
+	}
+	return state.accepts(file, stats) ? value : void 0;
+}
+function trackFailedDependencyReconciliation(context, environment, key, id, versions, recover) {
+	const state = states.get(context);
+	if (!state || state.closed.has(environment) || !versions.size) return;
+	let pending = state.pending.get(environment);
+	if (!pending) {
+		pending = /* @__PURE__ */ new Map();
+		state.pending.set(environment, pending);
+	}
+	pending.set(key, {
+		id,
+		versions,
+		recover
+	});
+	schedule(context, state);
+}
+function forgetFailedDependencyReconciliation(context, environment, key) {
+	const state = states.get(context), pending = state?.pending.get(environment);
+	pending?.delete(key);
+	if (!pending?.size) state?.pending.delete(environment);
+	if (state && !state.pending.size) {
+		clearTimeout(state.timer);
+		state.timer = void 0;
+	}
+}
+function clearFailedDependencyReconciliation(context, environment) {
+	const state = states.get(context);
+	if (!state) return;
+	if (environment) {
+		state.closed.add(environment);
+		state.pending.delete(environment);
+	} else {
+		state.pending.clear();
+		states.delete(context);
+	}
+	if (!state.pending.size) {
+		clearTimeout(state.timer);
+		state.timer = void 0;
+	}
+}
+function schedule(context, state) {
+	if (state.timer || state.running || !state.pending.size || states.get(context) !== state) return;
+	state.timer = setTimeout(() => {
+		state.timer = void 0;
+		reconcile(context, state);
+	}, 100);
+	state.timer.unref();
+}
+async function reconcile(context, state) {
+	state.running = true;
+	try {
+		const jobs = [...state.pending].flatMap(([environment, entries]) => [...entries].map(([key, entry]) => ({
+			environment,
+			key,
+			entry
+		})));
+		const files = [...new Set(jobs.flatMap(({ entry }) => [...entry.versions.keys()]))];
+		const current = new Map(await Promise.all(files.map(async (file) => {
+			let stats, value;
+			try {
+				stats = await stat(file);
+				value = version(stats);
+			} catch (error) {
+				value = missing(error);
+			}
+			return [file, state.accepts(file, stats) ? value : void 0];
+		})));
+		for (const { environment, key, entry } of jobs) {
+			const active = () => states.get(context) === state && !state.closed.has(environment);
+			if (!active() || state.pending.get(environment)?.get(key) !== entry) continue;
+			const changed = [];
+			for (const [file, before] of entry.versions) {
+				const after = current.get(file);
+				if (after === void 0) entry.versions.delete(file);
+				else if (after !== before) {
+					entry.versions.set(file, after);
+					changed.push(file);
+				}
+			}
+			if (!entry.versions.size) forgetFailedDependencyReconciliation(context, environment, key);
+			if (changed.length) try {
+				await (entry.recover ?? state.recover)(environment, entry.id, changed, active);
+			} catch {}
+		}
+	} finally {
+		state.running = false;
+		schedule(context, state);
+	}
+}
+export { acknowledgeFailedDependencyChange, clearFailedDependencyReconciliation, configureBuildDependencyReconciliation, configureFailedDependencyReconciliation, failedDependencyVersion, forgetFailedDependencyReconciliation, trackFailedDependencyReconciliation };

package/dist/utils/failed-stylesheet-dependencies.d.ts

@@ -0,0 +1,16 @@
+import { ViteDevServer } from "vite";
+import { MasterCSSVitePluginContext } from "../core.js";
+import { FailedDependencyRecovery } from "./failed-dependency-reconciliation.js";
+interface DependencyHost {
+  environment?: object;
+  addWatchFile?(file: string): void;
+}
+declare function configureStylesheetRecovery(context: MasterCSSVitePluginContext, watcher: ViteDevServer['watcher']): void;
+/** Keep current host dependencies without retaining Vite CSS file-only graph edges. */
+declare function withStylesheetDependencies<T>(context: MasterCSSVitePluginContext, host: DependencyHost, id: string, operation: (onDependency: (file: string) => void) => Promise<T>, scope?: string, recover?: FailedDependencyRecovery): Promise<T>;
+declare function stylesheetDependencyOwners(context: MasterCSSVitePluginContext, environment: object, file: string): {
+  id: string;
+  failed: boolean;
+}[];
+declare function clearFailedStylesheets(context: MasterCSSVitePluginContext, environment?: object): void;
+export { DependencyHost, clearFailedStylesheets, configureStylesheetRecovery, stylesheetDependencyOwners, withStylesheetDependencies };

package/dist/utils/failed-stylesheet-dependencies.js

@@ -0,0 +1,92 @@
+import { normalizeFilePath } from "./path.js";
+import { clearFailedDependencyReconciliation, failedDependencyVersion, forgetFailedDependencyReconciliation, trackFailedDependencyReconciliation } from "./failed-dependency-reconciliation.js";
+import { trackBuildStylesheetRecovery } from "./build-watch-recovery.js";
+import { existsSync } from "node:fs";
+import { dirname, isAbsolute } from "node:path";
+// src/utils/failed-stylesheet-dependencies.ts
+const watchers = /* @__PURE__ */ new WeakMap();
+function configureStylesheetRecovery(context, watcher) {
+	failures.delete(context);
+	watchers.set(context, watcher);
+}
+function watchDependency(context, file) {
+	if (!isAbsolute(file)) return;
+	let watchedPath = file;
+	while (!existsSync(watchedPath)) {
+		const parent = dirname(watchedPath);
+		if (parent === watchedPath) break;
+		watchedPath = parent;
+	}
+	watchers.get(context)?.add(watchedPath);
+}
+const failures = /* @__PURE__ */ new WeakMap();
+function forEnvironment(context, environment) {
+	let environments = failures.get(context);
+	if (!environments) {
+		environments = /* @__PURE__ */ new WeakMap();
+		failures.set(context, environments);
+	}
+	let modules = environments.get(environment);
+	if (!modules) {
+		modules = /* @__PURE__ */ new Map();
+		environments.set(environment, modules);
+	}
+	return modules;
+}
+/** Keep current host dependencies without retaining Vite CSS file-only graph edges. */
+async function withStylesheetDependencies(context, host, id, operation, scope = "local", recover) {
+	const key = `${scope}:${id}`;
+	const dependencies = /* @__PURE__ */ new Set();
+	const modules = host.environment && context.config?.command === "serve" ? forEnvironment(context, host.environment) : void 0;
+	const versions = /* @__PURE__ */ new Map();
+	const buildRecovery = context.config?.command === "build" && Boolean(context.config.build?.watch);
+	const environment = host.environment ?? context;
+	if (modules || buildRecovery) forgetFailedDependencyReconciliation(context, environment, key);
+	try {
+		const result = await operation((file) => {
+			if (file.includes("\0")) return;
+			file = normalizeFilePath(file);
+			if ((modules || buildRecovery) && !dependencies.has(file)) {
+				const version = failedDependencyVersion(context, file);
+				if (version !== void 0) versions.set(file, version);
+			}
+			dependencies.add(file);
+			if (modules && watchers.has(context)) watchDependency(context, file);
+			else host.addWatchFile?.(file);
+		});
+		if (modules && dependencies.size) modules.set(key, {
+			id,
+			dependencies,
+			failed: false
+		});
+		else modules?.delete(key);
+		return result;
+	} catch (error) {
+		if (modules && dependencies.size) {
+			modules.set(key, {
+				id,
+				dependencies,
+				failed: true
+			});
+			trackFailedDependencyReconciliation(context, host.environment, key, id, versions, recover);
+			for (const file of dependencies) watchDependency(context, file);
+		}
+		if (buildRecovery) trackBuildStylesheetRecovery(context, host, key, id, versions);
+		throw error;
+	}
+}
+function stylesheetDependencyOwners(context, environment, file) {
+	file = normalizeFilePath(file);
+	const owners = /* @__PURE__ */ new Map();
+	for (const entry of failures.get(context)?.get(environment)?.values() ?? []) if (entry.dependencies.has(file)) owners.set(entry.id, {
+		id: entry.id,
+		failed: entry.failed || Boolean(owners.get(entry.id)?.failed)
+	});
+	return [...owners.values()];
+}
+function clearFailedStylesheets(context, environment) {
+	clearFailedDependencyReconciliation(context, environment);
+	if (environment) failures.get(context)?.delete(environment);
+	else failures.delete(context);
+}
+export { clearFailedStylesheets, configureStylesheetRecovery, stylesheetDependencyOwners, withStylesheetDependencies };

package/dist/utils/html.d.ts

@@ -0,0 +1,8 @@
+declare function escapeRegExp(source: string): string;
+declare function toAssetHref(fileName: string, base?: string, htmlPath?: string): string;
+declare function hasModulePreloadLink(html: string, href: string, options?: {
+  as?: string;
+}): boolean;
+/** A `<link rel="preload" as="fetch">` without a type, as runtime programs use. */
+declare function hasFetchPreloadLink(html: string, href: string): boolean;
+export { escapeRegExp, hasFetchPreloadLink, hasModulePreloadLink, toAssetHref };

package/dist/utils/html.js

@@ -0,0 +1,36 @@
+// src/utils/html.ts
+function splitPathSegments(path) {
+	return path.split("/").filter(Boolean);
+}
+function getHTMLDirectorySegments(path = "/index.html") {
+	const cleanPath = path.split(/[?#]/)[0] || "/index.html";
+	const segments = splitPathSegments(cleanPath);
+	if (!cleanPath.endsWith("/")) segments.pop();
+	return segments;
+}
+function toRelativeAssetHref(fileName, htmlPath) {
+	const fromSegments = getHTMLDirectorySegments(htmlPath);
+	const toSegments = splitPathSegments(fileName);
+	let common = 0;
+	while (common < fromSegments.length && common < toSegments.length && fromSegments[common] === toSegments[common]) common += 1;
+	return [...Array.from({ length: fromSegments.length - common }, () => ".."), ...toSegments.slice(common)].join("/") || ".";
+}
+function escapeRegExp(source) {
+	return source.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function toAssetHref(fileName, base = "/", htmlPath) {
+	const normalizedFileName = fileName.replace(/^\/+/, "");
+	if (base && base !== "./") return `${base.replace(/\/?$/, "/")}${normalizedFileName}`;
+	return toRelativeAssetHref(normalizedFileName, htmlPath);
+}
+function hasModulePreloadLink(html, href, options) {
+	const quotedHref = escapeRegExp(href);
+	const asPattern = options?.as ? String.raw`(?=[^>]*\bas=(?:"${escapeRegExp(options.as)}"|'${escapeRegExp(options.as)}'))` : "";
+	return new RegExp(String.raw`<link\b(?=[^>]*\brel=(?:"modulepreload"|'modulepreload'))${asPattern}(?=[^>]*\bhref=(?:"${quotedHref}"|'${quotedHref}'))[^>]*>`, "i").test(html);
+}
+/** A `<link rel="preload" as="fetch">` without a type, as runtime programs use. */
+function hasFetchPreloadLink(html, href) {
+	const quotedHref = escapeRegExp(href);
+	return new RegExp(String.raw`<link\b(?=[^>]*\brel=(?:"preload"|'preload'))(?=[^>]*\bas=(?:"fetch"|'fetch'))(?=[^>]*\bhref=(?:"${quotedHref}"|'${quotedHref}'))[^>]*>`, "i").test(html);
+}
+export { escapeRegExp, hasFetchPreloadLink, hasModulePreloadLink, toAssetHref };

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

@@ -0,0 +1,37 @@
+import { ResolvedConfig } from "vite";
+import { MasterCSSStylesheetCollection, MasterCSSStylesheetDeliveryOptions, MasterCSSStylesheetTransformResult } from "@master/css-compiler/stylesheet";
+import { MasterCSSVitePluginContext } from "../core.js";
+interface InlineStylesheet {
+  collection: MasterCSSStylesheetCollection;
+  local?: MasterCSSStylesheetTransformResult;
+  token: string;
+  reference?: string;
+  css?: string;
+  urlMarker?: string;
+  files?: Map<string, string>;
+}
+declare const INLINE_URL_BASE = "https://master-css-inline.invalid/";
+declare function inlineDigest(value: string): string;
+declare function isInlineStylesheet(id: string): boolean;
+declare function inlineStylesheets(context: MasterCSSVitePluginContext): Map<string, InlineStylesheet>;
+declare function disposeInlineStylesheets(context: MasterCSSVitePluginContext): void;
+declare function inlineDelivery(context: MasterCSSVitePluginContext): MasterCSSStylesheetDeliveryOptions;
+declare function registerInlineStylesheet(context: MasterCSSVitePluginContext, id: string, source: string, host: Pick<MasterCSSStylesheetDeliveryOptions, 'resolveImport' | 'onDependency'>): Promise<import("@master/css-compiler").MasterCSSCompileResult>;
+declare function registerLocalInlineStylesheet(context: MasterCSSVitePluginContext, id: string, local: MasterCSSStylesheetTransformResult): void;
+/** Return resource/import references using the compiler's source analysis. */
+declare function inlineURLReferences(compiler: import('@master/css-compiler').MasterCSSCompiler, css: string): {
+  readonly start: number;
+  readonly end: number;
+  readonly url: string;
+}[];
+/** Rewrite host-issued URLs only at Rust-reported resource/import ranges. */
+declare function rewriteInlineURLs(compiler: import('@master/css-compiler').MasterCSSCompiler, css: string, target: (url: string) => string, ownedURLs: ReadonlySet<string>): string;
+/** Apply Vite's public output URL hook to the actual referenced file. */
+declare function inlineBuiltURL(config: Pick<ResolvedConfig, 'base' | 'experimental'>, ssr: boolean, filename: string, hostId: string, hostType: 'js' | 'css'): {
+  url: string;
+} | {
+  runtime: string;
+} | {
+  relative: true;
+};
+export { INLINE_URL_BASE, InlineStylesheet, disposeInlineStylesheets, inlineBuiltURL, inlineDelivery, inlineDigest, inlineStylesheets, inlineURLReferences, isInlineStylesheet, registerInlineStylesheet, registerLocalInlineStylesheet, rewriteInlineURLs };