@pixerate/editor 0.35.0 → 0.37.0

package/dist/{bezier-D8bsO-L0.d.cts → stroke-CWjFKal4.d.cts}

@@ -544,4 +544,218 @@ declare function pointInBezierPath(input: BezierPathInput, point: Point, fillRul
 /** Distance from `point` to the path outline (closing lines of closed subpaths included). */
 declare function distanceToBezierPath(input: BezierPathInput | readonly BezierContour[], point: Point): number;
 
-export { formatNumber as $, type AffineMatrix as A, type BezierPathInput as B, type CanvasGradientDef as C, type ShapeRenderData as D, type EllipseShape as E, type FlattenOptions as F, type GetShapeRenderDataOptions as G, type StarShape as H, type SvgGradientStop as I, angleToSvgLinearCoords as J, arcToCubics as K, bezierPathBounds as L, type MultiPolygon as M, bezierPathLength as N, bezierPathPointAtLength as O, type PolygonBooleanOperation as P, bezierPathSignedArea as Q, type RectShape as R, type SvgGradientDef as S, bezierPathToSvg as T, closeContour as U, contourSignedArea as V, contoursToPath as W, countPathSegments as X, distanceToBezierPath as Y, dividePolygons as Z, flattenSvgPath as _, type BezierPath as a, getShapeRenderData as a0, getShapeSvg as a1, gradientToSvgDef as a2, intersectPolygons as a3, isCanvasGradient as a4, isShapeDescription as a5, multiPolygonArea as a6, multiPolygonBounds as a7, parseCssGradient as a8, parseSvgPath as a9, unionPolygons as aA, windingNumber as aB, xorPolygons as aC, pathToContours as aa, pointInBezierPath as ab, pointInMultiPolygon as ac, pointInRings as ad, polygonArea as ae, polygonBoolean as af, polygonToSvgPath as ag, resolveCanvasGradient as ah, ringSignedArea as ai, segmentBounds as aj, segmentCurvature as ak, segmentDerivative as al, segmentExtrema as am, segmentLength as an, segmentNearest as ao, segmentParamAtLength as ap, segmentPoint as aq, segmentTangent as ar, shapeToPolygon as as, simplifyRing as at, splitSegment as au, subSegment as av, subtractPolygons as aw, toBezierPath as ax, transformBezierPath as ay, trimSegments as az, type PolygonFillRule as b, type BezierSegment as c, type BezierContour as d, type ShapeDescription as e, type PolygonRing as f, type ShapeSize as g, type BezierCommand as h, type BezierPathToSvgOptions as i, CANVAS_GRADIENT_PRESETS as j, type CanvasLinearGradient as k, type CanvasRadialGradient as l, type GradientStop as m, type PathCommand as n, type PathPointAtLength as o, type PathShape as p, type PolygonBooleanOptions as q, type PolygonInput as r, type PolygonOperand as s, type PolygonPiece as t, type PolygonToPathOptions as u, type PolygonWithHoles as v, type RegularPolygonShape as w, SHAPE_KINDS as x, type ShapeKind as y, type ShapePaint as z };
+/**
+ * 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;
+
+/**
+ * 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;
+
+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 };

package/dist/{bezier-BvqVmWMg.d.ts → stroke-ysgaPpAo.d.ts}

@@ -544,4 +544,218 @@ declare function pointInBezierPath(input: BezierPathInput, point: Point, fillRul
 /** Distance from `point` to the path outline (closing lines of closed subpaths included). */
 declare function distanceToBezierPath(input: BezierPathInput | readonly BezierContour[], point: Point): number;
 
-export { formatNumber as $, type AffineMatrix as A, type BezierPathInput as B, type CanvasGradientDef as C, type ShapeRenderData as D, type EllipseShape as E, type FlattenOptions as F, type GetShapeRenderDataOptions as G, type StarShape as H, type SvgGradientStop as I, angleToSvgLinearCoords as J, arcToCubics as K, bezierPathBounds as L, type MultiPolygon as M, bezierPathLength as N, bezierPathPointAtLength as O, type PolygonBooleanOperation as P, bezierPathSignedArea as Q, type RectShape as R, type SvgGradientDef as S, bezierPathToSvg as T, closeContour as U, contourSignedArea as V, contoursToPath as W, countPathSegments as X, distanceToBezierPath as Y, dividePolygons as Z, flattenSvgPath as _, type BezierPath as a, getShapeRenderData as a0, getShapeSvg as a1, gradientToSvgDef as a2, intersectPolygons as a3, isCanvasGradient as a4, isShapeDescription as a5, multiPolygonArea as a6, multiPolygonBounds as a7, parseCssGradient as a8, parseSvgPath as a9, unionPolygons as aA, windingNumber as aB, xorPolygons as aC, pathToContours as aa, pointInBezierPath as ab, pointInMultiPolygon as ac, pointInRings as ad, polygonArea as ae, polygonBoolean as af, polygonToSvgPath as ag, resolveCanvasGradient as ah, ringSignedArea as ai, segmentBounds as aj, segmentCurvature as ak, segmentDerivative as al, segmentExtrema as am, segmentLength as an, segmentNearest as ao, segmentParamAtLength as ap, segmentPoint as aq, segmentTangent as ar, shapeToPolygon as as, simplifyRing as at, splitSegment as au, subSegment as av, subtractPolygons as aw, toBezierPath as ax, transformBezierPath as ay, trimSegments as az, type PolygonFillRule as b, type BezierSegment as c, type BezierContour as d, type ShapeDescription as e, type PolygonRing as f, type ShapeSize as g, type BezierCommand as h, type BezierPathToSvgOptions as i, CANVAS_GRADIENT_PRESETS as j, type CanvasLinearGradient as k, type CanvasRadialGradient as l, type GradientStop as m, type PathCommand as n, type PathPointAtLength as o, type PathShape as p, type PolygonBooleanOptions as q, type PolygonInput as r, type PolygonOperand as s, type PolygonPiece as t, type PolygonToPathOptions as u, type PolygonWithHoles as v, type RegularPolygonShape as w, SHAPE_KINDS as x, type ShapeKind as y, type ShapePaint as z };
+/**
+ * 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;
+
+/**
+ * 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;
+
+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 };