@pixerate/editor 0.37.0 → 0.39.0

package/dist/{stroke-ysgaPpAo.d.ts → pathfinder-D98S2lV5.d.ts}

@@ -671,6 +671,48 @@ declare function dividePaths(operands: PathOperandInput[], options?: PathOpsOpti
 declare function normalizeBezierPath(path: BezierPathInput, fillRule?: PolygonFillRule, options?: PathOpsOptions): BezierPath;
 /** Filled area of a path under its fill rule (overlaps counted once; exact for curves). */
 declare function bezierPathArea(path: BezierPathInput, fillRule?: PolygonFillRule, options?: PathOpsOptions): number;
+/** One edge of `planarSplit`: a piece of an input segment between two vertices. */
+interface PlanarSplitEdge {
+    /** Vertex indices at the start and end of `pts`. */
+    a: number;
+    b: number;
+    /** Control points from vertex `a` to vertex `b`. */
+    pts: Point[];
+    /** Inputs whose chains run along this edge, ascending (several where outlines coincide). */
+    operands: number[];
+    /** The source segment it is a piece of (index into `sources`) and its parameters there at `a` and `b`. */
+    src: number;
+    sa: number;
+    sb: number;
+}
+interface PlanarSplitResult {
+    vertices: Point[];
+    edges: PlanarSplitEdge[];
+    /** The input segments, as `src` refers to them. */
+    sources: BezierSegment[];
+    eps: number;
+    scale: number;
+}
+/**
+ * The chains of every input (open or closed, as given: nothing is closed for filling) split
+ * wherever they cross or touch each other or themselves, with the same intersection search as
+ * the boolean operations. Coincident pieces become one edge that lists every input along it.
+ * Throws a `PathOpsError` when the search does not settle or the input is not finite.
+ */
+declare function planarSplit(inputs: readonly (readonly (readonly BezierSegment[])[])[], options?: PathOpsOptions): PlanarSplitResult;
+/** Result of `pathBooleanSelect`: per selector, its connected parts (each an outer subpath with its holes). */
+interface PathSelectResult extends PathOpsReport {
+    parts: BezierPath[][];
+}
+/**
+ * Several boolean selections over one arrangement of the operands (the Pathfinder panel's
+ * Trim, Merge, Crop and Minus Back are each a selection per output). A selector gets the
+ * ascending indices of the operands covering an area and keeps the area when it returns true.
+ * Each selection comes back as its connected parts, largest first, built as `pathBoolean`
+ * builds its result; areas that only touch at an edge are one part. Falls back to the
+ * polygon engine like `pathBoolean`.
+ */
+declare function pathBooleanSelect(operands: PathOperandInput[], selectors: readonly ((covering: readonly number[]) => boolean)[], options?: PathOpsOptions): PathSelectResult;
 
 /**
  * Offset Path and Outline Stroke on Bézier paths.
@@ -758,4 +800,213 @@ declare function outlineStroke(input: BezierPathInput, options: OutlineStrokeOpt
  */
 declare function offsetPath(input: BezierPathInput, distance: number, options?: OffsetPathOptions): BezierPath;
 
-export { type SvgGradientStop as $, type AffineMatrix as A, type BezierPathInput as B, type CanvasGradientDef as C, type DashedPath as D, type EllipseShape as E, type FlattenOptions as F, type GetShapeRenderDataOptions as G, type PathShape as H, type PolygonBooleanOperation as I, type PolygonBooleanOptions as J, type PolygonInput as K, type PolygonOperand as L, type MultiPolygon as M, type PolygonPiece as N, type OffsetPathOptions as O, type PolygonFillRule as P, type PolygonToPathOptions as Q, type PolygonWithHoles as R, type SvgGradientDef as S, type RectShape as T, type RegularPolygonShape as U, SHAPE_KINDS as V, type SegmentIntersection as W, type ShapeKind as X, type ShapePaint as Y, type ShapeRenderData as Z, type StarShape as _, type BezierPath as a, unionPolygons as a$, angleToSvgLinearCoords as a0, arcToCubics as a1, bezierPathArea as a2, bezierPathBounds as a3, bezierPathLength as a4, bezierPathPointAtLength as a5, bezierPathSignedArea as a6, bezierPathToSvg as a7, closeContour as a8, contourSignedArea as a9, pointInMultiPolygon as aA, pointInRings as aB, polygonArea as aC, polygonBoolean as aD, polygonToSvgPath as aE, resolveCanvasGradient as aF, ringSignedArea as aG, segmentBounds as aH, segmentCurvature as aI, segmentDerivative as aJ, segmentExtrema as aK, segmentIntersections as aL, segmentLength as aM, segmentNearest as aN, segmentParamAtLength as aO, segmentPoint as aP, segmentTangent as aQ, shapeToPolygon as aR, simplifyRing as aS, splitSegment as aT, strokeOutlineRings as aU, subSegment as aV, subtractPaths as aW, subtractPolygons as aX, toBezierPath as aY, transformBezierPath as aZ, trimSegments as a_, contoursToPath as aa, countPathSegments as ab, dashContours as ac, distanceToBezierPath as ad, dividePaths as ae, dividePolygons as af, excludePaths as ag, flattenSvgPath as ah, formatNumber as ai, getShapeRenderData as aj, getShapeSvg as ak, gradientToSvgDef as al, intersectPaths as am, intersectPolygons as an, isCanvasGradient as ao, isShapeDescription as ap, multiPolygonArea as aq, multiPolygonBounds as ar, normalizeBezierPath as as, offsetPath as at, outlineStroke as au, parseCssGradient as av, parseSvgPath as aw, pathBoolean as ax, pathToContours as ay, pointInBezierPath as az, type StrokeJoin as b, unitePaths as b0, windingNumber as b1, xorPolygons as b2, type StrokeCap as c, type ShapeDescription as d, type PolygonRing as e, type ShapeSize as f, type BezierCommand as g, type BezierContour as h, type BezierPathToSvgOptions as i, type BezierSegment as j, CANVAS_GRADIENT_PRESETS as k, type CanvasLinearGradient as l, type CanvasRadialGradient as m, type DividePathsResult as n, type GradientStop as o, type OutlineStrokeOptions as p, type PathBooleanOperation as q, type PathBooleanResult as r, type PathCommand as s, type PathOperand as t, type PathOperandInput as u, PathOpsError as v, type PathOpsOptions as w, type PathOpsReport as x, type PathPiece as y, type PathPointAtLength as z };
+/**
+ * Planar maps: the faces and edges a set of paths divides the plane into (Shape Builder, fill
+ * regions, Pathfinder Outline).
+ *
+ * Unlike `dividePaths`, which splits the *filled areas* of closed shapes, every path here is an
+ * edge, open ones included: three crossing lines enclose a triangle, a line across a rectangle
+ * splits it in two, and an area enclosed by paths is a face whether or not anything fills it.
+ *
+ * 1. `planarSplit` (the boolean engine's intersection search) cuts every input segment wherever
+ *    it meets another one; coincident pieces become one edge.
+ * 2. Each edge gives two half-edges. Around every vertex the half-edges leaving it are sorted by
+ *    the direction in which they cross a small circle around it (half the shortest edge there),
+ *    which orders tangent curves correctly.
+ * 3. A face walk takes, at each vertex, the half-edge just clockwise of the way back — the
+ *    sharpest left turn. Bounded faces come out counter-clockwise (positive area in a y-up
+ *    frame), the outer boundary of every connected piece clockwise; spurs (loose line ends) are
+ *    dropped. Each outer boundary becomes a hole of the smallest face of another piece around
+ *    it, so nesting is decided face by face, never by an even-odd rule over the whole network.
+ * 4. Faces learn which inputs fill them from a point well inside each face.
+ *
+ * Adjacency is kept in per-vertex lists and half-edge slots (no scans over all edges per step).
+ *
+ * Ported from vectorcraft-main/crates/pathops/src/planar.rs (`map`, `Map::merge`, `build`,
+ * `interior_point`, `without_spurs`, `leaving_angle`, `cut_out`), figcraft-main/crates/doc/src/vector_faces.rs
+ * (`faces`: half-edge walk with an angle-sorted next edge, the winding deciding inside or
+ * outside) and cadcraft-main/crates/geom/src/region.rs (`enclosing_loop`, `boundary_at_gap`:
+ * a ray from the point, the sharpest left turn, islands as holes, gaps between open ends
+ * closed). MIT OR Apache-2.0, © ArtCraft Team and contributors. See THIRD_PARTY_NOTICES.md.
+ */
+
+/** One input of a planar map. */
+interface PlanarInput {
+    /** Its subpaths: closed ones bound faces and the area the input fills, open ones are edges only. */
+    path: BezierPathInput;
+    /** How its closed subpaths fill (default `nonzero`). */
+    fillRule?: PolygonFillRule;
+    /** Whether its closed subpaths count as filling the faces inside them (default true). */
+    fills?: boolean;
+}
+interface PlanarMapOptions extends PathOpsOptions {
+    /**
+     * Close gaps up to this distance between loose ends (vertices with one edge): each one joins
+     * the nearest other loose end within reach by a straight edge (default 0, off).
+     */
+    gap?: number;
+    /** Most input segments mapped (default 4096); a bigger input gives no map. */
+    maxSegments?: number;
+}
+/** A bounded face: an outer outline with the holes other pieces of the map make in it. */
+interface PlanarFace {
+    /** Outer subpath (counter-clockwise in a y-up frame) followed by its holes (clockwise). */
+    path: BezierPath;
+    /** Area (holes taken out). */
+    area: number;
+    bounds: {
+        minX: number;
+        minY: number;
+        maxX: number;
+        maxY: number;
+    };
+}
+/** A run of edges between junctions (vertices where paths meet or a path ends). */
+interface PlanarChain {
+    segments: BezierSegment[];
+    /** A loop with no junction on it. */
+    closed: boolean;
+    /** The input it lies on: the front-most (highest index) where several coincide. */
+    source: number;
+}
+/**
+ * A point strictly inside a filled path (nonzero), well away from its edges where it can be:
+ * the middle of the widest span of a few horizontal lines through it. Null for an empty path.
+ * Ported from vectorcraft's `interior_point` (cadcraft's `interior_point` for polygons).
+ */
+declare function interiorPoint(path: BezierPathInput | readonly (readonly BezierSegment[])[]): Point | null;
+/**
+ * The planar map of a set of paths. Build it with `PlanarMap.build`; faces, chains and fills
+ * are computed on first use.
+ */
+declare class PlanarMap {
+    readonly vertices: Point[];
+    private readonly edges;
+    private readonly sources;
+    readonly eps: number;
+    readonly inputCount: number;
+    private readonly around;
+    private readonly slot;
+    private readonly component;
+    private cyclesCache;
+    private sourcesCache;
+    private readonly fills;
+    private constructor();
+    /**
+     * Maps `inputs` (their subpaths as given: open ones stay open). Null when they cannot be mapped
+     * (non-finite points, more than `maxSegments` segments or an intersection search that does
+     * not settle) or have no edges.
+     */
+    static build(inputs: readonly PlanarInput[], options?: PlanarMapOptions): PlanarMap | null;
+    private origin;
+    private halfPts;
+    /** The half-edge after `h` on the face to its left: the sharpest left turn at its end. */
+    private next;
+    /** Direction (angle) in which half-edge `h`, leaving `at`, first gets `r` away from it. */
+    private leavingAngle;
+    /** Segments of a run of half-edges (a loop unless `closed` is false), pieces of one input segment joined again. */
+    private cycleSegments;
+    private cycles;
+    private faceChains;
+    /** The bounded faces of the map. */
+    get faces(): PlanarFace[];
+    /** The inputs whose fill covers face `i`, ascending (empty for an area only outlines enclose). */
+    faceSources(i: number): number[];
+    /** A point well inside face `i`. */
+    faceInterior(i: number): Point | null;
+    /** The face under `p` (the smallest one around it), or -1. */
+    faceAt(p: Point): number;
+    /**
+     * The union of faces, traced along the map's own edges: those between two merged faces drop
+     * out exactly, so no seam or sliver is left where a boolean union of their outlines could
+     * round shared corners apart. Outer subpaths come out counter-clockwise (y-up), holes clockwise.
+     */
+    merge(faceIndices: readonly number[]): BezierPath;
+    /**
+     * The edges joined into runs between junctions: vertices where other than two edges meet, or
+     * where the two edges lie on different inputs. Each run is keyed by its input.
+     */
+    chains(): PlanarChain[];
+    /**
+     * The region enclosing `p`, traced as cadcraft does it: a ray from `p` towards +x meets the
+     * edges in order; for each, the half-edge with `p` on its left is followed by always taking the
+     * sharpest left turn, until a loop that runs counter-clockwise round `p` comes back. The pieces
+     * of the map nested inside that loop (islands) become its holes. Null when nothing encloses `p`.
+     */
+    regionAt(p: Point): BezierPath | null;
+}
+/** Whether a contour, closed, encloses an area (rather than retracing itself). */
+declare function contourEnclosesArea(contour: BezierContour): boolean;
+/**
+ * `path` without `piece`, a run along one of its subpaths between two points (a Shape Builder
+ * edge from `PlanarMap.chains`): a closed subpath opens there, an open one splits in two (or
+ * loses an end), and a piece that runs all the way round (`closed`, or ending where it starts)
+ * takes its subpath with it. With `fillCloses`, open subpaths that enclose an area run on round
+ * an invisible closing edge, as the Shape Builder sees a filled path: a piece may run over it,
+ * and it never comes back as a visible segment. Null when the piece does not lie on `path`
+ * within `tol`.
+ *
+ * Ported from vectorcraft-main/crates/pathops/src/planar.rs (`cut_out`, `nearest_u`, `span`,
+ * `snap_ends`). MIT OR Apache-2.0, © ArtCraft Team and contributors. See THIRD_PARTY_NOTICES.md.
+ */
+declare function cutOutPiece(path: BezierPathInput, piece: {
+    segments: readonly BezierSegment[];
+    closed?: boolean;
+}, fillCloses: boolean, tol: number): BezierPath | null;
+
+/**
+ * The Pathfinder panel's dividing operations over a stack of shapes (index 0 at the back):
+ * Divide, Trim, Merge, Crop, Outline and Minus Back. (Unite, Minus Front, Intersect and Exclude
+ * are `pathBoolean`.) Every result carries the index of the shape whose paint it keeps.
+ *
+ * The filled areas come from one arrangement of all shapes (`dividePaths`, `pathBooleanSelect`):
+ * each area knows the shapes covering it, so an operation is a choice of areas per result.
+ * Outline and Divide with cutting lines use the planar map (`PlanarMap`).
+ *
+ * Ported from vectorcraft-main/crates/pathops/src/pathfinder.rs (`pathfinder`, `PathfinderOp`,
+ * `outline_edges`), MIT OR Apache-2.0, © ArtCraft Team and contributors. See
+ * THIRD_PARTY_NOTICES.md.
+ */
+
+type PathfinderOperation = 'divide' | 'trim' | 'merge' | 'crop' | 'outline' | 'minusBack';
+declare const PATHFINDER_OPERATIONS: readonly PathfinderOperation[];
+/** A shape of the stack. */
+interface PathfinderShape {
+    /** Its outline; open subpaths are closed for filling (unless `line`). */
+    path: BezierPathInput;
+    fillRule?: PolygonFillRule;
+    /** Identifies its paint: Merge joins touching areas whose shapes share a key (default: the index). */
+    key?: string | number;
+    /**
+     * An unfilled open path: a cutting edge for Divide, splitting the faces it crosses without
+     * becoming one (ignored by the other operations).
+     */
+    line?: boolean;
+}
+/** One result: a filled area (or an open stroke for Outline). */
+interface PathfinderPiece {
+    path: BezierPath;
+    /** Index of the shape whose paint it keeps. */
+    source: number;
+    /** Outline edges are open paths (a loop with no junction on it stays closed). */
+    open?: boolean;
+}
+interface PathfinderResult extends PathOpsReport {
+    pieces: PathfinderPiece[];
+}
+/**
+ * Runs a Pathfinder operation:
+ * - `divide`: every face of the arrangement becomes its own piece, painted like the top-most
+ *   shape covering it. `line` shapes cut the faces they cross.
+ * - `trim`: hidden parts are removed; one piece per shape that stays visible, nothing merged.
+ * - `merge`: like Trim, then touching or overlapping visible parts of shapes with the same key
+ *   become one piece (one per connected area).
+ * - `crop`: the top shape crops the others; it is removed, the visible parts of the shapes below
+ *   inside it stay.
+ * - `outline`: every outline is cut where it meets another; the pieces are open paths painted
+ *   like the shape they bound (the top-most where outlines coincide).
+ * - `minusBack`: the top shape minus everything behind it.
+ */
+declare function pathfinder(op: PathfinderOperation, shapes: readonly PathfinderShape[], options?: PathOpsOptions): PathfinderResult;
+
+export { type PolygonInput as $, type AffineMatrix as A, type BezierPathInput as B, type CanvasGradientDef as C, type DashedPath as D, type EllipseShape as E, type FlattenOptions as F, type GetShapeRenderDataOptions as G, type PathOpsOptions as H, type PathOpsReport as I, type PathPiece as J, type PathPointAtLength as K, type PathSelectResult as L, type MultiPolygon as M, type PathShape as N, type OffsetPathOptions as O, PlanarMap as P, type PathfinderPiece as Q, type PathfinderResult as R, type SvgGradientDef as S, type PlanarChain as T, type PlanarFace as U, type PlanarInput as V, type PlanarMapOptions as W, type PlanarSplitEdge as X, type PlanarSplitResult as Y, type PolygonBooleanOperation as Z, type PolygonBooleanOptions as _, type BezierPath as a, segmentCurvature as a$, type PolygonOperand as a0, type PolygonPiece as a1, type PolygonToPathOptions as a2, type PolygonWithHoles as a3, type RectShape as a4, type RegularPolygonShape as a5, SHAPE_KINDS as a6, type SegmentIntersection as a7, type ShapeKind as a8, type ShapePaint as a9, gradientToSvgDef as aA, interiorPoint as aB, intersectPaths as aC, intersectPolygons as aD, isCanvasGradient as aE, isShapeDescription as aF, multiPolygonArea as aG, multiPolygonBounds as aH, normalizeBezierPath as aI, offsetPath as aJ, outlineStroke as aK, parseCssGradient as aL, parseSvgPath as aM, pathBoolean as aN, pathBooleanSelect as aO, pathToContours as aP, pathfinder as aQ, planarSplit as aR, pointInBezierPath as aS, pointInMultiPolygon as aT, pointInRings as aU, polygonArea as aV, polygonBoolean as aW, polygonToSvgPath as aX, resolveCanvasGradient as aY, ringSignedArea as aZ, segmentBounds as a_, type ShapeRenderData as aa, type StarShape as ab, type SvgGradientStop as ac, angleToSvgLinearCoords as ad, arcToCubics as ae, bezierPathArea as af, bezierPathBounds as ag, bezierPathLength as ah, bezierPathPointAtLength as ai, bezierPathSignedArea as aj, bezierPathToSvg as ak, closeContour as al, contourEnclosesArea as am, contourSignedArea as an, contoursToPath as ao, countPathSegments as ap, cutOutPiece as aq, dashContours as ar, distanceToBezierPath as as, dividePaths as at, dividePolygons as au, excludePaths as av, flattenSvgPath as aw, formatNumber as ax, getShapeRenderData as ay, getShapeSvg as az, type StrokeJoin as b, segmentDerivative as b0, segmentExtrema as b1, segmentIntersections as b2, segmentLength as b3, segmentNearest as b4, segmentParamAtLength as b5, segmentPoint as b6, segmentTangent as b7, shapeToPolygon as b8, simplifyRing as b9, splitSegment as ba, strokeOutlineRings as bb, subSegment as bc, subtractPaths as bd, subtractPolygons as be, toBezierPath as bf, transformBezierPath as bg, trimSegments as bh, unionPolygons as bi, unitePaths as bj, windingNumber as bk, xorPolygons as bl, type StrokeCap as c, type BezierSegment as d, type PathfinderOperation as e, type PathfinderShape as f, type ShapeDescription as g, type PolygonFillRule as h, type PolygonRing as i, type ShapeSize as j, type BezierCommand as k, type BezierContour as l, type BezierPathToSvgOptions as m, CANVAS_GRADIENT_PRESETS as n, type CanvasLinearGradient as o, type CanvasRadialGradient as p, type DividePathsResult as q, type GradientStop as r, type OutlineStrokeOptions as s, PATHFINDER_OPERATIONS as t, type PathBooleanOperation as u, type PathBooleanResult as v, type PathCommand as w, type PathOperand as x, type PathOperandInput as y, PathOpsError as z };

package/dist/{stroke-CWjFKal4.d.cts → pathfinder-DKRcXiLS.d.cts}

@@ -671,6 +671,48 @@ declare function dividePaths(operands: PathOperandInput[], options?: PathOpsOpti
 declare function normalizeBezierPath(path: BezierPathInput, fillRule?: PolygonFillRule, options?: PathOpsOptions): BezierPath;
 /** Filled area of a path under its fill rule (overlaps counted once; exact for curves). */
 declare function bezierPathArea(path: BezierPathInput, fillRule?: PolygonFillRule, options?: PathOpsOptions): number;
+/** One edge of `planarSplit`: a piece of an input segment between two vertices. */
+interface PlanarSplitEdge {
+    /** Vertex indices at the start and end of `pts`. */
+    a: number;
+    b: number;
+    /** Control points from vertex `a` to vertex `b`. */
+    pts: Point[];
+    /** Inputs whose chains run along this edge, ascending (several where outlines coincide). */
+    operands: number[];
+    /** The source segment it is a piece of (index into `sources`) and its parameters there at `a` and `b`. */
+    src: number;
+    sa: number;
+    sb: number;
+}
+interface PlanarSplitResult {
+    vertices: Point[];
+    edges: PlanarSplitEdge[];
+    /** The input segments, as `src` refers to them. */
+    sources: BezierSegment[];
+    eps: number;
+    scale: number;
+}
+/**
+ * The chains of every input (open or closed, as given: nothing is closed for filling) split
+ * wherever they cross or touch each other or themselves, with the same intersection search as
+ * the boolean operations. Coincident pieces become one edge that lists every input along it.
+ * Throws a `PathOpsError` when the search does not settle or the input is not finite.
+ */
+declare function planarSplit(inputs: readonly (readonly (readonly BezierSegment[])[])[], options?: PathOpsOptions): PlanarSplitResult;
+/** Result of `pathBooleanSelect`: per selector, its connected parts (each an outer subpath with its holes). */
+interface PathSelectResult extends PathOpsReport {
+    parts: BezierPath[][];
+}
+/**
+ * Several boolean selections over one arrangement of the operands (the Pathfinder panel's
+ * Trim, Merge, Crop and Minus Back are each a selection per output). A selector gets the
+ * ascending indices of the operands covering an area and keeps the area when it returns true.
+ * Each selection comes back as its connected parts, largest first, built as `pathBoolean`
+ * builds its result; areas that only touch at an edge are one part. Falls back to the
+ * polygon engine like `pathBoolean`.
+ */
+declare function pathBooleanSelect(operands: PathOperandInput[], selectors: readonly ((covering: readonly number[]) => boolean)[], options?: PathOpsOptions): PathSelectResult;
 
 /**
  * Offset Path and Outline Stroke on Bézier paths.
@@ -758,4 +800,213 @@ declare function outlineStroke(input: BezierPathInput, options: OutlineStrokeOpt
  */
 declare function offsetPath(input: BezierPathInput, distance: number, options?: OffsetPathOptions): BezierPath;
 
-export { type SvgGradientStop as $, type AffineMatrix as A, type BezierPathInput as B, type CanvasGradientDef as C, type DashedPath as D, type EllipseShape as E, type FlattenOptions as F, type GetShapeRenderDataOptions as G, type PathShape as H, type PolygonBooleanOperation as I, type PolygonBooleanOptions as J, type PolygonInput as K, type PolygonOperand as L, type MultiPolygon as M, type PolygonPiece as N, type OffsetPathOptions as O, type PolygonFillRule as P, type PolygonToPathOptions as Q, type PolygonWithHoles as R, type SvgGradientDef as S, type RectShape as T, type RegularPolygonShape as U, SHAPE_KINDS as V, type SegmentIntersection as W, type ShapeKind as X, type ShapePaint as Y, type ShapeRenderData as Z, type StarShape as _, type BezierPath as a, unionPolygons as a$, angleToSvgLinearCoords as a0, arcToCubics as a1, bezierPathArea as a2, bezierPathBounds as a3, bezierPathLength as a4, bezierPathPointAtLength as a5, bezierPathSignedArea as a6, bezierPathToSvg as a7, closeContour as a8, contourSignedArea as a9, pointInMultiPolygon as aA, pointInRings as aB, polygonArea as aC, polygonBoolean as aD, polygonToSvgPath as aE, resolveCanvasGradient as aF, ringSignedArea as aG, segmentBounds as aH, segmentCurvature as aI, segmentDerivative as aJ, segmentExtrema as aK, segmentIntersections as aL, segmentLength as aM, segmentNearest as aN, segmentParamAtLength as aO, segmentPoint as aP, segmentTangent as aQ, shapeToPolygon as aR, simplifyRing as aS, splitSegment as aT, strokeOutlineRings as aU, subSegment as aV, subtractPaths as aW, subtractPolygons as aX, toBezierPath as aY, transformBezierPath as aZ, trimSegments as a_, contoursToPath as aa, countPathSegments as ab, dashContours as ac, distanceToBezierPath as ad, dividePaths as ae, dividePolygons as af, excludePaths as ag, flattenSvgPath as ah, formatNumber as ai, getShapeRenderData as aj, getShapeSvg as ak, gradientToSvgDef as al, intersectPaths as am, intersectPolygons as an, isCanvasGradient as ao, isShapeDescription as ap, multiPolygonArea as aq, multiPolygonBounds as ar, normalizeBezierPath as as, offsetPath as at, outlineStroke as au, parseCssGradient as av, parseSvgPath as aw, pathBoolean as ax, pathToContours as ay, pointInBezierPath as az, type StrokeJoin as b, unitePaths as b0, windingNumber as b1, xorPolygons as b2, type StrokeCap as c, type ShapeDescription as d, type PolygonRing as e, type ShapeSize as f, type BezierCommand as g, type BezierContour as h, type BezierPathToSvgOptions as i, type BezierSegment as j, CANVAS_GRADIENT_PRESETS as k, type CanvasLinearGradient as l, type CanvasRadialGradient as m, type DividePathsResult as n, type GradientStop as o, type OutlineStrokeOptions as p, type PathBooleanOperation as q, type PathBooleanResult as r, type PathCommand as s, type PathOperand as t, type PathOperandInput as u, PathOpsError as v, type PathOpsOptions as w, type PathOpsReport as x, type PathPiece as y, type PathPointAtLength as z };
+/**
+ * Planar maps: the faces and edges a set of paths divides the plane into (Shape Builder, fill
+ * regions, Pathfinder Outline).
+ *
+ * Unlike `dividePaths`, which splits the *filled areas* of closed shapes, every path here is an
+ * edge, open ones included: three crossing lines enclose a triangle, a line across a rectangle
+ * splits it in two, and an area enclosed by paths is a face whether or not anything fills it.
+ *
+ * 1. `planarSplit` (the boolean engine's intersection search) cuts every input segment wherever
+ *    it meets another one; coincident pieces become one edge.
+ * 2. Each edge gives two half-edges. Around every vertex the half-edges leaving it are sorted by
+ *    the direction in which they cross a small circle around it (half the shortest edge there),
+ *    which orders tangent curves correctly.
+ * 3. A face walk takes, at each vertex, the half-edge just clockwise of the way back — the
+ *    sharpest left turn. Bounded faces come out counter-clockwise (positive area in a y-up
+ *    frame), the outer boundary of every connected piece clockwise; spurs (loose line ends) are
+ *    dropped. Each outer boundary becomes a hole of the smallest face of another piece around
+ *    it, so nesting is decided face by face, never by an even-odd rule over the whole network.
+ * 4. Faces learn which inputs fill them from a point well inside each face.
+ *
+ * Adjacency is kept in per-vertex lists and half-edge slots (no scans over all edges per step).
+ *
+ * Ported from vectorcraft-main/crates/pathops/src/planar.rs (`map`, `Map::merge`, `build`,
+ * `interior_point`, `without_spurs`, `leaving_angle`, `cut_out`), figcraft-main/crates/doc/src/vector_faces.rs
+ * (`faces`: half-edge walk with an angle-sorted next edge, the winding deciding inside or
+ * outside) and cadcraft-main/crates/geom/src/region.rs (`enclosing_loop`, `boundary_at_gap`:
+ * a ray from the point, the sharpest left turn, islands as holes, gaps between open ends
+ * closed). MIT OR Apache-2.0, © ArtCraft Team and contributors. See THIRD_PARTY_NOTICES.md.
+ */
+
+/** One input of a planar map. */
+interface PlanarInput {
+    /** Its subpaths: closed ones bound faces and the area the input fills, open ones are edges only. */
+    path: BezierPathInput;
+    /** How its closed subpaths fill (default `nonzero`). */
+    fillRule?: PolygonFillRule;
+    /** Whether its closed subpaths count as filling the faces inside them (default true). */
+    fills?: boolean;
+}
+interface PlanarMapOptions extends PathOpsOptions {
+    /**
+     * Close gaps up to this distance between loose ends (vertices with one edge): each one joins
+     * the nearest other loose end within reach by a straight edge (default 0, off).
+     */
+    gap?: number;
+    /** Most input segments mapped (default 4096); a bigger input gives no map. */
+    maxSegments?: number;
+}
+/** A bounded face: an outer outline with the holes other pieces of the map make in it. */
+interface PlanarFace {
+    /** Outer subpath (counter-clockwise in a y-up frame) followed by its holes (clockwise). */
+    path: BezierPath;
+    /** Area (holes taken out). */
+    area: number;
+    bounds: {
+        minX: number;
+        minY: number;
+        maxX: number;
+        maxY: number;
+    };
+}
+/** A run of edges between junctions (vertices where paths meet or a path ends). */
+interface PlanarChain {
+    segments: BezierSegment[];
+    /** A loop with no junction on it. */
+    closed: boolean;
+    /** The input it lies on: the front-most (highest index) where several coincide. */
+    source: number;
+}
+/**
+ * A point strictly inside a filled path (nonzero), well away from its edges where it can be:
+ * the middle of the widest span of a few horizontal lines through it. Null for an empty path.
+ * Ported from vectorcraft's `interior_point` (cadcraft's `interior_point` for polygons).
+ */
+declare function interiorPoint(path: BezierPathInput | readonly (readonly BezierSegment[])[]): Point | null;
+/**
+ * The planar map of a set of paths. Build it with `PlanarMap.build`; faces, chains and fills
+ * are computed on first use.
+ */
+declare class PlanarMap {
+    readonly vertices: Point[];
+    private readonly edges;
+    private readonly sources;
+    readonly eps: number;
+    readonly inputCount: number;
+    private readonly around;
+    private readonly slot;
+    private readonly component;
+    private cyclesCache;
+    private sourcesCache;
+    private readonly fills;
+    private constructor();
+    /**
+     * Maps `inputs` (their subpaths as given: open ones stay open). Null when they cannot be mapped
+     * (non-finite points, more than `maxSegments` segments or an intersection search that does
+     * not settle) or have no edges.
+     */
+    static build(inputs: readonly PlanarInput[], options?: PlanarMapOptions): PlanarMap | null;
+    private origin;
+    private halfPts;
+    /** The half-edge after `h` on the face to its left: the sharpest left turn at its end. */
+    private next;
+    /** Direction (angle) in which half-edge `h`, leaving `at`, first gets `r` away from it. */
+    private leavingAngle;
+    /** Segments of a run of half-edges (a loop unless `closed` is false), pieces of one input segment joined again. */
+    private cycleSegments;
+    private cycles;
+    private faceChains;
+    /** The bounded faces of the map. */
+    get faces(): PlanarFace[];
+    /** The inputs whose fill covers face `i`, ascending (empty for an area only outlines enclose). */
+    faceSources(i: number): number[];
+    /** A point well inside face `i`. */
+    faceInterior(i: number): Point | null;
+    /** The face under `p` (the smallest one around it), or -1. */
+    faceAt(p: Point): number;
+    /**
+     * The union of faces, traced along the map's own edges: those between two merged faces drop
+     * out exactly, so no seam or sliver is left where a boolean union of their outlines could
+     * round shared corners apart. Outer subpaths come out counter-clockwise (y-up), holes clockwise.
+     */
+    merge(faceIndices: readonly number[]): BezierPath;
+    /**
+     * The edges joined into runs between junctions: vertices where other than two edges meet, or
+     * where the two edges lie on different inputs. Each run is keyed by its input.
+     */
+    chains(): PlanarChain[];
+    /**
+     * The region enclosing `p`, traced as cadcraft does it: a ray from `p` towards +x meets the
+     * edges in order; for each, the half-edge with `p` on its left is followed by always taking the
+     * sharpest left turn, until a loop that runs counter-clockwise round `p` comes back. The pieces
+     * of the map nested inside that loop (islands) become its holes. Null when nothing encloses `p`.
+     */
+    regionAt(p: Point): BezierPath | null;
+}
+/** Whether a contour, closed, encloses an area (rather than retracing itself). */
+declare function contourEnclosesArea(contour: BezierContour): boolean;
+/**
+ * `path` without `piece`, a run along one of its subpaths between two points (a Shape Builder
+ * edge from `PlanarMap.chains`): a closed subpath opens there, an open one splits in two (or
+ * loses an end), and a piece that runs all the way round (`closed`, or ending where it starts)
+ * takes its subpath with it. With `fillCloses`, open subpaths that enclose an area run on round
+ * an invisible closing edge, as the Shape Builder sees a filled path: a piece may run over it,
+ * and it never comes back as a visible segment. Null when the piece does not lie on `path`
+ * within `tol`.
+ *
+ * Ported from vectorcraft-main/crates/pathops/src/planar.rs (`cut_out`, `nearest_u`, `span`,
+ * `snap_ends`). MIT OR Apache-2.0, © ArtCraft Team and contributors. See THIRD_PARTY_NOTICES.md.
+ */
+declare function cutOutPiece(path: BezierPathInput, piece: {
+    segments: readonly BezierSegment[];
+    closed?: boolean;
+}, fillCloses: boolean, tol: number): BezierPath | null;
+
+/**
+ * The Pathfinder panel's dividing operations over a stack of shapes (index 0 at the back):
+ * Divide, Trim, Merge, Crop, Outline and Minus Back. (Unite, Minus Front, Intersect and Exclude
+ * are `pathBoolean`.) Every result carries the index of the shape whose paint it keeps.
+ *
+ * The filled areas come from one arrangement of all shapes (`dividePaths`, `pathBooleanSelect`):
+ * each area knows the shapes covering it, so an operation is a choice of areas per result.
+ * Outline and Divide with cutting lines use the planar map (`PlanarMap`).
+ *
+ * Ported from vectorcraft-main/crates/pathops/src/pathfinder.rs (`pathfinder`, `PathfinderOp`,
+ * `outline_edges`), MIT OR Apache-2.0, © ArtCraft Team and contributors. See
+ * THIRD_PARTY_NOTICES.md.
+ */
+
+type PathfinderOperation = 'divide' | 'trim' | 'merge' | 'crop' | 'outline' | 'minusBack';
+declare const PATHFINDER_OPERATIONS: readonly PathfinderOperation[];
+/** A shape of the stack. */
+interface PathfinderShape {
+    /** Its outline; open subpaths are closed for filling (unless `line`). */
+    path: BezierPathInput;
+    fillRule?: PolygonFillRule;
+    /** Identifies its paint: Merge joins touching areas whose shapes share a key (default: the index). */
+    key?: string | number;
+    /**
+     * An unfilled open path: a cutting edge for Divide, splitting the faces it crosses without
+     * becoming one (ignored by the other operations).
+     */
+    line?: boolean;
+}
+/** One result: a filled area (or an open stroke for Outline). */
+interface PathfinderPiece {
+    path: BezierPath;
+    /** Index of the shape whose paint it keeps. */
+    source: number;
+    /** Outline edges are open paths (a loop with no junction on it stays closed). */
+    open?: boolean;
+}
+interface PathfinderResult extends PathOpsReport {
+    pieces: PathfinderPiece[];
+}
+/**
+ * Runs a Pathfinder operation:
+ * - `divide`: every face of the arrangement becomes its own piece, painted like the top-most
+ *   shape covering it. `line` shapes cut the faces they cross.
+ * - `trim`: hidden parts are removed; one piece per shape that stays visible, nothing merged.
+ * - `merge`: like Trim, then touching or overlapping visible parts of shapes with the same key
+ *   become one piece (one per connected area).
+ * - `crop`: the top shape crops the others; it is removed, the visible parts of the shapes below
+ *   inside it stay.
+ * - `outline`: every outline is cut where it meets another; the pieces are open paths painted
+ *   like the shape they bound (the top-most where outlines coincide).
+ * - `minusBack`: the top shape minus everything behind it.
+ */
+declare function pathfinder(op: PathfinderOperation, shapes: readonly PathfinderShape[], options?: PathOpsOptions): PathfinderResult;
+
+export { type PolygonInput as $, type AffineMatrix as A, type BezierPathInput as B, type CanvasGradientDef as C, type DashedPath as D, type EllipseShape as E, type FlattenOptions as F, type GetShapeRenderDataOptions as G, type PathOpsOptions as H, type PathOpsReport as I, type PathPiece as J, type PathPointAtLength as K, type PathSelectResult as L, type MultiPolygon as M, type PathShape as N, type OffsetPathOptions as O, PlanarMap as P, type PathfinderPiece as Q, type PathfinderResult as R, type SvgGradientDef as S, type PlanarChain as T, type PlanarFace as U, type PlanarInput as V, type PlanarMapOptions as W, type PlanarSplitEdge as X, type PlanarSplitResult as Y, type PolygonBooleanOperation as Z, type PolygonBooleanOptions as _, type BezierPath as a, segmentCurvature as a$, type PolygonOperand as a0, type PolygonPiece as a1, type PolygonToPathOptions as a2, type PolygonWithHoles as a3, type RectShape as a4, type RegularPolygonShape as a5, SHAPE_KINDS as a6, type SegmentIntersection as a7, type ShapeKind as a8, type ShapePaint as a9, gradientToSvgDef as aA, interiorPoint as aB, intersectPaths as aC, intersectPolygons as aD, isCanvasGradient as aE, isShapeDescription as aF, multiPolygonArea as aG, multiPolygonBounds as aH, normalizeBezierPath as aI, offsetPath as aJ, outlineStroke as aK, parseCssGradient as aL, parseSvgPath as aM, pathBoolean as aN, pathBooleanSelect as aO, pathToContours as aP, pathfinder as aQ, planarSplit as aR, pointInBezierPath as aS, pointInMultiPolygon as aT, pointInRings as aU, polygonArea as aV, polygonBoolean as aW, polygonToSvgPath as aX, resolveCanvasGradient as aY, ringSignedArea as aZ, segmentBounds as a_, type ShapeRenderData as aa, type StarShape as ab, type SvgGradientStop as ac, angleToSvgLinearCoords as ad, arcToCubics as ae, bezierPathArea as af, bezierPathBounds as ag, bezierPathLength as ah, bezierPathPointAtLength as ai, bezierPathSignedArea as aj, bezierPathToSvg as ak, closeContour as al, contourEnclosesArea as am, contourSignedArea as an, contoursToPath as ao, countPathSegments as ap, cutOutPiece as aq, dashContours as ar, distanceToBezierPath as as, dividePaths as at, dividePolygons as au, excludePaths as av, flattenSvgPath as aw, formatNumber as ax, getShapeRenderData as ay, getShapeSvg as az, type StrokeJoin as b, segmentDerivative as b0, segmentExtrema as b1, segmentIntersections as b2, segmentLength as b3, segmentNearest as b4, segmentParamAtLength as b5, segmentPoint as b6, segmentTangent as b7, shapeToPolygon as b8, simplifyRing as b9, splitSegment as ba, strokeOutlineRings as bb, subSegment as bc, subtractPaths as bd, subtractPolygons as be, toBezierPath as bf, transformBezierPath as bg, trimSegments as bh, unionPolygons as bi, unitePaths as bj, windingNumber as bk, xorPolygons as bl, type StrokeCap as c, type BezierSegment as d, type PathfinderOperation as e, type PathfinderShape as f, type ShapeDescription as g, type PolygonFillRule as h, type PolygonRing as i, type ShapeSize as j, type BezierCommand as k, type BezierContour as l, type BezierPathToSvgOptions as m, CANVAS_GRADIENT_PRESETS as n, type CanvasLinearGradient as o, type CanvasRadialGradient as p, type DividePathsResult as q, type GradientStop as r, type OutlineStrokeOptions as s, PATHFINDER_OPERATIONS as t, type PathBooleanOperation as u, type PathBooleanResult as v, type PathCommand as w, type PathOperand as x, type PathOperandInput as y, PathOpsError as z };