@jannchie/icons 0.0.0-stage → 0.2.0

package/dist/src/symbols.js

@@ -0,0 +1,637 @@
+import { align, snap } from "./clearance.js";
+import { dot } from "./scene.js";
+import { circle, crisp, rounded } from "./geometry.js";
+import { inset } from "./folder.js";
+import { triangle, triangleWidth } from "./media.js";
+//#region src/symbols.js
+var BADGE_GROW = 1.15;
+var cornerScale = Object.fromEntries(Object.entries({
+	plus: 1.2,
+	minus: 1.2,
+	cross: 1,
+	check: 1,
+	image: 1,
+	music: .9,
+	video: 1,
+	assets: 1,
+	ring: 1,
+	star: 1,
+	cloud: 1,
+	shield: 1,
+	ban: 1,
+	arrowUp: 1,
+	arrowDown: 1,
+	arrowLeft: 1,
+	arrowRight: 1,
+	bookmark: 1,
+	sparkle: 1,
+	puzzle: 1,
+	plug: 1,
+	clock: 1,
+	gauge: 1,
+	lock: 1,
+	code: 1,
+	search: 1
+}).map(([name, k]) => [name, k * BADGE_GROW]));
+cornerScale.cross = inset / 2;
+var tri = 3 / Math.tan(Math.PI / 6);
+var outlines = {
+	plus: { box: [
+		-2.5,
+		-2.5,
+		2.5,
+		2.5
+	] },
+	minus: { box: [
+		-2.5,
+		-2.5,
+		2.5,
+		2.5
+	] },
+	cross: { box: [
+		-2,
+		-2,
+		2,
+		2
+	] },
+	check: { box: [
+		-3,
+		-2,
+		3,
+		2
+	] },
+	image: { box: [
+		-3.5,
+		-3.5,
+		3.5,
+		3.5
+	] },
+	music: { box: [
+		-2.75,
+		-3.75,
+		2.75,
+		3.75
+	] },
+	video: { box: [
+		-tri / 3,
+		-3,
+		tri * 2 / 3,
+		3
+	] },
+	assets: { box: [
+		-3.5,
+		-3.5,
+		3.5,
+		3.5
+	] },
+	ring: { circle: 3 },
+	star: { circle: 3.45 },
+	cloud: { box: [
+		-3.65,
+		-2.65,
+		3.6,
+		2.65
+	] },
+	shield: { box: [
+		-3.01,
+		-3.5,
+		3.01,
+		3.5
+	] },
+	ban: { circle: 3.25 },
+	arrowUp: { box: [
+		-3,
+		-3.5,
+		3,
+		3.5
+	] },
+	arrowDown: { box: [
+		-3,
+		-3.5,
+		3,
+		3.5
+	] },
+	arrowLeft: { box: [
+		-3.5,
+		-3,
+		3.5,
+		3
+	] },
+	arrowRight: { box: [
+		-3.5,
+		-3,
+		3.5,
+		3
+	] },
+	bookmark: { box: [
+		-2.5,
+		-3.5,
+		2.5,
+		3.5
+	] },
+	sparkle: { circle: 3.2 },
+	puzzle: { box: [
+		-3.5,
+		-3.5,
+		3.5,
+		3.5
+	] },
+	plug: { box: [
+		-2.4,
+		-3.5,
+		2.4,
+		3.5
+	] },
+	clock: { circle: 3.5 },
+	gauge: { box: [
+		-3.5,
+		-3.5,
+		3.5,
+		3.5
+	] },
+	lock: { box: [
+		-3,
+		-3.5,
+		3,
+		3.5
+	] },
+	code: { box: [
+		-3.5,
+		-2.5,
+		3.5,
+		2.5
+	] },
+	search: { box: [
+		-3.5,
+		-3.5,
+		3.5,
+		3.5
+	] }
+};
+var grids = {
+	plus: {
+		x: 0,
+		y: 0
+	},
+	minus: { y: 0 },
+	image: {
+		unit: 7,
+		x: 3.5,
+		y: 3.5
+	},
+	music: { x: .25 },
+	video: { x: -triangleWidth(6) / 3 },
+	assets: {
+		unit: 3.5,
+		x: 0,
+		y: 0
+	},
+	cloud: { y: 2.65 },
+	shield: {
+		unit: 6.02,
+		x: 3.01
+	},
+	arrowUp: { x: 0 },
+	arrowDown: { x: 0 },
+	arrowLeft: { y: 0 },
+	arrowRight: { y: 0 },
+	bookmark: {
+		unit: 5,
+		x: 2.5,
+		y: -3.5
+	},
+	puzzle: {
+		unit: 5.15,
+		x: 3.5,
+		y: 3.5
+	},
+	plug: {
+		x: 0,
+		y: -1.75
+	},
+	clock: { x: 0 },
+	lock: {
+		unit: 3,
+		x: 0,
+		y: -.5
+	}
+};
+for (const [name, grid] of Object.entries(grids)) if (outlines[name]) outlines[name].grid = grid;
+var symbol = (draw, grid) => (center, scale = 1, radius = 0) => {
+	const { c, k } = snap(grid, center, scale);
+	const paths = draw(c, k, radius);
+	return scale < 2 ? paths.map((p) => typeof p === "string" ? {
+		d: p,
+		detail: true
+	} : {
+		...p,
+		detail: true
+	}) : paths;
+};
+var at = ([cx, cy], k) => ([x, y]) => [cx + x * k, cy + y * k];
+var drawPlus = ([x, y], k = 1) => [`M${x} ${y - 2.5 * k}V${y + 2.5 * k}`, `M${x - 2.5 * k} ${y}H${x + 2.5 * k}`];
+var drawMinus = ([x, y], k = 1) => [`M${x - 2.5 * k} ${y}H${x + 2.5 * k}`];
+var drawCross = ([x, y], k = 1) => [`M${x - 2 * k} ${y - 2 * k}L${x + 2 * k} ${y + 2 * k}`, `M${x + 2 * k} ${y - 2 * k}L${x - 2 * k} ${y + 2 * k}`];
+var drawCheck = (c, k = 1) => {
+	const p = at(c, k);
+	const [a, b, d] = [
+		p([-3, 0]),
+		p([-1, 2]),
+		p([3, -2])
+	];
+	return [`M${a[0]} ${a[1]}L${b[0]} ${b[1]}L${d[0]} ${d[1]}`];
+};
+var drawImage = (c, k = 1, radius = 0) => {
+	const p = at(c, k);
+	const sun = p([1.75, -1.75]);
+	return [
+		rounded([
+			[-3.5, -3.5],
+			[3.5, -3.5],
+			[3.5, 3.5],
+			[-3.5, 3.5]
+		].map(p), Math.min(radius, k)),
+		dot(sun[0], sun[1]),
+		rounded([
+			[-3.5, 2],
+			[-1.5, 0],
+			[2, 3.5]
+		].map(p), crisp(radius), false)
+	];
+};
+var drawMusic = (c, k = 1, radius = 0) => {
+	const p = at(c, k);
+	const head = p([-1.25, 2.25]);
+	return [circle(head[0], head[1], 1.5 * k), rounded([
+		[.25, 2.25],
+		[.25, -3.75],
+		[2.75, -1.25]
+	].map(p), crisp(radius), false)];
+};
+var drawVideo = ([x, y], k = 1, radius = 0) => {
+	const h = 6 * k;
+	return [rounded(triangle(x - triangleWidth(h) / 3, h, 1, y), Math.min(radius, k))];
+};
+var drawAssets = ([x, y], k = 1, radius = 0) => {
+	const s = 3.5 * k;
+	return [
+		rounded([
+			[x - s, y - s],
+			[x + s, y - s],
+			[x + s, y + s],
+			[x - s, y + s]
+		], Math.min(radius, k)),
+		`M${x} ${y - s}V${y + s}`,
+		`M${x - s} ${y}H${x + s}`
+	];
+};
+var drawRing = ([x, y], k = 1) => [circle(x, y, 3 * k)];
+var drawStar = ([x, y], k = 1, radius = 0) => {
+	const R = 3.6 * k;
+	const r = R * .48;
+	const dy = R * (1 - Math.cos(Math.PI / 5)) / 2;
+	const corner = Math.min(radius, k * .75);
+	const points = Array.from({ length: 10 }, (_, i) => {
+		const a = -Math.PI / 2 + i * Math.PI / 5;
+		const d = i % 2 ? r : R;
+		return [
+			x + Math.cos(a) * d,
+			y + dy + Math.sin(a) * d,
+			i % 2 ? corner : corner * 2
+		];
+	});
+	return [rounded(points, corner)];
+};
+var cloudCircles = [
+	[
+		-1.95,
+		.95,
+		1.7
+	],
+	[
+		.1,
+		-.25,
+		2.4
+	],
+	[
+		2,
+		1.05,
+		1.6
+	]
+];
+var cloudFillet = .5;
+function upperIntersection([x1, y1, r1], [x2, y2, r2]) {
+	const d = Math.hypot(x2 - x1, y2 - y1);
+	const a = (r1 * r1 - r2 * r2 + d * d) / (2 * d);
+	const h = Math.sqrt(r1 * r1 - a * a);
+	const [mx, my] = [x1 + (x2 - x1) * a / d, y1 + (y2 - y1) * a / d];
+	const p = [mx + h * (y2 - y1) / d, my - h * (x2 - x1) / d];
+	const q = [mx - h * (y2 - y1) / d, my + h * (x2 - x1) / d];
+	return p[1] < q[1] ? p : q;
+}
+var angleOn = ([cx, cy], [x, y]) => Math.atan2(y - cy, x - cx);
+var pointOn = ([cx, cy, r], t) => [cx + r * Math.cos(t), cy + r * Math.sin(t)];
+function arcTo([cx, cy, r], from, to) {
+	const a0 = Math.atan2(from[1] - cy, from[0] - cx);
+	return `A${r} ${r} 0 ${((Math.atan2(to[1] - cy, to[0] - cx) - a0) % (2 * Math.PI) + 2 * Math.PI) % (2 * Math.PI) > Math.PI ? 1 : 0} 1 ${to[0]} ${to[1]}`;
+}
+function cloudTop([x, y], k) {
+	const [left, mid, right] = cloudCircles.map(([cx, cy, r]) => [
+		x + cx * k,
+		y + cy * k,
+		r * k
+	]);
+	const f = cloudFillet * k;
+	const p1 = upperIntersection(left, mid);
+	const p2 = upperIntersection(mid, right);
+	const l1 = pointOn(left, angleOn(left, p1) - f / left[2]);
+	const m1 = pointOn(mid, angleOn(mid, p1) + f / mid[2]);
+	const m2 = pointOn(mid, angleOn(mid, p2) - f / mid[2]);
+	const r1 = pointOn(right, angleOn(right, p2) + f / right[2]);
+	const start = [left[0], left[1] + left[2]];
+	const end = [right[0], right[1] + right[2]];
+	const pt = (p) => `${p[0]} ${p[1]}`;
+	return {
+		arcs: `${arcTo(left, start, l1)}Q${pt(p1)} ${pt(m1)}${arcTo(mid, m1, m2)}Q${pt(p2)} ${pt(r1)}${arcTo(right, r1, end)}`,
+		start,
+		end
+	};
+}
+var drawCloud = (c, k = 1) => {
+	const { arcs, start } = cloudTop(c, k);
+	return [`M${start[0]} ${start[1]}${arcs}Z`];
+};
+function cloudOpen(center, k, gap) {
+	const { c } = snap(grids.cloud, center, k);
+	const { arcs, start, end } = cloudTop(c, k);
+	if (gap === Infinity) return [`M${start[0]} ${start[1]}${arcs}`];
+	const [cx, base] = [c[0], start[1]];
+	return [`M${cx - gap} ${base}L${start[0]} ${base}${arcs}L${cx + gap} ${base}`];
+}
+var drawShield = ([x, y], k = 1) => {
+	k *= .86;
+	const p = at([x, y + .175 * k], k);
+	const pt = (q) => p(q).join(" ");
+	const w = 3.5;
+	const R = 12.8125 / 1.5 * k;
+	return [`M${pt([-3.5, -3.5])}A${R} ${R} 0 0 1 ${pt([w, -3.5])}L${pt([w, -.5])}C${pt([w, 1.8])} ${pt([w * .55, 3.1])} ${pt([0, 3.9])}C${pt([-3.5 * .55, 3.1])} ${pt([-3.5, 1.8])} ${pt([-3.5, -.5])}Z`];
+};
+var drawBan = ([x, y], k = 1) => {
+	const r = 3.25 * k;
+	const d = r * Math.SQRT1_2;
+	return [circle(x, y, r), `M${x - d} ${y - d}L${x + d} ${y + d}`];
+};
+var DIRS = {
+	up: [0, -1],
+	down: [0, 1],
+	left: [-1, 0],
+	right: [1, 0],
+	upRight: [1, -1],
+	upLeft: [-1, -1],
+	downRight: [1, 1],
+	downLeft: [-1, 1]
+};
+var WING = 3;
+var DIAGONAL_WING = 4.25;
+function head([x, y], [dx, dy], k) {
+	if (dx && dy) {
+		const w = DIAGONAL_WING * k;
+		return [
+			[x - dx * w, y],
+			[x, y],
+			[x, y - dy * w]
+		];
+	}
+	const s = WING * k;
+	const [sx, sy] = dx ? [0, s] : [s, 0];
+	return [
+		[x - dx * s - sx, y - dy * s - sy],
+		[x, y],
+		[x - dx * s + sx, y - dy * s + sy]
+	];
+}
+var diagonalArrow = (dir) => ({
+	x: DIRS[dir][0] * 3,
+	y: DIRS[dir][1] * 3
+});
+var diagonalChevron = (dir) => ({
+	x: DIRS[dir][0] * DIAGONAL_WING / 2,
+	y: DIRS[dir][1] * DIAGONAL_WING / 2
+});
+var pointer = (dir) => ([x, y], k = 1, radius = 0) => {
+	const [dx, dy] = DIRS[dir];
+	const half = (dx && dy ? 3 : 3.5) * k;
+	const tip = [x + dx * half, y + dy * half];
+	return [`M${x - dx * half} ${y - dy * half}L${tip[0]} ${tip[1]}`, rounded(head(tip, [dx, dy], k), crisp(radius), false)];
+};
+var chevron = (dir) => ([x, y], k = 1, radius = 0) => {
+	const [dx, dy] = DIRS[dir];
+	const shift = (dx && dy ? DIAGONAL_WING / 2 : WING / 2) * k;
+	return [rounded(head([x + dx * shift, y + dy * shift], [dx, dy], k), crisp(radius), false)];
+};
+var halfPointer = (dir) => ([x, y], k = 1, radius = 0) => {
+	const [dx, dy] = DIRS[dir];
+	const half = (dx && dy ? 3 : 3.5) * k;
+	const tip = [x + dx * half, y + dy * half];
+	const [perpX, perpY] = [dy, -dx];
+	const wing = head(tip, [dx, dy], k).filter((_, i) => i !== 1).find(([wx, wy]) => (wx - tip[0]) * perpX + (wy - tip[1]) * perpY > 0);
+	return [rounded([
+		[x - dx * half, y - dy * half],
+		[...tip, crisp(radius)],
+		wing
+	], crisp(radius), false)];
+};
+var drawArrowUp = pointer("up");
+var drawArrowDown = pointer("down");
+var drawArrowLeft = pointer("left");
+var drawArrowRight = pointer("right");
+var drawBookmark = (c, k = 1, radius = 0) => {
+	const p = at(c, k);
+	const notch = [...p([0, 1]), crisp(radius)];
+	return [rounded([
+		p([-2.5, -3.5]),
+		p([2.5, -3.5]),
+		p([2.5, 3.5]),
+		notch,
+		p([-2.5, 3.5])
+	], Math.min(radius, k))];
+};
+var drawSparkle = (c, k = 1) => {
+	const p = at(c, k);
+	const pt = (q) => p(q).join(" ");
+	const R = 3.5;
+	const b = 1.2;
+	const fillet = .6;
+	const s = 1 / Math.sqrt(.7760770975056689);
+	const tp = Math.acos(s / b);
+	const fp = Math.acos(s / R);
+	const t = tp + fillet / Math.hypot(b * Math.sin(tp), R * Math.cos(tp));
+	const f = fp - fillet / Math.hypot(R * Math.sin(fp), b * Math.cos(fp));
+	const v = [b * Math.cos(t), R * Math.sin(t)];
+	const h = [R * Math.cos(f), b * Math.sin(f)];
+	const q = ([x, y], sx, sy) => pt([x * sx, y * sy]);
+	const arc = (rx, ry, sx, sy, to) => `A${rx * k} ${ry * k} 0 0 1 ${q(to, sx, sy)}`;
+	const corner = (sx, sy, to) => `Q${q([s, s], sx, sy)} ${q(to, sx, sy)}`;
+	return [`M${q(v, -1, -1)}${arc(b, R, 1, -1, v)}${corner(1, -1, h)}${arc(R, b, 1, 1, h)}${corner(1, 1, v)}${arc(b, R, -1, 1, v)}${corner(-1, 1, h)}${arc(R, b, -1, -1, h)}${corner(-1, -1, v)}Z`];
+};
+var drawPuzzle = (c, k = 1, radius = 0) => {
+	const mirror = at(c, k);
+	const p = ([x, y]) => mirror([-x, y]);
+	const pt = (q) => p(q).join(" ");
+	const r = 1.3;
+	const out = .55;
+	const f = .5;
+	const [x0, x1, y0, y1] = [
+		-3.5,
+		1.6500000000000001,
+		-1.6500000000000001,
+		3.5
+	];
+	const neck = Math.sqrt(r * r - out * out);
+	const [tx, ry] = [(x0 + x1) / 2, (y0 + y1) / 2];
+	const corner = Math.min(radius, k);
+	const knob = (o, from, to) => {
+		const ang = (q) => Math.atan2(q[1] - o[1], q[0] - o[0]);
+		const on = (t) => [o[0] + r * Math.cos(t), o[1] + r * Math.sin(t)];
+		const [a, b] = [on(ang(from) + f / r), on(ang(to) - f / r)];
+		return `Q${pt(from)} ${pt(a)}A${r * k} ${r * k} 0 1 0 ${pt(b)}Q${pt(to)} `;
+	};
+	const top = [tx, y0 - out];
+	const right = [x1 + out, ry];
+	const a = rounded([
+		[tx + neck + f, y0],
+		[x1, y0],
+		[x1, ry - neck - f]
+	].map(p), corner, false);
+	const b = rounded([
+		[x1, ry + neck + f],
+		[x1, y1],
+		[x0, y1],
+		[x0, y0],
+		[tx - neck - f, y0]
+	].map(p), corner, false);
+	return [`${a}${knob(right, [x1, ry - neck], [x1, ry + neck])}${b.replace(/^M/, "")}${knob(top, [tx - neck, y0], [tx + neck, y0])}${pt([tx + neck + f, y0])}Z`];
+};
+var drawPlug = (c, k = 1, radius = 0) => {
+	const p = at(c, k);
+	const pt = (q) => p(q).join(" ");
+	const top = -1.75;
+	const [w, neck, pin] = [
+		align(2.4, 0, k, 1),
+		align(2.25, top, k, 1),
+		align(1, 0, k, 1)
+	];
+	const [shoulder, neckW, bottom] = [
+		-.25,
+		.8,
+		3.5
+	];
+	const rc = Math.min(radius, 1);
+	const prong = (x) => `M${pt([x, -3.5])}L${pt([x, top])}`;
+	return [
+		prong(-pin),
+		prong(pin),
+		`M${pt([0, bottom])}L${pt([0, neck])}L${pt([-neckW, neck])}C${pt([-w * .65, neck])} ${pt([-w, 1.25])} ${pt([-w, shoulder])}L${pt([-w, top + rc])}` + (rc ? `A${rc * k} ${rc * k} 0 0 1 ${pt([-w + rc, top])}` : "") + `L${pt([w - rc, top])}` + (rc ? `A${rc * k} ${rc * k} 0 0 1 ${pt([w, top + rc])}` : "") + `L${pt([w, shoulder])}C${pt([w, 1.25])} ${pt([w * .65, neck])} ${pt([neckW, neck])}L${pt([0, neck])}`
+	];
+};
+var drawClock = ([x, y], k = 1) => [circle(x, y, 3.5 * k), `M${x} ${y - 2 * k}V${y}L${x - 1.5 * k} ${y + 1.5 * k}`];
+var drawGauge = ([x, y], k = 1) => {
+	const r = 3.5 * k;
+	const d = r * Math.SQRT1_2;
+	const cy = y + (r - d) / 2;
+	const n = 2.25 * k * Math.SQRT1_2;
+	return [`M${x - d} ${cy + d}A${r} ${r} 0 1 1 ${x + d} ${cy + d}`, `M${x} ${cy}L${x + n} ${cy - n}`];
+};
+var drawLock = (c, k = 1, radius = 0) => {
+	const p = at(c, k);
+	const pt = (q) => p(q).join(" ");
+	const b = align(3.5, -.5, k, 1);
+	const s = align(1.75, 3, k, 1);
+	const r = s * k;
+	return [
+		rounded([
+			[-3, -.5],
+			[3, -.5],
+			[3, b],
+			[-3, b]
+		].map(p), Math.min(radius, k)),
+		`M${pt([-s, -.5])}L${pt([-s, -1.75])}A${r} ${r} 0 0 1 ${pt([s, -1.75])}L${pt([s, -.5])}`,
+		`M${pt([0, 1])}L${pt([0, 2])}`
+	];
+};
+var drawCode = (c, k = 1, radius = 0) => {
+	const p = at(c, k);
+	const slash = 2.5 * Math.tan(Math.PI / 12);
+	return [
+		rounded([
+			[-1.5, -2],
+			[-3.5, 0],
+			[-1.5, 2]
+		].map(p), crisp(radius), false),
+		rounded([
+			[1.5, -2],
+			[3.5, 0],
+			[1.5, 2]
+		].map(p), crisp(radius), false),
+		`M${p([slash, -2.5]).join(" ")}L${p([-slash, 2.5]).join(" ")}`
+	];
+};
+var drawSearch = ([x, y], k = 1) => {
+	const r = 2.5 * k;
+	const [cx, cy] = [x - 1 * k, y - 1 * k];
+	const d = r * Math.SQRT1_2;
+	return [circle(cx, cy, r), `M${cx + d} ${cy + d}L${x + 3.5 * k} ${y + 3.5 * k}`];
+};
+var plus = symbol(drawPlus, grids.plus);
+var minus = symbol(drawMinus, grids.minus);
+var cross = symbol(drawCross);
+var check = symbol(drawCheck);
+var image = symbol(drawImage, grids.image);
+var music = symbol(drawMusic, grids.music);
+var video = symbol(drawVideo, grids.video);
+var assets = symbol(drawAssets, grids.assets);
+var ring = symbol(drawRing);
+var star = symbol(drawStar);
+var cloud = symbol(drawCloud, grids.cloud);
+var shield = symbol(drawShield, grids.shield);
+var ban = symbol(drawBan);
+var arrowUp = symbol(drawArrowUp, grids.arrowUp);
+var arrowDown = symbol(drawArrowDown, grids.arrowDown);
+var arrowLeft = symbol(drawArrowLeft, grids.arrowLeft);
+var arrowRight = symbol(drawArrowRight, grids.arrowRight);
+var bookmark = symbol(drawBookmark, grids.bookmark);
+var sparkle = symbol(drawSparkle);
+var puzzle = symbol(drawPuzzle, grids.puzzle);
+var plug = symbol(drawPlug, grids.plug);
+var clock = symbol(drawClock, grids.clock);
+var gauge = symbol(drawGauge);
+var lock = symbol(drawLock, grids.lock);
+var arrowUpRight = symbol(pointer("upRight"), diagonalArrow("upRight"));
+var arrowUpLeft = symbol(pointer("upLeft"), diagonalArrow("upLeft"));
+var arrowDownRight = symbol(pointer("downRight"), diagonalArrow("downRight"));
+var arrowDownLeft = symbol(pointer("downLeft"), diagonalArrow("downLeft"));
+var chevronUp = symbol(chevron("up"));
+var chevronDown = symbol(chevron("down"));
+var chevronLeft = symbol(chevron("left"));
+var chevronRight = symbol(chevron("right"));
+var chevronUpRight = symbol(chevron("upRight"), diagonalChevron("upRight"));
+var chevronUpLeft = symbol(chevron("upLeft"), diagonalChevron("upLeft"));
+var chevronDownRight = symbol(chevron("downRight"), diagonalChevron("downRight"));
+var chevronDownLeft = symbol(chevron("downLeft"), diagonalChevron("downLeft"));
+var arrowUpHalf = symbol(halfPointer("up"), grids.arrowUp);
+var arrowDownHalf = symbol(halfPointer("down"), grids.arrowDown);
+var arrowLeftHalf = symbol(halfPointer("left"), grids.arrowLeft);
+var arrowRightHalf = symbol(halfPointer("right"), grids.arrowRight);
+var arrowUpRightHalf = symbol(halfPointer("upRight"), diagonalArrow("upRight"));
+var arrowUpLeftHalf = symbol(halfPointer("upLeft"), diagonalArrow("upLeft"));
+var arrowDownRightHalf = symbol(halfPointer("downRight"), diagonalArrow("downRight"));
+var arrowDownLeftHalf = symbol(halfPointer("downLeft"), diagonalArrow("downLeft"));
+var code = symbol(drawCode);
+var search = symbol(drawSearch);
+var searchCut = (c, k, radius) => search(c, k, radius).map((p) => ({
+	d: p.d ?? p,
+	cut: true,
+	occlude: true
+}));
+//#endregion
+export { arrowDown, arrowDownHalf, arrowDownLeft, arrowDownLeftHalf, arrowDownRight, arrowDownRightHalf, arrowLeft, arrowLeftHalf, arrowRight, arrowRightHalf, arrowUp, arrowUpHalf, arrowUpLeft, arrowUpLeftHalf, arrowUpRight, arrowUpRightHalf, assets, ban, bookmark, check, chevronDown, chevronDownLeft, chevronDownRight, chevronLeft, chevronRight, chevronUp, chevronUpLeft, chevronUpRight, clock, cloud, cloudOpen, code, cornerScale, cross, gauge, image, lock, minus, music, outlines, plug, plus, puzzle, ring, search, searchCut, shield, sparkle, star, video };

package/dist/src/tone.js

@@ -0,0 +1,37 @@
+//#region src/tone.js
+var ROLES = {
+	accent: {
+		light: "#a16207",
+		dark: "#fde047"
+	},
+	danger: {
+		light: "#9f1239",
+		dark: "#fda4af"
+	},
+	success: {
+		light: "#15803d",
+		dark: "#4ade80"
+	},
+	warning: {
+		light: "#c2410c",
+		dark: "#fb923c"
+	},
+	info: {
+		light: "#2563eb",
+		dark: "#60a5fa"
+	}
+};
+var mark = (role) => (p) => Array.isArray(p) ? p.map(mark(role)) : typeof p === "string" ? {
+	d: p,
+	tone: role
+} : {
+	...p,
+	tone: role
+};
+var danger = mark("danger");
+var success = mark("success");
+var warning = mark("warning");
+var info = mark("info");
+var accent = mark("accent");
+//#endregion
+export { ROLES, accent, danger, info, success, warning };

package/dist/src/transform.js

@@ -0,0 +1,38 @@
+import { parse } from "./svg.js";
+//#region src/transform.js
+var fmt = (p) => `${p[0]} ${p[1]}`;
+function mapPath(d, pt, arc = (v) => v) {
+	return parse(d, true).map(([type, v]) => {
+		if (type === "Z") return "Z";
+		if (type === "A") return `A${arc(v.slice(0, 5)).join(" ")} ${fmt(pt([v[5], v[6]]))}`;
+		const pts = [];
+		for (let i = 0; i < v.length; i += 2) pts.push(fmt(pt([v[i], v[i + 1]])));
+		return type + pts.join(" ");
+	}).join("");
+}
+function rotate(d, deg, [cx, cy] = [12, 12]) {
+	const a = deg * Math.PI / 180;
+	const [c, s] = [Math.cos(a), Math.sin(a)];
+	return mapPath(d, ([x, y]) => [cx + (x - cx) * c - (y - cy) * s, cy + (x - cx) * s + (y - cy) * c], ([rx, ry, phi, fa, fs]) => [
+		rx,
+		ry,
+		phi + deg,
+		fa,
+		fs
+	]);
+}
+function affine(d, sx, sy, dx, dy) {
+	const flip = sx * sy < 0;
+	return mapPath(d, ([x, y]) => [x * sx + dx, y * sy + dy], ([rx, ry, phi, fa, fs]) => [
+		rx * Math.abs(sx),
+		ry * Math.abs(sy),
+		flip ? -phi : phi,
+		fa,
+		flip ? 1 - fs : fs
+	]);
+}
+var scale = (d, s, [cx, cy] = [12, 12]) => affine(d, s, s, cx - cx * s, cy - cy * s);
+var mirror = (d, cx = 12) => affine(d, -1, 1, 2 * cx, 0);
+var translate = (d, dx, dy) => affine(d, 1, 1, dx, dy);
+//#endregion
+export { affine, mapPath, mirror, rotate, scale, translate };

package/dist/src/weapons.js

@@ -0,0 +1,10 @@
+import { circle } from "./geometry.js";
+//#region src/weapons.js
+var sword = [
+	"M10.5 15V5L12 2.5L13.5 5V15",
+	"M8 15H16",
+	"M12 15V19.5",
+	circle(12, 20.75, 1.25)
+];
+//#endregion
+export { sword };