@weasel-js/stroke 0.0.0-stage → 1.9.4

package/dist/index.js

@@ -0,0 +1,819 @@
+import { getMarker } from './chunk-HZ37OTXN.js';
+export { BUILTIN_MARKERS, getMarker, listMarkers, markerGeneration, markerRegistry, registerMarker } from './chunk-HZ37OTXN.js';
+import { resolveScreenLength, alignedStrokeRect } from '@weasel-js/paint';
+import { trimPolyline, extractPolylines } from '@weasel-js/geom/tessellate';
+import { boundsOfPath } from '@weasel-js/geom';
+import { trianglesToPath, pathIntersect, pathSubtract, pathUnion } from '@weasel-js/geom/booleans';
+
+// src/tessellate/dash.ts
+function splitForDash(pl, dash) {
+  const out = [];
+  const plA = pl.anchorA ?? new Uint32Array(pl.points.length / 2);
+  const plB = pl.anchorB ?? new Uint32Array(pl.points.length / 2);
+  const plT = pl.anchorT ?? new Float32Array(pl.points.length / 2);
+  let dashIdx = 0;
+  let dashRemaining = dash[0];
+  let onPhase = true;
+  let curPts = onPhase ? [pl.points[0], pl.points[1]] : null;
+  let curA = onPhase ? [plA[0]] : null;
+  let curB = onPhase ? [plB[0]] : null;
+  let curT = onPhase ? [plT[0]] : null;
+  const flushAndAdvance = () => {
+    if (curPts && curPts.length >= 4) {
+      out.push({
+        points: curPts,
+        closed: false,
+        anchorA: new Uint32Array(curA),
+        anchorB: new Uint32Array(curB),
+        anchorT: new Float32Array(curT)
+      });
+    }
+    curPts = null;
+    curA = null;
+    curB = null;
+    curT = null;
+    dashIdx = (dashIdx + 1) % dash.length;
+    dashRemaining = dash[dashIdx];
+    onPhase = !onPhase;
+  };
+  let prevX = pl.points[0], prevY = pl.points[1];
+  const ptCount = pl.points.length / 2;
+  const segCount = pl.closed ? ptCount : ptCount - 1;
+  for (let i = 0; i < segCount; i++) {
+    const nextIdx = (i + 1) % ptCount;
+    const cx = pl.points[nextIdx * 2], cy = pl.points[nextIdx * 2 + 1];
+    const startA = plA[i], startB = plB[i], startT = plT[i];
+    const endA = plA[nextIdx], endB = plB[nextIdx], endT = plT[nextIdx];
+    const segFullDx = cx - prevX, segFullDy = cy - prevY;
+    const segFullLen = Math.hypot(segFullDx, segFullDy);
+    let segDx = segFullDx, segDy = segFullDy;
+    let segLen = segFullLen;
+    let traveled = 0;
+    while (segLen > 1e-9) {
+      if (segLen <= dashRemaining) {
+        if (onPhase && curPts) {
+          curPts.push(cx, cy);
+          curA.push(endA);
+          curB.push(endB);
+          curT.push(endT);
+        }
+        dashRemaining -= segLen;
+        prevX = cx;
+        prevY = cy;
+        traveled = segFullLen;
+        segLen = 0;
+        if (dashRemaining <= 1e-9) {
+          flushAndAdvance();
+          if (onPhase) {
+            curPts = [prevX, prevY];
+            curA = [endA];
+            curB = [endB];
+            curT = [endT];
+          }
+        }
+      } else {
+        const tConsume = dashRemaining / segLen;
+        const ix = prevX + segDx * tConsume;
+        const iy = prevY + segDy * tConsume;
+        traveled += dashRemaining;
+        const frac = traveled / segFullLen;
+        let mA, mB, mT;
+        if (startA === endA && startB === endB) {
+          mA = startA;
+          mB = startB;
+          mT = startT + (endT - startT) * frac;
+        } else {
+          if (frac < 0.5) {
+            mA = startA;
+            mB = startB;
+            mT = startT;
+          } else {
+            mA = endA;
+            mB = endB;
+            mT = endT;
+          }
+        }
+        if (onPhase && curPts) {
+          curPts.push(ix, iy);
+          curA.push(mA);
+          curB.push(mB);
+          curT.push(mT);
+        }
+        prevX = ix;
+        prevY = iy;
+        segDx = cx - prevX;
+        segDy = cy - prevY;
+        segLen = Math.hypot(segDx, segDy);
+        flushAndAdvance();
+        if (onPhase) {
+          curPts = [prevX, prevY];
+          curA = [mA];
+          curB = [mB];
+          curT = [mT];
+        }
+      }
+    }
+  }
+  if (curPts && curPts.length >= 4) {
+    const tail = {
+      points: curPts,
+      closed: false,
+      anchorA: new Uint32Array(curA),
+      anchorB: new Uint32Array(curB),
+      anchorT: new Float32Array(curT)
+    };
+    const tx = curPts[curPts.length - 2], ty = curPts[curPts.length - 1];
+    const meets = (x, y) => Math.hypot(tx - x, ty - y) <= 1e-9;
+    if (pl.closed && out.length > 0 && meets(out[0].points[0], out[0].points[1])) {
+      out[0] = joinAtSeam(tail, out[0]);
+    } else if (pl.closed && out.length === 0 && meets(curPts[0], curPts[1])) {
+      out.push({
+        points: curPts.slice(0, -2),
+        closed: true,
+        anchorA: tail.anchorA.slice(0, -1),
+        anchorB: tail.anchorB.slice(0, -1),
+        anchorT: tail.anchorT.slice(0, -1)
+      });
+    } else {
+      out.push(tail);
+    }
+  }
+  return out;
+}
+function joinAtSeam(tail, head) {
+  return {
+    points: [...tail.points, ...head.points.slice(2)],
+    closed: false,
+    anchorA: Uint32Array.from([...tail.anchorA, ...head.anchorA.subarray(1)]),
+    anchorB: Uint32Array.from([...tail.anchorB, ...head.anchorB.subarray(1)]),
+    anchorT: Float32Array.from([...tail.anchorT, ...head.anchorT.subarray(1)])
+  };
+}
+
+// src/tessellate/vertexWidths.ts
+function populatePolylineWidths(pl, vertexWidths, fallbackWidth, scale) {
+  const ptCount = pl.points.length / 2;
+  if (ptCount === 0) return;
+  const aA = pl.anchorA ?? new Uint32Array(ptCount);
+  const aB = pl.anchorB ?? new Uint32Array(ptCount);
+  const aT = pl.anchorT ?? new Float32Array(ptCount);
+  const widths = new Float32Array(ptCount);
+  let k = 1;
+  const read = (i) => {
+    const v = vertexWidths[i];
+    return typeof v === "number" && isFinite(v) && v > 0 ? v * k : fallbackWidth;
+  };
+  for (let i = 0; i < ptCount; i++) {
+    if (scale) k = scaleAt(pl, i, scale);
+    const a = aA[i], b = aB[i], t = aT[i];
+    if (a === b) {
+      widths[i] = read(a);
+    } else {
+      const wa = read(a);
+      const wb = read(b);
+      widths[i] = wa + (wb - wa) * t;
+    }
+  }
+  pl.widths = widths;
+}
+function scaleAt(pl, i, scale) {
+  const pts = pl.points;
+  const n = pts.length / 2;
+  let tx = 0, ty = 0;
+  const add = (from, to) => {
+    const dx = pts[to * 2] - pts[from * 2], dy = pts[to * 2 + 1] - pts[from * 2 + 1];
+    const len2 = Math.hypot(dx, dy);
+    if (len2 > 0) {
+      tx += dx / len2;
+      ty += dy / len2;
+    }
+  };
+  if (i > 0) add(i - 1, i);
+  else if (pl.closed && n > 1) add(n - 1, 0);
+  if (i < n - 1) add(i, i + 1);
+  else if (pl.closed && n > 1) add(n - 1, 0);
+  const len = Math.hypot(tx, ty);
+  return len > 0 ? scale(tx / len, ty / len) : 1;
+}
+
+// src/tessellate/metric.ts
+function screenSpaceKey(space) {
+  return space === void 0 ? "" : `${metricKey(space.metric)}@${space.pxPerUnit}`;
+}
+var CONFORMAL_EPSILON = 1e-9;
+function strokeSpaceOf(a, b, c, d) {
+  const det2 = Math.abs(a * d - b * c);
+  const scale = Math.sqrt(det2);
+  if (!(det2 > 0) || !Number.isFinite(det2)) return { scale: 0, metric: null };
+  const g11 = (a * a + b * b) / det2;
+  const g12 = (a * c + b * d) / det2;
+  const g22 = (c * c + d * d) / det2;
+  const s = Math.sqrt(g11 + g22 + 2);
+  const p = (g11 + 1) / s;
+  const q = g12 / s;
+  const r = (g22 + 1) / s;
+  if (Math.abs(q) < CONFORMAL_EPSILON && Math.abs(p - r) < CONFORMAL_EPSILON) {
+    return { scale, metric: null };
+  }
+  return { scale, metric: { p, q, r } };
+}
+function metricKey(metric) {
+  return metric === void 0 ? "" : `${metric.p},${metric.q},${metric.r}`;
+}
+function polylineIntoMetric(pl, m) {
+  const pts = pl.points;
+  for (let i = 0; i < pts.length; i += 2) {
+    const x = pts[i], y = pts[i + 1];
+    pts[i] = m.p * x + m.q * y;
+    pts[i + 1] = m.q * x + m.r * y;
+  }
+}
+function polylineOutOfMetric(pl, m) {
+  const pts = pl.points;
+  for (let i = 0; i < pts.length; i += 2) {
+    const x = pts[i], y = pts[i + 1];
+    pts[i] = m.r * x - m.q * y;
+    pts[i + 1] = m.p * y - m.q * x;
+  }
+}
+function sameMetric(a, b) {
+  if (a === b) return true;
+  return a !== null && b !== null && a.p === b.p && a.q === b.q && a.r === b.r;
+}
+function worldWidthInMetric(m, tx, ty) {
+  return Math.hypot(m.r * tx - m.q * ty, m.p * ty - m.q * tx);
+}
+function worldWidthInMetricAlongWorld(m, ux, uy) {
+  return 1 / Math.hypot(m.p * ux + m.q * uy, m.q * ux + m.r * uy);
+}
+function coordsOutOfMetric(coords, m) {
+  for (let i = 0; i < coords.length; i += 2) {
+    const x = coords[i], y = coords[i + 1];
+    coords[i] = m.r * x - m.q * y;
+    coords[i + 1] = m.p * y - m.q * x;
+  }
+}
+function metricKeepsRects(m) {
+  return m.q === 0;
+}
+function rectIntoMetric(rect, m) {
+  if (!metricKeepsRects(m)) return null;
+  return { kind: "rect", x: m.p * rect.x, y: m.r * rect.y, width: m.p * rect.width, height: m.r * rect.height };
+}
+
+// src/tessellate/insets.ts
+var trimOf = (inset, ribbon) => inset === void 0 ? { length: 0, metric: ribbon } : typeof inset === "number" ? { length: inset, metric: ribbon } : inset;
+function trimInSpace(pl, from, ribbon, start, end) {
+  const s = trimOf(start, ribbon);
+  const e = trimOf(end, ribbon);
+  let cur = pl;
+  let space = from;
+  const moveTo = (to) => {
+    if (cur === null || sameMetric(space, to)) return;
+    if (space !== null) polylineOutOfMetric(cur, space);
+    if (to !== null) polylineIntoMetric(cur, to);
+    space = to;
+  };
+  if (s.length > 0 || e.length > 0) {
+    if (sameMetric(s.metric, e.metric)) {
+      moveTo(s.metric);
+      cur = trimPolyline(cur, s.length, e.length);
+    } else {
+      for (const [len, metric, atStart] of [[s.length, s.metric, true], [e.length, e.metric, false]]) {
+        if (!(len > 0) || cur === null) continue;
+        moveTo(metric);
+        cur = trimPolyline(cur, atStart ? len : 0, atStart ? 0 : len);
+      }
+    }
+  }
+  moveTo(ribbon);
+  return cur;
+}
+
+// src/tessellate/stroke.ts
+var EMPTY_MESH = {
+  vertices: new Float32Array(0),
+  indices: new Uint32Array(0),
+  anchorA: new Uint32Array(0),
+  anchorB: new Uint32Array(0),
+  anchorT: new Float32Array(0)
+};
+function resolveStrokeWidth(width, scale) {
+  return resolveScreenLength(width, scale);
+}
+function tessellateStroke(path, stroke, opts = {}) {
+  const width = resolveStrokeWidth(stroke.width ?? 1, 1);
+  if (width <= 0) return EMPTY_MESH;
+  const join = stroke.join ?? "miter";
+  const cap = stroke.cap ?? "butt";
+  const align = stroke.align ?? "center";
+  const miterLimit = stroke.miterLimit ?? DEFAULT_MITER_LIMIT;
+  const varyingThreshold = stroke.varyingWidthJoinThreshold ?? DEFAULT_VARYING_WIDTH_JOIN_THRESHOLD;
+  const metric = opts.metric;
+  const rectInMetric = metric && path.kind === "rect" ? rectIntoMetric(path, metric) : null;
+  let workingPath = rectInMetric ?? path;
+  if (workingPath.kind === "rect" && align !== "center") {
+    const aligned = alignedStrokeRect(workingPath, align, width);
+    workingPath = {
+      kind: "rect",
+      x: aligned.x,
+      y: aligned.y,
+      width: aligned.width,
+      height: aligned.height
+    };
+  }
+  const polylines = extractPolylines(workingPath, opts);
+  const vertexWidths = stroke.vertexWidths && stroke.vertexWidths.length > 0 ? stroke.vertexWidths : null;
+  const scale = !metric ? void 0 : rectInMetric ? (tx, ty) => worldWidthInMetric(metric, tx, ty) : (ux, uy) => worldWidthInMetricAlongWorld(metric, ux, uy);
+  const dash = stroke.dash ?? [];
+  const verts = [];
+  const idx = [];
+  const anchorA = [];
+  const anchorB = [];
+  const anchorT = [];
+  const ribbonSpace = metric ?? null;
+  for (const pl of polylines) {
+    if (vertexWidths) populatePolylineWidths(pl, vertexWidths, width, scale);
+    const trimmed = trimInSpace(pl, rectInMetric ? ribbonSpace : null, ribbonSpace, opts.startInset, opts.endInset);
+    if (trimmed === null) continue;
+    const subs = dash.length > 0 ? splitForDash(trimmed, dash) : [trimmed];
+    for (const sub of subs) {
+      expandPolyline(sub, width, join, cap, miterLimit, varyingThreshold, verts, idx, anchorA, anchorB, anchorT);
+    }
+  }
+  const vertices = new Float32Array(verts);
+  if (metric) coordsOutOfMetric(vertices, metric);
+  return {
+    vertices,
+    indices: new Uint32Array(idx),
+    anchorA: new Uint32Array(anchorA),
+    anchorB: new Uint32Array(anchorB),
+    anchorT: new Float32Array(anchorT)
+  };
+}
+function expandPolyline(pl, width, join, cap, miterLimit, varyingThreshold, verts, idx, anchorA, anchorB, anchorT) {
+  const half = width / 2;
+  const pts = pl.points;
+  const ptCount = pts.length / 2;
+  const segCount = ptCount - 1;
+  if (segCount < 1) return;
+  const plA = pl.anchorA ?? new Uint32Array(ptCount);
+  const plB = pl.anchorB ?? new Uint32Array(ptCount);
+  const plT = pl.anchorT ?? new Float32Array(ptCount);
+  const plHalf = pl.widths ? pl.widths.map((w) => w / 2) : null;
+  const segs = [];
+  const segSrcIdx = [];
+  for (let s = 0; s < segCount; s++) {
+    const ha = plHalf ? plHalf[s] : half;
+    const hb = plHalf ? plHalf[s + 1] : half;
+    const seg = makeSeg(pts[s * 2], pts[s * 2 + 1], pts[(s + 1) * 2], pts[(s + 1) * 2 + 1], ha, hb);
+    if (seg) {
+      segs.push(seg);
+      segSrcIdx.push(s);
+    }
+  }
+  let closerSrcIdx = -1;
+  if (pl.closed && segs.length >= 1) {
+    const last = segs[segs.length - 1];
+    const first = segs[0];
+    const haCloser = plHalf ? plHalf[ptCount - 1] : half;
+    const hbCloser = plHalf ? plHalf[0] : half;
+    const closer = makeSeg(last.bx, last.by, first.ax, first.ay, haCloser, hbCloser);
+    if (closer) {
+      segs.push(closer);
+      closerSrcIdx = ptCount - 1;
+      segSrcIdx.push(closerSrcIdx);
+    }
+  }
+  if (segs.length === 0) return;
+  const segBaseIdx = [];
+  for (let s = 0; s < segs.length; s++) {
+    const seg = segs[s];
+    const startSrc = segSrcIdx[s];
+    const endSrc = s === segs.length - 1 && pl.closed && closerSrcIdx >= 0 ? 0 : startSrc + 1;
+    const base = verts.length / 2;
+    segBaseIdx.push(base);
+    const nxA = seg.nxUnit * seg.halfA, nyA = seg.nyUnit * seg.halfA;
+    const nxB = seg.nxUnit * seg.halfB, nyB = seg.nyUnit * seg.halfB;
+    verts.push(seg.ax + nxA, seg.ay + nyA);
+    anchorA.push(plA[startSrc]);
+    anchorB.push(plB[startSrc]);
+    anchorT.push(plT[startSrc]);
+    verts.push(seg.ax - nxA, seg.ay - nyA);
+    anchorA.push(plA[startSrc]);
+    anchorB.push(plB[startSrc]);
+    anchorT.push(plT[startSrc]);
+    verts.push(seg.bx + nxB, seg.by + nyB);
+    anchorA.push(plA[endSrc]);
+    anchorB.push(plB[endSrc]);
+    anchorT.push(plT[endSrc]);
+    verts.push(seg.bx - nxB, seg.by - nyB);
+    anchorA.push(plA[endSrc]);
+    anchorB.push(plB[endSrc]);
+    anchorT.push(plT[endSrc]);
+    idx.push(base, base + 1, base + 2, base + 1, base + 3, base + 2);
+  }
+  const joinCount = pl.closed ? segs.length : segs.length - 1;
+  for (let j = 0; j < joinCount; j++) {
+    emitJoin(segs, segBaseIdx, j, join, miterLimit, varyingThreshold, verts, idx, anchorA, anchorB, anchorT, segSrcIdx, plA, plB, plT);
+  }
+  if (!pl.closed && cap !== "butt") {
+    const first = segs[0];
+    const firstBase = segBaseIdx[0];
+    emitCap(first, firstBase + 0, firstBase + 1, false, first.halfA, cap, verts, idx, anchorA, anchorB, anchorT, plA[0], plB[0], plT[0]);
+    const last = segs[segs.length - 1];
+    const lastBase = segBaseIdx[segs.length - 1];
+    const lastSrc = segSrcIdx[segs.length - 1] + 1;
+    emitCap(last, lastBase + 2, lastBase + 3, true, last.halfB, cap, verts, idx, anchorA, anchorB, anchorT, plA[lastSrc], plB[lastSrc], plT[lastSrc]);
+  }
+}
+var ROUND_CAP_STEP_RAD = 10 * Math.PI / 180;
+function emitCap(seg, leftIdx, rightIdx, atEnd, half, cap, verts, idx, anchorA, anchorB, anchorT, endA, endB, endT) {
+  const sign = atEnd ? 1 : -1;
+  const dx = (seg.bx - seg.ax) / seg.len * sign;
+  const dy = (seg.by - seg.ay) / seg.len * sign;
+  const cx = atEnd ? seg.bx : seg.ax;
+  const cy = atEnd ? seg.by : seg.ay;
+  const nx = seg.nxUnit * half;
+  const ny = seg.nyUnit * half;
+  if (cap === "square") {
+    const ox = cx + dx * half;
+    const oy = cy + dy * half;
+    const lOut = verts.length / 2;
+    verts.push(ox + nx, oy + ny);
+    anchorA.push(endA);
+    anchorB.push(endB);
+    anchorT.push(endT);
+    const rOut = verts.length / 2;
+    verts.push(ox - nx, oy - ny);
+    anchorA.push(endA);
+    anchorB.push(endB);
+    anchorT.push(endT);
+    if (atEnd) {
+      idx.push(leftIdx, lOut, rOut, leftIdx, rOut, rightIdx);
+    } else {
+      idx.push(leftIdx, rOut, lOut, leftIdx, rightIdx, rOut);
+    }
+    return;
+  }
+  if (cap === "round") {
+    const pivotIdx = verts.length / 2;
+    verts.push(cx, cy);
+    anchorA.push(endA);
+    anchorB.push(endB);
+    anchorT.push(endT);
+    const startAngle = Math.atan2(ny, nx);
+    const sweep = atEnd ? -Math.PI : Math.PI;
+    const steps = Math.max(1, Math.ceil(Math.abs(sweep) / ROUND_CAP_STEP_RAD));
+    const stepAngle = sweep / steps;
+    let prevIdx = leftIdx;
+    for (let i = 1; i < steps; i++) {
+      const ang = startAngle + i * stepAngle;
+      const fx = cx + Math.cos(ang) * half;
+      const fy = cy + Math.sin(ang) * half;
+      const newIdx = verts.length / 2;
+      verts.push(fx, fy);
+      anchorA.push(endA);
+      anchorB.push(endB);
+      anchorT.push(endT);
+      if (atEnd) idx.push(prevIdx, newIdx, pivotIdx);
+      else idx.push(prevIdx, pivotIdx, newIdx);
+      prevIdx = newIdx;
+    }
+    if (atEnd) idx.push(prevIdx, rightIdx, pivotIdx);
+    else idx.push(prevIdx, pivotIdx, rightIdx);
+  }
+}
+function makeSeg(ax, ay, bx, by, halfA, halfB) {
+  const dx = bx - ax, dy = by - ay;
+  const len = Math.hypot(dx, dy);
+  if (len === 0) return null;
+  return {
+    ax,
+    ay,
+    bx,
+    by,
+    nxUnit: -dy / len,
+    nyUnit: dx / len,
+    halfA,
+    halfB,
+    len
+  };
+}
+var DEFAULT_MITER_LIMIT = 4;
+var DEFAULT_VARYING_WIDTH_JOIN_THRESHOLD = 1.5;
+function emitJoin(segs, segBaseIdx, j, join, miterLimit, varyingThreshold, verts, idx, anchorA, anchorB, anchorT, segSrcIdx, plA, plB, plT) {
+  const a = segs[j];
+  const b = segs[(j + 1) % segs.length];
+  const aBase = segBaseIdx[j];
+  const bBase = segBaseIdx[(j + 1) % segs.length];
+  const adx = a.bx - a.ax, ady = a.by - a.ay;
+  const bdx = b.bx - b.ax, bdy = b.by - b.ay;
+  const cross = adx * bdy - ady * bdx;
+  if (cross === 0) return;
+  const onPositive = cross > 0;
+  const aOuterEnd = onPositive ? aBase + 3 : aBase + 2;
+  const bOuterStart = onPositive ? bBase + 1 : bBase + 0;
+  const nextSeg = (j + 1) % segs.length;
+  const cornerSrc = segSrcIdx[nextSeg];
+  const cornerA = plA[cornerSrc];
+  const cornerB = plB[cornerSrc];
+  const cornerT = plT[cornerSrc];
+  const halfAtCorner = a.halfB;
+  const taperA = Math.max(a.halfA, a.halfB) / Math.max(1e-9, Math.min(a.halfA, a.halfB));
+  const taperB = Math.max(b.halfA, b.halfB) / Math.max(1e-9, Math.min(b.halfA, b.halfB));
+  const forceBevelForVarying = taperA > varyingThreshold || taperB > varyingThreshold;
+  if (join === "bevel" || forceBevelForVarying) {
+    emitBevel(a, aOuterEnd, bOuterStart, onPositive, verts, idx, anchorA, anchorB, anchorT, cornerA, cornerB, cornerT);
+    return;
+  }
+  if (join === "miter") {
+    const aOX = verts[aOuterEnd * 2], aOY = verts[aOuterEnd * 2 + 1];
+    const bOX = verts[bOuterStart * 2], bOY = verts[bOuterStart * 2 + 1];
+    const apex = lineLineIntersect(aOX, aOY, adx, ady, bOX, bOY, -bdx, -bdy);
+    if (!apex) {
+      emitBevel(a, aOuterEnd, bOuterStart, onPositive, verts, idx, anchorA, anchorB, anchorT, cornerA, cornerB, cornerT);
+      return;
+    }
+    const miterLen = Math.hypot(apex[0] - a.bx, apex[1] - a.by);
+    if (miterLen > miterLimit * halfAtCorner) {
+      emitBevel(a, aOuterEnd, bOuterStart, onPositive, verts, idx, anchorA, anchorB, anchorT, cornerA, cornerB, cornerT);
+      return;
+    }
+    const apexIdx = verts.length / 2;
+    verts.push(apex[0], apex[1]);
+    anchorA.push(cornerA);
+    anchorB.push(cornerB);
+    anchorT.push(cornerT);
+    const jIdx = verts.length / 2;
+    verts.push(a.bx, a.by);
+    anchorA.push(cornerA);
+    anchorB.push(cornerB);
+    anchorT.push(cornerT);
+    if (onPositive) {
+      idx.push(aOuterEnd, apexIdx, bOuterStart);
+      idx.push(aOuterEnd, bOuterStart, jIdx);
+    } else {
+      idx.push(aOuterEnd, bOuterStart, apexIdx);
+      idx.push(aOuterEnd, jIdx, bOuterStart);
+    }
+    return;
+  }
+  if (join === "round") {
+    emitRoundJoin(a, aOuterEnd, bOuterStart, onPositive, verts, idx, anchorA, anchorB, anchorT, cornerA, cornerB, cornerT);
+    return;
+  }
+}
+var ROUND_STEP_RAD = 10 * Math.PI / 180;
+function emitRoundJoin(a, aOuterEnd, bOuterStart, onPositive, verts, idx, anchorA, anchorB, anchorT, cornerA, cornerB, cornerT) {
+  const cx = a.bx, cy = a.by;
+  const pivotIdx = verts.length / 2;
+  verts.push(cx, cy);
+  anchorA.push(cornerA);
+  anchorB.push(cornerB);
+  anchorT.push(cornerT);
+  const startX = verts[aOuterEnd * 2] - cx;
+  const startY = verts[aOuterEnd * 2 + 1] - cy;
+  const endX = verts[bOuterStart * 2] - cx;
+  const endY = verts[bOuterStart * 2 + 1] - cy;
+  const r = Math.hypot(startX, startY);
+  const startAngle = Math.atan2(startY, startX);
+  const endAngle = Math.atan2(endY, endX);
+  let sweep = endAngle - startAngle;
+  if (onPositive && sweep < 0) sweep += 2 * Math.PI;
+  else if (!onPositive && sweep > 0) sweep -= 2 * Math.PI;
+  const steps = Math.max(1, Math.ceil(Math.abs(sweep) / ROUND_STEP_RAD));
+  const stepAngle = sweep / steps;
+  let prevIdx = aOuterEnd;
+  for (let i = 1; i < steps; i++) {
+    const ang = startAngle + i * stepAngle;
+    const fx = cx + Math.cos(ang) * r;
+    const fy = cy + Math.sin(ang) * r;
+    const newIdx = verts.length / 2;
+    verts.push(fx, fy);
+    anchorA.push(cornerA);
+    anchorB.push(cornerB);
+    anchorT.push(cornerT);
+    if (onPositive) idx.push(prevIdx, pivotIdx, newIdx);
+    else idx.push(prevIdx, newIdx, pivotIdx);
+    prevIdx = newIdx;
+  }
+  if (onPositive) idx.push(prevIdx, pivotIdx, bOuterStart);
+  else idx.push(prevIdx, bOuterStart, pivotIdx);
+}
+function emitBevel(a, aOuterEnd, bOuterStart, onPositive, verts, idx, anchorA, anchorB, anchorT, cornerA, cornerB, cornerT) {
+  const jIdx = verts.length / 2;
+  verts.push(a.bx, a.by);
+  anchorA.push(cornerA);
+  anchorB.push(cornerB);
+  anchorT.push(cornerT);
+  if (onPositive) idx.push(aOuterEnd, jIdx, bOuterStart);
+  else idx.push(aOuterEnd, bOuterStart, jIdx);
+}
+function lineLineIntersect(apx, apy, adx, ady, bpx, bpy, bdx, bdy) {
+  const denom = adx * bdy - ady * bdx;
+  if (Math.abs(denom) < 1e-9) return null;
+  const t = ((bpx - apx) * bdy - (bpy - apy) * bdx) / denom;
+  return [apx + t * adx, apy + t * ady];
+}
+function resolveMarkerSize(ref, strokeWidth, scale = 1) {
+  if (typeof ref === "string" || ref.size === void 0) return strokeWidth;
+  return resolveScreenLength(ref.size, scale);
+}
+function markerKeyOf(ref) {
+  return typeof ref === "string" ? ref : ref.key;
+}
+function markerInset(ref, strokeWidth, scale = 1) {
+  if (ref === void 0) return 0;
+  const entry = getMarker(markerKeyOf(ref));
+  if (entry === void 0) return 0;
+  return (entry.inset ?? 0) * resolveMarkerSize(ref, strokeWidth, scale);
+}
+function strokeInsets(stroke, strokeWidth) {
+  return {
+    start: markerInset(stroke.markerStart, strokeWidth),
+    end: markerInset(stroke.markerEnd, strokeWidth)
+  };
+}
+
+// src/markerSites.ts
+var EPS = 1e-9;
+function dir(pl, i, j) {
+  const dx = pl.points[j * 2] - pl.points[i * 2];
+  const dy = pl.points[j * 2 + 1] - pl.points[i * 2 + 1];
+  const len = Math.hypot(dx, dy);
+  if (len < EPS) return null;
+  return { x: dx / len, y: dy / len };
+}
+function nextDistinct(pl, i, n) {
+  for (let k = i + 1; k < n; k++) if (dir(pl, i, k)) return k;
+  return -1;
+}
+function prevDistinct(pl, i) {
+  for (let k = i - 1; k >= 0; k--) if (dir(pl, k, i)) return k;
+  return -1;
+}
+function markerSites(pl, want) {
+  const out = [];
+  const n = pl.points.length / 2;
+  if (n < 2) return out;
+  if (want.start && !pl.closed) {
+    const j = nextDistinct(pl, 0, n);
+    const d = j >= 0 ? dir(pl, 0, j) : null;
+    if (d) {
+      out.push({ x: pl.points[0], y: pl.points[1], angle: Math.atan2(-d.y, -d.x), role: "start" });
+    }
+  }
+  if (want.mid) {
+    const A = pl.anchorA, B = pl.anchorB, T = pl.anchorT;
+    if (A && B && T) {
+      for (let i = 1; i < n - 1; i++) {
+        if (A[i] !== B[i] || T[i] !== 0) continue;
+        const p = prevDistinct(pl, i);
+        const q = nextDistinct(pl, i, n);
+        if (p < 0 || q < 0) continue;
+        const inDir = dir(pl, p, i);
+        const outDir = dir(pl, i, q);
+        let bx = inDir.x + outDir.x;
+        let by = inDir.y + outDir.y;
+        if (Math.hypot(bx, by) < EPS) {
+          bx = inDir.x;
+          by = inDir.y;
+        }
+        out.push({ x: pl.points[i * 2], y: pl.points[i * 2 + 1], angle: Math.atan2(by, bx), role: "mid" });
+      }
+    }
+  }
+  if (want.end && !pl.closed) {
+    const last = n - 1;
+    const p = prevDistinct(pl, last);
+    const d = p >= 0 ? dir(pl, p, last) : null;
+    if (d) {
+      out.push({ x: pl.points[last * 2], y: pl.points[last * 2 + 1], angle: Math.atan2(d.y, d.x), role: "end" });
+    }
+  }
+  return out;
+}
+function placed(path, site) {
+  const src = path;
+  const cos = Math.cos(site.angle);
+  const sin = Math.sin(site.angle);
+  const coords = new Float32Array(src.coords.length);
+  for (let i = 0; i < src.coords.length; i += 2) {
+    const x = src.coords[i], y = src.coords[i + 1];
+    coords[i] = site.x + x * cos - y * sin;
+    coords[i + 1] = site.y + x * sin + y * cos;
+  }
+  return { kind: "polygon", commands: src.commands, coords, fillRule: src.fillRule };
+}
+function markerHeads(path, stroke, strokeWidth, flattenTolerance, spaces = {}) {
+  const refs = { start: stroke.markerStart, mid: stroke.markerMid, end: stroke.markerEnd };
+  if (refs.start === void 0 && refs.mid === void 0 && refs.end === void 0) return [];
+  const groups = /* @__PURE__ */ new Map();
+  for (const role of ["start", "mid", "end"]) {
+    if (refs[role] === void 0) continue;
+    const space = spaces[role];
+    let want = groups.get(space);
+    if (want === void 0) groups.set(space, want = { start: false, mid: false, end: false });
+    want[role] = true;
+  }
+  const out = [];
+  for (const pl of extractPolylines(path, { flattenTolerance })) {
+    for (const [space, want] of groups) {
+      const inSpace = space ? { ...pl, points: pl.points.slice() } : pl;
+      if (space) polylineIntoMetric(inSpace, space.metric);
+      for (const site of markerSites(inSpace, want)) {
+        const ref = refs[site.role];
+        if (ref === void 0) continue;
+        const entry = getMarker(markerKeyOf(ref));
+        if (entry === void 0) continue;
+        const size = resolveMarkerSize(ref, strokeWidth);
+        const angle = entry.orient === void 0 || entry.orient === "auto" ? site.angle : entry.orient;
+        const head = placed(entry.path({ size, stroke }), { ...site, angle });
+        if (space) coordsOutOfMetric(head.coords, space.metric);
+        out.push(space ? { entry, size, path: head, space } : { entry, size, path: head });
+      }
+    }
+  }
+  return out;
+}
+function markerReadsKey(entry, stroke) {
+  if (entry.reads === void 0) return null;
+  let key = "";
+  for (const field of entry.reads) key += `${JSON.stringify(stroke[field]) ?? ""}|`;
+  return key;
+}
+var READINGS_PER_ENTRY = 64;
+var REACH_BY_READING = /* @__PURE__ */ new WeakMap();
+var REACH_BY_STROKE = /* @__PURE__ */ new WeakMap();
+function measureUnitReach(entry, stroke) {
+  const b = boundsOfPath(entry.path({ size: 1, stroke }));
+  return Math.max(Math.abs(b.x), Math.abs(b.x + b.width), Math.abs(b.y), Math.abs(b.y + b.height)) + (entry.outline ? entry.outline.width / 2 : 0);
+}
+function unitReach(entry, stroke) {
+  const key = markerReadsKey(entry, stroke);
+  if (key === null) {
+    let byStroke = REACH_BY_STROKE.get(entry);
+    if (byStroke === void 0) REACH_BY_STROKE.set(entry, byStroke = /* @__PURE__ */ new WeakMap());
+    let reach2 = byStroke.get(stroke);
+    if (reach2 === void 0) byStroke.set(stroke, reach2 = measureUnitReach(entry, stroke));
+    return reach2;
+  }
+  let byReading = REACH_BY_READING.get(entry);
+  if (byReading === void 0) REACH_BY_READING.set(entry, byReading = /* @__PURE__ */ new Map());
+  let reach = byReading.get(key);
+  if (reach === void 0) {
+    if (byReading.size >= READINGS_PER_ENTRY) byReading.clear();
+    byReading.set(key, reach = measureUnitReach(entry, stroke));
+  }
+  return reach;
+}
+function markerReach(stroke) {
+  const reach = { world: 0, px: 0 };
+  const width = stroke.width ?? 1;
+  for (const ref of [stroke.markerStart, stroke.markerMid, stroke.markerEnd]) {
+    if (ref === void 0) continue;
+    const entry = getMarker(markerKeyOf(ref));
+    if (entry === void 0) continue;
+    const size = typeof ref === "string" || ref.size === void 0 ? width : ref.size;
+    const unit = unitReach(entry, stroke);
+    if (typeof size === "number") reach.world = Math.max(reach.world, unit * size);
+    else reach.px = Math.max(reach.px, unit * size.px);
+  }
+  return reach;
+}
+var EMPTY = {
+  kind: "polygon",
+  commands: new Uint8Array(0),
+  coords: new Float32Array(0),
+  fillRule: "nonzero"
+};
+function strokeToPath(path, stroke, opts = {}) {
+  const width = resolveStrokeWidth(stroke.width ?? 1, opts.scale ?? 1);
+  if (!(width > 0)) return EMPTY;
+  const tolerance = opts.flattenTolerance;
+  const sized = { ...stroke, width };
+  const insets = strokeInsets(sized, width);
+  const align = stroke.align ?? "center";
+  const cut = align !== "center" && path.kind !== "rect";
+  const ribbonStroke = cut ? { ...sized, width: width * 2, align: "center", vertexWidths: stroke.vertexWidths?.map((w) => w * 2) } : sized;
+  const mesh = tessellateStroke(path, ribbonStroke, {
+    flattenTolerance: tolerance,
+    startInset: insets.start,
+    endInset: insets.end
+  });
+  let ribbon = trianglesToPath(mesh.vertices, mesh.indices);
+  if (cut) ribbon = align === "inner" ? pathIntersect(ribbon, path) : pathSubtract(ribbon, path);
+  const heads = [];
+  for (const { entry, path: head, size } of markerHeads(path, sized, width, tolerance)) {
+    if ((entry.fill ?? "line") !== "none") heads.push(head);
+    if (entry.outline && (entry.outline.paint ?? "line") !== "none") {
+      heads.push(strokeToPath(head, { width: entry.outline.width * size, cap: "round", join: "round" }, opts));
+    }
+  }
+  return heads.length === 0 ? ribbon : pathUnion(ribbon, ...heads);
+}
+
+export { coordsOutOfMetric, markerHeads, markerInset, markerKeyOf, markerReach, markerReadsKey, markerSites, metricKeepsRects, metricKey, polylineIntoMetric, polylineOutOfMetric, populatePolylineWidths, rectIntoMetric, resolveMarkerSize, resolveStrokeWidth, sameMetric, screenSpaceKey, splitForDash, strokeInsets, strokeSpaceOf, strokeToPath, tessellateStroke, trimInSpace, worldWidthInMetric, worldWidthInMetricAlongWorld };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map