@parity-app/cli 0.0.0-stage → 0.0.0

package/dist/src-CSeISXoZ.mjs

@@ -0,0 +1,1298 @@
+// ../core/src/css.ts
+/**
+* Custom properties holding 1% of a frame's viewport width and height, which viewport units are rewritten to: in a frame,
+* `100vh` is the height of the screen the frame stands for, not of Parity's window.
+*/
+const viewportWidthProperty = "--canvas-vw";
+const viewportHeightProperty = "--canvas-vh";
+new RegExp(String.raw`"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|url\([^)]*\)|var\((?:${viewportWidthProperty}|${viewportHeightProperty}),[^)]*\)`, "g");
+// ../core/src/devices.ts
+const deviceKinds = [
+	"phone",
+	"tablet",
+	"laptop",
+	"desktop"
+];
+/**
+* A CSS length in pixels, for breakpoints written in rem or em (16px each, the browser default) or px. Undefined for
+* anything else.
+*/
+function lengthToPixels(value) {
+	const match = /^\s*(-?[\d.]+)(px|rem|em)?\s*$/.exec(value);
+	if (!match) return void 0;
+	const number = Number(match[1]);
+	if (!Number.isFinite(number)) return void 0;
+	return match[2] === "rem" || match[2] === "em" ? number * 16 : number;
+}
+// ../core/src/validate.ts
+function expectObject(value, path) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new TypeError(`${path || "/"}: expected an object`);
+	return value;
+}
+function expectString(value, path) {
+	if (typeof value !== "string") throw new TypeError(`${path}: expected a string`);
+	return value;
+}
+function expectNumber(value, path) {
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new TypeError(`${path}: expected a number`);
+	return value;
+}
+function expectBoolean(value, path) {
+	if (typeof value !== "boolean") throw new TypeError(`${path}: expected true or false`);
+	return value;
+}
+function expectArray(value, path) {
+	if (!Array.isArray(value)) throw new TypeError(`${path}: expected an array`);
+	return value;
+}
+function expectOneOf(value, options, path) {
+	if (typeof value !== "string" || !options.includes(value)) throw new TypeError(`${path}: expected one of ${options.map((option) => `"${option}"`).join(", ")}`);
+	return value;
+}
+function optional(value, parse) {
+	return value === void 0 ? void 0 : parse(value);
+}
+/** Drops `undefined` entries, so parsed patches can be spread over defaults without erasing them. */
+function compact(value) {
+	return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
+}
+function expectKnownKeys(value, keys, path) {
+	for (const key of Object.keys(value)) if (!keys.includes(key)) throw new TypeError(`${path}/${key}: unknown property`);
+}
+// ../core/src/modes.ts
+const variableKinds = [
+	"viewport",
+	"theme",
+	"locale",
+	"custom"
+];
+function parseModeSettings(value) {
+	const settings = expectObject(value, "");
+	expectKnownKeys(settings, [
+		"$schema",
+		"version",
+		"variables",
+		"modes"
+	], "");
+	if (settings.version !== 1) throw new TypeError("/version: expected 1");
+	const variables = expectArray(settings.variables, "/variables").map((item, index) => {
+		const at = `/variables/${index}`;
+		const variable = expectObject(item, at);
+		expectKnownKeys(variable, [
+			"id",
+			"name",
+			"kind",
+			"options"
+		], at);
+		const options = expectArray(variable.options, `${at}/options`).map((entry, optionIndex) => {
+			const optionAt = `${at}/options/${optionIndex}`;
+			const option = expectObject(entry, optionAt);
+			expectKnownKeys(option, [
+				"id",
+				"name",
+				"width",
+				"height",
+				"device",
+				"className",
+				"attributes"
+			], optionAt);
+			return compact({
+				id: expectString(option.id, `${optionAt}/id`),
+				name: expectString(option.name, `${optionAt}/name`),
+				width: optional(option.width, (v) => expectNumber(v, `${optionAt}/width`)),
+				height: optional(option.height, (v) => expectNumber(v, `${optionAt}/height`)),
+				device: optional(option.device, (v) => expectOneOf(v, deviceKinds, `${optionAt}/device`)),
+				className: optional(option.className, (v) => expectString(v, `${optionAt}/className`)),
+				attributes: optional(option.attributes, (v) => {
+					const attributes = expectObject(v, `${optionAt}/attributes`);
+					for (const [name, attribute] of Object.entries(attributes)) expectString(attribute, `${optionAt}/attributes/${name}`);
+					return attributes;
+				})
+			});
+		});
+		if (options.length === 0) throw new TypeError(`${at}/options: expected at least one option`);
+		return {
+			id: expectString(variable.id, `${at}/id`),
+			name: expectString(variable.name, `${at}/name`),
+			kind: expectOneOf(variable.kind, variableKinds, `${at}/kind`),
+			options
+		};
+	});
+	const modes = expectArray(settings.modes, "/modes").map((item, index) => {
+		const at = `/modes/${index}`;
+		const mode = expectObject(item, at);
+		expectKnownKeys(mode, [
+			"id",
+			"name",
+			"values"
+		], at);
+		const values = {};
+		for (const [variableId, optionId] of Object.entries(expectObject(mode.values, `${at}/values`))) {
+			const variable = variables.find((candidate) => candidate.id === variableId);
+			if (!variable) throw new TypeError(`${at}/values/${variableId}: unknown variable`);
+			const option = expectString(optionId, `${at}/values/${variableId}`);
+			if (!variable.options.some((candidate) => candidate.id === option)) throw new TypeError(`${at}/values/${variableId}: "${option}" is not an option of ${variable.name}`);
+			values[variableId] = option;
+		}
+		return {
+			id: expectString(mode.id, `${at}/id`),
+			name: expectString(mode.name, `${at}/name`),
+			values
+		};
+	});
+	if (modes.length === 0) throw new TypeError("/modes: expected at least one mode");
+	return {
+		version: 1,
+		variables,
+		modes
+	};
+}
+// ../core/src/edit.ts
+const idAlphabet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+/** A short random id that isn't in `taken`, for nodes and designs created in the editor or by agents. */
+function generateId(taken, length = 5) {
+	for (;;) {
+		let id = idAlphabet[Math.floor(Math.random() * 52)];
+		while (id.length < length) id += idAlphabet[Math.floor(Math.random() * 62)];
+		if (!taken.has(id)) return id;
+	}
+}
+// ../core/src/document.ts
+const textTags = [
+	"p",
+	"span",
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"strong"
+];
+const imageFits = [
+	"cover",
+	"contain",
+	"fill"
+];
+const paramTypes = [
+	"text",
+	"boolean",
+	"number",
+	"value",
+	"variant"
+];
+const alignments = [
+	"start",
+	"center",
+	"end",
+	"stretch"
+];
+const justifications = [
+	"start",
+	"center",
+	"end",
+	"between",
+	"around",
+	"evenly"
+];
+/** Every style key, in the order panels show them. */
+const styleKeys = [
+	"display",
+	"direction",
+	"columns",
+	"rows",
+	"gap",
+	"rowGap",
+	"padding",
+	"margin",
+	"align",
+	"justify",
+	"wrap",
+	"width",
+	"height",
+	"minWidth",
+	"maxWidth",
+	"minHeight",
+	"maxHeight",
+	"colSpan",
+	"rowSpan",
+	"grow",
+	"self",
+	"position",
+	"top",
+	"right",
+	"bottom",
+	"left",
+	"background",
+	"foreground",
+	"border",
+	"borderWidth",
+	"borderStyle",
+	"radius",
+	"shadow",
+	"opacity",
+	"overflow",
+	"font",
+	"size",
+	"weight",
+	"leading",
+	"tracking",
+	"textAlign",
+	"transform",
+	"decoration",
+	"italic",
+	"lines"
+];
+function parseCanvasDocument(value) {
+	const document = expectObject(value, "");
+	if (document.version !== 3) throw new TypeError("/version: expected 3");
+	expectKnownKeys(document, [
+		"version",
+		"containers",
+		"notes",
+		"modes",
+		"detection"
+	], "");
+	return compact({
+		version: 3,
+		containers: expectArray(document.containers, "/containers").map((item, index) => parseContainer(item, `/containers/${index}`)),
+		modes: optional(document.modes, (value) => parseModeSettings(value)),
+		notes: optional(document.notes, (value) => expectArray(value, "/notes").map((item, index) => parseNote(item, `/notes/${index}`))),
+		detection: optional(document.detection, (value) => parseDetection(value, "/detection"))
+	});
+}
+function parseDetection(value, path) {
+	const detection = expectObject(value, path);
+	expectKnownKeys(detection, ["include", "exclude"], path);
+	const refs = (list, at) => expectArray(list, at).map((item, index) => {
+		const ref = expectObject(item, `${at}/${index}`);
+		expectKnownKeys(ref, ["path", "export"], `${at}/${index}`);
+		return {
+			path: expectString(ref.path, `${at}/${index}/path`),
+			export: expectString(ref.export, `${at}/${index}/export`)
+		};
+	});
+	return compact({
+		include: optional(detection.include, (list) => refs(list, `${path}/include`)),
+		exclude: optional(detection.exclude, (list) => refs(list, `${path}/exclude`))
+	});
+}
+function parseNote(value, path) {
+	const note = expectObject(value, path);
+	expectKnownKeys(note, [
+		"id",
+		"text",
+		"position",
+		"width"
+	], path);
+	const position = expectObject(note.position, `${path}/position`);
+	return compact({
+		id: expectString(note.id, `${path}/id`),
+		text: expectString(note.text, `${path}/text`),
+		position: {
+			x: expectNumber(position.x, `${path}/position/x`),
+			y: expectNumber(position.y, `${path}/position/y`)
+		},
+		width: optional(note.width, (v) => expectNumber(v, `${path}/width`))
+	});
+}
+function parseContainer(value, path) {
+	const container = expectObject(value, path);
+	expectKnownKeys(container, [
+		"id",
+		"name",
+		"kind",
+		"position",
+		"root",
+		"states",
+		"view",
+		"params",
+		"context",
+		"frames"
+	], path);
+	const position = expectObject(container.position, `${path}/position`);
+	const view = optional(container.view, (v) => {
+		const settings = expectObject(v, `${path}/view`);
+		expectKnownKeys(settings, [
+			"mode",
+			"modes",
+			"state",
+			"allStates",
+			"variants"
+		], `${path}/view`);
+		return compact({
+			mode: optional(settings.mode, (mode) => expectString(mode, `${path}/view/mode`)),
+			modes: optional(settings.modes, (list) => expectArray(list, `${path}/view/modes`).map((mode, index) => expectString(mode, `${path}/view/modes/${index}`))),
+			state: optional(settings.state, (state) => expectString(state, `${path}/view/state`)),
+			allStates: optional(settings.allStates, (all) => expectBoolean(all, `${path}/view/allStates`)),
+			variants: optional(settings.variants, (choices) => {
+				const variants = {};
+				for (const [param, option] of Object.entries(expectObject(choices, `${path}/view/variants`))) variants[param] = expectString(option, `${path}/view/variants/${param}`);
+				return variants;
+			})
+		});
+	});
+	const ids = /* @__PURE__ */ new Set();
+	const root = parseNode(container.root, `${path}/root`, ids);
+	const states = expectArray(container.states, `${path}/states`).map((item, index) => {
+		const at = `${path}/states/${index}`;
+		const state = expectObject(item, at);
+		expectKnownKeys(state, [
+			"id",
+			"name",
+			"overrides"
+		], at);
+		return {
+			id: expectString(state.id, `${at}/id`),
+			name: expectString(state.name, `${at}/name`),
+			overrides: optional(state.overrides, (v) => parsePatches(v, `${at}/overrides`, ids))
+		};
+	});
+	if (states.length === 0) throw new TypeError(`${path}/states: expected at least one state`);
+	return compact({
+		id: expectString(container.id, `${path}/id`),
+		name: expectString(container.name, `${path}/name`),
+		kind: optional(container.kind, (v) => expectOneOf(v, ["screen", "component"], `${path}/kind`)),
+		context: optional(container.context, (v) => expectArray(v, `${path}/context`).map((item, index) => {
+			const at = `${path}/context/${index}`;
+			const wrapper = expectObject(item, at);
+			expectKnownKeys(wrapper, ["component", "props"], at);
+			return compact({
+				component: expectString(wrapper.component, `${at}/component`),
+				props: optional(wrapper.props, (p) => expectObject(p, `${at}/props`))
+			});
+		})),
+		params: optional(container.params, (v) => {
+			const params = {};
+			for (const [name, entry] of Object.entries(expectObject(v, `${path}/params`))) {
+				const at = `${path}/params/${name}`;
+				const param = expectObject(entry, at);
+				expectKnownKeys(param, [
+					"type",
+					"default",
+					"description",
+					"options"
+				], at);
+				const type = expectOneOf(param.type, paramTypes, `${at}/type`);
+				const options = optional(param.options, (list) => {
+					const seen = /* @__PURE__ */ new Set();
+					return expectArray(list, `${at}/options`).map((item, index) => {
+						const where = `${at}/options/${index}`;
+						const option = expectObject(item, where);
+						expectKnownKeys(option, [
+							"id",
+							"name",
+							"overrides"
+						], where);
+						const id = expectString(option.id, `${where}/id`);
+						if (seen.has(id)) throw new TypeError(`${where}/id: duplicate option id "${id}"`);
+						seen.add(id);
+						return compact({
+							id,
+							name: expectString(option.name, `${where}/name`),
+							overrides: optional(option.overrides, (v) => parsePatches(v, `${where}/overrides`, ids))
+						});
+					});
+				});
+				if (type === "variant" && !options?.length) throw new TypeError(`${at}/options: a variant needs options`);
+				if (type !== "variant" && options) throw new TypeError(`${at}/options: only variants have options`);
+				params[name] = compact({
+					type,
+					default: param.default,
+					description: optional(param.description, (d) => expectString(d, `${at}/description`)),
+					options
+				});
+			}
+			return params;
+		}),
+		frames: optional(container.frames, (v) => {
+			const frames = {};
+			for (const [viewport, entry] of Object.entries(expectObject(v, `${path}/frames`))) {
+				const at = `${path}/frames/${viewport}`;
+				const size = expectObject(entry, at);
+				expectKnownKeys(size, ["width", "height"], at);
+				frames[viewport] = compact({
+					width: optional(size.width, (w) => expectNumber(w, `${at}/width`)),
+					height: optional(size.height, (h) => expectNumber(h, `${at}/height`))
+				});
+			}
+			return frames;
+		}),
+		position: {
+			x: expectNumber(position.x, `${path}/position/x`),
+			y: expectNumber(position.y, `${path}/position/y`)
+		},
+		root,
+		states,
+		view
+	});
+}
+function parseNode(value, path, ids) {
+	const node = expectObject(value, path);
+	const type = expectOneOf(node.type, [
+		"layout",
+		"component",
+		"text",
+		"instance",
+		"image"
+	], `${path}/type`);
+	const id = expectString(node.id, `${path}/id`);
+	if (ids.has(id)) throw new TypeError(`${path}/id: duplicate node id "${id}"`);
+	ids.add(id);
+	const base = compact({
+		id,
+		name: optional(node.name, (v) => expectString(v, `${path}/name`)),
+		hidden: optional(node.hidden, (v) => expectBoolean(v, `${path}/hidden`)),
+		style: optional(node.style, (v) => parseStyle(v, `${path}/style`)),
+		responsive: optional(node.responsive, (v) => parsePatches(v, `${path}/responsive`)),
+		bind: optional(node.bind, (v) => parseBinding(v, `${path}/bind`))
+	});
+	const common = [
+		"type",
+		"id",
+		"name",
+		"hidden",
+		"style",
+		"responsive",
+		"bind"
+	];
+	switch (type) {
+		case "layout":
+			expectKnownKeys(node, [...common, "children"], path);
+			return {
+				...base,
+				type,
+				children: expectArray(node.children, `${path}/children`).map((child, index) => parseNode(child, `${path}/children/${index}`, ids))
+			};
+		case "component": {
+			expectKnownKeys(node, [
+				...common,
+				"component",
+				"props",
+				"slots"
+			], path);
+			const slots = optional(node.slots, (v) => {
+				const result = {};
+				for (const [slot, children] of Object.entries(expectObject(v, `${path}/slots`))) result[slot] = expectArray(children, `${path}/slots/${slot}`).map((child, index) => parseNode(child, `${path}/slots/${slot}/${index}`, ids));
+				return result;
+			});
+			return {
+				...base,
+				type,
+				component: expectString(node.component, `${path}/component`),
+				props: optional(node.props, (v) => expectObject(v, `${path}/props`)),
+				slots
+			};
+		}
+		case "instance":
+			expectKnownKeys(node, [
+				...common,
+				"design",
+				"args",
+				"state",
+				"overrides"
+			], path);
+			return compact({
+				...base,
+				type,
+				design: expectString(node.design, `${path}/design`),
+				args: optional(node.args, (v) => expectObject(v, `${path}/args`)),
+				state: optional(node.state, (v) => expectString(v, `${path}/state`)),
+				overrides: optional(node.overrides, (v) => parsePatches(v, `${path}/overrides`))
+			});
+		case "text":
+			expectKnownKeys(node, [
+				...common,
+				"text",
+				"tag"
+			], path);
+			return {
+				...base,
+				type,
+				text: expectString(node.text, `${path}/text`),
+				tag: optional(node.tag, (v) => expectOneOf(v, textTags, `${path}/tag`))
+			};
+		case "image":
+			expectKnownKeys(node, [
+				...common,
+				"src",
+				"alt",
+				"fit",
+				"credit"
+			], path);
+			return compact({
+				...base,
+				type,
+				src: expectString(node.src, `${path}/src`),
+				alt: optional(node.alt, (v) => expectString(v, `${path}/alt`)),
+				fit: optional(node.fit, (v) => expectOneOf(v, imageFits, `${path}/fit`)),
+				credit: optional(node.credit, (v) => {
+					const credit = expectObject(v, `${path}/credit`);
+					expectKnownKeys(credit, [
+						"name",
+						"url",
+						"source"
+					], `${path}/credit`);
+					return compact({
+						name: expectString(credit.name, `${path}/credit/name`),
+						url: expectString(credit.url, `${path}/credit/url`),
+						source: optional(credit.source, (s) => expectString(s, `${path}/credit/source`))
+					});
+				})
+			});
+	}
+}
+function parseBinding(value, path) {
+	const binding = expectObject(value, path);
+	expectKnownKeys(binding, [
+		"text",
+		"props",
+		"visible"
+	], path);
+	return compact({
+		text: optional(binding.text, (v) => expectString(v, `${path}/text`)),
+		visible: optional(binding.visible, (v) => expectString(v, `${path}/visible`)),
+		props: optional(binding.props, (v) => {
+			const props = {};
+			for (const [prop, param] of Object.entries(expectObject(v, `${path}/props`))) props[prop] = expectString(param, `${path}/props/${prop}`);
+			return props;
+		})
+	});
+}
+/**
+* Patches keyed by node id. With `ids`, each key must name a node of the design, or start with one: `instance/inner`
+* reaches inside an instance, which can't be checked without the component.
+*/
+function parsePatches(value, path, ids) {
+	const patches = {};
+	for (const [key, entry] of Object.entries(expectObject(value, path))) {
+		if (ids && !ids.has(key.split("/")[0])) throw new TypeError(`${path}/${key}: no node has this id`);
+		patches[key] = parsePatch(entry, `${path}/${key}`);
+	}
+	return patches;
+}
+function parsePatch(value, path) {
+	const patch = expectObject(value, path);
+	expectKnownKeys(patch, [
+		"hidden",
+		"text",
+		"props",
+		"style"
+	], path);
+	return compact({
+		hidden: optional(patch.hidden, (v) => expectBoolean(v, `${path}/hidden`)),
+		text: optional(patch.text, (v) => expectString(v, `${path}/text`)),
+		props: optional(patch.props, (v) => expectObject(v, `${path}/props`)),
+		style: optional(patch.style, (v) => parseStyle(v, `${path}/style`))
+	});
+}
+function parseStyle(value, path) {
+	const style = expectObject(value, path);
+	const at = (key) => `${path}/${key}`;
+	const token = (key) => optional(style[key], (v) => expectString(v, at(key)));
+	const number = (key) => optional(style[key], (v) => expectNumber(v, at(key)));
+	const flag = (key) => optional(style[key], (v) => expectBoolean(v, at(key)));
+	const lengthAt = (v, where) => typeof v === "number" ? v : expectString(v, where);
+	const length = (key) => optional(style[key], (v) => lengthAt(v, at(key)));
+	const size = (key) => optional(style[key], (v) => lengthAt(v, at(key)));
+	const sides = (key) => optional(style[key], (v) => {
+		if (!Array.isArray(v)) return lengthAt(v, at(key));
+		if (v.length !== 2 && v.length !== 4) throw new TypeError(`${at(key)}: expected a length, [vertical, horizontal] or [top, right, bottom, left]`);
+		return v.map((side, index) => lengthAt(side, `${at(key)}/${index}`));
+	});
+	expectKnownKeys(style, styleKeys, path);
+	return compact({
+		display: optional(style.display, (v) => expectOneOf(v, ["flex", "grid"], at("display"))),
+		direction: optional(style.direction, (v) => expectOneOf(v, ["row", "column"], at("direction"))),
+		columns: number("columns"),
+		rows: number("rows"),
+		gap: length("gap"),
+		rowGap: length("rowGap"),
+		padding: sides("padding"),
+		margin: sides("margin"),
+		align: optional(style.align, (v) => expectOneOf(v, alignments, at("align"))),
+		justify: optional(style.justify, (v) => expectOneOf(v, justifications, at("justify"))),
+		wrap: flag("wrap"),
+		width: size("width"),
+		height: size("height"),
+		minWidth: length("minWidth"),
+		maxWidth: length("maxWidth"),
+		minHeight: length("minHeight"),
+		maxHeight: length("maxHeight"),
+		colSpan: number("colSpan"),
+		rowSpan: number("rowSpan"),
+		grow: flag("grow"),
+		self: optional(style.self, (v) => expectOneOf(v, alignments, at("self"))),
+		position: optional(style.position, (v) => expectOneOf(v, ["absolute"], at("position"))),
+		top: length("top"),
+		right: length("right"),
+		bottom: length("bottom"),
+		left: length("left"),
+		background: token("background"),
+		foreground: token("foreground"),
+		border: token("border"),
+		borderWidth: number("borderWidth"),
+		borderStyle: optional(style.borderStyle, (v) => expectOneOf(v, [
+			"solid",
+			"dashed",
+			"dotted"
+		], at("borderStyle"))),
+		radius: token("radius"),
+		shadow: token("shadow"),
+		opacity: number("opacity"),
+		overflow: optional(style.overflow, (v) => expectOneOf(v, [
+			"visible",
+			"hidden",
+			"scroll"
+		], at("overflow"))),
+		font: token("font"),
+		size: token("size"),
+		weight: number("weight"),
+		leading: token("leading"),
+		tracking: token("tracking"),
+		textAlign: optional(style.textAlign, (v) => expectOneOf(v, [
+			"start",
+			"center",
+			"end",
+			"justify"
+		], at("textAlign"))),
+		transform: optional(style.transform, (v) => expectOneOf(v, [
+			"uppercase",
+			"lowercase",
+			"capitalize"
+		], at("transform"))),
+		decoration: optional(style.decoration, (v) => expectOneOf(v, ["underline", "line-through"], at("decoration"))),
+		italic: flag("italic"),
+		lines: number("lines")
+	});
+}
+// ../core/src/library.ts
+/** How a component was recognised, which is also why it's believed to be one. */
+const componentEvidence = [
+	"function",
+	"forwardRef",
+	"memo",
+	"lazy",
+	"class",
+	"exotic"
+];
+/**
+* Where a part's parents came from: the library's own examples and stories, the namespace it's exported in
+* (`Accordion.Item`), the error it throws alone ("must be used within `Accordion`"), a shared name prefix
+* (`AccordionItem` under `Accordion`), or a hand edit.
+*/
+const parentSignals = [
+	"example",
+	"source",
+	"namespace",
+	"error",
+	"prefix",
+	"edit",
+	"app"
+];
+/** Whether a sample's prop value is elements. */
+function isSampleElement(value) {
+	return typeof value === "object" && value !== null && Array.isArray(value.$element);
+}
+/** Whether a sample's prop value is one the package makes. */
+function isMadeValue(value) {
+	const call = typeof value === "object" && value !== null ? value.$call : void 0;
+	return typeof call === "object" && call !== null && typeof call.import === "string";
+}
+/** Whether a sample's child or prop value is a render function. */
+function isSampleRender(value) {
+	return typeof value === "object" && value !== null && Array.isArray(value.$render);
+}
+/**
+* Where a part's sample calls what's inside it: its function children, else a render prop (Chakra's `TreeView.Node`
+* `render`), with the render function.
+*/
+function renderSlotOf(sample) {
+	const children = sample?.children?.find(isSampleRender);
+	if (children) return {
+		prop: "children",
+		render: children
+	};
+	const entry = Object.entries(sample?.props ?? {}).find(([, value]) => isSampleRender(value));
+	return entry ? {
+		prop: entry[0],
+		render: entry[1]
+	} : void 0;
+}
+const decoratorKeys = [
+	"when",
+	"wrap",
+	"add",
+	"class",
+	"attributes",
+	"style"
+];
+/** A library manifest's extension. It describes a library, and its `canvas` holds the library's own designs. */
+const libraryManifestExtension = ".lib.par";
+function parseLibraryManifest(value) {
+	const manifest = expectObject(value, "");
+	const keys = [
+		"$schema",
+		"version",
+		"id",
+		"name",
+		"description",
+		"styles",
+		"breakpoints",
+		"tokens",
+		"canvas"
+	];
+	if (manifest.version === 3) keys.push("package", "components", "icons", "decorators", "edits");
+	expectKnownKeys(manifest, keys, "");
+	if (manifest.version !== 1 && manifest.version !== 2 && manifest.version !== 3) throw new TypeError("/version: expected 1, 2 or 3");
+	return compact({
+		version: manifest.version,
+		id: optional(manifest.id, (v) => expectString(v, "/id")),
+		name: expectString(manifest.name, "/name"),
+		description: optional(manifest.description, (v) => expectString(v, "/description")),
+		package: optional(manifest.package, parsePackage),
+		styles: optional(manifest.styles, (v) => expectString(v, "/styles")),
+		breakpoints: optional(manifest.breakpoints, (v) => expectArray(v, "/breakpoints").map((item, index) => {
+			const at = `/breakpoints/${index}`;
+			const breakpoint = expectObject(item, at);
+			expectKnownKeys(breakpoint, [
+				"id",
+				"name",
+				"width"
+			], at);
+			return {
+				id: expectString(breakpoint.id, `${at}/id`),
+				name: expectString(breakpoint.name, `${at}/name`),
+				width: expectNumber(breakpoint.width, `${at}/width`)
+			};
+		}).sort((a, b) => a.width - b.width)),
+		tokens: optional(manifest.tokens, (v) => typeof v === "string" ? v : expectObject(v, "/tokens")),
+		components: optional(manifest.components, parseComponents),
+		icons: optional(manifest.icons, parseIcons),
+		decorators: optional(manifest.decorators, (v) => expectArray(v, "/decorators").map(parseDecorator)),
+		edits: optional(manifest.edits, (v) => typeof v === "string" ? v : parseLibraryEdits(v, "/edits")),
+		canvas: optional(manifest.canvas, (v) => {
+			try {
+				return parseCanvasDocument(v);
+			} catch (error) {
+				throw new TypeError(`/canvas${error instanceof Error ? error.message : String(error)}`);
+			}
+		})
+	});
+}
+function parsePackage(value) {
+	const pkg = expectObject(value, "/package");
+	expectKnownKeys(pkg, [
+		"name",
+		"version",
+		"range"
+	], "/package");
+	return compact({
+		name: expectString(pkg.name, "/package/name"),
+		version: optional(pkg.version, (v) => expectString(v, "/package/version")),
+		range: optional(pkg.range, (v) => expectString(v, "/package/range"))
+	});
+}
+function parseComponents(value) {
+	const components = expectObject(value, "/components");
+	expectKnownKeys(components, ["import", "list"], "/components");
+	const list = {};
+	for (const [name, entry] of Object.entries(expectObject(components.list, "/components/list"))) {
+		const at = `/components/list/${name}`;
+		const component = expectObject(entry, at);
+		expectKnownKeys(component, [
+			...componentKeys,
+			"fingerprint",
+			"props"
+		], at);
+		list[name] = compact({
+			...parseComponentFields(component, at),
+			as: expectOneOf(component.as, componentEvidence, `${at}/as`),
+			fingerprint: optional(component.fingerprint, (v) => expectString(v, `${at}/fingerprint`)),
+			props: optional(component.props, (v) => expectStringRecord(v, `${at}/props`))
+		});
+	}
+	return compact({
+		import: optional(components.import, (v) => expectString(v, "/components/import")),
+		list
+	});
+}
+const componentKeys = [
+	"as",
+	"declaration",
+	"group",
+	"parents",
+	"parentsFrom",
+	"optionalParents",
+	"parentParts",
+	"visual",
+	"internal",
+	"sample"
+];
+function parseComponentFields(component, at) {
+	return compact({
+		as: optional(component.as, (v) => expectOneOf(v, componentEvidence, `${at}/as`)),
+		declaration: optional(component.declaration, (v) => expectString(v, `${at}/declaration`)),
+		group: optional(component.group, (v) => expectString(v, `${at}/group`)),
+		parents: optional(component.parents, (v) => expectArray(v, `${at}/parents`).map((name, index) => expectString(name, `${at}/parents/${index}`))),
+		parentsFrom: optional(component.parentsFrom, (v) => expectOneOf(v, parentSignals, `${at}/parentsFrom`)),
+		optionalParents: optional(component.optionalParents, (v) => expectArray(v, `${at}/optionalParents`).map((name, index) => expectString(name, `${at}/optionalParents/${index}`))),
+		parentParts: optional(component.parentParts, (v) => {
+			if (typeof v !== "boolean") throw new TypeError(`${at}/parentParts: expected a boolean`);
+			return v;
+		}),
+		visual: optional(component.visual, (v) => {
+			if (typeof v !== "boolean") throw new TypeError(`${at}/visual: expected a boolean`);
+			return v;
+		}),
+		internal: optional(component.internal, (v) => {
+			if (typeof v !== "boolean") throw new TypeError(`${at}/internal: expected a boolean`);
+			return v;
+		}),
+		sample: optional(component.sample, (v) => parseSample(v, `${at}/sample`))
+	});
+}
+function parseSample(value, at) {
+	const sample = expectObject(value, at);
+	expectKnownKeys(sample, ["props", "children"], at);
+	return compact({
+		props: optional(sample.props, (v) => expectObject(v, `${at}/props`)),
+		children: optional(sample.children, (v) => parseSampleChildren(v, `${at}/children`))
+	});
+}
+function parseSampleChildren(value, at) {
+	return expectArray(value, at).map((item, index) => {
+		const here = `${at}/${index}`;
+		if (typeof item === "string") return item;
+		const child = expectObject(item, here);
+		if ("$render" in child) {
+			expectKnownKeys(child, [
+				"$render",
+				"spread",
+				"pass"
+			], here);
+			if (child.spread !== void 0 && child.spread !== true) throw new TypeError(`${here}/spread: expected true`);
+			const render = { $render: parseSampleChildren(child.$render, `${here}/$render`) };
+			if (child.spread) render.spread = true;
+			if (child.pass !== void 0) render.pass = expectArray(child.pass, `${here}/pass`).map((prop, index) => expectString(prop, `${here}/pass/${index}`));
+			return render;
+		}
+		expectKnownKeys(child, [
+			"component",
+			"props",
+			"children"
+		], here);
+		return compact({
+			component: expectString(child.component, `${here}/component`),
+			props: optional(child.props, (v) => expectObject(v, `${here}/props`)),
+			children: optional(child.children, (v) => parseSampleChildren(v, `${here}/children`))
+		});
+	});
+}
+/** Reads hand edits to a library file, from its `edits` or a shared file of them. */
+function parseLibraryEdits(value, at = "") {
+	const edits = expectObject(value, at);
+	expectKnownKeys(edits, [
+		"$schema",
+		"components",
+		"decorators"
+	], at);
+	return compact({
+		components: optional(edits.components, (v) => {
+			const result = {};
+			for (const [name, entry] of Object.entries(expectObject(v, `${at}/components`))) {
+				const here = `${at}/components/${name}`;
+				if (entry === false) {
+					result[name] = false;
+					continue;
+				}
+				const component = expectObject(entry, here);
+				expectKnownKeys(component, componentKeys, here);
+				result[name] = parseComponentFields(component, here);
+			}
+			return result;
+		}),
+		decorators: optional(edits.decorators, (v) => expectArray(v, `${at}/decorators`).map(parseDecorator))
+	});
+}
+/**
+* The manifest with hand edits merged over what was generated, and the edited exports it no longer has, which are
+* reported rather than dropped silently. An edit can add a component the checker missed, if it says what it's `as`.
+*/
+function applyLibraryEdits(manifest, edits) {
+	if (!edits) return {
+		manifest,
+		orphans: []
+	};
+	const orphans = [];
+	let components = manifest.components;
+	if (edits.components) {
+		const list = { ...components?.list };
+		for (const [name, edit] of Object.entries(edits.components)) {
+			const generated = list[name];
+			if (edit === false) {
+				if (generated) delete list[name];
+				else orphans.push(name);
+				continue;
+			}
+			if (!generated && !edit.as) {
+				orphans.push(name);
+				continue;
+			}
+			const merged = {
+				...generated,
+				...edit
+			};
+			if (edit.parents && !edit.parentsFrom) merged.parentsFrom = "edit";
+			if (edit.parents && !edit.optionalParents) delete merged.optionalParents;
+			list[name] = merged;
+		}
+		components = {
+			...components,
+			list
+		};
+	}
+	return {
+		manifest: compact({
+			...manifest,
+			components,
+			decorators: edits.decorators ?? manifest.decorators
+		}),
+		orphans
+	};
+}
+function parseIcons(value) {
+	const icons = expectObject(value, "/icons");
+	expectKnownKeys(icons, [
+		"import",
+		"render",
+		"match",
+		"exclude",
+		"prefer",
+		"variants",
+		"count",
+		"tags",
+		"tagSource"
+	], "/icons");
+	let render;
+	if (icons.render === "export") render = "export";
+	else {
+		const renderer = expectObject(icons.render, "/icons/render");
+		expectKnownKeys(renderer, [
+			"import",
+			"component",
+			"prop"
+		], "/icons/render");
+		render = {
+			import: expectString(renderer.import, "/icons/render/import"),
+			component: expectString(renderer.component, "/icons/render/component"),
+			prop: expectString(renderer.prop, "/icons/render/prop")
+		};
+	}
+	return compact({
+		import: optional(icons.import, (v) => expectString(v, "/icons/import")),
+		render,
+		match: optional(icons.match, (v) => expectPattern(v, "/icons/match")),
+		exclude: optional(icons.exclude, (v) => expectArray(v, "/icons/exclude").map((name, index) => expectString(name, `/icons/exclude/${index}`))),
+		prefer: optional(icons.prefer, (v) => expectArray(v, "/icons/prefer").map((name, index) => expectString(name, `/icons/prefer/${index}`))),
+		variants: optional(icons.variants, (v) => {
+			const variants = expectObject(v, "/icons/variants");
+			expectKnownKeys(variants, [
+				"pattern",
+				"prop",
+				"modules",
+				"styles",
+				"sizes",
+				"default"
+			], "/icons/variants");
+			return compact({
+				pattern: optional(variants.pattern, (pattern) => expectPattern(pattern, "/icons/variants/pattern")),
+				prop: optional(variants.prop, (prop) => expectString(prop, "/icons/variants/prop")),
+				modules: optional(variants.modules, (modules) => expectStringRecord(modules, "/icons/variants/modules")),
+				styles: optional(variants.styles, (list) => expectArray(list, "/icons/variants/styles").map((style, index) => expectString(style, `/icons/variants/styles/${index}`))),
+				sizes: optional(variants.sizes, (list) => expectArray(list, "/icons/variants/sizes").map((size, index) => expectNumber(size, `/icons/variants/sizes/${index}`))),
+				default: optional(variants.default, (d) => {
+					const fallback = expectObject(d, "/icons/variants/default");
+					expectKnownKeys(fallback, ["style", "size"], "/icons/variants/default");
+					return compact({
+						style: optional(fallback.style, (s) => expectString(s, "/icons/variants/default/style")),
+						size: optional(fallback.size, (s) => expectNumber(s, "/icons/variants/default/size"))
+					});
+				})
+			});
+		}),
+		count: optional(icons.count, (v) => expectNumber(v, "/icons/count")),
+		tags: optional(icons.tags, (v) => Object.fromEntries(Object.entries(expectObject(v, "/icons/tags")).map(([name, list]) => [name, expectArray(list, `/icons/tags/${name}`).map((tag, index) => expectString(tag, `/icons/tags/${name}/${index}`))]))),
+		tagSource: optional(icons.tagSource, (v) => expectString(v, "/icons/tagSource"))
+	});
+}
+function parseDecorator(value, index) {
+	const at = `/decorators/${index}`;
+	const decorator = expectObject(value, at);
+	expectKnownKeys(decorator, decoratorKeys, at);
+	if (decoratorKeys.filter((key) => key !== "when" && decorator[key] !== void 0).length !== 1) throw new TypeError(`${at}: expected one of wrap, add, class, attributes or style`);
+	const element = (v, path) => {
+		const spec = expectObject(v, path);
+		expectKnownKeys(spec, [
+			"import",
+			"component",
+			"props"
+		], path);
+		return compact({
+			import: expectString(spec.import, `${path}/import`),
+			component: expectString(spec.component, `${path}/component`),
+			props: optional(spec.props, (props) => expectObject(props, `${path}/props`))
+		});
+	};
+	return compact({
+		when: optional(decorator.when, (v) => {
+			const when = expectObject(v, `${at}/when`);
+			for (const [name, option] of Object.entries(when)) expectString(option, `${at}/when/${name}`);
+			return when;
+		}),
+		wrap: optional(decorator.wrap, (v) => element(v, `${at}/wrap`)),
+		add: optional(decorator.add, (v) => element(v, `${at}/add`)),
+		class: decorator.class,
+		attributes: optional(decorator.attributes, (v) => expectObject(v, `${at}/attributes`)),
+		style: optional(decorator.style, (v) => expectObject(v, `${at}/style`))
+	});
+}
+function expectPattern(value, path) {
+	const pattern = expectString(value, path);
+	try {
+		new RegExp(pattern);
+	} catch {
+		throw new TypeError(`${path}: expected a regular expression`);
+	}
+	return pattern;
+}
+function expectStringRecord(value, path) {
+	const record = expectObject(value, path);
+	for (const [key, item] of Object.entries(record)) expectString(item, `${path}/${key}`);
+	return record;
+}
+// ../core/src/library-insert.ts
+/**
+* A new node for a component, ready to show something: required props get their default or first option, and a
+* component that takes children gets its own name as text, so it isn't an empty box.
+*/
+function componentNode(component, info, taken, given = {}) {
+	const props = { ...given };
+	for (const prop of info?.props ?? []) {
+		if (prop.name in props) continue;
+		if (!prop.required || prop.default !== void 0 || prop.name === "children") continue;
+		if (prop.kind === "enum") props[prop.name] = prop.options?.[0];
+		else if (prop.kind === "boolean") props[prop.name] = false;
+		else if (prop.kind === "number") props[prop.name] = 0;
+		else if (prop.kind === "string") props[prop.name] = prop.name;
+	}
+	if (info?.props.some((prop) => prop.name === "children" && prop.kind === "node")) props.children = component.split("/").at(-1) ?? component;
+	return {
+		type: "component",
+		id: generateId(taken),
+		component,
+		...Object.keys(props).length > 0 ? { props } : {}
+	};
+}
+/**
+* A library component as its library file says it's used: with its sample (a collection's items, an Accordion's
+* item), and, for a part, inside the parents it needs that aren't around the drop target already. An
+* `AccordionTrigger` dropped into an empty layout comes inside an Accordion and an AccordionItem; dropped into an
+* AccordionItem, it comes alone.
+*/
+function withLibraryContext(node, sources, around, taken) {
+	if (node.type !== "component") return node;
+	const source = sources[node.component];
+	if (!source) return node;
+	const id = () => {
+		const next = generateId(taken);
+		taken.add(next);
+		return next;
+	};
+	const build = (child) => {
+		if (typeof child === "string") return {
+			type: "text",
+			id: id(),
+			text: child
+		};
+		if (!child.component.includes("/")) {
+			const text = child.children?.find((item) => typeof item === "string") ?? "Text";
+			return {
+				type: "text",
+				id: id(),
+				text
+			};
+		}
+		return component(child.component, child.props, child.children, !child.props && !child.children);
+	};
+	const nodes = (children) => children.flatMap((child) => isSampleRender(child) ? [] : [build(child)]);
+	/**
+	* Props and children as a node holds them. A render function (`renderInput`, function children) is a `$render:`
+	* slot of the nodes it returns, `$renderWith:` when what it's called with is spread onto them, so its nodes can be
+	* edited like any others.
+	*/
+	const held = (props, children = []) => {
+		const plain = {};
+		const slots = {};
+		const renderSlot = (prop, render) => {
+			const pass = render.pass ? `?pass=${render.pass.join(",")}` : "";
+			slots[`${render.spread ? "$renderWith" : "$render"}:${prop}${pass}`] = nodes(render.$render);
+		};
+		for (const [key, value] of Object.entries(props)) if (isSampleRender(value)) renderSlot(key, value);
+		else if (isSampleElement(value)) slots[key] = nodes(value.$element);
+		else plain[key] = value;
+		const render = children.find(isSampleRender);
+		if (render) renderSlot("children", render);
+		const rest = nodes(children);
+		if (rest.length > 0) slots.children = rest;
+		return {
+			props: plain,
+			slots
+		};
+	};
+	const component = (name, props, children, defaults = true) => {
+		const { props: merged, slots } = held({
+			...defaults ? sources[name]?.sample?.props : {},
+			...props
+		}, children);
+		return {
+			type: "component",
+			id: id(),
+			component: name,
+			...Object.keys(merged).length > 0 ? { props: merged } : {},
+			...Object.keys(slots).length > 0 ? { slots } : {}
+		};
+	};
+	let placed = node;
+	const sample = source.sample;
+	if (sample) {
+		const { props, slots } = held({
+			...sample.props,
+			...node.props
+		}, sample.children);
+		if (sample.children) delete props.children;
+		const { props: _label, ...rest } = node;
+		placed = {
+			...rest,
+			...Object.keys(props).length > 0 ? { props } : {},
+			...Object.keys(slots).length > 0 ? { slots: {
+				...node.slots,
+				...slots
+			} } : {}
+		};
+	}
+	const parents = source.parents ?? [];
+	const nearest = parents.findLastIndex((parent) => around.includes(parent));
+	const optional = new Set(source.optionalParents ?? []);
+	const missing = parents.slice(nearest + 1);
+	const added = missing.filter((parent, index) => !optional.has(parent) || missing.slice(0, index).some((outer) => !optional.has(outer)));
+	const calling = added.some((parent) => renderSlotOf(sources[parent]?.sample));
+	if (source.parentParts && added.length > 0 && !calling) return inOuterSample(added, placed);
+	for (const parent of added.reverse()) {
+		const wrapper = component(parent);
+		const calls = renderSlotOf(sources[parent]?.sample);
+		const slot = calls ? `$render:${calls.prop}${calls.render.pass ? `?pass=${calls.render.pass.join(",")}` : ""}` : "children";
+		const kept = Object.fromEntries(Object.entries(wrapper.type === "component" ? wrapper.slots ?? {} : {}).filter(([name]) => !calls || !name.startsWith(`$render:${calls.prop}`)));
+		placed = wrapper.type === "component" ? {
+			...wrapper,
+			slots: {
+				...calls ? kept : {},
+				[slot]: [placed]
+			}
+		} : placed;
+	}
+	return placed;
+	/**
+	* A part that needs what's around it (a table's header beside the body a row is in) goes into the outermost
+	* parent's whole sample, each level in place of the first like it there and the part in place of the first like it
+	* at the bottom, so the row it's in keeps its other cells. A level the sample doesn't hold comes alone.
+	*/
+	function inOuterSample(chain, part) {
+		const inside = (level, given) => {
+			let name = "";
+			if (level < chain.length) name = chain[level];
+			else if (part.type === "component") name = part.component;
+			const items = (given ?? []).filter((item) => !isSampleRender(item));
+			const at = items.findIndex((item) => typeof item === "object" && item.component === name);
+			const found = at === -1 ? void 0 : items[at];
+			let here = part;
+			if (level < chain.length) {
+				const written = found && (found.props || found.children);
+				const wrapper = component(name, found?.props, void 0, !written);
+				const children = inside(level + 1, written ? found.children : sources[name]?.sample?.children);
+				here = wrapper.type === "component" ? {
+					...wrapper,
+					slots: {
+						...wrapper.slots,
+						children
+					}
+				} : wrapper;
+			}
+			return at === -1 ? [here] : items.map((item, index) => index === at ? here : build(item));
+		};
+		const outer = component(chain[0]);
+		const children = inside(1, sources[chain[0]]?.sample?.children);
+		return outer.type === "component" ? {
+			...outer,
+			slots: {
+				...outer.slots,
+				children
+			}
+		} : outer;
+	}
+}
+/**
+* A library file's component as the canvas inserts it, but for where it's declared: its import, its parents and sample
+* by component id (`nova/AccordionItem`), and `imported` naming the package the way the project depends on it.
+*/
+function librarySource(library, name, component, path, imported = (specifier) => specifier) {
+	return {
+		path,
+		export: name,
+		library,
+		...component.group ? { group: component.group } : {},
+		...component.parents ? { parents: component.parents.map((parent) => `${library}/${parent}`) } : {},
+		...component.internal ? { internal: true } : {},
+		...component.optionalParents ? { optionalParents: component.optionalParents.map((parent) => `${library}/${parent}`) } : {},
+		...component.parentParts ? { parentParts: true } : {},
+		...component.sample ? { sample: sampleIds(component.sample, library, imported) } : {}
+	};
+}
+/**
+* A sample with its children's components named by id, as `nova/AccordionItem`; HTML elements keep their tag. A value the
+* package makes (`{ $call: { import: "@chakra-ui/react", ... } }`) imports it by the name the project depends on.
+*/
+function sampleIds(sample, library, imported = (specifier) => specifier) {
+	const child = (node) => {
+		if (typeof node === "string") return node;
+		if (isSampleRender(node)) return {
+			...node,
+			$render: node.$render.map(child)
+		};
+		return {
+			...node,
+			component: /^[a-z]/.test(node.component) ? node.component : `${library}/${node.component}`,
+			...node.props ? { props: propIds(node.props) } : {},
+			...node.children ? { children: node.children.map(child) } : {}
+		};
+	};
+	const propId = (item) => {
+		if (isSampleRender(item)) return {
+			...item,
+			$render: item.$render.map(child)
+		};
+		if (isSampleElement(item)) return { $element: item.$element.map(child) };
+		return isMadeValue(item) ? {
+			...item,
+			$call: {
+				...item.$call,
+				import: imported(item.$call.import)
+			}
+		} : item;
+	};
+	const propIds = (props) => Object.fromEntries(Object.entries(props).map(([key, item]) => [key, propId(item)]));
+	return {
+		...sample,
+		...sample.props ? { props: propIds(sample.props) } : {},
+		...sample.children ? { children: sample.children.map(child) } : {}
+	};
+}
+export { viewportHeightProperty as C, lengthToPixels as S, parseCanvasDocument as _, applyLibraryEdits as a, parseModeSettings as b, isSampleElement as c, parentSignals as d, parseLibraryEdits as f, paramTypes as g, imageFits as h, withLibraryContext as i, isSampleRender as l, renderSlotOf as m, librarySource as n, componentEvidence as o, parseLibraryManifest as p, sampleIds as r, isMadeValue as s, componentNode as t, libraryManifestExtension as u, styleKeys as v, viewportWidthProperty as w, deviceKinds as x, generateId as y };