@parity-app/cli 0.0.0-stage → 0.1.0

package/dist/src-8MhDV_sA.mjs

@@ -0,0 +1,4780 @@
+import { S as lengthToPixels, a as applyLibraryEdits, c as isSampleElement, f as parseLibraryEdits, l as isSampleRender, m as renderSlotOf, p as parseLibraryManifest, s as isMadeValue, u as libraryManifestExtension } from "./src-D9EMN48r.mjs";
+import "./src-DXZqtm6z.mjs";
+import { a as publishedVersions, n as packageFile, o as repositoryFiles, r as publishedSource } from "./published-CdXoUgfD.mjs";
+import { createRequire } from "node:module";
+import { mkdir, readFile, readdir, realpath, rm, stat, writeFile } from "node:fs/promises";
+import { basename, dirname, join, posix, relative, resolve, sep } from "node:path";
+import { promisify } from "node:util";
+import { createHash } from "node:crypto";
+import { homedir } from "node:os";
+import { existsSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+import ts from "typescript";
+import "semver";
+import { execFile } from "node:child_process";
+// ../core/src/icon-names.ts
+/**
+* Each export's icon, size and style, for a set whose names carry them (Fluent's `Add24Regular`). Digits before the
+* style are a size only when they're one of the set's sizes and the name before them is an icon the set exports
+* without a size (`CalendarDay` for `CalendarDay32Color`); otherwise they're part of the name, as in `Battery10` and
+* `TextHeader1`. An icon the set ships only at fixed sizes (`CodeCs16Regular`), whose name no other export has at a
+* size, reads as that icon at that size. Exports the pattern doesn't match are left out.
+*/
+function iconVariants(names, variants) {
+	const pattern = variants.pattern ? new RegExp(variants.pattern) : void 0;
+	const sizes = new Set(variants.sizes ?? []);
+	const parsed = names.flatMap((name) => {
+		if (!pattern) return [{
+			name,
+			base: name,
+			digits: ""
+		}];
+		const groups = pattern.exec(name)?.groups;
+		if (!groups) return [];
+		return [{
+			name,
+			base: groups.name ?? name,
+			digits: groups.size ?? "",
+			...groups.style ? { style: groups.style } : {}
+		}];
+	});
+	const bare = new Set(parsed.map(({ base, digits }) => base + digits));
+	const splits = ({ base, digits }) => digits.split("").flatMap((_, at) => {
+		const size = digits.slice(at);
+		return String(Number(size)) === size && (sizes.size === 0 || sizes.has(Number(size))) ? [{
+			label: base + digits.slice(0, at),
+			size: Number(size)
+		}] : [];
+	});
+	const read = /* @__PURE__ */ new Map();
+	for (const entry of parsed) {
+		const copy = entry.digits ? splits(entry).find((split) => bare.has(split.label)) : void 0;
+		read.set(entry.name, {
+			...copy ?? { label: entry.base + entry.digits },
+			style: entry.style
+		});
+	}
+	const sized = new Set([...read.values()].flatMap((reading) => reading.size === void 0 ? [] : [reading.label]));
+	for (const entry of parsed) {
+		const reading = read.get(entry.name);
+		if (!entry.digits || reading.size !== void 0 || sized.has(reading.label)) continue;
+		const fixed = splits(entry)[0];
+		if (fixed) read.set(entry.name, {
+			...fixed,
+			style: entry.style,
+			fixed: true
+		});
+	}
+	const preferred = variants.default?.size ?? 20;
+	const distance = (size) => Math.abs(size - preferred) - (size > preferred ? .5 : 0);
+	const nearest = /* @__PURE__ */ new Map();
+	for (const [name, reading] of read) {
+		if (!reading.fixed) continue;
+		const key = `${reading.label}\u0000${reading.style ?? ""}`;
+		const current = nearest.get(key);
+		if (!current || distance(reading.size) < distance(read.get(current).size)) nearest.set(key, name);
+	}
+	const listed = new Set(nearest.values());
+	const result = /* @__PURE__ */ new Map();
+	for (const [name, { label, size, style }] of read) result.set(name, {
+		label,
+		...size === void 0 ? {} : { size },
+		...style === void 0 ? {} : { style },
+		listed: size === void 0 || listed.has(name)
+	});
+	return result;
+}
+// ../code/src/checker.ts
+const probeName = "__parity_probe__.ts";
+const probeText = "import type { ReactNode } from \"react\"\nexport type ParityNode = ReactNode\n";
+/** The settings components are read with: the scan's own over ones that read JSX, JavaScript and modern modules. */
+function componentOptions(compilerOptions) {
+	return {
+		target: ts.ScriptTarget.ES2022,
+		module: ts.ModuleKind.ESNext,
+		moduleResolution: ts.ModuleResolutionKind.Bundler,
+		jsx: ts.JsxEmit.ReactJSX,
+		strict: true,
+		skipLibCheck: true,
+		noEmit: true,
+		allowJs: true,
+		types: [],
+		...compilerOptions,
+		incremental: false
+	};
+}
+/** A file only the checker sees, naming React's `ReactNode` so it can tell what React renders. */
+function reactProbe(root) {
+	return slashes(join(root, probeName));
+}
+/** A compiler host that also serves `reactProbe(root)`. */
+function withReactProbe(host, root) {
+	const probe = reactProbe(root);
+	const getSourceFile = host.getSourceFile.bind(host);
+	const fileExists = host.fileExists.bind(host);
+	const readFile = host.readFile.bind(host);
+	host.getSourceFile = (fileName, language, onError, create) => slashes(fileName) === probe ? ts.createSourceFile(fileName, probeText, language, true) : getSourceFile(fileName, language, onError, create);
+	host.fileExists = (fileName) => slashes(fileName) === probe || fileExists(fileName);
+	host.readFile = (fileName) => slashes(fileName) === probe ? probeText : readFile(fileName);
+	return host;
+}
+/**
+* Finds the components a package or an app exports, by asking TypeScript what each export is, as
+* `proposals/component-detection.md` describes: a capitalised function taking one props object (or nothing) and
+* returning something React renders, or a `forwardRef`, `memo` or `lazy` result, or a class with `render` and `props`.
+* Members of namespace exports count too, as `Dialog.Root`.
+*/
+function findComponents(scan) {
+	const probe = reactProbe(scan.root);
+	const program = scan.program ?? (() => {
+		const options = componentOptions(scan.compilerOptions);
+		const host = withReactProbe(ts.createCompilerHost(options, true), scan.root);
+		return ts.createProgram({
+			rootNames: [...scan.entries, probe],
+			options,
+			host
+		});
+	})();
+	const checker = program.getTypeChecker();
+	const node = reactNodeType(checker, program.getSourceFile(probe));
+	const report = {
+		components: [],
+		ambiguous: [],
+		rejected: [],
+		reactTypes: node !== void 0
+	};
+	const verdicts = /* @__PURE__ */ new Map();
+	const seen = /* @__PURE__ */ new Map();
+	const visit = (name, symbol, from, namespace) => {
+		const short = name.slice(name.lastIndexOf(".") + 1);
+		if (!/^[A-Z]/.test(short) || !(symbol.flags & ts.SymbolFlags.Value)) return;
+		const declaration = symbol.valueDeclaration ?? symbol.declarations?.[0];
+		if (!declaration) return;
+		const type = checker.getTypeOfSymbolAtLocation(symbol, declaration);
+		let verdict = verdicts.get(type);
+		if (!verdict) {
+			verdict = judge(checker, type, node);
+			if (!(type.flags & ts.TypeFlags.Any)) verdicts.set(type, verdict);
+		}
+		const where = scan.defaultExports ? from : {};
+		if ("ambiguous" in verdict) return void report.ambiguous.push({
+			name,
+			reason: verdict.ambiguous,
+			...where
+		});
+		if ("not" in verdict) return void report.rejected.push({
+			name,
+			reason: verdict.not,
+			...where
+		});
+		const existing = seen.get(symbol);
+		if (existing) {
+			const declaredIn = (entry) => slashes(entry) === slashes(declaration.getSourceFile().fileName);
+			if (scan.defaultExports && declaredIn(from.entry) !== declaredIn(existing.entry) ? declaredIn(from.entry) : preferred(name, existing.name, namespace)) Object.assign(existing, {
+				name,
+				...from
+			});
+			return;
+		}
+		const file = declaration.getSourceFile().fileName;
+		const props = verdict.props ? ownProps(checker, verdict.props) : {};
+		const found = {
+			name,
+			as: verdict.as,
+			file,
+			group: namespace ?? groupOf(file, short),
+			requiredProps: verdict.requiredProps,
+			type: checker.typeToString(type),
+			...from,
+			props,
+			fingerprint: hash([verdict.as, ...Object.entries(props).map(([prop, kind]) => `${prop}:${kind}`).sort()].join("|")),
+			samples: verdict.props ? samplesFor(checker, verdict.props, verdict.requiredProps) : {}
+		};
+		seen.set(symbol, found);
+		report.components.push(found);
+	};
+	for (const entry of scan.entries) {
+		const file = program.getSourceFile(entry);
+		const moduleSymbol = file && checker.getSymbolAtLocation(file);
+		if (!moduleSymbol) continue;
+		for (const exported of checker.getExportsOfModule(moduleSymbol)) {
+			const target = exported.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(exported) : exported;
+			let name = exported.name;
+			if (name === "default") {
+				if (!scan.defaultExports) continue;
+				name = defaultExportName(target, entry);
+			}
+			if (isNamespace(target)) {
+				if (!/^[A-Z]/.test(name)) continue;
+				for (const member of checker.getExportsOfModule(target)) {
+					const resolved = member.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(member) : member;
+					visit(`${name}.${member.name}`, resolved, {
+						entry,
+						export: `${exported.name}.${member.name}`
+					}, name);
+				}
+			} else visit(name, target, {
+				entry,
+				export: exported.name
+			});
+		}
+	}
+	const names = new Set(report.components.map((component) => component.name));
+	report.components = report.components.filter((component) => {
+		const dot = component.name.lastIndexOf(".");
+		if (dot === -1) return true;
+		const namespace = component.name.slice(0, dot).split(".").at(-1);
+		const member = component.name.slice(dot + 1);
+		if (!member.startsWith(namespace)) return true;
+		return !names.has(`${component.name.slice(0, dot)}.${member.slice(namespace.length) || "Root"}`);
+	});
+	report.components.sort((a, b) => a.name.localeCompare(b.name, "en"));
+	return report;
+}
+function judge(checker, type, node) {
+	if (type.flags & ts.TypeFlags.Any) return { ambiguous: "its type is any, so it can't be told apart from a helper" };
+	const written = checker.typeToString(type, void 0, ts.TypeFormatFlags.NoTruncation);
+	if (type.getProperty("Provider") && type.getProperty("Consumer")) return { not: "a context, which passes a value down rather than drawing anything" };
+	if (type.getProperty("$$typeof")) {
+		let as = "exotic";
+		if (/ForwardRef/.test(written)) as = "forwardRef";
+		else if (/Memo|NamedExotic/.test(written)) as = "memo";
+		else if (/Lazy/.test(written)) as = "lazy";
+		return {
+			as,
+			...propsOf(checker, type.getCallSignatures()[0])
+		};
+	}
+	const constructs = type.getConstructSignatures();
+	if (constructs.length > 0) {
+		const instance = constructs[0].getReturnType();
+		if (instance.getProperty("render") && instance.getProperty("props")) {
+			const props = instance.getProperty("props");
+			const propsType = checker.getTypeOfSymbol(props);
+			return {
+				as: "class",
+				requiredProps: required(checker, propsType),
+				props: propsType
+			};
+		}
+		return { not: "a class without React's `render` and `props`" };
+	}
+	const calls = type.getCallSignatures();
+	if (calls.length === 0) return { not: "not a function" };
+	for (const signature of calls) {
+		const parameters = signature.getParameters();
+		const needed = parameters.filter((parameter) => isRequired(parameter));
+		if (needed.length > 1) return { not: `takes ${needed.length} arguments, not one props object` };
+		const first = parameters[0];
+		if (first) {
+			const propsType = checker.getTypeOfSymbol(first);
+			if (isPrimitive(propsType)) return { not: `takes ${checker.typeToString(propsType)}, not props` };
+		}
+		const returned = signature.getReturnType();
+		if (returned.flags & ts.TypeFlags.Any) return { ambiguous: "returns any, so whether React can render it isn't known" };
+		if (node) {
+			const awaited = checker.getAwaitedType(returned) ?? returned;
+			if (!checker.isTypeAssignableTo(awaited, node)) return { not: `returns ${shorten(checker.typeToString(returned))}, which React doesn't render` };
+			if (isPrimitive(returned)) return { not: `returns ${checker.typeToString(returned)} only` };
+		} else if (!/Element|ReactNode|ReactPortal|null/.test(checker.typeToString(returned))) return { ambiguous: "React's types aren't installed, and its return type doesn't look like an element" };
+	}
+	return {
+		as: "function",
+		...propsOf(checker, calls[0])
+	};
+}
+function propsOf(checker, signature) {
+	const first = signature?.getParameters()[0];
+	if (!first) return { requiredProps: [] };
+	const props = checker.getTypeOfSymbol(first);
+	return {
+		requiredProps: required(checker, props),
+		props
+	};
+}
+function required(checker, type) {
+	if (type.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) return [];
+	return (type.isUnion() ? type.types : [type]).map((shape) => checker.getPropertiesOfType(shape).filter((property) => !(property.flags & ts.SymbolFlags.Optional)).map((property) => property.name)).reduce((all, names) => all.filter((name) => names.includes(name)));
+}
+function isRequired(parameter) {
+	const declaration = parameter.valueDeclaration;
+	if (!declaration || !ts.isParameter(declaration)) return true;
+	return !declaration.questionToken && !declaration.initializer && !declaration.dotDotDotToken;
+}
+const primitive = ts.TypeFlags.StringLike | ts.TypeFlags.NumberLike | ts.TypeFlags.BooleanLike | ts.TypeFlags.BigIntLike | ts.TypeFlags.ESSymbolLike | ts.TypeFlags.Undefined | ts.TypeFlags.Null | ts.TypeFlags.Void;
+function isPrimitive(type) {
+	return (type.isUnion() ? type.types : [type]).every((part) => (part.flags & primitive) !== 0);
+}
+function isNamespace(symbol) {
+	const valueKinds = ts.SymbolFlags.Function | ts.SymbolFlags.Variable | ts.SymbolFlags.Class;
+	return (symbol.flags & ts.SymbolFlags.ValueModule) !== 0 && (symbol.flags & valueKinds) === 0;
+}
+function reactNodeType(checker, probe) {
+	const moduleSymbol = probe && checker.getSymbolAtLocation(probe);
+	const alias = moduleSymbol && checker.getExportsOfModule(moduleSymbol).find((symbol) => symbol.name === "ParityNode");
+	if (!alias) return void 0;
+	const type = checker.getDeclaredTypeOfSymbol(alias);
+	return type.flags & ts.TypeFlags.Any ? void 0 : type;
+}
+/**
+* Which of two names for one component to keep: a namespace's member over its flat twin (`Dialog.Root`, not
+* `DialogRoot`); inside a namespace, the one that doesn't repeat it (`Dialog.Root`, not `Dialog.Dialog`); otherwise
+* the shorter (`Heart`, not `LucideHeart`).
+*/
+function preferred(candidate, current, namespace) {
+	if (candidate.replace(".", "") === current.replace(".", "")) return candidate.includes(".");
+	if (namespace) {
+		const repeats = (name) => name.slice(namespace.length + 1).startsWith(namespace);
+		if (repeats(current) !== repeats(candidate)) return repeats(current);
+	}
+	return candidate.length < current.length || candidate.length === current.length && candidate < current;
+}
+const buildFolders = /* @__PURE__ */ new Set([
+	"dist",
+	"lib",
+	"esm",
+	"cjs",
+	"types",
+	"src",
+	"build",
+	"es",
+	"node",
+	"browser"
+]);
+/**
+* A component's family, from where it's declared: its file (`Button/Button.d.ts` is Button), or for a file named
+* `index`, its package or folder, as Fluent's `@fluentui/react-button` is Button.
+*/
+function groupOf(file, fallback) {
+	const name = basename(file).replace(/(\.d)?\.[cm]?[jt]sx?$/, "");
+	if (name !== "index") return pascal(name);
+	let folder = dirname(file);
+	while (buildFolders.has(basename(folder)) && dirname(folder) !== folder) folder = dirname(folder);
+	const base = basename(folder).replace(/^react-/, "");
+	return base ? pascal(base) : fallback;
+}
+function pascal(name) {
+	return name.split(/[-_.]/).filter(Boolean).map((part) => part[0].toUpperCase() + part.slice(1)).join("");
+}
+function defaultExportName(symbol, entry) {
+	const declared = symbol.valueDeclaration && ts.getNameOfDeclaration(symbol.valueDeclaration);
+	if (declared && ts.isIdentifier(declared) && /^[A-Z]/.test(declared.text)) return declared.text;
+	return pascal(basename(entry).replace(/\.[cm]?[jt]sx?$/, ""));
+}
+function shorten(text, length = 60) {
+	return text.length > length ? `${text.slice(0, length - 1)}…` : text;
+}
+function slashes(path) {
+	return path.replaceAll("\\", "/");
+}
+/** A path relative to a folder, with forward slashes. */
+function relativePath(from, to) {
+	return slashes(relative(from, to));
+}
+/**
+* A component's own props: those its package declares, not the HTML attributes and React props it passes on, which
+* every component shares and which would make every fingerprint change with React's types.
+*/
+function ownProps(checker, type) {
+	const props = {};
+	for (const property of checker.getPropertiesOfType(type)) {
+		const declared = property.declarations?.[0]?.getSourceFile().fileName ?? "";
+		if (/[/\\]@types[/\\]react|[/\\]typescript[/\\]lib[/\\]/.test(declared)) continue;
+		const written = checker.typeToString(checker.getTypeOfSymbol(property), void 0, ts.TypeFormatFlags.NoTruncation);
+		const optional = property.flags & ts.SymbolFlags.Optional ? "?" : "";
+		props[`${property.name}${optional}`] = hash(written).slice(0, 6);
+	}
+	return Object.fromEntries(Object.entries(props).sort(([a], [b]) => a.localeCompare(b, "en")));
+}
+/**
+* Sample values for required props, from their types: the first of a set of strings, a word for a string or a
+* node, a number, `true`, or an empty list. A function or an object is left out, since a sample can't say what it does.
+*/
+function samplesFor(checker, type, required) {
+	const samples = {};
+	for (const name of required) {
+		const property = type.getProperty(name);
+		if (!property) continue;
+		const value = sampleOf$1(checker, checker.getNonNullableType(checker.getTypeOfSymbol(property)), name);
+		if (value !== void 0) samples[name] = value;
+	}
+	return samples;
+}
+function sampleOf$1(checker, type, name) {
+	const parts = type.isUnion() ? type.types : [type];
+	const literal = parts.find((part) => part.isStringLiteral());
+	if (literal?.isStringLiteral()) return literal.value;
+	if (parts.some((part) => part.flags & ts.TypeFlags.String)) return /src|href|url/i.test(name) ? "#" : "Text";
+	if (parts.some((part) => part.flags & ts.TypeFlags.Number)) return 1;
+	if (parts.some((part) => part.flags & ts.TypeFlags.BooleanLike)) return true;
+	if (parts.some((part) => checker.isArrayType(part))) return [];
+	if (/ReactNode|ReactElement|Element\b/.test(checker.typeToString(type))) return "Text";
+}
+function hash(text) {
+	return createHash("sha1").update(text).digest("hex").slice(0, 8);
+}
+({ ...ts.sys });
+ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.NonPrimitive | ts.TypeFlags.TypeParameter;
+// ../project/src/jsonc.ts
+/** Parses JSON with comments and trailing commas, as tsconfig files allow. Comment markers inside strings are kept. */
+function parseJsonc(text) {
+	let output = "";
+	let index = 0;
+	while (index < text.length) {
+		const char = text[index];
+		if (char === "\"") {
+			const start = index++;
+			while (index < text.length && text[index] !== "\"") index += text[index] === "\\" ? 2 : 1;
+			output += text.slice(start, ++index);
+		} else if (char === "/" && text[index + 1] === "/") while (index < text.length && text[index] !== "\n") index++;
+		else if (char === "/" && text[index + 1] === "*") {
+			const end = text.indexOf("*/", index + 2);
+			index = end === -1 ? text.length : end + 2;
+		} else {
+			output += char;
+			index++;
+		}
+	}
+	return JSON.parse(output.replace(/,(\s*[}\]])/g, "$1"));
+}
+new Intl.Collator("en", {
+	numeric: true,
+	sensitivity: "base"
+});
+// ../project/src/libraries.ts
+/**
+* Where a dependency is installed, found the way Node finds packages: in `node_modules` here or in a folder above. It
+* doesn't resolve `<name>/package.json`, because a package whose `exports` leaves that out can't be resolved that way.
+*/
+async function installedPackage(root, importName) {
+	for (let folder = resolve(root);; folder = dirname(folder)) {
+		const candidate = join(folder, "node_modules", importName);
+		if (await isFile(join(candidate, "package.json"))) return realpath(candidate);
+		if (dirname(folder) === folder) return void 0;
+	}
+}
+async function isFile(path) {
+	return stat(path).then((stats) => stats.isFile(), () => false);
+}
+// ../libgen/src/examples.ts
+const run = promisify(execFile);
+/** Example and story files: stories, demos, examples and docs' demo files, in TypeScript or JavaScript. */
+const examplePath = /(?:\.stories\.[jt]sx?$|\.demo\.[\w.-]*\.?[jt]sx?$|-demo\.[jt]sx?$|\/(?:examples?|demos?|stories)\/.*\.[jt]sx?$)/;
+const skipped = /(?:^|\/)(?:node_modules|dist|build|__tests__|test|tests)\//;
+/**
+* Downloads a library's examples at the commit its installed version was published from, so how its authors put its
+* parts together can be read rather than guessed. Only the example files are fetched (a shallow, sparse git fetch with
+* no other blobs), into a cache kept per commit. Without git, network or a matching commit it returns no files and
+* says why, and generation goes on without them.
+*/
+async function fetchExamples(pkg, packageDir, hints = {}, cacheRoot = join(homedir(), ".parity", "cache", "examples")) {
+	const upstream = await readUpstream(packageDir);
+	const repo = normalizeRepo(hints.repo ?? upstream?.repository ?? repositoryOf(pkg));
+	if (!repo) return {
+		files: [],
+		note: "No repository is named, so no examples were read."
+	};
+	try {
+		const found = await findCommit(repo, pkg, upstream?.revision, cacheRoot);
+		if (!found) return {
+			files: [],
+			note: `No commit of ${repo} could be matched to ${pkg.name} ${pkg.version}.`
+		};
+		const checkedOut = await checkoutExamples(join(cacheRoot, `${slug(repo)}-${found.commit.slice(0, 12)}`), repo, found.commit, hints);
+		const files = checkedOut.filter((file) => !/\.mdx?$/.test(file.path));
+		const docs = checkedOut.filter((file) => /\.mdx?$/.test(file.path));
+		const empty = [
+			...hints.paths ?? [],
+			...hints.demos ?? [],
+			...hints.anatomy ?? []
+		].filter((folder) => !checkedOut.some((file) => file.path.replaceAll("\\", "/").includes(folder.replace(/\/$/, ""))));
+		return {
+			files,
+			docs,
+			source: {
+				repo,
+				commit: found.commit,
+				how: found.how,
+				files: files.length
+			},
+			...empty.length > 0 ? { note: `No examples in ${empty.join(", ")} at ${found.commit.slice(0, 10)}; the folder may have moved.` } : {}
+		};
+	} catch (error) {
+		return {
+			files: [],
+			note: `Examples weren't read from ${repo}: ${message$1(error)}`
+		};
+	}
+}
+async function readUpstream(packageDir) {
+	try {
+		return JSON.parse(await readFile(join(packageDir, "upstream.json"), "utf8"));
+	} catch {
+		return;
+	}
+}
+function repositoryOf(pkg) {
+	return typeof pkg.repository === "string" ? pkg.repository : pkg.repository?.url;
+}
+/** A repository URL git can fetch: `git+https://github.com/a/b.git` and `github:a/b` become `https://github.com/a/b`. */
+function normalizeRepo(url) {
+	if (!url) return void 0;
+	const short = /^(?:github:)?([\w.-]+\/[\w.-]+)$/.exec(url);
+	if (short) return `https://github.com/${short[1].replace(/\.git$/, "")}`;
+	const https = /^(?:git\+)?(?:https?|git|ssh):\/\/(?:git@)?([^/]+)\/(.+?)(?:\.git)?\/?$/.exec(url);
+	return https ? `https://${https[1]}/${https[2]}` : void 0;
+}
+/** The commit the installed version was published from: recorded upstream, npm's `gitHead`, a tag, or by date. */
+async function findCommit(repo, pkg, upstream, cacheRoot) {
+	if (upstream && /^[0-9a-f]{40}$/.test(upstream)) return {
+		commit: upstream,
+		how: "upstream"
+	};
+	const published = await npmVersion(pkg);
+	if (published?.gitHead) return {
+		commit: published.gitHead,
+		how: "gitHead"
+	};
+	const name = pkg.name ?? "";
+	const version = pkg.version ?? "";
+	const tags = /* @__PURE__ */ new Map();
+	const { stdout } = await git([
+		"ls-remote",
+		"--tags",
+		repo
+	], void 0, 6e4);
+	for (const line of stdout.split("\n")) {
+		const [sha, ref] = line.trim().split(/\s+/);
+		if (!sha || !ref) continue;
+		tags.set(ref.replace(/^refs\/tags\//, "").replace(/\^\{\}$/, ""), sha);
+	}
+	const short = name.replace(/^@[^/]+\//, "");
+	for (const tag of [
+		`v${version}`,
+		`${name}@${version}`,
+		`${short}@${version}`,
+		`${short}-v${version}`,
+		version
+	]) {
+		const sha = tags.get(tag);
+		if (sha) return {
+			commit: sha,
+			how: "tag"
+		};
+	}
+	if (!published?.time) return void 0;
+	const dir = join(cacheRoot, `${slug(repo)}-history`);
+	await mkdir(dir, { recursive: true });
+	if (!existsSync(join(dir, ".git"))) await git(["init", "-q"], dir);
+	await git([
+		"fetch",
+		"-q",
+		"--filter=tree:0",
+		`--shallow-since=${(/* @__PURE__ */ new Date(Date.parse(published.time) - 2592e5)).toISOString()}`,
+		repo,
+		"HEAD"
+	], dir, 3e5);
+	const { stdout: commit } = await git([
+		"rev-list",
+		"-1",
+		`--before=${published.time}`,
+		"FETCH_HEAD"
+	], dir);
+	return commit.trim() ? {
+		commit: commit.trim(),
+		how: "date"
+	} : void 0;
+}
+async function npmVersion(pkg) {
+	if (!pkg.name || !pkg.version) return void 0;
+	try {
+		const response = await fetch(`https://registry.npmjs.org/${pkg.name.replace("/", "%2F")}`, {
+			headers: { accept: "application/json" },
+			signal: AbortSignal.timeout(3e4)
+		});
+		if (!response.ok) return void 0;
+		const packument = await response.json();
+		const gitHead = packument.versions?.[pkg.version]?.gitHead;
+		return {
+			...gitHead ? { gitHead } : {},
+			...packument.time?.[pkg.version] ? { time: packument.time[pkg.version] } : {}
+		};
+	} catch {
+		return;
+	}
+}
+/**
+* Checks out only the example files of one commit, once: a later run reads them from the cache, unless the folders
+* looked in have changed since.
+*/
+async function checkoutExamples(dir, repo, commit, { paths, demos = [], anatomy = [] }) {
+	const done = join(dir, ".parity-examples");
+	const key = [
+		commit,
+		"imports",
+		...paths ?? [],
+		...demos.map((demo) => `demos:${demo}`),
+		...anatomy.map((folder) => `anatomy:${folder}`)
+	].join("\n");
+	if (await readFile(done, "utf8").catch(() => void 0) !== key) {
+		await rm(dir, {
+			recursive: true,
+			force: true
+		});
+		await mkdir(dir, { recursive: true });
+		await git(["init", "-q"], dir);
+		await git([
+			"remote",
+			"add",
+			"origin",
+			repo
+		], dir);
+		await git([
+			"fetch",
+			"-q",
+			"--depth",
+			"1",
+			"--filter=blob:none",
+			"origin",
+			commit
+		], dir, 3e5);
+		const { stdout } = await git([
+			"ls-tree",
+			"-r",
+			"--name-only",
+			"FETCH_HEAD"
+		], dir, 12e4);
+		const wanted = stdout.split("\n").filter((path) => path && !skipped.test(path)).filter((path) => examplePath.test(path) && (!paths || paths.some((prefix) => path.startsWith(prefix))) || /\.[jt]sx$/.test(path) && demos.some((prefix) => path.startsWith(prefix)) || /\.mdx?$/.test(path) && anatomy.some((prefix) => path.startsWith(prefix))).slice(0, 5e3);
+		const checkout = async (paths) => {
+			await git([
+				"sparse-checkout",
+				"set",
+				"--no-cone",
+				"--stdin"
+			], dir, 6e4, paths.map((path) => `/${path}`).join("\n"));
+			await git([
+				"checkout",
+				"-q",
+				"FETCH_HEAD"
+			], dir, 6e5);
+		};
+		if (wanted.length > 0) {
+			await checkout(wanted);
+			const tree = stdout.split("\n").filter((path) => /\.[jt]sx?$/.test(path) && !skipped.test(path));
+			let scan = [...wanted];
+			for (let added = 0; scan.length > 0 && added < 500;) {
+				const texts = await Promise.all(scan.map((path) => readFile(join(dir, path), "utf8").catch(() => "")));
+				const imported = localImports(scan, texts, tree).filter((path) => !wanted.includes(path)).slice(0, 500 - added);
+				if (imported.length === 0) break;
+				wanted.push(...imported);
+				added += imported.length;
+				await checkout(wanted);
+				scan = imported;
+			}
+		}
+		await writeFile(join(dir, ".parity-wanted"), wanted.join("\n"));
+		await writeFile(done, key);
+	}
+	const wanted = (await readFile(join(dir, ".parity-wanted"), "utf8")).split("\n").filter(Boolean);
+	const files = [];
+	for (const path of wanted) {
+		const text = await readFile(join(dir, path), "utf8").catch(() => void 0);
+		if (text !== void 0) files.push({
+			path,
+			text
+		});
+	}
+	return files;
+}
+/**
+* The files of a repository's tree that its example files import, relatively (`./utils`) or by a path the repository
+* maps (`compositions/ui/toaster`, matched by the end of a file's path), but not packages (`react`, `@chakra-ui/react`).
+*/
+function localImports(paths, texts, tree) {
+	const local = localResolver(tree);
+	const found = /* @__PURE__ */ new Set();
+	paths.forEach((path, index) => {
+		for (const match of texts[index].matchAll(/\bfrom\s+["']([^"']+)["']/g)) {
+			const target = local(path, match[1]);
+			if (target) found.add(target);
+		}
+	});
+	return [...found];
+}
+/** The file of a tree an import names, relatively or by a mapped path, or none for a package. */
+function localResolver(tree) {
+	const byStem = /* @__PURE__ */ new Map();
+	for (const path of tree) byStem.set(path.replaceAll("\\", "/").replace(/(?:\/index)?\.[jt]sx?$/, ""), path);
+	const bySuffix = /* @__PURE__ */ new Map();
+	for (const [stemmed, target] of byStem) {
+		const candidate = stemmed.replace(/\/src(?=\/)/g, "");
+		for (let at = -1; at < candidate.length; at = candidate.indexOf("/", at + 1)) {
+			const suffix = candidate.slice(at + 1);
+			if (!bySuffix.has(suffix)) bySuffix.set(suffix, target);
+			if (!candidate.includes("/", at + 1)) break;
+		}
+	}
+	return (from, specifier) => {
+		if (specifier.startsWith(".")) return byStem.get(posix.join(posix.dirname(from.replaceAll("\\", "/")), specifier));
+		if (!specifier.startsWith("@/") && (specifier.startsWith("@") ? specifier.split("/").length < 3 : !specifier.includes("/"))) return void 0;
+		return bySuffix.get(specifier.replace(/^[@~]\//, ""));
+	};
+}
+/**
+* The methods example files call on a value another file makes and exports (Chakra's `toaster.create({ title, type })`
+* on `compositions/ui/toaster`'s `toaster`), by that file and the name it exports, with arguments the caller spells out:
+* for each method, its fullest call.
+*/
+function methodCallsOn(files, sourceOf, pkg, reexported) {
+	const local = localResolver(files.map((file) => file.path));
+	const found = /* @__PURE__ */ new Map();
+	for (const file of files) {
+		if (!/\.\w+\(/.test(file.text) || !/\bfrom\s+["'](?:\.|[^"'@]+\/|@\/)/.test(file.text)) continue;
+		const source = sourceOf(file);
+		const imported = /* @__PURE__ */ new Map();
+		for (const statement of source.statements) {
+			if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier)) continue;
+			const target = local(file.path, statement.moduleSpecifier.text);
+			const bindings = statement.importClause?.namedBindings;
+			if (!target || !bindings || !ts.isNamedImports(bindings)) continue;
+			for (const element of bindings.elements) imported.set(element.name.text, {
+				file: target,
+				name: (element.propertyName ?? element.name).text
+			});
+		}
+		if (imported.size === 0) continue;
+		const context = {
+			source,
+			resolve: () => void 0,
+			scope: declarations(source),
+			env: /* @__PURE__ */ new Map(),
+			...pkg ? { imports: packageImports(source, pkg, reexported) } : {}
+		};
+		const visit = (node) => {
+			if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.expression)) {
+				const on = imported.get(node.expression.expression.text);
+				const args = node.arguments.map((argument) => evaluate(argument, context, 0));
+				if (on && args.length > 0 && !args.some((argument) => argument === void 0)) {
+					const method = node.expression.name.text;
+					const byName = found.get(on.file) ?? /* @__PURE__ */ new Map();
+					const calls = byName.get(on.name) ?? /* @__PURE__ */ new Map();
+					const call = {
+						method,
+						...args.length > 0 ? { args } : {}
+					};
+					const before = calls.get(method);
+					if (!before || JSON.stringify(call).length > JSON.stringify(before).length) calls.set(method, call);
+					byName.set(on.name, calls);
+					found.set(on.file, byName);
+				}
+			}
+			ts.forEachChild(node, visit);
+		};
+		visit(source);
+	}
+	return new Map([...found].map(([path, byName]) => [path, new Map([...byName].map(([name, calls]) => [name, [...calls.values()].slice(0, 3)]))]));
+}
+async function git(args, cwd, timeout = 6e4, input) {
+	const child = run("git", args, {
+		cwd,
+		timeout,
+		maxBuffer: 268435456,
+		windowsHide: true
+	});
+	if (input !== void 0) {
+		child.child.stdin?.write(input);
+		child.child.stdin?.end();
+	}
+	const { stdout } = await child;
+	return { stdout: String(stdout) };
+}
+function slug(repo) {
+	return repo.replace(/^https?:\/\//, "").replace(/[^\w.-]+/g, "-");
+}
+function message$1(error) {
+	return (error instanceof Error ? error.message : String(error)).split("\n")[0].slice(0, 200);
+}
+/**
+* Reads how a library's components are used in its examples: each element whose tag is one of its components (as
+* written, `Dialog.Content`, or with the dot left out, `Menu.Item` for `MenuItem`), every such element around it, and
+* its props and children. Props are worked out where the file says what they are: literals, names it declares
+* (`config={chartConfig}`), `useState`'s first value, and the items a list maps into elements.
+*/
+function readExamples(files, names, pkg, reexported = /* @__PURE__ */ new Set()) {
+	const known = new Set(names);
+	const flat = new Map(names.map((name) => [name.replaceAll(".", ""), name]));
+	const resolve = (tag) => known.has(tag) ? tag : flat.get(tag.replaceAll(".", ""));
+	const uses = /* @__PURE__ */ new Map();
+	const sources = /* @__PURE__ */ new Map();
+	/** How many uses of each part set each prop. */
+	const setBy = /* @__PURE__ */ new Map();
+	let kin = /* @__PURE__ */ new Map();
+	const sourceOf = (file) => {
+		const source = sources.get(file) ?? ts.createSourceFile(file.path, file.text, ts.ScriptTarget.Latest, false, ts.ScriptKind.TSX);
+		sources.set(file, source);
+		return source;
+	};
+	const imported = importedWrappers(files, sourceOf, resolve);
+	const calledOn = methodCallsOn(files, sourceOf, pkg, reexported);
+	for (const sampling of [false, true]) {
+		if (sampling) kin = kinOf(uses);
+		const family = (name) => kin.get(name) ?? familyOf(name);
+		for (const file of files) {
+			if (!sampling && !names.some((name) => file.text.includes(name.split(".").at(-1)))) continue;
+			if (sampling && !sources.has(file)) continue;
+			const source = sourceOf(file);
+			readSource(source, uses, resolve, sampling ? family : void 0, setBy, pkg, imported(source), reexported, calledOn.get(file.path));
+		}
+	}
+	for (const [name, family] of kin) {
+		const use = uses.get(name);
+		if (use) use.family = family;
+	}
+	for (const use of uses.values()) {
+		if (!use.made || !use.sample) continue;
+		const missing = Object.entries(use.made).filter(([prop]) => !(prop in (use.sample.props ?? {})));
+		if (missing.length > 0) use.sample.props = {
+			...Object.fromEntries(missing),
+			...use.sample.props
+		};
+	}
+	for (const [name, use] of uses) {
+		const props = use.sample?.props;
+		if (!props || use.count < 5) continue;
+		for (const prop of Object.keys(props)) {
+			if (madeIn(props[prop])) continue;
+			const set = setBy.get(name)?.get(prop) ?? 0;
+			if (set >= 2 && set * 4 >= use.usePaths.length) continue;
+			use.rare = {
+				...use.rare,
+				[prop]: props[prop]
+			};
+			delete props[prop];
+		}
+		if (Object.keys(props).length === 0) delete use.sample.props;
+	}
+	return uses;
+}
+/**
+* Reads one file's uses: where each part is placed, or with `family`, only the samples, each keeping its own family's
+* parts.
+*/
+function readSource(source, uses, base, family, setBy, pkg, imported = /* @__PURE__ */ new Map(), reexported = /* @__PURE__ */ new Set(), calledOn) {
+	const aliases = pkg ? importAliases(source, pkg) : /* @__PURE__ */ new Map();
+	const own = base;
+	base = (tag) => own(aliases.get(tag) ?? tag);
+	const wrapping = new Map([...imported, ...wrappers(source, base)]);
+	const resolve = (tag) => base(tag) ?? wrapping.get(tag)?.name;
+	const wrapped = new Set([...wrapping.values()].map((wrapper) => wrapper.root));
+	const context = {
+		source,
+		resolve,
+		scope: declarations(source),
+		env: /* @__PURE__ */ new Map(),
+		wrapping,
+		...pkg ? { imports: packageImports(source, pkg, reexported) } : {},
+		...calledOn ? { calledOn } : {}
+	};
+	const placedHere = /* @__PURE__ */ new Set();
+	const hooked = hookResults(source);
+	const drawnFromHook = mappedComponents(source, hooked, base);
+	context.hooked = hooked;
+	context.hookItem = hookItem(source, hooked, context);
+	const drawnWith = drawnProps(source, drawnFromHook, context);
+	const visit = (node, around, mapped, env) => {
+		let here = around;
+		if (ts.isJsxElement(node) || ts.isJsxSelfClosingElement(node)) {
+			const tag = (ts.isJsxElement(node) ? node.openingElement : node).tagName.getText(source);
+			const name = resolve(tag);
+			if (name) {
+				const use = uses.get(name) ?? {
+					count: 0,
+					topLevel: 0,
+					parents: /* @__PURE__ */ new Map(),
+					paths: [],
+					usePaths: [],
+					sampleSize: -1,
+					fromHook: true
+				};
+				if (!family && !wrapped.has(node)) {
+					if (!mapped) use.fromHook = false;
+					const path = [...new Set(around)].filter((parent) => parent !== name);
+					if (use.usePaths.length < 300) use.usePaths.push(path);
+					const key = `${name}<${path.join("<")}`;
+					if (!placedHere.has(key)) {
+						placedHere.add(key);
+						use.count++;
+						const nearest = path[0];
+						if (nearest) use.parents.set(nearest, (use.parents.get(nearest) ?? 0) + 1);
+						else use.topLevel++;
+						if (use.paths.length < 300) use.paths.push(path);
+					}
+				}
+				if (family) {
+					const sample = familySample(usedSample(node, {
+						...context,
+						env
+					}, 0), family(name), family);
+					const counts = setBy?.get(name) ?? /* @__PURE__ */ new Map();
+					for (const [prop, value] of Object.entries(sample.props ?? {})) {
+						counts.set(prop, (counts.get(prop) ?? 0) + 1);
+						if (madeIn(value) && !(prop in (use.made ?? {}))) use.made = {
+							...use.made,
+							[prop]: value
+						};
+					}
+					setBy?.set(name, counts);
+					const size = sampleWeight(sample);
+					if (size > use.sampleSize) {
+						use.sample = sample;
+						use.sampleSize = size;
+					}
+				}
+				uses.set(name, use);
+				here = [name, ...around];
+			}
+		}
+		const declared = declaredName(node);
+		const inList = mapped || hookMapped(node, hooked, source) || drawnFromHook.has(declared ?? "");
+		let inner = env;
+		const callback = mapCallback(node);
+		const mappedList = callback && node.expression.expression;
+		const listed = mappedList ? listOf(mappedList, {
+			...context,
+			env
+		}) : void 0;
+		if (callback && Array.isArray(listed) && listed[0] !== void 0) {
+			inner = new Map(env);
+			bind(callback.parameters[0]?.name, listed[0], inner);
+		} else if (callback && hookMapped(node, hooked, source) && context.hookItem) {
+			inner = new Map(env);
+			bind(callback.parameters[0]?.name, itemFor(callback, context.hookItem, source), inner);
+		} else if (declared && drawnWith.has(declared)) {
+			inner = new Map(env);
+			bind(firstParameter(node), drawnWith.get(declared), inner);
+		}
+		ts.forEachChild(node, (child) => {
+			if (!ts.isJsxAttributes(child)) visit(child, here, inList, inner);
+			else ts.forEachChild(child, (attribute) => visit(attribute, rendersInside(attribute) ? here : [], inList, inner));
+		});
+	};
+	visit(source, [], false, /* @__PURE__ */ new Map());
+}
+/**
+* The family each part joins beyond its name's: one the examples nearly always place, and place directly inside one
+* family, belongs to it (`Row` and `Cell` to `Table`), so a table's sample keeps its rows and columns. Not when its own
+* family is usually around it too, or into a layout box that holds every family.
+*/
+function kinOf(uses) {
+	const kin = /* @__PURE__ */ new Map();
+	const holds = /* @__PURE__ */ new Map();
+	for (const [name, use] of uses) for (const parent of use.parents.keys()) {
+		if (familyOf(parent) === familyOf(name)) continue;
+		holds.set(familyOf(parent), (holds.get(familyOf(parent)) ?? /* @__PURE__ */ new Set()).add(familyOf(name)));
+	}
+	const generic = (family) => (holds.get(family)?.size ?? 0) > 8;
+	for (let round = 0; round < 4; round++) {
+		let changed = false;
+		for (const [name, use] of uses) {
+			if (use.count < 2) continue;
+			if (use.paths.filter((path) => path.some((parent) => familyOf(parent) === familyOf(name))).length * 2 >= use.paths.length) continue;
+			const families = /* @__PURE__ */ new Map();
+			let placed = 0;
+			for (const [parent, count] of use.parents) {
+				const family = kin.get(parent) ?? familyOf(parent);
+				families.set(family, (families.get(family) ?? 0) + count);
+				placed += count;
+			}
+			const [family, count] = [...families].sort((a, b) => b[1] - a[1])[0] ?? [];
+			if (!family || !count || count < placed * .75 || family === familyOf(name) || kin.get(name) === family) continue;
+			if (!name.toLowerCase().includes(family.toLowerCase()) && (use.topLevel * 10 > use.count || generic(family))) continue;
+			kin.set(name, family);
+			changed = true;
+		}
+		if (!changed) break;
+	}
+	return kin;
+}
+/**
+* The wrappers a file imports from another example file beside it (React Aria's stories take `MyMenuItem` from
+* `./utils`). Only ones that pass their props on count: a wrapper's own element is sampled from its file, not this one.
+*/
+function importedWrappers(files, sourceOf, resolve) {
+	const byPath = new Map(files.map((file) => [file.path.replaceAll("\\", "/"), file]));
+	const declared = /* @__PURE__ */ new Map();
+	return (source) => {
+		const found = /* @__PURE__ */ new Map();
+		for (const statement of source.statements) {
+			if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier)) continue;
+			const specifier = statement.moduleSpecifier.text;
+			const bindings = statement.importClause?.namedBindings;
+			if (!specifier.startsWith(".") || !bindings || !ts.isNamedImports(bindings)) continue;
+			const base = posix.join(posix.dirname(source.fileName.replaceAll("\\", "/")), specifier);
+			const file = [
+				"",
+				".tsx",
+				".ts",
+				".jsx",
+				".js",
+				"/index.tsx",
+				"/index.ts"
+			].map((extension) => byPath.get(base + extension)).find((item) => item !== void 0);
+			if (!file) continue;
+			let theirs = declared.get(file);
+			if (!theirs) {
+				theirs = wrappers(sourceOf(file), resolve, false);
+				declared.set(file, theirs);
+			}
+			for (const element of bindings.elements) {
+				const wrapper = theirs.get((element.propertyName ?? element.name).text);
+				if (wrapper?.spread) found.set(element.name.text, wrapper);
+			}
+		}
+		return found;
+	};
+}
+/**
+* The example's own components that return one of the library's parts and no other element (`const CustomTab = (props)
+* => <Tab {...props} />`), each with the part, its element, and whether it hands its props on. With `usedHere`, only
+* those the file places, as against ones it declares for other files.
+*/
+function wrappers(source, resolve, usedHere = true) {
+	const found = /* @__PURE__ */ new Map();
+	const tags = /* @__PURE__ */ new Set();
+	const visit = (node) => {
+		if (ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node)) tags.add(node.tagName.getText(source));
+		const declared = declaredName(node);
+		if (declared && !resolve(declared)) {
+			let fn = ts.isVariableDeclaration(node) ? node.initializer && unwrap$1(node.initializer) : node;
+			if (fn && ts.isCallExpression(fn)) fn = fn.arguments.find((argument) => ts.isFunctionLike(argument));
+			const body = fn && (ts.isArrowFunction(fn) || ts.isFunctionExpression(fn) || ts.isFunctionDeclaration(fn)) ? returned(fn) : void 0;
+			const elements = body && ts.isJsxFragment(body) ? body.children.filter((child) => ts.isJsxElement(child) || ts.isJsxSelfClosingElement(child)) : [];
+			const root = elements.length === 1 ? elements[0] : body;
+			const opening = root && openingOf(root);
+			const name = opening && resolve(opening.tagName.getText(source));
+			if (root && opening && name) {
+				const spread = opening.attributes.properties.some(ts.isJsxSpreadAttribute);
+				found.set(declared, {
+					name,
+					root,
+					spread
+				});
+			}
+		}
+		ts.forEachChild(node, visit);
+	};
+	visit(source);
+	if (usedHere) {
+		for (const declared of found.keys()) if (!tags.has(declared)) found.delete(declared);
+	}
+	return found;
+}
+/** The names a file imports from a package or its subpaths (`@base-ui/react/toast`), with what each is there. */
+/** Whether a prop's value is one the package makes, or a list holding one. */
+function madeIn(value) {
+	return isMadeValue(value) || Array.isArray(value) && value.some(isMadeValue);
+}
+/** The library's parts a file imports under names of its own, by those names. */
+function importAliases(source, pkg) {
+	const found = /* @__PURE__ */ new Map();
+	for (const statement of source.statements) {
+		if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier)) continue;
+		const from = statement.moduleSpecifier.text;
+		const bindings = statement.importClause?.namedBindings;
+		if (from !== pkg && !from.startsWith(`${pkg}/`) || !bindings || !ts.isNamedImports(bindings)) continue;
+		for (const element of bindings.elements) if (element.propertyName) found.set(element.name.text, element.propertyName.text);
+	}
+	return found;
+}
+function packageImports(source, pkg, reexported = /* @__PURE__ */ new Set()) {
+	const found = /* @__PURE__ */ new Map();
+	for (const statement of source.statements) {
+		if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier)) continue;
+		const from = statement.moduleSpecifier.text;
+		const own = from === pkg || from.startsWith(`${pkg}/`);
+		const bindings = statement.importClause?.namedBindings;
+		if (from.startsWith(".") || !bindings || !ts.isNamedImports(bindings)) continue;
+		for (const element of bindings.elements) {
+			const name = (element.propertyName ?? element.name).text;
+			if (own) found.set(element.name.text, {
+				import: from,
+				export: name
+			});
+			else if (reexported.has(name)) found.set(element.name.text, {
+				import: pkg,
+				export: name
+			});
+		}
+	}
+	return found;
+}
+function sampleOf(node, context, depth) {
+	const opening = ts.isJsxElement(node) ? node.openingElement : node;
+	const props = {};
+	const skipped = (name) => name === "key" || name === "className" || name === "style" || name.startsWith("on");
+	for (const attribute of opening.attributes.properties) {
+		if (ts.isJsxSpreadAttribute(attribute)) {
+			const spread = evaluate(attribute.expression, context, 0);
+			if (typeof spread !== "object" || spread === null || Array.isArray(spread)) continue;
+			for (const [name, value] of Object.entries(spread)) if (!skipped(name)) props[name] = value;
+			continue;
+		}
+		if (!ts.isJsxAttribute(attribute)) continue;
+		const name = attribute.name.getText(context.source);
+		if (skipped(name)) continue;
+		const value = attributeValue(attribute.initializer, context);
+		if (value !== void 0) props[name] = value;
+	}
+	const children = [];
+	if (ts.isJsxElement(node) && depth < 4) collectChildren(node.children, context, depth, children);
+	return {
+		...Object.keys(props).length > 0 ? { props } : {},
+		...children.length > 0 ? { children } : {}
+	};
+}
+/**
+* An element's sample. The example's own wrapper that doesn't hand its props on (`<Item title="Docs">`) shows its own
+* element's props, and the children it's given when that element has none of its own.
+*/
+function usedSample(element, context, depth) {
+	const tag = (ts.isJsxElement(element) ? element.openingElement : element).tagName.getText(context.source);
+	const wrapper = context.wrapping?.get(tag);
+	const here = sampleOf(element, context, depth);
+	if (!wrapper || wrapper.spread) return here;
+	const own = sampleOf(wrapper.root, context, depth);
+	return {
+		...own.props ? { props: own.props } : {},
+		...own.children ?? here.children ? { children: own.children ?? here.children } : {}
+	};
+}
+function collectChildren(nodes, context, depth, children) {
+	for (const child of nodes) {
+		if (children.length >= 4) return;
+		if (ts.isJsxText(child)) {
+			const text = child.text.replace(/\s+/g, " ").trim();
+			if (text) children.push(text.slice(0, 60));
+		} else if (ts.isJsxFragment(child)) collectChildren(child.children, context, depth, children);
+		else if (ts.isJsxElement(child) || ts.isJsxSelfClosingElement(child)) pushElement(child, context, depth, children);
+		else if (ts.isJsxExpression(child) && child.expression) pushExpression(unwrap$1(child.expression), context, depth, children);
+	}
+}
+function pushElement(element, context, depth, children) {
+	const tag = (ts.isJsxElement(element) ? element.openingElement : element).tagName.getText(context.source);
+	const name = context.resolve(tag);
+	if (name) {
+		const sample = usedSample(element, context, depth + 1);
+		const filled = ts.isJsxElement(element) && element.children.some((child) => ts.isJsxElement(child) || ts.isJsxSelfClosingElement(child));
+		children.push({
+			component: name,
+			...sample,
+			...filled && !sample.children ? { children: [] } : {}
+		});
+	} else {
+		const text = textIn(element);
+		if (text) children.push(text);
+	}
+}
+/** A `{...}` child: a list mapped into elements (a few of its items), a condition's element, or text. */
+function pushExpression(expression, context, depth, children) {
+	if (ts.isArrowFunction(expression) || ts.isFunctionExpression(expression)) {
+		const render = renderOf(expression, context, depth);
+		if (render) children.push(render);
+		return;
+	}
+	if (ts.isJsxElement(expression) || ts.isJsxSelfClosingElement(expression)) {
+		pushElement(expression, context, depth, children);
+		return;
+	}
+	if (ts.isJsxFragment(expression)) {
+		collectChildren(expression.children, context, depth, children);
+		return;
+	}
+	if (ts.isBinaryExpression(expression) && expression.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken) {
+		pushExpression(unwrap$1(expression.right), context, depth, children);
+		return;
+	}
+	if (ts.isConditionalExpression(expression)) {
+		pushExpression(unwrap$1(expression.whenTrue), context, depth, children);
+		return;
+	}
+	if (ts.isCallExpression(expression) && ts.isPropertyAccessExpression(expression.expression) && expression.expression.name.text === "map") {
+		const callback = expression.arguments[0];
+		if (!callback || !(ts.isArrowFunction(callback) || ts.isFunctionExpression(callback))) return;
+		const body = returned(callback);
+		if (!body) return;
+		const list = listOf(expression.expression.expression, context);
+		let items;
+		if (Array.isArray(list)) items = list.slice(0, 3);
+		else if (context.hookItem && context.hooked && hookMapped(expression, context.hooked, context.source)) items = [itemFor(callback, context.hookItem, context.source)];
+		else items = [void 0];
+		items.forEach((item, index) => {
+			const env = new Map(context.env);
+			if (item !== void 0) bind(callback.parameters[0]?.name, item, env);
+			const second = callback.parameters[1]?.name;
+			if (second && ts.isIdentifier(second)) env.set(second.text, index);
+			pushExpression(body, {
+				...context,
+				env
+			}, depth, children);
+		});
+		return;
+	}
+	const value = evaluate(expression, context, 0);
+	if (typeof value === "string" || typeof value === "number") children.push(String(value).slice(0, 60));
+}
+/**
+* A function that returns elements, as a sample's render function: what it returns, and whether it spreads its first
+* parameter onto them (`(params) => <TextField {...params} />`).
+*/
+function renderOf(callback, context, depth) {
+	let body = returned(callback);
+	if (body && ts.isConditionalExpression(body)) body = unwrap$1(body.whenTrue);
+	if (!body || !(ts.isJsxElement(body) || ts.isJsxSelfClosingElement(body) || ts.isJsxFragment(body))) return void 0;
+	const inner = [];
+	pushExpression(body, context, depth, inner);
+	if (inner.length === 0) return void 0;
+	const first = callback.parameters[0]?.name;
+	const opening = openingOf(body);
+	const argument = first && ts.isIdentifier(first) ? first.text : void 0;
+	const takes = (expression) => !!argument && !!expression && ts.isIdentifier(expression) && expression.text === argument;
+	const attributes = opening?.attributes.properties ?? [];
+	const spread = attributes.some((attribute) => ts.isJsxSpreadAttribute(attribute) && takes(attribute.expression));
+	const pass = attributes.flatMap((attribute) => ts.isJsxAttribute(attribute) && attribute.initializer && ts.isJsxExpression(attribute.initializer) && takes(attribute.initializer.expression) ? [attribute.name.getText(context.source)] : []);
+	return {
+		$render: inner,
+		...spread ? { spread: true } : {},
+		...pass.length > 0 ? { pass } : {}
+	};
+}
+/** The JSX a callback returns, from an expression body or its first `return`. */
+function returned(callback) {
+	if (!callback.body) return void 0;
+	if (!ts.isBlock(callback.body)) return unwrap$1(callback.body);
+	const found = callback.body.statements.find(ts.isReturnStatement);
+	return found?.expression ? unwrap$1(found.expression) : void 0;
+}
+function bind(name, value, env) {
+	if (!name) return;
+	if (ts.isIdentifier(name)) env.set(name.text, value);
+	else if (ts.isObjectBindingPattern(name) && typeof value === "object" && value !== null) for (const element of name.elements) {
+		const key = element.propertyName ?? element.name;
+		if (ts.isIdentifier(key) || ts.isStringLiteral(key)) bind(element.name, value[key.text], env);
+	}
+	else if (ts.isArrayBindingPattern(name) && Array.isArray(value)) name.elements.forEach((element, index) => {
+		if (!ts.isOmittedExpression(element)) bind(element.name, value[index], env);
+	});
+}
+/** What each name a file declares is set to: `const x = ...`, and `const [x] = useState(...)`'s first value. */
+function declarations(source) {
+	const scope = /* @__PURE__ */ new Map();
+	const visit = (node) => {
+		if (ts.isVariableDeclaration(node) && node.initializer) {
+			const initializer = unwrap$1(node.initializer);
+			if (ts.isIdentifier(node.name) && !scope.has(node.name.text)) scope.set(node.name.text, initializer);
+			if (ts.isObjectBindingPattern(node.name) && ts.isCallExpression(initializer)) {
+				for (const element of node.name.elements) if (ts.isIdentifier(element.name) && !scope.has(element.name.text)) scope.set(element.name.text, initializer);
+			}
+			const state = ts.isArrayBindingPattern(node.name) && ts.isCallExpression(initializer) && /(?:^|\.)use(?:State|Controllable\w*)$/.test(initializer.expression.getText(source));
+			const first = state ? node.name.elements[0] : void 0;
+			const argument = state ? initializer.arguments[0] : void 0;
+			if (first && !ts.isOmittedExpression(first) && ts.isIdentifier(first.name) && argument) {
+				if (!scope.has(first.name.text)) scope.set(first.name.text, unwrap$1(argument));
+			}
+		}
+		ts.forEachChild(node, visit);
+	};
+	visit(source);
+	return scope;
+}
+/** Hooks that hold the example's own values, not data the library hands it. */
+const ownValueHooks = /(?:^|\.)use(?:State|Reducer|Memo|Callback|Ref|DeferredValue|Transition|Controllable\w*)$/;
+/**
+* The names a file binds to what a library hook returns (`const { toasts } = Toast.useToastManager()`), or to what a
+* library factory makes (`const manager = Toast.createToastManager()`), whose items reach the same lists.
+*/
+function hookResults(source) {
+	const names = /* @__PURE__ */ new Set();
+	const made = (expression) => isHookCall(expression, source) || ts.isCallExpression(expression) && /(?:^|\.)create[A-Z]\w*$/.test(expression.expression.getText(source));
+	const visit = (node) => {
+		if (ts.isVariableDeclaration(node) && node.initializer && made(unwrap$1(node.initializer))) {
+			if (ts.isIdentifier(node.name)) names.add(node.name.text);
+			else for (const element of node.name.elements) if (!ts.isOmittedExpression(element) && ts.isIdentifier(element.name)) names.add(element.name.text);
+		}
+		ts.forEachChild(node, visit);
+	};
+	visit(source);
+	return names;
+}
+function isHookCall(expression, source) {
+	if (!ts.isCallExpression(expression)) return false;
+	const callee = expression.expression.getText(source);
+	return /(?:^|\.)use[A-Z]\w*$/.test(callee) && !ownValueHooks.test(callee);
+}
+/**
+* The example's own components drawn only for a hook's list items (`toasts.map((toast) => <MyToast toast={toast} />)`),
+* and those they draw in turn, so the library parts inside them count as mapped too.
+*/
+function mappedComponents(source, hooked, resolve) {
+	const bodies = /* @__PURE__ */ new Map();
+	const visit = (node) => {
+		const name = declaredName(node);
+		if (name) bodies.set(name, node);
+		ts.forEachChild(node, visit);
+	};
+	visit(source);
+	const tagsIn = (node, found = []) => {
+		if (ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node)) {
+			const tag = node.tagName.getText(source);
+			if (bodies.has(tag) && !resolve(tag)) found.push(tag);
+		}
+		ts.forEachChild(node, (child) => {
+			tagsIn(child, found);
+		});
+		return found;
+	};
+	const found = /* @__PURE__ */ new Set();
+	const queue = [];
+	const lists = (node) => {
+		if (hookMapped(node, hooked, source)) queue.push(...tagsIn(node));
+		else ts.forEachChild(node, lists);
+	};
+	lists(source);
+	while (queue.length > 0) {
+		const next = queue.pop();
+		if (found.has(next)) continue;
+		found.add(next);
+		queue.push(...tagsIn(bodies.get(next)));
+	}
+	return found;
+}
+/**
+* A sample item for the lists a library keeps, across its examples: the fullest object they hand one of `values`, what
+* the package makes and exports (`toast.add({ title, description })` with Buildkit's `toast`).
+*/
+function exampleItem(files, values) {
+	let best;
+	if (values.size === 0) return void 0;
+	for (const file of files) {
+		if (![...values].some((value) => file.text.includes(`${value}.`))) continue;
+		const source = ts.createSourceFile(file.path, file.text, ts.ScriptTarget.Latest, false, ts.ScriptKind.TSX);
+		const item = hookItem(source, values, {
+			source,
+			resolve: () => void 0,
+			scope: declarations(source),
+			env: /* @__PURE__ */ new Map()
+		});
+		if (item && Object.keys(item).length > Object.keys(best ?? {}).length) best = item;
+	}
+	return best;
+}
+/**
+* A sample item for the lists a hook returns: the fullest object the file hands one of the hook's results
+* (`toastManager.add({ title, description })`), which is what the library puts in the list.
+*/
+function hookItem(source, hooked, context) {
+	let best;
+	const visit = (node) => {
+		if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)) {
+			let root = unwrap$1(node.expression.expression);
+			while (ts.isPropertyAccessExpression(root)) root = unwrap$1(root.expression);
+			const argument = node.arguments[0] && unwrap$1(node.arguments[0]);
+			if (ts.isIdentifier(root) && hooked.has(root.text) && argument && ts.isObjectLiteralExpression(argument)) {
+				const value = evaluate(argument, context, 0);
+				if (value && Object.keys(value).length > Object.keys(best ?? {}).length) best = value;
+			}
+		}
+		ts.forEachChild(node, visit);
+	};
+	visit(source);
+	return best;
+}
+/** The item a map callback gets, with an `id` when it reads one (`key={toast.id}`), as lists key their items. */
+function itemFor(callback, item, source) {
+	const name = callback.parameters[0]?.name;
+	return !!name && ts.isIdentifier(name) && callback.getText(source).includes(`${name.text}.id`) && item.id === void 0 ? {
+		id: "1",
+		...item
+	} : item;
+}
+/** The props each of the example's own components gets where a hook's list is mapped into it. */
+function drawnProps(source, drawn, context) {
+	const found = /* @__PURE__ */ new Map();
+	const { hooked, hookItem: item } = context;
+	if (drawn.size === 0 || !item || !hooked) return found;
+	const visit = (node) => {
+		const callback = hookMapped(node, hooked, source) ? node.arguments[0] : void 0;
+		if (!callback || !(ts.isArrowFunction(callback) || ts.isFunctionExpression(callback))) {
+			ts.forEachChild(node, visit);
+			return;
+		}
+		const env = /* @__PURE__ */ new Map();
+		bind(callback.parameters[0]?.name, itemFor(callback, item, source), env);
+		const inner = (child) => {
+			if (ts.isJsxOpeningElement(child) || ts.isJsxSelfClosingElement(child)) {
+				const tag = child.tagName.getText(source);
+				if (drawn.has(tag) && !found.has(tag)) {
+					const props = {};
+					for (const attribute of child.attributes.properties) {
+						if (!ts.isJsxAttribute(attribute)) continue;
+						const value = attributeValue(attribute.initializer, {
+							...context,
+							env
+						});
+						if (value !== void 0) props[attribute.name.getText(source)] = value;
+					}
+					found.set(tag, props);
+				}
+			}
+			ts.forEachChild(child, inner);
+		};
+		inner(callback);
+	};
+	visit(source);
+	return found;
+}
+/** A declared component's first parameter, for its props. */
+function firstParameter(node) {
+	let fn = ts.isVariableDeclaration(node) ? node.initializer && unwrap$1(node.initializer) : node;
+	if (fn && ts.isCallExpression(fn)) fn = fn.arguments.find((argument) => ts.isFunctionLike(argument));
+	if (fn && (ts.isFunctionDeclaration(fn) || ts.isArrowFunction(fn) || ts.isFunctionExpression(fn))) return fn.parameters[0]?.name;
+}
+/** The opening tag of a JSX element, or the element itself when it closes itself. */
+function openingOf(node) {
+	if (ts.isJsxElement(node)) return node.openingElement;
+	return ts.isJsxSelfClosingElement(node) ? node : void 0;
+}
+/** The name of a component a file declares: `function Name()` or `const Name = ...`, capitalised. */
+function declaredName(node) {
+	let name;
+	if (ts.isFunctionDeclaration(node) && node.name) name = node.name.text;
+	else if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer) name = node.name.text;
+	return name && /^[A-Z]/.test(name) ? name : void 0;
+}
+/** Whether a prop is a render function (`render={({ node }) => ...}`), which the component draws inside itself. */
+function rendersInside(attribute) {
+	const value = ts.isJsxAttribute(attribute) && attribute.initializer;
+	const expression = value && ts.isJsxExpression(value) && value.expression && unwrap$1(value.expression);
+	return !!expression && (ts.isArrowFunction(expression) || ts.isFunctionExpression(expression));
+}
+/** The callback of a `list.map(callback)` call. */
+function mapCallback(node) {
+	if (!ts.isCallExpression(node) || !ts.isPropertyAccessExpression(node.expression)) return void 0;
+	if (node.expression.name.text !== "map") return void 0;
+	const callback = node.arguments[0];
+	return callback && (ts.isArrowFunction(callback) || ts.isFunctionExpression(callback)) ? callback : void 0;
+}
+/**
+* A list a file maps: its value, or a field of the options a library factory or hook was given
+* (`createListCollection({ items })`, `useListCollection({ initialItems })`, where `initialItems` is what `items`
+* starts as). Only lists are read this way, so a prop given the collection itself isn't mistaken for its options.
+*/
+function listOf(expression, context) {
+	const value = evaluate(expression, context, 0);
+	if (value !== void 0) return value;
+	expression = unwrap$1(expression);
+	if (!ts.isPropertyAccessExpression(expression)) return void 0;
+	let made = unwrap$1(expression.expression);
+	if (ts.isIdentifier(made)) {
+		const declared = context.scope.get(made.text);
+		if (declared) made = unwrap$1(declared);
+	}
+	if (!ts.isCallExpression(made)) return void 0;
+	if (!/(?:^|\.)(?:create|use)[A-Z]\w*$/.test(made.expression.getText(context.source))) return void 0;
+	const argument = made.arguments[0] && unwrap$1(made.arguments[0]);
+	if (!argument || !ts.isObjectLiteralExpression(argument)) return void 0;
+	const options = evaluate(argument, context, 0);
+	const field = expression.name.text;
+	return options?.[field] ?? options?.[`initial${field[0].toUpperCase()}${field.slice(1)}`];
+}
+/** Whether a node is `list.map(...)` over a hook's result (`toasts.map`, `manager.toasts.map`, `useItems().map`). */
+function hookMapped(node, hooked, source) {
+	if (!ts.isCallExpression(node) || !ts.isPropertyAccessExpression(node.expression)) return false;
+	if (node.expression.name.text !== "map") return false;
+	let list = unwrap$1(node.expression.expression);
+	if (isHookCall(list, source)) return true;
+	while (ts.isPropertyAccessExpression(list)) list = unwrap$1(list.expression);
+	return ts.isIdentifier(list) && hooked.has(list.text);
+}
+function unwrap$1(expression) {
+	while (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isSatisfiesExpression(expression) || ts.isNonNullExpression(expression) || ts.isTypeAssertionExpression(expression)) expression = expression.expression;
+	return expression;
+}
+function attributeValue(initializer, context) {
+	if (!initializer) return true;
+	if (ts.isStringLiteral(initializer)) return initializer.text;
+	if (ts.isJsxExpression(initializer) && initializer.expression) {
+		const expression = unwrap$1(initializer.expression);
+		if (ts.isArrowFunction(expression) || ts.isFunctionExpression(expression)) return renderOf(expression, context, 0);
+		if (ts.isJsxElement(expression) || ts.isJsxSelfClosingElement(expression) || ts.isJsxFragment(expression)) {
+			const inner = [];
+			pushExpression(expression, context, 0, inner);
+			return inner.length > 0 ? { $element: inner } : void 0;
+		}
+		const value = evaluate(expression, context, 0);
+		return value !== void 0 && JSON.stringify(value).length <= 2e3 ? value : void 0;
+	}
+}
+/**
+* The value an expression has, when the file says: literals, arrays and objects of them, the names it declares, and
+* a mapped item's fields, and calls of the package's own functions as `$call`s. Anything else (other calls, functions,
+* imports) is undefined.
+*/
+function evaluate(expression, context, depth) {
+	if (depth > 6) return void 0;
+	expression = unwrap$1(expression);
+	if (ts.isStringLiteralLike(expression)) return expression.text.slice(0, 200);
+	if (ts.isTemplateExpression(expression)) {
+		let text = expression.head.text;
+		for (const span of expression.templateSpans) {
+			const value = evaluate(span.expression, context, depth + 1);
+			if (typeof value !== "string" && typeof value !== "number") return void 0;
+			text += `${value}${span.literal.text}`;
+		}
+		return text.slice(0, 200);
+	}
+	if (ts.isNumericLiteral(expression)) return Number(expression.text);
+	if (expression.kind === ts.SyntaxKind.TrueKeyword) return true;
+	if (expression.kind === ts.SyntaxKind.FalseKeyword) return false;
+	if (expression.kind === ts.SyntaxKind.NullKeyword) return null;
+	if (ts.isPrefixUnaryExpression(expression) && expression.operator === ts.SyntaxKind.MinusToken && ts.isNumericLiteral(expression.operand)) return -Number(expression.operand.text);
+	if (ts.isIdentifier(expression)) {
+		if (context.env.has(expression.text)) return context.env.get(expression.text);
+		const declared = context.scope.get(expression.text);
+		const value = declared ? evaluate(declared, context, depth + 1) : void 0;
+		const methods = context.calledOn?.get(expression.text);
+		return methods && isMadeValue(value) ? {
+			...value,
+			methods
+		} : value;
+	}
+	if (ts.isArrayLiteralExpression(expression)) {
+		const items = expression.elements.flatMap((element) => {
+			if (!ts.isSpreadElement(element)) return [evaluate(element, context, depth + 1)];
+			const spread = evaluate(element.expression, context, depth + 1);
+			return Array.isArray(spread) ? spread : [];
+		}).slice(0, 8).filter((item) => item !== void 0);
+		return items.length > 0 ? items : void 0;
+	}
+	if (ts.isObjectLiteralExpression(expression)) {
+		const object = {};
+		for (const property of expression.properties) {
+			if (ts.isSpreadAssignment(property)) {
+				const spread = evaluate(property.expression, context, depth + 1);
+				if (typeof spread === "object" && spread !== null && !Array.isArray(spread)) Object.assign(object, spread);
+				continue;
+			}
+			const key = property.name && (ts.isIdentifier(property.name) || ts.isStringLiteral(property.name)) ? property.name.text : void 0;
+			if (!key) continue;
+			let value;
+			if (ts.isPropertyAssignment(property)) value = evaluate(property.initializer, context, depth + 1);
+			else if (ts.isShorthandPropertyAssignment(property)) value = evaluate(property.name, context, depth + 1);
+			if (value !== void 0) object[key] = value;
+		}
+		return object;
+	}
+	if (ts.isCallExpression(expression) && ts.isIdentifier(expression.expression)) {
+		const callee = context.imports?.get(expression.expression.text);
+		if (!callee || !/^[a-z]/.test(callee.export) || /^use[A-Z]/.test(callee.export)) return void 0;
+		const args = expression.arguments.map((argument) => evaluate(argument, context, depth + 1));
+		if (args.some((argument) => argument === void 0)) return void 0;
+		return {
+			$call: {
+				import: callee.import,
+				export: callee.export
+			},
+			...args.length > 0 ? { args } : {}
+		};
+	}
+	if (ts.isPropertyAccessExpression(expression) || ts.isElementAccessExpression(expression)) {
+		const object = evaluate(expression.expression, context, depth + 1);
+		const key = ts.isPropertyAccessExpression(expression) ? expression.name.text : evaluate(expression.argumentExpression, context, depth + 1);
+		if (typeof object !== "object" || object === null || typeof key !== "string" && typeof key !== "number") return;
+		return object[key];
+	}
+}
+function textIn(node) {
+	const parts = [];
+	const visit = (child) => {
+		if (ts.isJsxText(child)) parts.push(child.text);
+		ts.forEachChild(child, visit);
+	};
+	visit(node);
+	return parts.join(" ").replace(/\s+/g, " ").trim().slice(0, 60);
+}
+function sampleWeight(sample) {
+	const children = sample.children ?? [];
+	return children.length * 2 + Object.keys(sample.props ?? {}).length + children.reduce((sum, child) => {
+		if (typeof child === "string") return sum;
+		return sum + (isSampleRender(child) ? sampleWeight({ children: child.$render }) : sampleWeight(child));
+	}, 0);
+}
+/** A component's family: its namespace (`Dialog` for `Dialog.Title`), else the first word of its name. */
+function familyOf(name) {
+	const dot = name.lastIndexOf(".");
+	if (dot !== -1) return name.slice(0, dot);
+	const word = /^[A-Z][a-z0-9]*/.exec(name)?.[0] ?? name;
+	return /[^s]s$/.test(word) ? word.slice(0, -1) : word;
+}
+/**
+* The parents the examples put a component in, at any depth, outermost first: every library ancestor at least half
+* its placed uses have, in the order they're usually nested. A level some examples leave out (`DropdownMenuGroup`)
+* is still here when most have it, with its share, so it can be marked optional. As with `nearestParent`, most uses
+* must be placed at all, and `sameFamily` keeps only its own family's. `share` lowers the share a level needs, for a
+* part that fails without a level fewer than half show (`Slider.Control`). Shares are counted per file, so one long
+* demo can't outvote ten short ones, and per use, so a level most uses show isn't lost; a level either count keeps
+* is kept, with the larger share.
+*/
+function exampleLevels(uses, name, sameFamily, share = .5) {
+	const use = uses.get(name);
+	if (!use || use.paths.length === 0) return void 0;
+	const family = familyOf(name);
+	const count = (all) => {
+		const paths = all.map((path) => sameFamily ? path.filter((parent) => familyOf(parent) === family) : path);
+		const placed = paths.filter((path) => path.length > 0);
+		if (placed.length * 2 < paths.length) return [];
+		const seen = /* @__PURE__ */ new Map();
+		for (const path of placed) path.forEach((parent, depth) => {
+			const entry = seen.get(parent) ?? {
+				count: 0,
+				depth: 0
+			};
+			entry.count++;
+			entry.depth += depth;
+			seen.set(parent, entry);
+		});
+		return [...seen].filter(([, entry]) => entry.count >= placed.length * share).map(([parent, entry]) => ({
+			parent,
+			share: entry.count / placed.length,
+			depth: entry.depth / entry.count
+		}));
+	};
+	const merged = /* @__PURE__ */ new Map();
+	for (const level of [...count(use.paths), ...count(use.usePaths)]) {
+		const known = merged.get(level.parent);
+		if (!known || level.share > known.share) merged.set(level.parent, level);
+	}
+	const levels = [...merged.values()].sort((a, b) => b.depth - a.depth).slice(-8).map(({ parent, share }) => ({
+		parent,
+		share
+	}));
+	return levels.length > 0 ? levels : void 0;
+}
+/** A sample with only its own family's components in it, as text where others were. */
+function familySample(sample, family, familyIn = familyOf) {
+	const keep = (child) => {
+		if (typeof child === "string") return child;
+		if (isSampleRender(child)) {
+			const inner = child.$render.flatMap((item) => keep(item) ?? []);
+			return inner.length > 0 ? {
+				...child,
+				$render: inner
+			} : void 0;
+		}
+		return familyIn(child.component) === family ? {
+			...child,
+			...child.children ? { children: child.children.flatMap((inner) => keep(inner) ?? []) } : {}
+		} : void 0;
+	};
+	const children = (sample.children ?? []).flatMap((child) => keep(child) ?? []);
+	return {
+		...sample.props ? { props: sample.props } : {},
+		...children.length > 0 ? { children } : {}
+	};
+}
+// ../libgen/src/anatomy.ts
+/**
+* Where the docs' Anatomy and Usage blocks put each part: every library ancestor of each place it's shown, nearest
+* first. The blocks are read as JSX, with their imports taken out.
+*/
+function readAnatomy(docs, names) {
+	const blocks = [];
+	for (const doc of docs) {
+		const sections = doc.text.split(/^(?=#{2,3} )/m).filter((section) => /^#{2,3} (?:Anatomy|Usage)\b/.test(section));
+		for (const section of sections) for (const [index, match] of [...section.matchAll(/```(?:jsx|tsx|js|ts)\b[^\n]*\n([\s\S]*?)```/g)].entries()) {
+			const code = match[1].replace(/^import[\s\S]*?from\s+["'][^"']+["'];?$/gm, "").replace(/^import\s+["'][^"']+["'];?$/gm, "").trim();
+			if (!code.startsWith("<")) continue;
+			blocks.push({
+				path: `${doc.path}#${index}`,
+				text: `const anatomy = (<>\n${code}\n</>)`
+			});
+		}
+	}
+	const anatomy = /* @__PURE__ */ new Map();
+	for (const [name, use] of readExamples(blocks, names)) {
+		const placed = use.paths.filter((path) => path.length > 0);
+		if (placed.length > 0) anatomy.set(name, placed);
+	}
+	return anatomy;
+}
+/**
+* Compares each part's chain with the docs. A part is placed right when one place the docs show has the nearest
+* parent the chain has, and every parent the chain needs (all but its optional ones); complete when the chain also
+* has every level that place does.
+*/
+function checkAnatomy(anatomy, list) {
+	const check = {
+		parts: 0,
+		placed: 0,
+		complete: 0,
+		differ: []
+	};
+	for (const [name, paths] of anatomy) {
+		const entry = list[name];
+		if (!entry || entry.visual === false) continue;
+		const known = paths.map((path) => path.filter((parent) => parent in list && !parent.endsWith("Portal"))).filter((path) => path.length > 0 && familyOf(path[0]) === familyOf(name));
+		if (known.length === 0) continue;
+		check.parts++;
+		const chain = entry.parents ?? [];
+		const needed = chain.filter((parent) => !entry.optionalParents?.includes(parent) && !parent.endsWith("Portal"));
+		const right = known.filter((path) => path.length > 0 && chain.includes(path[0]) && needed.every((parent) => path.includes(parent)));
+		if (right.length > 0) {
+			check.placed++;
+			if (right.some((path) => path.every((parent) => chain.includes(parent)))) check.complete++;
+		} else {
+			const docs = known.find((path) => path.length > 0);
+			check.differ.push({
+				name,
+				docs: [...docs].reverse(),
+				file: chain
+			});
+		}
+	}
+	return check;
+}
+// ../libgen/src/hosts.ts
+/**
+* What each of the package's own functions renders, by the names the package exports: read from its compiled files,
+* following `jsx()` and `createElement()` calls and JSX. Only files that mention one of `names` are read. `calls`, when
+* given, collects each render with the props passed, by the part rendered. `made`, when given, collects the values
+* the package exports that a factory makes (`export const toast = createToastManager()`), by their exported names.
+*/
+async function readRenders(packageDir, names, calls, made) {
+	const renders = /* @__PURE__ */ new Map();
+	for (const file of await sourceFiles$1(packageDir)) {
+		const text = await readFile(file, "utf8");
+		if (!names.some((name) => text.includes(name))) continue;
+		const source = ts.createSourceFile(file, text, ts.ScriptTarget.Latest, false, ts.ScriptKind.TSX);
+		const exportedAs = /* @__PURE__ */ new Map();
+		for (const statement of source.statements) {
+			if (!ts.isExportDeclaration(statement) || !statement.exportClause || !ts.isNamedExports(statement.exportClause)) continue;
+			for (const element of statement.exportClause.elements) exportedAs.set((element.propertyName ?? element.name).getText(source), element.name.getText(source));
+		}
+		const named = (local) => exportedAs.get(local) ?? local;
+		for (const statement of made ? source.statements : []) {
+			if (!ts.isVariableStatement(statement)) continue;
+			const exported = statement.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword);
+			for (const declaration of statement.declarationList.declarations) {
+				const init = declaration.initializer;
+				if (!ts.isIdentifier(declaration.name) || !init || !ts.isCallExpression(init)) continue;
+				if (!/(?:^|\.)create[A-Z]\w*$/.test(init.expression.getText(source))) continue;
+				const local = declaration.name.text;
+				if (exported || exportedAs.has(local)) made.add(named(local));
+			}
+		}
+		const visit = (node, owner, params) => {
+			let here = owner;
+			let own = params;
+			if (ts.isFunctionDeclaration(node) && node.name) {
+				here = named(node.name.text);
+				own = paramsOf(node);
+			} else if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer) {
+				if (/^[A-Z]/.test(node.name.text)) {
+					here = named(node.name.text);
+					own = paramsOf(node.initializer);
+				}
+			}
+			if (here) {
+				const rendered = renderedBy(node, source);
+				if (rendered) {
+					const set = renders.get(here) ?? /* @__PURE__ */ new Set();
+					set.add(named(rendered));
+					renders.set(here, set);
+					if (calls) {
+						const list = calls.get(named(rendered)) ?? [];
+						const children = renderedChildren(node, source, named);
+						list.push({
+							owner: here,
+							props: passedProps(node, own),
+							...children.length > 0 ? { children } : {}
+						});
+						calls.set(named(rendered), list);
+					}
+				}
+			}
+			const callback = ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === "map" ? node.arguments[0] : void 0;
+			const item = callback && (ts.isArrowFunction(callback) || ts.isFunctionExpression(callback)) ? callback.parameters[0]?.name : void 0;
+			ts.forEachChild(node, (child) => visit(child, here, child === callback && item && ts.isIdentifier(item) ? {
+				...own,
+				items: /* @__PURE__ */ new Set([...own.items, item.text])
+			} : own));
+		};
+		visit(source, void 0, {
+			locals: /* @__PURE__ */ new Map(),
+			objects: /* @__PURE__ */ new Set(),
+			items: /* @__PURE__ */ new Set()
+		});
+	}
+	return renders;
+}
+/** The components of the package that render each one, the reverse of `readRenders`. */
+function renderedIn(renders) {
+	const owners = /* @__PURE__ */ new Map();
+	for (const [owner, rendered] of renders) for (const name of rendered) if (name !== owner) owners.set(name, [...owners.get(name) ?? [], owner]);
+	return owners;
+}
+/**
+* The parts only a host renders: components the package's own code draws inside a host a decorator adds (`Toaster`
+* mapping the toast manager's list into `Toast`, `ToastTitle` and the rest), and nowhere else. A person never places
+* these, so they're not visual.
+*/
+function hostedParts(renders, hosts, names) {
+	const reached = new Set(hosts);
+	const queue = [...hosts];
+	while (queue.length > 0) for (const next of renders.get(queue.pop()) ?? []) if (!reached.has(next)) {
+		reached.add(next);
+		queue.push(next);
+	}
+	const owners = renderedIn(renders);
+	return names.filter((name) => !hosts.includes(name) && reached.has(name) && (owners.get(name) ?? []).every((owner) => reached.has(owner)));
+}
+/** The expression an attribute gives: `{expression}` or a string. */
+function attributeExpression(value) {
+	if (value && ts.isJsxExpression(value)) return value.expression;
+	return value && ts.isStringLiteral(value) ? value : void 0;
+}
+function paramsOf(node) {
+	const params = {
+		locals: /* @__PURE__ */ new Map(),
+		objects: /* @__PURE__ */ new Set(),
+		items: /* @__PURE__ */ new Set()
+	};
+	let fn = node;
+	if (ts.isCallExpression(fn)) fn = fn.arguments.find((arg) => ts.isFunctionLike(arg));
+	if (!fn || !(ts.isFunctionDeclaration(fn) || ts.isArrowFunction(fn) || ts.isFunctionExpression(fn))) return params;
+	const first = fn.parameters[0]?.name;
+	if (!first) return params;
+	if (ts.isIdentifier(first)) params.objects.add(first.text);
+	else if (ts.isObjectBindingPattern(first)) for (const element of first.elements) {
+		if (!ts.isIdentifier(element.name)) continue;
+		if (element.dotDotDotToken) params.objects.add(element.name.text);
+		else {
+			const key = element.propertyName ?? element.name;
+			if (ts.isIdentifier(key) || ts.isStringLiteral(key)) params.locals.set(element.name.text, key.text);
+		}
+	}
+	return params;
+}
+/** The props a render passes: the owner's own props by name, literal values, and the rest as worked out. */
+function passedProps(node, params) {
+	const props = {};
+	const object = ts.isCallExpression(node) ? node.arguments[1] : void 0;
+	const entries = [];
+	if (object && ts.isObjectLiteralExpression(object)) {
+		for (const property of object.properties) if (ts.isPropertyAssignment(property) && (ts.isIdentifier(property.name) || ts.isStringLiteral(property.name))) entries.push([property.name.text, property.initializer]);
+		else if (ts.isShorthandPropertyAssignment(property)) entries.push([property.name.text, property.name]);
+	} else if (ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node)) for (const attribute of node.attributes.properties) {
+		if (!ts.isJsxAttribute(attribute)) continue;
+		const value = attribute.initializer;
+		entries.push([attribute.name.getText(), attributeExpression(value)]);
+	}
+	for (const [key, value] of entries) {
+		if (key === "children" || key === "className") continue;
+		if (!value) props[key] = { value: true };
+		else if (ts.isIdentifier(value) && params.items.has(value.text)) props[key] = { item: true };
+		else if (ts.isIdentifier(value) && params.locals.has(value.text)) props[key] = { forward: params.locals.get(value.text) };
+		else if (ts.isPropertyAccessExpression(value) && ts.isIdentifier(value.expression) && params.objects.has(value.expression.text)) props[key] = { forward: value.name.text };
+		else if (ts.isStringLiteralLike(value)) props[key] = { value: value.text };
+		else if (ts.isNumericLiteral(value)) props[key] = { value: Number(value.text) };
+		else if (value.kind === ts.SyntaxKind.TrueKeyword || value.kind === ts.SyntaxKind.FalseKeyword) props[key] = { value: value.kind === ts.SyntaxKind.TrueKeyword };
+		else props[key] = { computed: true };
+	}
+	return props;
+}
+/**
+* The parts a `jsx(X, { children })` call puts inside X, through HTML elements, lists and conditions in between
+* (`_jsxs(ToastContent, { children: [_jsxs("div", { children: [_jsx(ToastTitle, {})] })] })`).
+*/
+function renderedChildren(node, source, named) {
+	const childrenOf = (call) => {
+		const object = call.arguments[1];
+		if (!object || !ts.isObjectLiteralExpression(object)) return [];
+		const children = object.properties.find((property) => ts.isPropertyAssignment(property) && ts.isIdentifier(property.name) && property.name.text === "children");
+		return children ? walk(children.initializer) : [];
+	};
+	const walk = (expression) => {
+		while (ts.isParenthesizedExpression(expression)) expression = expression.expression;
+		if (ts.isArrayLiteralExpression(expression)) return expression.elements.flatMap(walk);
+		if (ts.isConditionalExpression(expression)) return walk(expression.whenTrue);
+		if (ts.isBinaryExpression(expression) && expression.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken) return walk(expression.right);
+		if (!ts.isCallExpression(expression)) return [];
+		const first = expression.arguments[0];
+		const rendered = renderedBy(expression, source);
+		if (rendered) {
+			const children = childrenOf(expression);
+			return [{
+				component: named(rendered),
+				...children.length > 0 ? { children } : {}
+			}];
+		}
+		return first && ts.isStringLiteral(first) && /^[a-z]/.test(first.text) ? childrenOf(expression) : [];
+	};
+	return ts.isCallExpression(node) ? childrenOf(node) : [];
+}
+/** The component a `jsx(X, ...)`, `createElement(X, ...)` or `<X>` renders, when it's a plain name. */
+function renderedBy(node, source) {
+	if (ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node)) return ts.isIdentifier(node.tagName) && /^[A-Z]/.test(node.tagName.text) ? node.tagName.text : void 0;
+	if (!ts.isCallExpression(node)) return void 0;
+	let callee = node.expression;
+	while (ts.isParenthesizedExpression(callee)) callee = callee.expression;
+	if (ts.isBinaryExpression(callee) && callee.operatorToken.kind === ts.SyntaxKind.CommaToken) callee = callee.right;
+	const text = callee.getText(source);
+	if (!/(?:^|\.)(?:_?jsxs?|_?jsxDEV|createElement)$/.test(text)) return void 0;
+	const first = node.arguments[0];
+	return first && ts.isIdentifier(first) && /^[A-Z]/.test(first.text) ? first.text : void 0;
+}
+/** The package's own script files, skipping type declarations, source maps and its dependencies. */
+async function sourceFiles$1(dir, found = [], depth = 0) {
+	if (depth > 8 || found.length >= 4e3) return found;
+	const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+	for (const entry of entries) {
+		const path = join(dir, entry.name);
+		if (entry.isDirectory()) {
+			if (entry.name !== "node_modules" && !entry.name.startsWith(".")) await sourceFiles$1(path, found, depth + 1);
+		} else if (/\.(?:m?js|cjs|jsx)$/.test(entry.name) && (await stat(path)).size < 1e6) found.push(path);
+	}
+	return found;
+}
+// ../libgen/src/icon-exports.ts
+/**
+* The names an icon set's types say to insert where an icon is exported under several: one not marked deprecated over
+* one that is (Phosphor's `GearIcon` over `Gear`), then the name its declaration has over the aliases it's also
+* exported as (Lucide's `TriangleAlert` over `AlertTriangle`), then the shortest. Only the names that differ from the
+* shortest, which is what's inserted otherwise, are returned. Each group is one icon's names; `usable` says which names
+* the set's pattern allows.
+*/
+function preferredExports(typesFile, groups, usable) {
+	const program = ts.createProgram([typesFile], {
+		noEmit: true,
+		skipLibCheck: true,
+		types: []
+	});
+	const checker = program.getTypeChecker();
+	const source = program.getSourceFile(typesFile);
+	const module = source && checker.getSymbolAtLocation(source);
+	if (!module) return [];
+	const marks = /* @__PURE__ */ new Map();
+	for (const symbol of checker.getExportsOfModule(module)) {
+		const alias = (symbol.flags & ts.SymbolFlags.Alias) !== 0;
+		const target = alias ? checker.getAliasedSymbol(symbol) : symbol;
+		const tags = [...symbol.getJsDocTags(checker), ...alias ? target.getJsDocTags(checker) : []];
+		marks.set(symbol.name, {
+			deprecated: tags.some((tag) => tag.name === "deprecated"),
+			declared: target.name === symbol.name
+		});
+	}
+	const shortest = (a, b) => a.length - b.length || byCodeUnit$1(a, b);
+	const preferred = [];
+	for (const group of groups) {
+		const names = group.filter(usable);
+		const fallback = [...names].sort(shortest)[0];
+		const rank = (name) => {
+			const mark = marks.get(name);
+			return (mark?.deprecated ? 2 : 0) + (mark?.declared === false ? 1 : 0);
+		};
+		const best = [...names].sort((a, b) => rank(a) - rank(b) || shortest(a, b))[0];
+		if (best && best !== fallback) preferred.push(best);
+	}
+	return preferred.sort();
+}
+/** The types file a specifier resolves to from a folder, as a bundler would resolve it. */
+function typesFor(specifier, from) {
+	const resolved = ts.resolveModuleName(specifier, `${from}/index.ts`, {
+		module: ts.ModuleKind.ESNext,
+		moduleResolution: ts.ModuleResolutionKind.Bundler
+	}, ts.sys).resolvedModule?.resolvedFileName;
+	return resolved && /\.d\.[cm]?ts$/.test(resolved) ? resolved : void 0;
+}
+/** Compares two strings by their UTF-16 code units, as `sort` does without a comparer. */
+function byCodeUnit$1(a, b) {
+	if (a < b) return -1;
+	return a > b ? 1 : 0;
+}
+// ../libgen/src/icon-styles.ts
+/** How many of a set's icons are drawn from each module to tell its styles apart. */
+const sampled = 5;
+/**
+* The styles of a set that keeps each in a module of its own, as Heroicons keeps `@heroicons/react/16/solid` beside
+* `24/outline`, by name, with the module each is imported from: the package's other entry points that export most of
+* the same icons, and draw them differently. One that draws them the same (Phosphor's `ssr`, Lucide's `icons`) is
+* another way in, not a style; one that doesn't load (Fluent's `fonts`) or exports few of them isn't one either.
+* Styles are named by their path in the package, so `16/solid` is `16 Solid`, and listed in the package's order. A set
+* with no such modules has none.
+*/
+async function styleModules(packageName, entries, main, load, draw) {
+	const icons = (module) => Object.keys(module).filter((name) => /^[A-Z]/.test(name) && isComponent(module[name]));
+	const base = await load(main).catch(() => void 0);
+	if (!base) return void 0;
+	const names = icons(base).sort();
+	const sample = names.slice(0, sampled);
+	const drawn = new Map(sample.map((name) => [name, draw(base[name])]));
+	const found = [];
+	for (const entry of entries) {
+		if (entry === "." || entry.includes("*") || /\.[a-z]+$/i.test(entry)) continue;
+		const specifier = packageName + entry.slice(1);
+		if (specifier === main) {
+			found.push({
+				specifier,
+				module: base
+			});
+			continue;
+		}
+		const module = await load(specifier).catch(() => void 0);
+		if (!module) continue;
+		const own = new Set(icons(module));
+		const shared = sample.filter((name) => own.has(name));
+		if (own.size === 0 || names.filter((name) => own.has(name)).length * 2 < names.length || shared.length === 0) continue;
+		if (found.some((other) => shared.every((name) => other.module[name] === module[name]))) continue;
+		if (shared.some((name) => draw(module[name]) === drawn.get(name))) continue;
+		found.push({
+			specifier,
+			module
+		});
+	}
+	if (!found.some((style) => style.module === base)) found.unshift({
+		specifier: main,
+		module: base
+	});
+	if (found.length < 2) return void 0;
+	return Object.fromEntries(found.map(({ specifier }) => [specifier.startsWith(`${packageName}/`) ? styleName(specifier.slice(packageName.length + 1)) : "Default", specifier]));
+}
+/** A style's name from its module's path in the package: `24/outline` is `24 Outline`. */
+function styleName(path) {
+	return path.split(/[/_-]+/).filter(Boolean).map((word) => word[0].toUpperCase() + word.slice(1)).join(" ");
+}
+function isComponent(value) {
+	return typeof value === "function" || typeof value === "object" && value !== null && "$$typeof" in value;
+}
+// ../libgen/src/js-data.ts
+/**
+* The data a JavaScript module declares at its top level, read with the TypeScript parser rather than run: arrays,
+* objects, strings, numbers and booleans, by the name each is declared as. Members of enums compiled the way esbuild
+* writes them (`((i) => (i.ARROWS = "arrows", i))(e || {})`) read as their values, so a published data file such as
+* Phosphor's icon list can be read without running code that came from the network. Anything else is left out.
+*/
+function moduleData(text) {
+	const source = ts.createSourceFile("data.mjs", text, ts.ScriptTarget.Latest, false, ts.ScriptKind.JS);
+	const declared = /* @__PURE__ */ new Map();
+	for (const statement of source.statements) {
+		if (!ts.isVariableStatement(statement)) continue;
+		for (const declaration of statement.declarationList.declarations) {
+			if (!ts.isIdentifier(declaration.name) || !declaration.initializer) continue;
+			const value = compiledEnum(declaration.initializer) ?? literal(declaration.initializer, declared);
+			if (value !== void 0) declared.set(declaration.name.text, value);
+		}
+	}
+	return declared;
+}
+/** An enum as esbuild compiles it: an arrow that assigns each member to its parameter, called at once. */
+function compiledEnum(node) {
+	const call = unwrap(node);
+	if (!ts.isCallExpression(call)) return void 0;
+	const arrow = unwrap(call.expression);
+	if (!ts.isArrowFunction(arrow) || arrow.parameters.length !== 1) return void 0;
+	const param = arrow.parameters[0].name;
+	if (!ts.isIdentifier(param) || ts.isBlock(arrow.body)) return void 0;
+	const members = {};
+	const visit = (expression) => {
+		const node = unwrap(expression);
+		if (!ts.isBinaryExpression(node)) return;
+		if (node.operatorToken.kind === ts.SyntaxKind.CommaToken) {
+			visit(node.left);
+			visit(node.right);
+		} else if (node.operatorToken.kind === ts.SyntaxKind.EqualsToken && ts.isPropertyAccessExpression(node.left) && ts.isIdentifier(node.left.expression) && node.left.expression.text === param.text) members[node.left.name.text] = literal(node.right, /* @__PURE__ */ new Map());
+	};
+	visit(arrow.body);
+	return Object.keys(members).length > 0 ? members : void 0;
+}
+function unwrap(node) {
+	return ts.isParenthesizedExpression(node) ? unwrap(node.expression) : node;
+}
+/** A literal's value, with names and enum members looked up in what's been declared; `undefined` for anything else. */
+function literal(node, declared) {
+	const value = unwrap(node);
+	if (ts.isStringLiteral(value) || ts.isNoSubstitutionTemplateLiteral(value)) return value.text;
+	if (ts.isNumericLiteral(value)) return Number(value.text);
+	if (value.kind === ts.SyntaxKind.TrueKeyword) return true;
+	if (value.kind === ts.SyntaxKind.FalseKeyword) return false;
+	if (ts.isPrefixUnaryExpression(value) && value.operator === ts.SyntaxKind.MinusToken) {
+		const number = literal(value.operand, declared);
+		return typeof number === "number" ? -number : void 0;
+	}
+	if (ts.isArrayLiteralExpression(value)) return value.elements.map((element) => literal(element, declared));
+	if (ts.isObjectLiteralExpression(value)) {
+		const object = {};
+		for (const property of value.properties) {
+			if (!ts.isPropertyAssignment(property)) continue;
+			const name = property.name;
+			if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) object[name.text] = literal(property.initializer, declared);
+		}
+		return object;
+	}
+	if (ts.isIdentifier(value)) return declared.get(value.text);
+	if (ts.isPropertyAccessExpression(value) && ts.isIdentifier(value.expression)) {
+		const owner = declared.get(value.expression.text);
+		return owner && typeof owner === "object" ? owner[value.name.text] : void 0;
+	}
+}
+// ../libgen/src/icon-tags.ts
+const published = {
+	packageFile,
+	publishedVersions,
+	publishedSource,
+	repositoryFiles
+};
+/**
+* Reads a set's tags from its published metadata and keys them by each icon's label. A companion package's version is
+* the icon package's own when that was published, or else the newest one before it, since companions are released
+* together but not always every time.
+*/
+async function readIconTags(source, iconPackage, icons, fetchers = published) {
+	let data;
+	let from;
+	if ("files" in source) {
+		const { repository, commit } = await fetchers.publishedSource(iconPackage.name, iconPackage.version);
+		if (!repository || !commit) throw new Error(`npm doesn't say which repository and commit ${iconPackage.name}@${iconPackage.version} came from`);
+		data = [(await fetchers.repositoryFiles(repository, commit, glob(source.files))).flatMap(({ text }) => parsed(text))];
+		from = `${repository.replace(/^https:\/\//, "")}@${commit.slice(0, 12)}/${source.files}`;
+	} else {
+		const name = source.package ?? iconPackage.name;
+		const version = name === iconPackage.name ? iconPackage.version : closestVersion(await fetchers.publishedVersions(name), iconPackage.version);
+		if (!version) throw new Error(`${name} has no version at or before ${iconPackage.version}`);
+		const text = await fetchers.packageFile(name, version, source.file);
+		data = source.file.endsWith(".json") ? parsed(text) : [...moduleData(text).values()];
+		from = `${name}@${version}/${source.file}`;
+	}
+	const tags = iconWords(data, icons);
+	return {
+		tags,
+		source: from,
+		matched: Object.keys(tags).length
+	};
+}
+function parsed(text) {
+	try {
+		return [JSON.parse(text)];
+	} catch {
+		return [];
+	}
+}
+/**
+* Words for each icon by label, from metadata of whatever shape a set publishes. Its table of icons is the one that
+* names most of the set's icons, wherever it sits: an object keyed by icon (`{"circle-alert": [...]}`), or a list of
+* records with a field that names each (`[{ name: "acorn", tags: [...] }]`). An icon's words are its lists of strings,
+* and the values of fields that sort icons into groups, such as a category. Fields that barely vary (the styles most
+* icons come in), words most icons have, and markers that aren't words (`*new*`) are left out. Fields that tell icons
+* apart come before ones that group many, since a set's first tags count most in search.
+*/
+function iconWords(data, icons) {
+	const least = Math.max(1, Math.min(20, Math.floor(icons.length / 2)));
+	let best;
+	const consider = (entries) => {
+		const byKey = /* @__PURE__ */ new Map();
+		for (const [key, value] of entries) if (typeof key === "string" && !byKey.has(normalize$1(key))) byKey.set(normalize$1(key), value);
+		const matched = /* @__PURE__ */ new Map();
+		for (const icon of icons) {
+			const key = keysFor(icon).find((candidate) => byKey.has(candidate));
+			if (key) matched.set(icon.label, byKey.get(key));
+		}
+		if (matched.size > (best?.size ?? 0)) best = matched;
+	};
+	const visit = (value, depth) => {
+		if (Array.isArray(value)) {
+			const records = value.filter(isRecord);
+			if (records.length < least) return;
+			for (const field of new Set(records.flatMap((record) => Object.keys(record)))) if (records.some((record) => typeof record[field] === "string")) consider(records.map((record) => [record[field], record]));
+		} else if (isRecord(value)) {
+			const entries = Object.entries(value);
+			if (entries.length >= least) consider(entries);
+			else if (depth < 3) for (const [, inner] of entries) visit(inner, depth + 1);
+		}
+	};
+	for (const value of data) visit(value, 0);
+	if (!best) return {};
+	const fields = /* @__PURE__ */ new Map();
+	const add = (field, group, label, words) => {
+		if (words.length === 0) return;
+		let found = fields.get(field);
+		if (!found) fields.set(field, found = {
+			group,
+			byLabel: /* @__PURE__ */ new Map()
+		});
+		found.byLabel.set(label, words);
+	};
+	for (const [label, value] of best) if (Array.isArray(value)) add("", false, label, wordsOf(value));
+	else if (isRecord(value)) {
+		for (const [field, inner] of Object.entries(value)) if (Array.isArray(inner)) add(field, false, label, wordsOf(inner));
+		else if (typeof inner === "string") add(field, true, label, wordsOf([inner]).filter((word) => /\p{L}/u.test(word)));
+	}
+	const matched = best.size;
+	const kept = [...fields.values()].flatMap(({ group, byLabel }) => {
+		const counts = /* @__PURE__ */ new Map();
+		for (const word of [...byLabel.values()].flat()) counts.set(word, (counts.get(word) ?? 0) + 1);
+		const distinct = counts.size;
+		if (distinct < Math.min(5, Math.ceil(matched / 10))) return [];
+		if (group && (distinct > matched / 20 || Math.max(...counts.values()) > matched / 2)) return [];
+		return [{
+			byLabel,
+			distinct
+		}];
+	});
+	kept.sort((a, b) => b.distinct - a.distinct);
+	const tags = {};
+	const common = /* @__PURE__ */ new Map();
+	for (const icon of icons) {
+		const words = [...new Set(kept.flatMap(({ byLabel }) => byLabel.get(icon.label) ?? []))];
+		if (words.length === 0) continue;
+		tags[icon.label] = words;
+		for (const word of words) common.set(word, (common.get(word) ?? 0) + 1);
+	}
+	const tagged = Object.keys(tags).length;
+	if (tagged < 8) return tags;
+	for (const [label, words] of Object.entries(tags)) {
+		const specific = words.filter((word) => common.get(word) <= tagged / 4);
+		if (specific.length > 0) tags[label] = specific;
+		else delete tags[label];
+	}
+	return tags;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* A list's words, lowercased and without the punctuation that ends them: its strings and numbers (Tabler's `911`), when
+* it has any strings at all. One that starts with a symbol is a marker (`*new*`) or a symbol (`->`), not a word.
+*/
+function wordsOf(list) {
+	if (!list.some((item) => typeof item === "string")) return [];
+	return list.filter((item) => typeof item === "string" || typeof item === "number").map((item) => String(item).toLowerCase().replaceAll(/\s+/g, " ").trim().replace(/[^\p{L}\p{N}]+$/u, "")).filter((word) => /^[\p{L}\p{N}]/u.test(word));
+}
+/** A path where `*` is any one folder or file name, as a regular expression. */
+function glob(pattern) {
+	const parts = pattern.split("*").map((part) => part.replaceAll(/[.+?^${}()|[\]\\]/g, "\\$&"));
+	return new RegExp(`^${parts.join("[^/]+")}$`);
+}
+/** A key by its letters and digits, lowercased: `circle-alert`, `CircleAlert` and `circle_alert` are one key. */
+function normalize$1(key) {
+	return key.toLowerCase().replaceAll(/[^a-z0-9]/g, "");
+}
+/**
+* The keys an icon may be listed under: its label and each name, with and without an `Icon` before or after, and
+* without the `Ltr` or `Rtl` that names a mirrored copy (Fluent's `TextIndentIncreaseLtr`).
+*/
+function keysFor(icon) {
+	const keys = /* @__PURE__ */ new Set();
+	for (const name of [icon.label, ...icon.names]) {
+		const key = normalize$1(name);
+		for (const bare of [
+			key,
+			key.replace(/^icon/, ""),
+			key.replace(/icon$/, "")
+		]) {
+			keys.add(bare);
+			keys.add(bare.replace(/(?:ltr|rtl)$/, ""));
+		}
+	}
+	keys.delete("");
+	return [...keys];
+}
+/**
+* A `.lib.par` as JSON, indented by two spaces, with each icon's tags on a line of their own, so a set's thousands of
+* icons stay readable and its file half the size.
+*/
+function manifestText(manifest) {
+	const icons = manifest.icons;
+	if (!icons?.tags) return `${JSON.stringify(manifest, null, 2)}\n`;
+	const marker = JSON.stringify("\0tags\0");
+	const text = JSON.stringify({
+		...manifest,
+		icons: {
+			...icons,
+			tags: JSON.parse(marker)
+		}
+	}, null, 2);
+	const lines = Object.entries(icons.tags).map(([name, tags]) => `      ${JSON.stringify(name)}: ${JSON.stringify(tags)}`);
+	return `${text.replace(marker, `{\n${lines.join(",\n")}\n    }`)}\n`;
+}
+/** The version itself when published, or else the newest release before it; prereleases aren't counted. */
+function closestVersion(published, wanted) {
+	if (published.includes(wanted)) return wanted;
+	const parts = (version) => version.split(".").map(Number);
+	const target = parts(wanted.replace(/-.*$/, ""));
+	const before = (a, b) => {
+		for (let index = 0; index < 3; index++) if ((a[index] ?? 0) !== (b[index] ?? 0)) return (a[index] ?? 0) < (b[index] ?? 0);
+		return false;
+	};
+	let best;
+	for (const version of published) {
+		if (!/^\d+\.\d+\.\d+$/.test(version)) continue;
+		const candidate = parts(version);
+		if (!before(candidate, target)) continue;
+		if (!best || before(parts(best), candidate)) best = version;
+	}
+	return best;
+}
+// ../libgen/src/parts.ts
+const notVisual = /(?:Context|Consumer|Provider)$/;
+const maxDepth = 5;
+/**
+* Works out how a library's parts fit together, by rendering each with React's server renderer from the project, so
+* nothing needs a browser. A part that throws alone usually names what it needs ("`AccordionItem` must be used within
+* `Accordion`"), which is the strongest signal after a namespace export (`Accordion.Item` belongs in `Accordion.Root`).
+* Otherwise a shared name prefix (`AccordionItem` under `Accordion`) or a plural (`Tab` under `Tabs`) is tried. Each
+* chain is rendered again, so a suggestion that doesn't render is reported as such rather than trusted.
+*/
+async function relateParts(load, specifier, components, providers = [], edits = {}, examples = /* @__PURE__ */ new Map(), renderedBy = /* @__PURE__ */ new Map(), calls = /* @__PURE__ */ new Map(), listItem, appErrors = {}) {
+	let React;
+	let server;
+	let module;
+	try {
+		React = await load("react");
+		server = await load("react-dom/server");
+		module = await load(specifier);
+	} catch (error) {
+		return {
+			relations: /* @__PURE__ */ new Map(),
+			tried: false,
+			note: `Parts weren't tried: ${message(error)}`
+		};
+	}
+	const createElement = React.createElement ?? React.default?.createElement;
+	const renderToStaticMarkup = server.renderToStaticMarkup ?? server.default?.renderToStaticMarkup;
+	if (typeof createElement !== "function" || typeof renderToStaticMarkup !== "function") return {
+		relations: /* @__PURE__ */ new Map(),
+		tried: false,
+		note: "Parts weren't tried: React's server renderer wasn't found."
+	};
+	const byName = new Map(components.map((component) => [component.name, component]));
+	const wrappers = [];
+	for (const provider of providers) {
+		byName.delete(provider.component);
+		try {
+			let found = await load(provider.import);
+			for (const part of provider.component.split(".")) found = found?.[part];
+			if (found) wrappers.push({
+				type: found,
+				props: await trialValue(load, provider.props ?? {})
+			});
+		} catch {}
+	}
+	const value = (name) => {
+		const component = byName.get(name);
+		let found = module;
+		for (const part of (component?.export ?? name).split(".")) found = found?.[part];
+		return found;
+	};
+	const samples = /* @__PURE__ */ new Map();
+	for (const component of components) {
+		const edit = edits?.[component.name];
+		samples.set(component.name, {
+			...component.samples,
+			...edit ? edit.sample?.props : {}
+		});
+	}
+	const madeProps = /* @__PURE__ */ new Map();
+	for (const [name, use] of examples) {
+		const props = Object.fromEntries(Object.entries(use.sample?.props ?? {}).filter(([, value]) => isMadeValue(value)));
+		if (Object.keys(props).length === 0 || !samples.has(name)) continue;
+		madeProps.set(name, props);
+		samples.set(name, {
+			...samples.get(name),
+			...props
+		});
+	}
+	const made = /* @__PURE__ */ new Map();
+	const byCall = /* @__PURE__ */ new Map();
+	const callsIn = (value) => {
+		if (isMadeValue(value)) return [value];
+		if (Array.isArray(value)) return value.flatMap(callsIn);
+		return typeof value === "object" && value !== null ? Object.values(value).flatMap(callsIn) : [];
+	};
+	for (const use of examples.values()) for (const call of callsIn(use.sample)) {
+		const key = JSON.stringify(call);
+		if (!byCall.has(key)) try {
+			byCall.set(key, await trialValue(load, call));
+		} catch {
+			byCall.set(key, void 0);
+		}
+		made.set(call, byCall.get(key));
+	}
+	/** Each distinct call the examples make, to try as a value an owner works out. */
+	const madeCalls = [...new Map([...made.keys()].map((call) => [JSON.stringify(call), call])).values()];
+	const cloneElement = React.cloneElement ?? React.default?.cloneElement;
+	/** A render function as the part calls it: its children, with what it's called with spread on when asked. */
+	const live = (render) => (argument) => {
+		const elements = render.$render.map((item) => build(item));
+		if (elements.length === 1 && render.pass) return cloneElement(elements[0], Object.fromEntries(render.pass.map((prop) => [prop, argument])));
+		if (render.spread && elements.length === 1 && typeof argument === "object" && argument !== null) return cloneElement(elements[0], argument);
+		return elements.length === 1 ? elements[0] : elements;
+	};
+	const element = (value) => {
+		const elements = value.$element.map((item) => build(item));
+		return elements.length === 1 ? elements[0] : elements;
+	};
+	const liveValue = (item) => {
+		if (isSampleRender(item)) return live(item);
+		if (isSampleElement(item)) return element(item);
+		if (isMadeValue(item)) return made.get(item);
+		return Array.isArray(item) && item.some(isMadeValue) ? item.map((each) => isMadeValue(each) ? made.get(each) : each) : item;
+	};
+	const liveProps = (props) => Object.fromEntries(Object.entries(props ?? {}).map(([key, item]) => [key, liveValue(item)]));
+	/**
+	* A sample child's element. The part being tried takes its sample's props; a child a sample spells out (with props or
+	* children) is as written, as the app inserts it, and only a bare one takes its own sample's.
+	*/
+	const build = (child, own = false) => {
+		if (typeof child === "string") return child;
+		if (isSampleRender(child)) return live(child);
+		const type = /^[a-z]/.test(child.component) ? child.component : value(child.component);
+		const bare = !child.props && !child.children;
+		return createElement(type, liveProps({
+			...own || bare ? samples.get(child.component) : {},
+			...child.props
+		}), ...(child.children ?? []).map((inner) => build(inner)));
+	};
+	/** Parts whose parents need the other parts their examples hold around them. */
+	const withParts = /* @__PURE__ */ new Set();
+	/**
+	* The part inside the first parent's whole example, each level in place of the first like it there and the part in
+	* place of the first like it at the bottom (a cell in a table's first row, beside that row's other cells and the
+	* table's header), as the app inserts a part marked `parentParts`. A level the example doesn't hold comes alone.
+	*/
+	const inExample = (chain, name, part) => {
+		const inside = (level, given) => {
+			const target = level < chain.length ? chain[level] : name;
+			const items = given ?? [];
+			const at = items.findIndex((item) => typeof item === "object" && "component" in item && item.component === target);
+			const found = at === -1 ? void 0 : items[at];
+			let here = part;
+			if (level < chain.length) {
+				const written = found && (found.props || found.children);
+				here = createElement(value(target), liveProps(written ? found.props : samples.get(target)), ...inside(level + 1, written ? found.children : examples.get(target)?.sample?.children));
+			}
+			return at === -1 ? [here] : items.map((item, index) => index === at ? here : build(item));
+		};
+		return createElement(value(chain[0]), liveProps(samples.get(chain[0])), ...inside(1, examples.get(chain[0])?.sample?.children));
+	};
+	/** Renders a part inside a chain of parents; the error it throws, or undefined when it draws. */
+	const attempt = (chain, name, children, parts = withParts.has(name)) => render(placed(chain, name, build({
+		component: name,
+		...children ? { children } : {}
+	}, true), parts));
+	/** A part's element inside a chain of parents. */
+	const placed = (chain, name, part, parts) => {
+		const calling = chain.some((parent) => renderSlotOf(examples.get(parent)?.sample));
+		if (parts && chain.length > 0 && !calling) return inExample(chain, name, part);
+		let element = part;
+		for (const parent of [...chain].reverse()) {
+			const slot = renderSlotOf(examples.get(parent)?.sample);
+			const inner = element;
+			const render = slot ? (argument) => {
+				const spread = slot.render.spread && typeof argument === "object" && argument ? argument : {};
+				const named = Object.fromEntries((slot.render.pass ?? []).map((prop) => [prop, argument]));
+				return slot.render.pass || slot.render.spread ? cloneElement(inner, {
+					...spread,
+					...named
+				}) : inner;
+			} : void 0;
+			const props = liveProps(samples.get(parent));
+			element = slot && slot.prop !== "children" ? createElement(value(parent), {
+				...props,
+				[slot.prop]: render
+			}) : createElement(value(parent), props, render ?? element);
+		}
+		return element;
+	};
+	/** What an element renders on the server, or undefined when it throws. */
+	const markup = (element) => {
+		const quiet = [console.error, console.warn];
+		console.error = () => void 0;
+		console.warn = () => void 0;
+		try {
+			return renderToStaticMarkup(element).replace(/_R_\w+_/g, "");
+		} catch {
+			return;
+		} finally {
+			[console.error, console.warn] = quiet;
+		}
+	};
+	const render = (element, wrapped = true) => {
+		if (wrapped) for (const provider of [...usable].reverse()) element = createElement(provider.type, provider.props, element);
+		const quiet = [console.error, console.warn];
+		console.error = () => void 0;
+		console.warn = () => void 0;
+		try {
+			if (/^<(?:item|submenutrigger|tablebody|tableheader|column|cell|loader|separator)[\s>]/.test(renderToStaticMarkup(element))) return "Renders only as a placeholder outside a collection.";
+			return;
+		} catch (error) {
+			return message(error);
+		} finally {
+			[console.error, console.warn] = quiet;
+		}
+	};
+	const usable = wrappers.filter((provider) => render(createElement(provider.type, provider.props, "x"), false) === void 0);
+	const names = [...byName.keys()];
+	const named = (error, self, chain, guess = true) => {
+		const mentions = (text) => [...[...text.matchAll(/[`<"']([A-Z][\w.]*)/g)].map((match) => match[1]), ...[...text.matchAll(/\b([A-Z][\w.]*)/g)].map((match) => match[1])];
+		const all = [...mentions(error.split(/\b(?:within|inside|outside|wrap|wrapped|placed in|used in)\b/i).slice(1).join(" ")), ...mentions(error)];
+		for (const mention of all.flatMap((name) => [name.replace(/(?:Props)?(?:Provider|Context)$/, ""), name])) {
+			const target = resolveName(mention.replace(/\.$/, ""), self, names);
+			if (target && target !== self && !chain.includes(target)) return target;
+			const provider = `${self}Provider`;
+			if (target === self && !chain.includes(provider) && value(provider)) return provider;
+		}
+		if (!guess) return void 0;
+		const content = namespaceOf(self) && !self.endsWith(".Root") && `${namespaceOf(self)}.Content`;
+		return content && names.includes(content) && content !== self && !chain.includes(content) ? content : void 0;
+	};
+	const relations = /* @__PURE__ */ new Map();
+	/** Parts whose sample has example props they render without, with the props they had before. */
+	const loose = /* @__PURE__ */ new Map();
+	const aloneErrors = /* @__PURE__ */ new Map();
+	const failsAlone = (name) => {
+		if (!aloneErrors.has(name)) aloneErrors.set(name, attempt([], name));
+		return aloneErrors.get(name) !== void 0;
+	};
+	/** How many of each part's placed example uses have each parent, for marking the levels some leave out. */
+	const shares = /* @__PURE__ */ new Map();
+	const levelsOf = (name, sameFamily, taken, share) => (exampleLevels(examples, name, sameFamily, share) ?? []).filter((level) => names.includes(level.parent) && level.parent !== name && !taken.includes(level.parent));
+	/**
+	* The chain the examples show: every parent most of its uses are inside, at any depth, in their usual order. One
+	* that draws alone takes only its own family's, since examples put everything in forms. Examples split across a
+	* demo's own components show only the inner levels, so while the part still fails, the top one's own are added.
+	*/
+	const exampleChain = (name) => {
+		const levels = levelsOf(name, !failsAlone(name), []);
+		if (levels.length === 0) return void 0;
+		shares.set(name, new Map(levels.map((level) => [level.parent, level.share])));
+		const chain = levels.map((level) => level.parent);
+		if (heldChain(name, chain)) return chain;
+		while (chain.length < 10 && attempt(chain, name)) {
+			const up = levelsOf(chain[0], false, chain);
+			if (up.length === 0) break;
+			chain.unshift(...up.map((level) => level.parent));
+		}
+		return chain;
+	};
+	/**
+	* The chain, or the chain without the levels some examples leave out, that a part renders in with the other parts
+	* the examples hold around it (a table's header beside the body a row is in).
+	*/
+	const heldChain = (name, chain) => {
+		const usual = chain.filter((parent) => (shares.get(name)?.get(parent) ?? 1) >= .9);
+		const adds = (each) => markup(placed(each, name, build({ component: name }, true), true)) !== markup(placed(each, name, null, true));
+		return [chain, usual].find((each) => each.length > 0 && !attempt(each, name, void 0, true) && adds(each));
+	};
+	/**
+	* The levels some examples leave out (fewer than nine in ten have them) that the part still renders without, taken
+	* away one at a time so each is tried without the others too.
+	*/
+	const optionalOf = (name, chain) => {
+		const shown = shares.get(name);
+		const optional = [];
+		for (const parent of [...chain].reverse()) {
+			const share = shown?.get(parent);
+			if (share === void 0 || share >= .9) continue;
+			const without = chain.filter((other) => other !== parent && !optional.includes(other));
+			if (!attempt(without, name)) optional.push(parent);
+		}
+		return optional;
+	};
+	/** A part's family, as the examples place it (`Table` for React Aria's `Row`). */
+	const familyIn = (name) => examples.get(name)?.family ?? familyOf(name);
+	/** Drops parents from other families that a part renders without: where an example put it, not what it needs. */
+	const prune = (chain, name) => {
+		for (let dropped = true; dropped;) {
+			dropped = false;
+			for (const parent of chain) {
+				if (familyIn(parent) === familyIn(name) && !parent.endsWith("Portal")) continue;
+				const without = chain.filter((other) => other !== parent);
+				if (without.length > 0 && !attempt(without, name)) {
+					chain = without;
+					dropped = true;
+				}
+			}
+		}
+		return chain;
+	};
+	const chains = /* @__PURE__ */ new Map();
+	const chainOf = (name, depth) => {
+		if (chains.has(name)) return chains.get(name);
+		const edit = edits?.[name];
+		if (edit && edit.parents) return save(name, {
+			chain: edit.parents,
+			from: "edit"
+		});
+		chains.set(name, null);
+		const shown = exampleChain(name);
+		if (shown && !attempt(shown, name)) return save(name, {
+			chain: prune(shown, name),
+			from: "example"
+		});
+		const held = shown && attempt(shown, name) ? heldChain(name, shown) : void 0;
+		if (held) {
+			withParts.add(name);
+			return save(name, {
+				chain: held,
+				from: "example"
+			});
+		}
+		const pruned = shown && prune(shown, name);
+		if (pruned && pruned.length > 0 && !attempt(pruned, name)) return save(name, {
+			chain: pruned,
+			from: "example"
+		});
+		if (shown) for (const share of [1 / 3, 1 / 5]) {
+			const wider = levelsOf(name, !failsAlone(name), [], share).map((level) => level.parent);
+			if (wider.length > shown.length && !attempt(wider, name)) return save(name, {
+				chain: prune(wider, name),
+				from: "example"
+			});
+		}
+		const grown = shown ? grow(name, depth, shown, "example") : void 0;
+		if (grown && !grown.error) return save(name, {
+			chain: prune(grown.chain, name),
+			from: grown.from ?? "example"
+		});
+		const fromErrors = grow(name, depth, [], void 0);
+		const stray = fromErrors.chain.some((parent) => drawnParts.has(parent) && !drawnInside.get(parent)?.has(name));
+		if (!fromErrors.error && fromErrors.chain.length > 0 && !stray) return save(name, {
+			chain: fromErrors.chain,
+			from: fromErrors.from ?? "prefix"
+		});
+		if (!shown && failsAlone(name)) for (const owner of renderedBy.get(name) ?? []) {
+			if (!names.includes(owner) || owner === name) continue;
+			const chain = [...(chainOf(owner, depth + 1)?.chain ?? []).filter((parent) => parent !== name), owner];
+			if (!attempt(chain, name)) return save(name, {
+				chain,
+				from: "source"
+			});
+		}
+		const result = !grown || fromErrors.chain.length > 0 ? fromErrors : grown;
+		const chain = result.error ? result.chain.filter((parent) => familyIn(parent) === familyIn(name)) : result.chain;
+		return save(name, chain.length > 0 ? {
+			chain,
+			from: result.from ?? "prefix"
+		} : null);
+	};
+	/**
+	* The examples mostly use it with nothing of the library's around it (Chakra's `InputGroup`, around an `Input`), so its
+	* name doesn't say where it goes.
+	*/
+	const standsAlone = (name) => {
+		const use = examples.get(name);
+		return !!use && use.count >= 2 && use.topLevel * 2 >= use.count;
+	};
+	const grow = (name, depth, start, startFrom) => {
+		let chain = start;
+		let from = startFrom;
+		let error = attempt(chain, name);
+		for (let step = 0; error && step < maxDepth && depth < maxDepth; step++) {
+			const mentioned = named(error, name, chain);
+			let next;
+			let signal;
+			if (mentioned) [next, signal] = [mentioned, "error"];
+			else if (chain.length === 0 && !standsAlone(name)) [next, signal] = guessParent(name, names);
+			if (!next) break;
+			from ??= signal;
+			const above = chainOf(next, depth + 1)?.chain ?? [];
+			const rest = chain.filter((parent) => !above.includes(parent) && parent !== next);
+			const inner = [.../* @__PURE__ */ new Set([
+				...above,
+				...rest,
+				next
+			])];
+			const outer = [.../* @__PURE__ */ new Set([
+				...above,
+				next,
+				...rest
+			])];
+			const bare = [.../* @__PURE__ */ new Set([...rest, next])];
+			const rare = levelsOf(next, false, [name], .2).map((level) => level.parent);
+			const wide = [.../* @__PURE__ */ new Set([
+				...rare,
+				...rest,
+				next
+			])];
+			const tried = [
+				inner,
+				...rest.length > 0 ? [outer] : [],
+				...above.length > 0 ? [bare] : [],
+				...rare.some((level) => !inner.includes(level)) ? [wide] : []
+			].map((candidate) => ({
+				candidate,
+				error: attempt(candidate, name)
+			}));
+			const pick = tried.find((option) => !option.error) ?? (tried[0].error === error ? tried.find((option) => option.error !== error) : void 0) ?? tried[0];
+			chain = pick.candidate;
+			error = pick.error;
+		}
+		if (chain.length === 0) {
+			const [parent, signal] = guessParent(name, names);
+			if (parent && signal === "namespace") return {
+				chain: [parent],
+				from: signal,
+				error
+			};
+		}
+		return {
+			chain,
+			from,
+			error
+		};
+	};
+	const save = (name, result) => {
+		const chain = result?.chain.filter((parent) => parent !== name);
+		const saved = result && chain && chain.length > 0 ? {
+			...result,
+			chain
+		} : null;
+		chains.set(name, saved);
+		return saved;
+	};
+	const missing = [];
+	/** Parts drawn from a list the library keeps that render with an item of it. */
+	const drawnParts = /* @__PURE__ */ new Set();
+	/** What the package puts inside each of them. */
+	const drawnInside = /* @__PURE__ */ new Map();
+	for (const component of components) {
+		const relation = {};
+		const short = component.name.slice(component.name.lastIndexOf(".") + 1);
+		if (notVisual.test(short)) relation.visual = false;
+		const found = value(component.name);
+		if (typeof found !== "function" && (typeof found !== "object" || found === null)) {
+			relations.set(component.name, { visual: false });
+			missing.push(component.name);
+			continue;
+		}
+		const alone = attempt([], component.name);
+		if (alone) relation.alone = alone;
+		const chain = chainOf(component.name, 0);
+		if (chain && chain.chain.length > 0) {
+			relation.parents = chain.chain;
+			if (chain.from) relation.parentsFrom = chain.from;
+			if (withParts.has(component.name)) relation.parentParts = true;
+			if (chain.from === "example" && !attempt(chain.chain, component.name)) {
+				const optional = optionalOf(component.name, chain.chain);
+				if (optional.length > 0) relation.optionalParents = optional;
+			}
+		}
+		const edit = edits?.[component.name];
+		if (edit && edit.visual === false) relation.visual = false;
+		const editedChildren = edit ? edit.sample?.children : void 0;
+		let inside = alone ? attempt(relation.parents ?? [], component.name, editedChildren) : void 0;
+		if (editedChildren && !inside) relation.sample = { children: editedChildren };
+		if (inside && /Children\.only|single React element|valid child|element child|should be an element|accepts ref/i.test(inside)) {
+			const children = [{
+				component: "span",
+				children: ["Text"]
+			}];
+			if (!attempt(relation.parents ?? [], component.name, children)) {
+				relation.sample = { children };
+				inside = void 0;
+			}
+		}
+		if (Object.keys(component.samples).length > 0 && !inside) relation.sample = {
+			...relation.sample,
+			props: component.samples
+		};
+		const use = examples.get(component.name);
+		let shown = use?.sample;
+		if (shown && (shown.props || shown.children) && !editedChildren) {
+			const before = samples.get(component.name);
+			samples.set(component.name, {
+				...before,
+				...shown.props
+			});
+			let failed = attempt(relation.parents ?? [], component.name, shown.children);
+			if (failed && inside && use?.rare) {
+				samples.set(component.name, {
+					...before,
+					...shown.props,
+					...use?.rare
+				});
+				failed = attempt(relation.parents ?? [], component.name, shown.children);
+				if (!failed) shown = {
+					...shown,
+					props: {
+						...shown.props,
+						...use?.rare
+					}
+				};
+			}
+			if (failed || !inside) samples.set(component.name, before ?? {});
+			if (!failed) {
+				relation.sample = {
+					props: {
+						...component.samples,
+						...shown.props
+					},
+					...shown.children ? { children: shown.children } : {}
+				};
+				if (Object.keys(relation.sample.props).length === 0) delete relation.sample.props;
+				relation.sampleFrom = "example";
+				if (!inside && shown.props) loose.set(component.name, component.samples);
+				inside = void 0;
+			}
+		}
+		for (const call of inside ? calls.get(component.name) ?? [] : []) {
+			if (!names.includes(call.owner)) continue;
+			const owner = {
+				...samples.get(call.owner),
+				...examples.get(call.owner)?.sample?.props
+			};
+			const props = { ...component.samples };
+			const worked = [];
+			for (const [key, passed] of Object.entries(call.props)) {
+				let value;
+				if ("forward" in passed) value = owner[passed.forward];
+				else if ("value" in passed) value = passed.value;
+				if (value !== void 0) props[key] = value;
+				else if (!(key in props)) worked.push(key);
+			}
+			const before = samples.get(component.name);
+			const tries = [void 0, ...worked.length > 0 ? madeCalls : []];
+			let failed;
+			for (const made of tries) {
+				if (made) props[worked[0]] = made;
+				samples.set(component.name, props);
+				failed = attempt(relation.parents ?? [], component.name);
+				if (!failed) break;
+			}
+			if (failed) samples.set(component.name, before ?? {});
+			else {
+				relation.sample = {
+					...relation.sample,
+					props
+				};
+				inside = void 0;
+				break;
+			}
+		}
+		const drawn = listItem ? (calls.get(component.name) ?? []).find((call) => Object.values(call.props).some((passed) => "item" in passed)) : void 0;
+		const inDrawn = (relation.parents ?? []).some((parent) => drawnParts.has(parent));
+		if (drawn || inside && inDrawn) {
+			const before = samples.get(component.name);
+			const props = { ...before };
+			for (const [key, passed] of Object.entries(drawn?.props ?? {})) if ("item" in passed) props[key] = {
+				id: "1",
+				...listItem
+			};
+			samples.set(component.name, props);
+			let parents = relation.parents ?? [];
+			let failed = attempt(parents, component.name);
+			for (let tries = 0; failed && tries < 2; tries++) {
+				const needed = named(failed, component.name, parents);
+				if (!needed) break;
+				const next = attempt([needed, ...parents], component.name);
+				if (next === failed) break;
+				parents = [needed, ...parents];
+				failed = next;
+			}
+			if (failed) samples.set(component.name, before ?? {});
+			else {
+				if (parents.length > (relation.parents?.length ?? 0)) {
+					relation.parents = parents;
+					relation.parentsFrom = "error";
+					delete relation.optionalParents;
+				}
+				if (drawn) {
+					drawnParts.add(component.name);
+					const own = exportedChildren(drawn.children ?? [], names);
+					drawnInside.set(component.name, new Set(componentsIn(own)));
+					const children = own.length > 0 ? own : relation.sample?.children ?? [];
+					relation.sample = {
+						props,
+						...children.length > 0 ? { children } : {}
+					};
+				}
+				inside = void 0;
+			}
+		}
+		const madeHere = madeProps.get(component.name);
+		if (madeHere) relation.sample = {
+			...relation.sample,
+			props: {
+				...madeHere,
+				...relation.sample?.props
+			}
+		};
+		if (inside) relation.inside = inside;
+		relations.set(component.name, relation);
+	}
+	for (const [name, relation] of relations) {
+		if (!relation.inside || !relation.parents) continue;
+		if (!attempt(relation.parents, name, relation.sample?.children)) delete relation.inside;
+	}
+	const asInserted = (chain, name, children) => {
+		const saved = chain.map((parent) => [parent, samples.get(parent)]);
+		for (const parent of chain) if (loose.has(parent)) samples.set(parent, {
+			...samples.get(parent),
+			...relations.get(parent)?.sample?.props
+		});
+		const error = attempt(chain, name, children);
+		for (const [parent, sample] of saved) samples.set(parent, sample ?? {});
+		return error;
+	};
+	for (const [name, relation] of relations) {
+		if (!relation.parents || relation.inside || relation.visual === false) continue;
+		if (!relation.parents.some((parent) => loose.has(parent))) continue;
+		if (!asInserted(relation.parents, name, relation.sample?.children)) continue;
+		const cleared = [];
+		for (const parent of relation.parents) {
+			const generated = loose.get(parent);
+			const sample = relations.get(parent)?.sample;
+			if (!generated || !sample) continue;
+			loose.delete(parent);
+			const made = Object.entries(sample.props ?? {}).filter(([, value]) => isMadeValue(value) || Array.isArray(value) && value.some(isMadeValue));
+			const kept = {
+				...generated,
+				...Object.fromEntries(made)
+			};
+			if (made.length > 0) cleared.push([
+				parent,
+				generated,
+				kept
+			]);
+			if (Object.keys(kept).length > 0) sample.props = kept;
+			else delete sample.props;
+		}
+		if (cleared.length > 0) {
+			const saved = cleared.map(([parent]) => [parent, samples.get(parent)]);
+			for (const [parent, , kept] of cleared) samples.set(parent, kept);
+			const fails = attempt(relation.parents, name, relation.sample?.children);
+			for (const [parent, sample] of saved) samples.set(parent, sample ?? {});
+			if (fails) for (const [parent, generated] of cleared) {
+				const sample = relations.get(parent).sample;
+				if (Object.keys(generated).length > 0) sample.props = generated;
+				else delete sample.props;
+			}
+		}
+		for (const parent of relation.parents) {
+			const sample = relations.get(parent)?.sample;
+			if (sample && !sample.props && !sample.children) delete relations.get(parent).sample;
+		}
+	}
+	for (const [name, error] of Object.entries(appErrors)) {
+		const relation = relations.get(name);
+		if (!relation || relation.visual === false) continue;
+		if (/void element|self-closing tag/.test(error)) {
+			if (!relation.sample?.children) relation.sample = {
+				...relation.sample,
+				children: []
+			};
+			continue;
+		}
+		if (relation.parentsFrom === "edit") continue;
+		const parents = relation.parents ?? [];
+		const needed = named(error, name, parents, false);
+		if (!needed) {
+			const shown = exampleChain(name);
+			if (shown && shown.join() !== parents.join() && !attempt(shown, name, relation.sample?.children)) {
+				relation.parents = shown;
+				relation.parentsFrom = "app";
+				delete relation.optionalParents;
+			}
+			continue;
+		}
+		const outer = (relations.get(needed)?.parents ?? []).filter((parent) => parent !== name);
+		relation.parents = namespaceOf(needed) === namespaceOf(name) ? [.../* @__PURE__ */ new Set([
+			...outer,
+			needed,
+			...parents
+		])] : [...parents, needed];
+		relation.parentsFrom = "app";
+	}
+	completeChains(relations);
+	for (const [name, relation] of relations) {
+		if (relation.sample?.children || !relation.parents?.length || relation.visual === false) continue;
+		for (const parent of [...relation.parents].reverse()) {
+			const children = spelledOut(relations.get(parent)?.sample?.children ?? [], name);
+			if (!children) continue;
+			let parts = false;
+			if (attempt(relation.parents, name, children)) parts = attempt(relation.parents, name, children, true) ? void 0 : true;
+			if (parts !== void 0) {
+				relation.sample = {
+					...relation.sample,
+					children
+				};
+				if (parts) relation.parentParts = true;
+				delete relation.inside;
+			}
+			break;
+		}
+	}
+	const partsOf = /* @__PURE__ */ new Map();
+	for (const [name, relation] of relations) {
+		const parent = relation.parents?.at(-1);
+		if (!parent || relation.inside || relation.visual === false) continue;
+		partsOf.set(parent, [...partsOf.get(parent) ?? [], name]);
+	}
+	const depth = (name) => relations.get(name)?.parents?.length ?? 0;
+	for (const [parent, parts] of [...partsOf].sort(([a], [b]) => depth(b) - depth(a))) {
+		const relation = relations.get(parent);
+		if (!relation || relation.inside || relation.sampleFrom === "example" && relation.sample?.children) continue;
+		if (drawnParts.has(parent)) continue;
+		const children = parts.slice(0, 3).map((part) => ({
+			component: part,
+			...relations.get(part)?.sample?.props ? { props: relations.get(part).sample.props } : {},
+			...relations.get(part)?.sample?.children ? { children: relations.get(part).sample.children } : {}
+		}));
+		if (!attempt(relation.parents ?? [], parent, children)) relation.sample = {
+			...relation.sample,
+			children
+		};
+	}
+	for (const [name, relation] of relations) {
+		if (relation.visual === false || relation.sample?.children) continue;
+		const parents = relation.parents ?? [];
+		const failed = attempt(parents, name, ["Text"]);
+		if (failed && /void element|self-closing tag/.test(failed) && !attempt(parents, name, [])) relation.sample = {
+			...relation.sample,
+			children: []
+		};
+		const bare = failed && attempt(parents, name);
+		if (bare && /children is not a function/.test(bare) && !attempt(parents, name, [{ $render: ["Text"] }])) {
+			relation.sample = {
+				...relation.sample,
+				children: [{ $render: ["Text"] }]
+			};
+			delete relation.inside;
+		}
+	}
+	const textOnly = /* @__PURE__ */ new Set();
+	for (const [name, relation] of relations) {
+		const texts = relation.sample?.children;
+		if (!texts?.length || !texts.every((child) => typeof child === "string")) continue;
+		const parents = relation.parents ?? [];
+		if (!attempt(parents, name, [{
+			component: "p",
+			children: texts
+		}]) || attempt(parents, name, texts)) continue;
+		const { children: _, ...sample } = relation.sample;
+		relation.sample = {
+			...sample,
+			props: {
+				...sample.props,
+				children: texts.join("")
+			}
+		};
+		textOnly.add(name);
+	}
+	const asText = (children) => children.map((child) => {
+		if (typeof child !== "object" || !("component" in child) || !child.children) return child;
+		const { children: inner, ...node } = child;
+		if (textOnly.has(child.component) && inner.length > 0 && inner.every((item) => typeof item === "string")) return {
+			...node,
+			props: {
+				...node.props,
+				children: inner.join("")
+			}
+		};
+		return {
+			...node,
+			children: asText(inner)
+		};
+	});
+	if (textOnly.size > 0) {
+		for (const relation of relations.values()) if (relation.sample?.children) relation.sample = {
+			...relation.sample,
+			children: asText(relation.sample.children)
+		};
+	}
+	for (const relation of relations.values()) {
+		const nearest = relation.parents?.at(-1);
+		if (nearest && relations.get(nearest)?.sample?.children?.length === 0 && relation.parentsFrom !== "edit") {
+			delete relation.parents;
+			delete relation.optionalParents;
+			delete relation.parentsFrom;
+		}
+	}
+	const drawnTree = /* @__PURE__ */ new Set([...drawnParts, ...[...drawnInside.values()].flatMap((inside) => [...inside])]);
+	return {
+		relations,
+		tried: true,
+		...drawnTree.size > 0 ? { drawn: [...drawnTree] } : {},
+		...missing.length > 0 ? { note: `Declared but not exported when it runs, so left out: ${missing.slice(0, 10).join(", ")}${missing.length > 10 ? ` and ${missing.length - 10} more` : ""}.` } : {}
+	};
+}
+/**
+* The parent a name suggests: its namespace's `Root` (`Accordion.Item`), the longest other component its name starts
+* with (`AccordionItem` under `Accordion`), that one's plural when there is one (`TabPanels` under `Tabs`), or its own
+* plural (`Tab` under `Tabs`).
+*/
+function guessParent(name, names) {
+	const dot = name.lastIndexOf(".");
+	if (dot !== -1) {
+		const namespace = name.slice(0, dot);
+		const member = name.slice(dot + 1);
+		if (member === "Root" || member === "Provider") return [void 0, void 0];
+		const root = [
+			`${namespace}.Root`,
+			`${namespace}.Provider`,
+			namespace
+		].find((candidate) => names.includes(candidate));
+		return root ? [root, "namespace"] : [void 0, void 0];
+	}
+	const prefix = names.filter((other) => other !== name && !other.includes(".") && name.startsWith(other) && /^[A-Z]/.test(name.slice(other.length))).filter((other) => !notVisual.test(other)).sort((a, b) => b.length - a.length)[0];
+	if (prefix) return [names.includes(`${prefix}s`) && `${prefix}s` !== name ? `${prefix}s` : prefix, "prefix"];
+	if (names.includes(`${name}s`)) return [`${name}s`, "prefix"];
+	return [void 0, void 0];
+}
+/**
+* A name an error mentions, as one of the library's components. A namespaced part only goes inside its own namespace,
+* where an internal name maps by its last words (`MenuContent` and `PopperContent` to `ContextMenu.Content`,
+* `MenuSub` to `ContextMenu.Sub`). Other parts match exactly, or with the dots left out (`Menu.SubmenuRoot`).
+*/
+function resolveName(mention, self, names) {
+	const namespace = namespaceOf(self);
+	if (namespace) {
+		if (mention.startsWith(`${namespace}.`)) return names.includes(mention) ? mention : void 0;
+		if (namespace.slice(namespace.lastIndexOf(".") + 1).endsWith(mention) && names.includes(`${namespace}.Root`)) return `${namespace}.Root`;
+		const words = mention.replaceAll(".", "").split(/(?=[A-Z])/);
+		for (let start = 0; start < words.length; start++) {
+			const candidate = `${namespace}.${words.slice(start).join("")}`;
+			if (names.includes(candidate)) return candidate;
+		}
+		return mention.includes(".") && names.includes(mention) ? mention : void 0;
+	}
+	if (names.includes(mention)) return mention;
+	const flat = mention.replaceAll(".", "");
+	const exact = names.find((name) => name.replaceAll(".", "") === flat);
+	if (exact) return exact;
+	const family = names.filter((name) => name !== self && self.startsWith(name) && /^[A-Z]/.test(self.slice(name.length))).sort((a, b) => b.length - a.length)[0];
+	if (!family) return void 0;
+	const words = mention.split(".").at(-1).split(/(?=[A-Z])/);
+	if (words.join("") === "Root") return family;
+	for (let start = 0; start < words.length; start++) {
+		const candidate = `${family}${words.slice(start).join("")}`;
+		if (candidate !== self && names.includes(candidate)) return candidate;
+	}
+}
+function namespaceOf(name) {
+	const dot = name.lastIndexOf(".");
+	return dot === -1 ? void 0 : name.slice(0, dot);
+}
+function message(error) {
+	return (error instanceof Error ? error.message : String(error)).split("\n")[0].slice(0, 300);
+}
+/**
+* Starts each chain whose outermost parent needs parents of its own outside them (`SubmenuTrigger` in a `MenuSection`,
+* which goes in a `Menu`), as inserting the parent alone would, with the levels optional there optional here too.
+* Parents guessed round in a circle (a part among its parent's parents) are left as they are.
+*/
+function completeChains(relations) {
+	for (const [name, relation] of relations) for (let round = 0; round < 4 && relation.parents?.length; round++) {
+		const outer = relations.get(relation.parents[0]);
+		if (outer?.parents?.includes(name)) break;
+		const added = (outer?.parents ?? []).filter((parent) => !relation.parents.includes(parent));
+		if (added.length === 0) break;
+		relation.parents = [...added, ...relation.parents];
+		const optional = (outer?.optionalParents ?? []).filter((parent) => added.includes(parent));
+		if (optional.length > 0) relation.optionalParents = [.../* @__PURE__ */ new Set([...relation.optionalParents ?? [], ...optional])];
+	}
+}
+/** The children a sample spells out for the first `name` in it that has any, at any depth (a table's `Row` its `Cell`s). */
+function spelledOut(children, name) {
+	for (const child of children) {
+		if (typeof child === "string" || isSampleRender(child)) continue;
+		if (child.component === name && child.children?.length) return child.children;
+		const inner = spelledOut(child.children ?? [], name);
+		if (inner) return inner;
+	}
+}
+/**
+* A decorator's value outside a frame, for trying parts on the server: imports and calls are made, a mode's value is
+* its default, and the frame's own nodes are left undefined, as there's no frame. Direction and language take the
+* frame's defaults.
+*/
+async function trialValue(load, value) {
+	if (Array.isArray(value)) return Promise.all(value.map((item) => trialValue(load, item)));
+	if (typeof value !== "object" || value === null) return value;
+	const record = value;
+	if (typeof record.$import === "string") return exported(await load(record.$import), String(record.export ?? "default"));
+	if (typeof record.$call === "object" && record.$call !== null) {
+		const call = record.$call;
+		const fn = exported(await load(call.import), call.export ?? "default");
+		const args = await trialValue(load, record.args ?? []);
+		if (typeof fn !== "function") return void 0;
+		const made = fn(...args);
+		for (const step of record.methods ?? []) {
+			const method = made?.[step.method];
+			if (typeof method !== "function") continue;
+			const args = await trialValue(load, step.args ?? []);
+			try {
+				method.apply(made, args);
+			} catch {}
+		}
+		return made;
+	}
+	if (typeof record.$global === "string") return trialValue(load, record.default);
+	if (typeof record.$frame === "string") {
+		if (record.$frame === "dir") return "ltr";
+		return record.$frame === "lang" ? "en-US" : void 0;
+	}
+	if ("$function" in record) {
+		const result = await trialValue(load, record.$function);
+		return () => result;
+	}
+	const resolved = {};
+	for (const [key, item] of Object.entries(record)) resolved[key] = await trialValue(load, item);
+	return resolved;
+}
+function exported(module, name) {
+	let found = module;
+	for (const part of name.split(".")) found = found?.[part];
+	return found ?? (name === "default" ? module : void 0);
+}
+/** The parts the package puts inside another, as sample children, keeping only those it exports. */
+function exportedChildren(children, names) {
+	return children.flatMap((child) => {
+		const inner = exportedChildren(child.children ?? [], names);
+		if (!names.includes(child.component)) return inner;
+		return [{
+			component: child.component,
+			...inner.length > 0 ? { children: inner } : {}
+		}];
+	});
+}
+/** Every component a sample's children name, at any depth. */
+function componentsIn(children) {
+	return children.flatMap((child) => typeof child === "object" && "component" in child ? [child.component, ...componentsIn(child.children ?? [])] : []);
+}
+// ../libgen/src/presets.ts
+const createTheme = {
+	import: "@mui/material/styles",
+	export: "createTheme"
+};
+/** MUI's theme in CSS-variables mode, so its components read the custom properties the Tokens panel edits. */
+function muiTheme(mode) {
+	return {
+		$call: createTheme,
+		args: [{
+			cssVariables: {
+				rootSelector: ":host",
+				colorSchemeSelector: "class"
+			},
+			colorSchemes: {
+				light: true,
+				dark: true
+			},
+			defaultColorScheme: mode,
+			components: Object.fromEntries([
+				"MuiPopover",
+				"MuiPopper",
+				"MuiModal"
+			].map((name) => [name, { defaultProps: { container: { $frame: "body" } } }]))
+		}]
+	};
+}
+const fluentThemes = {
+	light: "webLightTheme",
+	dark: "webDarkTheme",
+	"teams-light": "teamsLightTheme",
+	"teams-dark": "teamsDarkTheme",
+	"teams-high-contrast": "teamsHighContrastTheme"
+};
+const presets = {
+	...Object.fromEntries([
+		"luma",
+		"lyra",
+		"maia",
+		"mira",
+		"nova",
+		"rhea",
+		"sera",
+		"vega"
+	].map((style) => {
+		const name = `@buildkitgg/shadcn-baseui-${style}`;
+		return [name, {
+			id: style,
+			name: `Shadcn ${style.charAt(0).toUpperCase()}${style.slice(1)}`,
+			description: `Every shadcn component on Base UI, in the ${style} style, kept in step with upstream.`,
+			styles: "tailwind.css",
+			examples: {
+				paths: ["apps/v4/examples/base/"],
+				anatomy: ["apps/v4/content/docs/components/base/"]
+			},
+			decorators: [{ wrap: {
+				import: name,
+				component: "TooltipProvider"
+			} }, { add: {
+				import: name,
+				component: "Toaster"
+			} }]
+		}];
+	})),
+	"radix-ui": {
+		examples: { paths: ["apps/storybook/stories/"] },
+		id: "radix",
+		name: "Radix Primitives",
+		description: "Unstyled, accessible primitives; styles come from the project's CSS.",
+		decorators: [
+			{ wrap: {
+				import: "radix-ui",
+				component: "Direction.Provider",
+				props: { dir: { $frame: "dir" } }
+			} },
+			{ wrap: {
+				import: "radix-ui",
+				component: "Tooltip.Provider"
+			} },
+			{ wrap: {
+				import: "radix-ui",
+				component: "Toast.Provider"
+			} },
+			{ add: {
+				import: "radix-ui",
+				component: "Toast.Viewport"
+			} }
+		],
+		notes: ["Portals take a container per component (`Dialog.Portal container`); Radix has no provider for all of them."]
+	},
+	"@base-ui/react": {
+		examples: {
+			paths: ["docs/"],
+			anatomy: ["docs/src/app/(docs)/react/components/"]
+		},
+		id: "baseui",
+		name: "Base UI",
+		description: "Unstyled components from the makers of Radix, Floating UI and Material UI.",
+		decorators: [{ wrap: {
+			import: "@base-ui/react",
+			component: "DirectionProvider",
+			props: { direction: { $frame: "dir" } }
+		} }, { wrap: {
+			import: "@base-ui/react",
+			component: "Toast.Provider"
+		} }],
+		notes: ["Portals take a container per component (`Dialog.Portal container`); Base UI has no provider for all of them."]
+	},
+	"react-aria-components": {
+		examples: { paths: ["packages/react-aria-components/", "packages/dev/s2-docs/pages/react-aria/"] },
+		id: "aria",
+		name: "React Aria Components",
+		description: "Adobe's unstyled, accessible components; styles come from the project's CSS.",
+		decorators: [{ wrap: {
+			import: "react-aria-components",
+			component: "I18nProvider",
+			props: { locale: { $frame: "lang" } }
+		} }],
+		notes: ["Toasts need the app's own `UNSTABLE_ToastQueue`, so there's no toast host to add."]
+	},
+	"@mui/material": {
+		examples: {
+			paths: [],
+			demos: ["docs/data/material/components/"]
+		},
+		id: "mui",
+		name: "Material UI",
+		description: "Google's Material Design in React, styled with Emotion.",
+		decorators: [
+			{ wrap: {
+				import: "@emotion/react",
+				component: "CacheProvider",
+				props: { value: {
+					$call: {
+						import: "@emotion/cache",
+						export: "default"
+					},
+					args: [{
+						key: "mui",
+						container: { $frame: "root" },
+						prepend: true
+					}]
+				} }
+			} },
+			{ wrap: {
+				import: "@mui/material/styles",
+				component: "ThemeProvider",
+				props: {
+					theme: {
+						$global: "theme",
+						values: { dark: muiTheme("dark") },
+						default: muiTheme("light")
+					},
+					defaultMode: {
+						$global: "theme",
+						values: { dark: "dark" },
+						default: "light"
+					},
+					colorSchemeNode: { $frame: "body" },
+					storageManager: null,
+					disableTransitionOnChange: true
+				}
+			} },
+			{ wrap: {
+				import: "@mui/material",
+				component: "ScopedCssBaseline"
+			} }
+		],
+		async theme(load) {
+			const make = (await load("@mui/material/styles")).createTheme;
+			const theme = make({
+				cssVariables: { colorSchemeSelector: "class" },
+				colorSchemes: {
+					light: true,
+					dark: true
+				}
+			});
+			const tokens = /* @__PURE__ */ new Map();
+			for (const sheet of theme.generateStyleSheets()) for (const [selector, declarations] of Object.entries(sheet)) {
+				const context = /\bdark\b/.test(selector) ? "dark" : "default";
+				for (const [name, value] of Object.entries(declarations)) {
+					if (!name.startsWith("--") || typeof value !== "string" && typeof value !== "number") continue;
+					const property = name.slice(2);
+					if (/Channel$|Opacity$/.test(property)) continue;
+					const token = tokens.get(property) ?? {
+						var: property,
+						category: muiCategory(property),
+						values: {}
+					};
+					token.values[context] = String(value);
+					tokens.set(property, token);
+				}
+			}
+			const unit = tokens.get("mui-spacing")?.values.default;
+			if (unit) tokens.set("spacing", {
+				var: "spacing",
+				category: "spacing",
+				values: { default: unit }
+			});
+			const plain = make({});
+			const breakpoints = plain.breakpoints.values;
+			for (const [id, width] of Object.entries(breakpoints)) if (width > 0) tokens.set(`mui-breakpoint-${id}`, {
+				var: `mui-breakpoint-${id}`,
+				category: "breakpoint",
+				values: { default: `${width}px` }
+			});
+			for (const [variant, style] of Object.entries(plain.typography)) {
+				const { fontSize, lineHeight } = style ?? {};
+				if (typeof fontSize !== "string") continue;
+				const size = `mui-font-size-${variant}`;
+				const leading = `mui-line-height-${variant}`;
+				if (typeof lineHeight === "number" || typeof lineHeight === "string") tokens.set(leading, {
+					var: leading,
+					category: "leading",
+					values: { default: String(lineHeight) }
+				});
+				tokens.set(size, {
+					var: size,
+					category: "font-size",
+					values: { default: fontSize },
+					...tokens.has(leading) ? { lineHeight: leading } : {}
+				});
+			}
+			return {
+				tokens: [...tokens.values()],
+				breakpoints: Object.entries(breakpoints).filter(([, width]) => width > 0).map(([id, width]) => ({
+					id,
+					name: breakpointName(id),
+					width
+				}))
+			};
+		}
+	},
+	"@chakra-ui/react": {
+		examples: {
+			paths: ["apps/compositions/"],
+			anatomy: ["apps/www/content/docs/components/"]
+		},
+		id: "chakra",
+		name: "Chakra UI",
+		description: "Accessible components with style props, on Emotion.",
+		decorators: [
+			{ wrap: {
+				import: "@emotion/react",
+				component: "CacheProvider",
+				props: { value: {
+					$call: {
+						import: "@emotion/cache",
+						export: "default"
+					},
+					args: [{
+						key: "chakra",
+						container: { $frame: "root" }
+					}]
+				} }
+			} },
+			{ wrap: {
+				import: "@chakra-ui/react",
+				component: "ChakraProvider",
+				props: { value: {
+					$import: "@chakra-ui/react",
+					export: "defaultSystem"
+				} }
+			} },
+			{ wrap: {
+				import: "@chakra-ui/react",
+				component: "EnvironmentProvider",
+				props: { value: { $function: { $frame: "root" } } }
+			} },
+			{ style: {
+				"font-family": "var(--chakra-fonts-body)",
+				color: "var(--chakra-colors-fg)",
+				"background-color": "var(--chakra-colors-bg)",
+				"line-height": "1.5"
+			} }
+		],
+		notes: ["Chakra's Toaster is a snippet the app generates (`npx @chakra-ui/cli snippet add toaster`), not an export."],
+		async theme(load) {
+			const system = (await load("@chakra-ui/react")).defaultSystem;
+			const tokens = /* @__PURE__ */ new Map();
+			const visit = (styles, context) => {
+				if (typeof styles !== "object" || styles === null) return;
+				for (const [key, value] of Object.entries(styles)) if (key.startsWith("--") && (typeof value === "string" || typeof value === "number")) {
+					const property = key.slice(2);
+					const token = tokens.get(property) ?? {
+						var: property,
+						category: chakraCategory(property, String(value)),
+						values: {}
+					};
+					token.values[context] = String(value);
+					tokens.set(property, token);
+				} else visit(value, /\bdark\b/.test(key) ? "dark" : context);
+			};
+			visit(system.getTokenCss(), "default");
+			const unit = tokens.get("chakra-spacing-1")?.values.default;
+			if (unit) tokens.set("spacing", {
+				var: "spacing",
+				category: "spacing",
+				values: { default: unit }
+			});
+			return { tokens: [...tokens.values()] };
+		}
+	},
+	"@mantine/core": {
+		examples: { paths: ["packages/@docs/demos/"] },
+		id: "mantine",
+		name: "Mantine",
+		description: "A full-featured component library with CSS modules and its own hooks.",
+		styles: "styles.css",
+		decorators: [{ wrap: {
+			import: "@mantine/core",
+			component: "MantineProvider",
+			props: {
+				forceColorScheme: {
+					$global: "theme",
+					values: { dark: "dark" },
+					default: "light"
+				},
+				cssVariablesSelector: ":host",
+				getRootElement: { $function: { $frame: "host" } },
+				theme: { components: { Portal: { defaultProps: { target: { $frame: "body" } } } } }
+			}
+		} }],
+		notes: ["`@mantine/notifications` has its own `Notifications` host; it's added once that package has a registry file."]
+	},
+	"@fluentui/react-components": {
+		examples: { paths: ["packages/react-components/"] },
+		id: "fluent",
+		name: "Fluent UI",
+		description: "Microsoft's Fluent 2 design system for React, styled with Griffel.",
+		decorators: [
+			{ wrap: {
+				import: "@fluentui/react-components",
+				component: "RendererProvider",
+				props: {
+					renderer: {
+						$call: {
+							import: "@griffel/shadow-dom",
+							export: "createShadowDOMRenderer"
+						},
+						args: [{ $frame: "root" }]
+					},
+					targetDocument: { $frame: "document" }
+				}
+			} },
+			{ wrap: {
+				import: "@fluentui/react-components",
+				component: "FluentProvider",
+				props: {
+					theme: {
+						$global: "theme",
+						values: Object.fromEntries(Object.entries(fluentThemes).map(([id, name]) => [id, {
+							$import: "@fluentui/react-components",
+							export: name
+						}])),
+						default: {
+							$import: "@fluentui/react-components",
+							export: "webLightTheme"
+						}
+					},
+					dir: { $frame: "dir" },
+					targetDocument: { $frame: "document" }
+				}
+			} },
+			{ wrap: {
+				import: "@fluentui/react-components",
+				component: "PortalMountNodeProvider",
+				props: { value: { $frame: "body" } }
+			} }
+		],
+		notes: ["FluentProvider writes its theme into the page's head, which frames can't see, so each theme's variables come from this file's tokens."],
+		async theme(load) {
+			const fluent = await load("@fluentui/tokens");
+			const tokens = /* @__PURE__ */ new Map();
+			for (const [context, name] of Object.entries(fluentThemes)) {
+				const theme = fluent[name];
+				if (!theme) continue;
+				for (const [property, value] of Object.entries(theme)) {
+					const token = tokens.get(property) ?? {
+						var: property,
+						category: fluentCategory(property),
+						values: {}
+					};
+					if (context === "light") token.values.default = String(value);
+					else token.values[context] = String(value);
+					tokens.set(property, token);
+				}
+			}
+			for (const token of tokens.values()) {
+				const step = /^fontSize(.+)$/.exec(token.var)?.[1];
+				if (step && tokens.has(`lineHeight${step}`)) token.lineHeight = `lineHeight${step}`;
+			}
+			return { tokens: [...tokens.values()] };
+		}
+	},
+	recharts: {
+		id: "recharts",
+		name: "Recharts",
+		description: "Charts, axes, series and grids to compose, as shadcn's charts are."
+	},
+	"lucide-react": {
+		id: "lucide",
+		name: "Lucide",
+		description: "Over 1,600 consistent, open source icons; shadcn's default icon set.",
+		tags: {
+			package: "lucide-static",
+			file: "tags.json"
+		}
+	},
+	"@hugeicons/core-free-icons": {
+		id: "hugeicons",
+		name: "Hugeicons",
+		description: "Thousands of free icons as data, drawn by Hugeicons' React component.",
+		icons: {
+			render: {
+				import: "@hugeicons/react",
+				component: "HugeiconsIcon",
+				prop: "icon"
+			},
+			match: "Icon$"
+		}
+	},
+	"@heroicons/react": {
+		id: "heroicons",
+		name: "Heroicons",
+		description: "Hand-crafted SVG icons from the makers of Tailwind CSS, outline and solid, at 24, 20 and 16px.",
+		icons: {
+			import: "@heroicons/react/24/outline",
+			render: "export"
+		}
+	},
+	"@phosphor-icons/react": {
+		id: "phosphor",
+		name: "Phosphor",
+		description: "A flexible icon family with six weights, picked with the weight prop.",
+		icons: {
+			render: "export",
+			variants: {
+				prop: "weight",
+				styles: [
+					"thin",
+					"light",
+					"regular",
+					"bold",
+					"fill",
+					"duotone"
+				],
+				default: { style: "regular" }
+			}
+		},
+		tags: {
+			package: "@phosphor-icons/core",
+			file: "dist/index.mjs"
+		}
+	},
+	"@tabler/icons-react": {
+		id: "tabler",
+		name: "Tabler Icons",
+		description: "Over 5,000 outline and filled icons on a 24px grid.",
+		icons: {
+			render: "export",
+			variants: {
+				pattern: "^(?<name>Icon.+?)(?<style>Filled)?$",
+				styles: ["Outline", "Filled"],
+				default: { style: "Outline" }
+			}
+		},
+		tags: {
+			package: "@tabler/icons",
+			file: "icons.json"
+		}
+	},
+	"@fluentui/react-icons": {
+		id: "fluent-icons",
+		name: "Fluent icons",
+		description: "Microsoft's Fluent System Icons, in Regular and Filled styles, some with a size in the name.",
+		icons: {
+			render: "export",
+			variants: {
+				pattern: "^(?<name>.+?)(?<size>\\d+)?(?<style>Regular|Filled|Color|Light)$",
+				styles: [
+					"Regular",
+					"Filled",
+					"Color",
+					"Light"
+				],
+				sizes: [
+					10,
+					12,
+					16,
+					20,
+					24,
+					28,
+					32,
+					48
+				],
+				default: { style: "Regular" }
+			}
+		},
+		tags: { files: "assets/*/metadata.json" }
+	}
+};
+function breakpointName(id) {
+	return {
+		xs: "Extra small",
+		sm: "Small",
+		md: "Medium",
+		lg: "Large",
+		xl: "XL"
+	}[id] ?? id.toUpperCase();
+}
+function muiCategory(name) {
+	if (name.startsWith("mui-palette-")) return "color";
+	if (name.startsWith("mui-shadows-")) return "shadow";
+	if (name === "mui-shape-borderRadius") return "radius";
+	if (name === "mui-spacing") return "spacing";
+	if (name.startsWith("mui-font-")) return "font";
+	if (name.startsWith("mui-zIndex-")) return "other";
+	return "other";
+}
+function chakraCategory(name, value) {
+	return {
+		colors: "color",
+		spacing: "spacing",
+		radii: "radius",
+		"font-sizes": "font-size",
+		fonts: "font",
+		"font-weights": "font-weight",
+		"letter-spacings": "tracking",
+		"line-heights": "leading",
+		shadows: "shadow",
+		breakpoints: "breakpoint",
+		sizes: "container",
+		durations: "motion",
+		easings: "motion"
+	}[/^chakra-([a-z]+(?:-[a-z]+)?)-/.exec(name)?.[1] ?? ""] ?? (/^(?:#|rgb|hsl|oklch|color-mix)/.test(value) ? "color" : "other");
+}
+function fluentCategory(name) {
+	if (name.startsWith("color")) return "color";
+	if (name.startsWith("spacing")) return "spacing";
+	if (name.startsWith("borderRadius")) return "radius";
+	if (name.startsWith("fontSize")) return "font-size";
+	if (name.startsWith("lineHeight")) return "leading";
+	if (name.startsWith("fontWeight")) return "font-weight";
+	if (name.startsWith("fontFamily")) return "font";
+	if (name.startsWith("shadow")) return "shadow";
+	if (name.startsWith("duration") || name.startsWith("curve")) return "motion";
+	return "other";
+}
+// ../libgen/src/tokens.ts
+/**
+* The category a custom property belongs in, from the words in its name, then its value: `--mantine-spacing-md` is
+* spacing, `--fontSizeBase300` a font size, and anything whose value is a colour a colour.
+*/
+function categorizeVar(name, value) {
+	const words = name.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase().split(/[-_]/);
+	const has = (...sequence) => words.some((_, index) => sequence.every((word, offset) => words[index + offset] === word));
+	if (has("breakpoint") || has("breakpoints") || has("screen")) return "breakpoint";
+	const textSize = words[0] === "text" && ![
+		"wrap",
+		"color",
+		"decoration",
+		"shadow"
+	].includes(words[1] ?? "");
+	if (has("font", "size") || has("font", "sizes") || textSize) return "font-size";
+	if (has("line", "height") || has("leading") || has("line", "heights")) return "leading";
+	if (has("font", "weight") || has("font", "weights")) return "font-weight";
+	if (has("letter", "spacing") || has("tracking")) return "tracking";
+	if (has("font", "family") || has("font") || has("fonts")) return "font";
+	if (has("radius") || has("radii") || has("rounded")) return "radius";
+	if (has("shadow") || has("shadows") || has("elevation")) return "shadow";
+	if (has("spacing") || has("space") || has("gap")) return "spacing";
+	if ([
+		"duration",
+		"easing",
+		"curve",
+		"ease",
+		"transition",
+		"animation",
+		"animate",
+		"delay"
+	].some((word) => has(word))) return "motion";
+	if (has("container") && !has("color")) return "container";
+	if (has("color") || has("colors") || has("palette") || isColor(value)) return "color";
+	return "other";
+}
+const colorValue = /^(?:#[\da-f]{3,8}|(?:rgba?|hsla?|oklch|oklab|lab|lch|hwb|color|color-mix|light-dark)\(|transparent$)/i;
+function isColor(value) {
+	return colorValue.test(value.trim());
+}
+/** A theme a selector belongs to: the root's defaults, or a dark theme however it's written. Anything else, none. */
+function themeOfSelector(selector, media = "") {
+	const parts = selector.split(",").map((part) => part.trim().replaceAll(/\s+/g, " "));
+	const dark = /prefers-color-scheme:\s*dark/.test(media);
+	const isRoot = (part) => /^(?::where\()?(?::root|:host|html)(?:\)|\s|$|\[|\.|,)/.test(part) || part === ":host";
+	const isDark = (part) => /(?:^|[.\s])dark(?:[\s.:[]|$)|\[[\w-]+=["']?dark["']?\]/.test(part);
+	const isLight = (part) => /(?:^|[.\s])light(?:[\s.:[]|$)|\[[\w-]+=["']?light["']?\]/.test(part);
+	if (parts.some(isDark)) return "dark";
+	if (parts.some((part) => isRoot(part) || isLight(part))) return dark ? "dark" : "default";
+}
+/** Splits CSS into nested blocks, each with its prelude and its own declarations. */
+function blocks(css) {
+	let index = 0;
+	const level = () => {
+		let text = "";
+		let declarations = "";
+		const children = [];
+		while (index < css.length) {
+			const char = css[index];
+			if (char === "/" && css[index + 1] === "*") {
+				const end = css.indexOf("*/", index + 2);
+				index = end === -1 ? css.length : end + 2;
+			} else if (char === "\"" || char === "'") {
+				const end = css.indexOf(char, index + 1);
+				text += css.slice(index, end === -1 ? css.length : end + 1);
+				index = end === -1 ? css.length : end + 1;
+			} else if (char === "{") {
+				index++;
+				const split = text.lastIndexOf(";") + 1;
+				declarations += text.slice(0, split);
+				const inner = level();
+				children.push({
+					prelude: text.slice(split).trim(),
+					...inner
+				});
+				text = "";
+			} else if (char === "}") {
+				index++;
+				return {
+					declarations: declarations + text,
+					children
+				};
+			} else {
+				text += char;
+				index++;
+			}
+		}
+		return {
+			declarations: declarations + text,
+			children
+		};
+	};
+	return level().children;
+}
+/**
+* The tokens a library's CSS defines: custom properties on the root, on a dark theme (a `.dark` class, a
+* `[data-…=dark]` attribute or a `prefers-color-scheme: dark` block), and in Tailwind's `@theme`. Properties scoped to
+* one component's class aren't tokens.
+*/
+function cssTokens(css) {
+	const tokens = /* @__PURE__ */ new Map();
+	const visit = (list, media) => {
+		for (const block of list) {
+			if (/^@theme\b/.test(block.prelude)) declarations(block.declarations, "default");
+			else if (block.prelude.startsWith("@")) {
+				visit(block.children, block.prelude.startsWith("@media") ? `${media} ${block.prelude}` : media);
+				continue;
+			} else {
+				const theme = themeOfSelector(block.prelude, media);
+				if (theme) declarations(block.declarations, theme);
+			}
+			visit(block.children, media);
+		}
+	};
+	const declarations = (text, theme) => {
+		for (const match of text.matchAll(/--([\w-]+)\s*:\s*([^;]+)/g)) {
+			const name = match[1];
+			const value = match[2].trim();
+			if (name.includes("--") || name.startsWith("tw-")) continue;
+			const token = tokens.get(name) ?? {
+				var: name,
+				category: categorizeVar(name, value),
+				values: {}
+			};
+			token.values[theme] = value;
+			tokens.set(name, token);
+		}
+		for (const match of text.matchAll(/--([\w-]+)--line-height\s*:\s*([^;]+)/g)) {
+			const token = tokens.get(match[1]);
+			if (token && !token.lineHeight) token.lineHeight = match[2].trim().replace(/^var\(--([\w-]+)\)$/, "$1");
+		}
+	};
+	visit(blocks(css), "");
+	return [...tokens.values()];
+}
+/**
+* Pairs each font size with the line height of the same step, as Parity's type controls do with Tailwind's
+* `--text-sm--line-height`: `--mantine-font-size-md` with `--mantine-line-height-md`, `fontSizeBase300` with
+* `lineHeightBase300`.
+*/
+function pairLineHeights(tokens) {
+	for (const token of tokens.values()) {
+		if (token.category !== "font-size" || token.lineHeight) continue;
+		const match = [
+			token.var.replace("font-size", "line-height"),
+			token.var.replace("fontSize", "lineHeight"),
+			token.var.replace(/^text-/, "leading-")
+		].find((name) => name !== token.var && tokens.get(name)?.category === "leading");
+		if (match) token.lineHeight = match;
+	}
+}
+/** Breakpoints from `--breakpoint-*` tokens, or any token in that category, in pixels at 16px to the rem. */
+function breakpointsOf(tokens) {
+	const names = {
+		xs: "Extra small",
+		sm: "Small",
+		md: "Medium",
+		lg: "Large",
+		xl: "XL"
+	};
+	const found = [];
+	for (const token of tokens) {
+		if (token.category !== "breakpoint" || !token.values.default) continue;
+		const width = lengthToPixels(token.values.default);
+		if (width === void 0 || width <= 0) continue;
+		const id = token.var.replace(/^.*breakpoints?-/, "");
+		found.push({
+			id,
+			name: names[id] ?? id.toUpperCase(),
+			width
+		});
+	}
+	return found.sort((a, b) => a.width - b.width);
+}
+/**
+* Tokens written as DTCG (2025.10): grouped by Parity's category, each naming its custom property in
+* `$extensions.parity`, so the Tokens panel puts `--mantine-spacing-md` under Spacing and frames can declare it. One
+* theme is a token file; several make a resolver whose `theme` modifier has a context for each.
+*/
+function toDtcg(tokens, prefix = "") {
+	const pathOf = /* @__PURE__ */ new Map();
+	const taken = /* @__PURE__ */ new Set();
+	for (const token of tokens) {
+		let path = [token.category, ...nameParts(token.var, prefix, token.category)];
+		if (path.length === 1 || taken.has(path.join("."))) path = [token.category, ...token.var.split("-").filter(Boolean)];
+		while (taken.has(path.join("."))) path = [...path.slice(0, -1), `${path.at(-1)}_`];
+		taken.add(path.join("."));
+		pathOf.set(token.var, path);
+	}
+	const contexts = [...new Set(tokens.flatMap((token) => Object.keys(token.values)))].filter((c) => c !== "default");
+	const groupsFor = (context) => {
+		const root = {};
+		for (const token of tokens) {
+			const value = token.values[context];
+			if (value === void 0 || context !== "default" && value === token.values.default) continue;
+			const path = pathOf.get(token.var);
+			let group = root;
+			for (const part of path.slice(0, -1)) group = group[part] ??= {};
+			const extension = { var: token.var };
+			if (token.lineHeight) extension.lineHeight = token.lineHeight;
+			group[path.at(-1)] = {
+				...dtcgValue(value, token.category, pathOf),
+				...token.description && context === "default" ? { $description: token.description } : {},
+				$extensions: { parity: extension }
+			};
+		}
+		return root;
+	};
+	if (contexts.length === 0) return groupsFor("default");
+	return {
+		version: "2025.10",
+		sets: { tokens: { sources: [groupsFor("default")] } },
+		modifiers: { theme: {
+			default: "default",
+			contexts: Object.fromEntries([["default", []], ...contexts.map((context) => [context, [groupsFor(context)]])])
+		} },
+		resolutionOrder: [{ $ref: "#/sets/tokens" }, { $ref: "#/modifiers/theme" }]
+	};
+}
+/** A token's name below its category: `mantine-spacing-md` is `md`, `colorNeutralBackground1` is `neutralBackground1`. */
+function nameParts(name, prefix, category) {
+	let rest = prefix && name.startsWith(prefix) ? name.slice(prefix.length) : name;
+	rest = rest.replace(/^-/, "");
+	return (rest.replace({
+		color: /^(?:colou?rs?|palette)[-_]?/i,
+		spacing: /^(?:spacing|space)[-_]?/i,
+		radius: /^(?:border-?radius|radius|radii|rounded)[-_]?/i,
+		"font-size": /^(?:font-?size|text)[-_]?/i,
+		font: /^(?:font-?family|fonts?)[-_]?/i,
+		"font-weight": /^font-?weight[-_]?/i,
+		tracking: /^(?:letter-?spacing|tracking)[-_]?/i,
+		leading: /^(?:line-?height|leading)[-_]?/i,
+		shadow: /^(?:shadows?|elevation)[-_]?/i,
+		breakpoint: /^(?:breakpoints?|screens?)[-_]?/i,
+		container: /^containers?[-_]?/i,
+		effect: /^$/,
+		motion: /^$/,
+		other: /^$/
+	}[category], "") || rest).split("-").filter(Boolean).map((part, index) => index === 0 ? part[0].toLowerCase() + part.slice(1) : part);
+}
+/** A CSS value as DTCG writes it, where DTCG can; anything else stays CSS, which Parity reads as written. */
+function dtcgValue(value, category, paths) {
+	const reference = /^var\(--([\w-]+)\)$/.exec(value.trim())?.[1];
+	if (reference && paths.has(reference)) return { $value: `{${paths.get(reference).join(".")}}` };
+	const hex = /^#([\da-f]{3,4}|[\da-f]{6}|[\da-f]{8})$/i.exec(value.trim())?.[1];
+	if (hex && category === "color") {
+		const full = hex.length <= 4 ? hex.split("").map((digit) => digit + digit).join("") : hex;
+		const channels = [
+			0,
+			2,
+			4
+		].map((at) => Math.round(parseInt(full.slice(at, at + 2), 16) / 255 * 1e3) / 1e3);
+		const alpha = full.length === 8 ? Math.round(parseInt(full.slice(6, 8), 16) / 255 * 1e3) / 1e3 : void 0;
+		return {
+			$type: "color",
+			$value: {
+				colorSpace: "srgb",
+				components: channels,
+				...alpha !== void 0 && alpha < 1 ? { alpha } : {},
+				hex: `#${full.slice(0, 6).toLowerCase()}`
+			}
+		};
+	}
+	const dimension = /^(-?\d*\.?\d+)(px|rem|em)$/.exec(value.trim());
+	if (dimension && [
+		"spacing",
+		"radius",
+		"font-size",
+		"breakpoint",
+		"tracking",
+		"container",
+		"leading"
+	].includes(category)) return {
+		$type: "dimension",
+		$value: {
+			value: Number(dimension[1]),
+			unit: dimension[2]
+		}
+	};
+	const duration = /^(-?\d*\.?\d+)(ms|s)$/.exec(value.trim());
+	if (duration && category === "motion") return {
+		$type: "duration",
+		$value: {
+			value: Number(duration[1]),
+			unit: duration[2]
+		}
+	};
+	if (/^-?\d*\.?\d+$/.test(value.trim())) {
+		const number = Number(value);
+		if (category === "font-weight") return {
+			$type: "fontWeight",
+			$value: number
+		};
+		return {
+			$type: "number",
+			$value: number
+		};
+	}
+	return { $value: value };
+}
+// ../libgen/src/index.ts
+/**
+* Describes a component library, an icon set or an app as a version 3 `.lib.par`: its components found with the type
+* checker, its tokens wherever it keeps them, written as DTCG in Parity's categories, its breakpoints, its icons' shape
+* and the decorators its components need.
+*/
+async function generateLibrary(options) {
+	return options.package ? describePackage(options, options.package) : describeApp(options);
+}
+async function describePackage(options, importName) {
+	const root = resolve(options.root);
+	const dir = await installedPackage(root, importName);
+	if (!dir) throw new Error(`${importName} isn't installed in ${root}. Install it with the project's package manager first.`);
+	const pkg = JSON.parse(await readFile(join(dir, "package.json"), "utf8"));
+	const name = pkg.name ?? importName;
+	const version = pkg.version ?? "0.0.0";
+	const preset = presets[name];
+	const notes = [...preset?.notes ?? []];
+	const iconImport = preset?.icons?.import;
+	const componentImport = iconImport ?? preset?.components;
+	const entry = typesEntry(dir, pkg, componentImport ? subpath(componentImport, name) : ".");
+	if (!entry) notes.push("No type declarations were found, so no components could be read.");
+	const scan = entry ? findComponents({
+		entries: [entry],
+		root
+	}) : {
+		components: [],
+		ambiguous: [],
+		rejected: [],
+		reactTypes: false
+	};
+	if (entry && !scan.reactTypes) notes.push("React's types (@types/react) aren't installed here; install them for exact results.");
+	const dataIcons = preset?.icons?.render !== void 0 && preset.icons.render !== "export";
+	const isIcons = preset?.icons !== void 0 || looksLikeIcons(scan);
+	const tokens = /* @__PURE__ */ new Map();
+	const styles = preset?.styles ?? stylesheetOf(dir, pkg);
+	if (styles) for (const token of cssTokens(await readCss(exportedFile(dir, pkg, styles)))) tokens.set(token.var, token);
+	let breakpoints;
+	if (preset?.theme) try {
+		const theme = await preset.theme(loader(root, dir));
+		for (const token of theme.tokens) tokens.set(token.var, token);
+		breakpoints = theme.breakpoints;
+	} catch (error) {
+		notes.push(`Its theme object couldn't be read: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	pairLineHeights(tokens);
+	const dtcgFile = await dtcgIn(dir);
+	breakpoints ??= breakpointsOf([...tokens.values()]);
+	const report = baseReport(isIcons ? "icons" : "components", scan, [...tokens.values()], notes);
+	report.package = {
+		name,
+		version
+	};
+	const manifest = {
+		version: 3,
+		id: options.id ?? preset?.id ?? name.replace(/^@[^/]+\//, "").replace(/^react-/, ""),
+		name: options.name ?? preset?.name ?? name,
+		...options.description ?? preset?.description ? { description: options.description ?? preset?.description } : {},
+		package: {
+			name,
+			version,
+			range: options.range ?? defaultRange(version)
+		}
+	};
+	if (styles && !isIcons) manifest.styles = styles;
+	if (breakpoints.length > 0) {
+		manifest.breakpoints = breakpoints;
+		report.breakpoints = breakpoints.length;
+	}
+	if (dtcgFile) {
+		manifest.tokens = dtcgFile.tokens;
+		notes.push(`Tokens are its own DTCG file, ${dtcgFile.path}.`);
+	} else if (tokens.size > 0) manifest.tokens = toDtcg([...tokens.values()], commonPrefix([...tokens.keys()]));
+	if (isIcons) {
+		const icons = { render: preset?.icons?.render ?? "export" };
+		if (iconImport) icons.import = iconImport;
+		if (preset?.icons?.match) icons.match = preset.icons.match;
+		if (!dataIcons) {
+			const notIcons = scan.components.filter((component) => component.requiredProps.length > 0 && !component.name.includes(".")).map((component) => component.name);
+			if (notIcons.length > 0) icons.exclude = notIcons;
+		}
+		if (preset?.icons?.variants) icons.variants = preset.icons.variants;
+		if (!dataIcons) {
+			const load = loader(root, dir);
+			const modules = await styleModules(name, typeof pkg.exports === "object" && pkg.exports !== null ? Object.keys(pkg.exports) : [], iconImport ?? name, load, await iconDrawer(load));
+			if (modules) {
+				const main = Object.keys(modules).find((style) => modules[style] === (iconImport ?? name));
+				icons.variants = {
+					...icons.variants,
+					modules,
+					styles: Object.keys(modules),
+					default: {
+						...icons.variants?.default,
+						style: main
+					}
+				};
+			}
+		}
+		const exported = await exportedIcons(loader(root, dir), iconImport ?? name, icons);
+		icons.count = exported.count;
+		const typesFile = typesFor(iconImport ?? name, root);
+		if (typesFile) {
+			const usable = icons.match ? new RegExp(icons.match) : /^[A-Z]/;
+			const prefer = preferredExports(typesFile, exported.groups, (candidate) => usable.test(candidate));
+			if (prefer.length > 0) icons.prefer = prefer;
+		}
+		if (preset?.tags && options.tags !== false) try {
+			const found = await readIconTags(preset.tags, {
+				name,
+				version
+			}, exported.icons);
+			if (found.matched > 0) {
+				icons.tags = found.tags;
+				icons.tagSource = found.source;
+			}
+			report.iconTags = {
+				matched: found.matched,
+				of: exported.icons.length,
+				source: found.source
+			};
+		} catch (error) {
+			notes.push(`Its tags weren't read: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		manifest.icons = icons;
+		report.icons = icons.count;
+		report.components = 0;
+	} else {
+		const providers = (preset?.decorators ?? []).flatMap((decorator) => decorator.wrap ? [decorator.wrap] : []);
+		let uses = /* @__PURE__ */ new Map();
+		let anatomy = /* @__PURE__ */ new Map();
+		let exampleFiles = [];
+		if (options.examples !== false) {
+			const fetched = await fetchExamples(pkg, dir, preset?.examples);
+			if (fetched.note) notes.push(fetched.note);
+			const componentNames = scan.components.map((component) => component.name);
+			exampleFiles = fetched.files;
+			const own = pkg.name ? await loader(root, dir)(pkg.name).then((module) => new Set(Object.keys(module).filter((key) => typeof module[key] === "function"))).catch(() => /* @__PURE__ */ new Set()) : /* @__PURE__ */ new Set();
+			uses = readExamples(fetched.files, componentNames, pkg.name, own);
+			anatomy = readAnatomy(fetched.docs ?? [], componentNames);
+			if (fetched.source) report.examples = {
+				...fetched.source,
+				used: uses.size
+			};
+		}
+		const names = scan.components.map((component) => component.name);
+		const calls = /* @__PURE__ */ new Map();
+		const made = /* @__PURE__ */ new Set();
+		const renders = await readRenders(dir, names, calls, made);
+		const listItem = new Set([...calls].flatMap(([part, list]) => list.some((call) => Object.values(call.props).some((passed) => "item" in passed)) ? [part] : [])).size > 0 ? exampleItem(exampleFiles, made) : void 0;
+		const parts = await relateParts(loader(root, dir), componentImport ?? name, scan.components, providers, options.trialEdits?.components, uses, renderedIn(renders), calls, listItem, options.appErrors);
+		if (parts.note) notes.push(parts.note);
+		const hosts = (preset?.decorators ?? []).flatMap((decorator) => decorator.add && !decorator.add.component.includes(".") ? [decorator.add.component] : []);
+		const drawnTree = new Set(parts.drawn);
+		if (hosts.length > 0) for (const hosted of hostedParts(renders, hosts, names)) {
+			if (uses.has(hosted)) continue;
+			const relation = parts.relations.get(hosted);
+			if (listItem && drawnTree.has(hosted) && !relation?.inside) continue;
+			parts.relations.set(hosted, {
+				...relation,
+				visual: false
+			});
+		}
+		const fromHook = [...uses].filter(([, use]) => use.fromHook).map(([part]) => part);
+		if (fromHook.length > 0) notes.push(`Drawn from a hook's list in every example, sampled with the item it's given: ${fromHook.join(", ")}`);
+		const owners = renderedIn(renders);
+		const internal = new Set(names.filter((part) => uses.size > 0 && !uses.has(part) && !anatomy.has(part) && !hosts.includes(part) && (owners.get(part) ?? []).some((owner) => owner !== part && names.includes(owner))));
+		const list = {};
+		for (const component of scan.components) {
+			const inside = component.file.startsWith(dir.replaceAll(sep, "/")) || component.file.startsWith(dir);
+			const relation = parts.relations.get(component.name);
+			list[component.name] = {
+				as: component.as,
+				...inside && exportsByName(component.file, component.name) ? { declaration: relativePath(dir, component.file) } : {},
+				group: component.group,
+				...relation?.parents ? {
+					parents: relation.parents,
+					parentsFrom: relation.parentsFrom ?? "prefix"
+				} : {},
+				...relation?.optionalParents ? { optionalParents: relation.optionalParents } : {},
+				...relation?.parentParts ? { parentParts: true } : {},
+				...relation?.visual === false ? { visual: false } : {},
+				...internal.has(component.name) ? { internal: true } : {},
+				...relation?.sample ? { sample: relation.sample } : {},
+				fingerprint: component.fingerprint,
+				...Object.keys(component.props).length > 0 ? { props: component.props } : {}
+			};
+		}
+		if (parts.tried) report.parts = summarizeParts(parts.relations);
+		if (anatomy.size > 0) report.anatomy = checkAnatomy(anatomy, list);
+		if (Object.keys(list).length > 0) manifest.components = {
+			...componentImport ? { import: componentImport } : {},
+			list
+		};
+	}
+	if (preset?.decorators?.length) {
+		manifest.decorators = preset.decorators;
+		report.decorators = preset.decorators.map(describeDecorator);
+	}
+	parseLibraryManifest(manifest);
+	return reviseLibrary({
+		manifest,
+		report
+	}, options);
+}
+/**
+* Lays a freshly generated file over the one it replaces: reports which components are new, changed and removed,
+* keeps the old entries `only` leaves alone, and carries the hand edits over (or points at shared ones), reporting
+* any whose export has gone. Edits are never dropped silently.
+*/
+async function reviseLibrary(generated, options) {
+	const manifest = { ...generated.manifest };
+	const report = { ...generated.report };
+	const previous = previousComponents(options.previous);
+	const components = manifest.components;
+	if (previous && components) {
+		report.changes = compareComponents(previous, components.list);
+		manifest.components = {
+			...components,
+			list: selectComponents(previous, components.list, report.changes, options.only ?? "all")
+		};
+	}
+	const kept = options.previous?.edits;
+	const edits = options.edits ?? kept;
+	if (edits !== void 0) {
+		manifest.edits = edits;
+		const resolved = parseLibraryEdits(typeof edits === "string" ? parseJsonc(await readFile(resolve(options.editsBase ?? options.root, edits), "utf8")) : edits);
+		const { orphans } = applyLibraryEdits(parseLibraryManifest(manifest), resolved);
+		if (orphans.length > 0) report.orphanEdits = orphans;
+	}
+	return {
+		manifest,
+		report
+	};
+}
+function previousComponents(previous) {
+	if (typeof previous !== "object" || previous === null) return void 0;
+	try {
+		return parseLibraryManifest(previous).components?.list;
+	} catch {
+		return;
+	}
+}
+/**
+* What changed between two versions of a library's components, by fingerprint: new, removed, and changed ones with the
+* props added, removed or retyped. A file written before fingerprints counts every component as changed.
+*/
+function compareComponents(before, after) {
+	const changes = {
+		added: [],
+		changed: [],
+		removed: [],
+		unchanged: 0
+	};
+	for (const [name, now] of Object.entries(after)) {
+		const then = before[name];
+		if (!then) changes.added.push(name);
+		else if (then.fingerprint && then.fingerprint === now.fingerprint) changes.unchanged++;
+		else {
+			const old = propTypes(then.props);
+			const fresh = propTypes(now.props);
+			changes.changed.push({
+				name,
+				added: [...fresh.keys()].filter((prop) => !old.has(prop)),
+				removed: [...old.keys()].filter((prop) => !fresh.has(prop)),
+				retyped: [...fresh.keys()].filter((prop) => old.has(prop) && old.get(prop) !== fresh.get(prop)),
+				...then.as === now.as ? {} : { as: `${then.as} to ${now.as}` }
+			});
+		}
+	}
+	changes.removed = Object.keys(before).filter((name) => !(name in after));
+	return changes;
+}
+/** Each prop by name, without the `?` that marks it optional, to its type hash and whether it's optional. */
+function propTypes(props) {
+	return new Map(Object.entries(props ?? {}).map(([prop, kind]) => [prop.endsWith("?") ? prop.slice(0, -1) : prop, prop.endsWith("?") ? `${kind}?` : kind]));
+}
+/**
+* The components to write: every one found (`all`), or the file as it was plus new components (`new`) or plus
+* these named ones. Components the package no longer has are dropped either way, since they can't be imported.
+*/
+function selectComponents(before, after, changes, only) {
+	if (only === "all") return after;
+	const picked = new Set(only === "new" ? changes.added : only);
+	const list = {};
+	for (const name of Object.keys(after)) {
+		const chosen = picked.has(name) ? after[name] : before[name];
+		if (chosen) list[name] = chosen;
+	}
+	return list;
+}
+function summarizeParts(relations) {
+	const summary = {
+		failedAlone: 0,
+		parents: {},
+		fixed: 0,
+		failing: [],
+		notVisual: 0
+	};
+	for (const [name, relation] of relations) {
+		if (relation.visual === false) summary.notVisual++;
+		if (relation.parentsFrom) summary.parents[relation.parentsFrom] = (summary.parents[relation.parentsFrom] ?? 0) + 1;
+		if (!relation.alone || relation.visual === false) continue;
+		summary.failedAlone++;
+		if (relation.inside) summary.failing.push({
+			name,
+			error: relation.inside
+		});
+		else summary.fixed++;
+	}
+	return summary;
+}
+async function describeApp(options) {
+	const root = resolve(options.root);
+	const pkg = JSON.parse(await readFile(join(root, "package.json"), "utf8"));
+	const notes = [];
+	const config = appConfig(root);
+	if (!config) notes.push("No tsconfig.json or jsconfig.json, so every .tsx and .jsx file under src was read.");
+	const scan = findComponents({
+		entries: (config?.fileNames ?? await sourceFiles(join(root, "src"))).filter((file) => /\.[jt]sx$/.test(file) && !/\.(stories|test|spec)\.[jt]sx$/.test(file) && !file.includes("/node_modules/")),
+		root,
+		...config ? { compilerOptions: config.options } : {},
+		defaultExports: true
+	});
+	const counts = /* @__PURE__ */ new Map();
+	for (const component of scan.components) counts.set(component.name, (counts.get(component.name) ?? 0) + 1);
+	const list = {};
+	for (const component of scan.components) {
+		const folder = basename(dirname(component.file));
+		const id = (counts.get(component.name) ?? 0) > 1 ? `${folder}/${component.name}` : component.name;
+		list[id] = {
+			as: component.as,
+			declaration: relativePath(root, component.file),
+			group: component.group
+		};
+	}
+	const tokens = /* @__PURE__ */ new Map();
+	for (const stylesheet of await appStylesheets(root)) for (const token of cssTokens(await readCss(join(root, stylesheet)))) tokens.set(token.var, token);
+	pairLineHeights(tokens);
+	const breakpoints = breakpointsOf([...tokens.values()]);
+	const name = pkg.name ?? basename(root);
+	const manifest = {
+		version: 3,
+		id: options.id ?? name.replace(/^@[^/]+\//, ""),
+		name: options.name ?? name,
+		...options.description ? { description: options.description } : {},
+		...breakpoints.length > 0 ? { breakpoints } : {},
+		...tokens.size > 0 ? { tokens: toDtcg([...tokens.values()]) } : {},
+		...Object.keys(list).length > 0 ? { components: { list } } : {}
+	};
+	const report = baseReport("app", scan, [...tokens.values()], notes);
+	report.breakpoints = breakpoints.length;
+	parseLibraryManifest(manifest);
+	return {
+		manifest,
+		report
+	};
+}
+/**
+* Where an app's `.lib.par` goes: an existing one at its root, else `<package name>.lib.par`. Writing it there makes
+* the app a library Parity opens on the canvas.
+*/
+async function appManifestPath(root) {
+	const existing = (await readdir(root)).find((file) => file.endsWith(libraryManifestExtension));
+	if (existing) return join(root, existing);
+	const pkg = JSON.parse(await readFile(join(root, "package.json"), "utf8"));
+	return join(root, `${(pkg.name ?? basename(root)).replace(/^@[^/]+\//, "")}${libraryManifestExtension}`);
+}
+/**
+* A generated manifest laid over the file already there: what generating finds replaces what it found before, and
+* what a person wrote (the canvas, decorators, a name or description) stays.
+*/
+function mergeManifest(existing, generated) {
+	if (typeof existing !== "object" || existing === null) return generated;
+	const kept = existing;
+	const authored = [
+		"$schema",
+		"id",
+		"name",
+		"description",
+		"decorators",
+		"edits",
+		"canvas"
+	];
+	const merged = { ...generated };
+	for (const key of authored) if (kept[key] !== void 0) merged[key] = kept[key];
+	return merged;
+}
+function baseReport(kind, scan, tokens, notes) {
+	const counts = {};
+	for (const token of tokens) counts[token.category] = (counts[token.category] ?? 0) + 1;
+	return {
+		kind,
+		components: scan.components.length,
+		ambiguous: scan.ambiguous,
+		rejected: scan.rejected.length,
+		tokens: counts,
+		themes: [...new Set(tokens.flatMap((token) => Object.keys(token.values)))].filter((theme) => theme !== "default"),
+		breakpoints: 0,
+		decorators: [],
+		providers: scan.components.map((component) => component.name).filter((name) => /(?:Provider|Toaster|Toast\.Viewport|Notifications)$/.test(name)).filter((name) => !/(?:Props|Root|Node|Adapter)Provider$/.test(name)),
+		notes
+	};
+}
+function describeDecorator(decorator) {
+	const when = decorator.when ? ` when ${Object.entries(decorator.when).map(([key, value]) => `${key} is ${value}`).join(" and ")}` : "";
+	if (decorator.wrap) return `wraps in ${decorator.wrap.component} from ${decorator.wrap.import}${when}`;
+	if (decorator.add) return `adds ${decorator.add.component} from ${decorator.add.import}${when}`;
+	if (decorator.class !== void 0) return `adds a class to the frame${when}`;
+	if (decorator.attributes) return `sets ${Object.keys(decorator.attributes).join(", ")} on the frame${when}`;
+	return `styles the frame${when}`;
+}
+/**
+* Whether a package is an icon set: hundreds of components that take no required props and nearly all share one type,
+* as Lucide's `LucideIcon` or Fluent's `FluentIcon`. A component library's components each have their own props.
+*/
+function looksLikeIcons(scan) {
+	if (scan.components.length < 200) return false;
+	const types = /* @__PURE__ */ new Map();
+	for (const component of scan.components) if (component.requiredProps.length === 0) types.set(component.type, (types.get(component.type) ?? 0) + 1);
+	return Math.max(0, ...types.values()) / scan.components.length > .9;
+}
+/** `^9.0.0` for 9.5.0, and `^0.4.0` for 0.4.1, since a 0.x minor can break. */
+function defaultRange(version) {
+	const [major = "0", minor = "0"] = version.split(/[.-]/);
+	return major === "0" ? `^0.${minor}.0` : `^${major}.0.0`;
+}
+function subpath(specifier, packageName) {
+	return specifier === packageName ? "." : `.${specifier.slice(packageName.length)}`;
+}
+/** The type declarations for one of a package's entry points, from `exports`, else `types`, else `index.d.ts`. */
+function typesEntry(dir, pkg, entry) {
+	const exported = typeof pkg.exports === "object" && pkg.exports !== null ? pkg.exports : {};
+	const condition = (value) => {
+		if (typeof value === "string") return /\.d\.[cm]?ts$/.test(value) ? value : void 0;
+		if (typeof value !== "object" || value === null) return void 0;
+		const record = value;
+		for (const key of [
+			"types",
+			"import",
+			"default",
+			"require"
+		]) {
+			const found = condition(record[key]);
+			if (found) return found;
+		}
+	};
+	const candidates = [
+		condition(exported[entry]),
+		entry === "." ? pkg.types ?? pkg.typings : void 0,
+		entry === "." ? "index.d.ts" : `${entry.slice(2)}/index.d.ts`,
+		entry === "." ? void 0 : `${entry.slice(2)}.d.ts`
+	];
+	for (const candidate of candidates) if (candidate && existsSync(join(dir, candidate))) return join(dir, candidate).replaceAll("\\", "/");
+}
+/** The stylesheet a project imports to use a package: its `style` field, else the CSS its `exports` list first. */
+function stylesheetOf(dir, pkg) {
+	if (pkg.style && existsSync(join(dir, pkg.style))) return pkg.style;
+	const css = (typeof pkg.exports === "object" && pkg.exports !== null ? Object.keys(pkg.exports) : []).filter((key) => key.endsWith(".css")).map((key) => key.slice(2));
+	const pick = [
+		"tailwind.css",
+		"styles.css",
+		"style.css",
+		"index.css",
+		"theme.css"
+	].find((name) => css.includes(name)) ?? css[0];
+	if (!pick) return void 0;
+	const target = pkg.exports[`./${pick}`];
+	const file = typeof target === "string" ? target : target?.default;
+	return typeof file === "string" && existsSync(join(dir, file)) ? pick : void 0;
+}
+/** The file an export such as `tailwind.css` points at: `dist/tailwind.css` for Buildkit's styles. */
+function exportedFile(dir, pkg, specifier) {
+	const target = (typeof pkg.exports === "object" && pkg.exports !== null ? pkg.exports : {})[`./${specifier}`];
+	const file = typeof target === "string" ? target : target?.default;
+	return join(dir, typeof file === "string" ? file : specifier);
+}
+/** A stylesheet with its relative `@import`s inlined, so a Tailwind entry brings its theme file with it. */
+async function readCss(path, seen = /* @__PURE__ */ new Set()) {
+	if (seen.has(path)) return "";
+	seen.add(path);
+	const source = await readFile(path, "utf8").catch(() => "");
+	const parts = [];
+	let last = 0;
+	for (const match of source.matchAll(/@import\s+(?:url\()?["'](\.{1,2}\/[^"']+\.css)["']\)?[^;]*;/g)) {
+		parts.push(source.slice(last, match.index), await readCss(join(dirname(path), match[1]), seen));
+		last = match.index + match[0].length;
+	}
+	parts.push(source.slice(last));
+	return parts.join("");
+}
+/** A DTCG token file the package ships, if it has one in the format; Buildkit's `tokens.json` isn't yet. */
+async function dtcgIn(dir) {
+	for (const candidate of [
+		"tokens.json",
+		"dist/tokens.json",
+		"tokens.resolver.json",
+		"dist/tokens.resolver.json"
+	]) {
+		const text = await readFile(join(dir, candidate), "utf8").catch(() => void 0);
+		if (!text) continue;
+		try {
+			const parsed = JSON.parse(text);
+			if (Array.isArray(parsed.resolutionOrder) || /"\$value"\s*:/.test(text)) return {
+				path: candidate,
+				tokens: parsed
+			};
+		} catch {}
+	}
+}
+/** The prefix most custom properties share, as in `mantine-`, which token paths leave out. */
+function commonPrefix(names) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const name of names) {
+		const first = /^([a-z]+)-/.exec(name)?.[1];
+		if (first) counts.set(first, (counts.get(first) ?? 0) + 1);
+	}
+	const [best, count] = [...counts].sort((a, b) => b[1] - a[1])[0] ?? ["", 0];
+	return count / Math.max(names.length, 1) > .5 ? `${best}-` : "";
+}
+/**
+* A set's icons as the Icons panel lists them: its matching exports, each alias of one icon (Lucide's `Heart` and
+* `HeartIcon`) once, counted, and grouped by label with every name each is exported under, for matching tags. The
+* package is loaded to tell aliases apart, since types can't.
+*/
+async function exportedIcons(load, specifier, icons) {
+	const module = await load(specifier).catch(() => ({}));
+	const pattern = icons.match ? new RegExp(icons.match) : /^[A-Z]/;
+	const excluded = new Set(icons.exclude);
+	const drawable = (value) => icons.render !== "export" ? value !== void 0 && typeof value !== "function" : typeof value === "function" || typeof value === "object" && value !== null && "$$typeof" in value;
+	const byValue = /* @__PURE__ */ new Map();
+	for (const [key, value] of Object.entries(module)) {
+		if (!/^[A-Z]/.test(key) || excluded.has(key) || !drawable(value)) continue;
+		const names = byValue.get(value);
+		if (names) names.push(key);
+		else byValue.set(value, [key]);
+	}
+	const kept = [...byValue.values()].flatMap((names) => {
+		const name = names.filter((candidate) => pattern.test(candidate)).sort((a, b) => a.length - b.length || byCodeUnit(a, b))[0];
+		return name ? [{
+			name,
+			names
+		}] : [];
+	});
+	const read = icons.variants?.pattern ? iconVariants(kept.map(({ name }) => name), icons.variants) : void 0;
+	const byLabel = /* @__PURE__ */ new Map();
+	for (const { name, names } of kept) {
+		const label = read?.get(name)?.label ?? name;
+		const all = byLabel.get(label) ?? /* @__PURE__ */ new Set();
+		for (const each of names) all.add(each);
+		byLabel.set(label, all);
+	}
+	return {
+		count: kept.length,
+		icons: [...byLabel].map(([label, names]) => ({
+			label,
+			names: [...names]
+		})),
+		groups: kept.map(({ names }) => names)
+	};
+}
+/** Compares two strings by their UTF-16 code units, as `sort` does without a comparer. */
+function byCodeUnit(a, b) {
+	if (a < b) return -1;
+	return a > b ? 1 : 0;
+}
+/** Draws an icon with the project's own React, to tell a set's styles apart; nothing draws where React can't load. */
+async function iconDrawer(load) {
+	try {
+		const React = await load("react");
+		const server = await load("react-dom/server");
+		const createElement = React.createElement ?? React.default?.createElement;
+		const renderToStaticMarkup = server.renderToStaticMarkup ?? server.default?.renderToStaticMarkup;
+		if (typeof createElement !== "function" || typeof renderToStaticMarkup !== "function") return () => void 0;
+		return (component) => {
+			try {
+				return renderToStaticMarkup(createElement(component));
+			} catch {
+				return;
+			}
+		};
+	} catch {
+		return () => void 0;
+	}
+}
+/** Whether a declaration file exports a name directly, so the props reader can find it there. */
+function exportsByName(file, name) {
+	if (name.includes(".")) return false;
+	const source = ts.sys.readFile(file) ?? "";
+	return new RegExp(`export\\s+(?:declare\\s+)?(?:const|function|class|let|var)\\s+${name}\\b|export\\s*\\{[^}]*\\b${name}\\b`).test(source);
+}
+/**
+* Imports a module from the project, as the project's code would, for reading theme objects and counting icons.
+* Packages a library depends on, such as Fluent's `@fluentui/tokens`, may only be reachable from the library itself.
+*/
+function loader(root, packageDir) {
+	return async (specifier) => {
+		for (const from of [root, packageDir]) {
+			const esm = await resolveImport(from, specifier);
+			const cjs = resolveRequire(from, specifier);
+			const path = esm ?? cjs;
+			if (!path) continue;
+			try {
+				return await import(pathToFileURL(path).href);
+			} catch (error) {
+				if (!cjs || cjs === path) throw error;
+				return await import(pathToFileURL(cjs).href);
+			}
+		}
+		throw new Error(`Can't find ${specifier} from ${root}`);
+	};
+}
+function resolveRequire(from, specifier) {
+	try {
+		return createRequire(join(from, "package.json")).resolve(specifier);
+	} catch {
+		return;
+	}
+}
+/** An ESM-only package's entry, from the `import` condition of its `exports`, which `require` can't see. */
+async function resolveImport(from, specifier) {
+	const name = specifier.startsWith("@") ? specifier.split("/").slice(0, 2).join("/") : specifier.split("/")[0];
+	const dir = await installedPackage(from, name);
+	if (!dir) return void 0;
+	const pkg = JSON.parse(await readFile(join(dir, "package.json"), "utf8"));
+	const exported = typeof pkg.exports === "object" && pkg.exports !== null ? pkg.exports : {};
+	const pick = (value) => {
+		if (typeof value === "string") return /\.d\.[cm]?ts$/.test(value) ? void 0 : value;
+		if (typeof value !== "object" || value === null) return void 0;
+		const record = value;
+		for (const key of [
+			"node",
+			"import",
+			"default"
+		]) {
+			const found = pick(record[key]);
+			if (found) return found;
+		}
+	};
+	const file = pick(exported[subpath(specifier, name)]) ?? (specifier === name ? pkg.module : void 0);
+	return file ? join(dir, file) : void 0;
+}
+function appConfig(root) {
+	for (const name of [
+		"tsconfig.app.json",
+		"tsconfig.json",
+		"jsconfig.json"
+	]) {
+		const path = join(root, name);
+		if (!existsSync(path)) continue;
+		const parsed = ts.getParsedCommandLineOfConfigFile(path, {}, {
+			...ts.sys,
+			onUnRecoverableConfigFileDiagnostic: () => void 0
+		});
+		if (parsed && parsed.fileNames.length > 0) return parsed;
+	}
+}
+async function sourceFiles(folder) {
+	const entries = await readdir(folder, { withFileTypes: true }).catch(() => []);
+	const files = [];
+	for (const entry of entries) {
+		const path = join(folder, entry.name).replaceAll("\\", "/");
+		if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") files.push(...await sourceFiles(path));
+		else if (/\.[jt]sx?$/.test(entry.name)) files.push(path);
+	}
+	return files;
+}
+/** An app's global stylesheets: shadcn's `components.json` names one; otherwise the usual places. */
+async function appStylesheets(root) {
+	const shadcn = await readFile(join(root, "components.json"), "utf8").then((text) => JSON.parse(text), () => void 0);
+	if (shadcn?.tailwind?.css) return [shadcn.tailwind.css];
+	return [
+		"src/index.css",
+		"src/styles.css",
+		"src/app.css",
+		"src/globals.css",
+		"app/globals.css"
+	].filter((path) => existsSync(join(root, path)));
+}
+export { appManifestPath, generateLibrary, manifestText, mergeManifest, parseLibraryEdits, reviseLibrary, iconVariants as t };