@weasel-js/geom 1.10.0 → 1.10.1

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-import { b as PathOpenFill, P as PolygonPath, c as PathFillRule, R as RectPath, a as Path } from './path-Bf9KeVxC.js';
-import { P as Point, a as PenAnchor } from './cubicMath-CFXbq6vp.js';
-export { b as anchorsToPath, c as countPathAnchors, d as cubicPointAt, f as fitCubicThroughDeletion, i as isAnchorSmooth, e as isStraightSegment, n as nearestSegmentT, p as pathToAnchors, s as segmentEnds, g as splitCubicAtT } from './cubicMath-CFXbq6vp.js';
+import { b as PathOpenFill, a as PolygonPath, c as PathFillRule, R as RectPath, P as Path } from './path-ljHxobyu.js';
+import { P as Point$1 } from './cubicMath-BW-HJrCE.js';
+export { c as cubicPointAt, s as splitCubicAtT } from './cubicMath-BW-HJrCE.js';
 export { PORT_REACH } from './nd/index.js';
 
 /**
@@ -70,28 +70,35 @@ 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 Mat3 = readonly [number, number, number, number, number, number];
+type Affine = readonly [number, number, number, number, number, number];
 /** The transform that leaves a point where it is. */
-declare function identity$1(): Mat3;
+declare function identity$1(): Affine;
 /** A pure translation by `(tx, ty)`. */
-declare function translate(tx: number, ty: number): Mat3;
+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): Mat3;
+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): Mat3;
+declare function rotate(rad: number): Affine;
 /** Compose: result applies `n` first, then `m` (m·n). */
-declare function multiply$1(m: Mat3, n: Mat3): Mat3;
+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: Mat3): Mat3 | null;
+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: Mat3, x: number, y: number): [number, number];
+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): Mat3;
+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): Mat3;
+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];
@@ -291,14 +298,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].
+ * length to yield t ∈ (0, 1]. `maxTurn`, in radians, also bounds how far each
+ * piece's control polygon may turn.
  */
-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[]): 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[], maxTurn?: 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[]): number;
+declare function flattenQuadraticWithArcLen(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, tolerance: number, out: number[], arcOut: number[], maxTurn?: number): number;
 
 /**
  * Even-odd ray-cast point-in-polygon over an interleaved, unclosed contour
@@ -452,12 +460,12 @@ declare function translatePath(path: Path, dx: number, dy: number): Path;
  */
 declare function scalePathToBounds(path: Path, target: RectPath): Path;
 
-/** Apply an affine `Mat3` to a path's geometry. Never mutates the input.
+/** Apply an `Affine` to a path's geometry. Never mutates the input.
  *
  * 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: Mat3): Path;
+declare function transformPath(path: Path, m: Affine): Path;
 
 /**
  * Translation-only compose/decompose for `Path` poses, the analog of
@@ -549,9 +557,9 @@ declare function pathFromD(d: string, onWarn?: (message: string) => void): Retur
 
 /** The answer `pointAlongPath` gives: a point on the path and its heading there. */
 interface PathStation {
-    point: Point;
+    point: Point$1;
     /** Unit vector along the path at `point`, pointing toward the end. */
-    tangent: Point;
+    tangent: Point$1;
 }
 /** Options for `pointAlongPath`. */
 interface PointAlongPathOptions {
@@ -585,6 +593,102 @@ declare function pointAlongPath(path: Path, t: number, opts?: PointAlongPathOpti
  *  combine with `pathContainsPoint` at the call site. */
 declare function pathDistanceToPoint(path: Path, px: number, py: number): number;
 
+/**
+ * Counts the path anchors used by the per-anchor coloring surface. An
+ * "anchor" is the destination point of a path command: M, L, C, Q each
+ * contribute one (the (x, y) where the pen ends up); Z contributes none
+ * (it closes back to the subpath's first M). RectPath has four implicit
+ * anchors — the corners — matching its M/L/L/L/Z stroke tessellation.
+ *
+ * Consumers use this to size their per-anchor color array; the renderer
+ * uses it to validate the array length in dev builds.
+ */
+
+/** One anchor of an editable path: its on-curve point plus the two control
+ *  handles that shape the segments either side of it. Handles are in the same
+ *  space as the point, and absent when the adjoining segment is straight. */
+interface PenAnchor {
+    x: number;
+    y: number;
+    inHandle?: {
+        x: number;
+        y: number;
+    };
+    outHandle?: {
+        x: number;
+        y: number;
+    };
+}
+/**
+ * Derive a per-subpath anchor model from a PolygonPath. Subpaths split on
+ * every `M` command; a subpath is closed iff it ends with `Z`.
+ *
+ * Cubic-segment control points become the outHandle of the previous anchor
+ * and the inHandle of the next anchor. A closed subpath whose last curve ends
+ * exactly on its first point holds that point twice; the two are one anchor,
+ * and the curve's second control is that anchor's inHandle. Quadratic segments are upgraded to
+ * cubics (each control reused for both adjacent handles) — this loses no
+ * geometry. Linear segments produce anchors with no handles.
+ */
+declare function pathToAnchors(path: PolygonPath): {
+    anchors: PenAnchor[][];
+    closed: boolean[];
+};
+/**
+ * Serialize the per-subpath anchor model back to a PolygonPath. Inverse of
+ * `pathToAnchors`. Curve-vs-line decision per segment:
+ *   - Both adjacent handles absent → straight L segment.
+ *   - Either handle present → C segment, with missing handles defaulting to
+ *     the anchor point itself (degenerate but valid; renders as a near-line).
+ * Given `like`, the path being reshaped, the result keeps its fill rules.
+ */
+declare function anchorsToPath(anchors: PenAnchor[][], closed: boolean[], like?: PolygonPath): PolygonPath;
+/**
+ * Returns true if the anchor's in-handle and out-handle are collinear with
+ * the anchor point, indicating "smooth" (mirror-drag) behavior. Detected via
+ * the magnitude of the normalized cross product of the two handle vectors.
+ *
+ * Edge cases:
+ *   - Missing in or out handle → false (corner by definition).
+ *   - Either handle at zero distance from anchor → false.
+ */
+declare function isAnchorSmooth(a: PenAnchor): boolean;
+/** How many anchors a path has. Matches the per-anchor arrays the renderer
+ *  expects for `vertexColors`. */
+declare function countPathAnchors(path: Path): number;
+/** The segment `(sub, segIdx)` as its two end anchors, or null when it
+ *  doesn't exist. `segIdx === sub.length - 1` names a closed subpath's
+ *  closing segment, which runs from the last anchor back to the first. */
+declare function segmentEnds(anchors: readonly PenAnchor[][], closed: readonly boolean[] | undefined, sub: number, segIdx: number): {
+    a: PenAnchor;
+    b: PenAnchor;
+} | null;
+/** Whether the segment from `a` to `b` is a straight line (no handles). */
+declare function isStraightSegment(a: PenAnchor, b: PenAnchor): boolean;
+/** The segment of a decoded path nearest `(wx, wy)`, and the parameter `t`
+ *  on it closest to that point. Pass `closed` (from `pathToAnchors`) to
+ *  include each closed subpath's closing segment, reported as
+ *  `segIdx === sub.length - 1`. `t` spans `[0, 1]`, endpoints included.
+ *  Returns `null` only when there are no segments. */
+declare function nearestSegmentT(anchors: PenAnchor[][], wx: number, wy: number, closed?: readonly boolean[]): {
+    sub: number;
+    segIdx: number;
+    t: number;
+} | null;
+
+/**
+ * Controls for the one cubic that replaces `prev → removed → next` when
+ * `removed` is deleted. The new controls keep the directions the curve leaves
+ * `prev` and arrives at `next` with, and their lengths are least-squares fitted
+ * to samples of the two segments being replaced, so the curve keeps its shape
+ * as closely as one cubic can. Where `removed` was inserted by splitting a
+ * cubic, the original cubic comes back.
+ */
+declare function fitCubicThroughDeletion(prev: PenAnchor, removed: PenAnchor, next: PenAnchor): {
+    c1: Point$1;
+    c2: Point$1;
+};
+
 /**
  * Schneider (1990, Graphics Gems I) adaptive cubic-Bezier fitter.
  * Given a sequence of sample points, returns a `PolygonPath` whose `C`
@@ -594,7 +698,273 @@ declare function pathDistanceToPoint(path: Path, px: number, py: number): number
  * `C` cubic segments. For colinear / two-point inputs, returns a single
  * degenerate cubic. For empty input, returns an empty polygon path.
  */
-declare function schneiderFit(samples: ReadonlyArray<Point>, errorTolerance: number): PolygonPath;
+declare function schneiderFit(samples: ReadonlyArray<Point$1>, errorTolerance: number): PolygonPath;
+/**
+ * The single cubic from the first sample to the last that best fits the
+ * samples between, with its control points held to the given unit tangents:
+ * `tStart` leaving the first sample, `tEnd` leaving the last one backward.
+ * Only the two handle lengths are solved for.
+ *
+ * `params` is the curve parameter each sample starts at, chord length when
+ * omitted; `passes` is how many times those are refined and the lengths
+ * solved again.
+ */
+declare function fitCubicWithTangents(samples: ReadonlyArray<Point$1>, tStart: Point$1, tEnd: Point$1, opts?: {
+    params?: ReadonlyArray<number>;
+    passes?: number;
+}): {
+    cp1: Point$1;
+    cp2: Point$1;
+};
+
+/** Options for {@link simplifyPath}. */
+interface SimplifyPathOptions {
+    /**
+     * An anchor whose path turns by more than this many degrees is a corner:
+     * it is kept, and the curve is refitted on either side of it. Default 40.
+     */
+    cornerAngle?: number;
+}
+/**
+ * `path` refitted with as few anchors as hold it within `tolerance`: every
+ * point sampled along the original lies within `tolerance` of the result.
+ * Corners (see {@link SimplifyPathOptions.cornerAngle}) and the ends of open
+ * subpaths stay where they are; the runs between them are refitted as smooth
+ * cubics, Schneider-style, and a run that lies within `tolerance` of a line
+ * becomes one straight segment. Fill rules carry over.
+ */
+declare function simplifyPath(path: PolygonPath, tolerance: number, opts?: SimplifyPathOptions): PolygonPath;
+
+/**
+ * Screen-pixel lengths in world units, per axis.
+ *
+ * Chrome declares its hit zones in screen pixels — an 8px handle stays 8px at
+ * every zoom, because it paints in screen space. Converting one such length to
+ * world units with a single scalar (see `meanScale`) is exact only under
+ * uniform zoom; per-axis it is too generous on one axis and too mean on the
+ * other, so the pickable region stops matching the painted one.
+ *
+ * Prefer {@link withinPxBox} / {@link withinPxRadius}, which compare in screen
+ * space and so can't drift from the paint at all. {@link pxExtent} is for the
+ * cases that must stay in world units — a tolerance handed to geometry that
+ * doesn't know about the view.
+ */
+interface Scale2 {
+    x: number;
+    y: number;
+}
+/** One screen-pixel length as world-space extents, per axis. `scale` is a
+ *  view's, so neither axis is zero (see `View`).
+ *
+ *  With `rotation`, the axes are a frame turned that far from world, and each
+ *  extent is how far along it an edge across it must move to move `px` on
+ *  screen — which, under non-uniform zoom, is not the extent along the screen
+ *  axis nearest to it. */
+declare function pxExtent(px: number, scale: Scale2, rotation?: number): {
+    x: number;
+    y: number;
+};
+/** World delta → screen delta. Only the scale participates: translation
+ *  cancels in a difference, and the kit's views carry no skew. */
+declare function scaleDelta(dx: number, dy: number, scale: Scale2): {
+    x: number;
+    y: number;
+};
+/**
+ * Is a world-space delta inside a screen-space square of half-extent `px`?
+ *
+ * The square is axis-aligned **on screen**, which is what a handle painted in
+ * screen space actually is — so this stays true under non-uniform zoom and
+ * under a rotated target, where an axis-aligned world-space test is a rotated
+ * rectangle on screen.
+ */
+declare function withinPxBox(dx: number, dy: number, px: number, scale: Scale2): boolean;
+/** Is a world-space delta inside a screen-space circle of radius `px`? */
+declare function withinPxRadius(dx: number, dy: number, px: number, scale: Scale2): boolean;
+/**
+ * A world point pushed `px` screen pixels off an edge, along the edge's normal
+ * as it lands on screen. `normal` is the edge's outward normal in world space.
+ *
+ * Scaling the world normal by the view is not the same thing: under
+ * non-uniform zoom the image of a normal is no longer perpendicular to the
+ * image of its edge, so chrome placed that way drifts sideways and sits closer
+ * than `px`. Returns the point in world coords and the on-screen unit normal.
+ */
+declare function standoff(anchor: {
+    x: number;
+    y: number;
+}, normal: {
+    x: number;
+    y: number;
+}, px: number, scale: Scale2): {
+    x: number;
+    y: number;
+    nx: number;
+    ny: number;
+};
+/** The screen angle a frame turned `rotation` from world lands its x axis at.
+ *  Equals `rotation` under uniform zoom; non-uniform zoom bends it. */
+declare function screenAngleOf(rotation: number, scale: Scale2): number;
+
+/**
+ * Pure anchor-set edits on the model `pathToAnchors` produces: subpath-major
+ * `PenAnchor[][]` plus a parallel `closed: boolean[]`. Every function here
+ * mutates that structure in place; callers decode with `pathToAnchors`,
+ * apply, and re-encode with `anchorsToPath` (see {@link editAnchorSet}).
+ *
+ * Callers address anchors by flat index — the sequential position in walk
+ * order across all subpaths, which is what `enumerateAnchors` reports.
+ * {@link locateAnchor} and {@link flatAnchorIndex} convert to and from the
+ * `(sub, idx)` pair.
+ *
+ * The two orders agree because `pathToAnchors` and `enumerateAnchors`
+ * walk the same command stream and emit one anchor per M/L/C/Q, less the
+ * end of a closing curve that lands on its subpath's first point.
+ * `countPathAnchors`, which sizes the renderer's per-anchor arrays, counts
+ * that end too and so can be one higher per closed subpath.
+ */
+
+/** Subpath-major anchor model — the decoded form of a `PolygonPath`. */
+interface AnchorSet {
+    anchors: PenAnchor[][];
+    closed: boolean[];
+}
+/** A world-space rectangle, as produced by a drag-rect gesture. */
+interface AnchorRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** Total anchors across every subpath. */
+declare function anchorCount(set: AnchorSet): number;
+/** Flat index → `(sub, idx)`. Returns null when out of range. */
+declare function locateAnchor(set: AnchorSet, flatIndex: number): {
+    sub: number;
+    idx: number;
+} | null;
+/** `(sub, idx)` → flat index. Returns -1 when out of range. */
+declare function flatAnchorIndex(set: AnchorSet, sub: number, idx: number): number;
+/** Resolve a flat index to the anchor itself. Null when out of range. */
+declare function anchorAt(set: AnchorSet, flatIndex: number): PenAnchor | null;
+/**
+ * Decode `path`, hand the mutable anchor set to `edit`, and re-encode.
+ * Returns null when `edit` returns `false` (it changed nothing), so callers
+ * can skip a no-op commit.
+ */
+declare function editAnchorSet(path: PolygonPath, edit: (set: AnchorSet) => boolean | void): PolygonPath | null;
+/** Translate an anchor and both of its handles by `(dx, dy)`. */
+declare function translateAnchorBy(set: AnchorSet, flatIndex: number, dx: number, dy: number): boolean;
+/**
+ * Move one control handle to an absolute world position. When the anchor was
+ * smooth (handles collinear through the anchor) and `breakSmoothness` is
+ * false, the opposite handle is mirrored so the curve stays smooth.
+ */
+declare function moveHandleTo(set: AnchorSet, flatIndex: number, side: 'in' | 'out', toX: number, toY: number, breakSmoothness: boolean): boolean;
+/**
+ * Split the segment `(sub, segIdx) → (sub, segIdx + 1)` at parameter `t`,
+ * inserting a new anchor there. On a closed subpath `segIdx` may also name
+ * the closing segment (`sub.length - 1`); its new anchor is appended.
+ *
+ * A straight segment stays straight — the new anchor has no handles. A curved
+ * one splits by de Casteljau, so the two halves trace the original path.
+ *
+ * Returns the new anchor's flat index, or -1 when the segment doesn't
+ * exist.
+ */
+declare function insertAnchorOnSegment(set: AnchorSet, args: {
+    sub: number;
+    segIdx: number;
+    t: number;
+}): number;
+/** A point on a segment, as {@link segmentAt} reports it. */
+interface SegmentHit {
+    sub: number;
+    segIdx: number;
+    /** Parameter on the segment — what {@link insertAnchorOnSegment} takes. */
+    t: number;
+    /** The point on the path at `t`, in the set's own space. */
+    x: number;
+    y: number;
+}
+/**
+ * The segment point under `(x, y)`, when it lies within `tolerancePx` of
+ * the path on screen and no nearer than that to either of the segment's
+ * own anchors — a press on an anchor is about the anchor, not the segment
+ * beside it.
+ *
+ * `scale` is the view's, so the tolerance holds per axis under
+ * non-uniform zoom. The search runs in screen-scaled space: scaling is
+ * affine, so the curve's parameterization, and therefore `t`, carries
+ * straight back to world space.
+ */
+declare function segmentAt(set: AnchorSet, x: number, y: number, opts: {
+    tolerancePx: number;
+    scale?: Scale2;
+}): SegmentHit | null;
+/**
+ * Delete the anchors at `flatIndexes`. Where a deleted anchor had
+ * neighbors on both sides — across the seam too, on a closed subpath — the
+ * surviving segment is refitted to the two it replaces (`fitCubicThroughDeletion`)
+ * so the path keeps its shape; a gap between two straight segments closes straight.
+ *
+ * Subpaths left with fewer than two anchors are dropped entirely. If that
+ * would leave the path with no subpaths at all, the whole deletion is refused
+ * (returns false, `set` untouched): an empty path leaves the node selected
+ * and in the scene with nothing on screen and no anchors to grab it by.
+ */
+declare function deleteAnchorsAt(set: AnchorSet, flatIndexes: Iterable<number>): boolean;
+/**
+ * Scissors: open a closed subpath at the given anchor. The anchor list is
+ * rotated to start there and a second anchor at the same point ends it, so
+ * every segment survives and the two ends can be pulled apart. No-ops on an
+ * already-open subpath — there's nothing to cut.
+ */
+declare function openSubpathAt(set: AnchorSet, flatIndex: number): boolean;
+/** Flat indices of every anchor whose on-curve point falls inside `rect`. */
+declare function anchorsInRect(set: AnchorSet, rect: AnchorRect): number[];
+
+/**
+ * Average and Join: anchor-set edits that bring anchors together. Both mutate
+ * the model `pathToAnchors` produces in place, like the edits in
+ * `anchorEdits`, and address anchors by flat index.
+ */
+
+/** Which coordinates {@link averageAnchorsAt} averages: `'x'` lines the
+ *  anchors up on one vertical, `'y'` on one horizontal, `'both'` stacks them
+ *  on one point. */
+type AverageAxis = 'x' | 'y' | 'both';
+/** One end of an open subpath. */
+interface SubpathEnd {
+    sub: number;
+    end: 'first' | 'last';
+}
+/**
+ * Move each anchor in `flatIndexes` to their mean position, along `axis`.
+ * Each anchor carries its handles with it. Returns false, changing nothing,
+ * when fewer than two of the indexes name anchors.
+ */
+declare function averageAnchorsAt(set: AnchorSet, flatIndexes: Iterable<number>, axis?: AverageAxis): boolean;
+/** The open-subpath end anchor `flatIndex` names, or null for an interior
+ *  anchor or one on a closed subpath. A lone anchor reads as `'last'`. */
+declare function subpathEndAt(set: AnchorSet, flatIndex: number): SubpathEnd | null;
+/**
+ * Join the two open-subpath ends `a` and `b`. The two ends of one subpath
+ * close it; ends of two subpaths make one subpath, `a`'s run followed by
+ * `b`'s, in the slot of whichever came first. Ends that coincide merge into
+ * one anchor, keeping the handle on either side; ends apart are bridged by a
+ * straight segment. Returns false, changing nothing, when the ends are not
+ * two distinct ends of open subpaths.
+ */
+declare function joinSubpathEnds(set: AnchorSet, a: SubpathEnd, b: SubpathEnd): boolean;
+/** {@link joinSubpathEnds} for two anchors named by flat index, each the end
+ *  of an open subpath. */
+declare function joinAnchorsAt(set: AnchorSet, flatA: number, flatB: number): boolean;
+/**
+ * The two open-subpath ends nearest each other that `accept` allows, on two
+ * different subpaths. Null when there are no two such subpaths.
+ */
+declare function closestOpenEnds(set: AnchorSet, accept?: (a: SubpathEnd, b: SubpathEnd) => boolean): [SubpathEnd, SubpathEnd] | null;
 
 /**
  * Path hit-testing: path-vs-point (filled region and stroke distance),
@@ -630,7 +1000,7 @@ interface StrokeHitTestOptions {
      *  transform no world distance equals it. */
     slop?: {
         px: number;
-        transform: Mat3;
+        transform: Affine;
     };
 }
 /** Filled-region hit-test for a path. Rect short-circuits to AABB; polygons run ray-cast / winding per `fillRule`. */
@@ -650,15 +1020,15 @@ declare function pathContainsRect(path: Path, rect: Rect, opts?: PointInPathOpti
 /** Returns true if `rect` overlaps (intersects or contains) `path`. */
 declare function pathIntersectsRect(path: Path, rect: Rect, opts?: PointInPathOptions): boolean;
 /** Returns true if every vertex of `polygon` lies inside `path`. */
-declare function pathContainsPolygon(path: Path, polygon: readonly Point[], opts?: PointInPathOptions): boolean;
+declare function pathContainsPolygon(path: Path, polygon: readonly Point$1[], opts?: PointInPathOptions): boolean;
 /** Returns true if `polygon` overlaps (intersects or is contained by) `path`. */
-declare function pathIntersectsPolygon(path: Path, polygon: readonly Point[], opts?: PointInPathOptions): boolean;
+declare function pathIntersectsPolygon(path: Path, polygon: readonly Point$1[], opts?: PointInPathOptions): boolean;
 /**
  * Returns true if all of `path` — every subpath, open ones included, beziers
  * flattened — lies inside the closed `polygon`: the inverse of
  * {@link pathContainsPolygon}. A lasso enclosing a shape asks this.
  */
-declare function polygonContainsPath(polygon: readonly Point[], path: Path, opts?: PointInPathOptions): boolean;
+declare function polygonContainsPath(polygon: readonly Point$1[], path: Path, opts?: PointInPathOptions): boolean;
 /**
  * Returns true if any of `path` meets the closed `polygon`: its filled region,
  * or the line of an open subpath, which encloses nothing. With `filled: false`
@@ -666,15 +1036,7 @@ declare function polygonContainsPath(polygon: readonly Point[], path: Path, opts
  * flattened, so a control point off the curve never counts. The companion of
  * {@link polygonContainsPath}; a lasso touching a shape asks this.
  */
-declare function polygonIntersectsPath(polygon: readonly Point[], path: Path, opts?: PolygonIntersectsPathOptions): boolean;
-
-/**
- * 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: Mat3): Float64Array;
+declare function polygonIntersectsPath(polygon: readonly Point$1[], path: Path, opts?: PolygonIntersectsPathOptions): boolean;
 
 /**
  * Ergonomic builders for tiny shape paths used by chrome / overlays / markers.
@@ -730,9 +1092,9 @@ declare function translated(m: GlMat3, tx: number, ty: number): GlMat3;
 declare function scaled(m: GlMat3, sx: number, sy: number): GlMat3;
 /** This layout read as the kernel's 6-element affine. The two carry the same
  *  logical order, so the conversion is a repack and nothing else. */
-declare function toAffine(m: GlMat3): Mat3;
+declare function toAffine(m: GlMat3): Affine;
 /** The kernel's affine in this layout. The inverse of {@link toAffine}. */
-declare function fromAffine(a: Mat3): GlMat3;
+declare function fromAffine(a: Affine): GlMat3;
 /** Inverse of an affine matrix, or `null` when `@weasel-js/geom`'s `invert`
  *  finds it singular — the same rule, read through this layout. */
 declare function invert(m: GlMat3): GlMat3 | null;
@@ -757,7 +1119,7 @@ declare function meanScaleOf(m: GlMat3): number;
 declare function minScaleOf(m: GlMat3): number;
 /** The renderer's 3x3 matrix operations, as one namespace. These work on the
  *  9-element form the GL uniform upload wants — distinct from the 6-element
- *  affine `Mat3`, though the logical element order is the same. */
+ *  `Affine`, though the logical element order is the same. */
 declare const mat3: {
     identity: typeof identity;
     toAffine: typeof toAffine;
@@ -996,77 +1358,6 @@ declare function meanScale(s: {
     y: number;
 }): number;
 
-/**
- * Screen-pixel lengths in world units, per axis.
- *
- * Chrome declares its hit zones in screen pixels — an 8px handle stays 8px at
- * every zoom, because it paints in screen space. Converting one such length to
- * world units with a single scalar (see `meanScale`) is exact only under
- * uniform zoom; per-axis it is too generous on one axis and too mean on the
- * other, so the pickable region stops matching the painted one.
- *
- * Prefer {@link withinPxBox} / {@link withinPxRadius}, which compare in screen
- * space and so can't drift from the paint at all. {@link pxExtent} is for the
- * cases that must stay in world units — a tolerance handed to geometry that
- * doesn't know about the view.
- */
-interface Scale2 {
-    x: number;
-    y: number;
-}
-/** One screen-pixel length as world-space extents, per axis. `scale` is a
- *  view's, so neither axis is zero (see `View`).
- *
- *  With `rotation`, the axes are a frame turned that far from world, and each
- *  extent is how far along it an edge across it must move to move `px` on
- *  screen — which, under non-uniform zoom, is not the extent along the screen
- *  axis nearest to it. */
-declare function pxExtent(px: number, scale: Scale2, rotation?: number): {
-    x: number;
-    y: number;
-};
-/** World delta → screen delta. Only the scale participates: translation
- *  cancels in a difference, and the kit's views carry no skew. */
-declare function scaleDelta(dx: number, dy: number, scale: Scale2): {
-    x: number;
-    y: number;
-};
-/**
- * Is a world-space delta inside a screen-space square of half-extent `px`?
- *
- * The square is axis-aligned **on screen**, which is what a handle painted in
- * screen space actually is — so this stays true under non-uniform zoom and
- * under a rotated target, where an axis-aligned world-space test is a rotated
- * rectangle on screen.
- */
-declare function withinPxBox(dx: number, dy: number, px: number, scale: Scale2): boolean;
-/** Is a world-space delta inside a screen-space circle of radius `px`? */
-declare function withinPxRadius(dx: number, dy: number, px: number, scale: Scale2): boolean;
-/**
- * A world point pushed `px` screen pixels off an edge, along the edge's normal
- * as it lands on screen. `normal` is the edge's outward normal in world space.
- *
- * Scaling the world normal by the view is not the same thing: under
- * non-uniform zoom the image of a normal is no longer perpendicular to the
- * image of its edge, so chrome placed that way drifts sideways and sits closer
- * than `px`. Returns the point in world coords and the on-screen unit normal.
- */
-declare function standoff(anchor: {
-    x: number;
-    y: number;
-}, normal: {
-    x: number;
-    y: number;
-}, px: number, scale: Scale2): {
-    x: number;
-    y: number;
-    nx: number;
-    ny: number;
-};
-/** The screen angle a frame turned `rotation` from world lands its x axis at.
- *  Equals `rotation` under uniform zoom; non-uniform zoom bends it. */
-declare function screenAngleOf(rotation: number, scale: Scale2): number;
-
 /** Pivot (`cx`, `cy`) and angle resolved from a pose's rotation convention. */
 interface PoseRotation {
     cx: number;
@@ -1098,7 +1389,7 @@ declare function rotatePathAround(path: Path, cx: number, cy: number, rotation:
 /**
  * The linear part of a box pose that its box, rotation, and flips cannot
  * hold: a skew, or a scale that differs by axis. `[a, b, c, d]` in
- * `Mat3` order (`x' = a·x + c·y`, `y' = b·x + d·y`), applied about the
+ * `Affine` order (`x' = a·x + c·y`, `y' = b·x + d·y`), applied about the
  * box center to what the node draws in its unrotated box, before the
  * rotation. Absent is the identity.
  */
@@ -1111,133 +1402,150 @@ declare function poseLinearOf(pose: unknown): PoseLinear | null;
  * `null` when the pose has neither, or is not a box, so a caller can skip
  * the step.
  */
-declare function poseFrameOf(pose: unknown): Mat3 | null;
+declare function poseFrameOf(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
  * the `transform` is singular and nothing maps back.
  */
-declare function poseFrameInverseOf(pose: unknown): Mat3 | null;
+declare function poseFrameInverseOf(pose: unknown): Affine | null;
 /** `path`, given in the pose's unrotated box frame, as the node draws it. */
 declare function pathThroughPoseFrame(path: Path, pose: unknown): Path;
 
-/**
- * Pure anchor-set edits on the model `pathToAnchors` produces: subpath-major
- * `PenAnchor[][]` plus a parallel `closed: boolean[]`. Every function here
- * mutates that structure in place; callers decode with `pathToAnchors`,
- * apply, and re-encode with `anchorsToPath` (see {@link editAnchorSet}).
- *
- * Callers address anchors by flat index — the sequential position in walk
- * order across all subpaths, which is what `enumerateAnchors` reports.
- * {@link locateAnchor} and {@link flatAnchorIndex} convert to and from the
- * `(sub, idx)` pair.
- *
- * The two orders agree because `pathToAnchors` and `enumerateAnchors`
- * walk the same command stream and emit one anchor per M/L/C/Q, less the
- * end of a closing curve that lands on its subpath's first point.
- * `countPathAnchors`, which sizes the renderer's per-anchor arrays, counts
- * that end too and so can be one higher per closed subpath.
- */
-
-/** Subpath-major anchor model — the decoded form of a `PolygonPath`. */
-interface AnchorSet {
-    anchors: PenAnchor[][];
-    closed: boolean[];
-}
-/** A world-space rectangle, as produced by a drag-rect gesture. */
-interface AnchorRect {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
+type Side = 'in' | 'out';
+/**
+ * How a path maps onto itself under one transform `m`: `partners[i]` is the
+ * flat index of the anchor that anchor `i` lands on, and `flips[i]` whether
+ * its in-handle lands on that anchor's out-handle — a mirror reverses which
+ * way a path runs, a rotation does not. An anchor `m` fixes is its own
+ * partner.
+ */
+interface AnchorSymmetry {
+    readonly m: Affine;
+    readonly partners: readonly number[];
+    readonly flips: readonly boolean[];
 }
-/** Total anchors across every subpath. */
-declare function anchorCount(set: AnchorSet): number;
-/** Flat index → `(sub, idx)`. Returns null when out of range. */
-declare function locateAnchor(set: AnchorSet, flatIndex: number): {
-    sub: number;
-    idx: number;
-} | null;
-/** `(sub, idx)` → flat index. Returns -1 when out of range. */
-declare function flatAnchorIndex(set: AnchorSet, sub: number, idx: number): number;
-/** Resolve a flat index to the anchor itself. Null when out of range. */
-declare function anchorAt(set: AnchorSet, flatIndex: number): PenAnchor | null;
 /**
- * Decode `path`, hand the mutable anchor set to `edit`, and re-encode.
- * Returns null when `edit` returns `false` (it changed nothing), so callers
- * can skip a no-op commit.
+ * The pairing that makes `set` its own image under `m`, or `null` when it is
+ * not one: every anchor, handles included, must land on a distinct anchor
+ * within `tolerance` on each axis.
  */
-declare function editAnchorSet(path: PolygonPath, edit: (set: AnchorSet) => boolean | void): PolygonPath | null;
-/** Translate an anchor and both of its handles by `(dx, dy)`. */
-declare function translateAnchorBy(set: AnchorSet, flatIndex: number, dx: number, dy: number): boolean;
+declare function anchorSymmetry(set: AnchorSet, m: Affine, tolerance?: number): AnchorSymmetry | null;
+/** Every transform in `group` that `set` is its own image under, paired. */
+declare function anchorSymmetries(set: AnchorSet, group: readonly Affine[], tolerance?: number): AnchorSymmetry[];
 /**
- * Move one control handle to an absolute world position. When the anchor was
- * smooth (handles collinear through the anchor) and `breakSmoothness` is
- * false, the opposite handle is mirrored so the curve stays smooth.
+ * Translate the anchors `flats` by `(dx, dy)` the way `translateAnchorBy`
+ * does, and every image of each under `syms` by the transformed delta, so a
+ * path that was its own image under each of them still is. `syms` should be
+ * the whole symmetry group less its identity, as `anchorSymmetries` gives it
+ * for a group; with a part of one, the anchors it fixes are only partly held.
+ * An anchor that is itself being dragged moves as dragged.
  */
-declare function moveHandleTo(set: AnchorSet, flatIndex: number, side: 'in' | 'out', toX: number, toY: number, breakSmoothness: boolean): boolean;
+declare function translateAnchorsSymmetric(set: AnchorSet, flats: readonly number[], dx: number, dy: number, syms: readonly AnchorSymmetry[]): boolean;
 /**
- * Split the segment `(sub, segIdx) → (sub, segIdx + 1)` at parameter `t`,
- * inserting a new anchor there. On a closed subpath `segIdx` may also name
- * the closing segment (`sub.length - 1`); its new anchor is appended.
+ * Move one handle to `(toX, toY)` and every image of it under `syms` to the
+ * image of that point, so a path that was its own image under each of them
+ * still is. A handle a transform maps onto itself keeps to where that
+ * transform allows; one mapped onto its own anchor's opposite handle drives
+ * that handle.
  *
- * A straight segment stays straight — the new anchor has no handles. A curved
- * one splits by de Casteljau, so the two halves trace the original path.
- *
- * Returns the new anchor's flat index, or -1 when the segment doesn't
- * exist.
+ * Otherwise a smooth anchor keeps the opposite handle opposite, as
+ * `moveHandleTo` does, unless `breakSmoothness`, and that handle's images
+ * follow it. Every handle is written once, from its target, so no anchor
+ * re-aims a handle another image already placed.
  */
-declare function insertAnchorOnSegment(set: AnchorSet, args: {
-    sub: number;
-    segIdx: number;
-    t: number;
-}): number;
-/** A point on a segment, as {@link segmentAt} reports it. */
-interface SegmentHit {
+declare function moveHandleSymmetric(set: AnchorSet, flat: number, side: Side, toX: number, toY: number, breakSmoothness: boolean, syms: readonly AnchorSymmetry[]): boolean;
+
+/** Where on a segment a bend is held, as `segmentAt` reports it. */
+interface BendGrip {
     sub: number;
     segIdx: number;
-    /** Parameter on the segment — what {@link insertAnchorOnSegment} takes. */
+    /** Curve parameter of the held point. */
     t: number;
-    /** The point on the path at `t`, in the set's own space. */
+}
+/**
+ * Bend one segment so the point held at `grip.t` moves by `(dx, dy)`, by
+ * moving its two control handles: each by an amount weighted toward the end it
+ * belongs to, together exactly enough to carry the held point along. A straight
+ * segment becomes a curve. Where an end anchor was smooth, its other handle
+ * turns to stay in line, keeping its length, so the neighboring segment bends
+ * with it rather than kinking.
+ *
+ * Returns false when the segment doesn't exist.
+ */
+declare function bendSegment(set: AnchorSet, grip: BendGrip, dx: number, dy: number): boolean;
+
+type Point = {
     x: number;
     y: number;
-}
+};
 /**
- * The segment point under `(x, y)`, when it lies within `tolerancePx` of
- * the path on screen and no nearer than that to either of the segment's
- * own anchors — a press on an anchor is about the anchor, not the segment
- * beside it.
+ * Collapse the handles of the anchors at `flatIndexes` onto their anchors,
+ * leaving sharp corners. A segment whose ends both lose their handles turns
+ * straight.
  *
- * `scale` is the view's, so the tolerance holds per axis under
- * non-uniform zoom. The search runs in screen-scaled space: scaling is
- * affine, so the curve's parameterization, and therefore `t`, carries
- * straight back to world space.
+ * Returns false when every handle was already on its anchor. A segment that
+ * stays curved because its far end keeps a handle still encodes a control at
+ * this end, so it decodes as a handle sitting on the anchor: retracted.
  */
-declare function segmentAt(set: AnchorSet, x: number, y: number, opts: {
-    tolerancePx: number;
-    scale?: Scale2;
-}): SegmentHit | null;
+declare function retractHandles(set: AnchorSet, flatIndexes: Iterable<number>): boolean;
 /**
- * Delete the anchors at `flatIndexes`. Where a deleted anchor had
- * neighbors on both sides — across the seam too, on a closed subpath — the
- * surviving segment is refitted through the gap (`fitCubicThroughDeletion`)
- * so the path keeps its shape instead of snapping to a straight line.
+ * Give each anchor at `flatIndexes` two handles of equal length pointing in
+ * opposite directions, so the curve passes through it smoothly. The shared
+ * direction splits the difference between the two handles' own directions,
+ * and the shared length is their mean; an anchor with one handle mirrors it.
  *
- * Subpaths left with fewer than two anchors are dropped entirely. If that
- * would leave the path with no subpaths at all, the whole deletion is refused
- * (returns false, `set` untouched): an empty path leaves the node selected
- * and in the scene with nothing on screen and no anchors to grab it by.
+ * Skipped: an anchor with no handles, and the ends of an open subpath, which
+ * have only one segment to shape. Returns false when nothing changed.
  */
-declare function deleteAnchorsAt(set: AnchorSet, flatIndexes: Iterable<number>): boolean;
+declare function makeHandlesSymmetric(set: AnchorSet, flatIndexes: Iterable<number>): boolean;
 /**
- * Scissors: open a closed subpath at the given anchor. The anchor list is
- * rotated to start there and a second anchor at the same point ends it, so
- * every segment survives and the two ends can be pulled apart. No-ops on an
- * already-open subpath — there's nothing to cut.
+ * Where a handle lands when dragged toward `to` but held to its current
+ * direction from `anchor`: `to` projected onto that ray. The length never
+ * goes below zero, so the handle can shrink onto the anchor but not flip
+ * through it. A handle already sitting on its anchor has no direction to
+ * keep and follows `to` freely.
  */
-declare function openSubpathAt(set: AnchorSet, flatIndex: number): boolean;
-/** Flat indices of every anchor whose on-curve point falls inside `rect`. */
-declare function anchorsInRect(set: AnchorSet, rect: AnchorRect): number[];
+declare function handleAlongItsAngle(anchor: Point, handle: Point, to: Point): Point;
+
+/**
+ * Where each point of an edited path came from, so an array kept per point (a skin's
+ * weights) can follow an edit that inserts, deletes, or reorders points.
+ */
+
+/** The anchor model `pathToAnchors` produces; `AnchorSet` in `anchorEdits`. */
+interface Anchors {
+    anchors: PenAnchor[][];
+    closed: boolean[];
+}
+/**
+ * Where a point of an edited path came from: point `a` of the path before the edit, or for a
+ * point the edit made, a blend `t` of the way from point `a` to point `b`.
+ */
+interface PointOrigin {
+    a: number;
+    b: number;
+    t: number;
+}
+/**
+ * `editAnchorSet`, answering also where each point of the new path came from.
+ *
+ * An anchor the edit kept, moved or not, keeps its points. One the edit put exactly where an
+ * anchor was takes that anchor's, each handle by where it is, so a subpath turned around
+ * keeps its weights. A handle an edit gave an anchor that had none takes the anchor's point. An anchor the edit made is a blend of the nearest kept anchors either side
+ * of it in its subpath, by its distance to each, or a copy of the one it has; its origin is
+ * `null` when its subpath has none.
+ */
+declare function editAnchorSetTracked(path: PolygonPath, edit: (set: Anchors) => boolean | void): {
+    path: PolygonPath;
+    origins: (PointOrigin | null)[];
+} | null;
+/**
+ * An array kept per point of a path, carried through an edit: `origins` is what
+ * {@link editAnchorSetTracked} answered. A point with no origin, and an origin past the
+ * array's end, read 0.
+ */
+declare function remapPointValues(values: ArrayLike<number>, origins: readonly (PointOrigin | null)[]): number[];
 
 /**
  * Anchor lookup across several paths, measured on screen: which existing
@@ -1363,4 +1671,4 @@ declare function reviveTypedArrays(value: unknown): unknown;
 /** `tagTypedArrays` as a `JSON.stringify` replacer. */
 declare function typedArrayReplacer(_key: string, value: unknown): unknown;
 
-export { type AnchorRect, type AnchorSet, type BezierEasing, type Box, type CubicCoords, type CurveNearest, DEFAULT_FLATTEN_TOLERANCE, EASINGS, EPS, type EasingFn, type EasingName, type EasingSpec, type GlMat3, type LineCoords, type Mat3, type NumberTypedArray, PATH_C, PATH_CMD_LENGTHS, PATH_COMMANDS, PATH_L, PATH_M, PATH_Q, PATH_Z, Path, type PathAnchorHit, PathBuilder, type PathCommandCode, type PathCommandName, PathFillRule, type PathInWorldPose, type PathNearest, PathOpenFill, type PathStation, PenAnchor, type PlaceRectOptions, type PlacedRect, type Placement, type PlacementAlign, type PlacementSide, Point, type PointAlongPathOptions, type PointInPathOptions, type PolygonIntersectsPathOptions, PolygonPath, type PoseLinear, type PoseRotation, type QuadraticCoords, type Rect, RectPath, SPRING_PRESETS, type Scale2, type SegmentHit, type SpringPreset, type SpringPresetName, type StrokeHitTestOptions, TYPED_ARRAY_CONSTRUCTORS, type TaggedTypedArray, type TypedArrayTag, type View, ZOOM_FLOOR, anchorAt, anchorCount, anchorsInRect, applyToPoint, approxEq, boundsOfCoords, boundsOfPath, boxContainsBox, boxContainsPoint, boxToBox, circlePath, clamp, clampRectWithin, composePath, cross, cubicBezierEasing, cubicBounds, cubicEvalAt, decomposePath, defaultOpenFill, deleteAnchorsAt, 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, editAnchorSet, elevateQuadraticToCubic, ellipsePath, fillsOpenSubpaths, flatAnchorIndex, flattenCubic, flattenCubicWithArcLen, flattenQuadratic, flattenQuadraticWithArcLen, forEachSegment, hasOpenSubpath, identity$1 as identity, insertAnchorOnSegment, invert$1 as invert, len2, linePath, linear, locateAnchor, mat3, meanScale, moveHandleTo, multiply$1 as multiply, nearestOnCubic, nearestOnLine, nearestOnPath, nearestOnQuadratic, nearestPathAnchor, normalizeZoom, openSubpathAt, pathCommandCoordCount, pathContainsPoint, pathContainsPolygon, pathContainsRect, pathDistanceToPoint, pathFromD, pathInPoseFrame, pathInWorld, pathIntersectsPolygon, pathIntersectsRect, pathSignedArea, pathThroughPoseFrame, placeRect, pointAlongPath, pointInPath, pointInPolygon, pointSegmentDist2, polygonContainsPath, polygonFromPoints, polygonIntersectsPath, polylineFromPoints, portControls, portCurvePoints, poseFrameInverseOf, poseFrameOf, poseLinearOf, poseRotationOf, pxExtent, quadraticEvalAt, rectMarkerPath, rectPath, rectToContour, regularPolygonPath, resolveEasing, reverseAnchors, reversePath, reviveTypedArrays, rotate, rotateAboutPoint, rotatePathAround, roundRectPath, scale, scaleDelta, scalePathToBounds, schneiderFit, screenAngleOf, segmentAt, segmentsCross, setDefaultOpenFill, sign, splitByClosure, splitCubicAt, splitLineAt, splitQuadraticAt, splitSubpaths, squarePath, standoff, starPath, strokeHitTest, sub, tagTypedArray, tagTypedArrays, transformCoords, transformPath, translate, translateAnchorBy, translatePath, typedArrayReplacer, unionBoundsPath, unionBox, untagTypedArray, viewToMat3, withinPxBox, withinPxRadius, worldEditToStorage };
+export { type Affine, type AnchorRect, type AnchorSet, type AnchorSymmetry, type AverageAxis, type BendGrip, type BezierEasing, type Box, type CubicCoords, type CurveNearest, DEFAULT_FLATTEN_TOLERANCE, EASINGS, EPS, type EasingFn, type EasingName, type EasingSpec, type GlMat3, type LineCoords, type NumberTypedArray, PATH_C, PATH_CMD_LENGTHS, PATH_COMMANDS, PATH_L, PATH_M, PATH_Q, PATH_Z, Path, type PathAnchorHit, PathBuilder, type PathCommandCode, type PathCommandName, PathFillRule, type PathInWorldPose, type PathNearest, PathOpenFill, type PathStation, type PenAnchor, type PlaceRectOptions, type PlacedRect, type Placement, type PlacementAlign, type PlacementSide, Point$1 as Point, type PointAlongPathOptions, type PointInPathOptions, type PointOrigin, type PolygonIntersectsPathOptions, PolygonPath, type PoseLinear, type PoseRotation, type QuadraticCoords, type Rect, RectPath, SPRING_PRESETS, type Scale2, type SegmentHit, type SimplifyPathOptions, type SpringPreset, type SpringPresetName, type StrokeHitTestOptions, type SubpathEnd, TYPED_ARRAY_CONSTRUCTORS, type TaggedTypedArray, type TypedArrayTag, type View, ZOOM_FLOOR, anchorAt, anchorCount, anchorSymmetries, anchorSymmetry, anchorsInRect, anchorsToPath, applyToPoint, approxEq, averageAnchorsAt, bendSegment, boundsOfCoords, boundsOfPath, boxContainsBox, boxContainsPoint, boxToBox, circlePath, clamp, clampRectWithin, closestOpenEnds, composePath, countPathAnchors, cross, cubicBezierEasing, cubicBounds, cubicEvalAt, decomposePath, defaultOpenFill, deleteAnchorsAt, 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, editAnchorSet, editAnchorSetTracked, elevateQuadraticToCubic, ellipsePath, fillsOpenSubpaths, fitCubicThroughDeletion, fitCubicWithTangents, flatAnchorIndex, flattenCubic, flattenCubicWithArcLen, flattenQuadratic, flattenQuadraticWithArcLen, forEachSegment, handleAlongItsAngle, hasOpenSubpath, identity$1 as identity, insertAnchorOnSegment, invert$1 as invert, isAnchorSmooth, isStraightSegment, joinAnchorsAt, joinSubpathEnds, len2, linePath, linear, locateAnchor, makeHandlesSymmetric, mat3, meanScale, moveHandleSymmetric, moveHandleTo, multiply$1 as multiply, nearestOnCubic, nearestOnLine, nearestOnPath, nearestOnQuadratic, nearestPathAnchor, nearestSegmentT, normalizeZoom, openSubpathAt, pathCommandCoordCount, pathContainsPoint, pathContainsPolygon, pathContainsRect, pathDistanceToPoint, pathFromD, pathInPoseFrame, pathInWorld, pathIntersectsPolygon, pathIntersectsRect, pathSignedArea, pathThroughPoseFrame, pathToAnchors, placeRect, pointAlongPath, pointInPath, pointInPolygon, pointSegmentDist2, polygonContainsPath, polygonFromPoints, polygonIntersectsPath, polylineFromPoints, portControls, portCurvePoints, poseFrameInverseOf, poseFrameOf, poseLinearOf, poseRotationOf, pxExtent, quadraticEvalAt, rectMarkerPath, rectPath, rectToContour, regularPolygonPath, remapPointValues, resolveEasing, retractHandles, reverseAnchors, reversePath, reviveTypedArrays, rotate, rotateAboutPoint, rotatePathAround, roundRectPath, scale, scaleDelta, scalePathToBounds, schneiderFit, screenAngleOf, segmentAt, segmentEnds, segmentsCross, setDefaultOpenFill, sign, simplifyPath, splitByClosure, splitCubicAt, splitLineAt, splitQuadraticAt, splitSubpaths, squarePath, standoff, starPath, strokeHitTest, sub, subpathEndAt, tagTypedArray, tagTypedArrays, transformCoords, transformPath, translate, translateAnchorBy, translateAnchorsSymmetric, translatePath, typedArrayReplacer, unionBoundsPath, unionBox, untagTypedArray, viewToMat3, withinPxBox, withinPxRadius, worldEditToStorage };