@pixerate/editor 0.36.0 → 0.38.0

package/dist/pathfinder-fLmmFOJw.d.ts

@@ -0,0 +1,994 @@
+import { P as Point } from './types-BFkYA4eF.js';
+
+/**
+ * Polygon boolean operations (union, intersection, difference, xor and divide) on
+ * multi-polygons with holes.
+ *
+ * Algorithm (overlay + winding classification):
+ * 1. Every input edge is collected into one segment set. Vertices are merged through a
+ *    tolerance-aware point pool, so points closer than `epsilon` become one vertex.
+ * 2. Segments are split at every crossing, T-junction and collinear overlap until no two
+ *    segments cross (a planar arrangement). Splitting is repeated because snapping a new
+ *    vertex can move a segment by up to `epsilon`.
+ * 3. Coincident segments (shared edges) are merged, keeping for every operand the signed
+ *    number of its edges that run along the segment.
+ * 4. For every segment the winding number of each operand on its right side is computed
+ *    with a ray cast from the segment midpoint (the segment itself excluded), and the left
+ *    side follows from the signed multiplicities. The fill rule turns windings into
+ *    inside / outside flags and the operation decides whether each side is in the result.
+ * 5. Segments with the result on exactly one side are kept, oriented with the result on
+ *    their left, and traced into rings (taking the sharpest left turn at shared vertices,
+ *    so rings that touch at a vertex stay separate simple rings). Rings with a positive
+ *    signed area are outer rings; negative ones are holes, assigned to the smallest outer
+ *    ring that contains them.
+ *
+ * Handles shared edges, touching vertices, collinear overlaps, holes, nested and disjoint
+ * inputs and self-intersecting input rings (resolved by the operand's fill rule).
+ *
+ * Limits: the overlay is O(n²) in the number of edges (pruned by a sweep on x), which is
+ * comfortable for canvas shapes (thousands of edges) but not for GIS-scale data. Features
+ * narrower than `epsilon` collapse. Coordinates must be finite.
+ */
+
+/** A closed ring of points. The closing point may be repeated or omitted. */
+type PolygonRing = Point[];
+/** A polygon: the outer ring followed by its holes. */
+type PolygonWithHoles = PolygonRing[];
+/** A set of polygons. */
+type MultiPolygon = PolygonWithHoles[];
+/** SVG fill rule used to decide which areas of a ring set are inside. */
+type PolygonFillRule = 'nonzero' | 'evenodd';
+/** Boolean operations. `xor` is Freeform's Exclude. */
+type PolygonBooleanOperation = 'union' | 'intersection' | 'difference' | 'xor';
+/**
+ * A raw ring set with a fill rule (e.g. flattened SVG path data). Ring orientation is
+ * significant for `nonzero`.
+ */
+interface PolygonOperand {
+    rings: PolygonRing[];
+    fillRule?: PolygonFillRule;
+}
+type PolygonInput = MultiPolygon | PolygonOperand;
+interface PolygonBooleanOptions {
+    /**
+     * Distance below which points are treated as equal. Defaults to `1e-9` times the
+     * largest coordinate magnitude of the inputs (at least `1e-9`).
+     */
+    epsilon?: number;
+}
+/** One region of `dividePolygons`, with the indices of the operands that cover it. */
+interface PolygonPiece {
+    polygon: PolygonWithHoles;
+    operands: number[];
+}
+/** Signed shoelace area of a ring (positive when counter-clockwise in a y-up frame). */
+declare function ringSignedArea(ring: readonly Point[]): number;
+/** Area of a polygon (outer ring minus holes). */
+declare function polygonArea(polygon: PolygonWithHoles): number;
+/** Total area of a multi-polygon (holes subtracted). */
+declare function multiPolygonArea(multi: MultiPolygon): number;
+/** Axis-aligned bounds of a multi-polygon (or ring list), or `null` when empty. */
+declare function multiPolygonBounds(input: MultiPolygon | PolygonRing[]): {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+} | null;
+/**
+ * Whether a point is inside a ring set under a fill rule. Points exactly on an edge may
+ * report either side.
+ */
+declare function pointInRings(point: Point, rings: readonly (readonly Point[])[], fillRule?: PolygonFillRule): boolean;
+/** Whether a point is inside a multi-polygon (holes excluded). */
+declare function pointInMultiPolygon(point: Point, multi: MultiPolygon): boolean;
+/**
+ * Applies a boolean operation to any number of operands.
+ * - `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).
+ *
+ * Returns simple rings: outer rings have a positive signed area, holes a negative one.
+ * Rings may touch at vertices but never cross.
+ */
+declare function polygonBoolean(operation: PolygonBooleanOperation, operands: PolygonInput[], options?: PolygonBooleanOptions): MultiPolygon;
+declare const unionPolygons: (a: PolygonInput, b: PolygonInput, options?: PolygonBooleanOptions) => MultiPolygon;
+declare const intersectPolygons: (a: PolygonInput, b: PolygonInput, options?: PolygonBooleanOptions) => MultiPolygon;
+declare const subtractPolygons: (a: PolygonInput, b: PolygonInput, options?: PolygonBooleanOptions) => MultiPolygon;
+declare const xorPolygons: (a: PolygonInput, b: PolygonInput, options?: PolygonBooleanOptions) => MultiPolygon;
+/**
+ * Splits the overlay of the operands into its distinct regions (Freeform's Divide): every
+ * connected area covered by the same set of operands becomes one piece. Pieces are ordered
+ * by their operand set, then by size (largest first).
+ */
+declare function dividePolygons(operands: PolygonInput[], options?: PolygonBooleanOptions): PolygonPiece[];
+
+/**
+ * Canvas gradient models, parsing, presets, and SVG defs generation.
+ * Supports linear and radial gradients for shape fills, strokes, and freehand drawing.
+ */
+interface GradientStop {
+    offset: number;
+    color: string;
+    opacity?: number;
+}
+interface CanvasLinearGradient {
+    type: 'linear';
+    angle?: number;
+    stops: GradientStop[];
+}
+interface CanvasRadialGradient {
+    type: 'radial';
+    cx?: number;
+    cy?: number;
+    r?: number;
+    stops: GradientStop[];
+}
+type CanvasGradientDef = CanvasLinearGradient | CanvasRadialGradient;
+interface SvgGradientStop {
+    offset: string;
+    stopColor: string;
+    stopOpacity?: number;
+}
+interface SvgGradientDef {
+    id: string;
+    type: 'linear' | 'radial';
+    attrs: Record<string, string | number>;
+    stops: SvgGradientStop[];
+}
+declare const CANVAS_GRADIENT_PRESETS: Record<string, CanvasLinearGradient>;
+/** Whether an arbitrary value matches a CanvasGradientDef object. */
+declare function isCanvasGradient(value: unknown): value is CanvasGradientDef;
+/**
+ * Parses CSS linear-gradient or radial-gradient strings into CanvasGradientDef.
+ * Supports forms like:
+ * - linear-gradient(90deg, #ff0000 0%, #0000ff 100%)
+ * - linear-gradient(to right, red, blue)
+ * - radial-gradient(circle, red 0%, blue 100%)
+ */
+declare function parseCssGradient(css: string): CanvasGradientDef | null;
+/**
+ * Resolves a paint value (which could be a CSS color, preset name, CSS gradient string, or CanvasGradientDef)
+ * into either a CanvasGradientDef (if gradient) or null (if solid color or invalid).
+ */
+declare function resolveCanvasGradient(value: unknown): CanvasGradientDef | null;
+/**
+ * Converts degrees clockwise (CSS angle: 0 = top, 90 = right, 180 = bottom, 270 = left)
+ * to SVG linearGradient vector coordinates (x1, y1, x2, y2) normalized [0, 1].
+ */
+declare function angleToSvgLinearCoords(angleDeg?: number): {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+};
+/**
+ * Converts a CanvasGradientDef to an SvgGradientDef descriptor ready for rendering `<linearGradient>` / `<radialGradient>`.
+ */
+declare function gradientToSvgDef(gradient: CanvasGradientDef, id: string): SvgGradientDef;
+
+/**
+ * Shape geometry: shape descriptions (rect, rounded rect, ellipse, regular polygon, star and
+ * SVG path data) to polygons, SVG path parsing / flattening, and polygons back to path data.
+ */
+
+/** Paint shared by every shape kind. Colours are any CSS colour, preset name, or gradient definition. */
+interface ShapePaint {
+    fill?: string | CanvasGradientDef;
+    stroke?: string | CanvasGradientDef;
+    strokeWidth?: number;
+    opacity?: number;
+    strokeLinecap?: 'round' | 'butt' | 'square';
+    strokeLinejoin?: 'round' | 'bevel' | 'miter';
+    fillGradient?: CanvasGradientDef;
+    strokeGradient?: CanvasGradientDef;
+}
+interface ShapeBase extends ShapePaint {
+    /** Clockwise rotation in degrees (on a y-down canvas) about the centre of the node box. */
+    rotation?: number;
+}
+/** Rectangle filling the node box, optionally with rounded corners. */
+interface RectShape extends ShapeBase {
+    kind: 'rect';
+    /** One radius, or `[topLeft, topRight, bottomRight, bottomLeft]`. Clamped to fit. */
+    cornerRadius?: number | readonly [number, number, number, number];
+}
+/** Ellipse (circle when the node is square) inscribed in the node box. */
+interface EllipseShape extends ShapeBase {
+    kind: 'ellipse';
+}
+/** Regular polygon, stretched so its bounding box fills the node box. */
+interface RegularPolygonShape extends ShapeBase {
+    kind: 'polygon';
+    /** Number of sides (at least 3, default 6). The first vertex points up. */
+    sides?: number;
+}
+/** Star, stretched so its bounding box fills the node box. */
+interface StarShape extends ShapeBase {
+    kind: 'star';
+    /** Number of points (at least 3, default 5). The first point points up. */
+    points?: number;
+    /** Inner radius as a fraction of the outer radius (default 0.5). */
+    innerRadius?: number;
+}
+/** Arbitrary SVG path data. */
+interface PathShape extends ShapeBase {
+    kind: 'path';
+    d: string;
+    /**
+     * `[minX, minY, width, height]` of the path's coordinate space, scaled to the node box.
+     * Without it the path coordinates are node-local pixels.
+     */
+    viewBox?: readonly [number, number, number, number];
+    /** Fill rule (default `nonzero`, as in SVG). */
+    fillRule?: PolygonFillRule;
+}
+/**
+ * Shape description stored on a node as `data.shape`. Geometry is relative to the node
+ * box (`0,0` to `width,height`), so resizing the node resizes the shape.
+ */
+type ShapeDescription = RectShape | EllipseShape | RegularPolygonShape | StarShape | PathShape;
+type ShapeKind = ShapeDescription['kind'];
+declare const SHAPE_KINDS: readonly ShapeKind[];
+/** Whether a value is a supported shape description. */
+declare function isShapeDescription(value: unknown): value is ShapeDescription;
+interface ShapeSize {
+    width: number;
+    height: number;
+}
+interface FlattenOptions {
+    /** Maximum distance between a curve and its polyline, in output units (default 0.25). */
+    tolerance?: number;
+    /** Upper bound on the segments one curve is split into (default 512). */
+    maxSegments?: number;
+}
+/** Normalised absolute path command produced by `parseSvgPath`. */
+type PathCommand = {
+    type: 'M';
+    x: number;
+    y: number;
+} | {
+    type: 'L';
+    x: number;
+    y: number;
+} | {
+    type: 'C';
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    x: number;
+    y: number;
+} | {
+    type: 'Q';
+    x1: number;
+    y1: number;
+    x: number;
+    y: number;
+} | {
+    type: 'A';
+    rx: number;
+    ry: number;
+    rotation: number;
+    largeArc: boolean;
+    sweep: boolean;
+    x: number;
+    y: number;
+} | {
+    type: 'Z';
+};
+/**
+ * Parses SVG path data into absolute `M`, `L`, `C`, `Q`, `A` and `Z` commands. Relative
+ * commands, `H` / `V`, smooth curves (`S` / `T`) and implicit repeated commands are
+ * normalised. Parsing stops at the first malformed command (as browsers do).
+ */
+declare function parseSvgPath(d: string): PathCommand[];
+/**
+ * Flattens SVG path data into closed rings (one per subpath; open subpaths are closed the
+ * way SVG fills them). Curves are approximated within `tolerance`.
+ */
+declare function flattenSvgPath(d: string | PathCommand[], options?: FlattenOptions): PolygonRing[];
+/**
+ * SVG path data for a shape in node-local pixels (exact curves: arcs for rounded corners
+ * and ellipses), plus the fill rule and a `transform` for rotation / path view boxes.
+ * Use it to render a shape; use `shapeToPolygon` for geometry.
+ */
+declare function getShapeSvg(shape: ShapeDescription, size: ShapeSize): {
+    d: string;
+    transform?: string;
+    fillRule: PolygonFillRule;
+};
+/** Everything a renderer needs to draw a shape as one SVG `<path>`. */
+interface ShapeRenderData {
+    /** SVG `viewBox` (`0 0 width height`): node-local pixels. */
+    viewBox: string;
+    width: number;
+    height: number;
+    d: string;
+    transform?: string;
+    fillRule: PolygonFillRule;
+    fill: string;
+    stroke: string;
+    strokeWidth: number;
+    opacity?: number;
+    strokeLinecap?: 'round' | 'butt' | 'square';
+    strokeLinejoin?: 'round' | 'bevel' | 'miter';
+    /** Gradient def for the fill, when fill uses a gradient. */
+    fillGradient?: SvgGradientDef;
+    /** Gradient def for the stroke, when stroke uses a gradient. */
+    strokeGradient?: SvgGradientDef;
+}
+interface GetShapeRenderDataOptions {
+    /** Unique ID suffix or base ID used when generating SVG gradient IDs (default: auto random). */
+    id?: string;
+}
+/**
+ * Resolves the SVG drawing of a shape for a node size. Without a size, a path's view box
+ * size (or 100x100) is used. Paint defaults: `fill: currentColor`, `stroke: none`,
+ * `strokeWidth: 1`. Supports solid colors, CSS gradients, presets, and CanvasGradientDef.
+ */
+declare function getShapeRenderData(shape: ShapeDescription, size?: Partial<ShapeSize>, options?: GetShapeRenderDataOptions): ShapeRenderData;
+/**
+ * Converts a shape to rings in node-local pixels (rotation applied), flattening curves at
+ * `tolerance`. Returns the rings with the fill rule they must be read with.
+ */
+declare function shapeToPolygon(shape: ShapeDescription, size: ShapeSize, options?: FlattenOptions): {
+    rings: PolygonRing[];
+    fillRule: PolygonFillRule;
+};
+/** Formats a number with at most `precision` decimals, without trailing zeros. */
+declare function formatNumber(value: number, precision?: number): string;
+/**
+ * Simplifies a closed ring with Ramer–Douglas–Peucker at `tolerance`. Returns an empty
+ * ring when fewer than three points survive.
+ */
+declare function simplifyRing(ring: readonly Point[], tolerance: number): Point[];
+interface PolygonToPathOptions {
+    /** Decimal places in the output (default 3). */
+    precision?: number;
+    /** Ramer–Douglas–Peucker tolerance; `0` (default) keeps every vertex. */
+    simplify?: number;
+    /** Added to every point before formatting (e.g. to make coordinates node-local). */
+    offset?: {
+        x: number;
+        y: number;
+    };
+    /**
+     * `'lines'` (default) writes every ring as `M`/`L`/`Z`. `'fit'` fits cubic Béziers to each
+     * ring (`fitPathData`), so flattened curves come back as smooth `C` curves while sharp
+     * corners (turning more than `cornerAngleDeg`) and straight edges stay as they are.
+     */
+    curves?: 'lines' | 'fit';
+    /** Curve-fitting tolerance in path units for `curves: 'fit'` (default 0.25). */
+    curveTolerance?: number;
+    /** Corner threshold in degrees for `curves: 'fit'` (default 30). */
+    cornerAngleDeg?: number;
+}
+/**
+ * Converts a multi-polygon (or a list of rings) to SVG path data using `M`/`L`/`Z`. Holes
+ * keep their opposite orientation, so the path fills correctly with either fill rule.
+ */
+declare function polygonToSvgPath(input: MultiPolygon | PolygonRing[], options?: PolygonToPathOptions): string;
+
+/**
+ * Bézier path model shared by the curve-preserving path operations: absolute `M` / `L` /
+ * `Q` / `C` / `Z` commands, conversion from SVG path data (arcs become cubics), segment
+ * math (evaluation, splitting, extrema, nearest point), exact areas, winding numbers and
+ * arc-length utilities.
+ */
+
+/** One absolute path command. Every subpath starts with `M`; `Z` closes it. */
+type BezierCommand = {
+    type: 'M';
+    x: number;
+    y: number;
+} | {
+    type: 'L';
+    x: number;
+    y: number;
+} | {
+    type: 'Q';
+    x1: number;
+    y1: number;
+    x: number;
+    y: number;
+} | {
+    type: 'C';
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    x: number;
+    y: number;
+} | {
+    type: 'Z';
+};
+/** A path as a list of absolute move / line / quadratic / cubic / close commands. */
+type BezierPath = BezierCommand[];
+/** Anything the path operations accept as a path: SVG path data, parsed commands or a `BezierPath`. */
+type BezierPathInput = string | readonly BezierCommand[] | readonly PathCommand[];
+/**
+ * One segment as its control points: 2 points for a line, 3 for a quadratic and 4 for a
+ * cubic Bézier.
+ */
+type BezierSegment = readonly Point[];
+/** A subpath as a chain of segments (each starts where the previous one ends). */
+interface BezierContour {
+    segments: BezierSegment[];
+    closed: boolean;
+}
+/** Point at parameter `t` (de Casteljau, works for any degree). */
+declare function segmentPoint(seg: BezierSegment, t: number): Point;
+/** First derivative at `t`. */
+declare function segmentDerivative(seg: BezierSegment, t: number): Point;
+/**
+ * Unit tangent at `t`. Where the derivative vanishes (a handle on its anchor) the direction
+ * a hair further along is used, and the chord as the last resort.
+ */
+declare function segmentTangent(seg: BezierSegment, t: number): Point;
+/** Signed curvature at `t` (positive when turning counter-clockwise in a y-up frame). */
+declare function segmentCurvature(seg: BezierSegment, t: number): number;
+/** Splits a segment at `t` (de Casteljau). */
+declare function splitSegment(seg: BezierSegment, t: number): [Point[], Point[]];
+/** The part of a segment between parameters `t0` and `t1` (reversed when `t1 < t0`). */
+declare function subSegment(seg: BezierSegment, t0: number, t1: number): Point[];
+/** Parameters in (0, 1) where the segment's `axis` coordinate has a local extremum. */
+declare function segmentExtrema(seg: BezierSegment, axis: 0 | 1): number[];
+/** Exact axis-aligned bounds of a segment. */
+declare function segmentBounds(seg: BezierSegment): {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+};
+/** Arc length of the segment between `t0` and `t1` (default the whole segment). */
+declare function segmentLength(seg: BezierSegment, t0?: number, t1?: number, tolerance?: number): number;
+/** Parameter at arc length `length` from the segment start (clamped to [0, 1]). */
+declare function segmentParamAtLength(seg: BezierSegment, length: number, total?: number): number;
+/**
+ * Nearest point of the segment to `p`: the parameter and the distance. Coarse sampling
+ * followed by Newton refinement around the best samples.
+ */
+declare function segmentNearest(seg: BezierSegment, p: Point): {
+    t: number;
+    distance: number;
+};
+/** Converts an SVG elliptical arc (SVG 1.1 F.6.5) to cubic segments, at most 90° each. */
+declare function arcToCubics(from: Point, cmd: {
+    rx: number;
+    ry: number;
+    rotation: number;
+    largeArc: boolean;
+    sweep: boolean;
+    x: number;
+    y: number;
+}): Point[][];
+/**
+ * Converts SVG path data or parsed commands to a `BezierPath` (absolute `M` / `L` / `Q` /
+ * `C` / `Z`); elliptical arcs become cubic Béziers (at most 90° each).
+ */
+declare function toBezierPath(input: BezierPathInput): BezierPath;
+/** Splits a path into contours of segments. Zero-length segments are dropped. */
+declare function pathToContours(input: BezierPathInput): BezierContour[];
+/** Builds a path from contours (a closed contour's closing line is left to `Z`). */
+declare function contoursToPath(contours: readonly BezierContour[]): BezierPath;
+interface BezierPathToSvgOptions {
+    /** Decimal places (default 3). */
+    precision?: number;
+    /** Added to every point before formatting. */
+    offset?: {
+        x: number;
+        y: number;
+    };
+}
+/** Writes a path as compact SVG path data. */
+declare function bezierPathToSvg(input: BezierPathInput, options?: BezierPathToSvgOptions): string;
+/** 2D affine matrix `[a, b, c, d, e, f]` mapping `(x, y)` to `(a x + c y + e, b x + d y + f)`. */
+type AffineMatrix = readonly [number, number, number, number, number, number];
+/** Applies an affine transform to every point (exact for Bézier curves). */
+declare function transformBezierPath(input: BezierPathInput, m: AffineMatrix): BezierPath;
+/** Number of drawing segments (`L` / `Q` / `C`, plus the closing line of `Z` when it has length). */
+declare function countPathSegments(input: BezierPathInput): {
+    lines: number;
+    quads: number;
+    cubics: number;
+};
+/** The contour's segments, with the closing line added when the contour is closed (or filled). */
+declare function closeContour(contour: BezierContour, force?: boolean): BezierSegment[];
+/** Exact bounds of a path, or `null` when it has no points. */
+declare function bezierPathBounds(input: BezierPathInput): {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+} | null;
+/**
+ * Signed area of the path as drawn: every subpath closed, contributions summed (positive
+ * for counter-clockwise subpaths in a y-up frame). Exact for curves. Overlapping subpaths
+ * count with their multiplicity; use `bezierPathArea` for the filled area.
+ */
+declare function bezierPathSignedArea(input: BezierPathInput): number;
+/** Signed area of a closed chain of segments. */
+declare function contourSignedArea(segs: readonly BezierSegment[]): number;
+/** Arc length of a path (closing lines of closed subpaths included). */
+declare function bezierPathLength(input: BezierPathInput): number;
+/** Point, unit tangent and angle (radians) at an arc length along the path. */
+interface PathPointAtLength {
+    point: Point;
+    tangent: Point;
+    angle: number;
+    /** Subpath index. */
+    contour: number;
+    /** Segment index within the subpath (closing line last). */
+    segment: number;
+    /** Parameter within the segment. */
+    t: number;
+}
+/**
+ * The point at arc length `length` from the start of the path (clamped to the path). Arc
+ * lengths run through the subpaths in order, as `bezierPathLength` counts them.
+ */
+declare function bezierPathPointAtLength(input: BezierPathInput, length: number): PathPointAtLength | null;
+/**
+ * Splits a segment chain by arc length: the part between `from` and `to` (measured from the
+ * chain's start) as new segments.
+ */
+declare function trimSegments(segs: readonly BezierSegment[], from: number, to: number, lengths?: number[]): Point[][];
+/**
+ * Winding number of a set of closed segment chains around `point` (ray to +x, half-open
+ * crossing rule). Points exactly on the outline may report either side.
+ */
+declare function windingNumber(chains: readonly (readonly BezierSegment[])[], point: Point): number;
+/** Whether `point` is inside the filled path (every subpath closed for filling). */
+declare function pointInBezierPath(input: BezierPathInput, point: Point, fillRule?: PolygonFillRule): boolean;
+/** Distance from `point` to the path outline (closing lines of closed subpaths included). */
+declare function distanceToBezierPath(input: BezierPathInput | readonly BezierContour[], point: Point): number;
+
+/**
+ * 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`), 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;
+}
+
+/**
+ * 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, segmentExtrema 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, intersectPaths as aA, intersectPolygons as aB, isCanvasGradient as aC, isShapeDescription as aD, multiPolygonArea as aE, multiPolygonBounds as aF, normalizeBezierPath as aG, offsetPath as aH, outlineStroke as aI, parseCssGradient as aJ, parseSvgPath as aK, pathBoolean as aL, pathBooleanSelect as aM, pathToContours as aN, pathfinder as aO, planarSplit as aP, pointInBezierPath as aQ, pointInMultiPolygon as aR, pointInRings as aS, polygonArea as aT, polygonBoolean as aU, polygonToSvgPath as aV, resolveCanvasGradient as aW, ringSignedArea as aX, segmentBounds as aY, segmentCurvature as aZ, segmentDerivative 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, contourSignedArea as am, contoursToPath as an, countPathSegments as ao, dashContours as ap, distanceToBezierPath as aq, dividePaths as ar, dividePolygons as as, excludePaths as at, flattenSvgPath as au, formatNumber as av, getShapeRenderData as aw, getShapeSvg as ax, gradientToSvgDef as ay, interiorPoint as az, type StrokeJoin as b, segmentIntersections as b0, segmentLength as b1, segmentNearest as b2, segmentParamAtLength as b3, segmentPoint as b4, segmentTangent as b5, shapeToPolygon as b6, simplifyRing as b7, splitSegment as b8, strokeOutlineRings as b9, subSegment as ba, subtractPaths as bb, subtractPolygons as bc, toBezierPath as bd, transformBezierPath as be, trimSegments as bf, unionPolygons as bg, unitePaths as bh, windingNumber as bi, xorPolygons as bj, 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 };