@weasel-js/stroke 1.15.2 → 1.16.0

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { Path, PolygonPath, Affine } from '@weasel-js/geom';
-import { ScreenLength, Stroke, VertexWidth, StrokeNib, MarkerRef } from '@weasel-js/paint';
+import { Path, LengthTable, LengthSpan, CurveSpan, PolygonPath, Affine } from '@weasel-js/geom';
+import { ScreenLength, Stroke, VertexWidth, StrokeNib, StrokeTrim, MarkerRef } from '@weasel-js/paint';
 import { Polyline, Mesh } from '@weasel-js/geom/tessellate';
 import { M as MarkerEntry } from './test-seams-D-zMT-bn.js';
 export { a as MarkerCtx, b as MarkerPaint, g as getMarker, l as listMarkers, m as markerGeneration, c as markerRegistry, r as registerMarker } from './test-seams-D-zMT-bn.js';
@@ -173,9 +173,10 @@ declare function dashLength(path: Path): number;
  * widths and offsets are carried through: a dash boundary landing mid-segment takes
  * {@link anchorParamsBetween}'s params and the width interpolated there.
  * A dash {@link dashPattern} reads as solid along `pl` returns `pl` whole,
- * and a non-finite one returns nothing.
+ * and a non-finite one returns nothing. `phase` is how far into the pattern
+ * `pl`'s first point sits, so a run cut from a longer line keeps its pattern.
  */
-declare function splitForDash(pl: Polyline, pattern: readonly number[]): Polyline[];
+declare function splitForDash(pl: Polyline, pattern: readonly number[], phase?: number): Polyline[];
 
 /** What one unit of a `vertexWidths` entry measures across the line at a
  *  point whose unit tangent, in the polyline's own space, is `(tx, ty)`. */
@@ -199,6 +200,54 @@ declare function widestStrokeWidth(width: number, vertexWidths: readonly VertexW
  */
 declare function nibWidthScale(nib: StrokeNib): WidthScale;
 
+/**
+ * The stretch of `t`'s path a trim draws, as pen-order lengths, or null when
+ * it draws nothing: a window starting at or past its end, or a position that
+ * is NaN. Positions clamp to the path; no trim is `{}`, the whole of it.
+ */
+declare function resolveTrim(t: LengthTable, trim: StrokeTrim | undefined): LengthSpan | null;
+
+/**
+ * Where `trim` cuts `path`, as curve positions on its corner-resolved
+ * outline: resolved once, by exact arc length, so every reader cuts its own
+ * flattening at the same points, and a copy carried through a transform
+ * command for command takes the positions as they are. Null when it draws
+ * nothing; no trim is the whole path.
+ */
+declare function trimSpan(path: Path, trim: StrokeTrim | undefined): CurveSpan | null;
+
+/** What a trimmed stroke draws, as a path a writer strokes itself. */
+interface TrimmedPath {
+    /** One subpath per visible run, in pen order; curves split, not flattened. */
+    path: Path;
+    /** Per subpath, how far into its pattern a dash starts: the exact arc length from
+     *  its subpath's start to the cut, the measure a writer's own dashes run in. */
+    dashPhases: number[];
+    /** Per subpath, whether it came from a closed one, so it takes no start or end marker. */
+    fromClosed: boolean[];
+}
+/**
+ * The part of `path` that `trim` strokes, cut on the curve points the ribbon
+ * cuts at: on the corner-resolved path, at the positions `trimSpan` resolves.
+ * A closed subpath the window covers whole stays closed. `null` when the
+ * window draws nothing; the input path itself, with no runs listed, when there
+ * is no trim.
+ */
+declare function trimmedPath(path: Path, trim: StrokeTrim | undefined): TrimmedPath | null;
+/** One stroke a writer states a {@link TrimmedPath} in. */
+interface TrimmedRun {
+    path: Path;
+    dashPhase: number;
+    fromClosed: boolean;
+}
+/**
+ * `cut` as the strokes a writer states separately: the whole path as one,
+ * unless its subpaths differ in dash phase (when `dashed`) or, with
+ * `byClosed`, in whether they came from a closed subpath. A writer that
+ * restarts a dash on every subpath, or sets markers per element, needs those apart.
+ */
+declare function trimmedRuns(cut: TrimmedPath, dashed: boolean, byClosed: boolean): TrimmedRun[];
+
 /**
  * The kit's built-in stroke-marker vocabulary.
  *
@@ -264,7 +313,8 @@ interface MarkerSite {
     angle: number;
     role: 'start' | 'mid' | 'end';
 }
-/** Which marker roles to place. `start` and `end` are ignored on a closed polyline. */
+/** Which marker roles to place. `start` and `end` are ignored on a closed polyline,
+ *  and on a run cut from one. */
 interface MarkerSiteRequest {
     start: boolean;
     mid: boolean;
@@ -274,8 +324,10 @@ interface MarkerSiteRequest {
  * Where each requested marker sits on `pl` and the angle it points at.
  * Mid sites fall only on authored vertices, never on flattened curve samples,
  * and need the polyline to carry anchor data; without it no mid sites are returned.
+ * `pl`'s first and last points are never mid sites, so a trimmed run's ends are ends.
+ * `fromClosed` marks an open run cut from a closed subpath, which takes no start or end site.
  */
-declare function markerSites(pl: Polyline, want: MarkerSiteRequest): MarkerSite[];
+declare function markerSites(pl: Polyline, want: MarkerSiteRequest, fromClosed?: boolean): MarkerSite[];
 
 /**
  * A stroke's marker heads as placed geometry, and how far they reach.
@@ -294,7 +346,8 @@ interface MarkerHead {
  * `strokeWidth` is the already width-resolved stroke width; `flattenTolerance`
  * matches what the ribbon used, so heads land on the same flattened vertices
  * the stroke did. A head `spaces` puts in a screen space is placed and sized
- * there and comes back in world units, so it meets the line it caps.
+ * there and comes back in world units, so it meets the line it caps. Under
+ * `stroke.trim` heads sit on the visible runs, windowed as the ribbon is.
  */
 declare function markerHeads(path: Path, stroke: Stroke, strokeWidth: number, flattenTolerance: number | undefined, spaces?: StrokeSpaces): MarkerHead[];
 /**
@@ -416,4 +469,4 @@ interface OffsetPathOptions {
  */
 declare function offsetPath(path: Path, distance: number, opts?: OffsetPathOptions): PolygonPath;
 
-export { BUILTIN_MARKERS, type InsetLength, MarkerEntry, type MarkerHead, type MarkerSite, type MarkerSiteRequest, type MeasuredLength, type OffsetPathOptions, type ScreenSpace, type StrokeEdgeHit, type StrokeEdgeOptions, type StrokeMetric, type StrokeOptions, type StrokeSide, type StrokeSpaces, type StrokeToPathOptions, type WidthScale, coordsOutOfMetric, dashLength, 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 };
+export { BUILTIN_MARKERS, type InsetLength, MarkerEntry, type MarkerHead, type MarkerSite, type MarkerSiteRequest, type MeasuredLength, type OffsetPathOptions, type ScreenSpace, type StrokeEdgeHit, type StrokeEdgeOptions, type StrokeMetric, type StrokeOptions, type StrokeSide, type StrokeSpaces, type StrokeToPathOptions, type TrimmedPath, type TrimmedRun, type WidthScale, coordsOutOfMetric, dashLength, markerHeads, markerInset, markerKeyOf, markerReach, markerReadsKey, markerSites, metricKeepsRects, metricKey, nibWidthScale, offsetPath, polylineIntoMetric, polylineOutOfMetric, populatePolylineWidths, rectIntoMetric, resolveMarkerSize, resolveStrokeWidth, resolveTrim, sameMetric, screenSpaceKey, splitForDash, strokeEdgeNear, strokeInsets, strokeSpaceOf, strokeToPath, tessellateStroke, trimInSpace, trimSpan, trimmedPath, trimmedRuns, widestStrokeWidth, worldWidthInMetric, worldWidthInMetricAlongWorld };

package/dist/index.js

@@ -1,8 +1,8 @@
 import { getMarker } from './chunk-PNX2RT7L.js';
 export { BUILTIN_MARKERS, getMarker, listMarkers, markerGeneration, markerRegistry, registerMarker } from './chunk-PNX2RT7L.js';
-import { resolveCornersWithSources, remapPerAnchor, segmentT, pointInPath, invert, transformPath, resolveCorners, offsetCornerTraces, restoreCorners, simplifyPath, anchorsToPath, pathToAnchors, DEFAULT_FLATTEN_TOLERANCE, boundsOfPath } from '@weasel-js/geom';
+import { lengthAtSegmentFraction, lengthAtAnchor, lengthAtSubpath, pathLengthTable, curveSpan, resolveCornersWithSources, remapPerAnchor, runSegments, lengthAtCurve, asPolygonPath, splitSubpaths, PATH_L, PATH_Q, PATH_C, PATH_M, PATH_Z, segmentT, pointInPath, invert, transformPath, resolveCorners, offsetCornerTraces, restoreCorners, simplifyPath, anchorsToPath, pathToAnchors, splitQuadraticAt, splitCubicAt, DEFAULT_FLATTEN_TOLERANCE, boundsOfPath, closingAnchor, DEG_TO_RAD } from '@weasel-js/geom';
 import { dashPattern, widestHalfWidth, resolveScreenLength, alignedStrokeRect, scaleVertexWidth, vertexHalfWidths } from '@weasel-js/paint';
-import { extractPolylines, anchorParamsBetween, trimPolyline } from '@weasel-js/geom/tessellate';
+import { extractPolylines, anchorParamsBetween, trimPolyline, polylineAtCurve } from '@weasel-js/geom/tessellate';
 import { trianglesToPath, pathIntersect, pathSubtract, pathUnion } from '@weasel-js/geom/booleans';
 
 function runFrom(p, widths, offsets) {
@@ -28,16 +28,16 @@ function toPolyline(run, closed = false) {
   if (run.o) pl.offsets = new Float32Array(run.o);
   return pl;
 }
-function dashPolylines(polylines, pattern) {
-  const dash = dashPattern(pattern, totalLength(polylines));
+function dashPolylines(polylines, pattern, phases, length = polylinesLength(polylines)) {
+  const dash = dashPattern(pattern, length);
   if (dash === "solid") return [...polylines];
   if (dash === "non-finite") return [];
-  return polylines.flatMap((pl) => splitForDash(pl, dash));
+  return polylines.flatMap((pl, i) => splitForDash(pl, dash, phases?.[i] ?? 0));
 }
 function dashLength(path) {
-  return totalLength(extractPolylines(path));
+  return polylinesLength(extractPolylines(path));
 }
-function totalLength(polylines) {
+function polylinesLength(polylines) {
   return polylines.reduce((sum, pl) => sum + polylineLength(pl), 0);
 }
 function polylineLength(pl) {
@@ -48,7 +48,7 @@ function polylineLength(pl) {
   if (pl.closed && n > 1) len += Math.hypot(p[0] - p[n * 2 - 2], p[1] - p[n * 2 - 1]);
   return len;
 }
-function splitForDash(pl, pattern) {
+function splitForDash(pl, pattern, phase = 0) {
   const dash = dashPattern(pattern, polylineLength(pl));
   if (dash === "solid") return [pl];
   if (dash === "non-finite") return [];
@@ -71,7 +71,16 @@ function splitForDash(pl, pattern) {
   let dashIdx = 0;
   let dashRemaining = dash[0];
   let onPhase = true;
-  let cur = runFrom(pointAt(0), !!W, !!O);
+  if (phase > 0) {
+    let into = phase % (dash.reduce((a, b) => a + b, 0) * (dash.length % 2 + 1));
+    while (into >= dash[dashIdx]) {
+      into -= dash[dashIdx];
+      dashIdx = (dashIdx + 1) % dash.length;
+      onPhase = !onPhase;
+    }
+    dashRemaining = dash[dashIdx] - into;
+  }
+  let cur = onPhase ? runFrom(pointAt(0), !!W, !!O) : null;
   const flushAndAdvance = (at) => {
     if (cur && cur.pts.length >= 4) out.push(toPolyline(cur));
     dashIdx = (dashIdx + 1) % dash.length;
@@ -364,9 +373,132 @@ function trimInSpace(pl, from, ribbon, start, end) {
   moveTo(ribbon);
   return cur;
 }
+function resolveTrim(t, trim) {
+  const { start = 0, end = 1, pace = "length" } = trim ?? {};
+  const from = lengthOf(t, start, pace);
+  const to = lengthOf(t, end, pace);
+  if (Number.isNaN(from) || Number.isNaN(to) || from >= to) return null;
+  return { from, to };
+}
+function lengthOf(t, at, pace) {
+  if (typeof at === "number") {
+    return pace === "anchor" ? lengthAtSegmentFraction(t, at) : clampLength(t, at * t.total);
+  }
+  if ("length" in at) return clampLength(t, at.length);
+  if ("anchor" in at) return lengthAtAnchor(t, at.anchor);
+  return lengthAtSubpath(t, at.subpath);
+}
+var clampLength = (t, s) => Number.isNaN(s) ? NaN : Math.min(Math.max(s, 0), t.total);
+
+// src/trim/trimSpan.ts
+function trimSpan(path, trim) {
+  const table = pathLengthTable(path);
+  const span = resolveTrim(table, trim);
+  return span && curveSpan(table, span);
+}
+
+// src/trim/windowPolylines.ts
+var EPS = 1e-9;
+function windowPolylines(polylines, span, runs) {
+  const out = [];
+  for (let r = Math.max(span.from.run, 0); r <= Math.min(span.to.run, polylines.length - 1); r++) {
+    const pl = polylines[r];
+    const place = (at) => polylineAtCurve(pl, at.segment, at.t, runs?.[r]);
+    const head = r === span.from.run ? place(span.from) : null;
+    const tail = r === span.to.run ? place(span.to) : null;
+    const total = polylinesLength([pl]);
+    const lo = head?.length ?? 0;
+    const hi = tail?.length ?? total;
+    if (hi - lo <= EPS) continue;
+    if (pl.closed && lo <= EPS && total - hi <= EPS) {
+      out.push({ polyline: pl, fromClosed: true, dashPhase: 0 });
+      continue;
+    }
+    const base = pl.closed ? opened(pl) : pl;
+    const cut = trimPolyline(base, lo, total - hi);
+    if (!cut) continue;
+    let dashPhase = lo;
+    if (cut !== base) {
+      const q = cut.points;
+      const k = q.length - 2;
+      if (head && lo > 0) {
+        const next = (x, y) => k >= 2 ? Math.hypot(q[2] - x, q[3] - y) : 0;
+        dashPhase = Math.max(0, lo + next(q[0], q[1]) - next(head.x, head.y));
+        [q[0], q[1]] = [head.x, head.y];
+      }
+      if (tail && total - hi > 0) [q[k], q[k + 1]] = [tail.x, tail.y];
+    }
+    out.push({ polyline: cut, fromClosed: pl.closed, dashPhase });
+  }
+  return out;
+}
+function windowTrim(polylines, path, trim) {
+  const span = trimSpan(path, trim);
+  if (!span) return null;
+  const { runs } = pathLengthTable(path);
+  return { span, runs, windowed: windowPolylines(polylines, span, runs) };
+}
+function opened(pl) {
+  const n = pl.points.length / 2;
+  const { anchorA: A, anchorB: B, anchorT: T, widths: W, offsets: O } = pl;
+  const end = closingAnchor(pl) ?? A?.[0] ?? 0;
+  const grow = (a, v) => {
+    const g = new a.constructor(n + 1);
+    g.set(a);
+    g[n] = v;
+    return g;
+  };
+  return {
+    points: [...pl.points, pl.points[0], pl.points[1]],
+    closed: false,
+    anchorA: grow(A ?? new Uint32Array(n), end),
+    anchorB: grow(B ?? new Uint32Array(n), end),
+    anchorT: grow(T ?? new Float32Array(n), 0),
+    ...W ? { widths: grow(W, W[0]) } : {},
+    ...O ? { offsets: grow(O, O[0]) } : {}
+  };
+}
 
-// src/tessellate/ribbon.ts
-var ROUND_CAP_STEP_RAD = 10 * Math.PI / 180;
+// src/tessellate/ribbonWindow.ts
+var withOwnPoints = (pl) => ({ ...pl, points: pl.points.slice() });
+var lengthOf2 = (pl) => pl ? polylinesLength([pl]) : 0;
+var worldInset = (inset) => inset === void 0 || typeof inset === "number" || inset.metric === null;
+var insetLength = (inset) => inset === void 0 ? 0 : typeof inset === "number" ? inset : inset.length;
+function windowRibbon(polylines, cut, ribbon, startInset, endInset, dashing) {
+  const windowed = cut?.windowed ?? [];
+  const inWorld = ribbon === null && worldInset(startInset) && worldInset(endInset);
+  const dashLength2 = !dashing ? void 0 : inWorld ? untrimmedWorldLength(polylines, insetLength(startInset), insetLength(endInset)) : polylinesLength(polylines.flatMap((pl) => trimInSpace(withOwnPoints(pl), null, ribbon, startInset, endInset) ?? []));
+  const phases = windowed.map((run) => !dashing || run.dashPhase <= 0 || inWorld ? run.dashPhase : measuredPhase(polylines, cut.runs, run, cut.span.from, ribbon, startInset));
+  const out = [];
+  const kept = [];
+  windowed.forEach(({ polyline, fromClosed }, i) => {
+    const t = trimInSpace(polyline, null, ribbon, fromClosed ? void 0 : startInset, fromClosed ? void 0 : endInset);
+    if (t !== null) {
+      out.push(t);
+      kept.push(phases[i]);
+    }
+  });
+  return { runs: out, phases: kept, dashLength: dashLength2 };
+}
+function untrimmedWorldLength(polylines, start, end) {
+  const cut = Math.max(0, start) + Math.max(0, end);
+  let sum = 0;
+  for (const pl of polylines) {
+    const len = polylinesLength([pl]);
+    sum += pl.closed || cut <= 0 ? len : Math.max(0, len - cut);
+  }
+  return sum;
+}
+function measuredPhase(polylines, runs, run, at, ribbon, startInset) {
+  const pl = polylines[at.run];
+  const inset = run.fromClosed ? void 0 : startInset;
+  const whole = trimInSpace(withOwnPoints(pl), null, ribbon, inset, void 0);
+  const toEnd = { from: { ...at, run: 0 }, to: { run: 0, segment: Infinity, t: 1 } };
+  const [rest] = windowPolylines([pl], toEnd, runs && [runs[at.run]]);
+  const tail = rest ? trimInSpace(withOwnPoints(rest.polyline), null, ribbon, inset, void 0) : null;
+  return Math.max(0, lengthOf2(whole) - lengthOf2(tail));
+}
+var ROUND_CAP_STEP_RAD = 10 * DEG_TO_RAD;
 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;
@@ -503,7 +635,7 @@ function emitJoin(segs, segBaseIdx, j, join, miterLimit, varyingThreshold, verts
     return;
   }
 }
-var ROUND_STEP_RAD = 10 * Math.PI / 180;
+var ROUND_STEP_RAD = 10 * DEG_TO_RAD;
 function emitRoundJoin(a, aOuterEnd, bOuterStart, onPositive, verts, idx, anchorA, anchorB, anchorT, cornerA, cornerB, cornerT, inner) {
   const cx = a.bx, cy = a.by;
   const pivotIdx = inner >= 0 ? inner : cornerVertex(a, verts, anchorA, anchorB, anchorT, cornerA, cornerB, cornerT);
@@ -649,13 +781,25 @@ function tessellateStroke(path, stroke, opts = {}) {
   const anchorB = [];
   const anchorT = [];
   const ribbonSpace = metric ?? null;
-  const trimmed = [];
-  for (const pl of polylines) {
-    populateWidths(pl, vertexWidths, stroke.nib, width, scale);
-    const t = trimInSpace(pl, rectInMetric ? ribbonSpace : null, ribbonSpace, opts.startInset, opts.endInset);
-    if (t !== null) trimmed.push(t);
+  const from = rectInMetric ? ribbonSpace : null;
+  for (const pl of polylines) populateWidths(pl, vertexWidths, stroke.nib, width, scale);
+  let runs;
+  let phases;
+  let dashLength2;
+  if (stroke.trim !== void 0) {
+    if (from) for (const pl of polylines) polylineOutOfMetric(pl, from);
+    ({ runs, phases, dashLength: dashLength2 } = windowRibbon(
+      polylines,
+      windowTrim(polylines, path, stroke.trim),
+      ribbonSpace,
+      opts.startInset,
+      opts.endInset,
+      stroke.dash !== void 0
+    ));
+  } else {
+    runs = polylines.flatMap((pl) => trimInSpace(pl, from, ribbonSpace, opts.startInset, opts.endInset) ?? []);
   }
-  for (const sub of dashPolylines(trimmed, stroke.dash)) {
+  for (const sub of dashPolylines(runs, stroke.dash, phases, dashLength2)) {
     expandPolyline(sub, width, join, cap, miterLimit, varyingThreshold, verts, idx, anchorA, anchorB, anchorT);
   }
   const vertices = new Float32Array(verts);
@@ -745,6 +889,75 @@ function expandPolyline(pl, width, join, cap, miterLimit, varyingThreshold, vert
 }
 var DEFAULT_MITER_LIMIT = 4;
 var DEFAULT_VARYING_WIDTH_JOIN_THRESHOLD = 1.5;
+var EPS2 = 1e-9;
+function trimmedPath(path, trim) {
+  if (trim === void 0) return { path, dashPhases: [], fromClosed: [] };
+  const span = trimSpan(path, trim);
+  if (!span) return null;
+  const table = pathLengthTable(path);
+  const out = { path, dashPhases: [], fromClosed: [] };
+  const commands = [];
+  const coords = [];
+  for (let r = span.from.run; r <= span.to.run; r++) {
+    const segs = runSegments(table, r);
+    const lo = r === span.from.run ? span.from : { run: r, segment: 0, t: 0 };
+    const hi = r === span.to.run ? span.to : { run: r, segment: segs - 1, t: 1 };
+    const at = table.runStart[r];
+    const head = lengthAtCurve(table, lo) - at;
+    if (segs <= 0 || lengthAtCurve(table, hi) - at - head <= EPS2) continue;
+    const { closed } = table.runs[r];
+    const whole = closed && head <= EPS2 && table.runStart[r + 1] - lengthAtCurve(table, hi) <= EPS2;
+    writeRun(table, r, lo, hi, whole, commands, coords);
+    out.dashPhases.push(whole ? 0 : head);
+    out.fromClosed.push(closed);
+  }
+  if (out.dashPhases.length === 0) return null;
+  const shape = path.kind === "rect" ? asPolygonPath(path) : path;
+  out.path = {
+    kind: "polygon",
+    commands: Uint8Array.from(commands),
+    coords: Float32Array.from(coords),
+    fillRule: shape.fillRule,
+    ...shape.origin ? { origin: shape.origin } : {}
+  };
+  return out;
+}
+function trimmedRuns(cut, dashed, byClosed) {
+  const { dashPhases: phases, fromClosed } = cut;
+  const alike = (i) => (!byClosed || fromClosed[i] === fromClosed[0]) && (!dashed || phases[i] === phases[0]);
+  if (phases.every((_p, i) => alike(i))) {
+    return [{ path: cut.path, dashPhase: phases[0] ?? 0, fromClosed: fromClosed[0] ?? false }];
+  }
+  return splitSubpaths(cut.path).map((path, i) => ({ path, dashPhase: phases[i], fromClosed: fromClosed[i] }));
+}
+function writeRun(table, r, lo, hi, whole, commands, coords) {
+  const { points, controls } = table.runs[r];
+  const n = points.length / 2;
+  for (let k = lo.segment; k <= hi.segment; k++) {
+    const ctl = controls?.[k];
+    const cmd = !ctl || ctl.length === 0 ? PATH_L : ctl.length === 2 ? PATH_Q : PATH_C;
+    if (whole && cmd === PATH_L && k === n - 1) break;
+    const j = (k + 1) % n;
+    const seg = [points[k * 2], points[k * 2 + 1], ...ctl ? Array.from(ctl) : [], points[j * 2], points[j * 2 + 1]];
+    const piece = subSegment(cmd, seg, k === lo.segment ? lo.t : 0, k === hi.segment ? hi.t : 1);
+    if (k === lo.segment) {
+      commands.push(PATH_M);
+      coords.push(piece[0], piece[1]);
+    }
+    commands.push(cmd);
+    for (let i = 2; i < piece.length; i++) coords.push(piece[i]);
+  }
+  if (whole) commands.push(PATH_Z);
+}
+function subSegment(cmd, c, t0, t1) {
+  if (cmd === PATH_L) {
+    const at = (t) => [c[0] + (c[2] - c[0]) * t, c[1] + (c[3] - c[1]) * t];
+    return [...at(t0), ...at(t1)];
+  }
+  const split = (p, t) => cmd === PATH_Q ? splitQuadraticAt(p[0], p[1], p[2], p[3], p[4], p[5], t) : splitCubicAt(p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], t);
+  const head = t1 >= 1 ? c : split(c, t1)[0];
+  return t0 <= 0 ? head : split(head, t1 > 0 ? t0 / t1 : 0)[1];
+}
 function resolveMarkerSize(ref, strokeWidth, scale = 1) {
   if (typeof ref === "string" || ref.size === void 0) return strokeWidth;
   return resolveScreenLength(ref.size, scale);
@@ -766,12 +979,12 @@ function strokeInsets(stroke, strokeWidth) {
 }
 
 // src/markerSites.ts
-var EPS = 1e-9;
+var EPS3 = 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;
+  if (len < EPS3) return null;
   return { x: dx / len, y: dy / len };
 }
 function nextDistinct(pl, i, n) {
@@ -782,11 +995,11 @@ 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) {
+function markerSites(pl, want, fromClosed = pl.closed) {
   const out = [];
   const n = pl.points.length / 2;
   if (n < 2) return out;
-  if (want.start && !pl.closed) {
+  if (want.start && !fromClosed) {
     const j = nextDistinct(pl, 0, n);
     const d = j >= 0 ? dir(pl, 0, j) : null;
     if (d) {
@@ -805,7 +1018,7 @@ function markerSites(pl, want) {
         const outDir = dir(pl, i, q);
         let bx = inDir.x + outDir.x;
         let by = inDir.y + outDir.y;
-        if (Math.hypot(bx, by) < EPS) {
+        if (Math.hypot(bx, by) < EPS3) {
           bx = inDir.x;
           by = inDir.y;
         }
@@ -813,7 +1026,7 @@ function markerSites(pl, want) {
       }
     }
   }
-  if (want.end && !pl.closed) {
+  if (want.end && !fromClosed) {
     const last = n - 1;
     const p = prevDistinct(pl, last);
     const d = p >= 0 ? dir(pl, p, last) : null;
@@ -848,11 +1061,11 @@ function markerHeads(path, stroke, strokeWidth, flattenTolerance, spaces = {}) {
   }
   const out = [];
   const origin = path.kind === "polygon" ? path.origin : void 0;
-  for (const pl of extractPolylines(path, strokeFlattening(flattenTolerance, strokeWidth, stroke.vertexWidths))) {
+  for (const { polyline: pl, fromClosed } of headRuns(path, stroke, strokeWidth, 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)) {
+      for (const site of markerSites(inSpace, want, fromClosed)) {
         const ref = refs[site.role];
         if (ref === void 0) continue;
         const entry = getMarker(markerKeyOf(ref));
@@ -867,6 +1080,11 @@ function markerHeads(path, stroke, strokeWidth, flattenTolerance, spaces = {}) {
   }
   return out;
 }
+function headRuns(path, stroke, strokeWidth, flattenTolerance) {
+  const polylines = extractPolylines(path, strokeFlattening(flattenTolerance, strokeWidth, stroke.vertexWidths));
+  if (stroke.trim === void 0) return polylines.map((polyline) => ({ polyline, fromClosed: polyline.closed }));
+  return windowTrim(polylines, path, stroke.trim)?.windowed ?? [];
+}
 function markerReadsKey(entry, stroke) {
   if (entry.reads === void 0) return null;
   let key = "";
@@ -1048,6 +1266,6 @@ function closedRegion(path) {
   return anchorsToPath(anchors, closed.map(() => true), path);
 }
 
-export { coordsOutOfMetric, dashLength, 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 };
+export { coordsOutOfMetric, dashLength, markerHeads, markerInset, markerKeyOf, markerReach, markerReadsKey, markerSites, metricKeepsRects, metricKey, nibWidthScale, offsetPath, polylineIntoMetric, polylineOutOfMetric, populatePolylineWidths, rectIntoMetric, resolveMarkerSize, resolveStrokeWidth, resolveTrim, sameMetric, screenSpaceKey, splitForDash, strokeEdgeNear, strokeInsets, strokeSpaceOf, strokeToPath, tessellateStroke, trimInSpace, trimSpan, trimmedPath, trimmedRuns, widestStrokeWidth, worldWidthInMetric, worldWidthInMetricAlongWorld };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map