@weasel-js/geom 1.9.3 → 1.10.0

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-import { a as PolygonPath, b as PathFillRule, R as RectPath, P as Path } from './path-D0CoudGM.js';
-import { P as Point } from './cubicMath-CpCvuEl8.js';
-export { c as cubicPointAt, f as fitCubicThroughDeletion, s as splitCubicAtT } from './cubicMath-CpCvuEl8.js';
+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';
 export { PORT_REACH } from './nd/index.js';
 
 /**
@@ -8,11 +8,12 @@ export { PORT_REACH } from './nd/index.js';
  *
  * Points are scalar pairs (px, py); there is no point struct. All math is
  * f64 (JS-native). Epsilons are f32-SCALE and magnitude-relative, because
- * stored coords are quantized to Float32 (~7 significant digits) — see the
- * geometry-kernel spec.
+ * stored coords are quantized to Float32 (~7 significant digits).
  */
 /** Base relative epsilon, sized for Float32 storage (~1 part in 1e-6). */
 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;
 /** 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. */
@@ -31,16 +32,47 @@ declare function sign(n: number): -1 | 0 | 1;
  *
  * The exception is a guard against an exact algebraic value that a formula
  * produces bit-for-bit: a homogeneous `w === 1`, a ray's `d === 0`. Those are
- * testing a branch, not comparing coordinates, and `geom/3d` has two of them
- * (`mat4.ts`, `ray3.ts`). Widening one to `approxEq` would change which branch
- * runs, not how precisely it runs.
+ * testing a branch, not comparing coordinates. Widening one to `approxEq`
+ * would change which branch runs, not how precisely it runs.
  */
 declare function approxEq(a: number, b: number, eps?: number): boolean;
 
+/**
+ * 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
+ * unit on each axis.
+ *
+ * A `View` names no orientation, so a kernel with a camera cannot express its
+ * viewport as one.
+ */
+interface View {
+    x: number;
+    y: number;
+    scale: {
+        x: number;
+        y: number;
+    };
+}
+/**
+ * The smallest zoom magnitude a view can hold, in `View.scale` units.
+ *
+ * A view's zoom is always finite and at least this far from 0. Nothing can be
+ * drawn or picked through a zoom of 0, and every screen↔world conversion
+ * divides by it, so it is ruled out where views are made rather than handled
+ * by each conversion.
+ */
+declare const ZOOM_FLOOR = 1e-9;
+/**
+ * The one rule for a zoom magnitude: a finite number no smaller than
+ * {@link ZOOM_FLOOR}. Anything else (0, negative, NaN, ±Infinity) becomes the
+ * floor.
+ */
+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];
 /** The transform that leaves a point where it is. */
-declare function identity(): Mat3;
+declare function identity$1(): Mat3;
 /** A pure translation by `(tx, ty)`. */
 declare function translate(tx: number, ty: number): Mat3;
 /** A pure scale about the origin. Scale about another point by composing
@@ -50,10 +82,10 @@ declare function scale(sx: number, sy: number): Mat3;
  *  coordinates (y down). */
 declare function rotate(rad: number): Mat3;
 /** Compose: result applies `n` first, then `m` (m·n). */
-declare function multiply(m: Mat3, n: Mat3): Mat3;
+declare function multiply$1(m: Mat3, n: Mat3): Mat3;
 /** Inverse, or null when the matrix is singular, non-finite, or too
  *  ill-conditioned to invert meaningfully at its own scale. */
-declare function invert(m: Mat3): Mat3 | null;
+declare function invert$1(m: Mat3): Mat3 | 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];
 /** Affine that maps source box (sx,sy,sw,sh) onto destination box (dx,dy,dw,dh). */
@@ -88,12 +120,12 @@ declare function rectToContour(x: number, y: number, w: number, h: number): Floa
 
 /**
  * SVG-style command-stream encoding — the kit's single declaration of the path
- * opcodes. `Path` (`./path`) wraps this with `kind` + `fillRule`.
+ * opcodes.
  *
  * The codes index a `Uint8Array` command stream whose coords live in a
  * parallel float array, so a code declared anywhere but `PATH_COMMANDS` makes
  * every walker that doesn't know it misread the coord stream from that command
- * on — silently, for every path. Derive, never restate.
+ * on — silently, for every path.
  */
 /** Opcode table: command code and the float coords it consumes. */
 declare const PATH_COMMANDS: {
@@ -144,16 +176,17 @@ declare const PATH_CMD_LENGTHS: readonly number[];
 declare function pathCommandCoordCount(cmd: number): number;
 /**
  * Visit each command with its coord offset and the pen position BEFORE the
- * command consumes its coords (the segment start). The callback receives
- * (cmd, coordIndex, penX, penY, commandIndex) and stops the walk by returning
- * `false`. The pen advances to the command's last coord pair afterward; `Z`
- * returns it to the subpath's opening `M`, so a command following a `Z`
- * without an intervening `M` starts where SVG says it does.
+ * command consumes its coords (the segment start). The callback stops the
+ * walk by returning `false`. `Z` returns the pen to the subpath's opening `M`.
+ *
+ * A command following a `Z` without an intervening `M` opens a new subpath at
+ * the pen, as does a drawing command no `M` precedes at all. The visitor is
+ * told with `opensSubpath`, and has to start its contour at `(penX, penY)`
+ * then: there is no `M` to do it.
  *
- * A code `PATH_COMMANDS` does not declare throws once the visitor has seen it,
- * since the walker cannot tell how many coords it consumes.
+ * A code `PATH_COMMANDS` does not declare throws once the visitor has seen it.
  */
-declare function forEachSegment(commands: ArrayLike<number>, coords: ArrayLike<number>, visit: (cmd: number, coordIndex: number, penX: number, penY: number, commandIndex: number) => void | boolean): void;
+declare function forEachSegment(commands: ArrayLike<number>, coords: ArrayLike<number>, visit: (cmd: number, coordIndex: number, penX: number, penY: number, commandIndex: number, opensSubpath: boolean) => void | boolean): void;
 
 /** Cubic Bezier point at parameter t (de Casteljau / Bernstein form). */
 declare function cubicEvalAt(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, t: number): [number, number];
@@ -236,13 +269,10 @@ declare function portCurvePoints(ax: number, ay: number, bx: number, by: number,
 
 /**
  * Bezier flattening — subdivide cubic and quadratic segments into polyline
- * approximations within a flatness tolerance. Used by hit-testing and
- * (eventually) any kernel that doesn't want to special-case curves.
+ * approximations within a flatness tolerance.
  *
- * The flatness metric is the maximum perpendicular distance from any
- * control point to the chord between endpoints. When that distance falls
- * below `tolerance`, the segment is "flat enough" and emitted as a single
- * line segment.
+ * The flatness metric is the maximum distance from any control point to the
+ * chord between endpoints.
  *
  * Tolerance is in world units. 0.5 is a sensible default for screen-rate
  * rendering at 1× zoom; consumers that zoom in heavily should pass a
@@ -258,16 +288,10 @@ declare function flattenCubic(x0: number, y0: number, x1: number, y1: number, x2
 /** Recursively subdivide a quadratic bezier (P0, P1, P2). */
 declare function flattenQuadratic(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, tolerance: number, out: number[]): void;
 /**
- * Like `flattenCubic` but also appends, for each new flattened point, its
- * arc-length fraction `t` (relative to the polyline distance accumulated so
- * far inside this curve) to `arcOut`. Caller then post-processes the segment's
- * `arcOut` range by dividing each by the segment's total flattened arc length
- * to yield t ∈ (0, 1].
- *
- * The returned values are *cumulative distance from the segment start*, not
- * normalized fractions. Two-pass design (accumulate, then divide) keeps the
- * recursive splitter simple — it doesn't need to know the total length up
- * front.
+ * 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].
  */
 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;
 /** Flatten a quadratic bezier into line segments within `tolerance`, appending
@@ -295,6 +319,15 @@ declare function segmentsCross(ax: number, ay: number, bx: number, by: number, c
 /** 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;
 
+/** Set whether a fill closes an open subpath, for every path that names no
+ *  `openFill` of its own. Starts at `'close'`. */
+declare function setDefaultOpenFill(rule: PathOpenFill): void;
+/** The rule a path with no `openFill` of its own follows. */
+declare function defaultOpenFill(): PathOpenFill;
+/** Whether `path`'s open subpaths fill, each closed by a straight edge back to
+ *  its start. What painting, area, and the filled-region hit tests all ask. */
+declare function fillsOpenSubpaths(path: PolygonPath): boolean;
+
 /**
  * Fluent builder for `PolygonPath`. Hides the `Uint8Array` / `Float32Array`
  * encoding behind move/line/curve/close calls and a final `build()`. Use
@@ -378,29 +411,10 @@ declare function linePath(a: {
 }): PolygonPath;
 
 /**
- * AABB bounds of a `Path`. Returned as `RectPath` for direct reuse with the
- * rect fast path machinery (selection AABB, area-select intersection).
- *
- * `RectPath` is its own bounds — O(1). For `PolygonPath`, walk segment by
- * segment, computing the tight bound per segment:
- *
- *   - `M` / `L`: just the endpoint.
- *   - `Q`: quadratic Bezier — endpoints plus axis-aligned extrema (one
- *     possible inflection per axis).
- *   - `C`: cubic Bezier — endpoints plus axis-aligned extrema (up to two
- *     possible inflections per axis, found via the quadratic formula on
- *     the derivative).
- *
- * Control points are NOT included directly; they're used only to compute
- * extrema that actually lie on the curve. This avoids the classic "AABB
- * extends past where the curve visibly reaches" bug for curved paths whose
- * control points poke outside the visible extent.
- *
- * Empty paths (no commands) return a zero-size rect anchored at the
- * origin — the convention used elsewhere in the kit for missing geometry.
+ * AABB of a `Path`, returned as a `RectPath` for direct reuse with rect-fast-path machinery.
+ * Control points are NOT included directly; they're used only to compute extrema that actually
+ * lie on the curve. Empty paths (no commands) return a zero-size rect anchored at the origin.
  */
-
-/** AABB of a `Path`, returned as a `RectPath` for direct reuse with rect-fast-path machinery. */
 declare function boundsOfPath(path: Path): RectPath;
 
 /**
@@ -438,18 +452,11 @@ 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.
+/** Apply an affine `Mat3` to a path's geometry. Never mutates the input.
  *
- * Axis-aligned maps (no rotation/shear, i.e. `m[1] === 0 && m[2] === 0`) keep a
- * `RectPath` a rect — the four corners stay axis-aligned, so we transform the
- * two diagonal corners and normalize negative extent (mirror). Rotation or
- * shear promotes the rect's four corners to a `PolygonPath`. Polygon paths map
- * every coord via the kernel's `transformCoords`, preserving the command stream
- * and `fillRule`. Never mutates the input.
- *
- * `Mat3` here is the 6-tuple `number[]` from `@weasel-js/geom` (DOMMatrix order:
- * `[a, b, c, d, e, f]` where `x' = a·x + c·y + e`, `y' = b·x + d·y + f`),
- * not the renderer's 9-element `Float32Array`. */
+ * 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;
 
 /**
@@ -468,24 +475,24 @@ declare function composePath(parent: Path, child: Path): Path;
 /** Inverse of `composePath` — undo `parent`'s translation from a world pose. */
 declare function decomposePath(parent: Path, world: Path): Path;
 
-/**
- * Split a `PolygonPath` at each `M` command, returning one `PolygonPath` per
- * subpath. Inverse-ish of compound-path construction: a multi-region
- * (compound) path becomes N independent paths.
- *
- * `fillRule` is propagated unchanged to every output. Even-odd compound paths
- * with interior "holes" lose the hole semantics — each subpath becomes its
- * own filled region. (Same behavior as Illustrator's Release Compound Path.)
- *
- * If the input has zero `M` commands (which would already be malformed) the
- * input is returned wrapped in a single-element array. A path with exactly
- * one subpath is also returned as a single-element array — a trivial pass.
- */
-
 /** Split a path into one path per subpath, cutting at each `M`. A path with a
- *  single subpath comes back as a one-element array. */
+ *  single subpath comes back as a one-element array. `fillRule` is propagated
+ *  unchanged, so even-odd compound paths with interior "holes" lose the hole
+ *  semantics — each subpath becomes its own filled region. */
 declare function splitSubpaths(path: PolygonPath): PolygonPath[];
 
+/** Whether any subpath of `path` lacks the `Z` that closes it. */
+declare function hasOpenSubpath(path: Path): boolean;
+/**
+ * `path` as two paths: the subpaths a `Z` closes, and those left open, each in
+ * the order `path` holds them and with its fill rules. A side with no subpaths
+ * is `null`. A fill that does not close an open subpath covers `closed` alone.
+ */
+declare function splitByClosure(path: PolygonPath): {
+    closed: PolygonPath | null;
+    open: PolygonPath | null;
+};
+
 /**
  * Contour orientation: which way a path winds, and the same path wound the
  * other way. Under `'nonzero'` two overlapping contours fill their overlap
@@ -497,7 +504,8 @@ declare function splitSubpaths(path: PolygonPath): PolygonPath[];
  * Signed area enclosed by `path`, summed over its contours. Positive for a
  * contour that turns clockwise on a y-down screen (the shoelace sign), so a
  * hole wound against its outer contour subtracts. An open contour counts as
- * closed by a straight edge back to its start, the way a fill closes it.
+ * closed by a straight edge back to its start where a fill closes it, and as
+ * nothing where one does not: see `fillsOpenSubpaths`.
  * Curved segments are integrated exactly, not through their control polygon.
  * A `RectPath` has no direction and counts as positive.
  */
@@ -513,31 +521,19 @@ declare function reversePath(path: PolygonPath): PolygonPath;
  * `pathFromD` — build a weasel `Path` from an **SVG path-data string** (the
  * value of SVG's `d` attribute, e.g. `"M0 0 L100 0 Z"`).
  *
- * This is the terse, declarative composition surface for geometry: a
- * consumer authors a shape as `d` and hands it straight to a scene/op API,
- * instead of chaining imperative builder calls. SVG `d` is deliberately the
- * language — it's a standard every consumer already knows, so the kit gets
- * path-language expressiveness without minting a new one. See
- * `docs/conventions.md` ("Compose scenes in a terse path language").
- *
  * Lowers every supported command (M/m L/l H/h V/v C/c S/s Q/q T/t A/a Z/z)
  * into weasel's `PathBuilder` primitives (move, line, cubic, quadratic,
- * close). Smooth (`S`/`s`/`T`/`t`) commands resolve their implicit reflected
- * control point from the previous cubic / quadratic. Arc commands (`A`/`a`)
- * convert to a series of cubic Bezier curves using the standard
- * endpoint-parameterization formulas (F.6.5 in the SVG spec): we reconstruct
- * the center, sweep angle, and a fixed number of (≤ 90°) cubic segments per
- * arc.
- *
- * No runtime dependency — a small hand-rolled parser. `@weasel-js/svg`'s
- * document parser (`parseSvg`) calls this for `<path d=…>` elements, so the
- * `d` grammar coverage is shared between the two entry points.
+ * close). Arc commands (`A`/`a`) convert to a series of cubic Bezier curves
+ * using the standard endpoint-parameterization formulas (F.6.5 in the SVG
+ * spec).
  */
 
 /**
  * Build a weasel `PolygonPath` from an SVG path-data (`d`) string. Unknown
  * command letters are skipped (and reported via `onWarn` when provided); the
- * builder still returns whatever valid commands preceded them.
+ * 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.
  */
 declare function pathFromD(d: string, onWarn?: (message: string) => void): ReturnType<PathBuilder['build']>;
 
@@ -607,19 +603,22 @@ declare function schneiderFit(samples: ReadonlyArray<Point>, errorTolerance: num
  * A `rect` path short-circuits to AABB arithmetic. A `polygon` path is its
  * filled region: beziers are flattened, `fillRule` is honored (default
  * `nonzero`), and every closed subpath counts — the hole of a donut is not
- * part of the shape under `evenodd`. Open subpaths enclose no area, so the
- * filled-region tests ignore them.
+ * part of the shape under `evenodd`. An open subpath counts as closed where a
+ * fill closes it and encloses nothing where one does not: see
+ * `fillsOpenSubpaths`.
  */
 
-type XY = {
-    x: number;
-    y: number;
-};
 /** Options for the path hit-tests. */
 interface PointInPathOptions {
     /** Bezier flattening tolerance in world units. Default 0.5. */
     tolerance?: number;
 }
+/** Options for {@link polygonIntersectsPath}. */
+interface PolygonIntersectsPathOptions extends PointInPathOptions {
+    /** False when nothing paints the path's interior: only its outline can meet
+     *  the polygon, and a polygon lying wholly inside meets nothing. Default true. */
+    filled?: boolean;
+}
 /** Options for {@link strokeHitTest}. */
 interface StrokeHitTestOptions {
     /** Bezier flattening tolerance in world units. Default 0.5. */
@@ -651,22 +650,23 @@ 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 XY[], opts?: PointInPathOptions): boolean;
+declare function pathContainsPolygon(path: Path, polygon: readonly Point[], opts?: PointInPathOptions): boolean;
 /** Returns true if `polygon` overlaps (intersects or is contained by) `path`. */
-declare function pathIntersectsPolygon(path: Path, polygon: readonly XY[], opts?: PointInPathOptions): boolean;
+declare function pathIntersectsPolygon(path: Path, polygon: readonly Point[], 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 XY[], path: Path, opts?: PointInPathOptions): boolean;
+declare function polygonContainsPath(polygon: readonly Point[], 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. Beziers are
+ * or the line of an open subpath, which encloses nothing. With `filled: false`
+ * a closed subpath is a line too. Beziers are
  * 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 XY[], path: Path, opts?: PointInPathOptions): boolean;
+declare function polygonIntersectsPath(polygon: readonly Point[], path: Path, opts?: PolygonIntersectsPathOptions): boolean;
 
 /**
  * Apply an affine to an interleaved coord stream, returning a fresh f64
@@ -676,6 +676,115 @@ declare function polygonIntersectsPath(polygon: readonly XY[], path: Path, opts?
  */
 declare function transformCoords(coords: ArrayLike<number>, m: Mat3): Float64Array;
 
+/**
+ * Ergonomic builders for tiny shape paths used by chrome / overlays / markers.
+ * They all return `PolygonPath`.
+ *
+ * Not appropriate for *user-drawn* shapes (those have a pose and live in the
+ * scene).
+ */
+
+/**
+ * N-segment polygon approximation of a circle. Default 32 segments → max
+ * radial deviation of ≈0.005·r (≈0.05 px at r=10). Bump higher for large
+ * filled circles where the facets become visible.
+ */
+declare function circlePath(cx: number, cy: number, r: number, segments?: number): PolygonPath;
+/** Axis-aligned square centred at (cx, cy) with side length `size`. */
+declare function squarePath(cx: number, cy: number, size: number): PolygonPath;
+/** Axis-aligned rectangle. Top-left at (x, y), width/height as given. */
+declare function rectMarkerPath(x: number, y: number, width: number, height: number): PolygonPath;
+/**
+ * Axis-aligned rounded rectangle. Top-left at (x, y); `r` is clamped to half
+ * the shorter side. Each corner is `cornerSamples` line segments — the
+ * default 8 gives the same angular resolution as `circlePath`'s 32.
+ */
+declare function roundRectPath(x: number, y: number, width: number, height: number, r: number, cornerSamples?: number): PolygonPath;
+
+/**
+ * 2D affine matrix utilities. Column-major 9 elements, matching
+ * `WebGL2RenderingContext.uniformMatrix3fv` element order so an upload needs
+ * no transpose flag.
+ *
+ * Layout (column-major):
+ *   [m00, m10, 0,
+ *    m01, m11, 0,
+ *    tx,  ty,  1]
+ */
+
+/**
+ * A 2D affine transform as a column-major 9-element array, laid out as above.
+ *
+ * Every matrix the kit builds is a `Float64Array`: a view translation far
+ * from the origin at high zoom needs more than a float32's 24 bits to hold a
+ * fraction of a pixel. A `Float32Array` is accepted wherever one is read.
+ * `mat3.toUniform` makes the float32 copy a GL uniform upload wants.
+ */
+type GlMat3 = Float32Array | Float64Array;
+declare function identity(): GlMat3;
+declare function multiply(out: GlMat3, m: GlMat3): GlMat3;
+/** `m · T(tx, ty)`: composes onto `m`, where `@weasel-js/geom`'s `translate`
+ *  constructs a fresh matrix. */
+declare function translated(m: GlMat3, tx: number, ty: number): GlMat3;
+/** `m · S(sx, sy)`: composes onto `m`, where geom's `scale` constructs one. */
+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;
+/** The kernel's affine in this layout. The inverse of {@link toAffine}. */
+declare function fromAffine(a: Mat3): 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;
+/** A float32 copy of `m`, for `uniformMatrix3fv` or a shader uniform value. */
+declare function toUniform(m: GlMat3): Float32Array;
+declare function apply(m: GlMat3, x: number, y: number): [number, number];
+/**
+ * Map screen pixel coords (0..width on X, 0..height on Y, top-left origin)
+ * into clip space (-1..1 on X, 1..-1 on Y — note Y flip so screen-down
+ * matches clip-down).
+ */
+declare function screenToClip(width: number, height: number): GlMat3;
+/**
+ * Uniform-equivalent scale factor: the square root of the absolute
+ * determinant of the linear part, i.e. the geometric mean of the two axis
+ * scales. Rotation-invariant. Under non-uniform scale it is between the two
+ * axes and exact on neither — the same compromise `meanScale` documents.
+ */
+declare function meanScaleOf(m: GlMat3): number;
+/** The least any direction is scaled by the linear part — its smaller singular
+ *  value. What a screen length is worth in world units, at most. */
+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. */
+declare const mat3: {
+    identity: typeof identity;
+    toAffine: typeof toAffine;
+    fromAffine: typeof fromAffine;
+    multiply: typeof multiply;
+    translated: typeof translated;
+    scaled: typeof scaled;
+    invert: typeof invert;
+    toUniform: typeof toUniform;
+    apply: typeof apply;
+    screenToClip: typeof screenToClip;
+    meanScaleOf: typeof meanScaleOf;
+    minScaleOf: typeof minScaleOf;
+};
+
+/**
+ * Build the world→screen transform matrix for a `View`.
+ * Use as the `transform` field of a `kind: 'group'` DrawCommand to wrap
+ * world-space content emitted from a layer `draw` implementation.
+ *
+ * Mapping: `screen = (world − {view.x, view.y}) × {view.scale.x, view.scale.y}`.
+ *
+ * Column-major layout (matches `mat3.identity()`):
+ * `[scale.x, 0, 0,  0, scale.y, 0,  -view.x*scale.x, -view.y*scale.y, 1]`.
+ */
+declare function viewToMat3(view: View): GlMat3;
+
 /** Which side of the anchor the overlay sits on. */
 type PlacementSide = 'top' | 'bottom' | 'left' | 'right';
 /** How the overlay lines up along the side it sits on. */
@@ -867,4 +976,391 @@ declare function cubicBezierEasing(x1: number, y1: number, x2: number, y2: numbe
 /** Resolve a spec to the function that shapes progress. `undefined` is linear. */
 declare function resolveEasing(spec?: EasingSpec): EasingFn;
 
-export { type BezierEasing, type Box, type CubicCoords, type CurveNearest, DEFAULT_FLATTEN_TOLERANCE, EASINGS, EPS, type EasingFn, type EasingName, type EasingSpec, type LineCoords, type Mat3, PATH_C, PATH_CMD_LENGTHS, PATH_COMMANDS, PATH_L, PATH_M, PATH_Q, PATH_Z, Path, PathBuilder, type PathCommandCode, type PathCommandName, PathFillRule, type PathNearest, type PathStation, type PlaceRectOptions, type PlacedRect, type Placement, type PlacementAlign, type PlacementSide, Point, type PointAlongPathOptions, type PointInPathOptions, PolygonPath, type QuadraticCoords, type Rect, RectPath, SPRING_PRESETS, type SpringPreset, type SpringPresetName, type StrokeHitTestOptions, applyToPoint, approxEq, boundsOfCoords, boundsOfPath, boxContainsBox, boxContainsPoint, boxToBox, clampRectWithin, composePath, cross, cubicBezierEasing, cubicBounds, cubicEvalAt, decomposePath, 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, elevateQuadraticToCubic, ellipsePath, flattenCubic, flattenCubicWithArcLen, flattenQuadratic, flattenQuadraticWithArcLen, forEachSegment, identity, invert, len2, linePath, linear, multiply, nearestOnCubic, nearestOnLine, nearestOnPath, nearestOnQuadratic, pathCommandCoordCount, pathContainsPoint, pathContainsPolygon, pathContainsRect, pathDistanceToPoint, pathFromD, pathIntersectsPolygon, pathIntersectsRect, pathSignedArea, placeRect, pointAlongPath, pointInPath, pointInPolygon, pointSegmentDist2, polygonContainsPath, polygonFromPoints, polygonIntersectsPath, polylineFromPoints, portControls, portCurvePoints, quadraticEvalAt, rectPath, rectToContour, regularPolygonPath, resolveEasing, reversePath, rotate, rotateAboutPoint, scale, scalePathToBounds, schneiderFit, segmentsCross, sign, splitCubicAt, splitLineAt, splitQuadraticAt, splitSubpaths, starPath, strokeHitTest, sub, transformCoords, transformPath, translate, translatePath, unionBoundsPath, unionBox };
+/**
+ * Geometric mean of a per-axis scale's magnitudes, so a flipped (negative)
+ * axis counts by its size.
+ *
+ * **Not for hit-testing.** A screen-pixel length is not one world distance
+ * under non-uniform zoom, and collapsing it to a scalar makes a pickable
+ * region too generous on one axis and too mean on the other. Use `pxExtent`
+ * for a per-axis world length, or `withinPxBox` / `withinPxRadius` to compare
+ * in screen space directly. Nor for placing chrome or measuring a pick slop:
+ * `standoff` and `strokeHitTest`'s `slop` work on screen.
+ *
+ * What legitimately remains is a stroke width for a line that is not
+ * axis-aligned: the renderer resolves a `{ px }` width through this same
+ * mean, so a picker reading ink widths must too.
+ */
+declare function meanScale(s: {
+    x: number;
+    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;
+    cy: number;
+    rotation: number;
+}
+/**
+ * Resolve a pose's rotation transform, or `null` when the pose carries no
+ * effective rotation. Non-null requires a nonzero `rotation` **and** all four
+ * AABB fields (`x`, `y`, `width`, `height`) — the pivot is the unrotated AABB
+ * center.
+ */
+declare function poseRotationOf(pose: unknown): PoseRotation | null;
+/**
+ * Rotate every coordinate of `path` about `(cx, cy)` by `rotation` radians.
+ * A `rect` promotes to a four-corner polygon (axis-aligned rects can't encode
+ * rotation). Returns a fresh `PolygonPath`; never mutates the input.
+ */
+declare function rotatePathAround(path: Path, cx: number, cy: number, rotation: number): PolygonPath;
+
+/**
+ * The one composition of a box pose into the matrix that carries its own
+ * frame to its parent's: the rotation convention of `poseRotationOf`, and the
+ * pose's residual `transform` inside it. Painting, culling, silhouettes, and
+ * picking all read a pose through `poseFrameOf` so they agree on where the
+ * node is.
+ */
+
+/**
+ * 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
+ * box center to what the node draws in its unrotated box, before the
+ * rotation. Absent is the identity.
+ */
+type PoseLinear = readonly [a: number, b: number, c: number, d: number];
+/** `transform` when it changes anything, `null` for absent or the identity. */
+declare function poseLinearOf(pose: unknown): PoseLinear | null;
+/**
+ * The matrix taking a point in the pose's own unrotated box frame to where
+ * the node draws it: `rotate(rotation) · transform`, about the box center.
+ * `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;
+/**
+ * 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;
+/** `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;
+}
+/** 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 through the gap (`fitCubicThroughDeletion`)
+ * so the path keeps its shape instead of snapping to a straight line.
+ *
+ * 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[];
+
+/**
+ * Anchor lookup across several paths, measured on screen: which existing
+ * anchor is nearest a point, and whether it ends an open subpath. Feeds the
+ * pen's anchor snapping and its pick-up of an open path's endpoint.
+ */
+
+/** An existing anchor found near a point. */
+interface PathAnchorHit {
+    /** The id the path was supplied under. */
+    id: string;
+    /** Subpath index, then anchor index within that subpath. */
+    sub: number;
+    idx: number;
+    x: number;
+    y: number;
+    /** Which end of an open subpath this anchor is, or null when it is an
+     *  interior anchor or its subpath is closed. A lone anchor reads `'last'`. */
+    end: 'first' | 'last' | null;
+}
+/**
+ * The anchor nearest `point` within a screen-space circle of radius `px`,
+ * across every subpath of every path in `paths`. Paths and `point` share one
+ * world frame; `scale` is the view's, so the radius stays round under
+ * non-uniform zoom. `accept` narrows the candidates (endpoints only, say).
+ * Ties go to the earlier path, so pass paths front-to-back.
+ */
+declare function nearestPathAnchor(paths: Iterable<{
+    id: string;
+    path: PolygonPath;
+}>, point: {
+    x: number;
+    y: number;
+}, px: number, scale: Scale2, accept?: (hit: PathAnchorHit) => boolean): PathAnchorHit | null;
+/** Reverse a subpath's direction without changing its shape: the anchor
+ *  order flips and each anchor's in and out handles trade places. */
+declare function reverseAnchors<A extends PenAnchor>(anchors: readonly A[]): A[];
+
+/**
+ * Project a leaf path from its source frame into world coordinates given a
+ * `{x, y, width, height, rotation?}` pose.
+ *
+ * RectPaths can't carry rotation as-is (they're axis-aligned by definition);
+ * a non-zero `pose.rotation` on a rect promotes the result to a polygon so
+ * the four corners are baked into world coords.
+ */
+
+/** Subset of pose fields this helper consumes: `x/y/width/height` define an
+ *  AABB whose unrotated center is the rotation pivot. */
+interface PathInWorldPose {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    rotation?: number;
+    transform?: PoseLinear;
+}
+/**
+ * Project a stored path into the pose's **local frame**: rebase its AABB onto
+ * the pose box. It does NOT apply `pose.rotation`; `pathInWorld` composes
+ * this with the rotation wrap.
+ *
+ * Rects rebase onto the pose's `width`/`height` because resize updates the pose,
+ * not the stored `RectPath` — so the live size lives on the pose.
+ */
+declare function pathInPoseFrame(path: Path, pose: PathInWorldPose): Path;
+/**
+ * Bake `pose` into `path`'s coordinates so the returned path is positioned
+ * in world space. Returns a fresh `Path` instance; never mutates inputs.
+ */
+declare function pathInWorld(path: Path, pose: PathInWorldPose): Path;
+/**
+ * Inverse of `pathInWorld` for a path in **world** space: the stored path
+ * in the pose's own frame plus the pose that draws it there. The pose's
+ * `rotation` and `transform` are preserved, and its AABB fields are fit to
+ * the result. The new box's center is placed where the old frame carries it,
+ * since the pivot moves with the box: `pathInWorld(result.path, result.pose)`
+ * reproduces `worldPath` whether or not its bounds changed.
+ */
+declare function worldEditToStorage<P extends PathInWorldPose>(pose: P, worldPath: PolygonPath): {
+    pose: P;
+    path: PolygonPath;
+};
+declare function worldEditToStorage<P extends PathInWorldPose>(pose: P, worldPath: Path): {
+    pose: P;
+    path: Path;
+};
+
+/** The constructor of each typed array of numbers, under the tag its type is written by. */
+declare const TYPED_ARRAY_CONSTRUCTORS: {
+    readonly i8: Int8ArrayConstructor;
+    readonly u8: Uint8ArrayConstructor;
+    readonly u8c: Uint8ClampedArrayConstructor;
+    readonly i16: Int16ArrayConstructor;
+    readonly u16: Uint16ArrayConstructor;
+    readonly i32: Int32ArrayConstructor;
+    readonly u32: Uint32ArrayConstructor;
+    readonly f32: Float32ArrayConstructor;
+    readonly f64: Float64ArrayConstructor;
+};
+/** The name a typed array's type is written under. */
+type TypedArrayTag = keyof typeof TYPED_ARRAY_CONSTRUCTORS;
+/** A typed array of numbers: what a `Path` keeps its commands and coords in. */
+type NumberTypedArray = InstanceType<(typeof TYPED_ARRAY_CONSTRUCTORS)[TypedArrayTag]>;
+/** A typed array as JSON holds it: its type's tag and its numbers. */
+interface TaggedTypedArray {
+    __ta: TypedArrayTag;
+    data: number[];
+}
+/** `value` as a tag and its numbers where it is a typed array of numbers, else `undefined`. */
+declare function tagTypedArray(value: unknown): TaggedTypedArray | undefined;
+/** The typed array a `TaggedTypedArray` describes, or `undefined` for anything else. */
+declare function untagTypedArray(value: unknown): NumberTypedArray | undefined;
+/**
+ * A copy of `value` that `JSON.stringify` writes whole: every typed array in it, at any
+ * depth of arrays and plain objects, becomes a `TaggedTypedArray`. A `Path` goes through it
+ * to be saved, and `reviveTypedArrays` reads it back.
+ */
+declare function tagTypedArrays(value: unknown): unknown;
+/** A copy of `value` with every `TaggedTypedArray` in it a typed array again: what
+ *  `JSON.parse` answered for something `tagTypedArrays` or `typedArrayReplacer` wrote. */
+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 };