@pixerate/editor 0.36.0 → 0.38.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pixerate/editor",
-  "version": "0.36.0",
+  "version": "0.38.0",
   "description": "UI-agnostic rich text and media editing core library",
   "author": "Pixerate",
   "license": "MIT",

package/dist/bezier-BvqVmWMg.d.ts

@@ -1,547 +0,0 @@
-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;
-
-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 };