@animus-ui/layergate 0.0.0-stage → 0.1.35

package/dist/vite.mjs

@@ -0,0 +1,290 @@
+import { t as readSheet } from "./sheet-DJGhbeYI.mjs";
+import { t as compileUnit } from "./compile-Cu_GFS3l.mjs";
+import { n as resolvePlan } from "./plan-Bsn_yxS9.mjs";
+import { a as real, i as ownership, n as fileOf, o as resolveEach, r as formatDiagnostic, t as Units } from "./host-BGcb1rMJ.mjs";
+import { createRequire } from "node:module";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { watch } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { createIdResolver, isCSSRequest, isFileLoadingAllowed, normalizePath, searchForWorkspaceRoot } from "vite";
+//#region src/vite.ts
+/**
+* The Vite adapter. layergate owns the load of each selected stylesheet:
+* the declared sheets, which `virtual:layergate` (or a host's own
+* stylesheet, `declaredBy`) delivers as one finished stylesheet, and, opted
+* in, the `.css` a JS module imports from another package, which loads as
+* `<realpath>?layergate`. Each finished stylesheet has no local `@import`
+* left, and Vite's own CSS pipeline then processes it once: PostCSS,
+* minification, injection or extraction. A JS module's import of an owned
+* sheet reaches it through a proxy that imports the declared sheets first,
+* so they keep their order wherever the app imports an owned sheet first.
+* A stylesheet Vite loads itself that is owned, or reaches an owned file,
+* is finished in `transform`. CSS Modules and special requests (`?inline`,
+* `?url`, `?raw`) stay Vite's.
+*/
+const OWNED = "?layergate";
+const ENTRY_ID = "virtual:layergate";
+/** `virtual:layergate` is a stylesheet: the declared sheets, finished. */
+const RESOLVED_ENTRY = `\0${ENTRY_ID}.css`;
+/** A JS module's import of an owned sheet: the declared sheets, then it.
+*  Its id names the file encoded and ends in `.js`, so Vite never takes it
+*  for a stylesheet. */
+const PROXY = "\0layergate-proxy:";
+const proxyId = (file) => `${PROXY}${encodeURIComponent(file)}.js`;
+const proxiedFile = (id) => decodeURIComponent(id.slice(17, -3));
+const PLAIN_CSS = /\.css$/;
+const MODULE_CSS = /\.module\.css$/;
+/** The stylesheet a request id names when the request is plain stylesheet
+*  delivery: no query, or only Vite's `direct` (a stylesheet an HTML link
+*  loads in development) and its `t`/`v` cache-busting params. Special
+*  requests (`?inline`, `?url`, `?raw`) and CSS Modules are not. */
+function plainCssFile(id) {
+	const at = id.indexOf("?");
+	const path = at === -1 ? id : id.slice(0, at);
+	if (!PLAIN_CSS.test(path) || MODULE_CSS.test(path)) return null;
+	return (at === -1 ? [] : id.slice(at + 1).split("&")).every((param) => param === "direct" || /^[tv]=/.test(param)) ? path : null;
+}
+/** Whether `file` lies outside the directory `root`. */
+const outside = (root, file) => {
+	const path = relative(root, file);
+	return path.startsWith("..") || isAbsolute(path);
+};
+function layergate(options = {}) {
+	const plan = resolvePlan(options);
+	const declaredBy = options.declaredBy ?? ENTRY_ID;
+	let root = process.cwd();
+	const owner = ownership(plan);
+	const { owns, owning } = owner;
+	/** `@import` inside an owned sheet resolves as Vite resolves a CSS
+	*  import: the `style` field and condition, CSS files only. */
+	let resolveCss;
+	/** Declared sheets, in order. */
+	let optedOut = /* @__PURE__ */ new Set();
+	/** Parsed files, the files each owned id's finished stylesheet read,
+	*  and reach answers. */
+	const units = new Units();
+	/** Each module's finished declared head, kept until a file it read
+	*  changes. */
+	const heads = /* @__PURE__ */ new Map();
+	let server;
+	/** Vite's watcher ignores node_modules, so an owned file there is
+	*  watched here through its directory, which sees edits, atomic saves,
+	*  deletion and creation alike, and its change handed to Vite's HMR. One
+	*  watch serves every owned file of a directory. */
+	const directories = /* @__PURE__ */ new Map();
+	const unwatch = (file) => {
+		const dir = dirname(file);
+		const watched = directories.get(dir);
+		watched?.files.delete(file);
+		if (watched?.files.size === 0) {
+			watched.watcher.close();
+			directories.delete(dir);
+		}
+	};
+	const watchInstalled = (file) => {
+		if (!server || !file.includes("/node_modules/")) return;
+		const dir = dirname(file);
+		const watched = directories.get(dir);
+		if (watched) {
+			watched.files.add(file);
+			return;
+		}
+		try {
+			const files = /* @__PURE__ */ new Set([file]);
+			const watcher = watch(dir, (_event, name) => {
+				const changed = name ? `${dir}/${basename(name)}` : null;
+				if (changed && files.has(changed)) server?.watcher.emit("change", changed);
+			});
+			directories.set(dir, {
+				watcher,
+				files
+			});
+		} catch {}
+	};
+	/** Records the files `id`'s finished stylesheet read, forgetting and
+	*  unwatching what it no longer reads. */
+	const reconcile = (id, files) => {
+		for (const file of units.record(id, files)) unwatch(file);
+		for (const file of files) watchInstalled(file);
+	};
+	/** A root-relative URL for `target`, which Vite resolves from any
+	*  stylesheet, its own virtual ones too; one outside the root through
+	*  Vite's `/@fs/`, which the dev server serves only inside
+	*  `server.fs.allow`: the directory of an owned file outside it is
+	*  allowed, and nothing more. */
+	const rootUrl = (target) => {
+		if (!outside(real(root), target)) return `/${normalizePath(relative(real(root), target))}`;
+		if (server && !isFileLoadingAllowed(server.config, normalizePath(target))) server.config.server.fs.allow.push(normalizePath(dirname(target)));
+		return `/@fs${normalizePath(target)}`;
+	};
+	/** The file an `@import` in `importer` reaches, as Vite resolves CSS. */
+	const resolveImport = async (context, specifier, importer) => {
+		const resolved = await resolveCss?.(context.environment, specifier, importer);
+		return resolved && PLAIN_CSS.test(fileOf(resolved)) ? fileOf(resolved) : null;
+	};
+	/** Compiles `roots` with the host's CSS resolver, the plan and the
+	*  parsed-file cache. */
+	const finish = (context, roots, extra = {}) => compileUnit(roots, {
+		layer: plan.layer,
+		order: plan.order,
+		base: root,
+		resolve: (specifier, from) => resolveImport(context, specifier, from),
+		read: (file) => readFile(file, "utf8"),
+		quarantined: (file) => !optedOut.has(file),
+		owns,
+		cache: units.parsed,
+		...extra
+	});
+	/** Reports `unit`'s diagnostics through `context` and records the files
+	*  module `id` now reads. */
+	const publish = (context, id, unit) => {
+		for (const file of unit.files) context.addWatchFile(file);
+		reconcile(id, unit.files);
+		for (const diagnostic of unit.diagnostics) {
+			const message = formatDiagnostic(diagnostic);
+			if (diagnostic.severity === "error") context.error(message);
+			else if (diagnostic.severity === "warning") context.warn(message);
+			else context.info(message);
+		}
+	};
+	/** The declared sheets as one finished stylesheet for module `id`, with
+	*  root-relative URLs; empty when nothing is declared. */
+	const head = async (context, id) => {
+		if (owner.declared.length === 0) return "";
+		const kept = heads.get(id);
+		if (kept !== void 0) return kept;
+		const unit = await finish(context, owner.declared, {
+			url: rootUrl,
+			map: false
+		});
+		publish(context, id, unit);
+		heads.set(id, unit.css);
+		return unit.css;
+	};
+	return Object.assign({
+		name: "layergate",
+		enforce: "pre",
+		config(userConfig, env) {
+			if (env.command !== "serve") return;
+			const base = resolve(userConfig.root ?? process.cwd());
+			const require = createRequire(join(base, "package.json"));
+			const dirs = [];
+			for (const specifier of plan.sheets) {
+				let file;
+				try {
+					file = real(specifier.startsWith(".") || isAbsolute(specifier) ? resolve(base, specifier) : require.resolve(specifier));
+				} catch {
+					continue;
+				}
+				if (outside(real(base), file)) dirs.push(dirname(file));
+			}
+			if (dirs.length === 0) return;
+			return { server: { fs: { allow: userConfig.server?.fs?.allow ? dirs : [searchForWorkspaceRoot(base), ...dirs] } } };
+		},
+		configResolved(config) {
+			root = config.root;
+			owner.reset(root, []);
+			resolveCss = createIdResolver(config, {
+				extensions: [".css"],
+				mainFields: ["style"],
+				conditions: ["style", "development|production"],
+				tryIndex: false,
+				preferRelative: true
+			});
+		},
+		configureServer(devServer) {
+			server = devServer;
+		},
+		buildEnd() {
+			for (const { watcher } of directories.values()) watcher.close();
+			directories.clear();
+		},
+		async buildStart() {
+			const importer = join(root, "index.html");
+			const resolveOne = async (specifier) => {
+				const resolved = await this.resolve(specifier, importer, { skipSelf: true });
+				return resolved && !resolved.external ? fileOf(resolved.id) : null;
+			};
+			const declared = await resolveEach(plan.sheets, "sheets", root, resolveOne);
+			owner.reset(root, declared);
+			const cssModule = declared.find((file) => MODULE_CSS.test(file));
+			if (cssModule) this.error(`[layergate] sheets: ${cssModule} is a CSS Module; layergate does not own CSS Modules yet`);
+			optedOut = new Set(await resolveEach(plan.optOut, "optOut", root, resolveOne));
+			heads.clear();
+		},
+		async resolveId(source, importer, resolveOptions) {
+			if (source === ENTRY_ID) return RESOLVED_ENTRY;
+			if (source.endsWith(OWNED) || source.startsWith(PROXY)) return source;
+			if (!owning()) return null;
+			if (!importer || importer.startsWith("\0") || isCSSRequest(importer)) return null;
+			if (source.includes("?") || !PLAIN_CSS.test(source)) return null;
+			const resolved = await this.resolve(source, importer, {
+				...resolveOptions,
+				skipSelf: true
+			});
+			if (!resolved || resolved.external) return null;
+			const file = fileOf(resolved.id);
+			if (!PLAIN_CSS.test(file) || MODULE_CSS.test(file)) return null;
+			return owns(file) ? proxyId(file) : null;
+		},
+		async load(id) {
+			if (id === RESOLVED_ENTRY) return head(this, id);
+			if (id.startsWith(PROXY)) {
+				const file = proxiedFile(id);
+				return (owner.declared.includes(file) ? [declaredBy] : [declaredBy, file + OWNED]).map((request) => `import ${JSON.stringify(request)};`).join("\n");
+			}
+			if (!id.endsWith(OWNED)) return null;
+			const unit = await finish(this, [id.slice(0, -10)]);
+			publish(this, id, unit);
+			return {
+				code: unit.css,
+				map: unit.map
+			};
+		},
+		async transform(code, id) {
+			if (!owning() || id.startsWith("\0")) return null;
+			const requested = plainCssFile(id);
+			if (!requested) return null;
+			const file = real(requested);
+			const { imports } = readSheet(code);
+			if (!owns(file) && imports.length === 0) return null;
+			if (!await units.reaches(file, imports, {
+				resolve: (specifier, from) => resolveImport(this, specifier, from),
+				read: (path) => readFile(path, "utf8"),
+				owns
+			})) return null;
+			units.parsed.delete(file);
+			const unit = await finish(this, [file], { read: (path) => path === file ? code : readFile(path, "utf8") });
+			publish(this, id, unit);
+			return {
+				code: unit.css,
+				map: unit.map
+			};
+		},
+		hotUpdate({ file, modules }) {
+			const stale = units.changed(normalizePath(file));
+			if (stale.size === 0) return;
+			const graph = this.environment.moduleGraph;
+			const affected = [];
+			for (const id of stale) {
+				heads.delete(id);
+				const node = graph.getModuleById(id);
+				if (!node) continue;
+				graph.invalidateModule(node);
+				affected.push(node);
+			}
+			return [...modules, ...affected];
+		}
+	}, { 
+	/**
+	* The declared sheets as one finished stylesheet, for a host that
+	* delivers them at the head of its own stylesheet module `id` (and
+	* names it `declaredBy`): URLs are root-relative, and an edit to any
+	* file read updates module `id`. Empty when nothing is declared.
+	*/
+stylesheetHead(id) {
+		return head(this, id);
+	} });
+}
+//#endregion
+export { layergate as default, layergate };

package/dist/webpack-loader.cjs

@@ -0,0 +1,104 @@
+const require_compile = require("./compile-C4GyCiuY.cjs");
+const require_sheet = require("./sheet-BUnyt5Jt.cjs");
+const require_host = require("./host-C4ZaMdkx.cjs");
+const require_webpack_state = require("./webpack-state-BtmtzsWZ.cjs");
+let node_path = require("node:path");
+//#region src/webpack-loader.ts
+/**
+* layergate's webpack loader. It runs on each global stylesheet before
+* PostCSS and css-loader (the plugin inserts it so). The declared sheets'
+* stylesheet gets them at its head; a declared sheet a module imports
+* itself loads nothing; an owned stylesheet is finished as an owned graph;
+* an app stylesheet whose imports reach an owned file is finished with its
+* own rules unlayered; anything else passes through. A finished stylesheet
+* has no local `@import` left, and a remote one that would need a layer is
+* refused: Next's css-loader renders `layer()` as media.
+*/
+/** A file through the compiler's file system. */
+const readFrom = (context) => (path) => new Promise((done, fail) => context.fs.readFile(path, (error, data) => error ? fail(error) : done(String(data))));
+/** The file an `@import` in `importer` reaches, where css-loader would
+*  reach it: by realpath unless `resolve.symlinks` is false. */
+const resolveFrom = (context) => {
+	const resolver = context.getResolve(require_webpack_state.CSS_RESOLVE);
+	return async (specifier, importer) => {
+		const resolved = await resolver((0, node_path.dirname)(importer), specifier).catch(() => null);
+		return resolved ? require_host.slashes(resolved) : null;
+	};
+};
+async function finish(context, state, file, source, roots, extra = {}) {
+	const readFile = readFrom(context);
+	const read = (path) => path === file ? Promise.resolve(source) : readFile(path);
+	state.units.parsed.delete(file);
+	const { units, owner, optedOut, declaredBy } = state;
+	const unit = await require_compile.compileUnit(roots, {
+		layer: state.plan.layer,
+		order: state.plan.order,
+		base: context.rootContext,
+		resolve: resolveFrom(context),
+		read,
+		quarantined: (path) => {
+			const canonical = units.canonical(path);
+			return !optedOut.has(canonical) && canonical !== declaredBy;
+		},
+		owns: (path) => owner.owns(units.canonical(path)),
+		remote: "refuse",
+		cache: state.units.parsed,
+		...extra
+	});
+	state.units.record(file, unit.files);
+	for (const path of unit.files) context.addDependency(path);
+	for (const diagnostic of unit.diagnostics) {
+		const error = new Error(require_host.formatDiagnostic(diagnostic));
+		if (diagnostic.severity === "error") context.emitError(error);
+		else if (diagnostic.severity === "warning") context.emitWarning(error);
+	}
+	return unit;
+}
+async function run(context, source) {
+	const state = require_webpack_state.registry().states.get(context.getOptions().id ?? "");
+	if (!state) return null;
+	const file = require_host.slashes(context.resourcePath);
+	const id = state.units.canonical(file);
+	const { owner, declaredBy } = state;
+	if (id === declaredBy) {
+		if (owner.declared.length === 0) return null;
+		const unit = await finish(context, state, file, source, state.roots, {
+			delivery: file,
+			map: false
+		});
+		context.cacheable(false);
+		return {
+			code: `${unit.css}\n${source}`,
+			map: null
+		};
+	}
+	if (!owner.owning()) return null;
+	if (declaredBy && owner.declared.includes(id)) {
+		context.cacheable(false);
+		return {
+			code: "",
+			map: null
+		};
+	}
+	if (!owner.owns(id)) {
+		const { imports } = require_sheet.readSheet(source);
+		if (imports.length === 0) return null;
+		if (!await state.units.reaches(file, imports, {
+			resolve: resolveFrom(context),
+			read: readFrom(context),
+			owns: (path) => owner.owns(state.units.canonical(path))
+		})) return null;
+	}
+	const unit = await finish(context, state, file, source, [file]);
+	context.cacheable(false);
+	return {
+		code: unit.css,
+		map: unit.map
+	};
+}
+function layergateLoader(source, map, meta) {
+	const done = this.async();
+	run(this, source).then((finished) => finished ? done(null, finished.code, finished.map) : done(null, source, map, meta), (error) => done(error));
+}
+//#endregion
+module.exports = layergateLoader;

package/dist/webpack-loader.d.cts

@@ -0,0 +1,35 @@
+import { n as CompiledUnit } from "./compile-DZwVBjTM.cjs";
+import { t as CSS_RESOLVE } from "./webpack-state-BpF2PPjA.cjs";
+//#region src/webpack-loader.d.ts
+type SourceMap = CompiledUnit['map'];
+/** The source map and metadata the loaders before this one passed on,
+ *  handed through untouched when the stylesheet passes. */
+interface IncomingMap {
+  readonly mappings?: string;
+}
+interface IncomingMeta {
+  readonly ast?: {
+    readonly type?: string;
+  };
+}
+/** The loader context, as far as layergate reads it. */
+interface LoaderContext {
+  resourcePath: string;
+  rootContext: string;
+  getOptions(): {
+    id?: string;
+  };
+  /** Whether webpack may cache this module's build. */
+  cacheable(flag: boolean): void;
+  async(): (error: Error | null, code?: string, map?: SourceMap | IncomingMap, meta?: IncomingMeta) => void;
+  getResolve(options: typeof CSS_RESOLVE): (context: string, request: string) => Promise<string | false>;
+  fs: {
+    readFile(path: string, done: (error: Error | null, data?: Buffer | string) => void): void;
+  };
+  addDependency(file: string): void;
+  emitError(error: Error): void;
+  emitWarning(error: Error): void;
+}
+declare function layergateLoader(this: LoaderContext, source: string, map?: IncomingMap, meta?: IncomingMeta): void;
+export = layergateLoader;
+//# sourceMappingURL=webpack-loader.d.cts.map

package/dist/webpack-loader.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webpack-loader.d.cts","names":[],"sources":["../src/webpack-loader.ts"],"mappings":";;;KAoBK,YAAY;;;UAIP;WACC;;UAED;WACC;aAAiB;;;;UAIlB;EACR;EACA;EACA;IAAgB;;;EAEhB,UAAU;EACV,UACE,OAAO,cACP,eACA,MAAM,YAAY,aAClB,OAAO;EAET,WACE,gBAAgB,eACd,iBAAiB,oBAAoB;EACzC;IACE,SACE,cACA,OAAO,OAAO,cAAc,OAAO;;EAGvC,cAAc;EACd,UAAU,OAAO;EACjB,YAAY,OAAO;;iBA6GG,gBACtB,MAAM,eACN,gBACA,MAAM,aACN,OAAO"}

package/dist/webpack-loader.d.mts

@@ -0,0 +1,36 @@
+import { n as CompiledUnit } from "./compile-DZwVBjTM.mjs";
+import { t as CSS_RESOLVE } from "./webpack-state-CXoQQ7XR.mjs";
+//#region src/webpack-loader.d.ts
+type SourceMap = CompiledUnit['map'];
+/** The source map and metadata the loaders before this one passed on,
+ *  handed through untouched when the stylesheet passes. */
+interface IncomingMap {
+  readonly mappings?: string;
+}
+interface IncomingMeta {
+  readonly ast?: {
+    readonly type?: string;
+  };
+}
+/** The loader context, as far as layergate reads it. */
+interface LoaderContext {
+  resourcePath: string;
+  rootContext: string;
+  getOptions(): {
+    id?: string;
+  };
+  /** Whether webpack may cache this module's build. */
+  cacheable(flag: boolean): void;
+  async(): (error: Error | null, code?: string, map?: SourceMap | IncomingMap, meta?: IncomingMeta) => void;
+  getResolve(options: typeof CSS_RESOLVE): (context: string, request: string) => Promise<string | false>;
+  fs: {
+    readFile(path: string, done: (error: Error | null, data?: Buffer | string) => void): void;
+  };
+  addDependency(file: string): void;
+  emitError(error: Error): void;
+  emitWarning(error: Error): void;
+}
+export default function layergateLoader(this: LoaderContext, source: string, map?: IncomingMap, meta?: IncomingMeta): void;
+//#endregion
+export {};
+//# sourceMappingURL=webpack-loader.d.mts.map

package/dist/webpack-loader.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webpack-loader.d.mts","names":[],"sources":["../src/webpack-loader.ts"],"mappings":";;;KAoBK,YAAY;;;UAIP;WACC;;UAED;WACC;aAAiB;;;;UAIlB;EACR;EACA;EACA;IAAgB;;;EAEhB,UAAU;EACV,UACE,OAAO,cACP,eACA,MAAM,YAAY,aAClB,OAAO;EAET,WACE,gBAAgB,eACd,iBAAiB,oBAAoB;EACzC;IACE,SACE,cACA,OAAO,OAAO,cAAc,OAAO;;EAGvC,cAAc;EACd,UAAU,OAAO;EACjB,YAAY,OAAO;;wBA6GG,gBACtB,MAAM,eACN,gBACA,MAAM,aACN,OAAO"}

package/dist/webpack-loader.mjs

@@ -0,0 +1,104 @@
+import { t as readSheet } from "./sheet-DJGhbeYI.mjs";
+import { t as compileUnit } from "./compile-Cu_GFS3l.mjs";
+import { r as formatDiagnostic, s as slashes } from "./host-BGcb1rMJ.mjs";
+import { r as registry, t as CSS_RESOLVE } from "./webpack-state-DwltSkQq.mjs";
+import { dirname } from "node:path";
+//#region src/webpack-loader.ts
+/**
+* layergate's webpack loader. It runs on each global stylesheet before
+* PostCSS and css-loader (the plugin inserts it so). The declared sheets'
+* stylesheet gets them at its head; a declared sheet a module imports
+* itself loads nothing; an owned stylesheet is finished as an owned graph;
+* an app stylesheet whose imports reach an owned file is finished with its
+* own rules unlayered; anything else passes through. A finished stylesheet
+* has no local `@import` left, and a remote one that would need a layer is
+* refused: Next's css-loader renders `layer()` as media.
+*/
+/** A file through the compiler's file system. */
+const readFrom = (context) => (path) => new Promise((done, fail) => context.fs.readFile(path, (error, data) => error ? fail(error) : done(String(data))));
+/** The file an `@import` in `importer` reaches, where css-loader would
+*  reach it: by realpath unless `resolve.symlinks` is false. */
+const resolveFrom = (context) => {
+	const resolver = context.getResolve(CSS_RESOLVE);
+	return async (specifier, importer) => {
+		const resolved = await resolver(dirname(importer), specifier).catch(() => null);
+		return resolved ? slashes(resolved) : null;
+	};
+};
+async function finish(context, state, file, source, roots, extra = {}) {
+	const readFile = readFrom(context);
+	const read = (path) => path === file ? Promise.resolve(source) : readFile(path);
+	state.units.parsed.delete(file);
+	const { units, owner, optedOut, declaredBy } = state;
+	const unit = await compileUnit(roots, {
+		layer: state.plan.layer,
+		order: state.plan.order,
+		base: context.rootContext,
+		resolve: resolveFrom(context),
+		read,
+		quarantined: (path) => {
+			const canonical = units.canonical(path);
+			return !optedOut.has(canonical) && canonical !== declaredBy;
+		},
+		owns: (path) => owner.owns(units.canonical(path)),
+		remote: "refuse",
+		cache: state.units.parsed,
+		...extra
+	});
+	state.units.record(file, unit.files);
+	for (const path of unit.files) context.addDependency(path);
+	for (const diagnostic of unit.diagnostics) {
+		const error = new Error(formatDiagnostic(diagnostic));
+		if (diagnostic.severity === "error") context.emitError(error);
+		else if (diagnostic.severity === "warning") context.emitWarning(error);
+	}
+	return unit;
+}
+async function run(context, source) {
+	const state = registry().states.get(context.getOptions().id ?? "");
+	if (!state) return null;
+	const file = slashes(context.resourcePath);
+	const id = state.units.canonical(file);
+	const { owner, declaredBy } = state;
+	if (id === declaredBy) {
+		if (owner.declared.length === 0) return null;
+		const unit = await finish(context, state, file, source, state.roots, {
+			delivery: file,
+			map: false
+		});
+		context.cacheable(false);
+		return {
+			code: `${unit.css}\n${source}`,
+			map: null
+		};
+	}
+	if (!owner.owning()) return null;
+	if (declaredBy && owner.declared.includes(id)) {
+		context.cacheable(false);
+		return {
+			code: "",
+			map: null
+		};
+	}
+	if (!owner.owns(id)) {
+		const { imports } = readSheet(source);
+		if (imports.length === 0) return null;
+		if (!await state.units.reaches(file, imports, {
+			resolve: resolveFrom(context),
+			read: readFrom(context),
+			owns: (path) => owner.owns(state.units.canonical(path))
+		})) return null;
+	}
+	const unit = await finish(context, state, file, source, [file]);
+	context.cacheable(false);
+	return {
+		code: unit.css,
+		map: unit.map
+	};
+}
+function layergateLoader(source, map, meta) {
+	const done = this.async();
+	run(this, source).then((finished) => finished ? done(null, finished.code, finished.map) : done(null, source, map, meta), (error) => done(error));
+}
+//#endregion
+export { layergateLoader as default };

package/dist/webpack-state-BpF2PPjA.d.cts

@@ -0,0 +1,15 @@
+import "./compile-DZwVBjTM.cjs";
+//#region src/webpack-state.d.ts
+/** CSS resolution as css-loader resolves an `@import`: the `style`
+ *  condition alone, its fields, CSS files only, relative first. */
+declare const CSS_RESOLVE: {
+  conditionNames: string[];
+  mainFields: string[];
+  mainFiles: string[];
+  extensions: string[];
+  restrictions: RegExp[];
+  preferRelative: boolean;
+};
+//#endregion
+export { CSS_RESOLVE as t };
+//# sourceMappingURL=webpack-state-BpF2PPjA.d.cts.map

package/dist/webpack-state-BpF2PPjA.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webpack-state-BpF2PPjA.d.cts","names":[],"sources":["../src/webpack-state.ts"],"mappings":";;;;cA8Ba;EACX;EACA;EACA;EACA;EACA,cAAY;EACZ"}

package/dist/webpack-state-BtmtzsWZ.cjs

@@ -0,0 +1,61 @@
+let node_path = require("node:path");
+let node_fs = require("node:fs");
+let node_url = require("node:url");
+//#region src/webpack-state.ts
+/**
+* What the webpack plugin and its loader share. webpack loads the loader
+* from its own file, a module instance apart from the plugin's, so the
+* state is kept on `globalThis`, by plugin id.
+*/
+/** CSS resolution as css-loader resolves an `@import`: the `style`
+*  condition alone, its fields, CSS files only, relative first. */
+const CSS_RESOLVE = {
+	conditionNames: ["style"],
+	mainFields: [
+		"css",
+		"style",
+		"main",
+		"..."
+	],
+	mainFiles: ["index", "..."],
+	extensions: [".css"],
+	restrictions: [/\.css$/i],
+	preferRelative: true
+};
+const KEY = Symbol.for("@animus-ui/layergate/webpack");
+function registry() {
+	const global = globalThis;
+	return global[KEY] ??= {
+		states: /* @__PURE__ */ new Map(),
+		made: 0
+	};
+}
+const here = (0, node_path.dirname)((0, node_url.fileURLToPath)(require("url").pathToFileURL(__filename).href));
+/** The loader's file: the built one beside this module, or the source in
+*  the workspace. */
+function loaderPath() {
+	for (const built of ["webpack-loader.cjs", "webpack-loader.mjs"]) {
+		const path = (0, node_path.resolve)(here, built);
+		if ((0, node_fs.existsSync)(path)) return path;
+	}
+	return (0, node_path.resolve)(here, "webpack-loader.ts");
+}
+//#endregion
+Object.defineProperty(exports, "CSS_RESOLVE", {
+	enumerable: true,
+	get: function() {
+		return CSS_RESOLVE;
+	}
+});
+Object.defineProperty(exports, "loaderPath", {
+	enumerable: true,
+	get: function() {
+		return loaderPath;
+	}
+});
+Object.defineProperty(exports, "registry", {
+	enumerable: true,
+	get: function() {
+		return registry;
+	}
+});

package/dist/webpack-state-CXoQQ7XR.d.mts

@@ -0,0 +1,15 @@
+import "./compile-DZwVBjTM.mjs";
+//#region src/webpack-state.d.ts
+/** CSS resolution as css-loader resolves an `@import`: the `style`
+ *  condition alone, its fields, CSS files only, relative first. */
+declare const CSS_RESOLVE: {
+  conditionNames: string[];
+  mainFields: string[];
+  mainFiles: string[];
+  extensions: string[];
+  restrictions: RegExp[];
+  preferRelative: boolean;
+};
+//#endregion
+export { CSS_RESOLVE as t };
+//# sourceMappingURL=webpack-state-CXoQQ7XR.d.mts.map

package/dist/webpack-state-CXoQQ7XR.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webpack-state-CXoQQ7XR.d.mts","names":[],"sources":["../src/webpack-state.ts"],"mappings":";;;;cA8Ba;EACX;EACA;EACA;EACA;EACA,cAAY;EACZ"}