@pixerate/editor 0.53.0 → 0.55.0

package/dist/pathfinder-BZL8aSu0.d.cts

@@ -0,0 +1,469 @@
+import { P as Point } from './types-BFkYA4eF.cjs';
+import { B as BezierPath, P as PolygonBooleanOperation, a as BezierPathInput, b as PolygonFillRule, c as BezierSegment, d as BezierContour } from './bezier-BfwIbVTl.cjs';
+
+/**
+ * Curve-preserving boolean operations (union, intersection, difference, xor and divide) on
+ * Bézier paths.
+ *
+ * Algorithm (planar arrangement of curve pieces + winding classification):
+ * 1. Every segment of every operand (open subpaths closed for filling) is a *source*; it is
+ *    cut into pieces monotone in x and y. Each piece remembers its source and its parameter
+ *    range there, so results can be rebuilt from exact sub-curves of the inputs.
+ * 2. Pieces are intersected pairwise (pruned by a sweep on x): lines analytically, curves by
+ *    recursive subdivision down to flat sub-curves, chord intersection and Newton polishing.
+ *    Endpoints lying on another piece (T-junctions, tangent touches), collinear / coincident
+ *    overlaps and clusters of hits along a tangency are resolved first. Points closer than
+ *    `epsilon` share one vertex. Splitting repeats until no piece crosses another.
+ * 3. Coincident pieces (shared edges, identical curves) merge into one edge carrying every
+ *    operand's signed multiplicity.
+ * 4. Each edge is classified by casting a horizontal or vertical ray from its midpoint (the
+ *    pieces are monotone, so a ray crosses each at most once); the operands' fill rules turn
+ *    the winding numbers on both sides into inside flags and the operation picks the edges
+ *    with the result on exactly one side.
+ * 5. The kept edges are traced into rings, taking the sharpest left turn at each vertex
+ *    (ties between tangent curves broken by a short chord along each curve), and consecutive
+ *    pieces of one source are merged back into one exact sub-curve, so circles stay four
+ *    cubics and rectangles four lines.
+ *
+ * When the curve engine fails (non-converging intersections on near-coincident curves,
+ * an inconsistent arrangement) the operation falls back to the polygon engine
+ * (`polygonBoolean`) on flattened input and reports it (`engine: 'polygon'`).
+ *
+ * Portions ported from vectorcraft-main/crates/pathops/src/boolean.rs (MIT OR Apache-2.0,
+ * © ArtCraft Team and contributors). See THIRD_PARTY_NOTICES.md.
+ */
+
+/** Boolean operations (same names as `polygonBoolean`). `xor` is Exclude. */
+type PathBooleanOperation = PolygonBooleanOperation;
+/** A path with the fill rule it is read with (default `nonzero`). */
+interface PathOperand {
+    path: BezierPathInput;
+    fillRule?: PolygonFillRule;
+}
+type PathOperandInput = BezierPathInput | PathOperand;
+interface PathOpsOptions {
+    /**
+     * Distance below which points are treated as equal. Defaults to `1e-9` times the
+     * largest coordinate magnitude (at least `1e-9`).
+     */
+    epsilon?: number;
+    /** Fall back to the polygon engine when the curve engine fails (default `true`). */
+    fallback?: boolean;
+    /** Flattening tolerance used by the polygon fallback (default 0.05). */
+    fallbackTolerance?: number;
+    /** Called with the reason whenever the polygon fallback is used. */
+    onFallback?: (reason: string) => void;
+    /**
+     * Work budget of the curve–curve intersection search (flat sub-curve pairs per pair of
+     * pieces, default 20,000). Exceeding it (nearly coincident curves) falls back.
+     */
+    subdivisionBudget?: number;
+}
+/** Which engine produced a result, and why the curve engine was not used. */
+interface PathOpsReport {
+    engine: 'curve' | 'polygon';
+    fallbackReason?: string;
+    /** Set when the input cannot be processed at all (non-finite coordinates); the result is empty. */
+    error?: string;
+}
+interface PathBooleanResult extends PathOpsReport {
+    path: BezierPath;
+}
+/** One region of `dividePaths`, with the indices of the operands that cover it. */
+interface PathPiece {
+    path: BezierPath;
+    operands: number[];
+}
+interface DividePathsResult extends PathOpsReport {
+    pieces: PathPiece[];
+}
+/** Raised by the curve engine when it cannot produce a reliable arrangement. */
+declare class PathOpsError extends Error {
+    constructor(message: string);
+}
+/** A crossing or touch of two segments: the parameter on each and the point. */
+interface SegmentIntersection {
+    ta: number;
+    tb: number;
+    point: Point;
+}
+/**
+ * Every point where two segments (lines, quadratics or cubics, as control points) cross or
+ * touch, by the same subdivision search the boolean operations use: flat sub-curves, chord
+ * intersection, Newton polishing. Hits closer than `epsilon` (default: 1e-9 of the segments'
+ * size) are one. Coincident stretches report the hits the search finds along them.
+ */
+declare function segmentIntersections(a: BezierSegment, b: BezierSegment, options?: {
+    epsilon?: number;
+    budget?: number;
+}): SegmentIntersection[];
+/**
+ * Applies a boolean operation to any number of path operands, keeping curves:
+ * - `union`: covered by any operand.
+ * - `intersection`: covered by every operand.
+ * - `difference`: the first operand minus all others.
+ * - `xor`: covered by an odd number of operands (Exclude).
+ *
+ * Open subpaths are closed for filling. Non-finite input gives an empty path (`error`); with
+ * `fallback: false` a failure of the curve engine throws a `PathOpsError`. The result is a set of simple closed subpaths that
+ * never cross (they may touch at points): outer subpaths run counter-clockwise in a y-up
+ * frame (clockwise on screen), holes the other way, so it fills the same with `nonzero`
+ * and `evenodd`. Segments of the inputs are kept as exact sub-curves.
+ */
+declare function pathBoolean(operation: PathBooleanOperation, operands: PathOperandInput[], options?: PathOpsOptions): PathBooleanResult;
+declare const unitePaths: (a: PathOperandInput, b: PathOperandInput, options?: PathOpsOptions) => BezierPath;
+declare const intersectPaths: (a: PathOperandInput, b: PathOperandInput, options?: PathOpsOptions) => BezierPath;
+declare const subtractPaths: (a: PathOperandInput, b: PathOperandInput, options?: PathOpsOptions) => BezierPath;
+declare const excludePaths: (a: PathOperandInput, b: PathOperandInput, options?: PathOpsOptions) => BezierPath;
+/**
+ * Splits the arrangement of the operands into its regions (Divide): every connected area
+ * covered by the same set of operands becomes one piece (an outer subpath with its holes).
+ * Pieces are ordered by operand set, then by area (largest first).
+ */
+declare function dividePaths(operands: PathOperandInput[], options?: PathOpsOptions): DividePathsResult;
+/**
+ * Resolves self-intersections and overlaps of one filled path into simple, consistently
+ * oriented subpaths (outer subpaths and holes) under its fill rule.
+ */
+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.
+ *
+ * The stroker offsets every segment by ± half the width (lines exactly, curves by cubic
+ * approximations refined until they stay within `tolerance` of the true offset), joins the
+ * pieces (miter with a miter limit, round or bevel on the outer side of a turn; through the
+ * vertex on the inner side) and adds caps (butt, round, square) to open subpaths. Dashes
+ * follow arc length, restart on every subpath and join across the start of a closed
+ * subpath. The raw outline overlaps itself, so it is filled with the non-zero rule and
+ * normalised with the curve boolean engine.
+ *
+ * When the stroke is wider than a curve's radius of curvature the inner offset turns inside
+ * out and its loops cancel winding, leaving holes that are really covered. Every face of
+ * the true result is bounded by the arrangement, so a face is spurious exactly when a point
+ * deep inside it is closer to the path than the offset distance (holes when growing,
+ * islands when insetting); such faces are dropped.
+ *
+ * Portions ported from vectorcraft-main/crates/pathops/src/offset.rs,
+ * vectorcraft-main/crates/pathops/src/boolean.rs (`try_merge`) and
+ * vectorcraft-main/crates/effects/src/stroke/dash.rs (MIT OR Apache-2.0, © ArtCraft Team
+ * and contributors). See THIRD_PARTY_NOTICES.md.
+ */
+
+/** Line join (as SVG `stroke-linejoin`). */
+type StrokeJoin = 'miter' | 'round' | 'bevel';
+/** Line cap (as SVG `stroke-linecap`). */
+type StrokeCap = 'butt' | 'round' | 'square';
+interface OutlineStrokeOptions extends PathOpsOptions {
+    /** Stroke width. Non-positive or non-finite widths give an empty result. */
+    width: number;
+    /** Default `miter` (as SVG). */
+    join?: StrokeJoin;
+    /** Default `butt` (as SVG). */
+    cap?: StrokeCap;
+    /** Miter length / stroke width above which a miter join is bevelled (default 4, as SVG). */
+    miterLimit?: number;
+    /** Dash pattern (as SVG `stroke-dasharray`); odd patterns repeat twice. */
+    dash?: readonly number[];
+    /** Distance into the dash pattern at the start of each subpath (as `stroke-dashoffset`). */
+    dashOffset?: number;
+    /** Maximum distance between the approximated and the true offset curve (default 0.01). */
+    tolerance?: number;
+}
+interface OffsetPathOptions extends PathOpsOptions {
+    /** Corner style of the grown / shrunk outline (default `miter`). */
+    join?: StrokeJoin;
+    /** Miter limit (default 4). */
+    miterLimit?: number;
+    /** Fill rule of the input (default `nonzero`). */
+    fillRule?: PolygonFillRule;
+    /** Maximum distance between the approximated and the true offset curve (default 0.01). */
+    tolerance?: number;
+}
+interface DashedPath {
+    /** The dashes, as open subpaths. */
+    contours: BezierContour[];
+    /** Zero-length dashes: where they sit and the path direction there. */
+    dots: {
+        point: Point;
+        tangent: Point;
+    }[];
+}
+/**
+ * Applies a dash pattern (SVG `stroke-dasharray` / `stroke-dashoffset` semantics) to the
+ * subpaths. Returns `null` when the pattern is invalid (negative or non-finite entries),
+ * has no positive entry, or would make more than 200,000 dashes: the line is solid.
+ */
+declare function dashContours(contours: readonly BezierContour[], pattern: readonly number[], offset?: number): DashedPath | null;
+/**
+ * The raw (overlapping) outline of a stroke as closed subpaths to fill with `nonzero`.
+ * `outlineStroke` normalises it; this is useful for previews.
+ */
+declare function strokeOutlineRings(input: BezierPathInput, options: OutlineStrokeOptions): BezierPath;
+/**
+ * Outline Stroke: the filled area painted by stroking `path`, as one clean path (overlaps
+ * removed, consistently oriented). Joins, caps, miter limit and dashes follow SVG.
+ */
+declare function outlineStroke(input: BezierPathInput, options: OutlineStrokeOptions): BezierPath;
+/**
+ * Offset Path: grows (`distance > 0`) or shrinks (`distance < 0`) the filled area by
+ * `distance`. Closed subpaths are a filled region (read with `fillRule`); open subpaths are
+ * outlined with a stroke of width `2·|distance|` and butt caps (when growing). Loops of the
+ * offset curves are removed.
+ */
+declare function offsetPath(input: BezierPathInput, distance: number, options?: OffsetPathOptions): BezierPath;
+
+/**
+ * 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 { cutOutPiece as A, dashContours as B, dividePaths as C, type DashedPath as D, excludePaths as E, interiorPoint as F, intersectPaths as G, normalizeBezierPath as H, offsetPath as I, outlineStroke as J, pathBoolean as K, pathBooleanSelect as L, pathfinder as M, planarSplit as N, type OffsetPathOptions as O, PlanarMap as P, segmentIntersections as Q, strokeOutlineRings as R, type StrokeJoin as S, subtractPaths as T, unitePaths as U, type StrokeCap as a, type PathfinderOperation as b, type PathfinderShape as c, type DividePathsResult as d, type OutlineStrokeOptions as e, PATHFINDER_OPERATIONS as f, type PathBooleanOperation as g, type PathBooleanResult as h, type PathOperand as i, type PathOperandInput as j, PathOpsError as k, type PathOpsOptions as l, type PathOpsReport as m, type PathPiece as n, type PathSelectResult as o, type PathfinderPiece as p, type PathfinderResult as q, type PlanarChain as r, type PlanarFace as s, type PlanarInput as t, type PlanarMapOptions as u, type PlanarSplitEdge as v, type PlanarSplitResult as w, type SegmentIntersection as x, bezierPathArea as y, contourEnclosesArea as z };