@weasel-js/stroke 1.10.0 → 1.11.0

package/dist/index.js

@@ -1,153 +1,185 @@
 import { getMarker } from './chunk-FQB7N6YD.js';
 export { BUILTIN_MARKERS, getMarker, listMarkers, markerGeneration, markerRegistry, registerMarker } from './chunk-FQB7N6YD.js';
-import { resolveScreenLength, alignedStrokeRect } from '@weasel-js/paint';
-import { trimPolyline, extractPolylines } from '@weasel-js/geom/tessellate';
-import { invert, transformPath, boundsOfPath } from '@weasel-js/geom';
+import { resolveCornersWithSources, remapPerAnchor, pointInPath, invert, transformPath, resolveCorners, offsetCornerTraces, restoreCorners, simplifyPath, anchorsToPath, pathToAnchors, DEFAULT_FLATTEN_TOLERANCE, boundsOfPath } from '@weasel-js/geom';
+import { widestHalfWidth, resolveScreenLength, alignedStrokeRect, scaleVertexWidth, vertexHalfWidths } from '@weasel-js/paint';
+import { anchorParamsBetween, trimPolyline, extractPolylines } from '@weasel-js/geom/tessellate';
 import { trianglesToPath, pathIntersect, pathSubtract, pathUnion } from '@weasel-js/geom/booleans';
 
-// src/tessellate/dash.ts
+function runFrom(p, widths, offsets) {
+  return { pts: [p.x, p.y], a: [p.a], b: [p.b], t: [p.t], w: widths ? [p.w] : null, o: offsets ? [p.o] : null };
+}
+function extend(run, p) {
+  run.pts.push(p.x, p.y);
+  run.a.push(p.a);
+  run.b.push(p.b);
+  run.t.push(p.t);
+  run.w?.push(p.w);
+  run.o?.push(p.o);
+}
+function toPolyline(run, closed = false) {
+  const pl = {
+    points: run.pts,
+    closed,
+    anchorA: new Uint32Array(run.a),
+    anchorB: new Uint32Array(run.b),
+    anchorT: new Float32Array(run.t)
+  };
+  if (run.w) pl.widths = new Float32Array(run.w);
+  if (run.o) pl.offsets = new Float32Array(run.o);
+  return pl;
+}
 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);
+  const ptCount = pl.points.length / 2;
+  const plA = pl.anchorA ?? new Uint32Array(ptCount);
+  const plB = pl.anchorB ?? new Uint32Array(ptCount);
+  const plT = pl.anchorT ?? new Float32Array(ptCount);
+  const W = pl.widths;
+  const O = pl.offsets;
+  const pointAt = (i) => ({
+    x: pl.points[i * 2],
+    y: pl.points[i * 2 + 1],
+    a: plA[i],
+    b: plB[i],
+    t: plT[i],
+    w: W ? W[i] : 0,
+    o: O ? O[i] : 0
+  });
   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;
+  let cur = runFrom(pointAt(0), !!W, !!O);
+  const flushAndAdvance = (at) => {
+    if (cur && cur.pts.length >= 4) out.push(toPolyline(cur));
     dashIdx = (dashIdx + 1) % dash.length;
     dashRemaining = dash[dashIdx];
     onPhase = !onPhase;
+    cur = onPhase ? runFrom(at, !!W, !!O) : null;
   };
   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;
+    const start = pointAt(i);
+    const end = pointAt((i + 1) % ptCount);
+    const segFullLen = Math.hypot(end.x - prevX, end.y - prevY);
+    if (segFullLen <= 1e-9) {
+      if (onPhase && cur) extend(cur, end);
+      continue;
+    }
     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);
-        }
+        if (onPhase && cur) extend(cur, end);
         dashRemaining -= segLen;
-        prevX = cx;
-        prevY = cy;
-        traveled = segFullLen;
+        prevX = end.x;
+        prevY = end.y;
         segLen = 0;
-        if (dashRemaining <= 1e-9) {
-          flushAndAdvance();
-          if (onPhase) {
-            curPts = [prevX, prevY];
-            curA = [endA];
-            curB = [endB];
-            curT = [endT];
-          }
-        }
+        if (dashRemaining <= 1e-9) flushAndAdvance(end);
       } 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];
-        }
+        const [a, b, t] = anchorParamsBetween(start.a, start.b, start.t, end.a, end.b, end.t, frac);
+        const mid = {
+          x: start.x + (end.x - start.x) * frac,
+          y: start.y + (end.y - start.y) * frac,
+          a,
+          b,
+          t,
+          w: start.w + (end.w - start.w) * frac,
+          o: start.o + (end.o - start.o) * frac
+        };
+        if (onPhase && cur) extend(cur, mid);
+        prevX = mid.x;
+        prevY = mid.y;
+        segLen = Math.hypot(end.x - prevX, end.y - prevY);
+        flushAndAdvance(mid);
       }
     }
   }
-  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);
-    }
-  }
+  const tail = cur;
+  if (tail && tail.pts.length >= 4) closeOut(pl, tail, out);
   return out;
 }
+function closeOut(pl, tail, out) {
+  const tx = tail.pts[tail.pts.length - 2], ty = tail.pts[tail.pts.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(toPolyline(tail), out[0]);
+  } else if (pl.closed && out.length === 0 && meets(tail.pts[0], tail.pts[1])) {
+    out.push(toPolyline({
+      pts: tail.pts.slice(0, -2),
+      a: tail.a.slice(0, -1),
+      b: tail.b.slice(0, -1),
+      t: tail.t.slice(0, -1),
+      w: tail.w ? tail.w.slice(0, -1) : null,
+      o: tail.o ? tail.o.slice(0, -1) : null
+    }, true));
+  } else {
+    out.push(toPolyline(tail));
+  }
+}
 function joinAtSeam(tail, head) {
-  return {
+  const pl = {
     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)])
   };
+  if (tail.widths && head.widths) pl.widths = Float32Array.from([...tail.widths, ...head.widths.subarray(1)]);
+  if (tail.offsets && head.offsets) pl.offsets = Float32Array.from([...tail.offsets, ...head.offsets.subarray(1)]);
+  return pl;
+}
+
+// src/tessellate/nib.ts
+function nibWidthScale(nib) {
+  const ex = Math.cos(nib.angle), ey = -Math.sin(nib.angle);
+  const r = Math.min(1, Math.max(0, nib.ratio));
+  return (tx, ty) => {
+    const across = ex * ty - ey * tx;
+    const along = ex * tx + ey * ty;
+    return Math.sqrt(across * across + r * r * along * along);
+  };
+}
+function applyNib(pl, nib, base) {
+  const n = pl.points.length / 2;
+  if (n < 2) return;
+  const P = pl.points;
+  const scale = nibWidthScale(nib);
+  const segCount = pl.closed ? n : n - 1;
+  const factors = [];
+  for (let i = 0; i < segCount; i++) {
+    const j = (i + 1) % n;
+    const dx = P[j * 2] - P[i * 2], dy = P[j * 2 + 1] - P[i * 2 + 1];
+    const len = Math.hypot(dx, dy);
+    factors.push(len > 0 ? scale(dx / len, dy / len) : NaN);
+  }
+  for (let i = 0; i < segCount; i++) {
+    if (Number.isNaN(factors[i])) factors[i] = i > 0 ? factors[i - 1] : factors.find((f) => !Number.isNaN(f)) ?? 1;
+  }
+  const A = pl.anchorA, B = pl.anchorB, T = pl.anchorT, W = pl.widths, O = pl.offsets;
+  const pts = [], aA = [], aB = [], aT = [], ws = [], os = [];
+  const push = (i, factor) => {
+    pts.push(P[i * 2], P[i * 2 + 1]);
+    aA.push(A ? A[i] : 0);
+    aB.push(B ? B[i] : 0);
+    aT.push(T ? T[i] : 0);
+    ws.push((W ? W[i] : base) * factor);
+    if (O) os.push(O[i] * factor);
+  };
+  push(0, factors[0]);
+  for (let i = 1; i < n; i++) {
+    push(i, factors[i - 1]);
+    if (i < segCount) push(i, factors[i]);
+  }
+  if (pl.closed) push(0, factors[segCount - 1]);
+  pl.points = pts;
+  pl.anchorA = Uint32Array.from(aA);
+  pl.anchorB = Uint32Array.from(aB);
+  pl.anchorT = Float32Array.from(aT);
+  pl.widths = Float32Array.from(ws);
+  if (O) pl.offsets = Float32Array.from(os);
 }
 
 // src/tessellate/vertexWidths.ts
@@ -158,23 +190,36 @@ function populatePolylineWidths(pl, vertexWidths, fallbackWidth, scale) {
   const aB = pl.anchorB ?? new Uint32Array(ptCount);
   const aT = pl.anchorT ?? new Float32Array(ptCount);
   const widths = new Float32Array(ptCount);
+  const offsets = new Float32Array(ptCount);
+  let sided = false;
+  const fallback = fallbackWidth / 2;
   let k = 1;
-  const read = (i) => {
-    const v = vertexWidths[i];
-    return typeof v === "number" && isFinite(v) && v > 0 ? v * k : fallbackWidth;
+  const sides = (i) => {
+    const h = vertexHalfWidths(vertexWidths[i], NaN);
+    return [Number.isNaN(h.left) ? fallback : h.left * k, Number.isNaN(h.right) ? fallback : h.right * k];
   };
   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;
+    let [left, right] = sides(a);
+    if (a !== b) {
+      const [lb, rb] = sides(b);
+      left += (lb - left) * t;
+      right += (rb - right) * t;
     }
+    widths[i] = left + right;
+    offsets[i] = (right - left) / 2;
+    if (offsets[i] !== 0) sided = true;
   }
   pl.widths = widths;
+  if (sided) pl.offsets = offsets;
+}
+function widestStrokeWidth(width, vertexWidths) {
+  return 2 * widestHalfWidth(width, vertexWidths);
+}
+function populateWidths(pl, vertexWidths, nib, width, scale) {
+  if (vertexWidths) populatePolylineWidths(pl, vertexWidths, width, scale);
+  if (nib) applyNib(pl, nib, width);
 }
 function scaleAt(pl, i, scale) {
   const pts = pl.points;
@@ -196,6 +241,14 @@ function scaleAt(pl, i, scale) {
   return len > 0 ? scale(tx / len, ty / len) : 1;
 }
 
+// src/tessellate/flattening.ts
+var STROKE_MAX_TURN = Math.PI / 18;
+function strokeFlattening(flattenTolerance, width, vertexWidths) {
+  const tolerance = flattenTolerance ?? DEFAULT_FLATTEN_TOLERANCE;
+  const widest = widestStrokeWidth(width, vertexWidths);
+  return widest / 2 > tolerance ? { flattenTolerance, maxTurn: STROKE_MAX_TURN } : { flattenTolerance };
+}
+
 // src/tessellate/metric.ts
 function screenSpaceKey(space) {
   return space === void 0 ? "" : `${metricKey(space.metric)}@${space.pxPerUnit}`;
@@ -290,150 +343,16 @@ function trimInSpace(pl, from, ribbon, start, end) {
   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]);
-  }
-}
+// src/tessellate/ribbon.ts
 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) {
+function emitCap(seg, leftIdx, rightIdx, atEnd, pos, neg, 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 half = (pos + neg) / 2;
+  const shift = (pos - neg) / 2;
+  const cx = (atEnd ? seg.bx : seg.ax) + seg.nxUnit * shift;
+  const cy = (atEnd ? seg.by : seg.ay) + seg.nyUnit * shift;
   const nx = seg.nxUnit * half;
   const ny = seg.nyUnit * half;
   if (cap === "square") {
@@ -484,7 +403,7 @@ function emitCap(seg, leftIdx, rightIdx, atEnd, half, cap, verts, idx, anchorA,
     else idx.push(prevIdx, pivotIdx, rightIdx);
   }
 }
-function makeSeg(ax, ay, bx, by, halfA, halfB) {
+function makeSeg(ax, ay, bx, by, posA, negA, posB, negB) {
   const dx = bx - ax, dy = by - ay;
   const len = Math.hypot(dx, dy);
   if (len === 0) return null;
@@ -495,13 +414,13 @@ function makeSeg(ax, ay, bx, by, halfA, halfB) {
     by,
     nxUnit: -dy / len,
     nyUnit: dx / len,
-    halfA,
-    halfB,
+    posA,
+    negA,
+    posB,
+    negB,
     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];
@@ -519,9 +438,11 @@ function emitJoin(segs, segBaseIdx, j, join, miterLimit, varyingThreshold, verts
   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 outerA = onPositive ? [a.negA, a.negB] : [a.posA, a.posB];
+  const outerB = onPositive ? [b.negA, b.negB] : [b.posA, b.posB];
+  const halfAtCorner = outerA[1];
+  const taperA = Math.max(...outerA) / Math.max(1e-9, Math.min(...outerA));
+  const taperB = Math.max(...outerB) / Math.max(1e-9, Math.min(...outerB));
   const forceBevelForVarying = taperA > varyingThreshold || taperB > varyingThreshold;
   if (join === "bevel" || forceBevelForVarying) {
     emitBevel(a, aOuterEnd, bOuterStart, onPositive, verts, idx, anchorA, anchorB, anchorT, cornerA, cornerB, cornerT);
@@ -576,7 +497,7 @@ function emitRoundJoin(a, aOuterEnd, bOuterStart, onPositive, verts, idx, anchor
   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 r0 = Math.hypot(startX, startY), r1 = Math.hypot(endX, endY);
   const startAngle = Math.atan2(startY, startX);
   const endAngle = Math.atan2(endY, endX);
   let sweep = endAngle - startAngle;
@@ -587,10 +508,9 @@ function emitRoundJoin(a, aOuterEnd, bOuterStart, onPositive, verts, idx, anchor
   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);
+    const r = r0 + (r1 - r0) * i / steps;
+    verts.push(cx + Math.cos(ang) * r, cy + Math.sin(ang) * r);
+    const newIdx = verts.length / 2 - 1;
     anchorA.push(cornerA);
     anchorB.push(cornerB);
     anchorT.push(cornerT);
@@ -616,6 +536,139 @@ function lineLineIntersect(apx, apy, adx, ady, bpx, bpy, bdx, bdy) {
   const t = ((bpx - apx) * bdy - (bpy - apy) * bdx) / denom;
   return [apx + t * adx, apy + t * ady];
 }
+
+// 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") {
+    workingPath = { kind: "rect", ...alignedStrokeRect(workingPath, align, width) };
+  }
+  const resolved = workingPath.kind === "polygon" ? resolveCornersWithSources(workingPath) : null;
+  if (resolved) workingPath = resolved.path;
+  const given = stroke.vertexWidths && stroke.vertexWidths.length > 0 ? stroke.vertexWidths : null;
+  const vertexWidths = given && resolved?.anchorSources ? remapPerAnchor(given, resolved.anchorSources, 1) : given;
+  const polylines = extractPolylines(workingPath, strokeFlattening(opts.flattenTolerance, width, vertexWidths ?? void 0));
+  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) {
+    populateWidths(pl, vertexWidths, stroke.nib, 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 W = pl.widths, O = pl.offsets;
+  const pos = (i) => (W ? W[i] / 2 : half) + (O ? O[i] : 0);
+  const neg = (i) => (W ? W[i] / 2 : half) - (O ? O[i] : 0);
+  const segs = [];
+  const segSrcIdx = [];
+  for (let s = 0; s < segCount; s++) {
+    const seg = makeSeg(pts[s * 2], pts[s * 2 + 1], pts[(s + 1) * 2], pts[(s + 1) * 2 + 1], pos(s), neg(s), pos(s + 1), neg(s + 1));
+    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 closer = makeSeg(last.bx, last.by, first.ax, first.ay, pos(ptCount - 1), neg(ptCount - 1), pos(0), neg(0));
+    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 { nxUnit: nx, nyUnit: ny } = seg;
+    verts.push(seg.ax + nx * seg.posA, seg.ay + ny * seg.posA);
+    anchorA.push(plA[startSrc]);
+    anchorB.push(plB[startSrc]);
+    anchorT.push(plT[startSrc]);
+    verts.push(seg.ax - nx * seg.negA, seg.ay - ny * seg.negA);
+    anchorA.push(plA[startSrc]);
+    anchorB.push(plB[startSrc]);
+    anchorT.push(plT[startSrc]);
+    verts.push(seg.bx + nx * seg.posB, seg.by + ny * seg.posB);
+    anchorA.push(plA[endSrc]);
+    anchorB.push(plB[endSrc]);
+    anchorT.push(plT[endSrc]);
+    verts.push(seg.bx - nx * seg.negB, seg.by - ny * seg.negB);
+    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.posA, first.negA, 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.posB, last.negB, cap, verts, idx, anchorA, anchorB, anchorT, plA[lastSrc], plB[lastSrc], plT[lastSrc]);
+  }
+}
+var DEFAULT_MITER_LIMIT = 4;
+var DEFAULT_VARYING_WIDTH_JOIN_THRESHOLD = 1.5;
 function resolveMarkerSize(ref, strokeWidth, scale = 1) {
   if (typeof ref === "string" || ref.size === void 0) return strokeWidth;
   return resolveScreenLength(ref.size, scale);
@@ -718,7 +771,7 @@ function markerHeads(path, stroke, strokeWidth, flattenTolerance, spaces = {}) {
     want[role] = true;
   }
   const out = [];
-  for (const pl of extractPolylines(path, { flattenTolerance })) {
+  for (const pl of extractPolylines(path, strokeFlattening(flattenTolerance, strokeWidth, stroke.vertexWidths))) {
     for (const [space, want] of groups) {
       const inSpace = space ? { ...pl, points: pl.points.slice() } : pl;
       if (space) polylineIntoMetric(inSpace, space.metric);
@@ -782,6 +835,74 @@ function markerReach(stroke) {
   }
   return reach;
 }
+function strokeEdgeNear(path, stroke, x, y, opts = {}) {
+  const width = resolveStrokeWidth(stroke.width ?? 1, opts.scale ?? 1);
+  const vw = stroke.vertexWidths && stroke.vertexWidths.length > 0 ? stroke.vertexWidths : null;
+  const nibScale = stroke.nib ? nibWidthScale(stroke.nib) : null;
+  const align = stroke.align ?? "center";
+  let best = null;
+  for (const pl of extractPolylines(path, strokeFlattening(opts.flattenTolerance, width, vw ?? void 0))) {
+    populateWidths(pl, vw, stroke.nib, width);
+    const P = pl.points, W = pl.widths, O = pl.offsets;
+    const n = P.length / 2;
+    const segCount = pl.closed ? n : n - 1;
+    const inked = align === "center" ? null : inkedSide(path, P, segCount, align === "inner");
+    for (let i = 0; i < segCount; i++) {
+      const j = (i + 1) % n;
+      const ax = P[i * 2], ay = P[i * 2 + 1];
+      const dx = P[j * 2] - ax, dy = P[j * 2 + 1] - ay;
+      const len2 = dx * dx + dy * dy;
+      if (len2 === 0) continue;
+      const len = Math.sqrt(len2);
+      const f = Math.min(1, Math.max(0, ((x - ax) * dx + (y - ay) * dy) / len2));
+      const fx = ax + dx * f, fy = ay + dy * f;
+      const rx = -dy / len, ry = dx / len;
+      const d = (x - fx) * rx + (y - fy) * ry;
+      const w = W ? W[i] + (W[j] - W[i]) * f : width;
+      const o = O ? O[i] + (O[j] - O[i]) * f : 0;
+      const side = inked ?? (d >= 0 ? "right" : "left");
+      const scale = inked ? 2 : 1;
+      const left = inked === "right" ? 0 : scale * (w / 2 - o);
+      const right = inked === "left" ? 0 : scale * (w / 2 + o);
+      const edge = side === "right" ? right : left;
+      const off = Math.hypot(x - fx, y - fy);
+      const gap = inked && d >= 0 !== (inked === "right") ? off + edge : off - edge;
+      if (best !== null && Math.abs(gap) >= Math.abs(best.gap)) continue;
+      const sign = side === "right" ? 1 : -1;
+      best = {
+        x: fx,
+        y: fy,
+        nx: rx * sign,
+        ny: ry * sign,
+        side,
+        left,
+        right,
+        gap,
+        factor: scale * (nibScale ? nibScale(dx / len, dy / len) : 1)
+      };
+    }
+  }
+  return best;
+}
+function inkedSide(path, P, segCount, inner) {
+  const n = P.length / 2;
+  let at = -1, longest = 0;
+  for (let i = 0; i < segCount; i++) {
+    const j2 = (i + 1) % n;
+    const l = Math.hypot(P[j2 * 2] - P[i * 2], P[j2 * 2 + 1] - P[i * 2 + 1]);
+    if (l > longest) {
+      longest = l;
+      at = i;
+    }
+  }
+  if (at < 0) return inner ? "right" : "left";
+  const j = (at + 1) % n;
+  const dx = P[j * 2] - P[at * 2], dy = P[j * 2 + 1] - P[at * 2 + 1];
+  const probe = Math.min(longest, 1) * 1e-3;
+  const mx = (P[at * 2] + P[j * 2]) / 2 - dy / longest * probe;
+  const my = (P[at * 2 + 1] + P[j * 2 + 1]) / 2 + dx / longest * probe;
+  return pointInPath(path, mx, my) === inner ? "right" : "left";
+}
 var EMPTY = {
   kind: "polygon",
   commands: new Uint8Array(0),
@@ -803,7 +924,7 @@ function outlineOf(path, stroke, opts) {
   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 ribbonStroke = cut ? { ...sized, width: width * 2, align: "center", vertexWidths: stroke.vertexWidths?.map((w) => scaleVertexWidth(w, 2)) } : sized;
   const mesh = tessellateStroke(path, ribbonStroke, {
     flattenTolerance: tolerance,
     startInset: insets.start,
@@ -820,7 +941,31 @@ function outlineOf(path, stroke, opts) {
   }
   return heads.length === 0 ? ribbon : pathUnion(ribbon, ...heads);
 }
+function offsetPath(path, distance, opts = {}) {
+  if (distance === 0) return closedRegion(path);
+  const region = closedRegion(resolveCorners(path));
+  const tolerance = opts.tolerance ?? 0.1;
+  const band = strokeToPath(region, {
+    width: Math.abs(distance) * 2,
+    join: opts.join ?? "miter",
+    miterLimit: opts.miterLimit ?? 4
+  }, { flattenTolerance: tolerance });
+  const cut = distance > 0 ? pathUnion(region, band) : pathSubtract(region, band);
+  const corners = offsetCornerTraces(path, distance);
+  const grown = restoreCorners(cut, corners, tolerance);
+  if (opts.refit === false || grown.commands.length === 0) return grown;
+  return restoreCorners(simplifyPath(grown, tolerance), corners, tolerance);
+}
+function closedRegion(path) {
+  if (path.kind === "rect") {
+    const { x, y, width: w, height: h } = path;
+    return anchorsToPath([[{ x, y }, { x: x + w, y }, { x: x + w, y: y + h }, { x, y: y + h }]], [true]);
+  }
+  const { anchors, closed } = pathToAnchors(path);
+  if (closed.every(Boolean)) return path;
+  return anchorsToPath(anchors, closed.map(() => true), path);
+}
 
-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 };
+export { coordsOutOfMetric, markerHeads, markerInset, markerKeyOf, markerReach, markerReadsKey, markerSites, metricKeepsRects, metricKey, nibWidthScale, offsetPath, polylineIntoMetric, polylineOutOfMetric, populatePolylineWidths, rectIntoMetric, resolveMarkerSize, resolveStrokeWidth, sameMetric, screenSpaceKey, splitForDash, strokeEdgeNear, strokeInsets, strokeSpaceOf, strokeToPath, tessellateStroke, trimInSpace, widestStrokeWidth, worldWidthInMetric, worldWidthInMetricAlongWorld };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map