@weasel-js/core 1.9.3 → 1.10.0

package/dist/features/paths/tessellate/stroke.js

@@ -1,170 +0,0 @@
-import { splitForDash as e } from "./dash.js";
-import { populatePolylineWidths as t } from "./vertexWidths.js";
-import { coordsOutOfMetric as n, rectIntoMetric as r, worldWidthInMetric as i, worldWidthInMetricAlongWorld as a } from "./metric.js";
-import { trimInSpace as o } from "./insets.js";
-import { alignedStrokeRect as s, resolveScreenLength as c } from "@weasel-js/paint";
-import { extractPolylines as l } from "@weasel-js/geom/tessellate";
-//#region src/features/paths/tessellate/stroke.ts
-var u = {
-	vertices: /* @__PURE__ */ new Float32Array(),
-	indices: /* @__PURE__ */ new Uint32Array(),
-	anchorA: /* @__PURE__ */ new Uint32Array(),
-	anchorB: /* @__PURE__ */ new Uint32Array(),
-	anchorT: /* @__PURE__ */ new Float32Array()
-};
-function d(e, t) {
-	return c(e, t);
-}
-function f(c, f, m = {}) {
-	let h = d(f.width ?? 1, 1);
-	if (h <= 0) return u;
-	let g = f.join ?? "miter", y = f.cap ?? "butt", b = f.align ?? "center", x = f.miterLimit ?? _, S = f.varyingWidthJoinThreshold ?? v, C = m.metric, w = C && c.kind === "rect" ? r(c, C) : null, T = w ?? c;
-	if (T.kind === "rect" && b !== "center") {
-		let e = s(T, b, h);
-		T = {
-			kind: "rect",
-			x: e.x,
-			y: e.y,
-			width: e.width,
-			height: e.height
-		};
-	}
-	let E = l(T, m), D = f.vertexWidths && f.vertexWidths.length > 0 ? f.vertexWidths : null, O = C ? w ? (e, t) => i(C, e, t) : (e, t) => a(C, e, t) : void 0, k = f.dash ?? [], A = [], j = [], M = [], N = [], P = [], F = C ?? null;
-	for (let n of E) {
-		D && t(n, D, h, O);
-		let r = o(n, w ? F : null, F, m.startInset, m.endInset);
-		if (r === null) continue;
-		let i = k.length > 0 ? e(r, k) : [r];
-		for (let e of i) p(e, h, g, y, x, S, A, j, M, N, P);
-	}
-	let I = new Float32Array(A);
-	return C && n(I, C), {
-		vertices: I,
-		indices: new Uint32Array(j),
-		anchorA: new Uint32Array(M),
-		anchorB: new Uint32Array(N),
-		anchorT: new Float32Array(P)
-	};
-}
-function p(e, t, n, r, i, a, o, s, c, l, u) {
-	let d = t / 2, f = e.points, p = f.length / 2, m = p - 1;
-	if (m < 1) return;
-	let _ = e.anchorA ?? new Uint32Array(p), v = e.anchorB ?? new Uint32Array(p), b = e.anchorT ?? new Float32Array(p), x = e.widths ? e.widths.map((e) => e / 2) : null, S = [], C = [];
-	for (let e = 0; e < m; e++) {
-		let t = x ? x[e] : d, n = x ? x[e + 1] : d, r = g(f[e * 2], f[e * 2 + 1], f[(e + 1) * 2], f[(e + 1) * 2 + 1], t, n);
-		r && (S.push(r), C.push(e));
-	}
-	let w = -1;
-	if (e.closed && S.length >= 1) {
-		let e = S[S.length - 1], t = S[0], n = x ? x[p - 1] : d, r = x ? x[0] : d, i = g(e.bx, e.by, t.ax, t.ay, n, r);
-		i && (S.push(i), w = p - 1, C.push(w));
-	}
-	if (S.length === 0) return;
-	let T = [];
-	for (let t = 0; t < S.length; t++) {
-		let n = S[t], r = C[t], i = t === S.length - 1 && e.closed && w >= 0 ? 0 : r + 1, a = o.length / 2;
-		T.push(a);
-		let d = n.nxUnit * n.halfA, f = n.nyUnit * n.halfA, p = n.nxUnit * n.halfB, m = n.nyUnit * n.halfB;
-		o.push(n.ax + d, n.ay + f), c.push(_[r]), l.push(v[r]), u.push(b[r]), o.push(n.ax - d, n.ay - f), c.push(_[r]), l.push(v[r]), u.push(b[r]), o.push(n.bx + p, n.by + m), c.push(_[i]), l.push(v[i]), u.push(b[i]), o.push(n.bx - p, n.by - m), c.push(_[i]), l.push(v[i]), u.push(b[i]), s.push(a, a + 1, a + 2, a + 1, a + 3, a + 2);
-	}
-	let E = e.closed ? S.length : S.length - 1;
-	for (let e = 0; e < E; e++) y(S, T, e, n, i, a, o, s, c, l, u, C, _, v, b);
-	if (!e.closed && r !== "butt") {
-		let e = S[0], t = T[0];
-		h(e, t + 0, t + 1, !1, e.halfA, r, o, s, c, l, u, _[0], v[0], b[0]);
-		let n = S[S.length - 1], i = T[S.length - 1], a = C[S.length - 1] + 1;
-		h(n, i + 2, i + 3, !0, n.halfB, r, o, s, c, l, u, _[a], v[a], b[a]);
-	}
-}
-var m = 10 * Math.PI / 180;
-function h(e, t, n, r, i, a, o, s, c, l, u, d, f, p) {
-	let h = r ? 1 : -1, g = (e.bx - e.ax) / e.len * h, _ = (e.by - e.ay) / e.len * h, v = r ? e.bx : e.ax, y = r ? e.by : e.ay, b = e.nxUnit * i, x = e.nyUnit * i;
-	if (a === "square") {
-		let e = v + g * i, a = y + _ * i, m = o.length / 2;
-		o.push(e + b, a + x), c.push(d), l.push(f), u.push(p);
-		let h = o.length / 2;
-		o.push(e - b, a - x), c.push(d), l.push(f), u.push(p), r ? s.push(t, m, h, t, h, n) : s.push(t, h, m, t, n, h);
-		return;
-	}
-	if (a === "round") {
-		let e = o.length / 2;
-		o.push(v, y), c.push(d), l.push(f), u.push(p);
-		let a = Math.atan2(x, b), h = r ? -Math.PI : Math.PI, g = Math.max(1, Math.ceil(Math.abs(h) / m)), _ = h / g, S = t;
-		for (let t = 1; t < g; t++) {
-			let n = a + t * _, m = v + Math.cos(n) * i, h = y + Math.sin(n) * i, g = o.length / 2;
-			o.push(m, h), c.push(d), l.push(f), u.push(p), r ? s.push(S, g, e) : s.push(S, e, g), S = g;
-		}
-		r ? s.push(S, n, e) : s.push(S, e, n);
-	}
-}
-function g(e, t, n, r, i, a) {
-	let o = n - e, s = r - t, c = Math.hypot(o, s);
-	return c === 0 ? null : {
-		ax: e,
-		ay: t,
-		bx: n,
-		by: r,
-		nxUnit: -s / c,
-		nyUnit: o / c,
-		halfA: i,
-		halfB: a,
-		len: c
-	};
-}
-var _ = 4, v = 1.5;
-function y(e, t, n, r, i, a, o, s, c, l, u, d, f, p, m) {
-	let h = e[n], g = e[(n + 1) % e.length], _ = t[n], v = t[(n + 1) % e.length], y = h.bx - h.ax, b = h.by - h.ay, w = g.bx - g.ax, T = g.by - g.ay, E = y * T - b * w;
-	if (E === 0) return;
-	let D = E > 0, O = D ? _ + 3 : _ + 2, k = D ? v + 1 : v + 0, A = d[(n + 1) % e.length], j = f[A], M = p[A], N = m[A], P = h.halfB, F = Math.max(h.halfA, h.halfB) / Math.max(1e-9, Math.min(h.halfA, h.halfB)), I = Math.max(g.halfA, g.halfB) / Math.max(1e-9, Math.min(g.halfA, g.halfB));
-	if (r === "bevel" || F > a || I > a) {
-		S(h, O, k, D, o, s, c, l, u, j, M, N);
-		return;
-	}
-	if (r === "miter") {
-		let e = o[O * 2], t = o[O * 2 + 1], n = o[k * 2], r = o[k * 2 + 1], a = C(e, t, y, b, n, r, -w, -T);
-		if (!a) {
-			S(h, O, k, D, o, s, c, l, u, j, M, N);
-			return;
-		}
-		if (Math.hypot(a[0] - h.bx, a[1] - h.by) > i * P) {
-			S(h, O, k, D, o, s, c, l, u, j, M, N);
-			return;
-		}
-		let d = o.length / 2;
-		o.push(a[0], a[1]), c.push(j), l.push(M), u.push(N);
-		let f = o.length / 2;
-		o.push(h.bx, h.by), c.push(j), l.push(M), u.push(N), D ? (s.push(O, d, k), s.push(O, k, f)) : (s.push(O, k, d), s.push(O, f, k));
-		return;
-	}
-	if (r === "round") {
-		x(h, O, k, D, o, s, c, l, u, j, M, N);
-		return;
-	}
-}
-var b = 10 * Math.PI / 180;
-function x(e, t, n, r, i, a, o, s, c, l, u, d) {
-	let f = e.bx, p = e.by, m = i.length / 2;
-	i.push(f, p), o.push(l), s.push(u), c.push(d);
-	let h = i[t * 2] - f, g = i[t * 2 + 1] - p, _ = i[n * 2] - f, v = i[n * 2 + 1] - p, y = Math.hypot(h, g), x = Math.atan2(g, h), S = Math.atan2(v, _) - x;
-	r && S < 0 ? S += 2 * Math.PI : !r && S > 0 && (S -= 2 * Math.PI);
-	let C = Math.max(1, Math.ceil(Math.abs(S) / b)), w = S / C, T = t;
-	for (let e = 1; e < C; e++) {
-		let t = x + e * w, n = f + Math.cos(t) * y, h = p + Math.sin(t) * y, g = i.length / 2;
-		i.push(n, h), o.push(l), s.push(u), c.push(d), r ? a.push(T, m, g) : a.push(T, g, m), T = g;
-	}
-	r ? a.push(T, m, n) : a.push(T, n, m);
-}
-function S(e, t, n, r, i, a, o, s, c, l, u, d) {
-	let f = i.length / 2;
-	i.push(e.bx, e.by), o.push(l), s.push(u), c.push(d), r ? a.push(t, f, n) : a.push(t, n, f);
-}
-function C(e, t, n, r, i, a, o, s) {
-	let c = n * s - r * o;
-	if (Math.abs(c) < 1e-9) return null;
-	let l = ((i - e) * s - (a - t) * o) / c;
-	return [e + l * n, t + l * r];
-}
-//#endregion
-export { d as resolveStrokeWidth, f as tessellateStroke };
-
-//# sourceMappingURL=stroke.js.map

package/dist/features/paths/tessellate/stroke.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"stroke.js","names":["EMPTY_MESH","resolveStrokeWidth","resolveScreenLength","width","scale","tessellateStroke","stroke","join","cap","align","miterLimit","DEFAULT_MITER_LIMIT","varyingThreshold","DEFAULT_VARYING_WIDTH_JOIN_THRESHOLD","metric","opts","rectInMetric","path","rectIntoMetric","workingPath","aligned","alignedStrokeRect","polylines","extractPolylines","vertexWidths","worldWidthInMetric","tx","ty","worldWidthInMetricAlongWorld","ux","uy","dash","verts","idx","anchorA","anchorB","anchorT","ribbonSpace","pl","populatePolylineWidths","trimmed","trimInSpace","subs","splitForDash","sub","vertices","coordsOutOfMetric","expandPolyline","half","pts","ptCount","segCount","plA","plB","plT","plHalf","w","segs","segSrcIdx","s","ha","hb","seg","makeSeg","closerSrcIdx","last","first","haCloser","hbCloser","closer","segBaseIdx","startSrc","endSrc","base","nxA","nyA","nxB","nyB","joinCount","j","firstBase","lastBase","lastSrc","ROUND_CAP_STEP_RAD","emitCap","sign","atEnd","dx","dy","cx","cy","nx","ny","ox","oy","lOut","endA","endB","endT","rOut","leftIdx","rightIdx","pivotIdx","startAngle","sweep","steps","stepAngle","prevIdx","i","ang","fx","fy","newIdx","bx","ax","by","ay","len","emitJoin","a","b","aBase","bBase","adx","ady","bdx","bdy","cross","onPositive","aOuterEnd","bOuterStart","cornerSrc","cornerA","cornerB","cornerT","halfAtCorner","taperA","taperB","aOX","aOY","bOX","bOY","apex","lineLineIntersect","apexIdx","jIdx","ROUND_STEP_RAD","emitRoundJoin","startX","startY","endX","endY","r","emitBevel","denom","t","bpx","apx","bpy","apy"],"sources":["../../../../src/features/paths/tessellate/stroke.ts"],"sourcesContent":["import type { Path } from '@weasel-js/core';\nimport type { ScreenLength, Stroke } from '@weasel-js/paint';\nimport { alignedStrokeRect, resolveScreenLength } from '@weasel-js/paint';\nimport { type Mesh, extractPolylines, type Polyline } from '@weasel-js/geom/tessellate';\nimport { splitForDash } from './dash';\nimport { populatePolylineWidths, type WidthScale } from './vertexWidths';\nimport { type InsetLength, trimInSpace } from './insets';\nimport {\n  type StrokeMetric, coordsOutOfMetric, rectIntoMetric, worldWidthInMetric, worldWidthInMetricAlongWorld,\n} from './metric';\n\n/** Options for stroke tessellation. */\nexport interface StrokeOptions {\n  flattenTolerance?: number;\n  /**\n   * Shorten each open subpath by this much at its start / end: a length in\n   * the ribbon's space, or one measured in a space of its own. Stroke markers\n   * use this so a filled head is not speared by its own line; the caller\n   * resolves the distance, because this layer knows nothing about the marker\n   * registry.\n   */\n  startInset?: InsetLength;\n  endInset?: InsetLength;\n  /**\n   * Build the ribbon in this metric's space and map it back out, so the\n   * transform it was derived from draws it at an exact screen width — see\n   * `./metric`. Width and dash are then lengths in that space; `vertexWidths`\n   * stay world widths. The path is flattened in world first, so the ribbon\n   * follows the same vertices its fill does.\n   */\n  metric?: StrokeMetric;\n}\n\nconst EMPTY_MESH: Mesh = {\n  vertices: new Float32Array(0),\n  indices: new Uint32Array(0),\n  anchorA: new Uint32Array(0),\n  anchorB: new Uint32Array(0),\n  anchorT: new Float32Array(0),\n};\n\ntype Cap = 'butt' | 'round' | 'square';\ntype Join = 'miter' | 'round' | 'bevel';\n\n/** Per-segment data the join code needs. */\ninterface Seg {\n  ax: number; ay: number;\n  bx: number; by: number;\n  /** Unit perpendicular (rotated 90° CCW from direction). */\n  nxUnit: number; nyUnit: number;\n  /** Half-width at the start (a) and end (b) endpoints. Equal for uniform\n   *  strokes; differ when the polyline carries per-point widths. */\n  halfA: number; halfB: number;\n  len: number;\n}\n\n/** Resolve a stroke width to world units. A number is already world units;\n *  `{ px }` is screen pixels divided by the accumulated scale, so it holds its\n *  on-screen thickness as the view zooms. */\nexport function resolveStrokeWidth(width: ScreenLength, scale: number): number {\n  return resolveScreenLength(width, scale);\n}\n\n/**\n * Build a triangle-mesh ribbon from a stroked Path.\n *\n * Supports:\n *   - cap: 'butt' | 'round' | 'square'\n *   - join: 'miter' | 'round' | 'bevel'\n *   - center alignment directly; RectPath inner/outer alignment via a\n *     pre-shifted rect; PolygonPath inner/outer alignment via stencil at the\n *     renderer level\n *   - dash splitting\n */\nexport function tessellateStroke(\n  path: Path,\n  stroke: Stroke,\n  opts: StrokeOptions = {},\n): Mesh {\n  // The renderer resolves `{ px }` against the accumulated transform before it\n  // gets here; a stroke that reaches the tessellator unresolved is read at\n  // scale 1, matching what the ribbon cache keys it under.\n  const width = resolveStrokeWidth(stroke.width ?? 1, 1);\n  if (width <= 0) return EMPTY_MESH;\n  const join: Join = stroke.join ?? 'miter';\n  const cap: Cap = stroke.cap ?? 'butt';\n  const align = stroke.align ?? 'center';\n  const miterLimit = stroke.miterLimit ?? DEFAULT_MITER_LIMIT;\n  const varyingThreshold = stroke.varyingWidthJoinThreshold ?? DEFAULT_VARYING_WIDTH_JOIN_THRESHOLD;\n\n  // RectPath fast path for inner/outer alignment: shift the rect by half-width\n  // so the ribbon's center alignment lands the stroke on the desired side of\n  // the original geometric edge. Arbitrary paths handle alignment via stencil\n  // clipping at the renderer level (not here).\n  const metric = opts.metric;\n  const rectInMetric = metric && path.kind === 'rect' ? rectIntoMetric(path, metric) : null;\n  let workingPath: Path = rectInMetric ?? path;\n  if (workingPath.kind === 'rect' && align !== 'center') {\n    const aligned = alignedStrokeRect(workingPath, align, width);\n    workingPath = {\n      kind: 'rect',\n      x: aligned.x,\n      y: aligned.y,\n      width: aligned.width,\n      height: aligned.height,\n    };\n  }\n\n  const polylines = extractPolylines(workingPath, opts);\n  // Per-point widths come first, in the space the points are in, so a trim\n  // interpolates them rather than re-reading an anchor's.\n  const vertexWidths = stroke.vertexWidths && stroke.vertexWidths.length > 0 ? stroke.vertexWidths : null;\n  const scale: WidthScale | undefined = !metric ? undefined\n    : rectInMetric ? (tx, ty) => worldWidthInMetric(metric, tx, ty)\n      : (ux, uy) => worldWidthInMetricAlongWorld(metric, ux, uy);\n  const dash = stroke.dash ?? [];\n  const verts: number[] = [];\n  const idx: number[] = [];\n  const anchorA: number[] = [];\n  const anchorB: number[] = [];\n  const anchorT: number[] = [];\n\n  // Trim before dashing, so the dash pattern fits the visible line rather than\n  // running off under a marker head.\n  const ribbonSpace = metric ?? null;\n  for (const pl of polylines) {\n    if (vertexWidths) populatePolylineWidths(pl, vertexWidths, width, scale);\n    const trimmed = trimInSpace(pl, rectInMetric ? ribbonSpace : null, ribbonSpace, opts.startInset, opts.endInset);\n    if (trimmed === null) continue;\n    const subs = dash.length > 0 ? splitForDash(trimmed, dash) : [trimmed];\n    for (const sub of subs) {\n      expandPolyline(sub, width, join, cap, miterLimit, varyingThreshold, verts, idx, anchorA, anchorB, anchorT);\n    }\n  }\n\n  const vertices = new Float32Array(verts);\n  if (metric) coordsOutOfMetric(vertices, metric);\n  return {\n    vertices,\n    indices: new Uint32Array(idx),\n    anchorA: new Uint32Array(anchorA),\n    anchorB: new Uint32Array(anchorB),\n    anchorT: new Float32Array(anchorT),\n  };\n}\n\nfunction expandPolyline(\n  pl: Polyline,\n  width: number,\n  join: Join,\n  cap: Cap,\n  miterLimit: number,\n  varyingThreshold: number,\n  verts: number[],\n  idx: number[],\n  anchorA: number[],\n  anchorB: number[],\n  anchorT: number[],\n): void {\n  const half = width / 2;\n  const pts = pl.points;\n  const ptCount = pts.length / 2;\n  const segCount = ptCount - 1;\n  if (segCount < 1) return;\n\n  // Anchor params per polyline point (set by extractPolylines; splitForDash\n  // re-derives them on dash boundaries). Default to A=B=0,t=0 if missing.\n  const plA = pl.anchorA ?? new Uint32Array(ptCount);\n  const plB = pl.anchorB ?? new Uint32Array(ptCount);\n  const plT = pl.anchorT ?? new Float32Array(ptCount);\n  // Per-point half-widths: derived from pl.widths if present, else the\n  // uniform half. Indexing matches `pts` (one entry per polyline point).\n  const plHalf = pl.widths\n    ? pl.widths.map((w) => w / 2)\n    : null;\n\n  const segs: Seg[] = [];\n  const segSrcIdx: number[] = [];  // For each seg, the polyline-point index of its start.\n  for (let s = 0; s < segCount; s++) {\n    const ha = plHalf ? plHalf[s] : half;\n    const hb = plHalf ? plHalf[s + 1] : half;\n    const seg = makeSeg(pts[s * 2], pts[s * 2 + 1], pts[(s + 1) * 2], pts[(s + 1) * 2 + 1], ha, hb);\n    if (seg) {\n      segs.push(seg);\n      segSrcIdx.push(s);\n    }\n  }\n  let closerSrcIdx = -1;\n  if (pl.closed && segs.length >= 1) {\n    const last = segs[segs.length - 1];\n    const first = segs[0];\n    // Closer: from last point back to point 0. Half-widths are the\n    // already-resolved ones at those source indices.\n    const haCloser = plHalf ? plHalf[ptCount - 1] : half;\n    const hbCloser = plHalf ? plHalf[0] : half;\n    const closer = makeSeg(last.bx, last.by, first.ax, first.ay, haCloser, hbCloser);\n    if (closer) {\n      segs.push(closer);\n      closerSrcIdx = ptCount - 1;  // start is the last polyline point.\n      segSrcIdx.push(closerSrcIdx);\n    }\n  }\n  if (segs.length === 0) return;\n\n  // Emit ribbon quads. For each emitted vertex, record the (A, B, t) of the\n  // source polyline point that the geometric vertex sits at. Per-end\n  // half-widths produce trapezoidal segments when the stroke tapers.\n  const segBaseIdx: number[] = [];\n  for (let s = 0; s < segs.length; s++) {\n    const seg = segs[s];\n    const startSrc = segSrcIdx[s];\n    // End-source index for the seg. For closer (closed-path wraparound), end is point 0.\n    const endSrc = (s === segs.length - 1 && pl.closed && closerSrcIdx >= 0) ? 0 : startSrc + 1;\n    const base = verts.length / 2;\n    segBaseIdx.push(base);\n    const nxA = seg.nxUnit * seg.halfA, nyA = seg.nyUnit * seg.halfA;\n    const nxB = seg.nxUnit * seg.halfB, nyB = seg.nyUnit * seg.halfB;\n    // L0, R0 — at seg.ax/ay with start half-width.\n    verts.push(seg.ax + nxA, seg.ay + nyA);\n    anchorA.push(plA[startSrc]); anchorB.push(plB[startSrc]); anchorT.push(plT[startSrc]);\n    verts.push(seg.ax - nxA, seg.ay - nyA);\n    anchorA.push(plA[startSrc]); anchorB.push(plB[startSrc]); anchorT.push(plT[startSrc]);\n    // L1, R1 — at seg.bx/by with end half-width.\n    verts.push(seg.bx + nxB, seg.by + nyB);\n    anchorA.push(plA[endSrc]); anchorB.push(plB[endSrc]); anchorT.push(plT[endSrc]);\n    verts.push(seg.bx - nxB, seg.by - nyB);\n    anchorA.push(plA[endSrc]); anchorB.push(plB[endSrc]); anchorT.push(plT[endSrc]);\n    idx.push(base, base + 1, base + 2, base + 1, base + 3, base + 2);\n  }\n\n  // Joins between consecutive segments.\n  const joinCount = pl.closed ? segs.length : segs.length - 1;\n  for (let j = 0; j < joinCount; j++) {\n    emitJoin(segs, segBaseIdx, j, join, miterLimit, varyingThreshold, verts, idx, anchorA, anchorB, anchorT, segSrcIdx, plA, plB, plT);\n  }\n\n  // Caps. Use the local half-width at the cap end (seg.halfA at start, seg.halfB at end).\n  if (!pl.closed && cap !== 'butt') {\n    const first = segs[0];\n    const firstBase = segBaseIdx[0];\n    emitCap(first, firstBase + 0, firstBase + 1, false, first.halfA, cap, verts, idx, anchorA, anchorB, anchorT, plA[0], plB[0], plT[0]);\n\n    const last = segs[segs.length - 1];\n    const lastBase = segBaseIdx[segs.length - 1];\n    const lastSrc = segSrcIdx[segs.length - 1] + 1;\n    emitCap(last, lastBase + 2, lastBase + 3, true, last.halfB, cap, verts, idx, anchorA, anchorB, anchorT, plA[lastSrc], plB[lastSrc], plT[lastSrc]);\n  }\n}\n\nconst ROUND_CAP_STEP_RAD = (10 * Math.PI) / 180;\n\n/**\n * Emit a cap at one end of a segment. `leftIdx`/`rightIdx` are the buffer\n * indices of the L (perpendicular +n) and R (perpendicular -n) vertices at\n * the segment endpoint where the cap attaches. `atEnd` chooses which end of\n * the segment to extend from (and which cap-direction sign to use).\n */\nfunction emitCap(\n  seg: Seg, leftIdx: number, rightIdx: number, atEnd: boolean,\n  half: number, cap: Cap,\n  verts: number[], idx: number[],\n  anchorA: number[], anchorB: number[], anchorT: number[],\n  endA: number, endB: number, endT: number,\n): void {\n  // Outward direction = forward at end, backward at start.\n  const sign = atEnd ? 1 : -1;\n  const dx = (seg.bx - seg.ax) / seg.len * sign;\n  const dy = (seg.by - seg.ay) / seg.len * sign;\n  const cx = atEnd ? seg.bx : seg.ax;\n  const cy = atEnd ? seg.by : seg.ay;\n\n  // Perpendicular offset at this cap end uses the local half-width\n  // (varies along the polyline when vertexWidths is set).\n  const nx = seg.nxUnit * half;\n  const ny = seg.nyUnit * half;\n\n  if (cap === 'square') {\n    const ox = cx + dx * half;\n    const oy = cy + dy * half;\n    const lOut = verts.length / 2;\n    verts.push(ox + nx, oy + ny);\n    anchorA.push(endA); anchorB.push(endB); anchorT.push(endT);\n    const rOut = verts.length / 2;\n    verts.push(ox - nx, oy - ny);\n    anchorA.push(endA); anchorB.push(endB); anchorT.push(endT);\n    // Two triangles forming the cap rectangle. Wind so triangles are CCW\n    // viewed from the front; orientation symmetric for start vs. end caps.\n    if (atEnd) {\n      idx.push(leftIdx, lOut, rOut, leftIdx, rOut, rightIdx);\n    } else {\n      idx.push(leftIdx, rOut, lOut, leftIdx, rightIdx, rOut);\n    }\n    return;\n  }\n\n  if (cap === 'round') {\n    // Pivot vertex at the endpoint center; fan from L through the outward\n    // 180° arc to R.\n    const pivotIdx = verts.length / 2;\n    verts.push(cx, cy);\n    anchorA.push(endA); anchorB.push(endB); anchorT.push(endT);\n\n    // Starting angle: direction from pivot to L (= +n direction).\n    const startAngle = Math.atan2(ny, nx);\n    // Sweep 180° toward the outward direction. The outward unit is (dx, dy);\n    // we rotate from +n to -n the \"outward\" way. The dot product of (dx, dy)\n    // with the perpendicular tells us which way around the arc to go.\n    // A start-cap (sign = -1) sweeps backward; end-cap (sign = +1) sweeps forward.\n    const sweep = atEnd ? -Math.PI : Math.PI;\n    const steps = Math.max(1, Math.ceil(Math.abs(sweep) / ROUND_CAP_STEP_RAD));\n    const stepAngle = sweep / steps;\n\n    let prevIdx = leftIdx;\n    for (let i = 1; i < steps; i++) {\n      const ang = startAngle + i * stepAngle;\n      const fx = cx + Math.cos(ang) * half;\n      const fy = cy + Math.sin(ang) * half;\n      const newIdx = verts.length / 2;\n      verts.push(fx, fy);\n      anchorA.push(endA); anchorB.push(endB); anchorT.push(endT);\n      if (atEnd) idx.push(prevIdx, newIdx, pivotIdx);\n      else       idx.push(prevIdx, pivotIdx, newIdx);\n      prevIdx = newIdx;\n    }\n    if (atEnd) idx.push(prevIdx, rightIdx, pivotIdx);\n    else       idx.push(prevIdx, pivotIdx, rightIdx);\n  }\n}\n\nfunction makeSeg(ax: number, ay: number, bx: number, by: number, halfA: number, halfB: number): Seg | null {\n  const dx = bx - ax, dy = by - ay;\n  const len = Math.hypot(dx, dy);\n  if (len === 0) return null;\n  return {\n    ax, ay, bx, by,\n    nxUnit: -dy / len, nyUnit: dx / len,\n    halfA, halfB,\n    len,\n  };\n}\n\n/**\n * Miter limit for a stroke that does not set one. SVG's default, not\n * Canvas2D's 10, because the serializer omits the attribute when the field is\n * unset — so a kit stroke exported to SVG is read back by every other renderer\n * as 4, and a kit that used 10 would disagree with its own export. 10 also\n * lets an acute corner throw a spike four times the half-width, which is what\n * a glyph outline's sharpest vertices do.\n */\nconst DEFAULT_MITER_LIMIT = 4;\n/** Default `Stroke.varyingWidthJoinThreshold`. */\nconst DEFAULT_VARYING_WIDTH_JOIN_THRESHOLD = 1.5;\n\nfunction emitJoin(\n  segs: Seg[], segBaseIdx: number[], j: number, join: Join,\n  miterLimit: number,\n  varyingThreshold: number,\n  verts: number[], idx: number[],\n  anchorA: number[], anchorB: number[], anchorT: number[],\n  segSrcIdx: number[],\n  plA: Uint32Array, plB: Uint32Array, plT: Float32Array,\n): void {\n  const a = segs[j];\n  const b = segs[(j + 1) % segs.length];\n  const aBase = segBaseIdx[j];\n  const bBase = segBaseIdx[(j + 1) % segs.length];\n\n  const adx = a.bx - a.ax, ady = a.by - a.ay;\n  const bdx = b.bx - b.ax, bdy = b.by - b.ay;\n  const cross = adx * bdy - ady * bdx;\n  if (cross === 0) return;                                       // straight (collinear), no wedge\n  const onPositive = cross > 0;\n\n  const aOuterEnd = onPositive ? aBase + 3 : aBase + 2;\n  const bOuterStart = onPositive ? bBase + 1 : bBase + 0;\n\n  // The corner of join `j` is the start of segment `j+1` (which is the END of\n  // segment `j` — they share the same polyline point). For the wraparound join\n  // on a closed polyline, j+1 wraps to segment 0 whose start is the closer\n  // segment's endpoint, which is polyline point 0.\n  const nextSeg = (j + 1) % segs.length;\n  // The corner anchor is the start of the next segment (shared endpoint).\n  // For a closed path's final join, nextSeg wraps to 0, whose start is\n  // polyline point 0 — correct.\n  const cornerSrc = segSrcIdx[nextSeg];\n  const cornerA = plA[cornerSrc];\n  const cornerB = plB[cornerSrc];\n  const cornerT = plT[cornerSrc];\n  // The two adjoining half-widths agree at the shared corner (a.halfB ===\n  // b.halfA for a single-contour polyline), so use either for miter-limit\n  // sizing. Force bevel when either adjacent segment itself tapers by\n  // more than `varyingThreshold` — the miter apex math computes against\n  // outer edges parallel to the segment direction, an assumption that\n  // breaks on tapered trapezoids (outer edges fan in/out).\n  const halfAtCorner = a.halfB;\n  const taperA = Math.max(a.halfA, a.halfB) / Math.max(1e-9, Math.min(a.halfA, a.halfB));\n  const taperB = Math.max(b.halfA, b.halfB) / Math.max(1e-9, Math.min(b.halfA, b.halfB));\n  const forceBevelForVarying = taperA > varyingThreshold || taperB > varyingThreshold;\n\n  if (join === 'bevel' || forceBevelForVarying) {\n    emitBevel(a, aOuterEnd, bOuterStart, onPositive, verts, idx, anchorA, anchorB, anchorT, cornerA, cornerB, cornerT);\n    return;\n  }\n\n  if (join === 'miter') {\n    // Compute apex: intersection of A's outer edge extended forward and\n    // B's outer edge extended backward. If miter length > MITER_LIMIT * half,\n    // fall back to bevel.\n    const aOX = verts[aOuterEnd * 2], aOY = verts[aOuterEnd * 2 + 1];\n    const bOX = verts[bOuterStart * 2], bOY = verts[bOuterStart * 2 + 1];\n    const apex = lineLineIntersect(aOX, aOY, adx, ady, bOX, bOY, -bdx, -bdy);\n    if (!apex) {\n      emitBevel(a, aOuterEnd, bOuterStart, onPositive, verts, idx, anchorA, anchorB, anchorT, cornerA, cornerB, cornerT);\n      return;\n    }\n    const miterLen = Math.hypot(apex[0] - a.bx, apex[1] - a.by);\n    if (miterLen > miterLimit * halfAtCorner) {\n      emitBevel(a, aOuterEnd, bOuterStart, onPositive, verts, idx, anchorA, anchorB, anchorT, cornerA, cornerB, cornerT);\n      return;\n    }\n    // A miter join's outer face is a kite quadrilateral with vertices\n    // (R1, apex, R0, J) — covered by TWO triangles. The bevel inner half\n    // (R1, R0, J) fills the area between the joint corner and the diagonal\n    // hypotenuse R0-R1; the outer extension (R1, apex, R0) fills from the\n    // hypotenuse to the apex point. Without the bevel half, an \"inverted\n    // triangle\" gap opens at every miter corner.\n    const apexIdx = verts.length / 2;\n    verts.push(apex[0], apex[1]);\n    anchorA.push(cornerA); anchorB.push(cornerB); anchorT.push(cornerT);\n    const jIdx = verts.length / 2;\n    verts.push(a.bx, a.by);\n    anchorA.push(cornerA); anchorB.push(cornerB); anchorT.push(cornerT);\n    if (onPositive) {\n      idx.push(aOuterEnd, apexIdx, bOuterStart);\n      idx.push(aOuterEnd, bOuterStart, jIdx);\n    } else {\n      idx.push(aOuterEnd, bOuterStart, apexIdx);\n      idx.push(aOuterEnd, jIdx, bOuterStart);\n    }\n    return;\n  }\n\n  if (join === 'round') {\n    emitRoundJoin(a, aOuterEnd, bOuterStart, onPositive, verts, idx, anchorA, anchorB, anchorT, cornerA, cornerB, cornerT);\n    return;\n  }\n}\n\nconst ROUND_STEP_RAD = (10 * Math.PI) / 180;   // ~10° per fan triangle\n\nfunction emitRoundJoin(\n  a: Seg, aOuterEnd: number, bOuterStart: number, onPositive: boolean,\n  verts: number[], idx: number[],\n  anchorA: number[], anchorB: number[], anchorT: number[],\n  cornerA: number, cornerB: number, cornerT: number,\n): void {\n  // Pivot = joint center; emit fresh vertex.\n  const cx = a.bx, cy = a.by;\n  const pivotIdx = verts.length / 2;\n  verts.push(cx, cy);\n  anchorA.push(cornerA); anchorB.push(cornerB); anchorT.push(cornerT);\n\n  const startX = verts[aOuterEnd * 2] - cx;\n  const startY = verts[aOuterEnd * 2 + 1] - cy;\n  const endX = verts[bOuterStart * 2] - cx;\n  const endY = verts[bOuterStart * 2 + 1] - cy;\n  const r = Math.hypot(startX, startY);\n\n  const startAngle = Math.atan2(startY, startX);\n  const endAngle = Math.atan2(endY, endX);\n  // Outer-side sweep: for CCW turns (cross > 0, onPositive true) outer is on\n  // the -n side and the arc sweeps from R1 (south of joint) clockwise to R0\n  // (east of joint) — i.e., negative sweep. For CW turns, sweep is positive.\n  // Pick the SHORT arc that crosses the outer wedge. For onPositive=true\n  // (CW turn in screen coords with y-down), the outer wedge sits where the\n  // natural sweep is positive; for onPositive=false, where it is negative.\n  // If the natural sweep has the wrong sign, wrap by ±2π.\n  let sweep = endAngle - startAngle;\n  if (onPositive && sweep < 0) sweep += 2 * Math.PI;\n  else if (!onPositive && sweep > 0) sweep -= 2 * Math.PI;\n\n  const steps = Math.max(1, Math.ceil(Math.abs(sweep) / ROUND_STEP_RAD));\n  const stepAngle = sweep / steps;\n\n  let prevIdx = aOuterEnd;\n  for (let i = 1; i < steps; i++) {\n    const ang = startAngle + i * stepAngle;\n    const fx = cx + Math.cos(ang) * r;\n    const fy = cy + Math.sin(ang) * r;\n    const newIdx = verts.length / 2;\n    verts.push(fx, fy);\n    anchorA.push(cornerA); anchorB.push(cornerB); anchorT.push(cornerT);\n    if (onPositive) idx.push(prevIdx, pivotIdx, newIdx);\n    else            idx.push(prevIdx, newIdx, pivotIdx);\n    prevIdx = newIdx;\n  }\n  if (onPositive) idx.push(prevIdx, pivotIdx, bOuterStart);\n  else            idx.push(prevIdx, bOuterStart, pivotIdx);\n}\n\nfunction emitBevel(\n  a: Seg, aOuterEnd: number, bOuterStart: number, onPositive: boolean,\n  verts: number[], idx: number[],\n  anchorA: number[], anchorB: number[], anchorT: number[],\n  cornerA: number, cornerB: number, cornerT: number,\n): void {\n  const jIdx = verts.length / 2;\n  verts.push(a.bx, a.by);\n  anchorA.push(cornerA); anchorB.push(cornerB); anchorT.push(cornerT);\n  if (onPositive) idx.push(aOuterEnd, jIdx, bOuterStart);\n  else            idx.push(aOuterEnd, bOuterStart, jIdx);\n}\n\n/**\n * Solve for the intersection of line A (point ap, direction ad) with line B\n * (point bp, direction bd). Returns null if parallel or near-parallel.\n */\nfunction lineLineIntersect(\n  apx: number, apy: number, adx: number, ady: number,\n  bpx: number, bpy: number, bdx: number, bdy: number,\n): [number, number] | null {\n  const denom = adx * bdy - ady * bdx;\n  if (Math.abs(denom) < 1e-9) return null;\n  const t = ((bpx - apx) * bdy - (bpy - apy) * bdx) / denom;\n  return [apx + t * adx, apy + t * ady];\n}\n"],"mappings":"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"}

package/dist/features/paths/tessellate/vertexWidths.js

@@ -1,32 +0,0 @@
-//#region src/features/paths/tessellate/vertexWidths.ts
-function e(e, n, r, i) {
-	let a = e.points.length / 2;
-	if (a === 0) return;
-	let o = e.anchorA ?? new Uint32Array(a), s = e.anchorB ?? new Uint32Array(a), c = e.anchorT ?? new Float32Array(a), l = new Float32Array(a), u = 1, d = (e) => {
-		let t = n[e];
-		return typeof t == "number" && isFinite(t) && t > 0 ? t * u : r;
-	};
-	for (let n = 0; n < a; n++) {
-		i && (u = t(e, n, i));
-		let r = o[n], a = s[n], f = c[n];
-		if (r === a) l[n] = d(r);
-		else {
-			let e = d(r), t = d(a);
-			l[n] = e + (t - e) * f;
-		}
-	}
-	e.widths = l;
-}
-function t(e, t, n) {
-	let r = e.points, i = r.length / 2, a = 0, o = 0, s = (e, t) => {
-		let n = r[t * 2] - r[e * 2], i = r[t * 2 + 1] - r[e * 2 + 1], s = Math.hypot(n, i);
-		s > 0 && (a += n / s, o += i / s);
-	};
-	t > 0 ? s(t - 1, t) : e.closed && i > 1 && s(i - 1, 0), t < i - 1 ? s(t, t + 1) : e.closed && i > 1 && s(i - 1, 0);
-	let c = Math.hypot(a, o);
-	return c > 0 ? n(a / c, o / c) : 1;
-}
-//#endregion
-export { e as populatePolylineWidths };
-
-//# sourceMappingURL=vertexWidths.js.map

package/dist/features/paths/tessellate/vertexWidths.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"vertexWidths.js","names":["populatePolylineWidths","ptCount","pl","aA","aB","aT","widths","k","read","v","vertexWidths","i","fallbackWidth","scale","scaleAt","a","b","t","wa","wb","pts","n","tx","ty","add","dx","to","from","dy","len"],"sources":["../../../../src/features/paths/tessellate/vertexWidths.ts"],"sourcesContent":["import type { Polyline } from '@weasel-js/geom/tessellate';\n\n/** What one unit of a `vertexWidths` entry measures across the line at a\n *  point whose unit tangent, in the polyline's own space, is `(tx, ty)`. */\nexport type WidthScale = (tx: number, ty: number) => number;\n\n/** Fill `pl.widths` by interpolating `vertexWidths` across each point's\n *  (anchorA, anchorB, anchorT). Anchor-aligned points (A === B) read the\n *  anchor's value directly. Out-of-range / non-finite anchor entries fall\n *  back to `fallbackWidth`. Given `scale`, each entry is scaled at the point\n *  that reads it, and the fallback is not. */\nexport function populatePolylineWidths(\n  pl: Polyline,\n  vertexWidths: number[],\n  fallbackWidth: number,\n  scale?: WidthScale,\n): void {\n  const ptCount = pl.points.length / 2;\n  if (ptCount === 0) return;\n  const aA = pl.anchorA ?? new Uint32Array(ptCount);\n  const aB = pl.anchorB ?? new Uint32Array(ptCount);\n  const aT = pl.anchorT ?? new Float32Array(ptCount);\n  const widths = new Float32Array(ptCount);\n  let k = 1;\n  const read = (i: number): number => {\n    const v = vertexWidths[i];\n    return typeof v === 'number' && isFinite(v) && v > 0 ? v * k : fallbackWidth;\n  };\n  for (let i = 0; i < ptCount; i++) {\n    if (scale) k = scaleAt(pl, i, scale);\n    const a = aA[i], b = aB[i], t = aT[i];\n    if (a === b) {\n      widths[i] = read(a);\n    } else {\n      const wa = read(a);\n      const wb = read(b);\n      widths[i] = wa + (wb - wa) * t;\n    }\n  }\n  pl.widths = widths;\n}\n\n/** `scale` along the line's direction at point `i`: the bisector of the\n *  segments either side, or the one segment at an open end. */\nfunction scaleAt(pl: Polyline, i: number, scale: WidthScale): number {\n  const pts = pl.points;\n  const n = pts.length / 2;\n  let tx = 0, ty = 0;\n  const add = (from: number, to: number) => {\n    const dx = pts[to * 2] - pts[from * 2], dy = pts[to * 2 + 1] - pts[from * 2 + 1];\n    const len = Math.hypot(dx, dy);\n    if (len > 0) { tx += dx / len; ty += dy / len; }\n  };\n  if (i > 0) add(i - 1, i);\n  else if (pl.closed && n > 1) add(n - 1, 0);\n  if (i < n - 1) add(i, i + 1);\n  else if (pl.closed && n > 1) add(n - 1, 0);\n  const len = Math.hypot(tx, ty);\n  return len > 0 ? scale(tx / len, ty / len) : 1;\n}\n"],"mappings":";AAWA,SAAgBA,EACd,GACA,GACA,GACA,GACM;CACN,IAAMC,IAAUC,EAAG,OAAO,SAAS;CACnC,IAAID,MAAY,GAAG;CACnB,IAAME,IAAKD,EAAG,WAAW,IAAI,YAAYD,CAAO,GAC1CG,IAAKF,EAAG,WAAW,IAAI,YAAYD,CAAO,GAC1CI,IAAKH,EAAG,WAAW,IAAI,aAAaD,CAAO,GAC3CK,IAAS,IAAI,aAAaL,CAAO,GACnCM,IAAI,GACFC,KAAQ,MAAsB;EAClC,IAAMC,IAAIC,EAAaC;EACvB,OAAO,OAAOF,KAAM,YAAY,SAASA,CAAC,KAAKA,IAAI,IAAIA,IAAIF,IAAIK;CACjE;CACA,KAAK,IAAID,IAAI,GAAGA,IAAIV,GAAS,KAAK;EAChC,AAAIY,MAAO,IAAIC,EAAQZ,GAAIS,GAAGE,CAAK;EACnC,IAAME,IAAIZ,EAAGQ,IAAIK,IAAIZ,EAAGO,IAAIM,IAAIZ,EAAGM;EACnC,IAAII,MAAMC,GACR,EAAOL,KAAKH,EAAKO,CAAC;OACb;GACL,IAAMG,IAAKV,EAAKO,CAAC,GACXI,IAAKX,EAAKQ,CAAC;GACjB,EAAOL,KAAKO,KAAMC,IAAKD,KAAMD;EAC/B;CACF;CACA,EAAG,SAASX;AACd;AAIA,SAASQ,EAAQ,GAAc,GAAW,GAA2B;CACnE,IAAMM,IAAMlB,EAAG,QACTmB,IAAID,EAAI,SAAS,GACnBE,IAAK,GAAGC,IAAK,GACXC,KAAO,GAAc,MAAe;EACxC,IAAMC,IAAKL,EAAIM,IAAK,KAAKN,EAAIO,IAAO,IAAIC,IAAKR,EAAIM,IAAK,IAAI,KAAKN,EAAIO,IAAO,IAAI,IACxEE,IAAM,KAAK,MAAMJ,GAAIG,CAAE;EAC7B,AAAIC,IAAM,MAAK,KAAMJ,IAAKI,GAAK,KAAMD,IAAKC;CAC5C;CAGA,AAFIlB,IAAI,IAAGa,EAAIb,IAAI,GAAGA,CAAC,IACdT,EAAG,UAAUmB,IAAI,KAAGG,EAAIH,IAAI,GAAG,CAAC,GACrCV,IAAIU,IAAI,IAAGG,EAAIb,GAAGA,IAAI,CAAC,IAClBT,EAAG,UAAUmB,IAAI,KAAGG,EAAIH,IAAI,GAAG,CAAC;CACzC,IAAMQ,IAAM,KAAK,MAAMP,GAAIC,CAAE;CAC7B,OAAOM,IAAM,IAAIhB,EAAMS,IAAKO,GAAKN,IAAKM,CAAG,IAAI;AAC/C"}

package/dist/features/patterns/index.js

@@ -1,23 +0,0 @@
-import { registerTexture as e } from "../../renderer/textures/registerTexture.js";
-//#region src/features/patterns/index.ts
-function t(t) {
-	let n;
-	try {
-		n = new OffscreenCanvas(t.size, t.size);
-	} catch {
-		if (typeof document > "u") return null;
-		let e = document.createElement("canvas");
-		e.width = t.size, e.height = t.size, n = e;
-	}
-	let r = n.getContext("2d");
-	if (!r) return null;
-	t.draw(r, t.size);
-	let i;
-	if (typeof n.transferToImageBitmap == "function") i = n.transferToImageBitmap();
-	else return null;
-	return e(i);
-}
-//#endregion
-export { t as createTilePattern };
-
-//# sourceMappingURL=index.js.map

package/dist/features/patterns/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":["createTilePattern","off","opts","c","oc","bitmap","registerTexture"],"sources":["../../../src/features/patterns/index.ts"],"sourcesContent":["/**\n * Tile-pattern primitive — a small helper for building repeating texture\n * tiles from a draw callback. The result plugs into a `FillStyle` of\n * `{ fill: 'pattern', pattern }` (see `@weasel-js/paint`).\n *\n * GL-backed: the tile is rendered to an `OffscreenCanvas` (with a 2D fallback\n * to a regular `<canvas>` for environments without `OffscreenCanvas`),\n * converted to an `ImageBitmap`, and registered with `registerTexture()`.\n * The returned `TextureHandle` is what `FillStyle.pattern` accepts.\n *\n * For ready-to-use named patterns (hatch, crosshatch, dots, chunks),\n * see the `@weasel-js/core/patterns-builtin` subpath.\n */\n\nimport { registerTexture } from '../../renderer/textures/registerTexture';\nimport type { TextureHandle } from '../../renderer/textures/registerTexture';\n\n/** Options for `createTilePattern`. */\nexport interface TilePatternOpts {\n  /** Edge length (in pixels) of the square offscreen tile. */\n  size: number;\n  /** FillStyle one tile at integer-pixel coordinates `(0, 0) .. (size, size)`. */\n  draw: (oc: CanvasRenderingContext2D, size: number) => void;\n}\n\n/**\n * Render a single tile to an offscreen canvas and register it as a GL\n * texture, returning a `TextureHandle` you can wrap in a `FillStyle` of\n * `{ fill: 'pattern', pattern }`. Returns `null` only when an\n * `OffscreenCanvas`/2D context can't be acquired (very rare; same fallback\n * semantics as the prior `CanvasPattern`-based implementation).\n */\nexport function createTilePattern(opts: TilePatternOpts): TextureHandle | null {\n  // Prefer OffscreenCanvas; fall back to <canvas> for environments without it\n  // (tests in jsdom may need that fallback — try OffscreenCanvas first).\n  let off: OffscreenCanvas | HTMLCanvasElement;\n  try {\n    off = new OffscreenCanvas(opts.size, opts.size);\n  } catch {\n    if (typeof document === 'undefined') return null;\n    const c = document.createElement('canvas');\n    c.width = opts.size;\n    c.height = opts.size;\n    off = c;\n  }\n  const oc = off.getContext('2d') as CanvasRenderingContext2D | null;\n  if (!oc) return null;\n  opts.draw(oc, opts.size);\n\n  // Convert to ImageBitmap so registerTexture can store it.\n  // OffscreenCanvas.transferToImageBitmap() is the fast path; the\n  // synchronous path requires OffscreenCanvas. If we got here without it,\n  // the env doesn't support OffscreenCanvas — fail gracefully.\n  let bitmap: ImageBitmap;\n  if (typeof (off as OffscreenCanvas).transferToImageBitmap === 'function') {\n    bitmap = (off as OffscreenCanvas).transferToImageBitmap();\n  } else {\n    return null;\n  }\n  return registerTexture(bitmap);\n}\n"],"mappings":";;AAgCA,SAAgBA,EAAkB,GAA6C;CAG7E,IAAIC;CACJ,IAAI;EACF,IAAM,IAAI,gBAAgBC,EAAK,MAAMA,EAAK,IAAI;CAChD,QAAQ;EACN,IAAI,OAAO,WAAa,KAAa,OAAO;EAC5C,IAAMC,IAAI,SAAS,cAAc,QAAQ;EAGzC,AAFA,EAAE,QAAQD,EAAK,MACf,EAAE,SAASA,EAAK,MAChB,IAAMC;CACR;CACA,IAAMC,IAAKH,EAAI,WAAW,IAAI;CAC9B,IAAI,CAACG,GAAI,OAAO;CAChB,EAAK,KAAKA,GAAIF,EAAK,IAAI;CAMvB,IAAIG;CACJ,IAAI,OAAQJ,EAAwB,yBAA0B,YAC5D,IAAUA,EAAwB,sBAAsB;MAExD,OAAO;CAET,OAAOK,EAAgBD,CAAM;AAC/B"}

package/dist/features/patterns/patterns-builtin.js

@@ -1,38 +0,0 @@
-import { drawTileShapes as e, tileGeometry as t, tileSize as n } from "./tileGeometry.js";
-import { createTilePattern as r } from "./index.js";
-//#region src/features/patterns/patterns-builtin.ts
-function i(i) {
-	let a = t(i);
-	return r({
-		size: n(i),
-		draw: (t) => e(t, a)
-	});
-}
-function a(e) {
-	return i({
-		tile: "hatch",
-		...e
-	});
-}
-function o(e) {
-	return i({
-		tile: "crosshatch",
-		...e
-	});
-}
-function s(e) {
-	return i({
-		tile: "dots",
-		...e
-	});
-}
-function c(e) {
-	return i({
-		tile: "chunks",
-		...e
-	});
-}
-//#endregion
-export { c as chunks, o as crosshatch, s as dots, e as drawTileShapes, a as hatch, t as tileGeometry, n as tileSize };
-
-//# sourceMappingURL=patterns-builtin.js.map

package/dist/features/patterns/patterns-builtin.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"patterns-builtin.js","names":["build","geometry","tileGeometry","spec","createTilePattern","tileSize","drawTileShapes","oc","hatch","params","crosshatch","dots","chunks"],"sources":["../../../src/features/patterns/patterns-builtin.ts"],"sourcesContent":["/**\n * Built-in pattern factories — generic line/dot/scatter textures. Each\n * returns a `TextureHandle` you can wrap in a `FillStyle` of\n * `{ fill: 'pattern', pattern }` and pass to anything that accepts a `FillStyle`\n * (`FillStyle`-aware layers, path fills, etc.).\n * Imported from a subpath so consumers that ship their own catalog can\n * avoid the bundle cost.\n *\n * All factories require an explicit `color` (and `bg` for `chunks`). No\n * defaults are baked in — the caller's design system is the source of truth\n * for palette decisions.\n *\n * Each is a thin wrapper over `tileGeometry`, which describes the tile as\n * shapes so `@weasel-js/svg` can emit the same tile as a `<pattern>`.\n * Prefer naming a tile in a `TilePatternSpec` over calling these directly —\n * a spec serializes, a `TextureHandle` does not.\n */\n\nexport { tileGeometry, tileSize, drawTileShapes } from './tileGeometry';\nexport type { TileShape, TileGeometry } from './tileGeometry';\n\nimport { createTilePattern } from '.';\nimport { tileGeometry, drawTileShapes, tileSize } from './tileGeometry';\nimport type { TilePatternSpec } from '@weasel-js/paint';\nimport type { TextureHandle } from '../../renderer/textures/registerTexture';\n\nfunction build(spec: TilePatternSpec): TextureHandle | null {\n  const geometry = tileGeometry(spec);\n  return createTilePattern({\n    size: tileSize(spec),\n    draw: (oc) => drawTileShapes(oc, geometry),\n  });\n}\n\n/** Diagonal hatch (forward slash). */\nexport interface HatchParams {\n  color: string;\n  size?: number;\n  lineWidth?: number;\n}\n\n/** Build a diagonal-hatch pattern texture. */\nexport function hatch(params: HatchParams): TextureHandle | null {\n  return build({ tile: 'hatch', ...params });\n}\n\n/** Diagonal hatch in both directions. */\nexport interface CrosshatchParams {\n  color: string;\n  size?: number;\n  lineWidth?: number;\n}\n\n/** Build a crosshatch pattern texture. */\nexport function crosshatch(params: CrosshatchParams): TextureHandle | null {\n  return build({ tile: 'crosshatch', ...params });\n}\n\n/** Regular grid of filled dots. */\nexport interface DotsParams {\n  color: string;\n  size?: number;\n  radius?: number;\n}\n\n/** Build a dot-grid pattern texture. */\nexport function dots(params: DotsParams): TextureHandle | null {\n  return build({ tile: 'dots', ...params });\n}\n\n/**\n * Random scatter of small ellipses on top of a solid background. Driven by a\n * seeded PRNG so the same `seed` produces a deterministic tile.\n *\n * Note: the `bg` field is optional — omit it for a transparent background\n * (the scatter shapes draw directly onto whatever sits beneath the overlay).\n */\nexport interface ChunksParams {\n  color: string;\n  bg?: string;\n  size?: number;\n  /** Coverage: `chunks * chunkSize²` per `size²` tile. Range ~[0, 1]. */\n  density?: number;\n  chunkSize?: number;\n  seed?: number;\n}\n\n/** Build a seeded random-scatter pattern texture. */\nexport function chunks(params: ChunksParams): TextureHandle | null {\n  return build({ tile: 'chunks', ...params });\n}\n"],"mappings":";;;AA0BA,SAASA,EAAM,GAA6C;CAC1D,IAAMC,IAAWC,EAAaC,CAAI;CAClC,OAAOC,EAAkB;EACvB,MAAMC,EAASF,CAAI;EACnB,OAAO,MAAOG,EAAeC,GAAIN,CAAQ;CAC3C,CAAC;AACH;AAUA,SAAgBO,EAAM,GAA2C;CAC/D,OAAOR,EAAM;EAAE,MAAM;EAAS,GAAGS;CAAO,CAAC;AAC3C;AAUA,SAAgBC,EAAW,GAAgD;CACzE,OAAOV,EAAM;EAAE,MAAM;EAAc,GAAGS;CAAO,CAAC;AAChD;AAUA,SAAgBE,EAAK,GAA0C;CAC7D,OAAOX,EAAM;EAAE,MAAM;EAAQ,GAAGS;CAAO,CAAC;AAC1C;AAoBA,SAAgBG,EAAO,GAA4C;CACjE,OAAOZ,EAAM;EAAE,MAAM;EAAU,GAAGS;CAAO,CAAC;AAC5C"}

package/dist/features/patterns/resolveSpec.js

@@ -1,57 +0,0 @@
-import { chunks as e, crosshatch as t, dots as n, hatch as r } from "./patterns-builtin.js";
-//#region src/features/patterns/resolveSpec.ts
-var i = /* @__PURE__ */ new Map();
-function a(e) {
-	let t = Object.keys(e).sort(), n = e;
-	return t.map((e) => `${e}=${String(n[e])}`).join("&");
-}
-function o(e) {
-	let t = a(e), n = i.get(t);
-	if (n !== void 0) return n;
-	let r = s(e);
-	return i.set(t, r), r;
-}
-function s(i) {
-	let { color: a, size: o } = i;
-	switch (i.tile) {
-		case "hatch": return r({
-			color: a,
-			size: o,
-			lineWidth: i.lineWidth
-		});
-		case "crosshatch": return t({
-			color: a,
-			size: o,
-			lineWidth: i.lineWidth
-		});
-		case "dots": return n({
-			color: a,
-			size: o,
-			radius: i.radius
-		});
-		case "chunks": return e({
-			color: a,
-			size: o,
-			bg: i.bg,
-			density: i.density,
-			chunkSize: i.chunkSize,
-			seed: i.seed
-		});
-		default: return null;
-	}
-}
-function c(e) {
-	return "tile" in e;
-}
-function l(e) {
-	if (e.fill !== "pattern" || !c(e.pattern)) return e;
-	let t = o(e.pattern);
-	return t ? {
-		...e,
-		pattern: t
-	} : null;
-}
-//#endregion
-export { c as isPatternSpec, l as resolveFillPattern, o as resolvePatternSpec };
-
-//# sourceMappingURL=resolveSpec.js.map

package/dist/features/patterns/resolveSpec.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"resolveSpec.js","names":["cache","specKey","keys","spec","bag","k","resolvePatternSpec","key","hit","built","buildTile","hatch","crosshatch","dots","chunks","isPatternSpec","payload","resolveFillPattern","fill","handle"],"sources":["../../../src/features/patterns/resolveSpec.ts"],"sourcesContent":["/**\n * `TilePatternSpec` → `TextureHandle`. The bridge between the serializable\n * half of a pattern paint and the GL texture that paints it.\n *\n * Memoized on the spec's field values, so identical specs across nodes share\n * one texture and a re-render never re-rasterizes. Entries live for the\n * session, matching `registerTexture`'s own lifetime.\n */\n\nimport type { FillStyle, TilePatternSpec } from '@weasel-js/paint';\nimport type { TextureHandle } from '../../renderer/textures/registerTexture';\nimport { hatch, crosshatch, dots, chunks } from './patterns-builtin';\n\nconst cache = new Map<string, TextureHandle | null>();\n\n/** Stable key across key order — specs arriving from JSON have no guaranteed\n *  field order, and two orderings must not rasterize two tiles. */\nfunction specKey(spec: TilePatternSpec): string {\n  const keys = Object.keys(spec).sort();\n  const bag = spec as unknown as Record<string, unknown>;\n  return keys.map((k) => `${k}=${String(bag[k])}`).join('&');\n}\n\n/** @internal Test helper — do not call from product code. */\nexport function _resetPatternSpecCacheForTests(): void {\n  cache.clear();\n}\n\n/**\n * Build (or fetch) the texture for a spec. Returns `null` when the tile\n * can't be rasterized — no `OffscreenCanvas`, same as `createTilePattern`.\n */\nexport function resolvePatternSpec(spec: TilePatternSpec): TextureHandle | null {\n  const key = specKey(spec);\n  const hit = cache.get(key);\n  if (hit !== undefined) return hit;\n\n  const built = buildTile(spec);\n  cache.set(key, built);\n  return built;\n}\n\nfunction buildTile(spec: TilePatternSpec): TextureHandle | null {\n  const { color, size } = spec;\n  switch (spec.tile) {\n    case 'hatch':\n      return hatch({ color, size, lineWidth: spec.lineWidth });\n    case 'crosshatch':\n      return crosshatch({ color, size, lineWidth: spec.lineWidth });\n    case 'dots':\n      return dots({ color, size, radius: spec.radius });\n    case 'chunks':\n      return chunks({\n        color, size, bg: spec.bg,\n        density: spec.density, chunkSize: spec.chunkSize, seed: spec.seed,\n      });\n    default:\n      return null;\n  }\n}\n\n/** Whether a pattern payload is a spec rather than an already-built handle. */\nexport function isPatternSpec(\n  payload: TextureHandle | TilePatternSpec,\n): payload is TilePatternSpec {\n  return 'tile' in payload;\n}\n\n/**\n * Swap a pattern paint's spec payload for the texture that paints it,\n * leaving every other fill untouched. The built-in painters run this\n * alongside `fillInPoseFrame`; a consumer emitting its own draw commands\n * runs it at the same place it runs that one.\n *\n * A spec that can't rasterize drops the fill rather than painting garbage.\n */\nexport function resolveFillPattern(fill: FillStyle): FillStyle | null {\n  if (fill.fill !== 'pattern') return fill;\n  if (!isPatternSpec(fill.pattern)) return fill;\n  const handle = resolvePatternSpec(fill.pattern);\n  return handle ? { ...fill, pattern: handle } : null;\n}\n"],"mappings":";;AAaA,IAAMA,oBAAQ,IAAI,IAAkC;AAIpD,SAASC,EAAQ,GAA+B;CAC9C,IAAMC,IAAO,OAAO,KAAKC,CAAI,CAAC,CAAC,KAAK,GAC9BC,IAAMD;CACZ,OAAOD,EAAK,KAAK,MAAM,GAAGG,EAAE,GAAG,OAAOD,EAAIC,EAAE,GAAG,CAAC,CAAC,KAAK,GAAG;AAC3D;AAWA,SAAgBC,EAAmB,GAA6C;CAC9E,IAAMC,IAAMN,EAAQE,CAAI,GAClBK,IAAMR,EAAM,IAAIO,CAAG;CACzB,IAAIC,MAAQ,KAAA,GAAW,OAAOA;CAE9B,IAAMC,IAAQC,EAAUP,CAAI;CAE5B,OADAH,EAAM,IAAIO,GAAKE,CAAK,GACbA;AACT;AAEA,SAASC,EAAU,GAA6C;CAC9D,IAAM,EAAE,UAAO,YAASP;CACxB,QAAQA,EAAK,MAAb;EACE,KAAK,SACH,OAAOQ,EAAM;GAAE;GAAO;GAAM,WAAWR,EAAK;EAAU,CAAC;EACzD,KAAK,cACH,OAAOS,EAAW;GAAE;GAAO;GAAM,WAAWT,EAAK;EAAU,CAAC;EAC9D,KAAK,QACH,OAAOU,EAAK;GAAE;GAAO;GAAM,QAAQV,EAAK;EAAO,CAAC;EAClD,KAAK,UACH,OAAOW,EAAO;GACZ;GAAO;GAAM,IAAIX,EAAK;GACtB,SAASA,EAAK;GAAS,WAAWA,EAAK;GAAW,MAAMA,EAAK;EAC/D,CAAC;EACH,SACE,OAAO;CACX;AACF;AAGA,SAAgBY,EACd,GAC4B;CAC5B,OAAO,UAAUC;AACnB;AAUA,SAAgBC,EAAmB,GAAmC;CAEpE,IADIC,EAAK,SAAS,aACd,CAACH,EAAcG,EAAK,OAAO,GAAG,OAAOA;CACzC,IAAMC,IAASb,EAAmBY,EAAK,OAAO;CAC9C,OAAOC,IAAS;EAAE,GAAGD;EAAM,SAASC;CAAO,IAAI;AACjD"}

package/dist/features/patterns/tileGeometry.js

@@ -1,158 +0,0 @@
-//#region src/features/patterns/tileGeometry.ts
-function e(e) {
-	if (e.size !== void 0) return e.size;
-	switch (e.tile) {
-		case "hatch": return 5;
-		case "crosshatch": return 6;
-		case "dots": return 6;
-		case "chunks": return 48;
-		default: return 8;
-	}
-}
-function t(e) {
-	let t = e | 0;
-	return () => {
-		t = t + 1831565813 | 0;
-		let e = Math.imul(t ^ t >>> 15, 1 | t);
-		return e = e + Math.imul(e ^ e >>> 7, 61 | e) ^ e, ((e ^ e >>> 14) >>> 0) / 4294967296;
-	};
-}
-function n(n) {
-	let a = e(n), { color: o } = n;
-	switch (n.tile) {
-		case "hatch": return {
-			size: a,
-			shapes: r(a, n.lineWidth ?? 1, o)
-		};
-		case "crosshatch": {
-			let e = n.lineWidth ?? .8;
-			return {
-				size: a,
-				shapes: [...r(a, e, o), ...i(a, e, o)]
-			};
-		}
-		case "dots": {
-			let e = n.radius ?? 1;
-			return {
-				size: a,
-				shapes: [{
-					kind: "circle",
-					cx: a / 2,
-					cy: a / 2,
-					r: e,
-					color: o
-				}]
-			};
-		}
-		case "chunks": {
-			let e = n.density ?? .35, r = n.chunkSize ?? 3, i = t(n.seed ?? 42), s = Math.round(a * a * e / (r * r)), c = [];
-			n.bg !== void 0 && c.push({
-				kind: "rect",
-				x: 0,
-				y: 0,
-				width: a,
-				height: a,
-				color: n.bg
-			});
-			for (let e = 0; e < s; e++) {
-				let e = i() * a, t = i() * a, n = r * (.5 + i()), s = r * (.5 + i()), l = i() * Math.PI;
-				c.push({
-					kind: "ellipse",
-					cx: e,
-					cy: t,
-					rx: n / 2,
-					ry: s / 2,
-					rotation: l,
-					color: o
-				});
-			}
-			return {
-				size: a,
-				shapes: c
-			};
-		}
-		default: return {
-			size: a,
-			shapes: []
-		};
-	}
-}
-function r(e, t, n) {
-	return [
-		{
-			kind: "line",
-			x1: -1,
-			y1: e + 1,
-			x2: e + 1,
-			y2: -1,
-			width: t,
-			color: n
-		},
-		{
-			kind: "line",
-			x1: -1,
-			y1: 1,
-			x2: 1,
-			y2: -1,
-			width: t,
-			color: n
-		},
-		{
-			kind: "line",
-			x1: e - 1,
-			y1: e + 1,
-			x2: e + 1,
-			y2: e - 1,
-			width: t,
-			color: n
-		}
-	];
-}
-function i(e, t, n) {
-	return [
-		{
-			kind: "line",
-			x1: -1,
-			y1: -1,
-			x2: e + 1,
-			y2: e + 1,
-			width: t,
-			color: n
-		},
-		{
-			kind: "line",
-			x1: e - 1,
-			y1: -1,
-			x2: e + 1,
-			y2: 1,
-			width: t,
-			color: n
-		},
-		{
-			kind: "line",
-			x1: -1,
-			y1: e - 1,
-			x2: 1,
-			y2: e + 1,
-			width: t,
-			color: n
-		}
-	];
-}
-function a(e, t) {
-	for (let n of t.shapes) {
-		if (n.kind === "line") {
-			e.strokeStyle = n.color, e.lineWidth = n.width, e.beginPath(), e.moveTo(n.x1, n.y1), e.lineTo(n.x2, n.y2), e.stroke();
-			continue;
-		}
-		if (e.fillStyle = n.color, n.kind === "rect") {
-			e.fillRect(n.x, n.y, n.width, n.height);
-			continue;
-		}
-		e.beginPath(), n.kind === "circle" ? e.arc(n.cx, n.cy, n.r, 0, Math.PI * 2) : e.ellipse(n.cx, n.cy, n.rx, n.ry, n.rotation, 0, Math.PI * 2), e.fill();
-	}
-}
-//#endregion
-export { a as drawTileShapes, n as tileGeometry, e as tileSize };
-
-//# sourceMappingURL=tileGeometry.js.map

package/dist/features/patterns/tileGeometry.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"tileGeometry.js","names":["tileSize","spec","mulberry32","s","seed","t","tileGeometry","forwardDiagonals","color","width","backwardDiagonals","r","density","chunkSize","rand","count","shapes","i","cx","cy","w","h","rotation","drawTileShapes","shape","geometry","oc"],"sources":["../../../src/features/patterns/tileGeometry.ts"],"sourcesContent":["/**\n * The shapes a built-in tile is made of, as data.\n *\n * One description, two renderers: `patterns-builtin` strokes/fills these to\n * an `OffscreenCanvas` to build the GL texture, and `@weasel-js/svg` maps\n * them to `<pattern>` children. Duplicating the tile drawing in the\n * serializer would let the raster and vector forms drift apart silently.\n */\n\nimport type { TilePatternSpec } from '@weasel-js/paint';\n\n/** One primitive within a pattern tile, in tile-local coordinates. */\nexport type TileShape =\n  | { kind: 'line'; x1: number; y1: number; x2: number; y2: number; width: number; color: string }\n  | { kind: 'circle'; cx: number; cy: number; r: number; color: string }\n  | { kind: 'ellipse'; cx: number; cy: number; rx: number; ry: number; rotation: number; color: string }\n  | { kind: 'rect'; x: number; y: number; width: number; height: number; color: string };\n\n/** A built-in tile's shapes plus the edge length they're drawn within. */\nexport interface TileGeometry {\n  size: number;\n  shapes: TileShape[];\n}\n\n/** Defaults per tile kind, matching each factory's signature. */\nexport function tileSize(spec: TilePatternSpec): number {\n  if (spec.size !== undefined) return spec.size;\n  switch (spec.tile) {\n    case 'hatch': return 5;\n    case 'crosshatch': return 6;\n    case 'dots': return 6;\n    case 'chunks': return 48;\n    default: return 8;\n  }\n}\n\n/** Seeded PRNG (mulberry32) — `chunks` places its scatter with this, so the\n *  same `seed` yields the same tile in both the raster and vector paths. */\nfunction mulberry32(seed: number): () => number {\n  let s = seed | 0;\n  return () => {\n    s = (s + 0x6D2B79F5) | 0;\n    let t = Math.imul(s ^ (s >>> 15), 1 | s);\n    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;\n    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;\n  };\n}\n\n/** Resolve a pattern spec to the shapes that make up one tile. Consumers that\n *  want to draw a pattern swatch themselves — a picker, an SVG export — read\n *  this rather than rasterizing a texture. */\nexport function tileGeometry(spec: TilePatternSpec): TileGeometry {\n  const s = tileSize(spec);\n  const { color } = spec;\n\n  switch (spec.tile) {\n    case 'hatch': {\n      const width = spec.lineWidth ?? 1;\n      return { size: s, shapes: forwardDiagonals(s, width, color) };\n    }\n    case 'crosshatch': {\n      const width = spec.lineWidth ?? 0.8;\n      return {\n        size: s,\n        shapes: [...forwardDiagonals(s, width, color), ...backwardDiagonals(s, width, color)],\n      };\n    }\n    case 'dots': {\n      const r = spec.radius ?? 1;\n      return { size: s, shapes: [{ kind: 'circle', cx: s / 2, cy: s / 2, r, color }] };\n    }\n    case 'chunks': {\n      const density = spec.density ?? 0.35;\n      const chunkSize = spec.chunkSize ?? 3;\n      const rand = mulberry32(spec.seed ?? 42);\n      const count = Math.round((s * s * density) / (chunkSize * chunkSize));\n      const shapes: TileShape[] = [];\n      if (spec.bg !== undefined) {\n        shapes.push({ kind: 'rect', x: 0, y: 0, width: s, height: s, color: spec.bg });\n      }\n      for (let i = 0; i < count; i++) {\n        const cx = rand() * s;\n        const cy = rand() * s;\n        const w = chunkSize * (0.5 + rand());\n        const h = chunkSize * (0.5 + rand());\n        const rotation = rand() * Math.PI;\n        shapes.push({ kind: 'ellipse', cx, cy, rx: w / 2, ry: h / 2, rotation, color });\n      }\n      return { size: s, shapes };\n    }\n    default:\n      return { size: s, shapes: [] };\n  }\n}\n\n/** The forward (`/`) diagonal, plus the two corner stubs that make it tile\n *  seamlessly across the edges. */\nfunction forwardDiagonals(s: number, width: number, color: string): TileShape[] {\n  return [\n    { kind: 'line', x1: -1, y1: s + 1, x2: s + 1, y2: -1, width, color },\n    { kind: 'line', x1: -1, y1: 1, x2: 1, y2: -1, width, color },\n    { kind: 'line', x1: s - 1, y1: s + 1, x2: s + 1, y2: s - 1, width, color },\n  ];\n}\n\n/** The backward (`\\`) diagonal and its two stubs. */\nfunction backwardDiagonals(s: number, width: number, color: string): TileShape[] {\n  return [\n    { kind: 'line', x1: -1, y1: -1, x2: s + 1, y2: s + 1, width, color },\n    { kind: 'line', x1: s - 1, y1: -1, x2: s + 1, y2: 1, width, color },\n    { kind: 'line', x1: -1, y1: s - 1, x2: 1, y2: s + 1, width, color },\n  ];\n}\n\n/** Draw a tile's shapes to a 2D context — the raster half of the pair. */\nexport function drawTileShapes(oc: CanvasRenderingContext2D, geometry: TileGeometry): void {\n  for (const shape of geometry.shapes) {\n    if (shape.kind === 'line') {\n      oc.strokeStyle = shape.color;\n      oc.lineWidth = shape.width;\n      oc.beginPath();\n      oc.moveTo(shape.x1, shape.y1);\n      oc.lineTo(shape.x2, shape.y2);\n      oc.stroke();\n      continue;\n    }\n    oc.fillStyle = shape.color;\n    if (shape.kind === 'rect') {\n      oc.fillRect(shape.x, shape.y, shape.width, shape.height);\n      continue;\n    }\n    oc.beginPath();\n    if (shape.kind === 'circle') {\n      oc.arc(shape.cx, shape.cy, shape.r, 0, Math.PI * 2);\n    } else {\n      oc.ellipse(shape.cx, shape.cy, shape.rx, shape.ry, shape.rotation, 0, Math.PI * 2);\n    }\n    oc.fill();\n  }\n}\n"],"mappings":"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"}