@octane-xplat/nano-icons 0.1.0 → 0.16.0

package/dist/build/build-BbWkFu_9.js

@@ -0,0 +1,4308 @@
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import fs$1 from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { getIcons } from "@iconify/utils";
+import { iconToSVG } from "@iconify/utils/lib/svg/build";
+import { DOMParser } from "@xmldom/xmldom";
+import { Font, woff2 } from "fonteditor-core";
+import svg2ttf from "svg2ttf";
+import cubic2quadImport from "cubic2quad";
+//#region src/build/core/svgPatterns.ts
+/** Path already starts with a moveto. */
+var SVG_MOVE_PREFIX = /^[Mm]/;
+/** Trailing close-path command (+ optional whitespace). */
+var SVG_TRAILING_CLOSE = /[Zz]\s*$/;
+/** A signed int/float token. */
+var SVG_NUMBER = /-?\d+(?:\.\d+)?/g;
+/** Whitespace separator (e.g. viewBox parts). */
+var WHITESPACE = /\s+/;
+/** `<mask …>` element (unsupported). */
+var XML_MASK = /<mask[\s/>]/i;
+/** `<filter …>` element (unsupported). */
+var XML_FILTER = /<filter[\s/>]/i;
+/** `<image …>` element (unsupported). */
+var XML_IMAGE = /<image[\s/>]/i;
+var XML_UNCONVERTIBLE = /<(text|style|foreignObject|a|switch)[\s/>]/i;
+/** An `xmlns=` attribute. */
+var XML_XMLNS = /xmlns\s*=/;
+/** Opening `<svg` tag. */
+var SVG_OPEN_TAG = /<svg\b/;
+var PX_ATTRIBUTE_VALUE = /=(["'])(\s*-?(?:\d+\.?\d*|\.\d+))px\s*\1/g;
+var PX_STYLE_VALUE = /(:\s*-?(?:\d+\.?\d*|\.\d+))px(?=\s*(?:;|["']|$))/g;
+/** viewBox: comma or whitespace separated. */
+var VIEWBOX_SEPARATOR = /,|\s+/;
+/** transform() arguments: comma and/or whitespace separated. */
+var TRANSFORM_ARG_SEPARATOR = /\s*[,\s]\s*/;
+/** stroke-dasharray: single comma or space separated. */
+var DASHARRAY_SEPARATOR = /[, ]/;
+/** One transform function call, e.g. `rotate(30)`; captures name and args. */
+var TRANSFORM_FUNCTION = /(matrix|translate|scale|rotate|skewX|skewY)\s*\(([^)]*)\)/gi;
+/** `url(#id)` reference; captures the id. */
+var URL_ID_REFERENCE = /^url[(]#([\w-]+)[)]$/;
+/** A well-formed XML attribute name. */
+var XML_ATTRIBUTE_NAME = /^[A-Za-z_][\w.-]*$/;
+var XML_AMP = /&/g;
+var XML_LT = /</g;
+var XML_GT = />/g;
+var XML_QUOT = /"/g;
+/** svg2ttf error `glyph "u<hex>"` → captures the hex codepoint. */
+var GLYPH_CODEPOINT = /glyph\s+"u([0-9a-fA-F]+)"/;
+//#endregion
+//#region src/build/core/flatten/dom.ts
+var SVG_NS = "http://www.w3.org/2000/svg";
+var XLINK_NS = "http://www.w3.org/1999/xlink";
+function svgTag(local) {
+	return `{${SVG_NS}}${local}`;
+}
+function xlinkHrefAttr() {
+	return `{${XLINK_NS}}href`;
+}
+function splitNs(name) {
+	if (name.startsWith("{")) {
+		const end = name.indexOf("}");
+		return [name.slice(1, end), name.slice(end + 1)];
+	}
+	return [null, name];
+}
+function stripNs(name) {
+	return splitNs(name)[1];
+}
+var XEl = class XEl {
+	tag;
+	attrib;
+	children;
+	parent = null;
+	constructor(tag, attrib) {
+		this.tag = tag;
+		this.attrib = new Map(attrib ?? []);
+		this.children = [];
+	}
+	append(child) {
+		child.detach();
+		child.parent = this;
+		this.children.push(child);
+	}
+	insert(index, child) {
+		child.detach();
+		child.parent = this;
+		this.children.splice(index, 0, child);
+	}
+	detach() {
+		if (this.parent) {
+			const idx = this.parent.children.indexOf(this);
+			if (idx !== -1) this.parent.children.splice(idx, 1);
+			this.parent = null;
+		}
+	}
+	index(child) {
+		return this.children.indexOf(child);
+	}
+	deepClone() {
+		const copy = new XEl(this.tag, this.attrib);
+		for (const child of this.children) copy.append(child.deepClone());
+		return copy;
+	}
+	*iter() {
+		yield this;
+		for (const child of this.children) yield* child.iter();
+	}
+};
+function findAll(root, pred) {
+	const out = [];
+	for (const el of root.iter()) if (pred(el)) out.push(el);
+	return out;
+}
+function replaceEl(el, replacements) {
+	const parent = el.parent;
+	if (!parent) throw new Error("Cannot replace element without parent");
+	const idx = parent.index(el);
+	el.detach();
+	replacements.forEach((child, childIdx) => {
+		parent.insert(idx + childIdx, child);
+	});
+}
+function delAttrs(el, ...attrNames) {
+	for (const name of attrNames) el.attrib.delete(name);
+}
+function domNsToTag(node) {
+	const ns = node.namespaceURI;
+	return ns ? `{${ns}}${node.localName}` : node.nodeName;
+}
+function convertElement(node) {
+	const el = new XEl(domNsToTag(node));
+	const attrs = node.attributes;
+	for (let i = 0; i < attrs.length; i++) {
+		const attr = attrs.item(i);
+		if (attr.prefix === "xmlns" || attr.nodeName === "xmlns") continue;
+		const name = attr.namespaceURI ? `{${attr.namespaceURI}}${attr.localName}` : attr.nodeName;
+		el.attrib.set(name, attr.value);
+	}
+	const children = node.childNodes;
+	for (let i = 0; i < children.length; i++) {
+		const child = children.item(i);
+		if (child.nodeType === 1) el.append(convertElement(child));
+	}
+	return el;
+}
+function parseSvgDocument(content) {
+	let text = content;
+	if (text.includes("xlink:") && !text.includes("xmlns:xlink")) text = text.replace(/<svg([^>]*)>/, (_m, attrs) => `<svg${attrs} xmlns:xlink="${XLINK_NS}">`);
+	let parseError = null;
+	const root = new DOMParser({ onError: (_level, message) => {
+		parseError = parseError ?? message;
+	} }).parseFromString(text, "text/xml").documentElement;
+	if (!root || parseError) throw new Error(`Unable to parse SVG: ${parseError ?? "no root element"}`);
+	return convertElement(root);
+}
+function escapeAttr(value) {
+	return value.replace(XML_AMP, "&amp;").replace(XML_LT, "&lt;").replace(XML_GT, "&gt;").replace(XML_QUOT, "&quot;");
+}
+function attrDisplayName(name) {
+	const [ns, local] = splitNs(name);
+	if (ns === "http://www.w3.org/1999/xlink") return `xlink:${local}`;
+	if (ns === "http://www.w3.org/2000/svg" || ns === null) return local;
+	return local;
+}
+function tagDisplayName(tag) {
+	const [ns, local] = splitNs(tag);
+	if (ns === "http://www.w3.org/2000/svg" || ns === null) return local;
+	throw new Error(`Cannot serialize tag outside svg namespace: ${tag}`);
+}
+function usesXlink(root) {
+	for (const el of root.iter()) for (const name of el.attrib.keys()) if (splitNs(name)[0] === "http://www.w3.org/1999/xlink") return true;
+	return false;
+}
+function serializeEl(el, indent, out) {
+	const pad = "  ".repeat(indent);
+	const parts = [`${pad}<${tagDisplayName(el.tag)}`];
+	for (const [name, value] of el.attrib) parts.push(` ${attrDisplayName(name)}="${escapeAttr(value)}"`);
+	if (!el.children.length) {
+		parts.push("/>");
+		out.push(parts.join(""));
+		return;
+	}
+	parts.push(">");
+	out.push(parts.join(""));
+	for (const child of el.children) serializeEl(child, indent + 1, out);
+	out.push(`${pad}</${tagDisplayName(el.tag)}>`);
+}
+function serializeSvg(root) {
+	const out = [];
+	const attrs = [`xmlns="${SVG_NS}"`];
+	if (usesXlink(root)) attrs.push(`xmlns:xlink="${XLINK_NS}"`);
+	for (const [name, value] of root.attrib) attrs.push(`${attrDisplayName(name)}="${escapeAttr(value)}"`);
+	if (!root.children.length) out.push(`<${tagDisplayName(root.tag)} ${attrs.join(" ")}/>`);
+	else {
+		out.push(`<${tagDisplayName(root.tag)} ${attrs.join(" ")}>`);
+		for (const child of root.children) serializeEl(child, 1, out);
+		out.push(`</${tagDisplayName(root.tag)}>`);
+	}
+	return out.join("\n") + "\n";
+}
+//#endregion
+//#region src/build/iconify.ts
+/**
+* Materialize an Iconify collection (e.g. `@iconify-json/heroicons`) as
+* standalone SVG documents for `buildNanoIconFont`. Iconify geometry comes
+* from the icon's own `width`/`height`/`left`/`top` — the artwork is not
+* rescaled; glyph placement maps the viewBox into the font's em square.
+* `currentColor` fills are preserved as tintable `currentColor` layers.
+*/
+function iconifyCollectionToSvgs(collection) {
+	const names = [...Object.keys(collection.icons), ...Object.keys(collection.aliases ?? {})];
+	const resolved = getIcons(collection, names);
+	if (!resolved) throw new Error(`Iconify collection "${collection.prefix}" has no resolvable icons`);
+	const inputs = [];
+	for (const [name, icon] of Object.entries(resolved.icons)) {
+		const doc = iconifyIconToSvg(name, icon);
+		inputs.push({
+			name: `${resolved.prefix}:${name}`,
+			file: `${resolved.prefix}:${name}.svg`,
+			svg: doc
+		});
+	}
+	return inputs;
+}
+/** Standalone SVG document for one resolved Iconify icon. */
+function iconifyIconToSvg(name, icon) {
+	const result = iconToSVG(icon, { height: "unset" });
+	const { viewBox } = result.attributes;
+	return `<svg xmlns="${SVG_NS}" viewBox="${viewBox}">${result.body}</svg>`;
+}
+//#endregion
+//#region src/build/core/config.ts
+/** Create directory if it does not exist; do not remove existing contents (for shared output dirs). */
+function ensureDir(dir) {
+	fs$1.mkdirSync(dir, { recursive: true });
+}
+function writeFileAtomic(filePath, data) {
+	const tmpPath = `${filePath}.tmp`;
+	fs$1.writeFileSync(tmpPath, data);
+	fs$1.renameSync(tmpPath, filePath);
+}
+//#endregion
+//#region src/build/core/naming.ts
+/** Word separators in a set name (split → PascalCase parts). */
+var NAME_SEPARATORS = /[^a-zA-Z0-9]+/;
+/** Manifest identifiers must start with a letter. */
+var STARTS_WITH_LETTER = /^[a-zA-Z]/;
+/** "my-tab icons" → "MyTabIcons" — PascalCase base for manifest identifiers. */
+function manifestBaseName(setName) {
+	const pascal = setName.split(NAME_SEPARATORS).filter(Boolean).map((part) => part[0].toUpperCase() + part.slice(1)).join("");
+	return STARTS_WITH_LETTER.test(pascal) ? pascal : `Set${pascal}`;
+}
+//#endregion
+//#region src/build/module.ts
+/** Escape a string for embedding inside a single-quoted TS literal. */
+function tsString(value) {
+	return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+}
+/**
+* Emit `<fontFamily>.ts` beside the font assets. The module exports the
+* glyphmap, a bound `NanoIconSet`, a `NanoIcon` alias for `set.Icon`, and a
+* union type of icon names. `url` is a lazy getter so non-web runtimes never
+* evaluate `import.meta.url` resolution.
+*/
+function emitNanoIconSetModule(options) {
+	const base = manifestBaseName(options.fontFamily);
+	const fontFile = `${options.family}.ttf`;
+	const names = Object.keys(options.glyphMap.i);
+	const urlLine = options.web ? `get url() {\n\t\treturn new URL('./${options.family}.woff2', import.meta.url).href;\n\t},` : `get url() {\n\t\treturn new URL('./${fontFile}', import.meta.url).href;\n\t},`;
+	const source = `// Generated by @octane-xplat/nano-icons. Regenerate with the nano-icons build — do not edit.
+import { createNanoIconSet } from '@octane-xplat/nano-icons';
+import type { NanoIconSet } from '@octane-xplat/nano-icons';
+
+export const glyphMap = ${JSON.stringify(options.glyphMap)} as const;
+
+/** iOS/Android: copy ${tsString(fontFile)} into the app's fonts directory (see @octane-xplat/nano-icons docs). */
+export const ${base}Icons: NanoIconSet<${base}IconName> = createNanoIconSet(glyphMap, {
+	font: {
+		// NativeScript resolves app fonts by file name; keep it equal to the family.
+		fileName: ${tsString(fontFile)},
+		// Web font source; evaluated lazily so native bundles never touch import.meta.url.
+		${urlLine}
+	},
+});
+
+export const NanoIcon = ${base}Icons.Icon;
+
+export type ${base}IconName =
+${names.length ? names.map((n) => `\t| ${tsString(n)}`).join("\n") : "	| never"};
+`;
+	ensureDir(options.outputDir);
+	const modulePath = path.join(options.outputDir, `${options.fontFamily}.ts`);
+	writeFileAtomic(modulePath, source);
+	return modulePath;
+}
+//#endregion
+//#region src/build/core/font/metrics.ts
+var FIXED_TIMESTAMP_MS = Date.UTC(1970, 0, 1, 0, 0, 1);
+function forceTtfMetrics(ttfBuffer, upm, ascent, descent, lineGap) {
+	const font = Font.create(ttfBuffer, {
+		type: "ttf",
+		hinting: false,
+		compound2simple: false,
+		combinePath: false
+	});
+	const data = font.get();
+	data.head.unitsPerEm = upm;
+	data.hhea.ascent = ascent;
+	data.hhea.descent = -Math.abs(descent);
+	data.hhea.lineGap = lineGap;
+	data["OS/2"].usWinAscent = ascent;
+	data["OS/2"].usWinDescent = Math.abs(descent);
+	data["OS/2"].sTypoAscender = ascent;
+	data["OS/2"].sTypoDescender = -Math.abs(descent);
+	data["OS/2"].sTypoLineGap = lineGap;
+	data["OS/2"].fsSelection = (data["OS/2"].fsSelection || 0) | 128;
+	data.head.created = FIXED_TIMESTAMP_MS;
+	data.head.modified = FIXED_TIMESTAMP_MS;
+	data.post.format = 3;
+	for (const glyph of data.glyf) delete glyph.name;
+	font.set(data);
+	const out = font.write({
+		type: "ttf",
+		hinting: false
+	});
+	return Buffer.from(out);
+}
+//#endregion
+//#region src/build/core/font/compile.ts
+function escapeXml(s) {
+	return s.replace(XML_AMP, "&amp;").replace(XML_QUOT, "&quot;");
+}
+/**
+* Build an SVG font XML string from pre-transformed glyph data.
+*/
+function buildSvgFontXml(opts) {
+	const { fontName, glyphs, upm, ascent, descent } = opts;
+	const glyphLines = glyphs.map((g) => {
+		const hex = g.codepoint.toString(16);
+		return `<glyph glyph-name="${`u${hex.padStart(4, "0")}`}" unicode="&#x${hex};" horiz-adv-x="${g.advanceWidth}" d="${escapeXml(g.d)}"/>`;
+	});
+	return `<?xml version="1.0" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg xmlns="${SVG_NS}">
+<defs>
+<font id="${escapeXml(fontName)}" horiz-adv-x="${upm}">
+<font-face font-family="${escapeXml(fontName)}" units-per-em="${upm}" ascent="${ascent}" descent="${-Math.abs(descent)}"/>
+<missing-glyph horiz-adv-x="0"/>
+${glyphLines.join("\n")}
+</font>
+</defs>
+</svg>`;
+}
+function parseCompileTtfFromGlyphsError(err, codepointToIcon) {
+	const msg = err instanceof Error ? err.message : String(err);
+	const cpMatch = msg.match(GLYPH_CODEPOINT);
+	if (cpMatch) {
+		const cp = parseInt(cpMatch[1], 16);
+		const iconName = codepointToIcon.get(cp);
+		const detail = iconName ? `icon "${iconName}" (codepoint u${cpMatch[1]})` : `codepoint u${cpMatch[1]}`;
+		throw new Error(`Font compilation failed for ${detail}: ${msg}`);
+	}
+	throw err;
+}
+/**
+* Compile a TTF font from pre-transformed glyph data.
+* Builds SVG font XML directly (no intermediate files), then converts via svg2ttf.
+*/
+async function compileTtfFromGlyphs(opts) {
+	const { glyphs, outTtfPath, fontName, upm, ascent, descent } = opts;
+	const lineGap = opts.lineGap ?? 0;
+	if (glyphs.length === 0) throw new Error("No glyphs to compile");
+	const svgFontString = buildSvgFontXml({
+		fontName,
+		glyphs,
+		upm,
+		ascent,
+		descent
+	});
+	const ttfRaw = svg2ttf(svgFontString, { ts: 0 });
+	const fixedBuf = forceTtfMetrics(Buffer.from(ttfRaw.buffer), upm, ascent, descent, lineGap);
+	fs$1.mkdirSync(path.dirname(outTtfPath), { recursive: true });
+	writeFileAtomic(outTtfPath, fixedBuf);
+	return fixedBuf;
+}
+var woff2Ready;
+async function compileWoff2FromTtf(ttfBuffer) {
+	woff2Ready ??= woff2.init();
+	await woff2Ready;
+	return Buffer.from(woff2.encode(ttfBuffer));
+}
+//#endregion
+//#region src/build/core/fontIdentity.ts
+var BUILD_HASH_LENGTH = 8;
+var BUILD_HASH = `[0-9a-f]{${BUILD_HASH_LENGTH}}`;
+new RegExp(`-${BUILD_HASH}$`);
+new RegExp(`-${BUILD_HASH}\\.ttf$`);
+function buildFontFamily(fontFamily, inputHash) {
+	return `${fontFamily}-${inputHash.slice(0, BUILD_HASH_LENGTH)}`;
+}
+//#endregion
+//#region src/build/core/pathkit/load.ts
+var require = createRequire(import.meta.url);
+var instance = null;
+async function loadPathKit() {
+	if (instance) return instance;
+	const PathKitInit = require("pathkit-wasm/bin/pathkit.js");
+	const pathkitJsPath = require.resolve("pathkit-wasm/bin/pathkit.js");
+	const pathkitBinDir = path.dirname(pathkitJsPath);
+	const pathkitWasmPath = path.join(pathkitBinDir, "pathkit.wasm");
+	const pkInit = PathKitInit({
+		wasmBinary: await fs.readFile(pathkitWasmPath),
+		locateFile: (file) => path.join(pathkitBinDir, file)
+	});
+	instance = await (typeof pkInit?.ready === "function" ? pkInit.ready() : pkInit);
+	return instance;
+}
+//#endregion
+//#region src/build/core/font/quadratic.ts
+var cubic2quad = cubic2quadImport;
+var COMMAND = /([MLQCZ])([^MLQCZ]*)/g;
+var NUMBER = /-?(?:\d+\.?\d*|\.\d+)(?:e[-+]?\d+)?/gi;
+var QUADRATIC_ERROR_BOUND_EM = 1 / 512;
+function toQuadraticPath(d, errorBound) {
+	const out = [];
+	let x = 0;
+	let y = 0;
+	for (const [, cmd, rawArgs] of d.matchAll(COMMAND)) {
+		const args = (rawArgs.match(NUMBER) ?? []).map(Number);
+		if (cmd === "C") {
+			for (let i = 0; i + 5 < args.length; i += 6) {
+				const quads = cubic2quad(x, y, args[i], args[i + 1], args[i + 2], args[i + 3], args[i + 4], args[i + 5], errorBound);
+				for (let j = 2; j + 3 < quads.length; j += 4) out.push(`Q${quads[j]} ${quads[j + 1]} ${quads[j + 2]} ${quads[j + 3]}`);
+				x = args[i + 4];
+				y = args[i + 5];
+			}
+			continue;
+		}
+		out.push(`${cmd}${rawArgs.trim()}`);
+		if (cmd !== "Z" && args.length >= 2) {
+			x = args[args.length - 2];
+			y = args[args.length - 1];
+		}
+	}
+	return out.join("");
+}
+//#endregion
+//#region src/build/core/colors.ts
+var CSS_NAMED_COLORS = {
+	aliceblue: [
+		240,
+		248,
+		255
+	],
+	antiquewhite: [
+		250,
+		235,
+		215
+	],
+	aqua: [
+		0,
+		255,
+		255
+	],
+	aquamarine: [
+		127,
+		255,
+		212
+	],
+	azure: [
+		240,
+		255,
+		255
+	],
+	beige: [
+		245,
+		245,
+		220
+	],
+	bisque: [
+		255,
+		228,
+		196
+	],
+	black: [
+		0,
+		0,
+		0
+	],
+	blanchedalmond: [
+		255,
+		235,
+		205
+	],
+	blue: [
+		0,
+		0,
+		255
+	],
+	blueviolet: [
+		138,
+		43,
+		226
+	],
+	brown: [
+		165,
+		42,
+		42
+	],
+	burlywood: [
+		222,
+		184,
+		135
+	],
+	cadetblue: [
+		95,
+		158,
+		160
+	],
+	chartreuse: [
+		127,
+		255,
+		0
+	],
+	chocolate: [
+		210,
+		105,
+		30
+	],
+	coral: [
+		255,
+		127,
+		80
+	],
+	cornflowerblue: [
+		100,
+		149,
+		237
+	],
+	cornsilk: [
+		255,
+		248,
+		220
+	],
+	crimson: [
+		220,
+		20,
+		60
+	],
+	cyan: [
+		0,
+		255,
+		255
+	],
+	darkblue: [
+		0,
+		0,
+		139
+	],
+	darkcyan: [
+		0,
+		139,
+		139
+	],
+	darkgoldenrod: [
+		184,
+		134,
+		11
+	],
+	darkgray: [
+		169,
+		169,
+		169
+	],
+	darkgreen: [
+		0,
+		100,
+		0
+	],
+	darkgrey: [
+		169,
+		169,
+		169
+	],
+	darkkhaki: [
+		189,
+		183,
+		107
+	],
+	darkmagenta: [
+		139,
+		0,
+		139
+	],
+	darkolivegreen: [
+		85,
+		107,
+		47
+	],
+	darkorange: [
+		255,
+		140,
+		0
+	],
+	darkorchid: [
+		153,
+		50,
+		204
+	],
+	darkred: [
+		139,
+		0,
+		0
+	],
+	darksalmon: [
+		233,
+		150,
+		122
+	],
+	darkseagreen: [
+		143,
+		188,
+		143
+	],
+	darkslateblue: [
+		72,
+		61,
+		139
+	],
+	darkslategray: [
+		47,
+		79,
+		79
+	],
+	darkslategrey: [
+		47,
+		79,
+		79
+	],
+	darkturquoise: [
+		0,
+		206,
+		209
+	],
+	darkviolet: [
+		148,
+		0,
+		211
+	],
+	deeppink: [
+		255,
+		20,
+		147
+	],
+	deepskyblue: [
+		0,
+		191,
+		255
+	],
+	dimgray: [
+		105,
+		105,
+		105
+	],
+	dimgrey: [
+		105,
+		105,
+		105
+	],
+	dodgerblue: [
+		30,
+		144,
+		255
+	],
+	firebrick: [
+		178,
+		34,
+		34
+	],
+	floralwhite: [
+		255,
+		250,
+		240
+	],
+	forestgreen: [
+		34,
+		139,
+		34
+	],
+	fuchsia: [
+		255,
+		0,
+		255
+	],
+	gainsboro: [
+		220,
+		220,
+		220
+	],
+	ghostwhite: [
+		248,
+		248,
+		255
+	],
+	gold: [
+		255,
+		215,
+		0
+	],
+	goldenrod: [
+		218,
+		165,
+		32
+	],
+	gray: [
+		128,
+		128,
+		128
+	],
+	green: [
+		0,
+		128,
+		0
+	],
+	greenyellow: [
+		173,
+		255,
+		47
+	],
+	grey: [
+		128,
+		128,
+		128
+	],
+	honeydew: [
+		240,
+		255,
+		240
+	],
+	hotpink: [
+		255,
+		105,
+		180
+	],
+	indianred: [
+		205,
+		92,
+		92
+	],
+	indigo: [
+		75,
+		0,
+		130
+	],
+	ivory: [
+		255,
+		255,
+		240
+	],
+	khaki: [
+		240,
+		230,
+		140
+	],
+	lavender: [
+		230,
+		230,
+		250
+	],
+	lavenderblush: [
+		255,
+		240,
+		245
+	],
+	lawngreen: [
+		124,
+		252,
+		0
+	],
+	lemonchiffon: [
+		255,
+		250,
+		205
+	],
+	lightblue: [
+		173,
+		216,
+		230
+	],
+	lightcoral: [
+		240,
+		128,
+		128
+	],
+	lightcyan: [
+		224,
+		255,
+		255
+	],
+	lightgoldenrodyellow: [
+		250,
+		250,
+		210
+	],
+	lightgray: [
+		211,
+		211,
+		211
+	],
+	lightgreen: [
+		144,
+		238,
+		144
+	],
+	lightgrey: [
+		211,
+		211,
+		211
+	],
+	lightpink: [
+		255,
+		182,
+		193
+	],
+	lightsalmon: [
+		255,
+		160,
+		122
+	],
+	lightseagreen: [
+		32,
+		178,
+		170
+	],
+	lightskyblue: [
+		135,
+		206,
+		250
+	],
+	lightslategray: [
+		119,
+		136,
+		153
+	],
+	lightslategrey: [
+		119,
+		136,
+		153
+	],
+	lightsteelblue: [
+		176,
+		196,
+		222
+	],
+	lightyellow: [
+		255,
+		255,
+		224
+	],
+	lime: [
+		0,
+		255,
+		0
+	],
+	limegreen: [
+		50,
+		205,
+		50
+	],
+	linen: [
+		250,
+		240,
+		230
+	],
+	magenta: [
+		255,
+		0,
+		255
+	],
+	maroon: [
+		128,
+		0,
+		0
+	],
+	mediumaquamarine: [
+		102,
+		205,
+		170
+	],
+	mediumblue: [
+		0,
+		0,
+		205
+	],
+	mediumorchid: [
+		186,
+		85,
+		211
+	],
+	mediumpurple: [
+		147,
+		112,
+		219
+	],
+	mediumseagreen: [
+		60,
+		179,
+		113
+	],
+	mediumslateblue: [
+		123,
+		104,
+		238
+	],
+	mediumspringgreen: [
+		0,
+		250,
+		154
+	],
+	mediumturquoise: [
+		72,
+		209,
+		204
+	],
+	mediumvioletred: [
+		199,
+		21,
+		133
+	],
+	midnightblue: [
+		25,
+		25,
+		112
+	],
+	mintcream: [
+		245,
+		255,
+		250
+	],
+	mistyrose: [
+		255,
+		228,
+		225
+	],
+	moccasin: [
+		255,
+		228,
+		181
+	],
+	navajowhite: [
+		255,
+		222,
+		173
+	],
+	navy: [
+		0,
+		0,
+		128
+	],
+	oldlace: [
+		253,
+		245,
+		230
+	],
+	olive: [
+		128,
+		128,
+		0
+	],
+	olivedrab: [
+		107,
+		142,
+		35
+	],
+	orange: [
+		255,
+		165,
+		0
+	],
+	orangered: [
+		255,
+		69,
+		0
+	],
+	orchid: [
+		218,
+		112,
+		214
+	],
+	palegoldenrod: [
+		238,
+		232,
+		170
+	],
+	palegreen: [
+		152,
+		251,
+		152
+	],
+	paleturquoise: [
+		175,
+		238,
+		238
+	],
+	palevioletred: [
+		219,
+		112,
+		147
+	],
+	papayawhip: [
+		255,
+		239,
+		213
+	],
+	peachpuff: [
+		255,
+		218,
+		185
+	],
+	peru: [
+		205,
+		133,
+		63
+	],
+	pink: [
+		255,
+		192,
+		203
+	],
+	plum: [
+		221,
+		160,
+		221
+	],
+	powderblue: [
+		176,
+		224,
+		230
+	],
+	purple: [
+		128,
+		0,
+		128
+	],
+	rebeccapurple: [
+		102,
+		51,
+		153
+	],
+	red: [
+		255,
+		0,
+		0
+	],
+	rosybrown: [
+		188,
+		143,
+		143
+	],
+	royalblue: [
+		65,
+		105,
+		225
+	],
+	saddlebrown: [
+		139,
+		69,
+		19
+	],
+	salmon: [
+		250,
+		128,
+		114
+	],
+	sandybrown: [
+		244,
+		164,
+		96
+	],
+	seagreen: [
+		46,
+		139,
+		87
+	],
+	seashell: [
+		255,
+		245,
+		238
+	],
+	sienna: [
+		160,
+		82,
+		45
+	],
+	silver: [
+		192,
+		192,
+		192
+	],
+	skyblue: [
+		135,
+		206,
+		235
+	],
+	slateblue: [
+		106,
+		90,
+		205
+	],
+	slategray: [
+		112,
+		128,
+		144
+	],
+	slategrey: [
+		112,
+		128,
+		144
+	],
+	snow: [
+		255,
+		250,
+		250
+	],
+	springgreen: [
+		0,
+		255,
+		127
+	],
+	steelblue: [
+		70,
+		130,
+		180
+	],
+	tan: [
+		210,
+		180,
+		140
+	],
+	teal: [
+		0,
+		128,
+		128
+	],
+	thistle: [
+		216,
+		191,
+		216
+	],
+	tomato: [
+		255,
+		99,
+		71
+	],
+	turquoise: [
+		64,
+		224,
+		208
+	],
+	violet: [
+		238,
+		130,
+		238
+	],
+	wheat: [
+		245,
+		222,
+		179
+	],
+	white: [
+		255,
+		255,
+		255
+	],
+	whitesmoke: [
+		245,
+		245,
+		245
+	],
+	yellow: [
+		255,
+		255,
+		0
+	],
+	yellowgreen: [
+		154,
+		205,
+		50
+	]
+};
+//#endregion
+//#region src/build/core/parse.ts
+function parseColor(color) {
+	const c = color.trim();
+	if (c.indexOf("rgba(") === 0) {
+		const p = c.slice(5, c.indexOf(")")).split(",");
+		return [
+			+(p[0] ?? "0"),
+			+(p[1] ?? "0"),
+			+(p[2] ?? "0"),
+			+(p[3] ?? "1")
+		];
+	}
+	if (c.indexOf("rgb(") === 0) {
+		const p = c.slice(4, c.indexOf(")")).split(",");
+		return [
+			+(p[0] ?? "0"),
+			+(p[1] ?? "0"),
+			+(p[2] ?? "0"),
+			1
+		];
+	}
+	if (c.charCodeAt(0) === 35) {
+		if (c.length === 9) return [
+			parseInt(c.slice(1, 3), 16),
+			parseInt(c.slice(3, 5), 16),
+			parseInt(c.slice(5, 7), 16),
+			parseInt(c.slice(7, 9), 16) / 255
+		];
+		if (c.length === 7) return [
+			parseInt(c.slice(1, 3), 16),
+			parseInt(c.slice(3, 5), 16),
+			parseInt(c.slice(5, 7), 16),
+			1
+		];
+		if (c.length === 4) return [
+			parseInt(c.slice(1, 2), 16) * 17,
+			parseInt(c.slice(2, 3), 16) * 17,
+			parseInt(c.slice(3, 4), 16) * 17,
+			1
+		];
+	}
+	const named = CSS_NAMED_COLORS[c.toLowerCase()];
+	if (named !== void 0) return [
+		named[0],
+		named[1],
+		named[2],
+		1
+	];
+	return [
+		0,
+		0,
+		0,
+		1
+	];
+}
+//#endregion
+//#region src/build/core/glyph/parse.ts
+function resolveInheritedFill(el) {
+	let current = el.parentElement;
+	while (current !== null) {
+		const fill = current.getAttribute("fill");
+		if (fill !== null && fill !== "inherit") return fill;
+		current = current.parentElement;
+	}
+	return "black";
+}
+function calculateOpColor(fill, opacity, el) {
+	const [r, g, b, a] = parseColor(fill ?? resolveInheritedFill(el));
+	return `rgba(${r},${g},${b},${+(a * opacity).toFixed(4)})`;
+}
+/**
+* If a flattened path lost its initial moveto (e.g. an empty `Mx y z`
+* subpath was dropped), prepend `M` using the path's last coordinate pair.
+* For closed icon shapes the endpoint equals the start point.
+*/
+function sanitizePathData(d) {
+	const trimmed = d.trim();
+	if (!trimmed || SVG_MOVE_PREFIX.test(trimmed)) return {
+		d: trimmed,
+		sanitized: false
+	};
+	const nums = trimmed.replace(SVG_TRAILING_CLOSE, "").match(SVG_NUMBER);
+	if (!nums || nums.length < 2) return {
+		d: trimmed,
+		sanitized: false
+	};
+	return {
+		d: `M${nums[nums.length - 2]},${nums[nums.length - 1]} ${trimmed}`,
+		sanitized: true
+	};
+}
+var parsePath = (p) => {
+	const d = p.getAttribute("d") ?? "";
+	const op = p.getAttribute("opacity");
+	const fillOp = p.getAttribute("fill-opacity");
+	const fill = p.getAttribute("fill");
+	const fillRule = p.getAttribute("fill-rule") === "evenodd" || p.getAttribute("clip-rule") === "evenodd" ? "evenodd" : void 0;
+	if (op !== null || fillOp !== null) return {
+		d,
+		fill: calculateOpColor(fill, (op !== null ? parseFloat(op) : 1) * (fillOp !== null ? parseFloat(fillOp) : 1), p),
+		fillRule
+	};
+	return {
+		d,
+		fill,
+		fillRule
+	};
+};
+function parseFlattenedSvg(flattenedSvg, options) {
+	const svgEl = new DOMParser().parseFromString(flattenedSvg, "image/svg+xml").documentElement;
+	const viewBoxRaw = svgEl?.getAttribute("viewBox")?.split(WHITESPACE).map(Number);
+	let viewBox;
+	if (viewBoxRaw?.length === 4 && viewBoxRaw.every(Number.isFinite)) viewBox = [
+		viewBoxRaw[0],
+		viewBoxRaw[1],
+		viewBoxRaw[2],
+		viewBoxRaw[3]
+	];
+	else {
+		const width = parseFloat(svgEl?.getAttribute("width") ?? "");
+		const height = parseFloat(svgEl?.getAttribute("height") ?? "");
+		viewBox = width > 0 && height > 0 ? [
+			0,
+			0,
+			width,
+			height
+		] : [
+			0,
+			0,
+			100,
+			100
+		];
+		options?.onMissingViewBox?.(viewBox);
+	}
+	const paths = (svgEl ? Array.from(svgEl.getElementsByTagName("path")) : []).map(parsePath).filter((p) => p.d.trim() !== "").map((p) => {
+		const { d, sanitized } = sanitizePathData(p.d);
+		if (sanitized) options?.onSanitize?.(p.d);
+		return {
+			...p,
+			d
+		};
+	});
+	return {
+		viewBox,
+		paths
+	};
+}
+function shouldSkipPath(d, fill) {
+	if (!d || d.trim() === "") return true;
+	const f = (fill ?? "").trim().toLowerCase();
+	return f === "transparent" || f === "none";
+}
+//#endregion
+//#region src/build/core/glyph/placement.ts
+function roundInt(n) {
+	return Math.round(n);
+}
+function computePlacement(opts) {
+	const [vx, vy, vw, vh] = opts.viewBox;
+	const safeVh = vh === 0 ? 1 : vh;
+	const scale = opts.safeZone / safeVh;
+	const totalPadding = (opts.upm - opts.safeZone) / 2;
+	const scaledW = vw * scale;
+	const scaledH = vh * scale;
+	const adv = Math.max(1, roundInt(scaledW + totalPadding * 2));
+	return {
+		vx,
+		vy,
+		scale,
+		xOff: (adv - scaledW) / 2,
+		yOff: (opts.upm - scaledH) / 2,
+		adv
+	};
+}
+/**
+* Transform an SVG path `d` string from source SVG coordinates into font
+* glyph coordinates (Y-up, with placement scaling and centering applied).
+*
+* Combines placement transform (translate + scale + translate) with the
+* SVG→font Y-axis flip into a single affine transform applied via PathKit.
+*/
+function transformPathForFont(PathKit, d, opts) {
+	const { vx, vy, scale, xOff, yOff, upm } = opts;
+	const p = PathKit.FromSVGString(d);
+	if (!p) return d;
+	const scaleX = scale;
+	const scaleY = -scale;
+	const transX = xOff - vx * scale;
+	const transY = upm - yOff + vy * scale;
+	p.transform(scaleX, 0, transX, 0, scaleY, transY, 0, 0, 1);
+	const result = p.toSVGString();
+	p.delete?.();
+	return result;
+}
+//#endregion
+//#region src/build/core/flatten/geometry.ts
+var DEFAULT_ALMOST_EQUAL_TOLERANCE = 1e-9;
+function pt(x = 0, y = 0) {
+	return {
+		x,
+		y
+	};
+}
+function almostEqual(c1, c2, tolerance = DEFAULT_ALMOST_EQUAL_TOLERANCE) {
+	return Math.abs(c1 - c2) <= tolerance;
+}
+function ptEquals(a, b) {
+	return a.x === b.x && a.y === b.y;
+}
+function ptAlmostEquals(a, b, tolerance = DEFAULT_ALMOST_EQUAL_TOLERANCE) {
+	return almostEqual(a.x, b.x, tolerance) && almostEqual(a.y, b.y, tolerance);
+}
+function ptSub(a, b) {
+	return {
+		x: a.x - b.x,
+		y: a.y - b.y
+	};
+}
+function ptAdd(a, b) {
+	return {
+		x: a.x + b.x,
+		y: a.y + b.y
+	};
+}
+function ptMul(a, scalar) {
+	return {
+		x: a.x * scalar,
+		y: a.y * scalar
+	};
+}
+function pythonRound(x, ndigits) {
+	if (!Number.isFinite(x) || Number.isInteger(x) && ndigits >= 0) return x;
+	const buf = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(8));
+	buf.setFloat64(0, x);
+	const bits = buf.getBigUint64(0);
+	const negative = bits >> 63n === 1n;
+	const expBits = Number(bits >> 52n & 2047n);
+	const fracBits = bits & 4503599627370495n;
+	let mantissa;
+	let exp;
+	if (expBits === 0) {
+		mantissa = fracBits;
+		exp = -1074;
+	} else {
+		mantissa = fracBits | 1n << 52n;
+		exp = expBits - 1075;
+	}
+	const pow10 = 10n ** BigInt(Math.abs(ndigits));
+	let num = mantissa * (ndigits >= 0 ? pow10 : 1n);
+	let den = ndigits >= 0 ? 1n : pow10;
+	if (exp >= 0) num <<= BigInt(exp);
+	else den <<= BigInt(-exp);
+	let k = num / den;
+	const twice = num % den * 2n;
+	if (twice > den || twice === den && k % 2n === 1n) k += 1n;
+	const scaled = ndigits >= 0 ? Number(k) / Number(pow10) : Number(k) * Number(pow10);
+	return negative ? -scaled : scaled;
+}
+function ntos(n) {
+	return Object.is(n, -0) ? "0" : String(n);
+}
+function rectEmpty(r) {
+	return r.w === 0 || r.h === 0;
+}
+//#endregion
+//#region src/build/core/flatten/transform.ts
+var RADIAN_ARG_OPS = /* @__PURE__ */ new Set([
+	"rotate",
+	"skewx",
+	"skewy"
+]);
+var Affine2D = class Affine2D {
+	a;
+	b;
+	c;
+	d;
+	e;
+	f;
+	constructor(a, b, c, d, e, f) {
+		this.a = a;
+		this.b = b;
+		this.c = c;
+		this.d = d;
+		this.e = e;
+		this.f = f;
+	}
+	static _identity = new Affine2D(1, 0, 0, 1, 0, 0);
+	static _degenerate = new Affine2D(0, 0, 0, 0, 0, 0);
+	static identity() {
+		return Affine2D._identity;
+	}
+	static degenerate() {
+		return Affine2D._degenerate;
+	}
+	static fromString(rawTransform) {
+		let transform = Affine2D.identity();
+		const re = new RegExp(TRANSFORM_FUNCTION);
+		let match;
+		while ((match = re.exec(rawTransform)) !== null) {
+			const op = match[1].toLowerCase();
+			const args = match[2].trim().split(TRANSFORM_ARG_SEPARATOR).map((p) => parseFloat(p));
+			if (RADIAN_ARG_OPS.has(op)) args[0] = args[0] * Math.PI / 180;
+			switch (op) {
+				case "matrix":
+					transform = transform.matrix(args[0], args[1], args[2], args[3], args[4], args[5]);
+					break;
+				case "translate":
+					transform = transform.translate(args[0], args[1]);
+					break;
+				case "scale":
+					transform = transform.scale(args[0], args[1]);
+					break;
+				case "rotate":
+					transform = transform.rotate(args[0], args[1], args[2]);
+					break;
+				case "skewx":
+					transform = transform.skewx(args[0]);
+					break;
+				case "skewy": transform = transform.skewy(args[0]);
+			}
+		}
+		return transform;
+	}
+	values() {
+		return [
+			this.a,
+			this.b,
+			this.c,
+			this.d,
+			this.e,
+			this.f
+		];
+	}
+	equals(other) {
+		return this.a === other.a && this.b === other.b && this.c === other.c && this.d === other.d && this.e === other.e && this.f === other.f;
+	}
+	toString() {
+		const [tx, ty] = this.getTranslate();
+		if (this.equals(Affine2D.identity().translate(tx, ty))) return `translate(${[tx, ty].map(ntos).join(", ")})`;
+		return `matrix(${this.values().map(ntos).join(" ")})`;
+	}
+	matMul(other) {
+		return new Affine2D(this.a * other.a + this.c * other.b, this.b * other.a + this.d * other.b, this.a * other.c + this.c * other.d, this.b * other.c + this.d * other.d, this.a * other.e + this.c * other.f + this.e, this.b * other.e + this.d * other.f + this.f);
+	}
+	matrix(a, b, c, d, e, f) {
+		return this.matMul(new Affine2D(a, b, c, d, e, f));
+	}
+	translate(tx, ty = 0) {
+		if (tx === 0 && ty === 0) return this;
+		return this.matrix(1, 0, 0, 1, tx, ty);
+	}
+	getTranslate() {
+		return [this.e, this.f];
+	}
+	scale(sx, sy) {
+		if (sy === void 0) sy = sx;
+		return this.matrix(sx, 0, 0, sy, 0, 0);
+	}
+	rotate(a, cx = 0, cy = 0) {
+		return this.translate(cx, cy).matrix(Math.cos(a), Math.sin(a), -Math.sin(a), Math.cos(a), 0, 0).translate(-cx, -cy);
+	}
+	skewx(a) {
+		return this.matrix(1, 0, Math.tan(a), 1, 0, 0);
+	}
+	skewy(a) {
+		return this.matrix(1, Math.tan(a), 0, 1, 0, 0);
+	}
+	determinant() {
+		return this.a * this.d - this.b * this.c;
+	}
+	isDegenerate() {
+		return Math.abs(this.determinant()) <= Number.EPSILON;
+	}
+	inverse() {
+		if (this.equals(Affine2D.identity())) return this;
+		else if (this.isDegenerate()) return Affine2D.degenerate();
+		const det = this.determinant();
+		const a = this.d / det;
+		const b = -this.b / det;
+		const c = -this.c / det;
+		const d = this.a / det;
+		const e = -a * this.e - c * this.f;
+		const f = -b * this.e - d * this.f;
+		return new Affine2D(a, b, c, d, e, f);
+	}
+	mapPoint(p) {
+		return {
+			x: this.a * p.x + this.c * p.y + this.e,
+			y: this.b * p.x + this.d * p.y + this.f
+		};
+	}
+	mapVector(v) {
+		return {
+			x: this.a * v.x + this.c * v.y,
+			y: this.b * v.x + this.d * v.y
+		};
+	}
+	static composeLtr(affines) {
+		let result = Affine2D.identity();
+		for (let i = affines.length - 1; i >= 0; i--) result = result.matMul(affines[i]);
+		return result;
+	}
+	static _ALIGN_VALUES = /* @__PURE__ */ new Set([
+		"none",
+		"xminymin",
+		"xminymid",
+		"xminymax",
+		"xmidymin",
+		"xmidymid",
+		"xmidymax",
+		"xmaxymin",
+		"xmaxymid",
+		"xmaxymax"
+	]);
+	static _MEET_OR_SLICE = /* @__PURE__ */ new Set(["meet", "slice"]);
+	static rectToRect(src, dst, preserveAspectRatio = "none") {
+		if (rectEmpty(src)) return Affine2D.identity();
+		if (rectEmpty(dst)) return new Affine2D(0, 0, 0, 0, 0, 0);
+		let sx = dst.w / src.w;
+		let sy = dst.h / src.h;
+		const normalized = preserveAspectRatio.toLowerCase().trim();
+		const spaceIdx = normalized.indexOf(" ");
+		const align = spaceIdx === -1 ? normalized : normalized.slice(0, spaceIdx);
+		const meetOrSlice = spaceIdx === -1 ? "" : normalized.slice(spaceIdx + 1).trim();
+		if (!Affine2D._ALIGN_VALUES.has(align) || meetOrSlice && !Affine2D._MEET_OR_SLICE.has(meetOrSlice)) throw new Error(`Invalid preserveAspectRatio: ${preserveAspectRatio}`);
+		if (align !== "none") sx = sy = meetOrSlice.includes("slice") ? Math.max(sx, sy) : Math.min(sx, sy);
+		let tx = dst.x - src.x * sx;
+		let ty = dst.y - src.y * sy;
+		if (align.includes("xmid")) tx += (dst.w - src.w * sx) / 2;
+		else if (align.includes("xmax")) tx += dst.w - src.w * sx;
+		if (align.includes("ymid")) ty += (dst.h - src.h * sy) / 2;
+		else if (align.includes("ymax")) ty += dst.h - src.h * sy;
+		return new Affine2D(sx, 0, 0, sy, tx, ty);
+	}
+};
+//#endregion
+//#region src/build/core/flatten/inherit.ts
+var ATTRIB_DEFAULTS = {
+	"clip-path": "",
+	"clip-rule": "nonzero",
+	fill: "black",
+	"fill-opacity": 1,
+	"fill-rule": "nonzero",
+	stroke: "none",
+	"stroke-width": 1,
+	"stroke-linecap": "butt",
+	"stroke-linejoin": "miter",
+	"stroke-miterlimit": 4,
+	"stroke-dasharray": "none",
+	"stroke-dashoffset": 0,
+	"stroke-opacity": 1,
+	opacity: 1,
+	transform: "",
+	style: "",
+	display: "inline",
+	d: "",
+	id: ""
+};
+function attribDefault(name) {
+	const value = ATTRIB_DEFAULTS[name];
+	if (value === void 0) throw new Error(`No entry for '${name}' and no default given`);
+	return value;
+}
+var COMMON_SHAPE_FIELDS = [
+	"id",
+	"clip_path",
+	"clip_rule",
+	"fill",
+	"fill_opacity",
+	"fill_rule",
+	"stroke",
+	"stroke_width",
+	"stroke_linecap",
+	"stroke_linejoin",
+	"stroke_miterlimit",
+	"stroke_dasharray",
+	"stroke_dashoffset",
+	"stroke_opacity",
+	"opacity",
+	"transform",
+	"style",
+	"display"
+];
+var VALID_FIELDS = {
+	path: /* @__PURE__ */ new Set([...COMMON_SHAPE_FIELDS, "d"]),
+	circle: /* @__PURE__ */ new Set([
+		...COMMON_SHAPE_FIELDS,
+		"r",
+		"cx",
+		"cy"
+	]),
+	ellipse: /* @__PURE__ */ new Set([
+		...COMMON_SHAPE_FIELDS,
+		"rx",
+		"ry",
+		"cx",
+		"cy"
+	]),
+	line: /* @__PURE__ */ new Set([
+		...COMMON_SHAPE_FIELDS,
+		"x1",
+		"y1",
+		"x2",
+		"y2"
+	]),
+	polygon: /* @__PURE__ */ new Set([...COMMON_SHAPE_FIELDS, "points"]),
+	polyline: /* @__PURE__ */ new Set([...COMMON_SHAPE_FIELDS, "points"]),
+	rect: /* @__PURE__ */ new Set([
+		...COMMON_SHAPE_FIELDS,
+		"x",
+		"y",
+		"width",
+		"height",
+		"rx",
+		"ry"
+	]),
+	linearGradient: /* @__PURE__ */ new Set([
+		"id",
+		"x1",
+		"y1",
+		"x2",
+		"y2",
+		"gradientTransform",
+		"gradientUnits",
+		"spreadMethod"
+	]),
+	radialGradient: /* @__PURE__ */ new Set([
+		"id",
+		"cx",
+		"cy",
+		"r",
+		"fx",
+		"fy",
+		"fr",
+		"gradientTransform",
+		"gradientUnits",
+		"spreadMethod"
+	]),
+	stop: /* @__PURE__ */ new Set([
+		"offset",
+		"stop_color",
+		"stop_opacity"
+	])
+};
+function attrName(fieldName) {
+	return fieldName.replace(/_/g, "-");
+}
+function fieldName(attr) {
+	return attr.replace(/-/g, "_");
+}
+function attrSupported(el, attr) {
+	const fields = VALID_FIELDS[stripNs(el.tag)];
+	if (fields) return fields.has(fieldName(attr));
+	return true;
+}
+function inheritCopy(attrib, child, attr) {
+	if (child.attrib.has(attr)) return;
+	if (attr in attrib) child.attrib.set(attr, attrib[attr]);
+}
+function inheritMultiply(attrib, child, attr) {
+	if (!(attr in attrib) && !child.attrib.has(attr)) return;
+	let value = parseFloat(attrib[attr] ?? "1");
+	value *= parseFloat(child.attrib.get(attr) ?? "1");
+	child.attrib.set(attr, ntos(value));
+}
+function inheritClipPath(attrib, child, _attr) {
+	const clips = [...(child.attrib.get("clip-path") ?? "").split(","), attrib["clip-path"] ?? ""].sort();
+	child.attrib.set("clip-path", clips.filter((c) => c).join(","));
+}
+function inheritNondefaultOverflow(attrib, child, attr) {
+	if ((attrib[attr] ?? "visible") !== "visible") inheritCopy(attrib, child, attr);
+}
+function inheritNondefaultDisplay(attrib, child, attr) {
+	const value = attrib[attr] ?? "";
+	if (value === "none") child.attrib.set(attr, value);
+	else inheritCopy(attrib, child, attr);
+}
+function inheritMatrixMultiply(attrib, child, attr) {
+	let transform = Affine2D.identity();
+	if (attr in attrib) transform = Affine2D.fromString(attrib[attr]);
+	if (child.attrib.has(attr)) transform = Affine2D.composeLtr([Affine2D.fromString(child.attrib.get(attr)), transform]);
+	if (!transform.equals(Affine2D.identity())) child.attrib.set(attr, transform.toString());
+	else child.attrib.delete(attr);
+}
+var DO_NOT_INHERIT = () => {};
+var INHERIT_ATTRIB_HANDLERS = {
+	"clip-rule": inheritCopy,
+	color: inheritCopy,
+	display: inheritNondefaultDisplay,
+	fill: inheritCopy,
+	"fill-rule": inheritCopy,
+	style: inheritCopy,
+	transform: inheritMatrixMultiply,
+	stroke: inheritCopy,
+	"stroke-width": inheritCopy,
+	"stroke-linecap": inheritCopy,
+	"stroke-linejoin": inheritCopy,
+	"stroke-miterlimit": inheritCopy,
+	"stroke-dasharray": inheritCopy,
+	"stroke-dashoffset": inheritCopy,
+	"stroke-opacity": inheritCopy,
+	"fill-opacity": inheritCopy,
+	opacity: inheritMultiply,
+	"clip-path": inheritClipPath,
+	id: DO_NOT_INHERIT,
+	"data-name": DO_NOT_INHERIT,
+	"enable-background": DO_NOT_INHERIT,
+	overflow: inheritNondefaultOverflow
+};
+var INHERITABLE_ATTRIB = new Set(Object.entries(INHERIT_ATTRIB_HANDLERS).filter(([, handler]) => handler !== DO_NOT_INHERIT).map(([name]) => name));
+var ATTRIB_W_CUSTOM_INHERITANCE = /* @__PURE__ */ new Set([
+	"clip-path",
+	"opacity",
+	"transform"
+]);
+var INHERITABLE_ATTRIB_DEFAULTS = Object.fromEntries(Object.entries(INHERIT_ATTRIB_HANDLERS).filter(([name, handler]) => name in ATTRIB_DEFAULTS && handler === inheritCopy).map(([name]) => {
+	const value = ATTRIB_DEFAULTS[name];
+	return [name, typeof value === "number" ? ntos(value) : value];
+}));
+function inheritAttrib(attrib, child, skipUnhandled = false, skips = /* @__PURE__ */ new Set()) {
+	const work = attrib instanceof Map ? Object.fromEntries(attrib) : { ...attrib };
+	for (const attr of Object.keys(work).sort()) {
+		if (skips.has(attr) || !attrSupported(child, attr)) {
+			delete work[attr];
+			continue;
+		}
+		const handler = INHERIT_ATTRIB_HANDLERS[attr];
+		if (!handler) continue;
+		handler(work, child, attr);
+		delete work[attr];
+	}
+	if (Object.keys(work).length && !skipUnhandled) throw new Error(`Unable to process attrib ${JSON.stringify(work)}`);
+}
+function attribToPassOn(currentAttrib, el, skips = ATTRIB_W_CUSTOM_INHERITANCE) {
+	const attrCatcher = new XEl("dummy");
+	inheritAttrib(el.attrib, attrCatcher, true, skips);
+	inheritAttrib(currentAttrib, attrCatcher, false, skips);
+	return Object.fromEntries(attrCatcher.attrib);
+}
+function dropDefaultAttrib(attrib) {
+	for (const attr of [...attrib.keys()].sort()) {
+		const defaultValue = ATTRIB_DEFAULTS[attr];
+		if (defaultValue === void 0) continue;
+		const value = attrib.get(attr);
+		if (typeof defaultValue === "number") {
+			if (parseFloat(value) === defaultValue) attrib.delete(attr);
+		} else if (value === defaultValue) attrib.delete(attr);
+	}
+}
+//#endregion
+//#region src/build/core/flatten/arcs.ts
+var TWO_PI = 2 * Math.PI;
+var PI_OVER_TWO = .5 * Math.PI;
+function isStraightLine(arc) {
+	const rx = Math.abs(arc.rx);
+	const ry = Math.abs(arc.ry);
+	return !(rx && ry);
+}
+function isZeroLength(arc) {
+	return ptEquals(arc.endPoint, arc.startPoint);
+}
+function correctOutOfRangeRadii(arc) {
+	if (isStraightLine(arc) || isZeroLength(arc)) return arc;
+	const midPointDistance = ptMul(ptSub(arc.startPoint, arc.endPoint), .5);
+	const angle = arc.rotation * Math.PI / 180;
+	const transformedMidPoint = Affine2D.identity().rotate(-angle).mapVector(midPointDistance);
+	let rx = arc.rx;
+	let ry = arc.ry;
+	const squareRx = rx * rx;
+	const squareRy = ry * ry;
+	const squareX = transformedMidPoint.x * transformedMidPoint.x;
+	const squareY = transformedMidPoint.y * transformedMidPoint.y;
+	const radiiScale = squareX / squareRx + squareY / squareRy;
+	if (radiiScale > 1) {
+		rx *= Math.sqrt(radiiScale);
+		ry *= Math.sqrt(radiiScale);
+		return {
+			...arc,
+			rx,
+			ry
+		};
+	}
+	return arc;
+}
+function endToCenterParametrization(arc) {
+	const angle = arc.rotation * Math.PI / 180;
+	const pointTransform = Affine2D.identity().scale(1 / arc.rx, 1 / arc.ry).rotate(-angle);
+	const point1 = pointTransform.mapPoint(arc.startPoint);
+	const point2 = pointTransform.mapPoint(arc.endPoint);
+	let delta = ptSub(point2, point1);
+	const d = delta.x * delta.x + delta.y * delta.y;
+	const scaleFactorSquared = Math.max(1 / d - .25, 0);
+	let scaleFactor = Math.sqrt(scaleFactorSquared);
+	if (arc.sweep === arc.large) scaleFactor = -scaleFactor;
+	delta = ptMul(delta, scaleFactor);
+	let centerPoint = ptAdd(ptAdd(point1, ptMul(ptSub(point2, point1), .5)), pt(-delta.y, delta.x));
+	const v1 = ptSub(point1, centerPoint);
+	const v2 = ptSub(point2, centerPoint);
+	const theta1 = Math.atan2(v1.y, v1.x);
+	let thetaArc = Math.atan2(v2.y, v2.x) - theta1;
+	if (thetaArc < 0 && arc.sweep) thetaArc += TWO_PI;
+	else if (thetaArc > 0 && !arc.sweep) thetaArc -= TWO_PI;
+	centerPoint = pointTransform.inverse().mapPoint(centerPoint);
+	return {
+		theta1,
+		thetaArc,
+		centerPoint
+	};
+}
+function* ellipticalArcToCubic(arc) {
+	arc = correctOutOfRangeRadii(arc);
+	const arcParams = endToCenterParametrization(arc);
+	const pointTransform = Affine2D.identity().translate(arcParams.centerPoint.x, arcParams.centerPoint.y).rotate(arc.rotation * Math.PI / 180).scale(arc.rx, arc.ry);
+	const numSegments = Math.ceil(Math.abs(arcParams.thetaArc / (PI_OVER_TWO + .001)));
+	for (let i = 0; i < numSegments; i++) {
+		const startTheta = arcParams.theta1 + i * arcParams.thetaArc / numSegments;
+		const endTheta = arcParams.theta1 + (i + 1) * arcParams.thetaArc / numSegments;
+		const t = 4 / 3 * Math.tan(.25 * (endTheta - startTheta));
+		if (!Number.isFinite(t)) return;
+		const sinStartTheta = Math.sin(startTheta);
+		const cosStartTheta = Math.cos(startTheta);
+		const sinEndTheta = Math.sin(endTheta);
+		const cosEndTheta = Math.cos(endTheta);
+		let point1 = pt(cosStartTheta - t * sinStartTheta, sinStartTheta + t * cosStartTheta);
+		let endPoint = pt(cosEndTheta, sinEndTheta);
+		let point2 = ptAdd(endPoint, pt(t * sinEndTheta, -t * cosEndTheta));
+		point1 = pointTransform.mapPoint(point1);
+		point2 = pointTransform.mapPoint(point2);
+		if (i === numSegments - 1) endPoint = arc.endPoint;
+		else endPoint = pointTransform.mapPoint(endPoint);
+		yield [
+			point1,
+			point2,
+			endPoint
+		];
+	}
+}
+function* arcToCubic(startPoint, rx, ry, rotation, large, sweep, endPoint) {
+	const arc = {
+		startPoint,
+		rx,
+		ry,
+		rotation,
+		large,
+		sweep,
+		endPoint
+	};
+	if (isZeroLength(arc)) return;
+	else if (isStraightLine(arc)) yield [
+		null,
+		null,
+		arc.endPoint
+	];
+	else yield* ellipticalArcToCubic(arc);
+}
+//#endregion
+//#region src/build/core/flatten/path.ts
+var CMD_ARGS = {
+	m: 2,
+	z: 0,
+	l: 2,
+	h: 1,
+	v: 1,
+	c: 6,
+	s: 4,
+	q: 4,
+	t: 2,
+	a: 7
+};
+for (const [k, v] of Object.entries(CMD_ARGS)) CMD_ARGS[k.toUpperCase()] = v;
+var CMD_COORDS = {
+	m: [[0], [1]],
+	z: [[], []],
+	l: [[0], [1]],
+	h: [[0], []],
+	v: [[], [0]],
+	c: [[
+		0,
+		2,
+		4
+	], [
+		1,
+		3,
+		5
+	]],
+	s: [[0, 2], [1, 3]],
+	q: [[0, 2], [1, 3]],
+	t: [[0], [1]],
+	a: [[5], [6]]
+};
+for (const [k, v] of Object.entries(CMD_COORDS)) CMD_COORDS[k.toUpperCase()] = v;
+function numArgs(cmd) {
+	const n = CMD_ARGS[cmd];
+	if (n === void 0) throw new Error(`Invalid svg command "${cmd}"`);
+	return n;
+}
+function checkCmd(cmd, args) {
+	const cmdArgs = numArgs(cmd);
+	if (cmdArgs === 0) {
+		if (args.length) throw new Error(`${cmd} has no args, ${args.length} invalid`);
+	} else if (args.length % cmdArgs !== 0) throw new Error(`${cmd} has sets of ${cmdArgs} args, ${args.length} invalid`);
+	return cmdArgs;
+}
+function cmdCoords(cmd) {
+	const coords = CMD_COORDS[cmd];
+	if (coords === void 0) throw new Error(`Invalid svg command "${cmd}"`);
+	return coords;
+}
+function pathSegment(cmd, ...args) {
+	const argsPerCmd = checkCmd(cmd, args);
+	const strArgs = args.map(ntos);
+	const combinedArgs = [];
+	const [xCoords, yCoords] = cmdCoords(cmd);
+	const xyCoords = new Set(xCoords.map((x, i) => `${x},${yCoords[i]}`).slice(0, yCoords.length));
+	if (argsPerCmd) for (let n = 0; n < strArgs.length / argsPerCmd; n++) {
+		const subArgs = strArgs.slice(n * argsPerCmd, (n + 1) * argsPerCmd);
+		let i = 0;
+		while (i < subArgs.length) if (xyCoords.has(`${i},${i + 1}`)) {
+			combinedArgs.push(`${subArgs[i]},${subArgs[i + 1]}`);
+			i += 2;
+		} else {
+			combinedArgs.push(subArgs[i]);
+			i += 1;
+		}
+	}
+	return cmd + combinedArgs.join(" ");
+}
+var CMD_RE = /([mzlhvcsqtaMZLHVCSQTA])/;
+var SEPARATOR_RE = /[, ]+/;
+var FLOAT_RE = /* @__PURE__ */ new RegExp("^[-+]?(?:(?:0|[1-9][0-9]*)(?:\\.[0-9]+)?|(?:\\.[0-9]+))(?:[eE][-+]?[0-9]+)?");
+var BOOL_RE = /^[01]/;
+var ARC_ARGUMENT_TYPES = [
+	FLOAT_RE,
+	FLOAT_RE,
+	FLOAT_RE,
+	BOOL_RE,
+	BOOL_RE,
+	FLOAT_RE,
+	FLOAT_RE
+];
+var IMPLICIT_REPEAT_CMD = {
+	m: "l",
+	M: "L"
+};
+function parseArgs(cmd, rawArgsStr) {
+	const rawArgs = rawArgsStr.split(SEPARATOR_RE).filter((s) => s);
+	const result = [];
+	if (!rawArgs.length) return result;
+	const argTypes = cmd.toUpperCase() === "A" ? ARC_ARGUMENT_TYPES : [FLOAT_RE];
+	const n = argTypes.length;
+	let i = 0;
+	let j = 0;
+	while (j < rawArgs.length) {
+		const arg = rawArgs[j];
+		const m = argTypes[i % n].exec(arg);
+		if (!m) throw new Error(`Invalid path data "${cmd}${rawArgsStr.slice(0, 40)}": argument #${i + 1} (${arg}) is not a number`);
+		const end = m[0].length;
+		result.push(parseFloat(arg.slice(0, end)));
+		if (end < arg.length) rawArgs[j] = arg.slice(end);
+		else j += 1;
+		i += 1;
+	}
+	return result;
+}
+function explodeCmd(argsPerCmd, cmd, args) {
+	const cmds = [];
+	for (let i = 0; i < Math.floor(args.length / argsPerCmd); i++) {
+		if (i > 0) cmd = IMPLICIT_REPEAT_CMD[cmd] ?? cmd;
+		cmds.push([cmd, args.slice(i * argsPerCmd, (i + 1) * argsPerCmd)]);
+	}
+	return cmds;
+}
+function parseSvgPath(svgPath, exploded = false) {
+	const commandTuples = [];
+	const parts = svgPath.split(CMD_RE).slice(1);
+	for (let i = 0; i < parts.length; i += 2) {
+		const cmd = parts[i];
+		const args = parseArgs(cmd, (parts[i + 1] ?? "").trim());
+		const argsPerCmd = checkCmd(cmd, args);
+		if (argsPerCmd === 0 || !exploded) commandTuples.push([cmd, args]);
+		else commandTuples.push(...explodeCmd(argsPerCmd, cmd, args));
+	}
+	return commandTuples;
+}
+function addCmdToD(d, cmd, args) {
+	const snippet = pathSegment(cmd, ...args);
+	return d ? `${d} ${snippet}` : snippet;
+}
+function buildD(cmds) {
+	let d = "";
+	for (const [cmd, args] of cmds) d = addCmdToD(d, cmd, args);
+	return d;
+}
+function nextPos(currPos, cmd, cmdArgs) {
+	const [xCoordIdxs, yCoordIdxs] = cmdCoords(cmd);
+	let newX = currPos.x;
+	let newY = currPos.y;
+	if (cmd === cmd.toUpperCase()) {
+		if (xCoordIdxs.length) newX = 0;
+		if (yCoordIdxs.length) newY = 0;
+	}
+	if (xCoordIdxs.length) newX += cmdArgs[xCoordIdxs[xCoordIdxs.length - 1]];
+	if (yCoordIdxs.length) newY += cmdArgs[yCoordIdxs[yCoordIdxs.length - 1]];
+	return pt(newX, newY);
+}
+function explicitLinesCallback(_subpathStart, currPos, cmd, args) {
+	let newArgs;
+	if (cmd === "v") newArgs = [0, args[0]];
+	else if (cmd === "V") newArgs = [currPos.x, args[0]];
+	else if (cmd === "h") newArgs = [args[0], 0];
+	else if (cmd === "H") newArgs = [args[0], currPos.y];
+	else return [[cmd, [...args]]];
+	return [[cmd === cmd.toLowerCase() ? "l" : "L", newArgs]];
+}
+function rewriteCoords(cmdConverter, coordConverter, currPos, cmd, args) {
+	const [xCoordIdxs, yCoordIdxs] = cmdCoords(cmd);
+	const desiredCmd = cmdConverter(cmd);
+	const newArgs = [...args];
+	if (cmd !== desiredCmd) {
+		cmd = desiredCmd;
+		for (const xCoordIdx of xCoordIdxs) newArgs[xCoordIdx] += coordConverter(currPos.x);
+		for (const yCoordIdx of yCoordIdxs) newArgs[yCoordIdx] += coordConverter(currPos.y);
+	}
+	return [cmd, newArgs];
+}
+function relativeToAbsolute(currPos, cmd, args) {
+	return rewriteCoords((c) => c.toUpperCase(), (scaler) => scaler, currPos, cmd, args);
+}
+function moveEndpoint(currPos, cmd, cmdArgs, newEndpoint) {
+	const [[newCmd, newArgs]] = explicitLinesCallback(null, currPos, cmd, cmdArgs);
+	cmd = newCmd;
+	const args = [...newArgs];
+	const [xCoordIdxs, yCoordIdxs] = cmdCoords(cmd);
+	if (xCoordIdxs.length || yCoordIdxs.length) {
+		let { x: newX, y: newY } = newEndpoint;
+		if (cmd === cmd.toLowerCase()) {
+			newX = newX - currPos.x;
+			newY = newY - currPos.y;
+		}
+		args[xCoordIdxs[xCoordIdxs.length - 1]] = newX;
+		args[yCoordIdxs[yCoordIdxs.length - 1]] = newY;
+	}
+	return [cmd, args];
+}
+function walkPath(d, callback) {
+	let currPos = pt();
+	let subpathStartPos = currPos;
+	const newCmds = [];
+	const exploded = parseSvgPath(d, true);
+	for (let idx = 0; idx < exploded.length; idx++) {
+		let [cmd, args] = exploded[idx];
+		checkCmd(cmd, args);
+		if (idx === 0 && cmd === "m") cmd = "M";
+		let prev = [
+			null,
+			null,
+			null
+		];
+		if (newCmds.length) prev = newCmds[newCmds.length - 1];
+		for (const [newCmd, newCmdArgs] of callback(subpathStartPos, currPos, cmd, args, ...prev)) {
+			let next;
+			if (newCmd.toLowerCase() !== "z") next = nextPos(currPos, newCmd, newCmdArgs);
+			else next = subpathStartPos;
+			const prevPos = currPos;
+			currPos = next;
+			if (newCmd.toUpperCase() === "M") subpathStartPos = currPos;
+			newCmds.push([
+				prevPos,
+				newCmd,
+				newCmdArgs
+			]);
+		}
+	}
+	let newD = "";
+	for (const [, cmd, args] of newCmds) newD = addCmdToD(newD, cmd, args);
+	return newD;
+}
+function rewritePath(d, rewriteFn) {
+	return walkPath(d, (subpathStart, currPos, cmd, args) => {
+		let [newCmd, newCmdArgs] = rewriteFn(currPos, cmd, args);
+		const next = nextPos(currPos, newCmd, newCmdArgs);
+		if (!ptEquals(next, subpathStart) && ptAlmostEquals(next, subpathStart)) [newCmd, newCmdArgs] = moveEndpoint(currPos, newCmd, newCmdArgs, subpathStart);
+		return [[newCmd, newCmdArgs]];
+	});
+}
+function absolutePath(d) {
+	return rewritePath(d, relativeToAbsolute);
+}
+function absoluteMoveto(d) {
+	return rewritePath(d, (currPos, cmd, args) => {
+		if (cmd === "M" || cmd === "m") return relativeToAbsolute(currPos, cmd, args);
+		return [cmd, [...args]];
+	});
+}
+function explicitLines(d) {
+	return walkPath(d, explicitLinesCallback);
+}
+function expandShorthand(d) {
+	const shortToLong = {
+		S: "C",
+		T: "Q"
+	};
+	return walkPath(d, (_, currPos, cmd, args, prevPos, prevCmd, prevArgs) => {
+		if (!(cmd.toUpperCase() in shortToLong)) return [[cmd, args]];
+		if (cmd === cmd.toLowerCase()) [cmd, args] = relativeToAbsolute(currPos, cmd, args);
+		let newCp = [currPos.x, currPos.y];
+		if (prevCmd) {
+			if (prevCmd === prevCmd.toLowerCase()) [prevCmd, prevArgs] = relativeToAbsolute(prevPos, prevCmd, prevArgs);
+			if (Object.values(shortToLong).includes(prevCmd)) {
+				const prevCpX = prevArgs[prevArgs.length - 4];
+				const prevCpY = prevArgs[prevArgs.length - 3];
+				newCp = [2 * currPos.x - prevCpX, 2 * currPos.y - prevCpY];
+			}
+		}
+		return [[shortToLong[cmd], [...newCp, ...args]]];
+	});
+}
+function arcsToCubics(d) {
+	return walkPath(d, (_subpathStart, currPos, cmd, args) => {
+		if (cmd !== "a" && cmd !== "A") return [[cmd, args]];
+		const rx = args[0];
+		const ry = args[1];
+		const xRotation = args[2];
+		const large = args[3];
+		const sweep = args[4];
+		let endX = args[5];
+		let endY = args[6];
+		if (cmd === "a") {
+			endX += currPos.x;
+			endY += currPos.y;
+		}
+		const result = [];
+		for (const [p1, p2, target] of arcToCubic(currPos, rx, ry, xRotation, large, sweep, pt(endX, endY))) {
+			const { x, y } = target;
+			if (p1 !== null) result.push(["C", [
+				p1.x,
+				p1.y,
+				p2.x,
+				p2.y,
+				x,
+				y
+			]]);
+			else result.push(["L", [x, y]]);
+		}
+		return result;
+	});
+}
+function subpaths(d) {
+	const result = [""];
+	walkPath(absoluteMoveto(d), (_subpathStart, _currPos, cmd, args) => {
+		if (cmd.toUpperCase() === "M") result.push("");
+		result[result.length - 1] = addCmdToD(result[result.length - 1], cmd, args);
+		if (cmd.toUpperCase() === "Z") result.push("");
+		return [[cmd, args]];
+	});
+	return result.filter((s) => s);
+}
+function roundFloatsD(d, ndigits) {
+	let out = "";
+	for (const [cmd, args] of parseSvgPath(d)) out = addCmdToD(out, cmd, args.map((n) => pythonRound(n, ndigits)));
+	return out;
+}
+function asCmdSeq(d) {
+	return parseSvgPath(arcsToCubics(absolutePath(expandShorthand(explicitLines(d)))), true);
+}
+//#endregion
+//#region src/build/core/flatten/shape.ts
+var f = (name, type, dflt) => ({
+	name,
+	type,
+	default: dflt
+});
+var COMMON_FIELDS = [
+	f("id", "str", ""),
+	f("clip_path", "str", attribDefault("clip-path")),
+	f("clip_rule", "str", attribDefault("clip-rule")),
+	f("fill", "str", attribDefault("fill")),
+	f("fill_opacity", "float", attribDefault("fill-opacity")),
+	f("fill_rule", "str", attribDefault("fill-rule")),
+	f("stroke", "str", attribDefault("stroke")),
+	f("stroke_width", "float", attribDefault("stroke-width")),
+	f("stroke_linecap", "str", attribDefault("stroke-linecap")),
+	f("stroke_linejoin", "str", attribDefault("stroke-linejoin")),
+	f("stroke_miterlimit", "float", attribDefault("stroke-miterlimit")),
+	f("stroke_dasharray", "str", attribDefault("stroke-dasharray")),
+	f("stroke_dashoffset", "float", attribDefault("stroke-dashoffset")),
+	f("stroke_opacity", "float", attribDefault("stroke-opacity")),
+	f("opacity", "float", attribDefault("opacity")),
+	f("transform", "str", attribDefault("transform")),
+	f("style", "str", attribDefault("style")),
+	f("display", "str", attribDefault("display"))
+];
+var TAG_FIELDS = {
+	path: [f("d", "str", "")],
+	circle: [
+		f("r", "float", 0),
+		f("cx", "float", 0),
+		f("cy", "float", 0)
+	],
+	ellipse: [
+		f("rx", "float", 0),
+		f("ry", "float", 0),
+		f("cx", "float", 0),
+		f("cy", "float", 0)
+	],
+	line: [
+		f("x1", "float", 0),
+		f("y1", "float", 0),
+		f("x2", "float", 0),
+		f("y2", "float", 0)
+	],
+	polygon: [f("points", "str", "")],
+	polyline: [f("points", "str", "")],
+	rect: [
+		f("x", "float", 0),
+		f("y", "float", 0),
+		f("width", "float", 0),
+		f("height", "float", 0),
+		f("rx", "float", 0),
+		f("ry", "float", 0)
+	]
+};
+var SHAPE_TAGS = new Set(Object.keys(TAG_FIELDS));
+function isShapeTag(tag) {
+	return SHAPE_TAGS.has(stripNs(tag));
+}
+function shapeFields(tag) {
+	const extra = TAG_FIELDS[tag];
+	if (!extra) throw new Error(`Bad tag <${tag}>`);
+	return [...COMMON_FIELDS, ...extra];
+}
+function newShape(tag) {
+	const fields = {};
+	for (const field of shapeFields(tag)) fields[field.name] = field.default;
+	return {
+		tag,
+		fields
+	};
+}
+function shapeStr(shape, name) {
+	return shape.fields[name];
+}
+function shapeNum(shape, name) {
+	return shape.fields[name];
+}
+function cloneShape(shape) {
+	return {
+		tag: shape.tag,
+		fields: { ...shape.fields }
+	};
+}
+function shapesEqual(a, b) {
+	if (a.tag !== b.tag) return false;
+	for (const field of shapeFields(a.tag)) if (a.fields[field.name] !== b.fields[field.name]) return false;
+	return true;
+}
+function parseFloatStrict(raw, tag, attr) {
+	const value = Number(raw.trim());
+	if (Number.isNaN(value)) throw new Error(`${attr}="${raw}" on <${tag}> is not a number (units other than px are not supported)`);
+	return value;
+}
+function fromElement(el, inheritedAttrib = {}) {
+	if (!isShapeTag(el.tag)) throw new Error(`Bad tag <${el.tag}>`);
+	const tag = stripNs(el.tag);
+	const attrs = { ...inheritedAttrib };
+	for (const [name, value] of el.attrib) attrs[name] = value;
+	const shape = newShape(tag);
+	for (const field of shapeFields(tag)) {
+		const raw = attrs[attrName(field.name)];
+		if (raw === void 0 || !raw.trim()) continue;
+		shape.fields[field.name] = field.type === "float" ? parseFloatStrict(raw, tag, attrName(field.name)) : raw;
+	}
+	if (tag === "rect") rectPostInit(shape);
+	return shape;
+}
+function rectPostInit(shape) {
+	if (!shapeNum(shape, "rx")) shape.fields.rx = shapeNum(shape, "ry");
+	if (!shapeNum(shape, "ry")) shape.fields.ry = shapeNum(shape, "rx");
+	shape.fields.rx = Math.min(shapeNum(shape, "rx"), shapeNum(shape, "width") / 2);
+	shape.fields.ry = Math.min(shapeNum(shape, "ry"), shapeNum(shape, "height") / 2);
+}
+function toElement(shape, inheritedAttrib = {}) {
+	const el = new XEl(svgTag(shape.tag));
+	for (const field of shapeFields(shape.tag)) {
+		const attr = attrName(field.name);
+		const fieldValue = shape.fields[field.name];
+		const attribValue = typeof fieldValue === "number" ? ntos(fieldValue) : fieldValue;
+		if (attr in inheritedAttrib) {
+			if (attribValue === inheritedAttrib[attr]) continue;
+		} else if (fieldValue === field.default) continue;
+		el.attrib.set(attr, attribValue);
+	}
+	return el;
+}
+function resetFields(shape, pred) {
+	for (const field of shapeFields(shape.tag)) if (pred(field.name)) shape.fields[field.name] = field.default;
+}
+function copyCommonFields(target, source) {
+	for (const field of COMMON_FIELDS) target.fields[field.name] = source.fields[field.name];
+}
+function pathFromD(d) {
+	const path = newShape("path");
+	path.fields.d = d;
+	return path;
+}
+function pathFromCommands(cmds) {
+	return pathFromD(buildD(cmds));
+}
+function asPath(shape) {
+	if (shape.tag === "path") return shape;
+	const fields = shape.fields;
+	let d = "";
+	const add = (cmd, ...args) => {
+		d = addCmdToD(d, cmd, args);
+	};
+	const addArc = (rx, ry, x, y, large = 0) => {
+		const snippet = pathSegment("A", rx, ry, 0, large, 1, x, y);
+		d = d ? `${d} ${snippet}` : snippet;
+	};
+	switch (shape.tag) {
+		case "circle":
+		case "ellipse": {
+			const rx = shape.tag === "circle" ? fields.r : fields.rx;
+			const ry = shape.tag === "circle" ? fields.r : fields.ry;
+			const cx = fields.cx;
+			const cy = fields.cy;
+			add("M", cx + rx, cy);
+			addArc(rx, ry, cx - rx, cy, 1);
+			addArc(rx, ry, cx + rx, cy, 1);
+			d = `${d} Z`;
+			break;
+		}
+		case "line":
+			add("M", fields.x1, fields.y1);
+			add("L", fields.x2, fields.y2);
+			break;
+		case "polygon":
+			d = fields.points ? `M${fields.points} Z` : "";
+			break;
+		case "polyline":
+			d = fields.points ? `M${fields.points}` : "";
+			break;
+		case "rect": {
+			const x = fields.x;
+			const y = fields.y;
+			const w = fields.width;
+			const h = fields.height;
+			const rx = fields.rx;
+			const ry = fields.ry;
+			add("M", x + rx, y);
+			add("H", x + w - rx);
+			if (rx > 0) addArc(rx, ry, x + w, y + ry);
+			add("V", y + h - ry);
+			if (rx > 0) addArc(rx, ry, x + w - rx, y + h);
+			add("H", x + rx);
+			if (rx > 0) addArc(rx, ry, x, y + h - ry);
+			add("V", y + ry);
+			if (rx > 0) addArc(rx, ry, x + rx, y);
+			d = `${d} Z`;
+			break;
+		}
+		default: throw new Error(`as_path not implemented for <${shape.tag}>`);
+	}
+	const path = pathFromD(d);
+	copyCommonFields(path, shape);
+	return path;
+}
+function shapeCmdSeq(shape) {
+	return asCmdSeq(shapeStr(asPath(shape), "d"));
+}
+function absoluteShape(shape) {
+	if (shape.tag !== "path") return shape;
+	const target = cloneShape(shape);
+	target.fields.d = absolutePath(shapeStr(target, "d"));
+	return target;
+}
+function explicitLinesExpandShorthand(shape) {
+	if (shape.tag !== "path") return shape;
+	const target = cloneShape(shape);
+	target.fields.d = expandShorthand(explicitLines(shapeStr(target, "d")));
+	return target;
+}
+function applyTransform(shape, transform, ops) {
+	let target = asPath(shape);
+	if (target === shape) target = cloneShape(target);
+	let cmds = [["M", [0, 0]]];
+	if (!transform.isDegenerate()) cmds = ops.transformCmds(shapeCmdSeq(shape), transform);
+	target.fields.d = buildD(cmds);
+	return target;
+}
+function removeOverlaps(shape, ops) {
+	const cmds = ops.removeOverlaps(shapeCmdSeq(shape), shapeStr(shape, "fill_rule"));
+	const target = cloneShape(asPath(shape));
+	target.fields.fill_rule = "nonzero";
+	target.fields.clip_rule = "nonzero";
+	target.fields.d = buildD(cmds);
+	return target;
+}
+function strokeCommands(shape, tolerance, ops) {
+	let dashArray = [];
+	const dasharray = shapeStr(shape, "stroke_dasharray");
+	if (dasharray !== "none") dashArray = dasharray.split(DASHARRAY_SEPARATOR).filter((v) => v).map((v) => parseFloatStrict(v, shape.tag, "stroke-dasharray"));
+	if (dashArray.length % 2 !== 0) dashArray = [...dashArray, ...dashArray];
+	return ops.strokeCmds(shapeCmdSeq(shape), shapeStr(shape, "stroke_linecap"), shapeStr(shape, "stroke_linejoin"), shapeNum(shape, "stroke_width"), shapeNum(shape, "stroke_miterlimit"), tolerance, dashArray, shapeNum(shape, "stroke_dashoffset"));
+}
+function parseCssDeclarations(style, output, propertyNames) {
+	const unparsed = [];
+	for (let declaration of style.split(";")) {
+		declaration = declaration.trim();
+		if ((declaration.match(/:/g) ?? []).length === 1) {
+			const [rawName, rawValue] = declaration.split(":");
+			const propertyName = rawName.trim();
+			const value = rawValue.trim();
+			if (propertyNames === void 0 || propertyNames.has(propertyName)) output[propertyName] = value;
+			else unparsed.push(declaration);
+		} else if (declaration) throw new Error(`Invalid CSS declaration syntax: ${declaration}`);
+	}
+	return unparsed.length ? unparsed.join("; ") + ";" : "";
+}
+function applyStyleAttribute(shape) {
+	const target = cloneShape(shape);
+	const style = shapeStr(target, "style");
+	if (style) {
+		const fields = shapeFields(target.tag);
+		const attrTypes = new Map(fields.map((fd) => [attrName(fd.name), fd]));
+		const rawAttrs = {};
+		const unparsedStyle = parseCssDeclarations(style, rawAttrs, new Set(attrTypes.keys()));
+		for (const [attr, rawValue] of Object.entries(rawAttrs)) {
+			const field = attrTypes.get(attr);
+			target.fields[field.name] = field.type === "float" ? parseFloatStrict(rawValue, target.tag, attr) : rawValue;
+		}
+		target.fields.style = unparsedStyle;
+	}
+	return target;
+}
+function mightPaint(shape, ops) {
+	const styled = applyStyleAttribute(shape);
+	if (shapeStr(styled, "display") === "none") return false;
+	const visible = (fill, opacity) => fill !== "none" && shapeNum(styled, "opacity") * opacity !== 0;
+	if (shapeCmdSeq(shape).every(([c]) => c.toUpperCase() === "M")) return false;
+	if (visible(shapeStr(styled, "stroke"), shapeNum(styled, "stroke_opacity")) && shapeNum(styled, "stroke_width") !== 0) return true;
+	if (!visible(shapeStr(styled, "fill"), shapeNum(styled, "fill_opacity"))) return false;
+	return ops.pathArea(shapeCmdSeq(styled), shapeStr(styled, "fill_rule")) > 0;
+}
+function normalizeOpacity(shape) {
+	if (shapeStr(shape, "fill") === "none" && shapeStr(shape, "stroke") === "none") return;
+	for (const [fillAttr, opacityAttr] of [["fill", "stroke_opacity"], ["stroke", "fill_opacity"]]) if (shapeStr(shape, fillAttr) === "none") {
+		shape.fields.opacity = shapeNum(shape, "opacity") * shapeNum(shape, opacityAttr);
+		shape.fields[opacityAttr] = 1;
+	}
+}
+function roundShapeFloats(shape, ndigits) {
+	for (const field of shapeFields(shape.tag)) {
+		const value = shape.fields[field.name];
+		if (field.type === "float" && typeof value === "number") shape.fields[field.name] = pythonRound(value, ndigits);
+	}
+	if (shape.tag === "path") shape.fields.d = roundFloatsD(shapeStr(shape, "d"), ndigits);
+}
+function removeEmptySubpaths(shape, ops) {
+	if (shape.tag !== "path") return;
+	shape.fields.d = subpaths(shapeStr(shape, "d")).filter((sub) => mightPaint(pathFromD(sub), ops)).join(" ");
+}
+//#endregion
+//#region src/build/core/flatten/element.ts
+var GRADIENT_TAGS = /* @__PURE__ */ new Set(["linearGradient", "radialGradient"]);
+function numberAttrib(el, name, fallback) {
+	return parseFloat(el.attrib.get(name) ?? String(fallback));
+}
+function isTag(el, local) {
+	return stripNs(el.tag) === local;
+}
+function isDefs(tag) {
+	return stripNs(tag) === "defs";
+}
+function isGradient(tag) {
+	return GRADIENT_TAGS.has(stripNs(tag));
+}
+function isGroup(tag) {
+	return stripNs(tag) === "g";
+}
+function clamp(value, minv = 0, maxv = 1) {
+	return Math.max(Math.min(value, maxv), minv);
+}
+function elOpacity(el) {
+	return clamp(numberAttrib(el, "opacity", 1));
+}
+function isRemovableGroup(el) {
+	if (!isGroup(el.tag)) return false;
+	if (el.attrib.size === 0) return true;
+	const numChildren = el.children.length;
+	const opacity = elOpacity(el);
+	return numChildren <= 1 || opacity === 0 || opacity === 1;
+}
+function tryRemoveGroup(groupEl, pushOpacity = true) {
+	const remove = isRemovableGroup(groupEl);
+	const opacity = elOpacity(groupEl);
+	if (remove) {
+		const children = [...groupEl.children];
+		if (groupEl.parent !== null) replaceEl(groupEl, children);
+		if (pushOpacity) for (const child of children) inheritAttrib({ opacity: ntos(opacity) }, child);
+	} else {
+		groupEl.attrib.clear();
+		groupEl.attrib.set("opacity", ntos(opacity));
+		dropDefaultAttrib(groupEl.attrib);
+	}
+	return remove;
+}
+function elementTransform(el, currentTransform = Affine2D.identity()) {
+	const attr = isGradient(el.tag) ? "gradientTransform" : "transform";
+	const raw = el.attrib.get(attr);
+	if (raw) return Affine2D.composeLtr([Affine2D.fromString(raw), currentTransform]);
+	return currentTransform;
+}
+function idOfTarget(url) {
+	const match = URL_ID_REFERENCE.exec(url);
+	if (!match) throw new Error(`Unrecognized url "${url}"`);
+	return match[1];
+}
+function parseViewBox(s) {
+	const box = s.split(VIEWBOX_SEPARATOR).filter((v) => v).map((v) => parseFloat(v));
+	if (box.length !== 4 || box.some((v) => Number.isNaN(v))) throw new Error(`Unable to parse viewBox: ${s}`);
+	return {
+		x: box[0],
+		y: box[1],
+		w: box[2],
+		h: box[3]
+	};
+}
+//#endregion
+//#region src/build/core/flatten/stages/use.ts
+function expandUses(doc, scopeEl) {
+	const attribNotCopied = /* @__PURE__ */ new Set([
+		"x",
+		"y",
+		"width",
+		"height",
+		"transform",
+		xlinkHrefAttr(),
+		"href"
+	]);
+	const elById = /* @__PURE__ */ new Map();
+	for (const el of findAll(doc.root, (e) => e.attrib.has("id"))) elById.set(el.attrib.get("id"), el);
+	for (;;) {
+		const useEls = findAll(scopeEl, (e) => isTag(e, "use"));
+		if (!useEls.length) break;
+		const swaps = [];
+		for (const useEl of useEls) {
+			const ref = useEl.attrib.get(xlinkHrefAttr()) ?? useEl.attrib.get("href");
+			if (ref === void 0) throw new Error("<use> has no href attribute to resolve");
+			if (!ref.startsWith("#")) throw new Error(`<use> href "${ref}" is not supported: only same-document #id references are`);
+			const target = elById.get(ref.slice(1));
+			if (target === void 0) throw new Error(`<use> references ${ref}, but no element has id "${ref.slice(1)}"`);
+			const newEl = target.deepClone();
+			for (const el of newEl.iter()) el.attrib.delete("id");
+			const group = new XEl(svgTag("g"));
+			let affine = Affine2D.identity().translate(numberAttrib(useEl, "x", 0), numberAttrib(useEl, "y", 0));
+			const useTransform = useEl.attrib.get("transform");
+			if (useTransform !== void 0) affine = Affine2D.composeLtr([affine, Affine2D.fromString(useTransform)]);
+			if (!affine.equals(Affine2D.identity())) group.attrib.set("transform", affine.toString());
+			for (const [name, value] of useEl.attrib) {
+				if (attribNotCopied.has(name)) continue;
+				group.attrib.set(name, value);
+			}
+			group.append(newEl);
+			if (tryRemoveGroup(group, false)) {
+				inheritAttrib(group.attrib, newEl);
+				swaps.push([useEl, newEl]);
+			} else swaps.push([useEl, group]);
+		}
+		for (const [oldEl, newEl] of swaps) replaceEl(oldEl, [newEl]);
+	}
+}
+function resolveUse(doc) {
+	doc.syncTree();
+	expandUses(doc, doc.root);
+}
+//#endregion
+//#region src/build/core/flatten/stages/clip-path.ts
+function resolveClipPath(doc, clipPathUrl, transform = Affine2D.identity()) {
+	const clipPathEl = doc.resolveUrl(clipPathUrl, "clipPath");
+	expandUses(doc, clipPathEl);
+	const clipTransform = elementTransform(clipPathEl, transform);
+	const clipShapes = clipPathEl.children.map((e) => applyTransform(fromElement(e), elementTransform(e, clipTransform), doc.ops));
+	let clip = pathFromCommands(doc.ops.union(clipShapes.map((s) => shapeCmdSeq(s)), clipShapes.map((s) => shapeStr(s, "clip_rule"))));
+	const nestedClip = clipPathEl.attrib.get("clip-path");
+	if (nestedClip !== void 0) {
+		const clipClop = resolveClipPath(doc, nestedClip, clipTransform);
+		clip = pathFromCommands(doc.ops.intersection([shapeCmdSeq(clip), shapeCmdSeq(clipClop)], [shapeStr(clip, "clip_rule"), shapeStr(clipClop, "clip_rule")]));
+	}
+	return clip;
+}
+//#endregion
+//#region src/build/core/flatten/document.ts
+var MAX_PCT_ERROR = .1;
+var DEFAULT_DEFAULT_TOLERANCE = .1;
+var SvgDocument = class SvgDocument {
+	root;
+	ops;
+	shapeCache = null;
+	constructor(root, ops) {
+		this.root = root;
+		this.ops = ops;
+	}
+	static parse(content, ops) {
+		return new SvgDocument(parseSvgDocument(content), ops);
+	}
+	hasShapes() {
+		return this.shapeCache !== null;
+	}
+	shapeEntries() {
+		if (this.shapeCache) return this.shapeCache;
+		const entries = [];
+		for (const context of this.depthFirst(false)) {
+			const el = context.element;
+			if (!isShapeTag(el.tag)) continue;
+			entries.push([el, [fromElement(el, context.attrib)]]);
+		}
+		this.shapeCache = entries;
+		return this.shapeCache;
+	}
+	invalidateShapes() {
+		this.shapeCache = null;
+	}
+	mapShapes(fn) {
+		const entries = this.shapeEntries();
+		entries.forEach(([el, shapes], idx) => {
+			entries[idx] = [el, shapes.map(fn)];
+		});
+	}
+	forEachShape(fn) {
+		for (const [, shapes] of this.shapeEntries()) for (const shape of shapes) fn(shape);
+	}
+	inheritedAttrib(el) {
+		const parents = [];
+		let current = el.parent;
+		while (current !== null) {
+			parents.push(current);
+			current = current.parent;
+		}
+		let attrib = { ...INHERITABLE_ATTRIB_DEFAULTS };
+		for (const parent of parents.reverse()) attrib = attribToPassOn(attrib, parent);
+		return attrib;
+	}
+	syncTree() {
+		if (!this.shapeCache) return;
+		for (const [oldEl, shapes] of this.shapeCache) {
+			const inherited = this.inheritedAttrib(oldEl);
+			replaceEl(oldEl, shapes.map((s) => toElement(s, inherited)));
+		}
+		this.shapeCache = null;
+	}
+	viewBox() {
+		const raw = this.root.attrib.get("viewBox");
+		if (raw === void 0) {
+			const w = this.root.attrib.get("width");
+			const h = this.root.attrib.get("height");
+			if (w && h) return {
+				x: 0,
+				y: 0,
+				w: parseFloat(w),
+				h: parseFloat(h)
+			};
+			return null;
+		}
+		return parseViewBox(raw);
+	}
+	get tolerance() {
+		const vbox = this.viewBox();
+		if (vbox === null) return DEFAULT_DEFAULT_TOLERANCE;
+		return Math.min(vbox.w, vbox.h) * MAX_PCT_ERROR / 100;
+	}
+	resolveUrl(url, elTag) {
+		const id = idOfTarget(url);
+		const matches = findAll(this.root, (el) => el.attrib.get("id") === id && (elTag === "*" || stripNs(el.tag) === elTag));
+		if (matches.length !== 1) {
+			const what = elTag === "*" ? "element" : `<${elTag}>`;
+			throw new Error(matches.length === 0 ? `${url} references ${what} with id "${id}", but no such element exists` : `${url} matches ${matches.length} ${what} elements with id "${id}", expected exactly one`);
+		}
+		return matches[0];
+	}
+	*traverse(nextFn, appendFn, resolveClipPaths) {
+		const frontier = [{
+			nthOfType: 0,
+			element: this.root,
+			path: "/svg[0]",
+			transform: Affine2D.identity(),
+			clips: [],
+			attrib: attribToPassOn({ ...INHERITABLE_ATTRIB_DEFAULTS }, this.root)
+		}];
+		while (frontier.length) {
+			const context = nextFn(frontier);
+			yield context;
+			const childIdxs = {};
+			const newEntries = [];
+			for (const child of context.element.children) {
+				const transform = elementTransform(child, context.transform);
+				let clips = context.clips;
+				const clipPathAttr = child.attrib.get("clip-path");
+				if (resolveClipPaths && clipPathAttr && clipPathAttr !== "none") clips = [...clips, resolveClipPath(this, clipPathAttr, transform)];
+				const localName = stripNs(child.tag);
+				const nthOfType = childIdxs[localName] ?? 0;
+				childIdxs[localName] = nthOfType + 1;
+				newEntries.push({
+					nthOfType,
+					element: child,
+					path: `${context.path}/${localName}[${nthOfType}]`,
+					transform,
+					clips,
+					attrib: attribToPassOn(context.attrib, child)
+				});
+			}
+			appendFn(frontier, newEntries);
+		}
+	}
+	depthFirst(resolveClipPaths = true) {
+		return this.traverse((f) => f.pop(), (f, e) => f.push(...e.reverse()), resolveClipPaths);
+	}
+	breadthFirst(resolveClipPaths = true) {
+		return this.traverse((f) => f.shift(), (f, e) => f.push(...e), resolveClipPaths);
+	}
+	serialize() {
+		this.syncTree();
+		return serializeSvg(this.root);
+	}
+};
+//#endregion
+//#region src/build/core/pathkit/contours.ts
+function verbMap(PathKit) {
+	return {
+		MOVE: PathKit.MOVE_VERB ?? 0,
+		LINE: PathKit.LINE_VERB ?? 1,
+		QUAD: PathKit.QUAD_VERB ?? 2,
+		CONIC: PathKit.CONIC_VERB ?? 3,
+		CUBIC: PathKit.CUBIC_VERB ?? 4,
+		CLOSE: PathKit.CLOSE_VERB ?? 5
+	};
+}
+function fillTypes(PathKit) {
+	return {
+		EVENODD: PathKit?.FillType?.EVENODD ?? PathKit?.FillType?.EVEN_ODD ?? 1,
+		WINDING: PathKit?.FillType?.WINDING ?? PathKit?.FillType?.NONZERO ?? 0
+	};
+}
+var EPS = .01;
+function roundN(x, ndigits = 3) {
+	const m = 10 ** ndigits;
+	const s = x * m;
+	if (!Number.isFinite(s)) return x;
+	const floor = Math.floor(s);
+	const frac = s - floor;
+	const TIE_EPS = 1e-12;
+	let roundedInt;
+	if (Math.abs(frac - .5) < TIE_EPS) roundedInt = floor % 2 === 0 ? floor : floor + 1;
+	else if (Math.abs(frac + .5) < TIE_EPS) {
+		const ceil = Math.ceil(s);
+		roundedInt = ceil % 2 === 0 ? ceil : ceil - 1;
+	} else roundedInt = Math.round(s);
+	return roundedInt / m;
+}
+function normPt(p) {
+	return [Math.round(p[0] * 1e4) / 1e4, Math.round(p[1] * 1e4) / 1e4];
+}
+function eqPt(a, b) {
+	const aa = normPt(a);
+	const bb = normPt(b);
+	return Math.abs(aa[0] - bb[0]) < EPS && Math.abs(aa[1] - bb[1]) < EPS;
+}
+function signedAreaPolyline(points) {
+	if (points.length < 3) return 0;
+	let a = 0;
+	for (let i = 0; i < points.length; i++) {
+		const [x1, y1] = points[i];
+		const [x2, y2] = points[(i + 1) % points.length];
+		a += x1 * y2 - x2 * y1;
+	}
+	return a / 2;
+}
+function approxSignedAreaFromContourCmds(contourCmds, VERB, steps = 24) {
+	let cx = 0, cy = 0;
+	let sx = 0, sy = 0;
+	const pts = [];
+	const add = (x, y) => pts.push([x, y]);
+	for (const cmd of contourCmds) {
+		const v = cmd[0];
+		if (v === VERB.MOVE) {
+			cx = cmd[1];
+			cy = cmd[2];
+			sx = cx;
+			sy = cy;
+			add(cx, cy);
+		} else if (v === VERB.LINE) {
+			cx = cmd[1];
+			cy = cmd[2];
+			add(cx, cy);
+		} else if (v === VERB.QUAD) {
+			const x0 = cx, y0 = cy;
+			const x1 = cmd[1], y1 = cmd[2];
+			const x2 = cmd[3], y2 = cmd[4];
+			for (let i = 1; i <= steps; i++) {
+				const t = i / steps;
+				const mt = 1 - t;
+				add(mt * mt * x0 + 2 * mt * t * x1 + t * t * x2, mt * mt * y0 + 2 * mt * t * y1 + t * t * y2);
+			}
+			cx = x2;
+			cy = y2;
+		} else if (v === VERB.CUBIC) {
+			const x0 = cx, y0 = cy;
+			const x1 = cmd[1], y1 = cmd[2];
+			const x2 = cmd[3], y2 = cmd[4];
+			const x3 = cmd[5], y3 = cmd[6];
+			for (let i = 1; i <= steps; i++) {
+				const t = i / steps;
+				const mt = 1 - t;
+				add(mt * mt * mt * x0 + 3 * mt * mt * t * x1 + 3 * mt * t * t * x2 + t * t * t * x3, mt * mt * mt * y0 + 3 * mt * mt * t * y1 + 3 * mt * t * t * y2 + t * t * t * y3);
+			}
+			cx = x3;
+			cy = y3;
+		} else if (v === VERB.CLOSE) add(sx, sy);
+	}
+	if (pts.length && (pts[0][0] !== pts[pts.length - 1][0] || pts[0][1] !== pts[pts.length - 1][1])) pts.push([pts[0][0], pts[0][1]]);
+	return signedAreaPolyline(pts);
+}
+function splitContours(cmds, VERB) {
+	const contours = [];
+	let cur = null;
+	for (const cmd of cmds) if (cmd[0] === VERB.MOVE) {
+		if (cur && cur.length) contours.push(cur);
+		cur = [cmd];
+	} else if (cur) cur.push(cmd);
+	if (cur && cur.length) contours.push(cur);
+	return contours;
+}
+function ensureClosed(contourCmds, VERB) {
+	return contourCmds.some((c) => c[0] === VERB.CLOSE) ? [...contourCmds] : [...contourCmds, [VERB.CLOSE]];
+}
+function explicitCloseWantedFromCmds(contourCmds, VERB) {
+	if (!contourCmds?.length) return false;
+	const m = contourCmds[0];
+	if (m[0] !== VERB.MOVE) return false;
+	const start = [m[1], m[2]];
+	for (let i = contourCmds.length - 1; i >= 1; i--) {
+		const cmd = contourCmds[i];
+		const v = cmd[0];
+		if (v === VERB.CLOSE) continue;
+		let end = null;
+		if (v === VERB.LINE) end = [cmd[1], cmd[2]];
+		else if (v === VERB.QUAD) end = [cmd[3], cmd[4]];
+		else if (v === VERB.CUBIC) end = [cmd[5], cmd[6]];
+		else continue;
+		return eqPt(end, start);
+	}
+	return false;
+}
+function contourToSegments(contourCmds, VERB) {
+	const c = ensureClosed(contourCmds, VERB);
+	const move = c[0];
+	const sx = move[1], sy = move[2];
+	let last = [sx, sy];
+	const segs = [];
+	for (let i = 1; i < c.length; i++) {
+		const cmd = c[i];
+		const v = cmd[0];
+		if (v === VERB.LINE) {
+			const end = [cmd[1], cmd[2]];
+			segs.push({
+				type: "L",
+				start: last,
+				end,
+				synthetic: false
+			});
+			last = end;
+		} else if (v === VERB.QUAD) {
+			const ctrl = [cmd[1], cmd[2]];
+			const end = [cmd[3], cmd[4]];
+			segs.push({
+				type: "Q",
+				start: last,
+				ctrl,
+				end,
+				synthetic: false
+			});
+			last = end;
+		} else if (v === VERB.CUBIC) {
+			const c1 = [cmd[1], cmd[2]];
+			const c2 = [cmd[3], cmd[4]];
+			const end = [cmd[5], cmd[6]];
+			segs.push({
+				type: "C",
+				start: last,
+				c1,
+				c2,
+				end,
+				synthetic: false
+			});
+			last = end;
+		} else if (v === VERB.CLOSE) {
+			const end = [sx, sy];
+			if (!eqPt(last, end)) segs.push({
+				type: "L",
+				start: last,
+				end,
+				synthetic: true
+			});
+			last = end;
+		}
+	}
+	return {
+		start: [sx, sy],
+		segs
+	};
+}
+function applyClosePolicy(segs, startPt, explicitCloseWanted) {
+	if (!segs.length) return segs;
+	for (const s of segs) s.synthetic = false;
+	const lastEnd = segs[segs.length - 1].end;
+	if (!eqPt(lastEnd, startPt)) segs.push({
+		type: "L",
+		start: lastEnd,
+		end: startPt,
+		synthetic: false
+	});
+	if (!explicitCloseWanted) segs[segs.length - 1].synthetic = true;
+	return segs;
+}
+function segmentsToContourCmds(startPt, segs, VERB) {
+	const out = [[
+		VERB.MOVE,
+		roundN(startPt[0]),
+		roundN(startPt[1])
+	]];
+	for (const s of segs) {
+		if (s.synthetic) continue;
+		if (s.type === "L") out.push([
+			VERB.LINE,
+			roundN(s.end[0]),
+			roundN(s.end[1])
+		]);
+		else if (s.type === "Q") out.push([
+			VERB.QUAD,
+			roundN(s.ctrl[0]),
+			roundN(s.ctrl[1]),
+			roundN(s.end[0]),
+			roundN(s.end[1])
+		]);
+		else out.push([
+			VERB.CUBIC,
+			roundN(s.c1[0]),
+			roundN(s.c1[1]),
+			roundN(s.c2[0]),
+			roundN(s.c2[1]),
+			roundN(s.end[0]),
+			roundN(s.end[1])
+		]);
+	}
+	out.push([VERB.CLOSE]);
+	return out;
+}
+function reverseClosedContourKeepStart(contourCmds, explicitCloseWanted, VERB) {
+	const { start, segs } = contourToSegments(contourCmds, VERB);
+	const reversed = segs.slice().reverse().map((s) => {
+		if (s.type === "L") return {
+			type: "L",
+			start: s.end,
+			end: s.start,
+			synthetic: false
+		};
+		if (s.type === "Q") return {
+			type: "Q",
+			start: s.end,
+			ctrl: s.ctrl,
+			end: s.start,
+			synthetic: false
+		};
+		return {
+			type: "C",
+			start: s.end,
+			c1: s.c2,
+			c2: s.c1,
+			end: s.start,
+			synthetic: false
+		};
+	});
+	applyClosePolicy(reversed, start, explicitCloseWanted);
+	return segmentsToContourCmds(start, reversed, VERB);
+}
+function rotateClosedContourToStart(contourCmds, desiredStart, explicitCloseWanted, VERB) {
+	const { segs } = contourToSegments(contourCmds, VERB);
+	let idx = -1;
+	for (let i = 0; i < segs.length; i++) if (eqPt(segs[i].start, desiredStart)) {
+		idx = i;
+		break;
+	}
+	if (idx === -1) {
+		for (let i = 0; i < segs.length; i++) if (eqPt(segs[i].end, desiredStart)) {
+			idx = (i + 1) % segs.length;
+			break;
+		}
+	}
+	if (idx === -1) return [...contourCmds];
+	const rotated = segs.slice(idx).concat(segs.slice(0, idx));
+	applyClosePolicy(rotated, desiredStart, explicitCloseWanted);
+	return segmentsToContourCmds(desiredStart, rotated, VERB);
+}
+function mergeMoves(aMoves, bMoves) {
+	const out = [];
+	const pushUnique = (pt) => {
+		for (const existing of out) if (eqPt(existing, pt)) return;
+		out.push(pt);
+	};
+	for (const m of aMoves || []) pushUnique(normPt(m));
+	for (const m of bMoves || []) pushUnique(normPt(m));
+	return out;
+}
+function bestStartMinYMinX(contourCmds, VERB) {
+	let best = null;
+	for (const cmd of contourCmds) {
+		const v = cmd[0];
+		const add = (x, y) => {
+			const p = [x, y];
+			if (!best) {
+				best = p;
+				return;
+			}
+			if (p[1] < best[1] - 1e-9) best = p;
+			else if (Math.abs(p[1] - best[1]) < 1e-9 && p[0] < best[0] - 1e-9) best = p;
+		};
+		if (v === VERB.MOVE) add(cmd[1], cmd[2]);
+		else if (v === VERB.LINE) add(cmd[1], cmd[2]);
+		else if (v === VERB.QUAD) add(cmd[3], cmd[4]);
+		else if (v === VERB.CUBIC) add(cmd[5], cmd[6]);
+	}
+	return best;
+}
+/**
+* Convert contour commands to a polyline by sampling curves.
+* Used for ray-casting containment tests.
+*/
+function contourToPolyline(contourCmds, V, steps = 8) {
+	let cx = 0, cy = 0;
+	let sx = 0, sy = 0;
+	const pts = [];
+	for (const cmd of contourCmds) {
+		const v = cmd[0];
+		if (v === V.MOVE) {
+			cx = cmd[1];
+			cy = cmd[2];
+			sx = cx;
+			sy = cy;
+			pts.push([cx, cy]);
+		} else if (v === V.LINE) {
+			cx = cmd[1];
+			cy = cmd[2];
+			pts.push([cx, cy]);
+		} else if (v === V.QUAD) {
+			const x0 = cx, y0 = cy;
+			const x1 = cmd[1], y1 = cmd[2];
+			const x2 = cmd[3], y2 = cmd[4];
+			for (let i = 1; i <= steps; i++) {
+				const t = i / steps;
+				const mt = 1 - t;
+				pts.push([mt * mt * x0 + 2 * mt * t * x1 + t * t * x2, mt * mt * y0 + 2 * mt * t * y1 + t * t * y2]);
+			}
+			cx = x2;
+			cy = y2;
+		} else if (v === V.CUBIC) {
+			const x0 = cx, y0 = cy;
+			const x1 = cmd[1], y1 = cmd[2];
+			const x2 = cmd[3], y2 = cmd[4];
+			const x3 = cmd[5], y3 = cmd[6];
+			for (let i = 1; i <= steps; i++) {
+				const t = i / steps;
+				const mt = 1 - t;
+				pts.push([mt * mt * mt * x0 + 3 * mt * mt * t * x1 + 3 * mt * t * t * x2 + t * t * t * x3, mt * mt * mt * y0 + 3 * mt * mt * t * y1 + 3 * mt * t * t * y2 + t * t * t * y3]);
+			}
+			cx = x3;
+			cy = y3;
+		} else if (v === V.CLOSE) {
+			if (cx !== sx || cy !== sy) pts.push([sx, sy]);
+			cx = sx;
+			cy = sy;
+		}
+	}
+	return pts;
+}
+/**
+* Ray-casting point-in-polygon test.
+*/
+function pointInPolygon(px, py, poly) {
+	let inside = false;
+	for (let i = 0, j = poly.length - 1; i < poly.length; j = i++) {
+		const [xi, yi] = poly[i];
+		const [xj, yj] = poly[j];
+		if (yi > py !== yj > py && px < (xj - xi) * (py - yi) / (yj - yi) + xi) inside = !inside;
+	}
+	return inside;
+}
+/**
+* Get a representative point on the contour boundary (midpoint of first segment).
+*/
+function getContourSamplePoint(contourCmds, V) {
+	let cx = 0, cy = 0;
+	for (const cmd of contourCmds) {
+		const v = cmd[0];
+		if (v === V.MOVE) {
+			cx = cmd[1];
+			cy = cmd[2];
+		} else if (v === V.LINE) return [(cx + cmd[1]) / 2, (cy + cmd[2]) / 2];
+		else if (v === V.QUAD) {
+			const t = .5, mt = .5;
+			return [mt * mt * cx + 2 * mt * t * cmd[1] + t * t * cmd[3], mt * mt * cy + 2 * mt * t * cmd[2] + t * t * cmd[4]];
+		} else if (v === V.CUBIC) {
+			const t = .5, mt = .5;
+			return [mt ** 3 * cx + 3 * mt ** 2 * t * cmd[1] + 3 * mt * t ** 2 * cmd[3] + t ** 3 * cmd[5], mt ** 3 * cy + 3 * mt ** 2 * t * cmd[2] + 3 * mt * t ** 2 * cmd[4] + t ** 3 * cmd[6]];
+		}
+	}
+	return null;
+}
+/**
+* Apply containment-based winding fix to contour objects.
+* Even nesting depth = CCW (outer), odd = CW (hole).
+*/
+function applyContainmentWinding(contourObjs, V) {
+	const n = contourObjs.length;
+	if (n === 0) return;
+	const polylines = contourObjs.map((obj) => contourToPolyline(obj.cmds, V));
+	const samplePts = contourObjs.map((obj) => getContourSamplePoint(obj.cmds, V));
+	const depths = new Array(n).fill(0);
+	for (let i = 0; i < n; i++) {
+		const pt = samplePts[i];
+		if (!pt) continue;
+		for (let j = 0; j < n; j++) {
+			if (i === j) continue;
+			if (pointInPolygon(pt[0], pt[1], polylines[j])) depths[i] = (depths[i] ?? 0) + 1;
+		}
+	}
+	const ensureOrient = (obj, wantCCW) => {
+		if (wantCCW !== approxSignedAreaFromContourCmds(obj.cmds, V) > 0) obj.cmds = reverseClosedContourKeepStart(obj.cmds, obj.explicitCloseWanted, V);
+	};
+	for (let i = 0; i < n; i++) ensureOrient(contourObjs[i], depths[i] % 2 === 0);
+}
+function orientedContours(cmds, V) {
+	const contours = splitContours(cmds, V).map((c) => {
+		const explicitCloseWanted = explicitCloseWantedFromCmds(c, V);
+		const cc = ensureClosed(c, V);
+		const a = approxSignedAreaFromContourCmds(cc, V);
+		return {
+			cmds: cc,
+			absA: Math.abs(a),
+			explicitCloseWanted
+		};
+	});
+	contours.sort((x, y) => y.absA - x.absA);
+	applyContainmentWinding(contours, V);
+	return contours;
+}
+function canonicalContourCmds(cmds, recordedMoves, preferMinYMinXStart, V) {
+	const moves = recordedMoves.map((m) => normPt([m[0], m[1]]));
+	const used = new Array(moves.length).fill(false);
+	const contours = orientedContours(cmds, V);
+	for (const obj of contours) {
+		let cc = obj.cmds;
+		for (let i = 0; i < moves.length; i++) {
+			if (used[i]) continue;
+			const target = moves[i];
+			const { segs } = contourToSegments(cc, V);
+			if (segs.some((s) => eqPt(s.start, target) || eqPt(s.end, target))) {
+				used[i] = true;
+				cc = rotateClosedContourToStart(cc, target, obj.explicitCloseWanted, V);
+				break;
+			}
+		}
+		if (preferMinYMinXStart) {
+			const best = bestStartMinYMinX(cc, V);
+			if (best) cc = rotateClosedContourToStart(cc, best, obj.explicitCloseWanted, V);
+		}
+		obj.cmds = cc;
+	}
+	return contours.flatMap((x) => x.cmds);
+}
+function cmdsToPathData(cmds, V) {
+	const parts = [];
+	for (const cmd of cmds) {
+		const v = cmd[0];
+		if (v === V.MOVE) parts.push(`M${roundN(cmd[1])} ${roundN(cmd[2])}`);
+		else if (v === V.LINE) parts.push(`L${roundN(cmd[1])} ${roundN(cmd[2])}`);
+		else if (v === V.QUAD) parts.push(`Q${roundN(cmd[1])} ${roundN(cmd[2])} ${roundN(cmd[3])} ${roundN(cmd[4])}`);
+		else if (v === V.CUBIC) parts.push(`C${roundN(cmd[1])} ${roundN(cmd[2])} ${roundN(cmd[3])} ${roundN(cmd[4])} ${roundN(cmd[5])} ${roundN(cmd[6])}`);
+		else if (v === V.CLOSE) parts.push("Z");
+	}
+	return parts.join(" ");
+}
+function contoursArea(cmds, V) {
+	let total = 0;
+	for (const c of splitContours(cmds, V)) total += Math.abs(approxSignedAreaFromContourCmds(ensureClosed(c, V), V));
+	return total;
+}
+//#endregion
+//#region src/build/core/flatten/pathops.ts
+var PathOpsError = class extends Error {};
+function createPathOps(PathKit) {
+	const V = verbMap(PathKit);
+	const FILL = fillTypes(PathKit);
+	const Caps = PathKit.StrokeCap ?? {};
+	const Joins = PathKit.StrokeJoin ?? {};
+	const Ops = PathKit.PathOp ?? {};
+	const LINE_CAP = {
+		butt: Caps.BUTT ?? 0,
+		round: Caps.ROUND ?? 1,
+		square: Caps.SQUARE ?? 2
+	};
+	const LINE_JOIN = {
+		miter: Joins.MITER ?? 0,
+		round: Joins.ROUND ?? 1,
+		bevel: Joins.BEVEL ?? 2
+	};
+	const OP_UNION = Ops.UNION ?? 0;
+	const OP_INTERSECT = Ops.INTERSECT ?? 1;
+	function fillTypeFor(fillRule) {
+		if (fillRule === "nonzero") return FILL.WINDING;
+		if (fillRule === "evenodd") return FILL.EVENODD;
+		throw new Error(`Invalid fill rule: ${fillRule}`);
+	}
+	function dispose(h) {
+		h.p.delete?.();
+	}
+	function fromCommands(cmds, fillRule) {
+		const p = PathKit.NewPath();
+		p.setFillType(fillTypeFor(fillRule));
+		const moves = [];
+		for (const [cmd, args] of cmds) switch (cmd) {
+			case "M":
+				p.moveTo(args[0], args[1]);
+				moves.push(normPt([args[0], args[1]]));
+				break;
+			case "L":
+				p.lineTo(args[0], args[1]);
+				break;
+			case "Q":
+				p.quadTo(args[0], args[1], args[2], args[3]);
+				break;
+			case "C":
+				p.cubicTo(args[0], args[1], args[2], args[3], args[4], args[5]);
+				break;
+			case "Z":
+				p.close();
+				break;
+			default:
+				p.delete?.();
+				throw new Error(`No mapping to Skia for "${cmd} ${args}"`);
+		}
+		return {
+			p,
+			moves
+		};
+	}
+	function normalizedCmds(h) {
+		const p2 = PathKit.FromSVGString(h.p.toSVGString());
+		const cmds = p2 ? p2.toCmds() : [];
+		p2?.delete?.();
+		return cmds;
+	}
+	function simplifyToWinding(h) {
+		try {
+			h.p.simplify();
+			const p2 = PathKit.FromSVGString(h.p.toSVGString());
+			if (p2) {
+				h.p.delete?.();
+				h.p = p2;
+			}
+		} catch {}
+		h.p.setFillType(FILL.WINDING);
+	}
+	function toCommands(h) {
+		const cmds = canonicalContourCmds(normalizedCmds(h), h.moves, h.moves.length === 0, V);
+		const out = [];
+		for (const cmd of cmds) {
+			const v = cmd[0];
+			if (v === V.MOVE) out.push(["M", [cmd[1], cmd[2]]]);
+			else if (v === V.LINE) out.push(["L", [cmd[1], cmd[2]]]);
+			else if (v === V.QUAD) out.push(["Q", [
+				cmd[1],
+				cmd[2],
+				cmd[3],
+				cmd[4]
+			]]);
+			else if (v === V.CUBIC) out.push(["C", [
+				cmd[1],
+				cmd[2],
+				cmd[3],
+				cmd[4],
+				cmd[5],
+				cmd[6]
+			]]);
+			else if (v === V.CLOSE) out.push(["Z", []]);
+			else throw new Error(`Unexpected verb in cmds: ${v}`);
+		}
+		return out;
+	}
+	function combine(a, b, op) {
+		try {
+			const out = PathKit.MakeFromOp(a.p, b.p, op);
+			if (!out) return null;
+			return {
+				p: out,
+				moves: mergeMoves(a.moves, b.moves)
+			};
+		} catch {
+			return null;
+		}
+	}
+	function doPathop(op, cmdSeqs, fillRules) {
+		if (!cmdSeqs.length) return [];
+		let skPath = fromCommands(cmdSeqs[0], fillRules[0]);
+		try {
+			for (let i = 1; i < cmdSeqs.length; i++) {
+				const skPath2 = fromCommands(cmdSeqs[i], fillRules[i]);
+				const merged = combine(skPath, skPath2, op);
+				dispose(skPath2);
+				if (merged === null) throw new PathOpsError("operation did not succeed");
+				dispose(skPath);
+				skPath = merged;
+			}
+			simplifyToWinding(skPath);
+			return toCommands(skPath);
+		} finally {
+			dispose(skPath);
+		}
+	}
+	return {
+		union(cmdSeqs, fillRules) {
+			return doPathop(OP_UNION, cmdSeqs, fillRules);
+		},
+		intersection(cmdSeqs, fillRules) {
+			return doPathop(OP_INTERSECT, cmdSeqs, fillRules);
+		},
+		removeOverlaps(cmds, fillRule) {
+			const h = fromCommands(cmds, fillRule);
+			try {
+				simplifyToWinding(h);
+				return toCommands(h);
+			} finally {
+				dispose(h);
+			}
+		},
+		transformCmds(cmds, affine) {
+			const h = fromCommands(cmds, "nonzero");
+			const { a, b, c, d, e, f } = affine;
+			const p = PathKit.NewPath(h.p);
+			p.transform(a, c, e, b, d, f, 0, 0, 1);
+			const transformed = {
+				p,
+				moves: h.moves.map(([x, y]) => normPt([a * x + c * y + e, b * x + d * y + f]))
+			};
+			try {
+				return toCommands(transformed);
+			} finally {
+				dispose(h);
+				dispose(transformed);
+			}
+		},
+		strokeCmds(cmds, svgLinecap, svgLinejoin, strokeWidth, strokeMiterlimit, _tolerance, dashArray = [], dashOffset = 0) {
+			const cap = LINE_CAP[svgLinecap];
+			if (cap === void 0) throw new Error(`Unsupported cap ${svgLinecap}`);
+			const join = LINE_JOIN[svgLinejoin];
+			if (join === void 0) throw new Error(`Unsupported join ${svgLinejoin}`);
+			const h = fromCommands(cmds, "nonzero");
+			const work = PathKit.NewPath(h.p);
+			let strokedPath;
+			try {
+				if (dashArray.length === 2 && typeof work.dash === "function") work.dash(Number(dashArray[0]), Number(dashArray[1]), dashOffset || 0);
+				let stroked = work.stroke({
+					width: strokeWidth,
+					cap,
+					join,
+					miter_limit: strokeMiterlimit
+				});
+				if (!stroked || typeof stroked.toCmds !== "function") stroked = work;
+				if (stroked !== work) work.delete?.();
+				strokedPath = stroked;
+			} catch {
+				strokedPath = work;
+			}
+			const result = {
+				p: strokedPath,
+				moves: []
+			};
+			try {
+				simplifyToWinding(result);
+				return toCommands(result);
+			} finally {
+				dispose(h);
+				dispose(result);
+			}
+		},
+		pathArea(cmds, fillRule) {
+			const h = fromCommands(cmds, fillRule);
+			try {
+				simplifyToWinding(h);
+				try {
+					return contoursArea(normalizedCmds(h), V);
+				} catch {
+					return 0;
+				}
+			} finally {
+				dispose(h);
+			}
+		}
+	};
+}
+//#endregion
+//#region src/build/core/flatten/stages/defs.ts
+function addToDefs(defs, newEl) {
+	const newId = newEl.attrib.get("id");
+	if (newId === void 0) return;
+	let insertAt = defs.children.length;
+	for (let i = 0; i < defs.children.length; i++) if (newId < (defs.children[i].attrib.get("id") ?? "")) {
+		insertAt = i;
+		break;
+	}
+	defs.insert(insertAt, newEl);
+}
+function removeOrphanedGradients(doc) {
+	const usedGradientIds = /* @__PURE__ */ new Set();
+	for (const [, shapes] of doc.shapeEntries()) for (const shape of shapes) {
+		const fill = shapeStr(shape, "fill");
+		if (!fill.startsWith("url(")) continue;
+		let el;
+		try {
+			el = doc.resolveUrl(fill, "*");
+		} catch {
+			continue;
+		}
+		if (!isGradient(el.tag)) continue;
+		const id = el.attrib.get("id");
+		if (id !== void 0) usedGradientIds.add(id);
+	}
+	for (const grad of findAll(doc.root, (e) => isGradient(e.tag))) if (!usedGradientIds.has(grad.attrib.get("id") ?? "")) grad.detach();
+	doc.invalidateShapes();
+}
+//#endregion
+//#region src/build/core/flatten/stages/stroke.ts
+function strokeToPaths(doc, shape) {
+	const stroke = cloneShape(asPath(shape));
+	stroke.fields.d = pathFromCommands(strokeCommands(shape, doc.tolerance, doc.ops)).fields.d;
+	stroke.fields.fill_rule = "nonzero";
+	stroke.fields.clip_rule = "nonzero";
+	stroke.fields.opacity = stroke.fields.opacity * stroke.fields.stroke_opacity;
+	stroke.fields.fill = stroke.fields.stroke;
+	shape.fields.opacity = shape.fields.opacity * shape.fields.fill_opacity;
+	shape.fields.fill_opacity = 1;
+	stroke.fields.fill_opacity = 1;
+	for (const cleanmeup of [shape, stroke]) resetFields(cleanmeup, (name) => name.startsWith("stroke"));
+	if (!mightPaint(shape, doc.ops)) return [stroke];
+	shape.fields.id = "";
+	stroke.fields.id = "";
+	return [shape, stroke];
+}
+//#endregion
+//#region src/build/core/flatten/stages/collapse.ts
+function collapse(doc) {
+	doc.syncTree();
+	const toProcess = [...doc.breadthFirst()].reverse();
+	const defs = new XEl(svgTag("defs"));
+	doc.root.insert(0, defs);
+	for (const context of toProcess) {
+		if (context.path.includes("clipPath")) {
+			context.element.detach();
+			continue;
+		}
+		const el = context.element;
+		delAttrs(el, "clip-path", "transform");
+		inheritAttrib(context.attrib, el);
+		if (isShapeTag(el.tag)) {
+			if (el.children.length) throw new Error("Shapes shouldn't have children");
+			const paths = [absoluteShape(asPath(fromElement(el)))];
+			const initialPath = cloneShape(paths[0]);
+			if (shapeStr(paths[0], "stroke") !== "none") paths.splice(0, paths.length, ...strokeToPaths(doc, paths[0]));
+			for (const path of paths) resetFields(path, (name) => name.startsWith("stroke"));
+			if (!context.transform.equals(Affine2D.identity())) paths.forEach((p, i) => {
+				paths[i] = applyTransform(p, context.transform, doc.ops);
+			});
+			if (context.clips.length) for (const p of paths) {
+				const cmds = doc.ops.intersection([shapeCmdSeq(p), ...context.clips.map((c) => shapeCmdSeq(c))], [shapeStr(p, "fill_rule"), ...context.clips.map((c) => shapeStr(c, "clip_rule"))]);
+				p.fields.d = pathFromCommands(cmds).fields.d;
+				p.fields.fill_rule = "nonzero";
+			}
+			if (paths.length !== 1 || !shapesEqual(paths[0], initialPath)) replaceEl(el, paths.map((p) => toElement(p)));
+		} else if (isGradient(el.tag)) {
+			el.detach();
+			addToDefs(defs, el);
+		} else if (isDefs(el.tag)) {
+			for (const childEl of [...el.children]) addToDefs(defs, childEl);
+			el.detach();
+		} else if (isGroup(el.tag)) tryRemoveGroup(el);
+	}
+	delAttrs(doc.root, ...INHERITABLE_ATTRIB);
+	removeOrphanedGradients(doc);
+	for (const unusedEl of [...defs.children]) if (!isGradient(unusedEl.tag)) unusedEl.detach();
+	doc.invalidateShapes();
+}
+//#endregion
+//#region src/build/core/flatten/stages/discard.ts
+function removeForeignAttrs(el, goodNs) {
+	const attrToRm = [];
+	for (const attr of el.attrib.keys()) if (!goodNs.has(splitNs(attr)[0])) attrToRm.push(attr);
+	delAttrs(el, ...attrToRm);
+}
+function removeNonSvgContent(doc) {
+	doc.syncTree();
+	const goodNs = /* @__PURE__ */ new Set([SVG_NS, XLINK_NS]);
+	if (splitNs(doc.root.tag)[0] === "http://www.w3.org/2000/svg") goodNs.add(null);
+	const elToRm = [];
+	for (const el of doc.root.iter()) {
+		if (el === doc.root) continue;
+		if (!goodNs.has(splitNs(el.tag)[0])) {
+			elToRm.push(el);
+			continue;
+		}
+		removeForeignAttrs(el, goodNs);
+	}
+	removeForeignAttrs(doc.root, goodNs);
+	for (const el of elToRm) el.detach();
+	doc.invalidateShapes();
+}
+function removeAnonymousSymbols(doc) {
+	doc.syncTree();
+	for (const el of findAll(doc.root, (e) => stripNs(e.tag) === "symbol" && !e.attrib.has("id"))) el.detach();
+}
+function removeTitleMetaDesc(doc) {
+	doc.syncTree();
+	const tags = /* @__PURE__ */ new Set([
+		"title",
+		"desc",
+		"metadata",
+		"comment"
+	]);
+	for (const el of findAll(doc.root, (e) => tags.has(stripNs(e.tag)))) el.detach();
+}
+//#endregion
+//#region src/build/core/flatten/stages/fill-rule.ts
+function evenoddToNonzeroWinding(doc) {
+	doc.mapShapes((s) => shapeStr(s, "fill_rule") === "evenodd" ? removeOverlaps(s, doc.ops) : s);
+}
+//#endregion
+//#region src/build/core/flatten/stages/nested-svg.ts
+function rectEquals(a, b) {
+	return a.x === b.x && a.y === b.y && a.w === b.w && a.h === b.h;
+}
+function nestedSvgTransform(attrs, parentWidth, parentHeight) {
+	const num = (raw, fallback) => {
+		if (raw === null || raw === void 0 || !raw.trim()) return fallback;
+		const value = parseFloat(raw);
+		return Number.isFinite(value) ? value : fallback;
+	};
+	const x = num(attrs.x, 0);
+	const y = num(attrs.y, 0);
+	const viewport = {
+		x,
+		y,
+		w: num(attrs.width, parentWidth),
+		h: num(attrs.height, parentHeight)
+	};
+	const viewBox = attrs.viewBox === null || attrs.viewBox === void 0 ? viewport : parseViewBox(attrs.viewBox);
+	let transform = rectEquals(viewport, viewBox) ? Affine2D.identity().translate(x, y) : Affine2D.rectToRect(viewBox, viewport, attrs.preserveAspectRatio ?? "xMidYMid");
+	if (attrs.transform !== null && attrs.transform !== void 0) transform = Affine2D.composeLtr([transform, Affine2D.fromString(attrs.transform)]);
+	return {
+		transform,
+		viewport,
+		viewBox
+	};
+}
+function viewportRect(x, y, width, height) {
+	return toElement(fromElement(new XEl(svgTag("rect"), [
+		["x", ntos(x)],
+		["y", ntos(y)],
+		["width", ntos(width)],
+		["height", ntos(height)]
+	])));
+}
+function newId(doc, template) {
+	for (let i = 0; i < 65536; i++) {
+		const candidate = template(i);
+		if (!findAll(doc.root, (el) => el.attrib.get("id") === candidate).length) return candidate;
+	}
+	throw new Error("No free id for nested svg viewport");
+}
+function nestedSvgs(root) {
+	const found = [];
+	const frontier = [...root.children];
+	while (frontier.length) {
+		const el = frontier.shift();
+		if (isTag(el, "svg")) found.push(el);
+		else if (el.children.length) frontier.push(...el.children);
+	}
+	return found;
+}
+function unnestSvg(doc, svg, parentWidth, parentHeight) {
+	const { transform, viewport, viewBox } = nestedSvgTransform({
+		x: svg.attrib.get("x") ?? null,
+		y: svg.attrib.get("y") ?? null,
+		width: svg.attrib.get("width") ?? null,
+		height: svg.attrib.get("height") ?? null,
+		viewBox: svg.attrib.get("viewBox") ?? null,
+		transform: svg.attrib.get("transform") ?? null,
+		preserveAspectRatio: svg.attrib.get("preserveAspectRatio") ?? null
+	}, parentWidth, parentHeight);
+	const { x, y, w: width, h: height } = viewport;
+	for (const inner of nestedSvgs(svg)) replaceEl(inner, unnestSvg(doc, inner, viewBox.w, viewBox.h));
+	const g = new XEl(svgTag("g"));
+	for (const child of [...svg.children]) g.append(child);
+	if (!transform.equals(Affine2D.identity())) g.attrib.set("transform", transform.toString());
+	const overflow = svg.attrib.get("overflow") ?? "hidden";
+	if (overflow === "visible") return [g];
+	if (overflow !== "hidden") throw new Error(`overflow='${overflow}' is not supported`);
+	const clipId = newId(doc, (i) => `nested-svg-viewport-${i}`);
+	const clipPath = new XEl(svgTag("clipPath"), [["id", clipId]]);
+	clipPath.append(viewportRect(x, y, width, height));
+	const clippedG = new XEl(svgTag("g"), [["clip-path", `url(#${clipId})`]]);
+	clippedG.append(g);
+	return [clipPath, clippedG];
+}
+function resolveNestedSvgs(doc) {
+	doc.syncTree();
+	const nested = nestedSvgs(doc.root);
+	if (!nested.length) return;
+	const vbox = doc.viewBox();
+	if (vbox === null) throw new Error("Can't determine root SVG width/height, which is required for resolving nested SVGs");
+	for (const el of nested) replaceEl(el, unnestSvg(doc, el, vbox.w, vbox.h));
+	doc.invalidateShapes();
+}
+//#endregion
+//#region src/build/core/flatten/stages/opacity.ts
+function normalizeOpacities(doc) {
+	doc.forEachShape((s) => normalizeOpacity(s));
+}
+//#endregion
+//#region src/build/core/flatten/stages/shapes.ts
+function shapesToPaths(doc) {
+	doc.mapShapes((s) => asPath(s));
+}
+function expandShorthandCommands(doc) {
+	doc.mapShapes((s) => s.tag === "path" ? explicitLinesExpandShorthand(s) : s);
+}
+function absoluteCoordinates(doc) {
+	doc.mapShapes((s) => absoluteShape(s));
+}
+function roundFloats(doc, ndigits) {
+	doc.forEachShape((s) => roundShapeFloats(s, ndigits));
+}
+function dropEmptySubpaths(doc) {
+	doc.forEachShape((s) => removeEmptySubpaths(s, doc.ops));
+}
+function removeUnpaintedShapes(doc) {
+	doc.syncTree();
+	const remove = [];
+	for (const [el, shapes] of doc.shapeEntries()) if (!mightPaint(shapes[0], doc.ops)) remove.push(el);
+	for (const el of remove) el.detach();
+	doc.invalidateShapes();
+}
+//#endregion
+//#region src/build/core/flatten/stages/styles.ts
+function applyStyles(el) {
+	const style = el.attrib.get("style") ?? "";
+	el.attrib.delete("style");
+	const parsed = {};
+	parseCssDeclarations(style, parsed);
+	for (const [name, value] of Object.entries(parsed)) if (XML_ATTRIBUTE_NAME.test(name)) el.attrib.set(name, value);
+}
+function applyStyleAttributes(doc) {
+	if (doc.hasShapes()) {
+		doc.mapShapes((s) => applyStyleAttribute(s));
+		doc.syncTree();
+	}
+	const styled = [doc.root, ...findAll(doc.root, (e) => e.attrib.has("style"))];
+	for (const el of styled) applyStyles(el);
+}
+//#endregion
+//#region src/build/core/flatten/stages/validate.ts
+var PATH_ALLOWLIST = [
+	/^\/svg\[0\]$/,
+	/^\/svg\[0\]\/defs\[0\]$/,
+	/^\/svg\[0\]\/defs\[0\]\/(linear|radial)Gradient\[\d+\](\/stop\[\d+\])?$/,
+	/^\/svg\[0\](\/(path|g)\[\d+\])+$/
+];
+function validateFlattened(doc) {
+	doc.syncTree();
+	const errors = [];
+	const badPaths = /* @__PURE__ */ new Set();
+	const pathsRequired = /* @__PURE__ */ new Set(["/svg[0]", "/svg[0]/defs[0]"]);
+	const ids = /* @__PURE__ */ new Map();
+	for (const context of doc.breadthFirst()) {
+		if ([...badPaths].some((bp) => context.path.startsWith(bp))) continue;
+		if (!PATH_ALLOWLIST.some((pat) => pat.test(context.path))) {
+			errors.push(`Unsupported element <${stripNs(context.element.tag)}> at ${context.path}`);
+			badPaths.add(context.path);
+			continue;
+		}
+		pathsRequired.delete(context.path);
+		const elId = context.element.attrib.get("id");
+		if (elId !== void 0) {
+			if (ids.has(elId)) errors.push(`Duplicate id "${elId}" at ${context.path}, first seen at ${ids.get(elId)}`);
+			ids.set(elId, context.path);
+		}
+	}
+	for (const path of pathsRequired) errors.push(`Missing element ${path}`);
+	return errors;
+}
+//#endregion
+//#region src/build/core/flatten/stages.ts
+function flattenDocument(doc, ndigits = 3) {
+	doc.syncTree();
+	removeNonSvgContent(doc);
+	removeAnonymousSymbols(doc);
+	removeTitleMetaDesc(doc);
+	applyStyleAttributes(doc);
+	resolveNestedSvgs(doc);
+	shapesToPaths(doc);
+	expandShorthandCommands(doc);
+	resolveUse(doc);
+	collapse(doc);
+	evenoddToNonzeroWinding(doc);
+	normalizeOpacities(doc);
+	absoluteCoordinates(doc);
+	roundFloats(doc, ndigits);
+	dropEmptySubpaths(doc);
+	removeUnpaintedShapes(doc);
+	const violations = validateFlattened(doc);
+	if (violations.length) throw new Error(violations.join("; "));
+}
+//#endregion
+//#region src/build/core/flatten/index.ts
+function flattenSvg(svgContent, pathkit) {
+	const doc = SvgDocument.parse(svgContent, createPathOps(pathkit));
+	flattenDocument(doc);
+	return doc.serialize();
+}
+//#endregion
+//#region src/build/core/glyph/merge.ts
+/**
+* Concatenate multiple SVG path `d` strings into a single compound path.
+* This preserves the exact geometry of each path (no boolean operations)
+* while combining them into one glyph. Under nonzero winding, this renders
+* identically to drawing each path separately with the same color.
+*/
+function concatPathDs(ds) {
+	if (ds.length === 0) return null;
+	if (ds.length === 1) return ds[0];
+	return ds.join(" ");
+}
+/**
+* Merge consecutive same-color paths into single compound paths.
+* Preserves z-order: only merges runs of adjacent paths with identical fill color.
+*/
+function mergeSameColorPaths(paths, logger) {
+	if (paths.length <= 1) return paths;
+	const result = [];
+	let i = 0;
+	while (i < paths.length) {
+		const fill = paths[i].fill;
+		const knockout = paths[i].knockout;
+		let j = i + 1;
+		if (!paths[i].noMerge) while (j < paths.length && paths[j].fill === fill && paths[j].knockout === knockout && !paths[j].noMerge) j++;
+		if (j - i === 1) result.push(paths[i]);
+		else {
+			const group = paths.slice(i, j);
+			const merged = concatPathDs(group.map((p) => p.d));
+			if (merged) {
+				logger?.info(`    ⊕ Merged ${group.length} same-color paths (fill=${fill})`);
+				result.push(knockout ? {
+					d: merged,
+					fill,
+					knockout
+				} : {
+					d: merged,
+					fill
+				});
+			} else result.push(...group);
+		}
+		i = j;
+	}
+	return result;
+}
+//#endregion
+//#region src/build/core/glyph/validate.ts
+function validateSvg(content) {
+	if (XML_MASK.test(content)) return {
+		valid: false,
+		reason: "<mask> is not supported yet"
+	};
+	if (XML_FILTER.test(content)) return {
+		valid: false,
+		reason: "<filter> is not supported yet"
+	};
+	if (XML_IMAGE.test(content)) return {
+		valid: false,
+		reason: "embedded raster <image> is not supported yet"
+	};
+	const unconvertible = XML_UNCONVERTIBLE.exec(content);
+	if (unconvertible) return {
+		valid: false,
+		reason: `<${unconvertible[1]}> is not supported yet`
+	};
+	return { valid: true };
+}
+function stripPxUnits(content) {
+	return content.replace(PX_ATTRIBUTE_VALUE, "=$1$2$1").replace(PX_STYLE_VALUE, "$1");
+}
+function preprocessSvg(content) {
+	const withUnits = stripPxUnits(content);
+	if (XML_XMLNS.test(withUnits)) return withUnits;
+	return withUnits.replace(SVG_OPEN_TAG, `<svg xmlns="${SVG_NS}"`);
+}
+//#endregion
+//#region src/build/core/pathkit/evenodd.ts
+/**
+* Convert a path `d` string with evenodd fill semantics to an equivalent
+* path that renders identically under nonzero winding.
+*
+* Steps:
+* 1. Parse via PathKit, set fill type to EVENODD, simplify (resolve topology)
+* 2. Split into contours, compute containment depths
+* 3. Fix winding: even depth = CCW (outer), odd depth = CW (hole)
+* 4. Reconstruct d string
+*/
+function convertEvenoddToWinding(PathKit, d) {
+	const V = verbMap(PathKit);
+	const p = PathKit.FromSVGString(d);
+	if (!p) return d;
+	p.setFillType(fillTypes(PathKit).EVENODD);
+	p.simplify();
+	const simplified = p.toSVGString();
+	p.delete?.();
+	const p2 = PathKit.FromSVGString(simplified);
+	if (!p2) return simplified;
+	const cmds = p2.toCmds();
+	p2.delete?.();
+	if (cmds.length === 0) return simplified;
+	return cmdsToPathData(orientedContours(cmds, V).flatMap((x) => x.cmds), V);
+}
+//#endregion
+//#region src/build/core/prepare.ts
+/**
+* Fill values that reference a paint server (`url(#…)`) cannot be expressed
+* as font glyph layers — a solid-color glyph has no gradient or pattern stop
+* representation. Reject rather than silently painting black.
+*/
+function assertNoPaintServers(paths, fileLabel) {
+	for (const p of paths) if (p.fill && p.fill.includes("url(")) throw new Error(`${fileLabel} uses a paint-server fill ("${p.fill}"); gradients and patterns cannot be compiled to font glyphs`);
+}
+/**
+* Shared per-file SVG prep: validate → preprocess → flatten → parse →
+* evenodd convert → same-color merge. Returns null for unsupported SVGs
+* (logged as a warning); throws for inputs that cannot be converted.
+*/
+async function prepareSvgLayers(opts) {
+	const { svg, fileLabel, pathkit, logger } = opts;
+	const validation = validateSvg(svg);
+	if (validation.valid === false) {
+		logger?.warn(`${fileLabel} skipped: ${validation.reason}`);
+		return null;
+	}
+	const preprocessed = preprocessSvg(svg);
+	let flattenedSvg;
+	try {
+		flattenedSvg = flattenSvg(preprocessed, pathkit);
+	} catch (err) {
+		throw new Error(`${fileLabel} failed to flatten: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+	}
+	const parsed = parseFlattenedSvg(flattenedSvg, {
+		onSanitize: (original) => {
+			logger?.info(`  ⚠ ${fileLabel} sanitized path: path was missing initial moveto (prepended M from endpoint)`);
+			logger?.info(`    Original: ${original.slice(0, 80)}…`);
+		},
+		onMissingViewBox: (assumed) => {
+			logger?.warn(`${fileLabel} has no viewBox; assuming [${assumed.join(" ")}]`);
+		}
+	});
+	assertNoPaintServers(parsed.paths, fileLabel);
+	for (const p of parsed.paths) if (p.fillRule === "evenodd") {
+		logger?.info(`  ↻ ${fileLabel} converting evenodd path to nonzero winding`);
+		p.d = convertEvenoddToWinding(pathkit, p.d);
+		delete p.fillRule;
+		p.noMerge = true;
+	}
+	const mergedPaths = mergeSameColorPaths(parsed.paths, logger);
+	return {
+		viewBox: parsed.viewBox,
+		paths: mergedPaths
+	};
+}
+//#endregion
+//#region src/build/core/prepareIcon.ts
+function collectingLogger(logs) {
+	const push = (level) => (msg) => {
+		logs.push([level, msg]);
+	};
+	return {
+		start: () => {},
+		update: () => {},
+		succeed: () => {},
+		fail: push("fail"),
+		info: push("info"),
+		warn: push("warn")
+	};
+}
+async function prepareIcon(task, pathkit) {
+	const logs = [];
+	const logger = collectingLogger(logs);
+	const iconName = task.file.replace(/\.svg$/i, "");
+	const fileLabel = `[${task.fontFamily}: ${task.file}]`;
+	const result = {
+		file: task.file,
+		iconName,
+		adv: 0,
+		layers: [],
+		logs,
+		error: null
+	};
+	logger.info(`Processing ${task.file}`);
+	let prepared;
+	try {
+		prepared = await prepareSvgLayers({
+			svg: task.svg,
+			fileLabel,
+			pathkit,
+			logger
+		});
+	} catch (err) {
+		result.error = err instanceof Error ? err.message : String(err);
+		return result;
+	}
+	if (!prepared) return result;
+	const { vx, vy, scale, xOff, yOff, adv } = computePlacement({
+		upm: task.upm,
+		safeZone: task.safeZone,
+		viewBox: prepared.viewBox
+	});
+	result.adv = adv;
+	for (const p of prepared.paths) {
+		if (shouldSkipPath(p.d, p.fill)) continue;
+		const placed = transformPathForFont(pathkit, p.d, {
+			vx,
+			vy,
+			scale,
+			xOff,
+			yOff,
+			upm: task.upm
+		});
+		result.layers.push({
+			fill: p.fill,
+			d: toQuadraticPath(placed, task.upm * QUADRATIC_ERROR_BOUND_EM)
+		});
+	}
+	if (result.layers.length === 0) logger.warn(`${fileLabel} produced no glyphs: nothing in it paints`);
+	return result;
+}
+//#endregion
+//#region src/build/core/runFontPipeline.ts
+var SKIP_REASONS = /skipped:|produced no glyphs/;
+/**
+* Run the font pipeline: prepared SVG layers → placement → glyphs → TTF +
+* glyphmap (+ WOFF2 when `config.web`). The PathKit WASM instance is shared
+* across calls.
+*/
+async function runFontPipeline(config, paths, inputs, options) {
+	const startTime = Date.now();
+	const logger = options?.logger;
+	logger?.update(`Building "${config.fontFamily}"…`);
+	ensureDir(paths.outputDir);
+	const inputHash = options?.inputHash;
+	const family = inputHash ? buildFontFamily(config.fontFamily, inputHash) : config.fontFamily;
+	const glyphMap = {
+		m: {
+			f: family,
+			u: config.upm,
+			z: config.safeZone,
+			s: config.startUnicode,
+			...config.web ? { w: true } : {}
+		},
+		i: {}
+	};
+	let currentUnicode = config.startUnicode;
+	const codepointToIcon = /* @__PURE__ */ new Map();
+	const allGlyphs = [];
+	const failed = [];
+	const skipped = [];
+	const pathkit = await loadPathKit();
+	for (const input of inputs) {
+		const result = await prepareIcon({
+			file: input.file,
+			svg: input.svg,
+			fontFamily: config.fontFamily,
+			upm: config.upm,
+			safeZone: config.safeZone
+		}, pathkit);
+		for (const [level, msg] of result.logs) logger?.[level](msg);
+		if (result.error !== null) {
+			logger?.fail(result.error);
+			failed.push(result.file);
+			continue;
+		}
+		if (result.layers.length === 0) {
+			skipped.push({
+				file: result.file,
+				reason: result.logs.filter(([, msg]) => SKIP_REASONS.test(msg)).map(([, msg]) => msg).at(-1) ?? "no paintable layers"
+			});
+			continue;
+		}
+		const layers = [];
+		for (const layer of result.layers) {
+			const cp = currentUnicode++;
+			codepointToIcon.set(cp, result.iconName);
+			allGlyphs.push({
+				codepoint: cp,
+				advanceWidth: result.adv,
+				d: layer.d
+			});
+			layers.push([cp, layer.fill || "black"]);
+		}
+		glyphMap.i[result.iconName] = [result.adv, layers];
+	}
+	if (failed.length) throw new Error(`${failed.length} of ${inputs.length} icons in [${config.fontFamily}] could not be converted: ${failed.join(", ")}`);
+	logger?.info(`Compiling TTF…`);
+	const ttfPath = path.join(paths.outputDir, `${family}.ttf`);
+	let ttfBuffer;
+	try {
+		ttfBuffer = await compileTtfFromGlyphs({
+			glyphs: allGlyphs,
+			outTtfPath: ttfPath,
+			fontName: family,
+			upm: config.upm,
+			ascent: config.upm,
+			descent: 0
+		});
+	} catch (err) {
+		parseCompileTtfFromGlyphsError(err, codepointToIcon);
+	}
+	let woff2Path;
+	if (config.web && ttfBuffer) {
+		logger?.info(`Compiling WOFF2…`);
+		woff2Path = path.join(paths.outputDir, `${family}.woff2`);
+		writeFileAtomic(woff2Path, await compileWoff2FromTtf(ttfBuffer));
+	}
+	const glyphmapPath = path.join(paths.outputDir, `${family}.glyphmap.json`);
+	if (inputHash) glyphMap.m.h = inputHash;
+	writeFileAtomic(glyphmapPath, JSON.stringify(glyphMap));
+	const iconCount = Object.keys(glyphMap.i).length;
+	const elapsed = Date.now() - startTime;
+	const products = woff2Path ? `${family}.ttf + ${family}.woff2` : `${family}.ttf`;
+	logger?.succeed(`Built ${products} [${iconCount} icon${iconCount === 1 ? "" : "s"} in ${elapsed}ms]`);
+	return {
+		ttfPath,
+		glyphmapPath,
+		family,
+		woff2Path,
+		glyphMap,
+		icons: Object.keys(glyphMap.i),
+		skipped
+	};
+}
+//#endregion
+//#region src/build/index.ts
+var DEFAULT_UPM = 1024;
+var DEFAULT_SAFE_ZONE = 1020;
+var DEFAULT_START_UNICODE = 59648;
+function generatorVersion() {
+	try {
+		const packageJsonPath = createRequire(import.meta.url).resolve("@octane-xplat/nano-icons/package.json");
+		return `@octane-xplat/nano-icons@${JSON.parse(fs$1.readFileSync(packageJsonPath, "utf8")).version ?? "unknown"}`;
+	} catch {
+		return "@octane-xplat/nano-icons@unknown";
+	}
+}
+function parseStartUnicode(value) {
+	if (value === void 0) return DEFAULT_START_UNICODE;
+	if (typeof value === "number") return value;
+	const parsed = value.startsWith("0x") ? parseInt(value, 16) : parseInt(value, 10);
+	if (!Number.isInteger(parsed) || parsed < 0 || parsed > 1114111) throw new RangeError(`Invalid startUnicode "${value}"`);
+	return parsed;
+}
+/** sha256 over sorted inputs + pipeline settings + generator version. */
+function fingerprintInputs(inputs, settings) {
+	const hash = crypto.createHash("sha256");
+	for (const input of [...inputs].sort((a, b) => a.file.localeCompare(b.file))) {
+		hash.update(input.file);
+		hash.update(input.svg);
+	}
+	hash.update(JSON.stringify(settings));
+	return hash.digest("hex");
+}
+/**
+* Build a layered icon font. Returns the emitted artifacts; throws if any
+* icon fails to convert. Icons that pass validation but paint nothing (or
+* use features skipped by validation) are listed in `skipped`.
+*/
+async function buildNanoIconFont(options) {
+	const fontFamily = options.fontFamily ?? (options.inputDir ? path.basename(path.resolve(options.inputDir)) : "nano-icons");
+	const web = options.web ?? true;
+	const config = {
+		fontFamily,
+		upm: options.upm ?? 1024,
+		safeZone: options.safeZone ?? 1020,
+		startUnicode: parseStartUnicode(options.startUnicode),
+		web
+	};
+	const inputs = [];
+	const namedIcons = /* @__PURE__ */ new Map();
+	if (options.inputDir) {
+		const dir = path.resolve(options.inputDir);
+		const files = (await fs.readdir(dir)).filter((f) => f.toLowerCase().endsWith(".svg"));
+		for (const file of files.sort()) inputs.push({
+			file,
+			svg: await fs.readFile(path.join(dir, file), "utf8")
+		});
+	}
+	for (const collection of options.iconify ?? []) for (const input of iconifyCollectionToSvgs(collection)) inputs.push({
+		file: input.file,
+		svg: input.svg
+	});
+	for (const icon of options.icons ?? []) {
+		if (namedIcons.has(icon.name)) throw new Error(`Duplicate icon name "${icon.name}"`);
+		namedIcons.set(icon.name, icon.svg);
+		inputs.push({
+			file: `${icon.name}.svg`,
+			svg: icon.svg
+		});
+	}
+	if (inputs.length === 0) throw new Error("buildNanoIconFont needs at least one of inputDir, icons, or iconify");
+	const inputHash = fingerprintInputs(inputs, [
+		config.upm,
+		config.safeZone,
+		config.startUnicode,
+		web,
+		generatorVersion()
+	]);
+	const family = `${config.fontFamily}-${inputHash.slice(0, 8)}`;
+	const outputDir = path.resolve(options.outputDir);
+	const glyphmapPath = path.join(outputDir, `${family}.glyphmap.json`);
+	const ttfPath = path.join(outputDir, `${family}.ttf`);
+	const woff2Path = path.join(outputDir, `${family}.woff2`);
+	if (fs$1.existsSync(glyphmapPath) && fs$1.existsSync(ttfPath)) {
+		const existing = JSON.parse(fs$1.readFileSync(glyphmapPath, "utf8"));
+		if (existing.m?.h === inputHash && existing.m.f === family) {
+			options.logger?.info?.(`Font "${family}" is up to date — skipping`);
+			const modulePath = options.module === false ? void 0 : emitNanoIconSetModule({
+				outputDir,
+				fontFamily,
+				family,
+				glyphMap: existing,
+				web
+			});
+			return {
+				fontFamily,
+				family,
+				ttfPath,
+				woff2Path: web && fs$1.existsSync(woff2Path) ? woff2Path : void 0,
+				glyphmapPath,
+				modulePath,
+				icons: Object.keys(existing.i),
+				skipped: [],
+				glyphMap: existing,
+				unchanged: true
+			};
+		}
+	}
+	const result = await runFontPipeline(config, { outputDir }, inputs, {
+		logger: options.logger,
+		inputHash
+	});
+	let modulePath;
+	if (options.module !== false) modulePath = emitNanoIconSetModule({
+		outputDir,
+		fontFamily,
+		family: result.family,
+		glyphMap: result.glyphMap,
+		web
+	});
+	if (options.appFontsDir) {
+		ensureDir(options.appFontsDir);
+		writeFileAtomic(path.join(options.appFontsDir, `${result.family}.ttf`), fs$1.readFileSync(result.ttfPath));
+	}
+	return {
+		fontFamily,
+		family: result.family,
+		ttfPath: result.ttfPath,
+		woff2Path: result.woff2Path,
+		glyphmapPath: result.glyphmapPath,
+		modulePath,
+		icons: result.icons,
+		skipped: result.skipped,
+		glyphMap: result.glyphMap,
+		unchanged: false
+	};
+}
+function loadNanoIconsConfig(configRoot) {
+	const configPath = path.join(configRoot, ".nanoicons.json");
+	if (!fs$1.existsSync(configPath)) throw new Error(`No .nanoicons.json found at ${configRoot}. Create one with:\n{ "iconSets": [{ "inputDir": "assets/icons", "fontFamily": "MyIcons", "outputDir": "src/generated/icons" }] }`);
+	return JSON.parse(fs$1.readFileSync(configPath, "utf8"));
+}
+/** Run every icon set in a config file; returns per-set results. */
+async function buildAllNanoIconFonts(config, configRoot, logger) {
+	if (!config.iconSets?.length) throw new Error("Config must contain an \"iconSets\" array with at least one entry");
+	const results = [];
+	for (const set of config.iconSets) results.push(await buildNanoIconFont({
+		...set,
+		outputDir: path.resolve(configRoot, set.outputDir ?? "nano-icons"),
+		inputDir: set.inputDir ? path.resolve(configRoot, set.inputDir) : void 0,
+		appFontsDir: set.appFontsDir ? path.resolve(configRoot, set.appFontsDir) : void 0,
+		logger
+	}));
+	return results;
+}
+//#endregion
+export { buildNanoIconFont as a, loadPathKit as c, buildAllNanoIconFonts as i, iconifyCollectionToSvgs as l, DEFAULT_START_UNICODE as n, loadNanoIconsConfig as o, DEFAULT_UPM as r, runFontPipeline as s, DEFAULT_SAFE_ZONE as t };