@weasel-js/core 1.9.4 → 1.10.1

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

@@ -1,52 +0,0 @@
-//#region src/features/paths/tessellate/dash.ts
-function e(e, n) {
-	let r = [], i = e.anchorA ?? new Uint32Array(e.points.length / 2), a = e.anchorB ?? new Uint32Array(e.points.length / 2), o = e.anchorT ?? new Float32Array(e.points.length / 2), s = 0, c = n[0], l = !0, u = l ? [e.points[0], e.points[1]] : null, d = l ? [i[0]] : null, f = l ? [a[0]] : null, p = l ? [o[0]] : null, m = () => {
-		u && u.length >= 4 && r.push({
-			points: u,
-			closed: !1,
-			anchorA: new Uint32Array(d),
-			anchorB: new Uint32Array(f),
-			anchorT: new Float32Array(p)
-		}), u = null, d = null, f = null, p = null, s = (s + 1) % n.length, c = n[s], l = !l;
-	}, h = e.points[0], g = e.points[1], _ = e.points.length / 2, v = e.closed ? _ : _ - 1;
-	for (let t = 0; t < v; t++) {
-		let n = (t + 1) % _, r = e.points[n * 2], s = e.points[n * 2 + 1], v = i[t], y = a[t], b = o[t], x = i[n], S = a[n], C = o[n], w = r - h, T = s - g, E = Math.hypot(w, T), D = w, O = T, k = E, A = 0;
-		for (; k > 1e-9;) if (k <= c) l && u && (u.push(r, s), d.push(x), f.push(S), p.push(C)), c -= k, h = r, g = s, A = E, k = 0, c <= 1e-9 && (m(), l && (u = [h, g], d = [x], f = [S], p = [C]));
-		else {
-			let e = c / k, t = h + D * e, n = g + O * e;
-			A += c;
-			let i = A / E, a, o, _;
-			v === x && y === S ? (a = v, o = y, _ = b + (C - b) * i) : i < .5 ? (a = v, o = y, _ = b) : (a = x, o = S, _ = C), l && u && (u.push(t, n), d.push(a), f.push(o), p.push(_)), h = t, g = n, D = r - h, O = s - g, k = Math.hypot(D, O), m(), l && (u = [h, g], d = [a], f = [o], p = [_]);
-		}
-	}
-	if (u && u.length >= 4) {
-		let n = {
-			points: u,
-			closed: !1,
-			anchorA: new Uint32Array(d),
-			anchorB: new Uint32Array(f),
-			anchorT: new Float32Array(p)
-		}, i = u[u.length - 2], a = u[u.length - 1], o = (e, t) => Math.hypot(i - e, a - t) <= 1e-9;
-		e.closed && r.length > 0 && o(r[0].points[0], r[0].points[1]) ? r[0] = t(n, r[0]) : e.closed && r.length === 0 && o(u[0], u[1]) ? r.push({
-			points: u.slice(0, -2),
-			closed: !0,
-			anchorA: n.anchorA.slice(0, -1),
-			anchorB: n.anchorB.slice(0, -1),
-			anchorT: n.anchorT.slice(0, -1)
-		}) : r.push(n);
-	}
-	return r;
-}
-function t(e, t) {
-	return {
-		points: [...e.points, ...t.points.slice(2)],
-		closed: !1,
-		anchorA: Uint32Array.from([...e.anchorA, ...t.anchorA.subarray(1)]),
-		anchorB: Uint32Array.from([...e.anchorB, ...t.anchorB.subarray(1)]),
-		anchorT: Float32Array.from([...e.anchorT, ...t.anchorT.subarray(1)])
-	};
-}
-//#endregion
-export { e as splitForDash };
-
-//# sourceMappingURL=dash.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"dash.js","names":["splitForDash","out","plA","pl","plB","plT","dashIdx","dashRemaining","dash","onPhase","curPts","curA","curB","curT","flushAndAdvance","prevX","prevY","ptCount","segCount","i","nextIdx","cx","cy","startA","startB","startT","endA","endB","endT","segFullDx","segFullDy","segFullLen","segDx","segDy","segLen","traveled","tConsume","ix","iy","frac","mA","mB","mT","tail","tx","ty","meets","x","y","joinAtSeam","head"],"sources":["../../../../src/features/paths/tessellate/dash.ts"],"sourcesContent":["import type { Polyline } from '@weasel-js/geom/tessellate';\n\n/**\n * Split a polyline into open sub-polylines for the \"on\" portions of a dash\n * pattern. Each output sub-polyline gets caps from the stroke's `cap` setting.\n * The \"off\" portions become invisible gaps. Anchor params are carried through:\n * sub-polyline endpoints inherit their source polyline-point's anchor params;\n * dash boundaries that land mid-segment (between two polyline points) snap\n * their anchor params to whichever endpoint they're closer to when the\n * segment crosses a path-anchor boundary, otherwise interpolate `t` linearly.\n */\nexport function splitForDash(pl: Polyline, dash: number[]): Polyline[] {\n  const out: Polyline[] = [];\n  const plA = pl.anchorA ?? new Uint32Array(pl.points.length / 2);\n  const plB = pl.anchorB ?? new Uint32Array(pl.points.length / 2);\n  const plT = pl.anchorT ?? new Float32Array(pl.points.length / 2);\n\n  let dashIdx = 0;\n  let dashRemaining = dash[0];\n  let onPhase = true;\n  let curPts: number[] | null = onPhase ? [pl.points[0], pl.points[1]] : null;\n  let curA: number[] | null = onPhase ? [plA[0]] : null;\n  let curB: number[] | null = onPhase ? [plB[0]] : null;\n  let curT: number[] | null = onPhase ? [plT[0]] : null;\n\n  const flushAndAdvance = () => {\n    if (curPts && curPts.length >= 4) {\n      out.push({\n        points: curPts,\n        closed: false,\n        anchorA: new Uint32Array(curA!),\n        anchorB: new Uint32Array(curB!),\n        anchorT: new Float32Array(curT!),\n      });\n    }\n    curPts = null; curA = null; curB = null; curT = null;\n    dashIdx = (dashIdx + 1) % dash.length;\n    dashRemaining = dash[dashIdx];\n    onPhase = !onPhase;\n  };\n\n  let prevX = pl.points[0], prevY = pl.points[1];\n  const ptCount = pl.points.length / 2;\n  const segCount = pl.closed ? ptCount : ptCount - 1;\n\n  for (let i = 0; i < segCount; i++) {\n    const nextIdx = (i + 1) % ptCount;\n    const cx = pl.points[nextIdx * 2], cy = pl.points[nextIdx * 2 + 1];\n    const startA = plA[i], startB = plB[i], startT = plT[i];\n    const endA = plA[nextIdx], endB = plB[nextIdx], endT = plT[nextIdx];\n    const segFullDx = cx - prevX, segFullDy = cy - prevY;\n    const segFullLen = Math.hypot(segFullDx, segFullDy);\n    let segDx = segFullDx, segDy = segFullDy;\n    let segLen = segFullLen;\n    let traveled = 0;\n\n    while (segLen > 1e-9) {\n      if (segLen <= dashRemaining) {\n        if (onPhase && curPts) {\n          curPts.push(cx, cy);\n          curA!.push(endA); curB!.push(endB); curT!.push(endT);\n        }\n        dashRemaining -= segLen;\n        prevX = cx; prevY = cy;\n        traveled = segFullLen;\n        segLen = 0;\n        if (dashRemaining <= 1e-9) {\n          flushAndAdvance();\n          if (onPhase) {\n            curPts = [prevX, prevY];\n            curA = [endA]; curB = [endB]; curT = [endT];\n          }\n        }\n      } else {\n        const tConsume = dashRemaining / segLen;\n        const ix = prevX + segDx * tConsume;\n        const iy = prevY + segDy * tConsume;\n        traveled += dashRemaining;\n        const frac = traveled / segFullLen;\n        let mA: number, mB: number, mT: number;\n        if (startA === endA && startB === endB) {\n          mA = startA; mB = startB;\n          mT = startT + (endT - startT) * frac;\n        } else {\n          // Cross-anchor segment: pick the nearer endpoint's params.\n          if (frac < 0.5) { mA = startA; mB = startB; mT = startT; }\n          else            { mA = endA; mB = endB; mT = endT; }\n        }\n        if (onPhase && curPts) {\n          curPts.push(ix, iy);\n          curA!.push(mA); curB!.push(mB); curT!.push(mT);\n        }\n        prevX = ix; prevY = iy;\n        segDx = cx - prevX; segDy = cy - prevY;\n        segLen = Math.hypot(segDx, segDy);\n        flushAndAdvance();\n        if (onPhase) {\n          curPts = [prevX, prevY];\n          curA = [mA]; curB = [mB]; curT = [mT];\n        }\n      }\n    }\n  }\n\n  if (curPts && curPts.length >= 4) {\n    const tail: Polyline = {\n      points: curPts,\n      closed: false,\n      anchorA: new Uint32Array(curA!),\n      anchorB: new Uint32Array(curB!),\n      anchorT: new Float32Array(curT!),\n    };\n    // A closed subpath's walk ends at the vertex it started from, so the run\n    // still open there and the run that started there are one dash. Pushed\n    // separately they are two butt-capped ribbons meeting at the seam — the\n    // visible artifact whenever the pattern doesn't divide the perimeter.\n    const tx = curPts[curPts.length - 2], ty = curPts[curPts.length - 1];\n    const meets = (x: number, y: number) => Math.hypot(tx - x, ty - y) <= 1e-9;\n    if (pl.closed && out.length > 0 && meets(out[0].points[0], out[0].points[1])) {\n      out[0] = joinAtSeam(tail, out[0]);\n    } else if (pl.closed && out.length === 0 && meets(curPts[0], curPts[1])) {\n      // Every gap fell outside the perimeter: the dash is the whole loop, and\n      // a loop stroked as an open run seams at its own start vertex too.\n      out.push({\n        points: curPts.slice(0, -2),\n        closed: true,\n        anchorA: tail.anchorA!.slice(0, -1),\n        anchorB: tail.anchorB!.slice(0, -1),\n        anchorT: tail.anchorT!.slice(0, -1),\n      });\n    } else {\n      out.push(tail);\n    }\n  }\n  return out;\n}\n\n/** `tail` continued by `head`, which starts where `tail` ends — the shared\n *  vertex is carried once. */\nfunction joinAtSeam(tail: Polyline, head: Polyline): Polyline {\n  return {\n    points: [...tail.points, ...head.points.slice(2)],\n    closed: false,\n    anchorA: Uint32Array.from([...tail.anchorA!, ...head.anchorA!.subarray(1)]),\n    anchorB: Uint32Array.from([...tail.anchorB!, ...head.anchorB!.subarray(1)]),\n    anchorT: Float32Array.from([...tail.anchorT!, ...head.anchorT!.subarray(1)]),\n  };\n}\n"],"mappings":"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"}

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

@@ -1,32 +0,0 @@
-import { polylineIntoMetric as e, polylineOutOfMetric as t, sameMetric as n } from "./metric.js";
-import { trimPolyline as r } from "@weasel-js/geom/tessellate";
-//#region src/features/paths/tessellate/insets.ts
-var i = (e, t) => e === void 0 ? {
-	length: 0,
-	metric: t
-} : typeof e == "number" ? {
-	length: e,
-	metric: t
-} : e;
-function a(a, o, s, c, l) {
-	let u = i(c, s), d = i(l, s), f = a, p = o, m = (r) => {
-		f === null || n(p, r) || (p !== null && t(f, p), r !== null && e(f, r), p = r);
-	};
-	if (u.length > 0 || d.length > 0) {
-		if (n(u.metric, d.metric)) m(u.metric), f = r(f, u.length, d.length);
-		else for (let [e, t, n] of [[
-			u.length,
-			u.metric,
-			!0
-		], [
-			d.length,
-			d.metric,
-			!1
-		]]) e > 0 && f !== null && (m(t), f = r(f, n ? e : 0, n ? 0 : e));
-	}
-	return m(s), f;
-}
-//#endregion
-export { a as trimInSpace };
-
-//# sourceMappingURL=insets.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"insets.js","names":["trimOf","inset","ribbon","trimInSpace","s","start","e","end","cur","pl","space","from","moveTo","sameMetric","to","polylineOutOfMetric","polylineIntoMetric","trimPolyline","len","metric","atStart"],"sources":["../../../../src/features/paths/tessellate/insets.ts"],"sourcesContent":["/**\n * Trimming a stroke's ends where each inset is measured.\n *\n * A head stops the line by a length in the head's own space, which need not be\n * the ribbon's: a world-sized head on a `{ px }` stroke stops it a world\n * distance short, a `{ px }` head on a world-width stroke a screen distance.\n * Under a stretching view one length means different distances in the two\n * spaces depending on which way the line runs, so each end is trimmed in its\n * own space rather than converted.\n */\nimport { type Polyline, trimPolyline } from '@weasel-js/geom/tessellate';\nimport {\n  type StrokeMetric, polylineIntoMetric, polylineOutOfMetric, sameMetric,\n} from './metric';\n\n/** A length along the line measured in `metric`'s space, or in world where\n *  `metric` is `null`. */\nexport interface MeasuredLength {\n  readonly length: number;\n  readonly metric: StrokeMetric | null;\n}\n\n/** A plain number is a length in the ribbon's own space. */\nexport type InsetLength = number | MeasuredLength;\n\ninterface Trim {\n  length: number;\n  metric: StrokeMetric | null;\n}\n\nconst trimOf = (inset: InsetLength | undefined, ribbon: StrokeMetric | null): Trim =>\n  inset === undefined ? { length: 0, metric: ribbon }\n    : typeof inset === 'number' ? { length: inset, metric: ribbon }\n      : inset;\n\n/**\n * `pl`, whose points are in `from`'s space, trimmed by `start` and `end` and\n * carried into `ribbon`'s — `null` for world in both. `pl` may be mapped in\n * place. Returns `null` when the insets consume the whole run.\n */\nexport function trimInSpace(\n  pl: Polyline,\n  from: StrokeMetric | null,\n  ribbon: StrokeMetric | null,\n  start: InsetLength | undefined,\n  end: InsetLength | undefined,\n): Polyline | null {\n  const s = trimOf(start, ribbon);\n  const e = trimOf(end, ribbon);\n  let cur: Polyline | null = pl;\n  let space = from;\n  const moveTo = (to: StrokeMetric | null) => {\n    if (cur === null || sameMetric(space, to)) return;\n    if (space !== null) polylineOutOfMetric(cur, space);\n    if (to !== null) polylineIntoMetric(cur, to);\n    space = to;\n  };\n  if (s.length > 0 || e.length > 0) {\n    if (sameMetric(s.metric, e.metric)) {\n      moveTo(s.metric);\n      cur = trimPolyline(cur, s.length, e.length);\n    } else {\n      for (const [len, metric, atStart] of [[s.length, s.metric, true], [e.length, e.metric, false]] as const) {\n        if (!(len > 0) || cur === null) continue;\n        moveTo(metric);\n        cur = trimPolyline(cur, atStart ? len : 0, atStart ? 0 : len);\n      }\n    }\n  }\n  moveTo(ribbon);\n  return cur;\n}\n"],"mappings":";;;AA8BA,IAAMA,KAAU,GAAgC,MAC9CC,MAAU,KAAA,IAAY;CAAE,QAAQ;CAAG,QAAQC;AAAO,IAC9C,OAAOD,KAAU,WAAW;CAAE,QAAQA;CAAO,QAAQC;AAAO,IAC1DD;AAOR,SAAgBE,EACd,GACA,GACA,GACA,GACA,GACiB;CACjB,IAAMC,IAAIJ,EAAOK,GAAOH,CAAM,GACxBI,IAAIN,EAAOO,GAAKL,CAAM,GACxBM,IAAuBC,GACvBC,IAAQC,GACNC,KAAU,MAA4B;EAC1C,AAAIJ,MAAQ,QAAQK,EAAWH,GAAOI,CAAE,MACpCJ,MAAU,QAAMK,EAAoBP,GAAKE,CAAK,GAC9CI,MAAO,QAAME,EAAmBR,GAAKM,CAAE,GAC3C,IAAQA;CACV;CACA,IAAIV,EAAE,SAAS,KAAKE,EAAE,SAAS,GAAG;EAChC,IAAIO,EAAWT,EAAE,QAAQE,EAAE,MAAM,GAE/B,AADAM,EAAOR,EAAE,MAAM,GACf,IAAMa,EAAaT,GAAKJ,EAAE,QAAQE,EAAE,MAAM;OAE1C,KAAK,IAAM,CAACY,GAAKC,GAAQC,MAAY,CAAC;GAAChB,EAAE;GAAQA,EAAE;GAAQ;EAAI,GAAG;GAACE,EAAE;GAAQA,EAAE;GAAQ;EAAK,CAAC,GAC3F,AAAMY,IAAM,KAAMV,MAAQ,SAC1BI,EAAOO,CAAM,GACb,IAAMF,EAAaT,GAAKY,IAAUF,IAAM,GAAGE,IAAU,IAAIF,CAAG;CAGlE;CAEA,OADAN,EAAOV,CAAM,GACNM;AACT"}

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

@@ -1,72 +0,0 @@
-//#region src/features/paths/tessellate/metric.ts
-function e(e) {
-	return e === void 0 ? "" : `${r(e.metric)}@${e.pxPerUnit}`;
-}
-var t = 1e-9;
-function n(e, n, r, i) {
-	let a = Math.abs(e * i - n * r), o = Math.sqrt(a);
-	if (!(a > 0) || !Number.isFinite(a)) return {
-		scale: 0,
-		metric: null
-	};
-	let s = (e * e + n * n) / a, c = (e * r + n * i) / a, l = (r * r + i * i) / a, u = Math.sqrt(s + l + 2), d = (s + 1) / u, f = c / u, p = (l + 1) / u;
-	return Math.abs(f) < t && Math.abs(d - p) < t ? {
-		scale: o,
-		metric: null
-	} : {
-		scale: o,
-		metric: {
-			p: d,
-			q: f,
-			r: p
-		}
-	};
-}
-function r(e) {
-	return e === void 0 ? "" : `${e.p},${e.q},${e.r}`;
-}
-function i(e, t) {
-	let n = e.points;
-	for (let e = 0; e < n.length; e += 2) {
-		let r = n[e], i = n[e + 1];
-		n[e] = t.p * r + t.q * i, n[e + 1] = t.q * r + t.r * i;
-	}
-}
-function a(e, t) {
-	let n = e.points;
-	for (let e = 0; e < n.length; e += 2) {
-		let r = n[e], i = n[e + 1];
-		n[e] = t.r * r - t.q * i, n[e + 1] = t.p * i - t.q * r;
-	}
-}
-function o(e, t) {
-	return e === t || e !== null && t !== null && e.p === t.p && e.q === t.q && e.r === t.r;
-}
-function s(e, t, n) {
-	return Math.hypot(e.r * t - e.q * n, e.p * n - e.q * t);
-}
-function c(e, t, n) {
-	return 1 / Math.hypot(e.p * t + e.q * n, e.q * t + e.r * n);
-}
-function l(e, t) {
-	for (let n = 0; n < e.length; n += 2) {
-		let r = e[n], i = e[n + 1];
-		e[n] = t.r * r - t.q * i, e[n + 1] = t.p * i - t.q * r;
-	}
-}
-function u(e) {
-	return e.q === 0;
-}
-function d(e, t) {
-	return u(t) ? {
-		kind: "rect",
-		x: t.p * e.x,
-		y: t.r * e.y,
-		width: t.p * e.width,
-		height: t.r * e.height
-	} : null;
-}
-//#endregion
-export { l as coordsOutOfMetric, u as metricKeepsRects, r as metricKey, i as polylineIntoMetric, a as polylineOutOfMetric, d as rectIntoMetric, o as sameMetric, e as screenSpaceKey, n as strokeSpaceOf, s as worldWidthInMetric, c as worldWidthInMetricAlongWorld };
-
-//# sourceMappingURL=metric.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"metric.js","names":["screenSpaceKey","space","metricKey","CONFORMAL_EPSILON","strokeSpaceOf","det2","a","d","b","c","scale","g11","g12","g22","s","p","q","r","metric","polylineIntoMetric","pts","pl","i","x","y","m","polylineOutOfMetric","sameMetric","worldWidthInMetric","tx","ty","worldWidthInMetricAlongWorld","ux","uy","coordsOutOfMetric","coords","metricKeepsRects","rectIntoMetric","rect"],"sources":["../../../../src/features/paths/tessellate/metric.ts"],"sourcesContent":["/**\n * The space a screen-pixel stroke is built in.\n *\n * A `{ px }` stroke is exact on screen only when its ribbon is offset in a\n * space that measures lengths the way the screen does. The transform's linear\n * part is `scale · R · P`: a uniform scale, a rotation (or reflection) that\n * moves no lengths, and `P`, the symmetric unit-determinant stretch left over.\n * Offsetting the ribbon after `P` and mapping it back through `P⁻¹` gives a\n * world-space mesh that the full transform turns into a ribbon of exactly\n * `width · scale` pixels in every direction — and keeps the mesh drawable by\n * every path that draws a world-space ribbon.\n *\n * `P` depends only on the lengths the transform induces (`LᵀL`), not on any\n * rotation applied after it, so a view that only pans or zooms uniformly keeps\n * the same metric and the ribbon cache keeps hitting.\n */\nimport type { Polyline } from '@weasel-js/geom/tessellate';\n\n/** `P` = [[p, q], [q, r]], with `pr − q² = 1`. */\nexport interface StrokeMetric {\n  readonly p: number;\n  readonly q: number;\n  readonly r: number;\n}\n\n/** A space a screen-sized part of a stroke is built in: the metric, and how\n *  many screen pixels one of its units is. */\nexport interface ScreenSpace {\n  readonly metric: StrokeMetric;\n  readonly pxPerUnit: number;\n}\n\n/**\n * Where each part of a stroke is built. An absent part is built in world:\n * everything is under a similarity, and otherwise a part whose size is a world\n * length. The ribbon is screen-sized for a `{ px }` width; a head for a\n * `{ px }` size, or for no size on a screen-sized ribbon, since it then takes\n * the stroke width.\n */\nexport interface StrokeSpaces {\n  readonly ribbon?: ScreenSpace;\n  readonly start?: ScreenSpace;\n  readonly mid?: ScreenSpace;\n  readonly end?: ScreenSpace;\n}\n\n/** A cache-key fragment naming `space`; empty for world. */\nexport function screenSpaceKey(space: ScreenSpace | undefined): string {\n  return space === undefined ? '' : `${metricKey(space.metric)}@${space.pxPerUnit}`;\n}\n\n/** Below this, a stretch is a rounding error and the transform a similarity. */\nconst CONFORMAL_EPSILON = 1e-9;\n\n/**\n * Split the linear map `x' = a·x + c·y, y' = b·x + d·y` — a GL `mat3`'s\n * `m[0], m[1], m[3], m[4]` — into its geometric-mean scale and its stroke\n * metric. `metric` is `null` when the map is a similarity, where world space\n * already measures like the screen; `scale` is `0` for a singular map.\n */\nexport function strokeSpaceOf(\n  a: number, b: number, c: number, d: number,\n): { scale: number; metric: StrokeMetric | null } {\n  const det2 = Math.abs(a * d - b * c);\n  const scale = Math.sqrt(det2);\n  if (!(det2 > 0) || !Number.isFinite(det2)) return { scale: 0, metric: null };\n  // G = LᵀL / det, whose determinant is 1, so √G = (G + I) / √(tr G + 2).\n  const g11 = (a * a + b * b) / det2;\n  const g12 = (a * c + b * d) / det2;\n  const g22 = (c * c + d * d) / det2;\n  const s = Math.sqrt(g11 + g22 + 2);\n  const p = (g11 + 1) / s;\n  const q = g12 / s;\n  const r = (g22 + 1) / s;\n  if (Math.abs(q) < CONFORMAL_EPSILON && Math.abs(p - r) < CONFORMAL_EPSILON) {\n    return { scale, metric: null };\n  }\n  return { scale, metric: { p, q, r } };\n}\n\n/** A cache-key fragment naming `metric`; empty for none. */\nexport function metricKey(metric: StrokeMetric | undefined): string {\n  return metric === undefined ? '' : `${metric.p},${metric.q},${metric.r}`;\n}\n\n/** Map `pl`'s points through `P`, in place. */\nexport function polylineIntoMetric(pl: Polyline, m: StrokeMetric): void {\n  const pts = pl.points;\n  for (let i = 0; i < pts.length; i += 2) {\n    const x = pts[i], y = pts[i + 1];\n    pts[i] = m.p * x + m.q * y;\n    pts[i + 1] = m.q * x + m.r * y;\n  }\n}\n\n/** Map `pl`'s points back out through `P⁻¹`, in place. */\nexport function polylineOutOfMetric(pl: Polyline, m: StrokeMetric): void {\n  const pts = pl.points;\n  for (let i = 0; i < pts.length; i += 2) {\n    const x = pts[i], y = pts[i + 1];\n    pts[i] = m.r * x - m.q * y;\n    pts[i + 1] = m.p * y - m.q * x;\n  }\n}\n\n/** Whether two spaces are the same — world being `null`. */\nexport function sameMetric(a: StrokeMetric | null, b: StrokeMetric | null): boolean {\n  if (a === b) return true;\n  return a !== null && b !== null && a.p === b.p && a.q === b.q && a.r === b.r;\n}\n\n/**\n * What one world unit of width, across a line running along the unit\n * direction `(tx, ty)` of the metric's own space, measures in that space.\n * `P` keeps areas, so a strip keeps its area while its length stretches by\n * `|P u|` (`u` the line's world direction): its width shrinks by the same,\n * and `1 / |P u|` is `|P⁻¹ t|`.\n */\nexport function worldWidthInMetric(m: StrokeMetric, tx: number, ty: number): number {\n  return Math.hypot(m.r * tx - m.q * ty, m.p * ty - m.q * tx);\n}\n\n/** The same, for a line running along the unit world direction `(ux, uy)`. */\nexport function worldWidthInMetricAlongWorld(m: StrokeMetric, ux: number, uy: number): number {\n  return 1 / Math.hypot(m.p * ux + m.q * uy, m.q * ux + m.r * uy);\n}\n\n/** Map interleaved x,y pairs back out through `P⁻¹` = [[r, −q], [−q, p]], in\n *  place. */\nexport function coordsOutOfMetric(coords: Float32Array, m: StrokeMetric): void {\n  for (let i = 0; i < coords.length; i += 2) {\n    const x = coords[i], y = coords[i + 1];\n    coords[i] = m.r * x - m.q * y;\n    coords[i + 1] = m.p * y - m.q * x;\n  }\n}\n\n/** Whether `P` takes an axis-aligned rect to another one. */\nexport function metricKeepsRects(m: StrokeMetric): boolean {\n  return m.q === 0;\n}\n\n/** `rect` in the metric's space, while `P` keeps it axis-aligned; otherwise\n *  `null`, and the rect has to be carried as a polygon. */\nexport function rectIntoMetric(\n  rect: { x: number; y: number; width: number; height: number },\n  m: StrokeMetric,\n): { kind: 'rect'; x: number; y: number; width: number; height: number } | null {\n  if (!metricKeepsRects(m)) return null;\n  return { kind: 'rect', x: m.p * rect.x, y: m.r * rect.y, width: m.p * rect.width, height: m.r * rect.height };\n}\n"],"mappings":"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"}

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/geom';\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/commandPaint.js

@@ -1,18 +0,0 @@
-import { fillInPoseFrame as e } from "../../core/fillInPoseFrame.js";
-import { resolveFillPattern as t } from "./resolveSpec.js";
-//#region src/features/patterns/commandPaint.ts
-function n(n, r) {
-	return t(e(n, r));
-}
-function r(e, t) {
-	if (e.paint == null) return null;
-	let r = n(e.paint, t);
-	return r === null ? null : r === e.paint ? e : {
-		...e,
-		paint: r
-	};
-}
-//#endregion
-export { n as commandFill, r as commandStroke };
-
-//# sourceMappingURL=commandPaint.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"commandPaint.js","names":["commandFill","resolveFillPattern","fillInPoseFrame","fill","box","commandStroke","stroke","paint"],"sources":["../../../src/features/patterns/commandPaint.ts"],"sourcesContent":["/**\n * A node's paint, resolved into what a draw command takes. One place composes\n * the two resolutions so every painter and layer applies both.\n */\n\nimport type { CommandFill, CommandStroke, FillStyle, Stroke } from '@weasel-js/paint';\nimport { fillInPoseFrame, type FillPoseBox } from '../../core/fillInPoseFrame';\nimport { resolveFillPattern } from './resolveSpec';\n\n/**\n * `fill` as a draw command's fill: `'bounds'` units mapped onto `box`, and a\n * tile spec swapped for its texture. `null` when a spec cannot rasterize.\n */\nexport function commandFill(fill: FillStyle, box: FillPoseBox): CommandFill | null {\n  return resolveFillPattern(fillInPoseFrame(fill, box));\n}\n\n/**\n * `stroke` as a draw command's stroke, its paint resolved as\n * {@link commandFill} resolves a fill. `null` when the stroke carries no\n * paint, or its paint cannot be resolved.\n */\nexport function commandStroke(stroke: Stroke, box: FillPoseBox): CommandStroke | null {\n  if (stroke.paint == null) return null;\n  const paint = commandFill(stroke.paint, box);\n  if (paint === null) return null;\n  // Same object when nothing changed: the renderer's stroke caches key on it.\n  return paint === stroke.paint ? (stroke as CommandStroke) : { ...stroke, paint };\n}\n"],"mappings":";;;AAaA,SAAgBA,EAAY,GAAiB,GAAsC;CACjF,OAAOC,EAAmBC,EAAgBC,GAAMC,CAAG,CAAC;AACtD;AAOA,SAAgBC,EAAc,GAAgB,GAAwC;CACpF,IAAIC,EAAO,SAAS,MAAM,OAAO;CACjC,IAAMC,IAAQP,EAAYM,EAAO,OAAOF,CAAG;CAG3C,OAFIG,MAAU,OAAa,OAEpBA,MAAUD,EAAO,QAASA,IAA2B;EAAE,GAAGA;EAAQ;CAAM;AACjF"}

package/dist/features/patterns/index.js

@@ -1,11 +0,0 @@
-import { registerTexture as e } from "../../renderer/textures/registerTexture.js";
-import { rasterizeTile as t } from "./rasterizeTile.js";
-//#region src/features/patterns/index.ts
-function n(n) {
-	let r = t(n);
-	return r ? e(r) : null;
-}
-//#endregion
-export { n as createTilePattern };
-
-//# sourceMappingURL=index.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":["createTilePattern","bitmap","rasterizeTile","opts","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';\nimport { rasterizeTile } from './rasterizeTile';\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  const bitmap = rasterizeTile(opts);\n  return bitmap ? registerTexture(bitmap) : null;\n}\n"],"mappings":";;;AAiCA,SAAgBA,EAAkB,GAA6C;CAC7E,IAAMC,IAASC,EAAcC,CAAI;CACjC,OAAOF,IAASG,EAAgBH,CAAM,IAAI;AAC5C"}

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/rasterizeTile.js

@@ -1,17 +0,0 @@
-//#region src/features/patterns/rasterizeTile.ts
-function e(e) {
-	let t;
-	try {
-		t = new OffscreenCanvas(e.size, e.size);
-	} catch {
-		if (typeof document > "u") return null;
-		let n = document.createElement("canvas");
-		n.width = e.size, n.height = e.size, t = n;
-	}
-	let n = t.getContext("2d");
-	return !n || (e.draw(n, e.size), typeof t.transferToImageBitmap != "function") ? null : t.transferToImageBitmap();
-}
-//#endregion
-export { e as rasterizeTile };
-
-//# sourceMappingURL=rasterizeTile.js.map