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

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-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';
+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 { 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';
 export { P as PORT_REACH } from './portCurve-C5HDWuuV.js';
 
 /**
@@ -70,37 +70,6 @@ declare const ZOOM_FLOOR = 1e-9;
  */
 declare function normalizeZoom(zoom: number): number;
 
-/** `[a, b, c, d, e, f]`: `x' = a·x + c·y + e`, `y' = b·x + d·y + f`. */
-type Affine = readonly [number, number, number, number, number, number];
-/** The transform that leaves a point where it is. */
-declare function identity$1(): Affine;
-/** A pure translation by `(tx, ty)`. */
-declare function translate(tx: number, ty: number): Affine;
-/** A pure scale about the origin. Scale about another point by composing
- *  translate → scale → inverse translate with `multiply`. */
-declare function scale(sx: number, sy: number): Affine;
-/** A pure rotation about the origin, in radians, clockwise in canvas
- *  coordinates (y down). */
-declare function rotate(rad: number): Affine;
-/** Compose: result applies `n` first, then `m` (m·n). */
-declare function multiply$1(m: Affine, n: Affine): Affine;
-/** Inverse, or null when the matrix is singular, non-finite, or too
- *  ill-conditioned to invert meaningfully at its own scale. */
-declare function invert$1(m: Affine): Affine | null;
-/** Apply to a point, returning a tuple. Cold-path use; hot loops inline. */
-declare function applyToPoint(m: Affine, x: number, y: number): [number, number];
-/** Affine that maps source box (sx,sy,sw,sh) onto destination box (dx,dy,dw,dh). */
-declare function boxToBox(sx: number, sy: number, sw: number, sh: number, dx: number, dy: number, dw: number, dh: number): Affine;
-/** Rotation by `rad` about pivot (cx,cy): translate(c)·rotate·translate(-c). */
-declare function rotateAboutPoint(cx: number, cy: number, rad: number): Affine;
-/**
- * Apply an affine to an interleaved coord stream, returning a fresh f64
- * buffer. Command codes are unaffected — for a Bezier the transformed control
- * points define the transformed curve exactly (affine invariance), so callers
- * pass `path.coords` straight through and keep `path.commands` as-is.
- */
-declare function transformCoords(coords: ArrayLike<number>, m: Affine): Float64Array;
-
 /** Axis-aligned box as [minX, minY, maxX, maxY]. */
 type Box = readonly [number, number, number, number];
 /** An axis-aligned rectangle in object form. `Box` is the tuple form; this is
@@ -413,7 +382,8 @@ declare function pathShape(path: Path, options?: {
 }): 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]). */
+ *  `angle` the CSS rotation in degrees that tips an upright item to the place (0 = upright, clockwise positive, in
+ *  (-180, 180]). Read right to left, `tangent` points against the direction `angle` turns an item's own left to right. */
 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
@@ -432,7 +402,12 @@ interface TrackRun extends TrackShape {
     readonly flipped: boolean;
     /** True when reading order runs against the shape's own direction. */
     readonly reversed: boolean;
+    /** The inline direction it reads in, from {@link TrackRunOptions.direction}. */
+    readonly direction: 'ltr' | 'rtl';
     at(g: number, options?: TrackAtOptions): TrackPlace;
+    /** The shape fraction reading fraction `g` falls at, unclamped: `from` at g = 0 and `to` at g = 1, or the other way
+     *  round when the run is `reversed`. */
+    toShape(g: number): number;
 }
 /** Which side of a shape a run's items stand on: `'auto'` whichever is upright, `'path'` the shape's own normal, `'flipped'`
  *  the other. */
@@ -443,9 +418,12 @@ interface TrackRunOptions {
     side?: TrackSide;
     /** The shape fraction `'auto'` judges the side at. Default the run's middle, `(from + to) / 2`. */
     about?: number;
+    /** The inline direction items read in on the side the run stands on: `'rtl'` starts the run at its right end. Each
+     *  item still stands as it would read left to right. Default `'ltr'`. */
+    direction?: 'ltr' | 'rtl';
 }
 /** 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. */
+ *  left to right on that side, or right to left under `options.direction: 'rtl'`. */
 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
@@ -562,15 +540,15 @@ declare function flattenQuadratic(x0: number, y0: number, x1: number, y1: number
  * Like `flattenCubic` but also appends to `arcOut`, for each new flattened
  * point, its *cumulative distance from the segment start* — not a normalized
  * fraction. The caller divides each by the segment's total flattened arc
- * length to yield t ∈ (0, 1]. `maxTurn`, in radians, also bounds how far each
- * piece's control polygon may turn.
+ * length to yield t ∈ (0, 1]. With `offset`, each piece is also fine enough
+ * that edges that far out from it stay within the tolerance.
  */
-declare function flattenCubicWithArcLen(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, tolerance: number, out: number[], arcOut: number[], maxTurn?: number): number;
+declare function flattenCubicWithArcLen(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, tolerance: number, out: number[], arcOut: number[], offset?: number): number;
 /** Flatten a quadratic bezier into line segments within `tolerance`, appending
  *  points to `out` and their cumulative arc lengths to `arcOut`. The arc
  *  lengths are what lets per-anchor color and dash phase be interpolated
  *  evenly along the curve rather than per segment. */
-declare function flattenQuadraticWithArcLen(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, tolerance: number, out: number[], arcOut: number[], maxTurn?: number): number;
+declare function flattenQuadraticWithArcLen(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, tolerance: number, out: number[], arcOut: number[], offset?: number): number;
 
 /**
  * Even-odd ray-cast point-in-polygon over an interleaved, unclosed contour
@@ -617,6 +595,8 @@ declare class PathBuilder {
     private cmds;
     private xs;
     private fillRule;
+    private origin;
+    private auto;
     /** Seed a builder with an existing `PolygonPath`. Useful for extending
      *  an in-flight path with another segment (e.g. appending a cubic to
      *  the end of a curve in response to a user action) without hand-
@@ -627,6 +607,21 @@ declare class PathBuilder {
      *  ```
      */
     static fromPath(path: PolygonPath): PathBuilder;
+    /**
+     * Measure the coords from `(x, y)`, which the built path carries as its
+     * `origin`: every point given before or after this call is still in the
+     * path's own space, and is stored as its offset from the origin, taken in
+     * doubles. Far from 0, an origin beside the shape is what keeps its
+     * coordinates' fractions.
+     */
+    setOrigin(x: number, y: number): this;
+    /**
+     * At `build`, if no origin was set, measure the coords from the one
+     * `originFor` picks for them: none while they stay within
+     * `ORIGIN_THRESHOLD` of 0. For a producer whose points may land far out.
+     */
+    autoOrigin(): this;
+    private push;
     setFillRule(rule: PathFillRule): this;
     moveTo(x: number, y: number): this;
     lineTo(x: number, y: number): this;
@@ -692,6 +687,55 @@ declare function linePath(a: {
  */
 declare function boundsOfPath(path: Path): RectPath;
 
+/**
+ * A polygon path's coords read in the path's own space: each pair plus
+ * `PolygonPath.origin`, added in doubles. Every reader that answers in that
+ * space (hit tests, anchors, booleans, SVG data) reads through here.
+ */
+
+/** The point `path`'s coords are measured from: `(0, 0)` when it has none. */
+declare function originOf(path: PolygonPath): {
+    readonly x: number;
+    readonly y: number;
+};
+/** Coordinate pair `i` of `path` (coords `2i`, `2i + 1`) in the path's own space. */
+declare function pathPoint(path: PolygonPath, i: number): Point;
+/**
+ * `path.coords` in the path's own space, in doubles: the coords themselves
+ * when the path has no origin, else a `Float64Array` of each pair plus it.
+ */
+declare function worldCoords(path: PolygonPath): Float32Array | Float64Array;
+/** `xy`, interleaved pairs measured from `path`'s origin, moved into the
+ *  path's own space in place: for a reader that derived offsets from the coords. */
+declare function addOrigin<T extends {
+    [i: number]: number;
+    readonly length: number;
+}>(path: PolygonPath, xy: T): T;
+/** `world`, interleaved pairs in a path's own space, as the float32 coords
+ *  of a path measured from `origin`: the inverse of {@link worldCoords}. */
+declare function coordsFrom(origin: {
+    readonly x: number;
+    readonly y: number;
+} | undefined, world: ArrayLike<number>): Float32Array;
+/**
+ * How far from 0 a coordinate may sit before a producer that picks its own
+ * origin (`PathBuilder.autoOrigin`, `transformPath`'s `autoOrigin`) gives the
+ * path one: 2^14. Past it a float32 coordinate's step is 1/512 world unit or
+ * coarser, so its rounding reaches 1/16 px at 64x zoom; inside it, paths in a
+ * document near 0 stay as they always were.
+ */
+declare const ORIGIN_THRESHOLD = 16384;
+/** The origin a path through the interleaved pairs `xy` is measured from: none
+ *  while every coordinate is within {@link ORIGIN_THRESHOLD} of 0, else the
+ *  center of their bounds, rounded to whole units. */
+declare function originFor(xy: ArrayLike<number>): {
+    x: number;
+    y: number;
+} | undefined;
+/** `parts` as one `'nonzero'` compound path, measured from the first part's
+ *  origin: a part measured from another is re-measured from it in doubles. */
+declare function joinPaths(parts: readonly PolygonPath[]): PolygonPath;
+
 /**
  * Corner expansion: a path's corner specs turned into the plain geometry
  * that every reader draws, hits, bounds, and exports.
@@ -854,8 +898,17 @@ declare function scalePathToBounds(path: Path, target: RectPath): Path;
  *
  * Axis-aligned maps (no rotation/shear: `m[1]` and `m[2]` within 1e-9 of 0) keep a
  * `RectPath` a rect, normalizing negative extent (mirror). Rotation or
- * shear promotes the rect's four corners to a `PolygonPath`. */
-declare function transformPath(path: Path, m: Affine): Path;
+ * shear promotes the rect's four corners to a `PolygonPath`.
+ *
+ * A polygon that had no origin and lands past `ORIGIN_THRESHOLD` is measured
+ * from the one `originFor` picks, so the map's doubles survive the float32
+ * coords; `autoOrigin: false` keeps it origin-free. */
+declare function transformPath(path: Path, m: Affine, opts?: TransformPathOptions): Path;
+/** Options for {@link transformPath}. */
+interface TransformPathOptions {
+    /** Give a far-out result with no origin one. Default true. */
+    autoOrigin?: boolean;
+}
 
 /**
  * Translation-only compose/decompose for `Path` poses, the analog of
@@ -932,7 +985,8 @@ declare function reversePath(path: PolygonPath): PolygonPath;
  * command letters are skipped (and reported via `onWarn` when provided); the
  * builder still returns whatever valid commands preceded them. Data that does
  * not begin with a moveto builds an empty path, and a command with the wrong
- * number of arguments ends the path before it, as SVG renders both.
+ * number of arguments ends the path before it, as SVG renders both. Data that
+ * reaches past `ORIGIN_THRESHOLD` builds a path measured from an origin.
  */
 declare function pathFromD(d: string, onWarn?: (message: string) => void): ReturnType<PathBuilder['build']>;
 
@@ -1109,6 +1163,72 @@ declare function stationsAlongPath(path: Path, opts?: RepeatAlongPathOptions): R
  */
 declare function repeatAlongPath(shape: Path, path: Path, opts?: RepeatAlongPathOptions): Path[];
 
+/**
+ * Roughen a path: every point of its outline moved by a random offset, after
+ * evenly spaced points are added to each segment. The offsets come from a
+ * seed, so the same path and options always roughen the same way.
+ */
+
+/** How a path is roughened. */
+interface RoughenPathOptions {
+    /** The largest offset on each axis, in the path's units. */
+    size: number;
+    /** Points added to each segment before roughening. Default 4. */
+    detail?: number;
+    /** Picks the offsets. Default 0. */
+    seed?: number;
+}
+/**
+ * `path` with each point of its outline, anchors and the `detail` points added
+ * between them, moved by up to `size` on each axis, joined by straight
+ * segments. A `size` of zero or less answers `path` itself.
+ */
+declare function roughenPath(path: Path, opts: RoughenPathOptions): Path;
+
+/**
+ * Zigzag a path: evenly spaced points laid along each segment, and every
+ * point of the outline pushed alternately to one side of it and the other.
+ */
+
+/** How a path is zigzagged. */
+interface ZigzagPathOptions {
+    /** How far each point is pushed off the outline, in the path's units. */
+    size: number;
+    /** Points added to each segment. Default 4. */
+    ridges?: number;
+    /** Run a curve through the pushed points instead of meeting at sharp
+     *  corners there. Default `false`. */
+    smooth?: boolean;
+}
+/**
+ * `path` with `ridges` points added to each segment and every point, anchors
+ * included, pushed `size` along the outline's normal, the side alternating
+ * from one point to the next. A `size` of zero answers `path` itself.
+ */
+declare function zigzagPath(path: Path, opts: ZigzagPathOptions): Path;
+
+/**
+ * Pucker or bloat a path: pull its anchors toward the center of its bounds
+ * and push its handles away, or the reverse.
+ */
+
+/** How far a path is puckered or bloated. */
+interface PuckerBloatPathOptions {
+    /**
+     * A fraction of each handle's distance from the center. Positive bloats:
+     * handles move that far away from the center, anchors half as far toward
+     * it, so segments bulge outward. Negative puckers: handles move toward the
+     * center and anchors away, so the anchors become spikes.
+     */
+    amount: number;
+}
+/**
+ * `path` puckered or bloated about the center of its bounds. A straight
+ * segment moves as a curve with its handles a third of the way along from
+ * each end. An `amount` of zero answers `path` itself.
+ */
+declare function puckerBloatPath(path: Path, opts: PuckerBloatPathOptions): Path;
+
 /**
  * Pure-geometry distance from a point to a path's boundary (stroke), with
  * no fill-side logic. Used by pickers that want to know "how close is this
@@ -2203,6 +2323,13 @@ declare function poseLinearOf(pose: unknown): PoseLinear | null;
  * the step.
  */
 declare function poseFrameOf(pose: unknown): Affine | null;
+/**
+ * The matrix taking a point in the box's own coordinates, with their origin
+ * on its corner and their axes along its own, to where the node draws it:
+ * what a container's children are laid out in when its pose is a frame.
+ * `null` when the pose is not a box.
+ */
+declare function boxFrameOf(pose: unknown): Affine | null;
 /**
  * The inverse of {@link poseFrameOf}: where a parent-frame point falls in the
  * pose's unrotated box frame. `null` when there is no frame to undo, or when
@@ -3105,4 +3232,4 @@ declare function reviveTypedArrays(value: unknown): unknown;
 /** `tagTypedArrays` as a `JSON.stringify` replacer. */
 declare function typedArrayReplacer(_key: string, value: unknown): unknown;
 
-export { ANCHOR_FIELDS, type Affine, type AnchorField, type AnchorFieldValues, type AnchorPair, type AnchorPathMeasure, AnchorSet, type AnchorSubpathMeasure, type AnchorSymmetry, type ArcTrackShape, type ArcTrackSpec, type AverageAxis, type BendAlongPathOptions, type BendGrip, type BezierEasing, type BlendPathsOptions, type Box, CONSTRAINT_TOLERANCE, CORNER_RESTORE_TOLERANCE, type ConflictingConstraintsOptions, type ConstrainPathEditOptions, type ConstrainedPathEdit, type ConstrainedPathsEdit, type ConstraintPoint, type CornerCut, type CornerFrame, CornerPiece, CornerSpec, type CornerTrace, type CubicContour, type CubicCoords, type CubicSegment, type CurveNearest, DEFAULT_FLATTEN_TOLERANCE, type DirectionMark, EASINGS, EPS, type EasingFn, type EasingName, type EasingSpec, type EllipseTrackShape, type EllipseTrackSpec, type ExtendToMeetOptions, type FramedBox, type GlMat3, type GrowRegionOptions, type HandleBalance, type HandleRef, type JoinOptions, type LengthenMode, type LineCoords, type MeasureAnchorPathOptions, type MeasurePathOptions, type MergeRegionOptions, type NumberEntry, type NumberTypedArray, type OpenPathEnd, PATH_C, PATH_CMD_LENGTHS, PATH_COMMANDS, PATH_L, PATH_M, PATH_Q, PATH_SNAP_KINDS, PATH_Z, Path, type PathAnchorHit, type PathAwayFromAnchors, type PathBlend, PathBuilder, type PathCommandCode, type PathCommandName, type PathConstraint, type PathConstraintKind, type PathCrossing, type PathEndFrame, PathFillRule, type PathInWorldPose, type PathLink, type PathMeasure, type PathNearest, type PathNearestStation, PathOpenFill, type PathSegment, type PathSnapHit, type PathSnapIndex, type PathSnapKind, type PathSnapQuery, type PathSnapTarget, type PathStation, type PathStop, type PathTrackShape, type PathsEditItem, PenAnchor, type PlaceAlongRunOptions, type PlaceRectOptions, type PlacedRect, type Placement, type PlacementAlign, type PlacementSide, Point, type PointAlongPathOptions, type PointInPathOptions, type PointOrigin, type PolygonIntersectsPathOptions, PolygonPath, type PoseLinear, type PoseRotation, type QuadraticCoords, type Rect, RectPath, type RepeatAlongPathOptions, type RepeatStation, type ResamplePathOptions, type ResolvedCorners, type RunAlign, type RunOrder, type 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 };
+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 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, 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, 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, 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 };