@animus-ui/layergate 0.0.0-stage → 0.1.36

package/README.md

@@ -1,3 +1,240 @@
-# Temporary Holding Version
+# @animus-ui/layergate
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+For the vendor stylesheet you have to import: a date picker's, a grid
+library's, a package's `styles.css`. layergate loads it into a cascade
+layer below yours, so its normal rules can't fight your design system,
+whatever their specificity or load order.
+
+A stylesheet outside any `@layer` beats every layered rule, so vendor CSS
+imported as usual overrides a design system or utility framework that uses
+layers. layergate loads that CSS itself, inlines its `@import`s, and puts
+each file's own rules in one layer below yours:
+
+```css
+@layer vendor, app;
+@layer vendor {
+  /* react-grid-layout/css/styles.css, as written */
+}
+```
+
+Your own CSS is out of scope. App stylesheets and CSS Modules stay as you
+configure them: layergate layers only the vendor files you declare
+(`sheets`) or opt into (`dependencies`), including where your CSS imports
+one.
+
+## Vite
+
+```ts
+import { layergate } from '@animus-ui/layergate/vite';
+// vite.config.ts
+import { defineConfig } from 'vite';
+
+export default defineConfig({
+  plugins: [
+    layergate({
+      layer: 'vendor',
+      order: ['vendor', 'base', 'components', 'utilities'],
+      sheets: ['react-grid-layout/css/styles.css', './styles/legacy.css'],
+      dependencies: ['react-datepicker'],
+      optOut: ['./styles/legacy/keep-unlayered.css'],
+    }),
+  ],
+});
+```
+
+```ts
+// your entry module, once, before other CSS
+import 'virtual:layergate';
+```
+
+| Option         | Meaning                                                                                                                                                    |
+| -------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `layer`        | The layer owned stylesheets go into. Default `vendor`.                                                                                                     |
+| `order`        | The full layer order every owned stylesheet declares first. It must include `layer`. Default `[layer]`.                                                    |
+| `sheets`       | Stylesheets `virtual:layergate` delivers, in this order, whether or not anything else imports them: package specifiers or paths relative to the Vite root. |
+| `dependencies` | Also own the `.css` a JS module imports from a package other than your app: `true` for every package, or package names. Default: none.                     |
+| `optOut`       | Files inside an owned stylesheet whose own rules stay outside the layer. Exact specifiers or paths, never globs.                                           |
+
+A JS module's import of an owned stylesheet, by any spelling, gets the same
+single copy, and the declared sheets always come first, in their declared
+order, whichever owned stylesheet the app imports first. Vite's own CSS
+pipeline then processes each one once: PostCSS, minification, injection and
+extraction. A nested `@import` of a package resolves as a CSS import does,
+through its `style` entry. Fonts and images keep resolving, because
+layergate rewrites a relative `url()` to resolve from the delivered file.
+Edits to an owned file, nested imports and files under `node_modules`
+included, hot-update in place.
+
+## webpack
+
+```js
+// webpack.config.js
+const { LayergatePlugin } = require('@animus-ui/layergate/webpack');
+
+module.exports = {
+  plugins: [
+    new LayergatePlugin({
+      layer: 'vendor',
+      order: ['vendor', 'base', 'components', 'utilities'],
+      sheets: ['react-grid-layout/css/styles.css'],
+      dependencies: ['react-datepicker'],
+      declaredBy: require.resolve('./src/styles/app.css'),
+    }),
+  ],
+};
+```
+
+The plugin adds no rule. It joins every loader chain of yours whose
+css-loader is explicitly global (`modules: false`, as Next's global chains
+are), just before PostCSS runs, and raises that css-loader's
+`importLoaders` by one, so every stylesheet passes through it, imported
+ones included. An owned stylesheet arrives finished, its `@import`s
+resolved as css-loader resolves them and inlined, so css-loader never sees
+a `layer()` import. PostCSS, Sass and css-loader keep running as before.
+
+Any other chain is left untouched. One whose css-loader may treat a file
+as a CSS Module (`modules` unset, or `auto`) is reported in one line
+(`layergate.coverage`); a chain that only builds CSS Modules, such as
+Next's, is left alone silently.
+
+### CSS Modules alongside layergate
+
+layergate does not decide which stylesheets are CSS Modules. If one rule
+handles both, split it: global CSS in a rule whose css-loader has
+`modules: false`, which layergate joins, and CSS Modules in a rule of
+their own, which it leaves alone.
+
+```js
+module.exports = {
+  module: {
+    rules: [
+      {
+        test: /\.css$/,
+        exclude: /\.module\.css$/,
+        use: [
+          'style-loader',
+          { loader: 'css-loader', options: { modules: false } },
+        ],
+      },
+      {
+        test: /\.module\.css$/,
+        use: [
+          'style-loader',
+          { loader: 'css-loader', options: { modules: true } },
+        ],
+      },
+    ],
+  },
+};
+```
+
+Next already builds CSS this way.
+
+What layergate returns is never cached by webpack, so a warm start with a
+persistent cache finishes owned stylesheets again: about 118 ms per 200
+vendor sheets in a synthetic measurement. Caching them safely needs their
+provenance (the files and plan they came from) kept with the cache, a
+possible later change. Ownership, opt-outs and
+the declared sheets go by realpath; `url()`s are rebased from where webpack
+reads each file, so `resolve.symlinks: false` resolves them as css-loader
+does. The `declaredBy` stylesheet is never layered, even when an owned
+stylesheet imports it.
+
+webpack has no `virtual:layergate`. Pass `declaredBy`, the path of a
+stylesheet of yours: the declared sheets are delivered at its head, and a
+module's own import of one then loads nothing. Without it, import each
+declared sheet yourself; it is owned wherever it is imported.
+
+- A remote `@import` in an owned stylesheet is an error
+  (`layergate.remote`): webpack cannot load it inside the layer, and an
+  unlayered copy would escape it. Vendor the sheet locally, or opt the file
+  out if unlayered is acceptable.
+- A chain that uses Lightning CSS instead of css-loader is not covered,
+  and is reported (`layergate.coverage`).
+- In watch mode, an edit to any file an owned stylesheet read, files under
+  `node_modules` included, rebuilds it. The plugin makes a RegExp or
+  function `watchOptions.ignored` watch those files; a host that owns its
+  watch options passes `watchIgnored: false` and asks `plugin.watches(path)`.
+- Turbopack runs no loader on the stylesheets a stylesheet imports, so
+  layergate cannot work there.
+
+With Next and Animus, use the `quarantine` option of
+`@animus-ui/next-plugin`, which sets this up for Next's client compiler.
+
+## What it does to a stylesheet
+
+- **Each file is decided on its own.** A file's own rules go into the
+  layer. An opted-out file's own rules stay outside it, under the
+  conditions of the `@import` that loads it, and the files it imports keep
+  their own decisions.
+- **Imports keep their conditions.** `@import "x.css" layer(a) supports(…)
+  screen` becomes `@media screen { @supports (…) { @layer a { … } } }`
+  inside the layer, so its rules land in `vendor.a`. An anonymous `layer`
+  import gets a private layer of its own, never the shared one.
+- **Text is kept as written.** Selectors, declarations, `!important`,
+  keyframes and the file's own layers reach the browser unchanged. Only a
+  relative `url()` in a file outside the delivered file's directory changes.
+- **Remote imports stay remote.** Under Vite, an `http(s):` import is
+  hoisted to the top, in its layer, and reported, since its contents are
+  not inspected. Under webpack it is an error (see above).
+
+## What a layer does not change
+
+A layer bounds normal declarations only. These are kept and reported as
+warnings, never stripped:
+
+- `!important` declarations, which beat your normal declarations from any
+  layer (`layergate.important`);
+- animations and keyframes, whose values override normal declarations
+  while they run (`layergate.animation`).
+
+Font, keyframe and property names are global, whatever their layer.
+
+## Not yet
+
+- CSS Modules, Sass, Less and Stylus are left to Vite. Under webpack, Sass
+  output is finished like any CSS, and CSS Modules are left alone.
+- An owned file can arrive more than once. A stylesheet Vite loads
+  itself, such as an app sheet whose `@import` reaches an owned file, is
+  finished by layergate too: its own rules stay unlayered and the owned
+  file is inlined layered, so no unlayered copy escapes. But each finished
+  stylesheet stands on its own, so the same owned file reached from two of
+  them is delivered in both, each copy layered. One delivery per file
+  across the document would need a document-wide registry, a possible
+  later increment.
+- App CSS is left alone unless you list it in `sheets`. CSS that loads
+  before `virtual:layergate`, or another tool's layer order statement that
+  comes first, can still place your layers after `vendor`.
+- A `.css` request with a query (`?inline`, `?url`, `?raw`) is left to Vite.
+- A stylesheet with `@namespace` is an error (`layergate.namespace`): it
+  applies to a whole stylesheet, which a file inlined into another is not.
+- A host's PostCSS runs once, over each finished stylesheet, not per file.
+- Turbopack: not supported (see webpack above).
+
+## Delivering from a host stylesheet
+
+A tool with its own stylesheet module can deliver the declared sheets at
+its head instead of through `virtual:layergate`: pass `declaredBy` (the
+module's specifier, which an owned stylesheet a JS module imports then
+loads first), and prepend `await plugin.stylesheetHead.call(this, id)` to
+that module's CSS in its `load` hook. The head uses root-relative URLs, so
+assets resolve from a virtual module too; a file outside the Vite root is
+reached through `/@fs/`: in development a declared sheet's directory is
+added to `server.fs.allow` when the server starts (beside your own list, or
+Vite's default workspace root), and an asset it references in another
+directory is allowed when it is found; in a build it is emitted as an
+asset. Animus's `quarantine`
+option works this way.
+
+## Core API
+
+`compileUnit(roots, { layer, order, resolve, read, quarantined, owns, url, base, cache })`
+compiles stylesheet graphs, in order, into one finished stylesheet with the
+host's resolver and file reader, and returns the CSS, a source map, the files
+read, whether anything was layered, and the diagnostics. `owns` says which
+files start an owned graph (default: all), and `url` maps a referenced file
+to its URL text (default: relative to the first root).
+`base` is the directory generated layer names are relative to (the project
+root), so they are the same on every machine. `cache` keeps parsed files
+between compiles; drop a file's entry when it changes. The Vite and webpack
+adapters are built on it.

package/dist/compile-C4GyCiuY.cjs

@@ -0,0 +1,323 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+const require_sheet = require("./sheet-BUnyt5Jt.cjs");
+let magic_string = require("magic-string");
+magic_string = __toESM(magic_string, 1);
+let node_crypto = require("node:crypto");
+let node_path = require("node:path");
+//#region src/compile.ts
+/**
+* Compiles one owned stylesheet graph into one finished stylesheet: every
+* local `@import` inlined at its position, under its media, supports and
+* layer conditions, and each file's own text placed inside the quarantine
+* layer, or outside it for a file opted out. Each file is decided on its
+* own, before assembly, so a parent's decision never reaches a child's
+* text. File text is kept as written; only relative URLs are rewritten, to
+* resolve from the finished stylesheet's location.
+*/
+const open = (frame) => frame.kind === "media" ? `@media ${frame.text} {\n` : frame.kind === "supports" ? `@supports (${frame.text}) {\n` : `@layer ${frame.text} {\n`;
+/** A URL the finished stylesheet leaves to the browser. */
+const isRemote = (url) => /^(?:[a-z][a-z0-9+.-]*:)?\/\//i.test(url);
+/** A URL that resolves the same from any stylesheet location. */
+const isLocationFree = (url) => url === "" || /^(?:[a-z][a-z0-9+.-]*:|\/|#|%23)/i.test(url);
+const quoted = (url) => `"${url.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\a ")}"`;
+/** `@import "x"` names a stylesheet relative to its own; a bare name that
+*  is no relative file is the package a bundler resolves. */
+function candidates(url) {
+	if (url.startsWith("~")) return [url.slice(1)];
+	if (url.startsWith(".") || url.startsWith("/")) return [url];
+	return [`./${url}`, url];
+}
+/** Line and column (1-based) of each offset in `text`. */
+function locator(text) {
+	const starts = [0];
+	for (let at = 0; at < text.length; at++) if (text[at] === "\n") starts.push(at + 1);
+	return (offset) => {
+		let low = 0;
+		let high = starts.length - 1;
+		while (low < high) {
+			const mid = low + high + 1 >> 1;
+			if (starts[mid] <= offset) low = mid;
+			else high = mid - 1;
+		}
+		return {
+			line: low + 1,
+			column: offset - starts[low] + 1
+		};
+	};
+}
+/** A URL's path and its `?query#fragment`. */
+function splitSuffix(url) {
+	const at = url.search(/[?#]/);
+	return at === -1 ? [url, ""] : [url.slice(0, at), url.slice(at)];
+}
+/** The frames an import adds, media, then supports, then layer; an
+*  anonymous layer as `anonymous`. */
+function importFrames(statement, anonymous) {
+	const frames = [];
+	if (statement.media) frames.push({
+		kind: "media",
+		text: statement.media
+	});
+	if (statement.supports !== null) frames.push({
+		kind: "supports",
+		text: statement.supports
+	});
+	if (statement.layer.kind === "named") frames.push({
+		kind: "layer",
+		text: statement.layer.name
+	});
+	else if (statement.layer.kind === "anonymous") frames.push({
+		kind: "layer",
+		text: anonymous()
+	});
+	return frames;
+}
+/** A remote `@import` hoisted to the top of the finished stylesheet: its
+*  layer is every layer on its way, its supports every supports, and its
+*  media the innermost media. */
+function remoteImport(url, frames) {
+	const of = (kind) => frames.filter((frame) => frame.kind === kind).map((frame) => frame.text);
+	const [layers, supports, media] = [
+		of("layer"),
+		of("supports"),
+		of("media")
+	];
+	return [
+		`@import url(${quoted(url)})`,
+		layers.length > 0 ? ` layer(${layers.join(".")})` : "",
+		supports.length > 0 ? ` supports(${supports.map((text) => `(${text})`).join(" and ")})` : "",
+		media.length > 0 ? ` ${combinedMedia(media)}` : "",
+		";"
+	].join("");
+}
+/** Media conditions on the way to an import, as one: joined when each is a
+*  bare condition (`(min-width: 1px)`), otherwise the innermost. */
+function combinedMedia(media) {
+	return media.every((text) => text.startsWith("(") && !text.includes(",")) ? media.join(" and ") : media.at(-1);
+}
+/** The layer names `frames` nest, outermost first. */
+function layerPath(frames) {
+	return frames.filter((frame) => frame.kind === "layer").flatMap((frame) => frame.text.split("."));
+}
+/** Compiles `roots`, in order, into one finished stylesheet. */
+async function compileUnit(roots, options) {
+	const deliveryDir = (0, node_path.dirname)(options.delivery ?? roots[0]);
+	/** The URL text reaching `target`; by default relative to the
+	*  delivery's directory, so a file there keeps its URLs as written. */
+	const url = options.url ?? ((target) => (0, node_path.relative)(deliveryDir, target).split(node_path.sep).join("/"));
+	/** Files whose own text went into the layer, and owned files opted out. */
+	const layered = /* @__PURE__ */ new Set();
+	const optedOut = /* @__PURE__ */ new Set();
+	const bundle = new magic_string.Bundle({ separator: "" });
+	const diagnostics = [];
+	const loaded = /* @__PURE__ */ new Map();
+	const remote = [];
+	/** Every layer path, in the order the original cascade first creates it. */
+	const created = /* @__PURE__ */ new Set();
+	const create = (path) => {
+		for (let depth = 1; depth <= path.length; depth++) {
+			const name = path.slice(0, depth).join(".");
+			created.add(name);
+		}
+	};
+	const report = (code, severity, message, file, at) => {
+		diagnostics.push({
+			code,
+			severity,
+			message,
+			file,
+			...loaded.get(file).locate(at)
+		});
+	};
+	/** A stable private name for the anonymous layer an import occurrence
+	*  creates: from the unit and the chain of imports that reaches it from
+	*  the root, so each occurrence, of the same file too, gets its own, and
+	*  the same on every machine. */
+	const anonymousName = (occurrence) => () => `layergate-anonymous-${(0, node_crypto.createHash)("sha256").update(occurrence).digest("hex").slice(0, 10)}`;
+	/** What a file holds that the layer cannot hold back, or that layergate
+	*  cannot place, reported once per file. */
+	const reportEffects = (file, sheet) => {
+		const effect = (offsets, code, what) => {
+			if (offsets.length === 0) return;
+			const them = offsets.length === 1 ? "it" : "them";
+			report(code, "warning", `${offsets.length} ${what} kept: the quarantine layer does not hold ${them} back`, file, offsets[0]);
+		};
+		effect(sheet.important, "layergate.important", "!important declaration(s)");
+		effect(sheet.keyframes, "layergate.animation", "@keyframes rule(s)");
+		effect(sheet.animations, "layergate.animation", "animation declaration(s)");
+	};
+	/** What layergate leaves as written or cannot place, reported once per
+	*  file; `placed` says the file's text sits inside a block, where
+	*  `@namespace` cannot. */
+	const reportFile = (file, sheet, placed) => {
+		for (const at of sheet.ignoredImports) report("layergate.ignored-import", "warning", "@import after other rules is ignored by browsers, and layergate leaves it as written", file, at);
+		if (placed && sheet.namespaces.length > 0) report("layergate.namespace", "error", "@namespace applies to a whole stylesheet, which layergate cannot place yet", file, sheet.namespaces[0]);
+	};
+	const load = async (file) => {
+		if (loaded.has(file)) return loaded.get(file);
+		let entry = null;
+		try {
+			let parsed = options.cache?.get(file);
+			if (!parsed) {
+				const text = String(await options.read(file));
+				parsed = {
+					text,
+					sheet: require_sheet.readSheet(text)
+				};
+				options.cache?.set(file, parsed);
+			}
+			const source = new magic_string.default(parsed.text);
+			const kept = !options.url && (0, node_path.dirname)(file) === deliveryDir;
+			for (const reference of kept ? [] : parsed.sheet.urls) {
+				if (isLocationFree(reference.url) || isRemote(reference.url)) continue;
+				const [path, suffix] = splitSuffix(reference.url);
+				const rebased = url((0, node_path.join)((0, node_path.dirname)(file), path)) + suffix;
+				if (rebased === reference.url) continue;
+				source.overwrite(reference.start, reference.end, reference.kind === "token" ? `url(${quoted(rebased)})` : quoted(rebased));
+			}
+			for (const [from, to] of parsed.sheet.removed) source.remove(from, to);
+			entry = {
+				...parsed,
+				source,
+				locate: locator(parsed.text)
+			};
+		} catch (error) {
+			diagnostics.push({
+				code: "layergate.unreadable",
+				severity: "error",
+				message: `cannot read ${file}: ${error instanceof Error ? error.message : String(error)}`,
+				file
+			});
+		}
+		loaded.set(file, entry);
+		return entry;
+	};
+	/** The file's text from `from` to `to` inside `frames`, unless it holds
+	*  only whitespace. */
+	const emit = (file, frames, from, to) => {
+		const entry = loaded.get(file);
+		let content = false;
+		let at = from;
+		for (const [start, end] of entry.sheet.removed) {
+			if (end <= at || start >= to) continue;
+			content ||= /\S/.test(entry.text.slice(at, start));
+			at = end;
+		}
+		if (!content && !/\S/.test(entry.text.slice(at, to))) return;
+		if (frames.length > 0) bundle.addSource({ content: new magic_string.default(frames.map(open).join("")) });
+		bundle.addSource({
+			filename: file,
+			content: entry.source.snip(from, to)
+		});
+		bundle.addSource({ content: new magic_string.default(`\n${"}\n".repeat(frames.length)}`) });
+	};
+	/** Emits `file` as one occurrence: `frames` are the conditions its import
+	*  chain puts it under, `stack` the files on that chain, `occurrence` the
+	*  chain's import indexes. A file imported twice is emitted at each
+	*  import, as a browser applies it at each. */
+	const visit = async (file, frames, stack, occurrence, insideOwned) => {
+		const first = !loaded.has(file);
+		const entry = await load(file);
+		if (!entry) return;
+		const owned = insideOwned || (options.owns?.(file) ?? true);
+		const quarantined = owned && (options.quarantined?.(file) ?? true);
+		if (owned && !quarantined) optedOut.add(file);
+		if (first) reportFile(file, entry.sheet, quarantined || stack.length > 1);
+		if (quarantined && !layered.has(file)) {
+			layered.add(file);
+			reportEffects(file, entry.sheet);
+		}
+		const own = quarantined ? [{
+			kind: "layer",
+			text: options.layer
+		}, ...frames] : frames;
+		const ownPath = layerPath(own);
+		const createLayers = (from, to) => {
+			for (const { at, names } of entry.sheet.layers) if (at >= from && at < to) for (const name of names) create([...ownPath, ...name.split(".")]);
+		};
+		create(ownPath);
+		let cursor = 0;
+		for (const [index, statement] of entry.sheet.imports.entries()) {
+			createLayers(cursor, statement.start);
+			emit(file, own, cursor, statement.start);
+			cursor = statement.end;
+			const added = importFrames(statement, anonymousName(`${occurrence}/${index}`));
+			if (isRemote(statement.url)) {
+				const chain = [...own, ...added];
+				if (options.remote === "refuse" && chain.some((frame) => frame.kind !== "media")) {
+					report("layergate.remote", "error", `@import "${statement.url}" is remote, and this host cannot load it inside a layer: vendor the sheet locally, or opt this file out explicitly if unlayered is acceptable`, file, statement.start);
+					continue;
+				}
+				const media = chain.filter((frame) => frame.kind === "media").length;
+				const kept = media > 1 ? `; its ${media} media conditions are joined where each is a bare condition, else only the innermost is kept` : "";
+				report("layergate.remote", "warning", `@import "${statement.url}" stays remote, so its contents are not inspected${kept}`, file, statement.start);
+				create(layerPath(chain));
+				remote.push(remoteImport(statement.url, chain));
+				continue;
+			}
+			let child = null;
+			for (const candidate of candidates(statement.url)) {
+				child = await options.resolve(candidate, file);
+				if (child) break;
+			}
+			if (!child) report("layergate.unresolved", "error", `cannot resolve @import "${statement.url}"`, file, statement.start);
+			else if (stack.includes(child)) report("layergate.cycle", "warning", `@import "${statement.url}" imports a stylesheet already being imported; skipped`, file, statement.start);
+			else await visit(child, [...frames, ...added], [...stack, child], `${occurrence}/${index}`, owned);
+		}
+		createLayers(cursor, entry.text.length);
+		emit(file, own, cursor, entry.text.length);
+	};
+	for (const root of roots) {
+		const name = (0, node_path.relative)(options.base ?? deliveryDir, root).split(node_path.sep).join("/");
+		await visit(root, [], [root], name, false);
+	}
+	bundle.prepend([
+		`@layer ${options.order.join(", ")};\n`,
+		...remote.length > 0 ? [`@layer ${[...created].join(", ")};\n`] : [],
+		...remote.map((line) => `${line}\n`)
+	].join(""));
+	for (const file of optedOut) diagnostics.push({
+		code: "layergate.opt-out",
+		severity: "info",
+		message: `opted out: its own rules stay outside @layer ${options.layer}`,
+		file
+	});
+	return {
+		css: bundle.toString(),
+		map: options.map === false ? null : bundle.generateMap({
+			hires: "boundary",
+			includeContent: true
+		}),
+		files: [...loaded.keys()],
+		layered: layered.size > 0,
+		diagnostics
+	};
+}
+//#endregion
+Object.defineProperty(exports, "compileUnit", {
+	enumerable: true,
+	get: function() {
+		return compileUnit;
+	}
+});