@popcraft/kit 0.25.0 → 0.26.1

package/dist/chunks/chunk-AISWLDDO.js

@@ -0,0 +1,895 @@
+import { createRequire as __popcraftRequire } from 'node:module';
+import { fileURLToPath as __popcraftPath } from 'node:url';
+import { dirname as __popcraftDirname } from 'node:path';
+const require = __popcraftRequire(import.meta.url);
+const __filename = __popcraftPath(import.meta.url);
+const __dirname = __popcraftDirname(__filename);
+import {
+  pt3,
+  rng
+} from "./chunk-BNVLVZUT.js";
+import {
+  init_define_POPCRAFT_COMPONENT_IDS
+} from "./chunk-6VMOKHMF.js";
+
+// templates/src/themes/holidays-shared.ts
+init_define_POPCRAFT_COMPONENT_IDS();
+function boxTight(paths) {
+  let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+  for (const p of paths) for (const q of p.points) {
+    for (const c of [q, q.handleIn, q.handleOut]) if (c) {
+      x0 = Math.min(x0, c.x);
+      y0 = Math.min(y0, c.y);
+      x1 = Math.max(x1, c.x);
+      y1 = Math.max(y1, c.y);
+    }
+  }
+  x0 = Math.floor(x0);
+  y0 = Math.floor(y0);
+  const mv = (q) => pt3(q.x - x0, q.y - y0);
+  const moved = paths.map((p) => ({ ...p, points: p.points.map((q) => ({ ...q, ...mv(q), ...q.handleIn ? { handleIn: mv(q.handleIn) } : {}, ...q.handleOut ? { handleOut: mv(q.handleOut) } : {} })) }));
+  return { x: x0, y: y0, width: Math.max(1, Math.ceil(x1 - x0)), height: Math.max(1, Math.ceil(y1 - y0)), paths: moved };
+}
+function draw(k, parent, parts) {
+  return parts.filter((p) => p.paths.length).map((p) => {
+    const b = boxTight(p.paths);
+    return k.vector(parent, b.width, b.height, b.paths, p.color, { name: p.name, ...p.o, absolute: { x: b.x, y: b.y } });
+  });
+}
+function redraw(k, root, parts) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const p of parts.filter((q) => q.paths.length)) {
+    const i = seen.get(p.name) ?? 0;
+    seen.set(p.name, i + 1);
+    const id = k.named(root, p.name)[i];
+    if (!id) continue;
+    const b = boxTight(p.paths);
+    const w = p.o?.strokeWidth;
+    const strokes = k.node(id).strokes ?? [];
+    k.patch(id, { x: b.x, y: b.y, width: b.width, height: b.height, paths: b.paths, ...w !== void 0 ? { strokes: strokes.map((st) => ({ ...st, width: w })) } : {} });
+  }
+}
+function restyleAll(k, root, pairs) {
+  for (const [layer, style] of pairs) for (const n of k.named(root, layer)) k.restyle(n, style);
+}
+function scaleGaps(k, root, s) {
+  for (const n of k.named(root, "Gap")) k.patch(n, { height: Math.max(2, Math.round(k.node(n).height * s)) });
+}
+function printVariant(preset, o) {
+  return {
+    preset,
+    adjust: (k, id) => {
+      const { width: w, height: h } = k.node(id);
+      const s = w / o.masterWidth;
+      redraw(k, id, o.art(w, h));
+      k.patch(id, { padding: { top: Math.round(o.pad.top * s), right: Math.round(o.pad.right * s), bottom: Math.round(o.pad.bottom * s), left: Math.round(o.pad.left * s) } });
+      restyleAll(k, id, o.styles ?? []);
+      scaleGaps(k, id, s);
+      o.more?.(k, id, s);
+    }
+  };
+}
+var C = 0.5523;
+function disc(cx, cy, r, ry = r) {
+  return { closed: true, points: [
+    { ...pt3(cx, cy - ry), handleIn: pt3(cx - r * C, cy - ry), handleOut: pt3(cx + r * C, cy - ry) },
+    { ...pt3(cx + r, cy), handleIn: pt3(cx + r, cy - ry * C), handleOut: pt3(cx + r, cy + ry * C) },
+    { ...pt3(cx, cy + ry), handleIn: pt3(cx + r * C, cy + ry), handleOut: pt3(cx - r * C, cy + ry) },
+    { ...pt3(cx - r, cy), handleIn: pt3(cx - r, cy + ry * C), handleOut: pt3(cx - r, cy - ry * C) }
+  ] };
+}
+function roundRect(x, y, w, h, r) {
+  r = Math.min(r, w / 2, h / 2);
+  const k = r * (1 - C);
+  return { closed: true, points: [
+    { ...pt3(x + r, y), handleIn: pt3(x + k, y) },
+    { ...pt3(x + w - r, y), handleOut: pt3(x + w - k, y) },
+    { ...pt3(x + w, y + r), handleIn: pt3(x + w, y + k) },
+    { ...pt3(x + w, y + h - r), handleOut: pt3(x + w, y + h - k) },
+    { ...pt3(x + w - r, y + h), handleIn: pt3(x + w - k, y + h) },
+    { ...pt3(x + r, y + h), handleOut: pt3(x + k, y + h) },
+    { ...pt3(x, y + h - r), handleIn: pt3(x, y + h - k) },
+    { ...pt3(x, y + r), handleOut: pt3(x, y + k) }
+  ] };
+}
+var rectPath = (x, y, w, h) => ({ closed: true, points: [pt3(x, y), pt3(x + w, y), pt3(x + w, y + h), pt3(x, y + h)] });
+var seg = (a, b) => ({ closed: false, points: [pt3(a.x, a.y), pt3(b.x, b.y)] });
+var polyP = (pts, closed = true) => ({ closed, points: pts.map((p) => pt3(p.x, p.y)) });
+var at = (cx, cy, r, a) => ({ x: cx + Math.cos(a) * r, y: cy + Math.sin(a) * r });
+function arc(cx, cy, r, a0, a1, n = 16, ry = r) {
+  return { closed: false, points: Array.from({ length: n + 1 }, (_, i) => {
+    const a = a0 + (a1 - a0) * i / n;
+    return pt3(cx + Math.cos(a) * r, cy + Math.sin(a) * ry);
+  }) };
+}
+function starPath(cx, cy, R, r = R * 0.42, n = 5, turn = 0) {
+  return polyP(Array.from({ length: n * 2 }, (_, i) => at(cx, cy, i % 2 ? r : R, -Math.PI / 2 + turn + i * Math.PI / n)));
+}
+function sparkle(cx, cy, s, pinch = 0.18) {
+  const q = s * pinch;
+  const pts = [];
+  for (let i = 0; i < 4; i++) {
+    const a = -Math.PI / 2 + i * Math.PI / 2;
+    const tip = at(cx, cy, s, a);
+    pts.push({ ...pt3(tip.x, tip.y) });
+    const mid = at(cx, cy, q, a + Math.PI / 4);
+    pts.push({ ...pt3(mid.x, mid.y) });
+  }
+  return { closed: true, points: pts };
+}
+function heart(cx, cy, s, turn = 0) {
+  const u = s / 2;
+  const raw = [
+    [0, -0.45, [-0.08, -0.85], [0.08, -0.85]],
+    [0.62, -0.78, [0.32, -1], [0.95, -0.55]],
+    [0.98, -0.18, [1.02, -0.45], [0.92, 0.18]],
+    [0, 0.95, [0.45, 0.55], [-0.45, 0.55]],
+    [-0.98, -0.18, [-0.92, 0.18], [-1.02, -0.45]],
+    [-0.62, -0.78, [-0.95, -0.55], [-0.32, -1]]
+  ];
+  const c = Math.cos(turn), sn = Math.sin(turn);
+  const tr = (x, y) => pt3(cx + (x * c - y * sn) * u, cy + (x * sn + y * c) * u + u * 0.08);
+  return { closed: true, points: raw.map(([x, y, hi, ho]) => ({ ...tr(x, y), ...hi ? { handleIn: tr(hi[0], hi[1]) } : {}, ...ho ? { handleOut: tr(ho[0], ho[1]) } : {} })) };
+}
+function leaf(base, len, w, angle) {
+  const c = Math.cos(angle), s = Math.sin(angle);
+  const p = (u, v) => pt3(base.x + u * c - v * s, base.y + u * s + v * c);
+  return { closed: true, points: [
+    { ...p(0, 0), handleIn: p(len * 0.3, w * 0.62), handleOut: p(len * 0.3, -w * 0.62) },
+    { ...p(len, 0), handleIn: p(len * 0.72, -w * 0.5), handleOut: p(len * 0.72, w * 0.5) }
+  ] };
+}
+function petal(base, len, w, angle) {
+  const c = Math.cos(angle), s = Math.sin(angle);
+  const p = (u, v) => pt3(base.x + u * c - v * s, base.y + u * s + v * c);
+  return { closed: true, points: [
+    { ...p(0, 0), handleIn: p(len * 0.15, w * 0.5), handleOut: p(len * 0.15, -w * 0.5) },
+    { ...p(len, 0), handleIn: p(len * 1.02, -w * 0.62), handleOut: p(len * 1.02, w * 0.62) }
+  ] };
+}
+function flame(cx, cy, w, h) {
+  return { closed: true, points: [
+    { ...pt3(cx, cy - h), handleIn: pt3(cx - w * 0.1, cy - h * 0.7), handleOut: pt3(cx + w * 0.1, cy - h * 0.7) },
+    { ...pt3(cx + w / 2, cy - h * 0.28), handleIn: pt3(cx + w * 0.5, cy - h * 0.5), handleOut: pt3(cx + w * 0.5, cy - h * 0.05) },
+    { ...pt3(cx, cy), handleIn: pt3(cx + w * 0.3, cy), handleOut: pt3(cx - w * 0.3, cy) },
+    { ...pt3(cx - w / 2, cy - h * 0.28), handleIn: pt3(cx - w * 0.5, cy - h * 0.05), handleOut: pt3(cx - w * 0.5, cy - h * 0.5) }
+  ] };
+}
+function crescent(cx, cy, r, bite = 0.62, side = 1, turn = 0) {
+  const d = r * bite, R2 = r * 0.92;
+  const pts = [];
+  const x = (r * r - R2 * R2 + d * d) / (2 * d), y = Math.sqrt(Math.max(0, r * r - x * x));
+  const a0 = Math.atan2(y, x), a1 = Math.atan2(-y, x);
+  for (let i = 0; i <= 28; i++) {
+    const a = a0 + (a1 + 2 * Math.PI - a0) * i / 28;
+    pts.push({ x: Math.cos(a) * r, y: Math.sin(a) * r });
+  }
+  const b0 = Math.atan2(-y, x - d), b1 = Math.atan2(y, x - d);
+  const span = (b1 > b0 ? b1 - 2 * Math.PI : b1) - b0;
+  for (let i = 1; i < 20; i++) {
+    const a = b0 + span * i / 20;
+    pts.push({ x: d + Math.cos(a) * R2, y: Math.sin(a) * R2 });
+  }
+  const c = Math.cos(turn), s = Math.sin(turn);
+  return polyP(pts.map((p) => ({ x: cx + side * (p.x * c - p.y * s), y: cy + p.x * s + p.y * c })));
+}
+function confetti(w, h, n, seed, size = 10, keepOut = []) {
+  const r = rng(seed), bars = [], dots = [];
+  for (let i = 0, made = 0; made < n && i < n * 8; i++) {
+    const x = r() * w, y = r() * h;
+    if (keepOut.some((b) => x > b.x && x < b.x + b.w && y > b.y && y < b.y + b.h)) continue;
+    made++;
+    if (r() < 0.6) {
+      const a = r() * Math.PI, l = size * (0.7 + r() * 0.8), t = size * 0.32;
+      const c = Math.cos(a), s = Math.sin(a);
+      const p = (u, v) => ({ x: x + u * c - v * s, y: y + u * s + v * c });
+      bars.push(polyP([p(-l / 2, -t / 2), p(l / 2, -t / 2), p(l / 2, t / 2), p(-l / 2, t / 2)]));
+    } else dots.push(disc(x, y, size * (0.22 + r() * 0.2)));
+  }
+  return { bars, dots };
+}
+function specks(w, h, n, seed, size = 2) {
+  const r = rng(seed);
+  return Array.from({ length: n }, () => {
+    const x = r() * w, y = r() * h, s = size * (0.5 + r());
+    return polyP([{ x, y }, { x: x + s, y: y + r() * s * 0.4 }, { x: x + s * 0.5, y: y + s }]);
+  });
+}
+function bandsAround(w, h, keep, bleed = 0) {
+  return [
+    { x: -bleed, y: -bleed, w: w + 2 * bleed, h: keep.y + bleed },
+    { x: -bleed, y: keep.y + keep.h, w: w + 2 * bleed, h: h - keep.y - keep.h + bleed },
+    { x: -bleed, y: keep.y, w: keep.x + bleed, h: keep.h },
+    { x: keep.x + keep.w, y: keep.y, w: w - keep.x - keep.w + bleed, h: keep.h }
+  ].filter((b) => b.w > 2 && b.h > 2);
+}
+function perBand(name, color, bands, paths, o) {
+  return bands.map((b, i) => ({ name, color, paths: paths(b, i), ...o ? { o } : {} }));
+}
+var specksIn = (b, density, seed, size = 2) => specks(b.w, b.h, Math.max(1, Math.round(b.w * b.h / density)), seed, size).map((p) => ({ ...p, points: p.points.map((q) => pt3(q.x + b.x, q.y + b.y)) }));
+function flourishComponent(k, name, role, mark, o = {}) {
+  if (k.hasComponent(name)) return;
+  const size = o.size ?? 9;
+  k.component(name, { direction: "HORIZONTAL", width: "HUG", gap: o.gap ?? 6, align: "CENTER" }, (id) => {
+    k.rect(id, o.rule ?? 28, 1, role, { name: "Rule" });
+    const b = boxTight([mark]);
+    k.vector(id, size, size * (b.height / Math.max(1, b.width)), b.paths.map((p) => ({ ...p, points: p.points.map((q) => scalePt(q, size / Math.max(1, b.width))) })), role, { name: "Mark" });
+    k.rect(id, o.rule ?? 28, 1, role, { name: "Rule" });
+  });
+}
+var scalePt = (q, f) => ({ ...q, ...pt3(q.x * f, q.y * f), ...q.handleIn ? { handleIn: pt3(q.handleIn.x * f, q.handleIn.y * f) } : {}, ...q.handleOut ? { handleOut: pt3(q.handleOut.x * f, q.handleOut.y * f) } : {} });
+function bauble(cx, top, r, o = {}) {
+  const s = o.string ?? 0;
+  const cy = top + s + r * 0.28 + r;
+  return {
+    string: s > 0 ? [seg({ x: cx, y: top }, { x: cx, y: top + s })] : [],
+    cap: [rectPath(cx - r * 0.2, top + s, r * 0.4, r * 0.3), disc(cx, top + s - r * 0.04, r * 0.09)],
+    body: [disc(cx, cy, r)],
+    band: [arc(cx, cy, r * 0.98, Math.PI * 0.05, Math.PI * 0.95, 14, r * 0.3), arc(cx, cy + r * 0.1, r * 0.99, Math.PI * 0.08, Math.PI * 0.92, 14, r * 0.42)].map((p) => ({ ...p })),
+    shine: [leaf({ x: cx - r * 0.62, y: cy - r * 0.05 }, r * 0.55, r * 0.16, -1.25), disc(cx - r * 0.42, cy - r * 0.62, r * 0.07)],
+    shade: [crescent(cx, cy, r, 0.36, -1, -0.75)]
+  };
+}
+function pine(a, b, c, o) {
+  const r = rng(o.seed);
+  const n = Math.round(26 * (o.density ?? 1));
+  const pts = Array.from({ length: 13 }, (_, i) => along(a, b, c, i / 12).p);
+  const dark = [], light = [];
+  for (let i = 0; i < n; i++) {
+    const t = 0.04 + 0.94 * i / n;
+    const { p, angle } = along(a, b, c, t);
+    const len = o.needle * (1 - t * 0.45) * (0.85 + r() * 0.3);
+    for (const side of [-1, 1]) {
+      const tilt = angle + side * (0.55 + r() * 0.2);
+      const end = at(p.x, p.y, len, tilt);
+      ((i + (side > 0 ? 1 : 0)) % 2 ? dark : light).push(seg(p, end));
+    }
+  }
+  return { stem: polyP(pts, false), dark, light };
+}
+function holly(base, len, angle) {
+  const c = Math.cos(angle), s = Math.sin(angle);
+  const p = (u, v) => ({ x: base.x + u * c - v * s, y: base.y + u * s + v * c });
+  const w = len * 0.24, pts = [p(0, 0)];
+  for (let i = 1; i <= 4; i++) {
+    const u = len * i / 5;
+    const bulge = Math.sin(Math.PI * i / 5) * w;
+    pts.push(p(u - len * 0.08, bulge * 0.55), p(u, bulge * 1.05));
+  }
+  pts.push(p(len, 0));
+  for (let i = 4; i >= 1; i--) {
+    const u = len * i / 5;
+    const bulge = Math.sin(Math.PI * i / 5) * w;
+    pts.push(p(u, -bulge * 1.05), p(u - len * 0.08, -bulge * 0.55));
+  }
+  return polyP(pts);
+}
+function snowflake(cx, cy, r, turn = 0) {
+  const out = [];
+  for (let i = 0; i < 6; i++) {
+    const a = turn + i * Math.PI / 3;
+    out.push(seg({ x: cx, y: cy }, at(cx, cy, r, a)));
+    for (const f of [0.45, 0.72]) {
+      const p = at(cx, cy, r * f, a), l = r * (f < 0.6 ? 0.3 : 0.2);
+      out.push(seg(p, at(p.x, p.y, l, a + 0.75)), seg(p, at(p.x, p.y, l, a - 0.75)));
+    }
+  }
+  return out;
+}
+function along(a, b, c, t) {
+  const u = 1 - t;
+  const p = { x: u * u * a.x + 2 * u * t * b.x + t * t * c.x, y: u * u * a.y + 2 * u * t * b.y + t * t * c.y };
+  const d = { x: 2 * u * (b.x - a.x) + 2 * t * (c.x - b.x), y: 2 * u * (b.y - a.y) + 2 * t * (c.y - b.y) };
+  return { p, angle: Math.atan2(d.y, d.x) };
+}
+var quad = (a, b, c, n = 20) => polyP(Array.from({ length: n + 1 }, (_, i) => along(a, b, c, i / n).p), false);
+function sprig(a, b, c, o) {
+  const r = rng(o.seed);
+  const dark = [], light = [], berries = [];
+  for (let i = 0; i < o.leaves; i++) {
+    const t = 0.08 + 0.9 * i / o.leaves;
+    const { p, angle } = along(a, b, c, t);
+    const len = o.size * (1 - t * 0.5) * (0.85 + r() * 0.3), w = len * (o.narrow ?? 0.42);
+    for (const side of [-1, 1]) (side < 0 === (i % 2 === 0) ? dark : light).push(leaf(p, len, w, angle + side * (0.75 + r() * 0.25)));
+  }
+  const tip = along(a, b, c, 1);
+  dark.push(leaf(tip.p, o.size * 0.55, o.size * 0.22, tip.angle));
+  for (let i = 0; i < (o.berries ?? 0); i++) {
+    const { p, angle } = along(a, b, c, 0.2 + r() * 0.65);
+    const off = (r() > 0.5 ? 1 : -1) * o.size * 0.42;
+    berries.push(disc(p.x - Math.sin(angle) * off, p.y + Math.cos(angle) * off, o.size * 0.1));
+  }
+  return { stem: quad(a, b, c), dark, light, berries };
+}
+function menorah(cx, base, w, h, nights = 8) {
+  const stand = [], candles = [], flames = [], cups = [];
+  const cupY = base - h, armBase = base - h * 0.32;
+  const step = w / 8;
+  stand.push(seg({ x: cx, y: base - h * 0.06 }, { x: cx, y: cupY - h * 0.1 }));
+  for (let i = 1; i <= 4; i++) stand.push(arc(cx, cupY, step * i, 0, Math.PI, 18, armBase - cupY));
+  const foot = [polyP([{ x: cx - w * 0.2, y: base }, { x: cx + w * 0.2, y: base }, { x: cx + w * 0.05, y: base - h * 0.08 }, { x: cx - w * 0.05, y: base - h * 0.08 }])];
+  const cw = step * 0.34, ch = h * 0.3;
+  for (let i = -4; i <= 4; i++) {
+    const x = cx + i * step, top = i === 0 ? cupY - h * 0.1 : cupY;
+    cups.push(rectPath(x - cw * 0.85, top - h * 0.03, cw * 1.7, h * 0.04));
+    const rank = i > 0 ? 4 - i : 3 - i;
+    if (i !== 0 && rank >= nights) continue;
+    candles.push(rectPath(x - cw / 2, top - h * 0.03 - ch, cw, ch));
+    flames.push(flame(x, top - h * 0.03 - ch - h * 0.015, cw * 1.25, ch * 0.62));
+  }
+  return { stand, candles, flames, foot, cups };
+}
+function dreidel(cx, cy, s, turn = 0) {
+  const c = Math.cos(turn), sn = Math.sin(turn);
+  const p = (x, y) => ({ x: cx + (x * c - y * sn) * s, y: cy + (x * sn + y * c) * s });
+  return {
+    handle: [polyP([p(-0.06, -0.62), p(0.06, -0.62), p(0.06, -0.3), p(-0.06, -0.3)])],
+    body: [polyP([p(-0.3, -0.3), p(0.22, -0.3), p(0.22, 0.18), p(0, 0.5), p(-0.3, 0.18)])],
+    side: [polyP([p(0.22, -0.3), p(0.36, -0.36), p(0.36, 0.1), p(0, 0.5), p(0.22, 0.18)])]
+  };
+}
+function starOfDavid(cx, cy, r) {
+  const tri = (off) => polyP([0, 1, 2].map((i) => at(cx, cy, r, -Math.PI / 2 + off + i * 2 * Math.PI / 3)));
+  return [tri(0), tri(Math.PI / 3)];
+}
+var gelt = (cx, cy, r) => ({ coin: [disc(cx, cy, r)], rim: [disc(cx, cy, r * 0.78)] });
+function burst(cx, cy, r1, n = 18, seed = 1, r0 = r1 * 0.25) {
+  const r = rng(seed), rays = [], sparks = [];
+  for (let i = 0; i < n; i++) {
+    const a = i * 2 * Math.PI / n + (r() - 0.5) * 0.12;
+    const len = r1 * (0.82 + r() * 0.18);
+    const p0 = at(cx, cy, r0, a), p1 = at(cx, cy, len, a);
+    rays.push({ closed: false, points: [pt3(p0.x, p0.y), { ...pt3(p1.x, p1.y + len * 0.04), handleIn: pt3((p0.x + p1.x) / 2, (p0.y + p1.y) / 2 - len * 0.03) }] });
+    const e = at(cx, cy, len * 1.08, a);
+    sparks.push(disc(e.x, e.y + len * 0.05, r1 * 0.022));
+    if (i % 2 === 0) {
+      const m = at(cx, cy, len * 0.62, a + Math.PI / n);
+      sparks.push(disc(m.x, m.y, r1 * 0.014));
+    }
+  }
+  return { rays, sparks };
+}
+function coupe(cx, base, s, tilt = 0) {
+  const c = Math.cos(tilt), sn = Math.sin(tilt);
+  const p = (x, y) => pt3(cx + (x * c - y * sn) * s, base + (x * sn + y * c) * s);
+  const bowl = { closed: true, points: [
+    { ...p(-0.42, -0.92) },
+    { ...p(0.42, -0.92), handleOut: p(0.4, -0.66) },
+    { ...p(0.04, -0.6), handleIn: p(0.22, -0.6) },
+    { ...p(-0.04, -0.6), handleOut: p(-0.22, -0.6) },
+    { ...p(-0.42, -0.92), handleIn: p(-0.4, -0.66) }
+  ] };
+  return {
+    glass: [bowl, polyP([p(-0.025, -0.6), p(0.025, -0.6), p(0.025, -0.06), p(-0.025, -0.06)].map((q) => ({ x: q.x, y: q.y }))), disc(p(0, -0.03).x, p(0, -0.03).y, 0.26 * s, 0.045 * s)],
+    wine: [{ closed: true, points: [{ ...p(-0.36, -0.86) }, { ...p(0.36, -0.86), handleOut: p(0.34, -0.66) }, { ...p(0, -0.63), handleIn: p(0.2, -0.63), handleOut: p(-0.2, -0.63) }, { ...p(-0.36, -0.86), handleIn: p(-0.34, -0.66) }] }]
+  };
+}
+function streamer(a, len, angle, amp, waves) {
+  const c = Math.cos(angle), s = Math.sin(angle);
+  const n = Math.round(waves * 10);
+  return polyP(Array.from({ length: n + 1 }, (_, i) => {
+    const u = len * i / n, v = Math.sin(i / n * waves * 2 * Math.PI) * amp;
+    return { x: a.x + u * c - v * s, y: a.y + u * s + v * c };
+  }), false);
+}
+function clock(cx, cy, r) {
+  const ticks = Array.from({ length: 12 }, (_, i) => {
+    const a = i * Math.PI / 6;
+    return seg(at(cx, cy, r * (i % 3 ? 0.84 : 0.76), a), at(cx, cy, r * 0.92, a));
+  });
+  return { ring: [disc(cx, cy, r)], ticks, hands: [seg({ x: cx, y: cy }, at(cx, cy, r * 0.5, -Math.PI / 2 - 0.08)), seg({ x: cx, y: cy }, at(cx, cy, r * 0.74, -Math.PI / 2 - Math.PI / 6 * 0.5))] };
+}
+function rose(cx, cy, r, seed = 1) {
+  const rr = rng(seed);
+  const ring = (n, R, off) => Array.from({ length: n }, (_, i) => {
+    const a = off + i * 2 * Math.PI / n + (rr() - 0.5) * 0.25;
+    const p = at(cx, cy, R * 0.5, a);
+    return disc(p.x, p.y, R * 0.56, R * 0.5);
+  });
+  const outer = ring(7, r, rr() * 6);
+  const mid = ring(5, r * 0.66, rr() * 6);
+  const core = [disc(cx, cy, r * 0.34)];
+  const swirl = Array.from({ length: 3 }, (_, i) => arc(cx, cy, r * (0.12 + i * 0.09), i * 2.1, i * 2.1 + 3.6, 12));
+  return { outer, inner: [...mid, ...core], mid, core, swirl };
+}
+function egg(cx, cy, w, h, turn = 0) {
+  const c = Math.cos(turn), s = Math.sin(turn);
+  const p = (x, y) => pt3(cx + (x * c - y * s), cy + (x * s + y * c));
+  const a = w / 2, top = -h * 0.55, bot = h * 0.45;
+  return { closed: true, points: [
+    { ...p(0, top), handleIn: p(-a * 0.58, top), handleOut: p(a * 0.58, top) },
+    { ...p(a, h * 0.08), handleIn: p(a, top * 0.55), handleOut: p(a, bot * 0.62) },
+    { ...p(0, bot), handleIn: p(a * 0.56, bot), handleOut: p(-a * 0.56, bot) },
+    { ...p(-a, h * 0.08), handleIn: p(-a, bot * 0.62), handleOut: p(-a, top * 0.55) }
+  ] };
+}
+function eggBands(cx, cy, w, h, turn = 0, kind = "zigzag") {
+  const c = Math.cos(turn), s = Math.sin(turn);
+  const p = (x, y) => ({ x: cx + (x * c - y * s), y: cy + (x * s + y * c) });
+  const half = (y) => {
+    const t = (y + h * 0.05) / (h * 0.52);
+    return w / 2 * Math.sqrt(Math.max(0, 1 - t * t)) * 0.96;
+  };
+  const lines = [], dots = [];
+  const band = (y) => {
+    const hw = half(y);
+    lines.push(polyP(Array.from({ length: 9 }, (_, i) => p(-hw + 2 * hw * i / 8, y + Math.sin(i / 8 * Math.PI) * h * 0.035)), false));
+  };
+  band(-h * 0.12);
+  band(h * 0.14);
+  if (kind === "zigzag") {
+    const hw = half(0);
+    lines.push(polyP(Array.from({ length: 11 }, (_, i) => p(-hw * 0.92 + 1.84 * hw * i / 10, (i % 2 ? -1 : 1) * h * 0.06 + h * 0.01)), false));
+  }
+  if (kind === "waves") {
+    const hw = half(0);
+    lines.push(polyP(Array.from({ length: 25 }, (_, i) => p(-hw * 0.94 + 1.88 * hw * i / 24, Math.sin(i * 0.8) * h * 0.045 + h * 0.01)), false));
+  }
+  if (kind === "dots") {
+    const hw = half(0);
+    for (let i = 0; i < 5; i++) {
+      const q = p(-hw * 0.7 + 1.4 * hw * i / 4, h * 0.01);
+      dots.push(disc(q.x, q.y, w * 0.055));
+    }
+  }
+  for (const y of [-h * 0.33, h * 0.32]) {
+    const hw = half(y) * 0.6;
+    for (let i = 0; i < 3; i++) {
+      const q = p(-hw + hw * i, y);
+      dots.push(disc(q.x, q.y, w * 0.035));
+    }
+  }
+  return { lines, dots };
+}
+function tulip(x, ground, h, lean = 0) {
+  const topX = x + lean * h, topY = ground - h;
+  const w = h * 0.2;
+  const cup = { closed: true, points: [
+    { ...pt3(topX - w / 2, topY - w * 0.9) },
+    { ...pt3(topX - w * 0.18, topY - w * 0.45) },
+    { ...pt3(topX, topY - w * 1) },
+    { ...pt3(topX + w * 0.18, topY - w * 0.45) },
+    { ...pt3(topX + w / 2, topY - w * 0.9), handleOut: pt3(topX + w * 0.62, topY - w * 0.1) },
+    { ...pt3(topX, topY + w * 0.12), handleIn: pt3(topX + w * 0.42, topY + w * 0.12), handleOut: pt3(topX - w * 0.42, topY + w * 0.12) },
+    { ...pt3(topX - w / 2, topY - w * 0.9), handleIn: pt3(topX - w * 0.62, topY - w * 0.1) }
+  ] };
+  return {
+    cup: [cup],
+    stem: [{ closed: false, points: [pt3(x, ground), { ...pt3(topX, topY), handleIn: pt3(x + lean * h * 0.2, ground - h * 0.6) }] }],
+    leaves: [leaf({ x, y: ground }, h * 0.55, h * 0.14, -Math.PI / 2 - 0.35), leaf({ x, y: ground }, h * 0.42, h * 0.12, -Math.PI / 2 + 0.42)]
+  };
+}
+function grass(x0, x1, ground, h, seed, n = 30) {
+  const r = rng(seed);
+  return Array.from({ length: n }, (_, i) => {
+    const x = x0 + (x1 - x0) * (i + r() * 0.8) / n, hh = h * (0.5 + r() * 0.6), lean = (r() - 0.5) * hh * 0.5, w = h * 0.06;
+    return { closed: true, points: [pt3(x - w, ground), { ...pt3(x + lean, ground - hh), handleIn: pt3(x - w * 0.5, ground - hh * 0.5) }, { ...pt3(x + w, ground), handleIn: pt3(x + w * 0.4, ground - hh * 0.5) }] };
+  });
+}
+function rabbit(cx, ground, s, facing = 1) {
+  const f = facing;
+  return {
+    body: [
+      disc(cx, ground - s * 0.27, s * 0.3, s * 0.27),
+      disc(cx + f * s * 0.2, ground - s * 0.56, s * 0.15, s * 0.14),
+      leaf({ x: cx + f * s * 0.17, y: ground - s * 0.64 }, s * 0.38, s * 0.12, -Math.PI / 2 - f * 0.25),
+      leaf({ x: cx + f * s * 0.25, y: ground - s * 0.64 }, s * 0.36, s * 0.11, -Math.PI / 2 + f * 0.05),
+      disc(cx + f * s * 0.2, ground - s * 0.04, s * 0.12, s * 0.05)
+    ],
+    tail: [disc(cx - f * s * 0.29, ground - s * 0.16, s * 0.07)]
+  };
+}
+function pumpkin(cx, ground, w, h) {
+  const cy = ground - h / 2;
+  const lobes = [disc(cx - w * 0.27, cy, w * 0.25, h / 2), disc(cx + w * 0.27, cy, w * 0.25, h / 2), disc(cx - w * 0.12, cy, w * 0.24, h / 2 * 1.01), disc(cx + w * 0.12, cy, w * 0.24, h / 2 * 1.01), disc(cx, cy, w * 0.2, h / 2 * 1.02)];
+  const creases = [-0.2, -0.07, 0.07, 0.2].map((f) => ({ closed: false, points: [pt3(cx + w * f * 0.7, cy - h * 0.42), { ...pt3(cx + w * f * 0.7, cy + h * 0.42), handleIn: pt3(cx + w * f * 1.35, cy) }] }));
+  const stem = { closed: true, points: [pt3(cx - w * 0.05, cy - h * 0.44), { ...pt3(cx - w * 0.03, cy - h * 0.66), handleIn: pt3(cx - w * 0.06, cy - h * 0.56) }, pt3(cx + w * 0.07, cy - h * 0.7), { ...pt3(cx + w * 0.05, cy - h * 0.44), handleIn: pt3(cx + w * 0.02, cy - h * 0.58) }] };
+  return { lobes, creases, stem: [stem] };
+}
+function jackFace(cx, cy, w) {
+  const u = w / 100;
+  const tri = (x, y, s, up = true) => polyP(up ? [{ x: cx + (x - s) * u, y: cy + (y + s * 0.7) * u }, { x: cx + (x + s) * u, y: cy + (y + s * 0.7) * u }, { x: cx + x * u, y: cy + (y - s) * u }] : [{ x: cx + (x - s) * u, y: cy + (y - s * 0.6) * u }, { x: cx + (x + s) * u, y: cy + (y - s * 0.6) * u }, { x: cx + x * u, y: cy + (y + s * 0.6) * u }]);
+  const mouth = polyP([[-32, 8], [-20, 14], [-14, 9], [-6, 16], [6, 16], [14, 9], [20, 14], [32, 8], [24, 24], [10, 28], [6, 22], [-6, 22], [-10, 28], [-24, 24]].map(([x, y]) => ({ x: cx + x * u, y: cy + y * u })));
+  return [tri(-17, -12, 10), tri(17, -12, 10), tri(0, 0, 5, true), mouth];
+}
+function bat(cx, cy, s, flap = 0) {
+  const u = s / 100, f = flap * 10;
+  const pts = [[0, -8], [4, -14], [6, -6], [14, -10 - f], [30, -18 - f], [50, -12 - f], [44, -2], [36, 2], [30, 8], [20, 4], [12, 12], [4, 6], [0, 12]];
+  const full = [...pts, ...pts.slice(1, -1).reverse().map(([x, y]) => [-x, y])];
+  return polyP(full.map(([x, y]) => ({ x: cx + x * u, y: cy + y * u })));
+}
+function web(cx, cy, r, a0, a1, spokes = 7, rings = 6) {
+  const out = [];
+  const angles = Array.from({ length: spokes }, (_, i) => a0 + (a1 - a0) * i / (spokes - 1));
+  for (const a of angles) out.push(seg({ x: cx, y: cy }, at(cx, cy, r, a)));
+  for (let j = 1; j <= rings; j++) {
+    const rr = r * j / (rings + 0.4);
+    for (let i = 0; i < spokes - 1; i++) {
+      const p0 = at(cx, cy, rr, angles[i]), p1 = at(cx, cy, rr, angles[i + 1]), m = at(cx, cy, rr * 0.86, (angles[i] + angles[i + 1]) / 2);
+      out.push({ closed: false, points: [pt3(p0.x, p0.y), { ...pt3(p1.x, p1.y), handleIn: pt3(m.x, m.y) }] });
+    }
+  }
+  return out;
+}
+function ghost(cx, top, s) {
+  const w = s * 0.62, bot = top + s;
+  const pts = [{ ...pt3(cx - w / 2, bot - s * 0.05), handleOut: pt3(cx - w / 2, top + s * 0.2) }, { ...pt3(cx, top), handleIn: pt3(cx - w / 2, top), handleOut: pt3(cx + w / 2, top) }, { ...pt3(cx + w / 2, bot - s * 0.05), handleIn: pt3(cx + w / 2, top + s * 0.2) }];
+  for (let i = 1; i <= 4; i++) {
+    const x = cx + w / 2 - w * i / 4;
+    pts.push({ ...pt3(x, bot - (i % 2 ? 0 : s * 0.08)), handleIn: pt3(x + w / 8, bot + (i % 2 ? s * 0.04 : -s * 0.12)) });
+  }
+  return { sheet: [{ closed: true, points: pts }], face: [disc(cx - w * 0.16, top + s * 0.32, s * 0.05, s * 0.07), disc(cx + w * 0.16, top + s * 0.32, s * 0.05, s * 0.07), disc(cx, top + s * 0.5, s * 0.06, s * 0.08)] };
+}
+function candyCorn(cx, cy, s, turn = 0) {
+  const c = Math.cos(turn), sn = Math.sin(turn);
+  const p = (x, y) => ({ x: cx + (x * c - y * sn) * s, y: cy + (x * sn + y * c) * s });
+  const band = (y0, y1) => {
+    const w0 = 0.36 * (y0 + 0.5), w1 = 0.36 * (y1 + 0.5);
+    return polyP([p(-w0, y0), p(w0, y0), p(w1, y1), p(-w1, y1)]);
+  };
+  return { tip: [polyP([p(0, -0.5), p(0.12, -0.17), p(-0.12, -0.17)])], mid: [band(-0.17, 0.15)], base: [{ ...band(0.15, 0.48) }] };
+}
+function maple(cx, cy, s, turn = 0) {
+  const u = s / 100, c = Math.cos(turn), sn = Math.sin(turn);
+  const raw = [[0, -50], [8, -30], [18, -36], [16, -14], [38, -26], [34, -14], [48, -10], [30, 4], [36, 14], [14, 12], [10, 22], [4, 18], [2, 40], [-2, 40], [-4, 18], [-10, 22], [-14, 12], [-36, 14], [-30, 4], [-48, -10], [-34, -14], [-38, -26], [-16, -14], [-18, -36], [-8, -30]];
+  const p = ([x, y]) => ({ x: cx + (x * c - y * sn) * u, y: cy + (x * sn + y * c) * u });
+  return [polyP(raw.map(p))];
+}
+function mapleVeins(cx, cy, s, turn = 0) {
+  const u = s / 100, c = Math.cos(turn), sn = Math.sin(turn);
+  const p = (x, y) => ({ x: cx + (x * c - y * sn) * u, y: cy + (x * sn + y * c) * u });
+  return [seg(p(0, 36), p(0, -42)), seg(p(0, 14), p(36, -20)), seg(p(0, 14), p(-36, -20)), seg(p(0, 20), p(28, 10)), seg(p(0, 20), p(-28, 10))];
+}
+function oak(base, len, angle) {
+  const c = Math.cos(angle), s = Math.sin(angle);
+  const p = (u, v) => ({ x: base.x + u * c - v * s, y: base.y + u * s + v * c });
+  const pts = [p(0, 0)];
+  const lobes = 4;
+  for (let i = 0; i < lobes; i++) {
+    const u0 = len * (0.12 + i * 0.8 / lobes), u1 = u0 + len * 0.8 / lobes / 2, w = len * 0.26 * (1 - i * 0.12);
+    pts.push(p(u0, w * 0.45), p(u1, w), p(u0 + len * 0.8 / lobes, w * 0.42));
+  }
+  pts.push(p(len, 0));
+  for (let i = lobes - 1; i >= 0; i--) {
+    const u0 = len * (0.12 + i * 0.8 / lobes), u1 = u0 + len * 0.8 / lobes / 2, w = len * 0.26 * (1 - i * 0.12);
+    pts.push(p(u0 + len * 0.8 / lobes, -w * 0.42), p(u1, -w), p(u0, -w * 0.45));
+  }
+  return smoothP(pts, 0.18);
+}
+function smoothP(pts, tension = 0.2) {
+  const n = pts.length;
+  return { closed: true, points: pts.map((p, i) => {
+    const a = pts[(i - 1 + n) % n], b = pts[(i + 1) % n], tx = (b.x - a.x) * tension, ty = (b.y - a.y) * tension;
+    return { ...pt3(p.x, p.y), handleIn: pt3(p.x - tx, p.y - ty), handleOut: pt3(p.x + tx, p.y + ty) };
+  }) };
+}
+function wheat(x, ground, h, lean = 0) {
+  const top = { x: x + lean * h, y: ground - h };
+  const grains = [];
+  const angle = Math.atan2(top.y - ground, top.x - x);
+  for (let i = 0; i < 7; i++) {
+    const t = 0.66 + i * 0.05;
+    const p = { x: x + (top.x - x) * t, y: ground + (top.y - ground) * t };
+    const len = h * 0.1 * (1 - i * 0.06);
+    grains.push(petal(p, len, len * 0.5, angle - 0.5), petal(p, len, len * 0.5, angle + 0.5));
+  }
+  grains.push(petal(top, h * 0.08, h * 0.04, angle));
+  return { stalk: [{ closed: false, points: [pt3(x, ground), { ...pt3(top.x, top.y), handleIn: pt3(x + lean * h * 0.3, ground - h * 0.5) }] }], grains };
+}
+function acorn(cx, cy, s, turn = 0) {
+  const c = Math.cos(turn), sn = Math.sin(turn);
+  const tr = (x, y) => ({ x: cx + (x * c - y * sn) * s, y: cy + (x * sn + y * c) * s });
+  const nut = egg(cx, cy + s * 0.12, s * 0.5, s * 0.66, turn + Math.PI);
+  const cap = smoothP([tr(-0.3, -0.1), tr(-0.28, -0.26), tr(0, -0.34), tr(0.28, -0.26), tr(0.3, -0.1), tr(0, -0.06)], 0.2);
+  return { nut: [nut], cap: [cap, polyP([tr(-0.03, -0.32), tr(0.03, -0.32), tr(0.06, -0.46), tr(0.01, -0.46)])] };
+}
+function diya(cx, ground, w) {
+  const h = w * 0.36, top = ground - h;
+  const bowl = { closed: true, points: [
+    { ...pt3(cx - w / 2, top) },
+    { ...pt3(cx + w * 0.38, top) },
+    { ...pt3(cx + w * 0.58, top - h * 0.28) },
+    { ...pt3(cx + w * 0.42, top + h * 0.3), handleOut: pt3(cx + w * 0.3, ground + h * 0.05) },
+    { ...pt3(cx - w * 0.1, ground), handleIn: pt3(cx + w * 0.15, ground + h * 0.02), handleOut: pt3(cx - w * 0.38, ground) },
+    { ...pt3(cx - w / 2, top), handleIn: pt3(cx - w * 0.52, top + h * 0.6) }
+  ] };
+  const rim = [polyP([{ x: cx - w * 0.47, y: top + h * 0.12 }, { x: cx + w * 0.4, y: top + h * 0.12 }, { x: cx + w * 0.37, y: top + h * 0.26 }, { x: cx - w * 0.45, y: top + h * 0.26 }])];
+  const fx = cx + w * 0.5, fy = top - h * 0.22;
+  return { bowl: [bowl], rim, flame: [flame(fx, fy, w * 0.2, w * 0.5)], core: [flame(fx, fy - w * 0.02, w * 0.09, w * 0.24)] };
+}
+function marigold(cx, cy, r, seed = 1) {
+  const rr = rng(seed);
+  const ring = (R, n, off) => Array.from({ length: n }, (_, i) => {
+    const a = off + i * 2 * Math.PI / n;
+    const p = at(cx, cy, R * (0.92 + rr() * 0.12), a);
+    return disc(p.x, p.y, r * 0.3);
+  });
+  return { outer: ring(r * 0.7, 12, 0), inner: [...ring(r * 0.36, 7, 0.3), disc(cx, cy, r * 0.36)] };
+}
+function rangoli(cx, cy, R, petals = 8) {
+  const outer = [], middle = [], inner = [], dots = [];
+  for (let i = 0; i < petals * 2; i++) {
+    const a = i * Math.PI / petals;
+    outer.push(petal(at(cx, cy, R * 0.42, a), R * 0.56, R * 0.3, a));
+  }
+  for (let i = 0; i < petals; i++) {
+    const a = i * 2 * Math.PI / petals + Math.PI / petals;
+    middle.push(petal(at(cx, cy, R * 0.18, a), R * 0.5, R * 0.36, a));
+  }
+  for (let i = 0; i < petals; i++) {
+    const a = i * 2 * Math.PI / petals;
+    inner.push(petal({ x: cx, y: cy }, R * 0.36, R * 0.2, a));
+  }
+  for (let i = 0; i < petals * 4; i++) {
+    const a = i * Math.PI / (petals * 2);
+    const p = at(cx, cy, R * 1.04, a);
+    dots.push(disc(p.x, p.y, R * 0.022));
+  }
+  for (let i = 0; i < petals * 2; i++) {
+    const a = i * Math.PI / petals + Math.PI / (petals * 2);
+    const p = at(cx, cy, R * 0.78, a);
+    dots.push(disc(p.x, p.y, R * 0.03));
+  }
+  return { outer, middle, inner, dots, heart: [disc(cx, cy, R * 0.12)] };
+}
+function toran(x0, x1, y, sag, n, r, seed = 3) {
+  const string = [], outer = [], inner = [], leaves = [];
+  const span = (x1 - x0) / n;
+  for (let i = 0; i < n; i++) {
+    const a = { x: x0 + span * i, y }, b = { x: x0 + span * (i + 1), y }, m = { x: (a.x + b.x) / 2, y: y + sag * 2 };
+    string.push(quad(a, m, b, 12));
+    const lowest = along(a, m, b, 0.5).p;
+    const g = marigold(lowest.x, lowest.y + r * 0.6, r, seed + i);
+    outer.push(...g.outer);
+    inner.push(...g.inner);
+    for (const t of [0.25, 0.75]) {
+      const p = along(a, m, b, t).p;
+      leaves.push(leaf(p, r * 2.3, r * 0.75, Math.PI / 2 + (t < 0.5 ? 0.15 : -0.15)));
+    }
+  }
+  return { string, blooms: { outer, inner }, leaves };
+}
+function eightStar(cx, cy, r) {
+  return starPath(cx, cy, r, r * 0.76, 8, Math.PI / 8);
+}
+function fanous(cx, top, s) {
+  const u = s / 100;
+  const y = (v) => top + v * u, x = (v) => cx + v * u;
+  const metal = [
+    disc(cx, y(3), 3 * u),
+    polyP([{ x: x(-3), y: y(6) }, { x: x(3), y: y(6) }, { x: x(2), y: y(14) }, { x: x(-2), y: y(14) }]),
+    { closed: true, points: [pt3(x(-16), y(26)), { ...pt3(x(0), y(13)), handleIn: pt3(x(-14), y(15)), handleOut: pt3(x(14), y(15)) }, pt3(x(16), y(26))] },
+    polyP([{ x: x(-20), y: y(26) }, { x: x(20), y: y(26) }, { x: x(18), y: y(30) }, { x: x(-18), y: y(30) }]),
+    polyP([{ x: x(-18), y: y(74) }, { x: x(18), y: y(74) }, { x: x(10), y: y(84) }, { x: x(-10), y: y(84) }]),
+    polyP([{ x: x(-4), y: y(84) }, { x: x(4), y: y(84) }, { x: x(0), y: y(97) }])
+  ];
+  const glass = [polyP([{ x: x(-17), y: y(30) }, { x: x(17), y: y(30) }, { x: x(22), y: y(52) }, { x: x(17), y: y(74) }, { x: x(-17), y: y(74) }, { x: x(-22), y: y(52) }])];
+  const frame = [
+    seg({ x: x(-6), y: y(30) }, { x: x(-6), y: y(74) }),
+    seg({ x: x(6), y: y(30) }, { x: x(6), y: y(74) }),
+    seg({ x: x(-22), y: y(52) }, { x: x(22), y: y(52) }),
+    { closed: false, points: [pt3(x(-6), y(44)), { ...pt3(x(6), y(44)), handleIn: pt3(x(0), y(36)) }] },
+    { closed: false, points: [pt3(x(-6), y(66)), { ...pt3(x(6), y(66)), handleIn: pt3(x(0), y(58)) }] }
+  ];
+  return { metal, glass, frame, glow: [flame(cx, y(70), 12 * u, 26 * u)] };
+}
+function archPath(cx, w, base, spring, tip) {
+  const l = cx - w / 2, r = cx + w / 2;
+  return { closed: true, points: [
+    pt3(l, base),
+    { ...pt3(l, spring), handleOut: pt3(l, spring - (spring - tip) * 0.55) },
+    { ...pt3(cx, tip), handleIn: pt3(cx - w * 0.12, tip + (spring - tip) * 0.35), handleOut: pt3(cx + w * 0.12, tip + (spring - tip) * 0.35) },
+    { ...pt3(r, spring), handleIn: pt3(r, spring - (spring - tip) * 0.55) },
+    pt3(r, base)
+  ] };
+}
+function tilePattern(w, h, step, x0 = 0, y0 = 0) {
+  const stars = [], joins = [];
+  for (let y = y0; y < h + step; y += step) for (let x = x0; x < w + step; x += step) {
+    stars.push(eightStar(x, y, step * 0.3));
+    const m = { x: x + step / 2, y: y + step / 2 };
+    joins.push(polyP([{ x: m.x, y: m.y - step * 0.12 }, { x: m.x + step * 0.12, y: m.y }, { x: m.x, y: m.y + step * 0.12 }, { x: m.x - step * 0.12, y: m.y }]));
+  }
+  return { stars, joins };
+}
+function redLantern(cx, top, w, cord = 0) {
+  const h = w * 0.82, y0 = top + cord + w * 0.08, cy = y0 + h / 2;
+  const ribs = [];
+  for (const f of [-0.62, -0.3, 0, 0.3, 0.62]) ribs.push({ closed: false, points: [pt3(cx + f * w * 0.32, y0 + h * 0.03), { ...pt3(cx + f * w * 0.32, y0 + h * 0.97), handleIn: pt3(cx + f * w * 0.62, cy) }] });
+  const tTop = y0 + h + w * 0.07;
+  return {
+    cord: cord > 0 ? [seg({ x: cx, y: top }, { x: cx, y: top + cord })] : [],
+    caps: [rectPath(cx - w * 0.22, y0 - w * 0.07, w * 0.44, w * 0.1), rectPath(cx - w * 0.22, y0 + h - w * 0.03, w * 0.44, w * 0.1)],
+    body: [disc(cx, cy, w / 2, h / 2)],
+    ribs,
+    tassel: [rectPath(cx - w * 0.04, tTop, w * 0.08, w * 0.06), polyP([{ x: cx - w * 0.06, y: tTop + w * 0.06 }, { x: cx + w * 0.06, y: tTop + w * 0.06 }, { x: cx + w * 0.1, y: tTop + w * 0.42 }, { x: cx - w * 0.1, y: tTop + w * 0.42 }])]
+  };
+}
+function plum(cx, cy, r, turn = 0) {
+  const petals = Array.from({ length: 5 }, (_, i) => {
+    const a = turn + i * 2 * Math.PI / 5;
+    const p = at(cx, cy, r * 0.55, a);
+    return disc(p.x, p.y, r * 0.48);
+  });
+  return { petals, heart: [disc(cx, cy, r * 0.22)] };
+}
+function branch(pts, seed, twigs = 5, len = 60) {
+  const r = rng(seed);
+  const limb = [polyP(pts, false)];
+  const tw = [], ends = [pts[pts.length - 1]];
+  for (let i = 0; i < twigs; i++) {
+    const j = 1 + Math.floor(r() * (pts.length - 2));
+    const a = pts[j - 1], b = pts[j], t = r();
+    const p = { x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t };
+    const dir = Math.atan2(b.y - a.y, b.x - a.x) + (r() > 0.5 ? 1 : -1) * (0.5 + r() * 0.5);
+    const l = len * (0.5 + r() * 0.6);
+    const e = at(p.x, p.y, l, dir), m = at(p.x, p.y, l * 0.5, dir + 0.2);
+    tw.push(polyP([p, m, e], false));
+    ends.push(e, m);
+  }
+  return { limb, twigs: tw, ends };
+}
+function cloudCurl(x, y, s, flip = 1) {
+  const u = s / 100;
+  const curl = (cx, cy, r, dir) => polyP(Array.from({ length: 22 }, (_, i) => {
+    const t = i / 21;
+    const a = dir * (Math.PI * 0.2 + t * Math.PI * 1.9);
+    const rr = r * (1 - t * 0.6);
+    return { x: x + flip * (cx + Math.cos(a + Math.PI) * rr) * u, y: y + (cy + Math.sin(a + Math.PI) * rr) * u };
+  }), false);
+  return [curl(30, 0, 22, 1), curl(62, -4, 18, -1), curl(48, -20, 14, 1), polyP([{ x: x + flip * 8 * u, y: y + 22 * u }, { x: x + flip * 96 * u, y: y + 22 * u }], false)];
+}
+function coin(cx, cy, r) {
+  return { coin: [disc(cx, cy, r)], rim: [disc(cx, cy, r * 0.82)], hole: [rectPath(cx - r * 0.24, cy - r * 0.24, r * 0.48, r * 0.48)] };
+}
+function firecrackers(cx, top, n, s) {
+  const crackers = [], tips = [];
+  for (let i = 0; i < n; i++) {
+    const y = top + s * 0.5 + i * s * 0.55, side = i % 2 ? 1 : -1;
+    const c = Math.cos(side * 0.5), sn = Math.sin(side * 0.5);
+    const p = (u, v) => ({ x: cx + u * c - v * sn, y: y + u * sn + v * c });
+    crackers.push(polyP([p(0, -s * 0.1), p(side * s * 0.6, -s * 0.1), p(side * s * 0.6, s * 0.1), p(0, s * 0.1)]));
+    tips.push(polyP([p(side * s * 0.6, -s * 0.1), p(side * s * 0.68, -s * 0.1), p(side * s * 0.68, s * 0.1), p(side * s * 0.6, s * 0.1)]));
+  }
+  return { cord: [seg({ x: cx, y: top }, { x: cx, y: top + s * 0.5 + n * s * 0.55 })], crackers, tips };
+}
+function dashedFrame(w, h, m, r = 0) {
+  return [r > 0 ? roundRect(m, m, w - 2 * m, h - 2 * m, r) : rectPath(m, m, w - 2 * m, h - 2 * m)];
+}
+function doubleRule(w, h, m, gap, r = 0) {
+  return [r ? roundRect(m, m, w - 2 * m, h - 2 * m, r) : rectPath(m, m, w - 2 * m, h - 2 * m), r ? roundRect(m + gap, m + gap, w - 2 * (m + gap), h - 2 * (m + gap), Math.max(0, r - gap)) : rectPath(m + gap, m + gap, w - 2 * (m + gap), h - 2 * (m + gap))];
+}
+function maze(x, y, cols, rows, cell, seed) {
+  const r = rng(seed);
+  const right = Array.from({ length: cols }, () => Array(rows).fill(true));
+  const bottom = Array.from({ length: cols }, () => Array(rows).fill(true));
+  const seen = Array.from({ length: cols }, () => Array(rows).fill(false));
+  const stack = [[0, 0]];
+  seen[0][0] = true;
+  while (stack.length) {
+    const [c, w] = stack[stack.length - 1];
+    const next = [[1, 0], [-1, 0], [0, 1], [0, -1]].map(([dc, dr]) => [c + dc, w + dr]).filter(([a2, b2]) => a2 >= 0 && b2 >= 0 && a2 < cols && b2 < rows && !seen[a2][b2]);
+    if (!next.length) {
+      stack.pop();
+      continue;
+    }
+    const [a, b] = next[Math.floor(r() * next.length)];
+    if (a > c) right[c][w] = false;
+    else if (a < c) right[a][b] = false;
+    else if (b > w) bottom[c][w] = false;
+    else bottom[a][b] = false;
+    seen[a][b] = true;
+    stack.push([a, b]);
+  }
+  const out = [];
+  out.push(seg({ x: x + cell, y }, { x: x + cols * cell, y }), seg({ x, y }, { x, y: y + rows * cell }));
+  out.push(seg({ x, y: y + rows * cell }, { x: x + (cols - 1) * cell, y: y + rows * cell }), seg({ x: x + cols * cell, y }, { x: x + cols * cell, y: y + rows * cell }));
+  for (let c = 0; c < cols; c++) for (let w = 0; w < rows; w++) {
+    if (right[c][w] && c < cols - 1) out.push(seg({ x: x + (c + 1) * cell, y: y + w * cell }, { x: x + (c + 1) * cell, y: y + (w + 1) * cell }));
+    if (bottom[c][w] && w < rows - 1) out.push(seg({ x: x + c * cell, y: y + (w + 1) * cell }, { x: x + (c + 1) * cell, y: y + (w + 1) * cell }));
+  }
+  return out;
+}
+function wordSearch(words, n, seed) {
+  const r = rng(seed);
+  const g = Array.from({ length: n }, () => Array(n).fill(""));
+  const dirs = [[1, 0], [0, 1], [1, 1], [1, -1]];
+  for (const word of words) {
+    const w = word.toUpperCase().replace(/[^A-Z]/g, "");
+    for (let tries = 0; tries < 400; tries++) {
+      const [dx, dy] = dirs[Math.floor(r() * dirs.length)];
+      const x = Math.floor(r() * n), y = Math.floor(r() * n);
+      const ex = x + dx * (w.length - 1), ey = y + dy * (w.length - 1);
+      if (ex < 0 || ex >= n || ey < 0 || ey >= n) continue;
+      if ([...w].some((ch, i) => {
+        const c = g[y + dy * i][x + dx * i];
+        return c && c !== ch;
+      })) continue;
+      [...w].forEach((ch, i) => {
+        g[y + dy * i][x + dx * i] = ch;
+      });
+      break;
+    }
+  }
+  const A = "ABCDEFGHIJKLMNOPRSTUWY";
+  return g.map((row) => row.map((c) => c || A[Math.floor(r() * A.length)]).join(" "));
+}
+
+export {
+  boxTight,
+  draw,
+  redraw,
+  restyleAll,
+  scaleGaps,
+  printVariant,
+  disc,
+  roundRect,
+  rectPath,
+  seg,
+  polyP,
+  arc,
+  starPath,
+  sparkle,
+  heart,
+  leaf,
+  petal,
+  flame,
+  crescent,
+  confetti,
+  specks,
+  bandsAround,
+  perBand,
+  specksIn,
+  flourishComponent,
+  bauble,
+  pine,
+  holly,
+  snowflake,
+  along,
+  quad,
+  sprig,
+  menorah,
+  dreidel,
+  starOfDavid,
+  gelt,
+  burst,
+  coupe,
+  streamer,
+  clock,
+  rose,
+  egg,
+  eggBands,
+  tulip,
+  grass,
+  rabbit,
+  pumpkin,
+  jackFace,
+  bat,
+  web,
+  ghost,
+  candyCorn,
+  maple,
+  mapleVeins,
+  oak,
+  smoothP,
+  wheat,
+  acorn,
+  diya,
+  marigold,
+  rangoli,
+  toran,
+  eightStar,
+  fanous,
+  archPath,
+  tilePattern,
+  redLantern,
+  plum,
+  branch,
+  cloudCurl,
+  coin,
+  firecrackers,
+  dashedFrame,
+  doubleRule,
+  maze,
+  wordSearch
+};