@jannchie/icons 0.0.0-stage → 0.1.0

package/dist/src/chinese-zodiac.js

@@ -0,0 +1,239 @@
+import { dot } from "./scene.js";
+import { mirror } from "./transform.js";
+import { circle, crisp, rounded } from "./geometry.js";
+import { face, longEar, pointedEar, roundEar } from "./chiikawa.js";
+//#region src/chinese-zodiac.js
+var thin = (d) => ({
+	d,
+	thin: true
+});
+var pair = (p) => typeof p === "string" ? [p, mirror(p)] : [p, {
+	...p,
+	d: mirror(p.d)
+}];
+var eyes = (x, y, size) => [dot(x, y, size), dot(24 - x, y, size)];
+var head = (d) => ({
+	d,
+	cut: true,
+	gap: 0,
+	occlude: true
+});
+var keep = (p) => typeof p === "string" ? {
+	d: p,
+	cut: true,
+	gap: 0
+} : {
+	...p,
+	cut: true,
+	gap: 0
+};
+var ellipse = (cx, cy, rx, ry) => `M${cx - rx} ${cy}a${rx} ${ry} 0 1 0 ${rx * 2} 0a${rx} ${ry} 0 1 0 ${-rx * 2} 0`;
+var CHINESE_ZODIAC = {
+	rat: {
+		zh: "鼠",
+		paths: () => [
+			head("M12 8C15.5 8 17.5 10.5 17.5 13C17.5 16 14.5 18.5 12.75 20Q12 20.6 11.25 20C9.5 18.5 6.5 16 6.5 13C6.5 10.5 8.5 8 12 8Z"),
+			circle(6.5, 7, 3.5),
+			circle(17.5, 7, 3.5),
+			...eyes(9.75, 12.75).map(keep),
+			keep(dot(12, 19.5, 2.5)),
+			...pair(thin("M8 16L3.5 15")),
+			...pair(thin("M8.5 18L4.5 19.5"))
+		]
+	},
+	ox: {
+		zh: "牛",
+		paths: () => [
+			"M7.5 7.5H16.5C17.5 7.5 18 8.25 17.75 9.5L16.75 14.5C18.5 15.5 18.75 17 18.25 18.5C17.75 20 16.5 20.5 15 20.5H9C7.5 20.5 6.25 20 5.75 18.5C5.25 17 5.5 15.5 7.25 14.5L6.25 9.5C6 8.25 6.5 7.5 7.5 7.5Z",
+			...pair("M7 7.5C4.5 7.5 3 6 3 3.5"),
+			...pair("M6.4 10.5C5 9.75 3.75 10 3 11.5C4.25 12.5 5.5 12.5 6.75 11.75"),
+			...eyes(9.5, 11.5),
+			...eyes(10, 17.75)
+		]
+	},
+	tiger: {
+		zh: "虎",
+		paths: () => [
+			face({
+				top: 6,
+				bottom: 20.5,
+				half: 9,
+				waist: 13.5
+			}, {
+				right: {
+					from: .22,
+					to: .48,
+					draw: roundEar(1.8)
+				},
+				left: {
+					from: .52,
+					to: .78,
+					draw: roundEar(1.8)
+				}
+			}),
+			thin("M10.5 7.75H13.5M10.75 9.25H13.25M10.5 10.75H13.5M12 7.75V10.75"),
+			...eyes(8.5, 13),
+			{
+				d: rounded([
+					[10.75, 15.25],
+					[13.25, 15.25],
+					[12, 16.75]
+				], .4),
+				fill: true
+			},
+			thin("M12 16.75V17.5C11.5 18.25 10.5 18.25 10 17.75M12 17.5C12.5 18.25 13.5 18.25 14 17.75"),
+			...pair(thin("M3 13.5L5.75 14")),
+			...pair(thin("M3.5 16.5L6 16"))
+		]
+	},
+	rabbit: {
+		zh: "兔",
+		paths: () => [
+			face({
+				top: 10.5,
+				bottom: 20.5,
+				half: 7,
+				waist: 15.5
+			}, {
+				right: {
+					from: .32,
+					to: .66,
+					draw: longEar(2.5)
+				},
+				left: {
+					from: .34,
+					to: .68,
+					draw: longEar(2.5)
+				}
+			}),
+			...eyes(9.25, 15),
+			thin("M11 17H13L12 18ZM12 18V18.5C11.5 19.25 10.75 19.25 10.25 18.75M12 18.5C12.5 19.25 13.25 19.25 13.75 18.75")
+		]
+	},
+	dragon: {
+		zh: "龙",
+		paths: (r) => [
+			rounded([
+				[8.5, 7.5],
+				[15.5, 7.5],
+				[19, 9.5],
+				[16, 12.5],
+				[15.5, 16.5],
+				[16.75, 18.5],
+				[15, 20.5],
+				[9, 20.5],
+				[7.25, 18.5],
+				[8.5, 16.5],
+				[8, 12.5],
+				[5, 9.5]
+			], crisp(r)),
+			...pair("M9.5 7.5C9 5.5 8 4.25 6 3.25"),
+			...pair("M8.5 5.25L9 3"),
+			...pair("M7.25 18.5C5 18.5 3.5 17 3.75 14.75"),
+			...pair(thin("M8.25 9.75L10.75 10.5")),
+			...eyes(9.75, 12),
+			...eyes(10.75, 18.25, 1.5)
+		]
+	},
+	snake: {
+		zh: "蛇",
+		paths: () => [
+			"M12 3C15.25 3 17 5 17 7.25C17 9.75 14.5 11.25 12 11.25C9.5 11.25 7 9.75 7 7.25C7 5 8.75 3 12 3Z",
+			...eyes(9.75, 6.75),
+			"M16.25 10C18.5 11.25 20.5 13.5 20.5 16.75C20.5 19.5 17 20.5 12 20.5C7 20.5 3.5 19.5 3.5 17.25C3.5 15.5 5.5 14.5 8 14.75",
+			"M11.5 11.23V13M11.5 13L10.25 14.5M11.5 13L12.75 14.5"
+		]
+	},
+	horse: {
+		zh: "马",
+		paths: () => [
+			"M8.25 7L7.25 3Q10 4.5 10.5 6.5H13.5Q14 4.5 16.75 3L15.75 7C17 8.5 17 11 16.25 13.5C15.75 15 16 16.5 16.5 17.5C17.25 19.5 15.5 21 12 21C8.5 21 6.75 19.5 7.5 17.5C8 16.5 8.25 15 7.75 13.5C7 11 7 8.5 8.25 7Z",
+			thin("M10.5 6.5C11.75 7.75 12.5 8.75 12 10.5M12.5 6.5C13.25 7.5 13.5 8 13.25 9"),
+			...eyes(9.25, 10.5),
+			...eyes(10, 18.5)
+		]
+	},
+	goat: {
+		zh: "羊",
+		paths: () => [
+			"M9 7.5H15C16.5 7.5 17 8.5 16.75 10L15 17C14.5 18.75 13.5 19.5 12 19.5C10.5 19.5 9.5 18.75 9 17L7.25 10C7 8.5 7.5 7.5 9 7.5Z",
+			...pair("M9 7.5C7 4.5 3 5 3 9C3 11.5 5.5 12.5 6.5 11C7 10 6.25 9 5.5 9.25"),
+			...eyes(10, 11.5),
+			"M11 19.5L12 21.5L13 19.5"
+		]
+	},
+	monkey: {
+		zh: "猴",
+		paths: () => [
+			head(circle(12, 12, 7.75)),
+			circle(4.5, 12.5, 2.25),
+			circle(19.5, 12.5, 2.25),
+			keep(thin("M12 9.25C11 7.75 7.75 7.75 7.75 11C7.75 12.75 8.75 13.5 8.75 15.25C8.75 17.25 10 18.25 12 18.25C14 18.25 15.25 17.25 15.25 15.25C15.25 13.5 16.25 12.75 16.25 11C16.25 7.75 13 7.75 12 9.25Z")),
+			...eyes(10, 12).map(keep),
+			...eyes(11.25, 14.75, 1.25).map(keep),
+			keep(thin("M10.75 16.75Q12 17.5 13.25 16.75"))
+		]
+	},
+	rooster: {
+		zh: "鸡",
+		paths: () => [
+			"M8.5 15.5C7 14.5 6 13 6 11.5C6 8.75 8.5 7 12 7C15.5 7 18 8.75 18 11.5C18 13 17 14.5 15.5 15.5",
+			"M8.5 7.75C6.75 7 6.75 4.25 9 4.25C9 1.75 12.25 1.25 12.75 3.5C14.25 2 17 3 16 5.75C17 6.5 16.25 7.75 15.25 8",
+			...eyes(9, 10.5),
+			{
+				d: rounded([
+					[10.25, 11.5],
+					[13.75, 11.5],
+					[12, 14.25]
+				], .5),
+				fill: true
+			},
+			"M12 15.75C10.25 15.75 9.75 17 9.75 18.25C9.75 19.75 10.25 21 11 21C11.5 21 12 20.5 12 19.75C12 20.5 12.5 21 13 21C13.75 21 14.25 19.75 14.25 18.25C14.25 17 13.75 15.75 12 15.75Z"
+		]
+	},
+	dog: {
+		zh: "狗",
+		paths: () => [
+			"M12 6C16 6 17.5 8 17.5 11V14C17.5 18 15 20.5 12 20.5C9 20.5 6.5 18 6.5 14V11C6.5 8 8 6 12 6Z",
+			...pair({
+				d: "M8.5 6.5C5 6 3.25 8.5 3.25 11.5C3.25 14 4.25 16 5.75 16C7 16 7.5 14.5 7.5 12.5C7.5 10 8 8 8.5 6.5Z",
+				cut: true,
+				gap: 0,
+				occlude: true
+			}),
+			...eyes(10, 11.5),
+			{
+				d: ellipse(12, 15.25, 1.75, 1.15),
+				fill: true
+			},
+			thin("M12 16.5V17.5C11.5 18.25 10.5 18.25 10 17.75M12 17.5C12.5 18.25 13.5 18.25 14 17.75")
+		]
+	},
+	pig: {
+		zh: "猪",
+		paths: () => [
+			face({
+				top: 6.5,
+				bottom: 20.5,
+				half: 9,
+				waist: 13.5
+			}, {
+				right: {
+					from: .2,
+					to: .5,
+					draw: pointedEar([19.5, 4], .6)
+				},
+				left: {
+					from: .5,
+					to: .8,
+					draw: pointedEar([4.5, 4], .6)
+				}
+			}),
+			...eyes(8.5, 11.5),
+			ellipse(12, 15.5, 3.5, 2.5),
+			...eyes(10.75, 15.5, 1.5)
+		]
+	}
+};
+//#endregion
+export { CHINESE_ZODIAC };

package/dist/src/clearance.js

@@ -0,0 +1,93 @@
+var SHIFT_COST = 4;
+var GROW_COST = 1.25;
+function snap(grid, c, k) {
+	if (!grid) return {
+		c,
+		k
+	};
+	const nested = k < 2;
+	const fix = (v, at, s) => {
+		if (at === void 0) return v;
+		const p = v + at * s;
+		const d = .5 - (p - Math.floor(p));
+		if (Math.abs(d) < 1e-6 || nested && d > .499999) return v;
+		return v + (d > .499999 ? -.5 : d);
+	};
+	const at = (s) => ({
+		c: [fix(c[0], grid.x, s), fix(c[1], grid.y, s)],
+		k: s
+	});
+	if (!grid.unit) return at(k);
+	const span = grid.unit * k;
+	const offGrid = (x, n) => Math.abs(((x + n / 2) % 1 + 1) % 1 - .5) > 1e-6 ? 2 : 0;
+	const cost = ({ c: [x, y], k: s }) => {
+		const n = s * grid.unit;
+		const d = n - span;
+		return (d > 0 ? d * GROW_COST : -d) + (Math.abs(x - c[0]) + Math.abs(y - c[1])) * SHIFT_COST + (nested ? offGrid(x, n) : 0);
+	};
+	const base = Math.round(span);
+	return [
+		base - 1,
+		base,
+		base + 1
+	].filter((n) => n >= 1).map((n) => at(n / grid.unit)).reduce((a, b) => cost(b) < cost(a) - 1e-6 ? b : a);
+}
+var align = (v, ref, k, min = 0) => {
+	const n = Math.round((v - ref) * k);
+	return ref + Math.sign(v - ref) * Math.max(Math.abs(n), min) / k;
+};
+function place(shape, center, scale) {
+	const { c: [cx, cy], k } = snap(shape.grid, center, scale);
+	if (shape.circle) return {
+		circle: shape.circle * k,
+		c: [cx, cy]
+	};
+	const [x0, y0, x1, y1] = shape.box;
+	return { box: [
+		cx + x0 * k,
+		cy + y0 * k,
+		cx + x1 * k,
+		cy + y1 * k
+	] };
+}
+function blocked(shape, axis, at, stroke) {
+	const g = 1 + stroke;
+	if (shape.circle) {
+		const [cx, cy] = shape.c;
+		const d = axis === "x" ? Math.abs(at - cy) : Math.abs(at - cx);
+		const reach = shape.circle + g;
+		if (d >= reach) return null;
+		const e = Math.sqrt(reach * reach - d * d);
+		const m = axis === "x" ? cx : cy;
+		return [m - e, m + e];
+	}
+	const [x0, y0, x1, y1] = shape.box;
+	const [lo, hi, a0, a1] = axis === "x" ? [
+		y0,
+		y1,
+		x0,
+		x1
+	] : [
+		x0,
+		x1,
+		y0,
+		y1
+	];
+	const d = Math.max(lo - at, at - hi, 0);
+	if (d >= g) return null;
+	const e = Math.sqrt(g * g - d * d);
+	return [a0 - e, a1 + e];
+}
+function rectAround(shape, stroke, [l, t, r, b]) {
+	const right = blocked(shape, "y", r, stroke);
+	const bottom = blocked(shape, "x", b, stroke);
+	return [
+		[bottom ? bottom[0] : r, b],
+		[l, b],
+		[l, t],
+		[r, t],
+		[r, right ? right[0] : b]
+	];
+}
+//#endregion
+export { align, blocked, place, rectAround, snap };

package/dist/src/clip.js

@@ -0,0 +1,220 @@
+import { parse } from "./svg.js";
+//#region src/clip.js
+var lerp = (a, b, t) => [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t];
+var fmt = (p) => `${p[0]} ${p[1]}`;
+function split(pts, t) {
+	const left = [pts[0]];
+	let cur = pts;
+	while (cur.length > 1) {
+		cur = cur.slice(1).map((p, i) => lerp(cur[i], p, t));
+		left.push(cur[0]);
+	}
+	return left;
+}
+var bezierAt = (ps, t) => split(ps, t).at(-1);
+function bezierSub(ps, t0, t1) {
+	const head = split(ps, t1);
+	return t1 === 0 || t0 === 0 ? head : split(head.reverse(), 1 - t0 / t1).reverse();
+}
+function arcCenter(p1, [rx, ry, phi, fa, fs, x2, y2]) {
+	const [x1, y1] = p1;
+	const r = phi * Math.PI / 180;
+	const [cos, sin] = [Math.cos(r), Math.sin(r)];
+	const [hx0, hy0] = [(x1 - x2) / 2, (y1 - y2) / 2];
+	const hx = cos * hx0 + sin * hy0;
+	const hy = -sin * hx0 + cos * hy0;
+	const lambda = hx * hx / (rx * rx) + hy * hy / (ry * ry);
+	if (lambda > 1) [rx, ry] = [rx * Math.sqrt(lambda), ry * Math.sqrt(lambda)];
+	const num = rx * rx * ry * ry - rx * rx * hy * hy - ry * ry * hx * hx;
+	const coef = (fa !== fs ? 1 : -1) * Math.sqrt(Math.max(0, num / (rx * rx * hy * hy + ry * ry * hx * hx)));
+	const [cxp, cyp] = [coef * rx * hy / ry, -coef * ry * hx / rx];
+	const c = [cos * cxp - sin * cyp + (x1 + x2) / 2, sin * cxp + cos * cyp + (y1 + y2) / 2];
+	const ang = (ux, uy) => Math.atan2(uy, ux);
+	const a1 = ang((hx - cxp) / rx, (hy - cyp) / ry);
+	let da = ang((-hx - cxp) / rx, (-hy - cyp) / ry) - a1;
+	if (fs && da < 0) da += 2 * Math.PI;
+	if (!fs && da > 0) da -= 2 * Math.PI;
+	const at = (t) => {
+		const a = a1 + da * t;
+		const [ex, ey] = [rx * Math.cos(a), ry * Math.sin(a)];
+		return [c[0] + cos * ex - sin * ey, c[1] + sin * ex + cos * ey];
+	};
+	return {
+		rx,
+		ry,
+		da,
+		at
+	};
+}
+function segments(d) {
+	const subs = [];
+	let cur = null;
+	let pos = [0, 0];
+	for (const [type, a] of parse(d, true)) {
+		if (type === "M") {
+			cur = {
+				start: a,
+				segs: [],
+				closed: false
+			};
+			subs.push(cur);
+			pos = a;
+			continue;
+		}
+		const from = pos;
+		let seg;
+		if (type === "L" || type === "Z") {
+			const to = type === "Z" ? cur.start : a;
+			seg = {
+				kind: "line",
+				at: (t) => lerp(from, to, t),
+				sub: (t0, t1) => `L${fmt(lerp(from, to, t1))}`
+			};
+			if (type === "Z") cur.closed = true;
+			pos = to;
+		} else if (type === "C" || type === "Q") {
+			const ps = [from];
+			for (let i = 0; i < a.length; i += 2) ps.push([a[i], a[i + 1]]);
+			seg = {
+				kind: "curve",
+				at: (t) => bezierAt(ps, t),
+				sub: (t0, t1) => `${type}${bezierSub(ps, t0, t1).slice(1).map(fmt).join(" ")}`
+			};
+			pos = ps.at(-1);
+		} else if (type === "A") {
+			const { rx, ry, da, at } = arcCenter(from, a);
+			seg = {
+				kind: "curve",
+				at,
+				sub: (t0, t1) => `A${rx} ${ry} ${a[2]} ${Math.abs(da * (t1 - t0)) > Math.PI ? 1 : 0} ${da > 0 ? 1 : 0} ${fmt(at(t1))}`
+			};
+			pos = [a[5], a[6]];
+		}
+		cur.segs.push(seg);
+	}
+	return subs;
+}
+function samples(seg, n) {
+	const [a, b] = [seg.at(0), seg.at(1)];
+	if (seg.kind === "line") return a[0] === b[0] && a[1] === b[1] ? [a] : [a, b];
+	return Array.from({ length: n + 1 }, (_, i) => seg.at(i / n));
+}
+var box = (pts) => pts.reduce((b, [x, y]) => [
+	Math.min(b[0], x),
+	Math.min(b[1], y),
+	Math.max(b[2], x),
+	Math.max(b[3], y)
+], [
+	Infinity,
+	Infinity,
+	-Infinity,
+	-Infinity
+]);
+var overlaps = (a, b, g) => a[0] - g <= b[2] && b[0] - g <= a[2] && a[1] - g <= b[3] && b[1] - g <= a[3];
+function blade(cuts, occluders) {
+	const lines = [];
+	for (const d of cuts) for (const { segs } of segments(d)) for (const s of segs) {
+		const pts = samples(s, 32);
+		if (pts.length === 1) lines.push([pts[0], pts[0]]);
+		for (let i = 1; i < pts.length; i++) lines.push([pts[i - 1], pts[i]]);
+	}
+	const polys = occluders.flatMap((d) => segments(d).map(({ segs }) => segs.flatMap((s) => samples(s, 32))));
+	return {
+		lines,
+		polys,
+		bounds: box([...lines.flat(), ...polys.flat()])
+	};
+}
+function distance(p, lines) {
+	let best = Infinity;
+	for (const [a, b] of lines) {
+		const [dx, dy] = [b[0] - a[0], b[1] - a[1]];
+		const len2 = dx * dx + dy * dy;
+		const t = len2 ? Math.max(0, Math.min(1, ((p[0] - a[0]) * dx + (p[1] - a[1]) * dy) / len2)) : 0;
+		best = Math.min(best, Math.hypot(p[0] - a[0] - dx * t, p[1] - a[1] - dy * t));
+	}
+	return best;
+}
+function inside([x, y], poly) {
+	let hit = false;
+	for (let i = 0, j = poly.length - 1; i < poly.length; j = i++) {
+		const [[xi, yi], [xj, yj]] = [poly[i], poly[j]];
+		if (yi > y !== yj > y && x < (xj - xi) * (y - yi) / (yj - yi) + xi) hit = !hit;
+	}
+	return hit;
+}
+function keptRanges(seg, cut, g) {
+	if (!overlaps(box(samples(seg, 8)), cut.bounds, g + .5)) return [[0, 1]];
+	const N = 48;
+	const out = (t) => {
+		const p = seg.at(t);
+		return distance(p, cut.lines) >= g && !cut.polys.some((poly) => inside(p, poly));
+	};
+	const edge = (a, b) => {
+		const sa = out(a);
+		for (let i = 0; i < 24; i++) {
+			const m = (a + b) / 2;
+			if (out(m) === sa) a = m;
+			else b = m;
+		}
+		return (a + b) / 2;
+	};
+	const ranges = [];
+	let start = out(0) ? 0 : null;
+	let prevT = 0;
+	let prevOut = out(0);
+	for (let i = 1; i <= N; i++) {
+		const t = i / N;
+		const o = out(t);
+		if (o !== prevOut) {
+			const e = edge(prevT, t);
+			if (o) start = e;
+			else ranges.push([start, e]);
+		}
+		prevT = t;
+		prevOut = o;
+	}
+	if (prevOut) ranges.push([start, 1]);
+	return ranges;
+}
+function clip(d, cuts, g, occluders = []) {
+	const cut = blade(cuts, occluders);
+	let result = "";
+	for (const sub of segments(d)) {
+		const length = (s) => Math.hypot(s.at(1)[0] - s.at(0)[0], s.at(1)[1] - s.at(0)[1]);
+		if (sub.segs.every((s) => length(s) === 0)) {
+			if (distance(sub.start, cut.lines) >= g && !cut.polys.some((poly) => inside(sub.start, poly))) result += `M${fmt(sub.start)}h0`;
+			continue;
+		}
+		const pieces = [];
+		sub.segs.forEach((s, i) => keptRanges(s, cut, g).forEach(([t0, t1]) => pieces.push([
+			i,
+			t0,
+			t1
+		])));
+		if (!pieces.length) continue;
+		const last = sub.segs.length - 1;
+		if (pieces.length === sub.segs.length && pieces.every(([, t0, t1]) => t0 === 0 && t1 === 1)) {
+			result += `M${fmt(sub.start)}${sub.segs.map((s) => s.sub(0, 1)).join("")}${sub.closed ? "Z" : ""}`;
+			continue;
+		}
+		if (sub.closed && pieces[0][0] === 0 && pieces[0][1] === 0 && pieces.at(-1)[0] === last && pieces.at(-1)[2] === 1) {
+			let k = 0;
+			while (k + 1 < pieces.length && pieces[k + 1][0] === pieces[k][0] + 1 && pieces[k][2] === 1 && pieces[k + 1][1] === 0) k++;
+			pieces.push(...pieces.splice(0, k + 1));
+		}
+		let prev = null;
+		for (const [i, t0, t1] of pieces) {
+			if (!(prev && t0 === 0 && prev[2] === 1 && (prev[0] + 1) % sub.segs.length === i)) result += `M${fmt(sub.segs[i].at(t0))}`;
+			result += sub.segs[i].sub(t0, t1);
+			prev = [
+				i,
+				t0,
+				t1
+			];
+		}
+	}
+	return result;
+}
+//#endregion
+export { bezierAt, bezierSub, clip, samples, segments };

package/dist/src/controller.js

@@ -0,0 +1,55 @@
+import { crisp, rounded } from "./geometry.js";
+import { line, snap } from "./letters.js";
+//#region src/controller.js
+var text = (str, center, s = 1, gap = 1.5) => snap(line(str, center, s, gap));
+var bumperLeft = "M2.5 18.5V12.5C2.5 9 5 6.5 8.5 6.5H16.5C19.75 6.5 21.5 8 21.5 10.5V18.5Z";
+var bumperRight = "M21.5 18.5V12.5C21.5 9 19 6.5 15.5 6.5H7.5C4.25 6.5 2.5 8 2.5 10.5V18.5Z";
+var triggerLeft = "M5.5 20.5V10C5.5 6 8.5 3.5 12.5 3.5C16 3.5 18.5 5 18.5 8V20.5Z";
+var triggerRight = "M18.5 20.5V10C18.5 6 15.5 3.5 11.5 3.5C8 3.5 5.5 5 5.5 8V20.5Z";
+var pill = rounded([
+	[7.5, 2.5],
+	[16.5, 2.5],
+	[16.5, 21.5],
+	[7.5, 21.5]
+], 4.5);
+var dpad = (radius) => rounded([
+	[8.5, 2.5],
+	[15.5, 2.5],
+	[15.5, 8.5],
+	[21.5, 8.5],
+	[21.5, 15.5],
+	[15.5, 15.5],
+	[15.5, 21.5],
+	[8.5, 21.5],
+	[8.5, 15.5],
+	[2.5, 15.5],
+	[2.5, 8.5],
+	[8.5, 8.5]
+], crisp(radius));
+var dpadArrow = (dir, radius) => {
+	const v = {
+		up: [
+			[10, 7.5],
+			[12, 5.5],
+			[14, 7.5]
+		],
+		down: [
+			[10, 16.5],
+			[12, 18.5],
+			[14, 16.5]
+		],
+		left: [
+			[7.5, 10],
+			[5.5, 12],
+			[7.5, 14]
+		],
+		right: [
+			[16.5, 10],
+			[18.5, 12],
+			[16.5, 14]
+		]
+	}[dir];
+	return rounded(v, crisp(radius), false);
+};
+//#endregion
+export { bumperLeft, bumperRight, dpad, dpadArrow, pill, text, triggerLeft, triggerRight };

package/dist/src/export.js

@@ -0,0 +1,68 @@
+import { resolveOptions } from "./options.js";
+import { minify } from "./svg.js";
+import { ROLES } from "./tone.js";
+import { animateAttrs, pathAttrs, pathsOf, svgAttrs } from "./render.js";
+//#region src/export.js
+var attrs = (obj) => Object.entries(obj).filter(([, v]) => v !== void 0).map(([k, v]) => `${k}="${v}"`).join(" ");
+function resolveColors({ duo = false, theme = "light", colors = {} } = {}) {
+	if (!duo) return void 0;
+	const roles = Object.fromEntries(Object.entries(ROLES).map(([r, c]) => [r, colors[r] ?? c[theme]]));
+	return {
+		primary: colors.primary,
+		...roles
+	};
+}
+function svgBody(paths, colors) {
+	const merged = /* @__PURE__ */ new Map();
+	const animated = [];
+	for (const p of paths) {
+		if (p.frames) {
+			animated.push(`<path ${attrs(pathAttrs(p, colors))}><animate ${attrs(animateAttrs(p))}/></path>`);
+			continue;
+		}
+		const { d, ...rest } = pathAttrs(p, colors);
+		const key = attrs(rest);
+		merged.set(key, (merged.get(key) ?? "") + d);
+	}
+	return [...[...merged].map(([key, d]) => `<path ${attrs({ d: minify(d, { packArcs: true }) })}${key ? ` ${key}` : ""}/>`), ...animated];
+}
+function svgString(paths, { stroke, sharp, colors, size = 24 }) {
+	const body = svgBody(paths, colors).map((l) => `  ${l}`).join("\n");
+	return `<svg xmlns="http://www.w3.org/2000/svg" width="${size}" height="${size}" viewBox="0 0 24 24" ${attrs(svgAttrs(stroke, sharp, colors))}>\n${body}\n</svg>\n`;
+}
+function toSvg(icon, { radius, weight, size = 24, duo, theme, colors } = {}) {
+	const o = resolveOptions({
+		radius,
+		weight
+	});
+	return svgString(pathsOf(icon, o.corner, o.weight), {
+		stroke: o.weight.stroke,
+		sharp: !!o.corner.sharp,
+		colors: resolveColors({
+			duo,
+			theme,
+			colors
+		}),
+		size
+	});
+}
+function toPaths(icon, { radius, weight, duo, theme, colors, px = 0 } = {}) {
+	const o = resolveOptions({
+		radius,
+		weight
+	});
+	const c = resolveColors({
+		duo,
+		theme,
+		colors
+	});
+	return {
+		svg: svgAttrs(o.weight.stroke, !!o.corner.sharp, c),
+		paths: pathsOf(icon, o.corner, o.weight, px).map((p) => ({
+			...pathAttrs(p, c),
+			animate: animateAttrs(p) ?? void 0
+		}))
+	};
+}
+//#endregion
+export { resolveColors, svgBody, svgString, toPaths, toSvg };