@weasel-js/geom 1.12.0 → 1.13.0-rc.0

package/dist/index.d.ts

@@ -339,6 +339,12 @@ interface TrackNearestOptions {
      *  the middle. */
     about?: number;
 }
+/** How `at` treats a fraction past 0 or 1. */
+interface TrackAtOptions {
+    /** Carry on past the ends rather than clamp: a line and an open path straight along their end, an arc and an ellipse
+     *  round themselves, a closed path round its contour. Default false. */
+    open?: boolean;
+}
 /** Which family a track shape belongs to. `'path'` is a shape over a measured `Path` (`pathShape`). */
 type TrackShapeKind = 'line' | 'arc' | 'ellipse' | 'path';
 /** A curve a control lies along, addressed by fraction 0..1 of its length. */
@@ -347,8 +353,8 @@ interface TrackShape {
     readonly length: number;
     /** True when the track's end meets its start: a whole circle or ellipse, or a path that is one closed contour. */
     readonly closed: boolean;
-    /** The station at fraction `f`, clamped to 0..1. */
-    at(f: number): TrackStation;
+    /** The station at fraction `f`, clamped to 0..1 unless `options.open`. */
+    at(f: number, options?: TrackAtOptions): TrackStation;
     /** The spot on the track nearest `p`. */
     nearest(p: Point, options?: TrackNearestOptions): TrackNearest;
 }
@@ -410,6 +416,10 @@ declare function pathShape(path: Path, options?: {
  *  `angle` the CSS rotation in degrees that tips an upright item to it (0 = upright, clockwise positive, in (-180, 180]). */
 interface TrackPlace extends TrackStation {
     angle: number;
+    /** True when `normal` points down the screen, so an item tipped by `angle` reads upside down. A run is turned over
+     *  by one place alone, so one across 3 or 9 o'clock has turned places toward one end; an item that should read
+     *  upright turns a half turn about its own center there. Nothing else in the place reflects it. */
+    turned: boolean;
 }
 /** The stretch `from..to` of a shape in reading order. It is itself a TrackShape: `at(g)` and `nearest(p).f` are
  *  in reading order, g = 0 at the reading start. */
@@ -422,7 +432,7 @@ interface TrackRun extends TrackShape {
     readonly flipped: boolean;
     /** True when reading order runs against the shape's own direction. */
     readonly reversed: boolean;
-    at(g: number): TrackPlace;
+    at(g: number, options?: TrackAtOptions): TrackPlace;
 }
 /** Which side of a shape a run's items stand on: `'auto'` whichever is upright, `'path'` the shape's own normal, `'flipped'`
  *  the other. */
@@ -442,6 +452,23 @@ declare function trackRun(shape: TrackShape, from?: number, to?: number, options
  *  64-step polyline. A whole path shape is its path's own data. */
 declare function trackShapeD(shape: TrackShape, from?: number, to?: number): string;
 
+/** Which way `shape` bends, against its own normal: 1 toward it, -1 away from it, 0 straight. A shape that bends both
+ *  ways answers for the way it turns more in all. An arc and an ellipse bend away from their normal. */
+declare function bendSide(shape: TrackShape): -1 | 0 | 1;
+/**
+ * The track `shift` px along `shape`'s normal from it at every point — negative is against the normal — as a track
+ * of its own, addressed by fraction of its own length, its tangent and normal those of `shape` at the point it came
+ * from. Null when the shift reaches a center of curvature, where the track would fold back over itself: an arc shifted
+ * in by its radius or more.
+ */
+declare function shiftTrack(shape: TrackShape, shift: number): TrackShape | null;
+
+/**
+ * The stretch `from..to` of a shape (fractions of it, `from` below `to`) as a shape of its own, running the same way.
+ * An arc stays an arc and an ellipse an ellipse, so `trackShapeD` still draws it as one; any other shape is read through.
+ */
+declare function trackSlice(shape: TrackShape, from: number, to: number): TrackShape;
+
 /** Where a sequence sits along a run: against its reading start, its middle, or its reading end. */
 type RunAlign = 'start' | 'center' | 'end';
 /** The order {@link placeAlongRun} lays items in: along the run's reading order, or from the end where the underlying
@@ -460,9 +487,12 @@ interface RunSpot {
 declare function runPlaces(lengths: readonly number[], gap: number, room: number, align: RunAlign, offset: number, at?: number): RunSpot[];
 /** How long items of `lengths` are laid end to end with `gap` between each two. */
 declare function runLength(lengths: readonly number[], gap: number): number;
-/** The place `distance` along `run`; past either end it carries on straight along that end, tipped as it is there. The
- *  point then moves `shift` along the place's up. */
-declare function runStationAt(run: TrackRun, distance: number, shift?: number): TrackPlace;
+/** How {@link runStationAt} carries a place past either end of its run: straight along that end, tipped as it is there
+ *  (`'extend'`), or on along the run's shape itself (`'follow'`), as a shape's `at` reads `open`. */
+type RunPast = 'extend' | 'follow';
+/** The place `distance` along `run`, carried past either end as `past` says (default `'extend'`). The point then moves
+ *  `shift` along the place's up. */
+declare function runStationAt(run: TrackRun, distance: number, shift?: number, past?: RunPast): TrackPlace;
 /** How {@link placeAlongRun} lays its items: spacing, alignment, offset, anchor, stand-off, wrap and past-end handling. */
 interface PlaceAlongRunOptions {
     /** Space between each two items, along the run. Default 0. */
@@ -478,8 +508,9 @@ interface PlaceAlongRunOptions {
     /** Carry items on round a closed run past its seam, and count an item past once it is a whole lap on from the first
      *  item's start. Default false. */
     wrap?: boolean;
-    /** Where an item wholly past an end is placed: carried on beyond it (`'extend'`, the default) or held at it. */
-    past?: 'extend' | 'hold';
+    /** Where an item past an end is placed: carried on straight beyond it (`'extend'`, the default), or on along the run's
+     *  own shape (`'follow'`); `'hold'` follows the shape until the item is wholly past, then holds it at that end. */
+    past?: RunPast | 'hold';
     /** `'reading'` (the default) lays item 1 at the run's reading start. `'track'` lays it at the shape's own start and
      *  proceeds in the shape's direction; items still stand as the run reads them. In `'track'` order `align`, `at`,
      *  `offset` and each `center` are measured from the shape's start. */
@@ -3074,4 +3105,4 @@ declare function reviveTypedArrays(value: unknown): unknown;
 /** `tagTypedArrays` as a `JSON.stringify` replacer. */
 declare function typedArrayReplacer(_key: string, value: unknown): unknown;
 
-export { ANCHOR_FIELDS, type Affine, type AnchorField, type AnchorFieldValues, type AnchorPair, type AnchorPathMeasure, AnchorSet, type AnchorSubpathMeasure, type AnchorSymmetry, type ArcTrackShape, type ArcTrackSpec, type AverageAxis, type BendAlongPathOptions, type BendGrip, type BezierEasing, type BlendPathsOptions, type Box, CONSTRAINT_TOLERANCE, CORNER_RESTORE_TOLERANCE, type ConflictingConstraintsOptions, type ConstrainPathEditOptions, type ConstrainedPathEdit, type ConstrainedPathsEdit, type ConstraintPoint, type CornerCut, type CornerFrame, CornerPiece, CornerSpec, type CornerTrace, type CubicContour, type CubicCoords, type CubicSegment, type CurveNearest, DEFAULT_FLATTEN_TOLERANCE, type DirectionMark, EASINGS, EPS, type EasingFn, type EasingName, type EasingSpec, type EllipseTrackShape, type EllipseTrackSpec, type ExtendToMeetOptions, type FramedBox, type GlMat3, type GrowRegionOptions, type HandleBalance, type HandleRef, type JoinOptions, type LengthenMode, type LineCoords, type MeasureAnchorPathOptions, type MeasurePathOptions, type MergeRegionOptions, type NumberEntry, type NumberTypedArray, type OpenPathEnd, PATH_C, PATH_CMD_LENGTHS, PATH_COMMANDS, PATH_L, PATH_M, PATH_Q, PATH_SNAP_KINDS, PATH_Z, Path, type PathAnchorHit, type PathAwayFromAnchors, type PathBlend, PathBuilder, type PathCommandCode, type PathCommandName, type PathConstraint, type PathConstraintKind, type PathCrossing, type PathEndFrame, PathFillRule, type PathInWorldPose, type PathLink, type PathMeasure, type PathNearest, type PathNearestStation, PathOpenFill, type PathSegment, type PathSnapHit, type PathSnapIndex, type PathSnapKind, type PathSnapQuery, type PathSnapTarget, type PathStation, type PathStop, type PathTrackShape, type PathsEditItem, PenAnchor, type PlaceAlongRunOptions, type PlaceRectOptions, type PlacedRect, type Placement, type PlacementAlign, type PlacementSide, Point, type PointAlongPathOptions, type PointInPathOptions, type PointOrigin, type PolygonIntersectsPathOptions, PolygonPath, type PoseLinear, type PoseRotation, type QuadraticCoords, type Rect, RectPath, type RepeatAlongPathOptions, type RepeatStation, type ResamplePathOptions, type ResolvedCorners, type RunAlign, type RunOrder, type RunPlace, type RunSpot, SPRING_PRESETS, Scale2, type SegmentCrossing, type SegmentMeasure, type SegmentRef, type SegmentType, type SimplifyPathOptions, type SmudgePathOptions, type SoftFalloff, type SolveConstraintsOptions, type SolveConstraintsResult, type SolvePathConstraintsResult, type SpiroContour, SpiroKind, type SpiroPath, SpiroPoint, type SpiroToPathOptions, type SpringPreset, type SpringPresetName, type StaticPathSnapKind, type StrokeHitTestOptions, type SubpathEnd, TYPED_ARRAY_CONSTRUCTORS, type TaggedTypedArray, type TrackNearest, type TrackNearestOptions, type TrackPlace, type TrackRun, type TrackRunOptions, type TrackShape, type TrackShapeKind, type TrackSide, type TrackStation, type TrimPathOptions, type TrimResult, type TypedArrayTag, type UnsatisfiedConstraintsOptions, type View, ZOOM_FLOOR, addExtremaAnchors, anchorOriginsOf, anchorSymmetries, anchorSymmetry, anchorsBefore, anchorsUnderBrush, anchorsWhere, applyToPoint, approxEq, arcShape, asPolygonPath, averageAnchorsAt, balanceFactorToward, bendAlongPath, bendSegment, blendPaths, boundsOfCoords, boundsOfPath, boxContainsBox, boxContainsPoint, boxToBox, circlePath, clamp, clampRectWithin, closestOpenEnds, composePath, conflictingConstraints, constrainPathEdit, constrainPathsEdit, constraintAnchors, constraintApplies, constraintFits, convertSegments, cornerAnchors, cornerCuts, cornerFrameAt, cornerFrames, cornerTraces, createPathSnapIndex, cross, cubicAxisExtremaTs, cubicBezierEasing, cubicBounds, cubicContoursToPath, cubicEvalAt, decomposePath, defaultOpenFill, directionMarks, dot, easeIn, easeInBack, easeInBounce, easeInCirc, easeInCubic, easeInElastic, easeInExpo, easeInOut, easeInOutBack, easeInOutBounce, easeInOutCirc, easeInOutCubic, easeInOutElastic, easeInOutExpo, easeInOutQuad, easeInOutQuart, easeInOutQuint, easeInOutSine, easeInQuad, easeInQuart, easeInQuint, easeInSine, easeOut, easeOutBack, easeOutBounce, easeOutCirc, easeOutCubic, easeOutElastic, easeOutExpo, easeOutQuad, easeOutQuart, easeOutQuint, easeOutSine, editAnchorSetTracked, elevateQuadraticToCubic, ellipsePath, ellipseShape, equalizeSegmentHandles, everyNthAnchor, extendToMeet, fillsOpenSubpaths, findPathSnap, findPathSnaps, fitAffine, fitCubicThroughDeletion, fitCubicWithTangents, flatIndexesAfterReverse, flattenCubic, flattenCubicWithArcLen, flattenQuadratic, flattenQuadraticWithArcLen, forEachSegment, growAnchorSelection, growRegion, handleAlongItsAngle, handleAtItsLength, handleBalances, harmonizeAnchors, hasOpenSubpath, identity$1 as identity, intersectSegments, invert$1 as invert, invertAnchorSelection, isSegmentStraight, joinAnchorsAt, joinSubpathEnds, keepCorners, len2, lengthToward, lengthenOpenEnd, lengthenPathEnd, linePath, lineShape, linear, makeHandlesSymmetric, mapConstraintAnchors, mat3, meanScale, measureAnchorPath, measurePath, mergeRegion, moveHandleSymmetric, multiply$1 as multiply, nearestOnCubic, nearestOnLine, nearestOnPath, nearestOnQuadratic, nearestPathAnchor, normalizeZoom, offsetCornerTraces, openEndAt, openEndRay, openPathEnds, pathAnchorPoints, pathAwayFromAnchors, pathCommandCoordCount, pathContainsPoint, pathContainsPolygon, pathContainsRect, pathCrossings, pathDistanceToPoint, pathEndAnchorIndex, pathEndFrame, pathFromD, pathInPoseFrame, pathInWorld, pathIntersectsPolygon, pathIntersectsRect, pathSegments, pathShape, pathSignedArea, pathThroughPoseFrame, pathToCubicContours, pathToD, placeAlongRun, placeRect, pointAlongPath, pointInPath, pointInPolygon, pointSegmentDist2, polygonContainsPath, polygonFromPoints, polygonIntersectsPath, polylineFromPoints, portControls, portCurvePoints, poseFrameInverseOf, poseFrameOf, poseLinearOf, poseRotationOf, prepareBlend, quadraticEvalAt, readAnchorFields, rectMarkerPath, rectPath, rectToContour, regularPolygonPath, remapAnchorValues, remapConstraints, remapPerAnchor, remapPointValues, repeatAlongPath, resamplePath, resolveCorners, resolveCornersWithSources, resolveEasing, restoreCorners, retractHandles, reverseAnchors, reversePath, reverseSubpaths, reviveTypedArrays, rotate, rotateAboutPoint, rotatePathAround, roundRectPath, runLength, runPlaces, runStationAt, scale, scalePathToBounds, scaleSegmentHandles, schneiderFit, segmentBetween, segmentExtremaTs, segmentsBetweenAnchors, segmentsCross, setDefaultOpenFill, setSubpathStart, shrinkAnchorSelection, sign, simplifyAnchorsAt, simplifyPath, simplifySpan, simplifySubpath, smoothAnchors, smudgePath, softFalloff, softSelectionBand, softSelectionWeights, solveConstraints, solvePathConstraints, spiroContoursFromControl, spiroContoursOf, spiroControlPath, spiroToPath, splitByClosure, splitCubicAt, splitLineAt, splitQuadraticAt, splitSubpaths, squarePath, starPath, stationsAlongPath, strokeHitTest, sub, subpathEndAt, subpathsOfAnchors, tagTypedArray, tagTypedArrays, trackRun, trackShapeD, transformCoords, transformPath, translate, translateAnchorsSymmetric, translatePath, trimPathAt, typedArrayReplacer, unionBoundsPath, unionBox, unsatisfiedConstraints, untagTypedArray, viewToMat3, withAnchorPoints, worldEditToStorage, writeAnchorField };
+export { ANCHOR_FIELDS, type Affine, type AnchorField, type AnchorFieldValues, type AnchorPair, type AnchorPathMeasure, AnchorSet, type AnchorSubpathMeasure, type AnchorSymmetry, type ArcTrackShape, type ArcTrackSpec, type AverageAxis, type BendAlongPathOptions, type BendGrip, type BezierEasing, type BlendPathsOptions, type Box, CONSTRAINT_TOLERANCE, CORNER_RESTORE_TOLERANCE, type ConflictingConstraintsOptions, type ConstrainPathEditOptions, type ConstrainedPathEdit, type ConstrainedPathsEdit, type ConstraintPoint, type CornerCut, type CornerFrame, CornerPiece, CornerSpec, type CornerTrace, type CubicContour, type CubicCoords, type CubicSegment, type CurveNearest, DEFAULT_FLATTEN_TOLERANCE, type DirectionMark, EASINGS, EPS, type EasingFn, type EasingName, type EasingSpec, type EllipseTrackShape, type EllipseTrackSpec, type ExtendToMeetOptions, type FramedBox, type GlMat3, type GrowRegionOptions, type HandleBalance, type HandleRef, type JoinOptions, type LengthenMode, type LineCoords, type MeasureAnchorPathOptions, type MeasurePathOptions, type MergeRegionOptions, type NumberEntry, type NumberTypedArray, type OpenPathEnd, PATH_C, PATH_CMD_LENGTHS, PATH_COMMANDS, PATH_L, PATH_M, PATH_Q, PATH_SNAP_KINDS, PATH_Z, Path, type PathAnchorHit, type PathAwayFromAnchors, type PathBlend, PathBuilder, type PathCommandCode, type PathCommandName, type PathConstraint, type PathConstraintKind, type PathCrossing, type PathEndFrame, PathFillRule, type PathInWorldPose, type PathLink, type PathMeasure, type PathNearest, type PathNearestStation, PathOpenFill, type PathSegment, type PathSnapHit, type PathSnapIndex, type PathSnapKind, type PathSnapQuery, type PathSnapTarget, type PathStation, type PathStop, type PathTrackShape, type PathsEditItem, PenAnchor, type PlaceAlongRunOptions, type PlaceRectOptions, type PlacedRect, type Placement, type PlacementAlign, type PlacementSide, Point, type PointAlongPathOptions, type PointInPathOptions, type PointOrigin, type PolygonIntersectsPathOptions, PolygonPath, type PoseLinear, type PoseRotation, type QuadraticCoords, type Rect, RectPath, type RepeatAlongPathOptions, type RepeatStation, type ResamplePathOptions, type ResolvedCorners, type RunAlign, type RunOrder, type RunPast, type RunPlace, type RunSpot, SPRING_PRESETS, Scale2, type SegmentCrossing, type SegmentMeasure, type SegmentRef, type SegmentType, type SimplifyPathOptions, type SmudgePathOptions, type SoftFalloff, type SolveConstraintsOptions, type SolveConstraintsResult, type SolvePathConstraintsResult, type SpiroContour, SpiroKind, type SpiroPath, SpiroPoint, type SpiroToPathOptions, type SpringPreset, type SpringPresetName, type StaticPathSnapKind, type StrokeHitTestOptions, type SubpathEnd, TYPED_ARRAY_CONSTRUCTORS, type TaggedTypedArray, type TrackAtOptions, type TrackNearest, type TrackNearestOptions, type TrackPlace, type TrackRun, type TrackRunOptions, type TrackShape, type TrackShapeKind, type TrackSide, type TrackStation, type TrimPathOptions, type TrimResult, type TypedArrayTag, type UnsatisfiedConstraintsOptions, type View, ZOOM_FLOOR, addExtremaAnchors, anchorOriginsOf, anchorSymmetries, anchorSymmetry, anchorsBefore, anchorsUnderBrush, anchorsWhere, applyToPoint, approxEq, arcShape, asPolygonPath, averageAnchorsAt, balanceFactorToward, bendAlongPath, bendSegment, bendSide, blendPaths, boundsOfCoords, boundsOfPath, boxContainsBox, boxContainsPoint, boxToBox, circlePath, clamp, clampRectWithin, closestOpenEnds, composePath, conflictingConstraints, constrainPathEdit, constrainPathsEdit, constraintAnchors, constraintApplies, constraintFits, convertSegments, cornerAnchors, cornerCuts, cornerFrameAt, cornerFrames, cornerTraces, createPathSnapIndex, cross, cubicAxisExtremaTs, cubicBezierEasing, cubicBounds, cubicContoursToPath, cubicEvalAt, decomposePath, defaultOpenFill, directionMarks, dot, easeIn, easeInBack, easeInBounce, easeInCirc, easeInCubic, easeInElastic, easeInExpo, easeInOut, easeInOutBack, easeInOutBounce, easeInOutCirc, easeInOutCubic, easeInOutElastic, easeInOutExpo, easeInOutQuad, easeInOutQuart, easeInOutQuint, easeInOutSine, easeInQuad, easeInQuart, easeInQuint, easeInSine, easeOut, easeOutBack, easeOutBounce, easeOutCirc, easeOutCubic, easeOutElastic, easeOutExpo, easeOutQuad, easeOutQuart, easeOutQuint, easeOutSine, editAnchorSetTracked, elevateQuadraticToCubic, ellipsePath, ellipseShape, equalizeSegmentHandles, everyNthAnchor, extendToMeet, fillsOpenSubpaths, findPathSnap, findPathSnaps, fitAffine, fitCubicThroughDeletion, fitCubicWithTangents, flatIndexesAfterReverse, flattenCubic, flattenCubicWithArcLen, flattenQuadratic, flattenQuadraticWithArcLen, forEachSegment, growAnchorSelection, growRegion, handleAlongItsAngle, handleAtItsLength, handleBalances, harmonizeAnchors, hasOpenSubpath, identity$1 as identity, intersectSegments, invert$1 as invert, invertAnchorSelection, isSegmentStraight, joinAnchorsAt, joinSubpathEnds, keepCorners, len2, lengthToward, lengthenOpenEnd, lengthenPathEnd, linePath, lineShape, linear, makeHandlesSymmetric, mapConstraintAnchors, mat3, meanScale, measureAnchorPath, measurePath, mergeRegion, moveHandleSymmetric, multiply$1 as multiply, nearestOnCubic, nearestOnLine, nearestOnPath, nearestOnQuadratic, nearestPathAnchor, normalizeZoom, offsetCornerTraces, openEndAt, openEndRay, openPathEnds, pathAnchorPoints, pathAwayFromAnchors, pathCommandCoordCount, pathContainsPoint, pathContainsPolygon, pathContainsRect, pathCrossings, pathDistanceToPoint, pathEndAnchorIndex, pathEndFrame, pathFromD, pathInPoseFrame, pathInWorld, pathIntersectsPolygon, pathIntersectsRect, pathSegments, pathShape, pathSignedArea, pathThroughPoseFrame, pathToCubicContours, pathToD, placeAlongRun, placeRect, pointAlongPath, pointInPath, pointInPolygon, pointSegmentDist2, polygonContainsPath, polygonFromPoints, polygonIntersectsPath, polylineFromPoints, portControls, portCurvePoints, poseFrameInverseOf, poseFrameOf, poseLinearOf, poseRotationOf, prepareBlend, quadraticEvalAt, readAnchorFields, rectMarkerPath, rectPath, rectToContour, regularPolygonPath, remapAnchorValues, remapConstraints, remapPerAnchor, remapPointValues, repeatAlongPath, resamplePath, resolveCorners, resolveCornersWithSources, resolveEasing, restoreCorners, retractHandles, reverseAnchors, reversePath, reverseSubpaths, reviveTypedArrays, rotate, rotateAboutPoint, rotatePathAround, roundRectPath, runLength, runPlaces, runStationAt, scale, scalePathToBounds, scaleSegmentHandles, schneiderFit, segmentBetween, segmentExtremaTs, segmentsBetweenAnchors, segmentsCross, setDefaultOpenFill, setSubpathStart, shiftTrack, shrinkAnchorSelection, sign, simplifyAnchorsAt, simplifyPath, simplifySpan, simplifySubpath, smoothAnchors, smudgePath, softFalloff, softSelectionBand, softSelectionWeights, solveConstraints, solvePathConstraints, spiroContoursFromControl, spiroContoursOf, spiroControlPath, spiroToPath, splitByClosure, splitCubicAt, splitLineAt, splitQuadraticAt, splitSubpaths, squarePath, starPath, stationsAlongPath, strokeHitTest, sub, subpathEndAt, subpathsOfAnchors, tagTypedArray, tagTypedArrays, trackRun, trackShapeD, trackSlice, transformCoords, transformPath, translate, translateAnchorsSymmetric, translatePath, trimPathAt, typedArrayReplacer, unionBoundsPath, unionBox, unsatisfiedConstraints, untagTypedArray, viewToMat3, withAnchorPoints, worldEditToStorage, writeAnchorField };

package/dist/index.js

@@ -93,8 +93,8 @@ function lineShape(from, to) {
     kind: "line",
     length: length2,
     closed: false,
-    at(f) {
-      const t = clamp(f, 0, 1);
+    at(f, options) {
+      const t = options?.open ? f : clamp(f, 0, 1);
       return {
         point: { x: from.x + t * dx2, y: from.y + t * dy2 },
         tangent: { ...tangent },
@@ -119,8 +119,8 @@ function arcShape(spec) {
   const raw = mod360(sign2 * (spec.end - start));
   const sweep = raw === 0 ? 360 : raw;
   const length2 = radius * sweep * RAD;
-  const at2 = (f) => {
-    const t = clamp(f, 0, 1);
+  const at2 = (f, options) => {
+    const t = options?.open ? f : clamp(f, 0, 1);
     const theta = (start + sign2 * t * sweep) * RAD;
     const s = Math.sin(theta);
     const c = Math.cos(theta);
@@ -249,8 +249,18 @@ function ellipseShape(spec) {
   const raw = mod3602(sign2 * (param(spec.end) - e.t0));
   const sweep = raw === 0 ? 360 : raw;
   const { length: length2, lengthTo, offsetAt } = lengthTable(e, sweep);
-  const at2 = (f) => {
-    const u = offsetAt(clamp(f, 0, 1));
+  const offsetPast = (f) => {
+    if (raw === 0) return offsetAt((f % 1 + 1) % 1);
+    let u = f * sweep;
+    for (let i = 0; i < 8; i++) {
+      const v = speed(e, u);
+      if (!(v > 0)) break;
+      u -= (lengthTo(u) - f * length2) / v;
+    }
+    return u;
+  };
+  const at2 = (f, options) => {
+    const u = options?.open && (f < 0 || f > 1) ? offsetPast(f) : offsetAt(clamp(f, 0, 1));
     const t = (e.t0 + sign2 * u) * RAD2;
     const s = Math.sin(t);
     const c = Math.cos(t);
@@ -407,9 +417,12 @@ function pathShape(path, options = {}) {
     kind: "path",
     length: length2,
     closed,
-    at(f) {
-      const { point, tangent } = measure2.at(clamp(f, 0, 1) * length2, true);
-      return { point, tangent, normal: { x: tangent.y, y: -tangent.x } };
+    at(f, options2) {
+      const open = options2?.open === true && (f < 0 || f > 1);
+      const g = open && closed ? (f % 1 + 1) % 1 : clamp(f, 0, 1);
+      const { point, tangent } = measure2.at(g * length2, true);
+      const past = open && !closed ? (f - g) * length2 : 0;
+      return { point: { x: point.x + past * tangent.x, y: point.y + past * tangent.y }, tangent, normal: { x: tangent.y, y: -tangent.x } };
     },
     nearest(p, opts) {
       const n = measure2.nearest(p);
@@ -425,10 +438,11 @@ function pathShape(path, options = {}) {
 }
 
 // src/track/run.ts
+var pointsDown = (normal2) => normal2.y > 1e-9;
 function trackRun(shape, from = 0, to = 1, options = {}) {
   const { side = "auto", about = (from + to) / 2 } = options;
   const mid = shape.at(about);
-  const flipped = side === "auto" ? mid.normal.y > 1e-9 : side === "flipped";
+  const flipped = side === "auto" ? pointsDown(mid.normal) : side === "flipped";
   const sgn = flipped ? -1 : 1;
   const reading = (n) => ({ x: -(sgn * n.y), y: sgn * n.x });
   const r0 = reading(mid.normal);
@@ -437,15 +451,17 @@ function trackRun(shape, from = 0, to = 1, options = {}) {
   const lo = Math.min(from, to);
   const hi = Math.max(from, to);
   const toF = (g) => reversed3 ? to - g * span : from + g * span;
-  const at2 = (g) => {
-    const s = shape.at(toF(clamp(g, 0, 1)));
+  const at2 = (g, options2) => {
+    const s = options2?.open ? shape.at(toF(g), options2) : shape.at(toF(clamp(g, 0, 1)));
     const dir = reading(s.normal);
     const angle = Math.atan2(dir.y, dir.x) * 180 / Math.PI;
+    const normal2 = { x: sgn * s.normal.x, y: sgn * s.normal.y };
     return {
       point: s.point,
       tangent: dir,
-      normal: { x: sgn * s.normal.x, y: sgn * s.normal.y },
-      angle: angle === 0 ? 0 : angle === -180 ? 180 : angle
+      normal: normal2,
+      angle: angle === 0 ? 0 : angle === -180 ? 180 : angle,
+      turned: pointsDown(normal2)
     };
   };
   const toG = (f) => span === 0 ? 0 : reversed3 ? (to - f) / span : (f - from) / span;
@@ -545,6 +561,109 @@ function trackShapeD(shape, from = 0, to = 1) {
   return d;
 }
 
+// src/track/shift.ts
+var SAMPLES2 = 256;
+var dot2 = (a, b) => a.x * b.x + a.y * b.y;
+function bendSide(shape) {
+  let turn = 0;
+  let prev = shape.at(0);
+  for (let i = 1; i <= SAMPLES2; i++) {
+    const next = shape.at(i / SAMPLES2);
+    turn += dot2({ x: next.tangent.x - prev.tangent.x, y: next.tangent.y - prev.tangent.y }, prev.normal);
+    prev = next;
+  }
+  return Math.abs(turn) < 1e-9 ? 0 : turn > 0 ? 1 : -1;
+}
+function shiftTrack(shape, shift) {
+  if (shift === 0) return shape;
+  const moved2 = (s) => ({ ...s, point: { x: s.point.x + shift * s.normal.x, y: s.point.y + shift * s.normal.y } });
+  const table = new Float64Array(SAMPLES2 + 1);
+  let prev = moved2(shape.at(0));
+  for (let i = 1; i <= SAMPLES2; i++) {
+    const next = moved2(shape.at(i / SAMPLES2));
+    const step = { x: next.point.x - prev.point.x, y: next.point.y - prev.point.y };
+    const tangent = { x: prev.tangent.x + next.tangent.x, y: prev.tangent.y + next.tangent.y };
+    if (shape.length > 0 && dot2(step, tangent) <= 0) return null;
+    table[i] = table[i - 1] + Math.hypot(step.x, step.y);
+    prev = next;
+  }
+  const length2 = table[SAMPLES2];
+  const per = shape.length / SAMPLES2;
+  const startRatio = table[1] > 0 ? per / table[1] : 1;
+  const endRatio = table[SAMPLES2] - table[SAMPLES2 - 1] > 0 ? per / (table[SAMPLES2] - table[SAMPLES2 - 1]) : 1;
+  const toBase = (f) => {
+    const d = f * length2;
+    if (length2 <= 0 || shape.length <= 0) return f;
+    if (d < 0) return d * startRatio / shape.length;
+    if (d > length2) return 1 + (d - length2) * endRatio / shape.length;
+    let lo = 0;
+    let hi = SAMPLES2;
+    while (hi - lo > 1) {
+      const mid = lo + hi >> 1;
+      if (table[mid] <= d) lo = mid;
+      else hi = mid;
+    }
+    const span = table[hi] - table[lo];
+    return (lo + (span > 0 ? (d - table[lo]) / span : 0)) / SAMPLES2;
+  };
+  const fromBase = (g) => {
+    if (length2 <= 0 || shape.length <= 0) return g;
+    if (g < 0) return g * shape.length / startRatio / length2;
+    if (g > 1) return (length2 + (g - 1) * shape.length / endRatio) / length2;
+    const x = g * SAMPLES2;
+    const i = Math.min(SAMPLES2 - 1, Math.floor(x));
+    return (table[i] + (x - i) * (table[i + 1] - table[i])) / length2;
+  };
+  const at2 = (f, options) => moved2(shape.at(toBase(options?.open ? f : clamp(f, 0, 1)), options));
+  return {
+    kind: shape.kind,
+    length: length2,
+    closed: shape.closed,
+    at: at2,
+    nearest(p, options) {
+      const base = shape.nearest(p, options?.open ? { open: true, about: toBase(options.about ?? 0.5) } : void 0);
+      const f = fromBase(base.f);
+      const q = at2(f, options).point;
+      return { f, dist: Math.hypot(p.x - q.x, p.y - q.y) };
+    }
+  };
+}
+
+// src/track/slice.ts
+var RAD3 = Math.PI / 180;
+var seen = (c, p) => Math.atan2(p.x - c.x, c.y - p.y) / RAD3;
+function trackSlice(shape, from, to) {
+  const lo = clamp(Math.min(from, to), 0, 1);
+  const hi = clamp(Math.max(from, to), 0, 1);
+  if (lo === 0 && hi === 1) return shape;
+  const a = shape.at(lo).point;
+  const b = shape.at(hi).point;
+  if (shape.kind === "line") return lineShape(a, b);
+  if (shape.kind === "arc" && "arc" in shape) {
+    const { center, radius, direction } = shape.arc;
+    if (hi === lo) return arcShape({ center, radius: 0, start: 0, end: 0 });
+    return arcShape({ center, radius, start: seen(center, a), end: seen(center, b), direction });
+  }
+  if (shape.kind === "ellipse" && "ellipse" in shape) {
+    const { center, radiusX, radiusY, direction } = shape.ellipse;
+    if (hi === lo) return ellipseShape({ center, radiusX: 0, radiusY: 0, start: 0, end: 0 });
+    return ellipseShape({ center, radiusX, radiusY, start: seen(center, a), end: seen(center, b), direction });
+  }
+  const span = hi - lo;
+  return {
+    kind: shape.kind,
+    length: shape.length * span,
+    closed: false,
+    at: (f, options) => shape.at(lo + (options?.open ? f : clamp(f, 0, 1)) * span, options),
+    nearest(p) {
+      const n = shape.nearest(p);
+      const f = clamp(n.f, lo, hi);
+      const q = shape.at(f).point;
+      return { f: span === 0 ? 0 : (f - lo) / span, dist: Math.hypot(p.x - q.x, p.y - q.y) };
+    }
+  };
+}
+
 // src/track/place.ts
 var clipOf = (lo, hi, start, end, hair = 0) => lo >= start - hair && hi <= end + hair ? "none" : hi <= start + hair || lo >= end - hair ? "past" : "part";
 function runPlaces(lengths, gap, room, align, offset2, at2) {
@@ -562,14 +681,19 @@ function runPlaces(lengths, gap, room, align, offset2, at2) {
 function runLength(lengths, gap) {
   return lengths.reduce((sum, length2, i) => sum + length2 + (i > 0 ? gap : 0), 0);
 }
-function runStationAt(run2, distance, shift = 0) {
+function runStationAt(run2, distance, shift = 0, past = "extend") {
   const { length: length2 } = run2;
+  if (past === "follow" && length2 > 0) {
+    const place2 = run2.at(distance / length2, { open: true });
+    const { point: point2, normal: normal3 } = place2;
+    return { ...place2, point: { x: point2.x + shift * normal3.x, y: point2.y + shift * normal3.y } };
+  }
   const place = run2.at(length2 === 0 ? 0 : distance / length2);
-  const past = distance < 0 ? distance : distance > length2 ? distance - length2 : 0;
+  const beyond = distance < 0 ? distance : distance > length2 ? distance - length2 : 0;
   const { point, tangent, normal: normal2 } = place;
   return {
     ...place,
-    point: { x: point.x + past * tangent.x + shift * normal2.x, y: point.y + past * tangent.y + shift * normal2.y }
+    point: { x: point.x + beyond * tangent.x + shift * normal2.x, y: point.y + beyond * tangent.y + shift * normal2.y }
   };
 }
 function placeAlongRun(run2, lengths, options = {}) {
@@ -584,7 +708,7 @@ function placeAlongRun(run2, lengths, options = {}) {
     let distance = spot.center;
     if (past === "hold" && clipped === "past") distance = clamp(distance, lap?.start ?? 0, lap?.end ?? length2);
     if (lap && length2 > 0) distance = (distance % length2 + length2) % length2;
-    return { ...runStationAt(run2, mirror ? length2 - distance : distance, shift), center: spot.center, clipped };
+    return { ...runStationAt(run2, mirror ? length2 - distance : distance, shift, past === "extend" ? "extend" : "follow"), center: spot.center, clipped };
   });
 }
 function wrapWindow(first, firstLength, length2) {
@@ -1592,9 +1716,9 @@ function arcToCubics(x1, y1, x2, y2, rx, ry, xAxisRotationDeg, largeArc, sweep,
   const cx = cosPhi * cxp - sinPhi * cyp + (x1 + x2) / 2;
   const cy = sinPhi * cxp + cosPhi * cyp + (y1 + y2) / 2;
   const angle = (ux, uy, vx, vy) => {
-    const dot2 = ux * vx + uy * vy;
+    const dot3 = ux * vx + uy * vy;
     const len = Math.sqrt((ux * ux + uy * uy) * (vx * vx + vy * vy));
-    let a = Math.acos(Math.max(-1, Math.min(1, dot2 / len)));
+    let a = Math.acos(Math.max(-1, Math.min(1, dot3 / len)));
     if (ux * vy - uy * vx < 0) a = -a;
     return a;
   };
@@ -2311,12 +2435,12 @@ function createPathSnapIndex(paths, extra = []) {
     if (kind === "center") return out;
     if (kind === "anchor") {
       segments.forEach((segs, path) => {
-        const seen = /* @__PURE__ */ new Set();
+        const seen2 = /* @__PURE__ */ new Set();
         for (const s of segs) {
           for (const p of [s.pts[0], s.pts[s.pts.length - 1]]) {
             const key = `${p.x},${p.y}`;
-            if (seen.has(key)) continue;
-            seen.add(key);
+            if (seen2.has(key)) continue;
+            seen2.add(key);
             out.push({ kind: "anchor", x: p.x, y: p.y, paths: [path] });
           }
         }
@@ -3304,7 +3428,7 @@ function unit(p) {
 
 // src/paths/growRegion.ts
 var MAX_DEPTH2 = 6;
-var SAMPLES2 = [0.2, 0.35, 0.5, 0.65, 0.8];
+var SAMPLES3 = [0.2, 0.35, 0.5, 0.65, 0.8];
 function growRegion(path, distance, opts = {}) {
   const b = new PathBuilder();
   if (!(distance > 0)) return b.build();
@@ -3343,15 +3467,15 @@ function joinPieces(prev, next, v, tin, tout, ctx) {
   const gap = Math.hypot(b[0] - a[0], b[1] - a[1]);
   if (gap <= ctx.tol * 1e-3) return [];
   const cross2 = tin[0] * tout[1] - tin[1] * tout[0];
-  const dot2 = tin[0] * tout[0] + tin[1] * tout[1];
-  const convex = ctx.sigma * cross2 > 0 || Math.abs(cross2) < 1e-9 && dot2 < 0;
+  const dot3 = tin[0] * tout[0] + tin[1] * tout[1];
+  const convex = ctx.sigma * cross2 > 0 || Math.abs(cross2) < 1e-9 && dot3 < 0;
   if (gap <= ctx.tol) return snap(prev, next, a);
   if (!convex) {
     if (trimAtCrossing(prev, next)) return [];
     return [lineSegment(a[0], a[1], v[0], v[1]), lineSegment(v[0], v[1], b[0], b[1])];
   }
   const nin = normal(tin, ctx.sigma), nout = normal(tout, ctx.sigma);
-  if (ctx.join === "round") return arc(v, ctx.d, nin, Math.atan2(cross2, dot2));
+  if (ctx.join === "round") return arc(v, ctx.d, nin, Math.atan2(cross2, dot3));
   const cos = nin[0] * nout[0] + nin[1] * nout[1];
   if (1 + cos < 1e-9 || Math.sqrt(2 / (1 + cos)) > ctx.miterLimit) return [lineSegment(a[0], a[1], b[0], b[1])];
   const k = ctx.d / (1 + cos);
@@ -3477,7 +3601,7 @@ function offsetSeg(seg, ctx, depth) {
 }
 function offsetError(c, q, ctx) {
   let worst2 = 0;
-  for (const t of SAMPLES2) {
+  for (const t of SAMPLES3) {
     const [dx2, dy2] = derivative(c, t);
     const len = Math.hypot(dx2, dy2);
     if (len < 1e-12) continue;
@@ -6663,6 +6787,6 @@ function typedArrayReplacer(_key, value) {
   return tagTypedArray(value) ?? value;
 }
 
-export { ANCHOR_FIELDS, CONSTRAINT_TOLERANCE, EASINGS, PATH_SNAP_KINDS, SPRING_PRESETS, TYPED_ARRAY_CONSTRUCTORS, ZOOM_FLOOR, addExtremaAnchors, anchorAt, anchorCount, anchorOriginsOf, anchorSymmetries, anchorSymmetry, anchorsBefore, anchorsInRect, anchorsUnderBrush, anchorsWhere, applyToPoint, arcShape, averageAnchorsAt, balanceFactorToward, bendAlongPath, bendSegment, blendPaths, boxToBox, circlePath, clampRectWithin, closestOpenEnds, composePath, conflictingConstraints, constrainPathEdit, constrainPathsEdit, constraintAnchors, constraintApplies, constraintFits, convertSegments, cornerAnchors, createPathSnapIndex, cubicBezierEasing, cubicContoursToPath, decomposePath, deleteAnchorsAt, directionMarks, easeIn, easeInBack, easeInBounce, easeInCirc, easeInCubic, easeInElastic, easeInExpo, easeInOut, easeInOutBack, easeInOutBounce, easeInOutCirc, easeInOutCubic, easeInOutElastic, easeInOutExpo, easeInOutQuad, easeInOutQuart, easeInOutQuint, easeInOutSine, easeInQuad, easeInQuart, easeInQuint, easeInSine, easeOut, easeOutBack, easeOutBounce, easeOutCirc, easeOutCubic, easeOutElastic, easeOutExpo, easeOutQuad, easeOutQuart, easeOutQuint, easeOutSine, editAnchorSet, editAnchorSetTracked, ellipseShape, equalizeSegmentHandles, everyNthAnchor, extendToMeet, findPathSnap, findPathSnaps, fitAffine, fitCubicThroughDeletion, flatAnchorIndex, flatIndexesAfterReverse, growAnchorSelection, growRegion, handleAlongItsAngle, handleAtItsLength, handleBalances, harmonizeAnchors, hasOpenSubpath, identity, insertAnchorOnSegment, intersectSegments, invert, invertAnchorSelection, isSegmentStraight, joinAnchorsAt, joinSubpathEnds, lengthToward, lengthenOpenEnd, lengthenPathEnd, lineShape, linear, locateAnchor, makeHandlesSymmetric, mapConstraintAnchors, mat3, meanScale, measureAnchorPath, measurePath, mergeRegion, moveHandleSymmetric, moveHandleTo, multiply, nearestPathAnchor, normalizeZoom, offsetCornerTraces, openEndAt, openEndRay, openPathEnds, openSubpathAt, pathAnchorPoints, pathAwayFromAnchors, pathContainsPoint, pathContainsPolygon, pathContainsRect, pathCrossings, pathDistanceToPoint, pathEndAnchorIndex, pathEndFrame, pathFromD, pathInPoseFrame, pathInWorld, pathIntersectsPolygon, pathIntersectsRect, pathSegments, pathShape, pathSignedArea, pathThroughPoseFrame, pathToCubicContours, pathToD, placeAlongRun, placeRect, pointAlongPath, pointInPath, polygonContainsPath, polygonIntersectsPath, portControls2 as portControls, portCurvePoints2 as portCurvePoints, poseFrameInverseOf, poseFrameOf, poseLinearOf, poseRotationOf, prepareBlend, pxExtent, readAnchorFields, rectMarkerPath, remapAnchorValues, remapConstraints, remapPointValues, repeatAlongPath, resamplePath, resolveEasing, retractHandles, reverseAnchors, reversePath, reverseSubpaths, reviveTypedArrays, rotate, rotateAboutPoint, rotatePathAround, roundRectPath, runLength, runPlaces, runStationAt, scale, scaleDelta, scalePathToBounds, scaleSegmentHandles, screenAngleOf, segmentAt2 as segmentAt, segmentBetween, segmentExtremaTs, segmentsBetweenAnchors, setSubpathStart, shrinkAnchorSelection, simplifyAnchorsAt, simplifyPath, simplifySpan, simplifySubpath, smoothAnchors, smudgePath, softFalloff, softSelectionBand, softSelectionWeights, solveConstraints, solvePathConstraints, splitByClosure, splitSubpaths, squarePath, standoff, stationsAlongPath, strokeHitTest, subpathEndAt, subpathsOfAnchors, tagTypedArray, tagTypedArrays, trackRun, trackShapeD, transformCoords, transformPath, translate, translateAnchorBy, translateAnchorsSymmetric, translatePath, trimPathAt, typedArrayReplacer, unionBoundsPath, unsatisfiedConstraints, untagTypedArray, viewToMat3, withAnchorPoints, withinPxBox, withinPxRadius, worldEditToStorage, writeAnchorField };
+export { ANCHOR_FIELDS, CONSTRAINT_TOLERANCE, EASINGS, PATH_SNAP_KINDS, SPRING_PRESETS, TYPED_ARRAY_CONSTRUCTORS, ZOOM_FLOOR, addExtremaAnchors, anchorAt, anchorCount, anchorOriginsOf, anchorSymmetries, anchorSymmetry, anchorsBefore, anchorsInRect, anchorsUnderBrush, anchorsWhere, applyToPoint, arcShape, averageAnchorsAt, balanceFactorToward, bendAlongPath, bendSegment, bendSide, blendPaths, boxToBox, circlePath, clampRectWithin, closestOpenEnds, composePath, conflictingConstraints, constrainPathEdit, constrainPathsEdit, constraintAnchors, constraintApplies, constraintFits, convertSegments, cornerAnchors, createPathSnapIndex, cubicBezierEasing, cubicContoursToPath, decomposePath, deleteAnchorsAt, directionMarks, easeIn, easeInBack, easeInBounce, easeInCirc, easeInCubic, easeInElastic, easeInExpo, easeInOut, easeInOutBack, easeInOutBounce, easeInOutCirc, easeInOutCubic, easeInOutElastic, easeInOutExpo, easeInOutQuad, easeInOutQuart, easeInOutQuint, easeInOutSine, easeInQuad, easeInQuart, easeInQuint, easeInSine, easeOut, easeOutBack, easeOutBounce, easeOutCirc, easeOutCubic, easeOutElastic, easeOutExpo, easeOutQuad, easeOutQuart, easeOutQuint, easeOutSine, editAnchorSet, editAnchorSetTracked, ellipseShape, equalizeSegmentHandles, everyNthAnchor, extendToMeet, findPathSnap, findPathSnaps, fitAffine, fitCubicThroughDeletion, flatAnchorIndex, flatIndexesAfterReverse, growAnchorSelection, growRegion, handleAlongItsAngle, handleAtItsLength, handleBalances, harmonizeAnchors, hasOpenSubpath, identity, insertAnchorOnSegment, intersectSegments, invert, invertAnchorSelection, isSegmentStraight, joinAnchorsAt, joinSubpathEnds, lengthToward, lengthenOpenEnd, lengthenPathEnd, lineShape, linear, locateAnchor, makeHandlesSymmetric, mapConstraintAnchors, mat3, meanScale, measureAnchorPath, measurePath, mergeRegion, moveHandleSymmetric, moveHandleTo, multiply, nearestPathAnchor, normalizeZoom, offsetCornerTraces, openEndAt, openEndRay, openPathEnds, openSubpathAt, pathAnchorPoints, pathAwayFromAnchors, pathContainsPoint, pathContainsPolygon, pathContainsRect, pathCrossings, pathDistanceToPoint, pathEndAnchorIndex, pathEndFrame, pathFromD, pathInPoseFrame, pathInWorld, pathIntersectsPolygon, pathIntersectsRect, pathSegments, pathShape, pathSignedArea, pathThroughPoseFrame, pathToCubicContours, pathToD, placeAlongRun, placeRect, pointAlongPath, pointInPath, polygonContainsPath, polygonIntersectsPath, portControls2 as portControls, portCurvePoints2 as portCurvePoints, poseFrameInverseOf, poseFrameOf, poseLinearOf, poseRotationOf, prepareBlend, pxExtent, readAnchorFields, rectMarkerPath, remapAnchorValues, remapConstraints, remapPointValues, repeatAlongPath, resamplePath, resolveEasing, retractHandles, reverseAnchors, reversePath, reverseSubpaths, reviveTypedArrays, rotate, rotateAboutPoint, rotatePathAround, roundRectPath, runLength, runPlaces, runStationAt, scale, scaleDelta, scalePathToBounds, scaleSegmentHandles, screenAngleOf, segmentAt2 as segmentAt, segmentBetween, segmentExtremaTs, segmentsBetweenAnchors, setSubpathStart, shiftTrack, shrinkAnchorSelection, simplifyAnchorsAt, simplifyPath, simplifySpan, simplifySubpath, smoothAnchors, smudgePath, softFalloff, softSelectionBand, softSelectionWeights, solveConstraints, solvePathConstraints, splitByClosure, splitSubpaths, squarePath, standoff, stationsAlongPath, strokeHitTest, subpathEndAt, subpathsOfAnchors, tagTypedArray, tagTypedArrays, trackRun, trackShapeD, trackSlice, transformCoords, transformPath, translate, translateAnchorBy, translateAnchorsSymmetric, translatePath, trimPathAt, typedArrayReplacer, unionBoundsPath, unsatisfiedConstraints, untagTypedArray, viewToMat3, withAnchorPoints, withinPxBox, withinPxRadius, worldEditToStorage, writeAnchorField };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map