@weasel-js/geom 1.11.0 → 1.12.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { c as PathOpenFill, P as PolygonPath, d as PathFillRule, a as Path, R as RectPath, b as Point, C as CornerSpec, e as CornerPiece } from './path-BW8d_2RY.js';
+import { b as Point, a as Path, c as PathOpenFill, P as PolygonPath, d as PathFillRule, R as RectPath, C as CornerSpec, e as CornerPiece } from './path-BW8d_2RY.js';
 export { f as CORNER_FIT_TOLERANCE, g as CORNER_KEYWORDS, h as CornerKeyword, i as CornerShape, j as CornerShapeFrame, k as compactCorners, l as cornerAt, m as cornerCenter, n as cornerKeywordOf, o as cornerShapeK, p as cornerShapePieces, q as cornerShapePoint, r as cornerSpecAt, s as cubicPointAt, t as hasCorners, u as isCornerShape, v as lerpCorners, w as nextCornerShape, x as scaleCorners, y as splitCubicAtT, z as withCorner, A as withoutCorners } from './path-BW8d_2RY.js';
 import { A as AnchorSet, P as PenAnchor, a as SpiroPoint, S as SpiroKind, b as Scale2 } from './curvature-PkoLduGc.js';
 export { c as AnchorRect, d as CombTooth, e as CurvatureCombOptions, C as CurvatureSource, E as EulerFit, f as EulerSegment, g as SPIRO_KINDS, h as SegmentComb, i as SegmentHit, j as SpiroSegment, k as anchorAt, l as anchorCount, m as anchorsInRect, n as anchorsToPath, o as combTeeth, p as countPathAnchors, q as cubicCurvatureAt, r as cubicCurvatureSource, s as cubicDerivativeAt, t as curvatureComb, u as deleteAnchorsAt, v as editAnchorSet, w as eulerAngleAt, x as eulerCurvatureAt, y as eulerCurvatureDerivativesAt, z as eulerPointAt, B as fitEulerSegment, D as flatAnchorIndex, F as insertAnchorOnSegment, G as isAnchorSmooth, H as isSpiroKind, I as isStraightSegment, J as locateAnchor, K as moveHandleTo, L as nearestSegmentT, M as openSubpathAt, N as pathToAnchors, O as placeEulerSegment, Q as pxExtent, R as scaleDelta, T as screenAngleOf, U as segmentAt, V as segmentEnds, W as solveSpiro, X as standoff, Y as translateAnchorBy, Z as withinPxBox, _ as withinPxRadius } from './curvature-PkoLduGc.js';
@@ -262,6 +262,235 @@ declare function nearestOnQuadratic(px: number, py: number, x0: number, y0: numb
  */
 declare function nearestOnPath(commands: ArrayLike<number>, coords: ArrayLike<number>, px: number, py: number): PathNearest | null;
 
+/**
+ * A path measured once by arc length, so many stations along it cost a binary
+ * search each rather than a fresh flatten: what `pointAlongPath` answers one
+ * fraction at a time, and what anything placing or bending geometry along a
+ * path reads many times over.
+ */
+
+/** A point on a path and its heading there. */
+interface PathStation {
+    point: Point;
+    /** Unit vector along the path at `point`, pointing toward the end. */
+    tangent: Point;
+}
+/** Options for {@link measurePath}. */
+interface MeasurePathOptions {
+    /** Curve flattening tolerance, in world units. Default 0.5. */
+    flattenTolerance?: number;
+    /** Keep a vertex that turns further than flattening at the tolerance could as a corner: `at`'s `smooth` heading then
+     *  blends only across the vertices flattening made, and a straight edge heads along itself. Default false. */
+    keepCorners?: boolean;
+}
+/** The station on a path nearest a point. */
+interface PathNearestStation extends PathStation {
+    /** Arc length at `point`, on the scale {@link PathMeasure.at} reads. */
+    s: number;
+    /** Distance from the queried point to `point`. */
+    dist: number;
+}
+/** A measured path: its length, and the station at any distance along it. */
+interface PathMeasure {
+    /** Total arc length, every subpath counted in order. */
+    readonly length: number;
+    /** True when the path is a single closed contour, so a distance past the
+     *  end can wrap round to the start. */
+    readonly closed: boolean;
+    /**
+     * The station `s` along the path, `s` clamped to `0..length`.
+     *
+     * The tangent is the heading of the flattened segment under `s`. With
+     * `smooth`, it is instead blended across each segment from the heading at
+     * one vertex to the next, so geometry bent along it turns without facets.
+     */
+    at(s: number, smooth?: boolean): PathStation;
+    /**
+     * The inverse of `at`: the station nearest `p`. On a tie the earliest
+     * segment wins. The tangent is the heading of the segment holding it.
+     */
+    nearest(p: Point): PathNearestStation;
+}
+/**
+ * Measure `path` by arc length. Subpaths are measured in order and treated as
+ * one run, the way a browser measures a whole `<path>`. Returns `null` for a
+ * path with no points; a path of zero length answers at its single point,
+ * heading along +X.
+ */
+declare function measurePath(path: Path, opts?: MeasurePathOptions): PathMeasure | null;
+
+/** A station on a track, plus the side items stand on. */
+interface TrackStation extends PathStation {
+    /** Unit vector the items stand on: away from an arc's center, left of travel on a line. */
+    normal: Point;
+}
+/** The nearest spot on a track to a point: its fraction along and the distance to it. */
+interface TrackNearest {
+    f: number;
+    dist: number;
+}
+/** How `nearest` treats a track's ends. */
+interface TrackNearestOptions {
+    /** Let `f` run on past 0 and 1: a line extends straight, an arc, an ellipse or a closed path round itself, unwrapped about
+     *  `about`. A shape that cannot extend clamps. `dist` is to the track either way. */
+    open?: boolean;
+    /** Where along the track an open arc is unwrapped about, in the same terms as the `f` this `nearest` answers (a
+     *  `TrackRun` reads it in reading order): a point is placed on whichever side of it is nearer by angle. Default 0.5,
+     *  the middle. */
+    about?: number;
+}
+/** 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. */
+interface TrackShape {
+    readonly kind: TrackShapeKind;
+    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 spot on the track nearest `p`. */
+    nearest(p: Point, options?: TrackNearestOptions): TrackNearest;
+}
+/** A straight track from `from` to `to`; its normal is the left of travel. */
+declare function lineShape(from: Point, to: Point): TrackShape;
+
+/** An arc track: degrees clockwise from 12 o'clock on a y-down plane. Equal `start` and `end` is a whole circle. */
+interface ArcTrackSpec {
+    center: Point;
+    radius: number;
+    start: number;
+    end: number;
+    /** Which way the track runs from `start` to `end`. Default `'cw'`. */
+    direction?: 'cw' | 'ccw';
+}
+/** A track shape that remembers the arc it was built from, so path data can be drawn as arcs. */
+type ArcTrackShape = TrackShape & {
+    readonly arc: ArcTrackSpec;
+};
+/** An arc track; its normal points away from the center, whichever way it runs. */
+declare function arcShape(spec: ArcTrackSpec): ArcTrackShape;
+
+/** An axis-aligned elliptical arc track. `start` and `end` are directions seen from the center, in degrees clockwise
+ *  from 12 o'clock on a y-down plane, as an arc's are; equal `start` and `end` is the whole ellipse. */
+interface EllipseTrackSpec {
+    center: Point;
+    /** Half the width. */
+    radiusX: number;
+    /** Half the height. */
+    radiusY: number;
+    start: number;
+    end: number;
+    /** Which way the track runs from `start` to `end`. Default `'cw'`. */
+    direction?: 'cw' | 'ccw';
+}
+/** A track shape that remembers the ellipse it was built from, so path data can be drawn as elliptical arcs. */
+type EllipseTrackShape = TrackShape & {
+    readonly ellipse: EllipseTrackSpec;
+};
+/**
+ * An elliptical arc track, addressed by fraction of its length; its normal points away from the center, square to the
+ * ellipse, whichever way it runs. With equal radii it is `arcShape`'s arc.
+ */
+declare function ellipseShape(spec: EllipseTrackSpec): EllipseTrackShape;
+
+/** A track shape that remembers the path it was built from, so path data can be drawn as the path itself. */
+type PathTrackShape = TrackShape & {
+    readonly path: Path;
+};
+/**
+ * A track along any path, every subpath counted in order, addressed by fraction of its length. Its normal is the left of
+ * travel, as a line's is: outward on a contour drawn clockwise on screen. `null` for a path with no points.
+ */
+declare function pathShape(path: Path, options?: {
+    flattenTolerance?: number;
+}): PathTrackShape | null;
+
+/** A station as a run places an item: `normal` is the item's up after any flip, `tangent` its reading direction,
+ *  `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;
+}
+/** 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. */
+interface TrackRun extends TrackShape {
+    readonly shape: TrackShape;
+    readonly from: number;
+    readonly to: number;
+    /** True when items stand on the shape's normal turned over: under `side: 'auto'`, when that normal points down the screen
+     *  at `about`, so they stand upright. */
+    readonly flipped: boolean;
+    /** True when reading order runs against the shape's own direction. */
+    readonly reversed: boolean;
+    at(g: number): 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. */
+type TrackSide = 'auto' | 'path' | 'flipped';
+/** How {@link trackRun} reads a shape: which side of it is up, and where that is judged. */
+interface TrackRunOptions {
+    /** Default `'auto'`. */
+    side?: TrackSide;
+    /** The shape fraction `'auto'` judges the side at. Default the run's middle, `(from + to) / 2`. */
+    about?: number;
+}
+/** The stretch `from..to` (default the whole shape) as items read it: on the side `options.side` picks, reversed to read
+ *  left to right on that side. */
+declare function trackRun(shape: TrackShape, from?: number, to?: number, options?: TrackRunOptions): TrackRun;
+
+/** SVG path data for the stretch `from..to` of a shape: a segment for a line, true arcs for an arc or an ellipse, else a
+ *  64-step polyline. A whole path shape is its path's own data. */
+declare function trackShapeD(shape: TrackShape, from?: number, to?: number): string;
+
+/** 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
+ *  shape's own direction starts. The two differ only on a run that is `reversed`. */
+type RunOrder = 'reading' | 'track';
+/** Where one item of a run falls: its center along the run, and how much of it lies past the run's ends. */
+interface RunSpot {
+    center: number;
+    clipped: 'none' | 'part' | 'past';
+}
+/**
+ * Where each item's center falls along a run `room` px long, gaps measured along it. Without `at`, a sequence that fits
+ * sits as `align` says, and one that does not is laid from the start less `offset`. With `at`, the sequence's align
+ * point sits at `at - offset` whether or not it fits.
+ */
+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 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. */
+    gap?: number;
+    /** Default `'center'`. */
+    align?: RunAlign;
+    /** How far the sequence is laid back along the run. Default 0. */
+    offset?: number;
+    /** Where along the run the sequence's align point sits, fitting or not; see {@link runPlaces}. */
+    at?: number;
+    /** How far each item stands off the run, along its up. Default 0. */
+    shift?: number;
+    /** 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';
+    /** `'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. */
+    order?: RunOrder;
+}
+/** One item laid along a run: where its center falls and the place there. `center` is unwrapped. */
+interface RunPlace extends RunSpot, TrackPlace {
+}
+/** Items of `lengths` laid end to end along `run`, each centered on its place and tipped to it. */
+declare function placeAlongRun(run: TrackRun, lengths: readonly number[], options?: PlaceAlongRunOptions): RunPlace[];
+
 /**
  * The port-curve rule in the 2D kernel's currency: loose scalars, the way
  * `cubicEvalAt` and `applyToPoint` take them. The rule itself lives in
@@ -677,46 +906,16 @@ declare function reversePath(path: PolygonPath): PolygonPath;
 declare function pathFromD(d: string, onWarn?: (message: string) => void): ReturnType<PathBuilder['build']>;
 
 /**
- * A path measured once by arc length, so many stations along it cost a binary
- * search each rather than a fresh flatten: what `pointAlongPath` answers one
- * fraction at a time, and what anything placing or bending geometry along a
- * path reads many times over.
+ * `pathToD` — a weasel `Path` as an SVG `d=` string, the inverse of
+ * `pathFromD`. `RectPath` lowers to `M h v h Z`; `PolygonPath` walks the
+ * (commands, coords) arrays, one SVG command per kit command, with corner
+ * shapes expanded into the geometry they draw.
+ *
+ * Absolute commands only; numbers are rounded to 6 decimals.
  */
 
-/** A point on a path and its heading there. */
-interface PathStation {
-    point: Point;
-    /** Unit vector along the path at `point`, pointing toward the end. */
-    tangent: Point;
-}
-/** Options for {@link measurePath}. */
-interface MeasurePathOptions {
-    /** Curve flattening tolerance, in world units. Default 0.5. */
-    flattenTolerance?: number;
-}
-/** A measured path: its length, and the station at any distance along it. */
-interface PathMeasure {
-    /** Total arc length, every subpath counted in order. */
-    readonly length: number;
-    /** True when the path is a single closed contour, so a distance past the
-     *  end can wrap round to the start. */
-    readonly closed: boolean;
-    /**
-     * The station `s` along the path, `s` clamped to `0..length`.
-     *
-     * The tangent is the heading of the flattened segment under `s`. With
-     * `smooth`, it is instead blended across each segment from the heading at
-     * one vertex to the next, so geometry bent along it turns without facets.
-     */
-    at(s: number, smooth?: boolean): PathStation;
-}
-/**
- * Measure `path` by arc length. Subpaths are measured in order and treated as
- * one run, the way a browser measures a whole `<path>`. Returns `null` for a
- * path with no points; a path of zero length answers at its single point,
- * heading along +X.
- */
-declare function measurePath(path: Path, opts?: MeasurePathOptions): PathMeasure | null;
+/** `path` as SVG path data. */
+declare function pathToD(given: Path): string;
 
 /**
  * A station along a path: where it is at a fraction of its length, and which
@@ -1294,7 +1493,8 @@ interface GrowRegionOptions {
  * overlap rather than merge, and a hole grown shut winds back on itself and
  * fills. At an inside corner the two offset edges are cut back to where they
  * cross; where they do not, the gap is passed through the corner's original
- * point, which closes it with a loop inside the fill.
+ * point, which closes it with a loop inside the fill. `mergeRegion`
+ * redraws the result as its outline alone, for a stroke.
  *
  * What it costs: one segment per curve, more where `tolerance` needs the curve
  * split; a miter corner between two straight edges costs nothing, one beside
@@ -1303,6 +1503,22 @@ interface GrowRegionOptions {
  */
 declare function growRegion(path: Path, distance: number, opts?: GrowRegionOptions): PolygonPath;
 
+/** Options for {@link mergeRegion}. */
+interface MergeRegionOptions {
+    /** How far from an edge a point is taken to tell which side is filled, in
+     *  the path's units; a sliver of region thinner than this may be lost.
+     *  Default 0.01. */
+    tolerance?: number;
+}
+/**
+ * The region `path` fills under `'nonzero'`, as contours that neither cross
+ * nor overlap, wound so the fill lies on the same side of each as it does on
+ * most of `path`. Stroking it traces only the region's edge. Every subpath
+ * counts as closed. Answers `path`'s own contours, unchanged, where nothing
+ * needs cutting or dropping.
+ */
+declare function mergeRegion(path: Path, opts?: MergeRegionOptions): PolygonPath;
+
 /**
  * Simplify only where `flatIndexes` say: each unbroken run of those anchors
  * along a subpath is refitted as one span by the fitter {@link simplifyPath}
@@ -2542,6 +2758,8 @@ interface PathsEditItem extends ConstrainPathEditOptions {
     /** `before` as the edit left it; `before` itself for a path the edit did not touch. */
     after: PolygonPath;
     constraints: readonly PathConstraint[];
+    /** For a path the edit left alone: its anchors give way as freely as any the edit did not move, rather than only when the edited paths cannot. */
+    yields?: boolean;
 }
 /**
  * A constraint across paths. Its anchors are numbered over the anchors of
@@ -2573,7 +2791,8 @@ interface ConstrainedPathsEdit {
  * An edit of constrained paths, finished so their constraints and the links
  * between them hold, as one solve over every anchor: the anchors and handles
  * the edit moved are held, and so are the anchors of a path it left alone
- * (`after === before`), except one held on a segment; `fixed` anchors go
+ * (`after === before`), except one held on a segment or on a path that
+ * `yields`; `fixed` anchors go
  * back to where they were, and the rest move the least they must. A constraint
  * that did not hold before the edit is left out of the solve, and reported.
  * Each item's own `horizontal` and `vertical` read its own `axisAngle`.
@@ -2855,4 +3074,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 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 ExtendToMeetOptions, type FramedBox, type GlMat3, type GrowRegionOptions, type HandleBalance, type HandleRef, type JoinOptions, type LengthenMode, type LineCoords, type MeasureAnchorPathOptions, type MeasurePathOptions, 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, PathOpenFill, type PathSegment, type PathSnapHit, type PathSnapIndex, type PathSnapKind, type PathSnapQuery, type PathSnapTarget, type PathStation, type PathStop, type PathsEditItem, PenAnchor, 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, 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 TrimPathOptions, type TrimResult, type TypedArrayTag, type UnsatisfiedConstraintsOptions, type View, ZOOM_FLOOR, addExtremaAnchors, anchorOriginsOf, anchorSymmetries, anchorSymmetry, anchorsBefore, anchorsUnderBrush, anchorsWhere, applyToPoint, approxEq, 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, 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, linear, makeHandlesSymmetric, mapConstraintAnchors, mat3, meanScale, measureAnchorPath, measurePath, 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, pathSignedArea, pathThroughPoseFrame, pathToCubicContours, 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, 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, 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 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 };