@weasel-js/geom 1.15.1 → 1.16.0

package/dist/index.d.ts

@@ -1,9 +1,32 @@
-import { A as Affine, a as AnchorSet, P as PenAnchor, b as SpiroPoint, S as SpiroKind, c as Scale2 } from './curvature-CDOI32hv.js';
-export { d as AnchorRect, e as CombTooth, f as CurvatureCombOptions, C as CurvatureSource, E as EulerFit, g as EulerSegment, h as SPIRO_KINDS, i as SegmentComb, j as SegmentHit, k as SpiroSegment, l as anchorAt, m as anchorCount, n as anchorsInRect, o as anchorsToPath, p as applyToPoint, q as boxToBox, r as combTeeth, s as countPathAnchors, t as cubicCurvatureAt, u as cubicCurvatureSource, v as cubicDerivativeAt, w as curvatureComb, x as deleteAnchorsAt, y as editAnchorSet, z as eulerAngleAt, B as eulerCurvatureAt, D as eulerCurvatureDerivativesAt, F as eulerPointAt, G as fitEulerSegment, H as flatAnchorIndex, I as identity, J as insertAnchorOnSegment, K as invert, L as isAnchorSmooth, M as isSpiroKind, N as isStraightSegment, O as locateAnchor, Q as moveHandleTo, R as multiply, T as nearestSegmentT, U as openSubpathAt, V as pathToAnchors, W as placeEulerSegment, X as pxExtent, Y as pxExtentInFrame, Z as rotate, _ as rotateAboutPoint, $ as scale, a0 as scaleDelta, a1 as screenAngleOf, a2 as segmentAt, a3 as segmentEnds, a4 as solveSpiro, a5 as standoff, a6 as transformCoords, a7 as translate, a8 as translateAnchorBy, a9 as withinPxBox, aa as withinPxRadius } from './curvature-CDOI32hv.js';
+import { A as Affine, a as AnchorSet, P as PenAnchor, b as SpiroPoint, S as SpiroKind, c as Scale2 } from './curvature-DKPO4Qeh.js';
+export { d as AnchorRect, e as CombTooth, f as CurvatureCombOptions, C as CurvatureSource, E as EulerFit, g as EulerSegment, h as SPIRO_KINDS, i as SegmentComb, j as SegmentHit, k as SpiroSegment, l as anchorAt, m as anchorCount, n as anchorsInRect, o as anchorsToPath, p as applyToPoint, q as boxToBox, r as combTeeth, s as countPathAnchors, t as cubicCurvatureAt, u as cubicCurvatureSource, v as cubicDerivativeAt, w as curvatureComb, x as deleteAnchorsAt, y as editAnchorSet, z as eulerAngleAt, B as eulerCurvatureAt, D as eulerCurvatureDerivativesAt, F as eulerPointAt, G as fitEulerSegment, H as flatAnchorIndex, I as identity, J as insertAnchorOnSegment, K as invert, L as isAnchorSmooth, M as isSpiroKind, N as isStraightSegment, O as locateAnchor, Q as moveHandleTo, R as multiply, T as nearestSegmentT, U as openSubpathAt, V as pathToAnchors, W as placeEulerSegment, X as pxExtent, Y as pxExtentInFrame, Z as rotate, _ as rotateAboutPoint, $ as scale, a0 as scaleDelta, a1 as screenAngleOf, a2 as segmentAt, a3 as segmentEnds, a4 as solveSpiro, a5 as standoff, a6 as transformCoords, a7 as translate, a8 as translateAnchorBy, a9 as withinPxBox, aa as withinPxRadius } from './curvature-DKPO4Qeh.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-t80OoJnM.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-t80OoJnM.js';
+import { L as LengthTable, a as LengthSpan } from './lengthTable-Cv3W6lsH.js';
+export { b as LengthRun, c as anchorAtLength, d as closingAnchor, l as lengthAtAnchor, e as lengthAtSegmentFraction, f as lengthAtSubpath, g as lengthTable } from './lengthTable-Cv3W6lsH.js';
 export { P as PORT_REACH } from './portCurve-C5HDWuuV.js';
 
+/** Measuring one Bézier segment by arc length, and finding where a run of it ends. */
+/**
+ * Length of a Bézier segment between parameters `a` and `b`, by Gauss–Legendre
+ * over eight panels, split where a component of its derivative is zero and
+ * the speed dips there within a panel's width. The panels beside such a root
+ * are halved until they settle, and so is any other where the eight- and
+ * four-point rules disagree. `coords` holds its control
+ * points flat, `dim` components each: two points for a line, three for a
+ * quadratic, four for a cubic. NaN when a coordinate is not finite.
+ */
+declare function segmentLength(coords: ArrayLike<number>, dim: 2 | 3, a?: number, b?: number): number;
+/**
+ * The parameter at which the segment {@link segmentLength} reads has run
+ * `length` from its start, clamped to 0..1: Newton steps on the arc length,
+ * held inside a shrinking bracket. `total` is its whole length, when the
+ * caller has it; it is trusted, not checked, and a wrong one misplaces the
+ * clamp and the first guess. 0 when a coordinate is not finite, as for a
+ * segment of no length.
+ */
+declare function segmentTAtLength(coords: ArrayLike<number>, dim: 2 | 3, length: number, total?: number): number;
+
 /**
  * Scalar / 2-vector primitives and the kernel-wide epsilon policy.
  *
@@ -15,6 +38,10 @@ export { P as PORT_REACH } from './portCurve-C5HDWuuV.js';
 declare const EPS = 0.000001;
 /** `v` held to `lo`..`hi`. `lo` wins when the bounds cross; `NaN` passes through. */
 declare function clamp(v: number, lo: number, hi: number): number;
+/** `v` held to `0`..`1`; `NaN` passes through. */
+declare function clamp01(v: number): number;
+/** The number `t` of the way from `a` to `b`; `t` outside [0, 1] extrapolates. */
+declare function lerp(a: number, b: number, t: number): number;
 /** 2D cross (wedge) product of vectors (ax,ay) and (bx,by). */
 declare function cross(ax: number, ay: number, bx: number, by: number): number;
 /** 2D dot product. */
@@ -38,6 +65,30 @@ declare function sign(n: number): -1 | 0 | 1;
  */
 declare function approxEq(a: number, b: number, eps?: number): boolean;
 
+/** Angle units and wrapping: one definition of each, so callers agree on where a half turn lands. */
+/** Multiply degrees by this to get radians. */
+declare const DEG_TO_RAD: number;
+/** Multiply radians by this to get degrees. */
+declare const RAD_TO_DEG: number;
+/**
+ * Where {@link wrapAngle} puts a half turn, the one angle with two names:
+ * `'max'` at `π`, `'min'` at `-π`, and `'sign'` at whichever of the two has
+ * the input's sign, so `-3π` stays a turn the negative way.
+ */
+type HalfTurn = 'max' | 'min' | 'sign';
+/**
+ * `a` radians as the turn of at most half a circle that reaches it, in
+ * `(-π, π]` by default. `half` picks the closed end (see {@link HalfTurn}).
+ * `NaN` and infinities give `NaN`.
+ */
+declare function wrapAngle(a: number, half?: HalfTurn): number;
+/**
+ * `a` in `[0, period)`: radians by default, `wrapPositive(deg, 360)` for
+ * degrees. Never returns `period` itself, however close to zero a negative
+ * `a` is. `NaN` and infinities give `NaN`.
+ */
+declare function wrapPositive(a: number, period?: number): number;
+
 /**
  * Viewport state. `(view.x, view.y)` is the world point currently rendered at
  * the canvas top-left; `view.scale.x` / `view.scale.y` is pixels per world
@@ -69,6 +120,38 @@ declare const ZOOM_FLOOR = 1e-9;
  * floor.
  */
 declare function normalizeZoom(zoom: number): number;
+/** The screen pixel `view` draws world point `p` at, from the canvas top-left. */
+declare function viewWorldToScreen(view: View, p: {
+    x: number;
+    y: number;
+}): {
+    x: number;
+    y: number;
+};
+/** The world point under screen pixel `p`; the inverse of {@link viewWorldToScreen}. */
+declare function viewScreenToWorld(view: View, p: {
+    x: number;
+    y: number;
+}): {
+    x: number;
+    y: number;
+};
+/**
+ * World rect `r` in screen pixels through `view`. A flipped axis (negative
+ * scale) still gives a positive width and height, with `x` / `y` at the
+ * rect's top-left on screen.
+ */
+declare function viewRectToScreen(view: View, r: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
 
 /** Axis-aligned box as [minX, minY, maxX, maxY]. */
 type Box = readonly [number, number, number, number];
@@ -94,6 +177,23 @@ declare function boxContainsBox(outer: Box, inner: Box): boolean;
  *  `pointInPolygon` takes, and what a repeated first vertex would leave as a
  *  zero-length segment for anything that strokes it. */
 declare function rectToContour(x: number, y: number, w: number, h: number): Float64Array;
+/** Whether `a` and `b` meet, edges inclusive: boxes touching along an edge or
+ *  at a corner answer true. */
+declare function boxesIntersect(a: Box, b: Box): boolean;
+/** Whether `a` and `b` share interior: rects that only touch along an edge or
+ *  at a corner answer false. */
+declare function rectsOverlap(a: Readonly<Rect>, b: Readonly<Rect>): boolean;
+/** Whether `a` and `b` meet, edges inclusive: rects touching along an edge or
+ *  at a corner answer true. {@link rectsOverlap} is the interior-only test. */
+declare function rectsIntersect(a: Readonly<Rect>, b: Readonly<Rect>): boolean;
+/** Inclusive point-in-rect test: a point on any edge is inside. */
+declare function rectContainsPoint(r: Readonly<Rect>, x: number, y: number): boolean;
+/** Half-open point-in-rect test: the left and top edges are inside, the right
+ *  and bottom ones outside, so rects that tile a plane never both claim a point. */
+declare function rectContainsPointHalfOpen(r: Readonly<Rect>, x: number, y: number): boolean;
+/** Smallest rect containing every one of `rects`, or null for none. A `NaN`
+ *  coordinate makes the matching edge of the result `NaN`. */
+declare function unionRects(rects: Iterable<Readonly<Rect>>): Rect | null;
 
 /**
  * SVG-style command-stream encoding — the kit's single declaration of the path
@@ -231,13 +331,6 @@ 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;
@@ -246,7 +339,8 @@ interface PathStation {
 }
 /** Options for {@link measurePath}. */
 interface MeasurePathOptions {
-    /** Curve flattening tolerance, in world units. Default 0.5. */
+    /** Curve flattening tolerance, in world units, for the headings `at` and the search `nearest` read; lengths
+     *  and points are exact whatever it is. 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. */
@@ -269,7 +363,7 @@ interface PathMeasure {
     /**
      * The station `s` along the path, `s` clamped to `0..length`.
      *
-     * The tangent is the heading of the flattened segment under `s`. With
+     * The point is exact. 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.
      */
@@ -527,6 +621,7 @@ declare function portCurvePoints(ax: number, ay: number, bx: number, by: number,
  * rendering at 1× zoom; consumers that zoom in heavily should pass a
  * tighter tolerance.
  */
+/** The tolerance, in world units, the flatteners use when none is given. */
 declare const DEFAULT_FLATTEN_TOLERANCE = 0.5;
 /**
  * Recursively subdivide a cubic bezier (P0..P3) and append `lineTo`-style
@@ -558,6 +653,13 @@ declare function flattenQuadraticWithArcLen(x0: number, y0: number, x1: number,
  * inside a buffer holding several.
  */
 declare function pointInPolygon(coords: ArrayLike<number>, px: number, py: number, start?: number, end?: number): boolean;
+/**
+ * Signed shoelace area of an interleaved, unclosed ring, its closing edge
+ * implicit as in {@link pointInPolygon}: positive when the ring runs
+ * counterclockwise with y up, so clockwise on a y-down screen. `start`/`end`
+ * are vertex indices bounding one ring in a buffer holding several.
+ */
+declare function ringSignedArea(coords: ArrayLike<number>, start?: number, end?: number): number;
 /**
  * True if segments (ax,ay)-(bx,by) and (cx,cy)-(dx,dy) intersect at a single
  * point. An endpoint landing on the other segment counts (a T-junction and a
@@ -566,8 +668,77 @@ declare function pointInPolygon(coords: ArrayLike<number>, px: number, py: numbe
  * point, so the sign test both segments rely on is zero on all four sides.
  */
 declare function segmentsCross(ax: number, ay: number, bx: number, by: number, cx: number, cy: number, dx: number, dy: number): boolean;
+
+/**
+ * The rules of `./points` in the 2D kernel's currency. The segment functions
+ * take loose scalars and allocate nothing, since hit tests call them per
+ * pointermove and per vertex; the point functions take `Point`. Each goes
+ * through the same scalar steps as its `./nd` counterpart, so the two agree
+ * to the bit.
+ */
+
+/** Squared distance between two points. */
+declare function distance2(a: Point, b: Point): number;
+/** Euclidean distance between two points. */
+declare function distance(a: Point, b: Point): number;
+/** The point `t` of the way from `a` to `b`; `t` outside [0, 1] extrapolates. */
+declare function lerpPoint(a: Point, b: Point, t: number): Point;
+/** The parameter, 0 to 1, of the point of segment (ax,ay)-(bx,by) nearest
+ *  (px,py). A zero-length segment answers 0. */
+declare function segmentT(px: number, py: number, ax: number, ay: number, bx: number, by: number): number;
 /** Squared distance from (px,py) to segment (ax,ay)-(bx,by), endpoint-clamped. */
 declare function pointSegmentDist2(px: number, py: number, ax: number, ay: number, bx: number, by: number): number;
+/** Distance from (px,py) to segment (ax,ay)-(bx,by), endpoint-clamped. */
+declare function pointSegmentDist(px: number, py: number, ax: number, ay: number, bx: number, by: number): number;
+
+type Comps = [number, number, number];
+/**
+ * The point at pen-order length `s`, and the unit tangent of the segment
+ * arriving there (leaving, at a run's start); on a curve, the exact point and
+ * the curve's own direction. Components past the table's
+ * `dim` read 0. Clamps to the path; where two runs meet, answers the end of the
+ * earlier one. A path with no length answers a zero tangent.
+ */
+declare function pointAtLength(t: LengthTable, s: number): {
+    point: Comps;
+    tangent: Comps;
+};
+
+/**
+ * A place on a path that no flattening moves: curve parameter `t` of segment
+ * `segment` of run `run`, segments counted from each run's first point, a
+ * closed run's closing edge last. Every flattening of the path cuts at the same
+ * point for it, whatever its tolerance.
+ */
+interface CurvePosition {
+    run: number;
+    segment: number;
+    t: number;
+}
+/** A stretch of a path between two curve positions, `from` before `to` in pen order. */
+interface CurveSpan {
+    from: CurvePosition;
+    to: CurvePosition;
+}
+/** How many segments run `r` of `t` has: its closing edge included when closed. */
+declare function runSegments(t: LengthTable, r: number): number;
+/**
+ * `span`, pen-order lengths along `t`, as curve positions: where a length falls
+ * on a run boundary, `from` starts the later run and `to` ends the earlier one,
+ * so neither carries a run of no length. Null when the span is empty.
+ */
+declare function curveSpan(t: LengthTable, span: LengthSpan): CurveSpan | null;
+/** The pen-order length at curve position `at`: the inverse of {@link curveSpan}. */
+declare function lengthAtCurve(t: LengthTable, at: CurvePosition): number;
+
+/**
+ * The exact length table of `path` as a stroke draws it: corners resolved,
+ * each curve measured by its arc length rather than by any flattening of it,
+ * anchors in authored numbering. Its runs are `extractPolylines`' subpaths,
+ * one point per anchor, with each curve's control points, so a curve position
+ * on it names the same place on every flattening of the path. Kept per path.
+ */
+declare function pathLengthTable(path: Path): LengthTable;
 
 /** Set whether a fill closes an open subpath, for every path that names no
  *  `openFill` of its own. Starts at `'close'`. */
@@ -1942,6 +2113,10 @@ interface StrokeHitTestOptions {
         px: number;
         transform: Affine;
     };
+    /** Only the stretch of the outline between these curve positions counts,
+     *  as `pathLengthTable` numbers them: a visible window of a trimmed stroke,
+     *  cut at the same points whatever `tolerance` flattens the outline at. */
+    span?: CurveSpan;
 }
 /** Filled-region hit-test for a path. Rect short-circuits to AABB; polygons run ray-cast / winding per `fillRule`. */
 declare function pointInPath(path: Path, x: number, y: number, opts?: PointInPathOptions): boolean;
@@ -2379,7 +2554,12 @@ declare function boxFrameOf(pose: unknown): Affine | null;
  * the `transform` is singular and nothing maps back.
  */
 declare function poseFrameInverseOf(pose: unknown): Affine | null;
-/** `path`, given in the pose's unrotated box frame, as the node draws it. */
+/**
+ * `path`, given in the pose's unrotated box frame, as the node draws it. The
+ * renderer rounds `corners` in the box frame and then frames the result, so a
+ * stretch or skew rounds them first here too; a uniform frame keeps them as
+ * corners, which it maps exactly.
+ */
 declare function pathThroughPoseFrame(path: Path, pose: unknown): Path;
 
 /**
@@ -3275,4 +3455,4 @@ declare function reviveTypedArrays(value: unknown): unknown;
 /** `tagTypedArrays` as a `JSON.stringify` replacer. */
 declare function typedArrayReplacer(_key: string, value: unknown): unknown;
 
-export { ANCHOR_FIELDS, 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 EaseOptions, type EasingFn, type EasingName, type EasingSpec, type EllipseTrackShape, type EllipseTrackSpec, type ExtendToMeetOptions, type ExtensionPiece, type ExtremaAxes, 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, ORIGIN_THRESHOLD, 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 PuckerBloatPathOptions, type QuadraticCoords, type Rect, RectPath, type RepeatAlongPathOptions, type RepeatStation, type ResamplePathOptions, type ResolvedCorners, type RoughenPathOptions, 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 TransformPathOptions, type TrimPathOptions, type TrimResult, type TypedArrayTag, type UnsatisfiedConstraintsOptions, type View, ZOOM_FLOOR, type ZigzagPathOptions, addExtremaAnchors, addOrigin, anchorOriginsOf, anchorSymmetries, anchorSymmetry, anchorsBefore, anchorsUnderBrush, anchorsWhere, approxEq, arcShape, asPolygonPath, averageAnchorsAt, balanceFactorToward, bendAlongPath, bendSegment, bendSide, blendPaths, boundsOfCoords, boundsOfPath, boxContainsBox, boxContainsPoint, boxFrameOf, circlePath, clamp, clampRectWithin, closestOpenEnds, composePath, conflictingConstraints, constrainPathEdit, constrainPathsEdit, constraintAnchors, constraintApplies, constraintFits, convertSegments, coordsFrom, 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, easeLength, easeOut, easeOutBack, easeOutBounce, easeOutCirc, easeOutCubic, easeOutElastic, easeOutExpo, easeOutQuad, easeOutQuart, easeOutQuint, easeOutSine, editAnchorSetTracked, elevateQuadraticToCubic, ellipsePath, ellipseShape, equalizeSegmentHandles, everyNthAnchor, extendToMeet, extensionPieces, fillsOpenSubpaths, findPathSnap, findPathSnaps, fitAffine, fitCubicThroughDeletion, fitCubicWithTangents, flatIndexesAfterReverse, flattenCubic, flattenCubicWithArcLen, flattenQuadratic, flattenQuadraticWithArcLen, forEachSegment, growAnchorSelection, growRegion, handleAlongItsAngle, handleAtItsLength, handleBalances, harmonizeAnchors, hasOpenSubpath, intersectSegments, invertAnchorSelection, isSegmentStraight, joinAnchorsAt, joinPaths, joinSubpathEnds, keepCorners, len2, lengthToward, lengthenOpenEnd, lengthenPathEnd, linePath, lineShape, linear, makeHandlesSymmetric, mapConstraintAnchors, mat3, meanScale, measureAnchorPath, measurePath, mergeRegion, moveHandleSymmetric, nearestOnCubic, nearestOnLine, nearestOnPath, nearestOnQuadratic, nearestPathAnchor, normalizeZoom, offsetCornerTraces, openEndAt, openEndRay, openPathEnds, originFor, originOf, pathAnchorPoints, pathAwayFromAnchors, pathCommandCoordCount, pathContainsPoint, pathContainsPolygon, pathContainsRect, pathCrossings, pathDistanceToPoint, pathEndAnchorIndex, pathEndFrame, pathFromD, pathInPoseFrame, pathInWorld, pathIntersectsPolygon, pathIntersectsRect, pathPoint, pathSegments, pathShape, pathSignedArea, pathThroughPoseFrame, pathToCubicContours, pathToD, placeAlongRun, placeRect, pointAlongPath, pointInPath, pointInPolygon, pointSegmentDist2, polygonContainsPath, polygonFromPoints, polygonIntersectsPath, polylineFromPoints, portControls, portCurvePoints, poseFrameInverseOf, poseFrameOf, poseLinearOf, poseRotationOf, prepareBlend, puckerBloatPath, quadraticEvalAt, readAnchorFields, rectMarkerPath, rectPath, rectToContour, regularPolygonPath, remapAnchorValues, remapConstraints, remapPerAnchor, remapPointValues, repeatAlongPath, resamplePath, resolveCorners, resolveCornersWithSources, resolveEasing, restoreCorners, retractHandles, reverseAnchors, reversePath, reverseSubpaths, reviveTypedArrays, rotatePathAround, roughenPath, roundRectPath, runLength, runPlaces, runStationAt, 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, transformPath, translateAnchorsSymmetric, translatePath, trimPathAt, typedArrayReplacer, unionBoundsPath, unionBox, unsatisfiedConstraints, untagTypedArray, viewToMat3, withAnchorPoints, worldCoords, worldEditToStorage, writeAnchorField, zigzagPath };
+export { ANCHOR_FIELDS, 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, type CurvePosition, type CurveSpan, DEFAULT_FLATTEN_TOLERANCE, DEG_TO_RAD, type DirectionMark, EASINGS, EPS, type EaseOptions, type EasingFn, type EasingName, type EasingSpec, type EllipseTrackShape, type EllipseTrackSpec, type ExtendToMeetOptions, type ExtensionPiece, type ExtremaAxes, type FramedBox, type GlMat3, type GrowRegionOptions, type HalfTurn, type HandleBalance, type HandleRef, type JoinOptions, LengthSpan, LengthTable, type LengthenMode, type LineCoords, type MeasureAnchorPathOptions, type MeasurePathOptions, type MergeRegionOptions, type NumberEntry, type NumberTypedArray, ORIGIN_THRESHOLD, 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 PuckerBloatPathOptions, type QuadraticCoords, RAD_TO_DEG, type Rect, RectPath, type RepeatAlongPathOptions, type RepeatStation, type ResamplePathOptions, type ResolvedCorners, type RoughenPathOptions, 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 TransformPathOptions, type TrimPathOptions, type TrimResult, type TypedArrayTag, type UnsatisfiedConstraintsOptions, type View, ZOOM_FLOOR, type ZigzagPathOptions, addExtremaAnchors, addOrigin, anchorOriginsOf, anchorSymmetries, anchorSymmetry, anchorsBefore, anchorsUnderBrush, anchorsWhere, approxEq, arcShape, asPolygonPath, averageAnchorsAt, balanceFactorToward, bendAlongPath, bendSegment, bendSide, blendPaths, boundsOfCoords, boundsOfPath, boxContainsBox, boxContainsPoint, boxFrameOf, boxesIntersect, circlePath, clamp, clamp01, clampRectWithin, closestOpenEnds, composePath, conflictingConstraints, constrainPathEdit, constrainPathsEdit, constraintAnchors, constraintApplies, constraintFits, convertSegments, coordsFrom, cornerAnchors, cornerCuts, cornerFrameAt, cornerFrames, cornerTraces, createPathSnapIndex, cross, cubicAxisExtremaTs, cubicBezierEasing, cubicBounds, cubicContoursToPath, cubicEvalAt, curveSpan, decomposePath, defaultOpenFill, directionMarks, distance, distance2, dot, easeIn, easeInBack, easeInBounce, easeInCirc, easeInCubic, easeInElastic, easeInExpo, easeInOut, easeInOutBack, easeInOutBounce, easeInOutCirc, easeInOutCubic, easeInOutElastic, easeInOutExpo, easeInOutQuad, easeInOutQuart, easeInOutQuint, easeInOutSine, easeInQuad, easeInQuart, easeInQuint, easeInSine, easeLength, easeOut, easeOutBack, easeOutBounce, easeOutCirc, easeOutCubic, easeOutElastic, easeOutExpo, easeOutQuad, easeOutQuart, easeOutQuint, easeOutSine, editAnchorSetTracked, elevateQuadraticToCubic, ellipsePath, ellipseShape, equalizeSegmentHandles, everyNthAnchor, extendToMeet, extensionPieces, fillsOpenSubpaths, findPathSnap, findPathSnaps, fitAffine, fitCubicThroughDeletion, fitCubicWithTangents, flatIndexesAfterReverse, flattenCubic, flattenCubicWithArcLen, flattenQuadratic, flattenQuadraticWithArcLen, forEachSegment, growAnchorSelection, growRegion, handleAlongItsAngle, handleAtItsLength, handleBalances, harmonizeAnchors, hasOpenSubpath, intersectSegments, invertAnchorSelection, isSegmentStraight, joinAnchorsAt, joinPaths, joinSubpathEnds, keepCorners, len2, lengthAtCurve, lengthToward, lengthenOpenEnd, lengthenPathEnd, lerp, lerpPoint, linePath, lineShape, linear, makeHandlesSymmetric, mapConstraintAnchors, mat3, meanScale, measureAnchorPath, measurePath, mergeRegion, moveHandleSymmetric, nearestOnCubic, nearestOnLine, nearestOnPath, nearestOnQuadratic, nearestPathAnchor, normalizeZoom, offsetCornerTraces, openEndAt, openEndRay, openPathEnds, originFor, originOf, pathAnchorPoints, pathAwayFromAnchors, pathCommandCoordCount, pathContainsPoint, pathContainsPolygon, pathContainsRect, pathCrossings, pathDistanceToPoint, pathEndAnchorIndex, pathEndFrame, pathFromD, pathInPoseFrame, pathInWorld, pathIntersectsPolygon, pathIntersectsRect, pathLengthTable, pathPoint, pathSegments, pathShape, pathSignedArea, pathThroughPoseFrame, pathToCubicContours, pathToD, placeAlongRun, placeRect, pointAlongPath, pointAtLength, pointInPath, pointInPolygon, pointSegmentDist, pointSegmentDist2, polygonContainsPath, polygonFromPoints, polygonIntersectsPath, polylineFromPoints, portControls, portCurvePoints, poseFrameInverseOf, poseFrameOf, poseLinearOf, poseRotationOf, prepareBlend, puckerBloatPath, quadraticEvalAt, readAnchorFields, rectContainsPoint, rectContainsPointHalfOpen, rectMarkerPath, rectPath, rectToContour, rectsIntersect, rectsOverlap, regularPolygonPath, remapAnchorValues, remapConstraints, remapPerAnchor, remapPointValues, repeatAlongPath, resamplePath, resolveCorners, resolveCornersWithSources, resolveEasing, restoreCorners, retractHandles, reverseAnchors, reversePath, reverseSubpaths, reviveTypedArrays, ringSignedArea, rotatePathAround, roughenPath, roundRectPath, runLength, runPlaces, runSegments, runStationAt, scalePathToBounds, scaleSegmentHandles, schneiderFit, segmentBetween, segmentExtremaTs, segmentLength, segmentT, segmentTAtLength, 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, transformPath, translateAnchorsSymmetric, translatePath, trimPathAt, typedArrayReplacer, unionBoundsPath, unionBox, unionRects, unsatisfiedConstraints, untagTypedArray, viewRectToScreen, viewScreenToWorld, viewToMat3, viewWorldToScreen, withAnchorPoints, worldCoords, worldEditToStorage, wrapAngle, wrapPositive, writeAnchorField, zigzagPath };