@weasel-js/geom 1.11.1 → 1.13.0-rc.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,266 @@ 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;
+}
+/** 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. */
+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 unless `options.open`. */
+    at(f: number, options?: TrackAtOptions): 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;
+    /** 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. */
+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, 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. */
+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;
+
+/** 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
+ *  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;
+/** 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. */
+    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 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. */
+    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
@@ -688,60 +948,6 @@ declare function pathFromD(d: string, onWarn?: (message: string) => void): Retur
 /** `path` as SVG path data. */
 declare function pathToD(given: Path): string;
 
-/**
- * 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;
-}
-/** 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 along a path: where it is at a fraction of its length, and which
  * way it is heading there.
@@ -2899,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 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 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 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, 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, pathSignedArea, pathThroughPoseFrame, pathToCubicContours, pathToD, 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 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 };