From cf28a769ab0f90b97fa9b5d81f164f9dbb883a3b Mon Sep 17 00:00:00 2001 From: Vlad Date: Tue, 4 Feb 2025 11:43:54 +0200 Subject: [PATCH 1/4] x --- dist/svg-path-commander.d.ts | 133 +- dist/util/util.d.cts | 1255 +++++++++++++ dist/util/util.d.ts | 1601 ---------------- package.json | 2 +- pnpm-lock.yaml | 3395 +++++++++++++++++----------------- vite.config-util.mts | 1 - 6 files changed, 3049 insertions(+), 3338 deletions(-) create mode 100644 dist/util/util.d.cts delete mode 100644 dist/util/util.d.ts diff --git a/dist/svg-path-commander.d.ts b/dist/svg-path-commander.d.ts index 0a10ef9..b8bd113 100644 --- a/dist/svg-path-commander.d.ts +++ b/dist/svg-path-commander.d.ts @@ -177,7 +177,7 @@ export declare type CubicSegment = CSegment | cSegment; export declare type CurveArray = [MSegment, ...CSegment[]]; -declare const defaultExport: typeof SVGPathCommander_2 & typeof util; +declare const defaultExport: typeof SVGPathCommander & typeof util; export default defaultExport; export declare type DeriveCallback = (t: number) => Point; @@ -446,7 +446,7 @@ export declare type sSegment = [sCommand, number, number, number, number]; * @author thednp * @returns a new SVGPathCommander instance */ -declare class SVGPathCommander_2 { +declare class SVGPathCommander { segments: PathArray; round: number | "off"; origin: [number, number, number]; @@ -727,6 +727,135 @@ declare namespace shapes { } +declare namespace simpleShapes { + let initial: string[]; + let normalized: string[]; + let transformed: string[]; + let scaled3d: string[]; + let skewedX: string[]; + let skewedY: string[]; + let reversed: string[]; + let length: number[]; + let width: number[]; + let height: number[]; + let pointAt0: { + x: number; + y: number; + }[]; + let pointAt400: { + x: number; + y: number; + }[]; + let pointAt50: { + x: number; + y: number; + }[]; +} + + +declare namespace shapes { + let initial: string[]; + let normalized: string[]; + let optimized: string[]; + let relative: string[]; + let absolute: string[]; + let curve: string[]; + let scaled: string[]; + let translated: string[]; + let length: number[]; + let pointAt50: { + x: number; + y: number; + }[]; +} + + +declare namespace simpleShapes { + let initial: string[]; + let normalized: string[]; + let transformed: string[]; + let scaled3d: string[]; + let skewedX: string[]; + let skewedY: string[]; + let reversed: string[]; + let length: number[]; + let width: number[]; + let height: number[]; + let pointAt0: { + x: number; + y: number; + }[]; + let pointAt400: { + x: number; + y: number; + }[]; + let pointAt50: { + x: number; + y: number; + }[]; +} + + +declare namespace shapes { + let initial: string[]; + let normalized: string[]; + let optimized: string[]; + let relative: string[]; + let absolute: string[]; + let curve: string[]; + let scaled: string[]; + let translated: string[]; + let length: number[]; + let pointAt50: { + x: number; + y: number; + }[]; +} + + +declare namespace simpleShapes { + let initial: string[]; + let normalized: string[]; + let transformed: string[]; + let scaled3d: string[]; + let skewedX: string[]; + let skewedY: string[]; + let reversed: string[]; + let length: number[]; + let width: number[]; + let height: number[]; + let pointAt0: { + x: number; + y: number; + }[]; + let pointAt400: { + x: number; + y: number; + }[]; + let pointAt50: { + x: number; + y: number; + }[]; +} + + +declare namespace shapes { + let initial: string[]; + let normalized: string[]; + let optimized: string[]; + let relative: string[]; + let absolute: string[]; + let curve: string[]; + let scaled: string[]; + let translated: string[]; + let length: number[]; + let pointAt50: { + x: number; + y: number; + }[]; +} + + declare namespace simpleShapes { let initial: string[]; let normalized: string[]; diff --git a/dist/util/util.d.cts b/dist/util/util.d.cts new file mode 100644 index 0000000..7d522ae --- /dev/null +++ b/dist/util/util.d.cts @@ -0,0 +1,1255 @@ +import CSSMatrix from '@thednp/dommatrix'; +export { default as CSSMatrix } from '@thednp/dommatrix'; + +type SegmentProperties = { + segment: PathSegment; + index: number; + length: number; + lengthAtSegment: number; +}; +type PointProperties = { + closest: { + x: number; + y: number; + }; + distance: number; + segment?: SegmentProperties; +}; +type LineAttr = { + type: "line"; + x1: number; + y1: number; + x2: number; + y2: number; + [key: string]: string | number; +}; +type PolyAttr = { + type: "polygon" | "polyline"; + points: string; + [key: string]: string | number; +}; +type CircleAttr = { + type: "circle"; + cx: number; + cy: number; + r: number; + [key: string]: string | number; +}; +type EllipseAttr = { + type: "ellipse"; + cx: number; + cy: number; + rx: number; + ry?: number; + [key: string]: string | number | undefined; +}; +type RectAttr = { + type: "rect"; + width: number; + height: number; + x: number; + y: number; + rx?: number; + ry?: number; + [key: string]: string | number | undefined; +}; +type GlyphAttr = { + type: "glyph"; + d: string; + [key: string]: string | number; +}; +type ShapeParams = { + line: ["x1", "y1", "x2", "y2"]; + circle: ["cx", "cy", "r"]; + ellipse: ["cx", "cy", "rx", "ry"]; + rect: ["width", "height", "x", "y", "rx", "ry"]; + polygon: ["points"]; + polyline: ["points"]; + glyph: ["d"]; +}; +type ParserParams = { + x1: number; + y1: number; + x2: number; + y2: number; + x: number; + y: number; + qx: number | null; + qy: number | null; +}; +type TransformObject = { + translate: number | number[]; + rotate: number | number[]; + scale: number | number[]; + skew: number | number[]; + origin: number[]; +}; + +type SpaceNumber = 0x1680 | 0x180e | 0x2000 | 0x2001 | 0x2002 | 0x2003 | 0x2004 | 0x2005 | 0x2006 | 0x2007 | 0x2008 | 0x2009 | 0x200a | 0x202f | 0x205f | 0x3000 | 0xfeff | 0x0a | 0x0d | 0x2028 | 0x2029 | 0x20 | 0x09 | 0x0b | 0x0c | 0xa0 | 0x1680; +type PathCommandNumber = 0x6d | 0x7a | 0x6c | 0x68 | 0x76 | 0x63 | 0x73 | 0x71 | 0x74 | 0x61; +type DigitNumber = 0x30 | 0x31 | 0x32 | 0x33 | 0x34 | 0x35 | 0x36 | 0x37 | 0x38 | 0x39; +type MCommand = "M"; +type mCommand = "m"; +type LCommand = "L"; +type lCommand = "l"; +type VCommand = "V"; +type vCommand = "v"; +type HCommand = "H"; +type hCommand = "h"; +type ZCommand = "Z"; +type zCommand = "z"; +type CCommand = "C"; +type cCommand = "c"; +type SCommand = "S"; +type sCommand = "s"; +type QCommand = "Q"; +type qCommand = "q"; +type TCommand = "T"; +type tCommand = "t"; +type ACommand = "A"; +type aCommand = "a"; +type AbsoluteCommand = MCommand | LCommand | VCommand | HCommand | ZCommand | CCommand | SCommand | QCommand | TCommand | ACommand; +type RelativeCommand = mCommand | lCommand | vCommand | hCommand | zCommand | cCommand | sCommand | qCommand | tCommand | aCommand; +type PathCommand = AbsoluteCommand | RelativeCommand; +type MSegment = [MCommand, number, number]; +type mSegment = [mCommand, number, number]; +type MoveSegment = MSegment | mSegment; +type LSegment = [LCommand, number, number]; +type lSegment = [lCommand, number, number]; +type LineSegment = LSegment | lSegment; +type VSegment = [VCommand, number]; +type vSegment = [vCommand, number]; +type VertLineSegment = vSegment | VSegment; +type HSegment = [HCommand, number]; +type hSegment = [hCommand, number]; +type HorLineSegment = HSegment | hSegment; +type ZSegment = [ZCommand]; +type zSegment = [zCommand]; +type CloseSegment = ZSegment | zSegment; +type CSegment = [ + CCommand, + number, + number, + number, + number, + number, + number +]; +type cSegment = [ + cCommand, + number, + number, + number, + number, + number, + number +]; +type CubicSegment = CSegment | cSegment; +type SSegment = [SCommand, number, number, number, number]; +type sSegment = [sCommand, number, number, number, number]; +type ShortCubicSegment = SSegment | sSegment; +type QSegment = [QCommand, number, number, number, number]; +type qSegment = [qCommand, number, number, number, number]; +type QuadSegment = QSegment | qSegment; +type TSegment = [TCommand, number, number]; +type tSegment = [tCommand, number, number]; +type ShortQuadSegment = TSegment | tSegment; +type ASegment = [ + ACommand, + number, + number, + number, + number, + number, + number, + number +]; +type aSegment = [ + aCommand, + number, + number, + number, + number, + number, + number, + number +]; +type ArcSegment = ASegment | aSegment; +type PathSegment = MoveSegment | LineSegment | VertLineSegment | HorLineSegment | CloseSegment | CubicSegment | ShortCubicSegment | QuadSegment | ShortQuadSegment | ArcSegment; +type ShortSegment = VertLineSegment | HorLineSegment | ShortCubicSegment | ShortQuadSegment | CloseSegment; +type AbsoluteSegment = MSegment | LSegment | VSegment | HSegment | CSegment | SSegment | QSegment | TSegment | ASegment | ZSegment; +type RelativeSegment = mSegment | lSegment | vSegment | hSegment | cSegment | sSegment | qSegment | tSegment | aSegment | zSegment; +type NormalSegment = MSegment | LSegment | CSegment | QSegment | ASegment | ZSegment; +type PathArray = [MSegment | mSegment, ...PathSegment[]]; +type AbsoluteArray = [MSegment, ...AbsoluteSegment[]]; +type RelativeArray = [MSegment, ...RelativeSegment[]]; +type NormalArray = [MSegment, ...NormalSegment[]]; +type CurveArray = [MSegment, ...CSegment[]]; +type ShapeTypes = SVGPolylineElement | SVGPolygonElement | SVGLineElement | SVGEllipseElement | SVGCircleElement | SVGRectElement; +type ShapeOps = LineAttr | PolyAttr | PolyAttr | EllipseAttr | CircleAttr | RectAttr | GlyphAttr; +type TransformObjectValues = Partial & { + origin: [number, number, number]; +}; +type Point = { + x: number; + y: number; +}; +type PointTuple = [number, number]; +type DerivedPoint = Point & { + t: number; +}; +type QuadPoints = [Point, Point, Point, Point, Point, Point]; +type CubicPoints = [ + Point, + Point, + Point, + Point, + Point, + Point, + Point, + Point +]; +type DerivedQuadPoints = [ + DerivedPoint, + DerivedPoint, + DerivedPoint, + DerivedPoint, + DerivedPoint, + DerivedPoint +]; +type DerivedCubicPoints = [ + DerivedPoint, + DerivedPoint, + DerivedPoint, + DerivedPoint, + DerivedPoint, + DerivedPoint, + DerivedPoint, + DerivedPoint +]; +type QuadCoordinates = [number, number, number, number, number, number]; +type CubicCoordinates = [ + number, + number, + number, + number, + number, + number, + number, + number +]; +type DeriveCallback = (t: number) => Point; +type IteratorCallback = (segment: PathSegment, index: number, lastX: number, lastY: number) => PathSegment | false | void | undefined; + +/** + * Returns the Arc segment length. + * @param rx radius along X axis + * @param ry radius along Y axis + * @param theta the angle in radians + * @returns the arc length + */ +declare const arcLength: (rx: number, ry: number, theta: number) => number; +/** + * Find point on ellipse at given angle around ellipse (theta); + * @param cx the center X + * @param cy the center Y + * @param rx the radius X + * @param ry the radius Y + * @param alpha the arc rotation angle in radians + * @param theta the arc sweep angle in radians + * @returns a point around ellipse at given angle + */ +declare const arcPoint: (cx: number, cy: number, rx: number, ry: number, alpha: number, theta: number) => PointTuple; +/** + * Returns the angle between two points. + * @param v0 starting point + * @param v1 ending point + * @returns the angle in radian + */ +declare const angleBetween: (v0: Point, v1: Point) => number; +/** + * Returns the following properties for an Arc segment: center, start angle, + * end angle, and radiuses on X and Y axis. + * + * @param x1 the starting point X + * @param y1 the starting point Y + * @param RX the radius on X axis + * @param RY the radius on Y axis + * @param angle the ellipse rotation in degrees + * @param LAF the large arc flag + * @param SF the sweep flag + * @param x2 the ending point X + * @param y2 the ending point Y + * @returns properties specific to Arc segments + */ +declare const getArcProps: (x1: number, y1: number, RX: number, RY: number, angle: number, LAF: number, SF: number, x: number, y: number) => { + rx: number; + ry: number; + startAngle: number; + endAngle: number; + center: { + x: number; + y: number; + }; +}; +/** + * Returns the length of an Arc segment. + * + * @param x1 the starting point X + * @param y1 the starting point Y + * @param c1x the first control point X + * @param c1y the first control point Y + * @param c2x the second control point X + * @param c2y the second control point Y + * @param x2 the ending point X + * @param y2 the ending point Y + * @returns the length of the Arc segment + */ +declare const getArcLength: (x1: number, y1: number, RX: number, RY: number, angle: number, LAF: number, SF: number, x: number, y: number) => number; +/** + * Returns a point along an Arc segment at a given distance. + * + * @param x1 the starting point X + * @param y1 the starting point Y + * @param RX the radius on X axis + * @param RY the radius on Y axis + * @param angle the ellipse rotation in degrees + * @param LAF the large arc flag + * @param SF the sweep flag + * @param x2 the ending point X + * @param y2 the ending point Y + * @param distance a [0-1] ratio + * @returns a point along the Arc segment + */ +declare const getPointAtArcLength: (x1: number, y1: number, RX: number, RY: number, angle: number, LAF: number, SF: number, x: number, y: number, distance?: number) => { + x: number; + y: number; +}; +/** + * Returns the extrema for an Arc segment in the following format: + * [MIN_X, MIN_Y, MAX_X, MAX_Y] + * + * @see https://github.com/herrstrietzel/svg-pathdata-getbbox + * + * @param x1 the starting point X + * @param y1 the starting point Y + * @param RX the radius on X axis + * @param RY the radius on Y axis + * @param angle the ellipse rotation in degrees + * @param LAF the large arc flag + * @param SF the sweep flag + * @param x2 the ending point X + * @param y2 the ending point Y + * @returns the extrema of the Arc segment + */ +declare const getArcBBox: (x1: number, y1: number, RX: number, RY: number, angle: number, LAF: number, SF: number, x: number, y: number) => [number, number, number, number]; + +declare const arcTools_angleBetween: typeof angleBetween; +declare const arcTools_arcLength: typeof arcLength; +declare const arcTools_arcPoint: typeof arcPoint; +declare const arcTools_getArcBBox: typeof getArcBBox; +declare const arcTools_getArcLength: typeof getArcLength; +declare const arcTools_getArcProps: typeof getArcProps; +declare const arcTools_getPointAtArcLength: typeof getPointAtArcLength; +declare namespace arcTools { + export { arcTools_angleBetween as angleBetween, arcTools_arcLength as arcLength, arcTools_arcPoint as arcPoint, arcTools_getArcBBox as getArcBBox, arcTools_getArcLength as getArcLength, arcTools_getArcProps as getArcProps, arcTools_getPointAtArcLength as getPointAtArcLength }; +} + +/** + * Tools from bezier.js by Mike 'Pomax' Kamermans + * @see https://github.com/Pomax/bezierjs + */ +declare const Tvalues: number[]; +declare const Cvalues: number[]; +/** + * @param points + * @returns + */ +declare const deriveBezier: (points: QuadPoints | CubicPoints) => (DerivedQuadPoints | DerivedCubicPoints)[]; +/** + * @param points + * @param t + */ +declare const computeBezier: (points: DerivedQuadPoints | DerivedCubicPoints, t: number) => DerivedPoint; +declare const calculateBezier: (derivativeFn: DeriveCallback, t: number) => number; +declare const bezierLength: (derivativeFn: DeriveCallback) => number; +/** + * Returns the length of CubicBezier / Quad segment. + * @param curve cubic / quad bezier segment + */ +declare const getBezierLength: (curve: CubicCoordinates | QuadCoordinates) => number; +declare const CBEZIER_MINMAX_EPSILON = 1e-8; +/** + * Returns the most extreme points in a Quad Bezier segment. + * @param A an array which consist of X/Y values + */ +declare const minmaxQ: ([v1, cp, v2]: [number, number, number]) => PointTuple; +/** + * Returns the most extreme points in a Cubic Bezier segment. + * @param A an array which consist of X/Y values + * @see https://github.com/kpym/SVGPathy/blob/acd1a50c626b36d81969f6e98e8602e128ba4302/lib/box.js#L127 + */ +declare const minmaxC: ([v1, cp1, cp2, v2]: [number, number, number, number]) => PointTuple; + +declare const bezier_CBEZIER_MINMAX_EPSILON: typeof CBEZIER_MINMAX_EPSILON; +declare const bezier_Cvalues: typeof Cvalues; +declare const bezier_Tvalues: typeof Tvalues; +declare const bezier_bezierLength: typeof bezierLength; +declare const bezier_calculateBezier: typeof calculateBezier; +declare const bezier_computeBezier: typeof computeBezier; +declare const bezier_deriveBezier: typeof deriveBezier; +declare const bezier_getBezierLength: typeof getBezierLength; +declare const bezier_minmaxC: typeof minmaxC; +declare const bezier_minmaxQ: typeof minmaxQ; +declare namespace bezier { + export { bezier_CBEZIER_MINMAX_EPSILON as CBEZIER_MINMAX_EPSILON, bezier_Cvalues as Cvalues, bezier_Tvalues as Tvalues, bezier_bezierLength as bezierLength, bezier_calculateBezier as calculateBezier, bezier_computeBezier as computeBezier, bezier_deriveBezier as deriveBezier, bezier_getBezierLength as getBezierLength, bezier_minmaxC as minmaxC, bezier_minmaxQ as minmaxQ }; +} + +/** + * Returns a point at a given length of a CubicBezier segment. + * + * @param x1 the starting point X + * @param y1 the starting point Y + * @param c1x the first control point X + * @param c1y the first control point Y + * @param c2x the second control point X + * @param c2y the second control point Y + * @param x2 the ending point X + * @param y2 the ending point Y + * @param t a [0-1] ratio + * @returns the point at cubic-bezier segment length + */ +declare const getPointAtCubicSegmentLength: ([x1, y1, c1x, c1y, c2x, c2y, x2, y2]: CubicCoordinates, t: number) => { + x: number; + y: number; +}; +/** + * Returns the length of a CubicBezier segment. + * + * @param x1 the starting point X + * @param y1 the starting point Y + * @param c1x the first control point X + * @param c1y the first control point Y + * @param c2x the second control point X + * @param c2y the second control point Y + * @param x2 the ending point X + * @param y2 the ending point Y + * @returns the CubicBezier segment length + */ +declare const getCubicLength: (x1: number, y1: number, c1x: number, c1y: number, c2x: number, c2y: number, x2: number, y2: number) => number; +/** + * Returns the point along a CubicBezier segment at a given distance. + * + * @param x1 the starting point X + * @param y1 the starting point Y + * @param c1x the first control point X + * @param c1y the first control point Y + * @param c2x the second control point X + * @param c2y the second control point Y + * @param x2 the ending point X + * @param y2 the ending point Y + * @param distance the distance to look at + * @returns the point at CubicBezier length + */ +declare const getPointAtCubicLength: (x1: number, y1: number, c1x: number, c1y: number, c2x: number, c2y: number, x2: number, y2: number, distance?: number) => { + x: number; + y: number; +}; +/** + * Returns the boundig box of a CubicBezier segment in the following format: + * [MIN_X, MIN_Y, MAX_X, MAX_Y] + * + * @param x1 the starting point X + * @param y1 the starting point Y + * @param c1x the first control point X + * @param c1y the first control point Y + * @param c2x the second control point X + * @param c2y the second control point Y + * @param x2 the ending point X + * @param y2 the ending point Y + * @returns the extrema of the CubicBezier segment + */ +declare const getCubicBBox: (x1: number, y1: number, c1x: number, c1y: number, c2x: number, c2y: number, x2: number, y2: number) => [number, number, number, number]; + +declare const cubicTools_getCubicBBox: typeof getCubicBBox; +declare const cubicTools_getCubicLength: typeof getCubicLength; +declare const cubicTools_getPointAtCubicLength: typeof getPointAtCubicLength; +declare const cubicTools_getPointAtCubicSegmentLength: typeof getPointAtCubicSegmentLength; +declare namespace cubicTools { + export { cubicTools_getCubicBBox as getCubicBBox, cubicTools_getCubicLength as getCubicLength, cubicTools_getPointAtCubicLength as getPointAtCubicLength, cubicTools_getPointAtCubicSegmentLength as getPointAtCubicSegmentLength }; +} + +/** + * Returns length for line segments (MoveTo, LineTo). + * + * @param x1 the starting point X + * @param y1 the starting point Y + * @param x2 the ending point X + * @param y2 the ending point Y + * @returns the line segment length + */ +declare const getLineLength: (x1: number, y1: number, x2: number, y2: number) => number; +/** + * Returns a point along the line segments (MoveTo, LineTo). + * + * @param x1 the starting point X + * @param y1 the starting point Y + * @param x2 the ending point X + * @param y2 the ending point Y + * @param distance the distance to point in [0-1] range + * @returns the point at length + */ +declare const getPointAtLineLength: (x1: number, y1: number, x2: number, y2: number, distance?: number) => { + x: number; + y: number; +}; +/** + * Returns bounding box for line segments (MoveTo, LineTo). + * + * @param x1 the starting point X + * @param y1 the starting point Y + * @param x2 the ending point X + * @param y2 the ending point Y + * @param distance the distance to point in [0-1] range + * @returns the extrema for line segments + */ +declare const getLineBBox: (x1: number, y1: number, x2: number, y2: number) => [number, number, number, number]; + +declare const lineTools_getLineBBox: typeof getLineBBox; +declare const lineTools_getLineLength: typeof getLineLength; +declare const lineTools_getPointAtLineLength: typeof getPointAtLineLength; +declare namespace lineTools { + export { lineTools_getLineBBox as getLineBBox, lineTools_getLineLength as getLineLength, lineTools_getPointAtLineLength as getPointAtLineLength }; +} + +/** + * Returns the {x,y} coordinates of a point at a + * given length of a quadratic-bezier segment. + * + * @see https://github.com/substack/point-at-length + * + * @param x1 the starting point X + * @param y1 the starting point Y + * @param cx the control point X + * @param cy the control point Y + * @param x2 the ending point X + * @param y2 the ending point Y + * @param t a [0-1] ratio + * @returns the requested {x,y} coordinates + */ +declare const getPointAtQuadSegmentLength: ([x1, y1, cx, cy, x2, y2]: QuadCoordinates, t: number) => { + x: number; + y: number; +}; +/** + * Returns the length of a QuadraticBezier segment. + * + * @param x1 the starting point X + * @param y1 the starting point Y + * @param cx the control point X + * @param cy the control point Y + * @param x2 the ending point X + * @param y2 the ending point Y + * @returns the QuadraticBezier segment length + */ +declare const getQuadLength: (x1: number, y1: number, cx: number, cy: number, x2: number, y2: number) => number; +/** + * Returns the point along a QuadraticBezier segment at a given distance. + * + * @param x1 the starting point X + * @param y1 the starting point Y + * @param cx the control point X + * @param cy the control point Y + * @param x2 the ending point X + * @param y2 the ending point Y + * @param distance the distance to look at + * @returns the point at QuadraticBezier length + */ +declare const getPointAtQuadLength: (x1: number, y1: number, cx: number, cy: number, x2: number, y2: number, distance?: number) => { + x: number; + y: number; +}; +/** + * Returns the boundig box of a QuadraticBezier segment in the following format: + * [MIN_X, MIN_Y, MAX_X, MAX_Y] + * + * @param x1 the starting point X + * @param y1 the starting point Y + * @param cx the control point X + * @param cy the control point Y + * @param x2 the ending point X + * @param y2 the ending point Y + * @returns the extrema of the QuadraticBezier segment + */ +declare const getQuadBBox: (x1: number, y1: number, cx: number, cy: number, x2: number, y2: number) => [number, number, number, number]; + +declare const quadTools_getPointAtQuadLength: typeof getPointAtQuadLength; +declare const quadTools_getPointAtQuadSegmentLength: typeof getPointAtQuadSegmentLength; +declare const quadTools_getQuadBBox: typeof getQuadBBox; +declare const quadTools_getQuadLength: typeof getQuadLength; +declare namespace quadTools { + export { quadTools_getPointAtQuadLength as getPointAtQuadLength, quadTools_getPointAtQuadSegmentLength as getPointAtQuadSegmentLength, quadTools_getQuadBBox as getQuadBBox, quadTools_getQuadLength as getQuadLength }; +} + +/** + * d3-polygon-area + * https://github.com/d3/d3-polygon + * + * Returns the area of a polygon. + * + * @param polygon an array of coordinates + * @returns the polygon area + */ +declare const polygonArea: (polygon: PointTuple[]) => number; +/** + * d3-polygon-length + * https://github.com/d3/d3-polygon + * + * Returns the perimeter of a polygon. + * + * @param polygon an array of coordinates + * @returns the polygon length + */ +declare const polygonLength: (polygon: PointTuple[]) => number; + +declare const polygonTools_polygonArea: typeof polygonArea; +declare const polygonTools_polygonLength: typeof polygonLength; +declare namespace polygonTools { + export { polygonTools_polygonArea as polygonArea, polygonTools_polygonLength as polygonLength }; +} + +/** + * Parses a path string value or object and returns an array + * of segments, all converted to absolute values. + * + * @param pathInput the path string | object + * @returns the resulted `pathArray` with absolute values + */ +declare const pathToAbsolute: (pathInput: string | PathArray) => AbsoluteArray; + +/** + * Parses a path string value or object and returns an array + * of segments, all converted to relative values. + * + * @param pathInput the path string | object + * @returns the resulted `pathArray` with relative values + */ +declare const pathToRelative: (pathInput: string | PathArray) => RelativeArray; + +/** + * Parses a path string value or 'pathArray' and returns a new one + * in which all segments are converted to cubic-bezier. + * + * In addition, un-necessary `Z` segment is removed if previous segment + * extends to the `M` segment. + * + * @param pathInput the string to be parsed or 'pathArray' + * @returns the resulted `pathArray` converted to cubic-bezier + */ +declare const pathToCurve: (pathInput: string | PathArray) => CurveArray; + +/** + * Returns a valid `d` attribute string value created + * by rounding values and concatenating the `pathArray` segments. + * + * @param path the `pathArray` object + * @param roundOption amount of decimals to round values to + * @returns the concatenated path string + */ +declare const pathToString: (path: PathArray, roundOption?: number | "off") => string; + +/** + * Returns the square root of the distance + * between two given points. + * + * @param a the first point coordinates + * @param b the second point coordinates + * @returns the distance value + */ +declare const distanceSquareRoot: (a: PointTuple, b: PointTuple) => number; + +/** + * Returns the coordinates of a specified distance + * ratio between two points. + * + * @param a the first point coordinates + * @param b the second point coordinates + * @param t the ratio + * @returns the midpoint coordinates + */ +declare const midPoint: (a: PointTuple, b: PointTuple, t: number) => PointTuple; + +/** + * Returns an {x,y} vector rotated by a given + * angle in radian. + * + * @param x the initial vector x + * @param y the initial vector y + * @param rad the radian vector angle + * @returns the rotated vector + */ +declare const rotateVector: (x: number, y: number, rad: number) => { + x: number; + y: number; +}; + +declare const roundTo: (n: number, round: number) => number; + +/** + * Parses a path string value and returns an array + * of segments we like to call `pathArray`. + * + * @param pathInput the string to be parsed + * @returns the resulted `pathArray` or error string + */ +declare const parsePathString: (pathInput: string | T) => PathArray; + +/** + * The `PathParser` is used by the `parsePathString` static method + * to generate a `pathArray`. + * + * @param pathString + */ +declare class PathParser { + segments: PathArray | PathSegment[]; + pathValue: string; + max: number; + index: number; + param: number; + segmentStart: number; + data: (string | number)[]; + err: string; + constructor(pathString: string); +} + +/** + * Breaks the parsing of a pathString once a segment is finalized. + * + * @param path the `PathParser` instance + */ +declare const finalizeSegment: (path: PathParser) => void; + +declare const invalidPathValue = "Invalid path value"; + +/** + * Checks if the character is an A (arc-to) path command. + * + * @param code the character to check + * @returns check result + */ +declare const isArcCommand: (code: number) => code is 97; + +/** + * Checks if a character is a digit. + * + * @param code the character to check + * @returns check result + */ +declare const isDigit: (code: number) => code is DigitNumber; + +/** + * Checks if the character is or belongs to a number. + * [0-9]|+|-|. + * + * @param code the character to check + * @returns check result + */ +declare const isDigitStart: (code: number) => code is DigitNumber | 43 | 45 | 46; + +/** + * Checks if the character is a MoveTo command. + * + * @param code the character to check + * @returns check result + */ +declare const isMoveCommand: (code: number) => code is 109 | 77; + +/** + * Checks if the character is a path command. + * + * @param code the character to check + * @returns check result + */ +declare const isPathCommand: (code: number) => code is PathCommandNumber; + +/** + * Checks if the character is a space. + * + * @param ch the character to check + * @returns check result + */ +declare const isSpace: (ch: number) => ch is SpaceNumber; + +/** Segment params length */ +declare const paramsCount: { + a: number; + c: number; + h: number; + l: number; + m: number; + r: number; + q: number; + s: number; + t: number; + v: number; + z: number; +}; + +declare const paramsParser: ParserParams; + +/** + * Validates an A (arc-to) specific path command value. + * Usually a `large-arc-flag` or `sweep-flag`. + * + * @param path the `PathParser` instance + */ +declare const scanFlag: (path: PathParser) => void; + +/** + * Validates every character of the path string, + * every path command, negative numbers or floating point numbers. + * + * @param path the `PathParser` instance + */ +declare const scanParam: (path: PathParser) => void; + +/** + * Scans every character in the path string to determine + * where a segment starts and where it ends. + * + * @param path the `PathParser` instance + */ +declare const scanSegment: (path: PathParser) => void; + +/** + * Points the parser to the next character in the + * path string every time it encounters any kind of + * space character. + * + * @param path the `PathParser` instance + */ +declare const skipSpaces: (path: PathParser) => void; + +declare const DISTANCE_EPSILON = 0.00001; + +/** + * Returns the point in path closest to a given point. + * + * @param pathInput target `pathArray` + * @param point the given point + * @returns the best match + */ +declare const getClosestPoint: (pathInput: string | PathArray, point: { + x: number; + y: number; +}) => { + x: number; + y: number; +}; + +/** + * Check if a path is drawn clockwise and returns true if so, + * false otherwise. + * + * @param path the path string or `pathArray` + * @returns true when clockwise or false if not + */ +declare const getDrawDirection: (path: string | PathArray) => boolean; + +/** + * Returns the area of a shape. + * + * @author Jürg Lehni & Jonathan Puckey + * + * @see https://github.com/paperjs/paper.js/blob/develop/src/path/Path.js + * + * @param path the shape `pathArray` + * @returns the length of the cubic-bezier segment + */ +declare const getPathArea: (path: PathArray) => number; + +declare const getPathBBox: (pathInput: PathArray | string) => { + x: number; + y: number; + width: number; + height: number; + x2: number; + y2: number; + cx: number; + cy: number; + cz: number; +}; + +/** + * Returns [x,y] coordinates of a point at a given length of a shape. + * + * @param pathInput the `pathArray` to look into + * @param distance the length of the shape to look at + * @returns the requested {x, y} point coordinates + */ +declare const getPointAtLength: (pathInput: string | PathArray, distance?: number) => { + x: number; + y: number; +}; + +/** + * Returns the segment, its index and length as well as + * the length to that segment at a given length in a path. + * + * @param pathInput target `pathArray` + * @param distance the given length + * @returns the requested properties + */ +declare const getPropertiesAtLength: (pathInput: string | PathArray, distance?: number) => SegmentProperties; + +/** + * Returns the point and segment in path closest to a given point as well as + * the distance to the path stroke. + * + * @see https://bl.ocks.org/mbostock/8027637 + * + * @param pathInput target `pathArray` + * @param point the given point + * @returns the requested properties + */ +declare const getPropertiesAtPoint: (pathInput: string | PathArray, point: Point) => PointProperties; + +/** + * Returns the segment at a given length. + * + * @param pathInput the target `pathArray` + * @param distance the distance in path to look at + * @returns the requested segment + */ +declare const getSegmentAtLength: (pathInput: string | PathArray, distance?: number) => PathSegment | undefined; + +/** + * Returns the path segment which contains a given point. + * + * @param path the `pathArray` to look into + * @param point the point of the shape to look for + * @returns the requested segment + */ +declare const getSegmentOfPoint: (path: string | PathArray, point: { + x: number; + y: number; +}) => SegmentProperties | undefined; + +/** + * Returns the shape total length, or the equivalent to `shape.getTotalLength()`. + * + * @param pathInput the target `pathArray` + * @returns the shape total length + */ +declare const getTotalLength: (pathInput: string | PathArray) => number; + +/** + * Iterates an array to check if it's a `pathArray` + * with all absolute values. + * + * @param path the `pathArray` to be checked + * @returns iteration result + */ +declare const isAbsoluteArray: (path: unknown) => path is AbsoluteArray; + +/** + * Iterates an array to check if it's a `pathArray` + * with all C (cubic bezier) segments. + * + * @param path the `Array` to be checked + * @returns iteration result + */ +declare const isCurveArray: (path: unknown) => path is CurveArray; + +/** + * Iterates an array to check if it's a `pathArray` + * with all segments are in non-shorthand notation + * with absolute values. + * + * @param {string | SVGPath.pathArray} path the `pathArray` to be checked + * @returns {boolean} iteration result + */ +declare const isNormalizedArray: (path: unknown) => path is NormalArray; + +/** + * Iterates an array to check if it's an actual `pathArray`. + * + * @param path the `pathArray` to be checked + * @returns iteration result + */ +declare const isPathArray: (path: unknown) => path is PathArray; + +/** + * Checks if a given point is in the stroke of a path. + * + * @param pathInput target path + * @param point the given `{x,y}` point + * @returns the query result + */ +declare const isPointInStroke: (pathInput: string | PathArray, point: { + x: number; + y: number; +}) => boolean; + +/** + * Iterates an array to check if it's a `pathArray` + * with relative values. + * + * @param path the `pathArray` to be checked + * @returns iteration result + */ +declare const isRelativeArray: (path: unknown) => path is RelativeArray; + +/** + * Parses a path string value to determine its validity + * then returns true if it's valid or false otherwise. + * + * @param pathString the path string to be parsed + * @returns the path string validity + */ +declare const isValidPath: (pathString: string) => boolean; + +/** + * Supported shapes and their specific parameters. + */ +declare const shapeParams: ShapeParams; + +/** + * Returns a new `` element created from attributes of a ``, ``, + * ``, ``, ``, `` or ``. If `replace` parameter + * is `true`, it will replace the target. The default `ownerDocument` is your current + * `document` browser page, if you want to use in server-side using `jsdom`, you can + * pass the `jsdom` `document` to `ownDocument`. + * + * It can also work with an options object, see the type below + * @see ShapeOps + * + * The newly created `` element keeps all non-specific + * attributes like `class`, `fill`, etc. + * + * @param element target shape + * @param replace option to replace target + * @param ownerDocument document for create element + * @return the newly created `` element + */ +declare const shapeToPath: (element: ShapeTypes | ShapeOps, replace?: boolean, ownerDocument?: Document) => SVGPathElement | false; + +/** + * Returns a new `pathArray` created from attributes of a ``, ``, + * ``, ``, ``, ``, or ``. + * + * It can also work with an options object, see the type below + * @see ShapeOps + * + * @param element target shape + * @return the newly created `` element + */ +declare const shapeToPathArray: (element: ShapeTypes | ShapeOps) => false | PathArray; + +/** + * Returns an absolute segment of a `PathArray` object. + * + * @param segment the segment object + * @param index the segment index + * @param lastX the last known X value + * @param lastY the last known Y value + * @returns the absolute segment + */ +declare const absolutizeSegment: (segment: PathSegment, index: number, lastX: number, lastY: number) => AbsoluteSegment; + +/** + * Converts A (arc-to) segments to C (cubic-bezier-to). + * + * For more information of where this math came from visit: + * http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes + * + * @param X1 the starting x position + * @param Y1 the starting y position + * @param RX x-radius of the arc + * @param RY y-radius of the arc + * @param angle x-axis-rotation of the arc + * @param LAF large-arc-flag of the arc + * @param SF sweep-flag of the arc + * @param X2 the ending x position + * @param Y2 the ending y position + * @param recursive the parameters needed to split arc into 2 segments + * @return the resulting cubic-bezier segment(s) + */ +declare const arcToCubic: (X1: number, Y1: number, RX: number, RY: number, angle: number, LAF: number, SF: number, X2: number, Y2: number, recursive?: [number, number, number, number]) => number[]; + +/** + * Returns a transformation matrix to apply to `` elements. + * + * @see TransformObjectValues + * + * @param transform the `transformObject` + * @returns a new transformation matrix + */ +declare const getSVGMatrix: (transform: TransformObjectValues) => CSSMatrix; + +declare const iterate: (path: PathArray, iterator: IteratorCallback) => T; + +/** + * Converts an L (line-to) segment to C (cubic-bezier). + * + * @param x1 line start x + * @param y1 line start y + * @param x2 line end x + * @param y2 line end y + * @returns the cubic-bezier segment + */ +declare const lineToCubic: (x1: number, y1: number, x2: number, y2: number) => number[]; + +/** + * Normalizes a `pathArray` object for further processing: + * * convert segments to absolute values + * * convert shorthand path commands to their non-shorthand notation + * + * @param pathInput the string to be parsed or 'pathArray' + * @returns the normalized `pathArray` + */ +declare const normalizePath: (pathInput: string | PathArray) => NormalArray; + +/** + * Normalizes a single segment of a `pathArray` object. + * + * @param segment the segment object + * @param params the normalization parameters + * @returns the normalized segment + */ +declare const normalizeSegment: (segment: PathSegment, params: ParserParams) => NormalSegment; + +/** + * Optimizes a `pathArray` object: + * * convert segments to shorthand if possible + * * select shortest segments from absolute and relative `pathArray`s + * + * @param pathInput a string or `pathArray` + * @param roundOption the amount of decimals to round values to + * @returns the optimized `pathArray` + */ +declare const optimizePath: (pathInput: PathArray, roundOption?: number) => PathArray; + +/** + * Returns the [x,y] projected coordinates for a given an [x,y] point + * and an [x,y,z] perspective origin point. + * + * Equation found here => + * http://en.wikipedia.org/wiki/3D_projection#Diagram + * Details => + * https://stackoverflow.com/questions/23792505/predicted-rendering-of-css-3d-transformed-pixel + * + * @param m the transformation matrix + * @param point2D the initial [x,y] coordinates + * @param origin the [x,y,z] transform origin + * @returns the projected [x,y] coordinates + */ +declare const projection2d: (m: CSSMatrix, point2D: PointTuple, origin: [number, number, number]) => PointTuple; + +/** + * Converts a Q (quadratic-bezier) segment to C (cubic-bezier). + * + * @param x1 curve start x + * @param y1 curve start y + * @param qx control point x + * @param qy control point y + * @param x2 curve end x + * @param y2 curve end y + * @returns the cubic-bezier segment + */ +declare const quadToCubic: (x1: number, y1: number, qx: number, qy: number, x2: number, y2: number) => [number, number, number, number, number, number]; + +/** + * Returns a relative segment of a `PathArray` object. + * + * @param segment the segment object + * @param index the segment index + * @param lastX the last known X value + * @param lastY the last known Y value + * @returns the relative segment + */ +declare const relativizeSegment: (segment: PathSegment, index: number, lastX: number, lastY: number) => MSegment | RelativeSegment; + +/** + * Reverses all segments of a `pathArray` + * which consists of only C (cubic-bezier) path commands. + * + * @param path the source `pathArray` + * @returns the reversed `pathArray` + */ +declare const reverseCurve: (path: CurveArray) => CurveArray; + +/** + * Reverses all segments of a `pathArray` and returns a new `pathArray` instance + * with absolute values. + * + * @param pathInput the source `pathArray` + * @returns the reversed `pathArray` + */ +declare const reversePath: (pathInput: PathArray) => PathArray; + +/** + * Rounds the values of a `pathArray` instance to + * a specified amount of decimals and returns it. + * + * @param path the source `pathArray` + * @param roundOption the amount of decimals to round numbers to + * @returns the resulted `pathArray` with rounded values + */ +declare const roundPath: (path: PathArray, roundOption?: number | "off") => PathArray; + +declare const roundSegment: (segment: T, roundOption: number) => T; + +/** + * Converts any segment to C (cubic-bezier). + * + * @param segment the source segment + * @param params the source segment parameters + * @returns the cubic-bezier segment + */ +declare const segmentToCubic: (segment: PathSegment, params: ParserParams) => MSegment | CSegment; + +/** + * Shorten a single segment of a `pathArray` object. + * + * @param segment the `absoluteSegment` object + * @param normalSegment the `normalSegment` object + * @param params the coordinates of the previous segment + * @param prevCommand the path command of the previous segment + * @returns the shortened segment + */ +declare const shortenSegment: (segment: AbsoluteSegment, normalSegment: NormalSegment, params: ParserParams, prevCommand: PathCommand) => ShortSegment; + +/** + * Split a cubic-bezier segment into two. + * + * @param pts the cubic-bezier parameters + * @param ratio the cubic-bezier parameters + * @return two new cubic-bezier segments + */ +declare const splitCubic: (pts: number[], ratio?: number) => [CubicSegment, CubicSegment]; + +/** + * Split a path into an `Array` of sub-path strings. + * + * In the process, values are converted to absolute + * for visual consistency. + * + * @param pathInput the source `pathArray` + * @return an array with all sub-path strings + */ +declare const splitPath: (pathInput: PathArray) => PathArray[]; + +/** + * Apply a 2D / 3D transformation to a `pathArray` instance. + * + * Since *SVGElement* doesn't support 3D transformation, this function + * creates a 2D projection of the element. + * + * @param path the `pathArray` to apply transformation + * @param transform the transform functions `Object` + * @returns the resulted `pathArray` + */ +declare const transformPath: (pathInput: PathArray | string, transform?: Partial) => PathArray; + +export { absolutizeSegment, arcToCubic, arcTools, bezier as bezierTools, cubicTools, DISTANCE_EPSILON as distanceEpsilon, distanceSquareRoot, finalizeSegment, getClosestPoint, getDrawDirection, getPathArea, getPathBBox, getPointAtLength, getPropertiesAtLength, getPropertiesAtPoint, getSVGMatrix, getSegmentAtLength, getSegmentOfPoint, getTotalLength, invalidPathValue, isAbsoluteArray, isArcCommand, isCurveArray, isDigit, isDigitStart, isMoveCommand, isNormalizedArray, isPathArray, isPathCommand, isPointInStroke, isRelativeArray, isSpace, isValidPath, iterate, lineToCubic, lineTools, midPoint, normalizePath, normalizeSegment, optimizePath, paramsCount, paramsParser, parsePathString, PathParser as pathParser, pathToAbsolute, pathToCurve, pathToRelative, pathToString, polygonTools, projection2d, quadToCubic, quadTools, relativizeSegment, reverseCurve, reversePath, rotateVector, roundPath, roundSegment, roundTo, scanFlag, scanParam, scanSegment, segmentToCubic, shapeParams, shapeToPath, shapeToPathArray, shortenSegment, skipSpaces, splitCubic, splitPath, transformPath }; diff --git a/dist/util/util.d.ts b/dist/util/util.d.ts deleted file mode 100644 index 8a7fcdc..0000000 --- a/dist/util/util.d.ts +++ /dev/null @@ -1,1601 +0,0 @@ -declare module "interface" { - import type { PathSegment } from "types"; - export type SegmentProperties = { - segment: PathSegment; - index: number; - length: number; - lengthAtSegment: number; - }; - export type PointProperties = { - closest: { - x: number; - y: number; - }; - distance: number; - segment?: SegmentProperties; - }; - export type LineAttr = { - type: "line"; - x1: number; - y1: number; - x2: number; - y2: number; - [key: string]: string | number; - }; - export type PolyAttr = { - type: "polygon" | "polyline"; - points: string; - [key: string]: string | number; - }; - export type CircleAttr = { - type: "circle"; - cx: number; - cy: number; - r: number; - [key: string]: string | number; - }; - export type EllipseAttr = { - type: "ellipse"; - cx: number; - cy: number; - rx: number; - ry?: number; - [key: string]: string | number | undefined; - }; - export type RectAttr = { - type: "rect"; - width: number; - height: number; - x: number; - y: number; - rx?: number; - ry?: number; - [key: string]: string | number | undefined; - }; - export type GlyphAttr = { - type: "glyph"; - d: string; - [key: string]: string | number; - }; - export type ShapeParams = { - line: ["x1", "y1", "x2", "y2"]; - circle: ["cx", "cy", "r"]; - ellipse: ["cx", "cy", "rx", "ry"]; - rect: ["width", "height", "x", "y", "rx", "ry"]; - polygon: ["points"]; - polyline: ["points"]; - glyph: ["d"]; - }; - export type PathBBox = { - width: number; - height: number; - x: number; - y: number; - x2: number; - y2: number; - cx: number; - cy: number; - cz: number; - }; - export type SegmentLimits = { - min: { - x: number; - y: number; - }; - max: { - x: number; - y: number; - }; - }; - export type ParserParams = { - x1: number; - y1: number; - x2: number; - y2: number; - x: number; - y: number; - qx: number | null; - qy: number | null; - }; - export type LengthFactory = { - length: number; - point: { - x: number; - y: number; - }; - min: { - x: number; - y: number; - }; - max: { - x: number; - y: number; - }; - }; - export type Options = { - round: "off" | number; - origin: number[]; - }; - export type PathTransform = { - s: PathSegment; - c: string; - x: number; - y: number; - }; - export type TransformObject = { - translate: number | number[]; - rotate: number | number[]; - scale: number | number[]; - skew: number | number[]; - origin: number[]; - }; - export type TransformProps = keyof TransformObject; - export type TransformEntries = [ - TransformProps, - TransformObject[TransformProps] - ][]; -} -declare module "types" { - import type { CircleAttr, EllipseAttr, GlyphAttr, LineAttr, PolyAttr, RectAttr, TransformObject } from "interface"; - export type SpaceNumber = 0x1680 | 0x180e | 0x2000 | 0x2001 | 0x2002 | 0x2003 | 0x2004 | 0x2005 | 0x2006 | 0x2007 | 0x2008 | 0x2009 | 0x200a | 0x202f | 0x205f | 0x3000 | 0xfeff | 0x0a | 0x0d | 0x2028 | 0x2029 | 0x20 | 0x09 | 0x0b | 0x0c | 0xa0 | 0x1680; - export type PathCommandNumber = 0x6d | 0x7a | 0x6c | 0x68 | 0x76 | 0x63 | 0x73 | 0x71 | 0x74 | 0x61; - export type DigitNumber = 0x30 | 0x31 | 0x32 | 0x33 | 0x34 | 0x35 | 0x36 | 0x37 | 0x38 | 0x39; - export type MCommand = "M"; - export type mCommand = "m"; - export type LCommand = "L"; - export type lCommand = "l"; - export type VCommand = "V"; - export type vCommand = "v"; - export type HCommand = "H"; - export type hCommand = "h"; - export type ZCommand = "Z"; - export type zCommand = "z"; - export type CCommand = "C"; - export type cCommand = "c"; - export type SCommand = "S"; - export type sCommand = "s"; - export type QCommand = "Q"; - export type qCommand = "q"; - export type TCommand = "T"; - export type tCommand = "t"; - export type ACommand = "A"; - export type aCommand = "a"; - export type AbsoluteCommand = MCommand | LCommand | VCommand | HCommand | ZCommand | CCommand | SCommand | QCommand | TCommand | ACommand; - export type RelativeCommand = mCommand | lCommand | vCommand | hCommand | zCommand | cCommand | sCommand | qCommand | tCommand | aCommand; - export type PathCommand = AbsoluteCommand | RelativeCommand; - export type MSegment = [MCommand, number, number]; - export type mSegment = [mCommand, number, number]; - export type MoveSegment = MSegment | mSegment; - export type LSegment = [LCommand, number, number]; - export type lSegment = [lCommand, number, number]; - export type LineSegment = LSegment | lSegment; - export type VSegment = [VCommand, number]; - export type vSegment = [vCommand, number]; - export type VertLineSegment = vSegment | VSegment; - export type HSegment = [HCommand, number]; - export type hSegment = [hCommand, number]; - export type HorLineSegment = HSegment | hSegment; - export type ZSegment = [ZCommand]; - export type zSegment = [zCommand]; - export type CloseSegment = ZSegment | zSegment; - export type CSegment = [ - CCommand, - number, - number, - number, - number, - number, - number - ]; - export type cSegment = [ - cCommand, - number, - number, - number, - number, - number, - number - ]; - export type CubicSegment = CSegment | cSegment; - export type SSegment = [SCommand, number, number, number, number]; - export type sSegment = [sCommand, number, number, number, number]; - export type ShortCubicSegment = SSegment | sSegment; - export type QSegment = [QCommand, number, number, number, number]; - export type qSegment = [qCommand, number, number, number, number]; - export type QuadSegment = QSegment | qSegment; - export type TSegment = [TCommand, number, number]; - export type tSegment = [tCommand, number, number]; - export type ShortQuadSegment = TSegment | tSegment; - export type ASegment = [ - ACommand, - number, - number, - number, - number, - number, - number, - number - ]; - export type aSegment = [ - aCommand, - number, - number, - number, - number, - number, - number, - number - ]; - export type ArcSegment = ASegment | aSegment; - export type PathSegment = MoveSegment | LineSegment | VertLineSegment | HorLineSegment | CloseSegment | CubicSegment | ShortCubicSegment | QuadSegment | ShortQuadSegment | ArcSegment; - export type ShortSegment = VertLineSegment | HorLineSegment | ShortCubicSegment | ShortQuadSegment | CloseSegment; - export type AbsoluteSegment = MSegment | LSegment | VSegment | HSegment | CSegment | SSegment | QSegment | TSegment | ASegment | ZSegment; - export type RelativeSegment = mSegment | lSegment | vSegment | hSegment | cSegment | sSegment | qSegment | tSegment | aSegment | zSegment; - export type NormalSegment = MSegment | LSegment | CSegment | QSegment | ASegment | ZSegment; - export type PathArray = [MSegment | mSegment, ...PathSegment[]]; - export type AbsoluteArray = [MSegment, ...AbsoluteSegment[]]; - export type RelativeArray = [MSegment, ...RelativeSegment[]]; - export type NormalArray = [MSegment, ...NormalSegment[]]; - export type CurveArray = [MSegment, ...CSegment[]]; - export type PolygonArray = [MSegment, ...LSegment[], ZSegment]; - export type PolylineArray = [MSegment, ...LSegment[]]; - export type ShapeTypes = SVGPolylineElement | SVGPolygonElement | SVGLineElement | SVGEllipseElement | SVGCircleElement | SVGRectElement; - export type ShapeTags = "line" | "polyline" | "polygon" | "ellipse" | "circle" | "rect" | "glyph"; - export type ShapeOps = LineAttr | PolyAttr | PolyAttr | EllipseAttr | CircleAttr | RectAttr | GlyphAttr; - export type TransformObjectValues = Partial & { - origin: [number, number, number]; - }; - export type Point = { - x: number; - y: number; - }; - export type PointTuple = [number, number]; - export type DerivedPoint = Point & { - t: number; - }; - export type QuadPoints = [Point, Point, Point, Point, Point, Point]; - export type CubicPoints = [ - Point, - Point, - Point, - Point, - Point, - Point, - Point, - Point - ]; - export type DerivedQuadPoints = [ - DerivedPoint, - DerivedPoint, - DerivedPoint, - DerivedPoint, - DerivedPoint, - DerivedPoint - ]; - export type DerivedCubicPoints = [ - DerivedPoint, - DerivedPoint, - DerivedPoint, - DerivedPoint, - DerivedPoint, - DerivedPoint, - DerivedPoint, - DerivedPoint - ]; - export type QuadCoordinates = [number, number, number, number, number, number]; - export type CubicCoordinates = [ - number, - number, - number, - number, - number, - number, - number, - number - ]; - export type ArcCoordinates = [ - number, - number, - number, - number, - number, - number, - number, - number, - number - ]; - export type LineCoordinates = [number, number, number, number]; - export type DeriveCallback = (t: number) => Point; - export type IteratorCallback = (segment: PathSegment, index: number, lastX: number, lastY: number) => PathSegment | false | void | undefined; -} -declare module "math/midPoint" { - import { PointTuple } from "types"; - /** - * Returns the coordinates of a specified distance - * ratio between two points. - * - * @param a the first point coordinates - * @param b the second point coordinates - * @param t the ratio - * @returns the midpoint coordinates - */ - const midPoint: (a: PointTuple, b: PointTuple, t: number) => PointTuple; - export default midPoint; -} -declare module "math/distanceSquareRoot" { - import { type PointTuple } from "types"; - /** - * Returns the square root of the distance - * between two given points. - * - * @param a the first point coordinates - * @param b the second point coordinates - * @returns the distance value - */ - const distanceSquareRoot: (a: PointTuple, b: PointTuple) => number; - export default distanceSquareRoot; -} -declare module "math/lineTools" { - /** - * Returns length for line segments (MoveTo, LineTo). - * - * @param x1 the starting point X - * @param y1 the starting point Y - * @param x2 the ending point X - * @param y2 the ending point Y - * @returns the line segment length - */ - const getLineLength: (x1: number, y1: number, x2: number, y2: number) => number; - /** - * Returns a point along the line segments (MoveTo, LineTo). - * - * @param x1 the starting point X - * @param y1 the starting point Y - * @param x2 the ending point X - * @param y2 the ending point Y - * @param distance the distance to point in [0-1] range - * @returns the point at length - */ - const getPointAtLineLength: (x1: number, y1: number, x2: number, y2: number, distance?: number) => { - x: number; - y: number; - }; - /** - * Returns bounding box for line segments (MoveTo, LineTo). - * - * @param x1 the starting point X - * @param y1 the starting point Y - * @param x2 the ending point X - * @param y2 the ending point Y - * @param distance the distance to point in [0-1] range - * @returns the extrema for line segments - */ - const getLineBBox: (x1: number, y1: number, x2: number, y2: number) => [number, number, number, number]; - export { getLineBBox, getLineLength, getPointAtLineLength }; -} -declare module "math/arcTools" { - import type { Point, PointTuple } from "types"; - /** - * Returns the Arc segment length. - * @param rx radius along X axis - * @param ry radius along Y axis - * @param theta the angle in radians - * @returns the arc length - */ - const arcLength: (rx: number, ry: number, theta: number) => number; - /** - * Find point on ellipse at given angle around ellipse (theta); - * @param cx the center X - * @param cy the center Y - * @param rx the radius X - * @param ry the radius Y - * @param alpha the arc rotation angle in radians - * @param theta the arc sweep angle in radians - * @returns a point around ellipse at given angle - */ - const arcPoint: (cx: number, cy: number, rx: number, ry: number, alpha: number, theta: number) => PointTuple; - /** - * Returns the angle between two points. - * @param v0 starting point - * @param v1 ending point - * @returns the angle in radian - */ - const angleBetween: (v0: Point, v1: Point) => number; - /** - * Returns the following properties for an Arc segment: center, start angle, - * end angle, and radiuses on X and Y axis. - * - * @param x1 the starting point X - * @param y1 the starting point Y - * @param RX the radius on X axis - * @param RY the radius on Y axis - * @param angle the ellipse rotation in degrees - * @param LAF the large arc flag - * @param SF the sweep flag - * @param x2 the ending point X - * @param y2 the ending point Y - * @returns properties specific to Arc segments - */ - const getArcProps: (x1: number, y1: number, RX: number, RY: number, angle: number, LAF: number, SF: number, x: number, y: number) => { - rx: number; - ry: number; - startAngle: number; - endAngle: number; - center: { - x: number; - y: number; - }; - }; - /** - * Returns the length of an Arc segment. - * - * @param x1 the starting point X - * @param y1 the starting point Y - * @param c1x the first control point X - * @param c1y the first control point Y - * @param c2x the second control point X - * @param c2y the second control point Y - * @param x2 the ending point X - * @param y2 the ending point Y - * @returns the length of the Arc segment - */ - const getArcLength: (x1: number, y1: number, RX: number, RY: number, angle: number, LAF: number, SF: number, x: number, y: number) => number; - /** - * Returns a point along an Arc segment at a given distance. - * - * @param x1 the starting point X - * @param y1 the starting point Y - * @param RX the radius on X axis - * @param RY the radius on Y axis - * @param angle the ellipse rotation in degrees - * @param LAF the large arc flag - * @param SF the sweep flag - * @param x2 the ending point X - * @param y2 the ending point Y - * @param distance a [0-1] ratio - * @returns a point along the Arc segment - */ - const getPointAtArcLength: (x1: number, y1: number, RX: number, RY: number, angle: number, LAF: number, SF: number, x: number, y: number, distance?: number) => { - x: number; - y: number; - }; - /** - * Returns the extrema for an Arc segment in the following format: - * [MIN_X, MIN_Y, MAX_X, MAX_Y] - * - * @see https://github.com/herrstrietzel/svg-pathdata-getbbox - * - * @param x1 the starting point X - * @param y1 the starting point Y - * @param RX the radius on X axis - * @param RY the radius on Y axis - * @param angle the ellipse rotation in degrees - * @param LAF the large arc flag - * @param SF the sweep flag - * @param x2 the ending point X - * @param y2 the ending point Y - * @returns the extrema of the Arc segment - */ - const getArcBBox: (x1: number, y1: number, RX: number, RY: number, angle: number, LAF: number, SF: number, x: number, y: number) => [number, number, number, number]; - export { angleBetween, arcLength, arcPoint, getArcBBox, getArcLength, getArcProps, getPointAtArcLength, }; -} -declare module "math/bezier" { - import type { CubicCoordinates, CubicPoints, DeriveCallback, DerivedCubicPoints, DerivedPoint, DerivedQuadPoints, PointTuple, QuadCoordinates, QuadPoints } from "types"; - /** - * Tools from bezier.js by Mike 'Pomax' Kamermans - * @see https://github.com/Pomax/bezierjs - */ - const Tvalues: number[]; - const Cvalues: number[]; - /** - * @param points - * @returns - */ - const deriveBezier: (points: QuadPoints | CubicPoints) => (DerivedQuadPoints | DerivedCubicPoints)[]; - /** - * @param points - * @param t - */ - const computeBezier: (points: DerivedQuadPoints | DerivedCubicPoints, t: number) => DerivedPoint; - const calculateBezier: (derivativeFn: DeriveCallback, t: number) => number; - const bezierLength: (derivativeFn: DeriveCallback) => number; - /** - * Returns the length of CubicBezier / Quad segment. - * @param curve cubic / quad bezier segment - */ - const getBezierLength: (curve: CubicCoordinates | QuadCoordinates) => number; - const CBEZIER_MINMAX_EPSILON = 1e-8; - /** - * Returns the most extreme points in a Quad Bezier segment. - * @param A an array which consist of X/Y values - */ - const minmaxQ: ([v1, cp, v2]: [number, number, number]) => PointTuple; - /** - * Returns the most extreme points in a Cubic Bezier segment. - * @param A an array which consist of X/Y values - * @see https://github.com/kpym/SVGPathy/blob/acd1a50c626b36d81969f6e98e8602e128ba4302/lib/box.js#L127 - */ - const minmaxC: ([v1, cp1, cp2, v2]: [number, number, number, number]) => PointTuple; - export { bezierLength, calculateBezier, CBEZIER_MINMAX_EPSILON, computeBezier, Cvalues, deriveBezier, getBezierLength, minmaxC, minmaxQ, Tvalues, }; -} -declare module "math/cubicTools" { - import { type CubicCoordinates } from "types"; - /** - * Returns a point at a given length of a CubicBezier segment. - * - * @param x1 the starting point X - * @param y1 the starting point Y - * @param c1x the first control point X - * @param c1y the first control point Y - * @param c2x the second control point X - * @param c2y the second control point Y - * @param x2 the ending point X - * @param y2 the ending point Y - * @param t a [0-1] ratio - * @returns the point at cubic-bezier segment length - */ - const getPointAtCubicSegmentLength: ([x1, y1, c1x, c1y, c2x, c2y, x2, y2]: CubicCoordinates, t: number) => { - x: number; - y: number; - }; - /** - * Returns the length of a CubicBezier segment. - * - * @param x1 the starting point X - * @param y1 the starting point Y - * @param c1x the first control point X - * @param c1y the first control point Y - * @param c2x the second control point X - * @param c2y the second control point Y - * @param x2 the ending point X - * @param y2 the ending point Y - * @returns the CubicBezier segment length - */ - const getCubicLength: (x1: number, y1: number, c1x: number, c1y: number, c2x: number, c2y: number, x2: number, y2: number) => number; - /** - * Returns the point along a CubicBezier segment at a given distance. - * - * @param x1 the starting point X - * @param y1 the starting point Y - * @param c1x the first control point X - * @param c1y the first control point Y - * @param c2x the second control point X - * @param c2y the second control point Y - * @param x2 the ending point X - * @param y2 the ending point Y - * @param distance the distance to look at - * @returns the point at CubicBezier length - */ - const getPointAtCubicLength: (x1: number, y1: number, c1x: number, c1y: number, c2x: number, c2y: number, x2: number, y2: number, distance?: number) => { - x: number; - y: number; - }; - /** - * Returns the boundig box of a CubicBezier segment in the following format: - * [MIN_X, MIN_Y, MAX_X, MAX_Y] - * - * @param x1 the starting point X - * @param y1 the starting point Y - * @param c1x the first control point X - * @param c1y the first control point Y - * @param c2x the second control point X - * @param c2y the second control point Y - * @param x2 the ending point X - * @param y2 the ending point Y - * @returns the extrema of the CubicBezier segment - */ - const getCubicBBox: (x1: number, y1: number, c1x: number, c1y: number, c2x: number, c2y: number, x2: number, y2: number) => [number, number, number, number]; - export { getCubicBBox, getCubicLength, getPointAtCubicLength, getPointAtCubicSegmentLength, }; -} -declare module "math/quadTools" { - import { type QuadCoordinates } from "types"; - /** - * Returns the {x,y} coordinates of a point at a - * given length of a quadratic-bezier segment. - * - * @see https://github.com/substack/point-at-length - * - * @param x1 the starting point X - * @param y1 the starting point Y - * @param cx the control point X - * @param cy the control point Y - * @param x2 the ending point X - * @param y2 the ending point Y - * @param t a [0-1] ratio - * @returns the requested {x,y} coordinates - */ - const getPointAtQuadSegmentLength: ([x1, y1, cx, cy, x2, y2]: QuadCoordinates, t: number) => { - x: number; - y: number; - }; - /** - * Returns the length of a QuadraticBezier segment. - * - * @param x1 the starting point X - * @param y1 the starting point Y - * @param cx the control point X - * @param cy the control point Y - * @param x2 the ending point X - * @param y2 the ending point Y - * @returns the QuadraticBezier segment length - */ - const getQuadLength: (x1: number, y1: number, cx: number, cy: number, x2: number, y2: number) => number; - /** - * Returns the point along a QuadraticBezier segment at a given distance. - * - * @param x1 the starting point X - * @param y1 the starting point Y - * @param cx the control point X - * @param cy the control point Y - * @param x2 the ending point X - * @param y2 the ending point Y - * @param distance the distance to look at - * @returns the point at QuadraticBezier length - */ - const getPointAtQuadLength: (x1: number, y1: number, cx: number, cy: number, x2: number, y2: number, distance?: number) => { - x: number; - y: number; - }; - /** - * Returns the boundig box of a QuadraticBezier segment in the following format: - * [MIN_X, MIN_Y, MAX_X, MAX_Y] - * - * @param x1 the starting point X - * @param y1 the starting point Y - * @param cx the control point X - * @param cy the control point Y - * @param x2 the ending point X - * @param y2 the ending point Y - * @returns the extrema of the QuadraticBezier segment - */ - const getQuadBBox: (x1: number, y1: number, cx: number, cy: number, x2: number, y2: number) => [number, number, number, number]; - export { getPointAtQuadLength, getPointAtQuadSegmentLength, getQuadBBox, getQuadLength, }; -} -declare module "math/polygonTools" { - import { type PointTuple } from "types"; - /** - * d3-polygon-area - * https://github.com/d3/d3-polygon - * - * Returns the area of a polygon. - * - * @param polygon an array of coordinates - * @returns the polygon area - */ - const polygonArea: (polygon: PointTuple[]) => number; - /** - * d3-polygon-length - * https://github.com/d3/d3-polygon - * - * Returns the perimeter of a polygon. - * - * @param polygon an array of coordinates - * @returns the polygon length - */ - const polygonLength: (polygon: PointTuple[]) => number; - export { polygonArea, polygonLength }; -} -declare module "parser/paramsCount" { - /** Segment params length */ - const paramsCount: { - a: number; - c: number; - h: number; - l: number; - m: number; - r: number; - q: number; - s: number; - t: number; - v: number; - z: number; - }; - export default paramsCount; -} -declare module "parser/pathParser" { - import type { PathArray, PathSegment } from "types"; - /** - * The `PathParser` is used by the `parsePathString` static method - * to generate a `pathArray`. - * - * @param pathString - */ - export default class PathParser { - segments: PathArray | PathSegment[]; - pathValue: string; - max: number; - index: number; - param: number; - segmentStart: number; - data: (string | number)[]; - err: string; - constructor(pathString: string); - } -} -declare module "parser/finalizeSegment" { - import PathParser from "parser/pathParser"; - /** - * Breaks the parsing of a pathString once a segment is finalized. - * - * @param path the `PathParser` instance - */ - const finalizeSegment: (path: PathParser) => void; - export default finalizeSegment; -} -declare module "parser/error" { - const error = "SVGPathCommander Error"; - export default error; -} -declare module "parser/scanFlag" { - import type PathParser from "parser/pathParser"; - /** - * Validates an A (arc-to) specific path command value. - * Usually a `large-arc-flag` or `sweep-flag`. - * - * @param path the `PathParser` instance - */ - const scanFlag: (path: PathParser) => void; - export default scanFlag; -} -declare module "parser/isDigit" { - import { DigitNumber } from "types"; - /** - * Checks if a character is a digit. - * - * @param code the character to check - * @returns check result - */ - const isDigit: (code: number) => code is DigitNumber; - export default isDigit; -} -declare module "parser/invalidPathValue" { - const invalidPathValue = "Invalid path value"; - export default invalidPathValue; -} -declare module "parser/scanParam" { - import type PathParser from "parser/pathParser"; - /** - * Validates every character of the path string, - * every path command, negative numbers or floating point numbers. - * - * @param path the `PathParser` instance - */ - const scanParam: (path: PathParser) => void; - export default scanParam; -} -declare module "parser/isSpace" { - import type { SpaceNumber } from "types"; - /** - * Checks if the character is a space. - * - * @param ch the character to check - * @returns check result - */ - const isSpace: (ch: number) => ch is SpaceNumber; - export default isSpace; -} -declare module "parser/skipSpaces" { - import type PathParser from "parser/pathParser"; - /** - * Points the parser to the next character in the - * path string every time it encounters any kind of - * space character. - * - * @param path the `PathParser` instance - */ - const skipSpaces: (path: PathParser) => void; - export default skipSpaces; -} -declare module "parser/isPathCommand" { - import type { PathCommandNumber } from "types"; - /** - * Checks if the character is a path command. - * - * @param code the character to check - * @returns check result - */ - const isPathCommand: (code: number) => code is PathCommandNumber; - export default isPathCommand; -} -declare module "parser/isDigitStart" { - import type { DigitNumber } from "types"; - /** - * Checks if the character is or belongs to a number. - * [0-9]|+|-|. - * - * @param code the character to check - * @returns check result - */ - const isDigitStart: (code: number) => code is DigitNumber | 43 | 45 | 46; - export default isDigitStart; -} -declare module "parser/isArcCommand" { - /** - * Checks if the character is an A (arc-to) path command. - * - * @param code the character to check - * @returns check result - */ - const isArcCommand: (code: number) => code is 97; - export default isArcCommand; -} -declare module "parser/isMoveCommand" { - /** - * Checks if the character is a MoveTo command. - * - * @param code the character to check - * @returns check result - */ - const isMoveCommand: (code: number) => code is 109 | 77; - export default isMoveCommand; -} -declare module "parser/scanSegment" { - import type PathParser from "parser/pathParser"; - /** - * Scans every character in the path string to determine - * where a segment starts and where it ends. - * - * @param path the `PathParser` instance - */ - const scanSegment: (path: PathParser) => void; - export default scanSegment; -} -declare module "parser/parsePathString" { - import type { PathArray } from "types"; - /** - * Parses a path string value and returns an array - * of segments we like to call `pathArray`. - * - * @param pathInput the string to be parsed - * @returns the resulted `pathArray` or error string - */ - const parsePathString: (pathInput: string | T) => PathArray; - export default parsePathString; -} -declare module "process/absolutizeSegment" { - import type { AbsoluteSegment, PathSegment } from "types"; - /** - * Returns an absolute segment of a `PathArray` object. - * - * @param segment the segment object - * @param index the segment index - * @param lastX the last known X value - * @param lastY the last known Y value - * @returns the absolute segment - */ - const absolutizeSegment: (segment: PathSegment, index: number, lastX: number, lastY: number) => AbsoluteSegment; - export default absolutizeSegment; -} -declare module "process/iterate" { - import type { IteratorCallback, PathArray } from "types"; - const iterate: (path: PathArray, iterator: IteratorCallback) => T; - export default iterate; -} -declare module "convert/pathToAbsolute" { - import type { AbsoluteArray, PathArray } from "types"; - /** - * Parses a path string value or object and returns an array - * of segments, all converted to absolute values. - * - * @param pathInput the path string | object - * @returns the resulted `pathArray` with absolute values - */ - const pathToAbsolute: (pathInput: string | PathArray) => AbsoluteArray; - export default pathToAbsolute; -} -declare module "process/relativizeSegment" { - import type { MSegment, PathSegment, RelativeSegment } from "types"; - /** - * Returns a relative segment of a `PathArray` object. - * - * @param segment the segment object - * @param index the segment index - * @param lastX the last known X value - * @param lastY the last known Y value - * @returns the relative segment - */ - const relativizeSegment: (segment: PathSegment, index: number, lastX: number, lastY: number) => MSegment | RelativeSegment; - export default relativizeSegment; -} -declare module "convert/pathToRelative" { - import type { PathArray, RelativeArray } from "types"; - /** - * Parses a path string value or object and returns an array - * of segments, all converted to relative values. - * - * @param pathInput the path string | object - * @returns the resulted `pathArray` with relative values - */ - const pathToRelative: (pathInput: string | PathArray) => RelativeArray; - export default pathToRelative; -} -declare module "math/rotateVector" { - /** - * Returns an {x,y} vector rotated by a given - * angle in radian. - * - * @param x the initial vector x - * @param y the initial vector y - * @param rad the radian vector angle - * @returns the rotated vector - */ - const rotateVector: (x: number, y: number, rad: number) => { - x: number; - y: number; - }; - export default rotateVector; -} -declare module "process/arcToCubic" { - /** - * Converts A (arc-to) segments to C (cubic-bezier-to). - * - * For more information of where this math came from visit: - * http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes - * - * @param X1 the starting x position - * @param Y1 the starting y position - * @param RX x-radius of the arc - * @param RY y-radius of the arc - * @param angle x-axis-rotation of the arc - * @param LAF large-arc-flag of the arc - * @param SF sweep-flag of the arc - * @param X2 the ending x position - * @param Y2 the ending y position - * @param recursive the parameters needed to split arc into 2 segments - * @return the resulting cubic-bezier segment(s) - */ - const arcToCubic: (X1: number, Y1: number, RX: number, RY: number, angle: number, LAF: number, SF: number, X2: number, Y2: number, recursive?: [number, number, number, number]) => number[]; - export default arcToCubic; -} -declare module "process/quadToCubic" { - /** - * Converts a Q (quadratic-bezier) segment to C (cubic-bezier). - * - * @param x1 curve start x - * @param y1 curve start y - * @param qx control point x - * @param qy control point y - * @param x2 curve end x - * @param y2 curve end y - * @returns the cubic-bezier segment - */ - const quadToCubic: (x1: number, y1: number, qx: number, qy: number, x2: number, y2: number) => [number, number, number, number, number, number]; - export default quadToCubic; -} -declare module "process/lineToCubic" { - /** - * Converts an L (line-to) segment to C (cubic-bezier). - * - * @param x1 line start x - * @param y1 line start y - * @param x2 line end x - * @param y2 line end y - * @returns the cubic-bezier segment - */ - const lineToCubic: (x1: number, y1: number, x2: number, y2: number) => number[]; - export default lineToCubic; -} -declare module "process/segmentToCubic" { - import type { CSegment, MSegment, PathSegment } from "types"; - import type { ParserParams } from "interface"; - /** - * Converts any segment to C (cubic-bezier). - * - * @param segment the source segment - * @param params the source segment parameters - * @returns the cubic-bezier segment - */ - const segmentToCubic: (segment: PathSegment, params: ParserParams) => MSegment | CSegment; - export default segmentToCubic; -} -declare module "process/normalizeSegment" { - import type { ParserParams } from "interface"; - import type { NormalSegment, PathSegment } from "types"; - /** - * Normalizes a single segment of a `pathArray` object. - * - * @param segment the segment object - * @param params the normalization parameters - * @returns the normalized segment - */ - const normalizeSegment: (segment: PathSegment, params: ParserParams) => NormalSegment; - export default normalizeSegment; -} -declare module "parser/paramsParser" { - import type { ParserParams } from "interface"; - const paramsParser: ParserParams; - export default paramsParser; -} -declare module "convert/pathToCurve" { - import { CurveArray, PathArray } from "types"; - /** - * Parses a path string value or 'pathArray' and returns a new one - * in which all segments are converted to cubic-bezier. - * - * In addition, un-necessary `Z` segment is removed if previous segment - * extends to the `M` segment. - * - * @param pathInput the string to be parsed or 'pathArray' - * @returns the resulted `pathArray` converted to cubic-bezier - */ - const pathToCurve: (pathInput: string | PathArray) => CurveArray; - export default pathToCurve; -} -declare module "options/options" { - import { Options } from "interface"; - /** SVGPathCommander default options */ - const defaultOptions: Options; - export default defaultOptions; -} -declare module "math/roundTo" { - const roundTo: (n: number, round: number) => number; - export default roundTo; -} -declare module "convert/pathToString" { - import type { PathArray } from "types"; - /** - * Returns a valid `d` attribute string value created - * by rounding values and concatenating the `pathArray` segments. - * - * @param path the `pathArray` object - * @param roundOption amount of decimals to round values to - * @returns the concatenated path string - */ - const pathToString: (path: PathArray, roundOption?: number | "off") => string; - export default pathToString; -} -declare module "util/distanceEpsilon" { - const DISTANCE_EPSILON = 0.00001; - export default DISTANCE_EPSILON; -} -declare module "process/normalizePath" { - import type { NormalArray, PathArray } from "types"; - /** - * Normalizes a `pathArray` object for further processing: - * * convert segments to absolute values - * * convert shorthand path commands to their non-shorthand notation - * - * @param pathInput the string to be parsed or 'pathArray' - * @returns the normalized `pathArray` - */ - const normalizePath: (pathInput: string | PathArray) => NormalArray; - export default normalizePath; -} -declare module "util/getPointAtLength" { - import type { PathArray } from "types"; - /** - * Returns [x,y] coordinates of a point at a given length of a shape. - * - * @param pathInput the `pathArray` to look into - * @param distance the length of the shape to look at - * @returns the requested {x, y} point coordinates - */ - const getPointAtLength: (pathInput: string | PathArray, distance?: number) => { - x: number; - y: number; - }; - export default getPointAtLength; -} -declare module "util/getTotalLength" { - import type { PathArray } from "types"; - /** - * Returns the shape total length, or the equivalent to `shape.getTotalLength()`. - * - * @param pathInput the target `pathArray` - * @returns the shape total length - */ - const getTotalLength: (pathInput: string | PathArray) => number; - export default getTotalLength; -} -declare module "util/getPropertiesAtLength" { - import type { PathArray } from "types"; - import type { SegmentProperties } from "interface"; - /** - * Returns the segment, its index and length as well as - * the length to that segment at a given length in a path. - * - * @param pathInput target `pathArray` - * @param distance the given length - * @returns the requested properties - */ - const getPropertiesAtLength: (pathInput: string | PathArray, distance?: number) => SegmentProperties; - export default getPropertiesAtLength; -} -declare module "util/getPropertiesAtPoint" { - import type { PathArray, Point } from "types"; - import type { PointProperties } from "interface"; - /** - * Returns the point and segment in path closest to a given point as well as - * the distance to the path stroke. - * - * @see https://bl.ocks.org/mbostock/8027637 - * - * @param pathInput target `pathArray` - * @param point the given point - * @returns the requested properties - */ - const getPropertiesAtPoint: (pathInput: string | PathArray, point: Point) => PointProperties; - export default getPropertiesAtPoint; -} -declare module "util/getClosestPoint" { - import type { PathArray } from "types"; - /** - * Returns the point in path closest to a given point. - * - * @param pathInput target `pathArray` - * @param point the given point - * @returns the best match - */ - const getClosestPoint: (pathInput: string | PathArray, point: { - x: number; - y: number; - }) => { - x: number; - y: number; - }; - export default getClosestPoint; -} -declare module "util/getPathArea" { - import type { PathArray } from "types"; - /** - * Returns the area of a shape. - * - * @author Jürg Lehni & Jonathan Puckey - * - * @see https://github.com/paperjs/paper.js/blob/develop/src/path/Path.js - * - * @param path the shape `pathArray` - * @returns the length of the cubic-bezier segment - */ - const getPathArea: (path: PathArray) => number; - export default getPathArea; -} -declare module "util/getDrawDirection" { - import type { PathArray } from "types"; - /** - * Check if a path is drawn clockwise and returns true if so, - * false otherwise. - * - * @param path the path string or `pathArray` - * @returns true when clockwise or false if not - */ - const getDrawDirection: (path: string | PathArray) => boolean; - export default getDrawDirection; -} -declare module "util/getPathBBox" { - import { PathArray } from "types"; - const getPathBBox: (pathInput: PathArray | string) => { - x: number; - y: number; - width: number; - height: number; - x2: number; - y2: number; - cx: number; - cy: number; - cz: number; - }; - export default getPathBBox; -} -declare module "util/getSegmentAtLength" { - import type { PathArray, PathSegment } from "types"; - /** - * Returns the segment at a given length. - * - * @param pathInput the target `pathArray` - * @param distance the distance in path to look at - * @returns the requested segment - */ - const getSegmentAtLength: (pathInput: string | PathArray, distance?: number) => PathSegment | undefined; - export default getSegmentAtLength; -} -declare module "util/getSegmentOfPoint" { - import type { SegmentProperties } from "interface"; - import type { PathArray } from "types"; - /** - * Returns the path segment which contains a given point. - * - * @param path the `pathArray` to look into - * @param point the point of the shape to look for - * @returns the requested segment - */ - const getSegmentOfPoint: (path: string | PathArray, point: { - x: number; - y: number; - }) => SegmentProperties | undefined; - export default getSegmentOfPoint; -} -declare module "util/isPathArray" { - import type { PathArray } from "types"; - /** - * Iterates an array to check if it's an actual `pathArray`. - * - * @param path the `pathArray` to be checked - * @returns iteration result - */ - const isPathArray: (path: unknown) => path is PathArray; - export default isPathArray; -} -declare module "util/isAbsoluteArray" { - import type { AbsoluteArray } from "types"; - /** - * Iterates an array to check if it's a `pathArray` - * with all absolute values. - * - * @param path the `pathArray` to be checked - * @returns iteration result - */ - const isAbsoluteArray: (path: unknown) => path is AbsoluteArray; - export default isAbsoluteArray; -} -declare module "util/isNormalizedArray" { - import type { NormalArray } from "types"; - /** - * Iterates an array to check if it's a `pathArray` - * with all segments are in non-shorthand notation - * with absolute values. - * - * @param {string | SVGPath.pathArray} path the `pathArray` to be checked - * @returns {boolean} iteration result - */ - const isNormalizedArray: (path: unknown) => path is NormalArray; - export default isNormalizedArray; -} -declare module "util/isCurveArray" { - import { CurveArray } from "types"; - /** - * Iterates an array to check if it's a `pathArray` - * with all C (cubic bezier) segments. - * - * @param path the `Array` to be checked - * @returns iteration result - */ - const isCurveArray: (path: unknown) => path is CurveArray; - export default isCurveArray; -} -declare module "util/isPointInStroke" { - import type { PathArray } from "types"; - /** - * Checks if a given point is in the stroke of a path. - * - * @param pathInput target path - * @param point the given `{x,y}` point - * @returns the query result - */ - const isPointInStroke: (pathInput: string | PathArray, point: { - x: number; - y: number; - }) => boolean; - export default isPointInStroke; -} -declare module "util/isRelativeArray" { - import type { RelativeArray } from "types"; - /** - * Iterates an array to check if it's a `pathArray` - * with relative values. - * - * @param path the `pathArray` to be checked - * @returns iteration result - */ - const isRelativeArray: (path: unknown) => path is RelativeArray; - export default isRelativeArray; -} -declare module "util/isValidPath" { - /** - * Parses a path string value to determine its validity - * then returns true if it's valid or false otherwise. - * - * @param pathString the path string to be parsed - * @returns the path string validity - */ - const isValidPath: (pathString: string) => boolean; - export default isValidPath; -} -declare module "util/shapeParams" { - import type { ShapeParams } from "interface"; - /** - * Supported shapes and their specific parameters. - */ - const shapeParams: ShapeParams; - export default shapeParams; -} -declare module "util/isElement" { - const isElement: (node?: unknown) => node is Element; - export default isElement; -} -declare module "util/shapeToPathArray" { - import type { CircleAttr, EllipseAttr, LineAttr, PolyAttr, RectAttr } from "interface"; - import type { PathArray, ShapeOps, ShapeTypes } from "types"; - /** - * Returns a new `pathArray` from line attributes. - * - * @param attr shape configuration - * @returns a new line `pathArray` - */ - export const getLinePath: (attr: LineAttr) => PathArray; - /** - * Returns a new `pathArray` like from polyline/polygon attributes. - * - * @param attr shape configuration - * @return a new polygon/polyline `pathArray` - */ - export const getPolyPath: (attr: PolyAttr) => PathArray; - /** - * Returns a new `pathArray` from circle attributes. - * - * @param attr shape configuration - * @return a circle `pathArray` - */ - export const getCirclePath: (attr: CircleAttr) => PathArray; - /** - * Returns a new `pathArray` from ellipse attributes. - * - * @param attr shape configuration - * @return an ellipse `pathArray` - */ - export const getEllipsePath: (attr: EllipseAttr) => PathArray; - /** - * Returns a new `pathArray` like from rect attributes. - * - * @param attr object with properties above - * @return a new `pathArray` from `` attributes - */ - export const getRectanglePath: (attr: RectAttr) => PathArray; - /** - * Returns a new `pathArray` created from attributes of a ``, ``, - * ``, ``, ``, ``, or ``. - * - * It can also work with an options object, see the type below - * @see ShapeOps - * - * @param element target shape - * @return the newly created `` element - */ - const shapeToPathArray: (element: ShapeTypes | ShapeOps) => false | PathArray; - export default shapeToPathArray; -} -declare module "util/shapeToPath" { - import type { ShapeOps, ShapeTypes } from "types"; - /** - * Returns a new `` element created from attributes of a ``, ``, - * ``, ``, ``, `` or ``. If `replace` parameter - * is `true`, it will replace the target. The default `ownerDocument` is your current - * `document` browser page, if you want to use in server-side using `jsdom`, you can - * pass the `jsdom` `document` to `ownDocument`. - * - * It can also work with an options object, see the type below - * @see ShapeOps - * - * The newly created `` element keeps all non-specific - * attributes like `class`, `fill`, etc. - * - * @param element target shape - * @param replace option to replace target - * @param ownerDocument document for create element - * @return the newly created `` element - */ - const shapeToPath: (element: ShapeTypes | ShapeOps, replace?: boolean, ownerDocument?: Document) => SVGPathElement | false; - export default shapeToPath; -} -declare module "process/getSVGMatrix" { - import CSSMatrix from "@thednp/dommatrix"; - import type { TransformObjectValues } from "types"; - /** - * Returns a transformation matrix to apply to `` elements. - * - * @see TransformObjectValues - * - * @param transform the `transformObject` - * @returns a new transformation matrix - */ - const getSVGMatrix: (transform: TransformObjectValues) => CSSMatrix; - export default getSVGMatrix; -} -declare module "process/shortenSegment" { - import type { ParserParams } from "interface"; - import type { AbsoluteSegment, NormalSegment, PathCommand, ShortSegment } from "types"; - /** - * Shorten a single segment of a `pathArray` object. - * - * @param segment the `absoluteSegment` object - * @param normalSegment the `normalSegment` object - * @param params the coordinates of the previous segment - * @param prevCommand the path command of the previous segment - * @returns the shortened segment - */ - const shortenSegment: (segment: AbsoluteSegment, normalSegment: NormalSegment, params: ParserParams, prevCommand: PathCommand) => ShortSegment; - export default shortenSegment; -} -declare module "process/roundSegment" { - import type { PathSegment } from "types"; - const roundSegment: (segment: T, roundOption: number) => T; - export default roundSegment; -} -declare module "process/optimizePath" { - import type { PathArray } from "types"; - /** - * Optimizes a `pathArray` object: - * * convert segments to shorthand if possible - * * select shortest segments from absolute and relative `pathArray`s - * - * @param pathInput a string or `pathArray` - * @param roundOption the amount of decimals to round values to - * @returns the optimized `pathArray` - */ - const optimizePath: (pathInput: PathArray, roundOption?: number) => PathArray; - export default optimizePath; -} -declare module "process/projection2d" { - import CSSMatrix from "@thednp/dommatrix"; - import { type PointTuple } from "types"; - /** - * Returns the [x,y] projected coordinates for a given an [x,y] point - * and an [x,y,z] perspective origin point. - * - * Equation found here => - * http://en.wikipedia.org/wiki/3D_projection#Diagram - * Details => - * https://stackoverflow.com/questions/23792505/predicted-rendering-of-css-3d-transformed-pixel - * - * @param m the transformation matrix - * @param point2D the initial [x,y] coordinates - * @param origin the [x,y,z] transform origin - * @returns the projected [x,y] coordinates - */ - const projection2d: (m: CSSMatrix, point2D: PointTuple, origin: [number, number, number]) => PointTuple; - export default projection2d; -} -declare module "process/reverseCurve" { - import type { CurveArray } from "types"; - /** - * Reverses all segments of a `pathArray` - * which consists of only C (cubic-bezier) path commands. - * - * @param path the source `pathArray` - * @returns the reversed `pathArray` - */ - const reverseCurve: (path: CurveArray) => CurveArray; - export default reverseCurve; -} -declare module "process/reversePath" { - import type { PathArray } from "types"; - /** - * Reverses all segments of a `pathArray` and returns a new `pathArray` instance - * with absolute values. - * - * @param pathInput the source `pathArray` - * @returns the reversed `pathArray` - */ - const reversePath: (pathInput: PathArray) => PathArray; - export default reversePath; -} -declare module "process/roundPath" { - import type { PathArray } from "types"; - /** - * Rounds the values of a `pathArray` instance to - * a specified amount of decimals and returns it. - * - * @param path the source `pathArray` - * @param roundOption the amount of decimals to round numbers to - * @returns the resulted `pathArray` with rounded values - */ - const roundPath: (path: PathArray, roundOption?: number | "off") => PathArray; - export default roundPath; -} -declare module "process/splitCubic" { - import type { CubicSegment } from "types"; - /** - * Split a cubic-bezier segment into two. - * - * @param pts the cubic-bezier parameters - * @param ratio the cubic-bezier parameters - * @return two new cubic-bezier segments - */ - const splitCubic: (pts: number[], ratio?: number) => [CubicSegment, CubicSegment]; - export default splitCubic; -} -declare module "process/splitPath" { - import type { PathArray } from "types"; - /** - * Split a path into an `Array` of sub-path strings. - * - * In the process, values are converted to absolute - * for visual consistency. - * - * @param pathInput the source `pathArray` - * @return an array with all sub-path strings - */ - const splitPath: (pathInput: PathArray) => PathArray[]; - export default splitPath; -} -declare module "process/transformPath" { - import type { PathArray } from "types"; - import type { TransformObject } from "interface"; - /** - * Apply a 2D / 3D transformation to a `pathArray` instance. - * - * Since *SVGElement* doesn't support 3D transformation, this function - * creates a 2D projection of the element. - * - * @param path the `pathArray` to apply transformation - * @param transform the transform functions `Object` - * @returns the resulted `pathArray` - */ - const transformPath: (pathInput: PathArray | string, transform?: Partial) => PathArray; - export default transformPath; -} -declare module "util" { - export { default as CSSMatrix } from "@thednp/dommatrix"; - import * as arcTools from "math/arcTools"; - import * as bezierTools from "math/bezier"; - import * as cubicTools from "math/cubicTools"; - import * as lineTools from "math/lineTools"; - import * as quadTools from "math/quadTools"; - import * as polygonTools from "math/polygonTools"; - export { arcTools, bezierTools, cubicTools, lineTools, quadTools, polygonTools }; - export { default as pathToAbsolute } from "convert/pathToAbsolute"; - export { default as pathToRelative } from "convert/pathToRelative"; - export { default as pathToCurve } from "convert/pathToCurve"; - export { default as pathToString } from "convert/pathToString"; - export { default as distanceSquareRoot } from "math/distanceSquareRoot"; - export { default as midPoint } from "math/midPoint"; - export { default as rotateVector } from "math/rotateVector"; - export { default as roundTo } from "math/roundTo"; - export { default as parsePathString } from "parser/parsePathString"; - export { default as finalizeSegment } from "parser/finalizeSegment"; - export { default as invalidPathValue } from "parser/invalidPathValue"; - export { default as isArcCommand } from "parser/isArcCommand"; - export { default as isDigit } from "parser/isDigit"; - export { default as isDigitStart } from "parser/isDigitStart"; - export { default as isMoveCommand } from "parser/isMoveCommand"; - export { default as isPathCommand } from "parser/isPathCommand"; - export { default as isSpace } from "parser/isSpace"; - export { default as paramsCount } from "parser/paramsCount"; - export { default as paramsParser } from "parser/paramsParser"; - export { default as pathParser } from "parser/pathParser"; - export { default as scanFlag } from "parser/scanFlag"; - export { default as scanParam } from "parser/scanParam"; - export { default as scanSegment } from "parser/scanSegment"; - export { default as skipSpaces } from "parser/skipSpaces"; - export { default as distanceEpsilon } from "util/distanceEpsilon"; - export { default as getClosestPoint } from "util/getClosestPoint"; - export { default as getDrawDirection } from "util/getDrawDirection"; - export { default as getPathArea } from "util/getPathArea"; - export { default as getPathBBox } from "util/getPathBBox"; - export { default as getPointAtLength } from "util/getPointAtLength"; - export { default as getPropertiesAtLength } from "util/getPropertiesAtLength"; - export { default as getPropertiesAtPoint } from "util/getPropertiesAtPoint"; - export { default as getSegmentAtLength } from "util/getSegmentAtLength"; - export { default as getSegmentOfPoint } from "util/getSegmentOfPoint"; - export { default as getTotalLength } from "util/getTotalLength"; - export { default as isAbsoluteArray } from "util/isAbsoluteArray"; - export { default as isCurveArray } from "util/isCurveArray"; - export { default as isNormalizedArray } from "util/isNormalizedArray"; - export { default as isPathArray } from "util/isPathArray"; - export { default as isPointInStroke } from "util/isPointInStroke"; - export { default as isRelativeArray } from "util/isRelativeArray"; - export { default as isValidPath } from "util/isValidPath"; - export { default as shapeParams } from "util/shapeParams"; - export { default as shapeToPath } from "util/shapeToPath"; - export { default as shapeToPathArray } from "util/shapeToPathArray"; - export { default as absolutizeSegment } from "process/absolutizeSegment"; - export { default as arcToCubic } from "process/arcToCubic"; - export { default as getSVGMatrix } from "process/getSVGMatrix"; - export { default as iterate } from "process/iterate"; - export { default as lineToCubic } from "process/lineToCubic"; - export { default as normalizePath } from "process/normalizePath"; - export { default as normalizeSegment } from "process/normalizeSegment"; - export { default as optimizePath } from "process/optimizePath"; - export { default as projection2d } from "process/projection2d"; - export { default as quadToCubic } from "process/quadToCubic"; - export { default as relativizeSegment } from "process/relativizeSegment"; - export { default as reverseCurve } from "process/reverseCurve"; - export { default as reversePath } from "process/reversePath"; - export { default as roundPath } from "process/roundPath"; - export { default as roundSegment } from "process/roundSegment"; - export { default as segmentToCubic } from "process/segmentToCubic"; - export { default as shortenSegment } from "process/shortenSegment"; - export { default as splitCubic } from "process/splitCubic"; - export { default as splitPath } from "process/splitPath"; - export { default as transformPath } from "process/transformPath"; -} diff --git a/package.json b/package.json index 8349b56..659b10d 100755 --- a/package.json +++ b/package.json @@ -37,7 +37,7 @@ "build": "pnpm build-vite && pnpm build-util", "build-vite": "vite build --config vite.config.mts && pnpm copy-docs", "build-util": "vite build --config vite.config-util.mts && pnpm built-util-types", - "built-util-types": "tsc src/util.ts --declaration --emitDeclarationOnly --outfile dist/util/util.d.ts --target esnext --moduleResolution bundler", + "built-util-types": "npx tsup src/util.ts --dts-only -d dist/util", "copy-docs": "cp dist/svg-path-commander.js docs/svg-path-commander.js && cp dist/svg-path-commander.js.map docs/svg-path-commander.js.map", "prepublishOnly": "pnpm update && pnpm format && pnpm lint:ts && pnpm build && pnpm badges" }, diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 75809f7..3fb1ad2 100755 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -1,278 +1,454 @@ -lockfileVersion: '9.0' +lockfileVersion: '6.0' settings: autoInstallPeers: true excludeLinksFromLockfile: false -importers: - - .: - dependencies: - '@thednp/dommatrix': - specifier: ^2.0.11 - version: 2.0.11 - devDependencies: - '@types/node': - specifier: ^22.13.0 - version: 22.13.0 - '@vitest/browser': - specifier: ^3.0.5 - version: 3.0.5(@types/node@22.13.0)(playwright@1.50.1)(typescript@5.7.3)(vite@6.0.11(@types/node@22.13.0))(vitest@3.0.5) - '@vitest/coverage-istanbul': - specifier: ^3.0.5 - version: 3.0.5(vitest@3.0.5) - '@vitest/ui': - specifier: ^3.0.5 - version: 3.0.5(vitest@3.0.5) - playwright: - specifier: ^1.50.1 - version: 1.50.1 - typescript: - specifier: 5.7.3 - version: 5.7.3 - vite: - specifier: ^6.0.11 - version: 6.0.11(@types/node@22.13.0) - vite-plugin-dts: - specifier: ^4.5.0 - version: 4.5.0(@types/node@22.13.0)(rollup@4.34.1)(typescript@5.7.3)(vite@6.0.11(@types/node@22.13.0)) - vitest: - specifier: ^3.0.5 - version: 3.0.5(@types/node@22.13.0)(@vitest/browser@3.0.5)(@vitest/ui@3.0.5)(msw@2.7.0(@types/node@22.13.0)(typescript@5.7.3)) +dependencies: + '@thednp/dommatrix': + specifier: ^2.0.11 + version: 2.0.11 + +devDependencies: + '@types/node': + specifier: ^22.13.0 + version: 22.13.0 + '@vitest/browser': + specifier: ^3.0.5 + version: 3.0.5(@types/node@22.13.0)(playwright@1.50.1)(typescript@5.7.3)(vite@6.0.11)(vitest@3.0.5) + '@vitest/coverage-istanbul': + specifier: ^3.0.5 + version: 3.0.5(vitest@3.0.5) + '@vitest/ui': + specifier: ^3.0.5 + version: 3.0.5(vitest@3.0.5) + playwright: + specifier: ^1.50.1 + version: 1.50.1 + tsup: + specifier: ^8.3.6 + version: 8.3.6(typescript@5.7.3) + typescript: + specifier: 5.7.3 + version: 5.7.3 + vite: + specifier: ^6.0.11 + version: 6.0.11(@types/node@22.13.0) + vite-plugin-dts: + specifier: ^4.5.0 + version: 4.5.0(@types/node@22.13.0)(typescript@5.7.3)(vite@6.0.11) + vitest: + specifier: ^3.0.5 + version: 3.0.5(@types/node@22.13.0)(@vitest/browser@3.0.5)(@vitest/ui@3.0.5) packages: - '@ampproject/remapping@2.3.0': + /@ampproject/remapping@2.3.0: resolution: {integrity: sha512-30iZtAPgz+LTIYoeivqYo853f02jBYSd5uGnGpkFV0M3xOt9aN73erkgYAmZU43x4VfqcnLxW9Kpg3R5LC4YYw==} engines: {node: '>=6.0.0'} + dependencies: + '@jridgewell/gen-mapping': 0.3.8 + '@jridgewell/trace-mapping': 0.3.25 + dev: true - '@babel/code-frame@7.26.2': + /@babel/code-frame@7.26.2: resolution: {integrity: sha512-RJlIHRueQgwWitWgF8OdFYGZX328Ax5BCemNGlqHfplnRT9ESi8JkFlvaVYbS+UubVY6dpv87Fs2u5M29iNFVQ==} engines: {node: '>=6.9.0'} + dependencies: + '@babel/helper-validator-identifier': 7.25.9 + js-tokens: 4.0.0 + picocolors: 1.1.1 + dev: true - '@babel/compat-data@7.26.5': + /@babel/compat-data@7.26.5: resolution: {integrity: sha512-XvcZi1KWf88RVbF9wn8MN6tYFloU5qX8KjuF3E1PVBmJ9eypXfs4GRiJwLuTZL0iSnJUKn1BFPa5BPZZJyFzPg==} engines: {node: '>=6.9.0'} + dev: true - '@babel/core@7.26.7': + /@babel/core@7.26.7: resolution: {integrity: sha512-SRijHmF0PSPgLIBYlWnG0hyeJLwXE2CgpsXaMOrtt2yp9/86ALw6oUlj9KYuZ0JN07T4eBMVIW4li/9S1j2BGA==} engines: {node: '>=6.9.0'} + dependencies: + '@ampproject/remapping': 2.3.0 + '@babel/code-frame': 7.26.2 + '@babel/generator': 7.26.5 + '@babel/helper-compilation-targets': 7.26.5 + '@babel/helper-module-transforms': 7.26.0(@babel/core@7.26.7) + '@babel/helpers': 7.26.7 + '@babel/parser': 7.26.7 + '@babel/template': 7.25.9 + '@babel/traverse': 7.26.7 + '@babel/types': 7.26.7 + convert-source-map: 2.0.0 + debug: 4.4.0 + gensync: 1.0.0-beta.2 + json5: 2.2.3 + semver: 6.3.1 + transitivePeerDependencies: + - supports-color + dev: true - '@babel/generator@7.26.5': + /@babel/generator@7.26.5: resolution: {integrity: sha512-2caSP6fN9I7HOe6nqhtft7V4g7/V/gfDsC3Ag4W7kEzzvRGKqiv0pu0HogPiZ3KaVSoNDhUws6IJjDjpfmYIXw==} engines: {node: '>=6.9.0'} + dependencies: + '@babel/parser': 7.26.7 + '@babel/types': 7.26.7 + '@jridgewell/gen-mapping': 0.3.8 + '@jridgewell/trace-mapping': 0.3.25 + jsesc: 3.1.0 + dev: true - '@babel/helper-compilation-targets@7.26.5': + /@babel/helper-compilation-targets@7.26.5: resolution: {integrity: sha512-IXuyn5EkouFJscIDuFF5EsiSolseme1s0CZB+QxVugqJLYmKdxI1VfIBOst0SUu4rnk2Z7kqTwmoO1lp3HIfnA==} engines: {node: '>=6.9.0'} + dependencies: + '@babel/compat-data': 7.26.5 + '@babel/helper-validator-option': 7.25.9 + browserslist: 4.24.4 + lru-cache: 5.1.1 + semver: 6.3.1 + dev: true - '@babel/helper-module-imports@7.25.9': + /@babel/helper-module-imports@7.25.9: resolution: {integrity: sha512-tnUA4RsrmflIM6W6RFTLFSXITtl0wKjgpnLgXyowocVPrbYrLUXSBXDgTs8BlbmIzIdlBySRQjINYs2BAkiLtw==} engines: {node: '>=6.9.0'} + dependencies: + '@babel/traverse': 7.26.7 + '@babel/types': 7.26.7 + transitivePeerDependencies: + - supports-color + dev: true - '@babel/helper-module-transforms@7.26.0': + /@babel/helper-module-transforms@7.26.0(@babel/core@7.26.7): resolution: {integrity: sha512-xO+xu6B5K2czEnQye6BHA7DolFFmS3LB7stHZFaOLb1pAwO1HWLS8fXA+eh0A2yIvltPVmx3eNNDBJA2SLHXFw==} engines: {node: '>=6.9.0'} peerDependencies: '@babel/core': ^7.0.0 + dependencies: + '@babel/core': 7.26.7 + '@babel/helper-module-imports': 7.25.9 + '@babel/helper-validator-identifier': 7.25.9 + '@babel/traverse': 7.26.7 + transitivePeerDependencies: + - supports-color + dev: true - '@babel/helper-string-parser@7.25.9': + /@babel/helper-string-parser@7.25.9: resolution: {integrity: sha512-4A/SCr/2KLd5jrtOMFzaKjVtAei3+2r/NChoBNoZ3EyP/+GlhoaEGoWOZUmFmoITP7zOJyHIMm+DYRd8o3PvHA==} engines: {node: '>=6.9.0'} + dev: true - '@babel/helper-validator-identifier@7.25.9': + /@babel/helper-validator-identifier@7.25.9: resolution: {integrity: sha512-Ed61U6XJc3CVRfkERJWDz4dJwKe7iLmmJsbOGu9wSloNSFttHV0I8g6UAgb7qnK5ly5bGLPd4oXZlxCdANBOWQ==} engines: {node: '>=6.9.0'} + dev: true - '@babel/helper-validator-option@7.25.9': + /@babel/helper-validator-option@7.25.9: resolution: {integrity: sha512-e/zv1co8pp55dNdEcCynfj9X7nyUKUXoUEwfXqaZt0omVOmDe9oOTdKStH4GmAw6zxMFs50ZayuMfHDKlO7Tfw==} engines: {node: '>=6.9.0'} + dev: true - '@babel/helpers@7.26.7': + /@babel/helpers@7.26.7: resolution: {integrity: sha512-8NHiL98vsi0mbPQmYAGWwfcFaOy4j2HY49fXJCfuDcdE7fMIsH9a7GdaeXpIBsbT7307WU8KCMp5pUVDNL4f9A==} engines: {node: '>=6.9.0'} + dependencies: + '@babel/template': 7.25.9 + '@babel/types': 7.26.7 + dev: true - '@babel/parser@7.26.7': + /@babel/parser@7.26.7: resolution: {integrity: sha512-kEvgGGgEjRUutvdVvZhbn/BxVt+5VSpwXz1j3WYXQbXDo8KzFOPNG2GQbdAiNq8g6wn1yKk7C/qrke03a84V+w==} engines: {node: '>=6.0.0'} hasBin: true + dependencies: + '@babel/types': 7.26.7 + dev: true - '@babel/runtime@7.26.7': + /@babel/runtime@7.26.7: resolution: {integrity: sha512-AOPI3D+a8dXnja+iwsUqGRjr1BbZIe771sXdapOtYI531gSqpi92vXivKcq2asu/DFpdl1ceFAKZyRzK2PCVcQ==} engines: {node: '>=6.9.0'} + dependencies: + regenerator-runtime: 0.14.1 + dev: true - '@babel/template@7.25.9': + /@babel/template@7.25.9: resolution: {integrity: sha512-9DGttpmPvIxBb/2uwpVo3dqJ+O6RooAFOS+lB+xDqoE2PVCE8nfoHMdZLpfCQRLwvohzXISPZcgxt80xLfsuwg==} engines: {node: '>=6.9.0'} + dependencies: + '@babel/code-frame': 7.26.2 + '@babel/parser': 7.26.7 + '@babel/types': 7.26.7 + dev: true - '@babel/traverse@7.26.7': + /@babel/traverse@7.26.7: resolution: {integrity: sha512-1x1sgeyRLC3r5fQOM0/xtQKsYjyxmFjaOrLJNtZ81inNjyJHGIolTULPiSc/2qe1/qfpFLisLQYFnnZl7QoedA==} engines: {node: '>=6.9.0'} + dependencies: + '@babel/code-frame': 7.26.2 + '@babel/generator': 7.26.5 + '@babel/parser': 7.26.7 + '@babel/template': 7.25.9 + '@babel/types': 7.26.7 + debug: 4.4.0 + globals: 11.12.0 + transitivePeerDependencies: + - supports-color + dev: true - '@babel/types@7.26.7': + /@babel/types@7.26.7: resolution: {integrity: sha512-t8kDRGrKXyp6+tjUh7hw2RLyclsW4TRoRvRHtSyAX9Bb5ldlFh+90YAYY6awRXrlB4G5G2izNeGySpATlFzmOg==} engines: {node: '>=6.9.0'} + dependencies: + '@babel/helper-string-parser': 7.25.9 + '@babel/helper-validator-identifier': 7.25.9 + dev: true - '@bundled-es-modules/cookie@2.0.1': + /@bundled-es-modules/cookie@2.0.1: resolution: {integrity: sha512-8o+5fRPLNbjbdGRRmJj3h6Hh1AQJf2dk3qQ/5ZFb+PXkRNiSoMGGUKlsgLfrxneb72axVJyIYji64E2+nNfYyw==} + dependencies: + cookie: 0.7.2 + dev: true - '@bundled-es-modules/statuses@1.0.1': + /@bundled-es-modules/statuses@1.0.1: resolution: {integrity: sha512-yn7BklA5acgcBr+7w064fGV+SGIFySjCKpqjcWgBAIfrAkY+4GQTJJHQMeT3V/sgz23VTEVV8TtOmkvJAhFVfg==} + dependencies: + statuses: 2.0.1 + dev: true - '@bundled-es-modules/tough-cookie@0.1.6': + /@bundled-es-modules/tough-cookie@0.1.6: resolution: {integrity: sha512-dvMHbL464C0zI+Yqxbz6kZ5TOEp7GLW+pry/RWndAR8MJQAXZ2rPmIs8tziTZjeIyhSNZgZbCePtfSbdWqStJw==} + dependencies: + '@types/tough-cookie': 4.0.5 + tough-cookie: 4.1.4 + dev: true - '@esbuild/aix-ppc64@0.24.2': + /@esbuild/aix-ppc64@0.24.2: resolution: {integrity: sha512-thpVCb/rhxE/BnMLQ7GReQLLN8q9qbHmI55F4489/ByVg2aQaQ6kbcLb6FHkocZzQhxc4gx0sCk0tJkKBFzDhA==} engines: {node: '>=18'} cpu: [ppc64] os: [aix] + requiresBuild: true + dev: true + optional: true - '@esbuild/android-arm64@0.24.2': + /@esbuild/android-arm64@0.24.2: resolution: {integrity: sha512-cNLgeqCqV8WxfcTIOeL4OAtSmL8JjcN6m09XIgro1Wi7cF4t/THaWEa7eL5CMoMBdjoHOTh/vwTO/o2TRXIyzg==} engines: {node: '>=18'} cpu: [arm64] os: [android] + requiresBuild: true + dev: true + optional: true - '@esbuild/android-arm@0.24.2': + /@esbuild/android-arm@0.24.2: resolution: {integrity: sha512-tmwl4hJkCfNHwFB3nBa8z1Uy3ypZpxqxfTQOcHX+xRByyYgunVbZ9MzUUfb0RxaHIMnbHagwAxuTL+tnNM+1/Q==} engines: {node: '>=18'} cpu: [arm] os: [android] + requiresBuild: true + dev: true + optional: true - '@esbuild/android-x64@0.24.2': + /@esbuild/android-x64@0.24.2: resolution: {integrity: sha512-B6Q0YQDqMx9D7rvIcsXfmJfvUYLoP722bgfBlO5cGvNVb5V/+Y7nhBE3mHV9OpxBf4eAS2S68KZztiPaWq4XYw==} engines: {node: '>=18'} cpu: [x64] os: [android] + requiresBuild: true + dev: true + optional: true - '@esbuild/darwin-arm64@0.24.2': + /@esbuild/darwin-arm64@0.24.2: resolution: {integrity: sha512-kj3AnYWc+CekmZnS5IPu9D+HWtUI49hbnyqk0FLEJDbzCIQt7hg7ucF1SQAilhtYpIujfaHr6O0UHlzzSPdOeA==} engines: {node: '>=18'} cpu: [arm64] os: [darwin] + requiresBuild: true + dev: true + optional: true - '@esbuild/darwin-x64@0.24.2': + /@esbuild/darwin-x64@0.24.2: resolution: {integrity: sha512-WeSrmwwHaPkNR5H3yYfowhZcbriGqooyu3zI/3GGpF8AyUdsrrP0X6KumITGA9WOyiJavnGZUwPGvxvwfWPHIA==} engines: {node: '>=18'} cpu: [x64] os: [darwin] + requiresBuild: true + dev: true + optional: true - '@esbuild/freebsd-arm64@0.24.2': + /@esbuild/freebsd-arm64@0.24.2: resolution: {integrity: sha512-UN8HXjtJ0k/Mj6a9+5u6+2eZ2ERD7Edt1Q9IZiB5UZAIdPnVKDoG7mdTVGhHJIeEml60JteamR3qhsr1r8gXvg==} engines: {node: '>=18'} cpu: [arm64] os: [freebsd] + requiresBuild: true + dev: true + optional: true - '@esbuild/freebsd-x64@0.24.2': + /@esbuild/freebsd-x64@0.24.2: resolution: {integrity: sha512-TvW7wE/89PYW+IevEJXZ5sF6gJRDY/14hyIGFXdIucxCsbRmLUcjseQu1SyTko+2idmCw94TgyaEZi9HUSOe3Q==} engines: {node: '>=18'} cpu: [x64] os: [freebsd] + requiresBuild: true + dev: true + optional: true - '@esbuild/linux-arm64@0.24.2': + /@esbuild/linux-arm64@0.24.2: resolution: {integrity: sha512-7HnAD6074BW43YvvUmE/35Id9/NB7BeX5EoNkK9obndmZBUk8xmJJeU7DwmUeN7tkysslb2eSl6CTrYz6oEMQg==} engines: {node: '>=18'} cpu: [arm64] os: [linux] + requiresBuild: true + dev: true + optional: true - '@esbuild/linux-arm@0.24.2': + /@esbuild/linux-arm@0.24.2: resolution: {integrity: sha512-n0WRM/gWIdU29J57hJyUdIsk0WarGd6To0s+Y+LwvlC55wt+GT/OgkwoXCXvIue1i1sSNWblHEig00GBWiJgfA==} engines: {node: '>=18'} cpu: [arm] os: [linux] + requiresBuild: true + dev: true + optional: true - '@esbuild/linux-ia32@0.24.2': + /@esbuild/linux-ia32@0.24.2: resolution: {integrity: sha512-sfv0tGPQhcZOgTKO3oBE9xpHuUqguHvSo4jl+wjnKwFpapx+vUDcawbwPNuBIAYdRAvIDBfZVvXprIj3HA+Ugw==} engines: {node: '>=18'} cpu: [ia32] os: [linux] + requiresBuild: true + dev: true + optional: true - '@esbuild/linux-loong64@0.24.2': + /@esbuild/linux-loong64@0.24.2: resolution: {integrity: sha512-CN9AZr8kEndGooS35ntToZLTQLHEjtVB5n7dl8ZcTZMonJ7CCfStrYhrzF97eAecqVbVJ7APOEe18RPI4KLhwQ==} engines: {node: '>=18'} cpu: [loong64] os: [linux] + requiresBuild: true + dev: true + optional: true - '@esbuild/linux-mips64el@0.24.2': + /@esbuild/linux-mips64el@0.24.2: resolution: {integrity: sha512-iMkk7qr/wl3exJATwkISxI7kTcmHKE+BlymIAbHO8xanq/TjHaaVThFF6ipWzPHryoFsesNQJPE/3wFJw4+huw==} engines: {node: '>=18'} cpu: [mips64el] os: [linux] + requiresBuild: true + dev: true + optional: true - '@esbuild/linux-ppc64@0.24.2': + /@esbuild/linux-ppc64@0.24.2: resolution: {integrity: sha512-shsVrgCZ57Vr2L8mm39kO5PPIb+843FStGt7sGGoqiiWYconSxwTiuswC1VJZLCjNiMLAMh34jg4VSEQb+iEbw==} engines: {node: '>=18'} cpu: [ppc64] os: [linux] + requiresBuild: true + dev: true + optional: true - '@esbuild/linux-riscv64@0.24.2': + /@esbuild/linux-riscv64@0.24.2: resolution: {integrity: sha512-4eSFWnU9Hhd68fW16GD0TINewo1L6dRrB+oLNNbYyMUAeOD2yCK5KXGK1GH4qD/kT+bTEXjsyTCiJGHPZ3eM9Q==} engines: {node: '>=18'} cpu: [riscv64] os: [linux] + requiresBuild: true + dev: true + optional: true - '@esbuild/linux-s390x@0.24.2': + /@esbuild/linux-s390x@0.24.2: resolution: {integrity: sha512-S0Bh0A53b0YHL2XEXC20bHLuGMOhFDO6GN4b3YjRLK//Ep3ql3erpNcPlEFed93hsQAjAQDNsvcK+hV90FubSw==} engines: {node: '>=18'} cpu: [s390x] os: [linux] + requiresBuild: true + dev: true + optional: true - '@esbuild/linux-x64@0.24.2': + /@esbuild/linux-x64@0.24.2: resolution: {integrity: sha512-8Qi4nQcCTbLnK9WoMjdC9NiTG6/E38RNICU6sUNqK0QFxCYgoARqVqxdFmWkdonVsvGqWhmm7MO0jyTqLqwj0Q==} engines: {node: '>=18'} cpu: [x64] os: [linux] + requiresBuild: true + dev: true + optional: true - '@esbuild/netbsd-arm64@0.24.2': + /@esbuild/netbsd-arm64@0.24.2: resolution: {integrity: sha512-wuLK/VztRRpMt9zyHSazyCVdCXlpHkKm34WUyinD2lzK07FAHTq0KQvZZlXikNWkDGoT6x3TD51jKQ7gMVpopw==} engines: {node: '>=18'} cpu: [arm64] os: [netbsd] + requiresBuild: true + dev: true + optional: true - '@esbuild/netbsd-x64@0.24.2': + /@esbuild/netbsd-x64@0.24.2: resolution: {integrity: sha512-VefFaQUc4FMmJuAxmIHgUmfNiLXY438XrL4GDNV1Y1H/RW3qow68xTwjZKfj/+Plp9NANmzbH5R40Meudu8mmw==} engines: {node: '>=18'} cpu: [x64] os: [netbsd] + requiresBuild: true + dev: true + optional: true - '@esbuild/openbsd-arm64@0.24.2': + /@esbuild/openbsd-arm64@0.24.2: resolution: {integrity: sha512-YQbi46SBct6iKnszhSvdluqDmxCJA+Pu280Av9WICNwQmMxV7nLRHZfjQzwbPs3jeWnuAhE9Jy0NrnJ12Oz+0A==} engines: {node: '>=18'} cpu: [arm64] os: [openbsd] + requiresBuild: true + dev: true + optional: true - '@esbuild/openbsd-x64@0.24.2': + /@esbuild/openbsd-x64@0.24.2: resolution: {integrity: sha512-+iDS6zpNM6EnJyWv0bMGLWSWeXGN/HTaF/LXHXHwejGsVi+ooqDfMCCTerNFxEkM3wYVcExkeGXNqshc9iMaOA==} engines: {node: '>=18'} cpu: [x64] os: [openbsd] + requiresBuild: true + dev: true + optional: true - '@esbuild/sunos-x64@0.24.2': + /@esbuild/sunos-x64@0.24.2: resolution: {integrity: sha512-hTdsW27jcktEvpwNHJU4ZwWFGkz2zRJUz8pvddmXPtXDzVKTTINmlmga3ZzwcuMpUvLw7JkLy9QLKyGpD2Yxig==} engines: {node: '>=18'} cpu: [x64] os: [sunos] + requiresBuild: true + dev: true + optional: true - '@esbuild/win32-arm64@0.24.2': + /@esbuild/win32-arm64@0.24.2: resolution: {integrity: sha512-LihEQ2BBKVFLOC9ZItT9iFprsE9tqjDjnbulhHoFxYQtQfai7qfluVODIYxt1PgdoyQkz23+01rzwNwYfutxUQ==} engines: {node: '>=18'} cpu: [arm64] os: [win32] + requiresBuild: true + dev: true + optional: true - '@esbuild/win32-ia32@0.24.2': + /@esbuild/win32-ia32@0.24.2: resolution: {integrity: sha512-q+iGUwfs8tncmFC9pcnD5IvRHAzmbwQ3GPS5/ceCyHdjXubwQWI12MKWSNSMYLJMq23/IUCvJMS76PDqXe1fxA==} engines: {node: '>=18'} cpu: [ia32] os: [win32] + requiresBuild: true + dev: true + optional: true - '@esbuild/win32-x64@0.24.2': + /@esbuild/win32-x64@0.24.2: resolution: {integrity: sha512-7VTgWzgMGvup6aSqDPLiW5zHaxYJGTO4OokMjIlrCtf+VpEL+cXKtCvg723iguPYI5oaUNdS+/V7OU2gvXVWEg==} engines: {node: '>=18'} cpu: [x64] os: [win32] + requiresBuild: true + dev: true + optional: true - '@inquirer/confirm@5.1.5': + /@inquirer/confirm@5.1.5(@types/node@22.13.0): resolution: {integrity: sha512-ZB2Cz8KeMINUvoeDi7IrvghaVkYT2RB0Zb31EaLWOE87u276w4wnApv0SH2qWaJ3r0VSUa3BIuz7qAV2ZvsZlg==} engines: {node: '>=18'} peerDependencies: @@ -280,8 +456,13 @@ packages: peerDependenciesMeta: '@types/node': optional: true + dependencies: + '@inquirer/core': 10.1.6(@types/node@22.13.0) + '@inquirer/type': 3.0.4(@types/node@22.13.0) + '@types/node': 22.13.0 + dev: true - '@inquirer/core@10.1.6': + /@inquirer/core@10.1.6(@types/node@22.13.0): resolution: {integrity: sha512-Bwh/Zk6URrHwZnSSzAZAKH7YgGYi0xICIBDFOqBQoXNNAzBHw/bgXgLmChfp+GyR3PnChcTbiCTZGC6YJNJkMA==} engines: {node: '>=18'} peerDependencies: @@ -289,12 +470,24 @@ packages: peerDependenciesMeta: '@types/node': optional: true + dependencies: + '@inquirer/figures': 1.0.10 + '@inquirer/type': 3.0.4(@types/node@22.13.0) + '@types/node': 22.13.0 + ansi-escapes: 4.3.2 + cli-width: 4.1.0 + mute-stream: 2.0.0 + signal-exit: 4.1.0 + wrap-ansi: 6.2.0 + yoctocolors-cjs: 2.1.2 + dev: true - '@inquirer/figures@1.0.10': + /@inquirer/figures@1.0.10: resolution: {integrity: sha512-Ey6176gZmeqZuY/W/nZiUyvmb1/qInjcpiZjXWi6nON+nxJpD1bxtSoBxNliGISae32n6OwbY+TSXPZ1CfS4bw==} engines: {node: '>=18'} + dev: true - '@inquirer/type@3.0.4': + /@inquirer/type@3.0.4(@types/node@22.13.0): resolution: {integrity: sha512-2MNFrDY8jkFYc9Il9DgLsHhMzuHnOYM1+CUYVWbzu9oT0hC7V7EcYvdCKeoll/Fcci04A+ERZ9wcc7cQ8lTkIA==} engines: {node: '>=18'} peerDependencies: @@ -302,67 +495,140 @@ packages: peerDependenciesMeta: '@types/node': optional: true + dependencies: + '@types/node': 22.13.0 + dev: true - '@isaacs/cliui@8.0.2': + /@isaacs/cliui@8.0.2: resolution: {integrity: sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==} engines: {node: '>=12'} + dependencies: + string-width: 5.1.2 + string-width-cjs: /string-width@4.2.3 + strip-ansi: 7.1.0 + strip-ansi-cjs: /strip-ansi@6.0.1 + wrap-ansi: 8.1.0 + wrap-ansi-cjs: /wrap-ansi@7.0.0 + dev: true - '@istanbuljs/schema@0.1.3': + /@istanbuljs/schema@0.1.3: resolution: {integrity: sha512-ZXRY4jNvVgSVQ8DL3LTcakaAtXwTVUxE81hslsyD2AtoXW/wVob10HkOJ1X/pAlcI7D+2YoZKg5do8G/w6RYgA==} engines: {node: '>=8'} + dev: true - '@jridgewell/gen-mapping@0.3.8': + /@jridgewell/gen-mapping@0.3.8: resolution: {integrity: sha512-imAbBGkb+ebQyxKgzv5Hu2nmROxoDOXHh80evxdoXNOrvAnVx7zimzc1Oo5h9RlfV4vPXaE2iM5pOFbvOCClWA==} engines: {node: '>=6.0.0'} + dependencies: + '@jridgewell/set-array': 1.2.1 + '@jridgewell/sourcemap-codec': 1.5.0 + '@jridgewell/trace-mapping': 0.3.25 + dev: true - '@jridgewell/resolve-uri@3.1.2': + /@jridgewell/resolve-uri@3.1.2: resolution: {integrity: sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==} engines: {node: '>=6.0.0'} + dev: true - '@jridgewell/set-array@1.2.1': + /@jridgewell/set-array@1.2.1: resolution: {integrity: sha512-R8gLRTZeyp03ymzP/6Lil/28tGeGEzhx1q2k703KGWRAI1VdvPIXdG70VJc2pAMw3NA6JKL5hhFu1sJX0Mnn/A==} engines: {node: '>=6.0.0'} + dev: true - '@jridgewell/sourcemap-codec@1.5.0': + /@jridgewell/sourcemap-codec@1.5.0: resolution: {integrity: sha512-gv3ZRaISU3fjPAgNsriBRqGWQL6quFx04YMPW/zD8XMLsU32mhCCbfbO6KZFLjvYpCZ8zyDEgqsgf+PwPaM7GQ==} + dev: true - '@jridgewell/trace-mapping@0.3.25': + /@jridgewell/trace-mapping@0.3.25: resolution: {integrity: sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ==} + dependencies: + '@jridgewell/resolve-uri': 3.1.2 + '@jridgewell/sourcemap-codec': 1.5.0 + dev: true - '@microsoft/api-extractor-model@7.30.3': + /@microsoft/api-extractor-model@7.30.3(@types/node@22.13.0): resolution: {integrity: sha512-yEAvq0F78MmStXdqz9TTT4PZ05Xu5R8nqgwI5xmUmQjWBQ9E6R2n8HB/iZMRciG4rf9iwI2mtuQwIzDXBvHn1w==} + dependencies: + '@microsoft/tsdoc': 0.15.1 + '@microsoft/tsdoc-config': 0.17.1 + '@rushstack/node-core-library': 5.11.0(@types/node@22.13.0) + transitivePeerDependencies: + - '@types/node' + dev: true - '@microsoft/api-extractor@7.49.2': + /@microsoft/api-extractor@7.49.2(@types/node@22.13.0): resolution: {integrity: sha512-DI/WnvhbkHcucxxc4ys00ejCiViFls5EKPrEfe4NV3GGpVkoM5ZXF61HZNSGA8IG0oEV4KfTqIa59Rc3wdMopw==} hasBin: true + dependencies: + '@microsoft/api-extractor-model': 7.30.3(@types/node@22.13.0) + '@microsoft/tsdoc': 0.15.1 + '@microsoft/tsdoc-config': 0.17.1 + '@rushstack/node-core-library': 5.11.0(@types/node@22.13.0) + '@rushstack/rig-package': 0.5.3 + '@rushstack/terminal': 0.14.6(@types/node@22.13.0) + '@rushstack/ts-command-line': 4.23.4(@types/node@22.13.0) + lodash: 4.17.21 + minimatch: 3.0.8 + resolve: 1.22.10 + semver: 7.5.4 + source-map: 0.6.1 + typescript: 5.7.2 + transitivePeerDependencies: + - '@types/node' + dev: true - '@microsoft/tsdoc-config@0.17.1': + /@microsoft/tsdoc-config@0.17.1: resolution: {integrity: sha512-UtjIFe0C6oYgTnad4q1QP4qXwLhe6tIpNTRStJ2RZEPIkqQPREAwE5spzVxsdn9UaEMUqhh0AqSx3X4nWAKXWw==} + dependencies: + '@microsoft/tsdoc': 0.15.1 + ajv: 8.12.0 + jju: 1.4.0 + resolve: 1.22.10 + dev: true - '@microsoft/tsdoc@0.15.1': + /@microsoft/tsdoc@0.15.1: resolution: {integrity: sha512-4aErSrCR/On/e5G2hDP0wjooqDdauzEbIq8hIkIe5pXV0rtWJZvdCEKL0ykZxex+IxIwBp0eGeV48hQN07dXtw==} + dev: true - '@mswjs/interceptors@0.37.6': + /@mswjs/interceptors@0.37.6: resolution: {integrity: sha512-wK+5pLK5XFmgtH3aQ2YVvA3HohS3xqV/OxuVOdNx9Wpnz7VE/fnC+e1A7ln6LFYeck7gOJ/dsZV6OLplOtAJ2w==} engines: {node: '>=18'} + dependencies: + '@open-draft/deferred-promise': 2.2.0 + '@open-draft/logger': 0.3.0 + '@open-draft/until': 2.1.0 + is-node-process: 1.2.0 + outvariant: 1.4.3 + strict-event-emitter: 0.5.1 + dev: true - '@open-draft/deferred-promise@2.2.0': + /@open-draft/deferred-promise@2.2.0: resolution: {integrity: sha512-CecwLWx3rhxVQF6V4bAgPS5t+So2sTbPgAzafKkVizyi7tlwpcFpdFqq+wqF2OwNBmqFuu6tOyouTuxgpMfzmA==} + dev: true - '@open-draft/logger@0.3.0': + /@open-draft/logger@0.3.0: resolution: {integrity: sha512-X2g45fzhxH238HKO4xbSr7+wBS8Fvw6ixhTDuvLd5mqh6bJJCFAPwU9mPDxbcrRtfxv4u5IHCEH77BmxvXmmxQ==} + dependencies: + is-node-process: 1.2.0 + outvariant: 1.4.3 + dev: true - '@open-draft/until@2.1.0': + /@open-draft/until@2.1.0: resolution: {integrity: sha512-U69T3ItWHvLwGg5eJ0n3I62nWuE6ilHlmz7zM0npLBRvPRd7e6NYmg54vvRtP5mZG7kZqZCFVdsTWo7BPtBujg==} + dev: true - '@pkgjs/parseargs@0.11.0': + /@pkgjs/parseargs@0.11.0: resolution: {integrity: sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==} engines: {node: '>=14'} + requiresBuild: true + dev: true + optional: true - '@polka/url@1.0.0-next.28': + /@polka/url@1.0.0-next.28: resolution: {integrity: sha512-8LduaNlMZGwdZ6qWrKlfa+2M4gahzFkprZiAt2TF8uS0qQgBizKXpXURqvTJ4WtmupWxaLqjRb2UCTe72mu+Aw==} + dev: true - '@rollup/pluginutils@5.1.4': + /@rollup/pluginutils@5.1.4: resolution: {integrity: sha512-USm05zrsFxYLPdWWq+K3STlWiT/3ELn3RcV5hJMghpeAIhxfsUIg6mt12CBJBInWMV4VneoV7SfGv8xIwo2qNQ==} engines: {node: '>=14.0.0'} peerDependencies: @@ -370,160 +636,273 @@ packages: peerDependenciesMeta: rollup: optional: true + dependencies: + '@types/estree': 1.0.6 + estree-walker: 2.0.2 + picomatch: 4.0.2 + dev: true - '@rollup/rollup-android-arm-eabi@4.34.1': - resolution: {integrity: sha512-kwctwVlswSEsr4ljpmxKrRKp1eG1v2NAhlzFzDf1x1OdYaMjBYjDCbHkzWm57ZXzTwqn8stMXgROrnMw8dJK3w==} + /@rollup/rollup-android-arm-eabi@4.34.2: + resolution: {integrity: sha512-6Fyg9yQbwJR+ykVdT9sid1oc2ewejS6h4wzQltmJfSW53N60G/ah9pngXGANdy9/aaE/TcUFpWosdm7JXS1WTQ==} cpu: [arm] os: [android] + requiresBuild: true + dev: true + optional: true - '@rollup/rollup-android-arm64@4.34.1': - resolution: {integrity: sha512-4H5ZtZitBPlbPsTv6HBB8zh1g5d0T8TzCmpndQdqq20Ugle/nroOyDMf9p7f88Gsu8vBLU78/cuh8FYHZqdXxw==} + /@rollup/rollup-android-arm64@4.34.2: + resolution: {integrity: sha512-K5GfWe+vtQ3kyEbihrimM38UgX57UqHp+oME7X/EX9Im6suwZfa7Hsr8AtzbJvukTpwMGs+4s29YMSO3rwWtsw==} cpu: [arm64] os: [android] + requiresBuild: true + dev: true + optional: true - '@rollup/rollup-darwin-arm64@4.34.1': - resolution: {integrity: sha512-f2AJ7Qwx9z25hikXvg+asco8Sfuc5NCLg8rmqQBIOUoWys5sb/ZX9RkMZDPdnnDevXAMJA5AWLnRBmgdXGEUiA==} + /@rollup/rollup-darwin-arm64@4.34.2: + resolution: {integrity: sha512-PSN58XG/V/tzqDb9kDGutUruycgylMlUE59f40ny6QIRNsTEIZsrNQTJKUN2keMMSmlzgunMFqyaGLmly39sug==} cpu: [arm64] os: [darwin] + requiresBuild: true + dev: true + optional: true - '@rollup/rollup-darwin-x64@4.34.1': - resolution: {integrity: sha512-+/2JBrRfISCsWE4aEFXxd+7k9nWGXA8+wh7ZUHn/u8UDXOU9LN+QYKKhd57sIn6WRcorOnlqPMYFIwie/OHXWw==} + /@rollup/rollup-darwin-x64@4.34.2: + resolution: {integrity: sha512-gQhK788rQJm9pzmXyfBB84VHViDERhAhzGafw+E5mUpnGKuxZGkMVDa3wgDFKT6ukLC5V7QTifzsUKdNVxp5qQ==} cpu: [x64] os: [darwin] + requiresBuild: true + dev: true + optional: true - '@rollup/rollup-freebsd-arm64@4.34.1': - resolution: {integrity: sha512-SUeB0pYjIXwT2vfAMQ7E4ERPq9VGRrPR7Z+S4AMssah5EHIilYqjWQoTn5dkDtuIJUSTs8H+C9dwoEcg3b0sCA==} + /@rollup/rollup-freebsd-arm64@4.34.2: + resolution: {integrity: sha512-eiaHgQwGPpxLC3+zTAcdKl4VsBl3r0AiJOd1Um/ArEzAjN/dbPK1nROHrVkdnoE6p7Svvn04w3f/jEZSTVHunA==} cpu: [arm64] os: [freebsd] + requiresBuild: true + dev: true + optional: true - '@rollup/rollup-freebsd-x64@4.34.1': - resolution: {integrity: sha512-L3T66wAZiB/ooiPbxz0s6JEX6Sr2+HfgPSK+LMuZkaGZFAFCQAHiP3dbyqovYdNaiUXcl9TlgnIbcsIicAnOZg==} + /@rollup/rollup-freebsd-x64@4.34.2: + resolution: {integrity: sha512-lhdiwQ+jf8pewYOTG4bag0Qd68Jn1v2gO1i0mTuiD+Qkt5vNfHVK/jrT7uVvycV8ZchlzXp5HDVmhpzjC6mh0g==} cpu: [x64] os: [freebsd] + requiresBuild: true + dev: true + optional: true - '@rollup/rollup-linux-arm-gnueabihf@4.34.1': - resolution: {integrity: sha512-UBXdQ4+ATARuFgsFrQ+tAsKvBi/Hly99aSVdeCUiHV9dRTTpMU7OrM3WXGys1l40wKVNiOl0QYY6cZQJ2xhKlQ==} + /@rollup/rollup-linux-arm-gnueabihf@4.34.2: + resolution: {integrity: sha512-lfqTpWjSvbgQP1vqGTXdv+/kxIznKXZlI109WkIFPbud41bjigjNmOAAKoazmRGx+k9e3rtIdbq2pQZPV1pMig==} cpu: [arm] os: [linux] + requiresBuild: true + dev: true + optional: true - '@rollup/rollup-linux-arm-musleabihf@4.34.1': - resolution: {integrity: sha512-m/yfZ25HGdcCSwmopEJm00GP7xAUyVcBPjttGLRAqZ60X/bB4Qn6gP7XTwCIU6bITeKmIhhwZ4AMh2XLro+4+w==} + /@rollup/rollup-linux-arm-musleabihf@4.34.2: + resolution: {integrity: sha512-RGjqULqIurqqv+NJTyuPgdZhka8ImMLB32YwUle2BPTDqDoXNgwFjdjQC59FbSk08z0IqlRJjrJ0AvDQ5W5lpw==} cpu: [arm] os: [linux] + requiresBuild: true + dev: true + optional: true - '@rollup/rollup-linux-arm64-gnu@4.34.1': - resolution: {integrity: sha512-Wy+cUmFuvziNL9qWRRzboNprqSQ/n38orbjRvd6byYWridp5TJ3CD+0+HUsbcWVSNz9bxkDUkyASGP0zS7GAvg==} + /@rollup/rollup-linux-arm64-gnu@4.34.2: + resolution: {integrity: sha512-ZvkPiheyXtXlFqHpsdgscx+tZ7hoR59vOettvArinEspq5fxSDSgfF+L5wqqJ9R4t+n53nyn0sKxeXlik7AY9Q==} cpu: [arm64] os: [linux] + requiresBuild: true + dev: true + optional: true - '@rollup/rollup-linux-arm64-musl@4.34.1': - resolution: {integrity: sha512-CQ3MAGgiFmQW5XJX5W3wnxOBxKwFlUAgSXFA2SwgVRjrIiVt5LHfcQLeNSHKq5OEZwv+VCBwlD1+YKCjDG8cpg==} + /@rollup/rollup-linux-arm64-musl@4.34.2: + resolution: {integrity: sha512-UlFk+E46TZEoxD9ufLKDBzfSG7Ki03fo6hsNRRRHF+KuvNZ5vd1RRVQm8YZlGsjcJG8R252XFK0xNPay+4WV7w==} cpu: [arm64] os: [linux] + requiresBuild: true + dev: true + optional: true - '@rollup/rollup-linux-loongarch64-gnu@4.34.1': - resolution: {integrity: sha512-rSzb1TsY4lSwH811cYC3OC2O2mzNMhM13vcnA7/0T6Mtreqr3/qs6WMDriMRs8yvHDI54qxHgOk8EV5YRAHFbw==} + /@rollup/rollup-linux-loongarch64-gnu@4.34.2: + resolution: {integrity: sha512-hJhfsD9ykx59jZuuoQgYT1GEcNNi3RCoEmbo5OGfG8RlHOiVS7iVNev9rhLKh7UBYq409f4uEw0cclTXx8nh8Q==} cpu: [loong64] os: [linux] + requiresBuild: true + dev: true + optional: true - '@rollup/rollup-linux-powerpc64le-gnu@4.34.1': - resolution: {integrity: sha512-fwr0n6NS0pG3QxxlqVYpfiY64Fd1Dqd8Cecje4ILAV01ROMp4aEdCj5ssHjRY3UwU7RJmeWd5fi89DBqMaTawg==} + /@rollup/rollup-linux-powerpc64le-gnu@4.34.2: + resolution: {integrity: sha512-g/O5IpgtrQqPegvqopvmdCF9vneLE7eqYfdPWW8yjPS8f63DNam3U4ARL1PNNB64XHZDHKpvO2Giftf43puB8Q==} cpu: [ppc64] os: [linux] + requiresBuild: true + dev: true + optional: true - '@rollup/rollup-linux-riscv64-gnu@4.34.1': - resolution: {integrity: sha512-4uJb9qz7+Z/yUp5RPxDGGGUcoh0PnKF33QyWgEZ3X/GocpWb6Mb+skDh59FEt5d8+Skxqs9mng6Swa6B2AmQZg==} + /@rollup/rollup-linux-riscv64-gnu@4.34.2: + resolution: {integrity: sha512-bSQijDC96M6PuooOuXHpvXUYiIwsnDmqGU8+br2U7iPoykNi9JtMUpN7K6xml29e0evK0/g0D1qbAUzWZFHY5Q==} cpu: [riscv64] os: [linux] + requiresBuild: true + dev: true + optional: true - '@rollup/rollup-linux-s390x-gnu@4.34.1': - resolution: {integrity: sha512-QlIo8ndocWBEnfmkYqj8vVtIUpIqJjfqKggjy7IdUncnt8BGixte1wDON7NJEvLg3Kzvqxtbo8tk+U1acYEBlw==} + /@rollup/rollup-linux-s390x-gnu@4.34.2: + resolution: {integrity: sha512-49TtdeVAsdRuiUHXPrFVucaP4SivazetGUVH8CIxVsNsaPHV4PFkpLmH9LeqU/R4Nbgky9lzX5Xe1NrzLyraVA==} cpu: [s390x] os: [linux] + requiresBuild: true + dev: true + optional: true - '@rollup/rollup-linux-x64-gnu@4.34.1': - resolution: {integrity: sha512-hzpleiKtq14GWjz3ahWvJXgU1DQC9DteiwcsY4HgqUJUGxZThlL66MotdUEK9zEo0PK/2ADeZGM9LIondE302A==} + /@rollup/rollup-linux-x64-gnu@4.34.2: + resolution: {integrity: sha512-j+jFdfOycLIQ7FWKka9Zd3qvsIyugg5LeZuHF6kFlXo6MSOc6R1w37YUVy8VpAKd81LMWGi5g9J25P09M0SSIw==} cpu: [x64] os: [linux] + requiresBuild: true + dev: true + optional: true - '@rollup/rollup-linux-x64-musl@4.34.1': - resolution: {integrity: sha512-jqtKrO715hDlvUcEsPn55tZt2TEiBvBtCMkUuU0R6fO/WPT7lO9AONjPbd8II7/asSiNVQHCMn4OLGigSuxVQA==} + /@rollup/rollup-linux-x64-musl@4.34.2: + resolution: {integrity: sha512-aDPHyM/D2SpXfSNCVWCxyHmOqN9qb7SWkY1+vaXqMNMXslZYnwh9V/UCudl6psyG0v6Ukj7pXanIpfZwCOEMUg==} cpu: [x64] os: [linux] + requiresBuild: true + dev: true + optional: true - '@rollup/rollup-win32-arm64-msvc@4.34.1': - resolution: {integrity: sha512-RnHy7yFf2Wz8Jj1+h8klB93N0NHNHXFhNwAmiy9zJdpY7DE01VbEVtPdrK1kkILeIbHGRJjvfBDBhnxBr8kD4g==} + /@rollup/rollup-win32-arm64-msvc@4.34.2: + resolution: {integrity: sha512-LQRkCyUBnAo7r8dbEdtNU08EKLCJMgAk2oP5H3R7BnUlKLqgR3dUjrLBVirmc1RK6U6qhtDw29Dimeer8d5hzQ==} cpu: [arm64] os: [win32] + requiresBuild: true + dev: true + optional: true - '@rollup/rollup-win32-ia32-msvc@4.34.1': - resolution: {integrity: sha512-i7aT5HdiZIcd7quhzvwQ2oAuX7zPYrYfkrd1QFfs28Po/i0q6kas/oRrzGlDhAEyug+1UfUtkWdmoVlLJj5x9Q==} + /@rollup/rollup-win32-ia32-msvc@4.34.2: + resolution: {integrity: sha512-wt8OhpQUi6JuPFkm1wbVi1BByeag87LDFzeKSXzIdGcX4bMLqORTtKxLoCbV57BHYNSUSOKlSL4BYYUghainYA==} cpu: [ia32] os: [win32] + requiresBuild: true + dev: true + optional: true - '@rollup/rollup-win32-x64-msvc@4.34.1': - resolution: {integrity: sha512-k3MVFD9Oq+laHkw2N2v7ILgoa9017ZMF/inTtHzyTVZjYs9cSH18sdyAf6spBAJIGwJ5UaC7et2ZH1WCdlhkMw==} + /@rollup/rollup-win32-x64-msvc@4.34.2: + resolution: {integrity: sha512-rUrqINax0TvrPBXrFKg0YbQx18NpPN3NNrgmaao9xRNbTwek7lOXObhx8tQy8gelmQ/gLaGy1WptpU2eKJZImg==} cpu: [x64] os: [win32] + requiresBuild: true + dev: true + optional: true - '@rushstack/node-core-library@5.11.0': + /@rushstack/node-core-library@5.11.0(@types/node@22.13.0): resolution: {integrity: sha512-I8+VzG9A0F3nH2rLpPd7hF8F7l5Xb7D+ldrWVZYegXM6CsKkvWc670RlgK3WX8/AseZfXA/vVrh0bpXe2Y2UDQ==} peerDependencies: '@types/node': '*' peerDependenciesMeta: '@types/node': optional: true + dependencies: + '@types/node': 22.13.0 + ajv: 8.13.0 + ajv-draft-04: 1.0.0(ajv@8.13.0) + ajv-formats: 3.0.1(ajv@8.13.0) + fs-extra: 11.3.0 + import-lazy: 4.0.0 + jju: 1.4.0 + resolve: 1.22.10 + semver: 7.5.4 + dev: true - '@rushstack/rig-package@0.5.3': + /@rushstack/rig-package@0.5.3: resolution: {integrity: sha512-olzSSjYrvCNxUFZowevC3uz8gvKr3WTpHQ7BkpjtRpA3wK+T0ybep/SRUMfr195gBzJm5gaXw0ZMgjIyHqJUow==} + dependencies: + resolve: 1.22.10 + strip-json-comments: 3.1.1 + dev: true - '@rushstack/terminal@0.14.6': + /@rushstack/terminal@0.14.6(@types/node@22.13.0): resolution: {integrity: sha512-4nMUy4h0u5PGXVG71kEA9uYI3l8GjVqewoHOFONiM6fuqS51ORdaJZ5ZXB2VZEGUyfg1TOTSy88MF2cdAy+lqA==} peerDependencies: '@types/node': '*' peerDependenciesMeta: '@types/node': optional: true + dependencies: + '@rushstack/node-core-library': 5.11.0(@types/node@22.13.0) + '@types/node': 22.13.0 + supports-color: 8.1.1 + dev: true - '@rushstack/ts-command-line@4.23.4': + /@rushstack/ts-command-line@4.23.4(@types/node@22.13.0): resolution: {integrity: sha512-pqmzDJCm0TS8VyeqnzcJ7ncwXgiLDQ6LVmXXfqv2nPL6VIz+UpyTpNVfZRJpyyJ+UDxqob1vIj2liaUfBjv8/A==} + dependencies: + '@rushstack/terminal': 0.14.6(@types/node@22.13.0) + '@types/argparse': 1.0.38 + argparse: 1.0.10 + string-argv: 0.3.2 + transitivePeerDependencies: + - '@types/node' + dev: true - '@testing-library/dom@10.4.0': + /@testing-library/dom@10.4.0: resolution: {integrity: sha512-pemlzrSESWbdAloYml3bAJMEfNh1Z7EduzqPKprCH5S341frlpYnUEW0H72dLxa6IsYr+mPno20GiSm+h9dEdQ==} engines: {node: '>=18'} + dependencies: + '@babel/code-frame': 7.26.2 + '@babel/runtime': 7.26.7 + '@types/aria-query': 5.0.4 + aria-query: 5.3.0 + chalk: 4.1.2 + dom-accessibility-api: 0.5.16 + lz-string: 1.5.0 + pretty-format: 27.5.1 + dev: true - '@testing-library/user-event@14.6.1': + /@testing-library/user-event@14.6.1(@testing-library/dom@10.4.0): resolution: {integrity: sha512-vq7fv0rnt+QTXgPxr5Hjc210p6YKq2kmdziLgnsZGgLJ9e6VAShx1pACLuRjd/AS/sr7phAR58OIIpf0LlmQNw==} engines: {node: '>=12', npm: '>=6'} peerDependencies: '@testing-library/dom': '>=7.21.4' + dependencies: + '@testing-library/dom': 10.4.0 + dev: true - '@thednp/dommatrix@2.0.11': + /@thednp/dommatrix@2.0.11: resolution: {integrity: sha512-e4X97qU68a4ycieaGiRgmeE4KltnV8GPE1pUxdtgvJQBe4VvzL4a6Xxb+X8dI1cQrUVAkl3uSe5nGRXrAmNpkQ==} engines: {node: '>=20', pnpm: '>=8.6.0'} + dev: false - '@types/argparse@1.0.38': + /@types/argparse@1.0.38: resolution: {integrity: sha512-ebDJ9b0e702Yr7pWgB0jzm+CX4Srzz8RcXtLJDJB+BSccqMa36uyH/zUsSYao5+BD1ytv3k3rPYCq4mAE1hsXA==} + dev: true - '@types/aria-query@5.0.4': + /@types/aria-query@5.0.4: resolution: {integrity: sha512-rfT93uj5s0PRL7EzccGMs3brplhcrghnDoV26NqKhCAS1hVo+WdNsPvE/yb6ilfr5hi2MEk6d5EWJTKdxg8jVw==} + dev: true - '@types/cookie@0.6.0': + /@types/cookie@0.6.0: resolution: {integrity: sha512-4Kh9a6B2bQciAhf7FSuMRRkUWecJgJu9nPnx3yzpsfXX/c50REIqpHY4C82bXP90qrLtXtkDxTZosYO3UpOwlA==} + dev: true - '@types/estree@1.0.6': + /@types/estree@1.0.6: resolution: {integrity: sha512-AYnb1nQyY49te+VRAVgmzfcgjYS91mY5P0TKUDCLEM+gNnA+3T6rWITXRLYCpahpqSQbN5cE+gHpnPyXjHWxcw==} + dev: true - '@types/node@22.13.0': + /@types/node@22.13.0: resolution: {integrity: sha512-ClIbNe36lawluuvq3+YYhnIN2CELi+6q8NpnM7PYp4hBn/TatfboPgVSm2rwKRfnV2M+Ty9GWDFI64KEe+kysA==} + dependencies: + undici-types: 6.20.0 + dev: true - '@types/statuses@2.0.5': + /@types/statuses@2.0.5: resolution: {integrity: sha512-jmIUGWrAiwu3dZpxntxieC+1n/5c3mjrImkmOSQ2NC5uP6cYO4aAZDdSmRcI5C1oiTmqlZGHC+/NmJrKogbP5A==} + dev: true - '@types/tough-cookie@4.0.5': + /@types/tough-cookie@4.0.5: resolution: {integrity: sha512-/Ad8+nIOV7Rl++6f1BdKxFSMgmoqEoYbHRpPcx3JEfv8VRsQe9Z4mCXeJBzxs7mbHY/XOZZuXlRNfhpVPbs6ZA==} + dev: true - '@vitest/browser@3.0.5': + /@vitest/browser@3.0.5(@types/node@22.13.0)(playwright@1.50.1)(typescript@5.7.3)(vite@6.0.11)(vitest@3.0.5): resolution: {integrity: sha512-5WAWJoucuWcGYU5t0HPBY03k9uogbUEIu4pDmZHoB4Dt+6pXqzDbzEmxGjejZSitSYA3k/udYfuotKNxETVA3A==} peerDependencies: playwright: '*' @@ -537,16 +916,56 @@ packages: optional: true webdriverio: optional: true + dependencies: + '@testing-library/dom': 10.4.0 + '@testing-library/user-event': 14.6.1(@testing-library/dom@10.4.0) + '@vitest/mocker': 3.0.5(msw@2.7.0)(vite@6.0.11) + '@vitest/utils': 3.0.5 + magic-string: 0.30.17 + msw: 2.7.0(@types/node@22.13.0)(typescript@5.7.3) + playwright: 1.50.1 + sirv: 3.0.0 + tinyrainbow: 2.0.0 + vitest: 3.0.5(@types/node@22.13.0)(@vitest/browser@3.0.5)(@vitest/ui@3.0.5) + ws: 8.18.0 + transitivePeerDependencies: + - '@types/node' + - bufferutil + - typescript + - utf-8-validate + - vite + dev: true - '@vitest/coverage-istanbul@3.0.5': + /@vitest/coverage-istanbul@3.0.5(vitest@3.0.5): resolution: {integrity: sha512-yTcIwrpLHOyPP28PXXLRv1NzzKCrqDnmT7oVypTa1Q24P6OwGT4Wi6dXNEaJg33vmrPpoe81f31kwB5MtfM+ow==} peerDependencies: vitest: 3.0.5 + dependencies: + '@istanbuljs/schema': 0.1.3 + debug: 4.4.0 + istanbul-lib-coverage: 3.2.2 + istanbul-lib-instrument: 6.0.3 + istanbul-lib-report: 3.0.1 + istanbul-lib-source-maps: 5.0.6 + istanbul-reports: 3.1.7 + magicast: 0.3.5 + test-exclude: 7.0.1 + tinyrainbow: 2.0.0 + vitest: 3.0.5(@types/node@22.13.0)(@vitest/browser@3.0.5)(@vitest/ui@3.0.5) + transitivePeerDependencies: + - supports-color + dev: true + + /@vitest/expect@3.0.5: + resolution: {integrity: sha512-nNIOqupgZ4v5jWuQx2DSlHLEs7Q4Oh/7AYwNyE+k0UQzG7tSmjPXShUikn1mpNGzYEN2jJbTvLejwShMitovBA==} + dependencies: + '@vitest/spy': 3.0.5 + '@vitest/utils': 3.0.5 + chai: 5.1.2 + tinyrainbow: 2.0.0 + dev: true - '@vitest/expect@3.0.5': - resolution: {integrity: sha512-nNIOqupgZ4v5jWuQx2DSlHLEs7Q4Oh/7AYwNyE+k0UQzG7tSmjPXShUikn1mpNGzYEN2jJbTvLejwShMitovBA==} - - '@vitest/mocker@3.0.5': + /@vitest/mocker@3.0.5(msw@2.7.0)(vite@6.0.11): resolution: {integrity: sha512-CLPNBFBIE7x6aEGbIjaQAX03ZZlBMaWwAjBdMkIf/cAn6xzLTiM3zYqO/WAbieEjsAZir6tO71mzeHZoodThvw==} peerDependencies: msw: ^2.4.9 @@ -556,192 +975,382 @@ packages: optional: true vite: optional: true + dependencies: + '@vitest/spy': 3.0.5 + estree-walker: 3.0.3 + magic-string: 0.30.17 + msw: 2.7.0(@types/node@22.13.0)(typescript@5.7.3) + vite: 6.0.11(@types/node@22.13.0) + dev: true - '@vitest/pretty-format@3.0.5': + /@vitest/pretty-format@3.0.5: resolution: {integrity: sha512-CjUtdmpOcm4RVtB+up8r2vVDLR16Mgm/bYdkGFe3Yj/scRfCpbSi2W/BDSDcFK7ohw8UXvjMbOp9H4fByd/cOA==} + dependencies: + tinyrainbow: 2.0.0 + dev: true - '@vitest/runner@3.0.5': + /@vitest/runner@3.0.5: resolution: {integrity: sha512-BAiZFityFexZQi2yN4OX3OkJC6scwRo8EhRB0Z5HIGGgd2q+Nq29LgHU/+ovCtd0fOfXj5ZI6pwdlUmC5bpi8A==} + dependencies: + '@vitest/utils': 3.0.5 + pathe: 2.0.2 + dev: true - '@vitest/snapshot@3.0.5': + /@vitest/snapshot@3.0.5: resolution: {integrity: sha512-GJPZYcd7v8QNUJ7vRvLDmRwl+a1fGg4T/54lZXe+UOGy47F9yUfE18hRCtXL5aHN/AONu29NGzIXSVFh9K0feA==} + dependencies: + '@vitest/pretty-format': 3.0.5 + magic-string: 0.30.17 + pathe: 2.0.2 + dev: true - '@vitest/spy@3.0.5': + /@vitest/spy@3.0.5: resolution: {integrity: sha512-5fOzHj0WbUNqPK6blI/8VzZdkBlQLnT25knX0r4dbZI9qoZDf3qAdjoMmDcLG5A83W6oUUFJgUd0EYBc2P5xqg==} + dependencies: + tinyspy: 3.0.2 + dev: true - '@vitest/ui@3.0.5': + /@vitest/ui@3.0.5(vitest@3.0.5): resolution: {integrity: sha512-gw2noso6WI+2PeMVCZFntdATS6xl9qhQcbhkPQ9sOmx/Xn0f4Bx4KDSbD90jpJPF0l5wOzSoGCmKyVR3W612mg==} peerDependencies: vitest: 3.0.5 + dependencies: + '@vitest/utils': 3.0.5 + fflate: 0.8.2 + flatted: 3.3.2 + pathe: 2.0.2 + sirv: 3.0.0 + tinyglobby: 0.2.10 + tinyrainbow: 2.0.0 + vitest: 3.0.5(@types/node@22.13.0)(@vitest/browser@3.0.5)(@vitest/ui@3.0.5) + dev: true - '@vitest/utils@3.0.5': + /@vitest/utils@3.0.5: resolution: {integrity: sha512-N9AX0NUoUtVwKwy21JtwzaqR5L5R5A99GAbrHfCCXK1lp593i/3AZAXhSP43wRQuxYsflrdzEfXZFo1reR1Nkg==} + dependencies: + '@vitest/pretty-format': 3.0.5 + loupe: 3.1.3 + tinyrainbow: 2.0.0 + dev: true - '@volar/language-core@2.4.11': + /@volar/language-core@2.4.11: resolution: {integrity: sha512-lN2C1+ByfW9/JRPpqScuZt/4OrUUse57GLI6TbLgTIqBVemdl1wNcZ1qYGEo2+Gw8coYLgCy7SuKqn6IrQcQgg==} + dependencies: + '@volar/source-map': 2.4.11 + dev: true - '@volar/source-map@2.4.11': + /@volar/source-map@2.4.11: resolution: {integrity: sha512-ZQpmafIGvaZMn/8iuvCFGrW3smeqkq/IIh9F1SdSx9aUl0J4Iurzd6/FhmjNO5g2ejF3rT45dKskgXWiofqlZQ==} + dev: true - '@volar/typescript@2.4.11': + /@volar/typescript@2.4.11: resolution: {integrity: sha512-2DT+Tdh88Spp5PyPbqhyoYavYCPDsqbHLFwcUI9K1NlY1YgUJvujGdrqUp0zWxnW7KWNTr3xSpMuv2WnaTKDAw==} + dependencies: + '@volar/language-core': 2.4.11 + path-browserify: 1.0.1 + vscode-uri: 3.0.8 + dev: true - '@vue/compiler-core@3.5.13': + /@vue/compiler-core@3.5.13: resolution: {integrity: sha512-oOdAkwqUfW1WqpwSYJce06wvt6HljgY3fGeM9NcVA1HaYOij3mZG9Rkysn0OHuyUAGMbEbARIpsG+LPVlBJ5/Q==} + dependencies: + '@babel/parser': 7.26.7 + '@vue/shared': 3.5.13 + entities: 4.5.0 + estree-walker: 2.0.2 + source-map-js: 1.2.1 + dev: true - '@vue/compiler-dom@3.5.13': + /@vue/compiler-dom@3.5.13: resolution: {integrity: sha512-ZOJ46sMOKUjO3e94wPdCzQ6P1Lx/vhp2RSvfaab88Ajexs0AHeV0uasYhi99WPaogmBlRHNRuly8xV75cNTMDA==} + dependencies: + '@vue/compiler-core': 3.5.13 + '@vue/shared': 3.5.13 + dev: true - '@vue/compiler-vue2@2.7.16': + /@vue/compiler-vue2@2.7.16: resolution: {integrity: sha512-qYC3Psj9S/mfu9uVi5WvNZIzq+xnXMhOwbTFKKDD7b1lhpnn71jXSFdTQ+WsIEk0ONCd7VV2IMm7ONl6tbQ86A==} + dependencies: + de-indent: 1.0.2 + he: 1.2.0 + dev: true - '@vue/language-core@2.2.0': + /@vue/language-core@2.2.0(typescript@5.7.3): resolution: {integrity: sha512-O1ZZFaaBGkKbsRfnVH1ifOK1/1BUkyK+3SQsfnh6PmMmD4qJcTU8godCeA96jjDRTL6zgnK7YzCHfaUlH2r0Mw==} peerDependencies: typescript: '*' peerDependenciesMeta: typescript: optional: true + dependencies: + '@volar/language-core': 2.4.11 + '@vue/compiler-dom': 3.5.13 + '@vue/compiler-vue2': 2.7.16 + '@vue/shared': 3.5.13 + alien-signals: 0.4.14 + minimatch: 9.0.5 + muggle-string: 0.4.1 + path-browserify: 1.0.1 + typescript: 5.7.3 + dev: true - '@vue/shared@3.5.13': + /@vue/shared@3.5.13: resolution: {integrity: sha512-/hnE/qP5ZoGpol0a5mDi45bOd7t3tjYJBjsgCsivow7D48cJeV5l05RD82lPqi7gRiphZM37rnhW1l6ZoCNNnQ==} + dev: true - acorn@8.14.0: + /acorn@8.14.0: resolution: {integrity: sha512-cl669nCJTZBsL97OF4kUQm5g5hC2uihk0NxY3WENAC0TYdILVkAyHymAntgxGkl7K+t0cXIrH5siy5S4XkFycA==} engines: {node: '>=0.4.0'} hasBin: true + dev: true - ajv-draft-04@1.0.0: + /ajv-draft-04@1.0.0(ajv@8.13.0): resolution: {integrity: sha512-mv00Te6nmYbRp5DCwclxtt7yV/joXJPGS7nM+97GdxvuttCOfgI3K4U25zboyeX0O+myI8ERluxQe5wljMmVIw==} peerDependencies: ajv: ^8.5.0 peerDependenciesMeta: ajv: optional: true + dependencies: + ajv: 8.13.0 + dev: true - ajv-formats@3.0.1: + /ajv-formats@3.0.1(ajv@8.13.0): resolution: {integrity: sha512-8iUql50EUR+uUcdRQ3HDqa6EVyo3docL8g5WJ3FNcWmu62IbkGUue/pEyLBW8VGKKucTPgqeks4fIU1DA4yowQ==} peerDependencies: ajv: ^8.0.0 peerDependenciesMeta: ajv: optional: true + dependencies: + ajv: 8.13.0 + dev: true - ajv@8.12.0: + /ajv@8.12.0: resolution: {integrity: sha512-sRu1kpcO9yLtYxBKvqfTeh9KzZEwO3STyX1HT+4CaDzC6HpTGYhIhPIzj9XuKU7KYDwnaeh5hcOwjy1QuJzBPA==} + dependencies: + fast-deep-equal: 3.1.3 + json-schema-traverse: 1.0.0 + require-from-string: 2.0.2 + uri-js: 4.4.1 + dev: true - ajv@8.13.0: + /ajv@8.13.0: resolution: {integrity: sha512-PRA911Blj99jR5RMeTunVbNXMF6Lp4vZXnk5GQjcnUWUTsrXtekg/pnmFFI2u/I36Y/2bITGS30GZCXei6uNkA==} + dependencies: + fast-deep-equal: 3.1.3 + json-schema-traverse: 1.0.0 + require-from-string: 2.0.2 + uri-js: 4.4.1 + dev: true - alien-signals@0.4.14: + /alien-signals@0.4.14: resolution: {integrity: sha512-itUAVzhczTmP2U5yX67xVpsbbOiquusbWVyA9N+sy6+r6YVbFkahXvNCeEPWEOMhwDYwbVbGHFkVL03N9I5g+Q==} + dev: true - ansi-escapes@4.3.2: + /ansi-escapes@4.3.2: resolution: {integrity: sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==} engines: {node: '>=8'} + dependencies: + type-fest: 0.21.3 + dev: true - ansi-regex@5.0.1: + /ansi-regex@5.0.1: resolution: {integrity: sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==} engines: {node: '>=8'} + dev: true - ansi-regex@6.1.0: + /ansi-regex@6.1.0: resolution: {integrity: sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA==} engines: {node: '>=12'} + dev: true - ansi-styles@4.3.0: + /ansi-styles@4.3.0: resolution: {integrity: sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==} engines: {node: '>=8'} + dependencies: + color-convert: 2.0.1 + dev: true - ansi-styles@5.2.0: + /ansi-styles@5.2.0: resolution: {integrity: sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==} engines: {node: '>=10'} + dev: true - ansi-styles@6.2.1: + /ansi-styles@6.2.1: resolution: {integrity: sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==} engines: {node: '>=12'} + dev: true + + /any-promise@1.3.0: + resolution: {integrity: sha512-7UvmKalWRt1wgjL1RrGxoSJW/0QZFIegpeGvZG9kjp8vrRu55XTHbwnqq2GpXm9uLbcuhxm3IqX9OB4MZR1b2A==} + dev: true - argparse@1.0.10: + /argparse@1.0.10: resolution: {integrity: sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==} + dependencies: + sprintf-js: 1.0.3 + dev: true - aria-query@5.3.0: + /aria-query@5.3.0: resolution: {integrity: sha512-b0P0sZPKtyu8HkeRAfCq0IfURZK+SuwMjY1UXGBU27wpAiTwQAIlq56IbIO+ytk/JjS1fMR14ee5WBBfKi5J6A==} + dependencies: + dequal: 2.0.3 + dev: true - assertion-error@2.0.1: + /assertion-error@2.0.1: resolution: {integrity: sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==} engines: {node: '>=12'} + dev: true - balanced-match@1.0.2: + /balanced-match@1.0.2: resolution: {integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==} + dev: true - brace-expansion@1.1.11: + /brace-expansion@1.1.11: resolution: {integrity: sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==} + dependencies: + balanced-match: 1.0.2 + concat-map: 0.0.1 + dev: true - brace-expansion@2.0.1: + /brace-expansion@2.0.1: resolution: {integrity: sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==} + dependencies: + balanced-match: 1.0.2 + dev: true - browserslist@4.24.4: + /browserslist@4.24.4: resolution: {integrity: sha512-KDi1Ny1gSePi1vm0q4oxSF8b4DR44GF4BbmS2YdhPLOEqd8pDviZOGH/GsmRwoWJ2+5Lr085X7naowMwKHDG1A==} engines: {node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7} hasBin: true + dependencies: + caniuse-lite: 1.0.30001697 + electron-to-chromium: 1.5.91 + node-releases: 2.0.19 + update-browserslist-db: 1.1.2(browserslist@4.24.4) + dev: true + + /bundle-require@5.1.0(esbuild@0.24.2): + resolution: {integrity: sha512-3WrrOuZiyaaZPWiEt4G3+IffISVC9HYlWueJEBWED4ZH4aIAC2PnkdnuRrR94M+w6yGWn4AglWtJtBI8YqvgoA==} + engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} + peerDependencies: + esbuild: '>=0.18' + dependencies: + esbuild: 0.24.2 + load-tsconfig: 0.2.5 + dev: true - cac@6.7.14: + /cac@6.7.14: resolution: {integrity: sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==} engines: {node: '>=8'} + dev: true - caniuse-lite@1.0.30001696: - resolution: {integrity: sha512-pDCPkvzfa39ehJtJ+OwGT/2yvT2SbjfHhiIW2LWOAcMQ7BzwxT/XuyUp4OTOd0XFWA6BKw0JalnBHgSi5DGJBQ==} + /caniuse-lite@1.0.30001697: + resolution: {integrity: sha512-GwNPlWJin8E+d7Gxq96jxM6w0w+VFeyyXRsjU58emtkYqnbwHqXm5uT2uCmO0RQE9htWknOP4xtBlLmM/gWxvQ==} + dev: true - chai@5.1.2: + /chai@5.1.2: resolution: {integrity: sha512-aGtmf24DW6MLHHG5gCx4zaI3uBq3KRtxeVs0DjFH6Z0rDNbsvTxFASFvdj79pxjxZ8/5u3PIiN3IwEIQkiiuPw==} engines: {node: '>=12'} + dependencies: + assertion-error: 2.0.1 + check-error: 2.1.1 + deep-eql: 5.0.2 + loupe: 3.1.3 + pathval: 2.0.0 + dev: true - chalk@4.1.2: + /chalk@4.1.2: resolution: {integrity: sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==} engines: {node: '>=10'} + dependencies: + ansi-styles: 4.3.0 + supports-color: 7.2.0 + dev: true - check-error@2.1.1: + /check-error@2.1.1: resolution: {integrity: sha512-OAlb+T7V4Op9OwdkjmguYRqncdlx5JiofwOAUkmTF+jNdHwzTaTs4sRAGpzLF3oOz5xAyDGrPgeIDFQmDOTiJw==} engines: {node: '>= 16'} + dev: true + + /chokidar@4.0.3: + resolution: {integrity: sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA==} + engines: {node: '>= 14.16.0'} + dependencies: + readdirp: 4.1.1 + dev: true - cli-width@4.1.0: + /cli-width@4.1.0: resolution: {integrity: sha512-ouuZd4/dm2Sw5Gmqy6bGyNNNe1qt9RpmxveLSO7KcgsTnU7RXfsw+/bukWGo1abgBiMAic068rclZsO4IWmmxQ==} engines: {node: '>= 12'} + dev: true - cliui@8.0.1: + /cliui@8.0.1: resolution: {integrity: sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==} engines: {node: '>=12'} + dependencies: + string-width: 4.2.3 + strip-ansi: 6.0.1 + wrap-ansi: 7.0.0 + dev: true - color-convert@2.0.1: + /color-convert@2.0.1: resolution: {integrity: sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==} engines: {node: '>=7.0.0'} + dependencies: + color-name: 1.1.4 + dev: true - color-name@1.1.4: + /color-name@1.1.4: resolution: {integrity: sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==} + dev: true + + /commander@4.1.1: + resolution: {integrity: sha512-NOKm8xhkzAjzFx8B2v5OAHT+u5pRQc2UCa2Vq9jYL/31o2wi9mxBA7LIFs3sV5VSC49z6pEhfbMULvShKj26WA==} + engines: {node: '>= 6'} + dev: true - compare-versions@6.1.1: + /compare-versions@6.1.1: resolution: {integrity: sha512-4hm4VPpIecmlg59CHXnRDnqGplJFrbLG4aFEl5vl6cK1u76ws3LLvX7ikFnTDl5vo39sjWD6AaDPYodJp/NNHg==} + dev: true - concat-map@0.0.1: + /concat-map@0.0.1: resolution: {integrity: sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==} + dev: true - confbox@0.1.8: + /confbox@0.1.8: resolution: {integrity: sha512-RMtmw0iFkeR4YV+fUOSucriAQNb9g8zFR52MWCtl+cCZOFRNL6zeB395vPzFhEjjn4fMxXudmELnl/KF/WrK6w==} + dev: true - convert-source-map@2.0.0: + /consola@3.4.0: + resolution: {integrity: sha512-EiPU8G6dQG0GFHNR8ljnZFki/8a+cQwEQ+7wpxdChl02Q8HXlwEZWD5lqAF8vC2sEC3Tehr8hy7vErz88LHyUA==} + engines: {node: ^14.18.0 || >=16.10.0} + dev: true + + /convert-source-map@2.0.0: resolution: {integrity: sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==} + dev: true - cookie@0.7.2: + /cookie@0.7.2: resolution: {integrity: sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==} engines: {node: '>= 0.6'} + dev: true - cross-spawn@7.0.6: + /cross-spawn@7.0.6: resolution: {integrity: sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==} engines: {node: '>= 8'} + dependencies: + path-key: 3.1.1 + shebang-command: 2.0.0 + which: 2.0.2 + dev: true - de-indent@1.0.2: + /de-indent@1.0.2: resolution: {integrity: sha512-e/1zu3xH5MQryN2zdVaF0OrdNLUbvWxzMbi+iNA6Bky7l1RoP8a2fIbRocyHclXt/arDrrR6lL3TqFD9pMQTsg==} + dev: true - debug@4.4.0: + /debug@4.4.0: resolution: {integrity: sha512-6WTZ/IxCY/T6BALoZHaE4ctp9xm+Z5kY/pzYaCHRFeyVhojxlrm+46y68HA6hr0TcwEssoxNiDEUJQjfPZ/RYA==} engines: {node: '>=6.0'} peerDependencies: @@ -749,553 +1358,1105 @@ packages: peerDependenciesMeta: supports-color: optional: true + dependencies: + ms: 2.1.3 + dev: true - deep-eql@5.0.2: + /deep-eql@5.0.2: resolution: {integrity: sha512-h5k/5U50IJJFpzfL6nO9jaaumfjO/f2NjK/oYB2Djzm4p9L+3T9qWpZqZ2hAbLPuuYq9wrU08WQyBTL5GbPk5Q==} engines: {node: '>=6'} + dev: true - dequal@2.0.3: + /dequal@2.0.3: resolution: {integrity: sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==} engines: {node: '>=6'} + dev: true - dom-accessibility-api@0.5.16: + /dom-accessibility-api@0.5.16: resolution: {integrity: sha512-X7BJ2yElsnOJ30pZF4uIIDfBEVgF4XEBxL9Bxhy6dnrm5hkzqmsWHGTiHqRiITNhMyFLyAiWndIJP7Z1NTteDg==} + dev: true - eastasianwidth@0.2.0: + /eastasianwidth@0.2.0: resolution: {integrity: sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==} + dev: true - electron-to-chromium@1.5.90: - resolution: {integrity: sha512-C3PN4aydfW91Natdyd449Kw+BzhLmof6tzy5W1pFC5SpQxVXT+oyiyOG9AgYYSN9OdA/ik3YkCrpwqI8ug5Tug==} + /electron-to-chromium@1.5.91: + resolution: {integrity: sha512-sNSHHyq048PFmZY4S90ax61q+gLCs0X0YmcOII9wG9S2XwbVr+h4VW2wWhnbp/Eys3cCwTxVF292W3qPaxIapQ==} + dev: true - emoji-regex@8.0.0: + /emoji-regex@8.0.0: resolution: {integrity: sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==} + dev: true - emoji-regex@9.2.2: + /emoji-regex@9.2.2: resolution: {integrity: sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==} + dev: true - entities@4.5.0: + /entities@4.5.0: resolution: {integrity: sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==} engines: {node: '>=0.12'} + dev: true - es-module-lexer@1.6.0: + /es-module-lexer@1.6.0: resolution: {integrity: sha512-qqnD1yMU6tk/jnaMosogGySTZP8YtUgAffA9nMN+E/rjxcfRQ6IEk7IiozUjgxKoFHBGjTLnrHB/YC45r/59EQ==} + dev: true - esbuild@0.24.2: + /esbuild@0.24.2: resolution: {integrity: sha512-+9egpBW8I3CD5XPe0n6BfT5fxLzxrlDzqydF3aviG+9ni1lDC/OvMHcxqEFV0+LANZG5R1bFMWfUrjVsdwxJvA==} engines: {node: '>=18'} hasBin: true + requiresBuild: true + optionalDependencies: + '@esbuild/aix-ppc64': 0.24.2 + '@esbuild/android-arm': 0.24.2 + '@esbuild/android-arm64': 0.24.2 + '@esbuild/android-x64': 0.24.2 + '@esbuild/darwin-arm64': 0.24.2 + '@esbuild/darwin-x64': 0.24.2 + '@esbuild/freebsd-arm64': 0.24.2 + '@esbuild/freebsd-x64': 0.24.2 + '@esbuild/linux-arm': 0.24.2 + '@esbuild/linux-arm64': 0.24.2 + '@esbuild/linux-ia32': 0.24.2 + '@esbuild/linux-loong64': 0.24.2 + '@esbuild/linux-mips64el': 0.24.2 + '@esbuild/linux-ppc64': 0.24.2 + '@esbuild/linux-riscv64': 0.24.2 + '@esbuild/linux-s390x': 0.24.2 + '@esbuild/linux-x64': 0.24.2 + '@esbuild/netbsd-arm64': 0.24.2 + '@esbuild/netbsd-x64': 0.24.2 + '@esbuild/openbsd-arm64': 0.24.2 + '@esbuild/openbsd-x64': 0.24.2 + '@esbuild/sunos-x64': 0.24.2 + '@esbuild/win32-arm64': 0.24.2 + '@esbuild/win32-ia32': 0.24.2 + '@esbuild/win32-x64': 0.24.2 + dev: true - escalade@3.2.0: + /escalade@3.2.0: resolution: {integrity: sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==} engines: {node: '>=6'} + dev: true - estree-walker@2.0.2: + /estree-walker@2.0.2: resolution: {integrity: sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==} + dev: true - estree-walker@3.0.3: + /estree-walker@3.0.3: resolution: {integrity: sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==} + dependencies: + '@types/estree': 1.0.6 + dev: true - expect-type@1.1.0: + /expect-type@1.1.0: resolution: {integrity: sha512-bFi65yM+xZgk+u/KRIpekdSYkTB5W1pEf0Lt8Q8Msh7b+eQ7LXVtIB1Bkm4fvclDEL1b2CZkMhv2mOeF8tMdkA==} engines: {node: '>=12.0.0'} + dev: true - fast-deep-equal@3.1.3: + /fast-deep-equal@3.1.3: resolution: {integrity: sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==} + dev: true - fdir@6.4.3: + /fdir@6.4.3(picomatch@4.0.2): resolution: {integrity: sha512-PMXmW2y1hDDfTSRc9gaXIuCCRpuoz3Kaz8cUelp3smouvfT632ozg2vrT6lJsHKKOF59YLbOGfAWGUcKEfRMQw==} peerDependencies: picomatch: ^3 || ^4 peerDependenciesMeta: picomatch: optional: true + dependencies: + picomatch: 4.0.2 + dev: true - fflate@0.8.2: + /fflate@0.8.2: resolution: {integrity: sha512-cPJU47OaAoCbg0pBvzsgpTPhmhqI5eJjh/JIu8tPj5q+T7iLvW/JAYUqmE7KOB4R1ZyEhzBaIQpQpardBF5z8A==} + dev: true - flatted@3.3.2: + /flatted@3.3.2: resolution: {integrity: sha512-AiwGJM8YcNOaobumgtng+6NHuOqC3A7MixFeDafM3X9cIUM+xUXoS5Vfgf+OihAYe20fxqNM9yPBXJzRtZ/4eA==} + dev: true - foreground-child@3.3.0: + /foreground-child@3.3.0: resolution: {integrity: sha512-Ld2g8rrAyMYFXBhEqMz8ZAHBi4J4uS1i/CxGMDnjyFWddMXLVcDp051DZfu+t7+ab7Wv6SMqpWmyFIj5UbfFvg==} engines: {node: '>=14'} + dependencies: + cross-spawn: 7.0.6 + signal-exit: 4.1.0 + dev: true - fs-extra@11.3.0: + /fs-extra@11.3.0: resolution: {integrity: sha512-Z4XaCL6dUDHfP/jT25jJKMmtxvuwbkrD1vNSMFlo9lNLY2c5FHYSQgHPRZUjAB26TpDEoW9HCOgplrdbaPV/ew==} engines: {node: '>=14.14'} + dependencies: + graceful-fs: 4.2.11 + jsonfile: 6.1.0 + universalify: 2.0.1 + dev: true - fsevents@2.3.2: + /fsevents@2.3.2: resolution: {integrity: sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==} engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0} os: [darwin] + requiresBuild: true + dev: true + optional: true - fsevents@2.3.3: + /fsevents@2.3.3: resolution: {integrity: sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==} engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0} os: [darwin] + requiresBuild: true + dev: true + optional: true - function-bind@1.1.2: + /function-bind@1.1.2: resolution: {integrity: sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==} + dev: true - gensync@1.0.0-beta.2: + /gensync@1.0.0-beta.2: resolution: {integrity: sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==} engines: {node: '>=6.9.0'} + dev: true - get-caller-file@2.0.5: + /get-caller-file@2.0.5: resolution: {integrity: sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==} engines: {node: 6.* || 8.* || >= 10.*} + dev: true - glob@10.4.5: + /glob@10.4.5: resolution: {integrity: sha512-7Bv8RF0k6xjo7d4A/PxYLbUCfb6c+Vpd2/mB2yRDlew7Jb5hEXiCD9ibfO7wpk8i4sevK6DFny9h7EYbM3/sHg==} hasBin: true + dependencies: + foreground-child: 3.3.0 + jackspeak: 3.4.3 + minimatch: 9.0.5 + minipass: 7.1.2 + package-json-from-dist: 1.0.1 + path-scurry: 1.11.1 + dev: true - globals@11.12.0: + /globals@11.12.0: resolution: {integrity: sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==} engines: {node: '>=4'} + dev: true - graceful-fs@4.2.11: + /graceful-fs@4.2.11: resolution: {integrity: sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==} + dev: true - graphql@16.10.0: + /graphql@16.10.0: resolution: {integrity: sha512-AjqGKbDGUFRKIRCP9tCKiIGHyriz2oHEbPIbEtcSLSs4YjReZOIPQQWek4+6hjw62H9QShXHyaGivGiYVLeYFQ==} engines: {node: ^12.22.0 || ^14.16.0 || ^16.0.0 || >=17.0.0} + dev: true - has-flag@4.0.0: + /has-flag@4.0.0: resolution: {integrity: sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==} engines: {node: '>=8'} + dev: true - hasown@2.0.2: + /hasown@2.0.2: resolution: {integrity: sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==} engines: {node: '>= 0.4'} + dependencies: + function-bind: 1.1.2 + dev: true - he@1.2.0: + /he@1.2.0: resolution: {integrity: sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==} hasBin: true + dev: true - headers-polyfill@4.0.3: + /headers-polyfill@4.0.3: resolution: {integrity: sha512-IScLbePpkvO846sIwOtOTDjutRMWdXdJmXdMvk6gCBHxFO8d+QKOQedyZSxFTTFYRSmlgSTDtXqqq4pcenBXLQ==} + dev: true - html-escaper@2.0.2: + /html-escaper@2.0.2: resolution: {integrity: sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==} + dev: true - import-lazy@4.0.0: + /import-lazy@4.0.0: resolution: {integrity: sha512-rKtvo6a868b5Hu3heneU+L4yEQ4jYKLtjpnPeUdK7h0yzXGmyBTypknlkCvHFBqfX9YlorEiMM6Dnq/5atfHkw==} engines: {node: '>=8'} + dev: true - is-core-module@2.16.1: + /is-core-module@2.16.1: resolution: {integrity: sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==} engines: {node: '>= 0.4'} + dependencies: + hasown: 2.0.2 + dev: true - is-fullwidth-code-point@3.0.0: + /is-fullwidth-code-point@3.0.0: resolution: {integrity: sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==} engines: {node: '>=8'} + dev: true - is-node-process@1.2.0: + /is-node-process@1.2.0: resolution: {integrity: sha512-Vg4o6/fqPxIjtxgUH5QLJhwZ7gW5diGCVlXpuUfELC62CuxM1iHcRe51f2W1FDy04Ai4KJkagKjx3XaqyfRKXw==} + dev: true - isexe@2.0.0: + /isexe@2.0.0: resolution: {integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==} + dev: true - istanbul-lib-coverage@3.2.2: + /istanbul-lib-coverage@3.2.2: resolution: {integrity: sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg==} engines: {node: '>=8'} + dev: true - istanbul-lib-instrument@6.0.3: + /istanbul-lib-instrument@6.0.3: resolution: {integrity: sha512-Vtgk7L/R2JHyyGW07spoFlB8/lpjiOLTjMdms6AFMraYt3BaJauod/NGrfnVG/y4Ix1JEuMRPDPEj2ua+zz1/Q==} engines: {node: '>=10'} + dependencies: + '@babel/core': 7.26.7 + '@babel/parser': 7.26.7 + '@istanbuljs/schema': 0.1.3 + istanbul-lib-coverage: 3.2.2 + semver: 7.7.1 + transitivePeerDependencies: + - supports-color + dev: true - istanbul-lib-report@3.0.1: + /istanbul-lib-report@3.0.1: resolution: {integrity: sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw==} engines: {node: '>=10'} + dependencies: + istanbul-lib-coverage: 3.2.2 + make-dir: 4.0.0 + supports-color: 7.2.0 + dev: true - istanbul-lib-source-maps@5.0.6: + /istanbul-lib-source-maps@5.0.6: resolution: {integrity: sha512-yg2d+Em4KizZC5niWhQaIomgf5WlL4vOOjZ5xGCmF8SnPE/mDWWXgvRExdcpCgh9lLRRa1/fSYp2ymmbJ1pI+A==} engines: {node: '>=10'} + dependencies: + '@jridgewell/trace-mapping': 0.3.25 + debug: 4.4.0 + istanbul-lib-coverage: 3.2.2 + transitivePeerDependencies: + - supports-color + dev: true - istanbul-reports@3.1.7: + /istanbul-reports@3.1.7: resolution: {integrity: sha512-BewmUXImeuRk2YY0PVbxgKAysvhRPUQE0h5QRM++nVWyubKGV0l8qQ5op8+B2DOmwSe63Jivj0BjkPQVf8fP5g==} engines: {node: '>=8'} + dependencies: + html-escaper: 2.0.2 + istanbul-lib-report: 3.0.1 + dev: true - jackspeak@3.4.3: + /jackspeak@3.4.3: resolution: {integrity: sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw==} + dependencies: + '@isaacs/cliui': 8.0.2 + optionalDependencies: + '@pkgjs/parseargs': 0.11.0 + dev: true - jju@1.4.0: + /jju@1.4.0: resolution: {integrity: sha512-8wb9Yw966OSxApiCt0K3yNJL8pnNeIv+OEq2YMidz4FKP6nonSRoOXc80iXY4JaN2FC11B9qsNmDsm+ZOfMROA==} + dev: true + + /joycon@3.1.1: + resolution: {integrity: sha512-34wB/Y7MW7bzjKRjUKTa46I2Z7eV62Rkhva+KkopW7Qvv/OSWBqvkSY7vusOPrNuZcUG3tApvdVgNB8POj3SPw==} + engines: {node: '>=10'} + dev: true - js-tokens@4.0.0: + /js-tokens@4.0.0: resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==} + dev: true - jsesc@3.1.0: + /jsesc@3.1.0: resolution: {integrity: sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==} engines: {node: '>=6'} hasBin: true + dev: true - json-schema-traverse@1.0.0: + /json-schema-traverse@1.0.0: resolution: {integrity: sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==} + dev: true - json5@2.2.3: + /json5@2.2.3: resolution: {integrity: sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==} engines: {node: '>=6'} hasBin: true + dev: true - jsonfile@6.1.0: + /jsonfile@6.1.0: resolution: {integrity: sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==} + dependencies: + universalify: 2.0.1 + optionalDependencies: + graceful-fs: 4.2.11 + dev: true - kolorist@1.8.0: + /kolorist@1.8.0: resolution: {integrity: sha512-Y+60/zizpJ3HRH8DCss+q95yr6145JXZo46OTpFvDZWLfRCE4qChOyk1b26nMaNpfHHgxagk9dXT5OP0Tfe+dQ==} + dev: true + + /lilconfig@3.1.3: + resolution: {integrity: sha512-/vlFKAoH5Cgt3Ie+JLhRbwOsCQePABiU3tJ1egGvyQ+33R/vcwM2Zl2QR/LzjsBeItPt3oSVXapn+m4nQDvpzw==} + engines: {node: '>=14'} + dev: true + + /lines-and-columns@1.2.4: + resolution: {integrity: sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==} + dev: true - local-pkg@0.5.1: + /load-tsconfig@0.2.5: + resolution: {integrity: sha512-IXO6OCs9yg8tMKzfPZ1YmheJbZCiEsnBdcB03l0OcfK9prKnJb96siuHCr5Fl37/yo9DnKU+TLpxzTUspw9shg==} + engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} + dev: true + + /local-pkg@0.5.1: resolution: {integrity: sha512-9rrA30MRRP3gBD3HTGnC6cDFpaE1kVDWxWgqWJUN0RvDNAo+Nz/9GxB+nHOH0ifbVFy0hSA1V6vFDvnx54lTEQ==} engines: {node: '>=14'} + dependencies: + mlly: 1.7.4 + pkg-types: 1.3.1 + dev: true - lodash@4.17.21: + /lodash.sortby@4.7.0: + resolution: {integrity: sha512-HDWXG8isMntAyRF5vZ7xKuEvOhT4AhlRt/3czTSjvGUxjYCBVRQY48ViDHyfYz9VIoBkW4TMGQNapx+l3RUwdA==} + dev: true + + /lodash@4.17.21: resolution: {integrity: sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==} + dev: true - loupe@3.1.3: + /loupe@3.1.3: resolution: {integrity: sha512-kkIp7XSkP78ZxJEsSxW3712C6teJVoeHHwgo9zJ380de7IYyJ2ISlxojcH2pC5OFLewESmnRi/+XCDIEEVyoug==} + dev: true - lru-cache@10.4.3: + /lru-cache@10.4.3: resolution: {integrity: sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==} + dev: true - lru-cache@5.1.1: + /lru-cache@5.1.1: resolution: {integrity: sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==} + dependencies: + yallist: 3.1.1 + dev: true - lru-cache@6.0.0: + /lru-cache@6.0.0: resolution: {integrity: sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==} engines: {node: '>=10'} + dependencies: + yallist: 4.0.0 + dev: true - lz-string@1.5.0: + /lz-string@1.5.0: resolution: {integrity: sha512-h5bgJWpxJNswbU7qCrV0tIKQCaS3blPDrqKWx+QxzuzL1zGUzij9XCWLrSLsJPu5t+eWA/ycetzYAO5IOMcWAQ==} hasBin: true + dev: true - magic-string@0.30.17: + /magic-string@0.30.17: resolution: {integrity: sha512-sNPKHvyjVf7gyjwS4xGTaW/mCnF8wnjtifKBEhxfZ7E/S8tQ0rssrwGNn6q8JH/ohItJfSQp9mBtQYuTlH5QnA==} + dependencies: + '@jridgewell/sourcemap-codec': 1.5.0 + dev: true - magicast@0.3.5: + /magicast@0.3.5: resolution: {integrity: sha512-L0WhttDl+2BOsybvEOLK7fW3UA0OQ0IQ2d6Zl2x/a6vVRs3bAY0ECOSHHeL5jD+SbOpOCUEi0y1DgHEn9Qn1AQ==} + dependencies: + '@babel/parser': 7.26.7 + '@babel/types': 7.26.7 + source-map-js: 1.2.1 + dev: true - make-dir@4.0.0: + /make-dir@4.0.0: resolution: {integrity: sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw==} engines: {node: '>=10'} + dependencies: + semver: 7.7.1 + dev: true - minimatch@3.0.8: + /minimatch@3.0.8: resolution: {integrity: sha512-6FsRAQsxQ61mw+qP1ZzbL9Bc78x2p5OqNgNpnoAFLTrX8n5Kxph0CsnhmKKNXTWjXqU5L0pGPR7hYk+XWZr60Q==} + dependencies: + brace-expansion: 1.1.11 + dev: true - minimatch@9.0.5: + /minimatch@9.0.5: resolution: {integrity: sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==} engines: {node: '>=16 || 14 >=14.17'} + dependencies: + brace-expansion: 2.0.1 + dev: true - minipass@7.1.2: + /minipass@7.1.2: resolution: {integrity: sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==} engines: {node: '>=16 || 14 >=14.17'} + dev: true - mlly@1.7.4: + /mlly@1.7.4: resolution: {integrity: sha512-qmdSIPC4bDJXgZTCR7XosJiNKySV7O215tsPtDN9iEO/7q/76b/ijtgRu/+epFXSJhijtTCCGp3DWS549P3xKw==} + dependencies: + acorn: 8.14.0 + pathe: 2.0.2 + pkg-types: 1.3.1 + ufo: 1.5.4 + dev: true - mrmime@2.0.0: + /mrmime@2.0.0: resolution: {integrity: sha512-eu38+hdgojoyq63s+yTpN4XMBdt5l8HhMhc4VKLO9KM5caLIBvUm4thi7fFaxyTmCKeNnXZ5pAlBwCUnhA09uw==} engines: {node: '>=10'} + dev: true - ms@2.1.3: + /ms@2.1.3: resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==} + dev: true - msw@2.7.0: + /msw@2.7.0(@types/node@22.13.0)(typescript@5.7.3): resolution: {integrity: sha512-BIodwZ19RWfCbYTxWTUfTXc+sg4OwjCAgxU1ZsgmggX/7S3LdUifsbUPJs61j0rWb19CZRGY5if77duhc0uXzw==} engines: {node: '>=18'} hasBin: true + requiresBuild: true peerDependencies: typescript: '>= 4.8.x' peerDependenciesMeta: typescript: optional: true + dependencies: + '@bundled-es-modules/cookie': 2.0.1 + '@bundled-es-modules/statuses': 1.0.1 + '@bundled-es-modules/tough-cookie': 0.1.6 + '@inquirer/confirm': 5.1.5(@types/node@22.13.0) + '@mswjs/interceptors': 0.37.6 + '@open-draft/deferred-promise': 2.2.0 + '@open-draft/until': 2.1.0 + '@types/cookie': 0.6.0 + '@types/statuses': 2.0.5 + graphql: 16.10.0 + headers-polyfill: 4.0.3 + is-node-process: 1.2.0 + outvariant: 1.4.3 + path-to-regexp: 6.3.0 + picocolors: 1.1.1 + strict-event-emitter: 0.5.1 + type-fest: 4.33.0 + typescript: 5.7.3 + yargs: 17.7.2 + transitivePeerDependencies: + - '@types/node' + dev: true + + /muggle-string@0.4.1: + resolution: {integrity: sha512-VNTrAak/KhO2i8dqqnqnAHOa3cYBwXEZe9h+D5h/1ZqFSTEFHdM65lR7RoIqq3tBBYavsOXV84NoHXZ0AkPyqQ==} + dev: true + + /mute-stream@2.0.0: + resolution: {integrity: sha512-WWdIxpyjEn+FhQJQQv9aQAYlHoNVdzIzUySNV1gHUPDSdZJ3yZn7pAAbQcV7B56Mvu881q9FZV+0Vx2xC44VWA==} + engines: {node: ^18.17.0 || >=20.5.0} + dev: true + + /mz@2.7.0: + resolution: {integrity: sha512-z81GNO7nnYMEhrGh9LeymoE4+Yr0Wn5McHIZMK5cfQCl+NDX08sCZgUc9/6MHni9IWuFLm1Z3HTCXu2z9fN62Q==} + dependencies: + any-promise: 1.3.0 + object-assign: 4.1.1 + thenify-all: 1.6.0 + dev: true + + /nanoid@3.3.8: + resolution: {integrity: sha512-WNLf5Sd8oZxOm+TzppcYk8gVOgP+l58xNy58D0nbUnOxOWRWvlcCV4kUF7ltmI6PsrLl/BgKEyS4mqsGChFN0w==} + engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1} + hasBin: true + dev: true + + /node-releases@2.0.19: + resolution: {integrity: sha512-xxOWJsBKtzAq7DY0J+DTzuz58K8e7sJbdgwkbMWQe8UYB6ekmsQ45q0M/tJDsGaZmbC+l7n57UV8Hl5tHxO9uw==} + dev: true + + /object-assign@4.1.1: + resolution: {integrity: sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==} + engines: {node: '>=0.10.0'} + dev: true - muggle-string@0.4.1: - resolution: {integrity: sha512-VNTrAak/KhO2i8dqqnqnAHOa3cYBwXEZe9h+D5h/1ZqFSTEFHdM65lR7RoIqq3tBBYavsOXV84NoHXZ0AkPyqQ==} - - mute-stream@2.0.0: - resolution: {integrity: sha512-WWdIxpyjEn+FhQJQQv9aQAYlHoNVdzIzUySNV1gHUPDSdZJ3yZn7pAAbQcV7B56Mvu881q9FZV+0Vx2xC44VWA==} - engines: {node: ^18.17.0 || >=20.5.0} - - nanoid@3.3.8: - resolution: {integrity: sha512-WNLf5Sd8oZxOm+TzppcYk8gVOgP+l58xNy58D0nbUnOxOWRWvlcCV4kUF7ltmI6PsrLl/BgKEyS4mqsGChFN0w==} - engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1} - hasBin: true - - node-releases@2.0.19: - resolution: {integrity: sha512-xxOWJsBKtzAq7DY0J+DTzuz58K8e7sJbdgwkbMWQe8UYB6ekmsQ45q0M/tJDsGaZmbC+l7n57UV8Hl5tHxO9uw==} - - outvariant@1.4.3: + /outvariant@1.4.3: resolution: {integrity: sha512-+Sl2UErvtsoajRDKCE5/dBz4DIvHXQQnAxtQTF04OJxY0+DyZXSo5P5Bb7XYWOh81syohlYL24hbDwxedPUJCA==} + dev: true - package-json-from-dist@1.0.1: + /package-json-from-dist@1.0.1: resolution: {integrity: sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==} + dev: true - path-browserify@1.0.1: + /path-browserify@1.0.1: resolution: {integrity: sha512-b7uo2UCUOYZcnF/3ID0lulOJi/bafxa1xPe7ZPsammBSpjSWQkjNxlt635YGS2MiR9GjvuXCtz2emr3jbsz98g==} + dev: true - path-key@3.1.1: + /path-key@3.1.1: resolution: {integrity: sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==} engines: {node: '>=8'} + dev: true - path-parse@1.0.7: + /path-parse@1.0.7: resolution: {integrity: sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==} + dev: true - path-scurry@1.11.1: + /path-scurry@1.11.1: resolution: {integrity: sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==} engines: {node: '>=16 || 14 >=14.18'} + dependencies: + lru-cache: 10.4.3 + minipass: 7.1.2 + dev: true - path-to-regexp@6.3.0: + /path-to-regexp@6.3.0: resolution: {integrity: sha512-Yhpw4T9C6hPpgPeA28us07OJeqZ5EzQTkbfwuhsUg0c237RomFoETJgmp2sa3F/41gfLE6G5cqcYwznmeEeOlQ==} + dev: true - pathe@2.0.2: + /pathe@2.0.2: resolution: {integrity: sha512-15Ztpk+nov8DR524R4BF7uEuzESgzUEAV4Ah7CUMNGXdE5ELuvxElxGXndBl32vMSsWa1jpNf22Z+Er3sKwq+w==} + dev: true - pathval@2.0.0: + /pathval@2.0.0: resolution: {integrity: sha512-vE7JKRyES09KiunauX7nd2Q9/L7lhok4smP9RZTDeD4MVs72Dp2qNFVz39Nz5a0FVEW0BJR6C0DYrq6unoziZA==} engines: {node: '>= 14.16'} + dev: true - picocolors@1.1.1: + /picocolors@1.1.1: resolution: {integrity: sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==} + dev: true - picomatch@4.0.2: + /picomatch@4.0.2: resolution: {integrity: sha512-M7BAV6Rlcy5u+m6oPhAPFgJTzAioX/6B0DxyvDlo9l8+T3nLKbrczg2WLUyzd45L8RqfUMyGPzekbMvX2Ldkwg==} engines: {node: '>=12'} + dev: true - pkg-types@1.3.1: + /pirates@4.0.6: + resolution: {integrity: sha512-saLsH7WeYYPiD25LDuLRRY/i+6HaPYr6G1OUlN39otzkSTxKnubR9RTxS3/Kk50s1g2JTgFwWQDQyplC5/SHZg==} + engines: {node: '>= 6'} + dev: true + + /pkg-types@1.3.1: resolution: {integrity: sha512-/Jm5M4RvtBFVkKWRu2BLUTNP8/M2a+UwuAX+ae4770q1qVGtfjG+WTCupoZixokjmHiry8uI+dlY8KXYV5HVVQ==} + dependencies: + confbox: 0.1.8 + mlly: 1.7.4 + pathe: 2.0.2 + dev: true - playwright-core@1.50.1: + /playwright-core@1.50.1: resolution: {integrity: sha512-ra9fsNWayuYumt+NiM069M6OkcRb1FZSK8bgi66AtpFoWkg2+y0bJSNmkFrWhMbEBbVKC/EruAHH3g0zmtwGmQ==} engines: {node: '>=18'} hasBin: true + dev: true - playwright@1.50.1: + /playwright@1.50.1: resolution: {integrity: sha512-G8rwsOQJ63XG6BbKj2w5rHeavFjy5zynBA9zsJMMtBoe/Uf757oG12NXz6e6OirF7RCrTVAKFXbLmn1RbL7Qaw==} engines: {node: '>=18'} hasBin: true + dependencies: + playwright-core: 1.50.1 + optionalDependencies: + fsevents: 2.3.2 + dev: true + + /postcss-load-config@6.0.1: + resolution: {integrity: sha512-oPtTM4oerL+UXmx+93ytZVN82RrlY/wPUV8IeDxFrzIjXOLF1pN+EmKPLbubvKHT2HC20xXsCAH2Z+CKV6Oz/g==} + engines: {node: '>= 18'} + peerDependencies: + jiti: '>=1.21.0' + postcss: '>=8.0.9' + tsx: ^4.8.1 + yaml: ^2.4.2 + peerDependenciesMeta: + jiti: + optional: true + postcss: + optional: true + tsx: + optional: true + yaml: + optional: true + dependencies: + lilconfig: 3.1.3 + dev: true - postcss@8.5.1: + /postcss@8.5.1: resolution: {integrity: sha512-6oz2beyjc5VMn/KV1pPw8fliQkhBXrVn1Z3TVyqZxU8kZpzEKhBdmCFqI6ZbmGtamQvQGuU1sgPTk8ZrXDD7jQ==} engines: {node: ^10 || ^12 || >=14} + dependencies: + nanoid: 3.3.8 + picocolors: 1.1.1 + source-map-js: 1.2.1 + dev: true - pretty-format@27.5.1: + /pretty-format@27.5.1: resolution: {integrity: sha512-Qb1gy5OrP5+zDf2Bvnzdl3jsTf1qXVMazbvCoKhtKqVs4/YK4ozX4gKQJJVyNe+cajNPn0KoC0MC3FUmaHWEmQ==} engines: {node: ^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0} + dependencies: + ansi-regex: 5.0.1 + ansi-styles: 5.2.0 + react-is: 17.0.2 + dev: true - psl@1.15.0: + /psl@1.15.0: resolution: {integrity: sha512-JZd3gMVBAVQkSs6HdNZo9Sdo0LNcQeMNP3CozBJb3JYC/QUYZTnKxP+f8oWRX4rHP5EurWxqAHTSwUCjlNKa1w==} + dependencies: + punycode: 2.3.1 + dev: true - punycode@2.3.1: + /punycode@2.3.1: resolution: {integrity: sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==} engines: {node: '>=6'} + dev: true - querystringify@2.2.0: + /querystringify@2.2.0: resolution: {integrity: sha512-FIqgj2EUvTa7R50u0rGsyTftzjYmv/a3hO345bZNrqabNqjtgiDMgmo4mkUjd+nzU5oF3dClKqFIPUKybUyqoQ==} + dev: true - react-is@17.0.2: + /react-is@17.0.2: resolution: {integrity: sha512-w2GsyukL62IJnlaff/nRegPQR94C/XXamvMWmSHRJ4y7Ts/4ocGRmTHvOs8PSE6pB3dWOrD/nueuU5sduBsQ4w==} + dev: true + + /readdirp@4.1.1: + resolution: {integrity: sha512-h80JrZu/MHUZCyHu5ciuoI0+WxsCxzxJTILn6Fs8rxSnFPh+UVHYfeIxK1nVGugMqkfC4vJcBOYbkfkwYK0+gw==} + engines: {node: '>= 14.18.0'} + dev: true - regenerator-runtime@0.14.1: + /regenerator-runtime@0.14.1: resolution: {integrity: sha512-dYnhHh0nJoMfnkZs6GmmhFknAGRrLznOu5nc9ML+EJxGvrx6H7teuevqVqCuPcPK//3eDrrjQhehXVx9cnkGdw==} + dev: true - require-directory@2.1.1: + /require-directory@2.1.1: resolution: {integrity: sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==} engines: {node: '>=0.10.0'} + dev: true - require-from-string@2.0.2: + /require-from-string@2.0.2: resolution: {integrity: sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==} engines: {node: '>=0.10.0'} + dev: true - requires-port@1.0.0: + /requires-port@1.0.0: resolution: {integrity: sha512-KigOCHcocU3XODJxsu8i/j8T9tzT4adHiecwORRQ0ZZFcp7ahwXuRU1m+yuO90C5ZUyGeGfocHDI14M3L3yDAQ==} + dev: true + + /resolve-from@5.0.0: + resolution: {integrity: sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==} + engines: {node: '>=8'} + dev: true - resolve@1.22.10: + /resolve@1.22.10: resolution: {integrity: sha512-NPRy+/ncIMeDlTAsuqwKIiferiawhefFJtkNSW0qZJEqMEb+qBt/77B/jGeeek+F0uOeN05CDa6HXbbIgtVX4w==} engines: {node: '>= 0.4'} hasBin: true + dependencies: + is-core-module: 2.16.1 + path-parse: 1.0.7 + supports-preserve-symlinks-flag: 1.0.0 + dev: true - rollup@4.34.1: - resolution: {integrity: sha512-iYZ/+PcdLYSGfH3S+dGahlW/RWmsqDhLgj1BT9DH/xXJ0ggZN7xkdP9wipPNjjNLczI+fmMLmTB9pye+d2r4GQ==} + /rollup@4.34.2: + resolution: {integrity: sha512-sBDUoxZEaqLu9QeNalL8v3jw6WjPku4wfZGyTU7l7m1oC+rpRihXc/n/H+4148ZkGz5Xli8CHMns//fFGKvpIQ==} engines: {node: '>=18.0.0', npm: '>=8.0.0'} hasBin: true + dependencies: + '@types/estree': 1.0.6 + optionalDependencies: + '@rollup/rollup-android-arm-eabi': 4.34.2 + '@rollup/rollup-android-arm64': 4.34.2 + '@rollup/rollup-darwin-arm64': 4.34.2 + '@rollup/rollup-darwin-x64': 4.34.2 + '@rollup/rollup-freebsd-arm64': 4.34.2 + '@rollup/rollup-freebsd-x64': 4.34.2 + '@rollup/rollup-linux-arm-gnueabihf': 4.34.2 + '@rollup/rollup-linux-arm-musleabihf': 4.34.2 + '@rollup/rollup-linux-arm64-gnu': 4.34.2 + '@rollup/rollup-linux-arm64-musl': 4.34.2 + '@rollup/rollup-linux-loongarch64-gnu': 4.34.2 + '@rollup/rollup-linux-powerpc64le-gnu': 4.34.2 + '@rollup/rollup-linux-riscv64-gnu': 4.34.2 + '@rollup/rollup-linux-s390x-gnu': 4.34.2 + '@rollup/rollup-linux-x64-gnu': 4.34.2 + '@rollup/rollup-linux-x64-musl': 4.34.2 + '@rollup/rollup-win32-arm64-msvc': 4.34.2 + '@rollup/rollup-win32-ia32-msvc': 4.34.2 + '@rollup/rollup-win32-x64-msvc': 4.34.2 + fsevents: 2.3.3 + dev: true - semver@6.3.1: + /semver@6.3.1: resolution: {integrity: sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==} hasBin: true + dev: true - semver@7.5.4: + /semver@7.5.4: resolution: {integrity: sha512-1bCSESV6Pv+i21Hvpxp3Dx+pSD8lIPt8uVjRrxAUt/nbswYc+tK6Y2btiULjd4+fnq15PX+nqQDC7Oft7WkwcA==} engines: {node: '>=10'} hasBin: true + dependencies: + lru-cache: 6.0.0 + dev: true - semver@7.7.0: - resolution: {integrity: sha512-DrfFnPzblFmNrIZzg5RzHegbiRWg7KMR7btwi2yjHwx06zsUbO5g613sVwEV7FTwmzJu+Io0lJe2GJ3LxqpvBQ==} + /semver@7.7.1: + resolution: {integrity: sha512-hlq8tAfn0m/61p4BVRcPzIGr6LKiMwo4VM6dGi6pt4qcRkmNzTcWq6eCEjEh+qXjkMDvPlOFFSGwQjoEa6gyMA==} engines: {node: '>=10'} hasBin: true + dev: true - shebang-command@2.0.0: + /shebang-command@2.0.0: resolution: {integrity: sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==} engines: {node: '>=8'} + dependencies: + shebang-regex: 3.0.0 + dev: true - shebang-regex@3.0.0: + /shebang-regex@3.0.0: resolution: {integrity: sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==} engines: {node: '>=8'} + dev: true - siginfo@2.0.0: + /siginfo@2.0.0: resolution: {integrity: sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==} + dev: true - signal-exit@4.1.0: + /signal-exit@4.1.0: resolution: {integrity: sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==} engines: {node: '>=14'} + dev: true - sirv@3.0.0: + /sirv@3.0.0: resolution: {integrity: sha512-BPwJGUeDaDCHihkORDchNyyTvWFhcusy1XMmhEVTQTwGeybFbp8YEmB+njbPnth1FibULBSBVwCQni25XlCUDg==} engines: {node: '>=18'} + dependencies: + '@polka/url': 1.0.0-next.28 + mrmime: 2.0.0 + totalist: 3.0.1 + dev: true - source-map-js@1.2.1: + /source-map-js@1.2.1: resolution: {integrity: sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==} engines: {node: '>=0.10.0'} + dev: true - source-map@0.6.1: + /source-map@0.6.1: resolution: {integrity: sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==} engines: {node: '>=0.10.0'} + dev: true - sprintf-js@1.0.3: + /source-map@0.8.0-beta.0: + resolution: {integrity: sha512-2ymg6oRBpebeZi9UUNsgQ89bhx01TcTkmNTGnNO88imTmbSgy4nfujrgVEFKWpMTEGA11EDkTt7mqObTPdigIA==} + engines: {node: '>= 8'} + dependencies: + whatwg-url: 7.1.0 + dev: true + + /sprintf-js@1.0.3: resolution: {integrity: sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==} + dev: true - stackback@0.0.2: + /stackback@0.0.2: resolution: {integrity: sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==} + dev: true - statuses@2.0.1: + /statuses@2.0.1: resolution: {integrity: sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==} engines: {node: '>= 0.8'} + dev: true - std-env@3.8.0: + /std-env@3.8.0: resolution: {integrity: sha512-Bc3YwwCB+OzldMxOXJIIvC6cPRWr/LxOp48CdQTOkPyk/t4JWWJbrilwBd7RJzKV8QW7tJkcgAmeuLLJugl5/w==} + dev: true - strict-event-emitter@0.5.1: + /strict-event-emitter@0.5.1: resolution: {integrity: sha512-vMgjE/GGEPEFnhFub6pa4FmJBRBVOLpIII2hvCZ8Kzb7K0hlHo7mQv6xYrBvCL2LtAIBwFUK8wvuJgTVSQ5MFQ==} + dev: true - string-argv@0.3.2: + /string-argv@0.3.2: resolution: {integrity: sha512-aqD2Q0144Z+/RqG52NeHEkZauTAUWJO8c6yTftGJKO3Tja5tUgIfmIl6kExvhtxSDP7fXB6DvzkfMpCd/F3G+Q==} engines: {node: '>=0.6.19'} + dev: true - string-width@4.2.3: + /string-width@4.2.3: resolution: {integrity: sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==} engines: {node: '>=8'} + dependencies: + emoji-regex: 8.0.0 + is-fullwidth-code-point: 3.0.0 + strip-ansi: 6.0.1 + dev: true - string-width@5.1.2: + /string-width@5.1.2: resolution: {integrity: sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==} engines: {node: '>=12'} + dependencies: + eastasianwidth: 0.2.0 + emoji-regex: 9.2.2 + strip-ansi: 7.1.0 + dev: true - strip-ansi@6.0.1: + /strip-ansi@6.0.1: resolution: {integrity: sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==} engines: {node: '>=8'} + dependencies: + ansi-regex: 5.0.1 + dev: true - strip-ansi@7.1.0: + /strip-ansi@7.1.0: resolution: {integrity: sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==} engines: {node: '>=12'} + dependencies: + ansi-regex: 6.1.0 + dev: true - strip-json-comments@3.1.1: + /strip-json-comments@3.1.1: resolution: {integrity: sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==} engines: {node: '>=8'} + dev: true + + /sucrase@3.35.0: + resolution: {integrity: sha512-8EbVDiu9iN/nESwxeSxDKe0dunta1GOlHufmSSXxMD2z2/tMZpDMpvXQGsc+ajGo8y2uYUmixaSRUc/QPoQ0GA==} + engines: {node: '>=16 || 14 >=14.17'} + hasBin: true + dependencies: + '@jridgewell/gen-mapping': 0.3.8 + commander: 4.1.1 + glob: 10.4.5 + lines-and-columns: 1.2.4 + mz: 2.7.0 + pirates: 4.0.6 + ts-interface-checker: 0.1.13 + dev: true - supports-color@7.2.0: + /supports-color@7.2.0: resolution: {integrity: sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==} engines: {node: '>=8'} + dependencies: + has-flag: 4.0.0 + dev: true - supports-color@8.1.1: + /supports-color@8.1.1: resolution: {integrity: sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==} engines: {node: '>=10'} + dependencies: + has-flag: 4.0.0 + dev: true - supports-preserve-symlinks-flag@1.0.0: + /supports-preserve-symlinks-flag@1.0.0: resolution: {integrity: sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==} engines: {node: '>= 0.4'} + dev: true - test-exclude@7.0.1: + /test-exclude@7.0.1: resolution: {integrity: sha512-pFYqmTw68LXVjeWJMST4+borgQP2AyMNbg1BpZh9LbyhUeNkeaPF9gzfPGUAnSMV3qPYdWUwDIjjCLiSDOl7vg==} engines: {node: '>=18'} + dependencies: + '@istanbuljs/schema': 0.1.3 + glob: 10.4.5 + minimatch: 9.0.5 + dev: true + + /thenify-all@1.6.0: + resolution: {integrity: sha512-RNxQH/qI8/t3thXJDwcstUO4zeqo64+Uy/+sNVRBx4Xn2OX+OZ9oP+iJnNFqplFra2ZUVeKCSa2oVWi3T4uVmA==} + engines: {node: '>=0.8'} + dependencies: + thenify: 3.3.1 + dev: true + + /thenify@3.3.1: + resolution: {integrity: sha512-RVZSIV5IG10Hk3enotrhvz0T9em6cyHBLkH/YAZuKqd8hRkKhSfCGIcP2KUY0EPxndzANBmNllzWPwak+bheSw==} + dependencies: + any-promise: 1.3.0 + dev: true - tinybench@2.9.0: + /tinybench@2.9.0: resolution: {integrity: sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==} + dev: true - tinyexec@0.3.2: + /tinyexec@0.3.2: resolution: {integrity: sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA==} + dev: true - tinyglobby@0.2.10: + /tinyglobby@0.2.10: resolution: {integrity: sha512-Zc+8eJlFMvgatPZTl6A9L/yht8QqdmUNtURHaKZLmKBE12hNPSrqNkUp2cs3M/UKmNVVAMFQYSjYIVHDjW5zew==} engines: {node: '>=12.0.0'} + dependencies: + fdir: 6.4.3(picomatch@4.0.2) + picomatch: 4.0.2 + dev: true - tinypool@1.0.2: + /tinypool@1.0.2: resolution: {integrity: sha512-al6n+QEANGFOMf/dmUMsuS5/r9B06uwlyNjZZql/zv8J7ybHCgoihBNORZCY2mzUuAnomQa2JdhyHKzZxPCrFA==} engines: {node: ^18.0.0 || >=20.0.0} + dev: true - tinyrainbow@2.0.0: + /tinyrainbow@2.0.0: resolution: {integrity: sha512-op4nsTR47R6p0vMUUoYl/a+ljLFVtlfaXkLQmqfLR1qHma1h/ysYk4hEXZ880bf2CYgTskvTa/e196Vd5dDQXw==} engines: {node: '>=14.0.0'} + dev: true - tinyspy@3.0.2: + /tinyspy@3.0.2: resolution: {integrity: sha512-n1cw8k1k0x4pgA2+9XrOkFydTerNcJ1zWCO5Nn9scWHTD+5tp8dghT2x1uduQePZTZgd3Tupf+x9BxJjeJi77Q==} engines: {node: '>=14.0.0'} + dev: true - totalist@3.0.1: + /totalist@3.0.1: resolution: {integrity: sha512-sf4i37nQ2LBx4m3wB74y+ubopq6W/dIzXg0FDGjsYnZHVa1Da8FH853wlL2gtUhg+xJXjfk3kUZS3BRoQeoQBQ==} engines: {node: '>=6'} + dev: true - tough-cookie@4.1.4: + /tough-cookie@4.1.4: resolution: {integrity: sha512-Loo5UUvLD9ScZ6jh8beX1T6sO1w2/MpCRpEP7V280GKMVUQ0Jzar2U3UJPsrdbziLEMMhu3Ujnq//rhiFuIeag==} engines: {node: '>=6'} + dependencies: + psl: 1.15.0 + punycode: 2.3.1 + universalify: 0.2.0 + url-parse: 1.5.10 + dev: true + + /tr46@1.0.1: + resolution: {integrity: sha512-dTpowEjclQ7Kgx5SdBkqRzVhERQXov8/l9Ft9dVM9fmg0W0KQSVaXX9T4i6twCPNtYiZM53lpSSUAwJbFPOHxA==} + dependencies: + punycode: 2.3.1 + dev: true + + /tree-kill@1.2.2: + resolution: {integrity: sha512-L0Orpi8qGpRG//Nd+H90vFB+3iHnue1zSSGmNOOCh1GLJ7rUKVwV2HvijphGQS2UmhUZewS9VgvxYIdgr+fG1A==} + hasBin: true + dev: true + + /ts-interface-checker@0.1.13: + resolution: {integrity: sha512-Y/arvbn+rrz3JCKl9C4kVNfTfSm2/mEp5FSz5EsZSANGPSlQrpRI5M4PKF+mJnE52jOO90PnPSc3Ur3bTQw0gA==} + dev: true + + /tsup@8.3.6(typescript@5.7.3): + resolution: {integrity: sha512-XkVtlDV/58S9Ye0JxUUTcrQk4S+EqlOHKzg6Roa62rdjL1nGWNUstG0xgI4vanHdfIpjP448J8vlN0oK6XOJ5g==} + engines: {node: '>=18'} + hasBin: true + peerDependencies: + '@microsoft/api-extractor': ^7.36.0 + '@swc/core': ^1 + postcss: ^8.4.12 + typescript: '>=4.5.0' + peerDependenciesMeta: + '@microsoft/api-extractor': + optional: true + '@swc/core': + optional: true + postcss: + optional: true + typescript: + optional: true + dependencies: + bundle-require: 5.1.0(esbuild@0.24.2) + cac: 6.7.14 + chokidar: 4.0.3 + consola: 3.4.0 + debug: 4.4.0 + esbuild: 0.24.2 + joycon: 3.1.1 + picocolors: 1.1.1 + postcss-load-config: 6.0.1 + resolve-from: 5.0.0 + rollup: 4.34.2 + source-map: 0.8.0-beta.0 + sucrase: 3.35.0 + tinyexec: 0.3.2 + tinyglobby: 0.2.10 + tree-kill: 1.2.2 + typescript: 5.7.3 + transitivePeerDependencies: + - jiti + - supports-color + - tsx + - yaml + dev: true - type-fest@0.21.3: + /type-fest@0.21.3: resolution: {integrity: sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==} engines: {node: '>=10'} + dev: true - type-fest@4.33.0: + /type-fest@4.33.0: resolution: {integrity: sha512-s6zVrxuyKbbAsSAD5ZPTB77q4YIdRctkTbJ2/Dqlinwz+8ooH2gd+YA7VA6Pa93KML9GockVvoxjZ2vHP+mu8g==} engines: {node: '>=16'} + dev: true - typescript@5.7.2: + /typescript@5.7.2: resolution: {integrity: sha512-i5t66RHxDvVN40HfDd1PsEThGNnlMCMT3jMUuoh9/0TaqWevNontacunWyN02LA9/fIbEWlcHZcgTKb9QoaLfg==} engines: {node: '>=14.17'} hasBin: true + dev: true - typescript@5.7.3: + /typescript@5.7.3: resolution: {integrity: sha512-84MVSjMEHP+FQRPy3pX9sTVV/INIex71s9TL2Gm5FG/WG1SqXeKyZ0k7/blY/4FdOzI12CBy1vGc4og/eus0fw==} engines: {node: '>=14.17'} hasBin: true + dev: true - ufo@1.5.4: + /ufo@1.5.4: resolution: {integrity: sha512-UsUk3byDzKd04EyoZ7U4DOlxQaD14JUKQl6/P7wiX4FNvUfm3XL246n9W5AmqwW5RSFJ27NAuM0iLscAOYUiGQ==} + dev: true - undici-types@6.20.0: + /undici-types@6.20.0: resolution: {integrity: sha512-Ny6QZ2Nju20vw1SRHe3d9jVu6gJ+4e3+MMpqu7pqE5HT6WsTSlce++GQmK5UXS8mzV8DSYHrQH+Xrf2jVcuKNg==} + dev: true - universalify@0.2.0: + /universalify@0.2.0: resolution: {integrity: sha512-CJ1QgKmNg3CwvAv/kOFmtnEN05f0D/cn9QntgNOQlQF9dgvVTHj3t+8JPdjqawCHk7V/KA+fbUqzZ9XWhcqPUg==} engines: {node: '>= 4.0.0'} + dev: true - universalify@2.0.1: + /universalify@2.0.1: resolution: {integrity: sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==} engines: {node: '>= 10.0.0'} + dev: true - update-browserslist-db@1.1.2: + /update-browserslist-db@1.1.2(browserslist@4.24.4): resolution: {integrity: sha512-PPypAm5qvlD7XMZC3BujecnaOxwhrtoFR+Dqkk5Aa/6DssiH0ibKoketaj9w8LP7Bont1rYeoV5plxD7RTEPRg==} hasBin: true peerDependencies: browserslist: '>= 4.21.0' + dependencies: + browserslist: 4.24.4 + escalade: 3.2.0 + picocolors: 1.1.1 + dev: true - uri-js@4.4.1: + /uri-js@4.4.1: resolution: {integrity: sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==} + dependencies: + punycode: 2.3.1 + dev: true - url-parse@1.5.10: + /url-parse@1.5.10: resolution: {integrity: sha512-WypcfiRhfeUP9vvF0j6rw0J3hrWrw6iZv3+22h6iRMJ/8z1Tj6XfLP4DsUix5MhMPnXpiHDoKyoZ/bdCkwBCiQ==} + dependencies: + querystringify: 2.2.0 + requires-port: 1.0.0 + dev: true - vite-node@3.0.5: + /vite-node@3.0.5(@types/node@22.13.0): resolution: {integrity: sha512-02JEJl7SbtwSDJdYS537nU6l+ktdvcREfLksk/NDAqtdKWGqHl+joXzEubHROmS3E6pip+Xgu2tFezMu75jH7A==} engines: {node: ^18.0.0 || ^20.0.0 || >=22.0.0} hasBin: true + dependencies: + cac: 6.7.14 + debug: 4.4.0 + es-module-lexer: 1.6.0 + pathe: 2.0.2 + vite: 6.0.11(@types/node@22.13.0) + transitivePeerDependencies: + - '@types/node' + - jiti + - less + - lightningcss + - sass + - sass-embedded + - stylus + - sugarss + - supports-color + - terser + - tsx + - yaml + dev: true - vite-plugin-dts@4.5.0: + /vite-plugin-dts@4.5.0(@types/node@22.13.0)(typescript@5.7.3)(vite@6.0.11): resolution: {integrity: sha512-M1lrPTdi7gilLYRZoLmGYnl4fbPryVYsehPN9JgaxjJKTs8/f7tuAlvCCvOLB5gRDQTTKnptBcB0ACsaw2wNLw==} peerDependencies: typescript: '*' @@ -1303,8 +2464,25 @@ packages: peerDependenciesMeta: vite: optional: true + dependencies: + '@microsoft/api-extractor': 7.49.2(@types/node@22.13.0) + '@rollup/pluginutils': 5.1.4 + '@volar/typescript': 2.4.11 + '@vue/language-core': 2.2.0(typescript@5.7.3) + compare-versions: 6.1.1 + debug: 4.4.0 + kolorist: 1.8.0 + local-pkg: 0.5.1 + magic-string: 0.30.17 + typescript: 5.7.3 + vite: 6.0.11(@types/node@22.13.0) + transitivePeerDependencies: + - '@types/node' + - rollup + - supports-color + dev: true - vite@6.0.11: + /vite@6.0.11(@types/node@22.13.0): resolution: {integrity: sha512-4VL9mQPKoHy4+FE0NnRE/kbY51TOfaknxAjt3fJbGJxhIpBZiqVzlZDEesWWsuREXHwNdAoOFZ9MkPEVXczHwg==} engines: {node: ^18.0.0 || ^20.0.0 || >=22.0.0} hasBin: true @@ -1343,8 +2521,16 @@ packages: optional: true yaml: optional: true + dependencies: + '@types/node': 22.13.0 + esbuild: 0.24.2 + postcss: 8.5.1 + rollup: 4.34.2 + optionalDependencies: + fsevents: 2.3.3 + dev: true - vitest@3.0.5: + /vitest@3.0.5(@types/node@22.13.0)(@vitest/browser@3.0.5)(@vitest/ui@3.0.5): resolution: {integrity: sha512-4dof+HvqONw9bvsYxtkfUp2uHsTN9bV2CZIi1pWgoFpL1Lld8LA1ka9q/ONSsoScAKG7NVGf2stJTI7XRkXb2Q==} engines: {node: ^18.0.0 || ^20.0.0 || >=22.0.0} hasBin: true @@ -1371,33 +2557,106 @@ packages: optional: true jsdom: optional: true + dependencies: + '@types/node': 22.13.0 + '@vitest/browser': 3.0.5(@types/node@22.13.0)(playwright@1.50.1)(typescript@5.7.3)(vite@6.0.11)(vitest@3.0.5) + '@vitest/expect': 3.0.5 + '@vitest/mocker': 3.0.5(msw@2.7.0)(vite@6.0.11) + '@vitest/pretty-format': 3.0.5 + '@vitest/runner': 3.0.5 + '@vitest/snapshot': 3.0.5 + '@vitest/spy': 3.0.5 + '@vitest/ui': 3.0.5(vitest@3.0.5) + '@vitest/utils': 3.0.5 + chai: 5.1.2 + debug: 4.4.0 + expect-type: 1.1.0 + magic-string: 0.30.17 + pathe: 2.0.2 + std-env: 3.8.0 + tinybench: 2.9.0 + tinyexec: 0.3.2 + tinypool: 1.0.2 + tinyrainbow: 2.0.0 + vite: 6.0.11(@types/node@22.13.0) + vite-node: 3.0.5(@types/node@22.13.0) + why-is-node-running: 2.3.0 + transitivePeerDependencies: + - jiti + - less + - lightningcss + - msw + - sass + - sass-embedded + - stylus + - sugarss + - supports-color + - terser + - tsx + - yaml + dev: true - vscode-uri@3.0.8: + /vscode-uri@3.0.8: resolution: {integrity: sha512-AyFQ0EVmsOZOlAnxoFOGOq1SQDWAB7C6aqMGS23svWAllfOaxbuFvcT8D1i8z3Gyn8fraVeZNNmN6e9bxxXkKw==} + dev: true + + /webidl-conversions@4.0.2: + resolution: {integrity: sha512-YQ+BmxuTgd6UXZW3+ICGfyqRyHXVlD5GtQr5+qjiNW7bF0cqrzX500HVXPBOvgXb5YnzDd+h0zqyv61KUD7+Sg==} + dev: true + + /whatwg-url@7.1.0: + resolution: {integrity: sha512-WUu7Rg1DroM7oQvGWfOiAK21n74Gg+T4elXEQYkOhtyLeWiJFoOGLXPKI/9gzIie9CtwVLm8wtw6YJdKyxSjeg==} + dependencies: + lodash.sortby: 4.7.0 + tr46: 1.0.1 + webidl-conversions: 4.0.2 + dev: true - which@2.0.2: + /which@2.0.2: resolution: {integrity: sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==} engines: {node: '>= 8'} hasBin: true + dependencies: + isexe: 2.0.0 + dev: true - why-is-node-running@2.3.0: + /why-is-node-running@2.3.0: resolution: {integrity: sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==} engines: {node: '>=8'} hasBin: true + dependencies: + siginfo: 2.0.0 + stackback: 0.0.2 + dev: true - wrap-ansi@6.2.0: + /wrap-ansi@6.2.0: resolution: {integrity: sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA==} engines: {node: '>=8'} - - wrap-ansi@7.0.0: - resolution: {integrity: sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==} + dependencies: + ansi-styles: 4.3.0 + string-width: 4.2.3 + strip-ansi: 6.0.1 + dev: true + + /wrap-ansi@7.0.0: + resolution: {integrity: sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==} engines: {node: '>=10'} + dependencies: + ansi-styles: 4.3.0 + string-width: 4.2.3 + strip-ansi: 6.0.1 + dev: true - wrap-ansi@8.1.0: + /wrap-ansi@8.1.0: resolution: {integrity: sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==} engines: {node: '>=12'} + dependencies: + ansi-styles: 6.2.1 + string-width: 5.1.2 + strip-ansi: 7.1.0 + dev: true - ws@8.18.0: + /ws@8.18.0: resolution: {integrity: sha512-8VbfWfHLbbwu3+N6OKsOMpBdT4kXPDDB9cJk2bJ6mh9ucxdlnNvH1e+roYkKmN9Nxw2yjz7VzeO9oOz2zJ04Pw==} engines: {node: '>=10.0.0'} peerDependencies: @@ -1408,1370 +2667,40 @@ packages: optional: true utf-8-validate: optional: true + dev: true - y18n@5.0.8: + /y18n@5.0.8: resolution: {integrity: sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==} engines: {node: '>=10'} + dev: true - yallist@3.1.1: + /yallist@3.1.1: resolution: {integrity: sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==} + dev: true - yallist@4.0.0: + /yallist@4.0.0: resolution: {integrity: sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==} + dev: true - yargs-parser@21.1.1: + /yargs-parser@21.1.1: resolution: {integrity: sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==} engines: {node: '>=12'} + dev: true - yargs@17.7.2: + /yargs@17.7.2: resolution: {integrity: sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==} engines: {node: '>=12'} + dependencies: + cliui: 8.0.1 + escalade: 3.2.0 + get-caller-file: 2.0.5 + require-directory: 2.1.1 + string-width: 4.2.3 + y18n: 5.0.8 + yargs-parser: 21.1.1 + dev: true - yoctocolors-cjs@2.1.2: + /yoctocolors-cjs@2.1.2: resolution: {integrity: sha512-cYVsTjKl8b+FrnidjibDWskAv7UKOfcwaVZdp/it9n1s9fU3IkgDbhdIRKCW4JDsAlECJY0ytoVPT3sK6kideA==} engines: {node: '>=18'} - -snapshots: - - '@ampproject/remapping@2.3.0': - dependencies: - '@jridgewell/gen-mapping': 0.3.8 - '@jridgewell/trace-mapping': 0.3.25 - - '@babel/code-frame@7.26.2': - dependencies: - '@babel/helper-validator-identifier': 7.25.9 - js-tokens: 4.0.0 - picocolors: 1.1.1 - - '@babel/compat-data@7.26.5': {} - - '@babel/core@7.26.7': - dependencies: - '@ampproject/remapping': 2.3.0 - '@babel/code-frame': 7.26.2 - '@babel/generator': 7.26.5 - '@babel/helper-compilation-targets': 7.26.5 - '@babel/helper-module-transforms': 7.26.0(@babel/core@7.26.7) - '@babel/helpers': 7.26.7 - '@babel/parser': 7.26.7 - '@babel/template': 7.25.9 - '@babel/traverse': 7.26.7 - '@babel/types': 7.26.7 - convert-source-map: 2.0.0 - debug: 4.4.0 - gensync: 1.0.0-beta.2 - json5: 2.2.3 - semver: 6.3.1 - transitivePeerDependencies: - - supports-color - - '@babel/generator@7.26.5': - dependencies: - '@babel/parser': 7.26.7 - '@babel/types': 7.26.7 - '@jridgewell/gen-mapping': 0.3.8 - '@jridgewell/trace-mapping': 0.3.25 - jsesc: 3.1.0 - - '@babel/helper-compilation-targets@7.26.5': - dependencies: - '@babel/compat-data': 7.26.5 - '@babel/helper-validator-option': 7.25.9 - browserslist: 4.24.4 - lru-cache: 5.1.1 - semver: 6.3.1 - - '@babel/helper-module-imports@7.25.9': - dependencies: - '@babel/traverse': 7.26.7 - '@babel/types': 7.26.7 - transitivePeerDependencies: - - supports-color - - '@babel/helper-module-transforms@7.26.0(@babel/core@7.26.7)': - dependencies: - '@babel/core': 7.26.7 - '@babel/helper-module-imports': 7.25.9 - '@babel/helper-validator-identifier': 7.25.9 - '@babel/traverse': 7.26.7 - transitivePeerDependencies: - - supports-color - - '@babel/helper-string-parser@7.25.9': {} - - '@babel/helper-validator-identifier@7.25.9': {} - - '@babel/helper-validator-option@7.25.9': {} - - '@babel/helpers@7.26.7': - dependencies: - '@babel/template': 7.25.9 - '@babel/types': 7.26.7 - - '@babel/parser@7.26.7': - dependencies: - '@babel/types': 7.26.7 - - '@babel/runtime@7.26.7': - dependencies: - regenerator-runtime: 0.14.1 - - '@babel/template@7.25.9': - dependencies: - '@babel/code-frame': 7.26.2 - '@babel/parser': 7.26.7 - '@babel/types': 7.26.7 - - '@babel/traverse@7.26.7': - dependencies: - '@babel/code-frame': 7.26.2 - '@babel/generator': 7.26.5 - '@babel/parser': 7.26.7 - '@babel/template': 7.25.9 - '@babel/types': 7.26.7 - debug: 4.4.0 - globals: 11.12.0 - transitivePeerDependencies: - - supports-color - - '@babel/types@7.26.7': - dependencies: - '@babel/helper-string-parser': 7.25.9 - '@babel/helper-validator-identifier': 7.25.9 - - '@bundled-es-modules/cookie@2.0.1': - dependencies: - cookie: 0.7.2 - - '@bundled-es-modules/statuses@1.0.1': - dependencies: - statuses: 2.0.1 - - '@bundled-es-modules/tough-cookie@0.1.6': - dependencies: - '@types/tough-cookie': 4.0.5 - tough-cookie: 4.1.4 - - '@esbuild/aix-ppc64@0.24.2': - optional: true - - '@esbuild/android-arm64@0.24.2': - optional: true - - '@esbuild/android-arm@0.24.2': - optional: true - - '@esbuild/android-x64@0.24.2': - optional: true - - '@esbuild/darwin-arm64@0.24.2': - optional: true - - '@esbuild/darwin-x64@0.24.2': - optional: true - - '@esbuild/freebsd-arm64@0.24.2': - optional: true - - '@esbuild/freebsd-x64@0.24.2': - optional: true - - '@esbuild/linux-arm64@0.24.2': - optional: true - - '@esbuild/linux-arm@0.24.2': - optional: true - - '@esbuild/linux-ia32@0.24.2': - optional: true - - '@esbuild/linux-loong64@0.24.2': - optional: true - - '@esbuild/linux-mips64el@0.24.2': - optional: true - - '@esbuild/linux-ppc64@0.24.2': - optional: true - - '@esbuild/linux-riscv64@0.24.2': - optional: true - - '@esbuild/linux-s390x@0.24.2': - optional: true - - '@esbuild/linux-x64@0.24.2': - optional: true - - '@esbuild/netbsd-arm64@0.24.2': - optional: true - - '@esbuild/netbsd-x64@0.24.2': - optional: true - - '@esbuild/openbsd-arm64@0.24.2': - optional: true - - '@esbuild/openbsd-x64@0.24.2': - optional: true - - '@esbuild/sunos-x64@0.24.2': - optional: true - - '@esbuild/win32-arm64@0.24.2': - optional: true - - '@esbuild/win32-ia32@0.24.2': - optional: true - - '@esbuild/win32-x64@0.24.2': - optional: true - - '@inquirer/confirm@5.1.5(@types/node@22.13.0)': - dependencies: - '@inquirer/core': 10.1.6(@types/node@22.13.0) - '@inquirer/type': 3.0.4(@types/node@22.13.0) - optionalDependencies: - '@types/node': 22.13.0 - - '@inquirer/core@10.1.6(@types/node@22.13.0)': - dependencies: - '@inquirer/figures': 1.0.10 - '@inquirer/type': 3.0.4(@types/node@22.13.0) - ansi-escapes: 4.3.2 - cli-width: 4.1.0 - mute-stream: 2.0.0 - signal-exit: 4.1.0 - wrap-ansi: 6.2.0 - yoctocolors-cjs: 2.1.2 - optionalDependencies: - '@types/node': 22.13.0 - - '@inquirer/figures@1.0.10': {} - - '@inquirer/type@3.0.4(@types/node@22.13.0)': - optionalDependencies: - '@types/node': 22.13.0 - - '@isaacs/cliui@8.0.2': - dependencies: - string-width: 5.1.2 - string-width-cjs: string-width@4.2.3 - strip-ansi: 7.1.0 - strip-ansi-cjs: strip-ansi@6.0.1 - wrap-ansi: 8.1.0 - wrap-ansi-cjs: wrap-ansi@7.0.0 - - '@istanbuljs/schema@0.1.3': {} - - '@jridgewell/gen-mapping@0.3.8': - dependencies: - '@jridgewell/set-array': 1.2.1 - '@jridgewell/sourcemap-codec': 1.5.0 - '@jridgewell/trace-mapping': 0.3.25 - - '@jridgewell/resolve-uri@3.1.2': {} - - '@jridgewell/set-array@1.2.1': {} - - '@jridgewell/sourcemap-codec@1.5.0': {} - - '@jridgewell/trace-mapping@0.3.25': - dependencies: - '@jridgewell/resolve-uri': 3.1.2 - '@jridgewell/sourcemap-codec': 1.5.0 - - '@microsoft/api-extractor-model@7.30.3(@types/node@22.13.0)': - dependencies: - '@microsoft/tsdoc': 0.15.1 - '@microsoft/tsdoc-config': 0.17.1 - '@rushstack/node-core-library': 5.11.0(@types/node@22.13.0) - transitivePeerDependencies: - - '@types/node' - - '@microsoft/api-extractor@7.49.2(@types/node@22.13.0)': - dependencies: - '@microsoft/api-extractor-model': 7.30.3(@types/node@22.13.0) - '@microsoft/tsdoc': 0.15.1 - '@microsoft/tsdoc-config': 0.17.1 - '@rushstack/node-core-library': 5.11.0(@types/node@22.13.0) - '@rushstack/rig-package': 0.5.3 - '@rushstack/terminal': 0.14.6(@types/node@22.13.0) - '@rushstack/ts-command-line': 4.23.4(@types/node@22.13.0) - lodash: 4.17.21 - minimatch: 3.0.8 - resolve: 1.22.10 - semver: 7.5.4 - source-map: 0.6.1 - typescript: 5.7.2 - transitivePeerDependencies: - - '@types/node' - - '@microsoft/tsdoc-config@0.17.1': - dependencies: - '@microsoft/tsdoc': 0.15.1 - ajv: 8.12.0 - jju: 1.4.0 - resolve: 1.22.10 - - '@microsoft/tsdoc@0.15.1': {} - - '@mswjs/interceptors@0.37.6': - dependencies: - '@open-draft/deferred-promise': 2.2.0 - '@open-draft/logger': 0.3.0 - '@open-draft/until': 2.1.0 - is-node-process: 1.2.0 - outvariant: 1.4.3 - strict-event-emitter: 0.5.1 - - '@open-draft/deferred-promise@2.2.0': {} - - '@open-draft/logger@0.3.0': - dependencies: - is-node-process: 1.2.0 - outvariant: 1.4.3 - - '@open-draft/until@2.1.0': {} - - '@pkgjs/parseargs@0.11.0': - optional: true - - '@polka/url@1.0.0-next.28': {} - - '@rollup/pluginutils@5.1.4(rollup@4.34.1)': - dependencies: - '@types/estree': 1.0.6 - estree-walker: 2.0.2 - picomatch: 4.0.2 - optionalDependencies: - rollup: 4.34.1 - - '@rollup/rollup-android-arm-eabi@4.34.1': - optional: true - - '@rollup/rollup-android-arm64@4.34.1': - optional: true - - '@rollup/rollup-darwin-arm64@4.34.1': - optional: true - - '@rollup/rollup-darwin-x64@4.34.1': - optional: true - - '@rollup/rollup-freebsd-arm64@4.34.1': - optional: true - - '@rollup/rollup-freebsd-x64@4.34.1': - optional: true - - '@rollup/rollup-linux-arm-gnueabihf@4.34.1': - optional: true - - '@rollup/rollup-linux-arm-musleabihf@4.34.1': - optional: true - - '@rollup/rollup-linux-arm64-gnu@4.34.1': - optional: true - - '@rollup/rollup-linux-arm64-musl@4.34.1': - optional: true - - '@rollup/rollup-linux-loongarch64-gnu@4.34.1': - optional: true - - '@rollup/rollup-linux-powerpc64le-gnu@4.34.1': - optional: true - - '@rollup/rollup-linux-riscv64-gnu@4.34.1': - optional: true - - '@rollup/rollup-linux-s390x-gnu@4.34.1': - optional: true - - '@rollup/rollup-linux-x64-gnu@4.34.1': - optional: true - - '@rollup/rollup-linux-x64-musl@4.34.1': - optional: true - - '@rollup/rollup-win32-arm64-msvc@4.34.1': - optional: true - - '@rollup/rollup-win32-ia32-msvc@4.34.1': - optional: true - - '@rollup/rollup-win32-x64-msvc@4.34.1': - optional: true - - '@rushstack/node-core-library@5.11.0(@types/node@22.13.0)': - dependencies: - ajv: 8.13.0 - ajv-draft-04: 1.0.0(ajv@8.13.0) - ajv-formats: 3.0.1(ajv@8.13.0) - fs-extra: 11.3.0 - import-lazy: 4.0.0 - jju: 1.4.0 - resolve: 1.22.10 - semver: 7.5.4 - optionalDependencies: - '@types/node': 22.13.0 - - '@rushstack/rig-package@0.5.3': - dependencies: - resolve: 1.22.10 - strip-json-comments: 3.1.1 - - '@rushstack/terminal@0.14.6(@types/node@22.13.0)': - dependencies: - '@rushstack/node-core-library': 5.11.0(@types/node@22.13.0) - supports-color: 8.1.1 - optionalDependencies: - '@types/node': 22.13.0 - - '@rushstack/ts-command-line@4.23.4(@types/node@22.13.0)': - dependencies: - '@rushstack/terminal': 0.14.6(@types/node@22.13.0) - '@types/argparse': 1.0.38 - argparse: 1.0.10 - string-argv: 0.3.2 - transitivePeerDependencies: - - '@types/node' - - '@testing-library/dom@10.4.0': - dependencies: - '@babel/code-frame': 7.26.2 - '@babel/runtime': 7.26.7 - '@types/aria-query': 5.0.4 - aria-query: 5.3.0 - chalk: 4.1.2 - dom-accessibility-api: 0.5.16 - lz-string: 1.5.0 - pretty-format: 27.5.1 - - '@testing-library/user-event@14.6.1(@testing-library/dom@10.4.0)': - dependencies: - '@testing-library/dom': 10.4.0 - - '@thednp/dommatrix@2.0.11': {} - - '@types/argparse@1.0.38': {} - - '@types/aria-query@5.0.4': {} - - '@types/cookie@0.6.0': {} - - '@types/estree@1.0.6': {} - - '@types/node@22.13.0': - dependencies: - undici-types: 6.20.0 - - '@types/statuses@2.0.5': {} - - '@types/tough-cookie@4.0.5': {} - - '@vitest/browser@3.0.5(@types/node@22.13.0)(playwright@1.50.1)(typescript@5.7.3)(vite@6.0.11(@types/node@22.13.0))(vitest@3.0.5)': - dependencies: - '@testing-library/dom': 10.4.0 - '@testing-library/user-event': 14.6.1(@testing-library/dom@10.4.0) - '@vitest/mocker': 3.0.5(msw@2.7.0(@types/node@22.13.0)(typescript@5.7.3))(vite@6.0.11(@types/node@22.13.0)) - '@vitest/utils': 3.0.5 - magic-string: 0.30.17 - msw: 2.7.0(@types/node@22.13.0)(typescript@5.7.3) - sirv: 3.0.0 - tinyrainbow: 2.0.0 - vitest: 3.0.5(@types/node@22.13.0)(@vitest/browser@3.0.5)(@vitest/ui@3.0.5)(msw@2.7.0(@types/node@22.13.0)(typescript@5.7.3)) - ws: 8.18.0 - optionalDependencies: - playwright: 1.50.1 - transitivePeerDependencies: - - '@types/node' - - bufferutil - - typescript - - utf-8-validate - - vite - - '@vitest/coverage-istanbul@3.0.5(vitest@3.0.5)': - dependencies: - '@istanbuljs/schema': 0.1.3 - debug: 4.4.0 - istanbul-lib-coverage: 3.2.2 - istanbul-lib-instrument: 6.0.3 - istanbul-lib-report: 3.0.1 - istanbul-lib-source-maps: 5.0.6 - istanbul-reports: 3.1.7 - magicast: 0.3.5 - test-exclude: 7.0.1 - tinyrainbow: 2.0.0 - vitest: 3.0.5(@types/node@22.13.0)(@vitest/browser@3.0.5)(@vitest/ui@3.0.5)(msw@2.7.0(@types/node@22.13.0)(typescript@5.7.3)) - transitivePeerDependencies: - - supports-color - - '@vitest/expect@3.0.5': - dependencies: - '@vitest/spy': 3.0.5 - '@vitest/utils': 3.0.5 - chai: 5.1.2 - tinyrainbow: 2.0.0 - - '@vitest/mocker@3.0.5(msw@2.7.0(@types/node@22.13.0)(typescript@5.7.3))(vite@6.0.11(@types/node@22.13.0))': - dependencies: - '@vitest/spy': 3.0.5 - estree-walker: 3.0.3 - magic-string: 0.30.17 - optionalDependencies: - msw: 2.7.0(@types/node@22.13.0)(typescript@5.7.3) - vite: 6.0.11(@types/node@22.13.0) - - '@vitest/pretty-format@3.0.5': - dependencies: - tinyrainbow: 2.0.0 - - '@vitest/runner@3.0.5': - dependencies: - '@vitest/utils': 3.0.5 - pathe: 2.0.2 - - '@vitest/snapshot@3.0.5': - dependencies: - '@vitest/pretty-format': 3.0.5 - magic-string: 0.30.17 - pathe: 2.0.2 - - '@vitest/spy@3.0.5': - dependencies: - tinyspy: 3.0.2 - - '@vitest/ui@3.0.5(vitest@3.0.5)': - dependencies: - '@vitest/utils': 3.0.5 - fflate: 0.8.2 - flatted: 3.3.2 - pathe: 2.0.2 - sirv: 3.0.0 - tinyglobby: 0.2.10 - tinyrainbow: 2.0.0 - vitest: 3.0.5(@types/node@22.13.0)(@vitest/browser@3.0.5)(@vitest/ui@3.0.5)(msw@2.7.0(@types/node@22.13.0)(typescript@5.7.3)) - - '@vitest/utils@3.0.5': - dependencies: - '@vitest/pretty-format': 3.0.5 - loupe: 3.1.3 - tinyrainbow: 2.0.0 - - '@volar/language-core@2.4.11': - dependencies: - '@volar/source-map': 2.4.11 - - '@volar/source-map@2.4.11': {} - - '@volar/typescript@2.4.11': - dependencies: - '@volar/language-core': 2.4.11 - path-browserify: 1.0.1 - vscode-uri: 3.0.8 - - '@vue/compiler-core@3.5.13': - dependencies: - '@babel/parser': 7.26.7 - '@vue/shared': 3.5.13 - entities: 4.5.0 - estree-walker: 2.0.2 - source-map-js: 1.2.1 - - '@vue/compiler-dom@3.5.13': - dependencies: - '@vue/compiler-core': 3.5.13 - '@vue/shared': 3.5.13 - - '@vue/compiler-vue2@2.7.16': - dependencies: - de-indent: 1.0.2 - he: 1.2.0 - - '@vue/language-core@2.2.0(typescript@5.7.3)': - dependencies: - '@volar/language-core': 2.4.11 - '@vue/compiler-dom': 3.5.13 - '@vue/compiler-vue2': 2.7.16 - '@vue/shared': 3.5.13 - alien-signals: 0.4.14 - minimatch: 9.0.5 - muggle-string: 0.4.1 - path-browserify: 1.0.1 - optionalDependencies: - typescript: 5.7.3 - - '@vue/shared@3.5.13': {} - - acorn@8.14.0: {} - - ajv-draft-04@1.0.0(ajv@8.13.0): - optionalDependencies: - ajv: 8.13.0 - - ajv-formats@3.0.1(ajv@8.13.0): - optionalDependencies: - ajv: 8.13.0 - - ajv@8.12.0: - dependencies: - fast-deep-equal: 3.1.3 - json-schema-traverse: 1.0.0 - require-from-string: 2.0.2 - uri-js: 4.4.1 - - ajv@8.13.0: - dependencies: - fast-deep-equal: 3.1.3 - json-schema-traverse: 1.0.0 - require-from-string: 2.0.2 - uri-js: 4.4.1 - - alien-signals@0.4.14: {} - - ansi-escapes@4.3.2: - dependencies: - type-fest: 0.21.3 - - ansi-regex@5.0.1: {} - - ansi-regex@6.1.0: {} - - ansi-styles@4.3.0: - dependencies: - color-convert: 2.0.1 - - ansi-styles@5.2.0: {} - - ansi-styles@6.2.1: {} - - argparse@1.0.10: - dependencies: - sprintf-js: 1.0.3 - - aria-query@5.3.0: - dependencies: - dequal: 2.0.3 - - assertion-error@2.0.1: {} - - balanced-match@1.0.2: {} - - brace-expansion@1.1.11: - dependencies: - balanced-match: 1.0.2 - concat-map: 0.0.1 - - brace-expansion@2.0.1: - dependencies: - balanced-match: 1.0.2 - - browserslist@4.24.4: - dependencies: - caniuse-lite: 1.0.30001696 - electron-to-chromium: 1.5.90 - node-releases: 2.0.19 - update-browserslist-db: 1.1.2(browserslist@4.24.4) - - cac@6.7.14: {} - - caniuse-lite@1.0.30001696: {} - - chai@5.1.2: - dependencies: - assertion-error: 2.0.1 - check-error: 2.1.1 - deep-eql: 5.0.2 - loupe: 3.1.3 - pathval: 2.0.0 - - chalk@4.1.2: - dependencies: - ansi-styles: 4.3.0 - supports-color: 7.2.0 - - check-error@2.1.1: {} - - cli-width@4.1.0: {} - - cliui@8.0.1: - dependencies: - string-width: 4.2.3 - strip-ansi: 6.0.1 - wrap-ansi: 7.0.0 - - color-convert@2.0.1: - dependencies: - color-name: 1.1.4 - - color-name@1.1.4: {} - - compare-versions@6.1.1: {} - - concat-map@0.0.1: {} - - confbox@0.1.8: {} - - convert-source-map@2.0.0: {} - - cookie@0.7.2: {} - - cross-spawn@7.0.6: - dependencies: - path-key: 3.1.1 - shebang-command: 2.0.0 - which: 2.0.2 - - de-indent@1.0.2: {} - - debug@4.4.0: - dependencies: - ms: 2.1.3 - - deep-eql@5.0.2: {} - - dequal@2.0.3: {} - - dom-accessibility-api@0.5.16: {} - - eastasianwidth@0.2.0: {} - - electron-to-chromium@1.5.90: {} - - emoji-regex@8.0.0: {} - - emoji-regex@9.2.2: {} - - entities@4.5.0: {} - - es-module-lexer@1.6.0: {} - - esbuild@0.24.2: - optionalDependencies: - '@esbuild/aix-ppc64': 0.24.2 - '@esbuild/android-arm': 0.24.2 - '@esbuild/android-arm64': 0.24.2 - '@esbuild/android-x64': 0.24.2 - '@esbuild/darwin-arm64': 0.24.2 - '@esbuild/darwin-x64': 0.24.2 - '@esbuild/freebsd-arm64': 0.24.2 - '@esbuild/freebsd-x64': 0.24.2 - '@esbuild/linux-arm': 0.24.2 - '@esbuild/linux-arm64': 0.24.2 - '@esbuild/linux-ia32': 0.24.2 - '@esbuild/linux-loong64': 0.24.2 - '@esbuild/linux-mips64el': 0.24.2 - '@esbuild/linux-ppc64': 0.24.2 - '@esbuild/linux-riscv64': 0.24.2 - '@esbuild/linux-s390x': 0.24.2 - '@esbuild/linux-x64': 0.24.2 - '@esbuild/netbsd-arm64': 0.24.2 - '@esbuild/netbsd-x64': 0.24.2 - '@esbuild/openbsd-arm64': 0.24.2 - '@esbuild/openbsd-x64': 0.24.2 - '@esbuild/sunos-x64': 0.24.2 - '@esbuild/win32-arm64': 0.24.2 - '@esbuild/win32-ia32': 0.24.2 - '@esbuild/win32-x64': 0.24.2 - - escalade@3.2.0: {} - - estree-walker@2.0.2: {} - - estree-walker@3.0.3: - dependencies: - '@types/estree': 1.0.6 - - expect-type@1.1.0: {} - - fast-deep-equal@3.1.3: {} - - fdir@6.4.3(picomatch@4.0.2): - optionalDependencies: - picomatch: 4.0.2 - - fflate@0.8.2: {} - - flatted@3.3.2: {} - - foreground-child@3.3.0: - dependencies: - cross-spawn: 7.0.6 - signal-exit: 4.1.0 - - fs-extra@11.3.0: - dependencies: - graceful-fs: 4.2.11 - jsonfile: 6.1.0 - universalify: 2.0.1 - - fsevents@2.3.2: - optional: true - - fsevents@2.3.3: - optional: true - - function-bind@1.1.2: {} - - gensync@1.0.0-beta.2: {} - - get-caller-file@2.0.5: {} - - glob@10.4.5: - dependencies: - foreground-child: 3.3.0 - jackspeak: 3.4.3 - minimatch: 9.0.5 - minipass: 7.1.2 - package-json-from-dist: 1.0.1 - path-scurry: 1.11.1 - - globals@11.12.0: {} - - graceful-fs@4.2.11: {} - - graphql@16.10.0: {} - - has-flag@4.0.0: {} - - hasown@2.0.2: - dependencies: - function-bind: 1.1.2 - - he@1.2.0: {} - - headers-polyfill@4.0.3: {} - - html-escaper@2.0.2: {} - - import-lazy@4.0.0: {} - - is-core-module@2.16.1: - dependencies: - hasown: 2.0.2 - - is-fullwidth-code-point@3.0.0: {} - - is-node-process@1.2.0: {} - - isexe@2.0.0: {} - - istanbul-lib-coverage@3.2.2: {} - - istanbul-lib-instrument@6.0.3: - dependencies: - '@babel/core': 7.26.7 - '@babel/parser': 7.26.7 - '@istanbuljs/schema': 0.1.3 - istanbul-lib-coverage: 3.2.2 - semver: 7.7.0 - transitivePeerDependencies: - - supports-color - - istanbul-lib-report@3.0.1: - dependencies: - istanbul-lib-coverage: 3.2.2 - make-dir: 4.0.0 - supports-color: 7.2.0 - - istanbul-lib-source-maps@5.0.6: - dependencies: - '@jridgewell/trace-mapping': 0.3.25 - debug: 4.4.0 - istanbul-lib-coverage: 3.2.2 - transitivePeerDependencies: - - supports-color - - istanbul-reports@3.1.7: - dependencies: - html-escaper: 2.0.2 - istanbul-lib-report: 3.0.1 - - jackspeak@3.4.3: - dependencies: - '@isaacs/cliui': 8.0.2 - optionalDependencies: - '@pkgjs/parseargs': 0.11.0 - - jju@1.4.0: {} - - js-tokens@4.0.0: {} - - jsesc@3.1.0: {} - - json-schema-traverse@1.0.0: {} - - json5@2.2.3: {} - - jsonfile@6.1.0: - dependencies: - universalify: 2.0.1 - optionalDependencies: - graceful-fs: 4.2.11 - - kolorist@1.8.0: {} - - local-pkg@0.5.1: - dependencies: - mlly: 1.7.4 - pkg-types: 1.3.1 - - lodash@4.17.21: {} - - loupe@3.1.3: {} - - lru-cache@10.4.3: {} - - lru-cache@5.1.1: - dependencies: - yallist: 3.1.1 - - lru-cache@6.0.0: - dependencies: - yallist: 4.0.0 - - lz-string@1.5.0: {} - - magic-string@0.30.17: - dependencies: - '@jridgewell/sourcemap-codec': 1.5.0 - - magicast@0.3.5: - dependencies: - '@babel/parser': 7.26.7 - '@babel/types': 7.26.7 - source-map-js: 1.2.1 - - make-dir@4.0.0: - dependencies: - semver: 7.7.0 - - minimatch@3.0.8: - dependencies: - brace-expansion: 1.1.11 - - minimatch@9.0.5: - dependencies: - brace-expansion: 2.0.1 - - minipass@7.1.2: {} - - mlly@1.7.4: - dependencies: - acorn: 8.14.0 - pathe: 2.0.2 - pkg-types: 1.3.1 - ufo: 1.5.4 - - mrmime@2.0.0: {} - - ms@2.1.3: {} - - msw@2.7.0(@types/node@22.13.0)(typescript@5.7.3): - dependencies: - '@bundled-es-modules/cookie': 2.0.1 - '@bundled-es-modules/statuses': 1.0.1 - '@bundled-es-modules/tough-cookie': 0.1.6 - '@inquirer/confirm': 5.1.5(@types/node@22.13.0) - '@mswjs/interceptors': 0.37.6 - '@open-draft/deferred-promise': 2.2.0 - '@open-draft/until': 2.1.0 - '@types/cookie': 0.6.0 - '@types/statuses': 2.0.5 - graphql: 16.10.0 - headers-polyfill: 4.0.3 - is-node-process: 1.2.0 - outvariant: 1.4.3 - path-to-regexp: 6.3.0 - picocolors: 1.1.1 - strict-event-emitter: 0.5.1 - type-fest: 4.33.0 - yargs: 17.7.2 - optionalDependencies: - typescript: 5.7.3 - transitivePeerDependencies: - - '@types/node' - - muggle-string@0.4.1: {} - - mute-stream@2.0.0: {} - - nanoid@3.3.8: {} - - node-releases@2.0.19: {} - - outvariant@1.4.3: {} - - package-json-from-dist@1.0.1: {} - - path-browserify@1.0.1: {} - - path-key@3.1.1: {} - - path-parse@1.0.7: {} - - path-scurry@1.11.1: - dependencies: - lru-cache: 10.4.3 - minipass: 7.1.2 - - path-to-regexp@6.3.0: {} - - pathe@2.0.2: {} - - pathval@2.0.0: {} - - picocolors@1.1.1: {} - - picomatch@4.0.2: {} - - pkg-types@1.3.1: - dependencies: - confbox: 0.1.8 - mlly: 1.7.4 - pathe: 2.0.2 - - playwright-core@1.50.1: {} - - playwright@1.50.1: - dependencies: - playwright-core: 1.50.1 - optionalDependencies: - fsevents: 2.3.2 - - postcss@8.5.1: - dependencies: - nanoid: 3.3.8 - picocolors: 1.1.1 - source-map-js: 1.2.1 - - pretty-format@27.5.1: - dependencies: - ansi-regex: 5.0.1 - ansi-styles: 5.2.0 - react-is: 17.0.2 - - psl@1.15.0: - dependencies: - punycode: 2.3.1 - - punycode@2.3.1: {} - - querystringify@2.2.0: {} - - react-is@17.0.2: {} - - regenerator-runtime@0.14.1: {} - - require-directory@2.1.1: {} - - require-from-string@2.0.2: {} - - requires-port@1.0.0: {} - - resolve@1.22.10: - dependencies: - is-core-module: 2.16.1 - path-parse: 1.0.7 - supports-preserve-symlinks-flag: 1.0.0 - - rollup@4.34.1: - dependencies: - '@types/estree': 1.0.6 - optionalDependencies: - '@rollup/rollup-android-arm-eabi': 4.34.1 - '@rollup/rollup-android-arm64': 4.34.1 - '@rollup/rollup-darwin-arm64': 4.34.1 - '@rollup/rollup-darwin-x64': 4.34.1 - '@rollup/rollup-freebsd-arm64': 4.34.1 - '@rollup/rollup-freebsd-x64': 4.34.1 - '@rollup/rollup-linux-arm-gnueabihf': 4.34.1 - '@rollup/rollup-linux-arm-musleabihf': 4.34.1 - '@rollup/rollup-linux-arm64-gnu': 4.34.1 - '@rollup/rollup-linux-arm64-musl': 4.34.1 - '@rollup/rollup-linux-loongarch64-gnu': 4.34.1 - '@rollup/rollup-linux-powerpc64le-gnu': 4.34.1 - '@rollup/rollup-linux-riscv64-gnu': 4.34.1 - '@rollup/rollup-linux-s390x-gnu': 4.34.1 - '@rollup/rollup-linux-x64-gnu': 4.34.1 - '@rollup/rollup-linux-x64-musl': 4.34.1 - '@rollup/rollup-win32-arm64-msvc': 4.34.1 - '@rollup/rollup-win32-ia32-msvc': 4.34.1 - '@rollup/rollup-win32-x64-msvc': 4.34.1 - fsevents: 2.3.3 - - semver@6.3.1: {} - - semver@7.5.4: - dependencies: - lru-cache: 6.0.0 - - semver@7.7.0: {} - - shebang-command@2.0.0: - dependencies: - shebang-regex: 3.0.0 - - shebang-regex@3.0.0: {} - - siginfo@2.0.0: {} - - signal-exit@4.1.0: {} - - sirv@3.0.0: - dependencies: - '@polka/url': 1.0.0-next.28 - mrmime: 2.0.0 - totalist: 3.0.1 - - source-map-js@1.2.1: {} - - source-map@0.6.1: {} - - sprintf-js@1.0.3: {} - - stackback@0.0.2: {} - - statuses@2.0.1: {} - - std-env@3.8.0: {} - - strict-event-emitter@0.5.1: {} - - string-argv@0.3.2: {} - - string-width@4.2.3: - dependencies: - emoji-regex: 8.0.0 - is-fullwidth-code-point: 3.0.0 - strip-ansi: 6.0.1 - - string-width@5.1.2: - dependencies: - eastasianwidth: 0.2.0 - emoji-regex: 9.2.2 - strip-ansi: 7.1.0 - - strip-ansi@6.0.1: - dependencies: - ansi-regex: 5.0.1 - - strip-ansi@7.1.0: - dependencies: - ansi-regex: 6.1.0 - - strip-json-comments@3.1.1: {} - - supports-color@7.2.0: - dependencies: - has-flag: 4.0.0 - - supports-color@8.1.1: - dependencies: - has-flag: 4.0.0 - - supports-preserve-symlinks-flag@1.0.0: {} - - test-exclude@7.0.1: - dependencies: - '@istanbuljs/schema': 0.1.3 - glob: 10.4.5 - minimatch: 9.0.5 - - tinybench@2.9.0: {} - - tinyexec@0.3.2: {} - - tinyglobby@0.2.10: - dependencies: - fdir: 6.4.3(picomatch@4.0.2) - picomatch: 4.0.2 - - tinypool@1.0.2: {} - - tinyrainbow@2.0.0: {} - - tinyspy@3.0.2: {} - - totalist@3.0.1: {} - - tough-cookie@4.1.4: - dependencies: - psl: 1.15.0 - punycode: 2.3.1 - universalify: 0.2.0 - url-parse: 1.5.10 - - type-fest@0.21.3: {} - - type-fest@4.33.0: {} - - typescript@5.7.2: {} - - typescript@5.7.3: {} - - ufo@1.5.4: {} - - undici-types@6.20.0: {} - - universalify@0.2.0: {} - - universalify@2.0.1: {} - - update-browserslist-db@1.1.2(browserslist@4.24.4): - dependencies: - browserslist: 4.24.4 - escalade: 3.2.0 - picocolors: 1.1.1 - - uri-js@4.4.1: - dependencies: - punycode: 2.3.1 - - url-parse@1.5.10: - dependencies: - querystringify: 2.2.0 - requires-port: 1.0.0 - - vite-node@3.0.5(@types/node@22.13.0): - dependencies: - cac: 6.7.14 - debug: 4.4.0 - es-module-lexer: 1.6.0 - pathe: 2.0.2 - vite: 6.0.11(@types/node@22.13.0) - transitivePeerDependencies: - - '@types/node' - - jiti - - less - - lightningcss - - sass - - sass-embedded - - stylus - - sugarss - - supports-color - - terser - - tsx - - yaml - - vite-plugin-dts@4.5.0(@types/node@22.13.0)(rollup@4.34.1)(typescript@5.7.3)(vite@6.0.11(@types/node@22.13.0)): - dependencies: - '@microsoft/api-extractor': 7.49.2(@types/node@22.13.0) - '@rollup/pluginutils': 5.1.4(rollup@4.34.1) - '@volar/typescript': 2.4.11 - '@vue/language-core': 2.2.0(typescript@5.7.3) - compare-versions: 6.1.1 - debug: 4.4.0 - kolorist: 1.8.0 - local-pkg: 0.5.1 - magic-string: 0.30.17 - typescript: 5.7.3 - optionalDependencies: - vite: 6.0.11(@types/node@22.13.0) - transitivePeerDependencies: - - '@types/node' - - rollup - - supports-color - - vite@6.0.11(@types/node@22.13.0): - dependencies: - esbuild: 0.24.2 - postcss: 8.5.1 - rollup: 4.34.1 - optionalDependencies: - '@types/node': 22.13.0 - fsevents: 2.3.3 - - vitest@3.0.5(@types/node@22.13.0)(@vitest/browser@3.0.5)(@vitest/ui@3.0.5)(msw@2.7.0(@types/node@22.13.0)(typescript@5.7.3)): - dependencies: - '@vitest/expect': 3.0.5 - '@vitest/mocker': 3.0.5(msw@2.7.0(@types/node@22.13.0)(typescript@5.7.3))(vite@6.0.11(@types/node@22.13.0)) - '@vitest/pretty-format': 3.0.5 - '@vitest/runner': 3.0.5 - '@vitest/snapshot': 3.0.5 - '@vitest/spy': 3.0.5 - '@vitest/utils': 3.0.5 - chai: 5.1.2 - debug: 4.4.0 - expect-type: 1.1.0 - magic-string: 0.30.17 - pathe: 2.0.2 - std-env: 3.8.0 - tinybench: 2.9.0 - tinyexec: 0.3.2 - tinypool: 1.0.2 - tinyrainbow: 2.0.0 - vite: 6.0.11(@types/node@22.13.0) - vite-node: 3.0.5(@types/node@22.13.0) - why-is-node-running: 2.3.0 - optionalDependencies: - '@types/node': 22.13.0 - '@vitest/browser': 3.0.5(@types/node@22.13.0)(playwright@1.50.1)(typescript@5.7.3)(vite@6.0.11(@types/node@22.13.0))(vitest@3.0.5) - '@vitest/ui': 3.0.5(vitest@3.0.5) - transitivePeerDependencies: - - jiti - - less - - lightningcss - - msw - - sass - - sass-embedded - - stylus - - sugarss - - supports-color - - terser - - tsx - - yaml - - vscode-uri@3.0.8: {} - - which@2.0.2: - dependencies: - isexe: 2.0.0 - - why-is-node-running@2.3.0: - dependencies: - siginfo: 2.0.0 - stackback: 0.0.2 - - wrap-ansi@6.2.0: - dependencies: - ansi-styles: 4.3.0 - string-width: 4.2.3 - strip-ansi: 6.0.1 - - wrap-ansi@7.0.0: - dependencies: - ansi-styles: 4.3.0 - string-width: 4.2.3 - strip-ansi: 6.0.1 - - wrap-ansi@8.1.0: - dependencies: - ansi-styles: 6.2.1 - string-width: 5.1.2 - strip-ansi: 7.1.0 - - ws@8.18.0: {} - - y18n@5.0.8: {} - - yallist@3.1.1: {} - - yallist@4.0.0: {} - - yargs-parser@21.1.1: {} - - yargs@17.7.2: - dependencies: - cliui: 8.0.1 - escalade: 3.2.0 - get-caller-file: 2.0.5 - require-directory: 2.1.1 - string-width: 4.2.3 - y18n: 5.0.8 - yargs-parser: 21.1.1 - - yoctocolors-cjs@2.1.2: {} + dev: true diff --git a/vite.config-util.mts b/vite.config-util.mts index 8cbf115..85f1f7f 100755 --- a/vite.config-util.mts +++ b/vite.config-util.mts @@ -43,4 +43,3 @@ export default defineConfig({ legalComments: 'none' } }); - From a691ee5bfb4971c65ad85dec5f10a7dfd2f8e264 Mon Sep 17 00:00:00 2001 From: Vlad Date: Tue, 4 Feb 2025 11:58:48 +0200 Subject: [PATCH 2/4] x --- .npmignore | 2 +- dist/svg-path-commander.cjs | 4 +- dist/svg-path-commander.cjs.map | 2 +- .../util.d.cts => svg-path-commander.d.cts} | 292 +- dist/svg-path-commander.d.ts | 2357 +++++++++++------ dist/svg-path-commander.js | 4 +- dist/svg-path-commander.js.map | 2 +- dist/svg-path-commander.mjs | 2125 +-------------- dist/svg-path-commander.mjs.map | 2 +- dist/util/util.cjs | 4 +- dist/util/util.cjs.map | 2 +- dist/util/util.js | 4 +- dist/util/util.js.map | 2 +- dist/util/util.mjs | 1930 +------------- dist/util/util.mjs.map | 2 +- package.json | 12 +- tsup.config.ts | 51 + vite.config-util.mts | 45 - vite.config.mts | 52 - 19 files changed, 1873 insertions(+), 5021 deletions(-) rename dist/{util/util.d.cts => svg-path-commander.d.cts} (75%) create mode 100644 tsup.config.ts delete mode 100755 vite.config-util.mts delete mode 100755 vite.config.mts diff --git a/.npmignore b/.npmignore index b4eed3b..2c626eb 100755 --- a/.npmignore +++ b/.npmignore @@ -8,6 +8,6 @@ coverage test src tsconfig.json -vite.config.mts vitest.config.mts vitest.config-ui.mts +tsup.config.ts diff --git a/dist/svg-path-commander.cjs b/dist/svg-path-commander.cjs index 39a5903..ae5f29c 100644 --- a/dist/svg-path-commander.cjs +++ b/dist/svg-path-commander.cjs @@ -1,2 +1,2 @@ -"use strict";var Et=Object.defineProperty,Ot=(t,e,r)=>e in t?Et(t,e,{enumerable:!0,configurable:!0,writable:!0,value:r}):t[e]=r,I=(t,e,r)=>Ot(t,typeof e!="symbol"?e+"":e,r);const Vt={a:1,b:0,c:0,d:1,e:0,f:0,m11:1,m12:0,m13:0,m14:0,m21:0,m22:1,m23:0,m24:0,m31:0,m32:0,m33:1,m34:0,m41:0,m42:0,m43:0,m44:1,is2D:!0,isIdentity:!0},Fe=t=>(t instanceof Float64Array||t instanceof Float32Array||Array.isArray(t)&&t.every(e=>typeof e=="number"))&&[6,16].some(e=>t.length===e),Ue=t=>t instanceof DOMMatrix||t instanceof P||typeof t=="object"&&Object.keys(Vt).every(e=>t&&e in t),oe=t=>{const e=new P,r=Array.from(t);if(!Fe(r))throw TypeError(`CSSMatrix: "${r.join(",")}" must be an array with 6/16 numbers.`);if(r.length===16){const[s,n,o,i,l,c,a,m,h,f,y,u,g,p,b,M]=r;e.m11=s,e.a=s,e.m21=l,e.c=l,e.m31=h,e.m41=g,e.e=g,e.m12=n,e.b=n,e.m22=c,e.d=c,e.m32=f,e.m42=p,e.f=p,e.m13=o,e.m23=a,e.m33=y,e.m43=b,e.m14=i,e.m24=m,e.m34=u,e.m44=M}else if(r.length===6){const[s,n,o,i,l,c]=r;e.m11=s,e.a=s,e.m12=n,e.b=n,e.m21=o,e.c=o,e.m22=i,e.d=i,e.m41=l,e.e=l,e.m42=c,e.f=c}return e},Ge=t=>{if(Ue(t))return oe([t.m11,t.m12,t.m13,t.m14,t.m21,t.m22,t.m23,t.m24,t.m31,t.m32,t.m33,t.m34,t.m41,t.m42,t.m43,t.m44]);throw TypeError(`CSSMatrix: "${JSON.stringify(t)}" is not a DOMMatrix / CSSMatrix / JSON compatible object.`)},Je=t=>{if(typeof t!="string")throw TypeError(`CSSMatrix: "${JSON.stringify(t)}" is not a string.`);const e=String(t).replace(/\s/g,"");let r=new P;const s=`CSSMatrix: invalid transform string "${t}"`;return e.split(")").filter(n=>n).forEach(n=>{const[o,i]=n.split("(");if(!i)throw TypeError(s);const l=i.split(",").map(u=>u.includes("rad")?parseFloat(u)*(180/Math.PI):parseFloat(u)),[c,a,m,h]=l,f=[c,a,m],y=[c,a,m,h];if(o==="perspective"&&c&&[a,m].every(u=>u===void 0))r.m34=-1/c;else if(o.includes("matrix")&&[6,16].includes(l.length)&&l.every(u=>!Number.isNaN(+u))){const u=l.map(g=>Math.abs(g)<1e-6?0:g);r=r.multiply(oe(u))}else if(o==="translate3d"&&f.every(u=>!Number.isNaN(+u)))r=r.translate(c,a,m);else if(o==="translate"&&c&&m===void 0)r=r.translate(c,a||0,0);else if(o==="rotate3d"&&y.every(u=>!Number.isNaN(+u))&&h)r=r.rotateAxisAngle(c,a,m,h);else if(o==="rotate"&&c&&[a,m].every(u=>u===void 0))r=r.rotate(0,0,c);else if(o==="scale3d"&&f.every(u=>!Number.isNaN(+u))&&f.some(u=>u!==1))r=r.scale(c,a,m);else if(o==="scale"&&!Number.isNaN(c)&&(c!==1||a!==1)&&m===void 0){const u=Number.isNaN(+a)?c:a;r=r.scale(c,u,1)}else if(o==="skew"&&(c||!Number.isNaN(c)&&a)&&m===void 0)r=r.skew(c,a||0);else if(["translate","rotate","scale","skew"].some(u=>o.includes(u))&&/[XYZ]/.test(o)&&c&&[a,m].every(u=>u===void 0))if(o==="skewX"||o==="skewY")r=r[o](c);else{const u=o.replace(/[XYZ]/,""),g=o.replace(u,""),p=["X","Y","Z"].indexOf(g),b=u==="scale"?1:0,M=[p===0?c:b,p===1?c:b,p===2?c:b];r=r[u](...M)}else throw TypeError(s)}),r},Le=(t,e)=>e?[t.a,t.b,t.c,t.d,t.e,t.f]:[t.m11,t.m12,t.m13,t.m14,t.m21,t.m22,t.m23,t.m24,t.m31,t.m32,t.m33,t.m34,t.m41,t.m42,t.m43,t.m44],Ke=(t,e,r)=>{const s=new P;return s.m41=t,s.e=t,s.m42=e,s.f=e,s.m43=r,s},We=(t,e,r)=>{const s=new P,n=Math.PI/180,o=t*n,i=e*n,l=r*n,c=Math.cos(o),a=-Math.sin(o),m=Math.cos(i),h=-Math.sin(i),f=Math.cos(l),y=-Math.sin(l),u=m*f,g=-m*y;s.m11=u,s.a=u,s.m12=g,s.b=g,s.m13=h;const p=a*h*f+c*y;s.m21=p,s.c=p;const b=c*f-a*h*y;return s.m22=b,s.d=b,s.m23=-a*m,s.m31=a*y-c*h*f,s.m32=a*f+c*h*y,s.m33=c*m,s},Xe=(t,e,r,s)=>{const n=new P,o=Math.sqrt(t*t+e*e+r*r);if(o===0)return n;const i=t/o,l=e/o,c=r/o,a=s*(Math.PI/360),m=Math.sin(a),h=Math.cos(a),f=m*m,y=i*i,u=l*l,g=c*c,p=1-2*(u+g)*f;n.m11=p,n.a=p;const b=2*(i*l*f+c*m*h);n.m12=b,n.b=b,n.m13=2*(i*c*f-l*m*h);const M=2*(l*i*f-c*m*h);n.m21=M,n.c=M;const d=1-2*(g+y)*f;return n.m22=d,n.d=d,n.m23=2*(l*c*f+i*m*h),n.m31=2*(c*i*f+l*m*h),n.m32=2*(c*l*f-i*m*h),n.m33=1-2*(y+u)*f,n},Ye=(t,e,r)=>{const s=new P;return s.m11=t,s.a=t,s.m22=e,s.d=e,s.m33=r,s},de=(t,e)=>{const r=new P;if(t){const s=t*Math.PI/180,n=Math.tan(s);r.m21=n,r.c=n}if(e){const s=e*Math.PI/180,n=Math.tan(s);r.m12=n,r.b=n}return r},et=t=>de(t,0),tt=t=>de(0,t),B=(t,e)=>{const r=e.m11*t.m11+e.m12*t.m21+e.m13*t.m31+e.m14*t.m41,s=e.m11*t.m12+e.m12*t.m22+e.m13*t.m32+e.m14*t.m42,n=e.m11*t.m13+e.m12*t.m23+e.m13*t.m33+e.m14*t.m43,o=e.m11*t.m14+e.m12*t.m24+e.m13*t.m34+e.m14*t.m44,i=e.m21*t.m11+e.m22*t.m21+e.m23*t.m31+e.m24*t.m41,l=e.m21*t.m12+e.m22*t.m22+e.m23*t.m32+e.m24*t.m42,c=e.m21*t.m13+e.m22*t.m23+e.m23*t.m33+e.m24*t.m43,a=e.m21*t.m14+e.m22*t.m24+e.m23*t.m34+e.m24*t.m44,m=e.m31*t.m11+e.m32*t.m21+e.m33*t.m31+e.m34*t.m41,h=e.m31*t.m12+e.m32*t.m22+e.m33*t.m32+e.m34*t.m42,f=e.m31*t.m13+e.m32*t.m23+e.m33*t.m33+e.m34*t.m43,y=e.m31*t.m14+e.m32*t.m24+e.m33*t.m34+e.m34*t.m44,u=e.m41*t.m11+e.m42*t.m21+e.m43*t.m31+e.m44*t.m41,g=e.m41*t.m12+e.m42*t.m22+e.m43*t.m32+e.m44*t.m42,p=e.m41*t.m13+e.m42*t.m23+e.m43*t.m33+e.m44*t.m43,b=e.m41*t.m14+e.m42*t.m24+e.m43*t.m34+e.m44*t.m44;return oe([r,s,n,o,i,l,c,a,m,h,f,y,u,g,p,b])};class P{constructor(e){return this.a=1,this.b=0,this.c=0,this.d=1,this.e=0,this.f=0,this.m11=1,this.m12=0,this.m13=0,this.m14=0,this.m21=0,this.m22=1,this.m23=0,this.m24=0,this.m31=0,this.m32=0,this.m33=1,this.m34=0,this.m41=0,this.m42=0,this.m43=0,this.m44=1,e?this.setMatrixValue(e):this}get isIdentity(){return this.m11===1&&this.m12===0&&this.m13===0&&this.m14===0&&this.m21===0&&this.m22===1&&this.m23===0&&this.m24===0&&this.m31===0&&this.m32===0&&this.m33===1&&this.m34===0&&this.m41===0&&this.m42===0&&this.m43===0&&this.m44===1}get is2D(){return this.m31===0&&this.m32===0&&this.m33===1&&this.m34===0&&this.m43===0&&this.m44===1}setMatrixValue(e){return typeof e=="string"&&e.length&&e!=="none"?Je(e):Array.isArray(e)||e instanceof Float64Array||e instanceof Float32Array?oe(e):typeof e=="object"?Ge(e):this}toFloat32Array(e){return Float32Array.from(Le(this,e))}toFloat64Array(e){return Float64Array.from(Le(this,e))}toString(){const{is2D:e}=this,r=this.toFloat64Array(e).join(", ");return`${e?"matrix":"matrix3d"}(${r})`}toJSON(){const{is2D:e,isIdentity:r}=this;return{...this,is2D:e,isIdentity:r}}multiply(e){return B(this,e)}translate(e,r,s){const n=e;let o=r,i=s;return typeof o>"u"&&(o=0),typeof i>"u"&&(i=0),B(this,Ke(n,o,i))}scale(e,r,s){const n=e;let o=r,i=s;return typeof o>"u"&&(o=e),typeof i>"u"&&(i=1),B(this,Ye(n,o,i))}rotate(e,r,s){let n=e,o=r||0,i=s||0;return typeof e=="number"&&typeof r>"u"&&typeof s>"u"&&(i=n,n=0,o=0),B(this,We(n,o,i))}rotateAxisAngle(e,r,s,n){if([e,r,s,n].some(o=>Number.isNaN(+o)))throw new TypeError("CSSMatrix: expecting 4 values");return B(this,Xe(e,r,s,n))}skewX(e){return B(this,et(e))}skewY(e){return B(this,tt(e))}skew(e,r){return B(this,de(e,r))}transformPoint(e){const r=this.m11*e.x+this.m21*e.y+this.m31*e.z+this.m41*e.w,s=this.m12*e.x+this.m22*e.y+this.m32*e.z+this.m42*e.w,n=this.m13*e.x+this.m23*e.y+this.m33*e.z+this.m43*e.w,o=this.m14*e.x+this.m24*e.y+this.m34*e.z+this.m44*e.w;return e instanceof DOMPoint?new DOMPoint(r,s,n,o):{x:r,y:s,z:n,w:o}}}I(P,"Translate",Ke),I(P,"Rotate",We),I(P,"RotateAxisAngle",Xe),I(P,"Scale",Ye),I(P,"SkewX",et),I(P,"SkewY",tt),I(P,"Skew",de),I(P,"Multiply",B),I(P,"fromArray",oe),I(P,"fromMatrix",Ge),I(P,"fromString",Je),I(P,"toArray",Le),I(P,"isCompatibleArray",Fe),I(P,"isCompatibleObject",Ue);const Z=(t,e,r)=>{const[s,n]=t,[o,i]=e;return[s+(o-s)*r,n+(i-n)*r]},xe=(t,e)=>Math.sqrt((t[0]-e[0])*(t[0]-e[0])+(t[1]-e[1])*(t[1]-e[1])),re=(t,e,r,s)=>xe([t,e],[r,s]),Oe=(t,e,r,s,n)=>{let o={x:t,y:e};if(typeof n=="number"){const i=xe([t,e],[r,s]);if(n<=0)o={x:t,y:e};else if(n>=i)o={x:r,y:s};else{const[l,c]=Z([t,e],[r,s],n/i);o={x:l,y:c}}}return o},Te=(t,e,r,s)=>{const{min:n,max:o}=Math;return[n(t,r),n(e,s),o(t,r),o(e,s)]},_t=Object.freeze(Object.defineProperty({__proto__:null,getLineBBox:Te,getLineLength:re,getPointAtLineLength:Oe},Symbol.toStringTag,{value:"Module"})),Ve=(t,e,r)=>{const s=r/2,n=Math.sin(s),o=Math.cos(s),i=t**2*n**2,l=e**2*o**2,c=Math.sqrt(i+l)*r;return Math.abs(c)},J=(t,e,r,s,n,o)=>{const{sin:i,cos:l}=Math,c=l(n),a=i(n),m=r*l(o),h=s*i(o);return[t+c*m-a*h,e+a*m+c*h]},ve=(t,e)=>{const{x:r,y:s}=t,{x:n,y:o}=e,i=r*n+s*o,l=Math.sqrt((r**2+s**2)*(n**2+o**2));return(r*o-s*n<0?-1:1)*Math.acos(i/l)},pe=(t,e,r,s,n,o,i,l,c)=>{const{abs:a,sin:m,cos:h,sqrt:f,PI:y}=Math;let u=a(r),g=a(s);const b=(n%360+360)%360*(y/180);if(t===l&&e===c)return{rx:u,ry:g,startAngle:0,endAngle:0,center:{x:l,y:c}};if(u===0||g===0)return{rx:u,ry:g,startAngle:0,endAngle:0,center:{x:(l+t)/2,y:(c+e)/2}};const M=(t-l)/2,d=(e-c)/2,x={x:h(b)*M+m(b)*d,y:-m(b)*M+h(b)*d},A=x.x**2/u**2+x.y**2/g**2;A>1&&(u*=f(A),g*=f(A));const S=u**2*g**2-u**2*x.y**2-g**2*x.x**2,j=u**2*x.y**2+g**2*x.x**2;let $=S/j;$=$<0?0:$;const L=(o!==i?1:-1)*f($),N={x:L*(u*x.y/g),y:L*(-(g*x.x)/u)},R={x:h(b)*N.x-m(b)*N.y+(t+l)/2,y:m(b)*N.x+h(b)*N.y+(e+c)/2},U={x:(x.x-N.x)/u,y:(x.y-N.y)/g},z=ve({x:1,y:0},U),C={x:(-x.x-N.x)/u,y:(-x.y-N.y)/g};let q=ve(U,C);!i&&q>0?q-=2*y:i&&q<0&&(q+=2*y),q%=2*y;const Q=z+q;return{center:R,startAngle:z,endAngle:Q,rx:u,ry:g}},_e=(t,e,r,s,n,o,i,l,c)=>{const{rx:a,ry:m,startAngle:h,endAngle:f}=pe(t,e,r,s,n,o,i,l,c);return Ve(a,m,f-h)},nt=(t,e,r,s,n,o,i,l,c,a)=>{let m={x:t,y:e};const{center:h,rx:f,ry:y,startAngle:u,endAngle:g}=pe(t,e,r,s,n,o,i,l,c);if(typeof a=="number"){const p=Ve(f,y,g-u);if(a<=0)m={x:t,y:e};else if(a>=p)m={x:l,y:c};else{if(t===l&&e===c)return{x:l,y:c};if(f===0||y===0)return Oe(t,e,l,c,a);const{PI:b,cos:M,sin:d}=Math,x=g-u,S=(n%360+360)%360*(b/180),j=u+x*(a/p),$=f*M(j),L=y*d(j);m={x:M(S)*$-d(S)*L+h.x,y:d(S)*$+M(S)*L+h.y}}}return m},rt=(t,e,r,s,n,o,i,l,c)=>{const{center:a,rx:m,ry:h,startAngle:f,endAngle:y}=pe(t,e,r,s,n,o,i,l,c),u=y-f,{min:g,max:p,tan:b,atan2:M,PI:d}=Math,{x,y:A}=a,S=n*d/180,j=b(S),$=M(-h*j,m),L=$,N=$+d,R=M(h,m*j),U=R+d,z=[l],C=[c];let q=g(t,l),Q=p(t,l),E=g(e,c),D=p(e,c);const W=y-u*1e-5,G=J(x,A,m,h,S,W),w=y-u*.99999,k=J(x,A,m,h,S,w);if(G[0]>Q||k[0]>Q){const T=J(x,A,m,h,S,L);z.push(T[0]),C.push(T[1])}if(G[0]D||k[1]>D){const T=J(x,A,m,h,S,R);z.push(T[0]),C.push(T[1])}return q=g.apply([],z),E=g.apply([],C),Q=p.apply([],z),D=p.apply([],C),[q,E,Q,D]},Rt=Object.freeze(Object.defineProperty({__proto__:null,angleBetween:ve,arcLength:Ve,arcPoint:J,getArcBBox:rt,getArcLength:_e,getArcProps:pe,getPointAtArcLength:nt},Symbol.toStringTag,{value:"Module"})),je=[-.06405689286260563,.06405689286260563,-.1911188674736163,.1911188674736163,-.3150426796961634,.3150426796961634,-.4337935076260451,.4337935076260451,-.5454214713888396,.5454214713888396,-.6480936519369755,.6480936519369755,-.7401241915785544,.7401241915785544,-.820001985973903,.820001985973903,-.8864155270044011,.8864155270044011,-.9382745520027328,.9382745520027328,-.9747285559713095,.9747285559713095,-.9951872199970213,.9951872199970213],st=[.12793819534675216,.12793819534675216,.1258374563468283,.1258374563468283,.12167047292780339,.12167047292780339,.1155056680537256,.1155056680537256,.10744427011596563,.10744427011596563,.09761865210411388,.09761865210411388,.08619016153195327,.08619016153195327,.0733464814110803,.0733464814110803,.05929858491543678,.05929858491543678,.04427743881741981,.04427743881741981,.028531388628933663,.028531388628933663,.0123412297999872,.0123412297999872],ot=t=>{const e=[];for(let r=t,s=r.length,n=s-1;s>1;s-=1,n-=1){const o=[];for(let i=0;i{if(e===0)return t[0].t=0,t[0];const r=t.length-1;if(e===1)return t[r].t=1,t[r];const s=1-e;let n=t;if(r===0)return t[0].t=e,t[0];if(r===1)return{x:s*n[0].x+e*n[1].x,y:s*n[0].y+e*n[1].y,t:e};const o=s*s,i=e*e;let l=0,c=0,a=0,m=0;return r===2?(n=[n[0],n[1],n[2],{x:0,y:0}],l=o,c=s*e*2,a=i):r===3&&(l=o*s,c=o*e*3,a=s*i*3,m=e*i),{x:l*n[0].x+c*n[1].x+a*n[2].x+m*n[3].x,y:l*n[0].y+c*n[1].y+a*n[2].y+m*n[3].y,t:e}},ct=(t,e)=>{const r=t(e),s=r.x*r.x+r.y*r.y;return Math.sqrt(s)},lt=t=>{const r=je.length;let s=0;for(let n=0,o;n{const e=[];for(let s=0,n=t.length,o=2;sit(r[0],s))},at=1e-8,ue=([t,e,r])=>{const s=Math.min(t,r),n=Math.max(t,r);if(e>=t?r>=e:r<=e)return[s,n];const o=(t*r-e*e)/(t-2*e+r);return o{const n=t-3*e+3*r-s;if(Math.abs(n)0&&m<1){const f=t*(1-m)*(1-m)*(1-m)+e*3*(1-m)*(1-m)*m+r*3*(1-m)*m*m+s*m*m*m;fc&&(c=f)}return[l,c]},Qt=Object.freeze(Object.defineProperty({__proto__:null,CBEZIER_MINMAX_EPSILON:at,Cvalues:st,Tvalues:je,bezierLength:lt,calculateBezier:ct,computeBezier:it,deriveBezier:ot,getBezierLength:ie,minmaxC:$e,minmaxQ:ue},Symbol.toStringTag,{value:"Module"})),mt=([t,e,r,s,n,o,i,l],c)=>{const a=1-c;return{x:a**3*t+3*a**2*c*r+3*a*c**2*n+c**3*i,y:a**3*e+3*a**2*c*s+3*a*c**2*o+c**3*l}},he=(t,e,r,s,n,o,i,l)=>ie([t,e,r,s,n,o,i,l]),ut=(t,e,r,s,n,o,i,l,c)=>{const a=typeof c=="number";let m={x:t,y:e};if(a){const h=ie([t,e,r,s,n,o,i,l]);c<=0||(c>=h?m={x:i,y:l}:m=mt([t,e,r,s,n,o,i,l],c/h))}return m},ze=(t,e,r,s,n,o,i,l)=>{const c=$e([t,r,n,i]),a=$e([e,s,o,l]);return[c[0],a[0],c[1],a[1]]},Zt=Object.freeze(Object.defineProperty({__proto__:null,getCubicBBox:ze,getCubicLength:he,getPointAtCubicLength:ut,getPointAtCubicSegmentLength:mt},Symbol.toStringTag,{value:"Module"})),ht=([t,e,r,s,n,o],i)=>{const l=1-i;return{x:l**2*t+2*l*i*r+i**2*n,y:l**2*e+2*l*i*s+i**2*o}},fe=(t,e,r,s,n,o)=>ie([t,e,r,s,n,o]),ft=(t,e,r,s,n,o,i)=>{const l=typeof i=="number";let c={x:t,y:e};if(l){const a=ie([t,e,r,s,n,o]);i<=0||(i>=a?c={x:n,y:o}:c=ht([t,e,r,s,n,o],i/a))}return c},qe=(t,e,r,s,n,o)=>{const i=ue([t,r,n]),l=ue([e,s,o]);return[i[0],l[0],i[1],l[1]]},Dt=Object.freeze(Object.defineProperty({__proto__:null,getPointAtQuadLength:ft,getPointAtQuadSegmentLength:ht,getQuadBBox:qe,getQuadLength:fe},Symbol.toStringTag,{value:"Module"})),Bt=t=>{const e=t.length;let r=-1,s,n=t[e-1],o=0;for(;++rt.reduce((e,r,s)=>s?e+xe(t[s-1],r):0,0),Ft=Object.freeze(Object.defineProperty({__proto__:null,polygonArea:Bt,polygonLength:Ht},Symbol.toStringTag,{value:"Module"})),X={a:7,c:6,h:1,l:2,m:2,r:4,q:4,s:4,t:2,v:1,z:0},ke=t=>{let e=t.pathValue[t.segmentStart],r=e.toLowerCase();const{data:s}=t;for(;s.length>=X[r]&&(r==="m"&&s.length>2?(t.segments.push([e].concat(s.splice(0,2))),r="l",e=e==="m"?"l":"L"):t.segments.push([e].concat(s.splice(0,X[r]))),!!X[r]););},O="SVGPathCommander Error",yt=t=>{const{index:e,pathValue:r}=t,s=r.charCodeAt(e);if(s===48){t.param=0,t.index+=1;return}if(s===49){t.param=1,t.index+=1;return}t.err=`${O}: invalid Arc flag "${r[e]}", expecting 0 or 1 at index ${e}`},H=t=>t>=48&&t<=57,F="Invalid path value",gt=t=>{const{max:e,pathValue:r,index:s}=t;let n=s,o=!1,i=!1,l=!1,c=!1,a;if(n>=e){t.err=`${O}: ${F} at index ${n}, "pathValue" is missing param`;return}if(a=r.charCodeAt(n),(a===43||a===45)&&(n+=1,a=r.charCodeAt(n)),!H(a)&&a!==46){t.err=`${O}: ${F} at index ${n}, "${r[n]}" is not a number`;return}if(a!==46){if(o=a===48,n+=1,a=r.charCodeAt(n),o&&n[5760,6158,8192,8193,8194,8195,8196,8197,8198,8199,8200,8201,8202,8239,8287,12288,65279,10,13,8232,8233,32,9,11,12,160].includes(t),Y=t=>{const{pathValue:e,max:r}=t;for(;t.index{switch(t|32){case 109:case 122:case 108:case 104:case 118:case 99:case 115:case 113:case 116:case 97:return!0;default:return!1}},pt=t=>H(t)||t===43||t===45||t===46,bt=t=>(t|32)===97,Mt=t=>{switch(t|32){case 109:case 77:return!0;default:return!1}},Re=t=>{var c;const{max:e,pathValue:r,index:s,segments:n}=t,o=r.charCodeAt(s),i=X[r[s].toLowerCase()];if(t.segmentStart=s,!xt(o)){t.err=`${O}: ${F} "${r[s]}" is not a path command at index ${s}`;return}const l=n[n.length-1];if(!Mt(o)&&((c=l==null?void 0:l[0])==null?void 0:c.toLocaleLowerCase())==="z"){t.err=`${O}: ${F} "${r[s]}" is not a MoveTo path command at index ${s}`;return}if(t.index+=1,Y(t),t.data=[],!i){ke(t);return}for(;;){for(let a=i;a>0;a-=1){if(bt(o)&&(a===3||a===4)?yt(t):gt(t),t.err.length)return;t.data.push(t.param),Y(t),t.index=t.max||!pt(r.charCodeAt(t.index)))break}ke(t)};class Qe{constructor(e){this.segments=[],this.pathValue=e,this.max=e.length,this.index=0,this.param=0,this.segmentStart=0,this.data=[],this.err=""}}const V=t=>{if(typeof t!="string")return t.slice(0);const e=new Qe(t);for(Y(e);e.index{const[n]=t,o=n.toUpperCase();if(e===0||o===n)return t;if(o==="A")return[o,t[1],t[2],t[3],t[4],t[5],t[6]+r,t[7]+s];if(o==="V")return[o,t[1]+s];if(o==="H")return[o,t[1]+r];if(o==="L")return[o,t[1]+r,t[2]+s];{const l=[],c=t.length;for(let a=1;a{let r=t.length,s,n="M",o="M",i=!1,l=0,c=0,a=0,m=0,h=0;for(let f=0;f{const e=V(t);return _(e,ce)},Ze=(t,e,r,s)=>{const[n]=t,o=n.toLowerCase();if(e===0||n===o)return t;if(o==="a")return[o,t[1],t[2],t[3],t[4],t[5],t[6]-r,t[7]-s];if(o==="v")return[o,t[1]-s];if(o==="h")return[o,t[1]-r];if(o==="l")return[o,t[1]-r,t[2]-s];{const l=[],c=t.length;for(let a=1;a{const e=V(t);return _(e,Ze)},te=(t,e,r)=>{const{sin:s,cos:n}=Math,o=t*n(r)-e*s(r),i=t*s(r)+e*n(r);return{x:o,y:i}},Me=(t,e,r,s,n,o,i,l,c,a)=>{let m=t,h=e,f=r,y=s,u=l,g=c;const p=Math.PI*120/180,b=Math.PI/180*(+n||0);let M=[],d,x,A,S,j;if(a)[x,A,S,j]=a;else{d=te(m,h,-b),m=d.x,h=d.y,d=te(u,g,-b),u=d.x,g=d.y;const w=(m-u)/2,k=(h-g)/2;let T=w*w/(f*f)+k*k/(y*y);T>1&&(T=Math.sqrt(T),f*=T,y*=T);const Ne=f*f,we=y*y,He=(o===i?-1:1)*Math.sqrt(Math.abs((Ne*we-Ne*k*k-we*w*w)/(Ne*k*k+we*w*w)));S=He*f*k/y+(m+u)/2,j=He*-y*w/f+(h+g)/2,x=Math.asin(((h-j)/y*10**9>>0)/10**9),A=Math.asin(((g-j)/y*10**9>>0)/10**9),x=mA&&(x-=Math.PI*2),!i&&A>x&&(A-=Math.PI*2)}let $=A-x;if(Math.abs($)>p){const w=A,k=u,T=g;A=x+p*(i&&A>x?1:-1),u=S+f*Math.cos(A),g=j+y*Math.sin(A),M=Me(u,g,f,y,n,0,i,k,T,[A,w,S,j])}$=A-x;const L=Math.cos(x),N=Math.sin(x),R=Math.cos(A),U=Math.sin(A),z=Math.tan($/4),C=4/3*f*z,q=4/3*y*z,Q=[m,h],E=[m+C*N,h-q*L],D=[u+C*U,g-q*R],W=[u,g];if(E[0]=2*Q[0]-E[0],E[1]=2*Q[1]-E[1],a)return[E[0],E[1],D[0],D[1],W[0],W[1]].concat(M);M=[E[0],E[1],D[0],D[1],W[0],W[1]].concat(M);const G=[];for(let w=0,k=M.length;w{const i=.3333333333333333,l=2/3;return[i*t+l*r,i*e+l*s,i*n+l*r,i*o+l*s,n,o]},Ie=(t,e,r,s)=>{const n=Z([t,e],[r,s],.3333333333333333),o=Z([t,e],[r,s],2/3);return[n[0],n[1],o[0],o[1],r,s]},St=(t,e)=>{const[r]=t,s=t.slice(1).map(Number),[n,o]=s,{x1:i,y1:l,x:c,y:a}=e;return"TQ".includes(r)||(e.qx=null,e.qy=null),r==="M"?(e.x=n,e.y=o,t):r==="A"?["C"].concat(Me(i,l,s[0],s[1],s[2],s[3],s[4],s[5],s[6])):r==="Q"?(e.qx=n,e.qy=o,["C"].concat(Ct(i,l,s[0],s[1],s[2],s[3]))):r==="L"?["C"].concat(Ie(i,l,n,o)):r==="Z"?["C"].concat(Ie(i,l,c,a)):t},Ae=(t,e)=>{const[r]=t,s=r.toUpperCase(),n=r!==s,{x1:o,y1:i,x2:l,y2:c,x:a,y:m}=e,h=t.slice(1);let f=h.map((y,u)=>y+(n?u%2?m:a:0));if("TQ".includes(s)||(e.qx=null,e.qy=null),s==="A")return f=h.slice(0,-2).concat(h[5]+(n?a:0),h[6]+(n?m:0)),["A"].concat(f);if(s==="H")return["L",t[1]+(n?a:0),i];if(s==="V")return["L",o,t[1]+(n?m:0)];if(s==="L")return["L",t[1]+(n?a:0),t[2]+(n?m:0)];if(s==="M")return["M",t[1]+(n?a:0),t[2]+(n?m:0)];if(s==="C")return["C"].concat(f);if(s==="S"){const y=o*2-l,u=i*2-c;return e.x1=y,e.y1=u,["C",y,u].concat(f)}else if(s==="T"){const y=o*2-(e.qx?e.qx:0),u=i*2-(e.qy?e.qy:0);return e.qx=y,e.qy=u,["Q",y,u].concat(f)}else if(s==="Q"){const[y,u]=f;return e.qx=y,e.qy=u,["Q"].concat(f)}else if(s==="Z")return["Z"];return t},le={x1:0,y1:0,x2:0,y2:0,x:0,y:0,qx:null,qy:null},Ce=t=>{const e={...le},r=V(t);return _(r,(s,n,o,i)=>{e.x=o,e.y=i;const l=Ae(s,e);let c=St(l,e);c[0]==="C"&&c.length>7&&(r.splice(n+1,0,["C"].concat(c.slice(7))),c=c.slice(0,7));const m=c.length;return e.x1=+c[m-2],e.y1=+c[m-1],e.x2=+c[m-4]||e.x1,e.y2=+c[m-3]||e.y1,c})},K={origin:[0,0,0],round:4},v=(t,e)=>{const r=e>=1?10**e:1;return e>0?Math.round(t*r)/r:Math.round(t)},De=(t,e)=>{const r=t.length;let{round:s}=K,n=t[0],o="";s=e==="off"||typeof e=="number"&&e>=0?e:typeof s=="number"&&s>=0?s:"off";for(let i=0;i{const e=V(t),r={...le};return _(e,(s,n,o,i)=>{r.x=o,r.y=i;const l=Ae(s,r),c=l.length;return r.x1=+l[c-2],r.y1=+l[c-1],r.x2=+l[c-4]||r.x1,r.y2=+l[c-3]||r.y1,l})},ne=(t,e)=>{const r=ae(t);let s=!1,n=[],o="M",i=0,l=0,[c,a]=r[0].slice(1);const m=typeof e=="number";let h={x:c,y:a},f=0,y=h,u=0;return!m||e{if([o]=g,s=o==="M",n=s?n:[b,M].concat(g.slice(1)),s?([,c,a]=g,h={x:c,y:a},f=0):o==="L"?(h=Oe(n[0],n[1],n[2],n[3],e-u),f=re(n[0],n[1],n[2],n[3])):o==="A"?(h=nt(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7],n[8],e-u),f=_e(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7],n[8])):o==="C"?(h=ut(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7],e-u),f=he(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7])):o==="Q"?(h=ft(n[0],n[1],n[2],n[3],n[4],n[5],e-u),f=fe(n[0],n[1],n[2],n[3],n[4],n[5])):o==="Z"&&(n=[b,M,c,a],h={x:c,y:a},f=re(n[0],n[1],n[2],n[3])),[i,l]=n.slice(-2),uu-ye?{x:i,y:l}:y)},ee=t=>{const e=V(t);let r=0,s=0,n=0,o=0,i=0,l=0,c="M",a=0,m=0,h=0;return _(e,(f,y,u,g)=>{[c]=f;const p=c.toUpperCase(),M=p!==c?ce(f,y,u,g):f.slice(0),d=p==="V"?["L",u,M[1]]:p==="H"?["L",M[1],g]:M;if([c]=d,"TQ".includes(p)||(i=0,l=0),c==="M")[,a,m]=d;else if(c==="L")h+=re(u,g,d[1],d[2]);else if(c==="A")h+=_e(u,g,d[1],d[2],d[3],d[4],d[5],d[6],d[7]);else if(c==="S"){const x=r*2-n,A=s*2-o;h+=he(u,g,x,A,d[1],d[2],d[3],d[4])}else c==="C"?h+=he(u,g,d[1],d[2],d[3],d[4],d[5],d[6]):c==="T"?(i=r*2-i,l=s*2-l,h+=fe(u,g,i,l,d[1],d[2])):c==="Q"?(i=d[1],l=d[2],h+=fe(u,g,d[1],d[2],d[3],d[4])):c==="Z"&&(h+=re(u,g,a,m));[r,s]=c==="Z"?[a,m]:d.slice(-2),[n,o]=c==="C"?[d[3],d[4]]:c==="S"?[d[1],d[2]]:[r,s]}),h},Be=(t,e)=>{const r=V(t);let s=r.slice(0),n=ee(s),o=s.length-1,i=0,l=0,c=r[0];if(o<=0||!e||!Number.isFinite(e))return{segment:c,index:0,length:l,lengthAtSegment:i};if(e>=n)return s=r.slice(0,-1),i=ee(s),l=n-i,c=r[o],{segment:c,index:o,length:l,lengthAtSegment:i};const a=[];for(;o>0;)c=s[o],s=s.slice(0,-1),i=ee(s),l=n-i,n=i,a.push({segment:c,index:o,length:l,lengthAtSegment:i}),o-=1;return a.find(({lengthAtSegment:m})=>m<=e)},Se=(t,e)=>{const r=V(t),s=ae(r),n=ee(s),o=x=>{const A=x.x-e.x,S=x.y-e.y;return A*A+S*S};let i=8,l,c={x:0,y:0},a=0,m=0,h=1/0;for(let x=0;x<=n;x+=i)l=ne(s,x),a=o(l),a1e-6&&(u=m-i,f=ne(s,u),p=o(f),g=m+i,y=ne(s,g),b=o(y),u>=0&&pSe(t,e).closest,Gt=(t,e,r,s,n,o,i,l)=>3*((l-e)*(r+n)-(i-t)*(s+o)+s*(t-n)-r*(e-o)+l*(n+t/3)-i*(o+e/3))/20,Pt=t=>{let e=0,r=0,s=0;return Ce(t).map(n=>{switch(n[0]){case"M":return[,e,r]=n,0;default:return s=Gt(e,r,n[1],n[2],n[3],n[4],n[5],n[6]),[e,r]=n.slice(-2),s}}).reduce((n,o)=>n+o,0)},Jt=t=>Pt(Ce(t))>=0,Nt=t=>{if(!t)return{x:0,y:0,width:0,height:0,x2:0,y2:0,cx:0,cy:0,cz:0};const e=V(t);let r="M",s=0,n=0;const{max:o,min:i}=Math;let l=1/0,c=1/0,a=-1/0,m=-1/0,h=0,f=0,y=0,u=0,g=0,p=0,b=0,M=0,d=0,x=0;_(e,(j,$,L,N)=>{[r]=j;const R=r.toUpperCase(),z=R!==r?ce(j,$,L,N):j.slice(0),C=R==="V"?["L",L,z[1]]:R==="H"?["L",z[1],N]:z;if([r]=C,"TQ".includes(R)||(d=0,x=0),r==="M")[,s,n]=C,h=s,f=n,y=s,u=n;else if(r==="L")[h,f,y,u]=Te(L,N,C[1],C[2]);else if(r==="A")[h,f,y,u]=rt(L,N,C[1],C[2],C[3],C[4],C[5],C[6],C[7]);else if(r==="S"){const q=g*2-b,Q=p*2-M;[h,f,y,u]=ze(L,N,q,Q,C[1],C[2],C[3],C[4])}else r==="C"?[h,f,y,u]=ze(L,N,C[1],C[2],C[3],C[4],C[5],C[6]):r==="T"?(d=g*2-d,x=p*2-x,[h,f,y,u]=qe(L,N,d,x,C[1],C[2])):r==="Q"?(d=C[1],x=C[2],[h,f,y,u]=qe(L,N,C[1],C[2],C[3],C[4])):r==="Z"&&([h,f,y,u]=Te(L,N,s,n));l=i(h,l),c=i(f,c),a=o(y,a),m=o(u,m),[g,p]=r==="Z"?[s,n]:C.slice(-2),[b,M]=r==="C"?[C[3],C[4]]:r==="S"?[C[1],C[2]]:[g,p]});const A=a-l,S=m-c;return{width:A,height:S,x:l,y:c,x2:a,y2:m,cx:l+A/2,cy:c+S/2,cz:Math.max(A,S)+Math.min(A,S)/2}},Kt=(t,e)=>Be(t,e).segment,Wt=(t,e)=>Se(t,e).segment,Pe=t=>Array.isArray(t)&&t.every(e=>{const r=e[0].toLowerCase();return X[r]===e.length-1&&"achlmqstvz".includes(r)&&e.slice(1).every(Number.isFinite)})&&t.length>0,wt=t=>Pe(t)&&t.every(([e])=>e===e.toUpperCase()),Lt=t=>wt(t)&&t.every(([e])=>"ACLMQZ".includes(e)),Xt=t=>Lt(t)&&t.every(([e])=>"MC".includes(e)),Yt=(t,e)=>{const{distance:r}=Se(t,e);return Math.abs(r)Pe(t)&&t.slice(1).every(([e])=>e===e.toLowerCase()),Tt=t=>{if(typeof t!="string"||!t.length)return!1;const e=new Qe(t);for(Y(e);e.indext!=null&&typeof t=="object"&&t.nodeType===1,tn=t=>{let{x1:e,y1:r,x2:s,y2:n}=t;return[e,r,s,n]=[e,r,s,n].map(o=>+o),[["M",e,r],["L",s,n]]},nn=t=>{const e=[],r=(t.points||"").trim().split(/[\s|,]/).map(n=>+n);let s=0;for(;s{let{cx:e,cy:r,r:s}=t;return[e,r,s]=[e,r,s].map(n=>+n),[["M",e-s,r],["a",s,s,0,1,0,2*s,0],["a",s,s,0,1,0,-2*s,0]]},sn=t=>{let{cx:e,cy:r}=t,s=t.rx||0,n=t.ry||s;return[e,r,s,n]=[e,r,s,n].map(o=>+o),[["M",e-s,r],["a",s,n,0,1,0,2*s,0],["a",s,n,0,1,0,-2*s,0]]},on=t=>{const e=+t.x||0,r=+t.y||0,s=+t.width,n=+t.height;let o=+(t.rx||0),i=+(t.ry||o);return o||i?(o*2>s&&(o-=(o*2-s)/2),i*2>n&&(i-=(i*2-n)/2),[["M",e+o,r],["h",s-o*2],["s",o,0,o,i],["v",n-i*2],["s",0,i,-o,i],["h",-s+o*2],["s",-o,0,-o,-i],["v",-n+i*2],["s",0,-i,o,-i]]):[["M",e,r],["h",s],["v",n],["H",e],["Z"]]},jt=t=>{const e=Object.keys(se),r=vt(t),s=r?t.tagName:null;if(s&&[...e,"path"].every(c=>s!==c))throw TypeError(`${O}: "${s}" is not SVGElement`);const n=r?s:t.type,o=se[n],i={type:n};r?o.forEach(c=>{i[c]=t.getAttribute(c)}):Object.assign(i,t);let l=[];return n==="circle"?l=rn(i):n==="ellipse"?l=sn(i):["polyline","polygon"].includes(n)?l=nn(i):n==="rect"?l=on(i):n==="line"?l=tn(i):["glyph","path"].includes(n)&&(l=V(r?t.getAttribute("d")||"":t.d||"")),Pe(l)&&l.length?l:!1},cn=(t,e,r)=>{const s=r||document,n=Object.keys(se),o=vt(t),i=o?t.tagName:null;if(i==="path")throw TypeError(`${O}: "${i}" is already SVGPathElement`);if(i&&n.every(u=>i!==u))throw TypeError(`${O}: "${i}" is not SVGElement`);const l=s.createElementNS("http://www.w3.org/2000/svg","path"),c=o?i:t.type,a=se[c],m={type:c},h=K.round,f=jt(t),y=f&&f.length?De(f,h):"";return o?(a.forEach(u=>{m[u]=t.getAttribute(u)}),Object.values(t.attributes).forEach(({name:u,value:g})=>{a.includes(u)||l.setAttribute(u,g)})):(Object.assign(m,t),Object.keys(m).forEach(u=>{!a.includes(u)&&u!=="type"&&l.setAttribute(u.replace(/[A-Z]/g,g=>`-${g.toLowerCase()}`),m[u])})),Tt(y)?(l.setAttribute("d",y),e&&o&&(t.before(l,t),t.remove()),l):!1},$t=t=>{let e=new P;const{origin:r}=t,[s,n]=r,{translate:o}=t,{rotate:i}=t,{skew:l}=t,{scale:c}=t;return Array.isArray(o)&&o.length>=2&&o.every(a=>!Number.isNaN(+a))&&o.some(a=>a!==0)?e=e.translate(...o):typeof o=="number"&&!Number.isNaN(o)&&(e=e.translate(o)),(i||l||c)&&(e=e.translate(s,n),Array.isArray(i)&&i.length>=2&&i.every(a=>!Number.isNaN(+a))&&i.some(a=>a!==0)?e=e.rotate(...i):typeof i=="number"&&!Number.isNaN(i)&&(e=e.rotate(i)),Array.isArray(l)&&l.length===2&&l.every(a=>!Number.isNaN(+a))&&l.some(a=>a!==0)?(e=l[0]?e.skewX(l[0]):e,e=l[1]?e.skewY(l[1]):e):typeof l=="number"&&!Number.isNaN(l)&&(e=e.skewX(l)),Array.isArray(c)&&c.length>=2&&c.every(a=>!Number.isNaN(+a))&&c.some(a=>a!==1)?e=e.scale(...c):typeof c=="number"&&!Number.isNaN(c)&&(e=e.scale(c)),e=e.translate(-s,-n)),e},zt=(t,e,r,s)=>{const[n]=t,{round:o}=K,i=o,l=e.slice(1),{x1:c,y1:a,x2:m,y2:h,x:f,y}=r,[u,g]=l.slice(-2),p=t;if("TQ".includes(n)||(r.qx=null,r.qy=null),n==="L"){if(v(f,i)===v(u,i))return["V",g];if(v(y,i)===v(g,i))return["H",u]}else if(n==="C"){const[b,M]=l;if(r.x1=b,r.y1=M,"CS".includes(s)&&(v(b,i)===v(c*2-m,i)&&v(M,i)===v(a*2-h,i)||v(c,i)===v(m*2-f,i)&&v(a,i)===v(h*2-y,i)))return["S",l[2],l[3],l[4],l[5]]}else if(n==="Q"){const[b,M]=l;if(r.qx=b,r.qy=M,"QT".includes(s)&&v(b,i)===v(c*2-m,i)&&v(M,i)===v(a*2-h,i))return["T",l[2],l[3]]}return p},ge=(t,e)=>{const r=t.slice(1).map(s=>v(s,e));return[t[0]].concat(r)},qt=(t,e)=>{const r=be(t),s=typeof e=="number"&&e>=0?e:2,n={...le},o=[];let i="M",l="Z";return _(r,(c,a,m,h)=>{n.x=m,n.y=h;const f=Ae(c,n);let y=c;if([i]=c,o[a]=i,a){l=o[a-1];const g=zt(c,f,n,l),p=ge(g,s),b=p.join(""),M=Ze(g,a,m,h),d=ge(M,s),x=d.join("");y=b.length{let r=P.Translate(e[0],e[1],e[2]);return[,,,r.m44]=e,r=t.multiply(r),[r.m41,r.m42,r.m43,r.m44]},Ee=(t,e,r)=>{const[s,n,o]=r,[i,l,c]=ln(t,[e[0],e[1],0,1]),a=i-s,m=l-n,h=c-o;return[a*(Math.abs(o)/Math.abs(h)||1)+s,m*(Math.abs(o)/Math.abs(h)||1)+n]},an=t=>{const e=t.slice(1).map((r,s,n)=>s?n[s-1].slice(-2).concat(r.slice(1)):t[0].slice(1).concat(r.slice(1))).map(r=>r.map((s,n)=>r[r.length-n-2*(1-n%2)])).reverse();return[["M"].concat(e[0].slice(0,2))].concat(e.map(r=>["C"].concat(r.slice(2))))},me=t=>{const e=be(t),r=ae(e),s=e.length,n=e[s-1][0]==="Z",o=_(e,(i,l)=>{const c=r[l],a=l&&e[l-1],m=a&&a[0],h=e[l+1],f=h&&h[0],[y]=i,[u,g]=r[l?l-1:s-1].slice(-2);let p=i;switch(y){case"M":p=n?["Z"]:[y,u,g];break;case"A":p=[y,i[1],i[2],i[3],i[4],i[5]===1?0:1,u,g];break;case"C":h&&f==="S"?p=["S",i[1],i[2],u,g]:p=[y,i[3],i[4],i[1],i[2],u,g];break;case"S":m&&"CS".includes(m)&&(!h||f!=="S")?p=["C",c[3],c[4],c[1],c[2],u,g]:p=[y,c[1],c[2],u,g];break;case"Q":h&&f==="T"?p=["T",u,g]:p=[y,i[1],i[2],u,g];break;case"T":m&&"QT".includes(m)&&(!h||f!=="T")?p=["Q",c[1],c[2],u,g]:p=[y,u,g];break;case"Z":p=["M",u,g];break;case"H":p=[y,u];break;case"V":p=[y,g];break;default:p=[y].concat(i.slice(1,-2),u,g)}return p});return n?o.reverse():[o[0]].concat(o.slice(1).reverse())},mn=(t,e)=>{let{round:r}=K;return r=e==="off"||typeof e=="number"&&e>=0?e:typeof r=="number"&&r>=0?r:"off",r==="off"?t.slice(0):_(t,s=>ge(s,r))},un=(t,e=.5)=>{const r=e,s=t.slice(0,2),n=t.slice(2,4),o=t.slice(4,6),i=t.slice(6,8),l=Z(s,n,r),c=Z(n,o,r),a=Z(o,i,r),m=Z(l,c,r),h=Z(c,a,r),f=Z(m,h,r);return[["C",l[0],l[1],m[0],m[1],f[0],f[1]],["C",h[0],h[1],a[0],a[1],i[0],i[1]]]},kt=t=>{const e=[];let r,s=-1,n=0,o=0,i=0,l=0;const c={...le};return t.forEach(a=>{const[m]=a,h=m.toUpperCase(),f=m.toLowerCase(),y=m===f,u=a.slice(1);h==="M"?(s+=1,[n,o]=u,n+=y?c.x:0,o+=y?c.y:0,i=n,l=o,r=[y?[h,i,l]:a]):(h==="Z"?(n=i,o=l):h==="H"?([,n]=a,n+=y?c.x:0):h==="V"?([,o]=a,o+=y?c.y:0):([n,o]=a.slice(-2),n+=y?c.x:0,o+=y?c.y:0),r.push(a)),c.x=n,c.y=o,e[s]=r}),e},It=(t,e)=>{let r=0,s=0,n=0,o=0,i=0,l=0,c="M";const a=V(t),m=e&&Object.keys(e);if(!e||m&&!m.length)return a.slice(0);e.origin||Object.assign(e,{origin:K.origin});const h=e.origin,f=$t(e);return f.isIdentity?a.slice(0):_(a,(y,u,g,p)=>{[c]=y;const b=c.toUpperCase(),d=b!==c?ce(y,u,g,p):y.slice(0);let x=b==="A"?["C"].concat(Me(g,p,d[1],d[2],d[3],d[4],d[5],d[6],d[7])):b==="V"?["L",g,d[1]]:b==="H"?["L",d[1],p]:d;c=x[0];const A=c==="C"&&x.length>7,S=A?x.slice(0,7):x.slice(0);if(A&&(a.splice(u+1,0,["C"].concat(x.slice(7))),x=S),c==="L")[n,o]=Ee(f,[x[1],x[2]],h),r!==n&&s!==o?x=["L",n,o]:s===o?x=["H",n]:r===n&&(x=["V",o]);else for(i=1,l=x.length;i"u";if(n||!e.length)throw TypeError(`${O}: "pathValue" is ${n?"undefined":"empty"}`);this.segments=V(e);const{round:o,origin:i}=s;let l;Number.isInteger(o)||o==="off"?l=o:l=K.round;let c=K.origin;if(Array.isArray(i)&&i.length>=2){const[a,m,h]=i.map(Number);c=[Number.isNaN(a)?0:a,Number.isNaN(m)?0:m,Number.isNaN(h)?0:h]}return this.round=l,this.origin=c,this}get bbox(){return Nt(this.segments)}get length(){return ee(this.segments)}getBBox(){return this.bbox}getTotalLength(){return this.length}getPointAtLength(e){return ne(this.segments,e)}toAbsolute(){const{segments:e}=this;return this.segments=be(e),this}toRelative(){const{segments:e}=this;return this.segments=At(e),this}toCurve(){const{segments:e}=this;return this.segments=Ce(e),this}reverse(e){const{segments:r}=this,s=kt(r),n=s.length>1?s:!1,o=n?n.map((l,c)=>e?c?me(l):l.slice(0):me(l)):r.slice(0);let i=[];return n?i=o.flat(1):i=e?r:me(r),this.segments=i.slice(0),this}normalize(){const{segments:e}=this;return this.segments=ae(e),this}optimize(){const{segments:e}=this,r=this.round==="off"?2:this.round;return this.segments=qt(e,r),this}transform(e){if(!e||typeof e!="object"||typeof e=="object"&&!["translate","rotate","skew","scale"].some(c=>c in e))return this;const{segments:r,origin:[s,n,o]}=this,i={};for(const[c,a]of Object.entries(e))c==="skew"&&Array.isArray(a)||(c==="rotate"||c==="translate"||c==="origin"||c==="scale")&&Array.isArray(a)?i[c]=a.map(Number):c!=="origin"&&typeof Number(a)=="number"&&(i[c]=Number(a));const{origin:l}=i;if(Array.isArray(l)&&l.length>=2){const[c,a,m]=l.map(Number);i.origin=[Number.isNaN(c)?s:c,Number.isNaN(a)?n:a,m||o]}else i.origin=[s,n,o];return this.segments=It(r,i),this}flipX(){const{cx:e,cy:r}=this.bbox;return this.transform({rotate:[0,180,0],origin:[e,r,0]}),this}flipY(){const{cx:e,cy:r}=this.bbox;return this.transform({rotate:[180,0,0],origin:[e,r,0]}),this}toString(){return De(this.segments,this.round)}dispose(){Object.keys(this).forEach(e=>delete this[e])}}const yn=Object.assign(fn,hn);module.exports=yn; -//# sourceMappingURL=svg-path-commander.cjs.map +"use strict";var Ut=Object.create;var Re=Object.defineProperty;var Kt=Object.getOwnPropertyDescriptor;var Ft=Object.getOwnPropertyNames;var Jt=Object.getPrototypeOf,Wt=Object.prototype.hasOwnProperty;var X=(t,e)=>{for(var n in e)Re(t,n,{get:e[n],enumerable:!0})},Ct=(t,e,n,o)=>{if(e&&typeof e=="object"||typeof e=="function")for(let r of Ft(e))!Wt.call(t,r)&&r!==n&&Re(t,r,{get:()=>e[r],enumerable:!(o=Kt(e,r))||o.enumerable});return t};var st=(t,e,n)=>(n=t!=null?Ut(Jt(t)):{},Ct(e||!t||!t.__esModule?Re(n,"default",{value:t,enumerable:!0}):n,t)),Xt=t=>Ct(Re({},"__esModule",{value:!0}),t);var Sn={};X(Sn,{default:()=>Pn});module.exports=Xt(Sn);var Pt={};X(Pt,{CSSMatrix:()=>_t.default,absolutizeSegment:()=>_,arcToCubic:()=>Pe,arcTools:()=>ct,bezierTools:()=>ht,cubicTools:()=>gt,distanceEpsilon:()=>fe,distanceSquareRoot:()=>ie,finalizeSegment:()=>ve,getClosestPoint:()=>Vt,getDrawDirection:()=>Qt,getPathArea:()=>_e,getPathBBox:()=>Ue,getPointAtLength:()=>re,getPropertiesAtLength:()=>Ae,getPropertiesAtPoint:()=>ne,getSVGMatrix:()=>Ye,getSegmentAtLength:()=>qt,getSegmentOfPoint:()=>Et,getTotalLength:()=>F,invalidPathValue:()=>H,isAbsoluteArray:()=>Ke,isArcCommand:()=>je,isCurveArray:()=>Dt,isDigit:()=>B,isDigitStart:()=>$e,isMoveCommand:()=>Be,isNormalizedArray:()=>Fe,isPathArray:()=>oe,isPathCommand:()=>Ie,isPointInStroke:()=>Ot,isRelativeArray:()=>It,isSpace:()=>Oe,isValidPath:()=>Je,iterate:()=>M,lineToCubic:()=>Ne,lineTools:()=>mt,midPoint:()=>D,normalizePath:()=>K,normalizeSegment:()=>ee,optimizePath:()=>tt,paramsCount:()=>Z,paramsParser:()=>U,parsePathString:()=>T,pathParser:()=>W,pathToAbsolute:()=>Y,pathToCurve:()=>te,pathToRelative:()=>He,pathToString:()=>Se,polygonTools:()=>xt,projection2d:()=>we,quadToCubic:()=>Ze,quadTools:()=>dt,relativizeSegment:()=>xe,reverseCurve:()=>Ht,reversePath:()=>Ce,rotateVector:()=>ce,roundPath:()=>Zt,roundSegment:()=>he,roundTo:()=>L,scanFlag:()=>Ee,scanParam:()=>De,scanSegment:()=>de,segmentToCubic:()=>Ge,shapeParams:()=>ae,shapeToPath:()=>$t,shapeToPathArray:()=>Xe,shortenSegment:()=>et,skipSpaces:()=>G,splitCubic:()=>Gt,splitPath:()=>rt,transformPath:()=>nt});var _t=st(require("@thednp/dommatrix"),1);var ct={};X(ct,{angleBetween:()=>it,arcLength:()=>ut,arcPoint:()=>le,getArcBBox:()=>pt,getArcLength:()=>Me,getArcProps:()=>ze,getPointAtArcLength:()=>lt});var mt={};X(mt,{getLineBBox:()=>ke,getLineLength:()=>ue,getPointAtLineLength:()=>Te});var Yt=(t,e,n)=>{let[o,r]=t,[s,a]=e;return[o+(s-o)*n,r+(a-r)*n]},D=Yt;var er=(t,e)=>Math.sqrt((t[0]-e[0])*(t[0]-e[0])+(t[1]-e[1])*(t[1]-e[1])),ie=er;var ue=(t,e,n,o)=>ie([t,e],[n,o]),Te=(t,e,n,o,r)=>{let s={x:t,y:e};if(typeof r=="number"){let a=ie([t,e],[n,o]);if(r<=0)s={x:t,y:e};else if(r>=a)s={x:n,y:o};else{let[i,m]=D([t,e],[n,o],r/a);s={x:i,y:m}}}return s},ke=(t,e,n,o)=>{let{min:r,max:s}=Math;return[r(t,n),r(e,o),s(t,n),s(e,o)]};var ut=(t,e,n)=>{let o=n/2,r=Math.sin(o),s=Math.cos(o),a=t**2*r**2,i=e**2*s**2,m=Math.sqrt(a+i)*n;return Math.abs(m)},le=(t,e,n,o,r,s)=>{let{sin:a,cos:i}=Math,m=i(r),u=a(r),l=n*i(s),p=o*a(s);return[t+m*l-u*p,e+u*l+m*p]},it=(t,e)=>{let{x:n,y:o}=t,{x:r,y:s}=e,a=n*r+o*s,i=Math.sqrt((n**2+o**2)*(r**2+s**2));return(n*s-o*r<0?-1:1)*Math.acos(a/i)},ze=(t,e,n,o,r,s,a,i,m)=>{let{abs:u,sin:l,cos:p,sqrt:f,PI:h}=Math,c=u(n),b=u(o),S=(r%360+360)%360*(h/180);if(t===i&&e===m)return{rx:c,ry:b,startAngle:0,endAngle:0,center:{x:i,y:m}};if(c===0||b===0)return{rx:c,ry:b,startAngle:0,endAngle:0,center:{x:(i+t)/2,y:(m+e)/2}};let A=(t-i)/2,y=(e-m)/2,g={x:p(S)*A+l(S)*y,y:-l(S)*A+p(S)*y},x=g.x**2/c**2+g.y**2/b**2;x>1&&(c*=f(x),b*=f(x));let C=c**2*b**2-c**2*g.y**2-b**2*g.x**2,k=c**2*g.y**2+b**2*g.x**2,V=C/k;V=V<0?0:V;let w=(s!==a?1:-1)*f(V),v={x:w*(c*g.y/b),y:w*(-(b*g.x)/c)},$={x:p(S)*v.x-l(S)*v.y+(t+i)/2,y:l(S)*v.x+p(S)*v.y+(e+m)/2},se={x:(g.x-v.x)/c,y:(g.y-v.y)/b},Q=it({x:1,y:0},se),P={x:(-g.x-v.x)/c,y:(-g.y-v.y)/b},q=it(se,P);!a&&q>0?q-=2*h:a&&q<0&&(q+=2*h),q%=2*h;let j=Q+q;return{center:$,startAngle:Q,endAngle:j,rx:c,ry:b}},Me=(t,e,n,o,r,s,a,i,m)=>{let{rx:u,ry:l,startAngle:p,endAngle:f}=ze(t,e,n,o,r,s,a,i,m);return ut(u,l,f-p)},lt=(t,e,n,o,r,s,a,i,m,u)=>{let l={x:t,y:e},{center:p,rx:f,ry:h,startAngle:c,endAngle:b}=ze(t,e,n,o,r,s,a,i,m);if(typeof u=="number"){let d=ut(f,h,b-c);if(u<=0)l={x:t,y:e};else if(u>=d)l={x:i,y:m};else{if(t===i&&e===m)return{x:i,y:m};if(f===0||h===0)return Te(t,e,i,m,u);let{PI:S,cos:A,sin:y}=Math,g=b-c,C=(r%360+360)%360*(S/180),k=c+g*(u/d),V=f*A(k),w=h*y(k);l={x:A(C)*V-y(C)*w+p.x,y:y(C)*V+A(C)*w+p.y}}}return l},pt=(t,e,n,o,r,s,a,i,m)=>{let{center:u,rx:l,ry:p,startAngle:f,endAngle:h}=ze(t,e,n,o,r,s,a,i,m),c=h-f,{min:b,max:d,tan:S,atan2:A,PI:y}=Math,{x:g,y:x}=u,C=r*y/180,k=S(C),V=A(-p*k,l),w=V,v=V+y,$=A(p,l*k),se=$+y,Q=[i],P=[m],q=b(t,i),j=d(t,i),O=b(e,m),J=d(e,m),be=h-c*1e-5,me=le(g,x,l,p,C,be),N=h-c*.99999,E=le(g,x,l,p,C,N);if(me[0]>j||E[0]>j){let R=le(g,x,l,p,C,w);Q.push(R[0]),P.push(R[1])}if(me[0]J||E[1]>J){let R=le(g,x,l,p,C,$);Q.push(R[0]),P.push(R[1])}return q=b.apply([],Q),O=b.apply([],P),j=d.apply([],Q),J=d.apply([],P),[q,O,j,J]};var ht={};X(ht,{CBEZIER_MINMAX_EPSILON:()=>wt,Cvalues:()=>Tt,Tvalues:()=>ft,bezierLength:()=>Nt,calculateBezier:()=>vt,computeBezier:()=>Lt,deriveBezier:()=>Mt,getBezierLength:()=>pe,minmaxC:()=>Ve,minmaxQ:()=>Le});var ft=[-.06405689286260563,.06405689286260563,-.1911188674736163,.1911188674736163,-.3150426796961634,.3150426796961634,-.4337935076260451,.4337935076260451,-.5454214713888396,.5454214713888396,-.6480936519369755,.6480936519369755,-.7401241915785544,.7401241915785544,-.820001985973903,.820001985973903,-.8864155270044011,.8864155270044011,-.9382745520027328,.9382745520027328,-.9747285559713095,.9747285559713095,-.9951872199970213,.9951872199970213],Tt=[.12793819534675216,.12793819534675216,.1258374563468283,.1258374563468283,.12167047292780339,.12167047292780339,.1155056680537256,.1155056680537256,.10744427011596563,.10744427011596563,.09761865210411388,.09761865210411388,.08619016153195327,.08619016153195327,.0733464814110803,.0733464814110803,.05929858491543678,.05929858491543678,.04427743881741981,.04427743881741981,.028531388628933663,.028531388628933663,.0123412297999872,.0123412297999872],Mt=t=>{let e=[];for(let n=t,o=n.length,r=o-1;o>1;o-=1,r-=1){let s=[];for(let a=0;a{if(e===0)return t[0].t=0,t[0];let n=t.length-1;if(e===1)return t[n].t=1,t[n];let o=1-e,r=t;if(n===0)return t[0].t=e,t[0];if(n===1)return{x:o*r[0].x+e*r[1].x,y:o*r[0].y+e*r[1].y,t:e};let s=o*o,a=e*e,i=0,m=0,u=0,l=0;return n===2?(r=[r[0],r[1],r[2],{x:0,y:0}],i=s,m=o*e*2,u=a):n===3&&(i=s*o,m=s*e*3,u=o*a*3,l=e*a),{x:i*r[0].x+m*r[1].x+u*r[2].x+l*r[3].x,y:i*r[0].y+m*r[1].y+u*r[2].y+l*r[3].y,t:e}},vt=(t,e)=>{let n=t(e),o=n.x*n.x+n.y*n.y;return Math.sqrt(o)},Nt=t=>{let n=ft.length,o=0;for(let r=0,s;r{let e=[];for(let o=0,r=t.length,s=2;oLt(n[0],o))},wt=1e-8,Le=([t,e,n])=>{let o=Math.min(t,n),r=Math.max(t,n);if(e>=t?n>=e:n<=e)return[o,r];let s=(t*n-e*e)/(t-2*e+n);return s{let r=t-3*e+3*n-o;if(Math.abs(r)0&&l<1){let f=t*(1-l)*(1-l)*(1-l)+e*3*(1-l)*(1-l)*l+n*3*(1-l)*l*l+o*l*l*l;fm&&(m=f)}}return[i,m]};var gt={};X(gt,{getCubicBBox:()=>Qe,getCubicLength:()=>ge,getPointAtCubicLength:()=>bt,getPointAtCubicSegmentLength:()=>Rt});var Rt=([t,e,n,o,r,s,a,i],m)=>{let u=1-m;return{x:u**3*t+3*u**2*m*n+3*u*m**2*r+m**3*a,y:u**3*e+3*u**2*m*o+3*u*m**2*s+m**3*i}},ge=(t,e,n,o,r,s,a,i)=>pe([t,e,n,o,r,s,a,i]),bt=(t,e,n,o,r,s,a,i,m)=>{let u=typeof m=="number",l={x:t,y:e};if(u){let p=pe([t,e,n,o,r,s,a,i]);m<=0||(m>=p?l={x:a,y:i}:l=Rt([t,e,n,o,r,s,a,i],m/p))}return l},Qe=(t,e,n,o,r,s,a,i)=>{let m=Ve([t,n,r,a]),u=Ve([e,o,s,i]);return[m[0],u[0],m[1],u[1]]};var dt={};X(dt,{getPointAtQuadLength:()=>yt,getPointAtQuadSegmentLength:()=>kt,getQuadBBox:()=>qe,getQuadLength:()=>ye});var kt=([t,e,n,o,r,s],a)=>{let i=1-a;return{x:i**2*t+2*i*a*n+a**2*r,y:i**2*e+2*i*a*o+a**2*s}},ye=(t,e,n,o,r,s)=>pe([t,e,n,o,r,s]),yt=(t,e,n,o,r,s,a)=>{let i=typeof a=="number",m={x:t,y:e};if(i){let u=pe([t,e,n,o,r,s]);a<=0||(a>=u?m={x:r,y:s}:m=kt([t,e,n,o,r,s],a/u))}return m},qe=(t,e,n,o,r,s)=>{let a=Le([t,n,r]),i=Le([e,o,s]);return[a[0],i[0],a[1],i[1]]};var xt={};X(xt,{polygonArea:()=>tr,polygonLength:()=>rr});var tr=t=>{let e=t.length,n=-1,o,r=t[e-1],s=0;for(;++nt.reduce((e,n,o)=>o?e+ie(t[o-1],n):0,0);var nr={a:7,c:6,h:1,l:2,m:2,r:4,q:4,s:4,t:2,v:1,z:0},Z=nr;var or=t=>{let e=t.pathValue[t.segmentStart],n=e.toLowerCase(),{data:o}=t;for(;o.length>=Z[n]&&(n==="m"&&o.length>2?(t.segments.push([e].concat(o.splice(0,2))),n="l",e=e==="m"?"l":"L"):t.segments.push([e].concat(o.splice(0,Z[n]))),!!Z[n]););},ve=or;var ar="SVGPathCommander Error",z=ar;var sr=t=>{let{index:e,pathValue:n}=t,o=n.charCodeAt(e);if(o===48){t.param=0,t.index+=1;return}if(o===49){t.param=1,t.index+=1;return}t.err=`${z}: invalid Arc flag "${n[e]}", expecting 0 or 1 at index ${e}`},Ee=sr;var mr=t=>t>=48&&t<=57,B=mr;var ir="Invalid path value",H=ir;var ur=t=>{let{max:e,pathValue:n,index:o}=t,r=o,s=!1,a=!1,i=!1,m=!1,u;if(r>=e){t.err=`${z}: ${H} at index ${r}, "pathValue" is missing param`;return}if(u=n.charCodeAt(r),(u===43||u===45)&&(r+=1,u=n.charCodeAt(r)),!B(u)&&u!==46){t.err=`${z}: ${H} at index ${r}, "${n[r]}" is not a number`;return}if(u!==46){if(s=u===48,r+=1,u=n.charCodeAt(r),s&&r[5760,6158,8192,8193,8194,8195,8196,8197,8198,8199,8200,8201,8202,8239,8287,12288,65279,10,13,8232,8233,32,9,11,12,160].includes(t),Oe=lr;var pr=t=>{let{pathValue:e,max:n}=t;for(;t.index{switch(t|32){case 109:case 122:case 108:case 104:case 118:case 99:case 115:case 113:case 116:case 97:return!0;default:return!1}},Ie=cr;var fr=t=>B(t)||t===43||t===45||t===46,$e=fr;var hr=t=>(t|32)===97,je=hr;var br=t=>{switch(t|32){case 109:case 77:return!0;default:return!1}},Be=br;var gr=t=>{let{max:e,pathValue:n,index:o,segments:r}=t,s=n.charCodeAt(o),a=Z[n[o].toLowerCase()];if(t.segmentStart=o,!Ie(s)){t.err=`${z}: ${H} "${n[o]}" is not a path command at index ${o}`;return}let i=r[r.length-1];if(!Be(s)&&i?.[0]?.toLocaleLowerCase()==="z"){t.err=`${z}: ${H} "${n[o]}" is not a MoveTo path command at index ${o}`;return}if(t.index+=1,G(t),t.data=[],!a){ve(t);return}for(;;){for(let m=a;m>0;m-=1){if(je(s)&&(m===3||m===4)?Ee(t):De(t),t.err.length)return;t.data.push(t.param),G(t),t.index=t.max||!$e(n.charCodeAt(t.index)))break}ve(t)},de=gr;var W=class{constructor(e){this.segments=[],this.pathValue=e,this.max=e.length,this.index=0,this.param=0,this.segmentStart=0,this.data=[],this.err=""}};var yr=t=>{if(typeof t!="string")return t.slice(0);let e=new W(t);for(G(e);e.index{let[r]=t,s=r.toUpperCase(),a=s===r;if(e===0||a)return t;if(s==="A")return[s,t[1],t[2],t[3],t[4],t[5],t[6]+n,t[7]+o];if(s==="V")return[s,t[1]+o];if(s==="H")return[s,t[1]+n];if(s==="L")return[s,t[1]+n,t[2]+o];{let i=[],m=t.length;for(let u=1;u{let n=t.length,o,r="M",s="M",a=!1,i=0,m=0,u=0,l=0,p=0;for(let f=0;f{let e=T(t);return M(e,_)},Y=Pr;var Sr=(t,e,n,o)=>{let[r]=t,s=r.toLowerCase(),a=r===s;if(e===0||a)return t;if(s==="a")return[s,t[1],t[2],t[3],t[4],t[5],t[6]-n,t[7]-o];if(s==="v")return[s,t[1]-o];if(s==="h")return[s,t[1]-n];if(s==="l")return[s,t[1]-n,t[2]-o];{let i=[],m=t.length;for(let u=1;u{let e=T(t);return M(e,xe)},He=Ar;var Cr=(t,e,n)=>{let{sin:o,cos:r}=Math,s=t*r(n)-e*o(n),a=t*o(n)+e*r(n);return{x:s,y:a}},ce=Cr;var zt=(t,e,n,o,r,s,a,i,m,u)=>{let l=t,p=e,f=n,h=o,c=i,b=m,d=Math.PI*120/180,S=Math.PI/180*(+r||0),A=[],y,g,x,C,k;if(u)[g,x,C,k]=u;else{y=ce(l,p,-S),l=y.x,p=y.y,y=ce(c,b,-S),c=y.x,b=y.y;let N=(l-c)/2,E=(p-b)/2,R=N*N/(f*f)+E*E/(h*h);R>1&&(R=Math.sqrt(R),f*=R,h*=R);let ot=f*f,at=h*h,At=(s===a?-1:1)*Math.sqrt(Math.abs((ot*at-ot*E*E-at*N*N)/(ot*E*E+at*N*N)));C=At*f*E/h+(l+c)/2,k=At*-h*N/f+(p+b)/2,g=Math.asin(((p-k)/h*10**9>>0)/10**9),x=Math.asin(((b-k)/h*10**9>>0)/10**9),g=lx&&(g-=Math.PI*2),!a&&x>g&&(x-=Math.PI*2)}let V=x-g;if(Math.abs(V)>d){let N=x,E=c,R=b;x=g+d*(a&&x>g?1:-1),c=C+f*Math.cos(x),b=k+h*Math.sin(x),A=zt(c,b,f,h,r,0,a,E,R,[x,N,C,k])}V=x-g;let w=Math.cos(g),v=Math.sin(g),$=Math.cos(x),se=Math.sin(x),Q=Math.tan(V/4),P=4/3*f*Q,q=4/3*h*Q,j=[l,p],O=[l+P*v,p-q*w],J=[c+P*se,b-q*$],be=[c,b];if(O[0]=2*j[0]-O[0],O[1]=2*j[1]-O[1],u)return[O[0],O[1],J[0],J[1],be[0],be[1]].concat(A);A=[O[0],O[1],J[0],J[1],be[0],be[1]].concat(A);let me=[];for(let N=0,E=A.length;N{let a=.3333333333333333,i=2/3;return[a*t+i*n,a*e+i*o,a*r+i*n,a*s+i*o,r,s]},Ze=Tr;var Mr=(t,e,n,o)=>{let r=D([t,e],[n,o],.3333333333333333),s=D([t,e],[n,o],2/3);return[r[0],r[1],s[0],s[1],n,o]},Ne=Mr;var Lr=(t,e)=>{let[n]=t,o=t.slice(1).map(Number),[r,s]=o,{x1:a,y1:i,x:m,y:u}=e;return"TQ".includes(n)||(e.qx=null,e.qy=null),n==="M"?(e.x=r,e.y=s,t):n==="A"?["C"].concat(Pe(a,i,o[0],o[1],o[2],o[3],o[4],o[5],o[6])):n==="Q"?(e.qx=r,e.qy=s,["C"].concat(Ze(a,i,o[0],o[1],o[2],o[3]))):n==="L"?["C"].concat(Ne(a,i,r,s)):n==="Z"?["C"].concat(Ne(a,i,m,u)):t},Ge=Lr;var vr=(t,e)=>{let[n]=t,o=n.toUpperCase(),r=n!==o,{x1:s,y1:a,x2:i,y2:m,x:u,y:l}=e,p=t.slice(1),f=p.map((h,c)=>h+(r?c%2?l:u:0));"TQ".includes(o)||(e.qx=null,e.qy=null);if(o==="A")return f=p.slice(0,-2).concat(p[5]+(r?u:0),p[6]+(r?l:0)),["A"].concat(f);if(o==="H")return["L",t[1]+(r?u:0),a];if(o==="V")return["L",s,t[1]+(r?l:0)];if(o==="L")return["L",t[1]+(r?u:0),t[2]+(r?l:0)];if(o==="M")return["M",t[1]+(r?u:0),t[2]+(r?l:0)];if(o==="C")return["C"].concat(f);if(o==="S"){let h=s*2-i,c=a*2-m;return e.x1=h,e.y1=c,["C",h,c].concat(f)}else if(o==="T"){let h=s*2-(e.qx?e.qx:0),c=a*2-(e.qy?e.qy:0);return e.qx=h,e.qy=c,["Q",h,c].concat(f)}else if(o==="Q"){let[h,c]=f;return e.qx=h,e.qy=c,["Q"].concat(f)}else if(o==="Z")return["Z"];return t},ee=vr;var Nr={x1:0,y1:0,x2:0,y2:0,x:0,y:0,qx:null,qy:null},U=Nr;var wr=t=>{let e={...U},n=T(t);return M(n,(o,r,s,a)=>{e.x=s,e.y=a;let i=ee(o,e),m=Ge(i,e);m[0]==="C"&&m.length>7&&(n.splice(r+1,0,["C"].concat(m.slice(7))),m=m.slice(0,7));let l=m.length;return e.x1=+m[l-2],e.y1=+m[l-1],e.x2=+m[l-4]||e.x1,e.y2=+m[l-3]||e.y1,m})},te=wr;var Rr={origin:[0,0,0],round:4},I=Rr;var kr=(t,e)=>{let n=e>=1?10**e:1;return e>0?Math.round(t*n)/n:Math.round(t)},L=kr;var zr=(t,e)=>{let n=t.length,{round:o}=I,r=t[0],s="";o=e==="off"||typeof e=="number"&&e>=0?e:typeof o=="number"&&o>=0?o:"off";for(let a=0;a{let e=T(t),n={...U};return M(e,(o,r,s,a)=>{n.x=s,n.y=a;let i=ee(o,n),m=i.length;return n.x1=+i[m-2],n.y1=+i[m-1],n.x2=+i[m-4]||n.x1,n.y2=+i[m-3]||n.y1,i})},K=Vr;var Qr=(t,e)=>{let n=K(t),o=!1,r=[],s="M",a=0,i=0,[m,u]=n[0].slice(1),l=typeof e=="number",p={x:m,y:u},f=0,h=p,c=0;return!l||e{[s]=b,o=s==="M",r=o?r:[S,A].concat(b.slice(1));if(o?([,m,u]=b,p={x:m,y:u},f=0):s==="L"?(p=Te(r[0],r[1],r[2],r[3],e-c),f=ue(r[0],r[1],r[2],r[3])):s==="A"?(p=lt(r[0],r[1],r[2],r[3],r[4],r[5],r[6],r[7],r[8],e-c),f=Me(r[0],r[1],r[2],r[3],r[4],r[5],r[6],r[7],r[8])):s==="C"?(p=bt(r[0],r[1],r[2],r[3],r[4],r[5],r[6],r[7],e-c),f=ge(r[0],r[1],r[2],r[3],r[4],r[5],r[6],r[7])):s==="Q"?(p=yt(r[0],r[1],r[2],r[3],r[4],r[5],e-c),f=ye(r[0],r[1],r[2],r[3],r[4],r[5])):s==="Z"&&(r=[S,A,m,u],p={x:m,y:u},f=ue(r[0],r[1],r[2],r[3])),[a,i]=r.slice(-2),cc-fe?{x:a,y:i}:h)},re=Qr;var qr=t=>{let e=T(t),n=0,o=0,r=0,s=0,a=0,i=0,m="M",u=0,l=0,p=0;return M(e,(f,h,c,b)=>{[m]=f;let d=m.toUpperCase(),A=d!==m?_(f,h,c,b):f.slice(0),y=d==="V"?["L",c,A[1]]:d==="H"?["L",A[1],b]:A;[m]=y,"TQ".includes(d)||(a=0,i=0);if(m==="M")[,u,l]=y;else if(m==="L")p+=ue(c,b,y[1],y[2]);else if(m==="A")p+=Me(c,b,y[1],y[2],y[3],y[4],y[5],y[6],y[7]);else if(m==="S"){let g=n*2-r,x=o*2-s;p+=ge(c,b,g,x,y[1],y[2],y[3],y[4])}else m==="C"?p+=ge(c,b,y[1],y[2],y[3],y[4],y[5],y[6]):m==="T"?(a=n*2-a,i=o*2-i,p+=ye(c,b,a,i,y[1],y[2])):m==="Q"?(a=y[1],i=y[2],p+=ye(c,b,y[1],y[2],y[3],y[4])):m==="Z"&&(p+=ue(c,b,u,l));[n,o]=m==="Z"?[u,l]:y.slice(-2),[r,s]=m==="C"?[y[3],y[4]]:m==="S"?[y[1],y[2]]:[n,o]}),p},F=qr;var Er=(t,e)=>{let n=T(t),o=n.slice(0),r=F(o),s=o.length-1,a=0,i=0,m=n[0];if(s<=0||!e||!Number.isFinite(e))return{segment:m,index:0,length:i,lengthAtSegment:a};if(e>=r)return o=n.slice(0,-1),a=F(o),i=r-a,m=n[s],{segment:m,index:s,length:i,lengthAtSegment:a};let u=[];for(;s>0;)m=o[s],o=o.slice(0,-1),a=F(o),i=r-a,r=a,u.push({segment:m,index:s,length:i,lengthAtSegment:a}),s-=1;return u.find(({lengthAtSegment:l})=>l<=e)},Ae=Er;var Dr=(t,e)=>{let n=T(t),o=K(n),r=F(o),s=g=>{let x=g.x-e.x,C=g.y-e.y;return x*x+C*C},a=8,i,m={x:0,y:0},u=0,l=0,p=1/0;for(let g=0;g<=r;g+=a)i=re(o,g),u=s(i),u1e-6&&(c=l-a,f=re(o,c),d=s(f),b=l+a,h=re(o,b),S=s(h),c>=0&&dne(t,e).closest,Vt=Or;var Ir=(t,e,n,o,r,s,a,i)=>3*((i-e)*(n+r)-(a-t)*(o+s)+o*(t-r)-n*(e-s)+i*(r+t/3)-a*(s+e/3))/20,$r=t=>{let e=0,n=0,o=0;return te(t).map(r=>{switch(r[0]){case"M":return[,e,n]=r,0;default:return o=Ir(e,n,r[1],r[2],r[3],r[4],r[5],r[6]),[e,n]=r.slice(-2),o}}).reduce((r,s)=>r+s,0)},_e=$r;var jr=t=>_e(te(t))>=0,Qt=jr;var Br=t=>{if(!t)return{x:0,y:0,width:0,height:0,x2:0,y2:0,cx:0,cy:0,cz:0};let e=T(t),n="M",o=0,r=0,{max:s,min:a}=Math,i=1/0,m=1/0,u=-1/0,l=-1/0,p=0,f=0,h=0,c=0,b=0,d=0,S=0,A=0,y=0,g=0;M(e,(k,V,w,v)=>{[n]=k;let $=n.toUpperCase(),Q=$!==n?_(k,V,w,v):k.slice(0),P=$==="V"?["L",w,Q[1]]:$==="H"?["L",Q[1],v]:Q;[n]=P,"TQ".includes($)||(y=0,g=0);if(n==="M")[,o,r]=P,p=o,f=r,h=o,c=r;else if(n==="L")[p,f,h,c]=ke(w,v,P[1],P[2]);else if(n==="A")[p,f,h,c]=pt(w,v,P[1],P[2],P[3],P[4],P[5],P[6],P[7]);else if(n==="S"){let q=b*2-S,j=d*2-A;[p,f,h,c]=Qe(w,v,q,j,P[1],P[2],P[3],P[4])}else n==="C"?[p,f,h,c]=Qe(w,v,P[1],P[2],P[3],P[4],P[5],P[6]):n==="T"?(y=b*2-y,g=d*2-g,[p,f,h,c]=qe(w,v,y,g,P[1],P[2])):n==="Q"?(y=P[1],g=P[2],[p,f,h,c]=qe(w,v,P[1],P[2],P[3],P[4])):n==="Z"&&([p,f,h,c]=ke(w,v,o,r));i=a(p,i),m=a(f,m),u=s(h,u),l=s(c,l),[b,d]=n==="Z"?[o,r]:P.slice(-2),[S,A]=n==="C"?[P[3],P[4]]:n==="S"?[P[1],P[2]]:[b,d]});let x=u-i,C=l-m;return{width:x,height:C,x:i,y:m,x2:u,y2:l,cx:i+x/2,cy:m+C/2,cz:Math.max(x,C)+Math.min(x,C)/2}},Ue=Br;var Hr=(t,e)=>Ae(t,e).segment,qt=Hr;var Zr=(t,e)=>ne(t,e).segment,Et=Zr;var Gr=t=>Array.isArray(t)&&t.every(e=>{let n=e[0].toLowerCase();return Z[n]===e.length-1&&"achlmqstvz".includes(n)&&e.slice(1).every(Number.isFinite)})&&t.length>0,oe=Gr;var _r=t=>oe(t)&&t.every(([e])=>e===e.toUpperCase()),Ke=_r;var Ur=t=>Ke(t)&&t.every(([e])=>"ACLMQZ".includes(e)),Fe=Ur;var Kr=t=>Fe(t)&&t.every(([e])=>"MC".includes(e)),Dt=Kr;var Fr=(t,e)=>{let{distance:n}=ne(t,e);return Math.abs(n)oe(t)&&t.slice(1).every(([e])=>e===e.toLowerCase()),It=Jr;var Wr=t=>{if(typeof t!="string"||!t.length)return!1;let e=new W(t);for(G(e);e.indext!=null&&typeof t=="object"&&t.nodeType===1,We=Yr;var en=t=>{let{x1:e,y1:n,x2:o,y2:r}=t;return[e,n,o,r]=[e,n,o,r].map(s=>+s),[["M",e,n],["L",o,r]]},tn=t=>{let e=[],n=(t.points||"").trim().split(/[\s|,]/).map(r=>+r),o=0;for(;o{let{cx:e,cy:n,r:o}=t;return[e,n,o]=[e,n,o].map(r=>+r),[["M",e-o,n],["a",o,o,0,1,0,2*o,0],["a",o,o,0,1,0,-2*o,0]]},nn=t=>{let{cx:e,cy:n}=t,o=t.rx||0,r=t.ry||o;return[e,n,o,r]=[e,n,o,r].map(s=>+s),[["M",e-o,n],["a",o,r,0,1,0,2*o,0],["a",o,r,0,1,0,-2*o,0]]},on=t=>{let e=+t.x||0,n=+t.y||0,o=+t.width,r=+t.height,s=+(t.rx||0),a=+(t.ry||s);if(s||a){s*2>o&&(s-=(s*2-o)/2);return a*2>r&&(a-=(a*2-r)/2),[["M",e+s,n],["h",o-s*2],["s",s,0,s,a],["v",r-a*2],["s",0,a,-s,a],["h",-o+s*2],["s",-s,0,-s,-a],["v",-r+a*2],["s",0,-a,s,-a]]}return[["M",e,n],["h",o],["v",r],["H",e],["Z"]]},an=t=>{let e=Object.keys(ae),n=We(t),o=n?t.tagName:null;if(o&&[...e,"path"].every(m=>o!==m))throw TypeError(`${z}: "${o}" is not SVGElement`);let r=n?o:t.type,s=ae[r],a={type:r};n?s.forEach(m=>{a[m]=t.getAttribute(m)}):Object.assign(a,t);let i=[];return r==="circle"?i=rn(a):r==="ellipse"?i=nn(a):["polyline","polygon"].includes(r)?i=tn(a):r==="rect"?i=on(a):r==="line"?i=en(a):["glyph","path"].includes(r)&&(i=T(n?t.getAttribute("d")||"":t.d||"")),oe(i)&&i.length?i:!1},Xe=an;var sn=(t,e,n)=>{let o=n||document,r=Object.keys(ae),s=We(t),a=s?t.tagName:null;if(a==="path")throw TypeError(`${z}: "${a}" is already SVGPathElement`);if(a&&r.every(c=>a!==c))throw TypeError(`${z}: "${a}" is not SVGElement`);let i=o.createElementNS("http://www.w3.org/2000/svg","path"),m=s?a:t.type,u=ae[m],l={type:m},p=I.round,f=Xe(t),h=f&&f.length?Se(f,p):"";return s?(u.forEach(c=>{l[c]=t.getAttribute(c)}),Object.values(t.attributes).forEach(({name:c,value:b})=>{u.includes(c)||i.setAttribute(c,b)})):(Object.assign(l,t),Object.keys(l).forEach(c=>{!u.includes(c)&&c!=="type"&&i.setAttribute(c.replace(/[A-Z]/g,b=>`-${b.toLowerCase()}`),l[c])})),Je(h)?(i.setAttribute("d",h),e&&s&&(t.before(i,t),t.remove()),i):!1},$t=sn;var jt=st(require("@thednp/dommatrix"),1),mn=t=>{let e=new jt.default,{origin:n}=t,[o,r]=n,{translate:s}=t,{rotate:a}=t,{skew:i}=t,{scale:m}=t;return Array.isArray(s)&&s.length>=2&&s.every(u=>!Number.isNaN(+u))&&s.some(u=>u!==0)?e=e.translate(...s):typeof s=="number"&&!Number.isNaN(s)&&(e=e.translate(s)),(a||i||m)&&(e=e.translate(o,r),Array.isArray(a)&&a.length>=2&&a.every(u=>!Number.isNaN(+u))&&a.some(u=>u!==0)?e=e.rotate(...a):typeof a=="number"&&!Number.isNaN(a)&&(e=e.rotate(a)),Array.isArray(i)&&i.length===2&&i.every(u=>!Number.isNaN(+u))&&i.some(u=>u!==0)?(e=i[0]?e.skewX(i[0]):e,e=i[1]?e.skewY(i[1]):e):typeof i=="number"&&!Number.isNaN(i)&&(e=e.skewX(i)),Array.isArray(m)&&m.length>=2&&m.every(u=>!Number.isNaN(+u))&&m.some(u=>u!==1)?e=e.scale(...m):typeof m=="number"&&!Number.isNaN(m)&&(e=e.scale(m)),e=e.translate(-o,-r)),e},Ye=mn;var un=(t,e,n,o)=>{let[r]=t,{round:s}=I,a=typeof s=="number"?s:4,i=e.slice(1),{x1:m,y1:u,x2:l,y2:p,x:f,y:h}=n,[c,b]=i.slice(-2),d=t;if("TQ".includes(r)||(n.qx=null,n.qy=null),r==="L"){if(L(f,a)===L(c,a))return["V",b];if(L(h,a)===L(b,a))return["H",c]}else if(r==="C"){let[S,A]=i;if(n.x1=S,n.y1=A,"CS".includes(o)&&(L(S,a)===L(m*2-l,a)&&L(A,a)===L(u*2-p,a)||L(m,a)===L(l*2-f,a)&&L(u,a)===L(p*2-h,a)))return["S",i[2],i[3],i[4],i[5]]}else if(r==="Q"){let[S,A]=i;if(n.qx=S,n.qy=A,"QT".includes(o)&&L(S,a)===L(m*2-l,a)&&L(A,a)===L(u*2-p,a))return["T",i[2],i[3]]}return d},et=un;var ln=(t,e)=>{let n=t.slice(1).map(o=>L(o,e));return[t[0]].concat(n)},he=ln;var pn=(t,e)=>{let n=Y(t),o=typeof e=="number"&&e>=0?e:2,r={...U},s=[],a="M",i="Z";return M(n,(m,u,l,p)=>{r.x=l,r.y=p;let f=ee(m,r),h=m;if([a]=m,s[u]=a,u){i=s[u-1];let b=et(m,f,r,i),d=he(b,o),S=d.join(""),A=xe(b,u,l,p),y=he(A,o),g=y.join("");h=S.length{let n=Bt.default.Translate(e[0],e[1],e[2]);return[,,,n.m44]=e,n=t.multiply(n),[n.m41,n.m42,n.m43,n.m44]},fn=(t,e,n)=>{let[o,r,s]=n,[a,i,m]=cn(t,[e[0],e[1],0,1]),u=a-o,l=i-r,p=m-s;return[u*(Math.abs(s)/Math.abs(p)||1)+o,l*(Math.abs(s)/Math.abs(p)||1)+r]},we=fn;var hn=t=>{let e=t.slice(1).map((n,o,r)=>o?r[o-1].slice(-2).concat(n.slice(1)):t[0].slice(1).concat(n.slice(1))).map(n=>n.map((o,r)=>n[n.length-r-2*(1-r%2)])).reverse();return[["M"].concat(e[0].slice(0,2))].concat(e.map(n=>["C"].concat(n.slice(2))))},Ht=hn;var bn=t=>{let e=Y(t),n=K(e),o=e.length,r=e[o-1][0]==="Z",s=M(e,(a,i)=>{let m=n[i],u=i&&e[i-1],l=u&&u[0],p=e[i+1],f=p&&p[0],[h]=a,[c,b]=n[i?i-1:o-1].slice(-2),d=a;switch(h){case"M":d=r?["Z"]:[h,c,b];break;case"A":d=[h,a[1],a[2],a[3],a[4],a[5]===1?0:1,c,b];break;case"C":p&&f==="S"?d=["S",a[1],a[2],c,b]:d=[h,a[3],a[4],a[1],a[2],c,b];break;case"S":l&&"CS".includes(l)&&(!p||f!=="S")?d=["C",m[3],m[4],m[1],m[2],c,b]:d=[h,m[1],m[2],c,b];break;case"Q":p&&f==="T"?d=["T",c,b]:d=[h,a[1],a[2],c,b];break;case"T":l&&"QT".includes(l)&&(!p||f!=="T")?d=["Q",m[1],m[2],c,b]:d=[h,c,b];break;case"Z":d=["M",c,b];break;case"H":d=[h,c];break;case"V":d=[h,b];break;default:d=[h].concat(a.slice(1,-2),c,b)}return d});return r?s.reverse():[s[0]].concat(s.slice(1).reverse())},Ce=bn;var gn=(t,e)=>{let{round:n}=I;n=e==="off"||typeof e=="number"&&e>=0?e:typeof n=="number"&&n>=0?n:"off";return n==="off"?t.slice(0):M(t,o=>he(o,n))},Zt=gn;var yn=(t,e=.5)=>{let n=e,o=t.slice(0,2),r=t.slice(2,4),s=t.slice(4,6),a=t.slice(6,8),i=D(o,r,n),m=D(r,s,n),u=D(s,a,n),l=D(i,m,n),p=D(m,u,n),f=D(l,p,n);return[["C",i[0],i[1],l[0],l[1],f[0],f[1]],["C",p[0],p[1],u[0],u[1],a[0],a[1]]]},Gt=yn;var dn=t=>{let e=[],n,o=-1,r=0,s=0,a=0,i=0,m={...U};return t.forEach(u=>{let[l]=u,p=l.toUpperCase(),f=l.toLowerCase(),h=l===f,c=u.slice(1);p==="M"?(o+=1,[r,s]=c,r+=h?m.x:0,s+=h?m.y:0,a=r,i=s,n=[h?[p,a,i]:u]):(p==="Z"?(r=a,s=i):p==="H"?([,r]=u,r+=h?m.x:0):p==="V"?([,s]=u,s+=h?m.y:0):([r,s]=u.slice(-2),r+=h?m.x:0,s+=h?m.y:0),n.push(u)),m.x=r,m.y=s,e[o]=n}),e},rt=dn;var xn=(t,e)=>{let n=0,o=0,r=0,s=0,a=0,i=0,m="M",u=T(t),l=e&&Object.keys(e);if(!e||l&&!l.length)return u.slice(0);e.origin||Object.assign(e,{origin:I.origin});let p=e.origin,f=Ye(e);return f.isIdentity?u.slice(0):M(u,(h,c,b,d)=>{[m]=h;let S=m.toUpperCase(),y=S!==m?_(h,c,b,d):h.slice(0),g=S==="A"?["C"].concat(Pe(b,d,y[1],y[2],y[3],y[4],y[5],y[6],y[7])):S==="V"?["L",b,y[1]]:S==="H"?["L",y[1],d]:y;m=g[0];let x=m==="C"&&g.length>7,C=x?g.slice(0,7):g.slice(0);if(x&&(u.splice(c+1,0,["C"].concat(g.slice(7))),g=C),m==="L"){[r,s]=we(f,[g[1],g[2]],p);n!==r&&o!==s?g=["L",r,s]:o===s?g=["H",r]:n===r&&(g=["V",s])}else for(a=1,i=g.length;a"u";if(r||!e.length)throw TypeError(`${z}: "pathValue" is ${r?"undefined":"empty"}`);this.segments=T(e);let{round:s,origin:a}=o,i;Number.isInteger(s)||s==="off"?i=s:i=I.round;let m=I.origin;if(Array.isArray(a)&&a.length>=2){let[u,l,p]=a.map(Number);m=[Number.isNaN(u)?0:u,Number.isNaN(l)?0:l,Number.isNaN(p)?0:p]}return this.round=i,this.origin=m,this}get bbox(){return Ue(this.segments)}get length(){return F(this.segments)}getBBox(){return this.bbox}getTotalLength(){return this.length}getPointAtLength(e){return re(this.segments,e)}toAbsolute(){let{segments:e}=this;return this.segments=Y(e),this}toRelative(){let{segments:e}=this;return this.segments=He(e),this}toCurve(){let{segments:e}=this;return this.segments=te(e),this}reverse(e){let{segments:n}=this,o=rt(n),r=o.length>1?o:!1,s=r?r.map((i,m)=>e?m?Ce(i):i.slice(0):Ce(i)):n.slice(0),a=[];return r?a=s.flat(1):a=e?n:Ce(n),this.segments=a.slice(0),this}normalize(){let{segments:e}=this;return this.segments=K(e),this}optimize(){let{segments:e}=this,n=this.round==="off"?2:this.round;return this.segments=tt(e,n),this}transform(e){if(!e||typeof e!="object"||typeof e=="object"&&!["translate","rotate","skew","scale"].some(m=>m in e))return this;let{segments:n,origin:[o,r,s]}=this,a={};for(let[m,u]of Object.entries(e)){m==="skew"&&Array.isArray(u)||(m==="rotate"||m==="translate"||m==="origin"||m==="scale")&&Array.isArray(u)?a[m]=u.map(Number):m!=="origin"&&typeof Number(u)=="number"&&(a[m]=Number(u))}let{origin:i}=a;if(Array.isArray(i)&&i.length>=2){let[m,u,l]=i.map(Number);a.origin=[Number.isNaN(m)?o:m,Number.isNaN(u)?r:u,l||s]}else a.origin=[o,r,s];return this.segments=nt(n,a),this}flipX(){let{cx:e,cy:n}=this.bbox;return this.transform({rotate:[0,180,0],origin:[e,n,0]}),this}flipY(){let{cx:e,cy:n}=this.bbox;return this.transform({rotate:[180,0,0],origin:[e,n,0]}),this}toString(){return Se(this.segments,this.round)}dispose(){Object.keys(this).forEach(e=>delete this[e])}},Pn=Object.assign(St,Pt); +//# sourceMappingURL=svg-path-commander.cjs.map \ No newline at end of file diff --git a/dist/svg-path-commander.cjs.map b/dist/svg-path-commander.cjs.map index e82dd78..3f5cd84 100644 --- a/dist/svg-path-commander.cjs.map +++ b/dist/svg-path-commander.cjs.map @@ -1 +1 @@ -{"version":3,"file":"svg-path-commander.cjs","sources":["../node_modules/.pnpm/@thednp+dommatrix@2.0.11/node_modules/@thednp/dommatrix/dist/dommatrix.mjs","../src/math/midPoint.ts","../src/math/distanceSquareRoot.ts","../src/math/lineTools.ts","../src/math/arcTools.ts","../src/math/bezier.ts","../src/math/cubicTools.ts","../src/math/quadTools.ts","../src/math/polygonTools.ts","../src/parser/paramsCount.ts","../src/parser/finalizeSegment.ts","../src/parser/error.ts","../src/parser/scanFlag.ts","../src/parser/isDigit.ts","../src/parser/invalidPathValue.ts","../src/parser/scanParam.ts","../src/parser/isSpace.ts","../src/parser/skipSpaces.ts","../src/parser/isPathCommand.ts","../src/parser/isDigitStart.ts","../src/parser/isArcCommand.ts","../src/parser/isMoveCommand.ts","../src/parser/scanSegment.ts","../src/parser/pathParser.ts","../src/parser/parsePathString.ts","../src/process/absolutizeSegment.ts","../src/process/iterate.ts","../src/convert/pathToAbsolute.ts","../src/process/relativizeSegment.ts","../src/convert/pathToRelative.ts","../src/math/rotateVector.ts","../src/process/arcToCubic.ts","../src/process/quadToCubic.ts","../src/process/lineToCubic.ts","../src/process/segmentToCubic.ts","../src/process/normalizeSegment.ts","../src/parser/paramsParser.ts","../src/convert/pathToCurve.ts","../src/options/options.ts","../src/math/roundTo.ts","../src/convert/pathToString.ts","../src/util/distanceEpsilon.ts","../src/process/normalizePath.ts","../src/util/getPointAtLength.ts","../src/util/getTotalLength.ts","../src/util/getPropertiesAtLength.ts","../src/util/getPropertiesAtPoint.ts","../src/util/getClosestPoint.ts","../src/util/getPathArea.ts","../src/util/getDrawDirection.ts","../src/util/getPathBBox.ts","../src/util/getSegmentAtLength.ts","../src/util/getSegmentOfPoint.ts","../src/util/isPathArray.ts","../src/util/isAbsoluteArray.ts","../src/util/isNormalizedArray.ts","../src/util/isCurveArray.ts","../src/util/isPointInStroke.ts","../src/util/isRelativeArray.ts","../src/util/isValidPath.ts","../src/util/shapeParams.ts","../src/util/isElement.ts","../src/util/shapeToPathArray.ts","../src/util/shapeToPath.ts","../src/process/getSVGMatrix.ts","../src/process/shortenSegment.ts","../src/process/roundSegment.ts","../src/process/optimizePath.ts","../src/process/projection2d.ts","../src/process/reverseCurve.ts","../src/process/reversePath.ts","../src/process/roundPath.ts","../src/process/splitCubic.ts","../src/process/splitPath.ts","../src/process/transformPath.ts","../src/index.ts"],"sourcesContent":["var Z = Object.defineProperty;\nvar z = (s, t, e) => t in s ? Z(s, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : s[t] = e;\nvar p = (s, t, e) => z(s, typeof t != \"symbol\" ? t + \"\" : t, e);\nconst $ = {\n a: 1,\n b: 0,\n c: 0,\n d: 1,\n e: 0,\n f: 0,\n m11: 1,\n m12: 0,\n m13: 0,\n m14: 0,\n m21: 0,\n m22: 1,\n m23: 0,\n m24: 0,\n m31: 0,\n m32: 0,\n m33: 1,\n m34: 0,\n m41: 0,\n m42: 0,\n m43: 0,\n m44: 1,\n is2D: !0,\n isIdentity: !0\n}, E = (s) => (s instanceof Float64Array || s instanceof Float32Array || Array.isArray(s) && s.every((t) => typeof t == \"number\")) && [6, 16].some((t) => s.length === t), P = (s) => s instanceof DOMMatrix || s instanceof y || typeof s == \"object\" && Object.keys($).every((t) => s && t in s), g = (s) => {\n const t = new y(), e = Array.from(s);\n if (!E(e))\n throw TypeError(\n `CSSMatrix: \"${e.join(\",\")}\" must be an array with 6/16 numbers.`\n );\n // istanbul ignore else @preserve\n if (e.length === 16) {\n const [\n n,\n i,\n r,\n a,\n l,\n m,\n h,\n c,\n u,\n f,\n w,\n o,\n d,\n A,\n M,\n b\n ] = e;\n t.m11 = n, t.a = n, t.m21 = l, t.c = l, t.m31 = u, t.m41 = d, t.e = d, t.m12 = i, t.b = i, t.m22 = m, t.d = m, t.m32 = f, t.m42 = A, t.f = A, t.m13 = r, t.m23 = h, t.m33 = w, t.m43 = M, t.m14 = a, t.m24 = c, t.m34 = o, t.m44 = b;\n } else if (e.length === 6) {\n const [n, i, r, a, l, m] = e;\n t.m11 = n, t.a = n, t.m12 = i, t.b = i, t.m21 = r, t.c = r, t.m22 = a, t.d = a, t.m41 = l, t.e = l, t.m42 = m, t.f = m;\n }\n return t;\n}, X = (s) => {\n if (P(s))\n return g([\n s.m11,\n s.m12,\n s.m13,\n s.m14,\n s.m21,\n s.m22,\n s.m23,\n s.m24,\n s.m31,\n s.m32,\n s.m33,\n s.m34,\n s.m41,\n s.m42,\n s.m43,\n s.m44\n ]);\n throw TypeError(\n `CSSMatrix: \"${JSON.stringify(s)}\" is not a DOMMatrix / CSSMatrix / JSON compatible object.`\n );\n}, O = (s) => {\n if (typeof s != \"string\")\n throw TypeError(`CSSMatrix: \"${JSON.stringify(s)}\" is not a string.`);\n const t = String(s).replace(/\\s/g, \"\");\n let e = new y();\n const n = `CSSMatrix: invalid transform string \"${s}\"`;\n return t.split(\")\").filter((i) => i).forEach((i) => {\n const [r, a] = i.split(\"(\");\n if (!a) throw TypeError(n);\n const l = a.split(\",\").map(\n (o) => o.includes(\"rad\") ? parseFloat(o) * (180 / Math.PI) : parseFloat(o)\n ), [m, h, c, u] = l, f = [m, h, c], w = [m, h, c, u];\n if (r === \"perspective\" && m && [h, c].every((o) => o === void 0))\n e.m34 = -1 / m;\n else if (r.includes(\"matrix\") && [6, 16].includes(l.length) && l.every((o) => !Number.isNaN(+o))) {\n const o = l.map((d) => Math.abs(d) < 1e-6 ? 0 : d);\n e = e.multiply(g(o));\n } else if (r === \"translate3d\" && f.every((o) => !Number.isNaN(+o)))\n e = e.translate(m, h, c);\n else if (r === \"translate\" && m && c === void 0)\n e = e.translate(m, h || 0, 0);\n else if (r === \"rotate3d\" && w.every((o) => !Number.isNaN(+o)) && u)\n e = e.rotateAxisAngle(m, h, c, u);\n else if (r === \"rotate\" && m && [h, c].every((o) => o === void 0))\n e = e.rotate(0, 0, m);\n else if (r === \"scale3d\" && f.every((o) => !Number.isNaN(+o)) && f.some((o) => o !== 1))\n e = e.scale(m, h, c);\n else if (\n // prop === \"scale\" && !Number.isNaN(x) && x !== 1 && z === undefined\n // prop === \"scale\" && !Number.isNaN(x) && [x, y].some((n) => n !== 1) &&\n r === \"scale\" && !Number.isNaN(m) && (m !== 1 || h !== 1) && c === void 0\n ) {\n const d = Number.isNaN(+h) ? m : h;\n e = e.scale(m, d, 1);\n } else if (r === \"skew\" && (m || !Number.isNaN(m) && h) && c === void 0)\n e = e.skew(m, h || 0);\n else if ([\"translate\", \"rotate\", \"scale\", \"skew\"].some(\n (o) => r.includes(o)\n ) && /[XYZ]/.test(r) && m && [h, c].every((o) => o === void 0))\n if (r === \"skewX\" || r === \"skewY\")\n e = e[r](m);\n else {\n const o = r.replace(/[XYZ]/, \"\"), d = r.replace(o, \"\"), A = [\"X\", \"Y\", \"Z\"].indexOf(d), M = o === \"scale\" ? 1 : 0, b = [\n A === 0 ? m : M,\n A === 1 ? m : M,\n A === 2 ? m : M\n ];\n e = e[o](...b);\n }\n else\n throw TypeError(n);\n }), e;\n}, x = (s, t) => t ? [s.a, s.b, s.c, s.d, s.e, s.f] : [\n s.m11,\n s.m12,\n s.m13,\n s.m14,\n s.m21,\n s.m22,\n s.m23,\n s.m24,\n s.m31,\n s.m32,\n s.m33,\n s.m34,\n s.m41,\n s.m42,\n s.m43,\n s.m44\n], Y = (s, t, e) => {\n const n = new y();\n return n.m41 = s, n.e = s, n.m42 = t, n.f = t, n.m43 = e, n;\n}, F = (s, t, e) => {\n const n = new y(), i = Math.PI / 180, r = s * i, a = t * i, l = e * i, m = Math.cos(r), h = -Math.sin(r), c = Math.cos(a), u = -Math.sin(a), f = Math.cos(l), w = -Math.sin(l), o = c * f, d = -c * w;\n n.m11 = o, n.a = o, n.m12 = d, n.b = d, n.m13 = u;\n const A = h * u * f + m * w;\n n.m21 = A, n.c = A;\n const M = m * f - h * u * w;\n return n.m22 = M, n.d = M, n.m23 = -h * c, n.m31 = h * w - m * u * f, n.m32 = h * f + m * u * w, n.m33 = m * c, n;\n}, T = (s, t, e, n) => {\n const i = new y(), r = Math.sqrt(s * s + t * t + e * e);\n if (r === 0)\n return i;\n const a = s / r, l = t / r, m = e / r, h = n * (Math.PI / 360), c = Math.sin(h), u = Math.cos(h), f = c * c, w = a * a, o = l * l, d = m * m, A = 1 - 2 * (o + d) * f;\n i.m11 = A, i.a = A;\n const M = 2 * (a * l * f + m * c * u);\n i.m12 = M, i.b = M, i.m13 = 2 * (a * m * f - l * c * u);\n const b = 2 * (l * a * f - m * c * u);\n i.m21 = b, i.c = b;\n const k = 1 - 2 * (d + w) * f;\n return i.m22 = k, i.d = k, i.m23 = 2 * (l * m * f + a * c * u), i.m31 = 2 * (m * a * f + l * c * u), i.m32 = 2 * (m * l * f - a * c * u), i.m33 = 1 - 2 * (w + o) * f, i;\n}, I = (s, t, e) => {\n const n = new y();\n return n.m11 = s, n.a = s, n.m22 = t, n.d = t, n.m33 = e, n;\n}, v = (s, t) => {\n const e = new y();\n if (s) {\n const n = s * Math.PI / 180, i = Math.tan(n);\n e.m21 = i, e.c = i;\n }\n if (t) {\n const n = t * Math.PI / 180, i = Math.tan(n);\n e.m12 = i, e.b = i;\n }\n return e;\n}, R = (s) => v(s, 0), D = (s) => v(0, s), N = (s, t) => {\n const e = t.m11 * s.m11 + t.m12 * s.m21 + t.m13 * s.m31 + t.m14 * s.m41, n = t.m11 * s.m12 + t.m12 * s.m22 + t.m13 * s.m32 + t.m14 * s.m42, i = t.m11 * s.m13 + t.m12 * s.m23 + t.m13 * s.m33 + t.m14 * s.m43, r = t.m11 * s.m14 + t.m12 * s.m24 + t.m13 * s.m34 + t.m14 * s.m44, a = t.m21 * s.m11 + t.m22 * s.m21 + t.m23 * s.m31 + t.m24 * s.m41, l = t.m21 * s.m12 + t.m22 * s.m22 + t.m23 * s.m32 + t.m24 * s.m42, m = t.m21 * s.m13 + t.m22 * s.m23 + t.m23 * s.m33 + t.m24 * s.m43, h = t.m21 * s.m14 + t.m22 * s.m24 + t.m23 * s.m34 + t.m24 * s.m44, c = t.m31 * s.m11 + t.m32 * s.m21 + t.m33 * s.m31 + t.m34 * s.m41, u = t.m31 * s.m12 + t.m32 * s.m22 + t.m33 * s.m32 + t.m34 * s.m42, f = t.m31 * s.m13 + t.m32 * s.m23 + t.m33 * s.m33 + t.m34 * s.m43, w = t.m31 * s.m14 + t.m32 * s.m24 + t.m33 * s.m34 + t.m34 * s.m44, o = t.m41 * s.m11 + t.m42 * s.m21 + t.m43 * s.m31 + t.m44 * s.m41, d = t.m41 * s.m12 + t.m42 * s.m22 + t.m43 * s.m32 + t.m44 * s.m42, A = t.m41 * s.m13 + t.m42 * s.m23 + t.m43 * s.m33 + t.m44 * s.m43, M = t.m41 * s.m14 + t.m42 * s.m24 + t.m43 * s.m34 + t.m44 * s.m44;\n return g([\n e,\n n,\n i,\n r,\n a,\n l,\n m,\n h,\n c,\n u,\n f,\n w,\n o,\n d,\n A,\n M\n ]);\n};\nclass y {\n /**\n * @constructor\n * @param init accepts all parameter configurations:\n * * valid CSS transform string,\n * * CSSMatrix/DOMMatrix instance,\n * * a 6/16 elements *Array*.\n */\n constructor(t) {\n return this.a = 1, this.b = 0, this.c = 0, this.d = 1, this.e = 0, this.f = 0, this.m11 = 1, this.m12 = 0, this.m13 = 0, this.m14 = 0, this.m21 = 0, this.m22 = 1, this.m23 = 0, this.m24 = 0, this.m31 = 0, this.m32 = 0, this.m33 = 1, this.m34 = 0, this.m41 = 0, this.m42 = 0, this.m43 = 0, this.m44 = 1, t ? this.setMatrixValue(t) : this;\n }\n /**\n * A `Boolean` whose value is `true` if the matrix is the identity matrix. The identity\n * matrix is one in which every value is 0 except those on the main diagonal from top-left\n * to bottom-right corner (in other words, where the offsets in each direction are equal).\n *\n * @return the current property value\n */\n get isIdentity() {\n return this.m11 === 1 && this.m12 === 0 && this.m13 === 0 && this.m14 === 0 && this.m21 === 0 && this.m22 === 1 && this.m23 === 0 && this.m24 === 0 && this.m31 === 0 && this.m32 === 0 && this.m33 === 1 && this.m34 === 0 && this.m41 === 0 && this.m42 === 0 && this.m43 === 0 && this.m44 === 1;\n }\n /**\n * A `Boolean` flag whose value is `true` if the matrix was initialized as a 2D matrix\n * and `false` if the matrix is 3D.\n *\n * @return the current property value\n */\n get is2D() {\n return this.m31 === 0 && this.m32 === 0 && this.m33 === 1 && this.m34 === 0 && this.m43 === 0 && this.m44 === 1;\n }\n /**\n * The `setMatrixValue` method replaces the existing matrix with one computed\n * in the browser. EG: `matrix(1,0.25,-0.25,1,0,0)`\n *\n * The method accepts any *Array* values, the result of\n * `DOMMatrix` instance method `toFloat64Array()` / `toFloat32Array()` calls\n * or `CSSMatrix` instance method `toArray()`.\n *\n * This method expects valid *matrix()* / *matrix3d()* string values, as well\n * as other transform functions like *translateX(10px)*.\n *\n * @param source\n * @return the matrix instance\n */\n setMatrixValue(t) {\n return typeof t == \"string\" && t.length && t !== \"none\" ? O(t) : Array.isArray(t) || t instanceof Float64Array || t instanceof Float32Array ? g(t) : typeof t == \"object\" ? X(t) : this;\n }\n /**\n * Returns a *Float32Array* containing elements which comprise the matrix.\n * The method can return either the 16 elements or the 6 elements\n * depending on the value of the `is2D` parameter.\n *\n * @param is2D *Array* representation of the matrix\n * @return an *Array* representation of the matrix\n */\n toFloat32Array(t) {\n return Float32Array.from(x(this, t));\n }\n /**\n * Returns a *Float64Array* containing elements which comprise the matrix.\n * The method can return either the 16 elements or the 6 elements\n * depending on the value of the `is2D` parameter.\n *\n * @param is2D *Array* representation of the matrix\n * @return an *Array* representation of the matrix\n */\n toFloat64Array(t) {\n return Float64Array.from(x(this, t));\n }\n /**\n * Creates and returns a string representation of the matrix in `CSS` matrix syntax,\n * using the appropriate `CSS` matrix notation.\n *\n * matrix3d *matrix3d(m11, m12, m13, m14, m21, ...)*\n * matrix *matrix(a, b, c, d, e, f)*\n *\n * @return a string representation of the matrix\n */\n toString() {\n const { is2D: t } = this, e = this.toFloat64Array(t).join(\", \");\n return `${t ? \"matrix\" : \"matrix3d\"}(${e})`;\n }\n /**\n * Returns a JSON representation of the `CSSMatrix` instance, a standard *Object*\n * that includes `{a,b,c,d,e,f}` and `{m11,m12,m13,..m44}` properties as well\n * as the `is2D` & `isIdentity` properties.\n *\n * The result can also be used as a second parameter for the `fromMatrix` static method\n * to load values into another matrix instance.\n *\n * @return an *Object* with all matrix values.\n */\n toJSON() {\n const { is2D: t, isIdentity: e } = this;\n return { ...this, is2D: t, isIdentity: e };\n }\n /**\n * The Multiply method returns a new CSSMatrix which is the result of this\n * matrix multiplied by the passed matrix, with the passed matrix to the right.\n * This matrix is not modified.\n *\n * @param m2 CSSMatrix\n * @return The resulted matrix.\n */\n multiply(t) {\n return N(this, t);\n }\n /**\n * The translate method returns a new matrix which is this matrix post\n * multiplied by a translation matrix containing the passed values. If the z\n * component is undefined, a 0 value is used in its place. This matrix is not\n * modified.\n *\n * @param x X component of the translation value.\n * @param y Y component of the translation value.\n * @param z Z component of the translation value.\n * @return The resulted matrix\n */\n translate(t, e, n) {\n const i = t;\n let r = e, a = n;\n return typeof r > \"u\" && (r = 0), typeof a > \"u\" && (a = 0), N(this, Y(i, r, a));\n }\n /**\n * The scale method returns a new matrix which is this matrix post multiplied by\n * a scale matrix containing the passed values. If the z component is undefined,\n * a 1 value is used in its place. If the y component is undefined, the x\n * component value is used in its place. This matrix is not modified.\n *\n * @param x The X component of the scale value.\n * @param y The Y component of the scale value.\n * @param z The Z component of the scale value.\n * @return The resulted matrix\n */\n scale(t, e, n) {\n const i = t;\n let r = e, a = n;\n return typeof r > \"u\" && (r = t), typeof a > \"u\" && (a = 1), N(this, I(i, r, a));\n }\n /**\n * The rotate method returns a new matrix which is this matrix post multiplied\n * by each of 3 rotation matrices about the major axes, first X, then Y, then Z.\n * If the y and z components are undefined, the x value is used to rotate the\n * object about the z axis, as though the vector (0,0,x) were passed. All\n * rotation values are in degrees. This matrix is not modified.\n *\n * @param rx The X component of the rotation, or Z if Y and Z are null.\n * @param ry The (optional) Y component of the rotation value.\n * @param rz The (optional) Z component of the rotation value.\n * @return The resulted matrix\n */\n rotate(t, e, n) {\n let i = t, r = e || 0, a = n || 0;\n return typeof t == \"number\" && typeof e > \"u\" && typeof n > \"u\" && (a = i, i = 0, r = 0), N(this, F(i, r, a));\n }\n /**\n * The rotateAxisAngle method returns a new matrix which is this matrix post\n * multiplied by a rotation matrix with the given axis and `angle`. The right-hand\n * rule is used to determine the direction of rotation. All rotation values are\n * in degrees. This matrix is not modified.\n *\n * @param x The X component of the axis vector.\n * @param y The Y component of the axis vector.\n * @param z The Z component of the axis vector.\n * @param angle The angle of rotation about the axis vector, in degrees.\n * @return The resulted matrix\n */\n rotateAxisAngle(t, e, n, i) {\n if ([t, e, n, i].some((r) => Number.isNaN(+r)))\n throw new TypeError(\"CSSMatrix: expecting 4 values\");\n return N(this, T(t, e, n, i));\n }\n /**\n * Specifies a skew transformation along the `x-axis` by the given angle.\n * This matrix is not modified.\n *\n * @param angle The angle amount in degrees to skew.\n * @return The resulted matrix\n */\n skewX(t) {\n return N(this, R(t));\n }\n /**\n * Specifies a skew transformation along the `y-axis` by the given angle.\n * This matrix is not modified.\n *\n * @param angle The angle amount in degrees to skew.\n * @return The resulted matrix\n */\n skewY(t) {\n return N(this, D(t));\n }\n /**\n * Specifies a skew transformation along both the `x-axis` and `y-axis`.\n * This matrix is not modified.\n *\n * @param angleX The X-angle amount in degrees to skew.\n * @param angleY The angle amount in degrees to skew.\n * @return The resulted matrix\n */\n skew(t, e) {\n return N(this, v(t, e));\n }\n /**\n * Transforms a specified vector using the matrix, returning a new\n * {x,y,z,w} Tuple *Object* comprising the transformed vector.\n * Neither the matrix nor the original vector are altered.\n *\n * The method is equivalent with `transformPoint()` method\n * of the `DOMMatrix` constructor.\n *\n * @param t Tuple with `{x,y,z,w}` components\n * @return the resulting Tuple\n */\n transformPoint(t) {\n const e = this.m11 * t.x + this.m21 * t.y + this.m31 * t.z + this.m41 * t.w, n = this.m12 * t.x + this.m22 * t.y + this.m32 * t.z + this.m42 * t.w, i = this.m13 * t.x + this.m23 * t.y + this.m33 * t.z + this.m43 * t.w, r = this.m14 * t.x + this.m24 * t.y + this.m34 * t.z + this.m44 * t.w;\n return t instanceof DOMPoint ? new DOMPoint(e, n, i, r) : {\n x: e,\n y: n,\n z: i,\n w: r\n };\n }\n}\np(y, \"Translate\", Y), p(y, \"Rotate\", F), p(y, \"RotateAxisAngle\", T), p(y, \"Scale\", I), p(y, \"SkewX\", R), p(y, \"SkewY\", D), p(y, \"Skew\", v), p(y, \"Multiply\", N), p(y, \"fromArray\", g), p(y, \"fromMatrix\", X), p(y, \"fromString\", O), p(y, \"toArray\", x), p(y, \"isCompatibleArray\", E), p(y, \"isCompatibleObject\", P);\nexport {\n y as default\n};\n//# sourceMappingURL=dommatrix.mjs.map\n","import { PointTuple } from \"../types\";\n\n/**\n * Returns the coordinates of a specified distance\n * ratio between two points.\n *\n * @param a the first point coordinates\n * @param b the second point coordinates\n * @param t the ratio\n * @returns the midpoint coordinates\n */\nconst midPoint = (a: PointTuple, b: PointTuple, t: number): PointTuple => {\n const [ax, ay] = a;\n const [bx, by] = b;\n return [ax + (bx - ax) * t, ay + (by - ay) * t];\n};\n\nexport default midPoint;\n","import { type PointTuple } from \"../types\";\n\n/**\n * Returns the square root of the distance\n * between two given points.\n *\n * @param a the first point coordinates\n * @param b the second point coordinates\n * @returns the distance value\n */\nconst distanceSquareRoot = (a: PointTuple, b: PointTuple) => {\n return Math.sqrt(\n (a[0] - b[0]) * (a[0] - b[0]) + (a[1] - b[1]) * (a[1] - b[1]),\n );\n};\n\nexport default distanceSquareRoot;\n","import midPoint from \"./midPoint\";\nimport distanceSquareRoot from \"./distanceSquareRoot\";\n\n/**\n * Returns length for line segments (MoveTo, LineTo).\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the line segment length\n */\nconst getLineLength = (x1: number, y1: number, x2: number, y2: number) => {\n return distanceSquareRoot([x1, y1], [x2, y2]);\n};\n\n/**\n * Returns a point along the line segments (MoveTo, LineTo).\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance the distance to point in [0-1] range\n * @returns the point at length\n */\nconst getPointAtLineLength = (\n x1: number,\n y1: number,\n x2: number,\n y2: number,\n distance?: number,\n) => {\n let point = { x: x1, y: y1 };\n\n /* istanbul ignore else @preserve */\n if (typeof distance === \"number\") {\n const length = distanceSquareRoot([x1, y1], [x2, y2]);\n if (distance <= 0) {\n point = { x: x1, y: y1 };\n } else if (distance >= length) {\n point = { x: x2, y: y2 };\n } else {\n const [x, y] = midPoint([x1, y1], [x2, y2], distance / length);\n point = { x, y };\n }\n }\n return point;\n};\n\n/**\n * Returns bounding box for line segments (MoveTo, LineTo).\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance the distance to point in [0-1] range\n * @returns the extrema for line segments\n */\nconst getLineBBox = (x1: number, y1: number, x2: number, y2: number) => {\n const { min, max } = Math;\n\n return [min(x1, x2), min(y1, y2), max(x1, x2), max(y1, y2)] as [\n number,\n number,\n number,\n number,\n ];\n};\n\nexport { getLineBBox, getLineLength, getPointAtLineLength };\n","import { getPointAtLineLength } from \"./lineTools\";\nimport type { Point, PointTuple } from \"../types\";\n\n/**\n * Returns the Arc segment length.\n * @param rx radius along X axis\n * @param ry radius along Y axis\n * @param theta the angle in radians\n * @returns the arc length\n */\nconst arcLength = (rx: number, ry: number, theta: number) => {\n const halfTheta = theta / 2;\n const sinHalfTheta = Math.sin(halfTheta);\n const cosHalfTheta = Math.cos(halfTheta);\n const term1 = rx ** 2 * sinHalfTheta ** 2;\n const term2 = ry ** 2 * cosHalfTheta ** 2;\n const length = Math.sqrt(term1 + term2) * theta;\n return Math.abs(length);\n};\n\n/**\n * Find point on ellipse at given angle around ellipse (theta);\n * @param cx the center X\n * @param cy the center Y\n * @param rx the radius X\n * @param ry the radius Y\n * @param alpha the arc rotation angle in radians\n * @param theta the arc sweep angle in radians\n * @returns a point around ellipse at given angle\n */\nconst arcPoint = (\n cx: number,\n cy: number,\n rx: number,\n ry: number,\n alpha: number,\n theta: number,\n) => {\n const { sin, cos } = Math;\n // theta is angle in radians around arc\n // alpha is angle of rotation of ellipse in radians\n const cosA = cos(alpha);\n const sinA = sin(alpha);\n const x = rx * cos(theta);\n const y = ry * sin(theta);\n\n return [cx + cosA * x - sinA * y, cy + sinA * x + cosA * y] as PointTuple;\n};\n\n/**\n * Returns the angle between two points.\n * @param v0 starting point\n * @param v1 ending point\n * @returns the angle in radian\n */\nconst angleBetween = (v0: Point, v1: Point) => {\n const { x: v0x, y: v0y } = v0;\n const { x: v1x, y: v1y } = v1;\n const p = v0x * v1x + v0y * v1y;\n const n = Math.sqrt((v0x ** 2 + v0y ** 2) * (v1x ** 2 + v1y ** 2));\n const sign = v0x * v1y - v0y * v1x < 0 ? -1 : 1;\n return sign * Math.acos(p / n);\n};\n\n/**\n * Returns the following properties for an Arc segment: center, start angle,\n * end angle, and radiuses on X and Y axis.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param RX the radius on X axis\n * @param RY the radius on Y axis\n * @param angle the ellipse rotation in degrees\n * @param LAF the large arc flag\n * @param SF the sweep flag\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns properties specific to Arc segments\n */\nconst getArcProps = (\n x1: number,\n y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n x: number,\n y: number,\n) => {\n const { abs, sin, cos, sqrt, PI } = Math;\n let rx = abs(RX);\n let ry = abs(RY);\n const xRot = ((angle % 360) + 360) % 360;\n const xRotRad = xRot * (PI / 180);\n\n // istanbul ignore next @preserve\n if (x1 === x && y1 === y) {\n return {\n rx,\n ry,\n startAngle: 0,\n endAngle: 0,\n center: { x, y },\n };\n }\n\n if (rx === 0 || ry === 0) {\n return {\n rx,\n ry,\n startAngle: 0,\n endAngle: 0,\n center: { x: (x + x1) / 2, y: (y + y1) / 2 },\n };\n }\n\n const dx = (x1 - x) / 2;\n const dy = (y1 - y) / 2;\n\n const transformedPoint = {\n x: cos(xRotRad) * dx + sin(xRotRad) * dy,\n y: -sin(xRotRad) * dx + cos(xRotRad) * dy,\n };\n\n const radiiCheck = transformedPoint.x ** 2 / rx ** 2 +\n transformedPoint.y ** 2 / ry ** 2;\n\n if (radiiCheck > 1) {\n rx *= sqrt(radiiCheck);\n ry *= sqrt(radiiCheck);\n }\n\n const cSquareNumerator = rx ** 2 * ry ** 2 -\n rx ** 2 * transformedPoint.y ** 2 - ry ** 2 * transformedPoint.x ** 2;\n const cSquareRootDenom = rx ** 2 * transformedPoint.y ** 2 +\n ry ** 2 * transformedPoint.x ** 2;\n\n let cRadicand = cSquareNumerator / cSquareRootDenom;\n /* istanbul ignore next @preserve */\n cRadicand = cRadicand < 0 ? 0 : cRadicand;\n const cCoef = (LAF !== SF ? 1 : -1) * sqrt(cRadicand);\n const transformedCenter = {\n x: cCoef * ((rx * transformedPoint.y) / ry),\n y: cCoef * (-(ry * transformedPoint.x) / rx),\n };\n\n const center = {\n x: cos(xRotRad) * transformedCenter.x - sin(xRotRad) * transformedCenter.y +\n (x1 + x) / 2,\n y: sin(xRotRad) * transformedCenter.x + cos(xRotRad) * transformedCenter.y +\n (y1 + y) / 2,\n };\n\n const startVector = {\n x: (transformedPoint.x - transformedCenter.x) / rx,\n y: (transformedPoint.y - transformedCenter.y) / ry,\n };\n\n const startAngle = angleBetween({ x: 1, y: 0 }, startVector);\n\n const endVector = {\n x: (-transformedPoint.x - transformedCenter.x) / rx,\n y: (-transformedPoint.y - transformedCenter.y) / ry,\n };\n\n let sweepAngle = angleBetween(startVector, endVector);\n if (!SF && sweepAngle > 0) {\n sweepAngle -= 2 * PI;\n } else if (SF && sweepAngle < 0) {\n sweepAngle += 2 * PI;\n }\n sweepAngle %= 2 * PI;\n\n const endAngle = startAngle + sweepAngle;\n\n // point.ellipticalArcStartAngle = startAngle;\n // point.ellipticalArcEndAngle = startAngle + sweepAngle;\n // point.ellipticalArcAngle = alpha;\n\n // point.ellipticalArcCenter = center;\n // point.resultantRx = rx;\n // point.resultantRy = ry;\n\n return {\n center,\n startAngle,\n endAngle,\n rx,\n ry,\n };\n};\n\n/**\n * Returns the length of an Arc segment.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the length of the Arc segment\n */\nconst getArcLength = (\n x1: number,\n y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n x: number,\n y: number,\n) => {\n const { rx, ry, startAngle, endAngle } = getArcProps(\n x1,\n y1,\n RX,\n RY,\n angle,\n LAF,\n SF,\n x,\n y,\n );\n return arcLength(rx, ry, endAngle - startAngle);\n};\n\n/**\n * Returns a point along an Arc segment at a given distance.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param RX the radius on X axis\n * @param RY the radius on Y axis\n * @param angle the ellipse rotation in degrees\n * @param LAF the large arc flag\n * @param SF the sweep flag\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance a [0-1] ratio\n * @returns a point along the Arc segment\n */\nconst getPointAtArcLength = (\n x1: number,\n y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n x: number,\n y: number,\n distance?: number,\n) => {\n let point = { x: x1, y: y1 };\n const { center, rx, ry, startAngle, endAngle } = getArcProps(\n x1,\n y1,\n RX,\n RY,\n angle,\n LAF,\n SF,\n x,\n y,\n );\n\n /* istanbul ignore else @preserve */\n if (typeof distance === \"number\") {\n const length = arcLength(rx, ry, endAngle - startAngle);\n if (distance <= 0) {\n point = { x: x1, y: y1 };\n } else if (distance >= length) {\n point = { x, y };\n } else {\n /* istanbul ignore next @preserve */\n if (x1 === x && y1 === y) {\n return { x, y };\n }\n /* istanbul ignore next @preserve */\n if (rx === 0 || ry === 0) {\n return getPointAtLineLength(x1, y1, x, y, distance);\n }\n const { PI, cos, sin } = Math;\n const sweepAngle = endAngle - startAngle;\n const xRot = ((angle % 360) + 360) % 360;\n const xRotRad = xRot * (PI / 180);\n const alpha = startAngle + sweepAngle * (distance / length);\n const ellipseComponentX = rx * cos(alpha);\n const ellipseComponentY = ry * sin(alpha);\n\n point = {\n x: cos(xRotRad) * ellipseComponentX - sin(xRotRad) * ellipseComponentY +\n center.x,\n y: sin(xRotRad) * ellipseComponentX + cos(xRotRad) * ellipseComponentY +\n center.y,\n };\n }\n }\n\n return point;\n};\n\n/**\n * Returns the extrema for an Arc segment in the following format:\n * [MIN_X, MIN_Y, MAX_X, MAX_Y]\n *\n * @see https://github.com/herrstrietzel/svg-pathdata-getbbox\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param RX the radius on X axis\n * @param RY the radius on Y axis\n * @param angle the ellipse rotation in degrees\n * @param LAF the large arc flag\n * @param SF the sweep flag\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the extrema of the Arc segment\n */\nconst getArcBBox = (\n x1: number,\n y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n x: number,\n y: number,\n) => {\n const { center, rx, ry, startAngle, endAngle } = getArcProps(\n x1,\n y1,\n RX,\n RY,\n angle,\n LAF,\n SF,\n x,\n y,\n );\n const deltaAngle = endAngle - startAngle;\n const { min, max, tan, atan2, PI } = Math;\n\n // circle/elipse center coordinates\n const { x: cx, y: cy } = center;\n\n // rotation to radians\n const alpha = (angle * PI) / 180;\n const tangent = tan(alpha);\n\n /**\n * find min/max from zeroes of directional derivative along x and y\n * along x axis\n */\n const theta = atan2(-ry * tangent, rx);\n const angle1 = theta;\n const angle2 = theta + PI;\n const angle3 = atan2(ry, rx * tangent);\n const angle4 = angle3 + PI;\n const xArray = [x];\n const yArray = [y];\n\n // inner bounding box\n let xMin = min(x1, x);\n let xMax = max(x1, x);\n let yMin = min(y1, y);\n let yMax = max(y1, y);\n\n // on path point close after start\n const angleAfterStart = endAngle - deltaAngle * 0.00001;\n const pP2 = arcPoint(cx, cy, rx, ry, alpha, angleAfterStart);\n\n // on path point close before end\n const angleBeforeEnd = endAngle - deltaAngle * 0.99999;\n const pP3 = arcPoint(cx, cy, rx, ry, alpha, angleBeforeEnd);\n\n /**\n * expected extremes\n * if leaving inner bounding box\n * (between segment start and end point)\n * otherwise exclude elliptic extreme points\n */\n\n // right\n if (pP2[0] > xMax || pP3[0] > xMax) {\n // get point for this theta\n const p1 = arcPoint(cx, cy, rx, ry, alpha, angle1);\n xArray.push(p1[0]);\n yArray.push(p1[1]);\n }\n\n // left\n if (pP2[0] < xMin || pP3[0] < xMin) {\n // get anti-symmetric point\n const p2 = arcPoint(cx, cy, rx, ry, alpha, angle2);\n xArray.push(p2[0]);\n yArray.push(p2[1]);\n }\n\n // top\n if (pP2[1] < yMin || pP3[1] < yMin) {\n // get anti-symmetric point\n const p4 = arcPoint(cx, cy, rx, ry, alpha, angle4);\n xArray.push(p4[0]);\n yArray.push(p4[1]);\n }\n\n // bottom\n if (pP2[1] > yMax || pP3[1] > yMax) {\n // get point for this theta\n const p3 = arcPoint(cx, cy, rx, ry, alpha, angle3);\n xArray.push(p3[0]);\n yArray.push(p3[1]);\n }\n\n xMin = min.apply([], xArray);\n yMin = min.apply([], yArray);\n xMax = max.apply([], xArray);\n yMax = max.apply([], yArray);\n\n return [xMin, yMin, xMax, yMax] as [number, number, number, number];\n};\n\nexport {\n angleBetween,\n arcLength,\n arcPoint,\n getArcBBox,\n getArcLength,\n getArcProps,\n getPointAtArcLength,\n};\n","import type {\n CubicCoordinates,\n CubicPoints,\n DeriveCallback,\n DerivedCubicPoints,\n DerivedPoint,\n DerivedQuadPoints,\n PointTuple,\n QuadCoordinates,\n QuadPoints,\n} from \"../types\";\n\n/**\n * Tools from bezier.js by Mike 'Pomax' Kamermans\n * @see https://github.com/Pomax/bezierjs\n */\n\nconst Tvalues = [\n -0.0640568928626056260850430826247450385909,\n 0.0640568928626056260850430826247450385909,\n -0.1911188674736163091586398207570696318404,\n 0.1911188674736163091586398207570696318404,\n -0.3150426796961633743867932913198102407864,\n 0.3150426796961633743867932913198102407864,\n -0.4337935076260451384870842319133497124524,\n 0.4337935076260451384870842319133497124524,\n -0.5454214713888395356583756172183723700107,\n 0.5454214713888395356583756172183723700107,\n -0.6480936519369755692524957869107476266696,\n 0.6480936519369755692524957869107476266696,\n -0.7401241915785543642438281030999784255232,\n 0.7401241915785543642438281030999784255232,\n -0.8200019859739029219539498726697452080761,\n 0.8200019859739029219539498726697452080761,\n -0.8864155270044010342131543419821967550873,\n 0.8864155270044010342131543419821967550873,\n -0.9382745520027327585236490017087214496548,\n 0.9382745520027327585236490017087214496548,\n -0.9747285559713094981983919930081690617411,\n 0.9747285559713094981983919930081690617411,\n -0.9951872199970213601799974097007368118745,\n 0.9951872199970213601799974097007368118745,\n];\n\nconst Cvalues = [\n 0.1279381953467521569740561652246953718517,\n 0.1279381953467521569740561652246953718517,\n 0.1258374563468282961213753825111836887264,\n 0.1258374563468282961213753825111836887264,\n 0.121670472927803391204463153476262425607,\n 0.121670472927803391204463153476262425607,\n 0.1155056680537256013533444839067835598622,\n 0.1155056680537256013533444839067835598622,\n 0.1074442701159656347825773424466062227946,\n 0.1074442701159656347825773424466062227946,\n 0.0976186521041138882698806644642471544279,\n 0.0976186521041138882698806644642471544279,\n 0.086190161531953275917185202983742667185,\n 0.086190161531953275917185202983742667185,\n 0.0733464814110803057340336152531165181193,\n 0.0733464814110803057340336152531165181193,\n 0.0592985849154367807463677585001085845412,\n 0.0592985849154367807463677585001085845412,\n 0.0442774388174198061686027482113382288593,\n 0.0442774388174198061686027482113382288593,\n 0.0285313886289336631813078159518782864491,\n 0.0285313886289336631813078159518782864491,\n 0.0123412297999871995468056670700372915759,\n 0.0123412297999871995468056670700372915759,\n];\n\n/**\n * @param points\n * @returns\n */\nconst deriveBezier = (points: QuadPoints | CubicPoints) => {\n const dpoints = [] as (DerivedCubicPoints | DerivedQuadPoints)[];\n for (let p = points, d = p.length, c = d - 1; d > 1; d -= 1, c -= 1) {\n const list = [] as unknown as DerivedCubicPoints | DerivedQuadPoints;\n for (let j = 0; j < c; j += 1) {\n list.push({\n x: c * (p[j + 1].x - p[j].x),\n y: c * (p[j + 1].y - p[j].y),\n t: 0,\n });\n }\n dpoints.push(list);\n p = list;\n }\n return dpoints;\n};\n\n/**\n * @param points\n * @param t\n */\nconst computeBezier = (\n points: DerivedQuadPoints | DerivedCubicPoints,\n t: number,\n) => {\n // shortcuts\n /* istanbul ignore next @preserve */\n if (t === 0) {\n points[0].t = 0;\n return points[0];\n }\n\n const order = points.length - 1;\n\n /* istanbul ignore next @preserve */\n if (t === 1) {\n points[order].t = 1;\n return points[order];\n }\n\n const mt = 1 - t;\n let p = points as typeof points | [\n DerivedPoint,\n DerivedPoint,\n DerivedPoint,\n DerivedPoint,\n ];\n\n // constant?\n /* istanbul ignore next @preserve */\n if (order === 0) {\n points[0].t = t;\n return points[0];\n }\n\n // linear?\n /* istanbul ignore else @preserve */\n if (order === 1) {\n return {\n x: mt * p[0].x + t * p[1].x,\n y: mt * p[0].y + t * p[1].y,\n t,\n };\n }\n\n // quadratic/cubic curve?\n const mt2 = mt * mt;\n const t2 = t * t;\n let a = 0;\n let b = 0;\n let c = 0;\n let d = 0;\n /* istanbul ignore else @preserve */\n if (order === 2) {\n p = [p[0], p[1], p[2], { x: 0, y: 0 } as DerivedPoint];\n a = mt2;\n b = mt * t * 2;\n c = t2;\n } else if (order === 3) {\n a = mt2 * mt;\n b = mt2 * t * 3;\n c = mt * t2 * 3;\n d = t * t2;\n }\n return {\n x: a * p[0].x + b * p[1].x + c * p[2].x + d * p[3].x,\n y: a * p[0].y + b * p[1].y + c * p[2].y + d * p[3].y,\n t,\n };\n};\n\nconst calculateBezier = (derivativeFn: DeriveCallback, t: number) => {\n const d = derivativeFn(t);\n const l = d.x * d.x + d.y * d.y;\n\n return Math.sqrt(l);\n};\n\nconst bezierLength = (derivativeFn: DeriveCallback) => {\n const z = 0.5;\n const len = Tvalues.length;\n\n let sum = 0;\n\n for (let i = 0, t; i < len; i++) {\n t = z * Tvalues[i] + z;\n sum += Cvalues[i] * calculateBezier(derivativeFn, t);\n }\n return z * sum;\n};\n\n/**\n * Returns the length of CubicBezier / Quad segment.\n * @param curve cubic / quad bezier segment\n */\nconst getBezierLength = (curve: CubicCoordinates | QuadCoordinates) => {\n const points = [] as unknown as CubicPoints | QuadPoints;\n for (let idx = 0, len = curve.length, step = 2; idx < len; idx += step) {\n points.push({\n x: curve[idx],\n y: curve[idx + 1],\n });\n }\n const dpoints = deriveBezier(points);\n return bezierLength((t: number) => {\n return computeBezier(dpoints[0], t);\n });\n};\n\n// Precision for consider cubic polynom as quadratic one\nconst CBEZIER_MINMAX_EPSILON = 0.00000001;\n\n/**\n * Returns the most extreme points in a Quad Bezier segment.\n * @param A an array which consist of X/Y values\n */\n// https://github.com/kpym/SVGPathy/blob/acd1a50c626b36d81969f6e98e8602e128ba4302/lib/box.js#L89\nconst minmaxQ = ([v1, cp, v2]: [number, number, number]) => {\n const min = Math.min(v1, v2);\n const max = Math.max(v1, v2);\n\n /* istanbul ignore next @preserve */\n if (cp >= v1 ? v2 >= cp : v2 <= cp) {\n // if no extremum in ]0,1[\n return [min, max] as PointTuple;\n }\n\n // check if the extremum E is min or max\n const E = (v1 * v2 - cp * cp) / (v1 - 2 * cp + v2);\n return (E < min ? [E, max] : [min, E]) as PointTuple;\n};\n\n/**\n * Returns the most extreme points in a Cubic Bezier segment.\n * @param A an array which consist of X/Y values\n * @see https://github.com/kpym/SVGPathy/blob/acd1a50c626b36d81969f6e98e8602e128ba4302/lib/box.js#L127\n */\nconst minmaxC = ([v1, cp1, cp2, v2]: [number, number, number, number]) => {\n const K = v1 - 3 * cp1 + 3 * cp2 - v2;\n\n // if the polynomial is (almost) quadratic and not cubic\n /* istanbul ignore next @preserve */\n if (Math.abs(K) < CBEZIER_MINMAX_EPSILON) {\n if (v1 === v2 && v1 === cp1) {\n // no curve, point targeting same location\n return [v1, v2] as PointTuple;\n }\n\n return minmaxQ([v1, -0.5 * v1 + 1.5 * cp1, v1 - 3 * cp1 + 3 * cp2]);\n }\n\n // the reduced discriminant of the derivative\n const T = -v1 * cp2 + v1 * v2 - cp1 * cp2 - cp1 * v2 + cp1 * cp1 + cp2 * cp2;\n\n // if the polynomial is monotone in [0,1]\n if (T <= 0) {\n return [Math.min(v1, v2), Math.max(v1, v2)] as PointTuple;\n }\n const S = Math.sqrt(T);\n\n // potential extrema\n let min = Math.min(v1, v2);\n let max = Math.max(v1, v2);\n\n const L = v1 - 2 * cp1 + cp2;\n // check local extrema\n for (let R = (L + S) / K, i = 1; i <= 2; R = (L - S) / K, i++) {\n // istanbul ignore next @preserve\n if (R > 0 && R < 1) {\n // if the extrema is for R in [0,1]\n const Q = v1 * (1 - R) * (1 - R) * (1 - R) +\n cp1 * 3 * (1 - R) * (1 - R) * R + cp2 * 3 * (1 - R) * R * R +\n v2 * R * R * R;\n if (Q < min) {\n min = Q;\n }\n if (Q > max) {\n max = Q;\n }\n }\n }\n\n return [min, max] as PointTuple;\n};\n\nexport {\n bezierLength,\n calculateBezier,\n CBEZIER_MINMAX_EPSILON,\n computeBezier,\n Cvalues,\n deriveBezier,\n getBezierLength,\n minmaxC,\n minmaxQ,\n Tvalues,\n};\n","import { getBezierLength, minmaxC } from \"./bezier\";\nimport { type CubicCoordinates } from \"../types\";\n\n/**\n * Returns a point at a given length of a CubicBezier segment.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param t a [0-1] ratio\n * @returns the point at cubic-bezier segment length\n */\nconst getPointAtCubicSegmentLength = (\n [x1, y1, c1x, c1y, c2x, c2y, x2, y2]: CubicCoordinates,\n t: number,\n) => {\n const t1 = 1 - t;\n return {\n x: t1 ** 3 * x1 + 3 * t1 ** 2 * t * c1x + 3 * t1 * t ** 2 * c2x +\n t ** 3 * x2,\n y: t1 ** 3 * y1 + 3 * t1 ** 2 * t * c1y + 3 * t1 * t ** 2 * c2y +\n t ** 3 * y2,\n };\n};\n\n/**\n * Returns the length of a CubicBezier segment.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the CubicBezier segment length\n */\nconst getCubicLength = (\n x1: number,\n y1: number,\n c1x: number,\n c1y: number,\n c2x: number,\n c2y: number,\n x2: number,\n y2: number,\n) => {\n return getBezierLength([x1, y1, c1x, c1y, c2x, c2y, x2, y2]);\n};\n\n/**\n * Returns the point along a CubicBezier segment at a given distance.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance the distance to look at\n * @returns the point at CubicBezier length\n */\nconst getPointAtCubicLength = (\n x1: number,\n y1: number,\n c1x: number,\n c1y: number,\n c2x: number,\n c2y: number,\n x2: number,\n y2: number,\n distance?: number,\n) => {\n const distanceIsNumber = typeof distance === \"number\";\n let point = { x: x1, y: y1 };\n /* istanbul ignore else @preserve */\n if (distanceIsNumber) {\n const currentLength = getBezierLength([x1, y1, c1x, c1y, c2x, c2y, x2, y2]);\n if (distance <= 0) {\n // first point already defined\n } else if (distance >= currentLength) {\n point = { x: x2, y: y2 };\n } else {\n point = getPointAtCubicSegmentLength(\n [x1, y1, c1x, c1y, c2x, c2y, x2, y2],\n distance / currentLength,\n );\n }\n }\n return point;\n};\n\n/**\n * Returns the boundig box of a CubicBezier segment in the following format:\n * [MIN_X, MIN_Y, MAX_X, MAX_Y]\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the extrema of the CubicBezier segment\n */\nconst getCubicBBox = (\n x1: number,\n y1: number,\n c1x: number,\n c1y: number,\n c2x: number,\n c2y: number,\n x2: number,\n y2: number,\n) => {\n const cxMinMax = minmaxC([x1, c1x, c2x, x2]);\n const cyMinMax = minmaxC([y1, c1y, c2y, y2]);\n\n return [cxMinMax[0], cyMinMax[0], cxMinMax[1], cyMinMax[1]] as [\n number,\n number,\n number,\n number,\n ];\n};\n\nexport {\n getCubicBBox,\n getCubicLength,\n getPointAtCubicLength,\n getPointAtCubicSegmentLength,\n};\n","import { getBezierLength, minmaxQ } from \"./bezier\";\nimport { type QuadCoordinates } from \"../types\";\n\n/**\n * Returns the {x,y} coordinates of a point at a\n * given length of a quadratic-bezier segment.\n *\n * @see https://github.com/substack/point-at-length\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param cx the control point X\n * @param cy the control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param t a [0-1] ratio\n * @returns the requested {x,y} coordinates\n */\nconst getPointAtQuadSegmentLength = (\n [x1, y1, cx, cy, x2, y2]: QuadCoordinates,\n t: number,\n) => {\n const t1 = 1 - t;\n return {\n x: t1 ** 2 * x1 + 2 * t1 * t * cx + t ** 2 * x2,\n y: t1 ** 2 * y1 + 2 * t1 * t * cy + t ** 2 * y2,\n };\n};\n\n/**\n * Returns the length of a QuadraticBezier segment.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param cx the control point X\n * @param cy the control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the QuadraticBezier segment length\n */\nconst getQuadLength = (\n x1: number,\n y1: number,\n cx: number,\n cy: number,\n x2: number,\n y2: number,\n) => {\n return getBezierLength([x1, y1, cx, cy, x2, y2]);\n};\n\n/**\n * Returns the point along a QuadraticBezier segment at a given distance.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param cx the control point X\n * @param cy the control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance the distance to look at\n * @returns the point at QuadraticBezier length\n */\nconst getPointAtQuadLength = (\n x1: number,\n y1: number,\n cx: number,\n cy: number,\n x2: number,\n y2: number,\n distance?: number,\n) => {\n const distanceIsNumber = typeof distance === \"number\";\n let point = { x: x1, y: y1 };\n\n /* istanbul ignore else @preserve */\n if (distanceIsNumber) {\n const currentLength = getBezierLength([x1, y1, cx, cy, x2, y2]);\n if (distance <= 0) {\n // first point already defined\n } else if (distance >= currentLength) {\n point = { x: x2, y: y2 };\n } else {\n point = getPointAtQuadSegmentLength(\n [x1, y1, cx, cy, x2, y2],\n distance / currentLength,\n );\n }\n }\n return point;\n};\n\n/**\n * Returns the boundig box of a QuadraticBezier segment in the following format:\n * [MIN_X, MIN_Y, MAX_X, MAX_Y]\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param cx the control point X\n * @param cy the control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the extrema of the QuadraticBezier segment\n */\nconst getQuadBBox = (\n x1: number,\n y1: number,\n cx: number,\n cy: number,\n x2: number,\n y2: number,\n) => {\n const cxMinMax = minmaxQ([x1, cx, x2]);\n const cyMinMax = minmaxQ([y1, cy, y2]);\n return [cxMinMax[0], cyMinMax[0], cxMinMax[1], cyMinMax[1]] as [\n number,\n number,\n number,\n number,\n ];\n};\n\nexport {\n getPointAtQuadLength,\n getPointAtQuadSegmentLength,\n getQuadBBox,\n getQuadLength,\n};\n","import distanceSquareRoot from \"./distanceSquareRoot\";\nimport { type PointTuple } from \"../types\";\n\n/**\n * d3-polygon-area\n * https://github.com/d3/d3-polygon\n *\n * Returns the area of a polygon.\n *\n * @param polygon an array of coordinates\n * @returns the polygon area\n */\nconst polygonArea = (polygon: PointTuple[]) => {\n const n = polygon.length;\n let i = -1;\n let a: PointTuple;\n let b = polygon[n - 1];\n let area = 0;\n\n /* eslint-disable-next-line */\n while (++i < n) {\n a = b;\n b = polygon[i];\n area += a[1] * b[0] - a[0] * b[1];\n }\n\n return area / 2;\n};\n\n/**\n * d3-polygon-length\n * https://github.com/d3/d3-polygon\n *\n * Returns the perimeter of a polygon.\n *\n * @param polygon an array of coordinates\n * @returns the polygon length\n */\nconst polygonLength = (polygon: PointTuple[]) => {\n return polygon.reduce((length, point, i) => {\n if (i) {\n return length + distanceSquareRoot(polygon[i - 1], point);\n }\n return 0;\n }, 0);\n};\n\nexport { polygonArea, polygonLength };\n","/** Segment params length */\nconst paramsCount = {\n a: 7,\n c: 6,\n h: 1,\n l: 2,\n m: 2,\n r: 4,\n q: 4,\n s: 4,\n t: 2,\n v: 1,\n z: 0,\n};\n\nexport default paramsCount;\n","import paramsCount from \"./paramsCount\";\nimport PathParser from \"./pathParser\";\nimport type { PathCommand, PathSegment, RelativeCommand } from \"../types\";\n\n/**\n * Breaks the parsing of a pathString once a segment is finalized.\n *\n * @param path the `PathParser` instance\n */\nconst finalizeSegment = (path: PathParser) => {\n let pathCommand = path.pathValue[path.segmentStart] as PathCommand;\n let relativeCommand = pathCommand.toLowerCase() as RelativeCommand;\n const { data } = path;\n\n while (data.length >= paramsCount[relativeCommand]) {\n // overloaded `moveTo`\n // https://github.com/rveciana/svg-path-properties/blob/master/src/parse.ts\n if (relativeCommand === \"m\" && data.length > 2) {\n path.segments.push(\n [pathCommand as PathCommand | number].concat(\n data.splice(0, 2) as number[],\n ) as PathSegment,\n );\n relativeCommand = \"l\";\n pathCommand = pathCommand === \"m\" ? \"l\" : \"L\";\n } else {\n path.segments.push(\n [pathCommand as PathCommand | number].concat(\n data.splice(0, paramsCount[relativeCommand]) as number[],\n ) as PathSegment,\n );\n }\n\n if (!paramsCount[relativeCommand]) {\n break;\n }\n }\n};\nexport default finalizeSegment;\n","const error = \"SVGPathCommander Error\";\nexport default error;\n","import error from \"./error\";\nimport type PathParser from \"./pathParser\";\n\n/**\n * Validates an A (arc-to) specific path command value.\n * Usually a `large-arc-flag` or `sweep-flag`.\n *\n * @param path the `PathParser` instance\n */\nconst scanFlag = (path: PathParser) => {\n const { index, pathValue } = path;\n const code = pathValue.charCodeAt(index);\n\n if (code === 0x30 /* 0 */) {\n path.param = 0;\n path.index += 1;\n return;\n }\n\n if (code === 0x31 /* 1 */) {\n path.param = 1;\n path.index += 1;\n return;\n }\n\n path.err = `${error}: invalid Arc flag \"${\n pathValue[index]\n }\", expecting 0 or 1 at index ${index}`;\n};\n\nexport default scanFlag;\n","import { DigitNumber } from \"../types\";\n\n/**\n * Checks if a character is a digit.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isDigit = (code: number): code is DigitNumber => {\n return code >= 48 && code <= 57; // 0..9\n};\nexport default isDigit;\n","const invalidPathValue = \"Invalid path value\";\nexport default invalidPathValue;\n","import isDigit from \"./isDigit\";\nimport invalidPathValue from \"./invalidPathValue\";\nimport error from \"./error\";\nimport type PathParser from \"./pathParser\";\n\n/**\n * Validates every character of the path string,\n * every path command, negative numbers or floating point numbers.\n *\n * @param path the `PathParser` instance\n */\nconst scanParam = (path: PathParser) => {\n const { max, pathValue, index: start } = path;\n let index = start;\n let zeroFirst = false;\n let hasCeiling = false;\n let hasDecimal = false;\n let hasDot = false;\n let ch;\n\n if (index >= max) {\n path.err =\n `${error}: ${invalidPathValue} at index ${index}, \"pathValue\" is missing param`;\n return;\n }\n ch = pathValue.charCodeAt(index);\n\n if (ch === 0x2b /* + */ || ch === 0x2d /* - */) {\n index += 1;\n // ch = (index < max) ? pathValue.charCodeAt(index) : 0;\n ch = pathValue.charCodeAt(index);\n }\n\n // This logic is shamelessly borrowed from Esprima\n // https://github.com/ariya/esprimas\n if (!isDigit(ch) && ch !== 0x2e /* . */) {\n // path.err = 'SvgPath: param should start with 0..9 or `.` (at pos ' + index + ')';\n path.err = `${error}: ${invalidPathValue} at index ${index}, \"${\n pathValue[index]\n }\" is not a number`;\n return;\n }\n\n if (ch !== 0x2e /* . */) {\n zeroFirst = ch === 0x30 /* 0 */;\n index += 1;\n\n ch = pathValue.charCodeAt(index);\n\n if (zeroFirst && index < max) {\n // decimal number starts with '0' such as '09' is illegal.\n if (ch && isDigit(ch)) {\n // path.err = 'SvgPath: numbers started with `0` such as `09`\n // are illegal (at pos ' + start + ')';\n path.err = `${error}: ${invalidPathValue} at index ${start}, \"${\n pathValue[start]\n }\" illegal number`;\n return;\n }\n }\n\n while (index < max && isDigit(pathValue.charCodeAt(index))) {\n index += 1;\n hasCeiling = true;\n }\n\n ch = pathValue.charCodeAt(index);\n }\n\n if (ch === 0x2e /* . */) {\n hasDot = true;\n index += 1;\n while (isDigit(pathValue.charCodeAt(index))) {\n index += 1;\n hasDecimal = true;\n }\n\n ch = pathValue.charCodeAt(index);\n }\n\n if (ch === 0x65 /* e */ || ch === 0x45 /* E */) {\n if (hasDot && !hasCeiling && !hasDecimal) {\n path.err = `${error}: ${invalidPathValue} at index ${index}, \"${\n pathValue[index]\n }\" invalid float exponent`;\n return;\n }\n\n index += 1;\n\n ch = pathValue.charCodeAt(index);\n\n if (ch === 0x2b /* + */ || ch === 0x2d /* - */) {\n index += 1;\n }\n if (index < max && isDigit(pathValue.charCodeAt(index))) {\n while (index < max && isDigit(pathValue.charCodeAt(index))) {\n index += 1;\n }\n } else {\n path.err = `${error}: ${invalidPathValue} at index ${index}, \"${\n pathValue[index]\n }\" invalid integer exponent`;\n return;\n }\n }\n\n path.index = index;\n path.param = +path.pathValue.slice(start, index);\n};\nexport default scanParam;\n","import type { SpaceNumber } from \"../types\";\n\n/**\n * Checks if the character is a space.\n *\n * @param ch the character to check\n * @returns check result\n */\n\nconst isSpace = (ch: number): ch is SpaceNumber => {\n const allSpaces = [\n // Special spaces\n 0x1680,\n 0x180e,\n 0x2000,\n 0x2001,\n 0x2002,\n 0x2003,\n 0x2004,\n 0x2005,\n 0x2006,\n 0x2007,\n 0x2008,\n 0x2009,\n 0x200a,\n 0x202f,\n 0x205f,\n 0x3000,\n 0xfeff,\n // Line terminators\n 0x0a,\n 0x0d,\n 0x2028,\n 0x2029,\n // White spaces\n 0x20,\n 0x09,\n 0x0b,\n 0x0c,\n 0xa0,\n ];\n\n return allSpaces.includes(ch);\n};\nexport default isSpace;\n","import isSpace from \"./isSpace\";\nimport type PathParser from \"./pathParser\";\n\n/**\n * Points the parser to the next character in the\n * path string every time it encounters any kind of\n * space character.\n *\n * @param path the `PathParser` instance\n */\nconst skipSpaces = (path: PathParser) => {\n const { pathValue, max } = path;\n while (path.index < max && isSpace(pathValue.charCodeAt(path.index))) {\n path.index += 1;\n }\n};\nexport default skipSpaces;\n","import type { PathCommandNumber } from \"../types\";\n\n/**\n * Checks if the character is a path command.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isPathCommand = (code: number): code is PathCommandNumber => {\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy\n switch (code | 0x20) {\n case 0x6d /* m */:\n case 0x7a /* z */:\n case 0x6c /* l */:\n case 0x68 /* h */:\n case 0x76 /* v */:\n case 0x63 /* c */:\n case 0x73 /* s */:\n case 0x71 /* q */:\n case 0x74 /* t */:\n case 0x61 /* a */:\n // case 0x72/* r */:\n return true;\n default:\n return false;\n }\n};\nexport default isPathCommand;\n","import isDigit from \"./isDigit\";\nimport type { DigitNumber } from \"../types\";\n\n/**\n * Checks if the character is or belongs to a number.\n * [0-9]|+|-|.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isDigitStart = (\n code: number,\n): code is DigitNumber | 0x2b | 0x2d | 0x2e => {\n return isDigit(code) /* 0..9 */ || code === 0x2b /* + */ ||\n code === 0x2d /* - */ || code === 0x2e; /* . */\n};\nexport default isDigitStart;\n","/**\n * Checks if the character is an A (arc-to) path command.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isArcCommand = (code: number): code is 0x61 => {\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy\n return (code | 0x20) === 0x61;\n};\nexport default isArcCommand;\n","/**\n * Checks if the character is a MoveTo command.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isMoveCommand = (code: number): code is 0x6d | 0x4d => {\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy\n switch (code | 0x20) {\n case 0x6d /* m */:\n case 0x4d /* M */:\n return true;\n default:\n return false;\n }\n};\nexport default isMoveCommand;\n","import finalizeSegment from \"./finalizeSegment\";\nimport paramCounts from \"./paramsCount\";\nimport scanFlag from \"./scanFlag\";\nimport scanParam from \"./scanParam\";\nimport skipSpaces from \"./skipSpaces\";\nimport isPathCommand from \"./isPathCommand\";\nimport isDigitStart from \"./isDigitStart\";\nimport isArcCommand from \"./isArcCommand\";\nimport isMoveCommand from \"./isMoveCommand\";\nimport invalidPathValue from \"./invalidPathValue\";\nimport error from \"./error\";\n\nimport type PathParser from \"./pathParser\";\nimport type { PathSegment, RelativeCommand } from \"../types\";\n\n/**\n * Scans every character in the path string to determine\n * where a segment starts and where it ends.\n *\n * @param path the `PathParser` instance\n */\nconst scanSegment = (path: PathParser) => {\n const { max, pathValue, index, segments } = path;\n const cmdCode = pathValue.charCodeAt(index);\n const reqParams =\n paramCounts[pathValue[index].toLowerCase() as RelativeCommand];\n\n path.segmentStart = index;\n\n // segments always start with a path command\n if (!isPathCommand(cmdCode)) {\n path.err = `${error}: ${invalidPathValue} \"${\n pathValue[index]\n }\" is not a path command at index ${index}`;\n return;\n }\n\n // after a Z segment, we only expect a MoveTo path command\n const lastSegment = segments[segments.length - 1] as PathSegment | undefined;\n if (\n !isMoveCommand(cmdCode) && lastSegment?.[0]?.toLocaleLowerCase() === \"z\"\n ) {\n path.err = `${error}: ${invalidPathValue} \"${\n pathValue[index]\n }\" is not a MoveTo path command at index ${index}`;\n return;\n }\n\n path.index += 1;\n skipSpaces(path);\n\n path.data = [];\n\n if (!reqParams) {\n // Z\n finalizeSegment(path);\n return;\n }\n\n for (;;) {\n for (let i = reqParams; i > 0; i -= 1) {\n if (isArcCommand(cmdCode) && (i === 3 || i === 4)) scanFlag(path);\n else scanParam(path);\n\n if (path.err.length) {\n return;\n }\n path.data.push(path.param);\n\n skipSpaces(path);\n\n // after ',' param is mandatory\n if (\n path.index < max && pathValue.charCodeAt(path.index) === 0x2c /* , */\n ) {\n path.index += 1;\n skipSpaces(path);\n }\n }\n\n if (path.index >= path.max) {\n break;\n }\n\n // Stop on next segment\n if (!isDigitStart(pathValue.charCodeAt(path.index))) {\n break;\n }\n }\n\n finalizeSegment(path);\n};\nexport default scanSegment;\n","import type { PathArray, PathSegment } from \"../types\";\n\n/**\n * The `PathParser` is used by the `parsePathString` static method\n * to generate a `pathArray`.\n *\n * @param pathString\n */\nexport default class PathParser {\n declare segments: PathArray | PathSegment[];\n declare pathValue: string;\n declare max: number;\n declare index: number;\n declare param: number;\n declare segmentStart: number;\n declare data: (string | number)[];\n declare err: string;\n\n constructor(pathString: string) {\n this.segments = [];\n this.pathValue = pathString;\n this.max = pathString.length;\n this.index = 0;\n this.param = 0.0;\n this.segmentStart = 0;\n this.data = [];\n this.err = \"\";\n }\n}\n","import scanSegment from \"./scanSegment\";\nimport skipSpaces from \"./skipSpaces\";\nimport PathParser from \"./pathParser\";\nimport type { PathArray } from \"../types\";\n\n/**\n * Parses a path string value and returns an array\n * of segments we like to call `pathArray`.\n *\n * @param pathInput the string to be parsed\n * @returns the resulted `pathArray` or error string\n */\nconst parsePathString = (pathInput: string | T) => {\n if (typeof pathInput !== \"string\") {\n return pathInput.slice(0) as typeof pathInput;\n }\n\n const path = new PathParser(pathInput);\n\n skipSpaces(path);\n\n while (path.index < path.max && !path.err.length) {\n scanSegment(path);\n }\n\n // handle valid paths first\n // handle errors second\n if (!path.err.length) {\n if (path.segments.length) {\n /**\n * force absolute first M\n * getPathBBox calculation requires first segment to be absolute\n * @see https://github.com/thednp/svg-path-commander/pull/49\n */\n path.segments[0][0] = \"M\";\n }\n } else {\n throw TypeError(path.err);\n }\n\n return path.segments as PathArray;\n};\n\nexport default parsePathString;\n","import type {\n AbsoluteCommand,\n AbsoluteSegment,\n ASegment,\n CSegment,\n HSegment,\n LSegment,\n MSegment,\n PathSegment,\n QSegment,\n SSegment,\n TSegment,\n VSegment,\n} from \"../types\";\n\n/**\n * Returns an absolute segment of a `PathArray` object.\n *\n * @param segment the segment object\n * @param index the segment index\n * @param lastX the last known X value\n * @param lastY the last known Y value\n * @returns the absolute segment\n */\nconst absolutizeSegment = (\n segment: PathSegment,\n index: number,\n lastX: number,\n lastY: number,\n) => {\n const [pathCommand] = segment;\n const absCommand = pathCommand.toUpperCase() as AbsoluteCommand;\n const isAbsolute = absCommand === pathCommand;\n\n /* istanbul ignore else @preserve */\n if (index === 0 || isAbsolute) return segment as MSegment | AbsoluteSegment;\n // const values = segment.slice(1) as number[];\n if (absCommand === \"A\") {\n return [\n absCommand,\n segment[1],\n segment[2],\n segment[3],\n segment[4],\n segment[5],\n (segment as ASegment)[6] + lastX,\n (segment as ASegment)[7] + lastY,\n ] as ASegment;\n } else if (absCommand === \"V\") {\n return [absCommand, (segment as VSegment)[1] + lastY] as VSegment;\n } else if (absCommand === \"H\") {\n return [absCommand, (segment as HSegment)[1] + lastX] as HSegment;\n } else if (absCommand === \"L\") {\n return [\n absCommand,\n (segment as LSegment)[1] + lastX,\n (segment as LSegment)[2] + lastY,\n ] as LSegment;\n } else {\n // use brakets for `eslint: no-case-declaration`\n // https://stackoverflow.com/a/50753272/803358\n const absValues = [] as number[];\n const seglen = segment.length;\n for (let j = 1; j < seglen; j += 1) {\n absValues.push((segment[j] as number) + (j % 2 ? lastX : lastY));\n }\n // for c, s, q, t\n return [absCommand as typeof absCommand | number].concat(absValues) as\n | MSegment\n | QSegment\n | TSegment\n | SSegment\n | CSegment;\n }\n};\nexport default absolutizeSegment;\n","// import paramsParser from '../parser/paramsParser';\nimport type {\n AbsoluteCommand,\n IteratorCallback,\n PathArray,\n PathCommand,\n PathSegment,\n} from \"../types\";\n\nconst iterate = (\n path: PathArray,\n iterator: IteratorCallback,\n) => {\n let pathLen = path.length;\n let segment: PathSegment;\n let pathCommand = \"M\" as PathCommand;\n let absCommand = \"M\" as AbsoluteCommand;\n let isRelative = false;\n let x = 0;\n let y = 0;\n let mx = 0;\n let my = 0;\n let segLen = 0;\n\n for (let i = 0; i < pathLen; i += 1) {\n segment = path[i];\n [pathCommand] = segment;\n segLen = segment.length;\n absCommand = pathCommand.toUpperCase() as AbsoluteCommand;\n isRelative = absCommand !== pathCommand;\n\n const iteratorResult = iterator(segment, i, x, y);\n // some methods like getPointAtLength would like to break\n // when task is complete\n if (iteratorResult === false) {\n break;\n }\n\n // segment = path[i];\n if (absCommand === \"Z\") {\n x = mx;\n y = my;\n } else if (absCommand === \"H\") {\n x = (segment[1] as number) + (isRelative ? x : 0);\n } else if (absCommand === \"V\") {\n y = (segment[1] as number) + (isRelative ? y : 0);\n } else {\n x = (segment[segLen - 2] as number) + (isRelative ? x : 0);\n y = (segment[segLen - 1] as number) + (isRelative ? y : 0);\n\n if (absCommand === \"M\") {\n mx = x;\n my = y;\n }\n }\n\n if (iteratorResult) {\n path[i] = iteratorResult;\n if (iteratorResult[0] === \"C\") {\n pathLen = path.length;\n }\n }\n }\n return path as T;\n};\n\nexport default iterate;\n","import parsePathString from \"../parser/parsePathString\";\nimport absolutizeSegment from \"../process/absolutizeSegment\";\nimport type { AbsoluteArray, PathArray } from \"../types\";\nimport iterate from \"../process/iterate\";\n\n/**\n * Parses a path string value or object and returns an array\n * of segments, all converted to absolute values.\n *\n * @param pathInput the path string | object\n * @returns the resulted `pathArray` with absolute values\n */\nconst pathToAbsolute = (pathInput: string | PathArray) => {\n const path = parsePathString(pathInput);\n\n return iterate(path, absolutizeSegment);\n};\nexport default pathToAbsolute;\n","import type {\n aSegment,\n cSegment,\n hSegment,\n lSegment,\n MSegment,\n PathSegment,\n qSegment,\n RelativeCommand,\n RelativeSegment,\n sSegment,\n tSegment,\n vSegment,\n} from \"../types\";\n\n/**\n * Returns a relative segment of a `PathArray` object.\n *\n * @param segment the segment object\n * @param index the segment index\n * @param lastX the last known X value\n * @param lastY the last known Y value\n * @returns the relative segment\n */\nconst relativizeSegment = (\n segment: PathSegment,\n index: number,\n lastX: number,\n lastY: number,\n) => {\n const [pathCommand] = segment;\n const relCommand = pathCommand.toLowerCase() as RelativeCommand;\n const isRelative = pathCommand === relCommand;\n\n /* istanbul ignore else @preserve */\n if (index === 0 || isRelative) return segment as MSegment | RelativeSegment;\n\n if (relCommand === \"a\") {\n return [\n relCommand,\n segment[1],\n segment[2],\n segment[3],\n segment[4],\n segment[5],\n (segment as aSegment)[6] - lastX,\n (segment as aSegment)[7] - lastY,\n ] as aSegment;\n } else if (relCommand === \"v\") {\n return [relCommand, (segment as vSegment)[1] - lastY] as vSegment;\n } else if (relCommand === \"h\") {\n return [relCommand, (segment as hSegment)[1] - lastX] as hSegment;\n } else if (relCommand === \"l\") {\n return [\n relCommand,\n (segment as lSegment)[1] - lastX,\n (segment as lSegment)[2] - lastY,\n ] as lSegment;\n } else {\n // use brakets for `eslint: no-case-declaration`\n // https://stackoverflow.com/a/50753272/803358\n const relValues = [] as number[];\n const seglen = segment.length;\n for (let j = 1; j < seglen; j += 1) {\n relValues.push((segment[j] as number) - (j % 2 ? lastX : lastY));\n }\n // for c, s, q, t\n return [relCommand as RelativeCommand | number].concat(relValues) as\n | qSegment\n | tSegment\n | sSegment\n | cSegment;\n }\n};\n\nexport default relativizeSegment;\n","import type { PathArray, RelativeArray } from \"../types\";\nimport parsePathString from \"../parser/parsePathString\";\nimport iterate from \"../process/iterate\";\nimport relativizeSegment from \"../process/relativizeSegment\";\n\n/**\n * Parses a path string value or object and returns an array\n * of segments, all converted to relative values.\n *\n * @param pathInput the path string | object\n * @returns the resulted `pathArray` with relative values\n */\nconst pathToRelative = (pathInput: string | PathArray): RelativeArray => {\n const path = parsePathString(pathInput);\n\n return iterate(path, relativizeSegment);\n};\nexport default pathToRelative;\n","/**\n * Returns an {x,y} vector rotated by a given\n * angle in radian.\n *\n * @param x the initial vector x\n * @param y the initial vector y\n * @param rad the radian vector angle\n * @returns the rotated vector\n */\nconst rotateVector = (\n x: number,\n y: number,\n rad: number,\n): { x: number; y: number } => {\n const { sin, cos } = Math;\n const X = x * cos(rad) - y * sin(rad);\n const Y = x * sin(rad) + y * cos(rad);\n return { x: X, y: Y };\n};\n\nexport default rotateVector;\n","import rotateVector from \"../math/rotateVector\";\n\n/**\n * Converts A (arc-to) segments to C (cubic-bezier-to).\n *\n * For more information of where this math came from visit:\n * http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes\n *\n * @param X1 the starting x position\n * @param Y1 the starting y position\n * @param RX x-radius of the arc\n * @param RY y-radius of the arc\n * @param angle x-axis-rotation of the arc\n * @param LAF large-arc-flag of the arc\n * @param SF sweep-flag of the arc\n * @param X2 the ending x position\n * @param Y2 the ending y position\n * @param recursive the parameters needed to split arc into 2 segments\n * @return the resulting cubic-bezier segment(s)\n */\nconst arcToCubic = (\n X1: number,\n Y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n X2: number,\n Y2: number,\n recursive?: [number, number, number, number],\n): number[] => {\n let x1 = X1;\n let y1 = Y1;\n let rx = RX;\n let ry = RY;\n let x2 = X2;\n let y2 = Y2;\n // for more information of where this Math came from visit:\n // http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes\n const d120 = (Math.PI * 120) / 180;\n\n const rad = (Math.PI / 180) * (+angle || 0);\n let res = [] as number[];\n let xy;\n let f1;\n let f2;\n let cx;\n let cy;\n\n if (!recursive) {\n xy = rotateVector(x1, y1, -rad);\n x1 = xy.x;\n y1 = xy.y;\n xy = rotateVector(x2, y2, -rad);\n x2 = xy.x;\n y2 = xy.y;\n\n const x = (x1 - x2) / 2;\n const y = (y1 - y2) / 2;\n let h = (x * x) / (rx * rx) + (y * y) / (ry * ry);\n if (h > 1) {\n h = Math.sqrt(h);\n rx *= h;\n ry *= h;\n }\n const rx2 = rx * rx;\n const ry2 = ry * ry;\n\n const k = (LAF === SF ? -1 : 1) *\n Math.sqrt(\n Math.abs(\n (rx2 * ry2 - rx2 * y * y - ry2 * x * x) / (rx2 * y * y + ry2 * x * x),\n ),\n );\n\n cx = (k * rx * y) / ry + (x1 + x2) / 2;\n cy = (k * -ry * x) / rx + (y1 + y2) / 2;\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy no-bitwise\n f1 = Math.asin(((((y1 - cy) / ry) * 10 ** 9) >> 0) / 10 ** 9);\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy no-bitwise\n f2 = Math.asin(((((y2 - cy) / ry) * 10 ** 9) >> 0) / 10 ** 9);\n\n f1 = x1 < cx ? Math.PI - f1 : f1;\n f2 = x2 < cx ? Math.PI - f2 : f2;\n if (f1 < 0) f1 = Math.PI * 2 + f1;\n if (f2 < 0) f2 = Math.PI * 2 + f2;\n if (SF && f1 > f2) {\n f1 -= Math.PI * 2;\n }\n if (!SF && f2 > f1) {\n f2 -= Math.PI * 2;\n }\n } else {\n [f1, f2, cx, cy] = recursive;\n }\n let df = f2 - f1;\n if (Math.abs(df) > d120) {\n const f2old = f2;\n const x2old = x2;\n const y2old = y2;\n f2 = f1 + d120 * (SF && f2 > f1 ? 1 : -1);\n x2 = cx + rx * Math.cos(f2);\n y2 = cy + ry * Math.sin(f2);\n res = arcToCubic(x2, y2, rx, ry, angle, 0, SF, x2old, y2old, [\n f2,\n f2old,\n cx,\n cy,\n ]);\n }\n df = f2 - f1;\n const c1 = Math.cos(f1);\n const s1 = Math.sin(f1);\n const c2 = Math.cos(f2);\n const s2 = Math.sin(f2);\n const t = Math.tan(df / 4);\n const hx = (4 / 3) * rx * t;\n const hy = (4 / 3) * ry * t;\n const m1 = [x1, y1];\n const m2 = [x1 + hx * s1, y1 - hy * c1];\n const m3 = [x2 + hx * s2, y2 - hy * c2];\n const m4 = [x2, y2];\n m2[0] = 2 * m1[0] - m2[0];\n m2[1] = 2 * m1[1] - m2[1];\n if (recursive) {\n return [m2[0], m2[1], m3[0], m3[1], m4[0], m4[1]].concat(res);\n }\n res = [m2[0], m2[1], m3[0], m3[1], m4[0], m4[1]].concat(res);\n const newres = [];\n for (let i = 0, ii = res.length; i < ii; i += 1) {\n newres[i] = i % 2\n ? rotateVector(res[i - 1], res[i], rad).y\n : rotateVector(res[i], res[i + 1], rad).x;\n }\n return newres;\n};\nexport default arcToCubic;\n","/**\n * Converts a Q (quadratic-bezier) segment to C (cubic-bezier).\n *\n * @param x1 curve start x\n * @param y1 curve start y\n * @param qx control point x\n * @param qy control point y\n * @param x2 curve end x\n * @param y2 curve end y\n * @returns the cubic-bezier segment\n */\nconst quadToCubic = (\n x1: number,\n y1: number,\n qx: number,\n qy: number,\n x2: number,\n y2: number,\n): [number, number, number, number, number, number] => {\n const r13 = 1 / 3;\n const r23 = 2 / 3;\n return [\n r13 * x1 + r23 * qx, // cpx1\n r13 * y1 + r23 * qy, // cpy1\n r13 * x2 + r23 * qx, // cpx2\n r13 * y2 + r23 * qy, // cpy2\n x2,\n y2, // x,y\n ];\n};\nexport default quadToCubic;\n","import midPoint from \"../math/midPoint\";\n\n/**\n * Converts an L (line-to) segment to C (cubic-bezier).\n *\n * @param x1 line start x\n * @param y1 line start y\n * @param x2 line end x\n * @param y2 line end y\n * @returns the cubic-bezier segment\n */\nconst lineToCubic = (x1: number, y1: number, x2: number, y2: number) => {\n const c1 = midPoint([x1, y1], [x2, y2], 1.0 / 3.0);\n const c2 = midPoint([x1, y1], [x2, y2], 2.0 / 3.0);\n return [c1[0], c1[1], c2[0], c2[1], x2, y2];\n};\nexport default lineToCubic;\n","import arcToCubic from \"./arcToCubic\";\nimport quadToCubic from \"./quadToCubic\";\nimport lineToCubic from \"./lineToCubic\";\nimport type { CSegment, MSegment, PathSegment } from \"../types\";\nimport type { ParserParams } from \"../interface\";\n\n/**\n * Converts any segment to C (cubic-bezier).\n *\n * @param segment the source segment\n * @param params the source segment parameters\n * @returns the cubic-bezier segment\n */\nconst segmentToCubic = (segment: PathSegment, params: ParserParams) => {\n const [pathCommand] = segment;\n const values = segment.slice(1).map(Number);\n const [x, y] = values;\n // let args;\n const { x1: px1, y1: py1, x: px, y: py } = params;\n\n if (!\"TQ\".includes(pathCommand)) {\n params.qx = null;\n params.qy = null;\n }\n\n if (pathCommand === \"M\") {\n params.x = x;\n params.y = y;\n return segment;\n } else if (pathCommand === \"A\") {\n return [\"C\" as string | number].concat(\n arcToCubic(\n px1,\n py1,\n values[0],\n values[1],\n values[2],\n values[3],\n values[4],\n values[5],\n values[6],\n ),\n ) as CSegment;\n } else if (pathCommand === \"Q\") {\n params.qx = x;\n params.qy = y;\n return [\"C\" as string | number].concat(\n quadToCubic(px1, py1, values[0], values[1], values[2], values[3]),\n ) as CSegment;\n } else if (pathCommand === \"L\") {\n return [\"C\" as string | number].concat(\n lineToCubic(px1, py1, x, y),\n ) as CSegment;\n } else if (pathCommand === \"Z\") {\n return [\"C\" as string | number].concat(\n lineToCubic(px1, py1, px, py),\n ) as CSegment;\n }\n\n return segment as MSegment | CSegment;\n};\nexport default segmentToCubic;\n","import type { ParserParams } from \"../interface\";\nimport type {\n ASegment,\n CSegment,\n HSegment,\n LSegment,\n MSegment,\n NormalSegment,\n PathCommand,\n PathSegment,\n PointTuple,\n QSegment,\n VSegment,\n} from \"../types\";\n\n/**\n * Normalizes a single segment of a `pathArray` object.\n *\n * @param segment the segment object\n * @param params the normalization parameters\n * @returns the normalized segment\n */\nconst normalizeSegment = (segment: PathSegment, params: ParserParams) => {\n const [pathCommand] = segment;\n const absCommand = pathCommand.toUpperCase();\n const isRelative = pathCommand !== absCommand;\n const { x1: px1, y1: py1, x2: px2, y2: py2, x, y } = params;\n const values = segment.slice(1) as number[];\n let absValues = values.map((n, j) => n + (isRelative ? (j % 2 ? y : x) : 0));\n\n if (!\"TQ\".includes(absCommand)) {\n // optional but good to be cautious\n params.qx = null;\n params.qy = null;\n }\n\n // istanbul ignore else @preserve\n if (absCommand === \"A\") {\n absValues = values.slice(0, -2).concat(\n values[5] + (isRelative ? x : 0),\n values[6] + (isRelative ? y : 0),\n );\n\n return [\"A\" as PathCommand | number].concat(absValues) as ASegment;\n } else if (absCommand === \"H\") {\n return [\n \"L\",\n (segment as HSegment)[1] + (isRelative ? x : 0),\n py1,\n ] as LSegment;\n } else if (absCommand === \"V\") {\n return [\n \"L\",\n px1,\n (segment as VSegment)[1] + (isRelative ? y : 0),\n ] as LSegment;\n } else if (absCommand === \"L\") {\n return [\n \"L\",\n (segment as LSegment)[1] + (isRelative ? x : 0),\n (segment as LSegment)[2] + (isRelative ? y : 0),\n ] as LSegment;\n } else if (absCommand === \"M\") {\n return [\n \"M\",\n (segment as MSegment)[1] + (isRelative ? x : 0),\n (segment as MSegment)[2] + (isRelative ? y : 0),\n ] as MSegment;\n } else if (absCommand === \"C\") {\n return [\"C\" as PathCommand | number].concat(absValues) as CSegment;\n } else if (absCommand === \"S\") {\n const x1 = px1 * 2 - px2;\n const y1 = py1 * 2 - py2;\n params.x1 = x1;\n params.y1 = y1;\n return [\"C\", x1, y1].concat(absValues) as CSegment;\n } else if (absCommand === \"T\") {\n const qx = px1 * 2 - (params.qx ? params.qx : /* istanbul ignore next */ 0);\n const qy = py1 * 2 - (params.qy ? params.qy : /* istanbul ignore next */ 0);\n params.qx = qx;\n params.qy = qy;\n return [\"Q\", qx, qy].concat(absValues) as QSegment;\n } else if (absCommand === \"Q\") {\n const [nqx, nqy] = absValues as PointTuple;\n params.qx = nqx;\n params.qy = nqy;\n return [\"Q\" as PathCommand | number].concat(absValues) as QSegment;\n } else if (absCommand === \"Z\") {\n return [\"Z\"] as NormalSegment;\n }\n\n // istanbul ignore next @preserve\n return segment as NormalSegment;\n};\nexport default normalizeSegment;\n","import type { ParserParams } from \"../interface\";\n\nconst paramsParser: ParserParams = {\n x1: 0,\n y1: 0,\n x2: 0,\n y2: 0,\n x: 0,\n y: 0,\n qx: null,\n qy: null,\n};\n\nexport default paramsParser;\n","import segmentToCubic from \"../process/segmentToCubic\";\nimport { AbsoluteCommand, CSegment, CurveArray, PathArray } from \"../types\";\nimport iterate from \"../process/iterate\";\nimport parsePathString from \"../parser/parsePathString\";\nimport normalizeSegment from \"../process/normalizeSegment\";\nimport paramsParser from \"../parser/paramsParser\";\n\n/**\n * Parses a path string value or 'pathArray' and returns a new one\n * in which all segments are converted to cubic-bezier.\n *\n * In addition, un-necessary `Z` segment is removed if previous segment\n * extends to the `M` segment.\n *\n * @param pathInput the string to be parsed or 'pathArray'\n * @returns the resulted `pathArray` converted to cubic-bezier\n */\nconst pathToCurve = (pathInput: string | PathArray): CurveArray => {\n const params = { ...paramsParser };\n const path = parsePathString(pathInput);\n\n return iterate(path, (seg, index, lastX, lastY) => {\n params.x = lastX;\n params.y = lastY;\n const normalSegment = normalizeSegment(seg, params);\n let result = segmentToCubic(normalSegment, params);\n const isLongArc = result[0] === \"C\" && result.length > 7;\n\n if (isLongArc) {\n path.splice(\n index + 1,\n 0,\n [\"C\" as AbsoluteCommand | number].concat(result.slice(7)) as CSegment,\n );\n result = result.slice(0, 7) as CSegment;\n }\n\n const seglen = result.length;\n params.x1 = +result[seglen - 2];\n params.y1 = +result[seglen - 1];\n params.x2 = +result[seglen - 4] || params.x1;\n params.y2 = +result[seglen - 3] || params.y1;\n\n return result;\n });\n};\nexport default pathToCurve;\n","import { Options } from \"../interface\";\n\n/** SVGPathCommander default options */\nconst defaultOptions: Options = {\n origin: [0, 0, 0],\n round: 4,\n};\n\nexport default defaultOptions;\n","const roundTo = (n: number, round: number) => {\n const pow = round >= 1 ? 10 ** round : 1;\n\n return round > 0 ? Math.round(n * pow) / pow : Math.round(n);\n};\n\nexport default roundTo;\n","import type { PathArray, PathSegment } from \"../types\";\nimport defaultOptions from \"../options/options\";\nimport roundTo from \"../math/roundTo\";\n\n/**\n * Returns a valid `d` attribute string value created\n * by rounding values and concatenating the `pathArray` segments.\n *\n * @param path the `pathArray` object\n * @param roundOption amount of decimals to round values to\n * @returns the concatenated path string\n */\nconst pathToString = (\n path: PathArray,\n roundOption?: number | \"off\",\n): string => {\n const pathLen = path.length;\n let { round } = defaultOptions;\n let segment = path[0] as PathSegment;\n let result = \"\";\n\n // allow for ZERO decimals\n round = roundOption === \"off\"\n ? roundOption\n : typeof roundOption === \"number\" && roundOption >= 0\n ? roundOption\n : typeof round === \"number\" && round >= 0\n ? round\n : /* istanbul ignore next @preserve */ \"off\";\n\n for (let i = 0; i < pathLen; i += 1) {\n segment = path[i];\n const [pathCommand] = segment;\n const values = segment.slice(1) as number[];\n result += pathCommand;\n if (round === \"off\") {\n result += values.join(\" \");\n } else {\n let j = 0;\n const valLen = values.length;\n while (j < valLen) {\n result += roundTo(values[j], round);\n if (j !== valLen - 1) result += \" \";\n j += 1;\n }\n }\n }\n\n return result;\n};\n\nexport default pathToString;\n","const DISTANCE_EPSILON = 0.00001;\n\nexport default DISTANCE_EPSILON;\n","import normalizeSegment from \"./normalizeSegment\";\nimport type { NormalArray, PathArray } from \"../types\";\nimport iterate from \"./iterate\";\nimport parsePathString from \"../parser/parsePathString\";\nimport paramsParser from \"../parser/paramsParser\";\n\n/**\n * Normalizes a `pathArray` object for further processing:\n * * convert segments to absolute values\n * * convert shorthand path commands to their non-shorthand notation\n *\n * @param pathInput the string to be parsed or 'pathArray'\n * @returns the normalized `pathArray`\n */\nconst normalizePath = (pathInput: string | PathArray) => {\n const path = parsePathString(pathInput);\n const params = { ...paramsParser };\n\n return iterate(path, (seg, _, lastX, lastY) => {\n params.x = lastX;\n params.y = lastY;\n const result = normalizeSegment(seg, params);\n\n const seglen = result.length;\n params.x1 = +result[seglen - 2];\n params.y1 = +result[seglen - 1];\n params.x2 = +result[seglen - 4] || params.x1;\n params.y2 = +result[seglen - 3] || params.y1;\n\n return result;\n });\n};\nexport default normalizePath;\n","import DISTANCE_EPSILON from \"./distanceEpsilon\";\nimport type { MSegment, PathArray, PointTuple } from \"../types\";\nimport iterate from \"../process/iterate\";\nimport { getLineLength, getPointAtLineLength } from \"../math/lineTools\";\nimport { getArcLength, getPointAtArcLength } from \"../math/arcTools\";\nimport { getCubicLength, getPointAtCubicLength } from \"../math/cubicTools\";\nimport { getPointAtQuadLength, getQuadLength } from \"../math/quadTools\";\nimport normalizePath from \"../process/normalizePath\";\n\n/**\n * Returns [x,y] coordinates of a point at a given length of a shape.\n *\n * @param pathInput the `pathArray` to look into\n * @param distance the length of the shape to look at\n * @returns the requested {x, y} point coordinates\n */\nconst getPointAtLength = (pathInput: string | PathArray, distance?: number) => {\n const path = normalizePath(pathInput);\n let isM = false;\n let data = [] as number[];\n let pathCommand = \"M\";\n let x = 0;\n let y = 0;\n let [mx, my] = path[0].slice(1) as PointTuple;\n const distanceIsNumber = typeof distance === \"number\";\n let point = { x: mx, y: my };\n let length = 0;\n let POINT = point;\n let totalLength = 0;\n\n if (!distanceIsNumber || distance < DISTANCE_EPSILON) return point;\n\n // for (let i = 0; i < pathLen; i += 1) {\n iterate(path, (seg, _, lastX, lastY) => {\n [pathCommand] = seg;\n isM = pathCommand === \"M\";\n data = !isM ? [lastX, lastY].concat(seg.slice(1) as number[]) : data;\n\n // this segment is always ZERO\n /* istanbul ignore else @preserve */\n if (isM) {\n // remember mx, my for Z\n [, mx, my] = seg as MSegment;\n point = { x: mx, y: my };\n length = 0;\n } else if (pathCommand === \"L\") {\n point = getPointAtLineLength(\n data[0],\n data[1],\n data[2],\n data[3],\n distance - totalLength,\n );\n length = getLineLength(data[0], data[1], data[2], data[3]);\n } else if (pathCommand === \"A\") {\n point = getPointAtArcLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n data[6],\n data[7],\n data[8],\n distance - totalLength,\n );\n length = getArcLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n data[6],\n data[7],\n data[8],\n );\n } else if (pathCommand === \"C\") {\n point = getPointAtCubicLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n data[6],\n data[7],\n distance - totalLength,\n );\n length = getCubicLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n data[6],\n data[7],\n );\n } else if (pathCommand === \"Q\") {\n point = getPointAtQuadLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n distance - totalLength,\n );\n length = getQuadLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n );\n } else if (pathCommand === \"Z\") {\n data = [lastX, lastY, mx, my];\n point = { x: mx, y: my };\n\n length = getLineLength(data[0], data[1], data[2], data[3]);\n }\n\n [x, y] = data.slice(-2);\n\n if (totalLength < distance) {\n POINT = point;\n } else {\n // totalLength >= distance\n // stop right here\n // stop iterator now!\n return false;\n }\n\n totalLength += length;\n return;\n });\n\n // native `getPointAtLength` behavior when the given distance\n // is higher than total length\n if (distance > totalLength - DISTANCE_EPSILON) {\n return { x, y };\n }\n\n return POINT;\n};\n\nexport default getPointAtLength;\n","import type { LSegment, MSegment, PathArray, PointTuple } from \"../types\";\nimport { getLineLength } from \"../math/lineTools\";\nimport { getArcLength } from \"../math/arcTools\";\nimport { getCubicLength } from \"../math/cubicTools\";\nimport { getQuadLength } from \"../math/quadTools\";\nimport iterate from \"../process/iterate\";\nimport parsePathString from \"../parser/parsePathString\";\nimport absolutizeSegment from \"../process/absolutizeSegment\";\n\n/**\n * Returns the shape total length, or the equivalent to `shape.getTotalLength()`.\n *\n * @param pathInput the target `pathArray`\n * @returns the shape total length\n */\nconst getTotalLength = (pathInput: string | PathArray) => {\n const path = parsePathString(pathInput);\n let paramX1 = 0;\n let paramY1 = 0;\n let paramX2 = 0;\n let paramY2 = 0;\n let paramQX = 0;\n let paramQY = 0;\n let pathCommand = \"M\";\n let mx = 0;\n let my = 0;\n let totalLength = 0;\n\n iterate(path, (seg, index, lastX, lastY) => {\n [pathCommand] = seg;\n const absCommand = pathCommand.toUpperCase();\n const isRelative = absCommand !== pathCommand;\n const absoluteSegment = isRelative\n ? absolutizeSegment(seg, index, lastX, lastY)\n : (seg.slice(0) as typeof seg);\n\n const normalSegment = absCommand === \"V\"\n ? ([\"L\", lastX, absoluteSegment[1]] as LSegment)\n : absCommand === \"H\"\n ? ([\"L\", absoluteSegment[1], lastY] as LSegment)\n : absoluteSegment;\n [pathCommand] = normalSegment;\n\n if (!\"TQ\".includes(absCommand)) {\n // optional but good to be cautious\n paramQX = 0;\n paramQY = 0;\n }\n\n // this segment is always ZERO\n /* istanbul ignore else @preserve */\n if (pathCommand === \"M\") {\n // remember mx, my for Z\n [, mx, my] = normalSegment as MSegment;\n } else if (pathCommand === \"L\") {\n totalLength += getLineLength(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n );\n } else if (pathCommand === \"A\") {\n totalLength += getArcLength(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n normalSegment[5] as number,\n normalSegment[6] as number,\n normalSegment[7] as number,\n );\n } else if (pathCommand === \"S\") {\n const cp1x = paramX1 * 2 - paramX2;\n const cp1y = paramY1 * 2 - paramY2;\n\n totalLength += getCubicLength(\n lastX,\n lastY,\n cp1x,\n cp1y,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n );\n } else if (pathCommand === \"C\") {\n totalLength += getCubicLength(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n normalSegment[5] as number,\n normalSegment[6] as number,\n );\n } else if (pathCommand === \"T\") {\n paramQX = paramX1 * 2 - paramQX;\n paramQY = paramY1 * 2 - paramQY;\n totalLength += getQuadLength(\n lastX,\n lastY,\n paramQX,\n paramQY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n );\n } else if (pathCommand === \"Q\") {\n paramQX = normalSegment[1] as number;\n paramQY = normalSegment[2] as number;\n totalLength += getQuadLength(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n );\n } else if (pathCommand === \"Z\") {\n totalLength += getLineLength(lastX, lastY, mx, my);\n }\n\n // update params\n [paramX1, paramY1] = pathCommand === \"Z\"\n ? [mx, my]\n : (normalSegment.slice(-2) as PointTuple);\n [paramX2, paramY2] = pathCommand === \"C\"\n ? ([normalSegment[3], normalSegment[4]] as PointTuple)\n : pathCommand === \"S\"\n ? ([normalSegment[1], normalSegment[2]] as PointTuple)\n : [paramX1, paramY1];\n });\n\n return totalLength;\n};\n\nexport default getTotalLength;\n","import type { PathArray, PathSegment } from \"../types\";\nimport type { SegmentProperties } from \"../interface\";\nimport parsePathString from \"../parser/parsePathString\";\nimport getTotalLength from \"./getTotalLength\";\n\n/**\n * Returns the segment, its index and length as well as\n * the length to that segment at a given length in a path.\n *\n * @param pathInput target `pathArray`\n * @param distance the given length\n * @returns the requested properties\n */\nconst getPropertiesAtLength = (\n pathInput: string | PathArray,\n distance?: number,\n): SegmentProperties => {\n const pathArray = parsePathString(pathInput);\n\n let pathTemp = pathArray.slice(0) as PathArray;\n let pathLength = getTotalLength(pathTemp);\n let index = pathTemp.length - 1;\n let lengthAtSegment = 0;\n let length = 0;\n let segment = pathArray[0] as PathSegment;\n\n // If the path is empty, return 0.\n if (index <= 0 || !distance || !Number.isFinite(distance)) {\n return {\n segment,\n index: 0,\n length,\n lengthAtSegment,\n };\n }\n\n if (distance >= pathLength) {\n pathTemp = pathArray.slice(0, -1) as PathArray;\n lengthAtSegment = getTotalLength(pathTemp);\n length = pathLength - lengthAtSegment;\n segment = pathArray[index];\n return {\n segment,\n index,\n length,\n lengthAtSegment,\n };\n }\n\n const segments = [] as SegmentProperties[];\n while (index > 0) {\n segment = pathTemp[index];\n pathTemp = pathTemp.slice(0, -1) as PathArray;\n lengthAtSegment = getTotalLength(pathTemp);\n length = pathLength - lengthAtSegment;\n pathLength = lengthAtSegment;\n\n segments.push({\n segment,\n index,\n length,\n lengthAtSegment,\n });\n index -= 1;\n }\n\n return segments.find(({ lengthAtSegment: l }) =>\n l <= distance\n ) as SegmentProperties;\n};\n\nexport default getPropertiesAtLength;\n","import type { PathArray, Point } from \"../types\";\nimport type { PointProperties } from \"../interface\";\nimport getPointAtLength from \"./getPointAtLength\";\nimport getPropertiesAtLength from \"./getPropertiesAtLength\";\nimport getTotalLength from \"./getTotalLength\";\nimport parsePathString from \"../parser/parsePathString\";\nimport normalizePath from \"../process/normalizePath\";\n\n/**\n * Returns the point and segment in path closest to a given point as well as\n * the distance to the path stroke.\n *\n * @see https://bl.ocks.org/mbostock/8027637\n *\n * @param pathInput target `pathArray`\n * @param point the given point\n * @returns the requested properties\n */\nconst getPropertiesAtPoint = (\n pathInput: string | PathArray,\n point: Point,\n): PointProperties => {\n const path = parsePathString(pathInput);\n const normalPath = normalizePath(path);\n const pathLength = getTotalLength(normalPath);\n const distanceTo = (p: Point) => {\n const dx = p.x - point.x;\n const dy = p.y - point.y;\n return dx * dx + dy * dy;\n };\n let precision = 8;\n let scan: Point;\n let closest = { x: 0, y: 0 }; // make TS happy\n let scanDistance = 0;\n let bestLength = 0;\n let bestDistance = Infinity;\n\n // linear scan for coarse approximation\n for (let scanLength = 0; scanLength <= pathLength; scanLength += precision) {\n scan = getPointAtLength(normalPath, scanLength);\n scanDistance = distanceTo(scan);\n\n if (scanDistance < bestDistance) {\n closest = scan;\n bestLength = scanLength;\n bestDistance = scanDistance;\n }\n }\n\n // binary search for precise estimate\n precision /= 2;\n let before: { x: number; y: number };\n let after: { x: number; y: number };\n let beforeLength = 0;\n let afterLength = 0;\n let beforeDistance = 0;\n let afterDistance = 0;\n\n while (precision > 0.000001) {\n beforeLength = bestLength - precision;\n before = getPointAtLength(normalPath, beforeLength);\n beforeDistance = distanceTo(before);\n afterLength = bestLength + precision;\n after = getPointAtLength(normalPath, afterLength);\n afterDistance = distanceTo(after);\n\n if (beforeLength >= 0 && beforeDistance < bestDistance) {\n closest = before;\n bestLength = beforeLength;\n bestDistance = beforeDistance;\n } else if (afterLength <= pathLength && afterDistance < bestDistance) {\n closest = after;\n bestLength = afterLength;\n bestDistance = afterDistance;\n } else {\n precision /= 2;\n }\n if (precision < 0.00001) break;\n }\n\n const segment = getPropertiesAtLength(path, bestLength);\n const distance = Math.sqrt(bestDistance);\n\n return { closest, distance, segment };\n};\n\nexport default getPropertiesAtPoint;\n","import type { PathArray } from \"../types\";\nimport getPropertiesAtPoint from \"./getPropertiesAtPoint\";\n\n/**\n * Returns the point in path closest to a given point.\n *\n * @param pathInput target `pathArray`\n * @param point the given point\n * @returns the best match\n */\nconst getClosestPoint = (\n pathInput: string | PathArray,\n point: { x: number; y: number },\n) => {\n return getPropertiesAtPoint(pathInput, point).closest;\n};\n\nexport default getClosestPoint;\n","import pathToCurve from \"../convert/pathToCurve\";\nimport type { PathArray, PointTuple } from \"../types\";\n\n/**\n * Returns the area of a single cubic-bezier segment.\n *\n * http://objectmix.com/graphics/133553-area-closed-bezier-curve.html\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the area of the cubic-bezier segment\n */\nconst getCubicSegArea = (\n x1: number,\n y1: number,\n c1x: number,\n c1y: number,\n c2x: number,\n c2y: number,\n x2: number,\n y2: number,\n) => {\n return (\n (3 *\n ((y2 - y1) * (c1x + c2x) -\n (x2 - x1) * (c1y + c2y) +\n c1y * (x1 - c2x) -\n c1x * (y1 - c2y) +\n y2 * (c2x + x1 / 3) -\n x2 * (c2y + y1 / 3))) /\n 20\n );\n};\n\n/**\n * Returns the area of a shape.\n *\n * @author Jürg Lehni & Jonathan Puckey\n *\n * @see https://github.com/paperjs/paper.js/blob/develop/src/path/Path.js\n *\n * @param path the shape `pathArray`\n * @returns the length of the cubic-bezier segment\n */\nconst getPathArea = (path: PathArray) => {\n let x = 0;\n let y = 0;\n let len = 0;\n\n return pathToCurve(path)\n .map((seg) => {\n switch (seg[0]) {\n case \"M\":\n [, x, y] = seg;\n return 0;\n default:\n len = getCubicSegArea(\n x,\n y,\n seg[1],\n seg[2],\n seg[3],\n seg[4],\n seg[5],\n seg[6],\n );\n [x, y] = seg.slice(-2) as PointTuple;\n return len;\n }\n })\n .reduce((a, b) => a + b, 0);\n};\nexport default getPathArea;\n","import getPathArea from \"./getPathArea\";\nimport pathToCurve from \"../convert/pathToCurve\";\nimport type { PathArray } from \"../types\";\n\n/**\n * Check if a path is drawn clockwise and returns true if so,\n * false otherwise.\n *\n * @param path the path string or `pathArray`\n * @returns true when clockwise or false if not\n */\nconst getDrawDirection = (path: string | PathArray) => {\n return getPathArea(pathToCurve(path)) >= 0;\n};\n\nexport default getDrawDirection;\n","import iterate from \"../process/iterate\";\nimport { PathBBox } from \"../interface\";\nimport { LSegment, MSegment, PathArray, PointTuple } from \"../types\";\nimport { getLineBBox } from \"../math/lineTools\";\nimport { getArcBBox } from \"../math/arcTools\";\nimport { getCubicBBox } from \"../math/cubicTools\";\nimport { getQuadBBox } from \"../math/quadTools\";\nimport parsePathString from \"../parser/parsePathString\";\nimport absolutizeSegment from \"../process/absolutizeSegment\";\n\nconst getPathBBox = (pathInput: PathArray | string) => {\n if (!pathInput) {\n return {\n x: 0,\n y: 0,\n width: 0,\n height: 0,\n x2: 0,\n y2: 0,\n cx: 0,\n cy: 0,\n cz: 0,\n };\n }\n\n const path = parsePathString(pathInput);\n let pathCommand = \"M\";\n let mx = 0;\n let my = 0;\n const { max, min } = Math;\n let xMin = Infinity;\n let yMin = Infinity;\n let xMax = -Infinity;\n let yMax = -Infinity;\n let minX = 0;\n let minY = 0;\n let maxX = 0;\n let maxY = 0;\n let paramX1 = 0;\n let paramY1 = 0;\n let paramX2 = 0;\n let paramY2 = 0;\n let paramQX = 0;\n let paramQY = 0;\n\n iterate(path, (seg, index, lastX, lastY) => {\n [pathCommand] = seg;\n const absCommand = pathCommand.toUpperCase();\n const isRelative = absCommand !== pathCommand;\n const absoluteSegment = isRelative\n ? absolutizeSegment(seg, index, lastX, lastY)\n : (seg.slice(0) as typeof seg);\n\n const normalSegment = absCommand === \"V\"\n ? ([\"L\", lastX, absoluteSegment[1]] as LSegment)\n : absCommand === \"H\"\n ? ([\"L\", absoluteSegment[1], lastY] as LSegment)\n : absoluteSegment;\n\n [pathCommand] = normalSegment;\n\n if (!\"TQ\".includes(absCommand)) {\n // optional but good to be cautious\n paramQX = 0;\n paramQY = 0;\n }\n\n // this segment is always ZERO\n /* istanbul ignore else @preserve */\n if (pathCommand === \"M\") {\n [, mx, my] = normalSegment as MSegment;\n minX = mx;\n minY = my;\n maxX = mx;\n maxY = my;\n } else if (pathCommand === \"L\") {\n [minX, minY, maxX, maxY] = getLineBBox(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n );\n } else if (pathCommand === \"A\") {\n [minX, minY, maxX, maxY] = getArcBBox(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n normalSegment[5] as number,\n normalSegment[6] as number,\n normalSegment[7] as number,\n );\n } else if (pathCommand === \"S\") {\n const cp1x = paramX1 * 2 - paramX2;\n const cp1y = paramY1 * 2 - paramY2;\n\n [minX, minY, maxX, maxY] = getCubicBBox(\n lastX,\n lastY,\n cp1x,\n cp1y,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n );\n } else if (pathCommand === \"C\") {\n [minX, minY, maxX, maxY] = getCubicBBox(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n normalSegment[5] as number,\n normalSegment[6] as number,\n );\n } else if (pathCommand === \"T\") {\n paramQX = paramX1 * 2 - paramQX;\n paramQY = paramY1 * 2 - paramQY;\n [minX, minY, maxX, maxY] = getQuadBBox(\n lastX,\n lastY,\n paramQX,\n paramQY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n );\n } else if (pathCommand === \"Q\") {\n paramQX = normalSegment[1] as number;\n paramQY = normalSegment[2] as number;\n [minX, minY, maxX, maxY] = getQuadBBox(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n );\n } else if (pathCommand === \"Z\") {\n [minX, minY, maxX, maxY] = getLineBBox(lastX, lastY, mx, my);\n }\n xMin = min(minX, xMin);\n yMin = min(minY, yMin);\n xMax = max(maxX, xMax);\n yMax = max(maxY, yMax);\n\n // update params\n [paramX1, paramY1] = pathCommand === \"Z\"\n ? [mx, my]\n : (normalSegment.slice(-2) as PointTuple);\n [paramX2, paramY2] = pathCommand === \"C\"\n ? ([normalSegment[3], normalSegment[4]] as PointTuple)\n : pathCommand === \"S\"\n ? ([normalSegment[1], normalSegment[2]] as PointTuple)\n : [paramX1, paramY1];\n });\n\n const width = xMax - xMin;\n const height = yMax - yMin;\n\n return {\n width,\n height,\n x: xMin,\n y: yMin,\n x2: xMax,\n y2: yMax,\n cx: xMin + width / 2,\n cy: yMin + height / 2,\n // an estimated guess\n cz: Math.max(width, height) + Math.min(width, height) / 2,\n } satisfies PathBBox;\n};\n\nexport default getPathBBox;\n","import type { PathArray, PathSegment } from \"../types\";\nimport getPropertiesAtLength from \"./getPropertiesAtLength\";\n\n/**\n * Returns the segment at a given length.\n *\n * @param pathInput the target `pathArray`\n * @param distance the distance in path to look at\n * @returns the requested segment\n */\nconst getSegmentAtLength = (\n pathInput: string | PathArray,\n distance?: number,\n): PathSegment | undefined => {\n return getPropertiesAtLength(pathInput, distance).segment;\n};\n\nexport default getSegmentAtLength;\n","import type { SegmentProperties } from \"../interface\";\nimport type { PathArray } from \"../types\";\nimport getPropertiesAtPoint from \"./getPropertiesAtPoint\";\n\n/**\n * Returns the path segment which contains a given point.\n *\n * @param path the `pathArray` to look into\n * @param point the point of the shape to look for\n * @returns the requested segment\n */\nconst getSegmentOfPoint = (\n path: string | PathArray,\n point: { x: number; y: number },\n): SegmentProperties | undefined => {\n return getPropertiesAtPoint(path, point).segment;\n};\nexport default getSegmentOfPoint;\n","import type { PathArray, PathSegment, RelativeCommand } from \"../types\";\nimport paramsCount from \"../parser/paramsCount\";\n\n/**\n * Iterates an array to check if it's an actual `pathArray`.\n *\n * @param path the `pathArray` to be checked\n * @returns iteration result\n */\nconst isPathArray = (path: unknown): path is PathArray => {\n return (\n Array.isArray(path) &&\n path.every((seg: PathSegment) => {\n const lk = seg[0].toLowerCase() as RelativeCommand;\n return (\n paramsCount[lk] === seg.length - 1 &&\n \"achlmqstvz\".includes(lk) &&\n (seg.slice(1) as unknown[]).every(Number.isFinite)\n );\n }) &&\n path.length > 0\n );\n};\nexport default isPathArray;\n","import type { AbsoluteArray } from \"../types\";\nimport isPathArray from \"./isPathArray\";\n\n/**\n * Iterates an array to check if it's a `pathArray`\n * with all absolute values.\n *\n * @param path the `pathArray` to be checked\n * @returns iteration result\n */\nconst isAbsoluteArray = (path: unknown): path is AbsoluteArray => {\n return (\n isPathArray(path) &&\n // `isPathArray` also checks if it's `Array`\n path.every(([x]) => x === x.toUpperCase())\n );\n};\nexport default isAbsoluteArray;\n","import type { NormalArray } from \"../types\";\nimport isAbsoluteArray from \"./isAbsoluteArray\";\n\n/**\n * Iterates an array to check if it's a `pathArray`\n * with all segments are in non-shorthand notation\n * with absolute values.\n *\n * @param {string | SVGPath.pathArray} path the `pathArray` to be checked\n * @returns {boolean} iteration result\n */\nconst isNormalizedArray = (path: unknown): path is NormalArray => {\n // `isAbsoluteArray` also checks if it's `Array`\n return isAbsoluteArray(path) && path.every(([pc]) => \"ACLMQZ\".includes(pc));\n};\nexport default isNormalizedArray;\n","import { CurveArray } from \"../types\";\nimport isNormalizedArray from \"./isNormalizedArray\";\n\n/**\n * Iterates an array to check if it's a `pathArray`\n * with all C (cubic bezier) segments.\n *\n * @param path the `Array` to be checked\n * @returns iteration result\n */\nconst isCurveArray = (path: unknown): path is CurveArray => {\n // `isPathArray` also checks if it's `Array`\n return isNormalizedArray(path) && path.every(([pc]) => \"MC\".includes(pc));\n};\nexport default isCurveArray;\n","import type { PathArray } from \"../types\";\nimport getPropertiesAtPoint from \"./getPropertiesAtPoint\";\nimport DISTANCE_EPSILON from \"./distanceEpsilon\";\n\n/**\n * Checks if a given point is in the stroke of a path.\n *\n * @param pathInput target path\n * @param point the given `{x,y}` point\n * @returns the query result\n */\nconst isPointInStroke = (\n pathInput: string | PathArray,\n point: { x: number; y: number },\n) => {\n const { distance } = getPropertiesAtPoint(pathInput, point);\n return Math.abs(distance) < DISTANCE_EPSILON; // 0.01 might be more permissive\n};\nexport default isPointInStroke;\n","import type { RelativeArray } from \"../types\";\nimport isPathArray from \"./isPathArray\";\n\n/**\n * Iterates an array to check if it's a `pathArray`\n * with relative values.\n *\n * @param path the `pathArray` to be checked\n * @returns iteration result\n */\nconst isRelativeArray = (path: unknown): path is RelativeArray => {\n return (\n isPathArray(path) &&\n // `isPathArray` checks if it's `Array`\n path.slice(1).every(([pc]) => pc === pc.toLowerCase())\n );\n};\nexport default isRelativeArray;\n","import scanSegment from \"../parser/scanSegment\";\nimport skipSpaces from \"../parser/skipSpaces\";\nimport PathParser from \"../parser/pathParser\";\n\n/**\n * Parses a path string value to determine its validity\n * then returns true if it's valid or false otherwise.\n *\n * @param pathString the path string to be parsed\n * @returns the path string validity\n */\nconst isValidPath = (pathString: string) => {\n if (typeof pathString !== \"string\" || !pathString.length) {\n return false;\n }\n\n const path = new PathParser(pathString);\n\n skipSpaces(path);\n\n while (path.index < path.max && !path.err.length) {\n scanSegment(path);\n }\n\n return !path.err.length && \"mM\".includes(path.segments[0][0]);\n};\nexport default isValidPath;\n","import type { ShapeParams } from \"../interface\";\n\n/**\n * Supported shapes and their specific parameters.\n */\nconst shapeParams: ShapeParams = {\n line: [\"x1\", \"y1\", \"x2\", \"y2\"],\n circle: [\"cx\", \"cy\", \"r\"],\n ellipse: [\"cx\", \"cy\", \"rx\", \"ry\"],\n rect: [\"width\", \"height\", \"x\", \"y\", \"rx\", \"ry\"],\n polygon: [\"points\"],\n polyline: [\"points\"],\n glyph: [\"d\"],\n};\n\nexport default shapeParams;\n","const isElement = (node?: unknown): node is Element =>\n node !== undefined && node !== null &&\n typeof node === \"object\" &&\n (node as Node).nodeType === 1; // ELEMENT_NODE\n\nexport default isElement;\n","import type {\n CircleAttr,\n EllipseAttr,\n GlyphAttr,\n LineAttr,\n PolyAttr,\n RectAttr,\n ShapeParams,\n} from \"../interface\";\nimport type { PathArray, PathSegment, ShapeOps, ShapeTypes } from \"../types\";\nimport error from \"../parser/error\";\nimport parsePathString from \"../parser/parsePathString\";\nimport shapeParams from \"./shapeParams\";\nimport isPathArray from \"./isPathArray\";\nimport isElement from \"./isElement\";\n\n/**\n * Returns a new `pathArray` from line attributes.\n *\n * @param attr shape configuration\n * @returns a new line `pathArray`\n */\nexport const getLinePath = (attr: LineAttr): PathArray => {\n let { x1, y1, x2, y2 } = attr;\n [x1, y1, x2, y2] = [x1, y1, x2, y2].map((a) => +a);\n return [\n [\"M\", x1, y1],\n [\"L\", x2, y2],\n ];\n};\n\n/**\n * Returns a new `pathArray` like from polyline/polygon attributes.\n *\n * @param attr shape configuration\n * @return a new polygon/polyline `pathArray`\n */\nexport const getPolyPath = (attr: PolyAttr): PathArray => {\n const pathArray = [] as PathSegment[];\n const points = (attr.points || \"\")\n .trim()\n .split(/[\\s|,]/)\n .map((a) => +a);\n\n let index = 0;\n while (index < points.length) {\n pathArray.push([index ? \"L\" : \"M\", points[index], points[index + 1]]);\n index += 2;\n }\n\n return (attr.type === \"polygon\"\n ? [...pathArray, [\"z\"]]\n : pathArray) as PathArray;\n};\n\n/**\n * Returns a new `pathArray` from circle attributes.\n *\n * @param attr shape configuration\n * @return a circle `pathArray`\n */\nexport const getCirclePath = (attr: CircleAttr): PathArray => {\n let { cx, cy, r } = attr;\n [cx, cy, r] = [cx, cy, r].map((a) => +a);\n\n return [\n [\"M\", cx - r, cy],\n [\"a\", r, r, 0, 1, 0, 2 * r, 0],\n [\"a\", r, r, 0, 1, 0, -2 * r, 0],\n ];\n};\n\n/**\n * Returns a new `pathArray` from ellipse attributes.\n *\n * @param attr shape configuration\n * @return an ellipse `pathArray`\n */\nexport const getEllipsePath = (attr: EllipseAttr): PathArray => {\n let { cx, cy } = attr;\n let rx = attr.rx || 0;\n let ry = attr.ry || rx;\n [cx, cy, rx, ry] = [cx, cy, rx, ry].map((a) => +a);\n\n return [\n [\"M\", cx - rx, cy],\n [\"a\", rx, ry, 0, 1, 0, 2 * rx, 0],\n [\"a\", rx, ry, 0, 1, 0, -2 * rx, 0],\n ];\n};\n\n/**\n * Returns a new `pathArray` like from rect attributes.\n *\n * @param attr object with properties above\n * @return a new `pathArray` from `` attributes\n */\nexport const getRectanglePath = (attr: RectAttr): PathArray => {\n const x = +attr.x || 0;\n const y = +attr.y || 0;\n const w = +attr.width;\n const h = +attr.height;\n let rx = +(attr.rx || 0);\n let ry = +(attr.ry || rx);\n\n // Validity checks from http://www.w3.org/TR/SVG/shapes.html#RectElement:\n if (rx || ry) {\n // rx = !rx ? ry : rx;\n // ry = !ry ? rx : ry;\n\n /* istanbul ignore else @preserve */\n if (rx * 2 > w) rx -= (rx * 2 - w) / 2;\n /* istanbul ignore else @preserve */\n if (ry * 2 > h) ry -= (ry * 2 - h) / 2;\n\n return [\n [\"M\", x + rx, y],\n [\"h\", w - rx * 2],\n [\"s\", rx, 0, rx, ry],\n [\"v\", h - ry * 2],\n [\"s\", 0, ry, -rx, ry],\n [\"h\", -w + rx * 2],\n [\"s\", -rx, 0, -rx, -ry],\n [\"v\", -h + ry * 2],\n [\"s\", 0, -ry, rx, -ry],\n ];\n }\n\n return [[\"M\", x, y], [\"h\", w], [\"v\", h], [\"H\", x], [\"Z\"]];\n};\n\n/**\n * Returns a new `pathArray` created from attributes of a ``, ``,\n * ``, ``, ``, ``, or ``.\n *\n * It can also work with an options object, see the type below\n * @see ShapeOps\n *\n * @param element target shape\n * @return the newly created `` element\n */\nconst shapeToPathArray = (\n element: ShapeTypes | ShapeOps,\n) => {\n const supportedShapes = Object.keys(shapeParams) as (keyof ShapeParams)[];\n const targetIsElement = isElement(element);\n const tagName = targetIsElement ? element.tagName : null;\n\n if (tagName && [...supportedShapes, \"path\"].every((s) => tagName !== s)) {\n throw TypeError(`${error}: \"${tagName}\" is not SVGElement`);\n }\n\n const type =\n (targetIsElement ? tagName : (element as ShapeOps).type) as ShapeOps[\n \"type\"\n ];\n const shapeAttrs = shapeParams[type] as string[];\n const config = { type } as Record;\n\n if (targetIsElement) {\n shapeAttrs.forEach((p) => {\n config[p] = element.getAttribute(p) as string;\n });\n } else {\n Object.assign(config, element);\n }\n\n // set d\n let pathArray = [] as unknown as PathArray;\n\n /* istanbul ignore else */\n if (type === \"circle\") {\n pathArray = getCirclePath(config as unknown as CircleAttr);\n } else if (type === \"ellipse\") {\n pathArray = getEllipsePath(config as unknown as EllipseAttr);\n } else if ([\"polyline\", \"polygon\"].includes(type)) {\n pathArray = getPolyPath(config as unknown as PolyAttr);\n } else if (type === \"rect\") {\n pathArray = getRectanglePath(config as unknown as RectAttr);\n } else if (type === \"line\") {\n pathArray = getLinePath(config as unknown as LineAttr);\n } else if ([\"glyph\", \"path\"].includes(type)) {\n pathArray = parsePathString(\n targetIsElement\n ? element.getAttribute(\"d\") || /* istanbul ignore next @preserve */ \"\"\n : (element as GlyphAttr).d || \"\",\n );\n }\n\n // replace target element\n if (isPathArray(pathArray) && pathArray.length) {\n return pathArray;\n }\n return false;\n};\nexport default shapeToPathArray;\n","import type { ShapeParams } from \"../interface\";\nimport type { ShapeOps, ShapeTypes } from \"../types\";\nimport pathToString from \"../convert/pathToString\";\nimport defaultOptions from \"../options/options\";\nimport error from \"../parser/error\";\nimport isValidPath from \"./isValidPath\";\nimport isElement from \"./isElement\";\nimport shapeToPathArray from \"./shapeToPathArray\";\nimport shapeParams from \"./shapeParams\";\n\n/**\n * Returns a new `` element created from attributes of a ``, ``,\n * ``, ``, ``, `` or ``. If `replace` parameter\n * is `true`, it will replace the target. The default `ownerDocument` is your current\n * `document` browser page, if you want to use in server-side using `jsdom`, you can\n * pass the `jsdom` `document` to `ownDocument`.\n *\n * It can also work with an options object, see the type below\n * @see ShapeOps\n *\n * The newly created `` element keeps all non-specific\n * attributes like `class`, `fill`, etc.\n *\n * @param element target shape\n * @param replace option to replace target\n * @param ownerDocument document for create element\n * @return the newly created `` element\n */\nconst shapeToPath = (\n element: ShapeTypes | ShapeOps,\n replace?: boolean,\n ownerDocument?: Document,\n): SVGPathElement | false => {\n const doc = ownerDocument || document;\n const supportedShapes = Object.keys(shapeParams) as (keyof ShapeParams)[];\n const targetIsElement = isElement(element);\n const tagName = targetIsElement ? element.tagName : null;\n\n if (tagName === \"path\") {\n throw TypeError(`${error}: \"${tagName}\" is already SVGPathElement`);\n }\n if (tagName && supportedShapes.every((s) => tagName !== s)) {\n throw TypeError(`${error}: \"${tagName}\" is not SVGElement`);\n }\n\n const path = doc.createElementNS(\"http://www.w3.org/2000/svg\", \"path\");\n const type =\n (targetIsElement ? tagName : (element as ShapeOps).type) as ShapeOps[\n \"type\"\n ];\n const shapeAttrs = shapeParams[type] as string[];\n const config = { type } as Record;\n\n // set d\n const round = defaultOptions.round as number;\n const pathArray = shapeToPathArray(element);\n const description = pathArray && pathArray.length\n ? pathToString(pathArray, round)\n : \"\";\n\n if (targetIsElement) {\n shapeAttrs.forEach((p) => {\n config[p] = element.getAttribute(p) as string;\n });\n // set no-specific shape attributes: fill, stroke, etc\n Object.values(element.attributes).forEach(({ name, value }) => {\n if (!shapeAttrs.includes(name)) path.setAttribute(name, value);\n });\n } else {\n Object.assign(config, element);\n // set no-specific shape attributes: fill, stroke, etc\n Object.keys(config).forEach((k) => {\n if (!shapeAttrs.includes(k) && k !== \"type\") {\n path.setAttribute(\n k.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`),\n config[k],\n );\n }\n });\n }\n\n // replace target element\n if (isValidPath(description)) {\n path.setAttribute(\"d\", description);\n if (replace && targetIsElement) {\n element.before(path, element);\n element.remove();\n }\n return path;\n }\n return false;\n};\n\nexport default shapeToPath;\n","import CSSMatrix from \"@thednp/dommatrix\";\n// import type { TransformObject } from '../interface';\nimport type { TransformObjectValues } from \"../types\";\n\n/**\n * Returns a transformation matrix to apply to `` elements.\n *\n * @see TransformObjectValues\n *\n * @param transform the `transformObject`\n * @returns a new transformation matrix\n */\nconst getSVGMatrix = (transform: TransformObjectValues): CSSMatrix => {\n let matrix = new CSSMatrix();\n const { origin } = transform;\n const [originX, originY] = origin as [number, number, number];\n const { translate } = transform;\n const { rotate } = transform;\n const { skew } = transform;\n const { scale } = transform;\n\n // set translate\n if (\n Array.isArray(translate) &&\n translate.length >= 2 &&\n translate.every((x) => !Number.isNaN(+x)) &&\n translate.some((x) => x !== 0)\n ) {\n matrix = matrix.translate(...(translate as [number, number, number?]));\n } else if (typeof translate === \"number\" && !Number.isNaN(translate)) {\n matrix = matrix.translate(translate);\n }\n\n if (rotate || skew || scale) {\n // set SVG transform-origin, always defined\n matrix = matrix.translate(originX, originY);\n\n // set rotation\n if (\n Array.isArray(rotate) &&\n rotate.length >= 2 &&\n rotate.every((x) => !Number.isNaN(+x)) &&\n rotate.some((x) => x !== 0)\n ) {\n matrix = matrix.rotate(...(rotate as [number, number, number?]));\n } else if (typeof rotate === \"number\" && !Number.isNaN(rotate)) {\n matrix = matrix.rotate(rotate);\n }\n\n // set skew(s)\n if (\n Array.isArray(skew) && skew.length === 2 && skew.every((x) =>\n !Number.isNaN(+x)\n ) && skew.some((x) => x !== 0)\n ) {\n matrix = skew[0] ? matrix.skewX(skew[0]) : matrix;\n matrix = skew[1] ? matrix.skewY(skew[1]) : matrix;\n } else if (typeof skew === \"number\" && !Number.isNaN(skew)) {\n matrix = matrix.skewX(skew);\n }\n\n // set scale\n if (\n Array.isArray(scale) && scale.length >= 2 && scale.every((x) =>\n !Number.isNaN(+x)\n ) && scale.some((x) => x !== 1)\n ) {\n matrix = matrix.scale(...(scale as [number, number, number?]));\n } else if (typeof scale === \"number\" && !Number.isNaN(scale)) {\n matrix = matrix.scale(scale);\n }\n // set SVG transform-origin\n matrix = matrix.translate(-originX, -originY);\n }\n\n return matrix;\n};\nexport default getSVGMatrix;\n","import defaultOptions from \"../options/options\";\nimport type { ParserParams } from \"../interface\";\nimport roundTo from \"../math/roundTo\";\nimport type {\n AbsoluteSegment,\n NormalSegment,\n PathCommand,\n ShortSegment,\n SSegment,\n TSegment,\n} from \"../types\";\n\n/**\n * Shorten a single segment of a `pathArray` object.\n *\n * @param segment the `absoluteSegment` object\n * @param normalSegment the `normalSegment` object\n * @param params the coordinates of the previous segment\n * @param prevCommand the path command of the previous segment\n * @returns the shortened segment\n */\nconst shortenSegment = (\n segment: AbsoluteSegment,\n normalSegment: NormalSegment,\n params: ParserParams,\n prevCommand: PathCommand,\n): ShortSegment => {\n const [pathCommand] = segment;\n const { round: defaultRound } = defaultOptions;\n const round = typeof defaultRound === \"number\"\n ? defaultRound\n : /* istanbul ignore next */ 4;\n const normalValues = normalSegment.slice(1) as number[];\n const { x1, y1, x2, y2, x, y } = params;\n const [nx, ny] = normalValues.slice(-2);\n const result = segment;\n\n if (!\"TQ\".includes(pathCommand)) {\n // optional but good to be cautious\n params.qx = null;\n params.qy = null;\n }\n\n if (pathCommand === \"L\") {\n if (roundTo(x, round) === roundTo(nx, round)) {\n return [\"V\", ny];\n } else if (roundTo(y, round) === roundTo(ny, round)) {\n return [\"H\", nx];\n }\n } else if (pathCommand === \"C\") {\n const [nx1, ny1] = normalValues;\n params.x1 = nx1;\n params.y1 = ny1;\n\n if (\n \"CS\".includes(prevCommand) &&\n ((roundTo(nx1, round) === roundTo(x1 * 2 - x2, round) &&\n roundTo(ny1, round) === roundTo(y1 * 2 - y2, round)) ||\n (roundTo(x1, round) === roundTo(x2 * 2 - x, round) &&\n roundTo(y1, round) === roundTo(y2 * 2 - y, round)))\n ) {\n return [\n \"S\",\n normalValues[2],\n normalValues[3],\n normalValues[4],\n normalValues[5],\n ] as SSegment;\n }\n } else if (pathCommand === \"Q\") {\n const [qx, qy] = normalValues;\n params.qx = qx;\n params.qy = qy;\n\n if (\n \"QT\".includes(prevCommand) &&\n roundTo(qx, round) === roundTo(x1 * 2 - x2, round) &&\n roundTo(qy, round) === roundTo(y1 * 2 - y2, round)\n ) {\n return [\"T\", normalValues[2], normalValues[3]] as TSegment;\n }\n }\n\n // ['V', 'H', 'S', 'T', 'Z'].includes(pathCommand)\n return result as ShortSegment;\n};\n\nexport default shortenSegment;\n","import type { PathCommand, PathSegment } from \"../types\";\nimport roundTo from \"../math/roundTo\";\n\nconst roundSegment = (\n segment: T,\n roundOption: number,\n) => {\n const values = (segment.slice(1) as number[]).map((n) =>\n roundTo(n, roundOption)\n );\n return [segment[0] as PathCommand | number].concat(values) as T;\n};\n\nexport default roundSegment;\n","import type { AbsoluteSegment, PathArray, PathCommand } from \"../types\";\nimport pathToAbsolute from \"../convert/pathToAbsolute\";\nimport shortenSegment from \"./shortenSegment\";\nimport paramsParser from \"../parser/paramsParser\";\nimport iterate from \"./iterate\";\nimport normalizeSegment from \"./normalizeSegment\";\nimport relativizeSegment from \"./relativizeSegment\";\nimport roundSegment from \"./roundSegment\";\n\n/**\n * Optimizes a `pathArray` object:\n * * convert segments to shorthand if possible\n * * select shortest segments from absolute and relative `pathArray`s\n *\n * @param pathInput a string or `pathArray`\n * @param roundOption the amount of decimals to round values to\n * @returns the optimized `pathArray`\n */\nconst optimizePath = (pathInput: PathArray, roundOption?: number) => {\n const path = pathToAbsolute(pathInput);\n // allow for ZERO decimals or use an aggressive value of 2\n const round = typeof roundOption === \"number\" && roundOption >= 0\n ? roundOption\n : /* istanbul ignore next @preserve */ 2;\n // this utility overrides the iterator params\n const optimParams = { ...paramsParser };\n\n const allPathCommands = [] as PathCommand[];\n let pathCommand = \"M\" as PathCommand;\n let prevCommand = \"Z\" as PathCommand;\n\n return iterate(path, (seg, i, lastX, lastY) => {\n optimParams.x = lastX;\n optimParams.y = lastY;\n const normalizedSegment = normalizeSegment(seg, optimParams);\n let result = seg;\n [pathCommand] = seg;\n\n // Save current path command\n allPathCommands[i] = pathCommand;\n if (i) {\n // Get previous path command for `shortenSegment`\n prevCommand = allPathCommands[i - 1];\n const shortSegment = shortenSegment(\n seg as AbsoluteSegment,\n normalizedSegment,\n optimParams,\n prevCommand,\n );\n const absSegment = roundSegment(shortSegment, round);\n const absString = absSegment.join(\"\");\n const relativeSegment = relativizeSegment(shortSegment, i, lastX, lastY);\n const relSegment = roundSegment(relativeSegment, round);\n const relString = relSegment.join(\"\");\n result = absString.length < relString.length ? absSegment : relSegment;\n }\n\n const seglen = normalizedSegment.length;\n optimParams.x1 = +normalizedSegment[seglen - 2];\n optimParams.y1 = +normalizedSegment[seglen - 1];\n optimParams.x2 = +normalizedSegment[seglen - 4] || optimParams.x1;\n optimParams.y2 = +normalizedSegment[seglen - 3] || optimParams.y1;\n\n return result;\n });\n};\n\nexport default optimizePath;\n","import CSSMatrix from \"@thednp/dommatrix\";\nimport { type PointTuple } from \"../types\";\n\n/**\n * Transforms a specified point using a matrix, returning a new\n * Tuple *Object* comprising of the transformed point.\n * Neither the matrix nor the original point are altered.\n *\n * @copyright thednp © 2021\n *\n * @param cssm CSSMatrix instance\n * @param v Tuple\n * @return the resulting Tuple\n */\nconst translatePoint = (\n cssm: CSSMatrix,\n v: [number, number, number, number],\n): [number, number, number, number] => {\n let m = CSSMatrix.Translate(v[0], v[1], v[2]);\n\n [, , , m.m44] = v;\n m = cssm.multiply(m);\n\n return [m.m41, m.m42, m.m43, m.m44];\n};\n\n/**\n * Returns the [x,y] projected coordinates for a given an [x,y] point\n * and an [x,y,z] perspective origin point.\n *\n * Equation found here =>\n * http://en.wikipedia.org/wiki/3D_projection#Diagram\n * Details =>\n * https://stackoverflow.com/questions/23792505/predicted-rendering-of-css-3d-transformed-pixel\n *\n * @param m the transformation matrix\n * @param point2D the initial [x,y] coordinates\n * @param origin the [x,y,z] transform origin\n * @returns the projected [x,y] coordinates\n */\nconst projection2d = (\n m: CSSMatrix,\n point2D: PointTuple,\n origin: [number, number, number],\n): PointTuple => {\n const [originX, originY, originZ] = origin;\n const [x, y, z] = translatePoint(m, [point2D[0], point2D[1], 0, 1]);\n\n const relativePositionX = x - originX;\n const relativePositionY = y - originY;\n const relativePositionZ = z - originZ;\n\n return [\n // protect against division by ZERO\n relativePositionX * (Math.abs(originZ) / Math.abs(relativePositionZ) || 1) +\n originX,\n relativePositionY * (Math.abs(originZ) / Math.abs(relativePositionZ) || 1) +\n originY,\n ];\n};\nexport default projection2d;\n","import type { CSegment, CurveArray, MSegment, PathCommand } from \"../types\";\n\n/**\n * Reverses all segments of a `pathArray`\n * which consists of only C (cubic-bezier) path commands.\n *\n * @param path the source `pathArray`\n * @returns the reversed `pathArray`\n */\nconst reverseCurve = (path: CurveArray) => {\n const rotatedCurve = path\n .slice(1)\n .map((x, i, curveOnly) =>\n !i\n ? path[0].slice(1).concat(x.slice(1) as number[])\n : curveOnly[i - 1].slice(-2).concat(x.slice(1))\n )\n .map((x) => x.map((_, i) => x[x.length - i - 2 * (1 - (i % 2))]))\n .reverse() as (MSegment | CSegment)[];\n\n return [[\"M\" as PathCommand | number].concat(rotatedCurve[0].slice(0, 2))]\n .concat(\n rotatedCurve.map((x) => [\"C\" as PathCommand | number].concat(x.slice(2))),\n ) as CurveArray;\n};\n\nexport default reverseCurve;\n","import type {\n ASegment,\n CSegment,\n HSegment,\n MSegment,\n PathArray,\n PathSegment,\n PointTuple,\n QSegment,\n SSegment,\n TSegment,\n VSegment,\n} from \"../types\";\nimport pathToAbsolute from \"../convert/pathToAbsolute\";\nimport normalizePath from \"./normalizePath\";\nimport iterate from \"./iterate\";\n\n/**\n * Reverses all segments of a `pathArray` and returns a new `pathArray` instance\n * with absolute values.\n *\n * @param pathInput the source `pathArray`\n * @returns the reversed `pathArray`\n */\nconst reversePath = (pathInput: PathArray) => {\n const absolutePath = pathToAbsolute(pathInput);\n const normalizedPath = normalizePath(absolutePath);\n const pLen = absolutePath.length;\n const isClosed = absolutePath[pLen - 1][0] === \"Z\";\n\n const reversedPath = iterate(absolutePath, (segment, i) => {\n const normalizedSegment = normalizedPath[i];\n const prevSeg = i && absolutePath[i - 1];\n const prevCommand = prevSeg && prevSeg[0];\n const nextSeg = absolutePath[i + 1];\n const nextCommand = nextSeg && nextSeg[0];\n const [pathCommand] = segment;\n const [x, y] = normalizedPath[i ? i - 1 : pLen - 1].slice(-2) as PointTuple;\n let result = segment;\n\n switch (pathCommand) {\n case \"M\":\n result = (isClosed ? [\"Z\"] : [pathCommand, x, y]) as PathSegment;\n break;\n case \"A\":\n result = [\n pathCommand,\n segment[1],\n segment[2],\n segment[3],\n segment[4],\n segment[5] === 1 ? 0 : 1,\n x,\n y,\n ] as ASegment;\n break;\n case \"C\":\n if (nextSeg && nextCommand === \"S\") {\n result = [\"S\", segment[1], segment[2], x, y] as SSegment;\n } else {\n result = [\n pathCommand,\n segment[3],\n segment[4],\n segment[1],\n segment[2],\n x,\n y,\n ] as CSegment;\n }\n break;\n case \"S\":\n if (\n prevCommand && \"CS\".includes(prevCommand) &&\n (!nextSeg || nextCommand !== \"S\")\n ) {\n result = [\n \"C\",\n normalizedSegment[3],\n normalizedSegment[4],\n normalizedSegment[1],\n normalizedSegment[2],\n x,\n y,\n ] as CSegment;\n } else {\n result = [\n pathCommand,\n normalizedSegment[1],\n normalizedSegment[2],\n x,\n y,\n ] as SSegment;\n }\n break;\n case \"Q\":\n if (nextSeg && nextCommand === \"T\") {\n result = [\"T\", x, y] as TSegment;\n } else {\n result = [pathCommand, segment[1], segment[2], x, y] as QSegment;\n }\n break;\n case \"T\":\n if (\n prevCommand && \"QT\".includes(prevCommand) &&\n (!nextSeg || nextCommand !== \"T\")\n ) {\n result = [\n \"Q\",\n normalizedSegment[1],\n normalizedSegment[2],\n x,\n y,\n ] as QSegment;\n } else {\n result = [pathCommand, x, y] as TSegment;\n }\n break;\n case \"Z\":\n result = [\"M\", x, y] as MSegment;\n break;\n case \"H\":\n result = [pathCommand, x] as HSegment;\n break;\n case \"V\":\n result = [pathCommand, y] as VSegment;\n break;\n default:\n result = [pathCommand as typeof pathCommand | number].concat(\n segment.slice(1, -2),\n x,\n y,\n ) as PathSegment;\n }\n\n return result;\n });\n\n return (\n isClosed\n ? reversedPath.reverse()\n : [reversedPath[0] as PathSegment].concat(reversedPath.slice(1).reverse())\n ) as PathArray;\n};\n\nexport default reversePath;\n","import type { PathArray } from \"../types\";\nimport defaultOptions from \"../options/options\";\nimport iterate from \"./iterate\";\nimport roundSegment from \"./roundSegment\";\n\n/**\n * Rounds the values of a `pathArray` instance to\n * a specified amount of decimals and returns it.\n *\n * @param path the source `pathArray`\n * @param roundOption the amount of decimals to round numbers to\n * @returns the resulted `pathArray` with rounded values\n */\nconst roundPath = (path: PathArray, roundOption?: number | \"off\") => {\n let { round } = defaultOptions;\n // allow for ZERO decimals\n round = roundOption === \"off\"\n ? roundOption\n : typeof roundOption === \"number\" && roundOption >= 0\n ? roundOption\n : typeof round === \"number\" && round >= 0\n ? round\n : /* istanbul ignore next @preserve */ \"off\";\n\n /* istanbul ignore else @preserve */\n if (round === \"off\") return path.slice(0) as PathArray;\n\n return iterate(path, (segment) => {\n return roundSegment(segment, round);\n });\n};\nexport default roundPath;\n","import midPoint from \"../math/midPoint\";\nimport type { CubicSegment, PointTuple } from \"../types\";\n\n/**\n * Split a cubic-bezier segment into two.\n *\n * @param pts the cubic-bezier parameters\n * @param ratio the cubic-bezier parameters\n * @return two new cubic-bezier segments\n */\nconst splitCubic = (\n pts: number[],\n ratio = 0.5,\n): [CubicSegment, CubicSegment] => {\n const t = ratio;\n const p0 = pts.slice(0, 2) as PointTuple;\n const p1 = pts.slice(2, 4) as PointTuple;\n const p2 = pts.slice(4, 6) as PointTuple;\n const p3 = pts.slice(6, 8) as PointTuple;\n const p4 = midPoint(p0, p1, t);\n const p5 = midPoint(p1, p2, t);\n const p6 = midPoint(p2, p3, t);\n const p7 = midPoint(p4, p5, t);\n const p8 = midPoint(p5, p6, t);\n const p9 = midPoint(p7, p8, t);\n\n return [\n [\"C\", p4[0], p4[1], p7[0], p7[1], p9[0], p9[1]],\n [\"C\", p8[0], p8[1], p6[0], p6[1], p3[0], p3[1]],\n ];\n};\nexport default splitCubic;\n","import paramsParser from \"../parser/paramsParser\";\nimport type {\n AbsoluteCommand,\n HSegment,\n MSegment,\n PathArray,\n PointTuple,\n RelativeCommand,\n VSegment,\n} from \"../types\";\n\n/**\n * Split a path into an `Array` of sub-path strings.\n *\n * In the process, values are converted to absolute\n * for visual consistency.\n *\n * @param pathInput the source `pathArray`\n * @return an array with all sub-path strings\n */\nconst splitPath = (pathInput: PathArray): PathArray[] => {\n const composite = [] as PathArray[];\n let path: PathArray;\n let pi = -1;\n let x = 0;\n let y = 0;\n let mx = 0;\n let my = 0;\n const params = { ...paramsParser };\n\n pathInput.forEach((seg) => {\n const [pathCommand] = seg;\n const absCommand = pathCommand.toUpperCase() as AbsoluteCommand;\n const relCommand = pathCommand.toLowerCase() as RelativeCommand;\n const isRelative = pathCommand === relCommand;\n const values = seg.slice(1) as number[];\n\n if (absCommand === \"M\") {\n pi += 1;\n [x, y] = values as PointTuple;\n x += isRelative ? params.x : 0;\n y += isRelative ? params.y : 0;\n mx = x;\n my = y;\n path = [(isRelative ? [absCommand, mx, my] : seg) as MSegment];\n } else {\n if (absCommand === \"Z\") {\n x = mx;\n y = my;\n } else if (absCommand === \"H\") {\n [, x] = seg as HSegment;\n x += isRelative ? params.x : /* istanbul ignore next @preserve */ 0;\n } else if (absCommand === \"V\") {\n [, y] = seg as VSegment;\n y += isRelative ? params.y : /* istanbul ignore next @preserve */ 0;\n } else {\n [x, y] = seg.slice(-2) as PointTuple;\n x += isRelative ? params.x : 0;\n y += isRelative ? params.y : 0;\n }\n path.push(seg);\n }\n\n params.x = x;\n params.y = y;\n composite[pi] = path;\n });\n\n return composite;\n};\nexport default splitPath;\n","import getSVGMatrix from \"./getSVGMatrix\";\nimport projection2d from \"./projection2d\";\nimport defaultOptions from \"../options/options\";\nimport type {\n AbsoluteArray,\n AbsoluteSegment,\n CSegment,\n LSegment,\n PathArray,\n TransformObjectValues,\n} from \"../types\";\nimport type { TransformObject } from \"../interface\";\nimport iterate from \"./iterate\";\nimport parsePathString from \"../parser/parsePathString\";\nimport absolutizeSegment from \"./absolutizeSegment\";\nimport arcToCubic from \"./arcToCubic\";\n\n/**\n * Apply a 2D / 3D transformation to a `pathArray` instance.\n *\n * Since *SVGElement* doesn't support 3D transformation, this function\n * creates a 2D projection of the element.\n *\n * @param path the `pathArray` to apply transformation\n * @param transform the transform functions `Object`\n * @returns the resulted `pathArray`\n */\nconst transformPath = (\n pathInput: PathArray | string,\n transform?: Partial,\n) => {\n // last x and y transformed values\n let x = 0;\n let y = 0;\n // new x and y transformed\n let lx = 0;\n let ly = 0;\n // segment params iteration index and length\n let j = 0;\n let jj = 0;\n let pathCommand = \"M\";\n // transform uses it's own set of params\n const path = parsePathString(pathInput);\n const transformProps = transform && Object.keys(transform);\n\n // when used as a static method, invalidate somehow\n if (!transform || (transformProps && !transformProps.length)) {\n return path.slice(0) as typeof path;\n }\n\n // transform origin is extremely important\n if (!transform.origin) {\n Object.assign(transform, { origin: defaultOptions.origin });\n }\n const origin = transform.origin as [number, number, number];\n const matrixInstance = getSVGMatrix(transform as TransformObjectValues);\n\n if (matrixInstance.isIdentity) return path.slice(0) as typeof path;\n\n return iterate(path, (seg, index, lastX, lastY) => {\n [pathCommand] = seg;\n const absCommand = pathCommand.toUpperCase();\n const isRelative = absCommand !== pathCommand;\n const absoluteSegment = isRelative\n ? absolutizeSegment(seg, index, lastX, lastY)\n : (seg.slice(0) as AbsoluteSegment);\n\n let result = absCommand === \"A\"\n // ? segmentToCubic(absoluteSegment, transformParams)\n ? ([\"C\" as string | number].concat(\n arcToCubic(\n lastX,\n lastY,\n absoluteSegment[1] as number,\n absoluteSegment[2] as number,\n absoluteSegment[3] as number,\n absoluteSegment[4] as number,\n absoluteSegment[5] as number,\n absoluteSegment[6] as number,\n absoluteSegment[7] as number,\n ),\n ) as CSegment)\n : absCommand === \"V\"\n ? ([\"L\", lastX, absoluteSegment[1]] as LSegment)\n : absCommand === \"H\"\n ? ([\"L\", absoluteSegment[1], lastY] as LSegment)\n : absoluteSegment;\n\n // update pathCommand\n pathCommand = result[0];\n const isLongArc = pathCommand === \"C\" && result.length > 7;\n const tempSegment =\n (isLongArc ? result.slice(0, 7) : result.slice(0)) as AbsoluteSegment;\n\n if (isLongArc) {\n path.splice(\n index + 1,\n 0,\n [\"C\" as typeof pathCommand | number].concat(\n result.slice(7),\n ) as CSegment,\n );\n result = tempSegment as CSegment;\n }\n\n if (pathCommand === \"L\") {\n [lx, ly] = projection2d(matrixInstance, [\n (result as LSegment)[1],\n (result as LSegment)[2],\n ], origin);\n\n /* istanbul ignore else @preserve */\n if (x !== lx && y !== ly) {\n result = [\"L\", lx, ly];\n } else if (y === ly) {\n result = [\"H\", lx];\n } else if (x === lx) {\n result = [\"V\", ly];\n }\n } else {\n for (j = 1, jj = result.length; j < jj; j += 2) {\n [lx, ly] = projection2d(\n matrixInstance,\n [+result[j], +result[j + 1]],\n origin,\n );\n result[j] = lx;\n result[j + 1] = ly;\n }\n }\n // now update x and y\n x = lx;\n y = ly;\n\n return result;\n });\n};\n\nexport default transformPath;\n","\"use strict\";\nimport * as util from \"./util\";\n// import CSSMatrix from \"@thednp/dommatrix\";\nimport type { PathArray, PointTuple, TransformObjectValues } from \"./types\";\nimport type { Options, TransformEntries, TransformObject } from \"./interface\";\nexport * from \"./types\";\nexport * from \"./interface\";\nimport defaultOptions from \"./options/options\";\n\nimport pathToAbsolute from \"./convert/pathToAbsolute\";\nimport pathToRelative from \"./convert/pathToRelative\";\nimport pathToCurve from \"./convert/pathToCurve\";\nimport pathToString from \"./convert/pathToString\";\n// import * as arcTools from \"./math/arcTools\";\n// import * as bezierTools from \"./math/bezier\";\n// import * as cubicTools from \"./math/cubicTools\";\n// import * as lineTools from \"./math/lineTools\";\n// import * as quadTools from \"./math/quadTools\";\n// import * as polygonTools from \"./math/polygonTools\";\n\n// import distanceSquareRoot from \"./math/distanceSquareRoot\";\n// import midPoint from \"./math/midPoint\";\n// import rotateVector from \"./math/rotateVector\";\n// import roundTo from \"./math/roundTo\";\n\nimport error from \"./parser/error\";\nimport parsePathString from \"./parser/parsePathString\";\n// import finalizeSegment from \"./parser/finalizeSegment\";\n// import invalidPathValue from \"./parser/invalidPathValue\";\n// import isArcCommand from \"./parser/isArcCommand\";\n// import isDigit from \"./parser/isDigit\";\n// import isDigitStart from \"./parser/isDigitStart\";\n// import isMoveCommand from \"./parser/isMoveCommand\";\n// import isPathCommand from \"./parser/isPathCommand\";\n// import isSpace from \"./parser/isSpace\";\n// import paramsCount from \"./parser/paramsCount\";\n// import paramsParser from \"./parser/paramsParser\";\n// import pathParser from \"./parser/pathParser\";\n// import scanFlag from \"./parser/scanFlag\";\n// import scanParam from \"./parser/scanParam\";\n// import scanSegment from \"./parser/scanSegment\";\n// import skipSpaces from \"./parser/skipSpaces\";\n\n// import distanceEpsilon from \"./util/distanceEpsilon\";\n// import getClosestPoint from \"./util/getClosestPoint\";\n// import getDrawDirection from \"./util/getDrawDirection\";\n// import getPathArea from \"./util/getPathArea\";\nimport getPathBBox from \"./util/getPathBBox\";\nimport getPointAtLength from \"./util/getPointAtLength\";\n// import getPropertiesAtLength from \"./util/getPropertiesAtLength\";\n// import getPropertiesAtPoint from \"./util/getPropertiesAtPoint\";\n// import getSegmentAtLength from \"./util/getSegmentAtLength\";\n// import getSegmentOfPoint from \"./util/getSegmentOfPoint\";\nimport getTotalLength from \"./util/getTotalLength\";\n\n// import isAbsoluteArray from \"./util/isAbsoluteArray\";\n// import isCurveArray from \"./util/isCurveArray\";\n// import isNormalizedArray from \"./util/isNormalizedArray\";\n// import isPathArray from \"./util/isPathArray\";\n// import isPointInStroke from \"./util/isPointInStroke\";\n// import isRelativeArray from \"./util/isRelativeArray\";\n// import isValidPath from \"./util/isValidPath\";\n// import shapeParams from \"./util/shapeParams\";\n// import shapeToPath from \"./util/shapeToPath\";\n// import shapeToPathArray from \"./util/shapeToPathArray\";\n\n// import absolutizeSegment from \"./process/absolutizeSegment\";\n// import arcToCubic from \"./process/arcToCubic\";\n// import getSVGMatrix from \"./process/getSVGMatrix\";\n// import iterate from \"./process/iterate\";\n// import lineToCubic from \"./process/lineToCubic\";\nimport normalizePath from \"./process/normalizePath\";\n// import normalizeSegment from \"./process/normalizeSegment\";\nimport optimizePath from \"./process/optimizePath\";\n// import projection2d from \"./process/projection2d\";\n// import quadToCubic from \"./process/quadToCubic\";\n// import relativizeSegment from \"./process/relativizeSegment\";\n// import reverseCurve from \"./process/reverseCurve\";\nimport reversePath from \"./process/reversePath\";\n// import roundPath from \"./process/roundPath\";\n// import roundSegment from \"./process/roundSegment\";\n// import segmentToCubic from \"./process/segmentToCubic\";\n// import shortenSegment from \"./process/shortenSegment\";\n// import splitCubic from \"./process/splitCubic\";\nimport splitPath from \"./process/splitPath\";\nimport transformPath from \"./process/transformPath\";\n\n/**\n * Creates a new SVGPathCommander instance with the following properties:\n * * segments: `pathArray`\n * * round: number\n * * origin: [number, number, number?]\n *\n * @class\n * @author thednp \n * @returns a new SVGPathCommander instance\n */\nclass SVGPathCommander {\n // declare class properties\n declare segments: PathArray;\n declare round: number | \"off\";\n declare origin: [number, number, number];\n\n /**\n * @constructor\n * @param pathValue the path string\n * @param config instance options\n */\n constructor(pathValue: string, config?: Partial) {\n const instanceOptions = config || {};\n const undefPath = typeof pathValue === \"undefined\";\n\n if (undefPath || !pathValue.length) {\n throw TypeError(\n `${error}: \"pathValue\" is ${undefPath ? \"undefined\" : \"empty\"}`,\n );\n }\n\n this.segments = parsePathString(pathValue);\n\n // // set instance options.round\n const { round: roundOption, origin: originOption } = instanceOptions;\n let round: number | \"off\";\n\n if (Number.isInteger(roundOption) || roundOption === \"off\") {\n round = roundOption as number | \"off\";\n } else {\n round = defaultOptions.round as number;\n }\n\n // set instance options.origin\n // the SVGPathCommander class will always override the default origin\n let origin = defaultOptions.origin as [number, number, number];\n /* istanbul ignore else @preserve */\n if (Array.isArray(originOption) && originOption.length >= 2) {\n const [originX, originY, originZ] = originOption.map(Number);\n origin = [\n !Number.isNaN(originX) ? originX : 0,\n !Number.isNaN(originY) ? originY : 0,\n !Number.isNaN(originZ) ? originZ : 0,\n ];\n }\n\n this.round = round;\n this.origin = origin;\n\n return this;\n }\n get bbox() {\n return getPathBBox(this.segments);\n }\n get length() {\n return getTotalLength(this.segments);\n }\n\n /**\n * Returns the path bounding box, equivalent to native `path.getBBox()`.\n *\n * @public\n * @returns the pathBBox\n */\n getBBox() {\n return this.bbox;\n }\n\n /**\n * Returns the total path length, equivalent to native `path.getTotalLength()`.\n *\n * @public\n * @returns the path total length\n */\n getTotalLength() {\n return this.length;\n }\n\n /**\n * Returns an `{x,y}` point in the path stroke at a given length,\n * equivalent to the native `path.getPointAtLength()`.\n *\n * @public\n * @param length the length\n * @returns the requested point\n */\n getPointAtLength(length: number) {\n return getPointAtLength(this.segments, length);\n }\n\n /**\n * Convert path to absolute values\n *\n * @public\n */\n toAbsolute() {\n const { segments } = this;\n this.segments = pathToAbsolute(segments);\n return this;\n }\n\n /**\n * Convert path to relative values\n *\n * @public\n */\n toRelative() {\n const { segments } = this;\n this.segments = pathToRelative(segments);\n return this;\n }\n\n /**\n * Convert path to cubic-bezier values. In addition, un-necessary `Z`\n * segment is removed if previous segment extends to the `M` segment.\n *\n * @public\n */\n toCurve() {\n const { segments } = this;\n this.segments = pathToCurve(segments);\n return this;\n }\n\n /**\n * Reverse the order of the segments and their values.\n *\n * @param onlySubpath option to reverse all sub-paths except first\n * @public\n */\n reverse(onlySubpath?: boolean) {\n const { segments } = this;\n const split = splitPath(segments);\n const subPath = split.length > 1 ? split : false;\n\n const absoluteMultiPath = subPath\n ? subPath.map((x, i) => {\n if (onlySubpath) {\n return i ? reversePath(x) : x.slice(0);\n }\n return reversePath(x);\n })\n : segments.slice(0);\n\n let path = [] as unknown as PathArray;\n if (subPath) {\n path = absoluteMultiPath.flat(1) as PathArray;\n } else {\n path = onlySubpath ? segments : reversePath(segments);\n }\n\n this.segments = path.slice(0) as PathArray;\n return this;\n }\n\n /**\n * Normalize path in 2 steps:\n * * convert `pathArray`(s) to absolute values\n * * convert shorthand notation to standard notation\n *\n * @public\n */\n normalize() {\n const { segments } = this;\n this.segments = normalizePath(segments);\n return this;\n }\n\n /**\n * Optimize `pathArray` values:\n * * convert segments to absolute and/or relative values\n * * select segments with shortest resulted string\n * * round values to the specified `decimals` option value\n *\n * @public\n */\n optimize() {\n const { segments } = this;\n const round = this.round === \"off\" ? 2 : this.round;\n\n this.segments = optimizePath(segments, round);\n return this;\n }\n\n /**\n * Transform path using values from an `Object` defined as `transformObject`.\n *\n * @see TransformObject for a quick refference\n *\n * @param source a `transformObject`as described above\n * @public\n */\n transform(source?: Partial) {\n if (\n !source ||\n typeof source !== \"object\" ||\n (typeof source === \"object\" &&\n ![\"translate\", \"rotate\", \"skew\", \"scale\"].some((x) => x in source))\n ) {\n return this;\n }\n\n const {\n segments,\n origin: [cx, cy, cz],\n } = this;\n const transform = {} as TransformObjectValues;\n for (const [k, v] of Object.entries(source) as TransformEntries) {\n // istanbul ignore else @preserve\n if (k === \"skew\" && Array.isArray(v)) {\n transform[k] = v.map(Number) as PointTuple;\n } else if (\n (k === \"rotate\" || k === \"translate\" || k === \"origin\" ||\n k === \"scale\") && Array.isArray(v)\n ) {\n transform[k] = v.map(Number) as [number, number, number];\n } else if (k !== \"origin\" && typeof Number(v) === \"number\") {\n transform[k] = Number(v);\n }\n }\n\n // if origin is not specified\n // it's important that we have one\n const { origin } = transform;\n\n if (Array.isArray(origin) && origin.length >= 2) {\n const [originX, originY, originZ] = origin.map(Number);\n transform.origin = [\n !Number.isNaN(originX) ? originX : cx,\n !Number.isNaN(originY) ? originY : cy,\n originZ || cz,\n ];\n } else {\n transform.origin = [cx, cy, cz];\n }\n\n this.segments = transformPath(segments, transform);\n return this;\n }\n\n /**\n * Rotate path 180deg vertically\n *\n * @public\n */\n flipX() {\n const { cx, cy } = this.bbox;\n this.transform({ rotate: [0, 180, 0], origin: [cx, cy, 0] });\n return this;\n }\n\n /**\n * Rotate path 180deg horizontally\n *\n * @public\n */\n flipY() {\n const { cx, cy } = this.bbox;\n this.transform({ rotate: [180, 0, 0], origin: [cx, cy, 0] });\n return this;\n }\n\n /**\n * Export the current path to be used\n * for the `d` (description) attribute.\n *\n * @public\n * @return the path string\n */\n toString() {\n return pathToString(this.segments, this.round);\n }\n\n /**\n * Remove the instance.\n *\n * @public\n * @return void\n */\n dispose() {\n Object.keys(this).forEach((key) => delete this[key as keyof typeof this]);\n }\n}\n\n// export {\n// absolutizeSegment,\n// arcToCubic,\n// arcTools,\n// bezierTools,\n// CSSMatrix,\n// cubicTools,\n// distanceEpsilon,\n// distanceSquareRoot,\n// finalizeSegment,\n// getClosestPoint,\n// getDrawDirection,\n// getPathArea,\n// getPathBBox,\n// getPointAtLength,\n// getPropertiesAtLength,\n// getPropertiesAtPoint,\n// getSegmentAtLength,\n// getSegmentOfPoint,\n// getSVGMatrix,\n// getTotalLength,\n// invalidPathValue,\n// isAbsoluteArray,\n// isArcCommand,\n// isCurveArray,\n// isDigit,\n// isDigitStart,\n// isMoveCommand,\n// isNormalizedArray,\n// isPathArray,\n// isPathCommand,\n// isPointInStroke,\n// isRelativeArray,\n// isSpace,\n// isValidPath,\n// iterate,\n// lineToCubic,\n// lineTools,\n// midPoint,\n// normalizePath,\n// normalizeSegment,\n// optimizePath,\n// paramsCount,\n// paramsParser,\n// parsePathString,\n// pathParser,\n// pathToAbsolute,\n// pathToCurve,\n// pathToRelative,\n// pathToString,\n// polygonTools,\n// projection2d,\n// quadToCubic,\n// quadTools,\n// relativizeSegment,\n// reverseCurve,\n// reversePath,\n// rotateVector,\n// roundPath,\n// roundSegment,\n// roundTo,\n// scanFlag,\n// scanParam,\n// scanSegment,\n// segmentToCubic,\n// shapeParams,\n// shapeToPath,\n// shapeToPathArray,\n// shortenSegment,\n// skipSpaces,\n// splitCubic,\n// splitPath,\n// // SVGPathCommander as default,\n// transformPath,\n// };\n\n// const index = {\n// absolutizeSegment,\n// arcToCubic,\n// arcTools,\n// bezierTools,\n// CSSMatrix,\n// cubicTools,\n// distanceEpsilon,\n// distanceSquareRoot,\n// finalizeSegment,\n// getClosestPoint,\n// getDrawDirection,\n// getPathArea,\n// getPathBBox,\n// getPointAtLength,\n// getPropertiesAtLength,\n// getPropertiesAtPoint,\n// getSegmentAtLength,\n// getSegmentOfPoint,\n// getSVGMatrix,\n// getTotalLength,\n// invalidPathValue,\n// isAbsoluteArray,\n// isArcCommand,\n// isCurveArray,\n// isDigit,\n// isDigitStart,\n// isMoveCommand,\n// isNormalizedArray,\n// isPathArray,\n// isPathCommand,\n// isPointInStroke,\n// isRelativeArray,\n// isSpace,\n// isValidPath,\n// iterate,\n// lineToCubic,\n// lineTools,\n// midPoint,\n// normalizePath,\n// normalizeSegment,\n// optimizePath,\n// paramsCount,\n// paramsParser,\n// parsePathString,\n// pathParser,\n// pathToAbsolute,\n// pathToCurve,\n// pathToRelative,\n// pathToString,\n// polygonTools,\n// projection2d,\n// quadToCubic,\n// quadTools,\n// relativizeSegment,\n// reverseCurve,\n// reversePath,\n// rotateVector,\n// roundPath,\n// roundSegment,\n// roundTo,\n// scanFlag,\n// scanParam,\n// scanSegment,\n// segmentToCubic,\n// shapeParams,\n// shapeToPath,\n// shapeToPathArray,\n// shortenSegment,\n// skipSpaces,\n// splitCubic,\n// splitPath,\n// transformPath,\n// };\n\n// export { absolutizeSegment }\n// export { arcToCubic }\n// export { arcTools }\n// export { bezierTools }\n// export { CSSMatrix }\n// export { cubicTools }\n// export { distanceEpsilon }\n// export { distanceSquareRoot }\n// export { finalizeSegment }\n// export { getClosestPoint }\n// export { getDrawDirection }\n// export { getPathArea }\n// export { getPathBBox }\n// export { getPointAtLength }\n// export { getPropertiesAtLength }\n// export { getPropertiesAtPoint }\n// export { getSegmentAtLength }\n// export { getSegmentOfPoint }\n// export { getSVGMatrix }\n// export { getTotalLength }\n// export { invalidPathValue }\n// export { isAbsoluteArray }\n// export { isArcCommand }\n// export { isCurveArray }\n// export { isDigit }\n// export { isDigitStart }\n// export { isMoveCommand }\n// export { isNormalizedArray }\n// export { isPathArray }\n// export { isPathCommand }\n// export { isPointInStroke }\n// export { isRelativeArray }\n// export { isSpace }\n// export { isValidPath }\n// export { iterate }\n// export { lineToCubic }\n// export { lineTools }\n// export { midPoint }\n// export { normalizePath }\n// export { normalizeSegment }\n// export { optimizePath }\n// export { paramsCount }\n// export { paramsParser }\n// export { parsePathString }\n// export { pathParser }\n// export { pathToAbsolute }\n// export { pathToCurve }\n// export { pathToRelative }\n// export { pathToString }\n// export { polygonTools }\n// export { projection2d }\n// export { quadToCubic }\n// export { quadTools }\n// export { relativizeSegment }\n// export { reverseCurve }\n// export { reversePath }\n// export { rotateVector }\n// export { roundPath }\n// export { roundSegment }\n// export { roundTo }\n// export { scanFlag }\n// export { scanParam }\n// export { scanSegment }\n// export { segmentToCubic }\n// export { shapeParams }\n// export { shapeToPath }\n// export { shapeToPathArray }\n// export { shortenSegment }\n// export { skipSpaces }\n// export { splitCubic }\n// export { splitPath }\n// export { transformPath }\n// export { SVGPathCommander as default }\n// export default SVGPathCommander;\nconst defaultExport = Object.assign(SVGPathCommander, util);\n\nexport { defaultExport as default };\n// export default Object.assign(SVGPathCommander, index);\n"],"names":["Z","z","s","t","e","p","$","E","P","y","g","n","i","r","a","m","h","c","u","w","o","d","A","M","b","X","O","x","Y","F","T","k","I","v","R","D","N","midPoint","ax","ay","bx","by","distanceSquareRoot","getLineLength","x1","y1","x2","y2","getPointAtLineLength","distance","point","length","getLineBBox","min","max","arcLength","rx","ry","theta","halfTheta","sinHalfTheta","cosHalfTheta","term1","term2","arcPoint","cx","cy","alpha","sin","cos","cosA","sinA","angleBetween","v0","v1","v0x","v0y","v1x","v1y","getArcProps","RX","RY","angle","LAF","SF","abs","sqrt","PI","xRotRad","dx","dy","transformedPoint","radiiCheck","cSquareNumerator","cSquareRootDenom","cRadicand","cCoef","transformedCenter","center","startVector","startAngle","endVector","sweepAngle","endAngle","getArcLength","getPointAtArcLength","ellipseComponentX","ellipseComponentY","getArcBBox","deltaAngle","tan","atan2","tangent","angle1","angle2","angle3","angle4","xArray","yArray","xMin","xMax","yMin","yMax","angleAfterStart","pP2","angleBeforeEnd","pP3","p1","p2","p4","p3","Tvalues","Cvalues","deriveBezier","points","dpoints","list","j","computeBezier","order","mt","mt2","t2","calculateBezier","derivativeFn","l","bezierLength","len","sum","getBezierLength","curve","idx","step","CBEZIER_MINMAX_EPSILON","minmaxQ","cp","v2","minmaxC","cp1","cp2","K","S","L","Q","getPointAtCubicSegmentLength","c1x","c1y","c2x","c2y","t1","getCubicLength","getPointAtCubicLength","distanceIsNumber","currentLength","getCubicBBox","cxMinMax","cyMinMax","getPointAtQuadSegmentLength","getQuadLength","getPointAtQuadLength","getQuadBBox","polygonArea","polygon","area","polygonLength","paramsCount","finalizeSegment","path","pathCommand","relativeCommand","data","error","scanFlag","index","pathValue","code","isDigit","invalidPathValue","scanParam","start","zeroFirst","hasCeiling","hasDecimal","hasDot","ch","isSpace","skipSpaces","isPathCommand","isDigitStart","isArcCommand","isMoveCommand","scanSegment","segments","cmdCode","reqParams","paramCounts","lastSegment","_a","PathParser","pathString","parsePathString","pathInput","absolutizeSegment","segment","lastX","lastY","absCommand","absValues","seglen","iterate","iterator","pathLen","isRelative","mx","my","segLen","iteratorResult","pathToAbsolute","relativizeSegment","relCommand","relValues","pathToRelative","rotateVector","rad","arcToCubic","X1","Y1","X2","Y2","recursive","d120","res","xy","f1","f2","rx2","ry2","df","f2old","x2old","y2old","c1","s1","c2","s2","hx","hy","m1","m2","m3","m4","newres","ii","quadToCubic","qx","qy","r13","r23","lineToCubic","segmentToCubic","params","values","px1","py1","px","py","normalizeSegment","px2","py2","nqx","nqy","paramsParser","pathToCurve","seg","normalSegment","result","defaultOptions","roundTo","round","pow","pathToString","roundOption","valLen","DISTANCE_EPSILON","normalizePath","_","getPointAtLength","isM","POINT","totalLength","getTotalLength","paramX1","paramY1","paramX2","paramY2","paramQX","paramQY","absoluteSegment","cp1x","cp1y","getPropertiesAtLength","pathArray","pathTemp","pathLength","lengthAtSegment","getPropertiesAtPoint","normalPath","distanceTo","precision","scan","closest","scanDistance","bestLength","bestDistance","scanLength","before","after","beforeLength","afterLength","beforeDistance","afterDistance","getClosestPoint","getCubicSegArea","getPathArea","getDrawDirection","getPathBBox","minX","minY","maxX","maxY","width","height","getSegmentAtLength","getSegmentOfPoint","isPathArray","lk","isAbsoluteArray","isNormalizedArray","pc","isCurveArray","isPointInStroke","isRelativeArray","isValidPath","shapeParams","isElement","node","getLinePath","attr","getPolyPath","getCirclePath","getEllipsePath","getRectanglePath","shapeToPathArray","element","supportedShapes","targetIsElement","tagName","type","shapeAttrs","config","shapeToPath","replace","ownerDocument","doc","description","name","value","getSVGMatrix","transform","matrix","CSSMatrix","origin","originX","originY","translate","rotate","skew","scale","shortenSegment","prevCommand","defaultRound","normalValues","nx","ny","nx1","ny1","roundSegment","optimizePath","optimParams","allPathCommands","normalizedSegment","shortSegment","absSegment","absString","relativeSegment","relSegment","relString","translatePoint","cssm","projection2d","point2D","originZ","relativePositionX","relativePositionY","relativePositionZ","reverseCurve","rotatedCurve","curveOnly","reversePath","absolutePath","normalizedPath","pLen","isClosed","reversedPath","prevSeg","nextSeg","nextCommand","roundPath","splitCubic","pts","ratio","p0","p5","p6","p7","p8","p9","splitPath","composite","pi","transformPath","lx","ly","jj","transformProps","matrixInstance","isLongArc","tempSegment","SVGPathCommander","instanceOptions","undefPath","originOption","onlySubpath","split","subPath","absoluteMultiPath","source","cz","key","defaultExport","util"],"mappings":"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","x_google_ignoreList":[0]} \ No newline at end of file +{"version":3,"sources":["../src/index.ts","../src/util.ts","../src/math/arcTools.ts","../src/math/lineTools.ts","../src/math/midPoint.ts","../src/math/distanceSquareRoot.ts","../src/math/bezier.ts","../src/math/cubicTools.ts","../src/math/quadTools.ts","../src/math/polygonTools.ts","../src/parser/paramsCount.ts","../src/parser/finalizeSegment.ts","../src/parser/error.ts","../src/parser/scanFlag.ts","../src/parser/isDigit.ts","../src/parser/invalidPathValue.ts","../src/parser/scanParam.ts","../src/parser/isSpace.ts","../src/parser/skipSpaces.ts","../src/parser/isPathCommand.ts","../src/parser/isDigitStart.ts","../src/parser/isArcCommand.ts","../src/parser/isMoveCommand.ts","../src/parser/scanSegment.ts","../src/parser/pathParser.ts","../src/parser/parsePathString.ts","../src/process/absolutizeSegment.ts","../src/process/iterate.ts","../src/convert/pathToAbsolute.ts","../src/process/relativizeSegment.ts","../src/convert/pathToRelative.ts","../src/math/rotateVector.ts","../src/process/arcToCubic.ts","../src/process/quadToCubic.ts","../src/process/lineToCubic.ts","../src/process/segmentToCubic.ts","../src/process/normalizeSegment.ts","../src/parser/paramsParser.ts","../src/convert/pathToCurve.ts","../src/options/options.ts","../src/math/roundTo.ts","../src/convert/pathToString.ts","../src/util/distanceEpsilon.ts","../src/process/normalizePath.ts","../src/util/getPointAtLength.ts","../src/util/getTotalLength.ts","../src/util/getPropertiesAtLength.ts","../src/util/getPropertiesAtPoint.ts","../src/util/getClosestPoint.ts","../src/util/getPathArea.ts","../src/util/getDrawDirection.ts","../src/util/getPathBBox.ts","../src/util/getSegmentAtLength.ts","../src/util/getSegmentOfPoint.ts","../src/util/isPathArray.ts","../src/util/isAbsoluteArray.ts","../src/util/isNormalizedArray.ts","../src/util/isCurveArray.ts","../src/util/isPointInStroke.ts","../src/util/isRelativeArray.ts","../src/util/isValidPath.ts","../src/util/shapeParams.ts","../src/util/isElement.ts","../src/util/shapeToPathArray.ts","../src/util/shapeToPath.ts","../src/process/getSVGMatrix.ts","../src/process/shortenSegment.ts","../src/process/roundSegment.ts","../src/process/optimizePath.ts","../src/process/projection2d.ts","../src/process/reverseCurve.ts","../src/process/reversePath.ts","../src/process/roundPath.ts","../src/process/splitCubic.ts","../src/process/splitPath.ts","../src/process/transformPath.ts"],"sourcesContent":["\"use strict\";\nimport * as util from \"./util\";\n// import CSSMatrix from \"@thednp/dommatrix\";\nimport type { PathArray, PointTuple, TransformObjectValues } from \"./types\";\nimport type { Options, TransformEntries, TransformObject } from \"./interface\";\nexport * from \"./types\";\nexport * from \"./interface\";\nimport defaultOptions from \"./options/options\";\n\nimport pathToAbsolute from \"./convert/pathToAbsolute\";\nimport pathToRelative from \"./convert/pathToRelative\";\nimport pathToCurve from \"./convert/pathToCurve\";\nimport pathToString from \"./convert/pathToString\";\n// import * as arcTools from \"./math/arcTools\";\n// import * as bezierTools from \"./math/bezier\";\n// import * as cubicTools from \"./math/cubicTools\";\n// import * as lineTools from \"./math/lineTools\";\n// import * as quadTools from \"./math/quadTools\";\n// import * as polygonTools from \"./math/polygonTools\";\n\n// import distanceSquareRoot from \"./math/distanceSquareRoot\";\n// import midPoint from \"./math/midPoint\";\n// import rotateVector from \"./math/rotateVector\";\n// import roundTo from \"./math/roundTo\";\n\nimport error from \"./parser/error\";\nimport parsePathString from \"./parser/parsePathString\";\n// import finalizeSegment from \"./parser/finalizeSegment\";\n// import invalidPathValue from \"./parser/invalidPathValue\";\n// import isArcCommand from \"./parser/isArcCommand\";\n// import isDigit from \"./parser/isDigit\";\n// import isDigitStart from \"./parser/isDigitStart\";\n// import isMoveCommand from \"./parser/isMoveCommand\";\n// import isPathCommand from \"./parser/isPathCommand\";\n// import isSpace from \"./parser/isSpace\";\n// import paramsCount from \"./parser/paramsCount\";\n// import paramsParser from \"./parser/paramsParser\";\n// import pathParser from \"./parser/pathParser\";\n// import scanFlag from \"./parser/scanFlag\";\n// import scanParam from \"./parser/scanParam\";\n// import scanSegment from \"./parser/scanSegment\";\n// import skipSpaces from \"./parser/skipSpaces\";\n\n// import distanceEpsilon from \"./util/distanceEpsilon\";\n// import getClosestPoint from \"./util/getClosestPoint\";\n// import getDrawDirection from \"./util/getDrawDirection\";\n// import getPathArea from \"./util/getPathArea\";\nimport getPathBBox from \"./util/getPathBBox\";\nimport getPointAtLength from \"./util/getPointAtLength\";\n// import getPropertiesAtLength from \"./util/getPropertiesAtLength\";\n// import getPropertiesAtPoint from \"./util/getPropertiesAtPoint\";\n// import getSegmentAtLength from \"./util/getSegmentAtLength\";\n// import getSegmentOfPoint from \"./util/getSegmentOfPoint\";\nimport getTotalLength from \"./util/getTotalLength\";\n\n// import isAbsoluteArray from \"./util/isAbsoluteArray\";\n// import isCurveArray from \"./util/isCurveArray\";\n// import isNormalizedArray from \"./util/isNormalizedArray\";\n// import isPathArray from \"./util/isPathArray\";\n// import isPointInStroke from \"./util/isPointInStroke\";\n// import isRelativeArray from \"./util/isRelativeArray\";\n// import isValidPath from \"./util/isValidPath\";\n// import shapeParams from \"./util/shapeParams\";\n// import shapeToPath from \"./util/shapeToPath\";\n// import shapeToPathArray from \"./util/shapeToPathArray\";\n\n// import absolutizeSegment from \"./process/absolutizeSegment\";\n// import arcToCubic from \"./process/arcToCubic\";\n// import getSVGMatrix from \"./process/getSVGMatrix\";\n// import iterate from \"./process/iterate\";\n// import lineToCubic from \"./process/lineToCubic\";\nimport normalizePath from \"./process/normalizePath\";\n// import normalizeSegment from \"./process/normalizeSegment\";\nimport optimizePath from \"./process/optimizePath\";\n// import projection2d from \"./process/projection2d\";\n// import quadToCubic from \"./process/quadToCubic\";\n// import relativizeSegment from \"./process/relativizeSegment\";\n// import reverseCurve from \"./process/reverseCurve\";\nimport reversePath from \"./process/reversePath\";\n// import roundPath from \"./process/roundPath\";\n// import roundSegment from \"./process/roundSegment\";\n// import segmentToCubic from \"./process/segmentToCubic\";\n// import shortenSegment from \"./process/shortenSegment\";\n// import splitCubic from \"./process/splitCubic\";\nimport splitPath from \"./process/splitPath\";\nimport transformPath from \"./process/transformPath\";\n\n/**\n * Creates a new SVGPathCommander instance with the following properties:\n * * segments: `pathArray`\n * * round: number\n * * origin: [number, number, number?]\n *\n * @class\n * @author thednp \n * @returns a new SVGPathCommander instance\n */\nclass SVGPathCommander {\n // declare class properties\n declare segments: PathArray;\n declare round: number | \"off\";\n declare origin: [number, number, number];\n\n /**\n * @constructor\n * @param pathValue the path string\n * @param config instance options\n */\n constructor(pathValue: string, config?: Partial) {\n const instanceOptions = config || {};\n const undefPath = typeof pathValue === \"undefined\";\n\n if (undefPath || !pathValue.length) {\n throw TypeError(\n `${error}: \"pathValue\" is ${undefPath ? \"undefined\" : \"empty\"}`,\n );\n }\n\n this.segments = parsePathString(pathValue);\n\n // // set instance options.round\n const { round: roundOption, origin: originOption } = instanceOptions;\n let round: number | \"off\";\n\n if (Number.isInteger(roundOption) || roundOption === \"off\") {\n round = roundOption as number | \"off\";\n } else {\n round = defaultOptions.round as number;\n }\n\n // set instance options.origin\n // the SVGPathCommander class will always override the default origin\n let origin = defaultOptions.origin as [number, number, number];\n /* istanbul ignore else @preserve */\n if (Array.isArray(originOption) && originOption.length >= 2) {\n const [originX, originY, originZ] = originOption.map(Number);\n origin = [\n !Number.isNaN(originX) ? originX : 0,\n !Number.isNaN(originY) ? originY : 0,\n !Number.isNaN(originZ) ? originZ : 0,\n ];\n }\n\n this.round = round;\n this.origin = origin;\n\n return this;\n }\n get bbox() {\n return getPathBBox(this.segments);\n }\n get length() {\n return getTotalLength(this.segments);\n }\n\n /**\n * Returns the path bounding box, equivalent to native `path.getBBox()`.\n *\n * @public\n * @returns the pathBBox\n */\n getBBox() {\n return this.bbox;\n }\n\n /**\n * Returns the total path length, equivalent to native `path.getTotalLength()`.\n *\n * @public\n * @returns the path total length\n */\n getTotalLength() {\n return this.length;\n }\n\n /**\n * Returns an `{x,y}` point in the path stroke at a given length,\n * equivalent to the native `path.getPointAtLength()`.\n *\n * @public\n * @param length the length\n * @returns the requested point\n */\n getPointAtLength(length: number) {\n return getPointAtLength(this.segments, length);\n }\n\n /**\n * Convert path to absolute values\n *\n * @public\n */\n toAbsolute() {\n const { segments } = this;\n this.segments = pathToAbsolute(segments);\n return this;\n }\n\n /**\n * Convert path to relative values\n *\n * @public\n */\n toRelative() {\n const { segments } = this;\n this.segments = pathToRelative(segments);\n return this;\n }\n\n /**\n * Convert path to cubic-bezier values. In addition, un-necessary `Z`\n * segment is removed if previous segment extends to the `M` segment.\n *\n * @public\n */\n toCurve() {\n const { segments } = this;\n this.segments = pathToCurve(segments);\n return this;\n }\n\n /**\n * Reverse the order of the segments and their values.\n *\n * @param onlySubpath option to reverse all sub-paths except first\n * @public\n */\n reverse(onlySubpath?: boolean) {\n const { segments } = this;\n const split = splitPath(segments);\n const subPath = split.length > 1 ? split : false;\n\n const absoluteMultiPath = subPath\n ? subPath.map((x, i) => {\n if (onlySubpath) {\n return i ? reversePath(x) : x.slice(0);\n }\n return reversePath(x);\n })\n : segments.slice(0);\n\n let path = [] as unknown as PathArray;\n if (subPath) {\n path = absoluteMultiPath.flat(1) as PathArray;\n } else {\n path = onlySubpath ? segments : reversePath(segments);\n }\n\n this.segments = path.slice(0) as PathArray;\n return this;\n }\n\n /**\n * Normalize path in 2 steps:\n * * convert `pathArray`(s) to absolute values\n * * convert shorthand notation to standard notation\n *\n * @public\n */\n normalize() {\n const { segments } = this;\n this.segments = normalizePath(segments);\n return this;\n }\n\n /**\n * Optimize `pathArray` values:\n * * convert segments to absolute and/or relative values\n * * select segments with shortest resulted string\n * * round values to the specified `decimals` option value\n *\n * @public\n */\n optimize() {\n const { segments } = this;\n const round = this.round === \"off\" ? 2 : this.round;\n\n this.segments = optimizePath(segments, round);\n return this;\n }\n\n /**\n * Transform path using values from an `Object` defined as `transformObject`.\n *\n * @see TransformObject for a quick refference\n *\n * @param source a `transformObject`as described above\n * @public\n */\n transform(source?: Partial) {\n if (\n !source ||\n typeof source !== \"object\" ||\n (typeof source === \"object\" &&\n ![\"translate\", \"rotate\", \"skew\", \"scale\"].some((x) => x in source))\n ) {\n return this;\n }\n\n const {\n segments,\n origin: [cx, cy, cz],\n } = this;\n const transform = {} as TransformObjectValues;\n for (const [k, v] of Object.entries(source) as TransformEntries) {\n // istanbul ignore else @preserve\n if (k === \"skew\" && Array.isArray(v)) {\n transform[k] = v.map(Number) as PointTuple;\n } else if (\n (k === \"rotate\" || k === \"translate\" || k === \"origin\" ||\n k === \"scale\") && Array.isArray(v)\n ) {\n transform[k] = v.map(Number) as [number, number, number];\n } else if (k !== \"origin\" && typeof Number(v) === \"number\") {\n transform[k] = Number(v);\n }\n }\n\n // if origin is not specified\n // it's important that we have one\n const { origin } = transform;\n\n if (Array.isArray(origin) && origin.length >= 2) {\n const [originX, originY, originZ] = origin.map(Number);\n transform.origin = [\n !Number.isNaN(originX) ? originX : cx,\n !Number.isNaN(originY) ? originY : cy,\n originZ || cz,\n ];\n } else {\n transform.origin = [cx, cy, cz];\n }\n\n this.segments = transformPath(segments, transform);\n return this;\n }\n\n /**\n * Rotate path 180deg vertically\n *\n * @public\n */\n flipX() {\n const { cx, cy } = this.bbox;\n this.transform({ rotate: [0, 180, 0], origin: [cx, cy, 0] });\n return this;\n }\n\n /**\n * Rotate path 180deg horizontally\n *\n * @public\n */\n flipY() {\n const { cx, cy } = this.bbox;\n this.transform({ rotate: [180, 0, 0], origin: [cx, cy, 0] });\n return this;\n }\n\n /**\n * Export the current path to be used\n * for the `d` (description) attribute.\n *\n * @public\n * @return the path string\n */\n toString() {\n return pathToString(this.segments, this.round);\n }\n\n /**\n * Remove the instance.\n *\n * @public\n * @return void\n */\n dispose() {\n Object.keys(this).forEach((key) => delete this[key as keyof typeof this]);\n }\n}\n\n// export {\n// absolutizeSegment,\n// arcToCubic,\n// arcTools,\n// bezierTools,\n// CSSMatrix,\n// cubicTools,\n// distanceEpsilon,\n// distanceSquareRoot,\n// finalizeSegment,\n// getClosestPoint,\n// getDrawDirection,\n// getPathArea,\n// getPathBBox,\n// getPointAtLength,\n// getPropertiesAtLength,\n// getPropertiesAtPoint,\n// getSegmentAtLength,\n// getSegmentOfPoint,\n// getSVGMatrix,\n// getTotalLength,\n// invalidPathValue,\n// isAbsoluteArray,\n// isArcCommand,\n// isCurveArray,\n// isDigit,\n// isDigitStart,\n// isMoveCommand,\n// isNormalizedArray,\n// isPathArray,\n// isPathCommand,\n// isPointInStroke,\n// isRelativeArray,\n// isSpace,\n// isValidPath,\n// iterate,\n// lineToCubic,\n// lineTools,\n// midPoint,\n// normalizePath,\n// normalizeSegment,\n// optimizePath,\n// paramsCount,\n// paramsParser,\n// parsePathString,\n// pathParser,\n// pathToAbsolute,\n// pathToCurve,\n// pathToRelative,\n// pathToString,\n// polygonTools,\n// projection2d,\n// quadToCubic,\n// quadTools,\n// relativizeSegment,\n// reverseCurve,\n// reversePath,\n// rotateVector,\n// roundPath,\n// roundSegment,\n// roundTo,\n// scanFlag,\n// scanParam,\n// scanSegment,\n// segmentToCubic,\n// shapeParams,\n// shapeToPath,\n// shapeToPathArray,\n// shortenSegment,\n// skipSpaces,\n// splitCubic,\n// splitPath,\n// // SVGPathCommander as default,\n// transformPath,\n// };\n\n// const index = {\n// absolutizeSegment,\n// arcToCubic,\n// arcTools,\n// bezierTools,\n// CSSMatrix,\n// cubicTools,\n// distanceEpsilon,\n// distanceSquareRoot,\n// finalizeSegment,\n// getClosestPoint,\n// getDrawDirection,\n// getPathArea,\n// getPathBBox,\n// getPointAtLength,\n// getPropertiesAtLength,\n// getPropertiesAtPoint,\n// getSegmentAtLength,\n// getSegmentOfPoint,\n// getSVGMatrix,\n// getTotalLength,\n// invalidPathValue,\n// isAbsoluteArray,\n// isArcCommand,\n// isCurveArray,\n// isDigit,\n// isDigitStart,\n// isMoveCommand,\n// isNormalizedArray,\n// isPathArray,\n// isPathCommand,\n// isPointInStroke,\n// isRelativeArray,\n// isSpace,\n// isValidPath,\n// iterate,\n// lineToCubic,\n// lineTools,\n// midPoint,\n// normalizePath,\n// normalizeSegment,\n// optimizePath,\n// paramsCount,\n// paramsParser,\n// parsePathString,\n// pathParser,\n// pathToAbsolute,\n// pathToCurve,\n// pathToRelative,\n// pathToString,\n// polygonTools,\n// projection2d,\n// quadToCubic,\n// quadTools,\n// relativizeSegment,\n// reverseCurve,\n// reversePath,\n// rotateVector,\n// roundPath,\n// roundSegment,\n// roundTo,\n// scanFlag,\n// scanParam,\n// scanSegment,\n// segmentToCubic,\n// shapeParams,\n// shapeToPath,\n// shapeToPathArray,\n// shortenSegment,\n// skipSpaces,\n// splitCubic,\n// splitPath,\n// transformPath,\n// };\n\n// export { absolutizeSegment }\n// export { arcToCubic }\n// export { arcTools }\n// export { bezierTools }\n// export { CSSMatrix }\n// export { cubicTools }\n// export { distanceEpsilon }\n// export { distanceSquareRoot }\n// export { finalizeSegment }\n// export { getClosestPoint }\n// export { getDrawDirection }\n// export { getPathArea }\n// export { getPathBBox }\n// export { getPointAtLength }\n// export { getPropertiesAtLength }\n// export { getPropertiesAtPoint }\n// export { getSegmentAtLength }\n// export { getSegmentOfPoint }\n// export { getSVGMatrix }\n// export { getTotalLength }\n// export { invalidPathValue }\n// export { isAbsoluteArray }\n// export { isArcCommand }\n// export { isCurveArray }\n// export { isDigit }\n// export { isDigitStart }\n// export { isMoveCommand }\n// export { isNormalizedArray }\n// export { isPathArray }\n// export { isPathCommand }\n// export { isPointInStroke }\n// export { isRelativeArray }\n// export { isSpace }\n// export { isValidPath }\n// export { iterate }\n// export { lineToCubic }\n// export { lineTools }\n// export { midPoint }\n// export { normalizePath }\n// export { normalizeSegment }\n// export { optimizePath }\n// export { paramsCount }\n// export { paramsParser }\n// export { parsePathString }\n// export { pathParser }\n// export { pathToAbsolute }\n// export { pathToCurve }\n// export { pathToRelative }\n// export { pathToString }\n// export { polygonTools }\n// export { projection2d }\n// export { quadToCubic }\n// export { quadTools }\n// export { relativizeSegment }\n// export { reverseCurve }\n// export { reversePath }\n// export { rotateVector }\n// export { roundPath }\n// export { roundSegment }\n// export { roundTo }\n// export { scanFlag }\n// export { scanParam }\n// export { scanSegment }\n// export { segmentToCubic }\n// export { shapeParams }\n// export { shapeToPath }\n// export { shapeToPathArray }\n// export { shortenSegment }\n// export { skipSpaces }\n// export { splitCubic }\n// export { splitPath }\n// export { transformPath }\n// export { SVGPathCommander as default }\n// export default SVGPathCommander;\nconst defaultExport = Object.assign(SVGPathCommander, util);\n\nexport { defaultExport as default };\n// export default Object.assign(SVGPathCommander, index);\n","export { default as CSSMatrix } from \"@thednp/dommatrix\";\n// export type { PathArray, PointTuple, TransformObjectValues } from \"./types\";\n// export type { Options, TransformEntries, TransformObject } from \"./interface\";\n// export * from \"./types\";\n// export * from \"./interface\";\n\nimport * as arcTools from \"./math/arcTools\";\nimport * as bezierTools from \"./math/bezier\";\nimport * as cubicTools from \"./math/cubicTools\";\nimport * as lineTools from \"./math/lineTools\";\nimport * as quadTools from \"./math/quadTools\";\nimport * as polygonTools from \"./math/polygonTools\";\nexport { arcTools, bezierTools, cubicTools, lineTools, quadTools, polygonTools };\n\n// export * from \"./math/arcTools\";\n// export * from \"./math/bezier\";\n// export * from \"./math/cubicTools\";\n// export * from \"./math/lineTools\";\n// export * from \"./math/quadTools\";\n// export * from \"./math/polygonTools\";\n\nexport { default as pathToAbsolute } from \"./convert/pathToAbsolute\";\nexport { default as pathToRelative } from \"./convert/pathToRelative\";\nexport { default as pathToCurve } from \"./convert/pathToCurve\";\nexport { default as pathToString } from \"./convert/pathToString\";\n\nexport { default as distanceSquareRoot } from \"./math/distanceSquareRoot\";\nexport { default as midPoint } from \"./math/midPoint\";\nexport { default as rotateVector } from \"./math/rotateVector\";\nexport { default as roundTo } from \"./math/roundTo\";\n\nexport { default as parsePathString } from \"./parser/parsePathString\";\nexport { default as finalizeSegment } from \"./parser/finalizeSegment\";\nexport { default as invalidPathValue } from \"./parser/invalidPathValue\";\nexport { default as isArcCommand } from \"./parser/isArcCommand\";\nexport { default as isDigit } from \"./parser/isDigit\";\nexport { default as isDigitStart } from \"./parser/isDigitStart\";\nexport { default as isMoveCommand } from \"./parser/isMoveCommand\";\nexport { default as isPathCommand } from \"./parser/isPathCommand\";\nexport { default as isSpace } from \"./parser/isSpace\";\nexport { default as paramsCount } from \"./parser/paramsCount\";\nexport { default as paramsParser } from \"./parser/paramsParser\";\nexport { default as pathParser } from \"./parser/pathParser\";\nexport { default as scanFlag } from \"./parser/scanFlag\";\nexport { default as scanParam } from \"./parser/scanParam\";\nexport { default as scanSegment } from \"./parser/scanSegment\";\nexport { default as skipSpaces } from \"./parser/skipSpaces\";\n\nexport { default as distanceEpsilon } from \"./util/distanceEpsilon\";\nexport { default as getClosestPoint } from \"./util/getClosestPoint\";\nexport { default as getDrawDirection } from \"./util/getDrawDirection\";\nexport { default as getPathArea } from \"./util/getPathArea\";\nexport { default as getPathBBox } from \"./util/getPathBBox\";\nexport { default as getPointAtLength } from \"./util/getPointAtLength\";\nexport { default as getPropertiesAtLength } from \"./util/getPropertiesAtLength\";\nexport { default as getPropertiesAtPoint } from \"./util/getPropertiesAtPoint\";\nexport { default as getSegmentAtLength } from \"./util/getSegmentAtLength\";\nexport { default as getSegmentOfPoint } from \"./util/getSegmentOfPoint\";\nexport { default as getTotalLength } from \"./util/getTotalLength\";\n\nexport { default as isAbsoluteArray } from \"./util/isAbsoluteArray\";\nexport { default as isCurveArray } from \"./util/isCurveArray\";\nexport { default as isNormalizedArray } from \"./util/isNormalizedArray\";\nexport { default as isPathArray } from \"./util/isPathArray\";\nexport { default as isPointInStroke } from \"./util/isPointInStroke\";\nexport { default as isRelativeArray } from \"./util/isRelativeArray\";\nexport { default as isValidPath } from \"./util/isValidPath\";\nexport { default as shapeParams } from \"./util/shapeParams\";\nexport { default as shapeToPath } from \"./util/shapeToPath\";\nexport { default as shapeToPathArray } from \"./util/shapeToPathArray\";\n\nexport { default as absolutizeSegment } from \"./process/absolutizeSegment\";\nexport { default as arcToCubic } from \"./process/arcToCubic\";\nexport { default as getSVGMatrix } from \"./process/getSVGMatrix\";\nexport { default as iterate } from \"./process/iterate\";\nexport { default as lineToCubic } from \"./process/lineToCubic\";\nexport { default as normalizePath } from \"./process/normalizePath\";\nexport { default as normalizeSegment } from \"./process/normalizeSegment\";\nexport { default as optimizePath } from \"./process/optimizePath\";\nexport { default as projection2d } from \"./process/projection2d\";\nexport { default as quadToCubic } from \"./process/quadToCubic\";\nexport { default as relativizeSegment } from \"./process/relativizeSegment\";\nexport { default as reverseCurve } from \"./process/reverseCurve\";\nexport { default as reversePath } from \"./process/reversePath\";\nexport { default as roundPath } from \"./process/roundPath\";\nexport { default as roundSegment } from \"./process/roundSegment\";\nexport { default as segmentToCubic } from \"./process/segmentToCubic\";\nexport { default as shortenSegment } from \"./process/shortenSegment\";\nexport { default as splitCubic } from \"./process/splitCubic\";\nexport { default as splitPath } from \"./process/splitPath\";\nexport { default as transformPath } from \"./process/transformPath\";\n","import { getPointAtLineLength } from \"./lineTools\";\nimport type { Point, PointTuple } from \"../types\";\n\n/**\n * Returns the Arc segment length.\n * @param rx radius along X axis\n * @param ry radius along Y axis\n * @param theta the angle in radians\n * @returns the arc length\n */\nconst arcLength = (rx: number, ry: number, theta: number) => {\n const halfTheta = theta / 2;\n const sinHalfTheta = Math.sin(halfTheta);\n const cosHalfTheta = Math.cos(halfTheta);\n const term1 = rx ** 2 * sinHalfTheta ** 2;\n const term2 = ry ** 2 * cosHalfTheta ** 2;\n const length = Math.sqrt(term1 + term2) * theta;\n return Math.abs(length);\n};\n\n/**\n * Find point on ellipse at given angle around ellipse (theta);\n * @param cx the center X\n * @param cy the center Y\n * @param rx the radius X\n * @param ry the radius Y\n * @param alpha the arc rotation angle in radians\n * @param theta the arc sweep angle in radians\n * @returns a point around ellipse at given angle\n */\nconst arcPoint = (\n cx: number,\n cy: number,\n rx: number,\n ry: number,\n alpha: number,\n theta: number,\n) => {\n const { sin, cos } = Math;\n // theta is angle in radians around arc\n // alpha is angle of rotation of ellipse in radians\n const cosA = cos(alpha);\n const sinA = sin(alpha);\n const x = rx * cos(theta);\n const y = ry * sin(theta);\n\n return [cx + cosA * x - sinA * y, cy + sinA * x + cosA * y] as PointTuple;\n};\n\n/**\n * Returns the angle between two points.\n * @param v0 starting point\n * @param v1 ending point\n * @returns the angle in radian\n */\nconst angleBetween = (v0: Point, v1: Point) => {\n const { x: v0x, y: v0y } = v0;\n const { x: v1x, y: v1y } = v1;\n const p = v0x * v1x + v0y * v1y;\n const n = Math.sqrt((v0x ** 2 + v0y ** 2) * (v1x ** 2 + v1y ** 2));\n const sign = v0x * v1y - v0y * v1x < 0 ? -1 : 1;\n return sign * Math.acos(p / n);\n};\n\n/**\n * Returns the following properties for an Arc segment: center, start angle,\n * end angle, and radiuses on X and Y axis.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param RX the radius on X axis\n * @param RY the radius on Y axis\n * @param angle the ellipse rotation in degrees\n * @param LAF the large arc flag\n * @param SF the sweep flag\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns properties specific to Arc segments\n */\nconst getArcProps = (\n x1: number,\n y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n x: number,\n y: number,\n) => {\n const { abs, sin, cos, sqrt, PI } = Math;\n let rx = abs(RX);\n let ry = abs(RY);\n const xRot = ((angle % 360) + 360) % 360;\n const xRotRad = xRot * (PI / 180);\n\n // istanbul ignore next @preserve\n if (x1 === x && y1 === y) {\n return {\n rx,\n ry,\n startAngle: 0,\n endAngle: 0,\n center: { x, y },\n };\n }\n\n if (rx === 0 || ry === 0) {\n return {\n rx,\n ry,\n startAngle: 0,\n endAngle: 0,\n center: { x: (x + x1) / 2, y: (y + y1) / 2 },\n };\n }\n\n const dx = (x1 - x) / 2;\n const dy = (y1 - y) / 2;\n\n const transformedPoint = {\n x: cos(xRotRad) * dx + sin(xRotRad) * dy,\n y: -sin(xRotRad) * dx + cos(xRotRad) * dy,\n };\n\n const radiiCheck = transformedPoint.x ** 2 / rx ** 2 +\n transformedPoint.y ** 2 / ry ** 2;\n\n if (radiiCheck > 1) {\n rx *= sqrt(radiiCheck);\n ry *= sqrt(radiiCheck);\n }\n\n const cSquareNumerator = rx ** 2 * ry ** 2 -\n rx ** 2 * transformedPoint.y ** 2 - ry ** 2 * transformedPoint.x ** 2;\n const cSquareRootDenom = rx ** 2 * transformedPoint.y ** 2 +\n ry ** 2 * transformedPoint.x ** 2;\n\n let cRadicand = cSquareNumerator / cSquareRootDenom;\n /* istanbul ignore next @preserve */\n cRadicand = cRadicand < 0 ? 0 : cRadicand;\n const cCoef = (LAF !== SF ? 1 : -1) * sqrt(cRadicand);\n const transformedCenter = {\n x: cCoef * ((rx * transformedPoint.y) / ry),\n y: cCoef * (-(ry * transformedPoint.x) / rx),\n };\n\n const center = {\n x: cos(xRotRad) * transformedCenter.x - sin(xRotRad) * transformedCenter.y +\n (x1 + x) / 2,\n y: sin(xRotRad) * transformedCenter.x + cos(xRotRad) * transformedCenter.y +\n (y1 + y) / 2,\n };\n\n const startVector = {\n x: (transformedPoint.x - transformedCenter.x) / rx,\n y: (transformedPoint.y - transformedCenter.y) / ry,\n };\n\n const startAngle = angleBetween({ x: 1, y: 0 }, startVector);\n\n const endVector = {\n x: (-transformedPoint.x - transformedCenter.x) / rx,\n y: (-transformedPoint.y - transformedCenter.y) / ry,\n };\n\n let sweepAngle = angleBetween(startVector, endVector);\n if (!SF && sweepAngle > 0) {\n sweepAngle -= 2 * PI;\n } else if (SF && sweepAngle < 0) {\n sweepAngle += 2 * PI;\n }\n sweepAngle %= 2 * PI;\n\n const endAngle = startAngle + sweepAngle;\n\n // point.ellipticalArcStartAngle = startAngle;\n // point.ellipticalArcEndAngle = startAngle + sweepAngle;\n // point.ellipticalArcAngle = alpha;\n\n // point.ellipticalArcCenter = center;\n // point.resultantRx = rx;\n // point.resultantRy = ry;\n\n return {\n center,\n startAngle,\n endAngle,\n rx,\n ry,\n };\n};\n\n/**\n * Returns the length of an Arc segment.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the length of the Arc segment\n */\nconst getArcLength = (\n x1: number,\n y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n x: number,\n y: number,\n) => {\n const { rx, ry, startAngle, endAngle } = getArcProps(\n x1,\n y1,\n RX,\n RY,\n angle,\n LAF,\n SF,\n x,\n y,\n );\n return arcLength(rx, ry, endAngle - startAngle);\n};\n\n/**\n * Returns a point along an Arc segment at a given distance.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param RX the radius on X axis\n * @param RY the radius on Y axis\n * @param angle the ellipse rotation in degrees\n * @param LAF the large arc flag\n * @param SF the sweep flag\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance a [0-1] ratio\n * @returns a point along the Arc segment\n */\nconst getPointAtArcLength = (\n x1: number,\n y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n x: number,\n y: number,\n distance?: number,\n) => {\n let point = { x: x1, y: y1 };\n const { center, rx, ry, startAngle, endAngle } = getArcProps(\n x1,\n y1,\n RX,\n RY,\n angle,\n LAF,\n SF,\n x,\n y,\n );\n\n /* istanbul ignore else @preserve */\n if (typeof distance === \"number\") {\n const length = arcLength(rx, ry, endAngle - startAngle);\n if (distance <= 0) {\n point = { x: x1, y: y1 };\n } else if (distance >= length) {\n point = { x, y };\n } else {\n /* istanbul ignore next @preserve */\n if (x1 === x && y1 === y) {\n return { x, y };\n }\n /* istanbul ignore next @preserve */\n if (rx === 0 || ry === 0) {\n return getPointAtLineLength(x1, y1, x, y, distance);\n }\n const { PI, cos, sin } = Math;\n const sweepAngle = endAngle - startAngle;\n const xRot = ((angle % 360) + 360) % 360;\n const xRotRad = xRot * (PI / 180);\n const alpha = startAngle + sweepAngle * (distance / length);\n const ellipseComponentX = rx * cos(alpha);\n const ellipseComponentY = ry * sin(alpha);\n\n point = {\n x: cos(xRotRad) * ellipseComponentX - sin(xRotRad) * ellipseComponentY +\n center.x,\n y: sin(xRotRad) * ellipseComponentX + cos(xRotRad) * ellipseComponentY +\n center.y,\n };\n }\n }\n\n return point;\n};\n\n/**\n * Returns the extrema for an Arc segment in the following format:\n * [MIN_X, MIN_Y, MAX_X, MAX_Y]\n *\n * @see https://github.com/herrstrietzel/svg-pathdata-getbbox\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param RX the radius on X axis\n * @param RY the radius on Y axis\n * @param angle the ellipse rotation in degrees\n * @param LAF the large arc flag\n * @param SF the sweep flag\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the extrema of the Arc segment\n */\nconst getArcBBox = (\n x1: number,\n y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n x: number,\n y: number,\n) => {\n const { center, rx, ry, startAngle, endAngle } = getArcProps(\n x1,\n y1,\n RX,\n RY,\n angle,\n LAF,\n SF,\n x,\n y,\n );\n const deltaAngle = endAngle - startAngle;\n const { min, max, tan, atan2, PI } = Math;\n\n // circle/elipse center coordinates\n const { x: cx, y: cy } = center;\n\n // rotation to radians\n const alpha = (angle * PI) / 180;\n const tangent = tan(alpha);\n\n /**\n * find min/max from zeroes of directional derivative along x and y\n * along x axis\n */\n const theta = atan2(-ry * tangent, rx);\n const angle1 = theta;\n const angle2 = theta + PI;\n const angle3 = atan2(ry, rx * tangent);\n const angle4 = angle3 + PI;\n const xArray = [x];\n const yArray = [y];\n\n // inner bounding box\n let xMin = min(x1, x);\n let xMax = max(x1, x);\n let yMin = min(y1, y);\n let yMax = max(y1, y);\n\n // on path point close after start\n const angleAfterStart = endAngle - deltaAngle * 0.00001;\n const pP2 = arcPoint(cx, cy, rx, ry, alpha, angleAfterStart);\n\n // on path point close before end\n const angleBeforeEnd = endAngle - deltaAngle * 0.99999;\n const pP3 = arcPoint(cx, cy, rx, ry, alpha, angleBeforeEnd);\n\n /**\n * expected extremes\n * if leaving inner bounding box\n * (between segment start and end point)\n * otherwise exclude elliptic extreme points\n */\n\n // right\n if (pP2[0] > xMax || pP3[0] > xMax) {\n // get point for this theta\n const p1 = arcPoint(cx, cy, rx, ry, alpha, angle1);\n xArray.push(p1[0]);\n yArray.push(p1[1]);\n }\n\n // left\n if (pP2[0] < xMin || pP3[0] < xMin) {\n // get anti-symmetric point\n const p2 = arcPoint(cx, cy, rx, ry, alpha, angle2);\n xArray.push(p2[0]);\n yArray.push(p2[1]);\n }\n\n // top\n if (pP2[1] < yMin || pP3[1] < yMin) {\n // get anti-symmetric point\n const p4 = arcPoint(cx, cy, rx, ry, alpha, angle4);\n xArray.push(p4[0]);\n yArray.push(p4[1]);\n }\n\n // bottom\n if (pP2[1] > yMax || pP3[1] > yMax) {\n // get point for this theta\n const p3 = arcPoint(cx, cy, rx, ry, alpha, angle3);\n xArray.push(p3[0]);\n yArray.push(p3[1]);\n }\n\n xMin = min.apply([], xArray);\n yMin = min.apply([], yArray);\n xMax = max.apply([], xArray);\n yMax = max.apply([], yArray);\n\n return [xMin, yMin, xMax, yMax] as [number, number, number, number];\n};\n\nexport {\n angleBetween,\n arcLength,\n arcPoint,\n getArcBBox,\n getArcLength,\n getArcProps,\n getPointAtArcLength,\n};\n","import midPoint from \"./midPoint\";\nimport distanceSquareRoot from \"./distanceSquareRoot\";\n\n/**\n * Returns length for line segments (MoveTo, LineTo).\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the line segment length\n */\nconst getLineLength = (x1: number, y1: number, x2: number, y2: number) => {\n return distanceSquareRoot([x1, y1], [x2, y2]);\n};\n\n/**\n * Returns a point along the line segments (MoveTo, LineTo).\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance the distance to point in [0-1] range\n * @returns the point at length\n */\nconst getPointAtLineLength = (\n x1: number,\n y1: number,\n x2: number,\n y2: number,\n distance?: number,\n) => {\n let point = { x: x1, y: y1 };\n\n /* istanbul ignore else @preserve */\n if (typeof distance === \"number\") {\n const length = distanceSquareRoot([x1, y1], [x2, y2]);\n if (distance <= 0) {\n point = { x: x1, y: y1 };\n } else if (distance >= length) {\n point = { x: x2, y: y2 };\n } else {\n const [x, y] = midPoint([x1, y1], [x2, y2], distance / length);\n point = { x, y };\n }\n }\n return point;\n};\n\n/**\n * Returns bounding box for line segments (MoveTo, LineTo).\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance the distance to point in [0-1] range\n * @returns the extrema for line segments\n */\nconst getLineBBox = (x1: number, y1: number, x2: number, y2: number) => {\n const { min, max } = Math;\n\n return [min(x1, x2), min(y1, y2), max(x1, x2), max(y1, y2)] as [\n number,\n number,\n number,\n number,\n ];\n};\n\nexport { getLineBBox, getLineLength, getPointAtLineLength };\n","import { PointTuple } from \"../types\";\n\n/**\n * Returns the coordinates of a specified distance\n * ratio between two points.\n *\n * @param a the first point coordinates\n * @param b the second point coordinates\n * @param t the ratio\n * @returns the midpoint coordinates\n */\nconst midPoint = (a: PointTuple, b: PointTuple, t: number): PointTuple => {\n const [ax, ay] = a;\n const [bx, by] = b;\n return [ax + (bx - ax) * t, ay + (by - ay) * t];\n};\n\nexport default midPoint;\n","import { type PointTuple } from \"../types\";\n\n/**\n * Returns the square root of the distance\n * between two given points.\n *\n * @param a the first point coordinates\n * @param b the second point coordinates\n * @returns the distance value\n */\nconst distanceSquareRoot = (a: PointTuple, b: PointTuple) => {\n return Math.sqrt(\n (a[0] - b[0]) * (a[0] - b[0]) + (a[1] - b[1]) * (a[1] - b[1]),\n );\n};\n\nexport default distanceSquareRoot;\n","import type {\n CubicCoordinates,\n CubicPoints,\n DeriveCallback,\n DerivedCubicPoints,\n DerivedPoint,\n DerivedQuadPoints,\n PointTuple,\n QuadCoordinates,\n QuadPoints,\n} from \"../types\";\n\n/**\n * Tools from bezier.js by Mike 'Pomax' Kamermans\n * @see https://github.com/Pomax/bezierjs\n */\n\nconst Tvalues = [\n -0.0640568928626056260850430826247450385909,\n 0.0640568928626056260850430826247450385909,\n -0.1911188674736163091586398207570696318404,\n 0.1911188674736163091586398207570696318404,\n -0.3150426796961633743867932913198102407864,\n 0.3150426796961633743867932913198102407864,\n -0.4337935076260451384870842319133497124524,\n 0.4337935076260451384870842319133497124524,\n -0.5454214713888395356583756172183723700107,\n 0.5454214713888395356583756172183723700107,\n -0.6480936519369755692524957869107476266696,\n 0.6480936519369755692524957869107476266696,\n -0.7401241915785543642438281030999784255232,\n 0.7401241915785543642438281030999784255232,\n -0.8200019859739029219539498726697452080761,\n 0.8200019859739029219539498726697452080761,\n -0.8864155270044010342131543419821967550873,\n 0.8864155270044010342131543419821967550873,\n -0.9382745520027327585236490017087214496548,\n 0.9382745520027327585236490017087214496548,\n -0.9747285559713094981983919930081690617411,\n 0.9747285559713094981983919930081690617411,\n -0.9951872199970213601799974097007368118745,\n 0.9951872199970213601799974097007368118745,\n];\n\nconst Cvalues = [\n 0.1279381953467521569740561652246953718517,\n 0.1279381953467521569740561652246953718517,\n 0.1258374563468282961213753825111836887264,\n 0.1258374563468282961213753825111836887264,\n 0.121670472927803391204463153476262425607,\n 0.121670472927803391204463153476262425607,\n 0.1155056680537256013533444839067835598622,\n 0.1155056680537256013533444839067835598622,\n 0.1074442701159656347825773424466062227946,\n 0.1074442701159656347825773424466062227946,\n 0.0976186521041138882698806644642471544279,\n 0.0976186521041138882698806644642471544279,\n 0.086190161531953275917185202983742667185,\n 0.086190161531953275917185202983742667185,\n 0.0733464814110803057340336152531165181193,\n 0.0733464814110803057340336152531165181193,\n 0.0592985849154367807463677585001085845412,\n 0.0592985849154367807463677585001085845412,\n 0.0442774388174198061686027482113382288593,\n 0.0442774388174198061686027482113382288593,\n 0.0285313886289336631813078159518782864491,\n 0.0285313886289336631813078159518782864491,\n 0.0123412297999871995468056670700372915759,\n 0.0123412297999871995468056670700372915759,\n];\n\n/**\n * @param points\n * @returns\n */\nconst deriveBezier = (points: QuadPoints | CubicPoints) => {\n const dpoints = [] as (DerivedCubicPoints | DerivedQuadPoints)[];\n for (let p = points, d = p.length, c = d - 1; d > 1; d -= 1, c -= 1) {\n const list = [] as unknown as DerivedCubicPoints | DerivedQuadPoints;\n for (let j = 0; j < c; j += 1) {\n list.push({\n x: c * (p[j + 1].x - p[j].x),\n y: c * (p[j + 1].y - p[j].y),\n t: 0,\n });\n }\n dpoints.push(list);\n p = list;\n }\n return dpoints;\n};\n\n/**\n * @param points\n * @param t\n */\nconst computeBezier = (\n points: DerivedQuadPoints | DerivedCubicPoints,\n t: number,\n) => {\n // shortcuts\n /* istanbul ignore next @preserve */\n if (t === 0) {\n points[0].t = 0;\n return points[0];\n }\n\n const order = points.length - 1;\n\n /* istanbul ignore next @preserve */\n if (t === 1) {\n points[order].t = 1;\n return points[order];\n }\n\n const mt = 1 - t;\n let p = points as typeof points | [\n DerivedPoint,\n DerivedPoint,\n DerivedPoint,\n DerivedPoint,\n ];\n\n // constant?\n /* istanbul ignore next @preserve */\n if (order === 0) {\n points[0].t = t;\n return points[0];\n }\n\n // linear?\n /* istanbul ignore else @preserve */\n if (order === 1) {\n return {\n x: mt * p[0].x + t * p[1].x,\n y: mt * p[0].y + t * p[1].y,\n t,\n };\n }\n\n // quadratic/cubic curve?\n const mt2 = mt * mt;\n const t2 = t * t;\n let a = 0;\n let b = 0;\n let c = 0;\n let d = 0;\n /* istanbul ignore else @preserve */\n if (order === 2) {\n p = [p[0], p[1], p[2], { x: 0, y: 0 } as DerivedPoint];\n a = mt2;\n b = mt * t * 2;\n c = t2;\n } else if (order === 3) {\n a = mt2 * mt;\n b = mt2 * t * 3;\n c = mt * t2 * 3;\n d = t * t2;\n }\n return {\n x: a * p[0].x + b * p[1].x + c * p[2].x + d * p[3].x,\n y: a * p[0].y + b * p[1].y + c * p[2].y + d * p[3].y,\n t,\n };\n};\n\nconst calculateBezier = (derivativeFn: DeriveCallback, t: number) => {\n const d = derivativeFn(t);\n const l = d.x * d.x + d.y * d.y;\n\n return Math.sqrt(l);\n};\n\nconst bezierLength = (derivativeFn: DeriveCallback) => {\n const z = 0.5;\n const len = Tvalues.length;\n\n let sum = 0;\n\n for (let i = 0, t; i < len; i++) {\n t = z * Tvalues[i] + z;\n sum += Cvalues[i] * calculateBezier(derivativeFn, t);\n }\n return z * sum;\n};\n\n/**\n * Returns the length of CubicBezier / Quad segment.\n * @param curve cubic / quad bezier segment\n */\nconst getBezierLength = (curve: CubicCoordinates | QuadCoordinates) => {\n const points = [] as unknown as CubicPoints | QuadPoints;\n for (let idx = 0, len = curve.length, step = 2; idx < len; idx += step) {\n points.push({\n x: curve[idx],\n y: curve[idx + 1],\n });\n }\n const dpoints = deriveBezier(points);\n return bezierLength((t: number) => {\n return computeBezier(dpoints[0], t);\n });\n};\n\n// Precision for consider cubic polynom as quadratic one\nconst CBEZIER_MINMAX_EPSILON = 0.00000001;\n\n/**\n * Returns the most extreme points in a Quad Bezier segment.\n * @param A an array which consist of X/Y values\n */\n// https://github.com/kpym/SVGPathy/blob/acd1a50c626b36d81969f6e98e8602e128ba4302/lib/box.js#L89\nconst minmaxQ = ([v1, cp, v2]: [number, number, number]) => {\n const min = Math.min(v1, v2);\n const max = Math.max(v1, v2);\n\n /* istanbul ignore next @preserve */\n if (cp >= v1 ? v2 >= cp : v2 <= cp) {\n // if no extremum in ]0,1[\n return [min, max] as PointTuple;\n }\n\n // check if the extremum E is min or max\n const E = (v1 * v2 - cp * cp) / (v1 - 2 * cp + v2);\n return (E < min ? [E, max] : [min, E]) as PointTuple;\n};\n\n/**\n * Returns the most extreme points in a Cubic Bezier segment.\n * @param A an array which consist of X/Y values\n * @see https://github.com/kpym/SVGPathy/blob/acd1a50c626b36d81969f6e98e8602e128ba4302/lib/box.js#L127\n */\nconst minmaxC = ([v1, cp1, cp2, v2]: [number, number, number, number]) => {\n const K = v1 - 3 * cp1 + 3 * cp2 - v2;\n\n // if the polynomial is (almost) quadratic and not cubic\n /* istanbul ignore next @preserve */\n if (Math.abs(K) < CBEZIER_MINMAX_EPSILON) {\n if (v1 === v2 && v1 === cp1) {\n // no curve, point targeting same location\n return [v1, v2] as PointTuple;\n }\n\n return minmaxQ([v1, -0.5 * v1 + 1.5 * cp1, v1 - 3 * cp1 + 3 * cp2]);\n }\n\n // the reduced discriminant of the derivative\n const T = -v1 * cp2 + v1 * v2 - cp1 * cp2 - cp1 * v2 + cp1 * cp1 + cp2 * cp2;\n\n // if the polynomial is monotone in [0,1]\n if (T <= 0) {\n return [Math.min(v1, v2), Math.max(v1, v2)] as PointTuple;\n }\n const S = Math.sqrt(T);\n\n // potential extrema\n let min = Math.min(v1, v2);\n let max = Math.max(v1, v2);\n\n const L = v1 - 2 * cp1 + cp2;\n // check local extrema\n for (let R = (L + S) / K, i = 1; i <= 2; R = (L - S) / K, i++) {\n // istanbul ignore next @preserve\n if (R > 0 && R < 1) {\n // if the extrema is for R in [0,1]\n const Q = v1 * (1 - R) * (1 - R) * (1 - R) +\n cp1 * 3 * (1 - R) * (1 - R) * R + cp2 * 3 * (1 - R) * R * R +\n v2 * R * R * R;\n if (Q < min) {\n min = Q;\n }\n if (Q > max) {\n max = Q;\n }\n }\n }\n\n return [min, max] as PointTuple;\n};\n\nexport {\n bezierLength,\n calculateBezier,\n CBEZIER_MINMAX_EPSILON,\n computeBezier,\n Cvalues,\n deriveBezier,\n getBezierLength,\n minmaxC,\n minmaxQ,\n Tvalues,\n};\n","import { getBezierLength, minmaxC } from \"./bezier\";\nimport { type CubicCoordinates } from \"../types\";\n\n/**\n * Returns a point at a given length of a CubicBezier segment.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param t a [0-1] ratio\n * @returns the point at cubic-bezier segment length\n */\nconst getPointAtCubicSegmentLength = (\n [x1, y1, c1x, c1y, c2x, c2y, x2, y2]: CubicCoordinates,\n t: number,\n) => {\n const t1 = 1 - t;\n return {\n x: t1 ** 3 * x1 + 3 * t1 ** 2 * t * c1x + 3 * t1 * t ** 2 * c2x +\n t ** 3 * x2,\n y: t1 ** 3 * y1 + 3 * t1 ** 2 * t * c1y + 3 * t1 * t ** 2 * c2y +\n t ** 3 * y2,\n };\n};\n\n/**\n * Returns the length of a CubicBezier segment.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the CubicBezier segment length\n */\nconst getCubicLength = (\n x1: number,\n y1: number,\n c1x: number,\n c1y: number,\n c2x: number,\n c2y: number,\n x2: number,\n y2: number,\n) => {\n return getBezierLength([x1, y1, c1x, c1y, c2x, c2y, x2, y2]);\n};\n\n/**\n * Returns the point along a CubicBezier segment at a given distance.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance the distance to look at\n * @returns the point at CubicBezier length\n */\nconst getPointAtCubicLength = (\n x1: number,\n y1: number,\n c1x: number,\n c1y: number,\n c2x: number,\n c2y: number,\n x2: number,\n y2: number,\n distance?: number,\n) => {\n const distanceIsNumber = typeof distance === \"number\";\n let point = { x: x1, y: y1 };\n /* istanbul ignore else @preserve */\n if (distanceIsNumber) {\n const currentLength = getBezierLength([x1, y1, c1x, c1y, c2x, c2y, x2, y2]);\n if (distance <= 0) {\n // first point already defined\n } else if (distance >= currentLength) {\n point = { x: x2, y: y2 };\n } else {\n point = getPointAtCubicSegmentLength(\n [x1, y1, c1x, c1y, c2x, c2y, x2, y2],\n distance / currentLength,\n );\n }\n }\n return point;\n};\n\n/**\n * Returns the boundig box of a CubicBezier segment in the following format:\n * [MIN_X, MIN_Y, MAX_X, MAX_Y]\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the extrema of the CubicBezier segment\n */\nconst getCubicBBox = (\n x1: number,\n y1: number,\n c1x: number,\n c1y: number,\n c2x: number,\n c2y: number,\n x2: number,\n y2: number,\n) => {\n const cxMinMax = minmaxC([x1, c1x, c2x, x2]);\n const cyMinMax = minmaxC([y1, c1y, c2y, y2]);\n\n return [cxMinMax[0], cyMinMax[0], cxMinMax[1], cyMinMax[1]] as [\n number,\n number,\n number,\n number,\n ];\n};\n\nexport {\n getCubicBBox,\n getCubicLength,\n getPointAtCubicLength,\n getPointAtCubicSegmentLength,\n};\n","import { getBezierLength, minmaxQ } from \"./bezier\";\nimport { type QuadCoordinates } from \"../types\";\n\n/**\n * Returns the {x,y} coordinates of a point at a\n * given length of a quadratic-bezier segment.\n *\n * @see https://github.com/substack/point-at-length\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param cx the control point X\n * @param cy the control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param t a [0-1] ratio\n * @returns the requested {x,y} coordinates\n */\nconst getPointAtQuadSegmentLength = (\n [x1, y1, cx, cy, x2, y2]: QuadCoordinates,\n t: number,\n) => {\n const t1 = 1 - t;\n return {\n x: t1 ** 2 * x1 + 2 * t1 * t * cx + t ** 2 * x2,\n y: t1 ** 2 * y1 + 2 * t1 * t * cy + t ** 2 * y2,\n };\n};\n\n/**\n * Returns the length of a QuadraticBezier segment.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param cx the control point X\n * @param cy the control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the QuadraticBezier segment length\n */\nconst getQuadLength = (\n x1: number,\n y1: number,\n cx: number,\n cy: number,\n x2: number,\n y2: number,\n) => {\n return getBezierLength([x1, y1, cx, cy, x2, y2]);\n};\n\n/**\n * Returns the point along a QuadraticBezier segment at a given distance.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param cx the control point X\n * @param cy the control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance the distance to look at\n * @returns the point at QuadraticBezier length\n */\nconst getPointAtQuadLength = (\n x1: number,\n y1: number,\n cx: number,\n cy: number,\n x2: number,\n y2: number,\n distance?: number,\n) => {\n const distanceIsNumber = typeof distance === \"number\";\n let point = { x: x1, y: y1 };\n\n /* istanbul ignore else @preserve */\n if (distanceIsNumber) {\n const currentLength = getBezierLength([x1, y1, cx, cy, x2, y2]);\n if (distance <= 0) {\n // first point already defined\n } else if (distance >= currentLength) {\n point = { x: x2, y: y2 };\n } else {\n point = getPointAtQuadSegmentLength(\n [x1, y1, cx, cy, x2, y2],\n distance / currentLength,\n );\n }\n }\n return point;\n};\n\n/**\n * Returns the boundig box of a QuadraticBezier segment in the following format:\n * [MIN_X, MIN_Y, MAX_X, MAX_Y]\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param cx the control point X\n * @param cy the control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the extrema of the QuadraticBezier segment\n */\nconst getQuadBBox = (\n x1: number,\n y1: number,\n cx: number,\n cy: number,\n x2: number,\n y2: number,\n) => {\n const cxMinMax = minmaxQ([x1, cx, x2]);\n const cyMinMax = minmaxQ([y1, cy, y2]);\n return [cxMinMax[0], cyMinMax[0], cxMinMax[1], cyMinMax[1]] as [\n number,\n number,\n number,\n number,\n ];\n};\n\nexport {\n getPointAtQuadLength,\n getPointAtQuadSegmentLength,\n getQuadBBox,\n getQuadLength,\n};\n","import distanceSquareRoot from \"./distanceSquareRoot\";\nimport { type PointTuple } from \"../types\";\n\n/**\n * d3-polygon-area\n * https://github.com/d3/d3-polygon\n *\n * Returns the area of a polygon.\n *\n * @param polygon an array of coordinates\n * @returns the polygon area\n */\nconst polygonArea = (polygon: PointTuple[]) => {\n const n = polygon.length;\n let i = -1;\n let a: PointTuple;\n let b = polygon[n - 1];\n let area = 0;\n\n /* eslint-disable-next-line */\n while (++i < n) {\n a = b;\n b = polygon[i];\n area += a[1] * b[0] - a[0] * b[1];\n }\n\n return area / 2;\n};\n\n/**\n * d3-polygon-length\n * https://github.com/d3/d3-polygon\n *\n * Returns the perimeter of a polygon.\n *\n * @param polygon an array of coordinates\n * @returns the polygon length\n */\nconst polygonLength = (polygon: PointTuple[]) => {\n return polygon.reduce((length, point, i) => {\n if (i) {\n return length + distanceSquareRoot(polygon[i - 1], point);\n }\n return 0;\n }, 0);\n};\n\nexport { polygonArea, polygonLength };\n","/** Segment params length */\nconst paramsCount = {\n a: 7,\n c: 6,\n h: 1,\n l: 2,\n m: 2,\n r: 4,\n q: 4,\n s: 4,\n t: 2,\n v: 1,\n z: 0,\n};\n\nexport default paramsCount;\n","import paramsCount from \"./paramsCount\";\nimport PathParser from \"./pathParser\";\nimport type { PathCommand, PathSegment, RelativeCommand } from \"../types\";\n\n/**\n * Breaks the parsing of a pathString once a segment is finalized.\n *\n * @param path the `PathParser` instance\n */\nconst finalizeSegment = (path: PathParser) => {\n let pathCommand = path.pathValue[path.segmentStart] as PathCommand;\n let relativeCommand = pathCommand.toLowerCase() as RelativeCommand;\n const { data } = path;\n\n while (data.length >= paramsCount[relativeCommand]) {\n // overloaded `moveTo`\n // https://github.com/rveciana/svg-path-properties/blob/master/src/parse.ts\n if (relativeCommand === \"m\" && data.length > 2) {\n path.segments.push(\n [pathCommand as PathCommand | number].concat(\n data.splice(0, 2) as number[],\n ) as PathSegment,\n );\n relativeCommand = \"l\";\n pathCommand = pathCommand === \"m\" ? \"l\" : \"L\";\n } else {\n path.segments.push(\n [pathCommand as PathCommand | number].concat(\n data.splice(0, paramsCount[relativeCommand]) as number[],\n ) as PathSegment,\n );\n }\n\n if (!paramsCount[relativeCommand]) {\n break;\n }\n }\n};\nexport default finalizeSegment;\n","const error = \"SVGPathCommander Error\";\nexport default error;\n","import error from \"./error\";\nimport type PathParser from \"./pathParser\";\n\n/**\n * Validates an A (arc-to) specific path command value.\n * Usually a `large-arc-flag` or `sweep-flag`.\n *\n * @param path the `PathParser` instance\n */\nconst scanFlag = (path: PathParser) => {\n const { index, pathValue } = path;\n const code = pathValue.charCodeAt(index);\n\n if (code === 0x30 /* 0 */) {\n path.param = 0;\n path.index += 1;\n return;\n }\n\n if (code === 0x31 /* 1 */) {\n path.param = 1;\n path.index += 1;\n return;\n }\n\n path.err = `${error}: invalid Arc flag \"${\n pathValue[index]\n }\", expecting 0 or 1 at index ${index}`;\n};\n\nexport default scanFlag;\n","import { DigitNumber } from \"../types\";\n\n/**\n * Checks if a character is a digit.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isDigit = (code: number): code is DigitNumber => {\n return code >= 48 && code <= 57; // 0..9\n};\nexport default isDigit;\n","const invalidPathValue = \"Invalid path value\";\nexport default invalidPathValue;\n","import isDigit from \"./isDigit\";\nimport invalidPathValue from \"./invalidPathValue\";\nimport error from \"./error\";\nimport type PathParser from \"./pathParser\";\n\n/**\n * Validates every character of the path string,\n * every path command, negative numbers or floating point numbers.\n *\n * @param path the `PathParser` instance\n */\nconst scanParam = (path: PathParser) => {\n const { max, pathValue, index: start } = path;\n let index = start;\n let zeroFirst = false;\n let hasCeiling = false;\n let hasDecimal = false;\n let hasDot = false;\n let ch;\n\n if (index >= max) {\n path.err =\n `${error}: ${invalidPathValue} at index ${index}, \"pathValue\" is missing param`;\n return;\n }\n ch = pathValue.charCodeAt(index);\n\n if (ch === 0x2b /* + */ || ch === 0x2d /* - */) {\n index += 1;\n // ch = (index < max) ? pathValue.charCodeAt(index) : 0;\n ch = pathValue.charCodeAt(index);\n }\n\n // This logic is shamelessly borrowed from Esprima\n // https://github.com/ariya/esprimas\n if (!isDigit(ch) && ch !== 0x2e /* . */) {\n // path.err = 'SvgPath: param should start with 0..9 or `.` (at pos ' + index + ')';\n path.err = `${error}: ${invalidPathValue} at index ${index}, \"${\n pathValue[index]\n }\" is not a number`;\n return;\n }\n\n if (ch !== 0x2e /* . */) {\n zeroFirst = ch === 0x30 /* 0 */;\n index += 1;\n\n ch = pathValue.charCodeAt(index);\n\n if (zeroFirst && index < max) {\n // decimal number starts with '0' such as '09' is illegal.\n if (ch && isDigit(ch)) {\n // path.err = 'SvgPath: numbers started with `0` such as `09`\n // are illegal (at pos ' + start + ')';\n path.err = `${error}: ${invalidPathValue} at index ${start}, \"${\n pathValue[start]\n }\" illegal number`;\n return;\n }\n }\n\n while (index < max && isDigit(pathValue.charCodeAt(index))) {\n index += 1;\n hasCeiling = true;\n }\n\n ch = pathValue.charCodeAt(index);\n }\n\n if (ch === 0x2e /* . */) {\n hasDot = true;\n index += 1;\n while (isDigit(pathValue.charCodeAt(index))) {\n index += 1;\n hasDecimal = true;\n }\n\n ch = pathValue.charCodeAt(index);\n }\n\n if (ch === 0x65 /* e */ || ch === 0x45 /* E */) {\n if (hasDot && !hasCeiling && !hasDecimal) {\n path.err = `${error}: ${invalidPathValue} at index ${index}, \"${\n pathValue[index]\n }\" invalid float exponent`;\n return;\n }\n\n index += 1;\n\n ch = pathValue.charCodeAt(index);\n\n if (ch === 0x2b /* + */ || ch === 0x2d /* - */) {\n index += 1;\n }\n if (index < max && isDigit(pathValue.charCodeAt(index))) {\n while (index < max && isDigit(pathValue.charCodeAt(index))) {\n index += 1;\n }\n } else {\n path.err = `${error}: ${invalidPathValue} at index ${index}, \"${\n pathValue[index]\n }\" invalid integer exponent`;\n return;\n }\n }\n\n path.index = index;\n path.param = +path.pathValue.slice(start, index);\n};\nexport default scanParam;\n","import type { SpaceNumber } from \"../types\";\n\n/**\n * Checks if the character is a space.\n *\n * @param ch the character to check\n * @returns check result\n */\n\nconst isSpace = (ch: number): ch is SpaceNumber => {\n const allSpaces = [\n // Special spaces\n 0x1680,\n 0x180e,\n 0x2000,\n 0x2001,\n 0x2002,\n 0x2003,\n 0x2004,\n 0x2005,\n 0x2006,\n 0x2007,\n 0x2008,\n 0x2009,\n 0x200a,\n 0x202f,\n 0x205f,\n 0x3000,\n 0xfeff,\n // Line terminators\n 0x0a,\n 0x0d,\n 0x2028,\n 0x2029,\n // White spaces\n 0x20,\n 0x09,\n 0x0b,\n 0x0c,\n 0xa0,\n ];\n\n return allSpaces.includes(ch);\n};\nexport default isSpace;\n","import isSpace from \"./isSpace\";\nimport type PathParser from \"./pathParser\";\n\n/**\n * Points the parser to the next character in the\n * path string every time it encounters any kind of\n * space character.\n *\n * @param path the `PathParser` instance\n */\nconst skipSpaces = (path: PathParser) => {\n const { pathValue, max } = path;\n while (path.index < max && isSpace(pathValue.charCodeAt(path.index))) {\n path.index += 1;\n }\n};\nexport default skipSpaces;\n","import type { PathCommandNumber } from \"../types\";\n\n/**\n * Checks if the character is a path command.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isPathCommand = (code: number): code is PathCommandNumber => {\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy\n switch (code | 0x20) {\n case 0x6d /* m */:\n case 0x7a /* z */:\n case 0x6c /* l */:\n case 0x68 /* h */:\n case 0x76 /* v */:\n case 0x63 /* c */:\n case 0x73 /* s */:\n case 0x71 /* q */:\n case 0x74 /* t */:\n case 0x61 /* a */:\n // case 0x72/* r */:\n return true;\n default:\n return false;\n }\n};\nexport default isPathCommand;\n","import isDigit from \"./isDigit\";\nimport type { DigitNumber } from \"../types\";\n\n/**\n * Checks if the character is or belongs to a number.\n * [0-9]|+|-|.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isDigitStart = (\n code: number,\n): code is DigitNumber | 0x2b | 0x2d | 0x2e => {\n return isDigit(code) /* 0..9 */ || code === 0x2b /* + */ ||\n code === 0x2d /* - */ || code === 0x2e; /* . */\n};\nexport default isDigitStart;\n","/**\n * Checks if the character is an A (arc-to) path command.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isArcCommand = (code: number): code is 0x61 => {\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy\n return (code | 0x20) === 0x61;\n};\nexport default isArcCommand;\n","/**\n * Checks if the character is a MoveTo command.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isMoveCommand = (code: number): code is 0x6d | 0x4d => {\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy\n switch (code | 0x20) {\n case 0x6d /* m */:\n case 0x4d /* M */:\n return true;\n default:\n return false;\n }\n};\nexport default isMoveCommand;\n","import finalizeSegment from \"./finalizeSegment\";\nimport paramCounts from \"./paramsCount\";\nimport scanFlag from \"./scanFlag\";\nimport scanParam from \"./scanParam\";\nimport skipSpaces from \"./skipSpaces\";\nimport isPathCommand from \"./isPathCommand\";\nimport isDigitStart from \"./isDigitStart\";\nimport isArcCommand from \"./isArcCommand\";\nimport isMoveCommand from \"./isMoveCommand\";\nimport invalidPathValue from \"./invalidPathValue\";\nimport error from \"./error\";\n\nimport type PathParser from \"./pathParser\";\nimport type { PathSegment, RelativeCommand } from \"../types\";\n\n/**\n * Scans every character in the path string to determine\n * where a segment starts and where it ends.\n *\n * @param path the `PathParser` instance\n */\nconst scanSegment = (path: PathParser) => {\n const { max, pathValue, index, segments } = path;\n const cmdCode = pathValue.charCodeAt(index);\n const reqParams =\n paramCounts[pathValue[index].toLowerCase() as RelativeCommand];\n\n path.segmentStart = index;\n\n // segments always start with a path command\n if (!isPathCommand(cmdCode)) {\n path.err = `${error}: ${invalidPathValue} \"${\n pathValue[index]\n }\" is not a path command at index ${index}`;\n return;\n }\n\n // after a Z segment, we only expect a MoveTo path command\n const lastSegment = segments[segments.length - 1] as PathSegment | undefined;\n if (\n !isMoveCommand(cmdCode) && lastSegment?.[0]?.toLocaleLowerCase() === \"z\"\n ) {\n path.err = `${error}: ${invalidPathValue} \"${\n pathValue[index]\n }\" is not a MoveTo path command at index ${index}`;\n return;\n }\n\n path.index += 1;\n skipSpaces(path);\n\n path.data = [];\n\n if (!reqParams) {\n // Z\n finalizeSegment(path);\n return;\n }\n\n for (;;) {\n for (let i = reqParams; i > 0; i -= 1) {\n if (isArcCommand(cmdCode) && (i === 3 || i === 4)) scanFlag(path);\n else scanParam(path);\n\n if (path.err.length) {\n return;\n }\n path.data.push(path.param);\n\n skipSpaces(path);\n\n // after ',' param is mandatory\n if (\n path.index < max && pathValue.charCodeAt(path.index) === 0x2c /* , */\n ) {\n path.index += 1;\n skipSpaces(path);\n }\n }\n\n if (path.index >= path.max) {\n break;\n }\n\n // Stop on next segment\n if (!isDigitStart(pathValue.charCodeAt(path.index))) {\n break;\n }\n }\n\n finalizeSegment(path);\n};\nexport default scanSegment;\n","import type { PathArray, PathSegment } from \"../types\";\n\n/**\n * The `PathParser` is used by the `parsePathString` static method\n * to generate a `pathArray`.\n *\n * @param pathString\n */\nexport default class PathParser {\n declare segments: PathArray | PathSegment[];\n declare pathValue: string;\n declare max: number;\n declare index: number;\n declare param: number;\n declare segmentStart: number;\n declare data: (string | number)[];\n declare err: string;\n\n constructor(pathString: string) {\n this.segments = [];\n this.pathValue = pathString;\n this.max = pathString.length;\n this.index = 0;\n this.param = 0.0;\n this.segmentStart = 0;\n this.data = [];\n this.err = \"\";\n }\n}\n","import scanSegment from \"./scanSegment\";\nimport skipSpaces from \"./skipSpaces\";\nimport PathParser from \"./pathParser\";\nimport type { PathArray } from \"../types\";\n\n/**\n * Parses a path string value and returns an array\n * of segments we like to call `pathArray`.\n *\n * @param pathInput the string to be parsed\n * @returns the resulted `pathArray` or error string\n */\nconst parsePathString = (pathInput: string | T) => {\n if (typeof pathInput !== \"string\") {\n return pathInput.slice(0) as typeof pathInput;\n }\n\n const path = new PathParser(pathInput);\n\n skipSpaces(path);\n\n while (path.index < path.max && !path.err.length) {\n scanSegment(path);\n }\n\n // handle valid paths first\n // handle errors second\n if (!path.err.length) {\n if (path.segments.length) {\n /**\n * force absolute first M\n * getPathBBox calculation requires first segment to be absolute\n * @see https://github.com/thednp/svg-path-commander/pull/49\n */\n path.segments[0][0] = \"M\";\n }\n } else {\n throw TypeError(path.err);\n }\n\n return path.segments as PathArray;\n};\n\nexport default parsePathString;\n","import type {\n AbsoluteCommand,\n AbsoluteSegment,\n ASegment,\n CSegment,\n HSegment,\n LSegment,\n MSegment,\n PathSegment,\n QSegment,\n SSegment,\n TSegment,\n VSegment,\n} from \"../types\";\n\n/**\n * Returns an absolute segment of a `PathArray` object.\n *\n * @param segment the segment object\n * @param index the segment index\n * @param lastX the last known X value\n * @param lastY the last known Y value\n * @returns the absolute segment\n */\nconst absolutizeSegment = (\n segment: PathSegment,\n index: number,\n lastX: number,\n lastY: number,\n) => {\n const [pathCommand] = segment;\n const absCommand = pathCommand.toUpperCase() as AbsoluteCommand;\n const isAbsolute = absCommand === pathCommand;\n\n /* istanbul ignore else @preserve */\n if (index === 0 || isAbsolute) return segment as MSegment | AbsoluteSegment;\n // const values = segment.slice(1) as number[];\n if (absCommand === \"A\") {\n return [\n absCommand,\n segment[1],\n segment[2],\n segment[3],\n segment[4],\n segment[5],\n (segment as ASegment)[6] + lastX,\n (segment as ASegment)[7] + lastY,\n ] as ASegment;\n } else if (absCommand === \"V\") {\n return [absCommand, (segment as VSegment)[1] + lastY] as VSegment;\n } else if (absCommand === \"H\") {\n return [absCommand, (segment as HSegment)[1] + lastX] as HSegment;\n } else if (absCommand === \"L\") {\n return [\n absCommand,\n (segment as LSegment)[1] + lastX,\n (segment as LSegment)[2] + lastY,\n ] as LSegment;\n } else {\n // use brakets for `eslint: no-case-declaration`\n // https://stackoverflow.com/a/50753272/803358\n const absValues = [] as number[];\n const seglen = segment.length;\n for (let j = 1; j < seglen; j += 1) {\n absValues.push((segment[j] as number) + (j % 2 ? lastX : lastY));\n }\n // for c, s, q, t\n return [absCommand as typeof absCommand | number].concat(absValues) as\n | MSegment\n | QSegment\n | TSegment\n | SSegment\n | CSegment;\n }\n};\nexport default absolutizeSegment;\n","// import paramsParser from '../parser/paramsParser';\nimport type {\n AbsoluteCommand,\n IteratorCallback,\n PathArray,\n PathCommand,\n PathSegment,\n} from \"../types\";\n\nconst iterate = (\n path: PathArray,\n iterator: IteratorCallback,\n) => {\n let pathLen = path.length;\n let segment: PathSegment;\n let pathCommand = \"M\" as PathCommand;\n let absCommand = \"M\" as AbsoluteCommand;\n let isRelative = false;\n let x = 0;\n let y = 0;\n let mx = 0;\n let my = 0;\n let segLen = 0;\n\n for (let i = 0; i < pathLen; i += 1) {\n segment = path[i];\n [pathCommand] = segment;\n segLen = segment.length;\n absCommand = pathCommand.toUpperCase() as AbsoluteCommand;\n isRelative = absCommand !== pathCommand;\n\n const iteratorResult = iterator(segment, i, x, y);\n // some methods like getPointAtLength would like to break\n // when task is complete\n if (iteratorResult === false) {\n break;\n }\n\n // segment = path[i];\n if (absCommand === \"Z\") {\n x = mx;\n y = my;\n } else if (absCommand === \"H\") {\n x = (segment[1] as number) + (isRelative ? x : 0);\n } else if (absCommand === \"V\") {\n y = (segment[1] as number) + (isRelative ? y : 0);\n } else {\n x = (segment[segLen - 2] as number) + (isRelative ? x : 0);\n y = (segment[segLen - 1] as number) + (isRelative ? y : 0);\n\n if (absCommand === \"M\") {\n mx = x;\n my = y;\n }\n }\n\n if (iteratorResult) {\n path[i] = iteratorResult;\n if (iteratorResult[0] === \"C\") {\n pathLen = path.length;\n }\n }\n }\n return path as T;\n};\n\nexport default iterate;\n","import parsePathString from \"../parser/parsePathString\";\nimport absolutizeSegment from \"../process/absolutizeSegment\";\nimport type { AbsoluteArray, PathArray } from \"../types\";\nimport iterate from \"../process/iterate\";\n\n/**\n * Parses a path string value or object and returns an array\n * of segments, all converted to absolute values.\n *\n * @param pathInput the path string | object\n * @returns the resulted `pathArray` with absolute values\n */\nconst pathToAbsolute = (pathInput: string | PathArray) => {\n const path = parsePathString(pathInput);\n\n return iterate(path, absolutizeSegment);\n};\nexport default pathToAbsolute;\n","import type {\n aSegment,\n cSegment,\n hSegment,\n lSegment,\n MSegment,\n PathSegment,\n qSegment,\n RelativeCommand,\n RelativeSegment,\n sSegment,\n tSegment,\n vSegment,\n} from \"../types\";\n\n/**\n * Returns a relative segment of a `PathArray` object.\n *\n * @param segment the segment object\n * @param index the segment index\n * @param lastX the last known X value\n * @param lastY the last known Y value\n * @returns the relative segment\n */\nconst relativizeSegment = (\n segment: PathSegment,\n index: number,\n lastX: number,\n lastY: number,\n) => {\n const [pathCommand] = segment;\n const relCommand = pathCommand.toLowerCase() as RelativeCommand;\n const isRelative = pathCommand === relCommand;\n\n /* istanbul ignore else @preserve */\n if (index === 0 || isRelative) return segment as MSegment | RelativeSegment;\n\n if (relCommand === \"a\") {\n return [\n relCommand,\n segment[1],\n segment[2],\n segment[3],\n segment[4],\n segment[5],\n (segment as aSegment)[6] - lastX,\n (segment as aSegment)[7] - lastY,\n ] as aSegment;\n } else if (relCommand === \"v\") {\n return [relCommand, (segment as vSegment)[1] - lastY] as vSegment;\n } else if (relCommand === \"h\") {\n return [relCommand, (segment as hSegment)[1] - lastX] as hSegment;\n } else if (relCommand === \"l\") {\n return [\n relCommand,\n (segment as lSegment)[1] - lastX,\n (segment as lSegment)[2] - lastY,\n ] as lSegment;\n } else {\n // use brakets for `eslint: no-case-declaration`\n // https://stackoverflow.com/a/50753272/803358\n const relValues = [] as number[];\n const seglen = segment.length;\n for (let j = 1; j < seglen; j += 1) {\n relValues.push((segment[j] as number) - (j % 2 ? lastX : lastY));\n }\n // for c, s, q, t\n return [relCommand as RelativeCommand | number].concat(relValues) as\n | qSegment\n | tSegment\n | sSegment\n | cSegment;\n }\n};\n\nexport default relativizeSegment;\n","import type { PathArray, RelativeArray } from \"../types\";\nimport parsePathString from \"../parser/parsePathString\";\nimport iterate from \"../process/iterate\";\nimport relativizeSegment from \"../process/relativizeSegment\";\n\n/**\n * Parses a path string value or object and returns an array\n * of segments, all converted to relative values.\n *\n * @param pathInput the path string | object\n * @returns the resulted `pathArray` with relative values\n */\nconst pathToRelative = (pathInput: string | PathArray): RelativeArray => {\n const path = parsePathString(pathInput);\n\n return iterate(path, relativizeSegment);\n};\nexport default pathToRelative;\n","/**\n * Returns an {x,y} vector rotated by a given\n * angle in radian.\n *\n * @param x the initial vector x\n * @param y the initial vector y\n * @param rad the radian vector angle\n * @returns the rotated vector\n */\nconst rotateVector = (\n x: number,\n y: number,\n rad: number,\n): { x: number; y: number } => {\n const { sin, cos } = Math;\n const X = x * cos(rad) - y * sin(rad);\n const Y = x * sin(rad) + y * cos(rad);\n return { x: X, y: Y };\n};\n\nexport default rotateVector;\n","import rotateVector from \"../math/rotateVector\";\n\n/**\n * Converts A (arc-to) segments to C (cubic-bezier-to).\n *\n * For more information of where this math came from visit:\n * http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes\n *\n * @param X1 the starting x position\n * @param Y1 the starting y position\n * @param RX x-radius of the arc\n * @param RY y-radius of the arc\n * @param angle x-axis-rotation of the arc\n * @param LAF large-arc-flag of the arc\n * @param SF sweep-flag of the arc\n * @param X2 the ending x position\n * @param Y2 the ending y position\n * @param recursive the parameters needed to split arc into 2 segments\n * @return the resulting cubic-bezier segment(s)\n */\nconst arcToCubic = (\n X1: number,\n Y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n X2: number,\n Y2: number,\n recursive?: [number, number, number, number],\n): number[] => {\n let x1 = X1;\n let y1 = Y1;\n let rx = RX;\n let ry = RY;\n let x2 = X2;\n let y2 = Y2;\n // for more information of where this Math came from visit:\n // http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes\n const d120 = (Math.PI * 120) / 180;\n\n const rad = (Math.PI / 180) * (+angle || 0);\n let res = [] as number[];\n let xy;\n let f1;\n let f2;\n let cx;\n let cy;\n\n if (!recursive) {\n xy = rotateVector(x1, y1, -rad);\n x1 = xy.x;\n y1 = xy.y;\n xy = rotateVector(x2, y2, -rad);\n x2 = xy.x;\n y2 = xy.y;\n\n const x = (x1 - x2) / 2;\n const y = (y1 - y2) / 2;\n let h = (x * x) / (rx * rx) + (y * y) / (ry * ry);\n if (h > 1) {\n h = Math.sqrt(h);\n rx *= h;\n ry *= h;\n }\n const rx2 = rx * rx;\n const ry2 = ry * ry;\n\n const k = (LAF === SF ? -1 : 1) *\n Math.sqrt(\n Math.abs(\n (rx2 * ry2 - rx2 * y * y - ry2 * x * x) / (rx2 * y * y + ry2 * x * x),\n ),\n );\n\n cx = (k * rx * y) / ry + (x1 + x2) / 2;\n cy = (k * -ry * x) / rx + (y1 + y2) / 2;\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy no-bitwise\n f1 = Math.asin(((((y1 - cy) / ry) * 10 ** 9) >> 0) / 10 ** 9);\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy no-bitwise\n f2 = Math.asin(((((y2 - cy) / ry) * 10 ** 9) >> 0) / 10 ** 9);\n\n f1 = x1 < cx ? Math.PI - f1 : f1;\n f2 = x2 < cx ? Math.PI - f2 : f2;\n if (f1 < 0) f1 = Math.PI * 2 + f1;\n if (f2 < 0) f2 = Math.PI * 2 + f2;\n if (SF && f1 > f2) {\n f1 -= Math.PI * 2;\n }\n if (!SF && f2 > f1) {\n f2 -= Math.PI * 2;\n }\n } else {\n [f1, f2, cx, cy] = recursive;\n }\n let df = f2 - f1;\n if (Math.abs(df) > d120) {\n const f2old = f2;\n const x2old = x2;\n const y2old = y2;\n f2 = f1 + d120 * (SF && f2 > f1 ? 1 : -1);\n x2 = cx + rx * Math.cos(f2);\n y2 = cy + ry * Math.sin(f2);\n res = arcToCubic(x2, y2, rx, ry, angle, 0, SF, x2old, y2old, [\n f2,\n f2old,\n cx,\n cy,\n ]);\n }\n df = f2 - f1;\n const c1 = Math.cos(f1);\n const s1 = Math.sin(f1);\n const c2 = Math.cos(f2);\n const s2 = Math.sin(f2);\n const t = Math.tan(df / 4);\n const hx = (4 / 3) * rx * t;\n const hy = (4 / 3) * ry * t;\n const m1 = [x1, y1];\n const m2 = [x1 + hx * s1, y1 - hy * c1];\n const m3 = [x2 + hx * s2, y2 - hy * c2];\n const m4 = [x2, y2];\n m2[0] = 2 * m1[0] - m2[0];\n m2[1] = 2 * m1[1] - m2[1];\n if (recursive) {\n return [m2[0], m2[1], m3[0], m3[1], m4[0], m4[1]].concat(res);\n }\n res = [m2[0], m2[1], m3[0], m3[1], m4[0], m4[1]].concat(res);\n const newres = [];\n for (let i = 0, ii = res.length; i < ii; i += 1) {\n newres[i] = i % 2\n ? rotateVector(res[i - 1], res[i], rad).y\n : rotateVector(res[i], res[i + 1], rad).x;\n }\n return newres;\n};\nexport default arcToCubic;\n","/**\n * Converts a Q (quadratic-bezier) segment to C (cubic-bezier).\n *\n * @param x1 curve start x\n * @param y1 curve start y\n * @param qx control point x\n * @param qy control point y\n * @param x2 curve end x\n * @param y2 curve end y\n * @returns the cubic-bezier segment\n */\nconst quadToCubic = (\n x1: number,\n y1: number,\n qx: number,\n qy: number,\n x2: number,\n y2: number,\n): [number, number, number, number, number, number] => {\n const r13 = 1 / 3;\n const r23 = 2 / 3;\n return [\n r13 * x1 + r23 * qx, // cpx1\n r13 * y1 + r23 * qy, // cpy1\n r13 * x2 + r23 * qx, // cpx2\n r13 * y2 + r23 * qy, // cpy2\n x2,\n y2, // x,y\n ];\n};\nexport default quadToCubic;\n","import midPoint from \"../math/midPoint\";\n\n/**\n * Converts an L (line-to) segment to C (cubic-bezier).\n *\n * @param x1 line start x\n * @param y1 line start y\n * @param x2 line end x\n * @param y2 line end y\n * @returns the cubic-bezier segment\n */\nconst lineToCubic = (x1: number, y1: number, x2: number, y2: number) => {\n const c1 = midPoint([x1, y1], [x2, y2], 1.0 / 3.0);\n const c2 = midPoint([x1, y1], [x2, y2], 2.0 / 3.0);\n return [c1[0], c1[1], c2[0], c2[1], x2, y2];\n};\nexport default lineToCubic;\n","import arcToCubic from \"./arcToCubic\";\nimport quadToCubic from \"./quadToCubic\";\nimport lineToCubic from \"./lineToCubic\";\nimport type { CSegment, MSegment, PathSegment } from \"../types\";\nimport type { ParserParams } from \"../interface\";\n\n/**\n * Converts any segment to C (cubic-bezier).\n *\n * @param segment the source segment\n * @param params the source segment parameters\n * @returns the cubic-bezier segment\n */\nconst segmentToCubic = (segment: PathSegment, params: ParserParams) => {\n const [pathCommand] = segment;\n const values = segment.slice(1).map(Number);\n const [x, y] = values;\n // let args;\n const { x1: px1, y1: py1, x: px, y: py } = params;\n\n if (!\"TQ\".includes(pathCommand)) {\n params.qx = null;\n params.qy = null;\n }\n\n if (pathCommand === \"M\") {\n params.x = x;\n params.y = y;\n return segment;\n } else if (pathCommand === \"A\") {\n return [\"C\" as string | number].concat(\n arcToCubic(\n px1,\n py1,\n values[0],\n values[1],\n values[2],\n values[3],\n values[4],\n values[5],\n values[6],\n ),\n ) as CSegment;\n } else if (pathCommand === \"Q\") {\n params.qx = x;\n params.qy = y;\n return [\"C\" as string | number].concat(\n quadToCubic(px1, py1, values[0], values[1], values[2], values[3]),\n ) as CSegment;\n } else if (pathCommand === \"L\") {\n return [\"C\" as string | number].concat(\n lineToCubic(px1, py1, x, y),\n ) as CSegment;\n } else if (pathCommand === \"Z\") {\n return [\"C\" as string | number].concat(\n lineToCubic(px1, py1, px, py),\n ) as CSegment;\n }\n\n return segment as MSegment | CSegment;\n};\nexport default segmentToCubic;\n","import type { ParserParams } from \"../interface\";\nimport type {\n ASegment,\n CSegment,\n HSegment,\n LSegment,\n MSegment,\n NormalSegment,\n PathCommand,\n PathSegment,\n PointTuple,\n QSegment,\n VSegment,\n} from \"../types\";\n\n/**\n * Normalizes a single segment of a `pathArray` object.\n *\n * @param segment the segment object\n * @param params the normalization parameters\n * @returns the normalized segment\n */\nconst normalizeSegment = (segment: PathSegment, params: ParserParams) => {\n const [pathCommand] = segment;\n const absCommand = pathCommand.toUpperCase();\n const isRelative = pathCommand !== absCommand;\n const { x1: px1, y1: py1, x2: px2, y2: py2, x, y } = params;\n const values = segment.slice(1) as number[];\n let absValues = values.map((n, j) => n + (isRelative ? (j % 2 ? y : x) : 0));\n\n if (!\"TQ\".includes(absCommand)) {\n // optional but good to be cautious\n params.qx = null;\n params.qy = null;\n }\n\n // istanbul ignore else @preserve\n if (absCommand === \"A\") {\n absValues = values.slice(0, -2).concat(\n values[5] + (isRelative ? x : 0),\n values[6] + (isRelative ? y : 0),\n );\n\n return [\"A\" as PathCommand | number].concat(absValues) as ASegment;\n } else if (absCommand === \"H\") {\n return [\n \"L\",\n (segment as HSegment)[1] + (isRelative ? x : 0),\n py1,\n ] as LSegment;\n } else if (absCommand === \"V\") {\n return [\n \"L\",\n px1,\n (segment as VSegment)[1] + (isRelative ? y : 0),\n ] as LSegment;\n } else if (absCommand === \"L\") {\n return [\n \"L\",\n (segment as LSegment)[1] + (isRelative ? x : 0),\n (segment as LSegment)[2] + (isRelative ? y : 0),\n ] as LSegment;\n } else if (absCommand === \"M\") {\n return [\n \"M\",\n (segment as MSegment)[1] + (isRelative ? x : 0),\n (segment as MSegment)[2] + (isRelative ? y : 0),\n ] as MSegment;\n } else if (absCommand === \"C\") {\n return [\"C\" as PathCommand | number].concat(absValues) as CSegment;\n } else if (absCommand === \"S\") {\n const x1 = px1 * 2 - px2;\n const y1 = py1 * 2 - py2;\n params.x1 = x1;\n params.y1 = y1;\n return [\"C\", x1, y1].concat(absValues) as CSegment;\n } else if (absCommand === \"T\") {\n const qx = px1 * 2 - (params.qx ? params.qx : /* istanbul ignore next */ 0);\n const qy = py1 * 2 - (params.qy ? params.qy : /* istanbul ignore next */ 0);\n params.qx = qx;\n params.qy = qy;\n return [\"Q\", qx, qy].concat(absValues) as QSegment;\n } else if (absCommand === \"Q\") {\n const [nqx, nqy] = absValues as PointTuple;\n params.qx = nqx;\n params.qy = nqy;\n return [\"Q\" as PathCommand | number].concat(absValues) as QSegment;\n } else if (absCommand === \"Z\") {\n return [\"Z\"] as NormalSegment;\n }\n\n // istanbul ignore next @preserve\n return segment as NormalSegment;\n};\nexport default normalizeSegment;\n","import type { ParserParams } from \"../interface\";\n\nconst paramsParser: ParserParams = {\n x1: 0,\n y1: 0,\n x2: 0,\n y2: 0,\n x: 0,\n y: 0,\n qx: null,\n qy: null,\n};\n\nexport default paramsParser;\n","import segmentToCubic from \"../process/segmentToCubic\";\nimport { AbsoluteCommand, CSegment, CurveArray, PathArray } from \"../types\";\nimport iterate from \"../process/iterate\";\nimport parsePathString from \"../parser/parsePathString\";\nimport normalizeSegment from \"../process/normalizeSegment\";\nimport paramsParser from \"../parser/paramsParser\";\n\n/**\n * Parses a path string value or 'pathArray' and returns a new one\n * in which all segments are converted to cubic-bezier.\n *\n * In addition, un-necessary `Z` segment is removed if previous segment\n * extends to the `M` segment.\n *\n * @param pathInput the string to be parsed or 'pathArray'\n * @returns the resulted `pathArray` converted to cubic-bezier\n */\nconst pathToCurve = (pathInput: string | PathArray): CurveArray => {\n const params = { ...paramsParser };\n const path = parsePathString(pathInput);\n\n return iterate(path, (seg, index, lastX, lastY) => {\n params.x = lastX;\n params.y = lastY;\n const normalSegment = normalizeSegment(seg, params);\n let result = segmentToCubic(normalSegment, params);\n const isLongArc = result[0] === \"C\" && result.length > 7;\n\n if (isLongArc) {\n path.splice(\n index + 1,\n 0,\n [\"C\" as AbsoluteCommand | number].concat(result.slice(7)) as CSegment,\n );\n result = result.slice(0, 7) as CSegment;\n }\n\n const seglen = result.length;\n params.x1 = +result[seglen - 2];\n params.y1 = +result[seglen - 1];\n params.x2 = +result[seglen - 4] || params.x1;\n params.y2 = +result[seglen - 3] || params.y1;\n\n return result;\n });\n};\nexport default pathToCurve;\n","import { Options } from \"../interface\";\n\n/** SVGPathCommander default options */\nconst defaultOptions: Options = {\n origin: [0, 0, 0],\n round: 4,\n};\n\nexport default defaultOptions;\n","const roundTo = (n: number, round: number) => {\n const pow = round >= 1 ? 10 ** round : 1;\n\n return round > 0 ? Math.round(n * pow) / pow : Math.round(n);\n};\n\nexport default roundTo;\n","import type { PathArray, PathSegment } from \"../types\";\nimport defaultOptions from \"../options/options\";\nimport roundTo from \"../math/roundTo\";\n\n/**\n * Returns a valid `d` attribute string value created\n * by rounding values and concatenating the `pathArray` segments.\n *\n * @param path the `pathArray` object\n * @param roundOption amount of decimals to round values to\n * @returns the concatenated path string\n */\nconst pathToString = (\n path: PathArray,\n roundOption?: number | \"off\",\n): string => {\n const pathLen = path.length;\n let { round } = defaultOptions;\n let segment = path[0] as PathSegment;\n let result = \"\";\n\n // allow for ZERO decimals\n round = roundOption === \"off\"\n ? roundOption\n : typeof roundOption === \"number\" && roundOption >= 0\n ? roundOption\n : typeof round === \"number\" && round >= 0\n ? round\n : /* istanbul ignore next @preserve */ \"off\";\n\n for (let i = 0; i < pathLen; i += 1) {\n segment = path[i];\n const [pathCommand] = segment;\n const values = segment.slice(1) as number[];\n result += pathCommand;\n if (round === \"off\") {\n result += values.join(\" \");\n } else {\n let j = 0;\n const valLen = values.length;\n while (j < valLen) {\n result += roundTo(values[j], round);\n if (j !== valLen - 1) result += \" \";\n j += 1;\n }\n }\n }\n\n return result;\n};\n\nexport default pathToString;\n","const DISTANCE_EPSILON = 0.00001;\n\nexport default DISTANCE_EPSILON;\n","import normalizeSegment from \"./normalizeSegment\";\nimport type { NormalArray, PathArray } from \"../types\";\nimport iterate from \"./iterate\";\nimport parsePathString from \"../parser/parsePathString\";\nimport paramsParser from \"../parser/paramsParser\";\n\n/**\n * Normalizes a `pathArray` object for further processing:\n * * convert segments to absolute values\n * * convert shorthand path commands to their non-shorthand notation\n *\n * @param pathInput the string to be parsed or 'pathArray'\n * @returns the normalized `pathArray`\n */\nconst normalizePath = (pathInput: string | PathArray) => {\n const path = parsePathString(pathInput);\n const params = { ...paramsParser };\n\n return iterate(path, (seg, _, lastX, lastY) => {\n params.x = lastX;\n params.y = lastY;\n const result = normalizeSegment(seg, params);\n\n const seglen = result.length;\n params.x1 = +result[seglen - 2];\n params.y1 = +result[seglen - 1];\n params.x2 = +result[seglen - 4] || params.x1;\n params.y2 = +result[seglen - 3] || params.y1;\n\n return result;\n });\n};\nexport default normalizePath;\n","import DISTANCE_EPSILON from \"./distanceEpsilon\";\nimport type { MSegment, PathArray, PointTuple } from \"../types\";\nimport iterate from \"../process/iterate\";\nimport { getLineLength, getPointAtLineLength } from \"../math/lineTools\";\nimport { getArcLength, getPointAtArcLength } from \"../math/arcTools\";\nimport { getCubicLength, getPointAtCubicLength } from \"../math/cubicTools\";\nimport { getPointAtQuadLength, getQuadLength } from \"../math/quadTools\";\nimport normalizePath from \"../process/normalizePath\";\n\n/**\n * Returns [x,y] coordinates of a point at a given length of a shape.\n *\n * @param pathInput the `pathArray` to look into\n * @param distance the length of the shape to look at\n * @returns the requested {x, y} point coordinates\n */\nconst getPointAtLength = (pathInput: string | PathArray, distance?: number) => {\n const path = normalizePath(pathInput);\n let isM = false;\n let data = [] as number[];\n let pathCommand = \"M\";\n let x = 0;\n let y = 0;\n let [mx, my] = path[0].slice(1) as PointTuple;\n const distanceIsNumber = typeof distance === \"number\";\n let point = { x: mx, y: my };\n let length = 0;\n let POINT = point;\n let totalLength = 0;\n\n if (!distanceIsNumber || distance < DISTANCE_EPSILON) return point;\n\n // for (let i = 0; i < pathLen; i += 1) {\n iterate(path, (seg, _, lastX, lastY) => {\n [pathCommand] = seg;\n isM = pathCommand === \"M\";\n data = !isM ? [lastX, lastY].concat(seg.slice(1) as number[]) : data;\n\n // this segment is always ZERO\n /* istanbul ignore else @preserve */\n if (isM) {\n // remember mx, my for Z\n [, mx, my] = seg as MSegment;\n point = { x: mx, y: my };\n length = 0;\n } else if (pathCommand === \"L\") {\n point = getPointAtLineLength(\n data[0],\n data[1],\n data[2],\n data[3],\n distance - totalLength,\n );\n length = getLineLength(data[0], data[1], data[2], data[3]);\n } else if (pathCommand === \"A\") {\n point = getPointAtArcLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n data[6],\n data[7],\n data[8],\n distance - totalLength,\n );\n length = getArcLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n data[6],\n data[7],\n data[8],\n );\n } else if (pathCommand === \"C\") {\n point = getPointAtCubicLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n data[6],\n data[7],\n distance - totalLength,\n );\n length = getCubicLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n data[6],\n data[7],\n );\n } else if (pathCommand === \"Q\") {\n point = getPointAtQuadLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n distance - totalLength,\n );\n length = getQuadLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n );\n } else if (pathCommand === \"Z\") {\n data = [lastX, lastY, mx, my];\n point = { x: mx, y: my };\n\n length = getLineLength(data[0], data[1], data[2], data[3]);\n }\n\n [x, y] = data.slice(-2);\n\n if (totalLength < distance) {\n POINT = point;\n } else {\n // totalLength >= distance\n // stop right here\n // stop iterator now!\n return false;\n }\n\n totalLength += length;\n return;\n });\n\n // native `getPointAtLength` behavior when the given distance\n // is higher than total length\n if (distance > totalLength - DISTANCE_EPSILON) {\n return { x, y };\n }\n\n return POINT;\n};\n\nexport default getPointAtLength;\n","import type { LSegment, MSegment, PathArray, PointTuple } from \"../types\";\nimport { getLineLength } from \"../math/lineTools\";\nimport { getArcLength } from \"../math/arcTools\";\nimport { getCubicLength } from \"../math/cubicTools\";\nimport { getQuadLength } from \"../math/quadTools\";\nimport iterate from \"../process/iterate\";\nimport parsePathString from \"../parser/parsePathString\";\nimport absolutizeSegment from \"../process/absolutizeSegment\";\n\n/**\n * Returns the shape total length, or the equivalent to `shape.getTotalLength()`.\n *\n * @param pathInput the target `pathArray`\n * @returns the shape total length\n */\nconst getTotalLength = (pathInput: string | PathArray) => {\n const path = parsePathString(pathInput);\n let paramX1 = 0;\n let paramY1 = 0;\n let paramX2 = 0;\n let paramY2 = 0;\n let paramQX = 0;\n let paramQY = 0;\n let pathCommand = \"M\";\n let mx = 0;\n let my = 0;\n let totalLength = 0;\n\n iterate(path, (seg, index, lastX, lastY) => {\n [pathCommand] = seg;\n const absCommand = pathCommand.toUpperCase();\n const isRelative = absCommand !== pathCommand;\n const absoluteSegment = isRelative\n ? absolutizeSegment(seg, index, lastX, lastY)\n : (seg.slice(0) as typeof seg);\n\n const normalSegment = absCommand === \"V\"\n ? ([\"L\", lastX, absoluteSegment[1]] as LSegment)\n : absCommand === \"H\"\n ? ([\"L\", absoluteSegment[1], lastY] as LSegment)\n : absoluteSegment;\n [pathCommand] = normalSegment;\n\n if (!\"TQ\".includes(absCommand)) {\n // optional but good to be cautious\n paramQX = 0;\n paramQY = 0;\n }\n\n // this segment is always ZERO\n /* istanbul ignore else @preserve */\n if (pathCommand === \"M\") {\n // remember mx, my for Z\n [, mx, my] = normalSegment as MSegment;\n } else if (pathCommand === \"L\") {\n totalLength += getLineLength(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n );\n } else if (pathCommand === \"A\") {\n totalLength += getArcLength(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n normalSegment[5] as number,\n normalSegment[6] as number,\n normalSegment[7] as number,\n );\n } else if (pathCommand === \"S\") {\n const cp1x = paramX1 * 2 - paramX2;\n const cp1y = paramY1 * 2 - paramY2;\n\n totalLength += getCubicLength(\n lastX,\n lastY,\n cp1x,\n cp1y,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n );\n } else if (pathCommand === \"C\") {\n totalLength += getCubicLength(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n normalSegment[5] as number,\n normalSegment[6] as number,\n );\n } else if (pathCommand === \"T\") {\n paramQX = paramX1 * 2 - paramQX;\n paramQY = paramY1 * 2 - paramQY;\n totalLength += getQuadLength(\n lastX,\n lastY,\n paramQX,\n paramQY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n );\n } else if (pathCommand === \"Q\") {\n paramQX = normalSegment[1] as number;\n paramQY = normalSegment[2] as number;\n totalLength += getQuadLength(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n );\n } else if (pathCommand === \"Z\") {\n totalLength += getLineLength(lastX, lastY, mx, my);\n }\n\n // update params\n [paramX1, paramY1] = pathCommand === \"Z\"\n ? [mx, my]\n : (normalSegment.slice(-2) as PointTuple);\n [paramX2, paramY2] = pathCommand === \"C\"\n ? ([normalSegment[3], normalSegment[4]] as PointTuple)\n : pathCommand === \"S\"\n ? ([normalSegment[1], normalSegment[2]] as PointTuple)\n : [paramX1, paramY1];\n });\n\n return totalLength;\n};\n\nexport default getTotalLength;\n","import type { PathArray, PathSegment } from \"../types\";\nimport type { SegmentProperties } from \"../interface\";\nimport parsePathString from \"../parser/parsePathString\";\nimport getTotalLength from \"./getTotalLength\";\n\n/**\n * Returns the segment, its index and length as well as\n * the length to that segment at a given length in a path.\n *\n * @param pathInput target `pathArray`\n * @param distance the given length\n * @returns the requested properties\n */\nconst getPropertiesAtLength = (\n pathInput: string | PathArray,\n distance?: number,\n): SegmentProperties => {\n const pathArray = parsePathString(pathInput);\n\n let pathTemp = pathArray.slice(0) as PathArray;\n let pathLength = getTotalLength(pathTemp);\n let index = pathTemp.length - 1;\n let lengthAtSegment = 0;\n let length = 0;\n let segment = pathArray[0] as PathSegment;\n\n // If the path is empty, return 0.\n if (index <= 0 || !distance || !Number.isFinite(distance)) {\n return {\n segment,\n index: 0,\n length,\n lengthAtSegment,\n };\n }\n\n if (distance >= pathLength) {\n pathTemp = pathArray.slice(0, -1) as PathArray;\n lengthAtSegment = getTotalLength(pathTemp);\n length = pathLength - lengthAtSegment;\n segment = pathArray[index];\n return {\n segment,\n index,\n length,\n lengthAtSegment,\n };\n }\n\n const segments = [] as SegmentProperties[];\n while (index > 0) {\n segment = pathTemp[index];\n pathTemp = pathTemp.slice(0, -1) as PathArray;\n lengthAtSegment = getTotalLength(pathTemp);\n length = pathLength - lengthAtSegment;\n pathLength = lengthAtSegment;\n\n segments.push({\n segment,\n index,\n length,\n lengthAtSegment,\n });\n index -= 1;\n }\n\n return segments.find(({ lengthAtSegment: l }) =>\n l <= distance\n ) as SegmentProperties;\n};\n\nexport default getPropertiesAtLength;\n","import type { PathArray, Point } from \"../types\";\nimport type { PointProperties } from \"../interface\";\nimport getPointAtLength from \"./getPointAtLength\";\nimport getPropertiesAtLength from \"./getPropertiesAtLength\";\nimport getTotalLength from \"./getTotalLength\";\nimport parsePathString from \"../parser/parsePathString\";\nimport normalizePath from \"../process/normalizePath\";\n\n/**\n * Returns the point and segment in path closest to a given point as well as\n * the distance to the path stroke.\n *\n * @see https://bl.ocks.org/mbostock/8027637\n *\n * @param pathInput target `pathArray`\n * @param point the given point\n * @returns the requested properties\n */\nconst getPropertiesAtPoint = (\n pathInput: string | PathArray,\n point: Point,\n): PointProperties => {\n const path = parsePathString(pathInput);\n const normalPath = normalizePath(path);\n const pathLength = getTotalLength(normalPath);\n const distanceTo = (p: Point) => {\n const dx = p.x - point.x;\n const dy = p.y - point.y;\n return dx * dx + dy * dy;\n };\n let precision = 8;\n let scan: Point;\n let closest = { x: 0, y: 0 }; // make TS happy\n let scanDistance = 0;\n let bestLength = 0;\n let bestDistance = Infinity;\n\n // linear scan for coarse approximation\n for (let scanLength = 0; scanLength <= pathLength; scanLength += precision) {\n scan = getPointAtLength(normalPath, scanLength);\n scanDistance = distanceTo(scan);\n\n if (scanDistance < bestDistance) {\n closest = scan;\n bestLength = scanLength;\n bestDistance = scanDistance;\n }\n }\n\n // binary search for precise estimate\n precision /= 2;\n let before: { x: number; y: number };\n let after: { x: number; y: number };\n let beforeLength = 0;\n let afterLength = 0;\n let beforeDistance = 0;\n let afterDistance = 0;\n\n while (precision > 0.000001) {\n beforeLength = bestLength - precision;\n before = getPointAtLength(normalPath, beforeLength);\n beforeDistance = distanceTo(before);\n afterLength = bestLength + precision;\n after = getPointAtLength(normalPath, afterLength);\n afterDistance = distanceTo(after);\n\n if (beforeLength >= 0 && beforeDistance < bestDistance) {\n closest = before;\n bestLength = beforeLength;\n bestDistance = beforeDistance;\n } else if (afterLength <= pathLength && afterDistance < bestDistance) {\n closest = after;\n bestLength = afterLength;\n bestDistance = afterDistance;\n } else {\n precision /= 2;\n }\n if (precision < 0.00001) break;\n }\n\n const segment = getPropertiesAtLength(path, bestLength);\n const distance = Math.sqrt(bestDistance);\n\n return { closest, distance, segment };\n};\n\nexport default getPropertiesAtPoint;\n","import type { PathArray } from \"../types\";\nimport getPropertiesAtPoint from \"./getPropertiesAtPoint\";\n\n/**\n * Returns the point in path closest to a given point.\n *\n * @param pathInput target `pathArray`\n * @param point the given point\n * @returns the best match\n */\nconst getClosestPoint = (\n pathInput: string | PathArray,\n point: { x: number; y: number },\n) => {\n return getPropertiesAtPoint(pathInput, point).closest;\n};\n\nexport default getClosestPoint;\n","import pathToCurve from \"../convert/pathToCurve\";\nimport type { PathArray, PointTuple } from \"../types\";\n\n/**\n * Returns the area of a single cubic-bezier segment.\n *\n * http://objectmix.com/graphics/133553-area-closed-bezier-curve.html\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the area of the cubic-bezier segment\n */\nconst getCubicSegArea = (\n x1: number,\n y1: number,\n c1x: number,\n c1y: number,\n c2x: number,\n c2y: number,\n x2: number,\n y2: number,\n) => {\n return (\n (3 *\n ((y2 - y1) * (c1x + c2x) -\n (x2 - x1) * (c1y + c2y) +\n c1y * (x1 - c2x) -\n c1x * (y1 - c2y) +\n y2 * (c2x + x1 / 3) -\n x2 * (c2y + y1 / 3))) /\n 20\n );\n};\n\n/**\n * Returns the area of a shape.\n *\n * @author Jürg Lehni & Jonathan Puckey\n *\n * @see https://github.com/paperjs/paper.js/blob/develop/src/path/Path.js\n *\n * @param path the shape `pathArray`\n * @returns the length of the cubic-bezier segment\n */\nconst getPathArea = (path: PathArray) => {\n let x = 0;\n let y = 0;\n let len = 0;\n\n return pathToCurve(path)\n .map((seg) => {\n switch (seg[0]) {\n case \"M\":\n [, x, y] = seg;\n return 0;\n default:\n len = getCubicSegArea(\n x,\n y,\n seg[1],\n seg[2],\n seg[3],\n seg[4],\n seg[5],\n seg[6],\n );\n [x, y] = seg.slice(-2) as PointTuple;\n return len;\n }\n })\n .reduce((a, b) => a + b, 0);\n};\nexport default getPathArea;\n","import getPathArea from \"./getPathArea\";\nimport pathToCurve from \"../convert/pathToCurve\";\nimport type { PathArray } from \"../types\";\n\n/**\n * Check if a path is drawn clockwise and returns true if so,\n * false otherwise.\n *\n * @param path the path string or `pathArray`\n * @returns true when clockwise or false if not\n */\nconst getDrawDirection = (path: string | PathArray) => {\n return getPathArea(pathToCurve(path)) >= 0;\n};\n\nexport default getDrawDirection;\n","import iterate from \"../process/iterate\";\nimport { PathBBox } from \"../interface\";\nimport { LSegment, MSegment, PathArray, PointTuple } from \"../types\";\nimport { getLineBBox } from \"../math/lineTools\";\nimport { getArcBBox } from \"../math/arcTools\";\nimport { getCubicBBox } from \"../math/cubicTools\";\nimport { getQuadBBox } from \"../math/quadTools\";\nimport parsePathString from \"../parser/parsePathString\";\nimport absolutizeSegment from \"../process/absolutizeSegment\";\n\nconst getPathBBox = (pathInput: PathArray | string) => {\n if (!pathInput) {\n return {\n x: 0,\n y: 0,\n width: 0,\n height: 0,\n x2: 0,\n y2: 0,\n cx: 0,\n cy: 0,\n cz: 0,\n };\n }\n\n const path = parsePathString(pathInput);\n let pathCommand = \"M\";\n let mx = 0;\n let my = 0;\n const { max, min } = Math;\n let xMin = Infinity;\n let yMin = Infinity;\n let xMax = -Infinity;\n let yMax = -Infinity;\n let minX = 0;\n let minY = 0;\n let maxX = 0;\n let maxY = 0;\n let paramX1 = 0;\n let paramY1 = 0;\n let paramX2 = 0;\n let paramY2 = 0;\n let paramQX = 0;\n let paramQY = 0;\n\n iterate(path, (seg, index, lastX, lastY) => {\n [pathCommand] = seg;\n const absCommand = pathCommand.toUpperCase();\n const isRelative = absCommand !== pathCommand;\n const absoluteSegment = isRelative\n ? absolutizeSegment(seg, index, lastX, lastY)\n : (seg.slice(0) as typeof seg);\n\n const normalSegment = absCommand === \"V\"\n ? ([\"L\", lastX, absoluteSegment[1]] as LSegment)\n : absCommand === \"H\"\n ? ([\"L\", absoluteSegment[1], lastY] as LSegment)\n : absoluteSegment;\n\n [pathCommand] = normalSegment;\n\n if (!\"TQ\".includes(absCommand)) {\n // optional but good to be cautious\n paramQX = 0;\n paramQY = 0;\n }\n\n // this segment is always ZERO\n /* istanbul ignore else @preserve */\n if (pathCommand === \"M\") {\n [, mx, my] = normalSegment as MSegment;\n minX = mx;\n minY = my;\n maxX = mx;\n maxY = my;\n } else if (pathCommand === \"L\") {\n [minX, minY, maxX, maxY] = getLineBBox(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n );\n } else if (pathCommand === \"A\") {\n [minX, minY, maxX, maxY] = getArcBBox(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n normalSegment[5] as number,\n normalSegment[6] as number,\n normalSegment[7] as number,\n );\n } else if (pathCommand === \"S\") {\n const cp1x = paramX1 * 2 - paramX2;\n const cp1y = paramY1 * 2 - paramY2;\n\n [minX, minY, maxX, maxY] = getCubicBBox(\n lastX,\n lastY,\n cp1x,\n cp1y,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n );\n } else if (pathCommand === \"C\") {\n [minX, minY, maxX, maxY] = getCubicBBox(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n normalSegment[5] as number,\n normalSegment[6] as number,\n );\n } else if (pathCommand === \"T\") {\n paramQX = paramX1 * 2 - paramQX;\n paramQY = paramY1 * 2 - paramQY;\n [minX, minY, maxX, maxY] = getQuadBBox(\n lastX,\n lastY,\n paramQX,\n paramQY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n );\n } else if (pathCommand === \"Q\") {\n paramQX = normalSegment[1] as number;\n paramQY = normalSegment[2] as number;\n [minX, minY, maxX, maxY] = getQuadBBox(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n );\n } else if (pathCommand === \"Z\") {\n [minX, minY, maxX, maxY] = getLineBBox(lastX, lastY, mx, my);\n }\n xMin = min(minX, xMin);\n yMin = min(minY, yMin);\n xMax = max(maxX, xMax);\n yMax = max(maxY, yMax);\n\n // update params\n [paramX1, paramY1] = pathCommand === \"Z\"\n ? [mx, my]\n : (normalSegment.slice(-2) as PointTuple);\n [paramX2, paramY2] = pathCommand === \"C\"\n ? ([normalSegment[3], normalSegment[4]] as PointTuple)\n : pathCommand === \"S\"\n ? ([normalSegment[1], normalSegment[2]] as PointTuple)\n : [paramX1, paramY1];\n });\n\n const width = xMax - xMin;\n const height = yMax - yMin;\n\n return {\n width,\n height,\n x: xMin,\n y: yMin,\n x2: xMax,\n y2: yMax,\n cx: xMin + width / 2,\n cy: yMin + height / 2,\n // an estimated guess\n cz: Math.max(width, height) + Math.min(width, height) / 2,\n } satisfies PathBBox;\n};\n\nexport default getPathBBox;\n","import type { PathArray, PathSegment } from \"../types\";\nimport getPropertiesAtLength from \"./getPropertiesAtLength\";\n\n/**\n * Returns the segment at a given length.\n *\n * @param pathInput the target `pathArray`\n * @param distance the distance in path to look at\n * @returns the requested segment\n */\nconst getSegmentAtLength = (\n pathInput: string | PathArray,\n distance?: number,\n): PathSegment | undefined => {\n return getPropertiesAtLength(pathInput, distance).segment;\n};\n\nexport default getSegmentAtLength;\n","import type { SegmentProperties } from \"../interface\";\nimport type { PathArray } from \"../types\";\nimport getPropertiesAtPoint from \"./getPropertiesAtPoint\";\n\n/**\n * Returns the path segment which contains a given point.\n *\n * @param path the `pathArray` to look into\n * @param point the point of the shape to look for\n * @returns the requested segment\n */\nconst getSegmentOfPoint = (\n path: string | PathArray,\n point: { x: number; y: number },\n): SegmentProperties | undefined => {\n return getPropertiesAtPoint(path, point).segment;\n};\nexport default getSegmentOfPoint;\n","import type { PathArray, PathSegment, RelativeCommand } from \"../types\";\nimport paramsCount from \"../parser/paramsCount\";\n\n/**\n * Iterates an array to check if it's an actual `pathArray`.\n *\n * @param path the `pathArray` to be checked\n * @returns iteration result\n */\nconst isPathArray = (path: unknown): path is PathArray => {\n return (\n Array.isArray(path) &&\n path.every((seg: PathSegment) => {\n const lk = seg[0].toLowerCase() as RelativeCommand;\n return (\n paramsCount[lk] === seg.length - 1 &&\n \"achlmqstvz\".includes(lk) &&\n (seg.slice(1) as unknown[]).every(Number.isFinite)\n );\n }) &&\n path.length > 0\n );\n};\nexport default isPathArray;\n","import type { AbsoluteArray } from \"../types\";\nimport isPathArray from \"./isPathArray\";\n\n/**\n * Iterates an array to check if it's a `pathArray`\n * with all absolute values.\n *\n * @param path the `pathArray` to be checked\n * @returns iteration result\n */\nconst isAbsoluteArray = (path: unknown): path is AbsoluteArray => {\n return (\n isPathArray(path) &&\n // `isPathArray` also checks if it's `Array`\n path.every(([x]) => x === x.toUpperCase())\n );\n};\nexport default isAbsoluteArray;\n","import type { NormalArray } from \"../types\";\nimport isAbsoluteArray from \"./isAbsoluteArray\";\n\n/**\n * Iterates an array to check if it's a `pathArray`\n * with all segments are in non-shorthand notation\n * with absolute values.\n *\n * @param {string | SVGPath.pathArray} path the `pathArray` to be checked\n * @returns {boolean} iteration result\n */\nconst isNormalizedArray = (path: unknown): path is NormalArray => {\n // `isAbsoluteArray` also checks if it's `Array`\n return isAbsoluteArray(path) && path.every(([pc]) => \"ACLMQZ\".includes(pc));\n};\nexport default isNormalizedArray;\n","import { CurveArray } from \"../types\";\nimport isNormalizedArray from \"./isNormalizedArray\";\n\n/**\n * Iterates an array to check if it's a `pathArray`\n * with all C (cubic bezier) segments.\n *\n * @param path the `Array` to be checked\n * @returns iteration result\n */\nconst isCurveArray = (path: unknown): path is CurveArray => {\n // `isPathArray` also checks if it's `Array`\n return isNormalizedArray(path) && path.every(([pc]) => \"MC\".includes(pc));\n};\nexport default isCurveArray;\n","import type { PathArray } from \"../types\";\nimport getPropertiesAtPoint from \"./getPropertiesAtPoint\";\nimport DISTANCE_EPSILON from \"./distanceEpsilon\";\n\n/**\n * Checks if a given point is in the stroke of a path.\n *\n * @param pathInput target path\n * @param point the given `{x,y}` point\n * @returns the query result\n */\nconst isPointInStroke = (\n pathInput: string | PathArray,\n point: { x: number; y: number },\n) => {\n const { distance } = getPropertiesAtPoint(pathInput, point);\n return Math.abs(distance) < DISTANCE_EPSILON; // 0.01 might be more permissive\n};\nexport default isPointInStroke;\n","import type { RelativeArray } from \"../types\";\nimport isPathArray from \"./isPathArray\";\n\n/**\n * Iterates an array to check if it's a `pathArray`\n * with relative values.\n *\n * @param path the `pathArray` to be checked\n * @returns iteration result\n */\nconst isRelativeArray = (path: unknown): path is RelativeArray => {\n return (\n isPathArray(path) &&\n // `isPathArray` checks if it's `Array`\n path.slice(1).every(([pc]) => pc === pc.toLowerCase())\n );\n};\nexport default isRelativeArray;\n","import scanSegment from \"../parser/scanSegment\";\nimport skipSpaces from \"../parser/skipSpaces\";\nimport PathParser from \"../parser/pathParser\";\n\n/**\n * Parses a path string value to determine its validity\n * then returns true if it's valid or false otherwise.\n *\n * @param pathString the path string to be parsed\n * @returns the path string validity\n */\nconst isValidPath = (pathString: string) => {\n if (typeof pathString !== \"string\" || !pathString.length) {\n return false;\n }\n\n const path = new PathParser(pathString);\n\n skipSpaces(path);\n\n while (path.index < path.max && !path.err.length) {\n scanSegment(path);\n }\n\n return !path.err.length && \"mM\".includes(path.segments[0][0]);\n};\nexport default isValidPath;\n","import type { ShapeParams } from \"../interface\";\n\n/**\n * Supported shapes and their specific parameters.\n */\nconst shapeParams: ShapeParams = {\n line: [\"x1\", \"y1\", \"x2\", \"y2\"],\n circle: [\"cx\", \"cy\", \"r\"],\n ellipse: [\"cx\", \"cy\", \"rx\", \"ry\"],\n rect: [\"width\", \"height\", \"x\", \"y\", \"rx\", \"ry\"],\n polygon: [\"points\"],\n polyline: [\"points\"],\n glyph: [\"d\"],\n};\n\nexport default shapeParams;\n","const isElement = (node?: unknown): node is Element =>\n node !== undefined && node !== null &&\n typeof node === \"object\" &&\n (node as Node).nodeType === 1; // ELEMENT_NODE\n\nexport default isElement;\n","import type {\n CircleAttr,\n EllipseAttr,\n GlyphAttr,\n LineAttr,\n PolyAttr,\n RectAttr,\n ShapeParams,\n} from \"../interface\";\nimport type { PathArray, PathSegment, ShapeOps, ShapeTypes } from \"../types\";\nimport error from \"../parser/error\";\nimport parsePathString from \"../parser/parsePathString\";\nimport shapeParams from \"./shapeParams\";\nimport isPathArray from \"./isPathArray\";\nimport isElement from \"./isElement\";\n\n/**\n * Returns a new `pathArray` from line attributes.\n *\n * @param attr shape configuration\n * @returns a new line `pathArray`\n */\nexport const getLinePath = (attr: LineAttr): PathArray => {\n let { x1, y1, x2, y2 } = attr;\n [x1, y1, x2, y2] = [x1, y1, x2, y2].map((a) => +a);\n return [\n [\"M\", x1, y1],\n [\"L\", x2, y2],\n ];\n};\n\n/**\n * Returns a new `pathArray` like from polyline/polygon attributes.\n *\n * @param attr shape configuration\n * @return a new polygon/polyline `pathArray`\n */\nexport const getPolyPath = (attr: PolyAttr): PathArray => {\n const pathArray = [] as PathSegment[];\n const points = (attr.points || \"\")\n .trim()\n .split(/[\\s|,]/)\n .map((a) => +a);\n\n let index = 0;\n while (index < points.length) {\n pathArray.push([index ? \"L\" : \"M\", points[index], points[index + 1]]);\n index += 2;\n }\n\n return (attr.type === \"polygon\"\n ? [...pathArray, [\"z\"]]\n : pathArray) as PathArray;\n};\n\n/**\n * Returns a new `pathArray` from circle attributes.\n *\n * @param attr shape configuration\n * @return a circle `pathArray`\n */\nexport const getCirclePath = (attr: CircleAttr): PathArray => {\n let { cx, cy, r } = attr;\n [cx, cy, r] = [cx, cy, r].map((a) => +a);\n\n return [\n [\"M\", cx - r, cy],\n [\"a\", r, r, 0, 1, 0, 2 * r, 0],\n [\"a\", r, r, 0, 1, 0, -2 * r, 0],\n ];\n};\n\n/**\n * Returns a new `pathArray` from ellipse attributes.\n *\n * @param attr shape configuration\n * @return an ellipse `pathArray`\n */\nexport const getEllipsePath = (attr: EllipseAttr): PathArray => {\n let { cx, cy } = attr;\n let rx = attr.rx || 0;\n let ry = attr.ry || rx;\n [cx, cy, rx, ry] = [cx, cy, rx, ry].map((a) => +a);\n\n return [\n [\"M\", cx - rx, cy],\n [\"a\", rx, ry, 0, 1, 0, 2 * rx, 0],\n [\"a\", rx, ry, 0, 1, 0, -2 * rx, 0],\n ];\n};\n\n/**\n * Returns a new `pathArray` like from rect attributes.\n *\n * @param attr object with properties above\n * @return a new `pathArray` from `` attributes\n */\nexport const getRectanglePath = (attr: RectAttr): PathArray => {\n const x = +attr.x || 0;\n const y = +attr.y || 0;\n const w = +attr.width;\n const h = +attr.height;\n let rx = +(attr.rx || 0);\n let ry = +(attr.ry || rx);\n\n // Validity checks from http://www.w3.org/TR/SVG/shapes.html#RectElement:\n if (rx || ry) {\n // rx = !rx ? ry : rx;\n // ry = !ry ? rx : ry;\n\n /* istanbul ignore else @preserve */\n if (rx * 2 > w) rx -= (rx * 2 - w) / 2;\n /* istanbul ignore else @preserve */\n if (ry * 2 > h) ry -= (ry * 2 - h) / 2;\n\n return [\n [\"M\", x + rx, y],\n [\"h\", w - rx * 2],\n [\"s\", rx, 0, rx, ry],\n [\"v\", h - ry * 2],\n [\"s\", 0, ry, -rx, ry],\n [\"h\", -w + rx * 2],\n [\"s\", -rx, 0, -rx, -ry],\n [\"v\", -h + ry * 2],\n [\"s\", 0, -ry, rx, -ry],\n ];\n }\n\n return [[\"M\", x, y], [\"h\", w], [\"v\", h], [\"H\", x], [\"Z\"]];\n};\n\n/**\n * Returns a new `pathArray` created from attributes of a ``, ``,\n * ``, ``, ``, ``, or ``.\n *\n * It can also work with an options object, see the type below\n * @see ShapeOps\n *\n * @param element target shape\n * @return the newly created `` element\n */\nconst shapeToPathArray = (\n element: ShapeTypes | ShapeOps,\n) => {\n const supportedShapes = Object.keys(shapeParams) as (keyof ShapeParams)[];\n const targetIsElement = isElement(element);\n const tagName = targetIsElement ? element.tagName : null;\n\n if (tagName && [...supportedShapes, \"path\"].every((s) => tagName !== s)) {\n throw TypeError(`${error}: \"${tagName}\" is not SVGElement`);\n }\n\n const type =\n (targetIsElement ? tagName : (element as ShapeOps).type) as ShapeOps[\n \"type\"\n ];\n const shapeAttrs = shapeParams[type] as string[];\n const config = { type } as Record;\n\n if (targetIsElement) {\n shapeAttrs.forEach((p) => {\n config[p] = element.getAttribute(p) as string;\n });\n } else {\n Object.assign(config, element);\n }\n\n // set d\n let pathArray = [] as unknown as PathArray;\n\n /* istanbul ignore else */\n if (type === \"circle\") {\n pathArray = getCirclePath(config as unknown as CircleAttr);\n } else if (type === \"ellipse\") {\n pathArray = getEllipsePath(config as unknown as EllipseAttr);\n } else if ([\"polyline\", \"polygon\"].includes(type)) {\n pathArray = getPolyPath(config as unknown as PolyAttr);\n } else if (type === \"rect\") {\n pathArray = getRectanglePath(config as unknown as RectAttr);\n } else if (type === \"line\") {\n pathArray = getLinePath(config as unknown as LineAttr);\n } else if ([\"glyph\", \"path\"].includes(type)) {\n pathArray = parsePathString(\n targetIsElement\n ? element.getAttribute(\"d\") || /* istanbul ignore next @preserve */ \"\"\n : (element as GlyphAttr).d || \"\",\n );\n }\n\n // replace target element\n if (isPathArray(pathArray) && pathArray.length) {\n return pathArray;\n }\n return false;\n};\nexport default shapeToPathArray;\n","import type { ShapeParams } from \"../interface\";\nimport type { ShapeOps, ShapeTypes } from \"../types\";\nimport pathToString from \"../convert/pathToString\";\nimport defaultOptions from \"../options/options\";\nimport error from \"../parser/error\";\nimport isValidPath from \"./isValidPath\";\nimport isElement from \"./isElement\";\nimport shapeToPathArray from \"./shapeToPathArray\";\nimport shapeParams from \"./shapeParams\";\n\n/**\n * Returns a new `` element created from attributes of a ``, ``,\n * ``, ``, ``, `` or ``. If `replace` parameter\n * is `true`, it will replace the target. The default `ownerDocument` is your current\n * `document` browser page, if you want to use in server-side using `jsdom`, you can\n * pass the `jsdom` `document` to `ownDocument`.\n *\n * It can also work with an options object, see the type below\n * @see ShapeOps\n *\n * The newly created `` element keeps all non-specific\n * attributes like `class`, `fill`, etc.\n *\n * @param element target shape\n * @param replace option to replace target\n * @param ownerDocument document for create element\n * @return the newly created `` element\n */\nconst shapeToPath = (\n element: ShapeTypes | ShapeOps,\n replace?: boolean,\n ownerDocument?: Document,\n): SVGPathElement | false => {\n const doc = ownerDocument || document;\n const supportedShapes = Object.keys(shapeParams) as (keyof ShapeParams)[];\n const targetIsElement = isElement(element);\n const tagName = targetIsElement ? element.tagName : null;\n\n if (tagName === \"path\") {\n throw TypeError(`${error}: \"${tagName}\" is already SVGPathElement`);\n }\n if (tagName && supportedShapes.every((s) => tagName !== s)) {\n throw TypeError(`${error}: \"${tagName}\" is not SVGElement`);\n }\n\n const path = doc.createElementNS(\"http://www.w3.org/2000/svg\", \"path\");\n const type =\n (targetIsElement ? tagName : (element as ShapeOps).type) as ShapeOps[\n \"type\"\n ];\n const shapeAttrs = shapeParams[type] as string[];\n const config = { type } as Record;\n\n // set d\n const round = defaultOptions.round as number;\n const pathArray = shapeToPathArray(element);\n const description = pathArray && pathArray.length\n ? pathToString(pathArray, round)\n : \"\";\n\n if (targetIsElement) {\n shapeAttrs.forEach((p) => {\n config[p] = element.getAttribute(p) as string;\n });\n // set no-specific shape attributes: fill, stroke, etc\n Object.values(element.attributes).forEach(({ name, value }) => {\n if (!shapeAttrs.includes(name)) path.setAttribute(name, value);\n });\n } else {\n Object.assign(config, element);\n // set no-specific shape attributes: fill, stroke, etc\n Object.keys(config).forEach((k) => {\n if (!shapeAttrs.includes(k) && k !== \"type\") {\n path.setAttribute(\n k.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`),\n config[k],\n );\n }\n });\n }\n\n // replace target element\n if (isValidPath(description)) {\n path.setAttribute(\"d\", description);\n if (replace && targetIsElement) {\n element.before(path, element);\n element.remove();\n }\n return path;\n }\n return false;\n};\n\nexport default shapeToPath;\n","import CSSMatrix from \"@thednp/dommatrix\";\n// import type { TransformObject } from '../interface';\nimport type { TransformObjectValues } from \"../types\";\n\n/**\n * Returns a transformation matrix to apply to `` elements.\n *\n * @see TransformObjectValues\n *\n * @param transform the `transformObject`\n * @returns a new transformation matrix\n */\nconst getSVGMatrix = (transform: TransformObjectValues): CSSMatrix => {\n let matrix = new CSSMatrix();\n const { origin } = transform;\n const [originX, originY] = origin as [number, number, number];\n const { translate } = transform;\n const { rotate } = transform;\n const { skew } = transform;\n const { scale } = transform;\n\n // set translate\n if (\n Array.isArray(translate) &&\n translate.length >= 2 &&\n translate.every((x) => !Number.isNaN(+x)) &&\n translate.some((x) => x !== 0)\n ) {\n matrix = matrix.translate(...(translate as [number, number, number?]));\n } else if (typeof translate === \"number\" && !Number.isNaN(translate)) {\n matrix = matrix.translate(translate);\n }\n\n if (rotate || skew || scale) {\n // set SVG transform-origin, always defined\n matrix = matrix.translate(originX, originY);\n\n // set rotation\n if (\n Array.isArray(rotate) &&\n rotate.length >= 2 &&\n rotate.every((x) => !Number.isNaN(+x)) &&\n rotate.some((x) => x !== 0)\n ) {\n matrix = matrix.rotate(...(rotate as [number, number, number?]));\n } else if (typeof rotate === \"number\" && !Number.isNaN(rotate)) {\n matrix = matrix.rotate(rotate);\n }\n\n // set skew(s)\n if (\n Array.isArray(skew) && skew.length === 2 && skew.every((x) =>\n !Number.isNaN(+x)\n ) && skew.some((x) => x !== 0)\n ) {\n matrix = skew[0] ? matrix.skewX(skew[0]) : matrix;\n matrix = skew[1] ? matrix.skewY(skew[1]) : matrix;\n } else if (typeof skew === \"number\" && !Number.isNaN(skew)) {\n matrix = matrix.skewX(skew);\n }\n\n // set scale\n if (\n Array.isArray(scale) && scale.length >= 2 && scale.every((x) =>\n !Number.isNaN(+x)\n ) && scale.some((x) => x !== 1)\n ) {\n matrix = matrix.scale(...(scale as [number, number, number?]));\n } else if (typeof scale === \"number\" && !Number.isNaN(scale)) {\n matrix = matrix.scale(scale);\n }\n // set SVG transform-origin\n matrix = matrix.translate(-originX, -originY);\n }\n\n return matrix;\n};\nexport default getSVGMatrix;\n","import defaultOptions from \"../options/options\";\nimport type { ParserParams } from \"../interface\";\nimport roundTo from \"../math/roundTo\";\nimport type {\n AbsoluteSegment,\n NormalSegment,\n PathCommand,\n ShortSegment,\n SSegment,\n TSegment,\n} from \"../types\";\n\n/**\n * Shorten a single segment of a `pathArray` object.\n *\n * @param segment the `absoluteSegment` object\n * @param normalSegment the `normalSegment` object\n * @param params the coordinates of the previous segment\n * @param prevCommand the path command of the previous segment\n * @returns the shortened segment\n */\nconst shortenSegment = (\n segment: AbsoluteSegment,\n normalSegment: NormalSegment,\n params: ParserParams,\n prevCommand: PathCommand,\n): ShortSegment => {\n const [pathCommand] = segment;\n const { round: defaultRound } = defaultOptions;\n const round = typeof defaultRound === \"number\"\n ? defaultRound\n : /* istanbul ignore next */ 4;\n const normalValues = normalSegment.slice(1) as number[];\n const { x1, y1, x2, y2, x, y } = params;\n const [nx, ny] = normalValues.slice(-2);\n const result = segment;\n\n if (!\"TQ\".includes(pathCommand)) {\n // optional but good to be cautious\n params.qx = null;\n params.qy = null;\n }\n\n if (pathCommand === \"L\") {\n if (roundTo(x, round) === roundTo(nx, round)) {\n return [\"V\", ny];\n } else if (roundTo(y, round) === roundTo(ny, round)) {\n return [\"H\", nx];\n }\n } else if (pathCommand === \"C\") {\n const [nx1, ny1] = normalValues;\n params.x1 = nx1;\n params.y1 = ny1;\n\n if (\n \"CS\".includes(prevCommand) &&\n ((roundTo(nx1, round) === roundTo(x1 * 2 - x2, round) &&\n roundTo(ny1, round) === roundTo(y1 * 2 - y2, round)) ||\n (roundTo(x1, round) === roundTo(x2 * 2 - x, round) &&\n roundTo(y1, round) === roundTo(y2 * 2 - y, round)))\n ) {\n return [\n \"S\",\n normalValues[2],\n normalValues[3],\n normalValues[4],\n normalValues[5],\n ] as SSegment;\n }\n } else if (pathCommand === \"Q\") {\n const [qx, qy] = normalValues;\n params.qx = qx;\n params.qy = qy;\n\n if (\n \"QT\".includes(prevCommand) &&\n roundTo(qx, round) === roundTo(x1 * 2 - x2, round) &&\n roundTo(qy, round) === roundTo(y1 * 2 - y2, round)\n ) {\n return [\"T\", normalValues[2], normalValues[3]] as TSegment;\n }\n }\n\n // ['V', 'H', 'S', 'T', 'Z'].includes(pathCommand)\n return result as ShortSegment;\n};\n\nexport default shortenSegment;\n","import type { PathCommand, PathSegment } from \"../types\";\nimport roundTo from \"../math/roundTo\";\n\nconst roundSegment = (\n segment: T,\n roundOption: number,\n) => {\n const values = (segment.slice(1) as number[]).map((n) =>\n roundTo(n, roundOption)\n );\n return [segment[0] as PathCommand | number].concat(values) as T;\n};\n\nexport default roundSegment;\n","import type { AbsoluteSegment, PathArray, PathCommand } from \"../types\";\nimport pathToAbsolute from \"../convert/pathToAbsolute\";\nimport shortenSegment from \"./shortenSegment\";\nimport paramsParser from \"../parser/paramsParser\";\nimport iterate from \"./iterate\";\nimport normalizeSegment from \"./normalizeSegment\";\nimport relativizeSegment from \"./relativizeSegment\";\nimport roundSegment from \"./roundSegment\";\n\n/**\n * Optimizes a `pathArray` object:\n * * convert segments to shorthand if possible\n * * select shortest segments from absolute and relative `pathArray`s\n *\n * @param pathInput a string or `pathArray`\n * @param roundOption the amount of decimals to round values to\n * @returns the optimized `pathArray`\n */\nconst optimizePath = (pathInput: PathArray, roundOption?: number) => {\n const path = pathToAbsolute(pathInput);\n // allow for ZERO decimals or use an aggressive value of 2\n const round = typeof roundOption === \"number\" && roundOption >= 0\n ? roundOption\n : /* istanbul ignore next @preserve */ 2;\n // this utility overrides the iterator params\n const optimParams = { ...paramsParser };\n\n const allPathCommands = [] as PathCommand[];\n let pathCommand = \"M\" as PathCommand;\n let prevCommand = \"Z\" as PathCommand;\n\n return iterate(path, (seg, i, lastX, lastY) => {\n optimParams.x = lastX;\n optimParams.y = lastY;\n const normalizedSegment = normalizeSegment(seg, optimParams);\n let result = seg;\n [pathCommand] = seg;\n\n // Save current path command\n allPathCommands[i] = pathCommand;\n if (i) {\n // Get previous path command for `shortenSegment`\n prevCommand = allPathCommands[i - 1];\n const shortSegment = shortenSegment(\n seg as AbsoluteSegment,\n normalizedSegment,\n optimParams,\n prevCommand,\n );\n const absSegment = roundSegment(shortSegment, round);\n const absString = absSegment.join(\"\");\n const relativeSegment = relativizeSegment(shortSegment, i, lastX, lastY);\n const relSegment = roundSegment(relativeSegment, round);\n const relString = relSegment.join(\"\");\n result = absString.length < relString.length ? absSegment : relSegment;\n }\n\n const seglen = normalizedSegment.length;\n optimParams.x1 = +normalizedSegment[seglen - 2];\n optimParams.y1 = +normalizedSegment[seglen - 1];\n optimParams.x2 = +normalizedSegment[seglen - 4] || optimParams.x1;\n optimParams.y2 = +normalizedSegment[seglen - 3] || optimParams.y1;\n\n return result;\n });\n};\n\nexport default optimizePath;\n","import CSSMatrix from \"@thednp/dommatrix\";\nimport { type PointTuple } from \"../types\";\n\n/**\n * Transforms a specified point using a matrix, returning a new\n * Tuple *Object* comprising of the transformed point.\n * Neither the matrix nor the original point are altered.\n *\n * @copyright thednp © 2021\n *\n * @param cssm CSSMatrix instance\n * @param v Tuple\n * @return the resulting Tuple\n */\nconst translatePoint = (\n cssm: CSSMatrix,\n v: [number, number, number, number],\n): [number, number, number, number] => {\n let m = CSSMatrix.Translate(v[0], v[1], v[2]);\n\n [, , , m.m44] = v;\n m = cssm.multiply(m);\n\n return [m.m41, m.m42, m.m43, m.m44];\n};\n\n/**\n * Returns the [x,y] projected coordinates for a given an [x,y] point\n * and an [x,y,z] perspective origin point.\n *\n * Equation found here =>\n * http://en.wikipedia.org/wiki/3D_projection#Diagram\n * Details =>\n * https://stackoverflow.com/questions/23792505/predicted-rendering-of-css-3d-transformed-pixel\n *\n * @param m the transformation matrix\n * @param point2D the initial [x,y] coordinates\n * @param origin the [x,y,z] transform origin\n * @returns the projected [x,y] coordinates\n */\nconst projection2d = (\n m: CSSMatrix,\n point2D: PointTuple,\n origin: [number, number, number],\n): PointTuple => {\n const [originX, originY, originZ] = origin;\n const [x, y, z] = translatePoint(m, [point2D[0], point2D[1], 0, 1]);\n\n const relativePositionX = x - originX;\n const relativePositionY = y - originY;\n const relativePositionZ = z - originZ;\n\n return [\n // protect against division by ZERO\n relativePositionX * (Math.abs(originZ) / Math.abs(relativePositionZ) || 1) +\n originX,\n relativePositionY * (Math.abs(originZ) / Math.abs(relativePositionZ) || 1) +\n originY,\n ];\n};\nexport default projection2d;\n","import type { CSegment, CurveArray, MSegment, PathCommand } from \"../types\";\n\n/**\n * Reverses all segments of a `pathArray`\n * which consists of only C (cubic-bezier) path commands.\n *\n * @param path the source `pathArray`\n * @returns the reversed `pathArray`\n */\nconst reverseCurve = (path: CurveArray) => {\n const rotatedCurve = path\n .slice(1)\n .map((x, i, curveOnly) =>\n !i\n ? path[0].slice(1).concat(x.slice(1) as number[])\n : curveOnly[i - 1].slice(-2).concat(x.slice(1))\n )\n .map((x) => x.map((_, i) => x[x.length - i - 2 * (1 - (i % 2))]))\n .reverse() as (MSegment | CSegment)[];\n\n return [[\"M\" as PathCommand | number].concat(rotatedCurve[0].slice(0, 2))]\n .concat(\n rotatedCurve.map((x) => [\"C\" as PathCommand | number].concat(x.slice(2))),\n ) as CurveArray;\n};\n\nexport default reverseCurve;\n","import type {\n ASegment,\n CSegment,\n HSegment,\n MSegment,\n PathArray,\n PathSegment,\n PointTuple,\n QSegment,\n SSegment,\n TSegment,\n VSegment,\n} from \"../types\";\nimport pathToAbsolute from \"../convert/pathToAbsolute\";\nimport normalizePath from \"./normalizePath\";\nimport iterate from \"./iterate\";\n\n/**\n * Reverses all segments of a `pathArray` and returns a new `pathArray` instance\n * with absolute values.\n *\n * @param pathInput the source `pathArray`\n * @returns the reversed `pathArray`\n */\nconst reversePath = (pathInput: PathArray) => {\n const absolutePath = pathToAbsolute(pathInput);\n const normalizedPath = normalizePath(absolutePath);\n const pLen = absolutePath.length;\n const isClosed = absolutePath[pLen - 1][0] === \"Z\";\n\n const reversedPath = iterate(absolutePath, (segment, i) => {\n const normalizedSegment = normalizedPath[i];\n const prevSeg = i && absolutePath[i - 1];\n const prevCommand = prevSeg && prevSeg[0];\n const nextSeg = absolutePath[i + 1];\n const nextCommand = nextSeg && nextSeg[0];\n const [pathCommand] = segment;\n const [x, y] = normalizedPath[i ? i - 1 : pLen - 1].slice(-2) as PointTuple;\n let result = segment;\n\n switch (pathCommand) {\n case \"M\":\n result = (isClosed ? [\"Z\"] : [pathCommand, x, y]) as PathSegment;\n break;\n case \"A\":\n result = [\n pathCommand,\n segment[1],\n segment[2],\n segment[3],\n segment[4],\n segment[5] === 1 ? 0 : 1,\n x,\n y,\n ] as ASegment;\n break;\n case \"C\":\n if (nextSeg && nextCommand === \"S\") {\n result = [\"S\", segment[1], segment[2], x, y] as SSegment;\n } else {\n result = [\n pathCommand,\n segment[3],\n segment[4],\n segment[1],\n segment[2],\n x,\n y,\n ] as CSegment;\n }\n break;\n case \"S\":\n if (\n prevCommand && \"CS\".includes(prevCommand) &&\n (!nextSeg || nextCommand !== \"S\")\n ) {\n result = [\n \"C\",\n normalizedSegment[3],\n normalizedSegment[4],\n normalizedSegment[1],\n normalizedSegment[2],\n x,\n y,\n ] as CSegment;\n } else {\n result = [\n pathCommand,\n normalizedSegment[1],\n normalizedSegment[2],\n x,\n y,\n ] as SSegment;\n }\n break;\n case \"Q\":\n if (nextSeg && nextCommand === \"T\") {\n result = [\"T\", x, y] as TSegment;\n } else {\n result = [pathCommand, segment[1], segment[2], x, y] as QSegment;\n }\n break;\n case \"T\":\n if (\n prevCommand && \"QT\".includes(prevCommand) &&\n (!nextSeg || nextCommand !== \"T\")\n ) {\n result = [\n \"Q\",\n normalizedSegment[1],\n normalizedSegment[2],\n x,\n y,\n ] as QSegment;\n } else {\n result = [pathCommand, x, y] as TSegment;\n }\n break;\n case \"Z\":\n result = [\"M\", x, y] as MSegment;\n break;\n case \"H\":\n result = [pathCommand, x] as HSegment;\n break;\n case \"V\":\n result = [pathCommand, y] as VSegment;\n break;\n default:\n result = [pathCommand as typeof pathCommand | number].concat(\n segment.slice(1, -2),\n x,\n y,\n ) as PathSegment;\n }\n\n return result;\n });\n\n return (\n isClosed\n ? reversedPath.reverse()\n : [reversedPath[0] as PathSegment].concat(reversedPath.slice(1).reverse())\n ) as PathArray;\n};\n\nexport default reversePath;\n","import type { PathArray } from \"../types\";\nimport defaultOptions from \"../options/options\";\nimport iterate from \"./iterate\";\nimport roundSegment from \"./roundSegment\";\n\n/**\n * Rounds the values of a `pathArray` instance to\n * a specified amount of decimals and returns it.\n *\n * @param path the source `pathArray`\n * @param roundOption the amount of decimals to round numbers to\n * @returns the resulted `pathArray` with rounded values\n */\nconst roundPath = (path: PathArray, roundOption?: number | \"off\") => {\n let { round } = defaultOptions;\n // allow for ZERO decimals\n round = roundOption === \"off\"\n ? roundOption\n : typeof roundOption === \"number\" && roundOption >= 0\n ? roundOption\n : typeof round === \"number\" && round >= 0\n ? round\n : /* istanbul ignore next @preserve */ \"off\";\n\n /* istanbul ignore else @preserve */\n if (round === \"off\") return path.slice(0) as PathArray;\n\n return iterate(path, (segment) => {\n return roundSegment(segment, round);\n });\n};\nexport default roundPath;\n","import midPoint from \"../math/midPoint\";\nimport type { CubicSegment, PointTuple } from \"../types\";\n\n/**\n * Split a cubic-bezier segment into two.\n *\n * @param pts the cubic-bezier parameters\n * @param ratio the cubic-bezier parameters\n * @return two new cubic-bezier segments\n */\nconst splitCubic = (\n pts: number[],\n ratio = 0.5,\n): [CubicSegment, CubicSegment] => {\n const t = ratio;\n const p0 = pts.slice(0, 2) as PointTuple;\n const p1 = pts.slice(2, 4) as PointTuple;\n const p2 = pts.slice(4, 6) as PointTuple;\n const p3 = pts.slice(6, 8) as PointTuple;\n const p4 = midPoint(p0, p1, t);\n const p5 = midPoint(p1, p2, t);\n const p6 = midPoint(p2, p3, t);\n const p7 = midPoint(p4, p5, t);\n const p8 = midPoint(p5, p6, t);\n const p9 = midPoint(p7, p8, t);\n\n return [\n [\"C\", p4[0], p4[1], p7[0], p7[1], p9[0], p9[1]],\n [\"C\", p8[0], p8[1], p6[0], p6[1], p3[0], p3[1]],\n ];\n};\nexport default splitCubic;\n","import paramsParser from \"../parser/paramsParser\";\nimport type {\n AbsoluteCommand,\n HSegment,\n MSegment,\n PathArray,\n PointTuple,\n RelativeCommand,\n VSegment,\n} from \"../types\";\n\n/**\n * Split a path into an `Array` of sub-path strings.\n *\n * In the process, values are converted to absolute\n * for visual consistency.\n *\n * @param pathInput the source `pathArray`\n * @return an array with all sub-path strings\n */\nconst splitPath = (pathInput: PathArray): PathArray[] => {\n const composite = [] as PathArray[];\n let path: PathArray;\n let pi = -1;\n let x = 0;\n let y = 0;\n let mx = 0;\n let my = 0;\n const params = { ...paramsParser };\n\n pathInput.forEach((seg) => {\n const [pathCommand] = seg;\n const absCommand = pathCommand.toUpperCase() as AbsoluteCommand;\n const relCommand = pathCommand.toLowerCase() as RelativeCommand;\n const isRelative = pathCommand === relCommand;\n const values = seg.slice(1) as number[];\n\n if (absCommand === \"M\") {\n pi += 1;\n [x, y] = values as PointTuple;\n x += isRelative ? params.x : 0;\n y += isRelative ? params.y : 0;\n mx = x;\n my = y;\n path = [(isRelative ? [absCommand, mx, my] : seg) as MSegment];\n } else {\n if (absCommand === \"Z\") {\n x = mx;\n y = my;\n } else if (absCommand === \"H\") {\n [, x] = seg as HSegment;\n x += isRelative ? params.x : /* istanbul ignore next @preserve */ 0;\n } else if (absCommand === \"V\") {\n [, y] = seg as VSegment;\n y += isRelative ? params.y : /* istanbul ignore next @preserve */ 0;\n } else {\n [x, y] = seg.slice(-2) as PointTuple;\n x += isRelative ? params.x : 0;\n y += isRelative ? params.y : 0;\n }\n path.push(seg);\n }\n\n params.x = x;\n params.y = y;\n composite[pi] = path;\n });\n\n return composite;\n};\nexport default splitPath;\n","import getSVGMatrix from \"./getSVGMatrix\";\nimport projection2d from \"./projection2d\";\nimport defaultOptions from \"../options/options\";\nimport type {\n AbsoluteArray,\n AbsoluteSegment,\n CSegment,\n LSegment,\n PathArray,\n TransformObjectValues,\n} from \"../types\";\nimport type { TransformObject } from \"../interface\";\nimport iterate from \"./iterate\";\nimport parsePathString from \"../parser/parsePathString\";\nimport absolutizeSegment from \"./absolutizeSegment\";\nimport arcToCubic from \"./arcToCubic\";\n\n/**\n * Apply a 2D / 3D transformation to a `pathArray` instance.\n *\n * Since *SVGElement* doesn't support 3D transformation, this function\n * creates a 2D projection of the element.\n *\n * @param path the `pathArray` to apply transformation\n * @param transform the transform functions `Object`\n * @returns the resulted `pathArray`\n */\nconst transformPath = (\n pathInput: PathArray | string,\n transform?: Partial,\n) => {\n // last x and y transformed values\n let x = 0;\n let y = 0;\n // new x and y transformed\n let lx = 0;\n let ly = 0;\n // segment params iteration index and length\n let j = 0;\n let jj = 0;\n let pathCommand = \"M\";\n // transform uses it's own set of params\n const path = parsePathString(pathInput);\n const transformProps = transform && Object.keys(transform);\n\n // when used as a static method, invalidate somehow\n if (!transform || (transformProps && !transformProps.length)) {\n return path.slice(0) as typeof path;\n }\n\n // transform origin is extremely important\n if (!transform.origin) {\n Object.assign(transform, { origin: defaultOptions.origin });\n }\n const origin = transform.origin as [number, number, number];\n const matrixInstance = getSVGMatrix(transform as TransformObjectValues);\n\n if (matrixInstance.isIdentity) return path.slice(0) as typeof path;\n\n return iterate(path, (seg, index, lastX, lastY) => {\n [pathCommand] = seg;\n const absCommand = pathCommand.toUpperCase();\n const isRelative = absCommand !== pathCommand;\n const absoluteSegment = isRelative\n ? absolutizeSegment(seg, index, lastX, lastY)\n : (seg.slice(0) as AbsoluteSegment);\n\n let result = absCommand === \"A\"\n // ? segmentToCubic(absoluteSegment, transformParams)\n ? ([\"C\" as string | number].concat(\n arcToCubic(\n lastX,\n lastY,\n absoluteSegment[1] as number,\n absoluteSegment[2] as number,\n absoluteSegment[3] as number,\n absoluteSegment[4] as number,\n absoluteSegment[5] as number,\n absoluteSegment[6] as number,\n absoluteSegment[7] as number,\n ),\n ) as CSegment)\n : absCommand === \"V\"\n ? ([\"L\", lastX, absoluteSegment[1]] as LSegment)\n : absCommand === \"H\"\n ? ([\"L\", absoluteSegment[1], lastY] as LSegment)\n : absoluteSegment;\n\n // update pathCommand\n pathCommand = result[0];\n const isLongArc = pathCommand === \"C\" && result.length > 7;\n const tempSegment =\n (isLongArc ? result.slice(0, 7) : result.slice(0)) as AbsoluteSegment;\n\n if (isLongArc) {\n path.splice(\n index + 1,\n 0,\n [\"C\" as typeof pathCommand | number].concat(\n result.slice(7),\n ) as CSegment,\n );\n result = tempSegment as CSegment;\n }\n\n if (pathCommand === \"L\") {\n [lx, ly] = projection2d(matrixInstance, [\n (result as LSegment)[1],\n (result as LSegment)[2],\n ], origin);\n\n /* istanbul ignore else @preserve */\n if (x !== lx && y !== ly) {\n result = [\"L\", lx, ly];\n } else if (y === ly) {\n result = [\"H\", lx];\n } else if (x === lx) {\n result = [\"V\", ly];\n }\n } else {\n for (j = 1, jj = result.length; j < jj; j += 2) {\n [lx, ly] = projection2d(\n matrixInstance,\n [+result[j], +result[j + 1]],\n origin,\n );\n result[j] = lx;\n result[j + 1] = ly;\n }\n }\n // now update x and y\n x = lx;\n y = ly;\n\n return result;\n });\n};\n\nexport default transformPath;\n"],"mappings":"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","names":["src_exports","__export","defaultExport","__toCommonJS","util_exports","__export","absolutizeSegment_default","arcToCubic_default","arcTools_exports","bezier_exports","cubicTools_exports","distanceEpsilon_default","distanceSquareRoot_default","finalizeSegment_default","getClosestPoint_default","getDrawDirection_default","getPathArea_default","getPathBBox_default","getPointAtLength_default","getPropertiesAtLength_default","getPropertiesAtPoint_default","getSVGMatrix_default","getSegmentAtLength_default","getSegmentOfPoint_default","getTotalLength_default","invalidPathValue_default","isAbsoluteArray_default","isArcCommand_default","isCurveArray_default","isDigit_default","isDigitStart_default","isMoveCommand_default","isNormalizedArray_default","isPathArray_default","isPathCommand_default","isPointInStroke_default","isRelativeArray_default","isSpace_default","isValidPath_default","iterate_default","lineToCubic_default","lineTools_exports","midPoint_default","normalizePath_default","normalizeSegment_default","optimizePath_default","paramsCount_default","paramsParser_default","parsePathString_default","PathParser","pathToAbsolute_default","pathToCurve_default","pathToRelative_default","pathToString_default","polygonTools_exports","projection2d_default","quadToCubic_default","quadTools_exports","relativizeSegment_default","reverseCurve_default","reversePath_default","rotateVector_default","roundPath_default","roundSegment_default","roundTo_default","scanFlag_default","scanParam_default","scanSegment_default","segmentToCubic_default","shapeParams_default","shapeToPath_default","shapeToPathArray_default","shortenSegment_default","skipSpaces_default","splitCubic_default","splitPath_default","transformPath_default","import_dommatrix","arcTools_exports","__export","angleBetween","arcLength","arcPoint","getArcBBox","getArcLength","getArcProps","getPointAtArcLength","lineTools_exports","__export","getLineBBox","getLineLength","getPointAtLineLength","midPoint","a","b","t","ax","ay","bx","by","midPoint_default","distanceSquareRoot","a","b","distanceSquareRoot_default","getLineLength","x1","y1","x2","y2","distanceSquareRoot_default","getPointAtLineLength","distance","point","length","x","y","midPoint_default","getLineBBox","min","max","arcLength","rx","ry","theta","halfTheta","sinHalfTheta","cosHalfTheta","term1","term2","length","arcPoint","cx","cy","alpha","sin","cos","cosA","sinA","x","y","angleBetween","v0","v1","v0x","v0y","v1x","v1y","p","n","getArcProps","x1","y1","RX","RY","angle","LAF","SF","abs","sqrt","PI","xRotRad","dx","dy","transformedPoint","radiiCheck","cSquareNumerator","cSquareRootDenom","cRadicand","cCoef","transformedCenter","center","startVector","startAngle","endVector","sweepAngle","endAngle","getArcLength","getPointAtArcLength","distance","point","getPointAtLineLength","ellipseComponentX","ellipseComponentY","getArcBBox","deltaAngle","min","max","tan","atan2","tangent","angle1","angle2","angle3","angle4","xArray","yArray","xMin","xMax","yMin","yMax","angleAfterStart","pP2","angleBeforeEnd","pP3","p1","p2","p4","p3","bezier_exports","__export","CBEZIER_MINMAX_EPSILON","Cvalues","Tvalues","bezierLength","calculateBezier","computeBezier","deriveBezier","getBezierLength","minmaxC","minmaxQ","points","dpoints","p","d","c","list","j","t","order","mt","mt2","t2","a","b","derivativeFn","l","len","sum","i","curve","idx","step","v1","cp","v2","min","max","E","cp1","cp2","K","T","S","L","R","Q","cubicTools_exports","__export","getCubicBBox","getCubicLength","getPointAtCubicLength","getPointAtCubicSegmentLength","getPointAtCubicSegmentLength","x1","y1","c1x","c1y","c2x","c2y","x2","y2","t","t1","getCubicLength","getBezierLength","getPointAtCubicLength","distance","distanceIsNumber","point","currentLength","getCubicBBox","cxMinMax","minmaxC","cyMinMax","quadTools_exports","__export","getPointAtQuadLength","getPointAtQuadSegmentLength","getQuadBBox","getQuadLength","getPointAtQuadSegmentLength","x1","y1","cx","cy","x2","y2","t","t1","getQuadLength","getBezierLength","getPointAtQuadLength","distance","distanceIsNumber","point","currentLength","getQuadBBox","cxMinMax","minmaxQ","cyMinMax","polygonTools_exports","__export","polygonArea","polygonLength","polygonArea","polygon","n","i","a","b","area","polygonLength","length","point","distanceSquareRoot_default","paramsCount","paramsCount_default","finalizeSegment","path","pathCommand","relativeCommand","data","paramsCount_default","finalizeSegment_default","error","error_default","scanFlag","path","index","pathValue","code","error_default","scanFlag_default","isDigit","code","isDigit_default","invalidPathValue","invalidPathValue_default","scanParam","path","max","pathValue","start","index","zeroFirst","hasCeiling","hasDecimal","hasDot","ch","error_default","invalidPathValue_default","isDigit_default","scanParam_default","isSpace","ch","isSpace_default","skipSpaces","path","pathValue","max","isSpace_default","skipSpaces_default","isPathCommand","code","isPathCommand_default","isDigitStart","code","isDigit_default","isDigitStart_default","isArcCommand","code","isArcCommand_default","isMoveCommand","code","isMoveCommand_default","scanSegment","path","max","pathValue","index","segments","cmdCode","reqParams","paramsCount_default","isPathCommand_default","error_default","invalidPathValue_default","lastSegment","isMoveCommand_default","skipSpaces_default","finalizeSegment_default","i","isArcCommand_default","scanFlag_default","scanParam_default","isDigitStart_default","scanSegment_default","PathParser","pathString","parsePathString","pathInput","path","PathParser","skipSpaces_default","scanSegment_default","parsePathString_default","absolutizeSegment","segment","index","lastX","lastY","pathCommand","absCommand","isAbsolute","absValues","seglen","j","absolutizeSegment_default","iterate","path","iterator","pathLen","segment","pathCommand","absCommand","isRelative","x","y","mx","my","segLen","i","iteratorResult","iterate_default","pathToAbsolute","pathInput","path","parsePathString_default","iterate_default","absolutizeSegment_default","pathToAbsolute_default","relativizeSegment","segment","index","lastX","lastY","pathCommand","relCommand","isRelative","relValues","seglen","j","relativizeSegment_default","pathToRelative","pathInput","path","parsePathString_default","iterate_default","relativizeSegment_default","pathToRelative_default","rotateVector","x","y","rad","sin","cos","X","Y","rotateVector_default","arcToCubic","X1","Y1","RX","RY","angle","LAF","SF","X2","Y2","recursive","x1","y1","rx","ry","x2","y2","d120","rad","res","xy","f1","f2","cx","cy","rotateVector_default","x","y","h","rx2","ry2","k","df","f2old","x2old","y2old","c1","s1","c2","s2","t","hx","hy","m1","m2","m3","m4","newres","i","ii","arcToCubic_default","quadToCubic","x1","y1","qx","qy","x2","y2","r13","r23","quadToCubic_default","lineToCubic","x1","y1","x2","y2","c1","midPoint_default","c2","lineToCubic_default","segmentToCubic","segment","params","pathCommand","values","x","y","px1","py1","px","py","arcToCubic_default","quadToCubic_default","lineToCubic_default","segmentToCubic_default","normalizeSegment","segment","params","pathCommand","absCommand","isRelative","px1","py1","px2","py2","x","y","values","absValues","n","j","x1","y1","qx","qy","nqx","nqy","normalizeSegment_default","paramsParser","paramsParser_default","pathToCurve","pathInput","params","paramsParser_default","path","parsePathString_default","iterate_default","seg","index","lastX","lastY","normalSegment","normalizeSegment_default","result","segmentToCubic_default","seglen","pathToCurve_default","defaultOptions","options_default","roundTo","n","round","pow","roundTo_default","pathToString","path","roundOption","pathLen","round","options_default","segment","result","i","pathCommand","values","j","valLen","roundTo_default","pathToString_default","distanceEpsilon_default","normalizePath","pathInput","path","parsePathString_default","params","paramsParser_default","iterate_default","seg","_","lastX","lastY","result","normalizeSegment_default","seglen","normalizePath_default","getPointAtLength","pathInput","distance","path","normalizePath_default","isM","data","pathCommand","x","y","mx","my","distanceIsNumber","point","length","POINT","totalLength","distanceEpsilon_default","iterate_default","seg","_","lastX","lastY","getPointAtLineLength","getLineLength","getPointAtArcLength","getArcLength","getPointAtCubicLength","getCubicLength","getPointAtQuadLength","getQuadLength","getPointAtLength_default","getTotalLength","pathInput","path","parsePathString_default","paramX1","paramY1","paramX2","paramY2","paramQX","paramQY","pathCommand","mx","my","totalLength","iterate_default","seg","index","lastX","lastY","absCommand","absoluteSegment","absolutizeSegment_default","normalSegment","getLineLength","getArcLength","cp1x","cp1y","getCubicLength","getQuadLength","getTotalLength_default","getPropertiesAtLength","pathInput","distance","pathArray","parsePathString_default","pathTemp","pathLength","getTotalLength_default","index","lengthAtSegment","length","segment","segments","getPropertiesAtLength_default","getPropertiesAtPoint","pathInput","point","path","parsePathString_default","normalPath","normalizePath_default","pathLength","getTotalLength_default","distanceTo","p","dx","dy","precision","scan","closest","scanDistance","bestLength","bestDistance","scanLength","getPointAtLength_default","before","after","beforeLength","afterLength","beforeDistance","afterDistance","segment","getPropertiesAtLength_default","distance","getPropertiesAtPoint_default","getClosestPoint","pathInput","point","getPropertiesAtPoint_default","getClosestPoint_default","getCubicSegArea","x1","y1","c1x","c1y","c2x","c2y","x2","y2","getPathArea","path","x","y","len","pathToCurve_default","seg","a","b","getPathArea_default","getDrawDirection","path","getPathArea_default","pathToCurve_default","getDrawDirection_default","getPathBBox","pathInput","path","parsePathString_default","pathCommand","mx","my","max","min","xMin","yMin","xMax","yMax","minX","minY","maxX","maxY","paramX1","paramY1","paramX2","paramY2","paramQX","paramQY","iterate_default","seg","index","lastX","lastY","absCommand","absoluteSegment","absolutizeSegment_default","normalSegment","getLineBBox","getArcBBox","cp1x","cp1y","getCubicBBox","getQuadBBox","width","height","getPathBBox_default","getSegmentAtLength","pathInput","distance","getPropertiesAtLength_default","getSegmentAtLength_default","getSegmentOfPoint","path","point","getPropertiesAtPoint_default","getSegmentOfPoint_default","isPathArray","path","seg","lk","paramsCount_default","isPathArray_default","isAbsoluteArray","path","isPathArray_default","x","isAbsoluteArray_default","isNormalizedArray","path","isAbsoluteArray_default","pc","isNormalizedArray_default","isCurveArray","path","isNormalizedArray_default","pc","isCurveArray_default","isPointInStroke","pathInput","point","distance","getPropertiesAtPoint_default","distanceEpsilon_default","isPointInStroke_default","isRelativeArray","path","isPathArray_default","pc","isRelativeArray_default","isValidPath","pathString","path","PathParser","skipSpaces_default","scanSegment_default","isValidPath_default","shapeParams","shapeParams_default","isElement","node","isElement_default","getLinePath","attr","x1","y1","x2","y2","a","getPolyPath","pathArray","points","index","getCirclePath","cx","cy","r","getEllipsePath","rx","ry","getRectanglePath","x","y","w","h","shapeToPathArray","element","supportedShapes","shapeParams_default","targetIsElement","isElement_default","tagName","s","error_default","type","shapeAttrs","config","p","parsePathString_default","isPathArray_default","shapeToPathArray_default","shapeToPath","element","replace","ownerDocument","doc","supportedShapes","shapeParams_default","targetIsElement","isElement_default","tagName","error_default","s","path","type","shapeAttrs","config","round","options_default","pathArray","shapeToPathArray_default","description","pathToString_default","p","name","value","k","m","isValidPath_default","shapeToPath_default","import_dommatrix","getSVGMatrix","transform","matrix","CSSMatrix","origin","originX","originY","translate","rotate","skew","scale","x","getSVGMatrix_default","shortenSegment","segment","normalSegment","params","prevCommand","pathCommand","defaultRound","options_default","round","normalValues","x1","y1","x2","y2","x","y","nx","ny","result","roundTo_default","nx1","ny1","qx","qy","shortenSegment_default","roundSegment","segment","roundOption","values","n","roundTo_default","roundSegment_default","optimizePath","pathInput","roundOption","path","pathToAbsolute_default","round","optimParams","paramsParser_default","allPathCommands","pathCommand","prevCommand","iterate_default","seg","i","lastX","lastY","normalizedSegment","normalizeSegment_default","result","shortSegment","shortenSegment_default","absSegment","roundSegment_default","absString","relativeSegment","relativizeSegment_default","relSegment","relString","seglen","optimizePath_default","import_dommatrix","translatePoint","cssm","v","m","CSSMatrix","projection2d","point2D","origin","originX","originY","originZ","x","y","z","relativePositionX","relativePositionY","relativePositionZ","projection2d_default","reverseCurve","path","rotatedCurve","x","i","curveOnly","_","reverseCurve_default","reversePath","pathInput","absolutePath","pathToAbsolute_default","normalizedPath","normalizePath_default","pLen","isClosed","reversedPath","iterate_default","segment","normalizedSegment","prevSeg","prevCommand","nextSeg","nextCommand","pathCommand","x","y","result","reversePath_default","roundPath","path","roundOption","round","options_default","iterate_default","segment","roundSegment_default","roundPath_default","splitCubic","pts","ratio","t","p0","p1","p2","p3","p4","midPoint_default","p5","p6","p7","p8","p9","splitCubic_default","splitPath","pathInput","composite","path","pi","x","y","mx","my","params","paramsParser_default","seg","pathCommand","absCommand","relCommand","isRelative","values","splitPath_default","transformPath","pathInput","transform","x","y","lx","ly","j","jj","pathCommand","path","parsePathString_default","transformProps","options_default","origin","matrixInstance","getSVGMatrix_default","iterate_default","seg","index","lastX","lastY","absCommand","absoluteSegment","absolutizeSegment_default","result","arcToCubic_default","isLongArc","tempSegment","projection2d_default","transformPath_default","SVGPathCommander","pathValue","config","instanceOptions","undefPath","error_default","parsePathString_default","roundOption","originOption","round","options_default","origin","originX","originY","originZ","getPathBBox_default","getTotalLength_default","length","getPointAtLength_default","segments","pathToAbsolute_default","pathToRelative_default","pathToCurve_default","onlySubpath","split","splitPath_default","subPath","absoluteMultiPath","x","i","reversePath_default","path","normalizePath_default","optimizePath_default","source","cx","cy","cz","transform","k","v","transformPath_default","pathToString_default","key","defaultExport","util_exports"]} \ No newline at end of file diff --git a/dist/util/util.d.cts b/dist/svg-path-commander.d.cts similarity index 75% rename from dist/util/util.d.cts rename to dist/svg-path-commander.d.cts index 7d522ae..bd36475 100644 --- a/dist/util/util.d.cts +++ b/dist/svg-path-commander.d.cts @@ -1,5 +1,4 @@ import CSSMatrix from '@thednp/dommatrix'; -export { default as CSSMatrix } from '@thednp/dommatrix'; type SegmentProperties = { segment: PathSegment; @@ -67,6 +66,27 @@ type ShapeParams = { polyline: ["points"]; glyph: ["d"]; }; +type PathBBox = { + width: number; + height: number; + x: number; + y: number; + x2: number; + y2: number; + cx: number; + cy: number; + cz: number; +}; +type SegmentLimits = { + min: { + x: number; + y: number; + }; + max: { + x: number; + y: number; + }; +}; type ParserParams = { x1: number; y1: number; @@ -77,6 +97,31 @@ type ParserParams = { qx: number | null; qy: number | null; }; +type LengthFactory = { + length: number; + point: { + x: number; + y: number; + }; + min: { + x: number; + y: number; + }; + max: { + x: number; + y: number; + }; +}; +type Options = { + round: "off" | number; + origin: number[]; +}; +type PathTransform = { + s: PathSegment; + c: string; + x: number; + y: number; +}; type TransformObject = { translate: number | number[]; rotate: number | number[]; @@ -84,6 +129,11 @@ type TransformObject = { skew: number | number[]; origin: number[]; }; +type TransformProps = keyof TransformObject; +type TransformEntries = [ + TransformProps, + TransformObject[TransformProps] +][]; type SpaceNumber = 0x1680 | 0x180e | 0x2000 | 0x2001 | 0x2002 | 0x2003 | 0x2004 | 0x2005 | 0x2006 | 0x2007 | 0x2008 | 0x2009 | 0x200a | 0x202f | 0x205f | 0x3000 | 0xfeff | 0x0a | 0x0d | 0x2028 | 0x2029 | 0x20 | 0x09 | 0x0b | 0x0c | 0xa0 | 0x1680; type PathCommandNumber = 0x6d | 0x7a | 0x6c | 0x68 | 0x76 | 0x63 | 0x73 | 0x71 | 0x74 | 0x61; @@ -185,7 +235,10 @@ type AbsoluteArray = [MSegment, ...AbsoluteSegment[]]; type RelativeArray = [MSegment, ...RelativeSegment[]]; type NormalArray = [MSegment, ...NormalSegment[]]; type CurveArray = [MSegment, ...CSegment[]]; +type PolygonArray = [MSegment, ...LSegment[], ZSegment]; +type PolylineArray = [MSegment, ...LSegment[]]; type ShapeTypes = SVGPolylineElement | SVGPolygonElement | SVGLineElement | SVGEllipseElement | SVGCircleElement | SVGRectElement; +type ShapeTags = "line" | "polyline" | "polygon" | "ellipse" | "circle" | "rect" | "glyph"; type ShapeOps = LineAttr | PolyAttr | PolyAttr | EllipseAttr | CircleAttr | RectAttr | GlyphAttr; type TransformObjectValues = Partial & { origin: [number, number, number]; @@ -238,6 +291,18 @@ type CubicCoordinates = [ number, number ]; +type ArcCoordinates = [ + number, + number, + number, + number, + number, + number, + number, + number, + number +]; +type LineCoordinates = [number, number, number, number]; type DeriveCallback = (t: number) => Point; type IteratorCallback = (segment: PathSegment, index: number, lastX: number, lastY: number) => PathSegment | false | void | undefined; @@ -1252,4 +1317,227 @@ declare const splitPath: (pathInput: PathArray) => PathArray[]; */ declare const transformPath: (pathInput: PathArray | string, transform?: Partial) => PathArray; -export { absolutizeSegment, arcToCubic, arcTools, bezier as bezierTools, cubicTools, DISTANCE_EPSILON as distanceEpsilon, distanceSquareRoot, finalizeSegment, getClosestPoint, getDrawDirection, getPathArea, getPathBBox, getPointAtLength, getPropertiesAtLength, getPropertiesAtPoint, getSVGMatrix, getSegmentAtLength, getSegmentOfPoint, getTotalLength, invalidPathValue, isAbsoluteArray, isArcCommand, isCurveArray, isDigit, isDigitStart, isMoveCommand, isNormalizedArray, isPathArray, isPathCommand, isPointInStroke, isRelativeArray, isSpace, isValidPath, iterate, lineToCubic, lineTools, midPoint, normalizePath, normalizeSegment, optimizePath, paramsCount, paramsParser, parsePathString, PathParser as pathParser, pathToAbsolute, pathToCurve, pathToRelative, pathToString, polygonTools, projection2d, quadToCubic, quadTools, relativizeSegment, reverseCurve, reversePath, rotateVector, roundPath, roundSegment, roundTo, scanFlag, scanParam, scanSegment, segmentToCubic, shapeParams, shapeToPath, shapeToPathArray, shortenSegment, skipSpaces, splitCubic, splitPath, transformPath }; +declare const util_CSSMatrix: typeof CSSMatrix; +declare const util_absolutizeSegment: typeof absolutizeSegment; +declare const util_arcToCubic: typeof arcToCubic; +declare const util_arcTools: typeof arcTools; +declare const util_cubicTools: typeof cubicTools; +declare const util_distanceSquareRoot: typeof distanceSquareRoot; +declare const util_finalizeSegment: typeof finalizeSegment; +declare const util_getClosestPoint: typeof getClosestPoint; +declare const util_getDrawDirection: typeof getDrawDirection; +declare const util_getPathArea: typeof getPathArea; +declare const util_getPathBBox: typeof getPathBBox; +declare const util_getPointAtLength: typeof getPointAtLength; +declare const util_getPropertiesAtLength: typeof getPropertiesAtLength; +declare const util_getPropertiesAtPoint: typeof getPropertiesAtPoint; +declare const util_getSVGMatrix: typeof getSVGMatrix; +declare const util_getSegmentAtLength: typeof getSegmentAtLength; +declare const util_getSegmentOfPoint: typeof getSegmentOfPoint; +declare const util_getTotalLength: typeof getTotalLength; +declare const util_invalidPathValue: typeof invalidPathValue; +declare const util_isAbsoluteArray: typeof isAbsoluteArray; +declare const util_isArcCommand: typeof isArcCommand; +declare const util_isCurveArray: typeof isCurveArray; +declare const util_isDigit: typeof isDigit; +declare const util_isDigitStart: typeof isDigitStart; +declare const util_isMoveCommand: typeof isMoveCommand; +declare const util_isNormalizedArray: typeof isNormalizedArray; +declare const util_isPathArray: typeof isPathArray; +declare const util_isPathCommand: typeof isPathCommand; +declare const util_isPointInStroke: typeof isPointInStroke; +declare const util_isRelativeArray: typeof isRelativeArray; +declare const util_isSpace: typeof isSpace; +declare const util_isValidPath: typeof isValidPath; +declare const util_iterate: typeof iterate; +declare const util_lineToCubic: typeof lineToCubic; +declare const util_lineTools: typeof lineTools; +declare const util_midPoint: typeof midPoint; +declare const util_normalizePath: typeof normalizePath; +declare const util_normalizeSegment: typeof normalizeSegment; +declare const util_optimizePath: typeof optimizePath; +declare const util_paramsCount: typeof paramsCount; +declare const util_paramsParser: typeof paramsParser; +declare const util_parsePathString: typeof parsePathString; +declare const util_pathToAbsolute: typeof pathToAbsolute; +declare const util_pathToCurve: typeof pathToCurve; +declare const util_pathToRelative: typeof pathToRelative; +declare const util_pathToString: typeof pathToString; +declare const util_polygonTools: typeof polygonTools; +declare const util_projection2d: typeof projection2d; +declare const util_quadToCubic: typeof quadToCubic; +declare const util_quadTools: typeof quadTools; +declare const util_relativizeSegment: typeof relativizeSegment; +declare const util_reverseCurve: typeof reverseCurve; +declare const util_reversePath: typeof reversePath; +declare const util_rotateVector: typeof rotateVector; +declare const util_roundPath: typeof roundPath; +declare const util_roundSegment: typeof roundSegment; +declare const util_roundTo: typeof roundTo; +declare const util_scanFlag: typeof scanFlag; +declare const util_scanParam: typeof scanParam; +declare const util_scanSegment: typeof scanSegment; +declare const util_segmentToCubic: typeof segmentToCubic; +declare const util_shapeParams: typeof shapeParams; +declare const util_shapeToPath: typeof shapeToPath; +declare const util_shapeToPathArray: typeof shapeToPathArray; +declare const util_shortenSegment: typeof shortenSegment; +declare const util_skipSpaces: typeof skipSpaces; +declare const util_splitCubic: typeof splitCubic; +declare const util_splitPath: typeof splitPath; +declare const util_transformPath: typeof transformPath; +declare namespace util { + export { util_CSSMatrix as CSSMatrix, util_absolutizeSegment as absolutizeSegment, util_arcToCubic as arcToCubic, util_arcTools as arcTools, bezier as bezierTools, util_cubicTools as cubicTools, DISTANCE_EPSILON as distanceEpsilon, util_distanceSquareRoot as distanceSquareRoot, util_finalizeSegment as finalizeSegment, util_getClosestPoint as getClosestPoint, util_getDrawDirection as getDrawDirection, util_getPathArea as getPathArea, util_getPathBBox as getPathBBox, util_getPointAtLength as getPointAtLength, util_getPropertiesAtLength as getPropertiesAtLength, util_getPropertiesAtPoint as getPropertiesAtPoint, util_getSVGMatrix as getSVGMatrix, util_getSegmentAtLength as getSegmentAtLength, util_getSegmentOfPoint as getSegmentOfPoint, util_getTotalLength as getTotalLength, util_invalidPathValue as invalidPathValue, util_isAbsoluteArray as isAbsoluteArray, util_isArcCommand as isArcCommand, util_isCurveArray as isCurveArray, util_isDigit as isDigit, util_isDigitStart as isDigitStart, util_isMoveCommand as isMoveCommand, util_isNormalizedArray as isNormalizedArray, util_isPathArray as isPathArray, util_isPathCommand as isPathCommand, util_isPointInStroke as isPointInStroke, util_isRelativeArray as isRelativeArray, util_isSpace as isSpace, util_isValidPath as isValidPath, util_iterate as iterate, util_lineToCubic as lineToCubic, util_lineTools as lineTools, util_midPoint as midPoint, util_normalizePath as normalizePath, util_normalizeSegment as normalizeSegment, util_optimizePath as optimizePath, util_paramsCount as paramsCount, util_paramsParser as paramsParser, util_parsePathString as parsePathString, PathParser as pathParser, util_pathToAbsolute as pathToAbsolute, util_pathToCurve as pathToCurve, util_pathToRelative as pathToRelative, util_pathToString as pathToString, util_polygonTools as polygonTools, util_projection2d as projection2d, util_quadToCubic as quadToCubic, util_quadTools as quadTools, util_relativizeSegment as relativizeSegment, util_reverseCurve as reverseCurve, util_reversePath as reversePath, util_rotateVector as rotateVector, util_roundPath as roundPath, util_roundSegment as roundSegment, util_roundTo as roundTo, util_scanFlag as scanFlag, util_scanParam as scanParam, util_scanSegment as scanSegment, util_segmentToCubic as segmentToCubic, util_shapeParams as shapeParams, util_shapeToPath as shapeToPath, util_shapeToPathArray as shapeToPathArray, util_shortenSegment as shortenSegment, util_skipSpaces as skipSpaces, util_splitCubic as splitCubic, util_splitPath as splitPath, util_transformPath as transformPath }; +} + +/** + * Creates a new SVGPathCommander instance with the following properties: + * * segments: `pathArray` + * * round: number + * * origin: [number, number, number?] + * + * @class + * @author thednp + * @returns a new SVGPathCommander instance + */ +declare class SVGPathCommander { + segments: PathArray; + round: number | "off"; + origin: [number, number, number]; + /** + * @constructor + * @param pathValue the path string + * @param config instance options + */ + constructor(pathValue: string, config?: Partial); + get bbox(): { + x: number; + y: number; + width: number; + height: number; + x2: number; + y2: number; + cx: number; + cy: number; + cz: number; + }; + get length(): number; + /** + * Returns the path bounding box, equivalent to native `path.getBBox()`. + * + * @public + * @returns the pathBBox + */ + getBBox(): { + x: number; + y: number; + width: number; + height: number; + x2: number; + y2: number; + cx: number; + cy: number; + cz: number; + }; + /** + * Returns the total path length, equivalent to native `path.getTotalLength()`. + * + * @public + * @returns the path total length + */ + getTotalLength(): number; + /** + * Returns an `{x,y}` point in the path stroke at a given length, + * equivalent to the native `path.getPointAtLength()`. + * + * @public + * @param length the length + * @returns the requested point + */ + getPointAtLength(length: number): { + x: number; + y: number; + }; + /** + * Convert path to absolute values + * + * @public + */ + toAbsolute(): this; + /** + * Convert path to relative values + * + * @public + */ + toRelative(): this; + /** + * Convert path to cubic-bezier values. In addition, un-necessary `Z` + * segment is removed if previous segment extends to the `M` segment. + * + * @public + */ + toCurve(): this; + /** + * Reverse the order of the segments and their values. + * + * @param onlySubpath option to reverse all sub-paths except first + * @public + */ + reverse(onlySubpath?: boolean): this; + /** + * Normalize path in 2 steps: + * * convert `pathArray`(s) to absolute values + * * convert shorthand notation to standard notation + * + * @public + */ + normalize(): this; + /** + * Optimize `pathArray` values: + * * convert segments to absolute and/or relative values + * * select segments with shortest resulted string + * * round values to the specified `decimals` option value + * + * @public + */ + optimize(): this; + /** + * Transform path using values from an `Object` defined as `transformObject`. + * + * @see TransformObject for a quick refference + * + * @param source a `transformObject`as described above + * @public + */ + transform(source?: Partial): this; + /** + * Rotate path 180deg vertically + * + * @public + */ + flipX(): this; + /** + * Rotate path 180deg horizontally + * + * @public + */ + flipY(): this; + /** + * Export the current path to be used + * for the `d` (description) attribute. + * + * @public + * @return the path string + */ + toString(): string; + /** + * Remove the instance. + * + * @public + * @return void + */ + dispose(): void; +} +declare const defaultExport: typeof SVGPathCommander & typeof util; + +export { type ACommand, type ASegment, type AbsoluteArray, type AbsoluteCommand, type AbsoluteSegment, type ArcCoordinates, type ArcSegment, type CCommand, type CSegment, type CircleAttr, type CloseSegment, type CubicCoordinates, type CubicPoints, type CubicSegment, type CurveArray, type DeriveCallback, type DerivedCubicPoints, type DerivedPoint, type DerivedQuadPoints, type DigitNumber, type EllipseAttr, type GlyphAttr, type HCommand, type HSegment, type HorLineSegment, type IteratorCallback, type LCommand, type LSegment, type LengthFactory, type LineAttr, type LineCoordinates, type LineSegment, type MCommand, type MSegment, type MoveSegment, type NormalArray, type NormalSegment, type Options, type ParserParams, type PathArray, type PathBBox, type PathCommand, type PathCommandNumber, type PathSegment, type PathTransform, type Point, type PointProperties, type PointTuple, type PolyAttr, type PolygonArray, type PolylineArray, type QCommand, type QSegment, type QuadCoordinates, type QuadPoints, type QuadSegment, type RectAttr, type RelativeArray, type RelativeCommand, type RelativeSegment, type SCommand, type SSegment, type SegmentLimits, type SegmentProperties, type ShapeOps, type ShapeParams, type ShapeTags, type ShapeTypes, type ShortCubicSegment, type ShortQuadSegment, type ShortSegment, type SpaceNumber, type TCommand, type TSegment, type TransformEntries, type TransformObject, type TransformObjectValues, type TransformProps, type VCommand, type VSegment, type VertLineSegment, type ZCommand, type ZSegment, type aCommand, type aSegment, type cCommand, type cSegment, defaultExport as default, type hCommand, type hSegment, type lCommand, type lSegment, type mCommand, type mSegment, type qCommand, type qSegment, type sCommand, type sSegment, type tCommand, type tSegment, type vCommand, type vSegment, type zCommand, type zSegment }; diff --git a/dist/svg-path-commander.d.ts b/dist/svg-path-commander.d.ts index b8bd113..bd36475 100644 --- a/dist/svg-path-commander.d.ts +++ b/dist/svg-path-commander.d.ts @@ -1,882 +1,1543 @@ -import * as arcTools from './math/arcTools'; -import * as bezierTools from './math/bezier'; -import * as cubicTools from './math/cubicTools'; -import { default as default_10 } from './math/roundTo'; -import { default as default_11 } from './parser/parsePathString'; -import { default as default_12 } from './parser/finalizeSegment'; -import { default as default_13 } from './parser/invalidPathValue'; -import { default as default_14 } from './parser/isArcCommand'; -import { default as default_15 } from './parser/isDigit'; -import { default as default_16 } from './parser/isDigitStart'; -import { default as default_17 } from './parser/isMoveCommand'; -import { default as default_18 } from './parser/isPathCommand'; -import { default as default_19 } from './parser/isSpace'; -import { default as default_2 } from '@thednp/dommatrix'; -import { default as default_20 } from './parser/paramsCount'; -import { default as default_21 } from './parser/paramsParser'; -import { default as default_22 } from './parser/pathParser'; -import { default as default_23 } from './parser/scanFlag'; -import { default as default_24 } from './parser/scanParam'; -import { default as default_25 } from './parser/scanSegment'; -import { default as default_26 } from './parser/skipSpaces'; -import { default as default_27 } from './util/distanceEpsilon'; -import { default as default_28 } from './util/getClosestPoint'; -import { default as default_29 } from './util/getDrawDirection'; -import { default as default_3 } from './convert/pathToAbsolute'; -import { default as default_30 } from './util/getPathArea'; -import { default as default_31 } from './util/getPathBBox'; -import { default as default_32 } from './util/getPointAtLength'; -import { default as default_33 } from './util/getPropertiesAtLength'; -import { default as default_34 } from './util/getPropertiesAtPoint'; -import { default as default_35 } from './util/getSegmentAtLength'; -import { default as default_36 } from './util/getSegmentOfPoint'; -import { default as default_37 } from './util/getTotalLength'; -import { default as default_38 } from './util/isAbsoluteArray'; -import { default as default_39 } from './util/isCurveArray'; -import { default as default_4 } from './convert/pathToRelative'; -import { default as default_40 } from './util/isNormalizedArray'; -import { default as default_41 } from './util/isPathArray'; -import { default as default_42 } from './util/isPointInStroke'; -import { default as default_43 } from './util/isRelativeArray'; -import { default as default_44 } from './util/isValidPath'; -import { default as default_45 } from './util/shapeParams'; -import { default as default_46 } from './util/shapeToPath'; -import { default as default_47 } from './util/shapeToPathArray'; -import { default as default_48 } from './process/absolutizeSegment'; -import { default as default_49 } from './process/arcToCubic'; -import { default as default_5 } from './convert/pathToCurve'; -import { default as default_50 } from './process/getSVGMatrix'; -import { default as default_51 } from './process/iterate'; -import { default as default_52 } from './process/lineToCubic'; -import { default as default_53 } from './process/normalizePath'; -import { default as default_54 } from './process/normalizeSegment'; -import { default as default_55 } from './process/optimizePath'; -import { default as default_56 } from './process/projection2d'; -import { default as default_57 } from './process/quadToCubic'; -import { default as default_58 } from './process/relativizeSegment'; -import { default as default_59 } from './process/reverseCurve'; -import { default as default_6 } from './convert/pathToString'; -import { default as default_60 } from './process/reversePath'; -import { default as default_61 } from './process/roundPath'; -import { default as default_62 } from './process/roundSegment'; -import { default as default_63 } from './process/segmentToCubic'; -import { default as default_64 } from './process/shortenSegment'; -import { default as default_65 } from './process/splitCubic'; -import { default as default_66 } from './process/splitPath'; -import { default as default_67 } from './process/transformPath'; -import { default as default_7 } from './math/distanceSquareRoot'; -import { default as default_8 } from './math/midPoint'; -import { default as default_9 } from './math/rotateVector'; -import * as lineTools from './math/lineTools'; -import * as polygonTools from './math/polygonTools'; -import * as quadTools from './math/quadTools'; - -export declare type AbsoluteArray = [MSegment, ...AbsoluteSegment[]]; - -export declare type AbsoluteCommand = MCommand | LCommand | VCommand | HCommand | ZCommand | CCommand | SCommand | QCommand | TCommand | ACommand; - -export declare type AbsoluteSegment = MSegment | LSegment | VSegment | HSegment | CSegment | SSegment | QSegment | TSegment | ASegment | ZSegment; - -export declare type ACommand = "A"; - -export declare type aCommand = "a"; - -export declare type ArcCoordinates = [ -number, -number, -number, -number, -number, -number, -number, -number, -number -]; - -export declare type ArcSegment = ASegment | aSegment; - -export declare type ASegment = [ -ACommand, -number, -number, -number, -number, -number, -number, -number -]; - -export declare type aSegment = [ -aCommand, -number, -number, -number, -number, -number, -number, -number -]; - -export declare type CCommand = "C"; - -export declare type cCommand = "c"; - -export declare type CircleAttr = { - type: "circle"; - cx: number; - cy: number; - r: number; - [key: string]: string | number; -}; - -export declare type CloseSegment = ZSegment | zSegment; - -export declare type CSegment = [ -CCommand, -number, -number, -number, -number, -number, -number -]; - -export declare type cSegment = [ -cCommand, -number, -number, -number, -number, -number, -number -]; - -export declare type CubicCoordinates = [ -number, -number, -number, -number, -number, -number, -number, -number -]; - -export declare type CubicPoints = [ -Point, -Point, -Point, -Point, -Point, -Point, -Point, -Point -]; - -export declare type CubicSegment = CSegment | cSegment; - -export declare type CurveArray = [MSegment, ...CSegment[]]; - -declare const defaultExport: typeof SVGPathCommander & typeof util; -export default defaultExport; - -export declare type DeriveCallback = (t: number) => Point; - -export declare type DerivedCubicPoints = [ -DerivedPoint, -DerivedPoint, -DerivedPoint, -DerivedPoint, -DerivedPoint, -DerivedPoint, -DerivedPoint, -DerivedPoint -]; - -export declare type DerivedPoint = Point & { - t: number; -}; - -export declare type DerivedQuadPoints = [ -DerivedPoint, -DerivedPoint, -DerivedPoint, -DerivedPoint, -DerivedPoint, -DerivedPoint -]; - -export declare type DigitNumber = 0x30 | 0x31 | 0x32 | 0x33 | 0x34 | 0x35 | 0x36 | 0x37 | 0x38 | 0x39; - -export declare type EllipseAttr = { - type: "ellipse"; - cx: number; - cy: number; - rx: number; - ry?: number; - [key: string]: string | number | undefined; -}; - -export declare type GlyphAttr = { - type: "glyph"; - d: string; - [key: string]: string | number; -}; - -export declare type HCommand = "H"; - -export declare type hCommand = "h"; - -export declare type HorLineSegment = HSegment | hSegment; - -export declare type HSegment = [HCommand, number]; - -export declare type hSegment = [hCommand, number]; - -export declare type IteratorCallback = (segment: PathSegment, index: number, lastX: number, lastY: number) => PathSegment | false | void | undefined; - -export declare type LCommand = "L"; - -export declare type lCommand = "l"; - -export declare type LengthFactory = { - length: number; - point: { - x: number; - y: number; - }; - min: { - x: number; - y: number; - }; - max: { - x: number; - y: number; - }; -}; - -export declare type LineAttr = { - type: "line"; - x1: number; - y1: number; - x2: number; - y2: number; - [key: string]: string | number; -}; - -export declare type LineCoordinates = [number, number, number, number]; - -export declare type LineSegment = LSegment | lSegment; - -export declare type LSegment = [LCommand, number, number]; - -export declare type lSegment = [lCommand, number, number]; - -export declare type MCommand = "M"; - -export declare type mCommand = "m"; - -export declare type MoveSegment = MSegment | mSegment; - -export declare type MSegment = [MCommand, number, number]; - -export declare type mSegment = [mCommand, number, number]; - -export declare type NormalArray = [MSegment, ...NormalSegment[]]; - -export declare type NormalSegment = MSegment | LSegment | CSegment | QSegment | ASegment | ZSegment; - -export declare type Options = { - round: "off" | number; - origin: number[]; -}; - -export declare type ParserParams = { - x1: number; - y1: number; - x2: number; - y2: number; - x: number; - y: number; - qx: number | null; - qy: number | null; -}; - -export declare type PathArray = [MSegment | mSegment, ...PathSegment[]]; - -export declare type PathBBox = { - width: number; - height: number; - x: number; - y: number; - x2: number; - y2: number; - cx: number; - cy: number; - cz: number; -}; - -export declare type PathCommand = AbsoluteCommand | RelativeCommand; - -export declare type PathCommandNumber = 0x6d | 0x7a | 0x6c | 0x68 | 0x76 | 0x63 | 0x73 | 0x71 | 0x74 | 0x61; - -export declare type PathSegment = MoveSegment | LineSegment | VertLineSegment | HorLineSegment | CloseSegment | CubicSegment | ShortCubicSegment | QuadSegment | ShortQuadSegment | ArcSegment; - -export declare type PathTransform = { - s: PathSegment; - c: string; - x: number; - y: number; -}; - -export declare type Point = { - x: number; - y: number; -}; - -export declare type PointProperties = { - closest: { - x: number; - y: number; - }; - distance: number; - segment?: SegmentProperties; -}; - -export declare type PointTuple = [number, number]; - -export declare type PolyAttr = { - type: "polygon" | "polyline"; - points: string; - [key: string]: string | number; -}; - -export declare type PolygonArray = [MSegment, ...LSegment[], ZSegment]; - -export declare type PolylineArray = [MSegment, ...LSegment[]]; - -export declare type QCommand = "Q"; - -export declare type qCommand = "q"; - -export declare type QSegment = [QCommand, number, number, number, number]; - -export declare type qSegment = [qCommand, number, number, number, number]; - -export declare type QuadCoordinates = [number, number, number, number, number, number]; - -export declare type QuadPoints = [Point, Point, Point, Point, Point, Point]; - -export declare type QuadSegment = QSegment | qSegment; - -export declare type RectAttr = { - type: "rect"; - width: number; - height: number; - x: number; - y: number; - rx?: number; - ry?: number; - [key: string]: string | number | undefined; -}; - -export declare type RelativeArray = [MSegment, ...RelativeSegment[]]; - -export declare type RelativeCommand = mCommand | lCommand | vCommand | hCommand | zCommand | cCommand | sCommand | qCommand | tCommand | aCommand; - -export declare type RelativeSegment = mSegment | lSegment | vSegment | hSegment | cSegment | sSegment | qSegment | tSegment | aSegment | zSegment; - -export declare type SCommand = "S"; - -export declare type sCommand = "s"; - -export declare type SegmentLimits = { - min: { - x: number; - y: number; - }; - max: { - x: number; - y: number; - }; -}; - -export declare type SegmentProperties = { - segment: PathSegment; - index: number; - length: number; - lengthAtSegment: number; -}; - -export declare type ShapeOps = LineAttr | PolyAttr | PolyAttr | EllipseAttr | CircleAttr | RectAttr | GlyphAttr; - -export declare type ShapeParams = { - line: ["x1", "y1", "x2", "y2"]; - circle: ["cx", "cy", "r"]; - ellipse: ["cx", "cy", "rx", "ry"]; - rect: ["width", "height", "x", "y", "rx", "ry"]; - polygon: ["points"]; - polyline: ["points"]; - glyph: ["d"]; -}; - -export declare type ShapeTags = "line" | "polyline" | "polygon" | "ellipse" | "circle" | "rect" | "glyph"; - -export declare type ShapeTypes = SVGPolylineElement | SVGPolygonElement | SVGLineElement | SVGEllipseElement | SVGCircleElement | SVGRectElement; - -export declare type ShortCubicSegment = SSegment | sSegment; - -export declare type ShortQuadSegment = TSegment | tSegment; - -export declare type ShortSegment = VertLineSegment | HorLineSegment | ShortCubicSegment | ShortQuadSegment | CloseSegment; - -export declare type SpaceNumber = 0x1680 | 0x180e | 0x2000 | 0x2001 | 0x2002 | 0x2003 | 0x2004 | 0x2005 | 0x2006 | 0x2007 | 0x2008 | 0x2009 | 0x200a | 0x202f | 0x205f | 0x3000 | 0xfeff | 0x0a | 0x0d | 0x2028 | 0x2029 | 0x20 | 0x09 | 0x0b | 0x0c | 0xa0 | 0x1680; - -export declare type SSegment = [SCommand, number, number, number, number]; - -export declare type sSegment = [sCommand, number, number, number, number]; - -/** - * Creates a new SVGPathCommander instance with the following properties: - * * segments: `pathArray` - * * round: number - * * origin: [number, number, number?] - * - * @class - * @author thednp - * @returns a new SVGPathCommander instance - */ -declare class SVGPathCommander { - segments: PathArray; - round: number | "off"; - origin: [number, number, number]; - /** - * @constructor - * @param pathValue the path string - * @param config instance options - */ - constructor(pathValue: string, config?: Partial); - get bbox(): { - x: number; - y: number; - width: number; - height: number; - x2: number; - y2: number; - cx: number; - cy: number; - cz: number; - }; - get length(): number; - /** - * Returns the path bounding box, equivalent to native `path.getBBox()`. - * - * @public - * @returns the pathBBox - */ - getBBox(): { - x: number; - y: number; - width: number; - height: number; - x2: number; - y2: number; - cx: number; - cy: number; - cz: number; - }; - /** - * Returns the total path length, equivalent to native `path.getTotalLength()`. - * - * @public - * @returns the path total length - */ - getTotalLength(): number; - /** - * Returns an `{x,y}` point in the path stroke at a given length, - * equivalent to the native `path.getPointAtLength()`. - * - * @public - * @param length the length - * @returns the requested point - */ - getPointAtLength(length: number): { - x: number; - y: number; - }; - /** - * Convert path to absolute values - * - * @public - */ - toAbsolute(): this; - /** - * Convert path to relative values - * - * @public - */ - toRelative(): this; - /** - * Convert path to cubic-bezier values. In addition, un-necessary `Z` - * segment is removed if previous segment extends to the `M` segment. - * - * @public - */ - toCurve(): this; - /** - * Reverse the order of the segments and their values. - * - * @param onlySubpath option to reverse all sub-paths except first - * @public - */ - reverse(onlySubpath?: boolean): this; - /** - * Normalize path in 2 steps: - * * convert `pathArray`(s) to absolute values - * * convert shorthand notation to standard notation - * - * @public - */ - normalize(): this; - /** - * Optimize `pathArray` values: - * * convert segments to absolute and/or relative values - * * select segments with shortest resulted string - * * round values to the specified `decimals` option value - * - * @public - */ - optimize(): this; - /** - * Transform path using values from an `Object` defined as `transformObject`. - * - * @see TransformObject for a quick refference - * - * @param source a `transformObject`as described above - * @public - */ - transform(source?: Partial): this; - /** - * Rotate path 180deg vertically - * - * @public - */ - flipX(): this; - /** - * Rotate path 180deg horizontally - * - * @public - */ - flipY(): this; - /** - * Export the current path to be used - * for the `d` (description) attribute. - * - * @public - * @return the path string - */ - toString(): string; - /** - * Remove the instance. - * - * @public - * @return void - */ - dispose(): void; -} - -export declare type TCommand = "T"; - -export declare type tCommand = "t"; - -export declare type TransformEntries = [ -TransformProps, -TransformObject[TransformProps] -][]; - -export declare type TransformObject = { - translate: number | number[]; - rotate: number | number[]; - scale: number | number[]; - skew: number | number[]; - origin: number[]; -}; - -export declare type TransformObjectValues = Partial & { - origin: [number, number, number]; -}; - -export declare type TransformProps = keyof TransformObject; - -export declare type TSegment = [TCommand, number, number]; - -export declare type tSegment = [tCommand, number, number]; - -declare namespace util { - export { - default_2 as CSSMatrix, - arcTools, - bezierTools, - cubicTools, - lineTools, - quadTools, - polygonTools, - default_3 as pathToAbsolute, - default_4 as pathToRelative, - default_5 as pathToCurve, - default_6 as pathToString, - default_7 as distanceSquareRoot, - default_8 as midPoint, - default_9 as rotateVector, - default_10 as roundTo, - default_11 as parsePathString, - default_12 as finalizeSegment, - default_13 as invalidPathValue, - default_14 as isArcCommand, - default_15 as isDigit, - default_16 as isDigitStart, - default_17 as isMoveCommand, - default_18 as isPathCommand, - default_19 as isSpace, - default_20 as paramsCount, - default_21 as paramsParser, - default_22 as pathParser, - default_23 as scanFlag, - default_24 as scanParam, - default_25 as scanSegment, - default_26 as skipSpaces, - default_27 as distanceEpsilon, - default_28 as getClosestPoint, - default_29 as getDrawDirection, - default_30 as getPathArea, - default_31 as getPathBBox, - default_32 as getPointAtLength, - default_33 as getPropertiesAtLength, - default_34 as getPropertiesAtPoint, - default_35 as getSegmentAtLength, - default_36 as getSegmentOfPoint, - default_37 as getTotalLength, - default_38 as isAbsoluteArray, - default_39 as isCurveArray, - default_40 as isNormalizedArray, - default_41 as isPathArray, - default_42 as isPointInStroke, - default_43 as isRelativeArray, - default_44 as isValidPath, - default_45 as shapeParams, - default_46 as shapeToPath, - default_47 as shapeToPathArray, - default_48 as absolutizeSegment, - default_49 as arcToCubic, - default_50 as getSVGMatrix, - default_51 as iterate, - default_52 as lineToCubic, - default_53 as normalizePath, - default_54 as normalizeSegment, - default_55 as optimizePath, - default_56 as projection2d, - default_57 as quadToCubic, - default_58 as relativizeSegment, - default_59 as reverseCurve, - default_60 as reversePath, - default_61 as roundPath, - default_62 as roundSegment, - default_63 as segmentToCubic, - default_64 as shortenSegment, - default_65 as splitCubic, - default_66 as splitPath, - default_67 as transformPath - } -} - -export declare type VCommand = "V"; - -export declare type vCommand = "v"; - -export declare type VertLineSegment = vSegment | VSegment; - -export declare type VSegment = [VCommand, number]; - -export declare type vSegment = [vCommand, number]; - -export declare type ZCommand = "Z"; - -export declare type zCommand = "z"; - -export declare type ZSegment = [ZCommand]; - -export declare type zSegment = [zCommand]; - -export { } - - -declare namespace shapes { - let initial: string[]; - let normalized: string[]; - let optimized: string[]; - let relative: string[]; - let absolute: string[]; - let curve: string[]; - let scaled: string[]; - let translated: string[]; - let length: number[]; - let pointAt50: { - x: number; - y: number; - }[]; -} - +import CSSMatrix from '@thednp/dommatrix'; -declare namespace simpleShapes { - let initial: string[]; - let normalized: string[]; - let transformed: string[]; - let scaled3d: string[]; - let skewedX: string[]; - let skewedY: string[]; - let reversed: string[]; - let length: number[]; - let width: number[]; - let height: number[]; - let pointAt0: { +type SegmentProperties = { + segment: PathSegment; + index: number; + length: number; + lengthAtSegment: number; +}; +type PointProperties = { + closest: { x: number; y: number; - }[]; - let pointAt400: { + }; + distance: number; + segment?: SegmentProperties; +}; +type LineAttr = { + type: "line"; + x1: number; + y1: number; + x2: number; + y2: number; + [key: string]: string | number; +}; +type PolyAttr = { + type: "polygon" | "polyline"; + points: string; + [key: string]: string | number; +}; +type CircleAttr = { + type: "circle"; + cx: number; + cy: number; + r: number; + [key: string]: string | number; +}; +type EllipseAttr = { + type: "ellipse"; + cx: number; + cy: number; + rx: number; + ry?: number; + [key: string]: string | number | undefined; +}; +type RectAttr = { + type: "rect"; + width: number; + height: number; + x: number; + y: number; + rx?: number; + ry?: number; + [key: string]: string | number | undefined; +}; +type GlyphAttr = { + type: "glyph"; + d: string; + [key: string]: string | number; +}; +type ShapeParams = { + line: ["x1", "y1", "x2", "y2"]; + circle: ["cx", "cy", "r"]; + ellipse: ["cx", "cy", "rx", "ry"]; + rect: ["width", "height", "x", "y", "rx", "ry"]; + polygon: ["points"]; + polyline: ["points"]; + glyph: ["d"]; +}; +type PathBBox = { + width: number; + height: number; + x: number; + y: number; + x2: number; + y2: number; + cx: number; + cy: number; + cz: number; +}; +type SegmentLimits = { + min: { x: number; y: number; - }[]; - let pointAt50: { + }; + max: { x: number; y: number; - }[]; -} - - -declare namespace shapes { - let initial: string[]; - let normalized: string[]; - let optimized: string[]; - let relative: string[]; - let absolute: string[]; - let curve: string[]; - let scaled: string[]; - let translated: string[]; - let length: number[]; - let pointAt50: { + }; +}; +type ParserParams = { + x1: number; + y1: number; + x2: number; + y2: number; + x: number; + y: number; + qx: number | null; + qy: number | null; +}; +type LengthFactory = { + length: number; + point: { x: number; y: number; - }[]; -} - - -declare namespace simpleShapes { - let initial: string[]; - let normalized: string[]; - let transformed: string[]; - let scaled3d: string[]; - let skewedX: string[]; - let skewedY: string[]; - let reversed: string[]; - let length: number[]; - let width: number[]; - let height: number[]; - let pointAt0: { + }; + min: { x: number; y: number; - }[]; - let pointAt400: { + }; + max: { x: number; y: number; - }[]; - let pointAt50: { + }; +}; +type Options = { + round: "off" | number; + origin: number[]; +}; +type PathTransform = { + s: PathSegment; + c: string; + x: number; + y: number; +}; +type TransformObject = { + translate: number | number[]; + rotate: number | number[]; + scale: number | number[]; + skew: number | number[]; + origin: number[]; +}; +type TransformProps = keyof TransformObject; +type TransformEntries = [ + TransformProps, + TransformObject[TransformProps] +][]; + +type SpaceNumber = 0x1680 | 0x180e | 0x2000 | 0x2001 | 0x2002 | 0x2003 | 0x2004 | 0x2005 | 0x2006 | 0x2007 | 0x2008 | 0x2009 | 0x200a | 0x202f | 0x205f | 0x3000 | 0xfeff | 0x0a | 0x0d | 0x2028 | 0x2029 | 0x20 | 0x09 | 0x0b | 0x0c | 0xa0 | 0x1680; +type PathCommandNumber = 0x6d | 0x7a | 0x6c | 0x68 | 0x76 | 0x63 | 0x73 | 0x71 | 0x74 | 0x61; +type DigitNumber = 0x30 | 0x31 | 0x32 | 0x33 | 0x34 | 0x35 | 0x36 | 0x37 | 0x38 | 0x39; +type MCommand = "M"; +type mCommand = "m"; +type LCommand = "L"; +type lCommand = "l"; +type VCommand = "V"; +type vCommand = "v"; +type HCommand = "H"; +type hCommand = "h"; +type ZCommand = "Z"; +type zCommand = "z"; +type CCommand = "C"; +type cCommand = "c"; +type SCommand = "S"; +type sCommand = "s"; +type QCommand = "Q"; +type qCommand = "q"; +type TCommand = "T"; +type tCommand = "t"; +type ACommand = "A"; +type aCommand = "a"; +type AbsoluteCommand = MCommand | LCommand | VCommand | HCommand | ZCommand | CCommand | SCommand | QCommand | TCommand | ACommand; +type RelativeCommand = mCommand | lCommand | vCommand | hCommand | zCommand | cCommand | sCommand | qCommand | tCommand | aCommand; +type PathCommand = AbsoluteCommand | RelativeCommand; +type MSegment = [MCommand, number, number]; +type mSegment = [mCommand, number, number]; +type MoveSegment = MSegment | mSegment; +type LSegment = [LCommand, number, number]; +type lSegment = [lCommand, number, number]; +type LineSegment = LSegment | lSegment; +type VSegment = [VCommand, number]; +type vSegment = [vCommand, number]; +type VertLineSegment = vSegment | VSegment; +type HSegment = [HCommand, number]; +type hSegment = [hCommand, number]; +type HorLineSegment = HSegment | hSegment; +type ZSegment = [ZCommand]; +type zSegment = [zCommand]; +type CloseSegment = ZSegment | zSegment; +type CSegment = [ + CCommand, + number, + number, + number, + number, + number, + number +]; +type cSegment = [ + cCommand, + number, + number, + number, + number, + number, + number +]; +type CubicSegment = CSegment | cSegment; +type SSegment = [SCommand, number, number, number, number]; +type sSegment = [sCommand, number, number, number, number]; +type ShortCubicSegment = SSegment | sSegment; +type QSegment = [QCommand, number, number, number, number]; +type qSegment = [qCommand, number, number, number, number]; +type QuadSegment = QSegment | qSegment; +type TSegment = [TCommand, number, number]; +type tSegment = [tCommand, number, number]; +type ShortQuadSegment = TSegment | tSegment; +type ASegment = [ + ACommand, + number, + number, + number, + number, + number, + number, + number +]; +type aSegment = [ + aCommand, + number, + number, + number, + number, + number, + number, + number +]; +type ArcSegment = ASegment | aSegment; +type PathSegment = MoveSegment | LineSegment | VertLineSegment | HorLineSegment | CloseSegment | CubicSegment | ShortCubicSegment | QuadSegment | ShortQuadSegment | ArcSegment; +type ShortSegment = VertLineSegment | HorLineSegment | ShortCubicSegment | ShortQuadSegment | CloseSegment; +type AbsoluteSegment = MSegment | LSegment | VSegment | HSegment | CSegment | SSegment | QSegment | TSegment | ASegment | ZSegment; +type RelativeSegment = mSegment | lSegment | vSegment | hSegment | cSegment | sSegment | qSegment | tSegment | aSegment | zSegment; +type NormalSegment = MSegment | LSegment | CSegment | QSegment | ASegment | ZSegment; +type PathArray = [MSegment | mSegment, ...PathSegment[]]; +type AbsoluteArray = [MSegment, ...AbsoluteSegment[]]; +type RelativeArray = [MSegment, ...RelativeSegment[]]; +type NormalArray = [MSegment, ...NormalSegment[]]; +type CurveArray = [MSegment, ...CSegment[]]; +type PolygonArray = [MSegment, ...LSegment[], ZSegment]; +type PolylineArray = [MSegment, ...LSegment[]]; +type ShapeTypes = SVGPolylineElement | SVGPolygonElement | SVGLineElement | SVGEllipseElement | SVGCircleElement | SVGRectElement; +type ShapeTags = "line" | "polyline" | "polygon" | "ellipse" | "circle" | "rect" | "glyph"; +type ShapeOps = LineAttr | PolyAttr | PolyAttr | EllipseAttr | CircleAttr | RectAttr | GlyphAttr; +type TransformObjectValues = Partial & { + origin: [number, number, number]; +}; +type Point = { + x: number; + y: number; +}; +type PointTuple = [number, number]; +type DerivedPoint = Point & { + t: number; +}; +type QuadPoints = [Point, Point, Point, Point, Point, Point]; +type CubicPoints = [ + Point, + Point, + Point, + Point, + Point, + Point, + Point, + Point +]; +type DerivedQuadPoints = [ + DerivedPoint, + DerivedPoint, + DerivedPoint, + DerivedPoint, + DerivedPoint, + DerivedPoint +]; +type DerivedCubicPoints = [ + DerivedPoint, + DerivedPoint, + DerivedPoint, + DerivedPoint, + DerivedPoint, + DerivedPoint, + DerivedPoint, + DerivedPoint +]; +type QuadCoordinates = [number, number, number, number, number, number]; +type CubicCoordinates = [ + number, + number, + number, + number, + number, + number, + number, + number +]; +type ArcCoordinates = [ + number, + number, + number, + number, + number, + number, + number, + number, + number +]; +type LineCoordinates = [number, number, number, number]; +type DeriveCallback = (t: number) => Point; +type IteratorCallback = (segment: PathSegment, index: number, lastX: number, lastY: number) => PathSegment | false | void | undefined; + +/** + * Returns the Arc segment length. + * @param rx radius along X axis + * @param ry radius along Y axis + * @param theta the angle in radians + * @returns the arc length + */ +declare const arcLength: (rx: number, ry: number, theta: number) => number; +/** + * Find point on ellipse at given angle around ellipse (theta); + * @param cx the center X + * @param cy the center Y + * @param rx the radius X + * @param ry the radius Y + * @param alpha the arc rotation angle in radians + * @param theta the arc sweep angle in radians + * @returns a point around ellipse at given angle + */ +declare const arcPoint: (cx: number, cy: number, rx: number, ry: number, alpha: number, theta: number) => PointTuple; +/** + * Returns the angle between two points. + * @param v0 starting point + * @param v1 ending point + * @returns the angle in radian + */ +declare const angleBetween: (v0: Point, v1: Point) => number; +/** + * Returns the following properties for an Arc segment: center, start angle, + * end angle, and radiuses on X and Y axis. + * + * @param x1 the starting point X + * @param y1 the starting point Y + * @param RX the radius on X axis + * @param RY the radius on Y axis + * @param angle the ellipse rotation in degrees + * @param LAF the large arc flag + * @param SF the sweep flag + * @param x2 the ending point X + * @param y2 the ending point Y + * @returns properties specific to Arc segments + */ +declare const getArcProps: (x1: number, y1: number, RX: number, RY: number, angle: number, LAF: number, SF: number, x: number, y: number) => { + rx: number; + ry: number; + startAngle: number; + endAngle: number; + center: { x: number; y: number; - }[]; + }; +}; +/** + * Returns the length of an Arc segment. + * + * @param x1 the starting point X + * @param y1 the starting point Y + * @param c1x the first control point X + * @param c1y the first control point Y + * @param c2x the second control point X + * @param c2y the second control point Y + * @param x2 the ending point X + * @param y2 the ending point Y + * @returns the length of the Arc segment + */ +declare const getArcLength: (x1: number, y1: number, RX: number, RY: number, angle: number, LAF: number, SF: number, x: number, y: number) => number; +/** + * Returns a point along an Arc segment at a given distance. + * + * @param x1 the starting point X + * @param y1 the starting point Y + * @param RX the radius on X axis + * @param RY the radius on Y axis + * @param angle the ellipse rotation in degrees + * @param LAF the large arc flag + * @param SF the sweep flag + * @param x2 the ending point X + * @param y2 the ending point Y + * @param distance a [0-1] ratio + * @returns a point along the Arc segment + */ +declare const getPointAtArcLength: (x1: number, y1: number, RX: number, RY: number, angle: number, LAF: number, SF: number, x: number, y: number, distance?: number) => { + x: number; + y: number; +}; +/** + * Returns the extrema for an Arc segment in the following format: + * [MIN_X, MIN_Y, MAX_X, MAX_Y] + * + * @see https://github.com/herrstrietzel/svg-pathdata-getbbox + * + * @param x1 the starting point X + * @param y1 the starting point Y + * @param RX the radius on X axis + * @param RY the radius on Y axis + * @param angle the ellipse rotation in degrees + * @param LAF the large arc flag + * @param SF the sweep flag + * @param x2 the ending point X + * @param y2 the ending point Y + * @returns the extrema of the Arc segment + */ +declare const getArcBBox: (x1: number, y1: number, RX: number, RY: number, angle: number, LAF: number, SF: number, x: number, y: number) => [number, number, number, number]; + +declare const arcTools_angleBetween: typeof angleBetween; +declare const arcTools_arcLength: typeof arcLength; +declare const arcTools_arcPoint: typeof arcPoint; +declare const arcTools_getArcBBox: typeof getArcBBox; +declare const arcTools_getArcLength: typeof getArcLength; +declare const arcTools_getArcProps: typeof getArcProps; +declare const arcTools_getPointAtArcLength: typeof getPointAtArcLength; +declare namespace arcTools { + export { arcTools_angleBetween as angleBetween, arcTools_arcLength as arcLength, arcTools_arcPoint as arcPoint, arcTools_getArcBBox as getArcBBox, arcTools_getArcLength as getArcLength, arcTools_getArcProps as getArcProps, arcTools_getPointAtArcLength as getPointAtArcLength }; } +/** + * Tools from bezier.js by Mike 'Pomax' Kamermans + * @see https://github.com/Pomax/bezierjs + */ +declare const Tvalues: number[]; +declare const Cvalues: number[]; +/** + * @param points + * @returns + */ +declare const deriveBezier: (points: QuadPoints | CubicPoints) => (DerivedQuadPoints | DerivedCubicPoints)[]; +/** + * @param points + * @param t + */ +declare const computeBezier: (points: DerivedQuadPoints | DerivedCubicPoints, t: number) => DerivedPoint; +declare const calculateBezier: (derivativeFn: DeriveCallback, t: number) => number; +declare const bezierLength: (derivativeFn: DeriveCallback) => number; +/** + * Returns the length of CubicBezier / Quad segment. + * @param curve cubic / quad bezier segment + */ +declare const getBezierLength: (curve: CubicCoordinates | QuadCoordinates) => number; +declare const CBEZIER_MINMAX_EPSILON = 1e-8; +/** + * Returns the most extreme points in a Quad Bezier segment. + * @param A an array which consist of X/Y values + */ +declare const minmaxQ: ([v1, cp, v2]: [number, number, number]) => PointTuple; +/** + * Returns the most extreme points in a Cubic Bezier segment. + * @param A an array which consist of X/Y values + * @see https://github.com/kpym/SVGPathy/blob/acd1a50c626b36d81969f6e98e8602e128ba4302/lib/box.js#L127 + */ +declare const minmaxC: ([v1, cp1, cp2, v2]: [number, number, number, number]) => PointTuple; -declare namespace shapes { - let initial: string[]; - let normalized: string[]; - let optimized: string[]; - let relative: string[]; - let absolute: string[]; - let curve: string[]; - let scaled: string[]; - let translated: string[]; - let length: number[]; - let pointAt50: { - x: number; - y: number; - }[]; +declare const bezier_CBEZIER_MINMAX_EPSILON: typeof CBEZIER_MINMAX_EPSILON; +declare const bezier_Cvalues: typeof Cvalues; +declare const bezier_Tvalues: typeof Tvalues; +declare const bezier_bezierLength: typeof bezierLength; +declare const bezier_calculateBezier: typeof calculateBezier; +declare const bezier_computeBezier: typeof computeBezier; +declare const bezier_deriveBezier: typeof deriveBezier; +declare const bezier_getBezierLength: typeof getBezierLength; +declare const bezier_minmaxC: typeof minmaxC; +declare const bezier_minmaxQ: typeof minmaxQ; +declare namespace bezier { + export { bezier_CBEZIER_MINMAX_EPSILON as CBEZIER_MINMAX_EPSILON, bezier_Cvalues as Cvalues, bezier_Tvalues as Tvalues, bezier_bezierLength as bezierLength, bezier_calculateBezier as calculateBezier, bezier_computeBezier as computeBezier, bezier_deriveBezier as deriveBezier, bezier_getBezierLength as getBezierLength, bezier_minmaxC as minmaxC, bezier_minmaxQ as minmaxQ }; } +/** + * Returns a point at a given length of a CubicBezier segment. + * + * @param x1 the starting point X + * @param y1 the starting point Y + * @param c1x the first control point X + * @param c1y the first control point Y + * @param c2x the second control point X + * @param c2y the second control point Y + * @param x2 the ending point X + * @param y2 the ending point Y + * @param t a [0-1] ratio + * @returns the point at cubic-bezier segment length + */ +declare const getPointAtCubicSegmentLength: ([x1, y1, c1x, c1y, c2x, c2y, x2, y2]: CubicCoordinates, t: number) => { + x: number; + y: number; +}; +/** + * Returns the length of a CubicBezier segment. + * + * @param x1 the starting point X + * @param y1 the starting point Y + * @param c1x the first control point X + * @param c1y the first control point Y + * @param c2x the second control point X + * @param c2y the second control point Y + * @param x2 the ending point X + * @param y2 the ending point Y + * @returns the CubicBezier segment length + */ +declare const getCubicLength: (x1: number, y1: number, c1x: number, c1y: number, c2x: number, c2y: number, x2: number, y2: number) => number; +/** + * Returns the point along a CubicBezier segment at a given distance. + * + * @param x1 the starting point X + * @param y1 the starting point Y + * @param c1x the first control point X + * @param c1y the first control point Y + * @param c2x the second control point X + * @param c2y the second control point Y + * @param x2 the ending point X + * @param y2 the ending point Y + * @param distance the distance to look at + * @returns the point at CubicBezier length + */ +declare const getPointAtCubicLength: (x1: number, y1: number, c1x: number, c1y: number, c2x: number, c2y: number, x2: number, y2: number, distance?: number) => { + x: number; + y: number; +}; +/** + * Returns the boundig box of a CubicBezier segment in the following format: + * [MIN_X, MIN_Y, MAX_X, MAX_Y] + * + * @param x1 the starting point X + * @param y1 the starting point Y + * @param c1x the first control point X + * @param c1y the first control point Y + * @param c2x the second control point X + * @param c2y the second control point Y + * @param x2 the ending point X + * @param y2 the ending point Y + * @returns the extrema of the CubicBezier segment + */ +declare const getCubicBBox: (x1: number, y1: number, c1x: number, c1y: number, c2x: number, c2y: number, x2: number, y2: number) => [number, number, number, number]; -declare namespace simpleShapes { - let initial: string[]; - let normalized: string[]; - let transformed: string[]; - let scaled3d: string[]; - let skewedX: string[]; - let skewedY: string[]; - let reversed: string[]; - let length: number[]; - let width: number[]; - let height: number[]; - let pointAt0: { - x: number; - y: number; - }[]; - let pointAt400: { - x: number; - y: number; - }[]; - let pointAt50: { - x: number; - y: number; - }[]; +declare const cubicTools_getCubicBBox: typeof getCubicBBox; +declare const cubicTools_getCubicLength: typeof getCubicLength; +declare const cubicTools_getPointAtCubicLength: typeof getPointAtCubicLength; +declare const cubicTools_getPointAtCubicSegmentLength: typeof getPointAtCubicSegmentLength; +declare namespace cubicTools { + export { cubicTools_getCubicBBox as getCubicBBox, cubicTools_getCubicLength as getCubicLength, cubicTools_getPointAtCubicLength as getPointAtCubicLength, cubicTools_getPointAtCubicSegmentLength as getPointAtCubicSegmentLength }; } +/** + * Returns length for line segments (MoveTo, LineTo). + * + * @param x1 the starting point X + * @param y1 the starting point Y + * @param x2 the ending point X + * @param y2 the ending point Y + * @returns the line segment length + */ +declare const getLineLength: (x1: number, y1: number, x2: number, y2: number) => number; +/** + * Returns a point along the line segments (MoveTo, LineTo). + * + * @param x1 the starting point X + * @param y1 the starting point Y + * @param x2 the ending point X + * @param y2 the ending point Y + * @param distance the distance to point in [0-1] range + * @returns the point at length + */ +declare const getPointAtLineLength: (x1: number, y1: number, x2: number, y2: number, distance?: number) => { + x: number; + y: number; +}; +/** + * Returns bounding box for line segments (MoveTo, LineTo). + * + * @param x1 the starting point X + * @param y1 the starting point Y + * @param x2 the ending point X + * @param y2 the ending point Y + * @param distance the distance to point in [0-1] range + * @returns the extrema for line segments + */ +declare const getLineBBox: (x1: number, y1: number, x2: number, y2: number) => [number, number, number, number]; -declare namespace shapes { - let initial: string[]; - let normalized: string[]; - let optimized: string[]; - let relative: string[]; - let absolute: string[]; - let curve: string[]; - let scaled: string[]; - let translated: string[]; - let length: number[]; - let pointAt50: { - x: number; - y: number; - }[]; +declare const lineTools_getLineBBox: typeof getLineBBox; +declare const lineTools_getLineLength: typeof getLineLength; +declare const lineTools_getPointAtLineLength: typeof getPointAtLineLength; +declare namespace lineTools { + export { lineTools_getLineBBox as getLineBBox, lineTools_getLineLength as getLineLength, lineTools_getPointAtLineLength as getPointAtLineLength }; } +/** + * Returns the {x,y} coordinates of a point at a + * given length of a quadratic-bezier segment. + * + * @see https://github.com/substack/point-at-length + * + * @param x1 the starting point X + * @param y1 the starting point Y + * @param cx the control point X + * @param cy the control point Y + * @param x2 the ending point X + * @param y2 the ending point Y + * @param t a [0-1] ratio + * @returns the requested {x,y} coordinates + */ +declare const getPointAtQuadSegmentLength: ([x1, y1, cx, cy, x2, y2]: QuadCoordinates, t: number) => { + x: number; + y: number; +}; +/** + * Returns the length of a QuadraticBezier segment. + * + * @param x1 the starting point X + * @param y1 the starting point Y + * @param cx the control point X + * @param cy the control point Y + * @param x2 the ending point X + * @param y2 the ending point Y + * @returns the QuadraticBezier segment length + */ +declare const getQuadLength: (x1: number, y1: number, cx: number, cy: number, x2: number, y2: number) => number; +/** + * Returns the point along a QuadraticBezier segment at a given distance. + * + * @param x1 the starting point X + * @param y1 the starting point Y + * @param cx the control point X + * @param cy the control point Y + * @param x2 the ending point X + * @param y2 the ending point Y + * @param distance the distance to look at + * @returns the point at QuadraticBezier length + */ +declare const getPointAtQuadLength: (x1: number, y1: number, cx: number, cy: number, x2: number, y2: number, distance?: number) => { + x: number; + y: number; +}; +/** + * Returns the boundig box of a QuadraticBezier segment in the following format: + * [MIN_X, MIN_Y, MAX_X, MAX_Y] + * + * @param x1 the starting point X + * @param y1 the starting point Y + * @param cx the control point X + * @param cy the control point Y + * @param x2 the ending point X + * @param y2 the ending point Y + * @returns the extrema of the QuadraticBezier segment + */ +declare const getQuadBBox: (x1: number, y1: number, cx: number, cy: number, x2: number, y2: number) => [number, number, number, number]; + +declare const quadTools_getPointAtQuadLength: typeof getPointAtQuadLength; +declare const quadTools_getPointAtQuadSegmentLength: typeof getPointAtQuadSegmentLength; +declare const quadTools_getQuadBBox: typeof getQuadBBox; +declare const quadTools_getQuadLength: typeof getQuadLength; +declare namespace quadTools { + export { quadTools_getPointAtQuadLength as getPointAtQuadLength, quadTools_getPointAtQuadSegmentLength as getPointAtQuadSegmentLength, quadTools_getQuadBBox as getQuadBBox, quadTools_getQuadLength as getQuadLength }; +} + +/** + * d3-polygon-area + * https://github.com/d3/d3-polygon + * + * Returns the area of a polygon. + * + * @param polygon an array of coordinates + * @returns the polygon area + */ +declare const polygonArea: (polygon: PointTuple[]) => number; +/** + * d3-polygon-length + * https://github.com/d3/d3-polygon + * + * Returns the perimeter of a polygon. + * + * @param polygon an array of coordinates + * @returns the polygon length + */ +declare const polygonLength: (polygon: PointTuple[]) => number; + +declare const polygonTools_polygonArea: typeof polygonArea; +declare const polygonTools_polygonLength: typeof polygonLength; +declare namespace polygonTools { + export { polygonTools_polygonArea as polygonArea, polygonTools_polygonLength as polygonLength }; +} + +/** + * Parses a path string value or object and returns an array + * of segments, all converted to absolute values. + * + * @param pathInput the path string | object + * @returns the resulted `pathArray` with absolute values + */ +declare const pathToAbsolute: (pathInput: string | PathArray) => AbsoluteArray; + +/** + * Parses a path string value or object and returns an array + * of segments, all converted to relative values. + * + * @param pathInput the path string | object + * @returns the resulted `pathArray` with relative values + */ +declare const pathToRelative: (pathInput: string | PathArray) => RelativeArray; + +/** + * Parses a path string value or 'pathArray' and returns a new one + * in which all segments are converted to cubic-bezier. + * + * In addition, un-necessary `Z` segment is removed if previous segment + * extends to the `M` segment. + * + * @param pathInput the string to be parsed or 'pathArray' + * @returns the resulted `pathArray` converted to cubic-bezier + */ +declare const pathToCurve: (pathInput: string | PathArray) => CurveArray; + +/** + * Returns a valid `d` attribute string value created + * by rounding values and concatenating the `pathArray` segments. + * + * @param path the `pathArray` object + * @param roundOption amount of decimals to round values to + * @returns the concatenated path string + */ +declare const pathToString: (path: PathArray, roundOption?: number | "off") => string; + +/** + * Returns the square root of the distance + * between two given points. + * + * @param a the first point coordinates + * @param b the second point coordinates + * @returns the distance value + */ +declare const distanceSquareRoot: (a: PointTuple, b: PointTuple) => number; + +/** + * Returns the coordinates of a specified distance + * ratio between two points. + * + * @param a the first point coordinates + * @param b the second point coordinates + * @param t the ratio + * @returns the midpoint coordinates + */ +declare const midPoint: (a: PointTuple, b: PointTuple, t: number) => PointTuple; + +/** + * Returns an {x,y} vector rotated by a given + * angle in radian. + * + * @param x the initial vector x + * @param y the initial vector y + * @param rad the radian vector angle + * @returns the rotated vector + */ +declare const rotateVector: (x: number, y: number, rad: number) => { + x: number; + y: number; +}; + +declare const roundTo: (n: number, round: number) => number; + +/** + * Parses a path string value and returns an array + * of segments we like to call `pathArray`. + * + * @param pathInput the string to be parsed + * @returns the resulted `pathArray` or error string + */ +declare const parsePathString: (pathInput: string | T) => PathArray; + +/** + * The `PathParser` is used by the `parsePathString` static method + * to generate a `pathArray`. + * + * @param pathString + */ +declare class PathParser { + segments: PathArray | PathSegment[]; + pathValue: string; + max: number; + index: number; + param: number; + segmentStart: number; + data: (string | number)[]; + err: string; + constructor(pathString: string); +} + +/** + * Breaks the parsing of a pathString once a segment is finalized. + * + * @param path the `PathParser` instance + */ +declare const finalizeSegment: (path: PathParser) => void; + +declare const invalidPathValue = "Invalid path value"; + +/** + * Checks if the character is an A (arc-to) path command. + * + * @param code the character to check + * @returns check result + */ +declare const isArcCommand: (code: number) => code is 97; + +/** + * Checks if a character is a digit. + * + * @param code the character to check + * @returns check result + */ +declare const isDigit: (code: number) => code is DigitNumber; + +/** + * Checks if the character is or belongs to a number. + * [0-9]|+|-|. + * + * @param code the character to check + * @returns check result + */ +declare const isDigitStart: (code: number) => code is DigitNumber | 43 | 45 | 46; + +/** + * Checks if the character is a MoveTo command. + * + * @param code the character to check + * @returns check result + */ +declare const isMoveCommand: (code: number) => code is 109 | 77; + +/** + * Checks if the character is a path command. + * + * @param code the character to check + * @returns check result + */ +declare const isPathCommand: (code: number) => code is PathCommandNumber; + +/** + * Checks if the character is a space. + * + * @param ch the character to check + * @returns check result + */ +declare const isSpace: (ch: number) => ch is SpaceNumber; + +/** Segment params length */ +declare const paramsCount: { + a: number; + c: number; + h: number; + l: number; + m: number; + r: number; + q: number; + s: number; + t: number; + v: number; + z: number; +}; + +declare const paramsParser: ParserParams; -declare namespace simpleShapes { - let initial: string[]; - let normalized: string[]; - let transformed: string[]; - let scaled3d: string[]; - let skewedX: string[]; - let skewedY: string[]; - let reversed: string[]; - let length: number[]; - let width: number[]; - let height: number[]; - let pointAt0: { +/** + * Validates an A (arc-to) specific path command value. + * Usually a `large-arc-flag` or `sweep-flag`. + * + * @param path the `PathParser` instance + */ +declare const scanFlag: (path: PathParser) => void; + +/** + * Validates every character of the path string, + * every path command, negative numbers or floating point numbers. + * + * @param path the `PathParser` instance + */ +declare const scanParam: (path: PathParser) => void; + +/** + * Scans every character in the path string to determine + * where a segment starts and where it ends. + * + * @param path the `PathParser` instance + */ +declare const scanSegment: (path: PathParser) => void; + +/** + * Points the parser to the next character in the + * path string every time it encounters any kind of + * space character. + * + * @param path the `PathParser` instance + */ +declare const skipSpaces: (path: PathParser) => void; + +declare const DISTANCE_EPSILON = 0.00001; + +/** + * Returns the point in path closest to a given point. + * + * @param pathInput target `pathArray` + * @param point the given point + * @returns the best match + */ +declare const getClosestPoint: (pathInput: string | PathArray, point: { + x: number; + y: number; +}) => { + x: number; + y: number; +}; + +/** + * Check if a path is drawn clockwise and returns true if so, + * false otherwise. + * + * @param path the path string or `pathArray` + * @returns true when clockwise or false if not + */ +declare const getDrawDirection: (path: string | PathArray) => boolean; + +/** + * Returns the area of a shape. + * + * @author Jürg Lehni & Jonathan Puckey + * + * @see https://github.com/paperjs/paper.js/blob/develop/src/path/Path.js + * + * @param path the shape `pathArray` + * @returns the length of the cubic-bezier segment + */ +declare const getPathArea: (path: PathArray) => number; + +declare const getPathBBox: (pathInput: PathArray | string) => { + x: number; + y: number; + width: number; + height: number; + x2: number; + y2: number; + cx: number; + cy: number; + cz: number; +}; + +/** + * Returns [x,y] coordinates of a point at a given length of a shape. + * + * @param pathInput the `pathArray` to look into + * @param distance the length of the shape to look at + * @returns the requested {x, y} point coordinates + */ +declare const getPointAtLength: (pathInput: string | PathArray, distance?: number) => { + x: number; + y: number; +}; + +/** + * Returns the segment, its index and length as well as + * the length to that segment at a given length in a path. + * + * @param pathInput target `pathArray` + * @param distance the given length + * @returns the requested properties + */ +declare const getPropertiesAtLength: (pathInput: string | PathArray, distance?: number) => SegmentProperties; + +/** + * Returns the point and segment in path closest to a given point as well as + * the distance to the path stroke. + * + * @see https://bl.ocks.org/mbostock/8027637 + * + * @param pathInput target `pathArray` + * @param point the given point + * @returns the requested properties + */ +declare const getPropertiesAtPoint: (pathInput: string | PathArray, point: Point) => PointProperties; + +/** + * Returns the segment at a given length. + * + * @param pathInput the target `pathArray` + * @param distance the distance in path to look at + * @returns the requested segment + */ +declare const getSegmentAtLength: (pathInput: string | PathArray, distance?: number) => PathSegment | undefined; + +/** + * Returns the path segment which contains a given point. + * + * @param path the `pathArray` to look into + * @param point the point of the shape to look for + * @returns the requested segment + */ +declare const getSegmentOfPoint: (path: string | PathArray, point: { + x: number; + y: number; +}) => SegmentProperties | undefined; + +/** + * Returns the shape total length, or the equivalent to `shape.getTotalLength()`. + * + * @param pathInput the target `pathArray` + * @returns the shape total length + */ +declare const getTotalLength: (pathInput: string | PathArray) => number; + +/** + * Iterates an array to check if it's a `pathArray` + * with all absolute values. + * + * @param path the `pathArray` to be checked + * @returns iteration result + */ +declare const isAbsoluteArray: (path: unknown) => path is AbsoluteArray; + +/** + * Iterates an array to check if it's a `pathArray` + * with all C (cubic bezier) segments. + * + * @param path the `Array` to be checked + * @returns iteration result + */ +declare const isCurveArray: (path: unknown) => path is CurveArray; + +/** + * Iterates an array to check if it's a `pathArray` + * with all segments are in non-shorthand notation + * with absolute values. + * + * @param {string | SVGPath.pathArray} path the `pathArray` to be checked + * @returns {boolean} iteration result + */ +declare const isNormalizedArray: (path: unknown) => path is NormalArray; + +/** + * Iterates an array to check if it's an actual `pathArray`. + * + * @param path the `pathArray` to be checked + * @returns iteration result + */ +declare const isPathArray: (path: unknown) => path is PathArray; + +/** + * Checks if a given point is in the stroke of a path. + * + * @param pathInput target path + * @param point the given `{x,y}` point + * @returns the query result + */ +declare const isPointInStroke: (pathInput: string | PathArray, point: { + x: number; + y: number; +}) => boolean; + +/** + * Iterates an array to check if it's a `pathArray` + * with relative values. + * + * @param path the `pathArray` to be checked + * @returns iteration result + */ +declare const isRelativeArray: (path: unknown) => path is RelativeArray; + +/** + * Parses a path string value to determine its validity + * then returns true if it's valid or false otherwise. + * + * @param pathString the path string to be parsed + * @returns the path string validity + */ +declare const isValidPath: (pathString: string) => boolean; + +/** + * Supported shapes and their specific parameters. + */ +declare const shapeParams: ShapeParams; + +/** + * Returns a new `` element created from attributes of a ``, ``, + * ``, ``, ``, `` or ``. If `replace` parameter + * is `true`, it will replace the target. The default `ownerDocument` is your current + * `document` browser page, if you want to use in server-side using `jsdom`, you can + * pass the `jsdom` `document` to `ownDocument`. + * + * It can also work with an options object, see the type below + * @see ShapeOps + * + * The newly created `` element keeps all non-specific + * attributes like `class`, `fill`, etc. + * + * @param element target shape + * @param replace option to replace target + * @param ownerDocument document for create element + * @return the newly created `` element + */ +declare const shapeToPath: (element: ShapeTypes | ShapeOps, replace?: boolean, ownerDocument?: Document) => SVGPathElement | false; + +/** + * Returns a new `pathArray` created from attributes of a ``, ``, + * ``, ``, ``, ``, or ``. + * + * It can also work with an options object, see the type below + * @see ShapeOps + * + * @param element target shape + * @return the newly created `` element + */ +declare const shapeToPathArray: (element: ShapeTypes | ShapeOps) => false | PathArray; + +/** + * Returns an absolute segment of a `PathArray` object. + * + * @param segment the segment object + * @param index the segment index + * @param lastX the last known X value + * @param lastY the last known Y value + * @returns the absolute segment + */ +declare const absolutizeSegment: (segment: PathSegment, index: number, lastX: number, lastY: number) => AbsoluteSegment; + +/** + * Converts A (arc-to) segments to C (cubic-bezier-to). + * + * For more information of where this math came from visit: + * http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes + * + * @param X1 the starting x position + * @param Y1 the starting y position + * @param RX x-radius of the arc + * @param RY y-radius of the arc + * @param angle x-axis-rotation of the arc + * @param LAF large-arc-flag of the arc + * @param SF sweep-flag of the arc + * @param X2 the ending x position + * @param Y2 the ending y position + * @param recursive the parameters needed to split arc into 2 segments + * @return the resulting cubic-bezier segment(s) + */ +declare const arcToCubic: (X1: number, Y1: number, RX: number, RY: number, angle: number, LAF: number, SF: number, X2: number, Y2: number, recursive?: [number, number, number, number]) => number[]; + +/** + * Returns a transformation matrix to apply to `` elements. + * + * @see TransformObjectValues + * + * @param transform the `transformObject` + * @returns a new transformation matrix + */ +declare const getSVGMatrix: (transform: TransformObjectValues) => CSSMatrix; + +declare const iterate: (path: PathArray, iterator: IteratorCallback) => T; + +/** + * Converts an L (line-to) segment to C (cubic-bezier). + * + * @param x1 line start x + * @param y1 line start y + * @param x2 line end x + * @param y2 line end y + * @returns the cubic-bezier segment + */ +declare const lineToCubic: (x1: number, y1: number, x2: number, y2: number) => number[]; + +/** + * Normalizes a `pathArray` object for further processing: + * * convert segments to absolute values + * * convert shorthand path commands to their non-shorthand notation + * + * @param pathInput the string to be parsed or 'pathArray' + * @returns the normalized `pathArray` + */ +declare const normalizePath: (pathInput: string | PathArray) => NormalArray; + +/** + * Normalizes a single segment of a `pathArray` object. + * + * @param segment the segment object + * @param params the normalization parameters + * @returns the normalized segment + */ +declare const normalizeSegment: (segment: PathSegment, params: ParserParams) => NormalSegment; + +/** + * Optimizes a `pathArray` object: + * * convert segments to shorthand if possible + * * select shortest segments from absolute and relative `pathArray`s + * + * @param pathInput a string or `pathArray` + * @param roundOption the amount of decimals to round values to + * @returns the optimized `pathArray` + */ +declare const optimizePath: (pathInput: PathArray, roundOption?: number) => PathArray; + +/** + * Returns the [x,y] projected coordinates for a given an [x,y] point + * and an [x,y,z] perspective origin point. + * + * Equation found here => + * http://en.wikipedia.org/wiki/3D_projection#Diagram + * Details => + * https://stackoverflow.com/questions/23792505/predicted-rendering-of-css-3d-transformed-pixel + * + * @param m the transformation matrix + * @param point2D the initial [x,y] coordinates + * @param origin the [x,y,z] transform origin + * @returns the projected [x,y] coordinates + */ +declare const projection2d: (m: CSSMatrix, point2D: PointTuple, origin: [number, number, number]) => PointTuple; + +/** + * Converts a Q (quadratic-bezier) segment to C (cubic-bezier). + * + * @param x1 curve start x + * @param y1 curve start y + * @param qx control point x + * @param qy control point y + * @param x2 curve end x + * @param y2 curve end y + * @returns the cubic-bezier segment + */ +declare const quadToCubic: (x1: number, y1: number, qx: number, qy: number, x2: number, y2: number) => [number, number, number, number, number, number]; + +/** + * Returns a relative segment of a `PathArray` object. + * + * @param segment the segment object + * @param index the segment index + * @param lastX the last known X value + * @param lastY the last known Y value + * @returns the relative segment + */ +declare const relativizeSegment: (segment: PathSegment, index: number, lastX: number, lastY: number) => MSegment | RelativeSegment; + +/** + * Reverses all segments of a `pathArray` + * which consists of only C (cubic-bezier) path commands. + * + * @param path the source `pathArray` + * @returns the reversed `pathArray` + */ +declare const reverseCurve: (path: CurveArray) => CurveArray; + +/** + * Reverses all segments of a `pathArray` and returns a new `pathArray` instance + * with absolute values. + * + * @param pathInput the source `pathArray` + * @returns the reversed `pathArray` + */ +declare const reversePath: (pathInput: PathArray) => PathArray; + +/** + * Rounds the values of a `pathArray` instance to + * a specified amount of decimals and returns it. + * + * @param path the source `pathArray` + * @param roundOption the amount of decimals to round numbers to + * @returns the resulted `pathArray` with rounded values + */ +declare const roundPath: (path: PathArray, roundOption?: number | "off") => PathArray; + +declare const roundSegment: (segment: T, roundOption: number) => T; + +/** + * Converts any segment to C (cubic-bezier). + * + * @param segment the source segment + * @param params the source segment parameters + * @returns the cubic-bezier segment + */ +declare const segmentToCubic: (segment: PathSegment, params: ParserParams) => MSegment | CSegment; + +/** + * Shorten a single segment of a `pathArray` object. + * + * @param segment the `absoluteSegment` object + * @param normalSegment the `normalSegment` object + * @param params the coordinates of the previous segment + * @param prevCommand the path command of the previous segment + * @returns the shortened segment + */ +declare const shortenSegment: (segment: AbsoluteSegment, normalSegment: NormalSegment, params: ParserParams, prevCommand: PathCommand) => ShortSegment; + +/** + * Split a cubic-bezier segment into two. + * + * @param pts the cubic-bezier parameters + * @param ratio the cubic-bezier parameters + * @return two new cubic-bezier segments + */ +declare const splitCubic: (pts: number[], ratio?: number) => [CubicSegment, CubicSegment]; + +/** + * Split a path into an `Array` of sub-path strings. + * + * In the process, values are converted to absolute + * for visual consistency. + * + * @param pathInput the source `pathArray` + * @return an array with all sub-path strings + */ +declare const splitPath: (pathInput: PathArray) => PathArray[]; + +/** + * Apply a 2D / 3D transformation to a `pathArray` instance. + * + * Since *SVGElement* doesn't support 3D transformation, this function + * creates a 2D projection of the element. + * + * @param path the `pathArray` to apply transformation + * @param transform the transform functions `Object` + * @returns the resulted `pathArray` + */ +declare const transformPath: (pathInput: PathArray | string, transform?: Partial) => PathArray; + +declare const util_CSSMatrix: typeof CSSMatrix; +declare const util_absolutizeSegment: typeof absolutizeSegment; +declare const util_arcToCubic: typeof arcToCubic; +declare const util_arcTools: typeof arcTools; +declare const util_cubicTools: typeof cubicTools; +declare const util_distanceSquareRoot: typeof distanceSquareRoot; +declare const util_finalizeSegment: typeof finalizeSegment; +declare const util_getClosestPoint: typeof getClosestPoint; +declare const util_getDrawDirection: typeof getDrawDirection; +declare const util_getPathArea: typeof getPathArea; +declare const util_getPathBBox: typeof getPathBBox; +declare const util_getPointAtLength: typeof getPointAtLength; +declare const util_getPropertiesAtLength: typeof getPropertiesAtLength; +declare const util_getPropertiesAtPoint: typeof getPropertiesAtPoint; +declare const util_getSVGMatrix: typeof getSVGMatrix; +declare const util_getSegmentAtLength: typeof getSegmentAtLength; +declare const util_getSegmentOfPoint: typeof getSegmentOfPoint; +declare const util_getTotalLength: typeof getTotalLength; +declare const util_invalidPathValue: typeof invalidPathValue; +declare const util_isAbsoluteArray: typeof isAbsoluteArray; +declare const util_isArcCommand: typeof isArcCommand; +declare const util_isCurveArray: typeof isCurveArray; +declare const util_isDigit: typeof isDigit; +declare const util_isDigitStart: typeof isDigitStart; +declare const util_isMoveCommand: typeof isMoveCommand; +declare const util_isNormalizedArray: typeof isNormalizedArray; +declare const util_isPathArray: typeof isPathArray; +declare const util_isPathCommand: typeof isPathCommand; +declare const util_isPointInStroke: typeof isPointInStroke; +declare const util_isRelativeArray: typeof isRelativeArray; +declare const util_isSpace: typeof isSpace; +declare const util_isValidPath: typeof isValidPath; +declare const util_iterate: typeof iterate; +declare const util_lineToCubic: typeof lineToCubic; +declare const util_lineTools: typeof lineTools; +declare const util_midPoint: typeof midPoint; +declare const util_normalizePath: typeof normalizePath; +declare const util_normalizeSegment: typeof normalizeSegment; +declare const util_optimizePath: typeof optimizePath; +declare const util_paramsCount: typeof paramsCount; +declare const util_paramsParser: typeof paramsParser; +declare const util_parsePathString: typeof parsePathString; +declare const util_pathToAbsolute: typeof pathToAbsolute; +declare const util_pathToCurve: typeof pathToCurve; +declare const util_pathToRelative: typeof pathToRelative; +declare const util_pathToString: typeof pathToString; +declare const util_polygonTools: typeof polygonTools; +declare const util_projection2d: typeof projection2d; +declare const util_quadToCubic: typeof quadToCubic; +declare const util_quadTools: typeof quadTools; +declare const util_relativizeSegment: typeof relativizeSegment; +declare const util_reverseCurve: typeof reverseCurve; +declare const util_reversePath: typeof reversePath; +declare const util_rotateVector: typeof rotateVector; +declare const util_roundPath: typeof roundPath; +declare const util_roundSegment: typeof roundSegment; +declare const util_roundTo: typeof roundTo; +declare const util_scanFlag: typeof scanFlag; +declare const util_scanParam: typeof scanParam; +declare const util_scanSegment: typeof scanSegment; +declare const util_segmentToCubic: typeof segmentToCubic; +declare const util_shapeParams: typeof shapeParams; +declare const util_shapeToPath: typeof shapeToPath; +declare const util_shapeToPathArray: typeof shapeToPathArray; +declare const util_shortenSegment: typeof shortenSegment; +declare const util_skipSpaces: typeof skipSpaces; +declare const util_splitCubic: typeof splitCubic; +declare const util_splitPath: typeof splitPath; +declare const util_transformPath: typeof transformPath; +declare namespace util { + export { util_CSSMatrix as CSSMatrix, util_absolutizeSegment as absolutizeSegment, util_arcToCubic as arcToCubic, util_arcTools as arcTools, bezier as bezierTools, util_cubicTools as cubicTools, DISTANCE_EPSILON as distanceEpsilon, util_distanceSquareRoot as distanceSquareRoot, util_finalizeSegment as finalizeSegment, util_getClosestPoint as getClosestPoint, util_getDrawDirection as getDrawDirection, util_getPathArea as getPathArea, util_getPathBBox as getPathBBox, util_getPointAtLength as getPointAtLength, util_getPropertiesAtLength as getPropertiesAtLength, util_getPropertiesAtPoint as getPropertiesAtPoint, util_getSVGMatrix as getSVGMatrix, util_getSegmentAtLength as getSegmentAtLength, util_getSegmentOfPoint as getSegmentOfPoint, util_getTotalLength as getTotalLength, util_invalidPathValue as invalidPathValue, util_isAbsoluteArray as isAbsoluteArray, util_isArcCommand as isArcCommand, util_isCurveArray as isCurveArray, util_isDigit as isDigit, util_isDigitStart as isDigitStart, util_isMoveCommand as isMoveCommand, util_isNormalizedArray as isNormalizedArray, util_isPathArray as isPathArray, util_isPathCommand as isPathCommand, util_isPointInStroke as isPointInStroke, util_isRelativeArray as isRelativeArray, util_isSpace as isSpace, util_isValidPath as isValidPath, util_iterate as iterate, util_lineToCubic as lineToCubic, util_lineTools as lineTools, util_midPoint as midPoint, util_normalizePath as normalizePath, util_normalizeSegment as normalizeSegment, util_optimizePath as optimizePath, util_paramsCount as paramsCount, util_paramsParser as paramsParser, util_parsePathString as parsePathString, PathParser as pathParser, util_pathToAbsolute as pathToAbsolute, util_pathToCurve as pathToCurve, util_pathToRelative as pathToRelative, util_pathToString as pathToString, util_polygonTools as polygonTools, util_projection2d as projection2d, util_quadToCubic as quadToCubic, util_quadTools as quadTools, util_relativizeSegment as relativizeSegment, util_reverseCurve as reverseCurve, util_reversePath as reversePath, util_rotateVector as rotateVector, util_roundPath as roundPath, util_roundSegment as roundSegment, util_roundTo as roundTo, util_scanFlag as scanFlag, util_scanParam as scanParam, util_scanSegment as scanSegment, util_segmentToCubic as segmentToCubic, util_shapeParams as shapeParams, util_shapeToPath as shapeToPath, util_shapeToPathArray as shapeToPathArray, util_shortenSegment as shortenSegment, util_skipSpaces as skipSpaces, util_splitCubic as splitCubic, util_splitPath as splitPath, util_transformPath as transformPath }; +} + +/** + * Creates a new SVGPathCommander instance with the following properties: + * * segments: `pathArray` + * * round: number + * * origin: [number, number, number?] + * + * @class + * @author thednp + * @returns a new SVGPathCommander instance + */ +declare class SVGPathCommander { + segments: PathArray; + round: number | "off"; + origin: [number, number, number]; + /** + * @constructor + * @param pathValue the path string + * @param config instance options + */ + constructor(pathValue: string, config?: Partial); + get bbox(): { x: number; y: number; - }[]; - let pointAt400: { + width: number; + height: number; + x2: number; + y2: number; + cx: number; + cy: number; + cz: number; + }; + get length(): number; + /** + * Returns the path bounding box, equivalent to native `path.getBBox()`. + * + * @public + * @returns the pathBBox + */ + getBBox(): { x: number; y: number; - }[]; - let pointAt50: { + width: number; + height: number; + x2: number; + y2: number; + cx: number; + cy: number; + cz: number; + }; + /** + * Returns the total path length, equivalent to native `path.getTotalLength()`. + * + * @public + * @returns the path total length + */ + getTotalLength(): number; + /** + * Returns an `{x,y}` point in the path stroke at a given length, + * equivalent to the native `path.getPointAtLength()`. + * + * @public + * @param length the length + * @returns the requested point + */ + getPointAtLength(length: number): { x: number; y: number; - }[]; + }; + /** + * Convert path to absolute values + * + * @public + */ + toAbsolute(): this; + /** + * Convert path to relative values + * + * @public + */ + toRelative(): this; + /** + * Convert path to cubic-bezier values. In addition, un-necessary `Z` + * segment is removed if previous segment extends to the `M` segment. + * + * @public + */ + toCurve(): this; + /** + * Reverse the order of the segments and their values. + * + * @param onlySubpath option to reverse all sub-paths except first + * @public + */ + reverse(onlySubpath?: boolean): this; + /** + * Normalize path in 2 steps: + * * convert `pathArray`(s) to absolute values + * * convert shorthand notation to standard notation + * + * @public + */ + normalize(): this; + /** + * Optimize `pathArray` values: + * * convert segments to absolute and/or relative values + * * select segments with shortest resulted string + * * round values to the specified `decimals` option value + * + * @public + */ + optimize(): this; + /** + * Transform path using values from an `Object` defined as `transformObject`. + * + * @see TransformObject for a quick refference + * + * @param source a `transformObject`as described above + * @public + */ + transform(source?: Partial): this; + /** + * Rotate path 180deg vertically + * + * @public + */ + flipX(): this; + /** + * Rotate path 180deg horizontally + * + * @public + */ + flipY(): this; + /** + * Export the current path to be used + * for the `d` (description) attribute. + * + * @public + * @return the path string + */ + toString(): string; + /** + * Remove the instance. + * + * @public + * @return void + */ + dispose(): void; } +declare const defaultExport: typeof SVGPathCommander & typeof util; + +export { type ACommand, type ASegment, type AbsoluteArray, type AbsoluteCommand, type AbsoluteSegment, type ArcCoordinates, type ArcSegment, type CCommand, type CSegment, type CircleAttr, type CloseSegment, type CubicCoordinates, type CubicPoints, type CubicSegment, type CurveArray, type DeriveCallback, type DerivedCubicPoints, type DerivedPoint, type DerivedQuadPoints, type DigitNumber, type EllipseAttr, type GlyphAttr, type HCommand, type HSegment, type HorLineSegment, type IteratorCallback, type LCommand, type LSegment, type LengthFactory, type LineAttr, type LineCoordinates, type LineSegment, type MCommand, type MSegment, type MoveSegment, type NormalArray, type NormalSegment, type Options, type ParserParams, type PathArray, type PathBBox, type PathCommand, type PathCommandNumber, type PathSegment, type PathTransform, type Point, type PointProperties, type PointTuple, type PolyAttr, type PolygonArray, type PolylineArray, type QCommand, type QSegment, type QuadCoordinates, type QuadPoints, type QuadSegment, type RectAttr, type RelativeArray, type RelativeCommand, type RelativeSegment, type SCommand, type SSegment, type SegmentLimits, type SegmentProperties, type ShapeOps, type ShapeParams, type ShapeTags, type ShapeTypes, type ShortCubicSegment, type ShortQuadSegment, type ShortSegment, type SpaceNumber, type TCommand, type TSegment, type TransformEntries, type TransformObject, type TransformObjectValues, type TransformProps, type VCommand, type VSegment, type VertLineSegment, type ZCommand, type ZSegment, type aCommand, type aSegment, type cCommand, type cSegment, defaultExport as default, type hCommand, type hSegment, type lCommand, type lSegment, type mCommand, type mSegment, type qCommand, type qSegment, type sCommand, type sSegment, type tCommand, type tSegment, type vCommand, type vSegment, type zCommand, type zSegment }; diff --git a/dist/svg-path-commander.js b/dist/svg-path-commander.js index 5a0b62c..1b3f5ef 100644 --- a/dist/svg-path-commander.js +++ b/dist/svg-path-commander.js @@ -1,2 +1,2 @@ -var SVGPathCommander=function(){"use strict";var Et=Object.defineProperty,Ot=(t,e,r)=>e in t?Et(t,e,{enumerable:!0,configurable:!0,writable:!0,value:r}):t[e]=r,I=(t,e,r)=>Ot(t,typeof e!="symbol"?e+"":e,r);const Vt={a:1,b:0,c:0,d:1,e:0,f:0,m11:1,m12:0,m13:0,m14:0,m21:0,m22:1,m23:0,m24:0,m31:0,m32:0,m33:1,m34:0,m41:0,m42:0,m43:0,m44:1,is2D:!0,isIdentity:!0},He=t=>(t instanceof Float64Array||t instanceof Float32Array||Array.isArray(t)&&t.every(e=>typeof e=="number"))&&[6,16].some(e=>t.length===e),Fe=t=>t instanceof DOMMatrix||t instanceof P||typeof t=="object"&&Object.keys(Vt).every(e=>t&&e in t),te=t=>{const e=new P,r=Array.from(t);if(!He(r))throw TypeError(`CSSMatrix: "${r.join(",")}" must be an array with 6/16 numbers.`);if(r.length===16){const[s,n,o,i,l,c,a,m,h,f,y,u,g,p,b,M]=r;e.m11=s,e.a=s,e.m21=l,e.c=l,e.m31=h,e.m41=g,e.e=g,e.m12=n,e.b=n,e.m22=c,e.d=c,e.m32=f,e.m42=p,e.f=p,e.m13=o,e.m23=a,e.m33=y,e.m43=b,e.m14=i,e.m24=m,e.m34=u,e.m44=M}else if(r.length===6){const[s,n,o,i,l,c]=r;e.m11=s,e.a=s,e.m12=n,e.b=n,e.m21=o,e.c=o,e.m22=i,e.d=i,e.m41=l,e.e=l,e.m42=c,e.f=c}return e},Ue=t=>{if(Fe(t))return te([t.m11,t.m12,t.m13,t.m14,t.m21,t.m22,t.m23,t.m24,t.m31,t.m32,t.m33,t.m34,t.m41,t.m42,t.m43,t.m44]);throw TypeError(`CSSMatrix: "${JSON.stringify(t)}" is not a DOMMatrix / CSSMatrix / JSON compatible object.`)},Ge=t=>{if(typeof t!="string")throw TypeError(`CSSMatrix: "${JSON.stringify(t)}" is not a string.`);const e=String(t).replace(/\s/g,"");let r=new P;const s=`CSSMatrix: invalid transform string "${t}"`;return e.split(")").filter(n=>n).forEach(n=>{const[o,i]=n.split("(");if(!i)throw TypeError(s);const l=i.split(",").map(u=>u.includes("rad")?parseFloat(u)*(180/Math.PI):parseFloat(u)),[c,a,m,h]=l,f=[c,a,m],y=[c,a,m,h];if(o==="perspective"&&c&&[a,m].every(u=>u===void 0))r.m34=-1/c;else if(o.includes("matrix")&&[6,16].includes(l.length)&&l.every(u=>!Number.isNaN(+u))){const u=l.map(g=>Math.abs(g)<1e-6?0:g);r=r.multiply(te(u))}else if(o==="translate3d"&&f.every(u=>!Number.isNaN(+u)))r=r.translate(c,a,m);else if(o==="translate"&&c&&m===void 0)r=r.translate(c,a||0,0);else if(o==="rotate3d"&&y.every(u=>!Number.isNaN(+u))&&h)r=r.rotateAxisAngle(c,a,m,h);else if(o==="rotate"&&c&&[a,m].every(u=>u===void 0))r=r.rotate(0,0,c);else if(o==="scale3d"&&f.every(u=>!Number.isNaN(+u))&&f.some(u=>u!==1))r=r.scale(c,a,m);else if(o==="scale"&&!Number.isNaN(c)&&(c!==1||a!==1)&&m===void 0){const u=Number.isNaN(+a)?c:a;r=r.scale(c,u,1)}else if(o==="skew"&&(c||!Number.isNaN(c)&&a)&&m===void 0)r=r.skew(c,a||0);else if(["translate","rotate","scale","skew"].some(u=>o.includes(u))&&/[XYZ]/.test(o)&&c&&[a,m].every(u=>u===void 0))if(o==="skewX"||o==="skewY")r=r[o](c);else{const u=o.replace(/[XYZ]/,""),g=o.replace(u,""),p=["X","Y","Z"].indexOf(g),b=u==="scale"?1:0,M=[p===0?c:b,p===1?c:b,p===2?c:b];r=r[u](...M)}else throw TypeError(s)}),r},Ne=(t,e)=>e?[t.a,t.b,t.c,t.d,t.e,t.f]:[t.m11,t.m12,t.m13,t.m14,t.m21,t.m22,t.m23,t.m24,t.m31,t.m32,t.m33,t.m34,t.m41,t.m42,t.m43,t.m44],Je=(t,e,r)=>{const s=new P;return s.m41=t,s.e=t,s.m42=e,s.f=e,s.m43=r,s},Ke=(t,e,r)=>{const s=new P,n=Math.PI/180,o=t*n,i=e*n,l=r*n,c=Math.cos(o),a=-Math.sin(o),m=Math.cos(i),h=-Math.sin(i),f=Math.cos(l),y=-Math.sin(l),u=m*f,g=-m*y;s.m11=u,s.a=u,s.m12=g,s.b=g,s.m13=h;const p=a*h*f+c*y;s.m21=p,s.c=p;const b=c*f-a*h*y;return s.m22=b,s.d=b,s.m23=-a*m,s.m31=a*y-c*h*f,s.m32=a*f+c*h*y,s.m33=c*m,s},We=(t,e,r,s)=>{const n=new P,o=Math.sqrt(t*t+e*e+r*r);if(o===0)return n;const i=t/o,l=e/o,c=r/o,a=s*(Math.PI/360),m=Math.sin(a),h=Math.cos(a),f=m*m,y=i*i,u=l*l,g=c*c,p=1-2*(u+g)*f;n.m11=p,n.a=p;const b=2*(i*l*f+c*m*h);n.m12=b,n.b=b,n.m13=2*(i*c*f-l*m*h);const M=2*(l*i*f-c*m*h);n.m21=M,n.c=M;const d=1-2*(g+y)*f;return n.m22=d,n.d=d,n.m23=2*(l*c*f+i*m*h),n.m31=2*(c*i*f+l*m*h),n.m32=2*(c*l*f-i*m*h),n.m33=1-2*(y+u)*f,n},Xe=(t,e,r)=>{const s=new P;return s.m11=t,s.a=t,s.m22=e,s.d=e,s.m33=r,s},me=(t,e)=>{const r=new P;if(t){const s=t*Math.PI/180,n=Math.tan(s);r.m21=n,r.c=n}if(e){const s=e*Math.PI/180,n=Math.tan(s);r.m12=n,r.b=n}return r},Ye=t=>me(t,0),et=t=>me(0,t),D=(t,e)=>{const r=e.m11*t.m11+e.m12*t.m21+e.m13*t.m31+e.m14*t.m41,s=e.m11*t.m12+e.m12*t.m22+e.m13*t.m32+e.m14*t.m42,n=e.m11*t.m13+e.m12*t.m23+e.m13*t.m33+e.m14*t.m43,o=e.m11*t.m14+e.m12*t.m24+e.m13*t.m34+e.m14*t.m44,i=e.m21*t.m11+e.m22*t.m21+e.m23*t.m31+e.m24*t.m41,l=e.m21*t.m12+e.m22*t.m22+e.m23*t.m32+e.m24*t.m42,c=e.m21*t.m13+e.m22*t.m23+e.m23*t.m33+e.m24*t.m43,a=e.m21*t.m14+e.m22*t.m24+e.m23*t.m34+e.m24*t.m44,m=e.m31*t.m11+e.m32*t.m21+e.m33*t.m31+e.m34*t.m41,h=e.m31*t.m12+e.m32*t.m22+e.m33*t.m32+e.m34*t.m42,f=e.m31*t.m13+e.m32*t.m23+e.m33*t.m33+e.m34*t.m43,y=e.m31*t.m14+e.m32*t.m24+e.m33*t.m34+e.m34*t.m44,u=e.m41*t.m11+e.m42*t.m21+e.m43*t.m31+e.m44*t.m41,g=e.m41*t.m12+e.m42*t.m22+e.m43*t.m32+e.m44*t.m42,p=e.m41*t.m13+e.m42*t.m23+e.m43*t.m33+e.m44*t.m43,b=e.m41*t.m14+e.m42*t.m24+e.m43*t.m34+e.m44*t.m44;return te([r,s,n,o,i,l,c,a,m,h,f,y,u,g,p,b])};class P{constructor(e){return this.a=1,this.b=0,this.c=0,this.d=1,this.e=0,this.f=0,this.m11=1,this.m12=0,this.m13=0,this.m14=0,this.m21=0,this.m22=1,this.m23=0,this.m24=0,this.m31=0,this.m32=0,this.m33=1,this.m34=0,this.m41=0,this.m42=0,this.m43=0,this.m44=1,e?this.setMatrixValue(e):this}get isIdentity(){return this.m11===1&&this.m12===0&&this.m13===0&&this.m14===0&&this.m21===0&&this.m22===1&&this.m23===0&&this.m24===0&&this.m31===0&&this.m32===0&&this.m33===1&&this.m34===0&&this.m41===0&&this.m42===0&&this.m43===0&&this.m44===1}get is2D(){return this.m31===0&&this.m32===0&&this.m33===1&&this.m34===0&&this.m43===0&&this.m44===1}setMatrixValue(e){return typeof e=="string"&&e.length&&e!=="none"?Ge(e):Array.isArray(e)||e instanceof Float64Array||e instanceof Float32Array?te(e):typeof e=="object"?Ue(e):this}toFloat32Array(e){return Float32Array.from(Ne(this,e))}toFloat64Array(e){return Float64Array.from(Ne(this,e))}toString(){const{is2D:e}=this,r=this.toFloat64Array(e).join(", ");return`${e?"matrix":"matrix3d"}(${r})`}toJSON(){const{is2D:e,isIdentity:r}=this;return{...this,is2D:e,isIdentity:r}}multiply(e){return D(this,e)}translate(e,r,s){const n=e;let o=r,i=s;return typeof o>"u"&&(o=0),typeof i>"u"&&(i=0),D(this,Je(n,o,i))}scale(e,r,s){const n=e;let o=r,i=s;return typeof o>"u"&&(o=e),typeof i>"u"&&(i=1),D(this,Xe(n,o,i))}rotate(e,r,s){let n=e,o=r||0,i=s||0;return typeof e=="number"&&typeof r>"u"&&typeof s>"u"&&(i=n,n=0,o=0),D(this,Ke(n,o,i))}rotateAxisAngle(e,r,s,n){if([e,r,s,n].some(o=>Number.isNaN(+o)))throw new TypeError("CSSMatrix: expecting 4 values");return D(this,We(e,r,s,n))}skewX(e){return D(this,Ye(e))}skewY(e){return D(this,et(e))}skew(e,r){return D(this,me(e,r))}transformPoint(e){const r=this.m11*e.x+this.m21*e.y+this.m31*e.z+this.m41*e.w,s=this.m12*e.x+this.m22*e.y+this.m32*e.z+this.m42*e.w,n=this.m13*e.x+this.m23*e.y+this.m33*e.z+this.m43*e.w,o=this.m14*e.x+this.m24*e.y+this.m34*e.z+this.m44*e.w;return e instanceof DOMPoint?new DOMPoint(r,s,n,o):{x:r,y:s,z:n,w:o}}}I(P,"Translate",Je),I(P,"Rotate",Ke),I(P,"RotateAxisAngle",We),I(P,"Scale",Xe),I(P,"SkewX",Ye),I(P,"SkewY",et),I(P,"Skew",me),I(P,"Multiply",D),I(P,"fromArray",te),I(P,"fromMatrix",Ue),I(P,"fromString",Ge),I(P,"toArray",Ne),I(P,"isCompatibleArray",He),I(P,"isCompatibleObject",Fe);const Z=(t,e,r)=>{const[s,n]=t,[o,i]=e;return[s+(o-s)*r,n+(i-n)*r]},ue=(t,e)=>Math.sqrt((t[0]-e[0])*(t[0]-e[0])+(t[1]-e[1])*(t[1]-e[1])),ne=(t,e,r,s)=>ue([t,e],[r,s]),we=(t,e,r,s,n)=>{let o={x:t,y:e};if(typeof n=="number"){const i=ue([t,e],[r,s]);if(n<=0)o={x:t,y:e};else if(n>=i)o={x:r,y:s};else{const[l,c]=Z([t,e],[r,s],n/i);o={x:l,y:c}}}return o},Le=(t,e,r,s)=>{const{min:n,max:o}=Math;return[n(t,r),n(e,s),o(t,r),o(e,s)]},_t=Object.freeze(Object.defineProperty({__proto__:null,getLineBBox:Le,getLineLength:ne,getPointAtLineLength:we},Symbol.toStringTag,{value:"Module"})),Te=(t,e,r)=>{const s=r/2,n=Math.sin(s),o=Math.cos(s),i=t**2*n**2,l=e**2*o**2,c=Math.sqrt(i+l)*r;return Math.abs(c)},U=(t,e,r,s,n,o)=>{const{sin:i,cos:l}=Math,c=l(n),a=i(n),m=r*l(o),h=s*i(o);return[t+c*m-a*h,e+a*m+c*h]},ve=(t,e)=>{const{x:r,y:s}=t,{x:n,y:o}=e,i=r*n+s*o,l=Math.sqrt((r**2+s**2)*(n**2+o**2));return(r*o-s*n<0?-1:1)*Math.acos(i/l)},he=(t,e,r,s,n,o,i,l,c)=>{const{abs:a,sin:m,cos:h,sqrt:f,PI:y}=Math;let u=a(r),g=a(s);const b=(n%360+360)%360*(y/180);if(t===l&&e===c)return{rx:u,ry:g,startAngle:0,endAngle:0,center:{x:l,y:c}};if(u===0||g===0)return{rx:u,ry:g,startAngle:0,endAngle:0,center:{x:(l+t)/2,y:(c+e)/2}};const M=(t-l)/2,d=(e-c)/2,x={x:h(b)*M+m(b)*d,y:-m(b)*M+h(b)*d},A=x.x**2/u**2+x.y**2/g**2;A>1&&(u*=f(A),g*=f(A));const S=u**2*g**2-u**2*x.y**2-g**2*x.x**2,j=u**2*x.y**2+g**2*x.x**2;let $=S/j;$=$<0?0:$;const T=(o!==i?1:-1)*f($),N={x:T*(u*x.y/g),y:T*(-(g*x.x)/u)},R={x:h(b)*N.x-m(b)*N.y+(t+l)/2,y:m(b)*N.x+h(b)*N.y+(e+c)/2},J={x:(x.x-N.x)/u,y:(x.y-N.y)/g},z=ve({x:1,y:0},J),C={x:(-x.x-N.x)/u,y:(-x.y-N.y)/g};let q=ve(J,C);!i&&q>0?q-=2*y:i&&q<0&&(q+=2*y),q%=2*y;const Q=z+q;return{center:R,startAngle:z,endAngle:Q,rx:u,ry:g}},je=(t,e,r,s,n,o,i,l,c)=>{const{rx:a,ry:m,startAngle:h,endAngle:f}=he(t,e,r,s,n,o,i,l,c);return Te(a,m,f-h)},tt=(t,e,r,s,n,o,i,l,c,a)=>{let m={x:t,y:e};const{center:h,rx:f,ry:y,startAngle:u,endAngle:g}=he(t,e,r,s,n,o,i,l,c);if(typeof a=="number"){const p=Te(f,y,g-u);if(a<=0)m={x:t,y:e};else if(a>=p)m={x:l,y:c};else{if(t===l&&e===c)return{x:l,y:c};if(f===0||y===0)return we(t,e,l,c,a);const{PI:b,cos:M,sin:d}=Math,x=g-u,S=(n%360+360)%360*(b/180),j=u+x*(a/p),$=f*M(j),T=y*d(j);m={x:M(S)*$-d(S)*T+h.x,y:d(S)*$+M(S)*T+h.y}}}return m},nt=(t,e,r,s,n,o,i,l,c)=>{const{center:a,rx:m,ry:h,startAngle:f,endAngle:y}=he(t,e,r,s,n,o,i,l,c),u=y-f,{min:g,max:p,tan:b,atan2:M,PI:d}=Math,{x,y:A}=a,S=n*d/180,j=b(S),$=M(-h*j,m),T=$,N=$+d,R=M(h,m*j),J=R+d,z=[l],C=[c];let q=g(t,l),Q=p(t,l),E=g(e,c),B=p(e,c);const ee=y-u*1e-5,K=U(x,A,m,h,S,ee),w=y-u*.99999,k=U(x,A,m,h,S,w);if(K[0]>Q||k[0]>Q){const v=U(x,A,m,h,S,T);z.push(v[0]),C.push(v[1])}if(K[0]B||k[1]>B){const v=U(x,A,m,h,S,R);z.push(v[0]),C.push(v[1])}return q=g.apply([],z),E=g.apply([],C),Q=p.apply([],z),B=p.apply([],C),[q,E,Q,B]},Rt=Object.freeze(Object.defineProperty({__proto__:null,angleBetween:ve,arcLength:Te,arcPoint:U,getArcBBox:nt,getArcLength:je,getArcProps:he,getPointAtArcLength:tt},Symbol.toStringTag,{value:"Module"})),$e=[-.06405689286260563,.06405689286260563,-.1911188674736163,.1911188674736163,-.3150426796961634,.3150426796961634,-.4337935076260451,.4337935076260451,-.5454214713888396,.5454214713888396,-.6480936519369755,.6480936519369755,-.7401241915785544,.7401241915785544,-.820001985973903,.820001985973903,-.8864155270044011,.8864155270044011,-.9382745520027328,.9382745520027328,-.9747285559713095,.9747285559713095,-.9951872199970213,.9951872199970213],rt=[.12793819534675216,.12793819534675216,.1258374563468283,.1258374563468283,.12167047292780339,.12167047292780339,.1155056680537256,.1155056680537256,.10744427011596563,.10744427011596563,.09761865210411388,.09761865210411388,.08619016153195327,.08619016153195327,.0733464814110803,.0733464814110803,.05929858491543678,.05929858491543678,.04427743881741981,.04427743881741981,.028531388628933663,.028531388628933663,.0123412297999872,.0123412297999872],st=t=>{const e=[];for(let r=t,s=r.length,n=s-1;s>1;s-=1,n-=1){const o=[];for(let i=0;i{if(e===0)return t[0].t=0,t[0];const r=t.length-1;if(e===1)return t[r].t=1,t[r];const s=1-e;let n=t;if(r===0)return t[0].t=e,t[0];if(r===1)return{x:s*n[0].x+e*n[1].x,y:s*n[0].y+e*n[1].y,t:e};const o=s*s,i=e*e;let l=0,c=0,a=0,m=0;return r===2?(n=[n[0],n[1],n[2],{x:0,y:0}],l=o,c=s*e*2,a=i):r===3&&(l=o*s,c=o*e*3,a=s*i*3,m=e*i),{x:l*n[0].x+c*n[1].x+a*n[2].x+m*n[3].x,y:l*n[0].y+c*n[1].y+a*n[2].y+m*n[3].y,t:e}},it=(t,e)=>{const r=t(e),s=r.x*r.x+r.y*r.y;return Math.sqrt(s)},ct=t=>{const r=$e.length;let s=0;for(let n=0,o;n{const e=[];for(let s=0,n=t.length,o=2;sot(r[0],s))},lt=1e-8,fe=([t,e,r])=>{const s=Math.min(t,r),n=Math.max(t,r);if(e>=t?r>=e:r<=e)return[s,n];const o=(t*r-e*e)/(t-2*e+r);return o{const n=t-3*e+3*r-s;if(Math.abs(n)0&&m<1){const f=t*(1-m)*(1-m)*(1-m)+e*3*(1-m)*(1-m)*m+r*3*(1-m)*m*m+s*m*m*m;fc&&(c=f)}return[l,c]},Qt=Object.freeze(Object.defineProperty({__proto__:null,CBEZIER_MINMAX_EPSILON:lt,Cvalues:rt,Tvalues:$e,bezierLength:ct,calculateBezier:it,computeBezier:ot,deriveBezier:st,getBezierLength:re,minmaxC:ze,minmaxQ:fe},Symbol.toStringTag,{value:"Module"})),at=([t,e,r,s,n,o,i,l],c)=>{const a=1-c;return{x:a**3*t+3*a**2*c*r+3*a*c**2*n+c**3*i,y:a**3*e+3*a**2*c*s+3*a*c**2*o+c**3*l}},ye=(t,e,r,s,n,o,i,l)=>re([t,e,r,s,n,o,i,l]),mt=(t,e,r,s,n,o,i,l,c)=>{const a=typeof c=="number";let m={x:t,y:e};if(a){const h=re([t,e,r,s,n,o,i,l]);c<=0||(c>=h?m={x:i,y:l}:m=at([t,e,r,s,n,o,i,l],c/h))}return m},qe=(t,e,r,s,n,o,i,l)=>{const c=ze([t,r,n,i]),a=ze([e,s,o,l]);return[c[0],a[0],c[1],a[1]]},Zt=Object.freeze(Object.defineProperty({__proto__:null,getCubicBBox:qe,getCubicLength:ye,getPointAtCubicLength:mt,getPointAtCubicSegmentLength:at},Symbol.toStringTag,{value:"Module"})),ut=([t,e,r,s,n,o],i)=>{const l=1-i;return{x:l**2*t+2*l*i*r+i**2*n,y:l**2*e+2*l*i*s+i**2*o}},ge=(t,e,r,s,n,o)=>re([t,e,r,s,n,o]),ht=(t,e,r,s,n,o,i)=>{const l=typeof i=="number";let c={x:t,y:e};if(l){const a=re([t,e,r,s,n,o]);i<=0||(i>=a?c={x:n,y:o}:c=ut([t,e,r,s,n,o],i/a))}return c},ke=(t,e,r,s,n,o)=>{const i=fe([t,r,n]),l=fe([e,s,o]);return[i[0],l[0],i[1],l[1]]},Dt=Object.freeze(Object.defineProperty({__proto__:null,getPointAtQuadLength:ht,getPointAtQuadSegmentLength:ut,getQuadBBox:ke,getQuadLength:ge},Symbol.toStringTag,{value:"Module"})),Bt=Object.freeze(Object.defineProperty({__proto__:null,polygonArea:t=>{const e=t.length;let r=-1,s,n=t[e-1],o=0;for(;++rt.reduce((e,r,s)=>s?e+ue(t[s-1],r):0,0)},Symbol.toStringTag,{value:"Module"})),W={a:7,c:6,h:1,l:2,m:2,r:4,q:4,s:4,t:2,v:1,z:0},Ie=t=>{let e=t.pathValue[t.segmentStart],r=e.toLowerCase();const{data:s}=t;for(;s.length>=W[r]&&(r==="m"&&s.length>2?(t.segments.push([e].concat(s.splice(0,2))),r="l",e=e==="m"?"l":"L"):t.segments.push([e].concat(s.splice(0,W[r]))),!!W[r]););},O="SVGPathCommander Error",ft=t=>{const{index:e,pathValue:r}=t,s=r.charCodeAt(e);if(s===48){t.param=0,t.index+=1;return}if(s===49){t.param=1,t.index+=1;return}t.err=`${O}: invalid Arc flag "${r[e]}", expecting 0 or 1 at index ${e}`},H=t=>t>=48&&t<=57,F="Invalid path value",yt=t=>{const{max:e,pathValue:r,index:s}=t;let n=s,o=!1,i=!1,l=!1,c=!1,a;if(n>=e){t.err=`${O}: ${F} at index ${n}, "pathValue" is missing param`;return}if(a=r.charCodeAt(n),(a===43||a===45)&&(n+=1,a=r.charCodeAt(n)),!H(a)&&a!==46){t.err=`${O}: ${F} at index ${n}, "${r[n]}" is not a number`;return}if(a!==46){if(o=a===48,n+=1,a=r.charCodeAt(n),o&&n[5760,6158,8192,8193,8194,8195,8196,8197,8198,8199,8200,8201,8202,8239,8287,12288,65279,10,13,8232,8233,32,9,11,12,160].includes(t),X=t=>{const{pathValue:e,max:r}=t;for(;t.index{switch(t|32){case 109:case 122:case 108:case 104:case 118:case 99:case 115:case 113:case 116:case 97:return!0;default:return!1}},xt=t=>H(t)||t===43||t===45||t===46,pt=t=>(t|32)===97,bt=t=>{switch(t|32){case 109:case 77:return!0;default:return!1}},Ee=t=>{var c;const{max:e,pathValue:r,index:s,segments:n}=t,o=r.charCodeAt(s),i=W[r[s].toLowerCase()];if(t.segmentStart=s,!dt(o)){t.err=`${O}: ${F} "${r[s]}" is not a path command at index ${s}`;return}const l=n[n.length-1];if(!bt(o)&&((c=l==null?void 0:l[0])==null?void 0:c.toLocaleLowerCase())==="z"){t.err=`${O}: ${F} "${r[s]}" is not a MoveTo path command at index ${s}`;return}if(t.index+=1,X(t),t.data=[],!i){Ie(t);return}for(;;){for(let a=i;a>0;a-=1){if(pt(o)&&(a===3||a===4)?ft(t):yt(t),t.err.length)return;t.data.push(t.param),X(t),t.index=t.max||!xt(r.charCodeAt(t.index)))break}Ie(t)};class Oe{constructor(e){this.segments=[],this.pathValue=e,this.max=e.length,this.index=0,this.param=0,this.segmentStart=0,this.data=[],this.err=""}}const V=t=>{if(typeof t!="string")return t.slice(0);const e=new Oe(t);for(X(e);e.index{const[n]=t,o=n.toUpperCase();if(e===0||o===n)return t;if(o==="A")return[o,t[1],t[2],t[3],t[4],t[5],t[6]+r,t[7]+s];if(o==="V")return[o,t[1]+s];if(o==="H")return[o,t[1]+r];if(o==="L")return[o,t[1]+r,t[2]+s];{const l=[],c=t.length;for(let a=1;a{let r=t.length,s,n="M",o="M",i=!1,l=0,c=0,a=0,m=0,h=0;for(let f=0;f{const e=V(t);return _(e,se)},Ve=(t,e,r,s)=>{const[n]=t,o=n.toLowerCase();if(e===0||n===o)return t;if(o==="a")return[o,t[1],t[2],t[3],t[4],t[5],t[6]-r,t[7]-s];if(o==="v")return[o,t[1]-s];if(o==="h")return[o,t[1]-r];if(o==="l")return[o,t[1]-r,t[2]-s];{const l=[],c=t.length;for(let a=1;a{const e=V(t);return _(e,Ve)},oe=(t,e,r)=>{const{sin:s,cos:n}=Math,o=t*n(r)-e*s(r),i=t*s(r)+e*n(r);return{x:o,y:i}},xe=(t,e,r,s,n,o,i,l,c,a)=>{let m=t,h=e,f=r,y=s,u=l,g=c;const p=Math.PI*120/180,b=Math.PI/180*(+n||0);let M=[],d,x,A,S,j;if(a)[x,A,S,j]=a;else{d=oe(m,h,-b),m=d.x,h=d.y,d=oe(u,g,-b),u=d.x,g=d.y;const w=(m-u)/2,k=(h-g)/2;let v=w*w/(f*f)+k*k/(y*y);v>1&&(v=Math.sqrt(v),f*=v,y*=v);const De=f*f,Be=y*y,It=(o===i?-1:1)*Math.sqrt(Math.abs((De*Be-De*k*k-Be*w*w)/(De*k*k+Be*w*w)));S=It*f*k/y+(m+u)/2,j=It*-y*w/f+(h+g)/2,x=Math.asin(((h-j)/y*10**9>>0)/10**9),A=Math.asin(((g-j)/y*10**9>>0)/10**9),x=mA&&(x-=Math.PI*2),!i&&A>x&&(A-=Math.PI*2)}let $=A-x;if(Math.abs($)>p){const w=A,k=u,v=g;A=x+p*(i&&A>x?1:-1),u=S+f*Math.cos(A),g=j+y*Math.sin(A),M=xe(u,g,f,y,n,0,i,k,v,[A,w,S,j])}$=A-x;const T=Math.cos(x),N=Math.sin(x),R=Math.cos(A),J=Math.sin(A),z=Math.tan($/4),C=4/3*f*z,q=4/3*y*z,Q=[m,h],E=[m+C*N,h-q*T],B=[u+C*J,g-q*R],ee=[u,g];if(E[0]=2*Q[0]-E[0],E[1]=2*Q[1]-E[1],a)return[E[0],E[1],B[0],B[1],ee[0],ee[1]].concat(M);M=[E[0],E[1],B[0],B[1],ee[0],ee[1]].concat(M);const K=[];for(let w=0,k=M.length;w{const i=.3333333333333333,l=2/3;return[i*t+l*r,i*e+l*s,i*n+l*r,i*o+l*s,n,o]},_e=(t,e,r,s)=>{const n=Z([t,e],[r,s],.3333333333333333),o=Z([t,e],[r,s],2/3);return[n[0],n[1],o[0],o[1],r,s]},Ct=(t,e)=>{const[r]=t,s=t.slice(1).map(Number),[n,o]=s,{x1:i,y1:l,x:c,y:a}=e;return"TQ".includes(r)||(e.qx=null,e.qy=null),r==="M"?(e.x=n,e.y=o,t):r==="A"?["C"].concat(xe(i,l,s[0],s[1],s[2],s[3],s[4],s[5],s[6])):r==="Q"?(e.qx=n,e.qy=o,["C"].concat(At(i,l,s[0],s[1],s[2],s[3]))):r==="L"?["C"].concat(_e(i,l,n,o)):r==="Z"?["C"].concat(_e(i,l,c,a)):t},pe=(t,e)=>{const[r]=t,s=r.toUpperCase(),n=r!==s,{x1:o,y1:i,x2:l,y2:c,x:a,y:m}=e,h=t.slice(1);let f=h.map((y,u)=>y+(n?u%2?m:a:0));if("TQ".includes(s)||(e.qx=null,e.qy=null),s==="A")return f=h.slice(0,-2).concat(h[5]+(n?a:0),h[6]+(n?m:0)),["A"].concat(f);if(s==="H")return["L",t[1]+(n?a:0),i];if(s==="V")return["L",o,t[1]+(n?m:0)];if(s==="L")return["L",t[1]+(n?a:0),t[2]+(n?m:0)];if(s==="M")return["M",t[1]+(n?a:0),t[2]+(n?m:0)];if(s==="C")return["C"].concat(f);if(s==="S"){const y=o*2-l,u=i*2-c;return e.x1=y,e.y1=u,["C",y,u].concat(f)}else if(s==="T"){const y=o*2-(e.qx?e.qx:0),u=i*2-(e.qy?e.qy:0);return e.qx=y,e.qy=u,["Q",y,u].concat(f)}else if(s==="Q"){const[y,u]=f;return e.qx=y,e.qy=u,["Q"].concat(f)}else if(s==="Z")return["Z"];return t},ie={x1:0,y1:0,x2:0,y2:0,x:0,y:0,qx:null,qy:null},be=t=>{const e={...ie},r=V(t);return _(r,(s,n,o,i)=>{e.x=o,e.y=i;const l=pe(s,e);let c=Ct(l,e);c[0]==="C"&&c.length>7&&(r.splice(n+1,0,["C"].concat(c.slice(7))),c=c.slice(0,7));const m=c.length;return e.x1=+c[m-2],e.y1=+c[m-1],e.x2=+c[m-4]||e.x1,e.y2=+c[m-3]||e.y1,c})},G={origin:[0,0,0],round:4},L=(t,e)=>{const r=e>=1?10**e:1;return e>0?Math.round(t*r)/r:Math.round(t)},Re=(t,e)=>{const r=t.length;let{round:s}=G,n=t[0],o="";s=e==="off"||typeof e=="number"&&e>=0?e:typeof s=="number"&&s>=0?s:"off";for(let i=0;i{const e=V(t),r={...ie};return _(e,(s,n,o,i)=>{r.x=o,r.y=i;const l=pe(s,r),c=l.length;return r.x1=+l[c-2],r.y1=+l[c-1],r.x2=+l[c-4]||r.x1,r.y2=+l[c-3]||r.y1,l})},le=(t,e)=>{const r=ce(t);let s=!1,n=[],o="M",i=0,l=0,[c,a]=r[0].slice(1);const m=typeof e=="number";let h={x:c,y:a},f=0,y=h,u=0;return!m||e{if([o]=g,s=o==="M",n=s?n:[b,M].concat(g.slice(1)),s?([,c,a]=g,h={x:c,y:a},f=0):o==="L"?(h=we(n[0],n[1],n[2],n[3],e-u),f=ne(n[0],n[1],n[2],n[3])):o==="A"?(h=tt(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7],n[8],e-u),f=je(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7],n[8])):o==="C"?(h=mt(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7],e-u),f=ye(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7])):o==="Q"?(h=ht(n[0],n[1],n[2],n[3],n[4],n[5],e-u),f=ge(n[0],n[1],n[2],n[3],n[4],n[5])):o==="Z"&&(n=[b,M,c,a],h={x:c,y:a},f=ne(n[0],n[1],n[2],n[3])),[i,l]=n.slice(-2),uu-Me?{x:i,y:l}:y)},Y=t=>{const e=V(t);let r=0,s=0,n=0,o=0,i=0,l=0,c="M",a=0,m=0,h=0;return _(e,(f,y,u,g)=>{[c]=f;const p=c.toUpperCase(),M=p!==c?se(f,y,u,g):f.slice(0),d=p==="V"?["L",u,M[1]]:p==="H"?["L",M[1],g]:M;if([c]=d,"TQ".includes(p)||(i=0,l=0),c==="M")[,a,m]=d;else if(c==="L")h+=ne(u,g,d[1],d[2]);else if(c==="A")h+=je(u,g,d[1],d[2],d[3],d[4],d[5],d[6],d[7]);else if(c==="S"){const x=r*2-n,A=s*2-o;h+=ye(u,g,x,A,d[1],d[2],d[3],d[4])}else c==="C"?h+=ye(u,g,d[1],d[2],d[3],d[4],d[5],d[6]):c==="T"?(i=r*2-i,l=s*2-l,h+=ge(u,g,i,l,d[1],d[2])):c==="Q"?(i=d[1],l=d[2],h+=ge(u,g,d[1],d[2],d[3],d[4])):c==="Z"&&(h+=ne(u,g,a,m));[r,s]=c==="Z"?[a,m]:d.slice(-2),[n,o]=c==="C"?[d[3],d[4]]:c==="S"?[d[1],d[2]]:[r,s]}),h},Qe=(t,e)=>{const r=V(t);let s=r.slice(0),n=Y(s),o=s.length-1,i=0,l=0,c=r[0];if(o<=0||!e||!Number.isFinite(e))return{segment:c,index:0,length:l,lengthAtSegment:i};if(e>=n)return s=r.slice(0,-1),i=Y(s),l=n-i,c=r[o],{segment:c,index:o,length:l,lengthAtSegment:i};const a=[];for(;o>0;)c=s[o],s=s.slice(0,-1),i=Y(s),l=n-i,n=i,a.push({segment:c,index:o,length:l,lengthAtSegment:i}),o-=1;return a.find(({lengthAtSegment:m})=>m<=e)},Ae=(t,e)=>{const r=V(t),s=ce(r),n=Y(s),o=x=>{const A=x.x-e.x,S=x.y-e.y;return A*A+S*S};let i=8,l,c={x:0,y:0},a=0,m=0,h=1/0;for(let x=0;x<=n;x+=i)l=le(s,x),a=o(l),a1e-6&&(u=m-i,f=le(s,u),p=o(f),g=m+i,y=le(s,g),b=o(y),u>=0&&pAe(t,e).closest,Ft=(t,e,r,s,n,o,i,l)=>3*((l-e)*(r+n)-(i-t)*(s+o)+s*(t-n)-r*(e-o)+l*(n+t/3)-i*(o+e/3))/20,St=t=>{let e=0,r=0,s=0;return be(t).map(n=>{switch(n[0]){case"M":return[,e,r]=n,0;default:return s=Ft(e,r,n[1],n[2],n[3],n[4],n[5],n[6]),[e,r]=n.slice(-2),s}}).reduce((n,o)=>n+o,0)},Ut=t=>St(be(t))>=0,Pt=t=>{if(!t)return{x:0,y:0,width:0,height:0,x2:0,y2:0,cx:0,cy:0,cz:0};const e=V(t);let r="M",s=0,n=0;const{max:o,min:i}=Math;let l=1/0,c=1/0,a=-1/0,m=-1/0,h=0,f=0,y=0,u=0,g=0,p=0,b=0,M=0,d=0,x=0;_(e,(j,$,T,N)=>{[r]=j;const R=r.toUpperCase(),z=R!==r?se(j,$,T,N):j.slice(0),C=R==="V"?["L",T,z[1]]:R==="H"?["L",z[1],N]:z;if([r]=C,"TQ".includes(R)||(d=0,x=0),r==="M")[,s,n]=C,h=s,f=n,y=s,u=n;else if(r==="L")[h,f,y,u]=Le(T,N,C[1],C[2]);else if(r==="A")[h,f,y,u]=nt(T,N,C[1],C[2],C[3],C[4],C[5],C[6],C[7]);else if(r==="S"){const q=g*2-b,Q=p*2-M;[h,f,y,u]=qe(T,N,q,Q,C[1],C[2],C[3],C[4])}else r==="C"?[h,f,y,u]=qe(T,N,C[1],C[2],C[3],C[4],C[5],C[6]):r==="T"?(d=g*2-d,x=p*2-x,[h,f,y,u]=ke(T,N,d,x,C[1],C[2])):r==="Q"?(d=C[1],x=C[2],[h,f,y,u]=ke(T,N,C[1],C[2],C[3],C[4])):r==="Z"&&([h,f,y,u]=Le(T,N,s,n));l=i(h,l),c=i(f,c),a=o(y,a),m=o(u,m),[g,p]=r==="Z"?[s,n]:C.slice(-2),[b,M]=r==="C"?[C[3],C[4]]:r==="S"?[C[1],C[2]]:[g,p]});const A=a-l,S=m-c;return{width:A,height:S,x:l,y:c,x2:a,y2:m,cx:l+A/2,cy:c+S/2,cz:Math.max(A,S)+Math.min(A,S)/2}},Gt=(t,e)=>Qe(t,e).segment,Jt=(t,e)=>Ae(t,e).segment,Ce=t=>Array.isArray(t)&&t.every(e=>{const r=e[0].toLowerCase();return W[r]===e.length-1&&"achlmqstvz".includes(r)&&e.slice(1).every(Number.isFinite)})&&t.length>0,Nt=t=>Ce(t)&&t.every(([e])=>e===e.toUpperCase()),wt=t=>Nt(t)&&t.every(([e])=>"ACLMQZ".includes(e)),Kt=t=>wt(t)&&t.every(([e])=>"MC".includes(e)),Wt=(t,e)=>{const{distance:r}=Ae(t,e);return Math.abs(r)Ce(t)&&t.slice(1).every(([e])=>e===e.toLowerCase()),Lt=t=>{if(typeof t!="string"||!t.length)return!1;const e=new Oe(t);for(X(e);e.indext!=null&&typeof t=="object"&&t.nodeType===1,Yt=t=>{let{x1:e,y1:r,x2:s,y2:n}=t;return[e,r,s,n]=[e,r,s,n].map(o=>+o),[["M",e,r],["L",s,n]]},en=t=>{const e=[],r=(t.points||"").trim().split(/[\s|,]/).map(n=>+n);let s=0;for(;s{let{cx:e,cy:r,r:s}=t;return[e,r,s]=[e,r,s].map(n=>+n),[["M",e-s,r],["a",s,s,0,1,0,2*s,0],["a",s,s,0,1,0,-2*s,0]]},nn=t=>{let{cx:e,cy:r}=t,s=t.rx||0,n=t.ry||s;return[e,r,s,n]=[e,r,s,n].map(o=>+o),[["M",e-s,r],["a",s,n,0,1,0,2*s,0],["a",s,n,0,1,0,-2*s,0]]},rn=t=>{const e=+t.x||0,r=+t.y||0,s=+t.width,n=+t.height;let o=+(t.rx||0),i=+(t.ry||o);return o||i?(o*2>s&&(o-=(o*2-s)/2),i*2>n&&(i-=(i*2-n)/2),[["M",e+o,r],["h",s-o*2],["s",o,0,o,i],["v",n-i*2],["s",0,i,-o,i],["h",-s+o*2],["s",-o,0,-o,-i],["v",-n+i*2],["s",0,-i,o,-i]]):[["M",e,r],["h",s],["v",n],["H",e],["Z"]]},vt=t=>{const e=Object.keys(ae),r=Tt(t),s=r?t.tagName:null;if(s&&[...e,"path"].every(c=>s!==c))throw TypeError(`${O}: "${s}" is not SVGElement`);const n=r?s:t.type,o=ae[n],i={type:n};r?o.forEach(c=>{i[c]=t.getAttribute(c)}):Object.assign(i,t);let l=[];return n==="circle"?l=tn(i):n==="ellipse"?l=nn(i):["polyline","polygon"].includes(n)?l=en(i):n==="rect"?l=rn(i):n==="line"?l=Yt(i):["glyph","path"].includes(n)&&(l=V(r?t.getAttribute("d")||"":t.d||"")),Ce(l)&&l.length?l:!1},sn=(t,e,r)=>{const s=r||document,n=Object.keys(ae),o=Tt(t),i=o?t.tagName:null;if(i==="path")throw TypeError(`${O}: "${i}" is already SVGPathElement`);if(i&&n.every(u=>i!==u))throw TypeError(`${O}: "${i}" is not SVGElement`);const l=s.createElementNS("http://www.w3.org/2000/svg","path"),c=o?i:t.type,a=ae[c],m={type:c},h=G.round,f=vt(t),y=f&&f.length?Re(f,h):"";return o?(a.forEach(u=>{m[u]=t.getAttribute(u)}),Object.values(t.attributes).forEach(({name:u,value:g})=>{a.includes(u)||l.setAttribute(u,g)})):(Object.assign(m,t),Object.keys(m).forEach(u=>{!a.includes(u)&&u!=="type"&&l.setAttribute(u.replace(/[A-Z]/g,g=>`-${g.toLowerCase()}`),m[u])})),Lt(y)?(l.setAttribute("d",y),e&&o&&(t.before(l,t),t.remove()),l):!1},jt=t=>{let e=new P;const{origin:r}=t,[s,n]=r,{translate:o}=t,{rotate:i}=t,{skew:l}=t,{scale:c}=t;return Array.isArray(o)&&o.length>=2&&o.every(a=>!Number.isNaN(+a))&&o.some(a=>a!==0)?e=e.translate(...o):typeof o=="number"&&!Number.isNaN(o)&&(e=e.translate(o)),(i||l||c)&&(e=e.translate(s,n),Array.isArray(i)&&i.length>=2&&i.every(a=>!Number.isNaN(+a))&&i.some(a=>a!==0)?e=e.rotate(...i):typeof i=="number"&&!Number.isNaN(i)&&(e=e.rotate(i)),Array.isArray(l)&&l.length===2&&l.every(a=>!Number.isNaN(+a))&&l.some(a=>a!==0)?(e=l[0]?e.skewX(l[0]):e,e=l[1]?e.skewY(l[1]):e):typeof l=="number"&&!Number.isNaN(l)&&(e=e.skewX(l)),Array.isArray(c)&&c.length>=2&&c.every(a=>!Number.isNaN(+a))&&c.some(a=>a!==1)?e=e.scale(...c):typeof c=="number"&&!Number.isNaN(c)&&(e=e.scale(c)),e=e.translate(-s,-n)),e},$t=(t,e,r,s)=>{const[n]=t,{round:o}=G,i=o,l=e.slice(1),{x1:c,y1:a,x2:m,y2:h,x:f,y}=r,[u,g]=l.slice(-2),p=t;if("TQ".includes(n)||(r.qx=null,r.qy=null),n==="L"){if(L(f,i)===L(u,i))return["V",g];if(L(y,i)===L(g,i))return["H",u]}else if(n==="C"){const[b,M]=l;if(r.x1=b,r.y1=M,"CS".includes(s)&&(L(b,i)===L(c*2-m,i)&&L(M,i)===L(a*2-h,i)||L(c,i)===L(m*2-f,i)&&L(a,i)===L(h*2-y,i)))return["S",l[2],l[3],l[4],l[5]]}else if(n==="Q"){const[b,M]=l;if(r.qx=b,r.qy=M,"QT".includes(s)&&L(b,i)===L(c*2-m,i)&&L(M,i)===L(a*2-h,i))return["T",l[2],l[3]]}return p},Se=(t,e)=>{const r=t.slice(1).map(s=>L(s,e));return[t[0]].concat(r)},zt=(t,e)=>{const r=de(t),s=typeof e=="number"&&e>=0?e:2,n={...ie},o=[];let i="M",l="Z";return _(r,(c,a,m,h)=>{n.x=m,n.y=h;const f=pe(c,n);let y=c;if([i]=c,o[a]=i,a){l=o[a-1];const g=$t(c,f,n,l),p=Se(g,s),b=p.join(""),M=Ve(g,a,m,h),d=Se(M,s),x=d.join("");y=b.length{let r=P.Translate(e[0],e[1],e[2]);return[,,,r.m44]=e,r=t.multiply(r),[r.m41,r.m42,r.m43,r.m44]},Ze=(t,e,r)=>{const[s,n,o]=r,[i,l,c]=on(t,[e[0],e[1],0,1]),a=i-s,m=l-n,h=c-o;return[a*(Math.abs(o)/Math.abs(h)||1)+s,m*(Math.abs(o)/Math.abs(h)||1)+n]},cn=t=>{const e=t.slice(1).map((r,s,n)=>s?n[s-1].slice(-2).concat(r.slice(1)):t[0].slice(1).concat(r.slice(1))).map(r=>r.map((s,n)=>r[r.length-n-2*(1-n%2)])).reverse();return[["M"].concat(e[0].slice(0,2))].concat(e.map(r=>["C"].concat(r.slice(2))))},Pe=t=>{const e=de(t),r=ce(e),s=e.length,n=e[s-1][0]==="Z",o=_(e,(i,l)=>{const c=r[l],a=l&&e[l-1],m=a&&a[0],h=e[l+1],f=h&&h[0],[y]=i,[u,g]=r[l?l-1:s-1].slice(-2);let p=i;switch(y){case"M":p=n?["Z"]:[y,u,g];break;case"A":p=[y,i[1],i[2],i[3],i[4],i[5]===1?0:1,u,g];break;case"C":h&&f==="S"?p=["S",i[1],i[2],u,g]:p=[y,i[3],i[4],i[1],i[2],u,g];break;case"S":m&&"CS".includes(m)&&(!h||f!=="S")?p=["C",c[3],c[4],c[1],c[2],u,g]:p=[y,c[1],c[2],u,g];break;case"Q":h&&f==="T"?p=["T",u,g]:p=[y,i[1],i[2],u,g];break;case"T":m&&"QT".includes(m)&&(!h||f!=="T")?p=["Q",c[1],c[2],u,g]:p=[y,u,g];break;case"Z":p=["M",u,g];break;case"H":p=[y,u];break;case"V":p=[y,g];break;default:p=[y].concat(i.slice(1,-2),u,g)}return p});return n?o.reverse():[o[0]].concat(o.slice(1).reverse())},ln=(t,e)=>{let{round:r}=G;return r=e==="off"||typeof e=="number"&&e>=0?e:typeof r=="number"&&r>=0?r:"off",r==="off"?t.slice(0):_(t,s=>Se(s,r))},an=(t,e=.5)=>{const r=e,s=t.slice(0,2),n=t.slice(2,4),o=t.slice(4,6),i=t.slice(6,8),l=Z(s,n,r),c=Z(n,o,r),a=Z(o,i,r),m=Z(l,c,r),h=Z(c,a,r),f=Z(m,h,r);return[["C",l[0],l[1],m[0],m[1],f[0],f[1]],["C",h[0],h[1],a[0],a[1],i[0],i[1]]]},qt=t=>{const e=[];let r,s=-1,n=0,o=0,i=0,l=0;const c={...ie};return t.forEach(a=>{const[m]=a,h=m.toUpperCase(),f=m.toLowerCase(),y=m===f,u=a.slice(1);h==="M"?(s+=1,[n,o]=u,n+=y?c.x:0,o+=y?c.y:0,i=n,l=o,r=[y?[h,i,l]:a]):(h==="Z"?(n=i,o=l):h==="H"?([,n]=a,n+=y?c.x:0):h==="V"?([,o]=a,o+=y?c.y:0):([n,o]=a.slice(-2),n+=y?c.x:0,o+=y?c.y:0),r.push(a)),c.x=n,c.y=o,e[s]=r}),e},kt=(t,e)=>{let r=0,s=0,n=0,o=0,i=0,l=0,c="M";const a=V(t),m=e&&Object.keys(e);if(!e||m&&!m.length)return a.slice(0);e.origin||Object.assign(e,{origin:G.origin});const h=e.origin,f=jt(e);return f.isIdentity?a.slice(0):_(a,(y,u,g,p)=>{[c]=y;const b=c.toUpperCase(),d=b!==c?se(y,u,g,p):y.slice(0);let x=b==="A"?["C"].concat(xe(g,p,d[1],d[2],d[3],d[4],d[5],d[6],d[7])):b==="V"?["L",g,d[1]]:b==="H"?["L",d[1],p]:d;c=x[0];const A=c==="C"&&x.length>7,S=A?x.slice(0,7):x.slice(0);if(A&&(a.splice(u+1,0,["C"].concat(x.slice(7))),x=S),c==="L")[n,o]=Ze(f,[x[1],x[2]],h),r!==n&&s!==o?x=["L",n,o]:s===o?x=["H",n]:r===n&&(x=["V",o]);else for(i=1,l=x.length;i"u";if(n||!e.length)throw TypeError(`${O}: "pathValue" is ${n?"undefined":"empty"}`);this.segments=V(e);const{round:o,origin:i}=s;let l;Number.isInteger(o)||o==="off"?l=o:l=G.round;let c=G.origin;if(Array.isArray(i)&&i.length>=2){const[a,m,h]=i.map(Number);c=[Number.isNaN(a)?0:a,Number.isNaN(m)?0:m,Number.isNaN(h)?0:h]}return this.round=l,this.origin=c,this}get bbox(){return Pt(this.segments)}get length(){return Y(this.segments)}getBBox(){return this.bbox}getTotalLength(){return this.length}getPointAtLength(e){return le(this.segments,e)}toAbsolute(){const{segments:e}=this;return this.segments=de(e),this}toRelative(){const{segments:e}=this;return this.segments=Mt(e),this}toCurve(){const{segments:e}=this;return this.segments=be(e),this}reverse(e){const{segments:r}=this,s=qt(r),n=s.length>1?s:!1,o=n?n.map((l,c)=>e?c?Pe(l):l.slice(0):Pe(l)):r.slice(0);let i=[];return n?i=o.flat(1):i=e?r:Pe(r),this.segments=i.slice(0),this}normalize(){const{segments:e}=this;return this.segments=ce(e),this}optimize(){const{segments:e}=this,r=this.round==="off"?2:this.round;return this.segments=zt(e,r),this}transform(e){if(!e||typeof e!="object"||typeof e=="object"&&!["translate","rotate","skew","scale"].some(c=>c in e))return this;const{segments:r,origin:[s,n,o]}=this,i={};for(const[c,a]of Object.entries(e))c==="skew"&&Array.isArray(a)||(c==="rotate"||c==="translate"||c==="origin"||c==="scale")&&Array.isArray(a)?i[c]=a.map(Number):c!=="origin"&&typeof Number(a)=="number"&&(i[c]=Number(a));const{origin:l}=i;if(Array.isArray(l)&&l.length>=2){const[c,a,m]=l.map(Number);i.origin=[Number.isNaN(c)?s:c,Number.isNaN(a)?n:a,m||o]}else i.origin=[s,n,o];return this.segments=kt(r,i),this}flipX(){const{cx:e,cy:r}=this.bbox;return this.transform({rotate:[0,180,0],origin:[e,r,0]}),this}flipY(){const{cx:e,cy:r}=this.bbox;return this.transform({rotate:[180,0,0],origin:[e,r,0]}),this}toString(){return Re(this.segments,this.round)}dispose(){Object.keys(this).forEach(e=>delete this[e])}}return Object.assign(un,mn)}(); -//# sourceMappingURL=svg-path-commander.js.map +"use strict";var SVGPathCommander=(()=>{var lt=Object.defineProperty;var or=Object.getOwnPropertyDescriptor;var ar=Object.getOwnPropertyNames;var mr=Object.prototype.hasOwnProperty;var te=(t,e)=>{for(var n in e)lt(t,n,{get:e[n],enumerable:!0})},sr=(t,e,n,o)=>{if(e&&typeof e=="object"||typeof e=="function")for(let r of ar(e))!mr.call(t,r)&&r!==n&<(t,r,{get:()=>e[r],enumerable:!(o=or(e,r))||o.enumerable});return t};var ir=t=>sr(lt({},"__esModule",{value:!0}),t);var On={};te(On,{default:()=>Vn});var Tt={};te(Tt,{CSSMatrix:()=>M,absolutizeSegment:()=>U,arcToCubic:()=>Ce,arcTools:()=>yt,bezierTools:()=>xt,cubicTools:()=>St,distanceEpsilon:()=>ge,distanceSquareRoot:()=>ce,finalizeSegment:()=>ze,getClosestPoint:()=>_t,getDrawDirection:()=>Ut,getPathArea:()=>Ke,getPathBBox:()=>We,getPointAtLength:()=>ae,getPropertiesAtLength:()=>Te,getPropertiesAtPoint:()=>me,getSVGMatrix:()=>nt,getSegmentAtLength:()=>Jt,getSegmentOfPoint:()=>Kt,getTotalLength:()=>W,invalidPathValue:()=>F,isAbsoluteArray:()=>Xe,isArcCommand:()=>Fe,isCurveArray:()=>Wt,isDigit:()=>H,isDigitStart:()=>He,isMoveCommand:()=>Ge,isNormalizedArray:()=>Ye,isPathArray:()=>se,isPathCommand:()=>Ze,isPointInStroke:()=>Xt,isRelativeArray:()=>Yt,isSpace:()=>Be,isValidPath:()=>et,iterate:()=>L,lineToCubic:()=>Re,lineTools:()=>ft,midPoint:()=>I,normalizePath:()=>K,normalizeSegment:()=>ne,optimizePath:()=>at,paramsCount:()=>G,paramsParser:()=>J,parsePathString:()=>T,pathParser:()=>ee,pathToAbsolute:()=>re,pathToCurve:()=>oe,pathToRelative:()=>_e,pathToString:()=>Me,polygonTools:()=>Mt,projection2d:()=>Ve,quadToCubic:()=>Ue,quadTools:()=>Ct,relativizeSegment:()=>Ae,reverseCurve:()=>tr,reversePath:()=>Le,rotateVector:()=>be,roundPath:()=>rr,roundSegment:()=>ye,roundTo:()=>v,scanFlag:()=>$e,scanParam:()=>je,scanSegment:()=>Se,segmentToCubic:()=>Je,shapeParams:()=>ie,shapeToPath:()=>er,shapeToPathArray:()=>rt,shortenSegment:()=>ot,skipSpaces:()=>_,splitCubic:()=>nr,splitPath:()=>mt,transformPath:()=>st});var ur=Object.defineProperty,lr=(t,e,n)=>e in t?ur(t,e,{enumerable:!0,configurable:!0,writable:!0,value:n}):t[e]=n,q=(t,e,n)=>lr(t,typeof e!="symbol"?e+"":e,n),cr={a:1,b:0,c:0,d:1,e:0,f:0,m11:1,m12:0,m13:0,m14:0,m21:0,m22:1,m23:0,m24:0,m31:0,m32:0,m33:1,m34:0,m41:0,m42:0,m43:0,m44:1,is2D:!0,isIdentity:!0},Nt=t=>(t instanceof Float64Array||t instanceof Float32Array||Array.isArray(t)&&t.every(e=>typeof e=="number"))&&[6,16].some(e=>t.length===e),wt=t=>t instanceof DOMMatrix||t instanceof M||typeof t=="object"&&Object.keys(cr).every(e=>t&&e in t),ve=t=>{let e=new M,n=Array.from(t);if(!Nt(n))throw TypeError(`CSSMatrix: "${n.join(",")}" must be an array with 6/16 numbers.`);if(n.length===16){let[o,r,a,m,i,s,u,l,f,p,h,c,b,d,x,P]=n;e.m11=o,e.a=o,e.m21=i,e.c=i,e.m31=f,e.m41=b,e.e=b,e.m12=r,e.b=r,e.m22=s,e.d=s,e.m32=p,e.m42=d,e.f=d,e.m13=a,e.m23=u,e.m33=h,e.m43=x,e.m14=m,e.m24=l,e.m34=c,e.m44=P}else if(n.length===6){let[o,r,a,m,i,s]=n;e.m11=o,e.a=o,e.m12=r,e.b=r,e.m21=a,e.c=a,e.m22=m,e.d=m,e.m41=i,e.e=i,e.m42=s,e.f=s}return e},kt=t=>{if(wt(t))return ve([t.m11,t.m12,t.m13,t.m14,t.m21,t.m22,t.m23,t.m24,t.m31,t.m32,t.m33,t.m34,t.m41,t.m42,t.m43,t.m44]);throw TypeError(`CSSMatrix: "${JSON.stringify(t)}" is not a DOMMatrix / CSSMatrix / JSON compatible object.`)},zt=t=>{if(typeof t!="string")throw TypeError(`CSSMatrix: "${JSON.stringify(t)}" is not a string.`);let e=String(t).replace(/\s/g,""),n=new M,o=`CSSMatrix: invalid transform string "${t}"`;return e.split(")").filter(r=>r).forEach(r=>{let[a,m]=r.split("(");if(!m)throw TypeError(o);let i=m.split(",").map(c=>c.includes("rad")?parseFloat(c)*(180/Math.PI):parseFloat(c)),[s,u,l,f]=i,p=[s,u,l],h=[s,u,l,f];if(a==="perspective"&&s&&[u,l].every(c=>c===void 0))n.m34=-1/s;else if(a.includes("matrix")&&[6,16].includes(i.length)&&i.every(c=>!Number.isNaN(+c))){let c=i.map(b=>Math.abs(b)<1e-6?0:b);n=n.multiply(ve(c))}else if(a==="translate3d"&&p.every(c=>!Number.isNaN(+c)))n=n.translate(s,u,l);else if(a==="translate"&&s&&l===void 0)n=n.translate(s,u||0,0);else if(a==="rotate3d"&&h.every(c=>!Number.isNaN(+c))&&f)n=n.rotateAxisAngle(s,u,l,f);else if(a==="rotate"&&s&&[u,l].every(c=>c===void 0))n=n.rotate(0,0,s);else if(a==="scale3d"&&p.every(c=>!Number.isNaN(+c))&&p.some(c=>c!==1))n=n.scale(s,u,l);else if(a==="scale"&&!Number.isNaN(s)&&(s!==1||u!==1)&&l===void 0){let c=Number.isNaN(+u)?s:u;n=n.scale(s,c,1)}else if(a==="skew"&&(s||!Number.isNaN(s)&&u)&&l===void 0)n=n.skew(s,u||0);else if(["translate","rotate","scale","skew"].some(c=>a.includes(c))&&/[XYZ]/.test(a)&&s&&[u,l].every(c=>c===void 0))if(a==="skewX"||a==="skewY")n=n[a](s);else{let c=a.replace(/[XYZ]/,""),b=a.replace(c,""),d=["X","Y","Z"].indexOf(b),x=c==="scale"?1:0,P=[d===0?s:x,d===1?s:x,d===2?s:x];n=n[c](...P)}else throw TypeError(o)}),n},ct=(t,e)=>e?[t.a,t.b,t.c,t.d,t.e,t.f]:[t.m11,t.m12,t.m13,t.m14,t.m21,t.m22,t.m23,t.m24,t.m31,t.m32,t.m33,t.m34,t.m41,t.m42,t.m43,t.m44],Rt=(t,e,n)=>{let o=new M;return o.m41=t,o.e=t,o.m42=e,o.f=e,o.m43=n,o},Vt=(t,e,n)=>{let o=new M,r=Math.PI/180,a=t*r,m=e*r,i=n*r,s=Math.cos(a),u=-Math.sin(a),l=Math.cos(m),f=-Math.sin(m),p=Math.cos(i),h=-Math.sin(i),c=l*p,b=-l*h;o.m11=c,o.a=c,o.m12=b,o.b=b,o.m13=f;let d=u*f*p+s*h;o.m21=d,o.c=d;let x=s*p-u*f*h;return o.m22=x,o.d=x,o.m23=-u*l,o.m31=u*h-s*f*p,o.m32=u*p+s*f*h,o.m33=s*l,o},Ot=(t,e,n,o)=>{let r=new M,a=Math.sqrt(t*t+e*e+n*n);if(a===0)return r;let m=t/a,i=e/a,s=n/a,u=o*(Math.PI/360),l=Math.sin(u),f=Math.cos(u),p=l*l,h=m*m,c=i*i,b=s*s,d=1-2*(c+b)*p;r.m11=d,r.a=d;let x=2*(m*i*p+s*l*f);r.m12=x,r.b=x,r.m13=2*(m*s*p-i*l*f);let P=2*(i*m*p-s*l*f);r.m21=P,r.c=P;let g=1-2*(b+h)*p;return r.m22=g,r.d=g,r.m23=2*(i*s*p+m*l*f),r.m31=2*(s*m*p+i*l*f),r.m32=2*(s*i*p-m*l*f),r.m33=1-2*(h+c)*p,r},Dt=(t,e,n)=>{let o=new M;return o.m11=t,o.a=t,o.m22=e,o.d=e,o.m33=n,o},Oe=(t,e)=>{let n=new M;if(t){let o=t*Math.PI/180,r=Math.tan(o);n.m21=r,n.c=r}if(e){let o=e*Math.PI/180,r=Math.tan(o);n.m12=r,n.b=r}return n},Et=t=>Oe(t,0),Qt=t=>Oe(0,t),Y=(t,e)=>{let n=e.m11*t.m11+e.m12*t.m21+e.m13*t.m31+e.m14*t.m41,o=e.m11*t.m12+e.m12*t.m22+e.m13*t.m32+e.m14*t.m42,r=e.m11*t.m13+e.m12*t.m23+e.m13*t.m33+e.m14*t.m43,a=e.m11*t.m14+e.m12*t.m24+e.m13*t.m34+e.m14*t.m44,m=e.m21*t.m11+e.m22*t.m21+e.m23*t.m31+e.m24*t.m41,i=e.m21*t.m12+e.m22*t.m22+e.m23*t.m32+e.m24*t.m42,s=e.m21*t.m13+e.m22*t.m23+e.m23*t.m33+e.m24*t.m43,u=e.m21*t.m14+e.m22*t.m24+e.m23*t.m34+e.m24*t.m44,l=e.m31*t.m11+e.m32*t.m21+e.m33*t.m31+e.m34*t.m41,f=e.m31*t.m12+e.m32*t.m22+e.m33*t.m32+e.m34*t.m42,p=e.m31*t.m13+e.m32*t.m23+e.m33*t.m33+e.m34*t.m43,h=e.m31*t.m14+e.m32*t.m24+e.m33*t.m34+e.m34*t.m44,c=e.m41*t.m11+e.m42*t.m21+e.m43*t.m31+e.m44*t.m41,b=e.m41*t.m12+e.m42*t.m22+e.m43*t.m32+e.m44*t.m42,d=e.m41*t.m13+e.m42*t.m23+e.m43*t.m33+e.m44*t.m43,x=e.m41*t.m14+e.m42*t.m24+e.m43*t.m34+e.m44*t.m44;return ve([n,o,r,a,m,i,s,u,l,f,p,h,c,b,d,x])},M=class{constructor(e){return this.a=1,this.b=0,this.c=0,this.d=1,this.e=0,this.f=0,this.m11=1,this.m12=0,this.m13=0,this.m14=0,this.m21=0,this.m22=1,this.m23=0,this.m24=0,this.m31=0,this.m32=0,this.m33=1,this.m34=0,this.m41=0,this.m42=0,this.m43=0,this.m44=1,e?this.setMatrixValue(e):this}get isIdentity(){return this.m11===1&&this.m12===0&&this.m13===0&&this.m14===0&&this.m21===0&&this.m22===1&&this.m23===0&&this.m24===0&&this.m31===0&&this.m32===0&&this.m33===1&&this.m34===0&&this.m41===0&&this.m42===0&&this.m43===0&&this.m44===1}get is2D(){return this.m31===0&&this.m32===0&&this.m33===1&&this.m34===0&&this.m43===0&&this.m44===1}setMatrixValue(e){return typeof e=="string"&&e.length&&e!=="none"?zt(e):Array.isArray(e)||e instanceof Float64Array||e instanceof Float32Array?ve(e):typeof e=="object"?kt(e):this}toFloat32Array(e){return Float32Array.from(ct(this,e))}toFloat64Array(e){return Float64Array.from(ct(this,e))}toString(){let{is2D:e}=this,n=this.toFloat64Array(e).join(", ");return`${e?"matrix":"matrix3d"}(${n})`}toJSON(){let{is2D:e,isIdentity:n}=this;return{...this,is2D:e,isIdentity:n}}multiply(e){return Y(this,e)}translate(e,n,o){let r=e,a=n,m=o;return typeof a>"u"&&(a=0),typeof m>"u"&&(m=0),Y(this,Rt(r,a,m))}scale(e,n,o){let r=e,a=n,m=o;return typeof a>"u"&&(a=e),typeof m>"u"&&(m=1),Y(this,Dt(r,a,m))}rotate(e,n,o){let r=e,a=n||0,m=o||0;return typeof e=="number"&&typeof n>"u"&&typeof o>"u"&&(m=r,r=0,a=0),Y(this,Vt(r,a,m))}rotateAxisAngle(e,n,o,r){if([e,n,o,r].some(a=>Number.isNaN(+a)))throw new TypeError("CSSMatrix: expecting 4 values");return Y(this,Ot(e,n,o,r))}skewX(e){return Y(this,Et(e))}skewY(e){return Y(this,Qt(e))}skew(e,n){return Y(this,Oe(e,n))}transformPoint(e){let n=this.m11*e.x+this.m21*e.y+this.m31*e.z+this.m41*e.w,o=this.m12*e.x+this.m22*e.y+this.m32*e.z+this.m42*e.w,r=this.m13*e.x+this.m23*e.y+this.m33*e.z+this.m43*e.w,a=this.m14*e.x+this.m24*e.y+this.m34*e.z+this.m44*e.w;return e instanceof DOMPoint?new DOMPoint(n,o,r,a):{x:n,y:o,z:r,w:a}}};q(M,"Translate",Rt),q(M,"Rotate",Vt),q(M,"RotateAxisAngle",Ot),q(M,"Scale",Dt),q(M,"SkewX",Et),q(M,"SkewY",Qt),q(M,"Skew",Oe),q(M,"Multiply",Y),q(M,"fromArray",ve),q(M,"fromMatrix",kt),q(M,"fromString",zt),q(M,"toArray",ct),q(M,"isCompatibleArray",Nt),q(M,"isCompatibleObject",wt);var yt={};te(yt,{angleBetween:()=>pt,arcLength:()=>ht,arcPoint:()=>pe,getArcBBox:()=>gt,getArcLength:()=>we,getArcProps:()=>Ee,getPointAtArcLength:()=>bt});var ft={};te(ft,{getLineBBox:()=>De,getLineLength:()=>fe,getPointAtLineLength:()=>Ne});var fr=(t,e,n)=>{let[o,r]=t,[a,m]=e;return[o+(a-o)*n,r+(m-r)*n]},I=fr;var pr=(t,e)=>Math.sqrt((t[0]-e[0])*(t[0]-e[0])+(t[1]-e[1])*(t[1]-e[1])),ce=pr;var fe=(t,e,n,o)=>ce([t,e],[n,o]),Ne=(t,e,n,o,r)=>{let a={x:t,y:e};if(typeof r=="number"){let m=ce([t,e],[n,o]);if(r<=0)a={x:t,y:e};else if(r>=m)a={x:n,y:o};else{let[i,s]=I([t,e],[n,o],r/m);a={x:i,y:s}}}return a},De=(t,e,n,o)=>{let{min:r,max:a}=Math;return[r(t,n),r(e,o),a(t,n),a(e,o)]};var ht=(t,e,n)=>{let o=n/2,r=Math.sin(o),a=Math.cos(o),m=t**2*r**2,i=e**2*a**2,s=Math.sqrt(m+i)*n;return Math.abs(s)},pe=(t,e,n,o,r,a)=>{let{sin:m,cos:i}=Math,s=i(r),u=m(r),l=n*i(a),f=o*m(a);return[t+s*l-u*f,e+u*l+s*f]},pt=(t,e)=>{let{x:n,y:o}=t,{x:r,y:a}=e,m=n*r+o*a,i=Math.sqrt((n**2+o**2)*(r**2+a**2));return(n*a-o*r<0?-1:1)*Math.acos(m/i)},Ee=(t,e,n,o,r,a,m,i,s)=>{let{abs:u,sin:l,cos:f,sqrt:p,PI:h}=Math,c=u(n),b=u(o),x=(r%360+360)%360*(h/180);if(t===i&&e===s)return{rx:c,ry:b,startAngle:0,endAngle:0,center:{x:i,y:s}};if(c===0||b===0)return{rx:c,ry:b,startAngle:0,endAngle:0,center:{x:(i+t)/2,y:(s+e)/2}};let P=(t-i)/2,g=(e-s)/2,y={x:f(x)*P+l(x)*g,y:-l(x)*P+f(x)*g},S=y.x**2/c**2+y.y**2/b**2;S>1&&(c*=p(S),b*=p(S));let C=c**2*b**2-c**2*y.y**2-b**2*y.x**2,R=c**2*y.y**2+b**2*y.x**2,O=C/R;O=O<0?0:O;let k=(a!==m?1:-1)*p(O),N={x:k*(c*y.y/b),y:k*(-(b*y.x)/c)},B={x:f(x)*N.x-l(x)*N.y+(t+i)/2,y:l(x)*N.x+f(x)*N.y+(e+s)/2},ue={x:(y.x-N.x)/c,y:(y.y-N.y)/b},D=pt({x:1,y:0},ue),A={x:(-y.x-N.x)/c,y:(-y.y-N.y)/b},E=pt(ue,A);!m&&E>0?E-=2*h:m&&E<0&&(E+=2*h),E%=2*h;let Z=D+E;return{center:B,startAngle:D,endAngle:Z,rx:c,ry:b}},we=(t,e,n,o,r,a,m,i,s)=>{let{rx:u,ry:l,startAngle:f,endAngle:p}=Ee(t,e,n,o,r,a,m,i,s);return ht(u,l,p-f)},bt=(t,e,n,o,r,a,m,i,s,u)=>{let l={x:t,y:e},{center:f,rx:p,ry:h,startAngle:c,endAngle:b}=Ee(t,e,n,o,r,a,m,i,s);if(typeof u=="number"){let d=ht(p,h,b-c);if(u<=0)l={x:t,y:e};else if(u>=d)l={x:i,y:s};else{if(t===i&&e===s)return{x:i,y:s};if(p===0||h===0)return Ne(t,e,i,s,u);let{PI:x,cos:P,sin:g}=Math,y=b-c,C=(r%360+360)%360*(x/180),R=c+y*(u/d),O=p*P(R),k=h*g(R);l={x:P(C)*O-g(C)*k+f.x,y:g(C)*O+P(C)*k+f.y}}}return l},gt=(t,e,n,o,r,a,m,i,s)=>{let{center:u,rx:l,ry:f,startAngle:p,endAngle:h}=Ee(t,e,n,o,r,a,m,i,s),c=h-p,{min:b,max:d,tan:x,atan2:P,PI:g}=Math,{x:y,y:S}=u,C=r*g/180,R=x(C),O=P(-f*R,l),k=O,N=O+g,B=P(f,l*R),ue=B+g,D=[i],A=[s],E=b(t,i),Z=d(t,i),$=b(e,s),X=d(e,s),de=h-c*1e-5,le=pe(y,S,l,f,C,de),w=h-c*.99999,Q=pe(y,S,l,f,C,w);if(le[0]>Z||Q[0]>Z){let z=pe(y,S,l,f,C,k);D.push(z[0]),A.push(z[1])}if(le[0]X||Q[1]>X){let z=pe(y,S,l,f,C,B);D.push(z[0]),A.push(z[1])}return E=b.apply([],D),$=b.apply([],A),Z=d.apply([],D),X=d.apply([],A),[E,$,Z,X]};var xt={};te(xt,{CBEZIER_MINMAX_EPSILON:()=>Zt,Cvalues:()=>qt,Tvalues:()=>dt,bezierLength:()=>Bt,calculateBezier:()=>jt,computeBezier:()=>$t,deriveBezier:()=>It,getBezierLength:()=>he,minmaxC:()=>Qe,minmaxQ:()=>ke});var dt=[-.06405689286260563,.06405689286260563,-.1911188674736163,.1911188674736163,-.3150426796961634,.3150426796961634,-.4337935076260451,.4337935076260451,-.5454214713888396,.5454214713888396,-.6480936519369755,.6480936519369755,-.7401241915785544,.7401241915785544,-.820001985973903,.820001985973903,-.8864155270044011,.8864155270044011,-.9382745520027328,.9382745520027328,-.9747285559713095,.9747285559713095,-.9951872199970213,.9951872199970213],qt=[.12793819534675216,.12793819534675216,.1258374563468283,.1258374563468283,.12167047292780339,.12167047292780339,.1155056680537256,.1155056680537256,.10744427011596563,.10744427011596563,.09761865210411388,.09761865210411388,.08619016153195327,.08619016153195327,.0733464814110803,.0733464814110803,.05929858491543678,.05929858491543678,.04427743881741981,.04427743881741981,.028531388628933663,.028531388628933663,.0123412297999872,.0123412297999872],It=t=>{let e=[];for(let n=t,o=n.length,r=o-1;o>1;o-=1,r-=1){let a=[];for(let m=0;m{if(e===0)return t[0].t=0,t[0];let n=t.length-1;if(e===1)return t[n].t=1,t[n];let o=1-e,r=t;if(n===0)return t[0].t=e,t[0];if(n===1)return{x:o*r[0].x+e*r[1].x,y:o*r[0].y+e*r[1].y,t:e};let a=o*o,m=e*e,i=0,s=0,u=0,l=0;return n===2?(r=[r[0],r[1],r[2],{x:0,y:0}],i=a,s=o*e*2,u=m):n===3&&(i=a*o,s=a*e*3,u=o*m*3,l=e*m),{x:i*r[0].x+s*r[1].x+u*r[2].x+l*r[3].x,y:i*r[0].y+s*r[1].y+u*r[2].y+l*r[3].y,t:e}},jt=(t,e)=>{let n=t(e),o=n.x*n.x+n.y*n.y;return Math.sqrt(o)},Bt=t=>{let n=dt.length,o=0;for(let r=0,a;r{let e=[];for(let o=0,r=t.length,a=2;o$t(n[0],o))},Zt=1e-8,ke=([t,e,n])=>{let o=Math.min(t,n),r=Math.max(t,n);if(e>=t?n>=e:n<=e)return[o,r];let a=(t*n-e*e)/(t-2*e+n);return a{let r=t-3*e+3*n-o;if(Math.abs(r)0&&l<1){let p=t*(1-l)*(1-l)*(1-l)+e*3*(1-l)*(1-l)*l+n*3*(1-l)*l*l+o*l*l*l;ps&&(s=p)}}return[i,s]};var St={};te(St,{getCubicBBox:()=>qe,getCubicLength:()=>xe,getPointAtCubicLength:()=>Pt,getPointAtCubicSegmentLength:()=>Ht});var Ht=([t,e,n,o,r,a,m,i],s)=>{let u=1-s;return{x:u**3*t+3*u**2*s*n+3*u*s**2*r+s**3*m,y:u**3*e+3*u**2*s*o+3*u*s**2*a+s**3*i}},xe=(t,e,n,o,r,a,m,i)=>he([t,e,n,o,r,a,m,i]),Pt=(t,e,n,o,r,a,m,i,s)=>{let u=typeof s=="number",l={x:t,y:e};if(u){let f=he([t,e,n,o,r,a,m,i]);s<=0||(s>=f?l={x:m,y:i}:l=Ht([t,e,n,o,r,a,m,i],s/f))}return l},qe=(t,e,n,o,r,a,m,i)=>{let s=Qe([t,n,r,m]),u=Qe([e,o,a,i]);return[s[0],u[0],s[1],u[1]]};var Ct={};te(Ct,{getPointAtQuadLength:()=>At,getPointAtQuadSegmentLength:()=>Ft,getQuadBBox:()=>Ie,getQuadLength:()=>Pe});var Ft=([t,e,n,o,r,a],m)=>{let i=1-m;return{x:i**2*t+2*i*m*n+m**2*r,y:i**2*e+2*i*m*o+m**2*a}},Pe=(t,e,n,o,r,a)=>he([t,e,n,o,r,a]),At=(t,e,n,o,r,a,m)=>{let i=typeof m=="number",s={x:t,y:e};if(i){let u=he([t,e,n,o,r,a]);m<=0||(m>=u?s={x:r,y:a}:s=Ft([t,e,n,o,r,a],m/u))}return s},Ie=(t,e,n,o,r,a)=>{let m=ke([t,n,r]),i=ke([e,o,a]);return[m[0],i[0],m[1],i[1]]};var Mt={};te(Mt,{polygonArea:()=>hr,polygonLength:()=>br});var hr=t=>{let e=t.length,n=-1,o,r=t[e-1],a=0;for(;++nt.reduce((e,n,o)=>o?e+ce(t[o-1],n):0,0);var gr={a:7,c:6,h:1,l:2,m:2,r:4,q:4,s:4,t:2,v:1,z:0},G=gr;var yr=t=>{let e=t.pathValue[t.segmentStart],n=e.toLowerCase(),{data:o}=t;for(;o.length>=G[n]&&(n==="m"&&o.length>2?(t.segments.push([e].concat(o.splice(0,2))),n="l",e=e==="m"?"l":"L"):t.segments.push([e].concat(o.splice(0,G[n]))),!!G[n]););},ze=yr;var dr="SVGPathCommander Error",V=dr;var xr=t=>{let{index:e,pathValue:n}=t,o=n.charCodeAt(e);if(o===48){t.param=0,t.index+=1;return}if(o===49){t.param=1,t.index+=1;return}t.err=`${V}: invalid Arc flag "${n[e]}", expecting 0 or 1 at index ${e}`},$e=xr;var Pr=t=>t>=48&&t<=57,H=Pr;var Sr="Invalid path value",F=Sr;var Ar=t=>{let{max:e,pathValue:n,index:o}=t,r=o,a=!1,m=!1,i=!1,s=!1,u;if(r>=e){t.err=`${V}: ${F} at index ${r}, "pathValue" is missing param`;return}if(u=n.charCodeAt(r),(u===43||u===45)&&(r+=1,u=n.charCodeAt(r)),!H(u)&&u!==46){t.err=`${V}: ${F} at index ${r}, "${n[r]}" is not a number`;return}if(u!==46){if(a=u===48,r+=1,u=n.charCodeAt(r),a&&r[5760,6158,8192,8193,8194,8195,8196,8197,8198,8199,8200,8201,8202,8239,8287,12288,65279,10,13,8232,8233,32,9,11,12,160].includes(t),Be=Cr;var Mr=t=>{let{pathValue:e,max:n}=t;for(;t.index{switch(t|32){case 109:case 122:case 108:case 104:case 118:case 99:case 115:case 113:case 116:case 97:return!0;default:return!1}},Ze=Tr;var Lr=t=>H(t)||t===43||t===45||t===46,He=Lr;var vr=t=>(t|32)===97,Fe=vr;var Nr=t=>{switch(t|32){case 109:case 77:return!0;default:return!1}},Ge=Nr;var wr=t=>{let{max:e,pathValue:n,index:o,segments:r}=t,a=n.charCodeAt(o),m=G[n[o].toLowerCase()];if(t.segmentStart=o,!Ze(a)){t.err=`${V}: ${F} "${n[o]}" is not a path command at index ${o}`;return}let i=r[r.length-1];if(!Ge(a)&&i?.[0]?.toLocaleLowerCase()==="z"){t.err=`${V}: ${F} "${n[o]}" is not a MoveTo path command at index ${o}`;return}if(t.index+=1,_(t),t.data=[],!m){ze(t);return}for(;;){for(let s=m;s>0;s-=1){if(Fe(a)&&(s===3||s===4)?$e(t):je(t),t.err.length)return;t.data.push(t.param),_(t),t.index=t.max||!He(n.charCodeAt(t.index)))break}ze(t)},Se=wr;var ee=class{constructor(e){this.segments=[],this.pathValue=e,this.max=e.length,this.index=0,this.param=0,this.segmentStart=0,this.data=[],this.err=""}};var kr=t=>{if(typeof t!="string")return t.slice(0);let e=new ee(t);for(_(e);e.index{let[r]=t,a=r.toUpperCase(),m=a===r;if(e===0||m)return t;if(a==="A")return[a,t[1],t[2],t[3],t[4],t[5],t[6]+n,t[7]+o];if(a==="V")return[a,t[1]+o];if(a==="H")return[a,t[1]+n];if(a==="L")return[a,t[1]+n,t[2]+o];{let i=[],s=t.length;for(let u=1;u{let n=t.length,o,r="M",a="M",m=!1,i=0,s=0,u=0,l=0,f=0;for(let p=0;p{let e=T(t);return L(e,U)},re=Vr;var Or=(t,e,n,o)=>{let[r]=t,a=r.toLowerCase(),m=r===a;if(e===0||m)return t;if(a==="a")return[a,t[1],t[2],t[3],t[4],t[5],t[6]-n,t[7]-o];if(a==="v")return[a,t[1]-o];if(a==="h")return[a,t[1]-n];if(a==="l")return[a,t[1]-n,t[2]-o];{let i=[],s=t.length;for(let u=1;u{let e=T(t);return L(e,Ae)},_e=Dr;var Er=(t,e,n)=>{let{sin:o,cos:r}=Math,a=t*r(n)-e*o(n),m=t*o(n)+e*r(n);return{x:a,y:m}},be=Er;var Gt=(t,e,n,o,r,a,m,i,s,u)=>{let l=t,f=e,p=n,h=o,c=i,b=s,d=Math.PI*120/180,x=Math.PI/180*(+r||0),P=[],g,y,S,C,R;if(u)[y,S,C,R]=u;else{g=be(l,f,-x),l=g.x,f=g.y,g=be(c,b,-x),c=g.x,b=g.y;let w=(l-c)/2,Q=(f-b)/2,z=w*w/(p*p)+Q*Q/(h*h);z>1&&(z=Math.sqrt(z),p*=z,h*=z);let it=p*p,ut=h*h,vt=(a===m?-1:1)*Math.sqrt(Math.abs((it*ut-it*Q*Q-ut*w*w)/(it*Q*Q+ut*w*w)));C=vt*p*Q/h+(l+c)/2,R=vt*-h*w/p+(f+b)/2,y=Math.asin(((f-R)/h*10**9>>0)/10**9),S=Math.asin(((b-R)/h*10**9>>0)/10**9),y=lS&&(y-=Math.PI*2),!m&&S>y&&(S-=Math.PI*2)}let O=S-y;if(Math.abs(O)>d){let w=S,Q=c,z=b;S=y+d*(m&&S>y?1:-1),c=C+p*Math.cos(S),b=R+h*Math.sin(S),P=Gt(c,b,p,h,r,0,m,Q,z,[S,w,C,R])}O=S-y;let k=Math.cos(y),N=Math.sin(y),B=Math.cos(S),ue=Math.sin(S),D=Math.tan(O/4),A=4/3*p*D,E=4/3*h*D,Z=[l,f],$=[l+A*N,f-E*k],X=[c+A*ue,b-E*B],de=[c,b];if($[0]=2*Z[0]-$[0],$[1]=2*Z[1]-$[1],u)return[$[0],$[1],X[0],X[1],de[0],de[1]].concat(P);P=[$[0],$[1],X[0],X[1],de[0],de[1]].concat(P);let le=[];for(let w=0,Q=P.length;w{let m=.3333333333333333,i=2/3;return[m*t+i*n,m*e+i*o,m*r+i*n,m*a+i*o,r,a]},Ue=Qr;var qr=(t,e,n,o)=>{let r=I([t,e],[n,o],.3333333333333333),a=I([t,e],[n,o],2/3);return[r[0],r[1],a[0],a[1],n,o]},Re=qr;var Ir=(t,e)=>{let[n]=t,o=t.slice(1).map(Number),[r,a]=o,{x1:m,y1:i,x:s,y:u}=e;return"TQ".includes(n)||(e.qx=null,e.qy=null),n==="M"?(e.x=r,e.y=a,t):n==="A"?["C"].concat(Ce(m,i,o[0],o[1],o[2],o[3],o[4],o[5],o[6])):n==="Q"?(e.qx=r,e.qy=a,["C"].concat(Ue(m,i,o[0],o[1],o[2],o[3]))):n==="L"?["C"].concat(Re(m,i,r,a)):n==="Z"?["C"].concat(Re(m,i,s,u)):t},Je=Ir;var $r=(t,e)=>{let[n]=t,o=n.toUpperCase(),r=n!==o,{x1:a,y1:m,x2:i,y2:s,x:u,y:l}=e,f=t.slice(1),p=f.map((h,c)=>h+(r?c%2?l:u:0));"TQ".includes(o)||(e.qx=null,e.qy=null);if(o==="A")return p=f.slice(0,-2).concat(f[5]+(r?u:0),f[6]+(r?l:0)),["A"].concat(p);if(o==="H")return["L",t[1]+(r?u:0),m];if(o==="V")return["L",a,t[1]+(r?l:0)];if(o==="L")return["L",t[1]+(r?u:0),t[2]+(r?l:0)];if(o==="M")return["M",t[1]+(r?u:0),t[2]+(r?l:0)];if(o==="C")return["C"].concat(p);if(o==="S"){let h=a*2-i,c=m*2-s;return e.x1=h,e.y1=c,["C",h,c].concat(p)}else if(o==="T"){let h=a*2-(e.qx?e.qx:0),c=m*2-(e.qy?e.qy:0);return e.qx=h,e.qy=c,["Q",h,c].concat(p)}else if(o==="Q"){let[h,c]=p;return e.qx=h,e.qy=c,["Q"].concat(p)}else if(o==="Z")return["Z"];return t},ne=$r;var jr={x1:0,y1:0,x2:0,y2:0,x:0,y:0,qx:null,qy:null},J=jr;var Br=t=>{let e={...J},n=T(t);return L(n,(o,r,a,m)=>{e.x=a,e.y=m;let i=ne(o,e),s=Je(i,e);s[0]==="C"&&s.length>7&&(n.splice(r+1,0,["C"].concat(s.slice(7))),s=s.slice(0,7));let l=s.length;return e.x1=+s[l-2],e.y1=+s[l-1],e.x2=+s[l-4]||e.x1,e.y2=+s[l-3]||e.y1,s})},oe=Br;var Zr={origin:[0,0,0],round:4},j=Zr;var Hr=(t,e)=>{let n=e>=1?10**e:1;return e>0?Math.round(t*n)/n:Math.round(t)},v=Hr;var Fr=(t,e)=>{let n=t.length,{round:o}=j,r=t[0],a="";o=e==="off"||typeof e=="number"&&e>=0?e:typeof o=="number"&&o>=0?o:"off";for(let m=0;m{let e=T(t),n={...J};return L(e,(o,r,a,m)=>{n.x=a,n.y=m;let i=ne(o,n),s=i.length;return n.x1=+i[s-2],n.y1=+i[s-1],n.x2=+i[s-4]||n.x1,n.y2=+i[s-3]||n.y1,i})},K=Gr;var _r=(t,e)=>{let n=K(t),o=!1,r=[],a="M",m=0,i=0,[s,u]=n[0].slice(1),l=typeof e=="number",f={x:s,y:u},p=0,h=f,c=0;return!l||e{[a]=b,o=a==="M",r=o?r:[x,P].concat(b.slice(1));if(o?([,s,u]=b,f={x:s,y:u},p=0):a==="L"?(f=Ne(r[0],r[1],r[2],r[3],e-c),p=fe(r[0],r[1],r[2],r[3])):a==="A"?(f=bt(r[0],r[1],r[2],r[3],r[4],r[5],r[6],r[7],r[8],e-c),p=we(r[0],r[1],r[2],r[3],r[4],r[5],r[6],r[7],r[8])):a==="C"?(f=Pt(r[0],r[1],r[2],r[3],r[4],r[5],r[6],r[7],e-c),p=xe(r[0],r[1],r[2],r[3],r[4],r[5],r[6],r[7])):a==="Q"?(f=At(r[0],r[1],r[2],r[3],r[4],r[5],e-c),p=Pe(r[0],r[1],r[2],r[3],r[4],r[5])):a==="Z"&&(r=[x,P,s,u],f={x:s,y:u},p=fe(r[0],r[1],r[2],r[3])),[m,i]=r.slice(-2),cc-ge?{x:m,y:i}:h)},ae=_r;var Ur=t=>{let e=T(t),n=0,o=0,r=0,a=0,m=0,i=0,s="M",u=0,l=0,f=0;return L(e,(p,h,c,b)=>{[s]=p;let d=s.toUpperCase(),P=d!==s?U(p,h,c,b):p.slice(0),g=d==="V"?["L",c,P[1]]:d==="H"?["L",P[1],b]:P;[s]=g,"TQ".includes(d)||(m=0,i=0);if(s==="M")[,u,l]=g;else if(s==="L")f+=fe(c,b,g[1],g[2]);else if(s==="A")f+=we(c,b,g[1],g[2],g[3],g[4],g[5],g[6],g[7]);else if(s==="S"){let y=n*2-r,S=o*2-a;f+=xe(c,b,y,S,g[1],g[2],g[3],g[4])}else s==="C"?f+=xe(c,b,g[1],g[2],g[3],g[4],g[5],g[6]):s==="T"?(m=n*2-m,i=o*2-i,f+=Pe(c,b,m,i,g[1],g[2])):s==="Q"?(m=g[1],i=g[2],f+=Pe(c,b,g[1],g[2],g[3],g[4])):s==="Z"&&(f+=fe(c,b,u,l));[n,o]=s==="Z"?[u,l]:g.slice(-2),[r,a]=s==="C"?[g[3],g[4]]:s==="S"?[g[1],g[2]]:[n,o]}),f},W=Ur;var Jr=(t,e)=>{let n=T(t),o=n.slice(0),r=W(o),a=o.length-1,m=0,i=0,s=n[0];if(a<=0||!e||!Number.isFinite(e))return{segment:s,index:0,length:i,lengthAtSegment:m};if(e>=r)return o=n.slice(0,-1),m=W(o),i=r-m,s=n[a],{segment:s,index:a,length:i,lengthAtSegment:m};let u=[];for(;a>0;)s=o[a],o=o.slice(0,-1),m=W(o),i=r-m,r=m,u.push({segment:s,index:a,length:i,lengthAtSegment:m}),a-=1;return u.find(({lengthAtSegment:l})=>l<=e)},Te=Jr;var Kr=(t,e)=>{let n=T(t),o=K(n),r=W(o),a=y=>{let S=y.x-e.x,C=y.y-e.y;return S*S+C*C},m=8,i,s={x:0,y:0},u=0,l=0,f=1/0;for(let y=0;y<=r;y+=m)i=ae(o,y),u=a(i),u1e-6&&(c=l-m,p=ae(o,c),d=a(p),b=l+m,h=ae(o,b),x=a(h),c>=0&&dme(t,e).closest,_t=Wr;var Xr=(t,e,n,o,r,a,m,i)=>3*((i-e)*(n+r)-(m-t)*(o+a)+o*(t-r)-n*(e-a)+i*(r+t/3)-m*(a+e/3))/20,Yr=t=>{let e=0,n=0,o=0;return oe(t).map(r=>{switch(r[0]){case"M":return[,e,n]=r,0;default:return o=Xr(e,n,r[1],r[2],r[3],r[4],r[5],r[6]),[e,n]=r.slice(-2),o}}).reduce((r,a)=>r+a,0)},Ke=Yr;var en=t=>Ke(oe(t))>=0,Ut=en;var tn=t=>{if(!t)return{x:0,y:0,width:0,height:0,x2:0,y2:0,cx:0,cy:0,cz:0};let e=T(t),n="M",o=0,r=0,{max:a,min:m}=Math,i=1/0,s=1/0,u=-1/0,l=-1/0,f=0,p=0,h=0,c=0,b=0,d=0,x=0,P=0,g=0,y=0;L(e,(R,O,k,N)=>{[n]=R;let B=n.toUpperCase(),D=B!==n?U(R,O,k,N):R.slice(0),A=B==="V"?["L",k,D[1]]:B==="H"?["L",D[1],N]:D;[n]=A,"TQ".includes(B)||(g=0,y=0);if(n==="M")[,o,r]=A,f=o,p=r,h=o,c=r;else if(n==="L")[f,p,h,c]=De(k,N,A[1],A[2]);else if(n==="A")[f,p,h,c]=gt(k,N,A[1],A[2],A[3],A[4],A[5],A[6],A[7]);else if(n==="S"){let E=b*2-x,Z=d*2-P;[f,p,h,c]=qe(k,N,E,Z,A[1],A[2],A[3],A[4])}else n==="C"?[f,p,h,c]=qe(k,N,A[1],A[2],A[3],A[4],A[5],A[6]):n==="T"?(g=b*2-g,y=d*2-y,[f,p,h,c]=Ie(k,N,g,y,A[1],A[2])):n==="Q"?(g=A[1],y=A[2],[f,p,h,c]=Ie(k,N,A[1],A[2],A[3],A[4])):n==="Z"&&([f,p,h,c]=De(k,N,o,r));i=m(f,i),s=m(p,s),u=a(h,u),l=a(c,l),[b,d]=n==="Z"?[o,r]:A.slice(-2),[x,P]=n==="C"?[A[3],A[4]]:n==="S"?[A[1],A[2]]:[b,d]});let S=u-i,C=l-s;return{width:S,height:C,x:i,y:s,x2:u,y2:l,cx:i+S/2,cy:s+C/2,cz:Math.max(S,C)+Math.min(S,C)/2}},We=tn;var rn=(t,e)=>Te(t,e).segment,Jt=rn;var nn=(t,e)=>me(t,e).segment,Kt=nn;var on=t=>Array.isArray(t)&&t.every(e=>{let n=e[0].toLowerCase();return G[n]===e.length-1&&"achlmqstvz".includes(n)&&e.slice(1).every(Number.isFinite)})&&t.length>0,se=on;var an=t=>se(t)&&t.every(([e])=>e===e.toUpperCase()),Xe=an;var mn=t=>Xe(t)&&t.every(([e])=>"ACLMQZ".includes(e)),Ye=mn;var sn=t=>Ye(t)&&t.every(([e])=>"MC".includes(e)),Wt=sn;var un=(t,e)=>{let{distance:n}=me(t,e);return Math.abs(n)se(t)&&t.slice(1).every(([e])=>e===e.toLowerCase()),Yt=ln;var cn=t=>{if(typeof t!="string"||!t.length)return!1;let e=new ee(t);for(_(e);e.indext!=null&&typeof t=="object"&&t.nodeType===1,tt=pn;var hn=t=>{let{x1:e,y1:n,x2:o,y2:r}=t;return[e,n,o,r]=[e,n,o,r].map(a=>+a),[["M",e,n],["L",o,r]]},bn=t=>{let e=[],n=(t.points||"").trim().split(/[\s|,]/).map(r=>+r),o=0;for(;o{let{cx:e,cy:n,r:o}=t;return[e,n,o]=[e,n,o].map(r=>+r),[["M",e-o,n],["a",o,o,0,1,0,2*o,0],["a",o,o,0,1,0,-2*o,0]]},yn=t=>{let{cx:e,cy:n}=t,o=t.rx||0,r=t.ry||o;return[e,n,o,r]=[e,n,o,r].map(a=>+a),[["M",e-o,n],["a",o,r,0,1,0,2*o,0],["a",o,r,0,1,0,-2*o,0]]},dn=t=>{let e=+t.x||0,n=+t.y||0,o=+t.width,r=+t.height,a=+(t.rx||0),m=+(t.ry||a);if(a||m){a*2>o&&(a-=(a*2-o)/2);return m*2>r&&(m-=(m*2-r)/2),[["M",e+a,n],["h",o-a*2],["s",a,0,a,m],["v",r-m*2],["s",0,m,-a,m],["h",-o+a*2],["s",-a,0,-a,-m],["v",-r+m*2],["s",0,-m,a,-m]]}return[["M",e,n],["h",o],["v",r],["H",e],["Z"]]},xn=t=>{let e=Object.keys(ie),n=tt(t),o=n?t.tagName:null;if(o&&[...e,"path"].every(s=>o!==s))throw TypeError(`${V}: "${o}" is not SVGElement`);let r=n?o:t.type,a=ie[r],m={type:r};n?a.forEach(s=>{m[s]=t.getAttribute(s)}):Object.assign(m,t);let i=[];return r==="circle"?i=gn(m):r==="ellipse"?i=yn(m):["polyline","polygon"].includes(r)?i=bn(m):r==="rect"?i=dn(m):r==="line"?i=hn(m):["glyph","path"].includes(r)&&(i=T(n?t.getAttribute("d")||"":t.d||"")),se(i)&&i.length?i:!1},rt=xn;var Pn=(t,e,n)=>{let o=n||document,r=Object.keys(ie),a=tt(t),m=a?t.tagName:null;if(m==="path")throw TypeError(`${V}: "${m}" is already SVGPathElement`);if(m&&r.every(c=>m!==c))throw TypeError(`${V}: "${m}" is not SVGElement`);let i=o.createElementNS("http://www.w3.org/2000/svg","path"),s=a?m:t.type,u=ie[s],l={type:s},f=j.round,p=rt(t),h=p&&p.length?Me(p,f):"";return a?(u.forEach(c=>{l[c]=t.getAttribute(c)}),Object.values(t.attributes).forEach(({name:c,value:b})=>{u.includes(c)||i.setAttribute(c,b)})):(Object.assign(l,t),Object.keys(l).forEach(c=>{!u.includes(c)&&c!=="type"&&i.setAttribute(c.replace(/[A-Z]/g,b=>`-${b.toLowerCase()}`),l[c])})),et(h)?(i.setAttribute("d",h),e&&a&&(t.before(i,t),t.remove()),i):!1},er=Pn;var Sn=t=>{let e=new M,{origin:n}=t,[o,r]=n,{translate:a}=t,{rotate:m}=t,{skew:i}=t,{scale:s}=t;return Array.isArray(a)&&a.length>=2&&a.every(u=>!Number.isNaN(+u))&&a.some(u=>u!==0)?e=e.translate(...a):typeof a=="number"&&!Number.isNaN(a)&&(e=e.translate(a)),(m||i||s)&&(e=e.translate(o,r),Array.isArray(m)&&m.length>=2&&m.every(u=>!Number.isNaN(+u))&&m.some(u=>u!==0)?e=e.rotate(...m):typeof m=="number"&&!Number.isNaN(m)&&(e=e.rotate(m)),Array.isArray(i)&&i.length===2&&i.every(u=>!Number.isNaN(+u))&&i.some(u=>u!==0)?(e=i[0]?e.skewX(i[0]):e,e=i[1]?e.skewY(i[1]):e):typeof i=="number"&&!Number.isNaN(i)&&(e=e.skewX(i)),Array.isArray(s)&&s.length>=2&&s.every(u=>!Number.isNaN(+u))&&s.some(u=>u!==1)?e=e.scale(...s):typeof s=="number"&&!Number.isNaN(s)&&(e=e.scale(s)),e=e.translate(-o,-r)),e},nt=Sn;var An=(t,e,n,o)=>{let[r]=t,{round:a}=j,m=typeof a=="number"?a:4,i=e.slice(1),{x1:s,y1:u,x2:l,y2:f,x:p,y:h}=n,[c,b]=i.slice(-2),d=t;if("TQ".includes(r)||(n.qx=null,n.qy=null),r==="L"){if(v(p,m)===v(c,m))return["V",b];if(v(h,m)===v(b,m))return["H",c]}else if(r==="C"){let[x,P]=i;if(n.x1=x,n.y1=P,"CS".includes(o)&&(v(x,m)===v(s*2-l,m)&&v(P,m)===v(u*2-f,m)||v(s,m)===v(l*2-p,m)&&v(u,m)===v(f*2-h,m)))return["S",i[2],i[3],i[4],i[5]]}else if(r==="Q"){let[x,P]=i;if(n.qx=x,n.qy=P,"QT".includes(o)&&v(x,m)===v(s*2-l,m)&&v(P,m)===v(u*2-f,m))return["T",i[2],i[3]]}return d},ot=An;var Cn=(t,e)=>{let n=t.slice(1).map(o=>v(o,e));return[t[0]].concat(n)},ye=Cn;var Mn=(t,e)=>{let n=re(t),o=typeof e=="number"&&e>=0?e:2,r={...J},a=[],m="M",i="Z";return L(n,(s,u,l,f)=>{r.x=l,r.y=f;let p=ne(s,r),h=s;if([m]=s,a[u]=m,u){i=a[u-1];let b=ot(s,p,r,i),d=ye(b,o),x=d.join(""),P=Ae(b,u,l,f),g=ye(P,o),y=g.join("");h=x.length{let n=M.Translate(e[0],e[1],e[2]);return[,,,n.m44]=e,n=t.multiply(n),[n.m41,n.m42,n.m43,n.m44]},Ln=(t,e,n)=>{let[o,r,a]=n,[m,i,s]=Tn(t,[e[0],e[1],0,1]),u=m-o,l=i-r,f=s-a;return[u*(Math.abs(a)/Math.abs(f)||1)+o,l*(Math.abs(a)/Math.abs(f)||1)+r]},Ve=Ln;var vn=t=>{let e=t.slice(1).map((n,o,r)=>o?r[o-1].slice(-2).concat(n.slice(1)):t[0].slice(1).concat(n.slice(1))).map(n=>n.map((o,r)=>n[n.length-r-2*(1-r%2)])).reverse();return[["M"].concat(e[0].slice(0,2))].concat(e.map(n=>["C"].concat(n.slice(2))))},tr=vn;var Nn=t=>{let e=re(t),n=K(e),o=e.length,r=e[o-1][0]==="Z",a=L(e,(m,i)=>{let s=n[i],u=i&&e[i-1],l=u&&u[0],f=e[i+1],p=f&&f[0],[h]=m,[c,b]=n[i?i-1:o-1].slice(-2),d=m;switch(h){case"M":d=r?["Z"]:[h,c,b];break;case"A":d=[h,m[1],m[2],m[3],m[4],m[5]===1?0:1,c,b];break;case"C":f&&p==="S"?d=["S",m[1],m[2],c,b]:d=[h,m[3],m[4],m[1],m[2],c,b];break;case"S":l&&"CS".includes(l)&&(!f||p!=="S")?d=["C",s[3],s[4],s[1],s[2],c,b]:d=[h,s[1],s[2],c,b];break;case"Q":f&&p==="T"?d=["T",c,b]:d=[h,m[1],m[2],c,b];break;case"T":l&&"QT".includes(l)&&(!f||p!=="T")?d=["Q",s[1],s[2],c,b]:d=[h,c,b];break;case"Z":d=["M",c,b];break;case"H":d=[h,c];break;case"V":d=[h,b];break;default:d=[h].concat(m.slice(1,-2),c,b)}return d});return r?a.reverse():[a[0]].concat(a.slice(1).reverse())},Le=Nn;var wn=(t,e)=>{let{round:n}=j;n=e==="off"||typeof e=="number"&&e>=0?e:typeof n=="number"&&n>=0?n:"off";return n==="off"?t.slice(0):L(t,o=>ye(o,n))},rr=wn;var kn=(t,e=.5)=>{let n=e,o=t.slice(0,2),r=t.slice(2,4),a=t.slice(4,6),m=t.slice(6,8),i=I(o,r,n),s=I(r,a,n),u=I(a,m,n),l=I(i,s,n),f=I(s,u,n),p=I(l,f,n);return[["C",i[0],i[1],l[0],l[1],p[0],p[1]],["C",f[0],f[1],u[0],u[1],m[0],m[1]]]},nr=kn;var zn=t=>{let e=[],n,o=-1,r=0,a=0,m=0,i=0,s={...J};return t.forEach(u=>{let[l]=u,f=l.toUpperCase(),p=l.toLowerCase(),h=l===p,c=u.slice(1);f==="M"?(o+=1,[r,a]=c,r+=h?s.x:0,a+=h?s.y:0,m=r,i=a,n=[h?[f,m,i]:u]):(f==="Z"?(r=m,a=i):f==="H"?([,r]=u,r+=h?s.x:0):f==="V"?([,a]=u,a+=h?s.y:0):([r,a]=u.slice(-2),r+=h?s.x:0,a+=h?s.y:0),n.push(u)),s.x=r,s.y=a,e[o]=n}),e},mt=zn;var Rn=(t,e)=>{let n=0,o=0,r=0,a=0,m=0,i=0,s="M",u=T(t),l=e&&Object.keys(e);if(!e||l&&!l.length)return u.slice(0);e.origin||Object.assign(e,{origin:j.origin});let f=e.origin,p=nt(e);return p.isIdentity?u.slice(0):L(u,(h,c,b,d)=>{[s]=h;let x=s.toUpperCase(),g=x!==s?U(h,c,b,d):h.slice(0),y=x==="A"?["C"].concat(Ce(b,d,g[1],g[2],g[3],g[4],g[5],g[6],g[7])):x==="V"?["L",b,g[1]]:x==="H"?["L",g[1],d]:g;s=y[0];let S=s==="C"&&y.length>7,C=S?y.slice(0,7):y.slice(0);if(S&&(u.splice(c+1,0,["C"].concat(y.slice(7))),y=C),s==="L"){[r,a]=Ve(p,[y[1],y[2]],f);n!==r&&o!==a?y=["L",r,a]:o===a?y=["H",r]:n===r&&(y=["V",a])}else for(m=1,i=y.length;m"u";if(r||!e.length)throw TypeError(`${V}: "pathValue" is ${r?"undefined":"empty"}`);this.segments=T(e);let{round:a,origin:m}=o,i;Number.isInteger(a)||a==="off"?i=a:i=j.round;let s=j.origin;if(Array.isArray(m)&&m.length>=2){let[u,l,f]=m.map(Number);s=[Number.isNaN(u)?0:u,Number.isNaN(l)?0:l,Number.isNaN(f)?0:f]}return this.round=i,this.origin=s,this}get bbox(){return We(this.segments)}get length(){return W(this.segments)}getBBox(){return this.bbox}getTotalLength(){return this.length}getPointAtLength(e){return ae(this.segments,e)}toAbsolute(){let{segments:e}=this;return this.segments=re(e),this}toRelative(){let{segments:e}=this;return this.segments=_e(e),this}toCurve(){let{segments:e}=this;return this.segments=oe(e),this}reverse(e){let{segments:n}=this,o=mt(n),r=o.length>1?o:!1,a=r?r.map((i,s)=>e?s?Le(i):i.slice(0):Le(i)):n.slice(0),m=[];return r?m=a.flat(1):m=e?n:Le(n),this.segments=m.slice(0),this}normalize(){let{segments:e}=this;return this.segments=K(e),this}optimize(){let{segments:e}=this,n=this.round==="off"?2:this.round;return this.segments=at(e,n),this}transform(e){if(!e||typeof e!="object"||typeof e=="object"&&!["translate","rotate","skew","scale"].some(s=>s in e))return this;let{segments:n,origin:[o,r,a]}=this,m={};for(let[s,u]of Object.entries(e)){s==="skew"&&Array.isArray(u)||(s==="rotate"||s==="translate"||s==="origin"||s==="scale")&&Array.isArray(u)?m[s]=u.map(Number):s!=="origin"&&typeof Number(u)=="number"&&(m[s]=Number(u))}let{origin:i}=m;if(Array.isArray(i)&&i.length>=2){let[s,u,l]=i.map(Number);m.origin=[Number.isNaN(s)?o:s,Number.isNaN(u)?r:u,l||a]}else m.origin=[o,r,a];return this.segments=st(n,m),this}flipX(){let{cx:e,cy:n}=this.bbox;return this.transform({rotate:[0,180,0],origin:[e,n,0]}),this}flipY(){let{cx:e,cy:n}=this.bbox;return this.transform({rotate:[180,0,0],origin:[e,n,0]}),this}toString(){return Me(this.segments,this.round)}dispose(){Object.keys(this).forEach(e=>delete this[e])}},Vn=Object.assign(Lt,Tt);return ir(On);})(); +//# sourceMappingURL=svg-path-commander.js.map \ No newline at end of file diff --git a/dist/svg-path-commander.js.map b/dist/svg-path-commander.js.map index 08bc8c9..678a970 100644 --- a/dist/svg-path-commander.js.map +++ b/dist/svg-path-commander.js.map @@ -1 +1 @@ -{"version":3,"file":"svg-path-commander.js","sources":["../node_modules/.pnpm/@thednp+dommatrix@2.0.11/node_modules/@thednp/dommatrix/dist/dommatrix.mjs","../src/math/midPoint.ts","../src/math/distanceSquareRoot.ts","../src/math/lineTools.ts","../src/math/arcTools.ts","../src/math/bezier.ts","../src/math/cubicTools.ts","../src/math/quadTools.ts","../src/math/polygonTools.ts","../src/parser/paramsCount.ts","../src/parser/finalizeSegment.ts","../src/parser/error.ts","../src/parser/scanFlag.ts","../src/parser/isDigit.ts","../src/parser/invalidPathValue.ts","../src/parser/scanParam.ts","../src/parser/isSpace.ts","../src/parser/skipSpaces.ts","../src/parser/isPathCommand.ts","../src/parser/isDigitStart.ts","../src/parser/isArcCommand.ts","../src/parser/isMoveCommand.ts","../src/parser/scanSegment.ts","../src/parser/pathParser.ts","../src/parser/parsePathString.ts","../src/process/absolutizeSegment.ts","../src/process/iterate.ts","../src/convert/pathToAbsolute.ts","../src/process/relativizeSegment.ts","../src/convert/pathToRelative.ts","../src/math/rotateVector.ts","../src/process/arcToCubic.ts","../src/process/quadToCubic.ts","../src/process/lineToCubic.ts","../src/process/segmentToCubic.ts","../src/process/normalizeSegment.ts","../src/parser/paramsParser.ts","../src/convert/pathToCurve.ts","../src/options/options.ts","../src/math/roundTo.ts","../src/convert/pathToString.ts","../src/util/distanceEpsilon.ts","../src/process/normalizePath.ts","../src/util/getPointAtLength.ts","../src/util/getTotalLength.ts","../src/util/getPropertiesAtLength.ts","../src/util/getPropertiesAtPoint.ts","../src/util/getClosestPoint.ts","../src/util/getPathArea.ts","../src/util/getDrawDirection.ts","../src/util/getPathBBox.ts","../src/util/getSegmentAtLength.ts","../src/util/getSegmentOfPoint.ts","../src/util/isPathArray.ts","../src/util/isAbsoluteArray.ts","../src/util/isNormalizedArray.ts","../src/util/isCurveArray.ts","../src/util/isPointInStroke.ts","../src/util/isRelativeArray.ts","../src/util/isValidPath.ts","../src/util/shapeParams.ts","../src/util/isElement.ts","../src/util/shapeToPathArray.ts","../src/util/shapeToPath.ts","../src/process/getSVGMatrix.ts","../src/process/shortenSegment.ts","../src/process/roundSegment.ts","../src/process/optimizePath.ts","../src/process/projection2d.ts","../src/process/reverseCurve.ts","../src/process/reversePath.ts","../src/process/roundPath.ts","../src/process/splitCubic.ts","../src/process/splitPath.ts","../src/process/transformPath.ts","../src/index.ts"],"sourcesContent":["var Z = Object.defineProperty;\nvar z = (s, t, e) => t in s ? Z(s, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : s[t] = e;\nvar p = (s, t, e) => z(s, typeof t != \"symbol\" ? t + \"\" : t, e);\nconst $ = {\n a: 1,\n b: 0,\n c: 0,\n d: 1,\n e: 0,\n f: 0,\n m11: 1,\n m12: 0,\n m13: 0,\n m14: 0,\n m21: 0,\n m22: 1,\n m23: 0,\n m24: 0,\n m31: 0,\n m32: 0,\n m33: 1,\n m34: 0,\n m41: 0,\n m42: 0,\n m43: 0,\n m44: 1,\n is2D: !0,\n isIdentity: !0\n}, E = (s) => (s instanceof Float64Array || s instanceof Float32Array || Array.isArray(s) && s.every((t) => typeof t == \"number\")) && [6, 16].some((t) => s.length === t), P = (s) => s instanceof DOMMatrix || s instanceof y || typeof s == \"object\" && Object.keys($).every((t) => s && t in s), g = (s) => {\n const t = new y(), e = Array.from(s);\n if (!E(e))\n throw TypeError(\n `CSSMatrix: \"${e.join(\",\")}\" must be an array with 6/16 numbers.`\n );\n // istanbul ignore else @preserve\n if (e.length === 16) {\n const [\n n,\n i,\n r,\n a,\n l,\n m,\n h,\n c,\n u,\n f,\n w,\n o,\n d,\n A,\n M,\n b\n ] = e;\n t.m11 = n, t.a = n, t.m21 = l, t.c = l, t.m31 = u, t.m41 = d, t.e = d, t.m12 = i, t.b = i, t.m22 = m, t.d = m, t.m32 = f, t.m42 = A, t.f = A, t.m13 = r, t.m23 = h, t.m33 = w, t.m43 = M, t.m14 = a, t.m24 = c, t.m34 = o, t.m44 = b;\n } else if (e.length === 6) {\n const [n, i, r, a, l, m] = e;\n t.m11 = n, t.a = n, t.m12 = i, t.b = i, t.m21 = r, t.c = r, t.m22 = a, t.d = a, t.m41 = l, t.e = l, t.m42 = m, t.f = m;\n }\n return t;\n}, X = (s) => {\n if (P(s))\n return g([\n s.m11,\n s.m12,\n s.m13,\n s.m14,\n s.m21,\n s.m22,\n s.m23,\n s.m24,\n s.m31,\n s.m32,\n s.m33,\n s.m34,\n s.m41,\n s.m42,\n s.m43,\n s.m44\n ]);\n throw TypeError(\n `CSSMatrix: \"${JSON.stringify(s)}\" is not a DOMMatrix / CSSMatrix / JSON compatible object.`\n );\n}, O = (s) => {\n if (typeof s != \"string\")\n throw TypeError(`CSSMatrix: \"${JSON.stringify(s)}\" is not a string.`);\n const t = String(s).replace(/\\s/g, \"\");\n let e = new y();\n const n = `CSSMatrix: invalid transform string \"${s}\"`;\n return t.split(\")\").filter((i) => i).forEach((i) => {\n const [r, a] = i.split(\"(\");\n if (!a) throw TypeError(n);\n const l = a.split(\",\").map(\n (o) => o.includes(\"rad\") ? parseFloat(o) * (180 / Math.PI) : parseFloat(o)\n ), [m, h, c, u] = l, f = [m, h, c], w = [m, h, c, u];\n if (r === \"perspective\" && m && [h, c].every((o) => o === void 0))\n e.m34 = -1 / m;\n else if (r.includes(\"matrix\") && [6, 16].includes(l.length) && l.every((o) => !Number.isNaN(+o))) {\n const o = l.map((d) => Math.abs(d) < 1e-6 ? 0 : d);\n e = e.multiply(g(o));\n } else if (r === \"translate3d\" && f.every((o) => !Number.isNaN(+o)))\n e = e.translate(m, h, c);\n else if (r === \"translate\" && m && c === void 0)\n e = e.translate(m, h || 0, 0);\n else if (r === \"rotate3d\" && w.every((o) => !Number.isNaN(+o)) && u)\n e = e.rotateAxisAngle(m, h, c, u);\n else if (r === \"rotate\" && m && [h, c].every((o) => o === void 0))\n e = e.rotate(0, 0, m);\n else if (r === \"scale3d\" && f.every((o) => !Number.isNaN(+o)) && f.some((o) => o !== 1))\n e = e.scale(m, h, c);\n else if (\n // prop === \"scale\" && !Number.isNaN(x) && x !== 1 && z === undefined\n // prop === \"scale\" && !Number.isNaN(x) && [x, y].some((n) => n !== 1) &&\n r === \"scale\" && !Number.isNaN(m) && (m !== 1 || h !== 1) && c === void 0\n ) {\n const d = Number.isNaN(+h) ? m : h;\n e = e.scale(m, d, 1);\n } else if (r === \"skew\" && (m || !Number.isNaN(m) && h) && c === void 0)\n e = e.skew(m, h || 0);\n else if ([\"translate\", \"rotate\", \"scale\", \"skew\"].some(\n (o) => r.includes(o)\n ) && /[XYZ]/.test(r) && m && [h, c].every((o) => o === void 0))\n if (r === \"skewX\" || r === \"skewY\")\n e = e[r](m);\n else {\n const o = r.replace(/[XYZ]/, \"\"), d = r.replace(o, \"\"), A = [\"X\", \"Y\", \"Z\"].indexOf(d), M = o === \"scale\" ? 1 : 0, b = [\n A === 0 ? m : M,\n A === 1 ? m : M,\n A === 2 ? m : M\n ];\n e = e[o](...b);\n }\n else\n throw TypeError(n);\n }), e;\n}, x = (s, t) => t ? [s.a, s.b, s.c, s.d, s.e, s.f] : [\n s.m11,\n s.m12,\n s.m13,\n s.m14,\n s.m21,\n s.m22,\n s.m23,\n s.m24,\n s.m31,\n s.m32,\n s.m33,\n s.m34,\n s.m41,\n s.m42,\n s.m43,\n s.m44\n], Y = (s, t, e) => {\n const n = new y();\n return n.m41 = s, n.e = s, n.m42 = t, n.f = t, n.m43 = e, n;\n}, F = (s, t, e) => {\n const n = new y(), i = Math.PI / 180, r = s * i, a = t * i, l = e * i, m = Math.cos(r), h = -Math.sin(r), c = Math.cos(a), u = -Math.sin(a), f = Math.cos(l), w = -Math.sin(l), o = c * f, d = -c * w;\n n.m11 = o, n.a = o, n.m12 = d, n.b = d, n.m13 = u;\n const A = h * u * f + m * w;\n n.m21 = A, n.c = A;\n const M = m * f - h * u * w;\n return n.m22 = M, n.d = M, n.m23 = -h * c, n.m31 = h * w - m * u * f, n.m32 = h * f + m * u * w, n.m33 = m * c, n;\n}, T = (s, t, e, n) => {\n const i = new y(), r = Math.sqrt(s * s + t * t + e * e);\n if (r === 0)\n return i;\n const a = s / r, l = t / r, m = e / r, h = n * (Math.PI / 360), c = Math.sin(h), u = Math.cos(h), f = c * c, w = a * a, o = l * l, d = m * m, A = 1 - 2 * (o + d) * f;\n i.m11 = A, i.a = A;\n const M = 2 * (a * l * f + m * c * u);\n i.m12 = M, i.b = M, i.m13 = 2 * (a * m * f - l * c * u);\n const b = 2 * (l * a * f - m * c * u);\n i.m21 = b, i.c = b;\n const k = 1 - 2 * (d + w) * f;\n return i.m22 = k, i.d = k, i.m23 = 2 * (l * m * f + a * c * u), i.m31 = 2 * (m * a * f + l * c * u), i.m32 = 2 * (m * l * f - a * c * u), i.m33 = 1 - 2 * (w + o) * f, i;\n}, I = (s, t, e) => {\n const n = new y();\n return n.m11 = s, n.a = s, n.m22 = t, n.d = t, n.m33 = e, n;\n}, v = (s, t) => {\n const e = new y();\n if (s) {\n const n = s * Math.PI / 180, i = Math.tan(n);\n e.m21 = i, e.c = i;\n }\n if (t) {\n const n = t * Math.PI / 180, i = Math.tan(n);\n e.m12 = i, e.b = i;\n }\n return e;\n}, R = (s) => v(s, 0), D = (s) => v(0, s), N = (s, t) => {\n const e = t.m11 * s.m11 + t.m12 * s.m21 + t.m13 * s.m31 + t.m14 * s.m41, n = t.m11 * s.m12 + t.m12 * s.m22 + t.m13 * s.m32 + t.m14 * s.m42, i = t.m11 * s.m13 + t.m12 * s.m23 + t.m13 * s.m33 + t.m14 * s.m43, r = t.m11 * s.m14 + t.m12 * s.m24 + t.m13 * s.m34 + t.m14 * s.m44, a = t.m21 * s.m11 + t.m22 * s.m21 + t.m23 * s.m31 + t.m24 * s.m41, l = t.m21 * s.m12 + t.m22 * s.m22 + t.m23 * s.m32 + t.m24 * s.m42, m = t.m21 * s.m13 + t.m22 * s.m23 + t.m23 * s.m33 + t.m24 * s.m43, h = t.m21 * s.m14 + t.m22 * s.m24 + t.m23 * s.m34 + t.m24 * s.m44, c = t.m31 * s.m11 + t.m32 * s.m21 + t.m33 * s.m31 + t.m34 * s.m41, u = t.m31 * s.m12 + t.m32 * s.m22 + t.m33 * s.m32 + t.m34 * s.m42, f = t.m31 * s.m13 + t.m32 * s.m23 + t.m33 * s.m33 + t.m34 * s.m43, w = t.m31 * s.m14 + t.m32 * s.m24 + t.m33 * s.m34 + t.m34 * s.m44, o = t.m41 * s.m11 + t.m42 * s.m21 + t.m43 * s.m31 + t.m44 * s.m41, d = t.m41 * s.m12 + t.m42 * s.m22 + t.m43 * s.m32 + t.m44 * s.m42, A = t.m41 * s.m13 + t.m42 * s.m23 + t.m43 * s.m33 + t.m44 * s.m43, M = t.m41 * s.m14 + t.m42 * s.m24 + t.m43 * s.m34 + t.m44 * s.m44;\n return g([\n e,\n n,\n i,\n r,\n a,\n l,\n m,\n h,\n c,\n u,\n f,\n w,\n o,\n d,\n A,\n M\n ]);\n};\nclass y {\n /**\n * @constructor\n * @param init accepts all parameter configurations:\n * * valid CSS transform string,\n * * CSSMatrix/DOMMatrix instance,\n * * a 6/16 elements *Array*.\n */\n constructor(t) {\n return this.a = 1, this.b = 0, this.c = 0, this.d = 1, this.e = 0, this.f = 0, this.m11 = 1, this.m12 = 0, this.m13 = 0, this.m14 = 0, this.m21 = 0, this.m22 = 1, this.m23 = 0, this.m24 = 0, this.m31 = 0, this.m32 = 0, this.m33 = 1, this.m34 = 0, this.m41 = 0, this.m42 = 0, this.m43 = 0, this.m44 = 1, t ? this.setMatrixValue(t) : this;\n }\n /**\n * A `Boolean` whose value is `true` if the matrix is the identity matrix. The identity\n * matrix is one in which every value is 0 except those on the main diagonal from top-left\n * to bottom-right corner (in other words, where the offsets in each direction are equal).\n *\n * @return the current property value\n */\n get isIdentity() {\n return this.m11 === 1 && this.m12 === 0 && this.m13 === 0 && this.m14 === 0 && this.m21 === 0 && this.m22 === 1 && this.m23 === 0 && this.m24 === 0 && this.m31 === 0 && this.m32 === 0 && this.m33 === 1 && this.m34 === 0 && this.m41 === 0 && this.m42 === 0 && this.m43 === 0 && this.m44 === 1;\n }\n /**\n * A `Boolean` flag whose value is `true` if the matrix was initialized as a 2D matrix\n * and `false` if the matrix is 3D.\n *\n * @return the current property value\n */\n get is2D() {\n return this.m31 === 0 && this.m32 === 0 && this.m33 === 1 && this.m34 === 0 && this.m43 === 0 && this.m44 === 1;\n }\n /**\n * The `setMatrixValue` method replaces the existing matrix with one computed\n * in the browser. EG: `matrix(1,0.25,-0.25,1,0,0)`\n *\n * The method accepts any *Array* values, the result of\n * `DOMMatrix` instance method `toFloat64Array()` / `toFloat32Array()` calls\n * or `CSSMatrix` instance method `toArray()`.\n *\n * This method expects valid *matrix()* / *matrix3d()* string values, as well\n * as other transform functions like *translateX(10px)*.\n *\n * @param source\n * @return the matrix instance\n */\n setMatrixValue(t) {\n return typeof t == \"string\" && t.length && t !== \"none\" ? O(t) : Array.isArray(t) || t instanceof Float64Array || t instanceof Float32Array ? g(t) : typeof t == \"object\" ? X(t) : this;\n }\n /**\n * Returns a *Float32Array* containing elements which comprise the matrix.\n * The method can return either the 16 elements or the 6 elements\n * depending on the value of the `is2D` parameter.\n *\n * @param is2D *Array* representation of the matrix\n * @return an *Array* representation of the matrix\n */\n toFloat32Array(t) {\n return Float32Array.from(x(this, t));\n }\n /**\n * Returns a *Float64Array* containing elements which comprise the matrix.\n * The method can return either the 16 elements or the 6 elements\n * depending on the value of the `is2D` parameter.\n *\n * @param is2D *Array* representation of the matrix\n * @return an *Array* representation of the matrix\n */\n toFloat64Array(t) {\n return Float64Array.from(x(this, t));\n }\n /**\n * Creates and returns a string representation of the matrix in `CSS` matrix syntax,\n * using the appropriate `CSS` matrix notation.\n *\n * matrix3d *matrix3d(m11, m12, m13, m14, m21, ...)*\n * matrix *matrix(a, b, c, d, e, f)*\n *\n * @return a string representation of the matrix\n */\n toString() {\n const { is2D: t } = this, e = this.toFloat64Array(t).join(\", \");\n return `${t ? \"matrix\" : \"matrix3d\"}(${e})`;\n }\n /**\n * Returns a JSON representation of the `CSSMatrix` instance, a standard *Object*\n * that includes `{a,b,c,d,e,f}` and `{m11,m12,m13,..m44}` properties as well\n * as the `is2D` & `isIdentity` properties.\n *\n * The result can also be used as a second parameter for the `fromMatrix` static method\n * to load values into another matrix instance.\n *\n * @return an *Object* with all matrix values.\n */\n toJSON() {\n const { is2D: t, isIdentity: e } = this;\n return { ...this, is2D: t, isIdentity: e };\n }\n /**\n * The Multiply method returns a new CSSMatrix which is the result of this\n * matrix multiplied by the passed matrix, with the passed matrix to the right.\n * This matrix is not modified.\n *\n * @param m2 CSSMatrix\n * @return The resulted matrix.\n */\n multiply(t) {\n return N(this, t);\n }\n /**\n * The translate method returns a new matrix which is this matrix post\n * multiplied by a translation matrix containing the passed values. If the z\n * component is undefined, a 0 value is used in its place. This matrix is not\n * modified.\n *\n * @param x X component of the translation value.\n * @param y Y component of the translation value.\n * @param z Z component of the translation value.\n * @return The resulted matrix\n */\n translate(t, e, n) {\n const i = t;\n let r = e, a = n;\n return typeof r > \"u\" && (r = 0), typeof a > \"u\" && (a = 0), N(this, Y(i, r, a));\n }\n /**\n * The scale method returns a new matrix which is this matrix post multiplied by\n * a scale matrix containing the passed values. If the z component is undefined,\n * a 1 value is used in its place. If the y component is undefined, the x\n * component value is used in its place. This matrix is not modified.\n *\n * @param x The X component of the scale value.\n * @param y The Y component of the scale value.\n * @param z The Z component of the scale value.\n * @return The resulted matrix\n */\n scale(t, e, n) {\n const i = t;\n let r = e, a = n;\n return typeof r > \"u\" && (r = t), typeof a > \"u\" && (a = 1), N(this, I(i, r, a));\n }\n /**\n * The rotate method returns a new matrix which is this matrix post multiplied\n * by each of 3 rotation matrices about the major axes, first X, then Y, then Z.\n * If the y and z components are undefined, the x value is used to rotate the\n * object about the z axis, as though the vector (0,0,x) were passed. All\n * rotation values are in degrees. This matrix is not modified.\n *\n * @param rx The X component of the rotation, or Z if Y and Z are null.\n * @param ry The (optional) Y component of the rotation value.\n * @param rz The (optional) Z component of the rotation value.\n * @return The resulted matrix\n */\n rotate(t, e, n) {\n let i = t, r = e || 0, a = n || 0;\n return typeof t == \"number\" && typeof e > \"u\" && typeof n > \"u\" && (a = i, i = 0, r = 0), N(this, F(i, r, a));\n }\n /**\n * The rotateAxisAngle method returns a new matrix which is this matrix post\n * multiplied by a rotation matrix with the given axis and `angle`. The right-hand\n * rule is used to determine the direction of rotation. All rotation values are\n * in degrees. This matrix is not modified.\n *\n * @param x The X component of the axis vector.\n * @param y The Y component of the axis vector.\n * @param z The Z component of the axis vector.\n * @param angle The angle of rotation about the axis vector, in degrees.\n * @return The resulted matrix\n */\n rotateAxisAngle(t, e, n, i) {\n if ([t, e, n, i].some((r) => Number.isNaN(+r)))\n throw new TypeError(\"CSSMatrix: expecting 4 values\");\n return N(this, T(t, e, n, i));\n }\n /**\n * Specifies a skew transformation along the `x-axis` by the given angle.\n * This matrix is not modified.\n *\n * @param angle The angle amount in degrees to skew.\n * @return The resulted matrix\n */\n skewX(t) {\n return N(this, R(t));\n }\n /**\n * Specifies a skew transformation along the `y-axis` by the given angle.\n * This matrix is not modified.\n *\n * @param angle The angle amount in degrees to skew.\n * @return The resulted matrix\n */\n skewY(t) {\n return N(this, D(t));\n }\n /**\n * Specifies a skew transformation along both the `x-axis` and `y-axis`.\n * This matrix is not modified.\n *\n * @param angleX The X-angle amount in degrees to skew.\n * @param angleY The angle amount in degrees to skew.\n * @return The resulted matrix\n */\n skew(t, e) {\n return N(this, v(t, e));\n }\n /**\n * Transforms a specified vector using the matrix, returning a new\n * {x,y,z,w} Tuple *Object* comprising the transformed vector.\n * Neither the matrix nor the original vector are altered.\n *\n * The method is equivalent with `transformPoint()` method\n * of the `DOMMatrix` constructor.\n *\n * @param t Tuple with `{x,y,z,w}` components\n * @return the resulting Tuple\n */\n transformPoint(t) {\n const e = this.m11 * t.x + this.m21 * t.y + this.m31 * t.z + this.m41 * t.w, n = this.m12 * t.x + this.m22 * t.y + this.m32 * t.z + this.m42 * t.w, i = this.m13 * t.x + this.m23 * t.y + this.m33 * t.z + this.m43 * t.w, r = this.m14 * t.x + this.m24 * t.y + this.m34 * t.z + this.m44 * t.w;\n return t instanceof DOMPoint ? new DOMPoint(e, n, i, r) : {\n x: e,\n y: n,\n z: i,\n w: r\n };\n }\n}\np(y, \"Translate\", Y), p(y, \"Rotate\", F), p(y, \"RotateAxisAngle\", T), p(y, \"Scale\", I), p(y, \"SkewX\", R), p(y, \"SkewY\", D), p(y, \"Skew\", v), p(y, \"Multiply\", N), p(y, \"fromArray\", g), p(y, \"fromMatrix\", X), p(y, \"fromString\", O), p(y, \"toArray\", x), p(y, \"isCompatibleArray\", E), p(y, \"isCompatibleObject\", P);\nexport {\n y as default\n};\n//# sourceMappingURL=dommatrix.mjs.map\n","import { PointTuple } from \"../types\";\n\n/**\n * Returns the coordinates of a specified distance\n * ratio between two points.\n *\n * @param a the first point coordinates\n * @param b the second point coordinates\n * @param t the ratio\n * @returns the midpoint coordinates\n */\nconst midPoint = (a: PointTuple, b: PointTuple, t: number): PointTuple => {\n const [ax, ay] = a;\n const [bx, by] = b;\n return [ax + (bx - ax) * t, ay + (by - ay) * t];\n};\n\nexport default midPoint;\n","import { type PointTuple } from \"../types\";\n\n/**\n * Returns the square root of the distance\n * between two given points.\n *\n * @param a the first point coordinates\n * @param b the second point coordinates\n * @returns the distance value\n */\nconst distanceSquareRoot = (a: PointTuple, b: PointTuple) => {\n return Math.sqrt(\n (a[0] - b[0]) * (a[0] - b[0]) + (a[1] - b[1]) * (a[1] - b[1]),\n );\n};\n\nexport default distanceSquareRoot;\n","import midPoint from \"./midPoint\";\nimport distanceSquareRoot from \"./distanceSquareRoot\";\n\n/**\n * Returns length for line segments (MoveTo, LineTo).\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the line segment length\n */\nconst getLineLength = (x1: number, y1: number, x2: number, y2: number) => {\n return distanceSquareRoot([x1, y1], [x2, y2]);\n};\n\n/**\n * Returns a point along the line segments (MoveTo, LineTo).\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance the distance to point in [0-1] range\n * @returns the point at length\n */\nconst getPointAtLineLength = (\n x1: number,\n y1: number,\n x2: number,\n y2: number,\n distance?: number,\n) => {\n let point = { x: x1, y: y1 };\n\n /* istanbul ignore else @preserve */\n if (typeof distance === \"number\") {\n const length = distanceSquareRoot([x1, y1], [x2, y2]);\n if (distance <= 0) {\n point = { x: x1, y: y1 };\n } else if (distance >= length) {\n point = { x: x2, y: y2 };\n } else {\n const [x, y] = midPoint([x1, y1], [x2, y2], distance / length);\n point = { x, y };\n }\n }\n return point;\n};\n\n/**\n * Returns bounding box for line segments (MoveTo, LineTo).\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance the distance to point in [0-1] range\n * @returns the extrema for line segments\n */\nconst getLineBBox = (x1: number, y1: number, x2: number, y2: number) => {\n const { min, max } = Math;\n\n return [min(x1, x2), min(y1, y2), max(x1, x2), max(y1, y2)] as [\n number,\n number,\n number,\n number,\n ];\n};\n\nexport { getLineBBox, getLineLength, getPointAtLineLength };\n","import { getPointAtLineLength } from \"./lineTools\";\nimport type { Point, PointTuple } from \"../types\";\n\n/**\n * Returns the Arc segment length.\n * @param rx radius along X axis\n * @param ry radius along Y axis\n * @param theta the angle in radians\n * @returns the arc length\n */\nconst arcLength = (rx: number, ry: number, theta: number) => {\n const halfTheta = theta / 2;\n const sinHalfTheta = Math.sin(halfTheta);\n const cosHalfTheta = Math.cos(halfTheta);\n const term1 = rx ** 2 * sinHalfTheta ** 2;\n const term2 = ry ** 2 * cosHalfTheta ** 2;\n const length = Math.sqrt(term1 + term2) * theta;\n return Math.abs(length);\n};\n\n/**\n * Find point on ellipse at given angle around ellipse (theta);\n * @param cx the center X\n * @param cy the center Y\n * @param rx the radius X\n * @param ry the radius Y\n * @param alpha the arc rotation angle in radians\n * @param theta the arc sweep angle in radians\n * @returns a point around ellipse at given angle\n */\nconst arcPoint = (\n cx: number,\n cy: number,\n rx: number,\n ry: number,\n alpha: number,\n theta: number,\n) => {\n const { sin, cos } = Math;\n // theta is angle in radians around arc\n // alpha is angle of rotation of ellipse in radians\n const cosA = cos(alpha);\n const sinA = sin(alpha);\n const x = rx * cos(theta);\n const y = ry * sin(theta);\n\n return [cx + cosA * x - sinA * y, cy + sinA * x + cosA * y] as PointTuple;\n};\n\n/**\n * Returns the angle between two points.\n * @param v0 starting point\n * @param v1 ending point\n * @returns the angle in radian\n */\nconst angleBetween = (v0: Point, v1: Point) => {\n const { x: v0x, y: v0y } = v0;\n const { x: v1x, y: v1y } = v1;\n const p = v0x * v1x + v0y * v1y;\n const n = Math.sqrt((v0x ** 2 + v0y ** 2) * (v1x ** 2 + v1y ** 2));\n const sign = v0x * v1y - v0y * v1x < 0 ? -1 : 1;\n return sign * Math.acos(p / n);\n};\n\n/**\n * Returns the following properties for an Arc segment: center, start angle,\n * end angle, and radiuses on X and Y axis.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param RX the radius on X axis\n * @param RY the radius on Y axis\n * @param angle the ellipse rotation in degrees\n * @param LAF the large arc flag\n * @param SF the sweep flag\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns properties specific to Arc segments\n */\nconst getArcProps = (\n x1: number,\n y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n x: number,\n y: number,\n) => {\n const { abs, sin, cos, sqrt, PI } = Math;\n let rx = abs(RX);\n let ry = abs(RY);\n const xRot = ((angle % 360) + 360) % 360;\n const xRotRad = xRot * (PI / 180);\n\n // istanbul ignore next @preserve\n if (x1 === x && y1 === y) {\n return {\n rx,\n ry,\n startAngle: 0,\n endAngle: 0,\n center: { x, y },\n };\n }\n\n if (rx === 0 || ry === 0) {\n return {\n rx,\n ry,\n startAngle: 0,\n endAngle: 0,\n center: { x: (x + x1) / 2, y: (y + y1) / 2 },\n };\n }\n\n const dx = (x1 - x) / 2;\n const dy = (y1 - y) / 2;\n\n const transformedPoint = {\n x: cos(xRotRad) * dx + sin(xRotRad) * dy,\n y: -sin(xRotRad) * dx + cos(xRotRad) * dy,\n };\n\n const radiiCheck = transformedPoint.x ** 2 / rx ** 2 +\n transformedPoint.y ** 2 / ry ** 2;\n\n if (radiiCheck > 1) {\n rx *= sqrt(radiiCheck);\n ry *= sqrt(radiiCheck);\n }\n\n const cSquareNumerator = rx ** 2 * ry ** 2 -\n rx ** 2 * transformedPoint.y ** 2 - ry ** 2 * transformedPoint.x ** 2;\n const cSquareRootDenom = rx ** 2 * transformedPoint.y ** 2 +\n ry ** 2 * transformedPoint.x ** 2;\n\n let cRadicand = cSquareNumerator / cSquareRootDenom;\n /* istanbul ignore next @preserve */\n cRadicand = cRadicand < 0 ? 0 : cRadicand;\n const cCoef = (LAF !== SF ? 1 : -1) * sqrt(cRadicand);\n const transformedCenter = {\n x: cCoef * ((rx * transformedPoint.y) / ry),\n y: cCoef * (-(ry * transformedPoint.x) / rx),\n };\n\n const center = {\n x: cos(xRotRad) * transformedCenter.x - sin(xRotRad) * transformedCenter.y +\n (x1 + x) / 2,\n y: sin(xRotRad) * transformedCenter.x + cos(xRotRad) * transformedCenter.y +\n (y1 + y) / 2,\n };\n\n const startVector = {\n x: (transformedPoint.x - transformedCenter.x) / rx,\n y: (transformedPoint.y - transformedCenter.y) / ry,\n };\n\n const startAngle = angleBetween({ x: 1, y: 0 }, startVector);\n\n const endVector = {\n x: (-transformedPoint.x - transformedCenter.x) / rx,\n y: (-transformedPoint.y - transformedCenter.y) / ry,\n };\n\n let sweepAngle = angleBetween(startVector, endVector);\n if (!SF && sweepAngle > 0) {\n sweepAngle -= 2 * PI;\n } else if (SF && sweepAngle < 0) {\n sweepAngle += 2 * PI;\n }\n sweepAngle %= 2 * PI;\n\n const endAngle = startAngle + sweepAngle;\n\n // point.ellipticalArcStartAngle = startAngle;\n // point.ellipticalArcEndAngle = startAngle + sweepAngle;\n // point.ellipticalArcAngle = alpha;\n\n // point.ellipticalArcCenter = center;\n // point.resultantRx = rx;\n // point.resultantRy = ry;\n\n return {\n center,\n startAngle,\n endAngle,\n rx,\n ry,\n };\n};\n\n/**\n * Returns the length of an Arc segment.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the length of the Arc segment\n */\nconst getArcLength = (\n x1: number,\n y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n x: number,\n y: number,\n) => {\n const { rx, ry, startAngle, endAngle } = getArcProps(\n x1,\n y1,\n RX,\n RY,\n angle,\n LAF,\n SF,\n x,\n y,\n );\n return arcLength(rx, ry, endAngle - startAngle);\n};\n\n/**\n * Returns a point along an Arc segment at a given distance.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param RX the radius on X axis\n * @param RY the radius on Y axis\n * @param angle the ellipse rotation in degrees\n * @param LAF the large arc flag\n * @param SF the sweep flag\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance a [0-1] ratio\n * @returns a point along the Arc segment\n */\nconst getPointAtArcLength = (\n x1: number,\n y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n x: number,\n y: number,\n distance?: number,\n) => {\n let point = { x: x1, y: y1 };\n const { center, rx, ry, startAngle, endAngle } = getArcProps(\n x1,\n y1,\n RX,\n RY,\n angle,\n LAF,\n SF,\n x,\n y,\n );\n\n /* istanbul ignore else @preserve */\n if (typeof distance === \"number\") {\n const length = arcLength(rx, ry, endAngle - startAngle);\n if (distance <= 0) {\n point = { x: x1, y: y1 };\n } else if (distance >= length) {\n point = { x, y };\n } else {\n /* istanbul ignore next @preserve */\n if (x1 === x && y1 === y) {\n return { x, y };\n }\n /* istanbul ignore next @preserve */\n if (rx === 0 || ry === 0) {\n return getPointAtLineLength(x1, y1, x, y, distance);\n }\n const { PI, cos, sin } = Math;\n const sweepAngle = endAngle - startAngle;\n const xRot = ((angle % 360) + 360) % 360;\n const xRotRad = xRot * (PI / 180);\n const alpha = startAngle + sweepAngle * (distance / length);\n const ellipseComponentX = rx * cos(alpha);\n const ellipseComponentY = ry * sin(alpha);\n\n point = {\n x: cos(xRotRad) * ellipseComponentX - sin(xRotRad) * ellipseComponentY +\n center.x,\n y: sin(xRotRad) * ellipseComponentX + cos(xRotRad) * ellipseComponentY +\n center.y,\n };\n }\n }\n\n return point;\n};\n\n/**\n * Returns the extrema for an Arc segment in the following format:\n * [MIN_X, MIN_Y, MAX_X, MAX_Y]\n *\n * @see https://github.com/herrstrietzel/svg-pathdata-getbbox\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param RX the radius on X axis\n * @param RY the radius on Y axis\n * @param angle the ellipse rotation in degrees\n * @param LAF the large arc flag\n * @param SF the sweep flag\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the extrema of the Arc segment\n */\nconst getArcBBox = (\n x1: number,\n y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n x: number,\n y: number,\n) => {\n const { center, rx, ry, startAngle, endAngle } = getArcProps(\n x1,\n y1,\n RX,\n RY,\n angle,\n LAF,\n SF,\n x,\n y,\n );\n const deltaAngle = endAngle - startAngle;\n const { min, max, tan, atan2, PI } = Math;\n\n // circle/elipse center coordinates\n const { x: cx, y: cy } = center;\n\n // rotation to radians\n const alpha = (angle * PI) / 180;\n const tangent = tan(alpha);\n\n /**\n * find min/max from zeroes of directional derivative along x and y\n * along x axis\n */\n const theta = atan2(-ry * tangent, rx);\n const angle1 = theta;\n const angle2 = theta + PI;\n const angle3 = atan2(ry, rx * tangent);\n const angle4 = angle3 + PI;\n const xArray = [x];\n const yArray = [y];\n\n // inner bounding box\n let xMin = min(x1, x);\n let xMax = max(x1, x);\n let yMin = min(y1, y);\n let yMax = max(y1, y);\n\n // on path point close after start\n const angleAfterStart = endAngle - deltaAngle * 0.00001;\n const pP2 = arcPoint(cx, cy, rx, ry, alpha, angleAfterStart);\n\n // on path point close before end\n const angleBeforeEnd = endAngle - deltaAngle * 0.99999;\n const pP3 = arcPoint(cx, cy, rx, ry, alpha, angleBeforeEnd);\n\n /**\n * expected extremes\n * if leaving inner bounding box\n * (between segment start and end point)\n * otherwise exclude elliptic extreme points\n */\n\n // right\n if (pP2[0] > xMax || pP3[0] > xMax) {\n // get point for this theta\n const p1 = arcPoint(cx, cy, rx, ry, alpha, angle1);\n xArray.push(p1[0]);\n yArray.push(p1[1]);\n }\n\n // left\n if (pP2[0] < xMin || pP3[0] < xMin) {\n // get anti-symmetric point\n const p2 = arcPoint(cx, cy, rx, ry, alpha, angle2);\n xArray.push(p2[0]);\n yArray.push(p2[1]);\n }\n\n // top\n if (pP2[1] < yMin || pP3[1] < yMin) {\n // get anti-symmetric point\n const p4 = arcPoint(cx, cy, rx, ry, alpha, angle4);\n xArray.push(p4[0]);\n yArray.push(p4[1]);\n }\n\n // bottom\n if (pP2[1] > yMax || pP3[1] > yMax) {\n // get point for this theta\n const p3 = arcPoint(cx, cy, rx, ry, alpha, angle3);\n xArray.push(p3[0]);\n yArray.push(p3[1]);\n }\n\n xMin = min.apply([], xArray);\n yMin = min.apply([], yArray);\n xMax = max.apply([], xArray);\n yMax = max.apply([], yArray);\n\n return [xMin, yMin, xMax, yMax] as [number, number, number, number];\n};\n\nexport {\n angleBetween,\n arcLength,\n arcPoint,\n getArcBBox,\n getArcLength,\n getArcProps,\n getPointAtArcLength,\n};\n","import type {\n CubicCoordinates,\n CubicPoints,\n DeriveCallback,\n DerivedCubicPoints,\n DerivedPoint,\n DerivedQuadPoints,\n PointTuple,\n QuadCoordinates,\n QuadPoints,\n} from \"../types\";\n\n/**\n * Tools from bezier.js by Mike 'Pomax' Kamermans\n * @see https://github.com/Pomax/bezierjs\n */\n\nconst Tvalues = [\n -0.0640568928626056260850430826247450385909,\n 0.0640568928626056260850430826247450385909,\n -0.1911188674736163091586398207570696318404,\n 0.1911188674736163091586398207570696318404,\n -0.3150426796961633743867932913198102407864,\n 0.3150426796961633743867932913198102407864,\n -0.4337935076260451384870842319133497124524,\n 0.4337935076260451384870842319133497124524,\n -0.5454214713888395356583756172183723700107,\n 0.5454214713888395356583756172183723700107,\n -0.6480936519369755692524957869107476266696,\n 0.6480936519369755692524957869107476266696,\n -0.7401241915785543642438281030999784255232,\n 0.7401241915785543642438281030999784255232,\n -0.8200019859739029219539498726697452080761,\n 0.8200019859739029219539498726697452080761,\n -0.8864155270044010342131543419821967550873,\n 0.8864155270044010342131543419821967550873,\n -0.9382745520027327585236490017087214496548,\n 0.9382745520027327585236490017087214496548,\n -0.9747285559713094981983919930081690617411,\n 0.9747285559713094981983919930081690617411,\n -0.9951872199970213601799974097007368118745,\n 0.9951872199970213601799974097007368118745,\n];\n\nconst Cvalues = [\n 0.1279381953467521569740561652246953718517,\n 0.1279381953467521569740561652246953718517,\n 0.1258374563468282961213753825111836887264,\n 0.1258374563468282961213753825111836887264,\n 0.121670472927803391204463153476262425607,\n 0.121670472927803391204463153476262425607,\n 0.1155056680537256013533444839067835598622,\n 0.1155056680537256013533444839067835598622,\n 0.1074442701159656347825773424466062227946,\n 0.1074442701159656347825773424466062227946,\n 0.0976186521041138882698806644642471544279,\n 0.0976186521041138882698806644642471544279,\n 0.086190161531953275917185202983742667185,\n 0.086190161531953275917185202983742667185,\n 0.0733464814110803057340336152531165181193,\n 0.0733464814110803057340336152531165181193,\n 0.0592985849154367807463677585001085845412,\n 0.0592985849154367807463677585001085845412,\n 0.0442774388174198061686027482113382288593,\n 0.0442774388174198061686027482113382288593,\n 0.0285313886289336631813078159518782864491,\n 0.0285313886289336631813078159518782864491,\n 0.0123412297999871995468056670700372915759,\n 0.0123412297999871995468056670700372915759,\n];\n\n/**\n * @param points\n * @returns\n */\nconst deriveBezier = (points: QuadPoints | CubicPoints) => {\n const dpoints = [] as (DerivedCubicPoints | DerivedQuadPoints)[];\n for (let p = points, d = p.length, c = d - 1; d > 1; d -= 1, c -= 1) {\n const list = [] as unknown as DerivedCubicPoints | DerivedQuadPoints;\n for (let j = 0; j < c; j += 1) {\n list.push({\n x: c * (p[j + 1].x - p[j].x),\n y: c * (p[j + 1].y - p[j].y),\n t: 0,\n });\n }\n dpoints.push(list);\n p = list;\n }\n return dpoints;\n};\n\n/**\n * @param points\n * @param t\n */\nconst computeBezier = (\n points: DerivedQuadPoints | DerivedCubicPoints,\n t: number,\n) => {\n // shortcuts\n /* istanbul ignore next @preserve */\n if (t === 0) {\n points[0].t = 0;\n return points[0];\n }\n\n const order = points.length - 1;\n\n /* istanbul ignore next @preserve */\n if (t === 1) {\n points[order].t = 1;\n return points[order];\n }\n\n const mt = 1 - t;\n let p = points as typeof points | [\n DerivedPoint,\n DerivedPoint,\n DerivedPoint,\n DerivedPoint,\n ];\n\n // constant?\n /* istanbul ignore next @preserve */\n if (order === 0) {\n points[0].t = t;\n return points[0];\n }\n\n // linear?\n /* istanbul ignore else @preserve */\n if (order === 1) {\n return {\n x: mt * p[0].x + t * p[1].x,\n y: mt * p[0].y + t * p[1].y,\n t,\n };\n }\n\n // quadratic/cubic curve?\n const mt2 = mt * mt;\n const t2 = t * t;\n let a = 0;\n let b = 0;\n let c = 0;\n let d = 0;\n /* istanbul ignore else @preserve */\n if (order === 2) {\n p = [p[0], p[1], p[2], { x: 0, y: 0 } as DerivedPoint];\n a = mt2;\n b = mt * t * 2;\n c = t2;\n } else if (order === 3) {\n a = mt2 * mt;\n b = mt2 * t * 3;\n c = mt * t2 * 3;\n d = t * t2;\n }\n return {\n x: a * p[0].x + b * p[1].x + c * p[2].x + d * p[3].x,\n y: a * p[0].y + b * p[1].y + c * p[2].y + d * p[3].y,\n t,\n };\n};\n\nconst calculateBezier = (derivativeFn: DeriveCallback, t: number) => {\n const d = derivativeFn(t);\n const l = d.x * d.x + d.y * d.y;\n\n return Math.sqrt(l);\n};\n\nconst bezierLength = (derivativeFn: DeriveCallback) => {\n const z = 0.5;\n const len = Tvalues.length;\n\n let sum = 0;\n\n for (let i = 0, t; i < len; i++) {\n t = z * Tvalues[i] + z;\n sum += Cvalues[i] * calculateBezier(derivativeFn, t);\n }\n return z * sum;\n};\n\n/**\n * Returns the length of CubicBezier / Quad segment.\n * @param curve cubic / quad bezier segment\n */\nconst getBezierLength = (curve: CubicCoordinates | QuadCoordinates) => {\n const points = [] as unknown as CubicPoints | QuadPoints;\n for (let idx = 0, len = curve.length, step = 2; idx < len; idx += step) {\n points.push({\n x: curve[idx],\n y: curve[idx + 1],\n });\n }\n const dpoints = deriveBezier(points);\n return bezierLength((t: number) => {\n return computeBezier(dpoints[0], t);\n });\n};\n\n// Precision for consider cubic polynom as quadratic one\nconst CBEZIER_MINMAX_EPSILON = 0.00000001;\n\n/**\n * Returns the most extreme points in a Quad Bezier segment.\n * @param A an array which consist of X/Y values\n */\n// https://github.com/kpym/SVGPathy/blob/acd1a50c626b36d81969f6e98e8602e128ba4302/lib/box.js#L89\nconst minmaxQ = ([v1, cp, v2]: [number, number, number]) => {\n const min = Math.min(v1, v2);\n const max = Math.max(v1, v2);\n\n /* istanbul ignore next @preserve */\n if (cp >= v1 ? v2 >= cp : v2 <= cp) {\n // if no extremum in ]0,1[\n return [min, max] as PointTuple;\n }\n\n // check if the extremum E is min or max\n const E = (v1 * v2 - cp * cp) / (v1 - 2 * cp + v2);\n return (E < min ? [E, max] : [min, E]) as PointTuple;\n};\n\n/**\n * Returns the most extreme points in a Cubic Bezier segment.\n * @param A an array which consist of X/Y values\n * @see https://github.com/kpym/SVGPathy/blob/acd1a50c626b36d81969f6e98e8602e128ba4302/lib/box.js#L127\n */\nconst minmaxC = ([v1, cp1, cp2, v2]: [number, number, number, number]) => {\n const K = v1 - 3 * cp1 + 3 * cp2 - v2;\n\n // if the polynomial is (almost) quadratic and not cubic\n /* istanbul ignore next @preserve */\n if (Math.abs(K) < CBEZIER_MINMAX_EPSILON) {\n if (v1 === v2 && v1 === cp1) {\n // no curve, point targeting same location\n return [v1, v2] as PointTuple;\n }\n\n return minmaxQ([v1, -0.5 * v1 + 1.5 * cp1, v1 - 3 * cp1 + 3 * cp2]);\n }\n\n // the reduced discriminant of the derivative\n const T = -v1 * cp2 + v1 * v2 - cp1 * cp2 - cp1 * v2 + cp1 * cp1 + cp2 * cp2;\n\n // if the polynomial is monotone in [0,1]\n if (T <= 0) {\n return [Math.min(v1, v2), Math.max(v1, v2)] as PointTuple;\n }\n const S = Math.sqrt(T);\n\n // potential extrema\n let min = Math.min(v1, v2);\n let max = Math.max(v1, v2);\n\n const L = v1 - 2 * cp1 + cp2;\n // check local extrema\n for (let R = (L + S) / K, i = 1; i <= 2; R = (L - S) / K, i++) {\n // istanbul ignore next @preserve\n if (R > 0 && R < 1) {\n // if the extrema is for R in [0,1]\n const Q = v1 * (1 - R) * (1 - R) * (1 - R) +\n cp1 * 3 * (1 - R) * (1 - R) * R + cp2 * 3 * (1 - R) * R * R +\n v2 * R * R * R;\n if (Q < min) {\n min = Q;\n }\n if (Q > max) {\n max = Q;\n }\n }\n }\n\n return [min, max] as PointTuple;\n};\n\nexport {\n bezierLength,\n calculateBezier,\n CBEZIER_MINMAX_EPSILON,\n computeBezier,\n Cvalues,\n deriveBezier,\n getBezierLength,\n minmaxC,\n minmaxQ,\n Tvalues,\n};\n","import { getBezierLength, minmaxC } from \"./bezier\";\nimport { type CubicCoordinates } from \"../types\";\n\n/**\n * Returns a point at a given length of a CubicBezier segment.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param t a [0-1] ratio\n * @returns the point at cubic-bezier segment length\n */\nconst getPointAtCubicSegmentLength = (\n [x1, y1, c1x, c1y, c2x, c2y, x2, y2]: CubicCoordinates,\n t: number,\n) => {\n const t1 = 1 - t;\n return {\n x: t1 ** 3 * x1 + 3 * t1 ** 2 * t * c1x + 3 * t1 * t ** 2 * c2x +\n t ** 3 * x2,\n y: t1 ** 3 * y1 + 3 * t1 ** 2 * t * c1y + 3 * t1 * t ** 2 * c2y +\n t ** 3 * y2,\n };\n};\n\n/**\n * Returns the length of a CubicBezier segment.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the CubicBezier segment length\n */\nconst getCubicLength = (\n x1: number,\n y1: number,\n c1x: number,\n c1y: number,\n c2x: number,\n c2y: number,\n x2: number,\n y2: number,\n) => {\n return getBezierLength([x1, y1, c1x, c1y, c2x, c2y, x2, y2]);\n};\n\n/**\n * Returns the point along a CubicBezier segment at a given distance.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance the distance to look at\n * @returns the point at CubicBezier length\n */\nconst getPointAtCubicLength = (\n x1: number,\n y1: number,\n c1x: number,\n c1y: number,\n c2x: number,\n c2y: number,\n x2: number,\n y2: number,\n distance?: number,\n) => {\n const distanceIsNumber = typeof distance === \"number\";\n let point = { x: x1, y: y1 };\n /* istanbul ignore else @preserve */\n if (distanceIsNumber) {\n const currentLength = getBezierLength([x1, y1, c1x, c1y, c2x, c2y, x2, y2]);\n if (distance <= 0) {\n // first point already defined\n } else if (distance >= currentLength) {\n point = { x: x2, y: y2 };\n } else {\n point = getPointAtCubicSegmentLength(\n [x1, y1, c1x, c1y, c2x, c2y, x2, y2],\n distance / currentLength,\n );\n }\n }\n return point;\n};\n\n/**\n * Returns the boundig box of a CubicBezier segment in the following format:\n * [MIN_X, MIN_Y, MAX_X, MAX_Y]\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the extrema of the CubicBezier segment\n */\nconst getCubicBBox = (\n x1: number,\n y1: number,\n c1x: number,\n c1y: number,\n c2x: number,\n c2y: number,\n x2: number,\n y2: number,\n) => {\n const cxMinMax = minmaxC([x1, c1x, c2x, x2]);\n const cyMinMax = minmaxC([y1, c1y, c2y, y2]);\n\n return [cxMinMax[0], cyMinMax[0], cxMinMax[1], cyMinMax[1]] as [\n number,\n number,\n number,\n number,\n ];\n};\n\nexport {\n getCubicBBox,\n getCubicLength,\n getPointAtCubicLength,\n getPointAtCubicSegmentLength,\n};\n","import { getBezierLength, minmaxQ } from \"./bezier\";\nimport { type QuadCoordinates } from \"../types\";\n\n/**\n * Returns the {x,y} coordinates of a point at a\n * given length of a quadratic-bezier segment.\n *\n * @see https://github.com/substack/point-at-length\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param cx the control point X\n * @param cy the control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param t a [0-1] ratio\n * @returns the requested {x,y} coordinates\n */\nconst getPointAtQuadSegmentLength = (\n [x1, y1, cx, cy, x2, y2]: QuadCoordinates,\n t: number,\n) => {\n const t1 = 1 - t;\n return {\n x: t1 ** 2 * x1 + 2 * t1 * t * cx + t ** 2 * x2,\n y: t1 ** 2 * y1 + 2 * t1 * t * cy + t ** 2 * y2,\n };\n};\n\n/**\n * Returns the length of a QuadraticBezier segment.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param cx the control point X\n * @param cy the control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the QuadraticBezier segment length\n */\nconst getQuadLength = (\n x1: number,\n y1: number,\n cx: number,\n cy: number,\n x2: number,\n y2: number,\n) => {\n return getBezierLength([x1, y1, cx, cy, x2, y2]);\n};\n\n/**\n * Returns the point along a QuadraticBezier segment at a given distance.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param cx the control point X\n * @param cy the control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance the distance to look at\n * @returns the point at QuadraticBezier length\n */\nconst getPointAtQuadLength = (\n x1: number,\n y1: number,\n cx: number,\n cy: number,\n x2: number,\n y2: number,\n distance?: number,\n) => {\n const distanceIsNumber = typeof distance === \"number\";\n let point = { x: x1, y: y1 };\n\n /* istanbul ignore else @preserve */\n if (distanceIsNumber) {\n const currentLength = getBezierLength([x1, y1, cx, cy, x2, y2]);\n if (distance <= 0) {\n // first point already defined\n } else if (distance >= currentLength) {\n point = { x: x2, y: y2 };\n } else {\n point = getPointAtQuadSegmentLength(\n [x1, y1, cx, cy, x2, y2],\n distance / currentLength,\n );\n }\n }\n return point;\n};\n\n/**\n * Returns the boundig box of a QuadraticBezier segment in the following format:\n * [MIN_X, MIN_Y, MAX_X, MAX_Y]\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param cx the control point X\n * @param cy the control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the extrema of the QuadraticBezier segment\n */\nconst getQuadBBox = (\n x1: number,\n y1: number,\n cx: number,\n cy: number,\n x2: number,\n y2: number,\n) => {\n const cxMinMax = minmaxQ([x1, cx, x2]);\n const cyMinMax = minmaxQ([y1, cy, y2]);\n return [cxMinMax[0], cyMinMax[0], cxMinMax[1], cyMinMax[1]] as [\n number,\n number,\n number,\n number,\n ];\n};\n\nexport {\n getPointAtQuadLength,\n getPointAtQuadSegmentLength,\n getQuadBBox,\n getQuadLength,\n};\n","import distanceSquareRoot from \"./distanceSquareRoot\";\nimport { type PointTuple } from \"../types\";\n\n/**\n * d3-polygon-area\n * https://github.com/d3/d3-polygon\n *\n * Returns the area of a polygon.\n *\n * @param polygon an array of coordinates\n * @returns the polygon area\n */\nconst polygonArea = (polygon: PointTuple[]) => {\n const n = polygon.length;\n let i = -1;\n let a: PointTuple;\n let b = polygon[n - 1];\n let area = 0;\n\n /* eslint-disable-next-line */\n while (++i < n) {\n a = b;\n b = polygon[i];\n area += a[1] * b[0] - a[0] * b[1];\n }\n\n return area / 2;\n};\n\n/**\n * d3-polygon-length\n * https://github.com/d3/d3-polygon\n *\n * Returns the perimeter of a polygon.\n *\n * @param polygon an array of coordinates\n * @returns the polygon length\n */\nconst polygonLength = (polygon: PointTuple[]) => {\n return polygon.reduce((length, point, i) => {\n if (i) {\n return length + distanceSquareRoot(polygon[i - 1], point);\n }\n return 0;\n }, 0);\n};\n\nexport { polygonArea, polygonLength };\n","/** Segment params length */\nconst paramsCount = {\n a: 7,\n c: 6,\n h: 1,\n l: 2,\n m: 2,\n r: 4,\n q: 4,\n s: 4,\n t: 2,\n v: 1,\n z: 0,\n};\n\nexport default paramsCount;\n","import paramsCount from \"./paramsCount\";\nimport PathParser from \"./pathParser\";\nimport type { PathCommand, PathSegment, RelativeCommand } from \"../types\";\n\n/**\n * Breaks the parsing of a pathString once a segment is finalized.\n *\n * @param path the `PathParser` instance\n */\nconst finalizeSegment = (path: PathParser) => {\n let pathCommand = path.pathValue[path.segmentStart] as PathCommand;\n let relativeCommand = pathCommand.toLowerCase() as RelativeCommand;\n const { data } = path;\n\n while (data.length >= paramsCount[relativeCommand]) {\n // overloaded `moveTo`\n // https://github.com/rveciana/svg-path-properties/blob/master/src/parse.ts\n if (relativeCommand === \"m\" && data.length > 2) {\n path.segments.push(\n [pathCommand as PathCommand | number].concat(\n data.splice(0, 2) as number[],\n ) as PathSegment,\n );\n relativeCommand = \"l\";\n pathCommand = pathCommand === \"m\" ? \"l\" : \"L\";\n } else {\n path.segments.push(\n [pathCommand as PathCommand | number].concat(\n data.splice(0, paramsCount[relativeCommand]) as number[],\n ) as PathSegment,\n );\n }\n\n if (!paramsCount[relativeCommand]) {\n break;\n }\n }\n};\nexport default finalizeSegment;\n","const error = \"SVGPathCommander Error\";\nexport default error;\n","import error from \"./error\";\nimport type PathParser from \"./pathParser\";\n\n/**\n * Validates an A (arc-to) specific path command value.\n * Usually a `large-arc-flag` or `sweep-flag`.\n *\n * @param path the `PathParser` instance\n */\nconst scanFlag = (path: PathParser) => {\n const { index, pathValue } = path;\n const code = pathValue.charCodeAt(index);\n\n if (code === 0x30 /* 0 */) {\n path.param = 0;\n path.index += 1;\n return;\n }\n\n if (code === 0x31 /* 1 */) {\n path.param = 1;\n path.index += 1;\n return;\n }\n\n path.err = `${error}: invalid Arc flag \"${\n pathValue[index]\n }\", expecting 0 or 1 at index ${index}`;\n};\n\nexport default scanFlag;\n","import { DigitNumber } from \"../types\";\n\n/**\n * Checks if a character is a digit.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isDigit = (code: number): code is DigitNumber => {\n return code >= 48 && code <= 57; // 0..9\n};\nexport default isDigit;\n","const invalidPathValue = \"Invalid path value\";\nexport default invalidPathValue;\n","import isDigit from \"./isDigit\";\nimport invalidPathValue from \"./invalidPathValue\";\nimport error from \"./error\";\nimport type PathParser from \"./pathParser\";\n\n/**\n * Validates every character of the path string,\n * every path command, negative numbers or floating point numbers.\n *\n * @param path the `PathParser` instance\n */\nconst scanParam = (path: PathParser) => {\n const { max, pathValue, index: start } = path;\n let index = start;\n let zeroFirst = false;\n let hasCeiling = false;\n let hasDecimal = false;\n let hasDot = false;\n let ch;\n\n if (index >= max) {\n path.err =\n `${error}: ${invalidPathValue} at index ${index}, \"pathValue\" is missing param`;\n return;\n }\n ch = pathValue.charCodeAt(index);\n\n if (ch === 0x2b /* + */ || ch === 0x2d /* - */) {\n index += 1;\n // ch = (index < max) ? pathValue.charCodeAt(index) : 0;\n ch = pathValue.charCodeAt(index);\n }\n\n // This logic is shamelessly borrowed from Esprima\n // https://github.com/ariya/esprimas\n if (!isDigit(ch) && ch !== 0x2e /* . */) {\n // path.err = 'SvgPath: param should start with 0..9 or `.` (at pos ' + index + ')';\n path.err = `${error}: ${invalidPathValue} at index ${index}, \"${\n pathValue[index]\n }\" is not a number`;\n return;\n }\n\n if (ch !== 0x2e /* . */) {\n zeroFirst = ch === 0x30 /* 0 */;\n index += 1;\n\n ch = pathValue.charCodeAt(index);\n\n if (zeroFirst && index < max) {\n // decimal number starts with '0' such as '09' is illegal.\n if (ch && isDigit(ch)) {\n // path.err = 'SvgPath: numbers started with `0` such as `09`\n // are illegal (at pos ' + start + ')';\n path.err = `${error}: ${invalidPathValue} at index ${start}, \"${\n pathValue[start]\n }\" illegal number`;\n return;\n }\n }\n\n while (index < max && isDigit(pathValue.charCodeAt(index))) {\n index += 1;\n hasCeiling = true;\n }\n\n ch = pathValue.charCodeAt(index);\n }\n\n if (ch === 0x2e /* . */) {\n hasDot = true;\n index += 1;\n while (isDigit(pathValue.charCodeAt(index))) {\n index += 1;\n hasDecimal = true;\n }\n\n ch = pathValue.charCodeAt(index);\n }\n\n if (ch === 0x65 /* e */ || ch === 0x45 /* E */) {\n if (hasDot && !hasCeiling && !hasDecimal) {\n path.err = `${error}: ${invalidPathValue} at index ${index}, \"${\n pathValue[index]\n }\" invalid float exponent`;\n return;\n }\n\n index += 1;\n\n ch = pathValue.charCodeAt(index);\n\n if (ch === 0x2b /* + */ || ch === 0x2d /* - */) {\n index += 1;\n }\n if (index < max && isDigit(pathValue.charCodeAt(index))) {\n while (index < max && isDigit(pathValue.charCodeAt(index))) {\n index += 1;\n }\n } else {\n path.err = `${error}: ${invalidPathValue} at index ${index}, \"${\n pathValue[index]\n }\" invalid integer exponent`;\n return;\n }\n }\n\n path.index = index;\n path.param = +path.pathValue.slice(start, index);\n};\nexport default scanParam;\n","import type { SpaceNumber } from \"../types\";\n\n/**\n * Checks if the character is a space.\n *\n * @param ch the character to check\n * @returns check result\n */\n\nconst isSpace = (ch: number): ch is SpaceNumber => {\n const allSpaces = [\n // Special spaces\n 0x1680,\n 0x180e,\n 0x2000,\n 0x2001,\n 0x2002,\n 0x2003,\n 0x2004,\n 0x2005,\n 0x2006,\n 0x2007,\n 0x2008,\n 0x2009,\n 0x200a,\n 0x202f,\n 0x205f,\n 0x3000,\n 0xfeff,\n // Line terminators\n 0x0a,\n 0x0d,\n 0x2028,\n 0x2029,\n // White spaces\n 0x20,\n 0x09,\n 0x0b,\n 0x0c,\n 0xa0,\n ];\n\n return allSpaces.includes(ch);\n};\nexport default isSpace;\n","import isSpace from \"./isSpace\";\nimport type PathParser from \"./pathParser\";\n\n/**\n * Points the parser to the next character in the\n * path string every time it encounters any kind of\n * space character.\n *\n * @param path the `PathParser` instance\n */\nconst skipSpaces = (path: PathParser) => {\n const { pathValue, max } = path;\n while (path.index < max && isSpace(pathValue.charCodeAt(path.index))) {\n path.index += 1;\n }\n};\nexport default skipSpaces;\n","import type { PathCommandNumber } from \"../types\";\n\n/**\n * Checks if the character is a path command.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isPathCommand = (code: number): code is PathCommandNumber => {\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy\n switch (code | 0x20) {\n case 0x6d /* m */:\n case 0x7a /* z */:\n case 0x6c /* l */:\n case 0x68 /* h */:\n case 0x76 /* v */:\n case 0x63 /* c */:\n case 0x73 /* s */:\n case 0x71 /* q */:\n case 0x74 /* t */:\n case 0x61 /* a */:\n // case 0x72/* r */:\n return true;\n default:\n return false;\n }\n};\nexport default isPathCommand;\n","import isDigit from \"./isDigit\";\nimport type { DigitNumber } from \"../types\";\n\n/**\n * Checks if the character is or belongs to a number.\n * [0-9]|+|-|.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isDigitStart = (\n code: number,\n): code is DigitNumber | 0x2b | 0x2d | 0x2e => {\n return isDigit(code) /* 0..9 */ || code === 0x2b /* + */ ||\n code === 0x2d /* - */ || code === 0x2e; /* . */\n};\nexport default isDigitStart;\n","/**\n * Checks if the character is an A (arc-to) path command.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isArcCommand = (code: number): code is 0x61 => {\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy\n return (code | 0x20) === 0x61;\n};\nexport default isArcCommand;\n","/**\n * Checks if the character is a MoveTo command.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isMoveCommand = (code: number): code is 0x6d | 0x4d => {\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy\n switch (code | 0x20) {\n case 0x6d /* m */:\n case 0x4d /* M */:\n return true;\n default:\n return false;\n }\n};\nexport default isMoveCommand;\n","import finalizeSegment from \"./finalizeSegment\";\nimport paramCounts from \"./paramsCount\";\nimport scanFlag from \"./scanFlag\";\nimport scanParam from \"./scanParam\";\nimport skipSpaces from \"./skipSpaces\";\nimport isPathCommand from \"./isPathCommand\";\nimport isDigitStart from \"./isDigitStart\";\nimport isArcCommand from \"./isArcCommand\";\nimport isMoveCommand from \"./isMoveCommand\";\nimport invalidPathValue from \"./invalidPathValue\";\nimport error from \"./error\";\n\nimport type PathParser from \"./pathParser\";\nimport type { PathSegment, RelativeCommand } from \"../types\";\n\n/**\n * Scans every character in the path string to determine\n * where a segment starts and where it ends.\n *\n * @param path the `PathParser` instance\n */\nconst scanSegment = (path: PathParser) => {\n const { max, pathValue, index, segments } = path;\n const cmdCode = pathValue.charCodeAt(index);\n const reqParams =\n paramCounts[pathValue[index].toLowerCase() as RelativeCommand];\n\n path.segmentStart = index;\n\n // segments always start with a path command\n if (!isPathCommand(cmdCode)) {\n path.err = `${error}: ${invalidPathValue} \"${\n pathValue[index]\n }\" is not a path command at index ${index}`;\n return;\n }\n\n // after a Z segment, we only expect a MoveTo path command\n const lastSegment = segments[segments.length - 1] as PathSegment | undefined;\n if (\n !isMoveCommand(cmdCode) && lastSegment?.[0]?.toLocaleLowerCase() === \"z\"\n ) {\n path.err = `${error}: ${invalidPathValue} \"${\n pathValue[index]\n }\" is not a MoveTo path command at index ${index}`;\n return;\n }\n\n path.index += 1;\n skipSpaces(path);\n\n path.data = [];\n\n if (!reqParams) {\n // Z\n finalizeSegment(path);\n return;\n }\n\n for (;;) {\n for (let i = reqParams; i > 0; i -= 1) {\n if (isArcCommand(cmdCode) && (i === 3 || i === 4)) scanFlag(path);\n else scanParam(path);\n\n if (path.err.length) {\n return;\n }\n path.data.push(path.param);\n\n skipSpaces(path);\n\n // after ',' param is mandatory\n if (\n path.index < max && pathValue.charCodeAt(path.index) === 0x2c /* , */\n ) {\n path.index += 1;\n skipSpaces(path);\n }\n }\n\n if (path.index >= path.max) {\n break;\n }\n\n // Stop on next segment\n if (!isDigitStart(pathValue.charCodeAt(path.index))) {\n break;\n }\n }\n\n finalizeSegment(path);\n};\nexport default scanSegment;\n","import type { PathArray, PathSegment } from \"../types\";\n\n/**\n * The `PathParser` is used by the `parsePathString` static method\n * to generate a `pathArray`.\n *\n * @param pathString\n */\nexport default class PathParser {\n declare segments: PathArray | PathSegment[];\n declare pathValue: string;\n declare max: number;\n declare index: number;\n declare param: number;\n declare segmentStart: number;\n declare data: (string | number)[];\n declare err: string;\n\n constructor(pathString: string) {\n this.segments = [];\n this.pathValue = pathString;\n this.max = pathString.length;\n this.index = 0;\n this.param = 0.0;\n this.segmentStart = 0;\n this.data = [];\n this.err = \"\";\n }\n}\n","import scanSegment from \"./scanSegment\";\nimport skipSpaces from \"./skipSpaces\";\nimport PathParser from \"./pathParser\";\nimport type { PathArray } from \"../types\";\n\n/**\n * Parses a path string value and returns an array\n * of segments we like to call `pathArray`.\n *\n * @param pathInput the string to be parsed\n * @returns the resulted `pathArray` or error string\n */\nconst parsePathString = (pathInput: string | T) => {\n if (typeof pathInput !== \"string\") {\n return pathInput.slice(0) as typeof pathInput;\n }\n\n const path = new PathParser(pathInput);\n\n skipSpaces(path);\n\n while (path.index < path.max && !path.err.length) {\n scanSegment(path);\n }\n\n // handle valid paths first\n // handle errors second\n if (!path.err.length) {\n if (path.segments.length) {\n /**\n * force absolute first M\n * getPathBBox calculation requires first segment to be absolute\n * @see https://github.com/thednp/svg-path-commander/pull/49\n */\n path.segments[0][0] = \"M\";\n }\n } else {\n throw TypeError(path.err);\n }\n\n return path.segments as PathArray;\n};\n\nexport default parsePathString;\n","import type {\n AbsoluteCommand,\n AbsoluteSegment,\n ASegment,\n CSegment,\n HSegment,\n LSegment,\n MSegment,\n PathSegment,\n QSegment,\n SSegment,\n TSegment,\n VSegment,\n} from \"../types\";\n\n/**\n * Returns an absolute segment of a `PathArray` object.\n *\n * @param segment the segment object\n * @param index the segment index\n * @param lastX the last known X value\n * @param lastY the last known Y value\n * @returns the absolute segment\n */\nconst absolutizeSegment = (\n segment: PathSegment,\n index: number,\n lastX: number,\n lastY: number,\n) => {\n const [pathCommand] = segment;\n const absCommand = pathCommand.toUpperCase() as AbsoluteCommand;\n const isAbsolute = absCommand === pathCommand;\n\n /* istanbul ignore else @preserve */\n if (index === 0 || isAbsolute) return segment as MSegment | AbsoluteSegment;\n // const values = segment.slice(1) as number[];\n if (absCommand === \"A\") {\n return [\n absCommand,\n segment[1],\n segment[2],\n segment[3],\n segment[4],\n segment[5],\n (segment as ASegment)[6] + lastX,\n (segment as ASegment)[7] + lastY,\n ] as ASegment;\n } else if (absCommand === \"V\") {\n return [absCommand, (segment as VSegment)[1] + lastY] as VSegment;\n } else if (absCommand === \"H\") {\n return [absCommand, (segment as HSegment)[1] + lastX] as HSegment;\n } else if (absCommand === \"L\") {\n return [\n absCommand,\n (segment as LSegment)[1] + lastX,\n (segment as LSegment)[2] + lastY,\n ] as LSegment;\n } else {\n // use brakets for `eslint: no-case-declaration`\n // https://stackoverflow.com/a/50753272/803358\n const absValues = [] as number[];\n const seglen = segment.length;\n for (let j = 1; j < seglen; j += 1) {\n absValues.push((segment[j] as number) + (j % 2 ? lastX : lastY));\n }\n // for c, s, q, t\n return [absCommand as typeof absCommand | number].concat(absValues) as\n | MSegment\n | QSegment\n | TSegment\n | SSegment\n | CSegment;\n }\n};\nexport default absolutizeSegment;\n","// import paramsParser from '../parser/paramsParser';\nimport type {\n AbsoluteCommand,\n IteratorCallback,\n PathArray,\n PathCommand,\n PathSegment,\n} from \"../types\";\n\nconst iterate = (\n path: PathArray,\n iterator: IteratorCallback,\n) => {\n let pathLen = path.length;\n let segment: PathSegment;\n let pathCommand = \"M\" as PathCommand;\n let absCommand = \"M\" as AbsoluteCommand;\n let isRelative = false;\n let x = 0;\n let y = 0;\n let mx = 0;\n let my = 0;\n let segLen = 0;\n\n for (let i = 0; i < pathLen; i += 1) {\n segment = path[i];\n [pathCommand] = segment;\n segLen = segment.length;\n absCommand = pathCommand.toUpperCase() as AbsoluteCommand;\n isRelative = absCommand !== pathCommand;\n\n const iteratorResult = iterator(segment, i, x, y);\n // some methods like getPointAtLength would like to break\n // when task is complete\n if (iteratorResult === false) {\n break;\n }\n\n // segment = path[i];\n if (absCommand === \"Z\") {\n x = mx;\n y = my;\n } else if (absCommand === \"H\") {\n x = (segment[1] as number) + (isRelative ? x : 0);\n } else if (absCommand === \"V\") {\n y = (segment[1] as number) + (isRelative ? y : 0);\n } else {\n x = (segment[segLen - 2] as number) + (isRelative ? x : 0);\n y = (segment[segLen - 1] as number) + (isRelative ? y : 0);\n\n if (absCommand === \"M\") {\n mx = x;\n my = y;\n }\n }\n\n if (iteratorResult) {\n path[i] = iteratorResult;\n if (iteratorResult[0] === \"C\") {\n pathLen = path.length;\n }\n }\n }\n return path as T;\n};\n\nexport default iterate;\n","import parsePathString from \"../parser/parsePathString\";\nimport absolutizeSegment from \"../process/absolutizeSegment\";\nimport type { AbsoluteArray, PathArray } from \"../types\";\nimport iterate from \"../process/iterate\";\n\n/**\n * Parses a path string value or object and returns an array\n * of segments, all converted to absolute values.\n *\n * @param pathInput the path string | object\n * @returns the resulted `pathArray` with absolute values\n */\nconst pathToAbsolute = (pathInput: string | PathArray) => {\n const path = parsePathString(pathInput);\n\n return iterate(path, absolutizeSegment);\n};\nexport default pathToAbsolute;\n","import type {\n aSegment,\n cSegment,\n hSegment,\n lSegment,\n MSegment,\n PathSegment,\n qSegment,\n RelativeCommand,\n RelativeSegment,\n sSegment,\n tSegment,\n vSegment,\n} from \"../types\";\n\n/**\n * Returns a relative segment of a `PathArray` object.\n *\n * @param segment the segment object\n * @param index the segment index\n * @param lastX the last known X value\n * @param lastY the last known Y value\n * @returns the relative segment\n */\nconst relativizeSegment = (\n segment: PathSegment,\n index: number,\n lastX: number,\n lastY: number,\n) => {\n const [pathCommand] = segment;\n const relCommand = pathCommand.toLowerCase() as RelativeCommand;\n const isRelative = pathCommand === relCommand;\n\n /* istanbul ignore else @preserve */\n if (index === 0 || isRelative) return segment as MSegment | RelativeSegment;\n\n if (relCommand === \"a\") {\n return [\n relCommand,\n segment[1],\n segment[2],\n segment[3],\n segment[4],\n segment[5],\n (segment as aSegment)[6] - lastX,\n (segment as aSegment)[7] - lastY,\n ] as aSegment;\n } else if (relCommand === \"v\") {\n return [relCommand, (segment as vSegment)[1] - lastY] as vSegment;\n } else if (relCommand === \"h\") {\n return [relCommand, (segment as hSegment)[1] - lastX] as hSegment;\n } else if (relCommand === \"l\") {\n return [\n relCommand,\n (segment as lSegment)[1] - lastX,\n (segment as lSegment)[2] - lastY,\n ] as lSegment;\n } else {\n // use brakets for `eslint: no-case-declaration`\n // https://stackoverflow.com/a/50753272/803358\n const relValues = [] as number[];\n const seglen = segment.length;\n for (let j = 1; j < seglen; j += 1) {\n relValues.push((segment[j] as number) - (j % 2 ? lastX : lastY));\n }\n // for c, s, q, t\n return [relCommand as RelativeCommand | number].concat(relValues) as\n | qSegment\n | tSegment\n | sSegment\n | cSegment;\n }\n};\n\nexport default relativizeSegment;\n","import type { PathArray, RelativeArray } from \"../types\";\nimport parsePathString from \"../parser/parsePathString\";\nimport iterate from \"../process/iterate\";\nimport relativizeSegment from \"../process/relativizeSegment\";\n\n/**\n * Parses a path string value or object and returns an array\n * of segments, all converted to relative values.\n *\n * @param pathInput the path string | object\n * @returns the resulted `pathArray` with relative values\n */\nconst pathToRelative = (pathInput: string | PathArray): RelativeArray => {\n const path = parsePathString(pathInput);\n\n return iterate(path, relativizeSegment);\n};\nexport default pathToRelative;\n","/**\n * Returns an {x,y} vector rotated by a given\n * angle in radian.\n *\n * @param x the initial vector x\n * @param y the initial vector y\n * @param rad the radian vector angle\n * @returns the rotated vector\n */\nconst rotateVector = (\n x: number,\n y: number,\n rad: number,\n): { x: number; y: number } => {\n const { sin, cos } = Math;\n const X = x * cos(rad) - y * sin(rad);\n const Y = x * sin(rad) + y * cos(rad);\n return { x: X, y: Y };\n};\n\nexport default rotateVector;\n","import rotateVector from \"../math/rotateVector\";\n\n/**\n * Converts A (arc-to) segments to C (cubic-bezier-to).\n *\n * For more information of where this math came from visit:\n * http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes\n *\n * @param X1 the starting x position\n * @param Y1 the starting y position\n * @param RX x-radius of the arc\n * @param RY y-radius of the arc\n * @param angle x-axis-rotation of the arc\n * @param LAF large-arc-flag of the arc\n * @param SF sweep-flag of the arc\n * @param X2 the ending x position\n * @param Y2 the ending y position\n * @param recursive the parameters needed to split arc into 2 segments\n * @return the resulting cubic-bezier segment(s)\n */\nconst arcToCubic = (\n X1: number,\n Y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n X2: number,\n Y2: number,\n recursive?: [number, number, number, number],\n): number[] => {\n let x1 = X1;\n let y1 = Y1;\n let rx = RX;\n let ry = RY;\n let x2 = X2;\n let y2 = Y2;\n // for more information of where this Math came from visit:\n // http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes\n const d120 = (Math.PI * 120) / 180;\n\n const rad = (Math.PI / 180) * (+angle || 0);\n let res = [] as number[];\n let xy;\n let f1;\n let f2;\n let cx;\n let cy;\n\n if (!recursive) {\n xy = rotateVector(x1, y1, -rad);\n x1 = xy.x;\n y1 = xy.y;\n xy = rotateVector(x2, y2, -rad);\n x2 = xy.x;\n y2 = xy.y;\n\n const x = (x1 - x2) / 2;\n const y = (y1 - y2) / 2;\n let h = (x * x) / (rx * rx) + (y * y) / (ry * ry);\n if (h > 1) {\n h = Math.sqrt(h);\n rx *= h;\n ry *= h;\n }\n const rx2 = rx * rx;\n const ry2 = ry * ry;\n\n const k = (LAF === SF ? -1 : 1) *\n Math.sqrt(\n Math.abs(\n (rx2 * ry2 - rx2 * y * y - ry2 * x * x) / (rx2 * y * y + ry2 * x * x),\n ),\n );\n\n cx = (k * rx * y) / ry + (x1 + x2) / 2;\n cy = (k * -ry * x) / rx + (y1 + y2) / 2;\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy no-bitwise\n f1 = Math.asin(((((y1 - cy) / ry) * 10 ** 9) >> 0) / 10 ** 9);\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy no-bitwise\n f2 = Math.asin(((((y2 - cy) / ry) * 10 ** 9) >> 0) / 10 ** 9);\n\n f1 = x1 < cx ? Math.PI - f1 : f1;\n f2 = x2 < cx ? Math.PI - f2 : f2;\n if (f1 < 0) f1 = Math.PI * 2 + f1;\n if (f2 < 0) f2 = Math.PI * 2 + f2;\n if (SF && f1 > f2) {\n f1 -= Math.PI * 2;\n }\n if (!SF && f2 > f1) {\n f2 -= Math.PI * 2;\n }\n } else {\n [f1, f2, cx, cy] = recursive;\n }\n let df = f2 - f1;\n if (Math.abs(df) > d120) {\n const f2old = f2;\n const x2old = x2;\n const y2old = y2;\n f2 = f1 + d120 * (SF && f2 > f1 ? 1 : -1);\n x2 = cx + rx * Math.cos(f2);\n y2 = cy + ry * Math.sin(f2);\n res = arcToCubic(x2, y2, rx, ry, angle, 0, SF, x2old, y2old, [\n f2,\n f2old,\n cx,\n cy,\n ]);\n }\n df = f2 - f1;\n const c1 = Math.cos(f1);\n const s1 = Math.sin(f1);\n const c2 = Math.cos(f2);\n const s2 = Math.sin(f2);\n const t = Math.tan(df / 4);\n const hx = (4 / 3) * rx * t;\n const hy = (4 / 3) * ry * t;\n const m1 = [x1, y1];\n const m2 = [x1 + hx * s1, y1 - hy * c1];\n const m3 = [x2 + hx * s2, y2 - hy * c2];\n const m4 = [x2, y2];\n m2[0] = 2 * m1[0] - m2[0];\n m2[1] = 2 * m1[1] - m2[1];\n if (recursive) {\n return [m2[0], m2[1], m3[0], m3[1], m4[0], m4[1]].concat(res);\n }\n res = [m2[0], m2[1], m3[0], m3[1], m4[0], m4[1]].concat(res);\n const newres = [];\n for (let i = 0, ii = res.length; i < ii; i += 1) {\n newres[i] = i % 2\n ? rotateVector(res[i - 1], res[i], rad).y\n : rotateVector(res[i], res[i + 1], rad).x;\n }\n return newres;\n};\nexport default arcToCubic;\n","/**\n * Converts a Q (quadratic-bezier) segment to C (cubic-bezier).\n *\n * @param x1 curve start x\n * @param y1 curve start y\n * @param qx control point x\n * @param qy control point y\n * @param x2 curve end x\n * @param y2 curve end y\n * @returns the cubic-bezier segment\n */\nconst quadToCubic = (\n x1: number,\n y1: number,\n qx: number,\n qy: number,\n x2: number,\n y2: number,\n): [number, number, number, number, number, number] => {\n const r13 = 1 / 3;\n const r23 = 2 / 3;\n return [\n r13 * x1 + r23 * qx, // cpx1\n r13 * y1 + r23 * qy, // cpy1\n r13 * x2 + r23 * qx, // cpx2\n r13 * y2 + r23 * qy, // cpy2\n x2,\n y2, // x,y\n ];\n};\nexport default quadToCubic;\n","import midPoint from \"../math/midPoint\";\n\n/**\n * Converts an L (line-to) segment to C (cubic-bezier).\n *\n * @param x1 line start x\n * @param y1 line start y\n * @param x2 line end x\n * @param y2 line end y\n * @returns the cubic-bezier segment\n */\nconst lineToCubic = (x1: number, y1: number, x2: number, y2: number) => {\n const c1 = midPoint([x1, y1], [x2, y2], 1.0 / 3.0);\n const c2 = midPoint([x1, y1], [x2, y2], 2.0 / 3.0);\n return [c1[0], c1[1], c2[0], c2[1], x2, y2];\n};\nexport default lineToCubic;\n","import arcToCubic from \"./arcToCubic\";\nimport quadToCubic from \"./quadToCubic\";\nimport lineToCubic from \"./lineToCubic\";\nimport type { CSegment, MSegment, PathSegment } from \"../types\";\nimport type { ParserParams } from \"../interface\";\n\n/**\n * Converts any segment to C (cubic-bezier).\n *\n * @param segment the source segment\n * @param params the source segment parameters\n * @returns the cubic-bezier segment\n */\nconst segmentToCubic = (segment: PathSegment, params: ParserParams) => {\n const [pathCommand] = segment;\n const values = segment.slice(1).map(Number);\n const [x, y] = values;\n // let args;\n const { x1: px1, y1: py1, x: px, y: py } = params;\n\n if (!\"TQ\".includes(pathCommand)) {\n params.qx = null;\n params.qy = null;\n }\n\n if (pathCommand === \"M\") {\n params.x = x;\n params.y = y;\n return segment;\n } else if (pathCommand === \"A\") {\n return [\"C\" as string | number].concat(\n arcToCubic(\n px1,\n py1,\n values[0],\n values[1],\n values[2],\n values[3],\n values[4],\n values[5],\n values[6],\n ),\n ) as CSegment;\n } else if (pathCommand === \"Q\") {\n params.qx = x;\n params.qy = y;\n return [\"C\" as string | number].concat(\n quadToCubic(px1, py1, values[0], values[1], values[2], values[3]),\n ) as CSegment;\n } else if (pathCommand === \"L\") {\n return [\"C\" as string | number].concat(\n lineToCubic(px1, py1, x, y),\n ) as CSegment;\n } else if (pathCommand === \"Z\") {\n return [\"C\" as string | number].concat(\n lineToCubic(px1, py1, px, py),\n ) as CSegment;\n }\n\n return segment as MSegment | CSegment;\n};\nexport default segmentToCubic;\n","import type { ParserParams } from \"../interface\";\nimport type {\n ASegment,\n CSegment,\n HSegment,\n LSegment,\n MSegment,\n NormalSegment,\n PathCommand,\n PathSegment,\n PointTuple,\n QSegment,\n VSegment,\n} from \"../types\";\n\n/**\n * Normalizes a single segment of a `pathArray` object.\n *\n * @param segment the segment object\n * @param params the normalization parameters\n * @returns the normalized segment\n */\nconst normalizeSegment = (segment: PathSegment, params: ParserParams) => {\n const [pathCommand] = segment;\n const absCommand = pathCommand.toUpperCase();\n const isRelative = pathCommand !== absCommand;\n const { x1: px1, y1: py1, x2: px2, y2: py2, x, y } = params;\n const values = segment.slice(1) as number[];\n let absValues = values.map((n, j) => n + (isRelative ? (j % 2 ? y : x) : 0));\n\n if (!\"TQ\".includes(absCommand)) {\n // optional but good to be cautious\n params.qx = null;\n params.qy = null;\n }\n\n // istanbul ignore else @preserve\n if (absCommand === \"A\") {\n absValues = values.slice(0, -2).concat(\n values[5] + (isRelative ? x : 0),\n values[6] + (isRelative ? y : 0),\n );\n\n return [\"A\" as PathCommand | number].concat(absValues) as ASegment;\n } else if (absCommand === \"H\") {\n return [\n \"L\",\n (segment as HSegment)[1] + (isRelative ? x : 0),\n py1,\n ] as LSegment;\n } else if (absCommand === \"V\") {\n return [\n \"L\",\n px1,\n (segment as VSegment)[1] + (isRelative ? y : 0),\n ] as LSegment;\n } else if (absCommand === \"L\") {\n return [\n \"L\",\n (segment as LSegment)[1] + (isRelative ? x : 0),\n (segment as LSegment)[2] + (isRelative ? y : 0),\n ] as LSegment;\n } else if (absCommand === \"M\") {\n return [\n \"M\",\n (segment as MSegment)[1] + (isRelative ? x : 0),\n (segment as MSegment)[2] + (isRelative ? y : 0),\n ] as MSegment;\n } else if (absCommand === \"C\") {\n return [\"C\" as PathCommand | number].concat(absValues) as CSegment;\n } else if (absCommand === \"S\") {\n const x1 = px1 * 2 - px2;\n const y1 = py1 * 2 - py2;\n params.x1 = x1;\n params.y1 = y1;\n return [\"C\", x1, y1].concat(absValues) as CSegment;\n } else if (absCommand === \"T\") {\n const qx = px1 * 2 - (params.qx ? params.qx : /* istanbul ignore next */ 0);\n const qy = py1 * 2 - (params.qy ? params.qy : /* istanbul ignore next */ 0);\n params.qx = qx;\n params.qy = qy;\n return [\"Q\", qx, qy].concat(absValues) as QSegment;\n } else if (absCommand === \"Q\") {\n const [nqx, nqy] = absValues as PointTuple;\n params.qx = nqx;\n params.qy = nqy;\n return [\"Q\" as PathCommand | number].concat(absValues) as QSegment;\n } else if (absCommand === \"Z\") {\n return [\"Z\"] as NormalSegment;\n }\n\n // istanbul ignore next @preserve\n return segment as NormalSegment;\n};\nexport default normalizeSegment;\n","import type { ParserParams } from \"../interface\";\n\nconst paramsParser: ParserParams = {\n x1: 0,\n y1: 0,\n x2: 0,\n y2: 0,\n x: 0,\n y: 0,\n qx: null,\n qy: null,\n};\n\nexport default paramsParser;\n","import segmentToCubic from \"../process/segmentToCubic\";\nimport { AbsoluteCommand, CSegment, CurveArray, PathArray } from \"../types\";\nimport iterate from \"../process/iterate\";\nimport parsePathString from \"../parser/parsePathString\";\nimport normalizeSegment from \"../process/normalizeSegment\";\nimport paramsParser from \"../parser/paramsParser\";\n\n/**\n * Parses a path string value or 'pathArray' and returns a new one\n * in which all segments are converted to cubic-bezier.\n *\n * In addition, un-necessary `Z` segment is removed if previous segment\n * extends to the `M` segment.\n *\n * @param pathInput the string to be parsed or 'pathArray'\n * @returns the resulted `pathArray` converted to cubic-bezier\n */\nconst pathToCurve = (pathInput: string | PathArray): CurveArray => {\n const params = { ...paramsParser };\n const path = parsePathString(pathInput);\n\n return iterate(path, (seg, index, lastX, lastY) => {\n params.x = lastX;\n params.y = lastY;\n const normalSegment = normalizeSegment(seg, params);\n let result = segmentToCubic(normalSegment, params);\n const isLongArc = result[0] === \"C\" && result.length > 7;\n\n if (isLongArc) {\n path.splice(\n index + 1,\n 0,\n [\"C\" as AbsoluteCommand | number].concat(result.slice(7)) as CSegment,\n );\n result = result.slice(0, 7) as CSegment;\n }\n\n const seglen = result.length;\n params.x1 = +result[seglen - 2];\n params.y1 = +result[seglen - 1];\n params.x2 = +result[seglen - 4] || params.x1;\n params.y2 = +result[seglen - 3] || params.y1;\n\n return result;\n });\n};\nexport default pathToCurve;\n","import { Options } from \"../interface\";\n\n/** SVGPathCommander default options */\nconst defaultOptions: Options = {\n origin: [0, 0, 0],\n round: 4,\n};\n\nexport default defaultOptions;\n","const roundTo = (n: number, round: number) => {\n const pow = round >= 1 ? 10 ** round : 1;\n\n return round > 0 ? Math.round(n * pow) / pow : Math.round(n);\n};\n\nexport default roundTo;\n","import type { PathArray, PathSegment } from \"../types\";\nimport defaultOptions from \"../options/options\";\nimport roundTo from \"../math/roundTo\";\n\n/**\n * Returns a valid `d` attribute string value created\n * by rounding values and concatenating the `pathArray` segments.\n *\n * @param path the `pathArray` object\n * @param roundOption amount of decimals to round values to\n * @returns the concatenated path string\n */\nconst pathToString = (\n path: PathArray,\n roundOption?: number | \"off\",\n): string => {\n const pathLen = path.length;\n let { round } = defaultOptions;\n let segment = path[0] as PathSegment;\n let result = \"\";\n\n // allow for ZERO decimals\n round = roundOption === \"off\"\n ? roundOption\n : typeof roundOption === \"number\" && roundOption >= 0\n ? roundOption\n : typeof round === \"number\" && round >= 0\n ? round\n : /* istanbul ignore next @preserve */ \"off\";\n\n for (let i = 0; i < pathLen; i += 1) {\n segment = path[i];\n const [pathCommand] = segment;\n const values = segment.slice(1) as number[];\n result += pathCommand;\n if (round === \"off\") {\n result += values.join(\" \");\n } else {\n let j = 0;\n const valLen = values.length;\n while (j < valLen) {\n result += roundTo(values[j], round);\n if (j !== valLen - 1) result += \" \";\n j += 1;\n }\n }\n }\n\n return result;\n};\n\nexport default pathToString;\n","const DISTANCE_EPSILON = 0.00001;\n\nexport default DISTANCE_EPSILON;\n","import normalizeSegment from \"./normalizeSegment\";\nimport type { NormalArray, PathArray } from \"../types\";\nimport iterate from \"./iterate\";\nimport parsePathString from \"../parser/parsePathString\";\nimport paramsParser from \"../parser/paramsParser\";\n\n/**\n * Normalizes a `pathArray` object for further processing:\n * * convert segments to absolute values\n * * convert shorthand path commands to their non-shorthand notation\n *\n * @param pathInput the string to be parsed or 'pathArray'\n * @returns the normalized `pathArray`\n */\nconst normalizePath = (pathInput: string | PathArray) => {\n const path = parsePathString(pathInput);\n const params = { ...paramsParser };\n\n return iterate(path, (seg, _, lastX, lastY) => {\n params.x = lastX;\n params.y = lastY;\n const result = normalizeSegment(seg, params);\n\n const seglen = result.length;\n params.x1 = +result[seglen - 2];\n params.y1 = +result[seglen - 1];\n params.x2 = +result[seglen - 4] || params.x1;\n params.y2 = +result[seglen - 3] || params.y1;\n\n return result;\n });\n};\nexport default normalizePath;\n","import DISTANCE_EPSILON from \"./distanceEpsilon\";\nimport type { MSegment, PathArray, PointTuple } from \"../types\";\nimport iterate from \"../process/iterate\";\nimport { getLineLength, getPointAtLineLength } from \"../math/lineTools\";\nimport { getArcLength, getPointAtArcLength } from \"../math/arcTools\";\nimport { getCubicLength, getPointAtCubicLength } from \"../math/cubicTools\";\nimport { getPointAtQuadLength, getQuadLength } from \"../math/quadTools\";\nimport normalizePath from \"../process/normalizePath\";\n\n/**\n * Returns [x,y] coordinates of a point at a given length of a shape.\n *\n * @param pathInput the `pathArray` to look into\n * @param distance the length of the shape to look at\n * @returns the requested {x, y} point coordinates\n */\nconst getPointAtLength = (pathInput: string | PathArray, distance?: number) => {\n const path = normalizePath(pathInput);\n let isM = false;\n let data = [] as number[];\n let pathCommand = \"M\";\n let x = 0;\n let y = 0;\n let [mx, my] = path[0].slice(1) as PointTuple;\n const distanceIsNumber = typeof distance === \"number\";\n let point = { x: mx, y: my };\n let length = 0;\n let POINT = point;\n let totalLength = 0;\n\n if (!distanceIsNumber || distance < DISTANCE_EPSILON) return point;\n\n // for (let i = 0; i < pathLen; i += 1) {\n iterate(path, (seg, _, lastX, lastY) => {\n [pathCommand] = seg;\n isM = pathCommand === \"M\";\n data = !isM ? [lastX, lastY].concat(seg.slice(1) as number[]) : data;\n\n // this segment is always ZERO\n /* istanbul ignore else @preserve */\n if (isM) {\n // remember mx, my for Z\n [, mx, my] = seg as MSegment;\n point = { x: mx, y: my };\n length = 0;\n } else if (pathCommand === \"L\") {\n point = getPointAtLineLength(\n data[0],\n data[1],\n data[2],\n data[3],\n distance - totalLength,\n );\n length = getLineLength(data[0], data[1], data[2], data[3]);\n } else if (pathCommand === \"A\") {\n point = getPointAtArcLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n data[6],\n data[7],\n data[8],\n distance - totalLength,\n );\n length = getArcLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n data[6],\n data[7],\n data[8],\n );\n } else if (pathCommand === \"C\") {\n point = getPointAtCubicLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n data[6],\n data[7],\n distance - totalLength,\n );\n length = getCubicLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n data[6],\n data[7],\n );\n } else if (pathCommand === \"Q\") {\n point = getPointAtQuadLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n distance - totalLength,\n );\n length = getQuadLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n );\n } else if (pathCommand === \"Z\") {\n data = [lastX, lastY, mx, my];\n point = { x: mx, y: my };\n\n length = getLineLength(data[0], data[1], data[2], data[3]);\n }\n\n [x, y] = data.slice(-2);\n\n if (totalLength < distance) {\n POINT = point;\n } else {\n // totalLength >= distance\n // stop right here\n // stop iterator now!\n return false;\n }\n\n totalLength += length;\n return;\n });\n\n // native `getPointAtLength` behavior when the given distance\n // is higher than total length\n if (distance > totalLength - DISTANCE_EPSILON) {\n return { x, y };\n }\n\n return POINT;\n};\n\nexport default getPointAtLength;\n","import type { LSegment, MSegment, PathArray, PointTuple } from \"../types\";\nimport { getLineLength } from \"../math/lineTools\";\nimport { getArcLength } from \"../math/arcTools\";\nimport { getCubicLength } from \"../math/cubicTools\";\nimport { getQuadLength } from \"../math/quadTools\";\nimport iterate from \"../process/iterate\";\nimport parsePathString from \"../parser/parsePathString\";\nimport absolutizeSegment from \"../process/absolutizeSegment\";\n\n/**\n * Returns the shape total length, or the equivalent to `shape.getTotalLength()`.\n *\n * @param pathInput the target `pathArray`\n * @returns the shape total length\n */\nconst getTotalLength = (pathInput: string | PathArray) => {\n const path = parsePathString(pathInput);\n let paramX1 = 0;\n let paramY1 = 0;\n let paramX2 = 0;\n let paramY2 = 0;\n let paramQX = 0;\n let paramQY = 0;\n let pathCommand = \"M\";\n let mx = 0;\n let my = 0;\n let totalLength = 0;\n\n iterate(path, (seg, index, lastX, lastY) => {\n [pathCommand] = seg;\n const absCommand = pathCommand.toUpperCase();\n const isRelative = absCommand !== pathCommand;\n const absoluteSegment = isRelative\n ? absolutizeSegment(seg, index, lastX, lastY)\n : (seg.slice(0) as typeof seg);\n\n const normalSegment = absCommand === \"V\"\n ? ([\"L\", lastX, absoluteSegment[1]] as LSegment)\n : absCommand === \"H\"\n ? ([\"L\", absoluteSegment[1], lastY] as LSegment)\n : absoluteSegment;\n [pathCommand] = normalSegment;\n\n if (!\"TQ\".includes(absCommand)) {\n // optional but good to be cautious\n paramQX = 0;\n paramQY = 0;\n }\n\n // this segment is always ZERO\n /* istanbul ignore else @preserve */\n if (pathCommand === \"M\") {\n // remember mx, my for Z\n [, mx, my] = normalSegment as MSegment;\n } else if (pathCommand === \"L\") {\n totalLength += getLineLength(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n );\n } else if (pathCommand === \"A\") {\n totalLength += getArcLength(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n normalSegment[5] as number,\n normalSegment[6] as number,\n normalSegment[7] as number,\n );\n } else if (pathCommand === \"S\") {\n const cp1x = paramX1 * 2 - paramX2;\n const cp1y = paramY1 * 2 - paramY2;\n\n totalLength += getCubicLength(\n lastX,\n lastY,\n cp1x,\n cp1y,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n );\n } else if (pathCommand === \"C\") {\n totalLength += getCubicLength(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n normalSegment[5] as number,\n normalSegment[6] as number,\n );\n } else if (pathCommand === \"T\") {\n paramQX = paramX1 * 2 - paramQX;\n paramQY = paramY1 * 2 - paramQY;\n totalLength += getQuadLength(\n lastX,\n lastY,\n paramQX,\n paramQY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n );\n } else if (pathCommand === \"Q\") {\n paramQX = normalSegment[1] as number;\n paramQY = normalSegment[2] as number;\n totalLength += getQuadLength(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n );\n } else if (pathCommand === \"Z\") {\n totalLength += getLineLength(lastX, lastY, mx, my);\n }\n\n // update params\n [paramX1, paramY1] = pathCommand === \"Z\"\n ? [mx, my]\n : (normalSegment.slice(-2) as PointTuple);\n [paramX2, paramY2] = pathCommand === \"C\"\n ? ([normalSegment[3], normalSegment[4]] as PointTuple)\n : pathCommand === \"S\"\n ? ([normalSegment[1], normalSegment[2]] as PointTuple)\n : [paramX1, paramY1];\n });\n\n return totalLength;\n};\n\nexport default getTotalLength;\n","import type { PathArray, PathSegment } from \"../types\";\nimport type { SegmentProperties } from \"../interface\";\nimport parsePathString from \"../parser/parsePathString\";\nimport getTotalLength from \"./getTotalLength\";\n\n/**\n * Returns the segment, its index and length as well as\n * the length to that segment at a given length in a path.\n *\n * @param pathInput target `pathArray`\n * @param distance the given length\n * @returns the requested properties\n */\nconst getPropertiesAtLength = (\n pathInput: string | PathArray,\n distance?: number,\n): SegmentProperties => {\n const pathArray = parsePathString(pathInput);\n\n let pathTemp = pathArray.slice(0) as PathArray;\n let pathLength = getTotalLength(pathTemp);\n let index = pathTemp.length - 1;\n let lengthAtSegment = 0;\n let length = 0;\n let segment = pathArray[0] as PathSegment;\n\n // If the path is empty, return 0.\n if (index <= 0 || !distance || !Number.isFinite(distance)) {\n return {\n segment,\n index: 0,\n length,\n lengthAtSegment,\n };\n }\n\n if (distance >= pathLength) {\n pathTemp = pathArray.slice(0, -1) as PathArray;\n lengthAtSegment = getTotalLength(pathTemp);\n length = pathLength - lengthAtSegment;\n segment = pathArray[index];\n return {\n segment,\n index,\n length,\n lengthAtSegment,\n };\n }\n\n const segments = [] as SegmentProperties[];\n while (index > 0) {\n segment = pathTemp[index];\n pathTemp = pathTemp.slice(0, -1) as PathArray;\n lengthAtSegment = getTotalLength(pathTemp);\n length = pathLength - lengthAtSegment;\n pathLength = lengthAtSegment;\n\n segments.push({\n segment,\n index,\n length,\n lengthAtSegment,\n });\n index -= 1;\n }\n\n return segments.find(({ lengthAtSegment: l }) =>\n l <= distance\n ) as SegmentProperties;\n};\n\nexport default getPropertiesAtLength;\n","import type { PathArray, Point } from \"../types\";\nimport type { PointProperties } from \"../interface\";\nimport getPointAtLength from \"./getPointAtLength\";\nimport getPropertiesAtLength from \"./getPropertiesAtLength\";\nimport getTotalLength from \"./getTotalLength\";\nimport parsePathString from \"../parser/parsePathString\";\nimport normalizePath from \"../process/normalizePath\";\n\n/**\n * Returns the point and segment in path closest to a given point as well as\n * the distance to the path stroke.\n *\n * @see https://bl.ocks.org/mbostock/8027637\n *\n * @param pathInput target `pathArray`\n * @param point the given point\n * @returns the requested properties\n */\nconst getPropertiesAtPoint = (\n pathInput: string | PathArray,\n point: Point,\n): PointProperties => {\n const path = parsePathString(pathInput);\n const normalPath = normalizePath(path);\n const pathLength = getTotalLength(normalPath);\n const distanceTo = (p: Point) => {\n const dx = p.x - point.x;\n const dy = p.y - point.y;\n return dx * dx + dy * dy;\n };\n let precision = 8;\n let scan: Point;\n let closest = { x: 0, y: 0 }; // make TS happy\n let scanDistance = 0;\n let bestLength = 0;\n let bestDistance = Infinity;\n\n // linear scan for coarse approximation\n for (let scanLength = 0; scanLength <= pathLength; scanLength += precision) {\n scan = getPointAtLength(normalPath, scanLength);\n scanDistance = distanceTo(scan);\n\n if (scanDistance < bestDistance) {\n closest = scan;\n bestLength = scanLength;\n bestDistance = scanDistance;\n }\n }\n\n // binary search for precise estimate\n precision /= 2;\n let before: { x: number; y: number };\n let after: { x: number; y: number };\n let beforeLength = 0;\n let afterLength = 0;\n let beforeDistance = 0;\n let afterDistance = 0;\n\n while (precision > 0.000001) {\n beforeLength = bestLength - precision;\n before = getPointAtLength(normalPath, beforeLength);\n beforeDistance = distanceTo(before);\n afterLength = bestLength + precision;\n after = getPointAtLength(normalPath, afterLength);\n afterDistance = distanceTo(after);\n\n if (beforeLength >= 0 && beforeDistance < bestDistance) {\n closest = before;\n bestLength = beforeLength;\n bestDistance = beforeDistance;\n } else if (afterLength <= pathLength && afterDistance < bestDistance) {\n closest = after;\n bestLength = afterLength;\n bestDistance = afterDistance;\n } else {\n precision /= 2;\n }\n if (precision < 0.00001) break;\n }\n\n const segment = getPropertiesAtLength(path, bestLength);\n const distance = Math.sqrt(bestDistance);\n\n return { closest, distance, segment };\n};\n\nexport default getPropertiesAtPoint;\n","import type { PathArray } from \"../types\";\nimport getPropertiesAtPoint from \"./getPropertiesAtPoint\";\n\n/**\n * Returns the point in path closest to a given point.\n *\n * @param pathInput target `pathArray`\n * @param point the given point\n * @returns the best match\n */\nconst getClosestPoint = (\n pathInput: string | PathArray,\n point: { x: number; y: number },\n) => {\n return getPropertiesAtPoint(pathInput, point).closest;\n};\n\nexport default getClosestPoint;\n","import pathToCurve from \"../convert/pathToCurve\";\nimport type { PathArray, PointTuple } from \"../types\";\n\n/**\n * Returns the area of a single cubic-bezier segment.\n *\n * http://objectmix.com/graphics/133553-area-closed-bezier-curve.html\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the area of the cubic-bezier segment\n */\nconst getCubicSegArea = (\n x1: number,\n y1: number,\n c1x: number,\n c1y: number,\n c2x: number,\n c2y: number,\n x2: number,\n y2: number,\n) => {\n return (\n (3 *\n ((y2 - y1) * (c1x + c2x) -\n (x2 - x1) * (c1y + c2y) +\n c1y * (x1 - c2x) -\n c1x * (y1 - c2y) +\n y2 * (c2x + x1 / 3) -\n x2 * (c2y + y1 / 3))) /\n 20\n );\n};\n\n/**\n * Returns the area of a shape.\n *\n * @author Jürg Lehni & Jonathan Puckey\n *\n * @see https://github.com/paperjs/paper.js/blob/develop/src/path/Path.js\n *\n * @param path the shape `pathArray`\n * @returns the length of the cubic-bezier segment\n */\nconst getPathArea = (path: PathArray) => {\n let x = 0;\n let y = 0;\n let len = 0;\n\n return pathToCurve(path)\n .map((seg) => {\n switch (seg[0]) {\n case \"M\":\n [, x, y] = seg;\n return 0;\n default:\n len = getCubicSegArea(\n x,\n y,\n seg[1],\n seg[2],\n seg[3],\n seg[4],\n seg[5],\n seg[6],\n );\n [x, y] = seg.slice(-2) as PointTuple;\n return len;\n }\n })\n .reduce((a, b) => a + b, 0);\n};\nexport default getPathArea;\n","import getPathArea from \"./getPathArea\";\nimport pathToCurve from \"../convert/pathToCurve\";\nimport type { PathArray } from \"../types\";\n\n/**\n * Check if a path is drawn clockwise and returns true if so,\n * false otherwise.\n *\n * @param path the path string or `pathArray`\n * @returns true when clockwise or false if not\n */\nconst getDrawDirection = (path: string | PathArray) => {\n return getPathArea(pathToCurve(path)) >= 0;\n};\n\nexport default getDrawDirection;\n","import iterate from \"../process/iterate\";\nimport { PathBBox } from \"../interface\";\nimport { LSegment, MSegment, PathArray, PointTuple } from \"../types\";\nimport { getLineBBox } from \"../math/lineTools\";\nimport { getArcBBox } from \"../math/arcTools\";\nimport { getCubicBBox } from \"../math/cubicTools\";\nimport { getQuadBBox } from \"../math/quadTools\";\nimport parsePathString from \"../parser/parsePathString\";\nimport absolutizeSegment from \"../process/absolutizeSegment\";\n\nconst getPathBBox = (pathInput: PathArray | string) => {\n if (!pathInput) {\n return {\n x: 0,\n y: 0,\n width: 0,\n height: 0,\n x2: 0,\n y2: 0,\n cx: 0,\n cy: 0,\n cz: 0,\n };\n }\n\n const path = parsePathString(pathInput);\n let pathCommand = \"M\";\n let mx = 0;\n let my = 0;\n const { max, min } = Math;\n let xMin = Infinity;\n let yMin = Infinity;\n let xMax = -Infinity;\n let yMax = -Infinity;\n let minX = 0;\n let minY = 0;\n let maxX = 0;\n let maxY = 0;\n let paramX1 = 0;\n let paramY1 = 0;\n let paramX2 = 0;\n let paramY2 = 0;\n let paramQX = 0;\n let paramQY = 0;\n\n iterate(path, (seg, index, lastX, lastY) => {\n [pathCommand] = seg;\n const absCommand = pathCommand.toUpperCase();\n const isRelative = absCommand !== pathCommand;\n const absoluteSegment = isRelative\n ? absolutizeSegment(seg, index, lastX, lastY)\n : (seg.slice(0) as typeof seg);\n\n const normalSegment = absCommand === \"V\"\n ? ([\"L\", lastX, absoluteSegment[1]] as LSegment)\n : absCommand === \"H\"\n ? ([\"L\", absoluteSegment[1], lastY] as LSegment)\n : absoluteSegment;\n\n [pathCommand] = normalSegment;\n\n if (!\"TQ\".includes(absCommand)) {\n // optional but good to be cautious\n paramQX = 0;\n paramQY = 0;\n }\n\n // this segment is always ZERO\n /* istanbul ignore else @preserve */\n if (pathCommand === \"M\") {\n [, mx, my] = normalSegment as MSegment;\n minX = mx;\n minY = my;\n maxX = mx;\n maxY = my;\n } else if (pathCommand === \"L\") {\n [minX, minY, maxX, maxY] = getLineBBox(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n );\n } else if (pathCommand === \"A\") {\n [minX, minY, maxX, maxY] = getArcBBox(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n normalSegment[5] as number,\n normalSegment[6] as number,\n normalSegment[7] as number,\n );\n } else if (pathCommand === \"S\") {\n const cp1x = paramX1 * 2 - paramX2;\n const cp1y = paramY1 * 2 - paramY2;\n\n [minX, minY, maxX, maxY] = getCubicBBox(\n lastX,\n lastY,\n cp1x,\n cp1y,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n );\n } else if (pathCommand === \"C\") {\n [minX, minY, maxX, maxY] = getCubicBBox(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n normalSegment[5] as number,\n normalSegment[6] as number,\n );\n } else if (pathCommand === \"T\") {\n paramQX = paramX1 * 2 - paramQX;\n paramQY = paramY1 * 2 - paramQY;\n [minX, minY, maxX, maxY] = getQuadBBox(\n lastX,\n lastY,\n paramQX,\n paramQY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n );\n } else if (pathCommand === \"Q\") {\n paramQX = normalSegment[1] as number;\n paramQY = normalSegment[2] as number;\n [minX, minY, maxX, maxY] = getQuadBBox(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n );\n } else if (pathCommand === \"Z\") {\n [minX, minY, maxX, maxY] = getLineBBox(lastX, lastY, mx, my);\n }\n xMin = min(minX, xMin);\n yMin = min(minY, yMin);\n xMax = max(maxX, xMax);\n yMax = max(maxY, yMax);\n\n // update params\n [paramX1, paramY1] = pathCommand === \"Z\"\n ? [mx, my]\n : (normalSegment.slice(-2) as PointTuple);\n [paramX2, paramY2] = pathCommand === \"C\"\n ? ([normalSegment[3], normalSegment[4]] as PointTuple)\n : pathCommand === \"S\"\n ? ([normalSegment[1], normalSegment[2]] as PointTuple)\n : [paramX1, paramY1];\n });\n\n const width = xMax - xMin;\n const height = yMax - yMin;\n\n return {\n width,\n height,\n x: xMin,\n y: yMin,\n x2: xMax,\n y2: yMax,\n cx: xMin + width / 2,\n cy: yMin + height / 2,\n // an estimated guess\n cz: Math.max(width, height) + Math.min(width, height) / 2,\n } satisfies PathBBox;\n};\n\nexport default getPathBBox;\n","import type { PathArray, PathSegment } from \"../types\";\nimport getPropertiesAtLength from \"./getPropertiesAtLength\";\n\n/**\n * Returns the segment at a given length.\n *\n * @param pathInput the target `pathArray`\n * @param distance the distance in path to look at\n * @returns the requested segment\n */\nconst getSegmentAtLength = (\n pathInput: string | PathArray,\n distance?: number,\n): PathSegment | undefined => {\n return getPropertiesAtLength(pathInput, distance).segment;\n};\n\nexport default getSegmentAtLength;\n","import type { SegmentProperties } from \"../interface\";\nimport type { PathArray } from \"../types\";\nimport getPropertiesAtPoint from \"./getPropertiesAtPoint\";\n\n/**\n * Returns the path segment which contains a given point.\n *\n * @param path the `pathArray` to look into\n * @param point the point of the shape to look for\n * @returns the requested segment\n */\nconst getSegmentOfPoint = (\n path: string | PathArray,\n point: { x: number; y: number },\n): SegmentProperties | undefined => {\n return getPropertiesAtPoint(path, point).segment;\n};\nexport default getSegmentOfPoint;\n","import type { PathArray, PathSegment, RelativeCommand } from \"../types\";\nimport paramsCount from \"../parser/paramsCount\";\n\n/**\n * Iterates an array to check if it's an actual `pathArray`.\n *\n * @param path the `pathArray` to be checked\n * @returns iteration result\n */\nconst isPathArray = (path: unknown): path is PathArray => {\n return (\n Array.isArray(path) &&\n path.every((seg: PathSegment) => {\n const lk = seg[0].toLowerCase() as RelativeCommand;\n return (\n paramsCount[lk] === seg.length - 1 &&\n \"achlmqstvz\".includes(lk) &&\n (seg.slice(1) as unknown[]).every(Number.isFinite)\n );\n }) &&\n path.length > 0\n );\n};\nexport default isPathArray;\n","import type { AbsoluteArray } from \"../types\";\nimport isPathArray from \"./isPathArray\";\n\n/**\n * Iterates an array to check if it's a `pathArray`\n * with all absolute values.\n *\n * @param path the `pathArray` to be checked\n * @returns iteration result\n */\nconst isAbsoluteArray = (path: unknown): path is AbsoluteArray => {\n return (\n isPathArray(path) &&\n // `isPathArray` also checks if it's `Array`\n path.every(([x]) => x === x.toUpperCase())\n );\n};\nexport default isAbsoluteArray;\n","import type { NormalArray } from \"../types\";\nimport isAbsoluteArray from \"./isAbsoluteArray\";\n\n/**\n * Iterates an array to check if it's a `pathArray`\n * with all segments are in non-shorthand notation\n * with absolute values.\n *\n * @param {string | SVGPath.pathArray} path the `pathArray` to be checked\n * @returns {boolean} iteration result\n */\nconst isNormalizedArray = (path: unknown): path is NormalArray => {\n // `isAbsoluteArray` also checks if it's `Array`\n return isAbsoluteArray(path) && path.every(([pc]) => \"ACLMQZ\".includes(pc));\n};\nexport default isNormalizedArray;\n","import { CurveArray } from \"../types\";\nimport isNormalizedArray from \"./isNormalizedArray\";\n\n/**\n * Iterates an array to check if it's a `pathArray`\n * with all C (cubic bezier) segments.\n *\n * @param path the `Array` to be checked\n * @returns iteration result\n */\nconst isCurveArray = (path: unknown): path is CurveArray => {\n // `isPathArray` also checks if it's `Array`\n return isNormalizedArray(path) && path.every(([pc]) => \"MC\".includes(pc));\n};\nexport default isCurveArray;\n","import type { PathArray } from \"../types\";\nimport getPropertiesAtPoint from \"./getPropertiesAtPoint\";\nimport DISTANCE_EPSILON from \"./distanceEpsilon\";\n\n/**\n * Checks if a given point is in the stroke of a path.\n *\n * @param pathInput target path\n * @param point the given `{x,y}` point\n * @returns the query result\n */\nconst isPointInStroke = (\n pathInput: string | PathArray,\n point: { x: number; y: number },\n) => {\n const { distance } = getPropertiesAtPoint(pathInput, point);\n return Math.abs(distance) < DISTANCE_EPSILON; // 0.01 might be more permissive\n};\nexport default isPointInStroke;\n","import type { RelativeArray } from \"../types\";\nimport isPathArray from \"./isPathArray\";\n\n/**\n * Iterates an array to check if it's a `pathArray`\n * with relative values.\n *\n * @param path the `pathArray` to be checked\n * @returns iteration result\n */\nconst isRelativeArray = (path: unknown): path is RelativeArray => {\n return (\n isPathArray(path) &&\n // `isPathArray` checks if it's `Array`\n path.slice(1).every(([pc]) => pc === pc.toLowerCase())\n );\n};\nexport default isRelativeArray;\n","import scanSegment from \"../parser/scanSegment\";\nimport skipSpaces from \"../parser/skipSpaces\";\nimport PathParser from \"../parser/pathParser\";\n\n/**\n * Parses a path string value to determine its validity\n * then returns true if it's valid or false otherwise.\n *\n * @param pathString the path string to be parsed\n * @returns the path string validity\n */\nconst isValidPath = (pathString: string) => {\n if (typeof pathString !== \"string\" || !pathString.length) {\n return false;\n }\n\n const path = new PathParser(pathString);\n\n skipSpaces(path);\n\n while (path.index < path.max && !path.err.length) {\n scanSegment(path);\n }\n\n return !path.err.length && \"mM\".includes(path.segments[0][0]);\n};\nexport default isValidPath;\n","import type { ShapeParams } from \"../interface\";\n\n/**\n * Supported shapes and their specific parameters.\n */\nconst shapeParams: ShapeParams = {\n line: [\"x1\", \"y1\", \"x2\", \"y2\"],\n circle: [\"cx\", \"cy\", \"r\"],\n ellipse: [\"cx\", \"cy\", \"rx\", \"ry\"],\n rect: [\"width\", \"height\", \"x\", \"y\", \"rx\", \"ry\"],\n polygon: [\"points\"],\n polyline: [\"points\"],\n glyph: [\"d\"],\n};\n\nexport default shapeParams;\n","const isElement = (node?: unknown): node is Element =>\n node !== undefined && node !== null &&\n typeof node === \"object\" &&\n (node as Node).nodeType === 1; // ELEMENT_NODE\n\nexport default isElement;\n","import type {\n CircleAttr,\n EllipseAttr,\n GlyphAttr,\n LineAttr,\n PolyAttr,\n RectAttr,\n ShapeParams,\n} from \"../interface\";\nimport type { PathArray, PathSegment, ShapeOps, ShapeTypes } from \"../types\";\nimport error from \"../parser/error\";\nimport parsePathString from \"../parser/parsePathString\";\nimport shapeParams from \"./shapeParams\";\nimport isPathArray from \"./isPathArray\";\nimport isElement from \"./isElement\";\n\n/**\n * Returns a new `pathArray` from line attributes.\n *\n * @param attr shape configuration\n * @returns a new line `pathArray`\n */\nexport const getLinePath = (attr: LineAttr): PathArray => {\n let { x1, y1, x2, y2 } = attr;\n [x1, y1, x2, y2] = [x1, y1, x2, y2].map((a) => +a);\n return [\n [\"M\", x1, y1],\n [\"L\", x2, y2],\n ];\n};\n\n/**\n * Returns a new `pathArray` like from polyline/polygon attributes.\n *\n * @param attr shape configuration\n * @return a new polygon/polyline `pathArray`\n */\nexport const getPolyPath = (attr: PolyAttr): PathArray => {\n const pathArray = [] as PathSegment[];\n const points = (attr.points || \"\")\n .trim()\n .split(/[\\s|,]/)\n .map((a) => +a);\n\n let index = 0;\n while (index < points.length) {\n pathArray.push([index ? \"L\" : \"M\", points[index], points[index + 1]]);\n index += 2;\n }\n\n return (attr.type === \"polygon\"\n ? [...pathArray, [\"z\"]]\n : pathArray) as PathArray;\n};\n\n/**\n * Returns a new `pathArray` from circle attributes.\n *\n * @param attr shape configuration\n * @return a circle `pathArray`\n */\nexport const getCirclePath = (attr: CircleAttr): PathArray => {\n let { cx, cy, r } = attr;\n [cx, cy, r] = [cx, cy, r].map((a) => +a);\n\n return [\n [\"M\", cx - r, cy],\n [\"a\", r, r, 0, 1, 0, 2 * r, 0],\n [\"a\", r, r, 0, 1, 0, -2 * r, 0],\n ];\n};\n\n/**\n * Returns a new `pathArray` from ellipse attributes.\n *\n * @param attr shape configuration\n * @return an ellipse `pathArray`\n */\nexport const getEllipsePath = (attr: EllipseAttr): PathArray => {\n let { cx, cy } = attr;\n let rx = attr.rx || 0;\n let ry = attr.ry || rx;\n [cx, cy, rx, ry] = [cx, cy, rx, ry].map((a) => +a);\n\n return [\n [\"M\", cx - rx, cy],\n [\"a\", rx, ry, 0, 1, 0, 2 * rx, 0],\n [\"a\", rx, ry, 0, 1, 0, -2 * rx, 0],\n ];\n};\n\n/**\n * Returns a new `pathArray` like from rect attributes.\n *\n * @param attr object with properties above\n * @return a new `pathArray` from `` attributes\n */\nexport const getRectanglePath = (attr: RectAttr): PathArray => {\n const x = +attr.x || 0;\n const y = +attr.y || 0;\n const w = +attr.width;\n const h = +attr.height;\n let rx = +(attr.rx || 0);\n let ry = +(attr.ry || rx);\n\n // Validity checks from http://www.w3.org/TR/SVG/shapes.html#RectElement:\n if (rx || ry) {\n // rx = !rx ? ry : rx;\n // ry = !ry ? rx : ry;\n\n /* istanbul ignore else @preserve */\n if (rx * 2 > w) rx -= (rx * 2 - w) / 2;\n /* istanbul ignore else @preserve */\n if (ry * 2 > h) ry -= (ry * 2 - h) / 2;\n\n return [\n [\"M\", x + rx, y],\n [\"h\", w - rx * 2],\n [\"s\", rx, 0, rx, ry],\n [\"v\", h - ry * 2],\n [\"s\", 0, ry, -rx, ry],\n [\"h\", -w + rx * 2],\n [\"s\", -rx, 0, -rx, -ry],\n [\"v\", -h + ry * 2],\n [\"s\", 0, -ry, rx, -ry],\n ];\n }\n\n return [[\"M\", x, y], [\"h\", w], [\"v\", h], [\"H\", x], [\"Z\"]];\n};\n\n/**\n * Returns a new `pathArray` created from attributes of a ``, ``,\n * ``, ``, ``, ``, or ``.\n *\n * It can also work with an options object, see the type below\n * @see ShapeOps\n *\n * @param element target shape\n * @return the newly created `` element\n */\nconst shapeToPathArray = (\n element: ShapeTypes | ShapeOps,\n) => {\n const supportedShapes = Object.keys(shapeParams) as (keyof ShapeParams)[];\n const targetIsElement = isElement(element);\n const tagName = targetIsElement ? element.tagName : null;\n\n if (tagName && [...supportedShapes, \"path\"].every((s) => tagName !== s)) {\n throw TypeError(`${error}: \"${tagName}\" is not SVGElement`);\n }\n\n const type =\n (targetIsElement ? tagName : (element as ShapeOps).type) as ShapeOps[\n \"type\"\n ];\n const shapeAttrs = shapeParams[type] as string[];\n const config = { type } as Record;\n\n if (targetIsElement) {\n shapeAttrs.forEach((p) => {\n config[p] = element.getAttribute(p) as string;\n });\n } else {\n Object.assign(config, element);\n }\n\n // set d\n let pathArray = [] as unknown as PathArray;\n\n /* istanbul ignore else */\n if (type === \"circle\") {\n pathArray = getCirclePath(config as unknown as CircleAttr);\n } else if (type === \"ellipse\") {\n pathArray = getEllipsePath(config as unknown as EllipseAttr);\n } else if ([\"polyline\", \"polygon\"].includes(type)) {\n pathArray = getPolyPath(config as unknown as PolyAttr);\n } else if (type === \"rect\") {\n pathArray = getRectanglePath(config as unknown as RectAttr);\n } else if (type === \"line\") {\n pathArray = getLinePath(config as unknown as LineAttr);\n } else if ([\"glyph\", \"path\"].includes(type)) {\n pathArray = parsePathString(\n targetIsElement\n ? element.getAttribute(\"d\") || /* istanbul ignore next @preserve */ \"\"\n : (element as GlyphAttr).d || \"\",\n );\n }\n\n // replace target element\n if (isPathArray(pathArray) && pathArray.length) {\n return pathArray;\n }\n return false;\n};\nexport default shapeToPathArray;\n","import type { ShapeParams } from \"../interface\";\nimport type { ShapeOps, ShapeTypes } from \"../types\";\nimport pathToString from \"../convert/pathToString\";\nimport defaultOptions from \"../options/options\";\nimport error from \"../parser/error\";\nimport isValidPath from \"./isValidPath\";\nimport isElement from \"./isElement\";\nimport shapeToPathArray from \"./shapeToPathArray\";\nimport shapeParams from \"./shapeParams\";\n\n/**\n * Returns a new `` element created from attributes of a ``, ``,\n * ``, ``, ``, `` or ``. If `replace` parameter\n * is `true`, it will replace the target. The default `ownerDocument` is your current\n * `document` browser page, if you want to use in server-side using `jsdom`, you can\n * pass the `jsdom` `document` to `ownDocument`.\n *\n * It can also work with an options object, see the type below\n * @see ShapeOps\n *\n * The newly created `` element keeps all non-specific\n * attributes like `class`, `fill`, etc.\n *\n * @param element target shape\n * @param replace option to replace target\n * @param ownerDocument document for create element\n * @return the newly created `` element\n */\nconst shapeToPath = (\n element: ShapeTypes | ShapeOps,\n replace?: boolean,\n ownerDocument?: Document,\n): SVGPathElement | false => {\n const doc = ownerDocument || document;\n const supportedShapes = Object.keys(shapeParams) as (keyof ShapeParams)[];\n const targetIsElement = isElement(element);\n const tagName = targetIsElement ? element.tagName : null;\n\n if (tagName === \"path\") {\n throw TypeError(`${error}: \"${tagName}\" is already SVGPathElement`);\n }\n if (tagName && supportedShapes.every((s) => tagName !== s)) {\n throw TypeError(`${error}: \"${tagName}\" is not SVGElement`);\n }\n\n const path = doc.createElementNS(\"http://www.w3.org/2000/svg\", \"path\");\n const type =\n (targetIsElement ? tagName : (element as ShapeOps).type) as ShapeOps[\n \"type\"\n ];\n const shapeAttrs = shapeParams[type] as string[];\n const config = { type } as Record;\n\n // set d\n const round = defaultOptions.round as number;\n const pathArray = shapeToPathArray(element);\n const description = pathArray && pathArray.length\n ? pathToString(pathArray, round)\n : \"\";\n\n if (targetIsElement) {\n shapeAttrs.forEach((p) => {\n config[p] = element.getAttribute(p) as string;\n });\n // set no-specific shape attributes: fill, stroke, etc\n Object.values(element.attributes).forEach(({ name, value }) => {\n if (!shapeAttrs.includes(name)) path.setAttribute(name, value);\n });\n } else {\n Object.assign(config, element);\n // set no-specific shape attributes: fill, stroke, etc\n Object.keys(config).forEach((k) => {\n if (!shapeAttrs.includes(k) && k !== \"type\") {\n path.setAttribute(\n k.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`),\n config[k],\n );\n }\n });\n }\n\n // replace target element\n if (isValidPath(description)) {\n path.setAttribute(\"d\", description);\n if (replace && targetIsElement) {\n element.before(path, element);\n element.remove();\n }\n return path;\n }\n return false;\n};\n\nexport default shapeToPath;\n","import CSSMatrix from \"@thednp/dommatrix\";\n// import type { TransformObject } from '../interface';\nimport type { TransformObjectValues } from \"../types\";\n\n/**\n * Returns a transformation matrix to apply to `` elements.\n *\n * @see TransformObjectValues\n *\n * @param transform the `transformObject`\n * @returns a new transformation matrix\n */\nconst getSVGMatrix = (transform: TransformObjectValues): CSSMatrix => {\n let matrix = new CSSMatrix();\n const { origin } = transform;\n const [originX, originY] = origin as [number, number, number];\n const { translate } = transform;\n const { rotate } = transform;\n const { skew } = transform;\n const { scale } = transform;\n\n // set translate\n if (\n Array.isArray(translate) &&\n translate.length >= 2 &&\n translate.every((x) => !Number.isNaN(+x)) &&\n translate.some((x) => x !== 0)\n ) {\n matrix = matrix.translate(...(translate as [number, number, number?]));\n } else if (typeof translate === \"number\" && !Number.isNaN(translate)) {\n matrix = matrix.translate(translate);\n }\n\n if (rotate || skew || scale) {\n // set SVG transform-origin, always defined\n matrix = matrix.translate(originX, originY);\n\n // set rotation\n if (\n Array.isArray(rotate) &&\n rotate.length >= 2 &&\n rotate.every((x) => !Number.isNaN(+x)) &&\n rotate.some((x) => x !== 0)\n ) {\n matrix = matrix.rotate(...(rotate as [number, number, number?]));\n } else if (typeof rotate === \"number\" && !Number.isNaN(rotate)) {\n matrix = matrix.rotate(rotate);\n }\n\n // set skew(s)\n if (\n Array.isArray(skew) && skew.length === 2 && skew.every((x) =>\n !Number.isNaN(+x)\n ) && skew.some((x) => x !== 0)\n ) {\n matrix = skew[0] ? matrix.skewX(skew[0]) : matrix;\n matrix = skew[1] ? matrix.skewY(skew[1]) : matrix;\n } else if (typeof skew === \"number\" && !Number.isNaN(skew)) {\n matrix = matrix.skewX(skew);\n }\n\n // set scale\n if (\n Array.isArray(scale) && scale.length >= 2 && scale.every((x) =>\n !Number.isNaN(+x)\n ) && scale.some((x) => x !== 1)\n ) {\n matrix = matrix.scale(...(scale as [number, number, number?]));\n } else if (typeof scale === \"number\" && !Number.isNaN(scale)) {\n matrix = matrix.scale(scale);\n }\n // set SVG transform-origin\n matrix = matrix.translate(-originX, -originY);\n }\n\n return matrix;\n};\nexport default getSVGMatrix;\n","import defaultOptions from \"../options/options\";\nimport type { ParserParams } from \"../interface\";\nimport roundTo from \"../math/roundTo\";\nimport type {\n AbsoluteSegment,\n NormalSegment,\n PathCommand,\n ShortSegment,\n SSegment,\n TSegment,\n} from \"../types\";\n\n/**\n * Shorten a single segment of a `pathArray` object.\n *\n * @param segment the `absoluteSegment` object\n * @param normalSegment the `normalSegment` object\n * @param params the coordinates of the previous segment\n * @param prevCommand the path command of the previous segment\n * @returns the shortened segment\n */\nconst shortenSegment = (\n segment: AbsoluteSegment,\n normalSegment: NormalSegment,\n params: ParserParams,\n prevCommand: PathCommand,\n): ShortSegment => {\n const [pathCommand] = segment;\n const { round: defaultRound } = defaultOptions;\n const round = typeof defaultRound === \"number\"\n ? defaultRound\n : /* istanbul ignore next */ 4;\n const normalValues = normalSegment.slice(1) as number[];\n const { x1, y1, x2, y2, x, y } = params;\n const [nx, ny] = normalValues.slice(-2);\n const result = segment;\n\n if (!\"TQ\".includes(pathCommand)) {\n // optional but good to be cautious\n params.qx = null;\n params.qy = null;\n }\n\n if (pathCommand === \"L\") {\n if (roundTo(x, round) === roundTo(nx, round)) {\n return [\"V\", ny];\n } else if (roundTo(y, round) === roundTo(ny, round)) {\n return [\"H\", nx];\n }\n } else if (pathCommand === \"C\") {\n const [nx1, ny1] = normalValues;\n params.x1 = nx1;\n params.y1 = ny1;\n\n if (\n \"CS\".includes(prevCommand) &&\n ((roundTo(nx1, round) === roundTo(x1 * 2 - x2, round) &&\n roundTo(ny1, round) === roundTo(y1 * 2 - y2, round)) ||\n (roundTo(x1, round) === roundTo(x2 * 2 - x, round) &&\n roundTo(y1, round) === roundTo(y2 * 2 - y, round)))\n ) {\n return [\n \"S\",\n normalValues[2],\n normalValues[3],\n normalValues[4],\n normalValues[5],\n ] as SSegment;\n }\n } else if (pathCommand === \"Q\") {\n const [qx, qy] = normalValues;\n params.qx = qx;\n params.qy = qy;\n\n if (\n \"QT\".includes(prevCommand) &&\n roundTo(qx, round) === roundTo(x1 * 2 - x2, round) &&\n roundTo(qy, round) === roundTo(y1 * 2 - y2, round)\n ) {\n return [\"T\", normalValues[2], normalValues[3]] as TSegment;\n }\n }\n\n // ['V', 'H', 'S', 'T', 'Z'].includes(pathCommand)\n return result as ShortSegment;\n};\n\nexport default shortenSegment;\n","import type { PathCommand, PathSegment } from \"../types\";\nimport roundTo from \"../math/roundTo\";\n\nconst roundSegment = (\n segment: T,\n roundOption: number,\n) => {\n const values = (segment.slice(1) as number[]).map((n) =>\n roundTo(n, roundOption)\n );\n return [segment[0] as PathCommand | number].concat(values) as T;\n};\n\nexport default roundSegment;\n","import type { AbsoluteSegment, PathArray, PathCommand } from \"../types\";\nimport pathToAbsolute from \"../convert/pathToAbsolute\";\nimport shortenSegment from \"./shortenSegment\";\nimport paramsParser from \"../parser/paramsParser\";\nimport iterate from \"./iterate\";\nimport normalizeSegment from \"./normalizeSegment\";\nimport relativizeSegment from \"./relativizeSegment\";\nimport roundSegment from \"./roundSegment\";\n\n/**\n * Optimizes a `pathArray` object:\n * * convert segments to shorthand if possible\n * * select shortest segments from absolute and relative `pathArray`s\n *\n * @param pathInput a string or `pathArray`\n * @param roundOption the amount of decimals to round values to\n * @returns the optimized `pathArray`\n */\nconst optimizePath = (pathInput: PathArray, roundOption?: number) => {\n const path = pathToAbsolute(pathInput);\n // allow for ZERO decimals or use an aggressive value of 2\n const round = typeof roundOption === \"number\" && roundOption >= 0\n ? roundOption\n : /* istanbul ignore next @preserve */ 2;\n // this utility overrides the iterator params\n const optimParams = { ...paramsParser };\n\n const allPathCommands = [] as PathCommand[];\n let pathCommand = \"M\" as PathCommand;\n let prevCommand = \"Z\" as PathCommand;\n\n return iterate(path, (seg, i, lastX, lastY) => {\n optimParams.x = lastX;\n optimParams.y = lastY;\n const normalizedSegment = normalizeSegment(seg, optimParams);\n let result = seg;\n [pathCommand] = seg;\n\n // Save current path command\n allPathCommands[i] = pathCommand;\n if (i) {\n // Get previous path command for `shortenSegment`\n prevCommand = allPathCommands[i - 1];\n const shortSegment = shortenSegment(\n seg as AbsoluteSegment,\n normalizedSegment,\n optimParams,\n prevCommand,\n );\n const absSegment = roundSegment(shortSegment, round);\n const absString = absSegment.join(\"\");\n const relativeSegment = relativizeSegment(shortSegment, i, lastX, lastY);\n const relSegment = roundSegment(relativeSegment, round);\n const relString = relSegment.join(\"\");\n result = absString.length < relString.length ? absSegment : relSegment;\n }\n\n const seglen = normalizedSegment.length;\n optimParams.x1 = +normalizedSegment[seglen - 2];\n optimParams.y1 = +normalizedSegment[seglen - 1];\n optimParams.x2 = +normalizedSegment[seglen - 4] || optimParams.x1;\n optimParams.y2 = +normalizedSegment[seglen - 3] || optimParams.y1;\n\n return result;\n });\n};\n\nexport default optimizePath;\n","import CSSMatrix from \"@thednp/dommatrix\";\nimport { type PointTuple } from \"../types\";\n\n/**\n * Transforms a specified point using a matrix, returning a new\n * Tuple *Object* comprising of the transformed point.\n * Neither the matrix nor the original point are altered.\n *\n * @copyright thednp © 2021\n *\n * @param cssm CSSMatrix instance\n * @param v Tuple\n * @return the resulting Tuple\n */\nconst translatePoint = (\n cssm: CSSMatrix,\n v: [number, number, number, number],\n): [number, number, number, number] => {\n let m = CSSMatrix.Translate(v[0], v[1], v[2]);\n\n [, , , m.m44] = v;\n m = cssm.multiply(m);\n\n return [m.m41, m.m42, m.m43, m.m44];\n};\n\n/**\n * Returns the [x,y] projected coordinates for a given an [x,y] point\n * and an [x,y,z] perspective origin point.\n *\n * Equation found here =>\n * http://en.wikipedia.org/wiki/3D_projection#Diagram\n * Details =>\n * https://stackoverflow.com/questions/23792505/predicted-rendering-of-css-3d-transformed-pixel\n *\n * @param m the transformation matrix\n * @param point2D the initial [x,y] coordinates\n * @param origin the [x,y,z] transform origin\n * @returns the projected [x,y] coordinates\n */\nconst projection2d = (\n m: CSSMatrix,\n point2D: PointTuple,\n origin: [number, number, number],\n): PointTuple => {\n const [originX, originY, originZ] = origin;\n const [x, y, z] = translatePoint(m, [point2D[0], point2D[1], 0, 1]);\n\n const relativePositionX = x - originX;\n const relativePositionY = y - originY;\n const relativePositionZ = z - originZ;\n\n return [\n // protect against division by ZERO\n relativePositionX * (Math.abs(originZ) / Math.abs(relativePositionZ) || 1) +\n originX,\n relativePositionY * (Math.abs(originZ) / Math.abs(relativePositionZ) || 1) +\n originY,\n ];\n};\nexport default projection2d;\n","import type { CSegment, CurveArray, MSegment, PathCommand } from \"../types\";\n\n/**\n * Reverses all segments of a `pathArray`\n * which consists of only C (cubic-bezier) path commands.\n *\n * @param path the source `pathArray`\n * @returns the reversed `pathArray`\n */\nconst reverseCurve = (path: CurveArray) => {\n const rotatedCurve = path\n .slice(1)\n .map((x, i, curveOnly) =>\n !i\n ? path[0].slice(1).concat(x.slice(1) as number[])\n : curveOnly[i - 1].slice(-2).concat(x.slice(1))\n )\n .map((x) => x.map((_, i) => x[x.length - i - 2 * (1 - (i % 2))]))\n .reverse() as (MSegment | CSegment)[];\n\n return [[\"M\" as PathCommand | number].concat(rotatedCurve[0].slice(0, 2))]\n .concat(\n rotatedCurve.map((x) => [\"C\" as PathCommand | number].concat(x.slice(2))),\n ) as CurveArray;\n};\n\nexport default reverseCurve;\n","import type {\n ASegment,\n CSegment,\n HSegment,\n MSegment,\n PathArray,\n PathSegment,\n PointTuple,\n QSegment,\n SSegment,\n TSegment,\n VSegment,\n} from \"../types\";\nimport pathToAbsolute from \"../convert/pathToAbsolute\";\nimport normalizePath from \"./normalizePath\";\nimport iterate from \"./iterate\";\n\n/**\n * Reverses all segments of a `pathArray` and returns a new `pathArray` instance\n * with absolute values.\n *\n * @param pathInput the source `pathArray`\n * @returns the reversed `pathArray`\n */\nconst reversePath = (pathInput: PathArray) => {\n const absolutePath = pathToAbsolute(pathInput);\n const normalizedPath = normalizePath(absolutePath);\n const pLen = absolutePath.length;\n const isClosed = absolutePath[pLen - 1][0] === \"Z\";\n\n const reversedPath = iterate(absolutePath, (segment, i) => {\n const normalizedSegment = normalizedPath[i];\n const prevSeg = i && absolutePath[i - 1];\n const prevCommand = prevSeg && prevSeg[0];\n const nextSeg = absolutePath[i + 1];\n const nextCommand = nextSeg && nextSeg[0];\n const [pathCommand] = segment;\n const [x, y] = normalizedPath[i ? i - 1 : pLen - 1].slice(-2) as PointTuple;\n let result = segment;\n\n switch (pathCommand) {\n case \"M\":\n result = (isClosed ? [\"Z\"] : [pathCommand, x, y]) as PathSegment;\n break;\n case \"A\":\n result = [\n pathCommand,\n segment[1],\n segment[2],\n segment[3],\n segment[4],\n segment[5] === 1 ? 0 : 1,\n x,\n y,\n ] as ASegment;\n break;\n case \"C\":\n if (nextSeg && nextCommand === \"S\") {\n result = [\"S\", segment[1], segment[2], x, y] as SSegment;\n } else {\n result = [\n pathCommand,\n segment[3],\n segment[4],\n segment[1],\n segment[2],\n x,\n y,\n ] as CSegment;\n }\n break;\n case \"S\":\n if (\n prevCommand && \"CS\".includes(prevCommand) &&\n (!nextSeg || nextCommand !== \"S\")\n ) {\n result = [\n \"C\",\n normalizedSegment[3],\n normalizedSegment[4],\n normalizedSegment[1],\n normalizedSegment[2],\n x,\n y,\n ] as CSegment;\n } else {\n result = [\n pathCommand,\n normalizedSegment[1],\n normalizedSegment[2],\n x,\n y,\n ] as SSegment;\n }\n break;\n case \"Q\":\n if (nextSeg && nextCommand === \"T\") {\n result = [\"T\", x, y] as TSegment;\n } else {\n result = [pathCommand, segment[1], segment[2], x, y] as QSegment;\n }\n break;\n case \"T\":\n if (\n prevCommand && \"QT\".includes(prevCommand) &&\n (!nextSeg || nextCommand !== \"T\")\n ) {\n result = [\n \"Q\",\n normalizedSegment[1],\n normalizedSegment[2],\n x,\n y,\n ] as QSegment;\n } else {\n result = [pathCommand, x, y] as TSegment;\n }\n break;\n case \"Z\":\n result = [\"M\", x, y] as MSegment;\n break;\n case \"H\":\n result = [pathCommand, x] as HSegment;\n break;\n case \"V\":\n result = [pathCommand, y] as VSegment;\n break;\n default:\n result = [pathCommand as typeof pathCommand | number].concat(\n segment.slice(1, -2),\n x,\n y,\n ) as PathSegment;\n }\n\n return result;\n });\n\n return (\n isClosed\n ? reversedPath.reverse()\n : [reversedPath[0] as PathSegment].concat(reversedPath.slice(1).reverse())\n ) as PathArray;\n};\n\nexport default reversePath;\n","import type { PathArray } from \"../types\";\nimport defaultOptions from \"../options/options\";\nimport iterate from \"./iterate\";\nimport roundSegment from \"./roundSegment\";\n\n/**\n * Rounds the values of a `pathArray` instance to\n * a specified amount of decimals and returns it.\n *\n * @param path the source `pathArray`\n * @param roundOption the amount of decimals to round numbers to\n * @returns the resulted `pathArray` with rounded values\n */\nconst roundPath = (path: PathArray, roundOption?: number | \"off\") => {\n let { round } = defaultOptions;\n // allow for ZERO decimals\n round = roundOption === \"off\"\n ? roundOption\n : typeof roundOption === \"number\" && roundOption >= 0\n ? roundOption\n : typeof round === \"number\" && round >= 0\n ? round\n : /* istanbul ignore next @preserve */ \"off\";\n\n /* istanbul ignore else @preserve */\n if (round === \"off\") return path.slice(0) as PathArray;\n\n return iterate(path, (segment) => {\n return roundSegment(segment, round);\n });\n};\nexport default roundPath;\n","import midPoint from \"../math/midPoint\";\nimport type { CubicSegment, PointTuple } from \"../types\";\n\n/**\n * Split a cubic-bezier segment into two.\n *\n * @param pts the cubic-bezier parameters\n * @param ratio the cubic-bezier parameters\n * @return two new cubic-bezier segments\n */\nconst splitCubic = (\n pts: number[],\n ratio = 0.5,\n): [CubicSegment, CubicSegment] => {\n const t = ratio;\n const p0 = pts.slice(0, 2) as PointTuple;\n const p1 = pts.slice(2, 4) as PointTuple;\n const p2 = pts.slice(4, 6) as PointTuple;\n const p3 = pts.slice(6, 8) as PointTuple;\n const p4 = midPoint(p0, p1, t);\n const p5 = midPoint(p1, p2, t);\n const p6 = midPoint(p2, p3, t);\n const p7 = midPoint(p4, p5, t);\n const p8 = midPoint(p5, p6, t);\n const p9 = midPoint(p7, p8, t);\n\n return [\n [\"C\", p4[0], p4[1], p7[0], p7[1], p9[0], p9[1]],\n [\"C\", p8[0], p8[1], p6[0], p6[1], p3[0], p3[1]],\n ];\n};\nexport default splitCubic;\n","import paramsParser from \"../parser/paramsParser\";\nimport type {\n AbsoluteCommand,\n HSegment,\n MSegment,\n PathArray,\n PointTuple,\n RelativeCommand,\n VSegment,\n} from \"../types\";\n\n/**\n * Split a path into an `Array` of sub-path strings.\n *\n * In the process, values are converted to absolute\n * for visual consistency.\n *\n * @param pathInput the source `pathArray`\n * @return an array with all sub-path strings\n */\nconst splitPath = (pathInput: PathArray): PathArray[] => {\n const composite = [] as PathArray[];\n let path: PathArray;\n let pi = -1;\n let x = 0;\n let y = 0;\n let mx = 0;\n let my = 0;\n const params = { ...paramsParser };\n\n pathInput.forEach((seg) => {\n const [pathCommand] = seg;\n const absCommand = pathCommand.toUpperCase() as AbsoluteCommand;\n const relCommand = pathCommand.toLowerCase() as RelativeCommand;\n const isRelative = pathCommand === relCommand;\n const values = seg.slice(1) as number[];\n\n if (absCommand === \"M\") {\n pi += 1;\n [x, y] = values as PointTuple;\n x += isRelative ? params.x : 0;\n y += isRelative ? params.y : 0;\n mx = x;\n my = y;\n path = [(isRelative ? [absCommand, mx, my] : seg) as MSegment];\n } else {\n if (absCommand === \"Z\") {\n x = mx;\n y = my;\n } else if (absCommand === \"H\") {\n [, x] = seg as HSegment;\n x += isRelative ? params.x : /* istanbul ignore next @preserve */ 0;\n } else if (absCommand === \"V\") {\n [, y] = seg as VSegment;\n y += isRelative ? params.y : /* istanbul ignore next @preserve */ 0;\n } else {\n [x, y] = seg.slice(-2) as PointTuple;\n x += isRelative ? params.x : 0;\n y += isRelative ? params.y : 0;\n }\n path.push(seg);\n }\n\n params.x = x;\n params.y = y;\n composite[pi] = path;\n });\n\n return composite;\n};\nexport default splitPath;\n","import getSVGMatrix from \"./getSVGMatrix\";\nimport projection2d from \"./projection2d\";\nimport defaultOptions from \"../options/options\";\nimport type {\n AbsoluteArray,\n AbsoluteSegment,\n CSegment,\n LSegment,\n PathArray,\n TransformObjectValues,\n} from \"../types\";\nimport type { TransformObject } from \"../interface\";\nimport iterate from \"./iterate\";\nimport parsePathString from \"../parser/parsePathString\";\nimport absolutizeSegment from \"./absolutizeSegment\";\nimport arcToCubic from \"./arcToCubic\";\n\n/**\n * Apply a 2D / 3D transformation to a `pathArray` instance.\n *\n * Since *SVGElement* doesn't support 3D transformation, this function\n * creates a 2D projection of the element.\n *\n * @param path the `pathArray` to apply transformation\n * @param transform the transform functions `Object`\n * @returns the resulted `pathArray`\n */\nconst transformPath = (\n pathInput: PathArray | string,\n transform?: Partial,\n) => {\n // last x and y transformed values\n let x = 0;\n let y = 0;\n // new x and y transformed\n let lx = 0;\n let ly = 0;\n // segment params iteration index and length\n let j = 0;\n let jj = 0;\n let pathCommand = \"M\";\n // transform uses it's own set of params\n const path = parsePathString(pathInput);\n const transformProps = transform && Object.keys(transform);\n\n // when used as a static method, invalidate somehow\n if (!transform || (transformProps && !transformProps.length)) {\n return path.slice(0) as typeof path;\n }\n\n // transform origin is extremely important\n if (!transform.origin) {\n Object.assign(transform, { origin: defaultOptions.origin });\n }\n const origin = transform.origin as [number, number, number];\n const matrixInstance = getSVGMatrix(transform as TransformObjectValues);\n\n if (matrixInstance.isIdentity) return path.slice(0) as typeof path;\n\n return iterate(path, (seg, index, lastX, lastY) => {\n [pathCommand] = seg;\n const absCommand = pathCommand.toUpperCase();\n const isRelative = absCommand !== pathCommand;\n const absoluteSegment = isRelative\n ? absolutizeSegment(seg, index, lastX, lastY)\n : (seg.slice(0) as AbsoluteSegment);\n\n let result = absCommand === \"A\"\n // ? segmentToCubic(absoluteSegment, transformParams)\n ? ([\"C\" as string | number].concat(\n arcToCubic(\n lastX,\n lastY,\n absoluteSegment[1] as number,\n absoluteSegment[2] as number,\n absoluteSegment[3] as number,\n absoluteSegment[4] as number,\n absoluteSegment[5] as number,\n absoluteSegment[6] as number,\n absoluteSegment[7] as number,\n ),\n ) as CSegment)\n : absCommand === \"V\"\n ? ([\"L\", lastX, absoluteSegment[1]] as LSegment)\n : absCommand === \"H\"\n ? ([\"L\", absoluteSegment[1], lastY] as LSegment)\n : absoluteSegment;\n\n // update pathCommand\n pathCommand = result[0];\n const isLongArc = pathCommand === \"C\" && result.length > 7;\n const tempSegment =\n (isLongArc ? result.slice(0, 7) : result.slice(0)) as AbsoluteSegment;\n\n if (isLongArc) {\n path.splice(\n index + 1,\n 0,\n [\"C\" as typeof pathCommand | number].concat(\n result.slice(7),\n ) as CSegment,\n );\n result = tempSegment as CSegment;\n }\n\n if (pathCommand === \"L\") {\n [lx, ly] = projection2d(matrixInstance, [\n (result as LSegment)[1],\n (result as LSegment)[2],\n ], origin);\n\n /* istanbul ignore else @preserve */\n if (x !== lx && y !== ly) {\n result = [\"L\", lx, ly];\n } else if (y === ly) {\n result = [\"H\", lx];\n } else if (x === lx) {\n result = [\"V\", ly];\n }\n } else {\n for (j = 1, jj = result.length; j < jj; j += 2) {\n [lx, ly] = projection2d(\n matrixInstance,\n [+result[j], +result[j + 1]],\n origin,\n );\n result[j] = lx;\n result[j + 1] = ly;\n }\n }\n // now update x and y\n x = lx;\n y = ly;\n\n return result;\n });\n};\n\nexport default transformPath;\n","\"use strict\";\nimport * as util from \"./util\";\n// import CSSMatrix from \"@thednp/dommatrix\";\nimport type { PathArray, PointTuple, TransformObjectValues } from \"./types\";\nimport type { Options, TransformEntries, TransformObject } from \"./interface\";\nexport * from \"./types\";\nexport * from \"./interface\";\nimport defaultOptions from \"./options/options\";\n\nimport pathToAbsolute from \"./convert/pathToAbsolute\";\nimport pathToRelative from \"./convert/pathToRelative\";\nimport pathToCurve from \"./convert/pathToCurve\";\nimport pathToString from \"./convert/pathToString\";\n// import * as arcTools from \"./math/arcTools\";\n// import * as bezierTools from \"./math/bezier\";\n// import * as cubicTools from \"./math/cubicTools\";\n// import * as lineTools from \"./math/lineTools\";\n// import * as quadTools from \"./math/quadTools\";\n// import * as polygonTools from \"./math/polygonTools\";\n\n// import distanceSquareRoot from \"./math/distanceSquareRoot\";\n// import midPoint from \"./math/midPoint\";\n// import rotateVector from \"./math/rotateVector\";\n// import roundTo from \"./math/roundTo\";\n\nimport error from \"./parser/error\";\nimport parsePathString from \"./parser/parsePathString\";\n// import finalizeSegment from \"./parser/finalizeSegment\";\n// import invalidPathValue from \"./parser/invalidPathValue\";\n// import isArcCommand from \"./parser/isArcCommand\";\n// import isDigit from \"./parser/isDigit\";\n// import isDigitStart from \"./parser/isDigitStart\";\n// import isMoveCommand from \"./parser/isMoveCommand\";\n// import isPathCommand from \"./parser/isPathCommand\";\n// import isSpace from \"./parser/isSpace\";\n// import paramsCount from \"./parser/paramsCount\";\n// import paramsParser from \"./parser/paramsParser\";\n// import pathParser from \"./parser/pathParser\";\n// import scanFlag from \"./parser/scanFlag\";\n// import scanParam from \"./parser/scanParam\";\n// import scanSegment from \"./parser/scanSegment\";\n// import skipSpaces from \"./parser/skipSpaces\";\n\n// import distanceEpsilon from \"./util/distanceEpsilon\";\n// import getClosestPoint from \"./util/getClosestPoint\";\n// import getDrawDirection from \"./util/getDrawDirection\";\n// import getPathArea from \"./util/getPathArea\";\nimport getPathBBox from \"./util/getPathBBox\";\nimport getPointAtLength from \"./util/getPointAtLength\";\n// import getPropertiesAtLength from \"./util/getPropertiesAtLength\";\n// import getPropertiesAtPoint from \"./util/getPropertiesAtPoint\";\n// import getSegmentAtLength from \"./util/getSegmentAtLength\";\n// import getSegmentOfPoint from \"./util/getSegmentOfPoint\";\nimport getTotalLength from \"./util/getTotalLength\";\n\n// import isAbsoluteArray from \"./util/isAbsoluteArray\";\n// import isCurveArray from \"./util/isCurveArray\";\n// import isNormalizedArray from \"./util/isNormalizedArray\";\n// import isPathArray from \"./util/isPathArray\";\n// import isPointInStroke from \"./util/isPointInStroke\";\n// import isRelativeArray from \"./util/isRelativeArray\";\n// import isValidPath from \"./util/isValidPath\";\n// import shapeParams from \"./util/shapeParams\";\n// import shapeToPath from \"./util/shapeToPath\";\n// import shapeToPathArray from \"./util/shapeToPathArray\";\n\n// import absolutizeSegment from \"./process/absolutizeSegment\";\n// import arcToCubic from \"./process/arcToCubic\";\n// import getSVGMatrix from \"./process/getSVGMatrix\";\n// import iterate from \"./process/iterate\";\n// import lineToCubic from \"./process/lineToCubic\";\nimport normalizePath from \"./process/normalizePath\";\n// import normalizeSegment from \"./process/normalizeSegment\";\nimport optimizePath from \"./process/optimizePath\";\n// import projection2d from \"./process/projection2d\";\n// import quadToCubic from \"./process/quadToCubic\";\n// import relativizeSegment from \"./process/relativizeSegment\";\n// import reverseCurve from \"./process/reverseCurve\";\nimport reversePath from \"./process/reversePath\";\n// import roundPath from \"./process/roundPath\";\n// import roundSegment from \"./process/roundSegment\";\n// import segmentToCubic from \"./process/segmentToCubic\";\n// import shortenSegment from \"./process/shortenSegment\";\n// import splitCubic from \"./process/splitCubic\";\nimport splitPath from \"./process/splitPath\";\nimport transformPath from \"./process/transformPath\";\n\n/**\n * Creates a new SVGPathCommander instance with the following properties:\n * * segments: `pathArray`\n * * round: number\n * * origin: [number, number, number?]\n *\n * @class\n * @author thednp \n * @returns a new SVGPathCommander instance\n */\nclass SVGPathCommander {\n // declare class properties\n declare segments: PathArray;\n declare round: number | \"off\";\n declare origin: [number, number, number];\n\n /**\n * @constructor\n * @param pathValue the path string\n * @param config instance options\n */\n constructor(pathValue: string, config?: Partial) {\n const instanceOptions = config || {};\n const undefPath = typeof pathValue === \"undefined\";\n\n if (undefPath || !pathValue.length) {\n throw TypeError(\n `${error}: \"pathValue\" is ${undefPath ? \"undefined\" : \"empty\"}`,\n );\n }\n\n this.segments = parsePathString(pathValue);\n\n // // set instance options.round\n const { round: roundOption, origin: originOption } = instanceOptions;\n let round: number | \"off\";\n\n if (Number.isInteger(roundOption) || roundOption === \"off\") {\n round = roundOption as number | \"off\";\n } else {\n round = defaultOptions.round as number;\n }\n\n // set instance options.origin\n // the SVGPathCommander class will always override the default origin\n let origin = defaultOptions.origin as [number, number, number];\n /* istanbul ignore else @preserve */\n if (Array.isArray(originOption) && originOption.length >= 2) {\n const [originX, originY, originZ] = originOption.map(Number);\n origin = [\n !Number.isNaN(originX) ? originX : 0,\n !Number.isNaN(originY) ? originY : 0,\n !Number.isNaN(originZ) ? originZ : 0,\n ];\n }\n\n this.round = round;\n this.origin = origin;\n\n return this;\n }\n get bbox() {\n return getPathBBox(this.segments);\n }\n get length() {\n return getTotalLength(this.segments);\n }\n\n /**\n * Returns the path bounding box, equivalent to native `path.getBBox()`.\n *\n * @public\n * @returns the pathBBox\n */\n getBBox() {\n return this.bbox;\n }\n\n /**\n * Returns the total path length, equivalent to native `path.getTotalLength()`.\n *\n * @public\n * @returns the path total length\n */\n getTotalLength() {\n return this.length;\n }\n\n /**\n * Returns an `{x,y}` point in the path stroke at a given length,\n * equivalent to the native `path.getPointAtLength()`.\n *\n * @public\n * @param length the length\n * @returns the requested point\n */\n getPointAtLength(length: number) {\n return getPointAtLength(this.segments, length);\n }\n\n /**\n * Convert path to absolute values\n *\n * @public\n */\n toAbsolute() {\n const { segments } = this;\n this.segments = pathToAbsolute(segments);\n return this;\n }\n\n /**\n * Convert path to relative values\n *\n * @public\n */\n toRelative() {\n const { segments } = this;\n this.segments = pathToRelative(segments);\n return this;\n }\n\n /**\n * Convert path to cubic-bezier values. In addition, un-necessary `Z`\n * segment is removed if previous segment extends to the `M` segment.\n *\n * @public\n */\n toCurve() {\n const { segments } = this;\n this.segments = pathToCurve(segments);\n return this;\n }\n\n /**\n * Reverse the order of the segments and their values.\n *\n * @param onlySubpath option to reverse all sub-paths except first\n * @public\n */\n reverse(onlySubpath?: boolean) {\n const { segments } = this;\n const split = splitPath(segments);\n const subPath = split.length > 1 ? split : false;\n\n const absoluteMultiPath = subPath\n ? subPath.map((x, i) => {\n if (onlySubpath) {\n return i ? reversePath(x) : x.slice(0);\n }\n return reversePath(x);\n })\n : segments.slice(0);\n\n let path = [] as unknown as PathArray;\n if (subPath) {\n path = absoluteMultiPath.flat(1) as PathArray;\n } else {\n path = onlySubpath ? segments : reversePath(segments);\n }\n\n this.segments = path.slice(0) as PathArray;\n return this;\n }\n\n /**\n * Normalize path in 2 steps:\n * * convert `pathArray`(s) to absolute values\n * * convert shorthand notation to standard notation\n *\n * @public\n */\n normalize() {\n const { segments } = this;\n this.segments = normalizePath(segments);\n return this;\n }\n\n /**\n * Optimize `pathArray` values:\n * * convert segments to absolute and/or relative values\n * * select segments with shortest resulted string\n * * round values to the specified `decimals` option value\n *\n * @public\n */\n optimize() {\n const { segments } = this;\n const round = this.round === \"off\" ? 2 : this.round;\n\n this.segments = optimizePath(segments, round);\n return this;\n }\n\n /**\n * Transform path using values from an `Object` defined as `transformObject`.\n *\n * @see TransformObject for a quick refference\n *\n * @param source a `transformObject`as described above\n * @public\n */\n transform(source?: Partial) {\n if (\n !source ||\n typeof source !== \"object\" ||\n (typeof source === \"object\" &&\n ![\"translate\", \"rotate\", \"skew\", \"scale\"].some((x) => x in source))\n ) {\n return this;\n }\n\n const {\n segments,\n origin: [cx, cy, cz],\n } = this;\n const transform = {} as TransformObjectValues;\n for (const [k, v] of Object.entries(source) as TransformEntries) {\n // istanbul ignore else @preserve\n if (k === \"skew\" && Array.isArray(v)) {\n transform[k] = v.map(Number) as PointTuple;\n } else if (\n (k === \"rotate\" || k === \"translate\" || k === \"origin\" ||\n k === \"scale\") && Array.isArray(v)\n ) {\n transform[k] = v.map(Number) as [number, number, number];\n } else if (k !== \"origin\" && typeof Number(v) === \"number\") {\n transform[k] = Number(v);\n }\n }\n\n // if origin is not specified\n // it's important that we have one\n const { origin } = transform;\n\n if (Array.isArray(origin) && origin.length >= 2) {\n const [originX, originY, originZ] = origin.map(Number);\n transform.origin = [\n !Number.isNaN(originX) ? originX : cx,\n !Number.isNaN(originY) ? originY : cy,\n originZ || cz,\n ];\n } else {\n transform.origin = [cx, cy, cz];\n }\n\n this.segments = transformPath(segments, transform);\n return this;\n }\n\n /**\n * Rotate path 180deg vertically\n *\n * @public\n */\n flipX() {\n const { cx, cy } = this.bbox;\n this.transform({ rotate: [0, 180, 0], origin: [cx, cy, 0] });\n return this;\n }\n\n /**\n * Rotate path 180deg horizontally\n *\n * @public\n */\n flipY() {\n const { cx, cy } = this.bbox;\n this.transform({ rotate: [180, 0, 0], origin: [cx, cy, 0] });\n return this;\n }\n\n /**\n * Export the current path to be used\n * for the `d` (description) attribute.\n *\n * @public\n * @return the path string\n */\n toString() {\n return pathToString(this.segments, this.round);\n }\n\n /**\n * Remove the instance.\n *\n * @public\n * @return void\n */\n dispose() {\n Object.keys(this).forEach((key) => delete this[key as keyof typeof this]);\n }\n}\n\n// export {\n// absolutizeSegment,\n// arcToCubic,\n// arcTools,\n// bezierTools,\n// CSSMatrix,\n// cubicTools,\n// distanceEpsilon,\n// distanceSquareRoot,\n// finalizeSegment,\n// getClosestPoint,\n// getDrawDirection,\n// getPathArea,\n// getPathBBox,\n// getPointAtLength,\n// getPropertiesAtLength,\n// getPropertiesAtPoint,\n// getSegmentAtLength,\n// getSegmentOfPoint,\n// getSVGMatrix,\n// getTotalLength,\n// invalidPathValue,\n// isAbsoluteArray,\n// isArcCommand,\n// isCurveArray,\n// isDigit,\n// isDigitStart,\n// isMoveCommand,\n// isNormalizedArray,\n// isPathArray,\n// isPathCommand,\n// isPointInStroke,\n// isRelativeArray,\n// isSpace,\n// isValidPath,\n// iterate,\n// lineToCubic,\n// lineTools,\n// midPoint,\n// normalizePath,\n// normalizeSegment,\n// optimizePath,\n// paramsCount,\n// paramsParser,\n// parsePathString,\n// pathParser,\n// pathToAbsolute,\n// pathToCurve,\n// pathToRelative,\n// pathToString,\n// polygonTools,\n// projection2d,\n// quadToCubic,\n// quadTools,\n// relativizeSegment,\n// reverseCurve,\n// reversePath,\n// rotateVector,\n// roundPath,\n// roundSegment,\n// roundTo,\n// scanFlag,\n// scanParam,\n// scanSegment,\n// segmentToCubic,\n// shapeParams,\n// shapeToPath,\n// shapeToPathArray,\n// shortenSegment,\n// skipSpaces,\n// splitCubic,\n// splitPath,\n// // SVGPathCommander as default,\n// transformPath,\n// };\n\n// const index = {\n// absolutizeSegment,\n// arcToCubic,\n// arcTools,\n// bezierTools,\n// CSSMatrix,\n// cubicTools,\n// distanceEpsilon,\n// distanceSquareRoot,\n// finalizeSegment,\n// getClosestPoint,\n// getDrawDirection,\n// getPathArea,\n// getPathBBox,\n// getPointAtLength,\n// getPropertiesAtLength,\n// getPropertiesAtPoint,\n// getSegmentAtLength,\n// getSegmentOfPoint,\n// getSVGMatrix,\n// getTotalLength,\n// invalidPathValue,\n// isAbsoluteArray,\n// isArcCommand,\n// isCurveArray,\n// isDigit,\n// isDigitStart,\n// isMoveCommand,\n// isNormalizedArray,\n// isPathArray,\n// isPathCommand,\n// isPointInStroke,\n// isRelativeArray,\n// isSpace,\n// isValidPath,\n// iterate,\n// lineToCubic,\n// lineTools,\n// midPoint,\n// normalizePath,\n// normalizeSegment,\n// optimizePath,\n// paramsCount,\n// paramsParser,\n// parsePathString,\n// pathParser,\n// pathToAbsolute,\n// pathToCurve,\n// pathToRelative,\n// pathToString,\n// polygonTools,\n// projection2d,\n// quadToCubic,\n// quadTools,\n// relativizeSegment,\n// reverseCurve,\n// reversePath,\n// rotateVector,\n// roundPath,\n// roundSegment,\n// roundTo,\n// scanFlag,\n// scanParam,\n// scanSegment,\n// segmentToCubic,\n// shapeParams,\n// shapeToPath,\n// shapeToPathArray,\n// shortenSegment,\n// skipSpaces,\n// splitCubic,\n// splitPath,\n// transformPath,\n// };\n\n// export { absolutizeSegment }\n// export { arcToCubic }\n// export { arcTools }\n// export { bezierTools }\n// export { CSSMatrix }\n// export { cubicTools }\n// export { distanceEpsilon }\n// export { distanceSquareRoot }\n// export { finalizeSegment }\n// export { getClosestPoint }\n// export { getDrawDirection }\n// export { getPathArea }\n// export { getPathBBox }\n// export { getPointAtLength }\n// export { getPropertiesAtLength }\n// export { getPropertiesAtPoint }\n// export { getSegmentAtLength }\n// export { getSegmentOfPoint }\n// export { getSVGMatrix }\n// export { getTotalLength }\n// export { invalidPathValue }\n// export { isAbsoluteArray }\n// export { isArcCommand }\n// export { isCurveArray }\n// export { isDigit }\n// export { isDigitStart }\n// export { isMoveCommand }\n// export { isNormalizedArray }\n// export { isPathArray }\n// export { isPathCommand }\n// export { isPointInStroke }\n// export { isRelativeArray }\n// export { isSpace }\n// export { isValidPath }\n// export { iterate }\n// export { lineToCubic }\n// export { lineTools }\n// export { midPoint }\n// export { normalizePath }\n// export { normalizeSegment }\n// export { optimizePath }\n// export { paramsCount }\n// export { paramsParser }\n// export { parsePathString }\n// export { pathParser }\n// export { pathToAbsolute }\n// export { pathToCurve }\n// export { pathToRelative }\n// export { pathToString }\n// export { polygonTools }\n// export { projection2d }\n// export { quadToCubic }\n// export { quadTools }\n// export { relativizeSegment }\n// export { reverseCurve }\n// export { reversePath }\n// export { rotateVector }\n// export { roundPath }\n// export { roundSegment }\n// export { roundTo }\n// export { scanFlag }\n// export { scanParam }\n// export { scanSegment }\n// export { segmentToCubic }\n// export { shapeParams }\n// export { shapeToPath }\n// export { shapeToPathArray }\n// export { shortenSegment }\n// export { skipSpaces }\n// export { splitCubic }\n// export { splitPath }\n// export { transformPath }\n// export { SVGPathCommander as default }\n// export default SVGPathCommander;\nconst defaultExport = Object.assign(SVGPathCommander, util);\n\nexport { defaultExport as default };\n// export default Object.assign(SVGPathCommander, index);\n"],"names":["Z","z","s","t","e","p","$","E","P","y","g","n","i","r","a","m","h","c","u","w","o","d","A","M","b","X","O","x","Y","F","T","k","I","v","R","D","N","midPoint","ax","ay","bx","by","distanceSquareRoot","getLineLength","x1","y1","x2","y2","getPointAtLineLength","distance","point","length","getLineBBox","min","max","arcLength","rx","ry","theta","halfTheta","sinHalfTheta","cosHalfTheta","term1","term2","arcPoint","cx","cy","alpha","sin","cos","cosA","sinA","angleBetween","v0","v1","v0x","v0y","v1x","v1y","getArcProps","RX","RY","angle","LAF","SF","abs","sqrt","PI","xRotRad","dx","dy","transformedPoint","radiiCheck","cSquareNumerator","cSquareRootDenom","cRadicand","cCoef","transformedCenter","center","startVector","startAngle","endVector","sweepAngle","endAngle","getArcLength","getPointAtArcLength","ellipseComponentX","ellipseComponentY","getArcBBox","deltaAngle","tan","atan2","tangent","angle1","angle2","angle3","angle4","xArray","yArray","xMin","xMax","yMin","yMax","angleAfterStart","pP2","angleBeforeEnd","pP3","p1","p2","p4","p3","Tvalues","Cvalues","deriveBezier","points","dpoints","list","j","computeBezier","order","mt","mt2","t2","calculateBezier","derivativeFn","l","bezierLength","len","sum","getBezierLength","curve","idx","step","CBEZIER_MINMAX_EPSILON","minmaxQ","cp","v2","minmaxC","cp1","cp2","K","S","L","Q","getPointAtCubicSegmentLength","c1x","c1y","c2x","c2y","t1","getCubicLength","getPointAtCubicLength","distanceIsNumber","currentLength","getCubicBBox","cxMinMax","cyMinMax","getPointAtQuadSegmentLength","getQuadLength","getPointAtQuadLength","getQuadBBox","polygon","area","paramsCount","finalizeSegment","path","pathCommand","relativeCommand","data","error","scanFlag","index","pathValue","code","isDigit","invalidPathValue","scanParam","start","zeroFirst","hasCeiling","hasDecimal","hasDot","ch","isSpace","skipSpaces","isPathCommand","isDigitStart","isArcCommand","isMoveCommand","scanSegment","segments","cmdCode","reqParams","paramCounts","lastSegment","_a","PathParser","pathString","parsePathString","pathInput","absolutizeSegment","segment","lastX","lastY","absCommand","absValues","seglen","iterate","iterator","pathLen","isRelative","mx","my","segLen","iteratorResult","pathToAbsolute","relativizeSegment","relCommand","relValues","pathToRelative","rotateVector","rad","arcToCubic","X1","Y1","X2","Y2","recursive","d120","res","xy","f1","f2","rx2","ry2","df","f2old","x2old","y2old","c1","s1","c2","s2","hx","hy","m1","m2","m3","m4","newres","ii","quadToCubic","qx","qy","r13","r23","lineToCubic","segmentToCubic","params","values","px1","py1","px","py","normalizeSegment","px2","py2","nqx","nqy","paramsParser","pathToCurve","seg","normalSegment","result","defaultOptions","roundTo","round","pow","pathToString","roundOption","valLen","DISTANCE_EPSILON","normalizePath","_","getPointAtLength","isM","POINT","totalLength","getTotalLength","paramX1","paramY1","paramX2","paramY2","paramQX","paramQY","absoluteSegment","cp1x","cp1y","getPropertiesAtLength","pathArray","pathTemp","pathLength","lengthAtSegment","getPropertiesAtPoint","normalPath","distanceTo","precision","scan","closest","scanDistance","bestLength","bestDistance","scanLength","before","after","beforeLength","afterLength","beforeDistance","afterDistance","getClosestPoint","getCubicSegArea","getPathArea","getDrawDirection","getPathBBox","minX","minY","maxX","maxY","width","height","getSegmentAtLength","getSegmentOfPoint","isPathArray","lk","isAbsoluteArray","isNormalizedArray","pc","isCurveArray","isPointInStroke","isRelativeArray","isValidPath","shapeParams","isElement","node","getLinePath","attr","getPolyPath","getCirclePath","getEllipsePath","getRectanglePath","shapeToPathArray","element","supportedShapes","targetIsElement","tagName","type","shapeAttrs","config","shapeToPath","replace","ownerDocument","doc","description","name","value","getSVGMatrix","transform","matrix","CSSMatrix","origin","originX","originY","translate","rotate","skew","scale","shortenSegment","prevCommand","defaultRound","normalValues","nx","ny","nx1","ny1","roundSegment","optimizePath","optimParams","allPathCommands","normalizedSegment","shortSegment","absSegment","absString","relativeSegment","relSegment","relString","translatePoint","cssm","projection2d","point2D","originZ","relativePositionX","relativePositionY","relativePositionZ","reverseCurve","rotatedCurve","curveOnly","reversePath","absolutePath","normalizedPath","pLen","isClosed","reversedPath","prevSeg","nextSeg","nextCommand","roundPath","splitCubic","pts","ratio","p0","p5","p6","p7","p8","p9","splitPath","composite","pi","transformPath","lx","ly","jj","transformProps","matrixInstance","isLongArc","tempSegment","SVGPathCommander","instanceOptions","undefPath","originOption","onlySubpath","split","subPath","absoluteMultiPath","source","cz","key","util"],"mappings":"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","x_google_ignoreList":[0]} \ No newline at end of file +{"version":3,"sources":["../src/index.ts","../src/util.ts","../node_modules/.pnpm/@thednp+dommatrix@2.0.11/node_modules/@thednp/dommatrix/src/index.ts","../src/math/arcTools.ts","../src/math/lineTools.ts","../src/math/midPoint.ts","../src/math/distanceSquareRoot.ts","../src/math/bezier.ts","../src/math/cubicTools.ts","../src/math/quadTools.ts","../src/math/polygonTools.ts","../src/parser/paramsCount.ts","../src/parser/finalizeSegment.ts","../src/parser/error.ts","../src/parser/scanFlag.ts","../src/parser/isDigit.ts","../src/parser/invalidPathValue.ts","../src/parser/scanParam.ts","../src/parser/isSpace.ts","../src/parser/skipSpaces.ts","../src/parser/isPathCommand.ts","../src/parser/isDigitStart.ts","../src/parser/isArcCommand.ts","../src/parser/isMoveCommand.ts","../src/parser/scanSegment.ts","../src/parser/pathParser.ts","../src/parser/parsePathString.ts","../src/process/absolutizeSegment.ts","../src/process/iterate.ts","../src/convert/pathToAbsolute.ts","../src/process/relativizeSegment.ts","../src/convert/pathToRelative.ts","../src/math/rotateVector.ts","../src/process/arcToCubic.ts","../src/process/quadToCubic.ts","../src/process/lineToCubic.ts","../src/process/segmentToCubic.ts","../src/process/normalizeSegment.ts","../src/parser/paramsParser.ts","../src/convert/pathToCurve.ts","../src/options/options.ts","../src/math/roundTo.ts","../src/convert/pathToString.ts","../src/util/distanceEpsilon.ts","../src/process/normalizePath.ts","../src/util/getPointAtLength.ts","../src/util/getTotalLength.ts","../src/util/getPropertiesAtLength.ts","../src/util/getPropertiesAtPoint.ts","../src/util/getClosestPoint.ts","../src/util/getPathArea.ts","../src/util/getDrawDirection.ts","../src/util/getPathBBox.ts","../src/util/getSegmentAtLength.ts","../src/util/getSegmentOfPoint.ts","../src/util/isPathArray.ts","../src/util/isAbsoluteArray.ts","../src/util/isNormalizedArray.ts","../src/util/isCurveArray.ts","../src/util/isPointInStroke.ts","../src/util/isRelativeArray.ts","../src/util/isValidPath.ts","../src/util/shapeParams.ts","../src/util/isElement.ts","../src/util/shapeToPathArray.ts","../src/util/shapeToPath.ts","../src/process/getSVGMatrix.ts","../src/process/shortenSegment.ts","../src/process/roundSegment.ts","../src/process/optimizePath.ts","../src/process/projection2d.ts","../src/process/reverseCurve.ts","../src/process/reversePath.ts","../src/process/roundPath.ts","../src/process/splitCubic.ts","../src/process/splitPath.ts","../src/process/transformPath.ts"],"sourcesContent":["\"use strict\";\nimport * as util from \"./util\";\n// import CSSMatrix from \"@thednp/dommatrix\";\nimport type { PathArray, PointTuple, TransformObjectValues } from \"./types\";\nimport type { Options, TransformEntries, TransformObject } from \"./interface\";\nexport * from \"./types\";\nexport * from \"./interface\";\nimport defaultOptions from \"./options/options\";\n\nimport pathToAbsolute from \"./convert/pathToAbsolute\";\nimport pathToRelative from \"./convert/pathToRelative\";\nimport pathToCurve from \"./convert/pathToCurve\";\nimport pathToString from \"./convert/pathToString\";\n// import * as arcTools from \"./math/arcTools\";\n// import * as bezierTools from \"./math/bezier\";\n// import * as cubicTools from \"./math/cubicTools\";\n// import * as lineTools from \"./math/lineTools\";\n// import * as quadTools from \"./math/quadTools\";\n// import * as polygonTools from \"./math/polygonTools\";\n\n// import distanceSquareRoot from \"./math/distanceSquareRoot\";\n// import midPoint from \"./math/midPoint\";\n// import rotateVector from \"./math/rotateVector\";\n// import roundTo from \"./math/roundTo\";\n\nimport error from \"./parser/error\";\nimport parsePathString from \"./parser/parsePathString\";\n// import finalizeSegment from \"./parser/finalizeSegment\";\n// import invalidPathValue from \"./parser/invalidPathValue\";\n// import isArcCommand from \"./parser/isArcCommand\";\n// import isDigit from \"./parser/isDigit\";\n// import isDigitStart from \"./parser/isDigitStart\";\n// import isMoveCommand from \"./parser/isMoveCommand\";\n// import isPathCommand from \"./parser/isPathCommand\";\n// import isSpace from \"./parser/isSpace\";\n// import paramsCount from \"./parser/paramsCount\";\n// import paramsParser from \"./parser/paramsParser\";\n// import pathParser from \"./parser/pathParser\";\n// import scanFlag from \"./parser/scanFlag\";\n// import scanParam from \"./parser/scanParam\";\n// import scanSegment from \"./parser/scanSegment\";\n// import skipSpaces from \"./parser/skipSpaces\";\n\n// import distanceEpsilon from \"./util/distanceEpsilon\";\n// import getClosestPoint from \"./util/getClosestPoint\";\n// import getDrawDirection from \"./util/getDrawDirection\";\n// import getPathArea from \"./util/getPathArea\";\nimport getPathBBox from \"./util/getPathBBox\";\nimport getPointAtLength from \"./util/getPointAtLength\";\n// import getPropertiesAtLength from \"./util/getPropertiesAtLength\";\n// import getPropertiesAtPoint from \"./util/getPropertiesAtPoint\";\n// import getSegmentAtLength from \"./util/getSegmentAtLength\";\n// import getSegmentOfPoint from \"./util/getSegmentOfPoint\";\nimport getTotalLength from \"./util/getTotalLength\";\n\n// import isAbsoluteArray from \"./util/isAbsoluteArray\";\n// import isCurveArray from \"./util/isCurveArray\";\n// import isNormalizedArray from \"./util/isNormalizedArray\";\n// import isPathArray from \"./util/isPathArray\";\n// import isPointInStroke from \"./util/isPointInStroke\";\n// import isRelativeArray from \"./util/isRelativeArray\";\n// import isValidPath from \"./util/isValidPath\";\n// import shapeParams from \"./util/shapeParams\";\n// import shapeToPath from \"./util/shapeToPath\";\n// import shapeToPathArray from \"./util/shapeToPathArray\";\n\n// import absolutizeSegment from \"./process/absolutizeSegment\";\n// import arcToCubic from \"./process/arcToCubic\";\n// import getSVGMatrix from \"./process/getSVGMatrix\";\n// import iterate from \"./process/iterate\";\n// import lineToCubic from \"./process/lineToCubic\";\nimport normalizePath from \"./process/normalizePath\";\n// import normalizeSegment from \"./process/normalizeSegment\";\nimport optimizePath from \"./process/optimizePath\";\n// import projection2d from \"./process/projection2d\";\n// import quadToCubic from \"./process/quadToCubic\";\n// import relativizeSegment from \"./process/relativizeSegment\";\n// import reverseCurve from \"./process/reverseCurve\";\nimport reversePath from \"./process/reversePath\";\n// import roundPath from \"./process/roundPath\";\n// import roundSegment from \"./process/roundSegment\";\n// import segmentToCubic from \"./process/segmentToCubic\";\n// import shortenSegment from \"./process/shortenSegment\";\n// import splitCubic from \"./process/splitCubic\";\nimport splitPath from \"./process/splitPath\";\nimport transformPath from \"./process/transformPath\";\n\n/**\n * Creates a new SVGPathCommander instance with the following properties:\n * * segments: `pathArray`\n * * round: number\n * * origin: [number, number, number?]\n *\n * @class\n * @author thednp \n * @returns a new SVGPathCommander instance\n */\nclass SVGPathCommander {\n // declare class properties\n declare segments: PathArray;\n declare round: number | \"off\";\n declare origin: [number, number, number];\n\n /**\n * @constructor\n * @param pathValue the path string\n * @param config instance options\n */\n constructor(pathValue: string, config?: Partial) {\n const instanceOptions = config || {};\n const undefPath = typeof pathValue === \"undefined\";\n\n if (undefPath || !pathValue.length) {\n throw TypeError(\n `${error}: \"pathValue\" is ${undefPath ? \"undefined\" : \"empty\"}`,\n );\n }\n\n this.segments = parsePathString(pathValue);\n\n // // set instance options.round\n const { round: roundOption, origin: originOption } = instanceOptions;\n let round: number | \"off\";\n\n if (Number.isInteger(roundOption) || roundOption === \"off\") {\n round = roundOption as number | \"off\";\n } else {\n round = defaultOptions.round as number;\n }\n\n // set instance options.origin\n // the SVGPathCommander class will always override the default origin\n let origin = defaultOptions.origin as [number, number, number];\n /* istanbul ignore else @preserve */\n if (Array.isArray(originOption) && originOption.length >= 2) {\n const [originX, originY, originZ] = originOption.map(Number);\n origin = [\n !Number.isNaN(originX) ? originX : 0,\n !Number.isNaN(originY) ? originY : 0,\n !Number.isNaN(originZ) ? originZ : 0,\n ];\n }\n\n this.round = round;\n this.origin = origin;\n\n return this;\n }\n get bbox() {\n return getPathBBox(this.segments);\n }\n get length() {\n return getTotalLength(this.segments);\n }\n\n /**\n * Returns the path bounding box, equivalent to native `path.getBBox()`.\n *\n * @public\n * @returns the pathBBox\n */\n getBBox() {\n return this.bbox;\n }\n\n /**\n * Returns the total path length, equivalent to native `path.getTotalLength()`.\n *\n * @public\n * @returns the path total length\n */\n getTotalLength() {\n return this.length;\n }\n\n /**\n * Returns an `{x,y}` point in the path stroke at a given length,\n * equivalent to the native `path.getPointAtLength()`.\n *\n * @public\n * @param length the length\n * @returns the requested point\n */\n getPointAtLength(length: number) {\n return getPointAtLength(this.segments, length);\n }\n\n /**\n * Convert path to absolute values\n *\n * @public\n */\n toAbsolute() {\n const { segments } = this;\n this.segments = pathToAbsolute(segments);\n return this;\n }\n\n /**\n * Convert path to relative values\n *\n * @public\n */\n toRelative() {\n const { segments } = this;\n this.segments = pathToRelative(segments);\n return this;\n }\n\n /**\n * Convert path to cubic-bezier values. In addition, un-necessary `Z`\n * segment is removed if previous segment extends to the `M` segment.\n *\n * @public\n */\n toCurve() {\n const { segments } = this;\n this.segments = pathToCurve(segments);\n return this;\n }\n\n /**\n * Reverse the order of the segments and their values.\n *\n * @param onlySubpath option to reverse all sub-paths except first\n * @public\n */\n reverse(onlySubpath?: boolean) {\n const { segments } = this;\n const split = splitPath(segments);\n const subPath = split.length > 1 ? split : false;\n\n const absoluteMultiPath = subPath\n ? subPath.map((x, i) => {\n if (onlySubpath) {\n return i ? reversePath(x) : x.slice(0);\n }\n return reversePath(x);\n })\n : segments.slice(0);\n\n let path = [] as unknown as PathArray;\n if (subPath) {\n path = absoluteMultiPath.flat(1) as PathArray;\n } else {\n path = onlySubpath ? segments : reversePath(segments);\n }\n\n this.segments = path.slice(0) as PathArray;\n return this;\n }\n\n /**\n * Normalize path in 2 steps:\n * * convert `pathArray`(s) to absolute values\n * * convert shorthand notation to standard notation\n *\n * @public\n */\n normalize() {\n const { segments } = this;\n this.segments = normalizePath(segments);\n return this;\n }\n\n /**\n * Optimize `pathArray` values:\n * * convert segments to absolute and/or relative values\n * * select segments with shortest resulted string\n * * round values to the specified `decimals` option value\n *\n * @public\n */\n optimize() {\n const { segments } = this;\n const round = this.round === \"off\" ? 2 : this.round;\n\n this.segments = optimizePath(segments, round);\n return this;\n }\n\n /**\n * Transform path using values from an `Object` defined as `transformObject`.\n *\n * @see TransformObject for a quick refference\n *\n * @param source a `transformObject`as described above\n * @public\n */\n transform(source?: Partial) {\n if (\n !source ||\n typeof source !== \"object\" ||\n (typeof source === \"object\" &&\n ![\"translate\", \"rotate\", \"skew\", \"scale\"].some((x) => x in source))\n ) {\n return this;\n }\n\n const {\n segments,\n origin: [cx, cy, cz],\n } = this;\n const transform = {} as TransformObjectValues;\n for (const [k, v] of Object.entries(source) as TransformEntries) {\n // istanbul ignore else @preserve\n if (k === \"skew\" && Array.isArray(v)) {\n transform[k] = v.map(Number) as PointTuple;\n } else if (\n (k === \"rotate\" || k === \"translate\" || k === \"origin\" ||\n k === \"scale\") && Array.isArray(v)\n ) {\n transform[k] = v.map(Number) as [number, number, number];\n } else if (k !== \"origin\" && typeof Number(v) === \"number\") {\n transform[k] = Number(v);\n }\n }\n\n // if origin is not specified\n // it's important that we have one\n const { origin } = transform;\n\n if (Array.isArray(origin) && origin.length >= 2) {\n const [originX, originY, originZ] = origin.map(Number);\n transform.origin = [\n !Number.isNaN(originX) ? originX : cx,\n !Number.isNaN(originY) ? originY : cy,\n originZ || cz,\n ];\n } else {\n transform.origin = [cx, cy, cz];\n }\n\n this.segments = transformPath(segments, transform);\n return this;\n }\n\n /**\n * Rotate path 180deg vertically\n *\n * @public\n */\n flipX() {\n const { cx, cy } = this.bbox;\n this.transform({ rotate: [0, 180, 0], origin: [cx, cy, 0] });\n return this;\n }\n\n /**\n * Rotate path 180deg horizontally\n *\n * @public\n */\n flipY() {\n const { cx, cy } = this.bbox;\n this.transform({ rotate: [180, 0, 0], origin: [cx, cy, 0] });\n return this;\n }\n\n /**\n * Export the current path to be used\n * for the `d` (description) attribute.\n *\n * @public\n * @return the path string\n */\n toString() {\n return pathToString(this.segments, this.round);\n }\n\n /**\n * Remove the instance.\n *\n * @public\n * @return void\n */\n dispose() {\n Object.keys(this).forEach((key) => delete this[key as keyof typeof this]);\n }\n}\n\n// export {\n// absolutizeSegment,\n// arcToCubic,\n// arcTools,\n// bezierTools,\n// CSSMatrix,\n// cubicTools,\n// distanceEpsilon,\n// distanceSquareRoot,\n// finalizeSegment,\n// getClosestPoint,\n// getDrawDirection,\n// getPathArea,\n// getPathBBox,\n// getPointAtLength,\n// getPropertiesAtLength,\n// getPropertiesAtPoint,\n// getSegmentAtLength,\n// getSegmentOfPoint,\n// getSVGMatrix,\n// getTotalLength,\n// invalidPathValue,\n// isAbsoluteArray,\n// isArcCommand,\n// isCurveArray,\n// isDigit,\n// isDigitStart,\n// isMoveCommand,\n// isNormalizedArray,\n// isPathArray,\n// isPathCommand,\n// isPointInStroke,\n// isRelativeArray,\n// isSpace,\n// isValidPath,\n// iterate,\n// lineToCubic,\n// lineTools,\n// midPoint,\n// normalizePath,\n// normalizeSegment,\n// optimizePath,\n// paramsCount,\n// paramsParser,\n// parsePathString,\n// pathParser,\n// pathToAbsolute,\n// pathToCurve,\n// pathToRelative,\n// pathToString,\n// polygonTools,\n// projection2d,\n// quadToCubic,\n// quadTools,\n// relativizeSegment,\n// reverseCurve,\n// reversePath,\n// rotateVector,\n// roundPath,\n// roundSegment,\n// roundTo,\n// scanFlag,\n// scanParam,\n// scanSegment,\n// segmentToCubic,\n// shapeParams,\n// shapeToPath,\n// shapeToPathArray,\n// shortenSegment,\n// skipSpaces,\n// splitCubic,\n// splitPath,\n// // SVGPathCommander as default,\n// transformPath,\n// };\n\n// const index = {\n// absolutizeSegment,\n// arcToCubic,\n// arcTools,\n// bezierTools,\n// CSSMatrix,\n// cubicTools,\n// distanceEpsilon,\n// distanceSquareRoot,\n// finalizeSegment,\n// getClosestPoint,\n// getDrawDirection,\n// getPathArea,\n// getPathBBox,\n// getPointAtLength,\n// getPropertiesAtLength,\n// getPropertiesAtPoint,\n// getSegmentAtLength,\n// getSegmentOfPoint,\n// getSVGMatrix,\n// getTotalLength,\n// invalidPathValue,\n// isAbsoluteArray,\n// isArcCommand,\n// isCurveArray,\n// isDigit,\n// isDigitStart,\n// isMoveCommand,\n// isNormalizedArray,\n// isPathArray,\n// isPathCommand,\n// isPointInStroke,\n// isRelativeArray,\n// isSpace,\n// isValidPath,\n// iterate,\n// lineToCubic,\n// lineTools,\n// midPoint,\n// normalizePath,\n// normalizeSegment,\n// optimizePath,\n// paramsCount,\n// paramsParser,\n// parsePathString,\n// pathParser,\n// pathToAbsolute,\n// pathToCurve,\n// pathToRelative,\n// pathToString,\n// polygonTools,\n// projection2d,\n// quadToCubic,\n// quadTools,\n// relativizeSegment,\n// reverseCurve,\n// reversePath,\n// rotateVector,\n// roundPath,\n// roundSegment,\n// roundTo,\n// scanFlag,\n// scanParam,\n// scanSegment,\n// segmentToCubic,\n// shapeParams,\n// shapeToPath,\n// shapeToPathArray,\n// shortenSegment,\n// skipSpaces,\n// splitCubic,\n// splitPath,\n// transformPath,\n// };\n\n// export { absolutizeSegment }\n// export { arcToCubic }\n// export { arcTools }\n// export { bezierTools }\n// export { CSSMatrix }\n// export { cubicTools }\n// export { distanceEpsilon }\n// export { distanceSquareRoot }\n// export { finalizeSegment }\n// export { getClosestPoint }\n// export { getDrawDirection }\n// export { getPathArea }\n// export { getPathBBox }\n// export { getPointAtLength }\n// export { getPropertiesAtLength }\n// export { getPropertiesAtPoint }\n// export { getSegmentAtLength }\n// export { getSegmentOfPoint }\n// export { getSVGMatrix }\n// export { getTotalLength }\n// export { invalidPathValue }\n// export { isAbsoluteArray }\n// export { isArcCommand }\n// export { isCurveArray }\n// export { isDigit }\n// export { isDigitStart }\n// export { isMoveCommand }\n// export { isNormalizedArray }\n// export { isPathArray }\n// export { isPathCommand }\n// export { isPointInStroke }\n// export { isRelativeArray }\n// export { isSpace }\n// export { isValidPath }\n// export { iterate }\n// export { lineToCubic }\n// export { lineTools }\n// export { midPoint }\n// export { normalizePath }\n// export { normalizeSegment }\n// export { optimizePath }\n// export { paramsCount }\n// export { paramsParser }\n// export { parsePathString }\n// export { pathParser }\n// export { pathToAbsolute }\n// export { pathToCurve }\n// export { pathToRelative }\n// export { pathToString }\n// export { polygonTools }\n// export { projection2d }\n// export { quadToCubic }\n// export { quadTools }\n// export { relativizeSegment }\n// export { reverseCurve }\n// export { reversePath }\n// export { rotateVector }\n// export { roundPath }\n// export { roundSegment }\n// export { roundTo }\n// export { scanFlag }\n// export { scanParam }\n// export { scanSegment }\n// export { segmentToCubic }\n// export { shapeParams }\n// export { shapeToPath }\n// export { shapeToPathArray }\n// export { shortenSegment }\n// export { skipSpaces }\n// export { splitCubic }\n// export { splitPath }\n// export { transformPath }\n// export { SVGPathCommander as default }\n// export default SVGPathCommander;\nconst defaultExport = Object.assign(SVGPathCommander, util);\n\nexport { defaultExport as default };\n// export default Object.assign(SVGPathCommander, index);\n","export { default as CSSMatrix } from \"@thednp/dommatrix\";\n// export type { PathArray, PointTuple, TransformObjectValues } from \"./types\";\n// export type { Options, TransformEntries, TransformObject } from \"./interface\";\n// export * from \"./types\";\n// export * from \"./interface\";\n\nimport * as arcTools from \"./math/arcTools\";\nimport * as bezierTools from \"./math/bezier\";\nimport * as cubicTools from \"./math/cubicTools\";\nimport * as lineTools from \"./math/lineTools\";\nimport * as quadTools from \"./math/quadTools\";\nimport * as polygonTools from \"./math/polygonTools\";\nexport { arcTools, bezierTools, cubicTools, lineTools, quadTools, polygonTools };\n\n// export * from \"./math/arcTools\";\n// export * from \"./math/bezier\";\n// export * from \"./math/cubicTools\";\n// export * from \"./math/lineTools\";\n// export * from \"./math/quadTools\";\n// export * from \"./math/polygonTools\";\n\nexport { default as pathToAbsolute } from \"./convert/pathToAbsolute\";\nexport { default as pathToRelative } from \"./convert/pathToRelative\";\nexport { default as pathToCurve } from \"./convert/pathToCurve\";\nexport { default as pathToString } from \"./convert/pathToString\";\n\nexport { default as distanceSquareRoot } from \"./math/distanceSquareRoot\";\nexport { default as midPoint } from \"./math/midPoint\";\nexport { default as rotateVector } from \"./math/rotateVector\";\nexport { default as roundTo } from \"./math/roundTo\";\n\nexport { default as parsePathString } from \"./parser/parsePathString\";\nexport { default as finalizeSegment } from \"./parser/finalizeSegment\";\nexport { default as invalidPathValue } from \"./parser/invalidPathValue\";\nexport { default as isArcCommand } from \"./parser/isArcCommand\";\nexport { default as isDigit } from \"./parser/isDigit\";\nexport { default as isDigitStart } from \"./parser/isDigitStart\";\nexport { default as isMoveCommand } from \"./parser/isMoveCommand\";\nexport { default as isPathCommand } from \"./parser/isPathCommand\";\nexport { default as isSpace } from \"./parser/isSpace\";\nexport { default as paramsCount } from \"./parser/paramsCount\";\nexport { default as paramsParser } from \"./parser/paramsParser\";\nexport { default as pathParser } from \"./parser/pathParser\";\nexport { default as scanFlag } from \"./parser/scanFlag\";\nexport { default as scanParam } from \"./parser/scanParam\";\nexport { default as scanSegment } from \"./parser/scanSegment\";\nexport { default as skipSpaces } from \"./parser/skipSpaces\";\n\nexport { default as distanceEpsilon } from \"./util/distanceEpsilon\";\nexport { default as getClosestPoint } from \"./util/getClosestPoint\";\nexport { default as getDrawDirection } from \"./util/getDrawDirection\";\nexport { default as getPathArea } from \"./util/getPathArea\";\nexport { default as getPathBBox } from \"./util/getPathBBox\";\nexport { default as getPointAtLength } from \"./util/getPointAtLength\";\nexport { default as getPropertiesAtLength } from \"./util/getPropertiesAtLength\";\nexport { default as getPropertiesAtPoint } from \"./util/getPropertiesAtPoint\";\nexport { default as getSegmentAtLength } from \"./util/getSegmentAtLength\";\nexport { default as getSegmentOfPoint } from \"./util/getSegmentOfPoint\";\nexport { default as getTotalLength } from \"./util/getTotalLength\";\n\nexport { default as isAbsoluteArray } from \"./util/isAbsoluteArray\";\nexport { default as isCurveArray } from \"./util/isCurveArray\";\nexport { default as isNormalizedArray } from \"./util/isNormalizedArray\";\nexport { default as isPathArray } from \"./util/isPathArray\";\nexport { default as isPointInStroke } from \"./util/isPointInStroke\";\nexport { default as isRelativeArray } from \"./util/isRelativeArray\";\nexport { default as isValidPath } from \"./util/isValidPath\";\nexport { default as shapeParams } from \"./util/shapeParams\";\nexport { default as shapeToPath } from \"./util/shapeToPath\";\nexport { default as shapeToPathArray } from \"./util/shapeToPathArray\";\n\nexport { default as absolutizeSegment } from \"./process/absolutizeSegment\";\nexport { default as arcToCubic } from \"./process/arcToCubic\";\nexport { default as getSVGMatrix } from \"./process/getSVGMatrix\";\nexport { default as iterate } from \"./process/iterate\";\nexport { default as lineToCubic } from \"./process/lineToCubic\";\nexport { default as normalizePath } from \"./process/normalizePath\";\nexport { default as normalizeSegment } from \"./process/normalizeSegment\";\nexport { default as optimizePath } from \"./process/optimizePath\";\nexport { default as projection2d } from \"./process/projection2d\";\nexport { default as quadToCubic } from \"./process/quadToCubic\";\nexport { default as relativizeSegment } from \"./process/relativizeSegment\";\nexport { default as reverseCurve } from \"./process/reverseCurve\";\nexport { default as reversePath } from \"./process/reversePath\";\nexport { default as roundPath } from \"./process/roundPath\";\nexport { default as roundSegment } from \"./process/roundSegment\";\nexport { default as segmentToCubic } from \"./process/segmentToCubic\";\nexport { default as shortenSegment } from \"./process/shortenSegment\";\nexport { default as splitCubic } from \"./process/splitCubic\";\nexport { default as splitPath } from \"./process/splitPath\";\nexport { default as transformPath } from \"./process/transformPath\";\n","import type {\n CSSMatrixInput,\n JSONMatrix,\n Matrix,\n Matrix3d,\n PointTuple,\n} from \"./types\";\n\n/** A model for JSONMatrix */\nconst JSON_MATRIX: JSONMatrix = {\n a: 1,\n b: 0,\n c: 0,\n d: 1,\n e: 0,\n f: 0,\n m11: 1,\n m12: 0,\n m13: 0,\n m14: 0,\n m21: 0,\n m22: 1,\n m23: 0,\n m24: 0,\n m31: 0,\n m32: 0,\n m33: 1,\n m34: 0,\n m41: 0,\n m42: 0,\n m43: 0,\n m44: 1,\n is2D: true,\n isIdentity: true,\n};\n\n// CSSMatrix Static methods\n// * `fromArray` is a more simple implementation, should also accept Float[32/64]Array;\n// * `fromMatrix` load values from another CSSMatrix/DOMMatrix instance or JSON object;\n// * `fromString` parses and loads values from any valid CSS transform string (TransformList).\n// * `isCompatibleArray` Checks if an array is compatible with CSSMatrix.\n// * `isCompatibleObject` Checks if an object is compatible with CSSMatrix.\n\n/** Checks if an array is compatible with CSSMatrix */\nconst isCompatibleArray = (\n array?: unknown,\n): array is Matrix | Matrix3d | Float32Array | Float64Array => {\n return (\n (array instanceof Float64Array ||\n array instanceof Float32Array ||\n (Array.isArray(array) && array.every((x) => typeof x === \"number\"))) &&\n [6, 16].some((x) => array.length === x)\n );\n};\n\n/** Checks if an object is compatible with CSSMatrix */\nconst isCompatibleObject = (\n object?: unknown,\n): object is CSSMatrix | DOMMatrix | JSONMatrix => {\n return (\n object instanceof DOMMatrix ||\n object instanceof CSSMatrix ||\n (typeof object === \"object\" &&\n Object.keys(JSON_MATRIX).every((k) => object && k in object))\n );\n};\n\n/**\n * Creates a new mutable `CSSMatrix` instance given an array of 16/6 floating point values.\n * This static method invalidates arrays that contain non-number elements.\n *\n * If the array has six values, the result is a 2D matrix; if the array has 16 values,\n * the result is a 3D matrix. Otherwise, a TypeError exception is thrown.\n *\n * @param array an `Array` to feed values from.\n * @return the resulted matrix.\n */\nconst fromArray = (\n array: number[] | Float32Array | Float64Array,\n): CSSMatrix => {\n const m = new CSSMatrix();\n const a = Array.from(array);\n\n if (!isCompatibleArray(a)) {\n throw TypeError(\n `CSSMatrix: \"${a.join(\",\")}\" must be an array with 6/16 numbers.`,\n );\n }\n // istanbul ignore else @preserve\n if (a.length === 16) {\n const [\n m11,\n m12,\n m13,\n m14,\n m21,\n m22,\n m23,\n m24,\n m31,\n m32,\n m33,\n m34,\n m41,\n m42,\n m43,\n m44,\n ] = a;\n\n m.m11 = m11;\n m.a = m11;\n\n m.m21 = m21;\n m.c = m21;\n\n m.m31 = m31;\n\n m.m41 = m41;\n m.e = m41;\n\n m.m12 = m12;\n m.b = m12;\n\n m.m22 = m22;\n m.d = m22;\n\n m.m32 = m32;\n\n m.m42 = m42;\n m.f = m42;\n\n m.m13 = m13;\n m.m23 = m23;\n m.m33 = m33;\n m.m43 = m43;\n m.m14 = m14;\n m.m24 = m24;\n m.m34 = m34;\n m.m44 = m44;\n } else if (a.length === 6) {\n const [M11, M12, M21, M22, M41, M42] = a;\n\n m.m11 = M11;\n m.a = M11;\n\n m.m12 = M12;\n m.b = M12;\n\n m.m21 = M21;\n m.c = M21;\n\n m.m22 = M22;\n m.d = M22;\n\n m.m41 = M41;\n m.e = M41;\n\n m.m42 = M42;\n m.f = M42;\n }\n return m;\n};\n\n/**\n * Creates a new mutable `CSSMatrix` instance given an existing matrix or a\n * `DOMMatrix` instance which provides the values for its properties.\n *\n * @param m the source matrix to feed values from.\n * @return the resulted matrix.\n */\nconst fromMatrix = (m: CSSMatrix | DOMMatrix | JSONMatrix): CSSMatrix => {\n if (isCompatibleObject(m)) {\n return fromArray([\n m.m11,\n m.m12,\n m.m13,\n m.m14,\n m.m21,\n m.m22,\n m.m23,\n m.m24,\n m.m31,\n m.m32,\n m.m33,\n m.m34,\n m.m41,\n m.m42,\n m.m43,\n m.m44,\n ]);\n }\n throw TypeError(\n `CSSMatrix: \"${\n JSON.stringify(m)\n }\" is not a DOMMatrix / CSSMatrix / JSON compatible object.`,\n );\n};\n\n/**\n * Creates a new mutable `CSSMatrix` given any valid CSS transform string,\n * or what we call `TransformList`:\n *\n * * `matrix(a, b, c, d, e, f)` - valid matrix() transform function\n * * `matrix3d(m11, m12, m13, ...m44)` - valid matrix3d() transform function\n * * `translate(tx, ty) rotateX(alpha)` - any valid transform function(s)\n *\n * @copyright thednp © 2021\n *\n * @param source valid CSS transform string syntax.\n * @return the resulted matrix.\n */\nconst fromString = (source: string): CSSMatrix => {\n if (typeof source !== \"string\") {\n throw TypeError(`CSSMatrix: \"${JSON.stringify(source)}\" is not a string.`);\n }\n const str = String(source).replace(/\\s/g, \"\");\n let m = new CSSMatrix();\n const invalidStringError = `CSSMatrix: invalid transform string \"${source}\"`;\n\n // const px = ['perspective'];\n // const length = ['translate', 'translate3d', 'translateX', 'translateY', 'translateZ'];\n // const deg = ['rotate', 'rotate3d', 'rotateX', 'rotateY', 'rotateZ', 'skew', 'skewX', 'skewY'];\n // const abs = ['scale', 'scale3d', 'matrix', 'matrix3d'];\n // const transformFunctions = px.concat(length, deg, abs);\n\n str\n .split(\")\")\n .filter((f) => f)\n .forEach((tf) => {\n const [prop, value] = tf.split(\"(\");\n\n // invalidate empty string\n if (!value) throw TypeError(invalidStringError);\n\n const components = value\n .split(\",\")\n .map((\n n,\n ) => (n.includes(\"rad\")\n ? parseFloat(n) * (180 / Math.PI)\n : parseFloat(n))\n );\n\n const [x, y, z, a] = components;\n const xyz = [x, y, z];\n const xyza = [x, y, z, a];\n\n // single number value expected\n if (\n prop === \"perspective\" && x && [y, z].every((n) => n === undefined)\n ) {\n m.m34 = -1 / x;\n // 6/16 number values expected\n } else if (\n prop.includes(\"matrix\") &&\n [6, 16].includes(components.length) &&\n components.every((n) => !Number.isNaN(+n))\n ) {\n const values = components.map((n) => (Math.abs(n) < 1e-6 ? 0 : n));\n m = m.multiply(fromArray(values as Matrix | Matrix3d));\n // 3 values expected\n } else if (\n prop === \"translate3d\" && xyz.every((n) => !Number.isNaN(+n))\n ) {\n m = m.translate(x, y, z);\n // single/double number value(s) expected\n } else if (prop === \"translate\" && x && z === undefined) {\n m = m.translate(x, y || 0, 0);\n // all 4 values expected\n } else if (\n prop === \"rotate3d\" && xyza.every((n) => !Number.isNaN(+n)) && a\n ) {\n m = m.rotateAxisAngle(x, y, z, a);\n // single value expected\n } else if (\n prop === \"rotate\" && x && [y, z].every((n) => n === undefined)\n ) {\n m = m.rotate(0, 0, x);\n // 3 values expected\n } else if (\n prop === \"scale3d\" && xyz.every((n) => !Number.isNaN(+n)) &&\n xyz.some((n) => n !== 1)\n ) {\n m = m.scale(x, y, z);\n // single value expected\n } else if (\n // prop === \"scale\" && !Number.isNaN(x) && x !== 1 && z === undefined\n // prop === \"scale\" && !Number.isNaN(x) && [x, y].some((n) => n !== 1) &&\n prop === \"scale\" && !Number.isNaN(x) && (x !== 1 || y !== 1) &&\n z === undefined\n ) {\n const nosy = Number.isNaN(+y);\n const sy = nosy ? x : y;\n m = m.scale(x, sy, 1);\n // single/double value expected\n } else if (\n prop === \"skew\" && (x || (!Number.isNaN(x) && y)) && z === undefined\n ) {\n m = m.skew(x, y || 0);\n } else if (\n [\"translate\", \"rotate\", \"scale\", \"skew\"].some((p) =>\n prop.includes(p)\n ) &&\n /[XYZ]/.test(prop) &&\n x &&\n [y, z].every((n) => n === undefined) // a single value expected\n ) {\n if (\"skewX\" === prop || \"skewY\" === prop) {\n m = m[prop](x);\n } else {\n const fn = prop.replace(/[XYZ]/, \"\") as\n | \"scale\"\n | \"translate\"\n | \"rotate\";\n const axis = prop.replace(fn, \"\");\n const idx = [\"X\", \"Y\", \"Z\"].indexOf(axis);\n const def = fn === \"scale\" ? 1 : 0;\n const axeValues: [number, number, number] = [\n idx === 0 ? x : def,\n idx === 1 ? x : def,\n idx === 2 ? x : def,\n ];\n m = m[fn](...axeValues);\n }\n } else {\n throw TypeError(invalidStringError);\n }\n });\n\n return m;\n};\n\n/**\n * Returns an *Array* containing elements which comprise the matrix.\n * The method can return either the 16 elements or the 6 elements\n * depending on the value of the `is2D` parameter.\n *\n * @param m the source matrix to feed values from.\n * @param is2D *Array* representation of the matrix\n * @return an *Array* representation of the matrix\n */\nconst toArray = (\n m: CSSMatrix | DOMMatrix | JSONMatrix,\n is2D?: boolean,\n): Matrix | Matrix3d => {\n if (is2D) {\n return [m.a, m.b, m.c, m.d, m.e, m.f];\n }\n return [\n m.m11,\n m.m12,\n m.m13,\n m.m14,\n m.m21,\n m.m22,\n m.m23,\n m.m24,\n m.m31,\n m.m32,\n m.m33,\n m.m34,\n m.m41,\n m.m42,\n m.m43,\n m.m44,\n ];\n};\n\n// Transform Functions\n// https://www.w3.org/TR/css-transforms-1/#transform-functions\n\n/**\n * Creates a new `CSSMatrix` for the translation matrix and returns it.\n * This method is equivalent to the CSS `translate3d()` function.\n *\n * https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/translate3d\n *\n * @param x the `x-axis` position.\n * @param y the `y-axis` position.\n * @param z the `z-axis` position.\n * @return the resulted matrix.\n */\nconst Translate = (x: number, y: number, z: number): CSSMatrix => {\n const m = new CSSMatrix();\n m.m41 = x;\n m.e = x;\n m.m42 = y;\n m.f = y;\n m.m43 = z;\n return m;\n};\n\n/**\n * Creates a new `CSSMatrix` for the rotation matrix and returns it.\n *\n * http://en.wikipedia.org/wiki/Rotation_matrix\n *\n * @param rx the `x-axis` rotation.\n * @param ry the `y-axis` rotation.\n * @param rz the `z-axis` rotation.\n * @return the resulted matrix.\n */\nconst Rotate = (rx: number, ry: number, rz: number): CSSMatrix => {\n const m = new CSSMatrix();\n const degToRad = Math.PI / 180;\n const radX = rx * degToRad;\n const radY = ry * degToRad;\n const radZ = rz * degToRad;\n\n // minus sin() because of right-handed system\n const cosx = Math.cos(radX);\n const sinx = -Math.sin(radX);\n const cosy = Math.cos(radY);\n const siny = -Math.sin(radY);\n const cosz = Math.cos(radZ);\n const sinz = -Math.sin(radZ);\n\n const m11 = cosy * cosz;\n const m12 = -cosy * sinz;\n\n m.m11 = m11;\n m.a = m11;\n\n m.m12 = m12;\n m.b = m12;\n\n m.m13 = siny;\n\n const m21 = sinx * siny * cosz + cosx * sinz;\n m.m21 = m21;\n m.c = m21;\n\n const m22 = cosx * cosz - sinx * siny * sinz;\n m.m22 = m22;\n m.d = m22;\n\n m.m23 = -sinx * cosy;\n\n m.m31 = sinx * sinz - cosx * siny * cosz;\n m.m32 = sinx * cosz + cosx * siny * sinz;\n m.m33 = cosx * cosy;\n\n return m;\n};\n\n/**\n * Creates a new `CSSMatrix` for the rotation matrix and returns it.\n * This method is equivalent to the CSS `rotate3d()` function.\n *\n * https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/rotate3d\n *\n * @param x the `x-axis` vector length.\n * @param y the `y-axis` vector length.\n * @param z the `z-axis` vector length.\n * @param alpha the value in degrees of the rotation.\n * @return the resulted matrix.\n */\nconst RotateAxisAngle = (\n x: number,\n y: number,\n z: number,\n alpha: number,\n): CSSMatrix => {\n const m = new CSSMatrix();\n const length = Math.sqrt(x * x + y * y + z * z);\n\n if (length === 0) {\n // bad vector length, return identity\n return m;\n }\n\n const X = x / length;\n const Y = y / length;\n const Z = z / length;\n\n const angle = alpha * (Math.PI / 360);\n const sinA = Math.sin(angle);\n const cosA = Math.cos(angle);\n const sinA2 = sinA * sinA;\n const x2 = X * X;\n const y2 = Y * Y;\n const z2 = Z * Z;\n\n const m11 = 1 - 2 * (y2 + z2) * sinA2;\n m.m11 = m11;\n m.a = m11;\n\n const m12 = 2 * (X * Y * sinA2 + Z * sinA * cosA);\n m.m12 = m12;\n m.b = m12;\n\n m.m13 = 2 * (X * Z * sinA2 - Y * sinA * cosA);\n\n const m21 = 2 * (Y * X * sinA2 - Z * sinA * cosA);\n m.m21 = m21;\n m.c = m21;\n\n const m22 = 1 - 2 * (z2 + x2) * sinA2;\n m.m22 = m22;\n m.d = m22;\n\n m.m23 = 2 * (Y * Z * sinA2 + X * sinA * cosA);\n m.m31 = 2 * (Z * X * sinA2 + Y * sinA * cosA);\n m.m32 = 2 * (Z * Y * sinA2 - X * sinA * cosA);\n m.m33 = 1 - 2 * (x2 + y2) * sinA2;\n\n return m;\n};\n\n/**\n * Creates a new `CSSMatrix` for the scale matrix and returns it.\n * This method is equivalent to the CSS `scale3d()` function, except it doesn't\n * accept {x, y, z} transform origin parameters.\n *\n * https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/scale3d\n *\n * @param x the `x-axis` scale.\n * @param y the `y-axis` scale.\n * @param z the `z-axis` scale.\n * @return the resulted matrix.\n */\nconst Scale = (x: number, y: number, z: number): CSSMatrix => {\n const m = new CSSMatrix();\n m.m11 = x;\n m.a = x;\n\n m.m22 = y;\n m.d = y;\n\n m.m33 = z;\n return m;\n};\n\n/**\n * Creates a new `CSSMatrix` for the shear of both the `x-axis` and`y-axis`\n * matrix and returns it. This method is equivalent to the CSS `skew()` function.\n *\n * https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/skew\n *\n * @param angleX the X-angle in degrees.\n * @param angleY the Y-angle in degrees.\n * @return the resulted matrix.\n */\nconst Skew = (angleX: number, angleY: number): CSSMatrix => {\n const m = new CSSMatrix();\n if (angleX) {\n const radX = (angleX * Math.PI) / 180;\n const tX = Math.tan(radX);\n m.m21 = tX;\n m.c = tX;\n }\n if (angleY) {\n const radY = (angleY * Math.PI) / 180;\n const tY = Math.tan(radY);\n m.m12 = tY;\n m.b = tY;\n }\n return m;\n};\n\n/**\n * Creates a new `CSSMatrix` for the shear of the `x-axis` rotation matrix and\n * returns it. This method is equivalent to the CSS `skewX()` function.\n *\n * https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/skewX\n *\n * @param angle the angle in degrees.\n * @return the resulted matrix.\n */\nconst SkewX = (angle: number): CSSMatrix => {\n return Skew(angle, 0);\n};\n\n/**\n * Creates a new `CSSMatrix` for the shear of the `y-axis` rotation matrix and\n * returns it. This method is equivalent to the CSS `skewY()` function.\n *\n * https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/skewY\n *\n * @param angle the angle in degrees.\n * @return the resulted matrix.\n */\nconst SkewY = (angle: number): CSSMatrix => {\n return Skew(0, angle);\n};\n\n/**\n * Creates a new `CSSMatrix` resulted from the multiplication of two matrixes\n * and returns it. Both matrixes are not changed.\n *\n * @param m1 the first matrix.\n * @param m2 the second matrix.\n * @return the resulted matrix.\n */\nconst Multiply = (\n m1: CSSMatrix | DOMMatrix | JSONMatrix,\n m2: CSSMatrix | DOMMatrix | JSONMatrix,\n): CSSMatrix => {\n const m11 = m2.m11 * m1.m11 + m2.m12 * m1.m21 + m2.m13 * m1.m31 +\n m2.m14 * m1.m41;\n const m12 = m2.m11 * m1.m12 + m2.m12 * m1.m22 + m2.m13 * m1.m32 +\n m2.m14 * m1.m42;\n const m13 = m2.m11 * m1.m13 + m2.m12 * m1.m23 + m2.m13 * m1.m33 +\n m2.m14 * m1.m43;\n const m14 = m2.m11 * m1.m14 + m2.m12 * m1.m24 + m2.m13 * m1.m34 +\n m2.m14 * m1.m44;\n\n const m21 = m2.m21 * m1.m11 + m2.m22 * m1.m21 + m2.m23 * m1.m31 +\n m2.m24 * m1.m41;\n const m22 = m2.m21 * m1.m12 + m2.m22 * m1.m22 + m2.m23 * m1.m32 +\n m2.m24 * m1.m42;\n const m23 = m2.m21 * m1.m13 + m2.m22 * m1.m23 + m2.m23 * m1.m33 +\n m2.m24 * m1.m43;\n const m24 = m2.m21 * m1.m14 + m2.m22 * m1.m24 + m2.m23 * m1.m34 +\n m2.m24 * m1.m44;\n\n const m31 = m2.m31 * m1.m11 + m2.m32 * m1.m21 + m2.m33 * m1.m31 +\n m2.m34 * m1.m41;\n const m32 = m2.m31 * m1.m12 + m2.m32 * m1.m22 + m2.m33 * m1.m32 +\n m2.m34 * m1.m42;\n const m33 = m2.m31 * m1.m13 + m2.m32 * m1.m23 + m2.m33 * m1.m33 +\n m2.m34 * m1.m43;\n const m34 = m2.m31 * m1.m14 + m2.m32 * m1.m24 + m2.m33 * m1.m34 +\n m2.m34 * m1.m44;\n\n const m41 = m2.m41 * m1.m11 + m2.m42 * m1.m21 + m2.m43 * m1.m31 +\n m2.m44 * m1.m41;\n const m42 = m2.m41 * m1.m12 + m2.m42 * m1.m22 + m2.m43 * m1.m32 +\n m2.m44 * m1.m42;\n const m43 = m2.m41 * m1.m13 + m2.m42 * m1.m23 + m2.m43 * m1.m33 +\n m2.m44 * m1.m43;\n const m44 = m2.m41 * m1.m14 + m2.m42 * m1.m24 + m2.m43 * m1.m34 +\n m2.m44 * m1.m44;\n\n return fromArray([\n m11,\n m12,\n m13,\n m14,\n m21,\n m22,\n m23,\n m24,\n m31,\n m32,\n m33,\n m34,\n m41,\n m42,\n m43,\n m44,\n ]);\n};\n\n/**\n * Creates and returns a new `DOMMatrix` compatible instance\n * with equivalent instance.\n *\n * @class CSSMatrix\n *\n * @author thednp \n * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMMatrix\n */\nexport default class CSSMatrix {\n declare m11: number;\n declare m12: number;\n declare m13: number;\n declare m14: number;\n declare m21: number;\n declare m22: number;\n declare m23: number;\n declare m24: number;\n declare m31: number;\n declare m32: number;\n declare m33: number;\n declare m34: number;\n declare m41: number;\n declare m42: number;\n declare m43: number;\n declare m44: number;\n declare a: number;\n declare b: number;\n declare c: number;\n declare d: number;\n declare e: number;\n declare f: number;\n static Translate = Translate;\n static Rotate = Rotate;\n static RotateAxisAngle = RotateAxisAngle;\n static Scale = Scale;\n static SkewX = SkewX;\n static SkewY = SkewY;\n static Skew = Skew;\n static Multiply = Multiply;\n static fromArray = fromArray;\n static fromMatrix = fromMatrix;\n static fromString = fromString;\n static toArray = toArray;\n static isCompatibleArray = isCompatibleArray;\n static isCompatibleObject = isCompatibleObject;\n\n /**\n * @constructor\n * @param init accepts all parameter configurations:\n * * valid CSS transform string,\n * * CSSMatrix/DOMMatrix instance,\n * * a 6/16 elements *Array*.\n */\n constructor(init?: CSSMatrixInput) {\n // array 6\n this.a = 1;\n this.b = 0;\n this.c = 0;\n this.d = 1;\n this.e = 0;\n this.f = 0;\n // array 16\n this.m11 = 1;\n this.m12 = 0;\n this.m13 = 0;\n this.m14 = 0;\n this.m21 = 0;\n this.m22 = 1;\n this.m23 = 0;\n this.m24 = 0;\n this.m31 = 0;\n this.m32 = 0;\n this.m33 = 1;\n this.m34 = 0;\n this.m41 = 0;\n this.m42 = 0;\n this.m43 = 0;\n this.m44 = 1;\n\n if (init) {\n return this.setMatrixValue(init);\n }\n return this;\n }\n\n /**\n * A `Boolean` whose value is `true` if the matrix is the identity matrix. The identity\n * matrix is one in which every value is 0 except those on the main diagonal from top-left\n * to bottom-right corner (in other words, where the offsets in each direction are equal).\n *\n * @return the current property value\n */\n get isIdentity(): boolean {\n return (\n this.m11 === 1 &&\n this.m12 === 0 &&\n this.m13 === 0 &&\n this.m14 === 0 &&\n this.m21 === 0 &&\n this.m22 === 1 &&\n this.m23 === 0 &&\n this.m24 === 0 &&\n this.m31 === 0 &&\n this.m32 === 0 &&\n this.m33 === 1 &&\n this.m34 === 0 &&\n this.m41 === 0 &&\n this.m42 === 0 &&\n this.m43 === 0 &&\n this.m44 === 1\n );\n }\n\n /**\n * A `Boolean` flag whose value is `true` if the matrix was initialized as a 2D matrix\n * and `false` if the matrix is 3D.\n *\n * @return the current property value\n */\n get is2D(): boolean {\n return this.m31 === 0 && this.m32 === 0 && this.m33 === 1 &&\n this.m34 === 0 && this.m43 === 0 && this.m44 === 1;\n }\n\n /**\n * The `setMatrixValue` method replaces the existing matrix with one computed\n * in the browser. EG: `matrix(1,0.25,-0.25,1,0,0)`\n *\n * The method accepts any *Array* values, the result of\n * `DOMMatrix` instance method `toFloat64Array()` / `toFloat32Array()` calls\n * or `CSSMatrix` instance method `toArray()`.\n *\n * This method expects valid *matrix()* / *matrix3d()* string values, as well\n * as other transform functions like *translateX(10px)*.\n *\n * @param source\n * @return the matrix instance\n */\n setMatrixValue(source?: CSSMatrixInput): CSSMatrix {\n // CSS transform string source - TransformList first\n if (typeof source === \"string\" && source.length && source !== \"none\") {\n return fromString(source);\n }\n\n // [Array | Float[32/64]Array] come next\n if (\n Array.isArray(source) || source instanceof Float64Array ||\n source instanceof Float32Array\n ) {\n return fromArray(source);\n }\n\n // new CSSMatrix(CSSMatrix | DOMMatrix | JSONMatrix) last\n if (typeof source === \"object\") {\n return fromMatrix(source);\n }\n\n return this;\n }\n\n /**\n * Returns a *Float32Array* containing elements which comprise the matrix.\n * The method can return either the 16 elements or the 6 elements\n * depending on the value of the `is2D` parameter.\n *\n * @param is2D *Array* representation of the matrix\n * @return an *Array* representation of the matrix\n */\n toFloat32Array(is2D?: boolean): Float32Array {\n return Float32Array.from(toArray(this, is2D));\n }\n\n /**\n * Returns a *Float64Array* containing elements which comprise the matrix.\n * The method can return either the 16 elements or the 6 elements\n * depending on the value of the `is2D` parameter.\n *\n * @param is2D *Array* representation of the matrix\n * @return an *Array* representation of the matrix\n */\n toFloat64Array(is2D?: boolean): Float64Array {\n return Float64Array.from(toArray(this, is2D));\n }\n\n /**\n * Creates and returns a string representation of the matrix in `CSS` matrix syntax,\n * using the appropriate `CSS` matrix notation.\n *\n * matrix3d *matrix3d(m11, m12, m13, m14, m21, ...)*\n * matrix *matrix(a, b, c, d, e, f)*\n *\n * @return a string representation of the matrix\n */\n toString(): string {\n const { is2D } = this;\n const values = this.toFloat64Array(is2D).join(\", \");\n const type = is2D ? \"matrix\" : \"matrix3d\";\n return `${type}(${values})`;\n }\n\n /**\n * Returns a JSON representation of the `CSSMatrix` instance, a standard *Object*\n * that includes `{a,b,c,d,e,f}` and `{m11,m12,m13,..m44}` properties as well\n * as the `is2D` & `isIdentity` properties.\n *\n * The result can also be used as a second parameter for the `fromMatrix` static method\n * to load values into another matrix instance.\n *\n * @return an *Object* with all matrix values.\n */\n toJSON(): JSONMatrix {\n const { is2D, isIdentity } = this;\n return { ...this, is2D, isIdentity };\n }\n\n /**\n * The Multiply method returns a new CSSMatrix which is the result of this\n * matrix multiplied by the passed matrix, with the passed matrix to the right.\n * This matrix is not modified.\n *\n * @param m2 CSSMatrix\n * @return The resulted matrix.\n */\n multiply(m2: CSSMatrix | DOMMatrix | JSONMatrix): CSSMatrix {\n return Multiply(this, m2);\n }\n\n /**\n * The translate method returns a new matrix which is this matrix post\n * multiplied by a translation matrix containing the passed values. If the z\n * component is undefined, a 0 value is used in its place. This matrix is not\n * modified.\n *\n * @param x X component of the translation value.\n * @param y Y component of the translation value.\n * @param z Z component of the translation value.\n * @return The resulted matrix\n */\n translate(x: number, y?: number, z?: number): CSSMatrix {\n const X = x;\n let Y = y;\n let Z = z;\n if (typeof Y === \"undefined\") Y = 0;\n if (typeof Z === \"undefined\") Z = 0;\n return Multiply(this, Translate(X, Y, Z));\n }\n\n /**\n * The scale method returns a new matrix which is this matrix post multiplied by\n * a scale matrix containing the passed values. If the z component is undefined,\n * a 1 value is used in its place. If the y component is undefined, the x\n * component value is used in its place. This matrix is not modified.\n *\n * @param x The X component of the scale value.\n * @param y The Y component of the scale value.\n * @param z The Z component of the scale value.\n * @return The resulted matrix\n */\n scale(x: number, y?: number, z?: number): CSSMatrix {\n const X = x;\n let Y = y;\n let Z = z;\n if (typeof Y === \"undefined\") Y = x;\n if (typeof Z === \"undefined\") Z = 1; // Z must be 1 if undefined\n\n return Multiply(this, Scale(X, Y, Z));\n }\n\n /**\n * The rotate method returns a new matrix which is this matrix post multiplied\n * by each of 3 rotation matrices about the major axes, first X, then Y, then Z.\n * If the y and z components are undefined, the x value is used to rotate the\n * object about the z axis, as though the vector (0,0,x) were passed. All\n * rotation values are in degrees. This matrix is not modified.\n *\n * @param rx The X component of the rotation, or Z if Y and Z are null.\n * @param ry The (optional) Y component of the rotation value.\n * @param rz The (optional) Z component of the rotation value.\n * @return The resulted matrix\n */\n rotate(rx: number, ry?: number, rz?: number): CSSMatrix {\n let RX = rx;\n let RY = ry || 0;\n let RZ = rz || 0;\n\n if (\n typeof rx === \"number\" && typeof ry === \"undefined\" &&\n typeof rz === \"undefined\"\n ) {\n RZ = RX;\n RX = 0;\n RY = 0;\n }\n\n return Multiply(this, Rotate(RX, RY, RZ));\n }\n\n /**\n * The rotateAxisAngle method returns a new matrix which is this matrix post\n * multiplied by a rotation matrix with the given axis and `angle`. The right-hand\n * rule is used to determine the direction of rotation. All rotation values are\n * in degrees. This matrix is not modified.\n *\n * @param x The X component of the axis vector.\n * @param y The Y component of the axis vector.\n * @param z The Z component of the axis vector.\n * @param angle The angle of rotation about the axis vector, in degrees.\n * @return The resulted matrix\n */\n rotateAxisAngle(x: number, y: number, z: number, angle: number): CSSMatrix {\n if ([x, y, z, angle].some((n) => Number.isNaN(+n))) {\n throw new TypeError(\"CSSMatrix: expecting 4 values\");\n }\n return Multiply(this, RotateAxisAngle(x, y, z, angle));\n }\n\n /**\n * Specifies a skew transformation along the `x-axis` by the given angle.\n * This matrix is not modified.\n *\n * @param angle The angle amount in degrees to skew.\n * @return The resulted matrix\n */\n skewX(angle: number): CSSMatrix {\n return Multiply(this, SkewX(angle));\n }\n\n /**\n * Specifies a skew transformation along the `y-axis` by the given angle.\n * This matrix is not modified.\n *\n * @param angle The angle amount in degrees to skew.\n * @return The resulted matrix\n */\n skewY(angle: number): CSSMatrix {\n return Multiply(this, SkewY(angle));\n }\n\n /**\n * Specifies a skew transformation along both the `x-axis` and `y-axis`.\n * This matrix is not modified.\n *\n * @param angleX The X-angle amount in degrees to skew.\n * @param angleY The angle amount in degrees to skew.\n * @return The resulted matrix\n */\n skew(angleX: number, angleY: number): CSSMatrix {\n return Multiply(this, Skew(angleX, angleY));\n }\n\n /**\n * Transforms a specified vector using the matrix, returning a new\n * {x,y,z,w} Tuple *Object* comprising the transformed vector.\n * Neither the matrix nor the original vector are altered.\n *\n * The method is equivalent with `transformPoint()` method\n * of the `DOMMatrix` constructor.\n *\n * @param t Tuple with `{x,y,z,w}` components\n * @return the resulting Tuple\n */\n transformPoint(t: PointTuple | DOMPoint): PointTuple | DOMPoint {\n const x = this.m11 * t.x + this.m21 * t.y + this.m31 * t.z + this.m41 * t.w;\n const y = this.m12 * t.x + this.m22 * t.y + this.m32 * t.z + this.m42 * t.w;\n const z = this.m13 * t.x + this.m23 * t.y + this.m33 * t.z + this.m43 * t.w;\n const w = this.m14 * t.x + this.m24 * t.y + this.m34 * t.z + this.m44 * t.w;\n\n return t instanceof DOMPoint ? new DOMPoint(x, y, z, w) : {\n x,\n y,\n z,\n w,\n };\n }\n}\n","import { getPointAtLineLength } from \"./lineTools\";\nimport type { Point, PointTuple } from \"../types\";\n\n/**\n * Returns the Arc segment length.\n * @param rx radius along X axis\n * @param ry radius along Y axis\n * @param theta the angle in radians\n * @returns the arc length\n */\nconst arcLength = (rx: number, ry: number, theta: number) => {\n const halfTheta = theta / 2;\n const sinHalfTheta = Math.sin(halfTheta);\n const cosHalfTheta = Math.cos(halfTheta);\n const term1 = rx ** 2 * sinHalfTheta ** 2;\n const term2 = ry ** 2 * cosHalfTheta ** 2;\n const length = Math.sqrt(term1 + term2) * theta;\n return Math.abs(length);\n};\n\n/**\n * Find point on ellipse at given angle around ellipse (theta);\n * @param cx the center X\n * @param cy the center Y\n * @param rx the radius X\n * @param ry the radius Y\n * @param alpha the arc rotation angle in radians\n * @param theta the arc sweep angle in radians\n * @returns a point around ellipse at given angle\n */\nconst arcPoint = (\n cx: number,\n cy: number,\n rx: number,\n ry: number,\n alpha: number,\n theta: number,\n) => {\n const { sin, cos } = Math;\n // theta is angle in radians around arc\n // alpha is angle of rotation of ellipse in radians\n const cosA = cos(alpha);\n const sinA = sin(alpha);\n const x = rx * cos(theta);\n const y = ry * sin(theta);\n\n return [cx + cosA * x - sinA * y, cy + sinA * x + cosA * y] as PointTuple;\n};\n\n/**\n * Returns the angle between two points.\n * @param v0 starting point\n * @param v1 ending point\n * @returns the angle in radian\n */\nconst angleBetween = (v0: Point, v1: Point) => {\n const { x: v0x, y: v0y } = v0;\n const { x: v1x, y: v1y } = v1;\n const p = v0x * v1x + v0y * v1y;\n const n = Math.sqrt((v0x ** 2 + v0y ** 2) * (v1x ** 2 + v1y ** 2));\n const sign = v0x * v1y - v0y * v1x < 0 ? -1 : 1;\n return sign * Math.acos(p / n);\n};\n\n/**\n * Returns the following properties for an Arc segment: center, start angle,\n * end angle, and radiuses on X and Y axis.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param RX the radius on X axis\n * @param RY the radius on Y axis\n * @param angle the ellipse rotation in degrees\n * @param LAF the large arc flag\n * @param SF the sweep flag\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns properties specific to Arc segments\n */\nconst getArcProps = (\n x1: number,\n y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n x: number,\n y: number,\n) => {\n const { abs, sin, cos, sqrt, PI } = Math;\n let rx = abs(RX);\n let ry = abs(RY);\n const xRot = ((angle % 360) + 360) % 360;\n const xRotRad = xRot * (PI / 180);\n\n // istanbul ignore next @preserve\n if (x1 === x && y1 === y) {\n return {\n rx,\n ry,\n startAngle: 0,\n endAngle: 0,\n center: { x, y },\n };\n }\n\n if (rx === 0 || ry === 0) {\n return {\n rx,\n ry,\n startAngle: 0,\n endAngle: 0,\n center: { x: (x + x1) / 2, y: (y + y1) / 2 },\n };\n }\n\n const dx = (x1 - x) / 2;\n const dy = (y1 - y) / 2;\n\n const transformedPoint = {\n x: cos(xRotRad) * dx + sin(xRotRad) * dy,\n y: -sin(xRotRad) * dx + cos(xRotRad) * dy,\n };\n\n const radiiCheck = transformedPoint.x ** 2 / rx ** 2 +\n transformedPoint.y ** 2 / ry ** 2;\n\n if (radiiCheck > 1) {\n rx *= sqrt(radiiCheck);\n ry *= sqrt(radiiCheck);\n }\n\n const cSquareNumerator = rx ** 2 * ry ** 2 -\n rx ** 2 * transformedPoint.y ** 2 - ry ** 2 * transformedPoint.x ** 2;\n const cSquareRootDenom = rx ** 2 * transformedPoint.y ** 2 +\n ry ** 2 * transformedPoint.x ** 2;\n\n let cRadicand = cSquareNumerator / cSquareRootDenom;\n /* istanbul ignore next @preserve */\n cRadicand = cRadicand < 0 ? 0 : cRadicand;\n const cCoef = (LAF !== SF ? 1 : -1) * sqrt(cRadicand);\n const transformedCenter = {\n x: cCoef * ((rx * transformedPoint.y) / ry),\n y: cCoef * (-(ry * transformedPoint.x) / rx),\n };\n\n const center = {\n x: cos(xRotRad) * transformedCenter.x - sin(xRotRad) * transformedCenter.y +\n (x1 + x) / 2,\n y: sin(xRotRad) * transformedCenter.x + cos(xRotRad) * transformedCenter.y +\n (y1 + y) / 2,\n };\n\n const startVector = {\n x: (transformedPoint.x - transformedCenter.x) / rx,\n y: (transformedPoint.y - transformedCenter.y) / ry,\n };\n\n const startAngle = angleBetween({ x: 1, y: 0 }, startVector);\n\n const endVector = {\n x: (-transformedPoint.x - transformedCenter.x) / rx,\n y: (-transformedPoint.y - transformedCenter.y) / ry,\n };\n\n let sweepAngle = angleBetween(startVector, endVector);\n if (!SF && sweepAngle > 0) {\n sweepAngle -= 2 * PI;\n } else if (SF && sweepAngle < 0) {\n sweepAngle += 2 * PI;\n }\n sweepAngle %= 2 * PI;\n\n const endAngle = startAngle + sweepAngle;\n\n // point.ellipticalArcStartAngle = startAngle;\n // point.ellipticalArcEndAngle = startAngle + sweepAngle;\n // point.ellipticalArcAngle = alpha;\n\n // point.ellipticalArcCenter = center;\n // point.resultantRx = rx;\n // point.resultantRy = ry;\n\n return {\n center,\n startAngle,\n endAngle,\n rx,\n ry,\n };\n};\n\n/**\n * Returns the length of an Arc segment.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the length of the Arc segment\n */\nconst getArcLength = (\n x1: number,\n y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n x: number,\n y: number,\n) => {\n const { rx, ry, startAngle, endAngle } = getArcProps(\n x1,\n y1,\n RX,\n RY,\n angle,\n LAF,\n SF,\n x,\n y,\n );\n return arcLength(rx, ry, endAngle - startAngle);\n};\n\n/**\n * Returns a point along an Arc segment at a given distance.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param RX the radius on X axis\n * @param RY the radius on Y axis\n * @param angle the ellipse rotation in degrees\n * @param LAF the large arc flag\n * @param SF the sweep flag\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance a [0-1] ratio\n * @returns a point along the Arc segment\n */\nconst getPointAtArcLength = (\n x1: number,\n y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n x: number,\n y: number,\n distance?: number,\n) => {\n let point = { x: x1, y: y1 };\n const { center, rx, ry, startAngle, endAngle } = getArcProps(\n x1,\n y1,\n RX,\n RY,\n angle,\n LAF,\n SF,\n x,\n y,\n );\n\n /* istanbul ignore else @preserve */\n if (typeof distance === \"number\") {\n const length = arcLength(rx, ry, endAngle - startAngle);\n if (distance <= 0) {\n point = { x: x1, y: y1 };\n } else if (distance >= length) {\n point = { x, y };\n } else {\n /* istanbul ignore next @preserve */\n if (x1 === x && y1 === y) {\n return { x, y };\n }\n /* istanbul ignore next @preserve */\n if (rx === 0 || ry === 0) {\n return getPointAtLineLength(x1, y1, x, y, distance);\n }\n const { PI, cos, sin } = Math;\n const sweepAngle = endAngle - startAngle;\n const xRot = ((angle % 360) + 360) % 360;\n const xRotRad = xRot * (PI / 180);\n const alpha = startAngle + sweepAngle * (distance / length);\n const ellipseComponentX = rx * cos(alpha);\n const ellipseComponentY = ry * sin(alpha);\n\n point = {\n x: cos(xRotRad) * ellipseComponentX - sin(xRotRad) * ellipseComponentY +\n center.x,\n y: sin(xRotRad) * ellipseComponentX + cos(xRotRad) * ellipseComponentY +\n center.y,\n };\n }\n }\n\n return point;\n};\n\n/**\n * Returns the extrema for an Arc segment in the following format:\n * [MIN_X, MIN_Y, MAX_X, MAX_Y]\n *\n * @see https://github.com/herrstrietzel/svg-pathdata-getbbox\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param RX the radius on X axis\n * @param RY the radius on Y axis\n * @param angle the ellipse rotation in degrees\n * @param LAF the large arc flag\n * @param SF the sweep flag\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the extrema of the Arc segment\n */\nconst getArcBBox = (\n x1: number,\n y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n x: number,\n y: number,\n) => {\n const { center, rx, ry, startAngle, endAngle } = getArcProps(\n x1,\n y1,\n RX,\n RY,\n angle,\n LAF,\n SF,\n x,\n y,\n );\n const deltaAngle = endAngle - startAngle;\n const { min, max, tan, atan2, PI } = Math;\n\n // circle/elipse center coordinates\n const { x: cx, y: cy } = center;\n\n // rotation to radians\n const alpha = (angle * PI) / 180;\n const tangent = tan(alpha);\n\n /**\n * find min/max from zeroes of directional derivative along x and y\n * along x axis\n */\n const theta = atan2(-ry * tangent, rx);\n const angle1 = theta;\n const angle2 = theta + PI;\n const angle3 = atan2(ry, rx * tangent);\n const angle4 = angle3 + PI;\n const xArray = [x];\n const yArray = [y];\n\n // inner bounding box\n let xMin = min(x1, x);\n let xMax = max(x1, x);\n let yMin = min(y1, y);\n let yMax = max(y1, y);\n\n // on path point close after start\n const angleAfterStart = endAngle - deltaAngle * 0.00001;\n const pP2 = arcPoint(cx, cy, rx, ry, alpha, angleAfterStart);\n\n // on path point close before end\n const angleBeforeEnd = endAngle - deltaAngle * 0.99999;\n const pP3 = arcPoint(cx, cy, rx, ry, alpha, angleBeforeEnd);\n\n /**\n * expected extremes\n * if leaving inner bounding box\n * (between segment start and end point)\n * otherwise exclude elliptic extreme points\n */\n\n // right\n if (pP2[0] > xMax || pP3[0] > xMax) {\n // get point for this theta\n const p1 = arcPoint(cx, cy, rx, ry, alpha, angle1);\n xArray.push(p1[0]);\n yArray.push(p1[1]);\n }\n\n // left\n if (pP2[0] < xMin || pP3[0] < xMin) {\n // get anti-symmetric point\n const p2 = arcPoint(cx, cy, rx, ry, alpha, angle2);\n xArray.push(p2[0]);\n yArray.push(p2[1]);\n }\n\n // top\n if (pP2[1] < yMin || pP3[1] < yMin) {\n // get anti-symmetric point\n const p4 = arcPoint(cx, cy, rx, ry, alpha, angle4);\n xArray.push(p4[0]);\n yArray.push(p4[1]);\n }\n\n // bottom\n if (pP2[1] > yMax || pP3[1] > yMax) {\n // get point for this theta\n const p3 = arcPoint(cx, cy, rx, ry, alpha, angle3);\n xArray.push(p3[0]);\n yArray.push(p3[1]);\n }\n\n xMin = min.apply([], xArray);\n yMin = min.apply([], yArray);\n xMax = max.apply([], xArray);\n yMax = max.apply([], yArray);\n\n return [xMin, yMin, xMax, yMax] as [number, number, number, number];\n};\n\nexport {\n angleBetween,\n arcLength,\n arcPoint,\n getArcBBox,\n getArcLength,\n getArcProps,\n getPointAtArcLength,\n};\n","import midPoint from \"./midPoint\";\nimport distanceSquareRoot from \"./distanceSquareRoot\";\n\n/**\n * Returns length for line segments (MoveTo, LineTo).\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the line segment length\n */\nconst getLineLength = (x1: number, y1: number, x2: number, y2: number) => {\n return distanceSquareRoot([x1, y1], [x2, y2]);\n};\n\n/**\n * Returns a point along the line segments (MoveTo, LineTo).\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance the distance to point in [0-1] range\n * @returns the point at length\n */\nconst getPointAtLineLength = (\n x1: number,\n y1: number,\n x2: number,\n y2: number,\n distance?: number,\n) => {\n let point = { x: x1, y: y1 };\n\n /* istanbul ignore else @preserve */\n if (typeof distance === \"number\") {\n const length = distanceSquareRoot([x1, y1], [x2, y2]);\n if (distance <= 0) {\n point = { x: x1, y: y1 };\n } else if (distance >= length) {\n point = { x: x2, y: y2 };\n } else {\n const [x, y] = midPoint([x1, y1], [x2, y2], distance / length);\n point = { x, y };\n }\n }\n return point;\n};\n\n/**\n * Returns bounding box for line segments (MoveTo, LineTo).\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance the distance to point in [0-1] range\n * @returns the extrema for line segments\n */\nconst getLineBBox = (x1: number, y1: number, x2: number, y2: number) => {\n const { min, max } = Math;\n\n return [min(x1, x2), min(y1, y2), max(x1, x2), max(y1, y2)] as [\n number,\n number,\n number,\n number,\n ];\n};\n\nexport { getLineBBox, getLineLength, getPointAtLineLength };\n","import { PointTuple } from \"../types\";\n\n/**\n * Returns the coordinates of a specified distance\n * ratio between two points.\n *\n * @param a the first point coordinates\n * @param b the second point coordinates\n * @param t the ratio\n * @returns the midpoint coordinates\n */\nconst midPoint = (a: PointTuple, b: PointTuple, t: number): PointTuple => {\n const [ax, ay] = a;\n const [bx, by] = b;\n return [ax + (bx - ax) * t, ay + (by - ay) * t];\n};\n\nexport default midPoint;\n","import { type PointTuple } from \"../types\";\n\n/**\n * Returns the square root of the distance\n * between two given points.\n *\n * @param a the first point coordinates\n * @param b the second point coordinates\n * @returns the distance value\n */\nconst distanceSquareRoot = (a: PointTuple, b: PointTuple) => {\n return Math.sqrt(\n (a[0] - b[0]) * (a[0] - b[0]) + (a[1] - b[1]) * (a[1] - b[1]),\n );\n};\n\nexport default distanceSquareRoot;\n","import type {\n CubicCoordinates,\n CubicPoints,\n DeriveCallback,\n DerivedCubicPoints,\n DerivedPoint,\n DerivedQuadPoints,\n PointTuple,\n QuadCoordinates,\n QuadPoints,\n} from \"../types\";\n\n/**\n * Tools from bezier.js by Mike 'Pomax' Kamermans\n * @see https://github.com/Pomax/bezierjs\n */\n\nconst Tvalues = [\n -0.0640568928626056260850430826247450385909,\n 0.0640568928626056260850430826247450385909,\n -0.1911188674736163091586398207570696318404,\n 0.1911188674736163091586398207570696318404,\n -0.3150426796961633743867932913198102407864,\n 0.3150426796961633743867932913198102407864,\n -0.4337935076260451384870842319133497124524,\n 0.4337935076260451384870842319133497124524,\n -0.5454214713888395356583756172183723700107,\n 0.5454214713888395356583756172183723700107,\n -0.6480936519369755692524957869107476266696,\n 0.6480936519369755692524957869107476266696,\n -0.7401241915785543642438281030999784255232,\n 0.7401241915785543642438281030999784255232,\n -0.8200019859739029219539498726697452080761,\n 0.8200019859739029219539498726697452080761,\n -0.8864155270044010342131543419821967550873,\n 0.8864155270044010342131543419821967550873,\n -0.9382745520027327585236490017087214496548,\n 0.9382745520027327585236490017087214496548,\n -0.9747285559713094981983919930081690617411,\n 0.9747285559713094981983919930081690617411,\n -0.9951872199970213601799974097007368118745,\n 0.9951872199970213601799974097007368118745,\n];\n\nconst Cvalues = [\n 0.1279381953467521569740561652246953718517,\n 0.1279381953467521569740561652246953718517,\n 0.1258374563468282961213753825111836887264,\n 0.1258374563468282961213753825111836887264,\n 0.121670472927803391204463153476262425607,\n 0.121670472927803391204463153476262425607,\n 0.1155056680537256013533444839067835598622,\n 0.1155056680537256013533444839067835598622,\n 0.1074442701159656347825773424466062227946,\n 0.1074442701159656347825773424466062227946,\n 0.0976186521041138882698806644642471544279,\n 0.0976186521041138882698806644642471544279,\n 0.086190161531953275917185202983742667185,\n 0.086190161531953275917185202983742667185,\n 0.0733464814110803057340336152531165181193,\n 0.0733464814110803057340336152531165181193,\n 0.0592985849154367807463677585001085845412,\n 0.0592985849154367807463677585001085845412,\n 0.0442774388174198061686027482113382288593,\n 0.0442774388174198061686027482113382288593,\n 0.0285313886289336631813078159518782864491,\n 0.0285313886289336631813078159518782864491,\n 0.0123412297999871995468056670700372915759,\n 0.0123412297999871995468056670700372915759,\n];\n\n/**\n * @param points\n * @returns\n */\nconst deriveBezier = (points: QuadPoints | CubicPoints) => {\n const dpoints = [] as (DerivedCubicPoints | DerivedQuadPoints)[];\n for (let p = points, d = p.length, c = d - 1; d > 1; d -= 1, c -= 1) {\n const list = [] as unknown as DerivedCubicPoints | DerivedQuadPoints;\n for (let j = 0; j < c; j += 1) {\n list.push({\n x: c * (p[j + 1].x - p[j].x),\n y: c * (p[j + 1].y - p[j].y),\n t: 0,\n });\n }\n dpoints.push(list);\n p = list;\n }\n return dpoints;\n};\n\n/**\n * @param points\n * @param t\n */\nconst computeBezier = (\n points: DerivedQuadPoints | DerivedCubicPoints,\n t: number,\n) => {\n // shortcuts\n /* istanbul ignore next @preserve */\n if (t === 0) {\n points[0].t = 0;\n return points[0];\n }\n\n const order = points.length - 1;\n\n /* istanbul ignore next @preserve */\n if (t === 1) {\n points[order].t = 1;\n return points[order];\n }\n\n const mt = 1 - t;\n let p = points as typeof points | [\n DerivedPoint,\n DerivedPoint,\n DerivedPoint,\n DerivedPoint,\n ];\n\n // constant?\n /* istanbul ignore next @preserve */\n if (order === 0) {\n points[0].t = t;\n return points[0];\n }\n\n // linear?\n /* istanbul ignore else @preserve */\n if (order === 1) {\n return {\n x: mt * p[0].x + t * p[1].x,\n y: mt * p[0].y + t * p[1].y,\n t,\n };\n }\n\n // quadratic/cubic curve?\n const mt2 = mt * mt;\n const t2 = t * t;\n let a = 0;\n let b = 0;\n let c = 0;\n let d = 0;\n /* istanbul ignore else @preserve */\n if (order === 2) {\n p = [p[0], p[1], p[2], { x: 0, y: 0 } as DerivedPoint];\n a = mt2;\n b = mt * t * 2;\n c = t2;\n } else if (order === 3) {\n a = mt2 * mt;\n b = mt2 * t * 3;\n c = mt * t2 * 3;\n d = t * t2;\n }\n return {\n x: a * p[0].x + b * p[1].x + c * p[2].x + d * p[3].x,\n y: a * p[0].y + b * p[1].y + c * p[2].y + d * p[3].y,\n t,\n };\n};\n\nconst calculateBezier = (derivativeFn: DeriveCallback, t: number) => {\n const d = derivativeFn(t);\n const l = d.x * d.x + d.y * d.y;\n\n return Math.sqrt(l);\n};\n\nconst bezierLength = (derivativeFn: DeriveCallback) => {\n const z = 0.5;\n const len = Tvalues.length;\n\n let sum = 0;\n\n for (let i = 0, t; i < len; i++) {\n t = z * Tvalues[i] + z;\n sum += Cvalues[i] * calculateBezier(derivativeFn, t);\n }\n return z * sum;\n};\n\n/**\n * Returns the length of CubicBezier / Quad segment.\n * @param curve cubic / quad bezier segment\n */\nconst getBezierLength = (curve: CubicCoordinates | QuadCoordinates) => {\n const points = [] as unknown as CubicPoints | QuadPoints;\n for (let idx = 0, len = curve.length, step = 2; idx < len; idx += step) {\n points.push({\n x: curve[idx],\n y: curve[idx + 1],\n });\n }\n const dpoints = deriveBezier(points);\n return bezierLength((t: number) => {\n return computeBezier(dpoints[0], t);\n });\n};\n\n// Precision for consider cubic polynom as quadratic one\nconst CBEZIER_MINMAX_EPSILON = 0.00000001;\n\n/**\n * Returns the most extreme points in a Quad Bezier segment.\n * @param A an array which consist of X/Y values\n */\n// https://github.com/kpym/SVGPathy/blob/acd1a50c626b36d81969f6e98e8602e128ba4302/lib/box.js#L89\nconst minmaxQ = ([v1, cp, v2]: [number, number, number]) => {\n const min = Math.min(v1, v2);\n const max = Math.max(v1, v2);\n\n /* istanbul ignore next @preserve */\n if (cp >= v1 ? v2 >= cp : v2 <= cp) {\n // if no extremum in ]0,1[\n return [min, max] as PointTuple;\n }\n\n // check if the extremum E is min or max\n const E = (v1 * v2 - cp * cp) / (v1 - 2 * cp + v2);\n return (E < min ? [E, max] : [min, E]) as PointTuple;\n};\n\n/**\n * Returns the most extreme points in a Cubic Bezier segment.\n * @param A an array which consist of X/Y values\n * @see https://github.com/kpym/SVGPathy/blob/acd1a50c626b36d81969f6e98e8602e128ba4302/lib/box.js#L127\n */\nconst minmaxC = ([v1, cp1, cp2, v2]: [number, number, number, number]) => {\n const K = v1 - 3 * cp1 + 3 * cp2 - v2;\n\n // if the polynomial is (almost) quadratic and not cubic\n /* istanbul ignore next @preserve */\n if (Math.abs(K) < CBEZIER_MINMAX_EPSILON) {\n if (v1 === v2 && v1 === cp1) {\n // no curve, point targeting same location\n return [v1, v2] as PointTuple;\n }\n\n return minmaxQ([v1, -0.5 * v1 + 1.5 * cp1, v1 - 3 * cp1 + 3 * cp2]);\n }\n\n // the reduced discriminant of the derivative\n const T = -v1 * cp2 + v1 * v2 - cp1 * cp2 - cp1 * v2 + cp1 * cp1 + cp2 * cp2;\n\n // if the polynomial is monotone in [0,1]\n if (T <= 0) {\n return [Math.min(v1, v2), Math.max(v1, v2)] as PointTuple;\n }\n const S = Math.sqrt(T);\n\n // potential extrema\n let min = Math.min(v1, v2);\n let max = Math.max(v1, v2);\n\n const L = v1 - 2 * cp1 + cp2;\n // check local extrema\n for (let R = (L + S) / K, i = 1; i <= 2; R = (L - S) / K, i++) {\n // istanbul ignore next @preserve\n if (R > 0 && R < 1) {\n // if the extrema is for R in [0,1]\n const Q = v1 * (1 - R) * (1 - R) * (1 - R) +\n cp1 * 3 * (1 - R) * (1 - R) * R + cp2 * 3 * (1 - R) * R * R +\n v2 * R * R * R;\n if (Q < min) {\n min = Q;\n }\n if (Q > max) {\n max = Q;\n }\n }\n }\n\n return [min, max] as PointTuple;\n};\n\nexport {\n bezierLength,\n calculateBezier,\n CBEZIER_MINMAX_EPSILON,\n computeBezier,\n Cvalues,\n deriveBezier,\n getBezierLength,\n minmaxC,\n minmaxQ,\n Tvalues,\n};\n","import { getBezierLength, minmaxC } from \"./bezier\";\nimport { type CubicCoordinates } from \"../types\";\n\n/**\n * Returns a point at a given length of a CubicBezier segment.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param t a [0-1] ratio\n * @returns the point at cubic-bezier segment length\n */\nconst getPointAtCubicSegmentLength = (\n [x1, y1, c1x, c1y, c2x, c2y, x2, y2]: CubicCoordinates,\n t: number,\n) => {\n const t1 = 1 - t;\n return {\n x: t1 ** 3 * x1 + 3 * t1 ** 2 * t * c1x + 3 * t1 * t ** 2 * c2x +\n t ** 3 * x2,\n y: t1 ** 3 * y1 + 3 * t1 ** 2 * t * c1y + 3 * t1 * t ** 2 * c2y +\n t ** 3 * y2,\n };\n};\n\n/**\n * Returns the length of a CubicBezier segment.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the CubicBezier segment length\n */\nconst getCubicLength = (\n x1: number,\n y1: number,\n c1x: number,\n c1y: number,\n c2x: number,\n c2y: number,\n x2: number,\n y2: number,\n) => {\n return getBezierLength([x1, y1, c1x, c1y, c2x, c2y, x2, y2]);\n};\n\n/**\n * Returns the point along a CubicBezier segment at a given distance.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance the distance to look at\n * @returns the point at CubicBezier length\n */\nconst getPointAtCubicLength = (\n x1: number,\n y1: number,\n c1x: number,\n c1y: number,\n c2x: number,\n c2y: number,\n x2: number,\n y2: number,\n distance?: number,\n) => {\n const distanceIsNumber = typeof distance === \"number\";\n let point = { x: x1, y: y1 };\n /* istanbul ignore else @preserve */\n if (distanceIsNumber) {\n const currentLength = getBezierLength([x1, y1, c1x, c1y, c2x, c2y, x2, y2]);\n if (distance <= 0) {\n // first point already defined\n } else if (distance >= currentLength) {\n point = { x: x2, y: y2 };\n } else {\n point = getPointAtCubicSegmentLength(\n [x1, y1, c1x, c1y, c2x, c2y, x2, y2],\n distance / currentLength,\n );\n }\n }\n return point;\n};\n\n/**\n * Returns the boundig box of a CubicBezier segment in the following format:\n * [MIN_X, MIN_Y, MAX_X, MAX_Y]\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the extrema of the CubicBezier segment\n */\nconst getCubicBBox = (\n x1: number,\n y1: number,\n c1x: number,\n c1y: number,\n c2x: number,\n c2y: number,\n x2: number,\n y2: number,\n) => {\n const cxMinMax = minmaxC([x1, c1x, c2x, x2]);\n const cyMinMax = minmaxC([y1, c1y, c2y, y2]);\n\n return [cxMinMax[0], cyMinMax[0], cxMinMax[1], cyMinMax[1]] as [\n number,\n number,\n number,\n number,\n ];\n};\n\nexport {\n getCubicBBox,\n getCubicLength,\n getPointAtCubicLength,\n getPointAtCubicSegmentLength,\n};\n","import { getBezierLength, minmaxQ } from \"./bezier\";\nimport { type QuadCoordinates } from \"../types\";\n\n/**\n * Returns the {x,y} coordinates of a point at a\n * given length of a quadratic-bezier segment.\n *\n * @see https://github.com/substack/point-at-length\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param cx the control point X\n * @param cy the control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param t a [0-1] ratio\n * @returns the requested {x,y} coordinates\n */\nconst getPointAtQuadSegmentLength = (\n [x1, y1, cx, cy, x2, y2]: QuadCoordinates,\n t: number,\n) => {\n const t1 = 1 - t;\n return {\n x: t1 ** 2 * x1 + 2 * t1 * t * cx + t ** 2 * x2,\n y: t1 ** 2 * y1 + 2 * t1 * t * cy + t ** 2 * y2,\n };\n};\n\n/**\n * Returns the length of a QuadraticBezier segment.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param cx the control point X\n * @param cy the control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the QuadraticBezier segment length\n */\nconst getQuadLength = (\n x1: number,\n y1: number,\n cx: number,\n cy: number,\n x2: number,\n y2: number,\n) => {\n return getBezierLength([x1, y1, cx, cy, x2, y2]);\n};\n\n/**\n * Returns the point along a QuadraticBezier segment at a given distance.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param cx the control point X\n * @param cy the control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance the distance to look at\n * @returns the point at QuadraticBezier length\n */\nconst getPointAtQuadLength = (\n x1: number,\n y1: number,\n cx: number,\n cy: number,\n x2: number,\n y2: number,\n distance?: number,\n) => {\n const distanceIsNumber = typeof distance === \"number\";\n let point = { x: x1, y: y1 };\n\n /* istanbul ignore else @preserve */\n if (distanceIsNumber) {\n const currentLength = getBezierLength([x1, y1, cx, cy, x2, y2]);\n if (distance <= 0) {\n // first point already defined\n } else if (distance >= currentLength) {\n point = { x: x2, y: y2 };\n } else {\n point = getPointAtQuadSegmentLength(\n [x1, y1, cx, cy, x2, y2],\n distance / currentLength,\n );\n }\n }\n return point;\n};\n\n/**\n * Returns the boundig box of a QuadraticBezier segment in the following format:\n * [MIN_X, MIN_Y, MAX_X, MAX_Y]\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param cx the control point X\n * @param cy the control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the extrema of the QuadraticBezier segment\n */\nconst getQuadBBox = (\n x1: number,\n y1: number,\n cx: number,\n cy: number,\n x2: number,\n y2: number,\n) => {\n const cxMinMax = minmaxQ([x1, cx, x2]);\n const cyMinMax = minmaxQ([y1, cy, y2]);\n return [cxMinMax[0], cyMinMax[0], cxMinMax[1], cyMinMax[1]] as [\n number,\n number,\n number,\n number,\n ];\n};\n\nexport {\n getPointAtQuadLength,\n getPointAtQuadSegmentLength,\n getQuadBBox,\n getQuadLength,\n};\n","import distanceSquareRoot from \"./distanceSquareRoot\";\nimport { type PointTuple } from \"../types\";\n\n/**\n * d3-polygon-area\n * https://github.com/d3/d3-polygon\n *\n * Returns the area of a polygon.\n *\n * @param polygon an array of coordinates\n * @returns the polygon area\n */\nconst polygonArea = (polygon: PointTuple[]) => {\n const n = polygon.length;\n let i = -1;\n let a: PointTuple;\n let b = polygon[n - 1];\n let area = 0;\n\n /* eslint-disable-next-line */\n while (++i < n) {\n a = b;\n b = polygon[i];\n area += a[1] * b[0] - a[0] * b[1];\n }\n\n return area / 2;\n};\n\n/**\n * d3-polygon-length\n * https://github.com/d3/d3-polygon\n *\n * Returns the perimeter of a polygon.\n *\n * @param polygon an array of coordinates\n * @returns the polygon length\n */\nconst polygonLength = (polygon: PointTuple[]) => {\n return polygon.reduce((length, point, i) => {\n if (i) {\n return length + distanceSquareRoot(polygon[i - 1], point);\n }\n return 0;\n }, 0);\n};\n\nexport { polygonArea, polygonLength };\n","/** Segment params length */\nconst paramsCount = {\n a: 7,\n c: 6,\n h: 1,\n l: 2,\n m: 2,\n r: 4,\n q: 4,\n s: 4,\n t: 2,\n v: 1,\n z: 0,\n};\n\nexport default paramsCount;\n","import paramsCount from \"./paramsCount\";\nimport PathParser from \"./pathParser\";\nimport type { PathCommand, PathSegment, RelativeCommand } from \"../types\";\n\n/**\n * Breaks the parsing of a pathString once a segment is finalized.\n *\n * @param path the `PathParser` instance\n */\nconst finalizeSegment = (path: PathParser) => {\n let pathCommand = path.pathValue[path.segmentStart] as PathCommand;\n let relativeCommand = pathCommand.toLowerCase() as RelativeCommand;\n const { data } = path;\n\n while (data.length >= paramsCount[relativeCommand]) {\n // overloaded `moveTo`\n // https://github.com/rveciana/svg-path-properties/blob/master/src/parse.ts\n if (relativeCommand === \"m\" && data.length > 2) {\n path.segments.push(\n [pathCommand as PathCommand | number].concat(\n data.splice(0, 2) as number[],\n ) as PathSegment,\n );\n relativeCommand = \"l\";\n pathCommand = pathCommand === \"m\" ? \"l\" : \"L\";\n } else {\n path.segments.push(\n [pathCommand as PathCommand | number].concat(\n data.splice(0, paramsCount[relativeCommand]) as number[],\n ) as PathSegment,\n );\n }\n\n if (!paramsCount[relativeCommand]) {\n break;\n }\n }\n};\nexport default finalizeSegment;\n","const error = \"SVGPathCommander Error\";\nexport default error;\n","import error from \"./error\";\nimport type PathParser from \"./pathParser\";\n\n/**\n * Validates an A (arc-to) specific path command value.\n * Usually a `large-arc-flag` or `sweep-flag`.\n *\n * @param path the `PathParser` instance\n */\nconst scanFlag = (path: PathParser) => {\n const { index, pathValue } = path;\n const code = pathValue.charCodeAt(index);\n\n if (code === 0x30 /* 0 */) {\n path.param = 0;\n path.index += 1;\n return;\n }\n\n if (code === 0x31 /* 1 */) {\n path.param = 1;\n path.index += 1;\n return;\n }\n\n path.err = `${error}: invalid Arc flag \"${\n pathValue[index]\n }\", expecting 0 or 1 at index ${index}`;\n};\n\nexport default scanFlag;\n","import { DigitNumber } from \"../types\";\n\n/**\n * Checks if a character is a digit.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isDigit = (code: number): code is DigitNumber => {\n return code >= 48 && code <= 57; // 0..9\n};\nexport default isDigit;\n","const invalidPathValue = \"Invalid path value\";\nexport default invalidPathValue;\n","import isDigit from \"./isDigit\";\nimport invalidPathValue from \"./invalidPathValue\";\nimport error from \"./error\";\nimport type PathParser from \"./pathParser\";\n\n/**\n * Validates every character of the path string,\n * every path command, negative numbers or floating point numbers.\n *\n * @param path the `PathParser` instance\n */\nconst scanParam = (path: PathParser) => {\n const { max, pathValue, index: start } = path;\n let index = start;\n let zeroFirst = false;\n let hasCeiling = false;\n let hasDecimal = false;\n let hasDot = false;\n let ch;\n\n if (index >= max) {\n path.err =\n `${error}: ${invalidPathValue} at index ${index}, \"pathValue\" is missing param`;\n return;\n }\n ch = pathValue.charCodeAt(index);\n\n if (ch === 0x2b /* + */ || ch === 0x2d /* - */) {\n index += 1;\n // ch = (index < max) ? pathValue.charCodeAt(index) : 0;\n ch = pathValue.charCodeAt(index);\n }\n\n // This logic is shamelessly borrowed from Esprima\n // https://github.com/ariya/esprimas\n if (!isDigit(ch) && ch !== 0x2e /* . */) {\n // path.err = 'SvgPath: param should start with 0..9 or `.` (at pos ' + index + ')';\n path.err = `${error}: ${invalidPathValue} at index ${index}, \"${\n pathValue[index]\n }\" is not a number`;\n return;\n }\n\n if (ch !== 0x2e /* . */) {\n zeroFirst = ch === 0x30 /* 0 */;\n index += 1;\n\n ch = pathValue.charCodeAt(index);\n\n if (zeroFirst && index < max) {\n // decimal number starts with '0' such as '09' is illegal.\n if (ch && isDigit(ch)) {\n // path.err = 'SvgPath: numbers started with `0` such as `09`\n // are illegal (at pos ' + start + ')';\n path.err = `${error}: ${invalidPathValue} at index ${start}, \"${\n pathValue[start]\n }\" illegal number`;\n return;\n }\n }\n\n while (index < max && isDigit(pathValue.charCodeAt(index))) {\n index += 1;\n hasCeiling = true;\n }\n\n ch = pathValue.charCodeAt(index);\n }\n\n if (ch === 0x2e /* . */) {\n hasDot = true;\n index += 1;\n while (isDigit(pathValue.charCodeAt(index))) {\n index += 1;\n hasDecimal = true;\n }\n\n ch = pathValue.charCodeAt(index);\n }\n\n if (ch === 0x65 /* e */ || ch === 0x45 /* E */) {\n if (hasDot && !hasCeiling && !hasDecimal) {\n path.err = `${error}: ${invalidPathValue} at index ${index}, \"${\n pathValue[index]\n }\" invalid float exponent`;\n return;\n }\n\n index += 1;\n\n ch = pathValue.charCodeAt(index);\n\n if (ch === 0x2b /* + */ || ch === 0x2d /* - */) {\n index += 1;\n }\n if (index < max && isDigit(pathValue.charCodeAt(index))) {\n while (index < max && isDigit(pathValue.charCodeAt(index))) {\n index += 1;\n }\n } else {\n path.err = `${error}: ${invalidPathValue} at index ${index}, \"${\n pathValue[index]\n }\" invalid integer exponent`;\n return;\n }\n }\n\n path.index = index;\n path.param = +path.pathValue.slice(start, index);\n};\nexport default scanParam;\n","import type { SpaceNumber } from \"../types\";\n\n/**\n * Checks if the character is a space.\n *\n * @param ch the character to check\n * @returns check result\n */\n\nconst isSpace = (ch: number): ch is SpaceNumber => {\n const allSpaces = [\n // Special spaces\n 0x1680,\n 0x180e,\n 0x2000,\n 0x2001,\n 0x2002,\n 0x2003,\n 0x2004,\n 0x2005,\n 0x2006,\n 0x2007,\n 0x2008,\n 0x2009,\n 0x200a,\n 0x202f,\n 0x205f,\n 0x3000,\n 0xfeff,\n // Line terminators\n 0x0a,\n 0x0d,\n 0x2028,\n 0x2029,\n // White spaces\n 0x20,\n 0x09,\n 0x0b,\n 0x0c,\n 0xa0,\n ];\n\n return allSpaces.includes(ch);\n};\nexport default isSpace;\n","import isSpace from \"./isSpace\";\nimport type PathParser from \"./pathParser\";\n\n/**\n * Points the parser to the next character in the\n * path string every time it encounters any kind of\n * space character.\n *\n * @param path the `PathParser` instance\n */\nconst skipSpaces = (path: PathParser) => {\n const { pathValue, max } = path;\n while (path.index < max && isSpace(pathValue.charCodeAt(path.index))) {\n path.index += 1;\n }\n};\nexport default skipSpaces;\n","import type { PathCommandNumber } from \"../types\";\n\n/**\n * Checks if the character is a path command.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isPathCommand = (code: number): code is PathCommandNumber => {\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy\n switch (code | 0x20) {\n case 0x6d /* m */:\n case 0x7a /* z */:\n case 0x6c /* l */:\n case 0x68 /* h */:\n case 0x76 /* v */:\n case 0x63 /* c */:\n case 0x73 /* s */:\n case 0x71 /* q */:\n case 0x74 /* t */:\n case 0x61 /* a */:\n // case 0x72/* r */:\n return true;\n default:\n return false;\n }\n};\nexport default isPathCommand;\n","import isDigit from \"./isDigit\";\nimport type { DigitNumber } from \"../types\";\n\n/**\n * Checks if the character is or belongs to a number.\n * [0-9]|+|-|.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isDigitStart = (\n code: number,\n): code is DigitNumber | 0x2b | 0x2d | 0x2e => {\n return isDigit(code) /* 0..9 */ || code === 0x2b /* + */ ||\n code === 0x2d /* - */ || code === 0x2e; /* . */\n};\nexport default isDigitStart;\n","/**\n * Checks if the character is an A (arc-to) path command.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isArcCommand = (code: number): code is 0x61 => {\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy\n return (code | 0x20) === 0x61;\n};\nexport default isArcCommand;\n","/**\n * Checks if the character is a MoveTo command.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isMoveCommand = (code: number): code is 0x6d | 0x4d => {\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy\n switch (code | 0x20) {\n case 0x6d /* m */:\n case 0x4d /* M */:\n return true;\n default:\n return false;\n }\n};\nexport default isMoveCommand;\n","import finalizeSegment from \"./finalizeSegment\";\nimport paramCounts from \"./paramsCount\";\nimport scanFlag from \"./scanFlag\";\nimport scanParam from \"./scanParam\";\nimport skipSpaces from \"./skipSpaces\";\nimport isPathCommand from \"./isPathCommand\";\nimport isDigitStart from \"./isDigitStart\";\nimport isArcCommand from \"./isArcCommand\";\nimport isMoveCommand from \"./isMoveCommand\";\nimport invalidPathValue from \"./invalidPathValue\";\nimport error from \"./error\";\n\nimport type PathParser from \"./pathParser\";\nimport type { PathSegment, RelativeCommand } from \"../types\";\n\n/**\n * Scans every character in the path string to determine\n * where a segment starts and where it ends.\n *\n * @param path the `PathParser` instance\n */\nconst scanSegment = (path: PathParser) => {\n const { max, pathValue, index, segments } = path;\n const cmdCode = pathValue.charCodeAt(index);\n const reqParams =\n paramCounts[pathValue[index].toLowerCase() as RelativeCommand];\n\n path.segmentStart = index;\n\n // segments always start with a path command\n if (!isPathCommand(cmdCode)) {\n path.err = `${error}: ${invalidPathValue} \"${\n pathValue[index]\n }\" is not a path command at index ${index}`;\n return;\n }\n\n // after a Z segment, we only expect a MoveTo path command\n const lastSegment = segments[segments.length - 1] as PathSegment | undefined;\n if (\n !isMoveCommand(cmdCode) && lastSegment?.[0]?.toLocaleLowerCase() === \"z\"\n ) {\n path.err = `${error}: ${invalidPathValue} \"${\n pathValue[index]\n }\" is not a MoveTo path command at index ${index}`;\n return;\n }\n\n path.index += 1;\n skipSpaces(path);\n\n path.data = [];\n\n if (!reqParams) {\n // Z\n finalizeSegment(path);\n return;\n }\n\n for (;;) {\n for (let i = reqParams; i > 0; i -= 1) {\n if (isArcCommand(cmdCode) && (i === 3 || i === 4)) scanFlag(path);\n else scanParam(path);\n\n if (path.err.length) {\n return;\n }\n path.data.push(path.param);\n\n skipSpaces(path);\n\n // after ',' param is mandatory\n if (\n path.index < max && pathValue.charCodeAt(path.index) === 0x2c /* , */\n ) {\n path.index += 1;\n skipSpaces(path);\n }\n }\n\n if (path.index >= path.max) {\n break;\n }\n\n // Stop on next segment\n if (!isDigitStart(pathValue.charCodeAt(path.index))) {\n break;\n }\n }\n\n finalizeSegment(path);\n};\nexport default scanSegment;\n","import type { PathArray, PathSegment } from \"../types\";\n\n/**\n * The `PathParser` is used by the `parsePathString` static method\n * to generate a `pathArray`.\n *\n * @param pathString\n */\nexport default class PathParser {\n declare segments: PathArray | PathSegment[];\n declare pathValue: string;\n declare max: number;\n declare index: number;\n declare param: number;\n declare segmentStart: number;\n declare data: (string | number)[];\n declare err: string;\n\n constructor(pathString: string) {\n this.segments = [];\n this.pathValue = pathString;\n this.max = pathString.length;\n this.index = 0;\n this.param = 0.0;\n this.segmentStart = 0;\n this.data = [];\n this.err = \"\";\n }\n}\n","import scanSegment from \"./scanSegment\";\nimport skipSpaces from \"./skipSpaces\";\nimport PathParser from \"./pathParser\";\nimport type { PathArray } from \"../types\";\n\n/**\n * Parses a path string value and returns an array\n * of segments we like to call `pathArray`.\n *\n * @param pathInput the string to be parsed\n * @returns the resulted `pathArray` or error string\n */\nconst parsePathString = (pathInput: string | T) => {\n if (typeof pathInput !== \"string\") {\n return pathInput.slice(0) as typeof pathInput;\n }\n\n const path = new PathParser(pathInput);\n\n skipSpaces(path);\n\n while (path.index < path.max && !path.err.length) {\n scanSegment(path);\n }\n\n // handle valid paths first\n // handle errors second\n if (!path.err.length) {\n if (path.segments.length) {\n /**\n * force absolute first M\n * getPathBBox calculation requires first segment to be absolute\n * @see https://github.com/thednp/svg-path-commander/pull/49\n */\n path.segments[0][0] = \"M\";\n }\n } else {\n throw TypeError(path.err);\n }\n\n return path.segments as PathArray;\n};\n\nexport default parsePathString;\n","import type {\n AbsoluteCommand,\n AbsoluteSegment,\n ASegment,\n CSegment,\n HSegment,\n LSegment,\n MSegment,\n PathSegment,\n QSegment,\n SSegment,\n TSegment,\n VSegment,\n} from \"../types\";\n\n/**\n * Returns an absolute segment of a `PathArray` object.\n *\n * @param segment the segment object\n * @param index the segment index\n * @param lastX the last known X value\n * @param lastY the last known Y value\n * @returns the absolute segment\n */\nconst absolutizeSegment = (\n segment: PathSegment,\n index: number,\n lastX: number,\n lastY: number,\n) => {\n const [pathCommand] = segment;\n const absCommand = pathCommand.toUpperCase() as AbsoluteCommand;\n const isAbsolute = absCommand === pathCommand;\n\n /* istanbul ignore else @preserve */\n if (index === 0 || isAbsolute) return segment as MSegment | AbsoluteSegment;\n // const values = segment.slice(1) as number[];\n if (absCommand === \"A\") {\n return [\n absCommand,\n segment[1],\n segment[2],\n segment[3],\n segment[4],\n segment[5],\n (segment as ASegment)[6] + lastX,\n (segment as ASegment)[7] + lastY,\n ] as ASegment;\n } else if (absCommand === \"V\") {\n return [absCommand, (segment as VSegment)[1] + lastY] as VSegment;\n } else if (absCommand === \"H\") {\n return [absCommand, (segment as HSegment)[1] + lastX] as HSegment;\n } else if (absCommand === \"L\") {\n return [\n absCommand,\n (segment as LSegment)[1] + lastX,\n (segment as LSegment)[2] + lastY,\n ] as LSegment;\n } else {\n // use brakets for `eslint: no-case-declaration`\n // https://stackoverflow.com/a/50753272/803358\n const absValues = [] as number[];\n const seglen = segment.length;\n for (let j = 1; j < seglen; j += 1) {\n absValues.push((segment[j] as number) + (j % 2 ? lastX : lastY));\n }\n // for c, s, q, t\n return [absCommand as typeof absCommand | number].concat(absValues) as\n | MSegment\n | QSegment\n | TSegment\n | SSegment\n | CSegment;\n }\n};\nexport default absolutizeSegment;\n","// import paramsParser from '../parser/paramsParser';\nimport type {\n AbsoluteCommand,\n IteratorCallback,\n PathArray,\n PathCommand,\n PathSegment,\n} from \"../types\";\n\nconst iterate = (\n path: PathArray,\n iterator: IteratorCallback,\n) => {\n let pathLen = path.length;\n let segment: PathSegment;\n let pathCommand = \"M\" as PathCommand;\n let absCommand = \"M\" as AbsoluteCommand;\n let isRelative = false;\n let x = 0;\n let y = 0;\n let mx = 0;\n let my = 0;\n let segLen = 0;\n\n for (let i = 0; i < pathLen; i += 1) {\n segment = path[i];\n [pathCommand] = segment;\n segLen = segment.length;\n absCommand = pathCommand.toUpperCase() as AbsoluteCommand;\n isRelative = absCommand !== pathCommand;\n\n const iteratorResult = iterator(segment, i, x, y);\n // some methods like getPointAtLength would like to break\n // when task is complete\n if (iteratorResult === false) {\n break;\n }\n\n // segment = path[i];\n if (absCommand === \"Z\") {\n x = mx;\n y = my;\n } else if (absCommand === \"H\") {\n x = (segment[1] as number) + (isRelative ? x : 0);\n } else if (absCommand === \"V\") {\n y = (segment[1] as number) + (isRelative ? y : 0);\n } else {\n x = (segment[segLen - 2] as number) + (isRelative ? x : 0);\n y = (segment[segLen - 1] as number) + (isRelative ? y : 0);\n\n if (absCommand === \"M\") {\n mx = x;\n my = y;\n }\n }\n\n if (iteratorResult) {\n path[i] = iteratorResult;\n if (iteratorResult[0] === \"C\") {\n pathLen = path.length;\n }\n }\n }\n return path as T;\n};\n\nexport default iterate;\n","import parsePathString from \"../parser/parsePathString\";\nimport absolutizeSegment from \"../process/absolutizeSegment\";\nimport type { AbsoluteArray, PathArray } from \"../types\";\nimport iterate from \"../process/iterate\";\n\n/**\n * Parses a path string value or object and returns an array\n * of segments, all converted to absolute values.\n *\n * @param pathInput the path string | object\n * @returns the resulted `pathArray` with absolute values\n */\nconst pathToAbsolute = (pathInput: string | PathArray) => {\n const path = parsePathString(pathInput);\n\n return iterate(path, absolutizeSegment);\n};\nexport default pathToAbsolute;\n","import type {\n aSegment,\n cSegment,\n hSegment,\n lSegment,\n MSegment,\n PathSegment,\n qSegment,\n RelativeCommand,\n RelativeSegment,\n sSegment,\n tSegment,\n vSegment,\n} from \"../types\";\n\n/**\n * Returns a relative segment of a `PathArray` object.\n *\n * @param segment the segment object\n * @param index the segment index\n * @param lastX the last known X value\n * @param lastY the last known Y value\n * @returns the relative segment\n */\nconst relativizeSegment = (\n segment: PathSegment,\n index: number,\n lastX: number,\n lastY: number,\n) => {\n const [pathCommand] = segment;\n const relCommand = pathCommand.toLowerCase() as RelativeCommand;\n const isRelative = pathCommand === relCommand;\n\n /* istanbul ignore else @preserve */\n if (index === 0 || isRelative) return segment as MSegment | RelativeSegment;\n\n if (relCommand === \"a\") {\n return [\n relCommand,\n segment[1],\n segment[2],\n segment[3],\n segment[4],\n segment[5],\n (segment as aSegment)[6] - lastX,\n (segment as aSegment)[7] - lastY,\n ] as aSegment;\n } else if (relCommand === \"v\") {\n return [relCommand, (segment as vSegment)[1] - lastY] as vSegment;\n } else if (relCommand === \"h\") {\n return [relCommand, (segment as hSegment)[1] - lastX] as hSegment;\n } else if (relCommand === \"l\") {\n return [\n relCommand,\n (segment as lSegment)[1] - lastX,\n (segment as lSegment)[2] - lastY,\n ] as lSegment;\n } else {\n // use brakets for `eslint: no-case-declaration`\n // https://stackoverflow.com/a/50753272/803358\n const relValues = [] as number[];\n const seglen = segment.length;\n for (let j = 1; j < seglen; j += 1) {\n relValues.push((segment[j] as number) - (j % 2 ? lastX : lastY));\n }\n // for c, s, q, t\n return [relCommand as RelativeCommand | number].concat(relValues) as\n | qSegment\n | tSegment\n | sSegment\n | cSegment;\n }\n};\n\nexport default relativizeSegment;\n","import type { PathArray, RelativeArray } from \"../types\";\nimport parsePathString from \"../parser/parsePathString\";\nimport iterate from \"../process/iterate\";\nimport relativizeSegment from \"../process/relativizeSegment\";\n\n/**\n * Parses a path string value or object and returns an array\n * of segments, all converted to relative values.\n *\n * @param pathInput the path string | object\n * @returns the resulted `pathArray` with relative values\n */\nconst pathToRelative = (pathInput: string | PathArray): RelativeArray => {\n const path = parsePathString(pathInput);\n\n return iterate(path, relativizeSegment);\n};\nexport default pathToRelative;\n","/**\n * Returns an {x,y} vector rotated by a given\n * angle in radian.\n *\n * @param x the initial vector x\n * @param y the initial vector y\n * @param rad the radian vector angle\n * @returns the rotated vector\n */\nconst rotateVector = (\n x: number,\n y: number,\n rad: number,\n): { x: number; y: number } => {\n const { sin, cos } = Math;\n const X = x * cos(rad) - y * sin(rad);\n const Y = x * sin(rad) + y * cos(rad);\n return { x: X, y: Y };\n};\n\nexport default rotateVector;\n","import rotateVector from \"../math/rotateVector\";\n\n/**\n * Converts A (arc-to) segments to C (cubic-bezier-to).\n *\n * For more information of where this math came from visit:\n * http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes\n *\n * @param X1 the starting x position\n * @param Y1 the starting y position\n * @param RX x-radius of the arc\n * @param RY y-radius of the arc\n * @param angle x-axis-rotation of the arc\n * @param LAF large-arc-flag of the arc\n * @param SF sweep-flag of the arc\n * @param X2 the ending x position\n * @param Y2 the ending y position\n * @param recursive the parameters needed to split arc into 2 segments\n * @return the resulting cubic-bezier segment(s)\n */\nconst arcToCubic = (\n X1: number,\n Y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n X2: number,\n Y2: number,\n recursive?: [number, number, number, number],\n): number[] => {\n let x1 = X1;\n let y1 = Y1;\n let rx = RX;\n let ry = RY;\n let x2 = X2;\n let y2 = Y2;\n // for more information of where this Math came from visit:\n // http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes\n const d120 = (Math.PI * 120) / 180;\n\n const rad = (Math.PI / 180) * (+angle || 0);\n let res = [] as number[];\n let xy;\n let f1;\n let f2;\n let cx;\n let cy;\n\n if (!recursive) {\n xy = rotateVector(x1, y1, -rad);\n x1 = xy.x;\n y1 = xy.y;\n xy = rotateVector(x2, y2, -rad);\n x2 = xy.x;\n y2 = xy.y;\n\n const x = (x1 - x2) / 2;\n const y = (y1 - y2) / 2;\n let h = (x * x) / (rx * rx) + (y * y) / (ry * ry);\n if (h > 1) {\n h = Math.sqrt(h);\n rx *= h;\n ry *= h;\n }\n const rx2 = rx * rx;\n const ry2 = ry * ry;\n\n const k = (LAF === SF ? -1 : 1) *\n Math.sqrt(\n Math.abs(\n (rx2 * ry2 - rx2 * y * y - ry2 * x * x) / (rx2 * y * y + ry2 * x * x),\n ),\n );\n\n cx = (k * rx * y) / ry + (x1 + x2) / 2;\n cy = (k * -ry * x) / rx + (y1 + y2) / 2;\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy no-bitwise\n f1 = Math.asin(((((y1 - cy) / ry) * 10 ** 9) >> 0) / 10 ** 9);\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy no-bitwise\n f2 = Math.asin(((((y2 - cy) / ry) * 10 ** 9) >> 0) / 10 ** 9);\n\n f1 = x1 < cx ? Math.PI - f1 : f1;\n f2 = x2 < cx ? Math.PI - f2 : f2;\n if (f1 < 0) f1 = Math.PI * 2 + f1;\n if (f2 < 0) f2 = Math.PI * 2 + f2;\n if (SF && f1 > f2) {\n f1 -= Math.PI * 2;\n }\n if (!SF && f2 > f1) {\n f2 -= Math.PI * 2;\n }\n } else {\n [f1, f2, cx, cy] = recursive;\n }\n let df = f2 - f1;\n if (Math.abs(df) > d120) {\n const f2old = f2;\n const x2old = x2;\n const y2old = y2;\n f2 = f1 + d120 * (SF && f2 > f1 ? 1 : -1);\n x2 = cx + rx * Math.cos(f2);\n y2 = cy + ry * Math.sin(f2);\n res = arcToCubic(x2, y2, rx, ry, angle, 0, SF, x2old, y2old, [\n f2,\n f2old,\n cx,\n cy,\n ]);\n }\n df = f2 - f1;\n const c1 = Math.cos(f1);\n const s1 = Math.sin(f1);\n const c2 = Math.cos(f2);\n const s2 = Math.sin(f2);\n const t = Math.tan(df / 4);\n const hx = (4 / 3) * rx * t;\n const hy = (4 / 3) * ry * t;\n const m1 = [x1, y1];\n const m2 = [x1 + hx * s1, y1 - hy * c1];\n const m3 = [x2 + hx * s2, y2 - hy * c2];\n const m4 = [x2, y2];\n m2[0] = 2 * m1[0] - m2[0];\n m2[1] = 2 * m1[1] - m2[1];\n if (recursive) {\n return [m2[0], m2[1], m3[0], m3[1], m4[0], m4[1]].concat(res);\n }\n res = [m2[0], m2[1], m3[0], m3[1], m4[0], m4[1]].concat(res);\n const newres = [];\n for (let i = 0, ii = res.length; i < ii; i += 1) {\n newres[i] = i % 2\n ? rotateVector(res[i - 1], res[i], rad).y\n : rotateVector(res[i], res[i + 1], rad).x;\n }\n return newres;\n};\nexport default arcToCubic;\n","/**\n * Converts a Q (quadratic-bezier) segment to C (cubic-bezier).\n *\n * @param x1 curve start x\n * @param y1 curve start y\n * @param qx control point x\n * @param qy control point y\n * @param x2 curve end x\n * @param y2 curve end y\n * @returns the cubic-bezier segment\n */\nconst quadToCubic = (\n x1: number,\n y1: number,\n qx: number,\n qy: number,\n x2: number,\n y2: number,\n): [number, number, number, number, number, number] => {\n const r13 = 1 / 3;\n const r23 = 2 / 3;\n return [\n r13 * x1 + r23 * qx, // cpx1\n r13 * y1 + r23 * qy, // cpy1\n r13 * x2 + r23 * qx, // cpx2\n r13 * y2 + r23 * qy, // cpy2\n x2,\n y2, // x,y\n ];\n};\nexport default quadToCubic;\n","import midPoint from \"../math/midPoint\";\n\n/**\n * Converts an L (line-to) segment to C (cubic-bezier).\n *\n * @param x1 line start x\n * @param y1 line start y\n * @param x2 line end x\n * @param y2 line end y\n * @returns the cubic-bezier segment\n */\nconst lineToCubic = (x1: number, y1: number, x2: number, y2: number) => {\n const c1 = midPoint([x1, y1], [x2, y2], 1.0 / 3.0);\n const c2 = midPoint([x1, y1], [x2, y2], 2.0 / 3.0);\n return [c1[0], c1[1], c2[0], c2[1], x2, y2];\n};\nexport default lineToCubic;\n","import arcToCubic from \"./arcToCubic\";\nimport quadToCubic from \"./quadToCubic\";\nimport lineToCubic from \"./lineToCubic\";\nimport type { CSegment, MSegment, PathSegment } from \"../types\";\nimport type { ParserParams } from \"../interface\";\n\n/**\n * Converts any segment to C (cubic-bezier).\n *\n * @param segment the source segment\n * @param params the source segment parameters\n * @returns the cubic-bezier segment\n */\nconst segmentToCubic = (segment: PathSegment, params: ParserParams) => {\n const [pathCommand] = segment;\n const values = segment.slice(1).map(Number);\n const [x, y] = values;\n // let args;\n const { x1: px1, y1: py1, x: px, y: py } = params;\n\n if (!\"TQ\".includes(pathCommand)) {\n params.qx = null;\n params.qy = null;\n }\n\n if (pathCommand === \"M\") {\n params.x = x;\n params.y = y;\n return segment;\n } else if (pathCommand === \"A\") {\n return [\"C\" as string | number].concat(\n arcToCubic(\n px1,\n py1,\n values[0],\n values[1],\n values[2],\n values[3],\n values[4],\n values[5],\n values[6],\n ),\n ) as CSegment;\n } else if (pathCommand === \"Q\") {\n params.qx = x;\n params.qy = y;\n return [\"C\" as string | number].concat(\n quadToCubic(px1, py1, values[0], values[1], values[2], values[3]),\n ) as CSegment;\n } else if (pathCommand === \"L\") {\n return [\"C\" as string | number].concat(\n lineToCubic(px1, py1, x, y),\n ) as CSegment;\n } else if (pathCommand === \"Z\") {\n return [\"C\" as string | number].concat(\n lineToCubic(px1, py1, px, py),\n ) as CSegment;\n }\n\n return segment as MSegment | CSegment;\n};\nexport default segmentToCubic;\n","import type { ParserParams } from \"../interface\";\nimport type {\n ASegment,\n CSegment,\n HSegment,\n LSegment,\n MSegment,\n NormalSegment,\n PathCommand,\n PathSegment,\n PointTuple,\n QSegment,\n VSegment,\n} from \"../types\";\n\n/**\n * Normalizes a single segment of a `pathArray` object.\n *\n * @param segment the segment object\n * @param params the normalization parameters\n * @returns the normalized segment\n */\nconst normalizeSegment = (segment: PathSegment, params: ParserParams) => {\n const [pathCommand] = segment;\n const absCommand = pathCommand.toUpperCase();\n const isRelative = pathCommand !== absCommand;\n const { x1: px1, y1: py1, x2: px2, y2: py2, x, y } = params;\n const values = segment.slice(1) as number[];\n let absValues = values.map((n, j) => n + (isRelative ? (j % 2 ? y : x) : 0));\n\n if (!\"TQ\".includes(absCommand)) {\n // optional but good to be cautious\n params.qx = null;\n params.qy = null;\n }\n\n // istanbul ignore else @preserve\n if (absCommand === \"A\") {\n absValues = values.slice(0, -2).concat(\n values[5] + (isRelative ? x : 0),\n values[6] + (isRelative ? y : 0),\n );\n\n return [\"A\" as PathCommand | number].concat(absValues) as ASegment;\n } else if (absCommand === \"H\") {\n return [\n \"L\",\n (segment as HSegment)[1] + (isRelative ? x : 0),\n py1,\n ] as LSegment;\n } else if (absCommand === \"V\") {\n return [\n \"L\",\n px1,\n (segment as VSegment)[1] + (isRelative ? y : 0),\n ] as LSegment;\n } else if (absCommand === \"L\") {\n return [\n \"L\",\n (segment as LSegment)[1] + (isRelative ? x : 0),\n (segment as LSegment)[2] + (isRelative ? y : 0),\n ] as LSegment;\n } else if (absCommand === \"M\") {\n return [\n \"M\",\n (segment as MSegment)[1] + (isRelative ? x : 0),\n (segment as MSegment)[2] + (isRelative ? y : 0),\n ] as MSegment;\n } else if (absCommand === \"C\") {\n return [\"C\" as PathCommand | number].concat(absValues) as CSegment;\n } else if (absCommand === \"S\") {\n const x1 = px1 * 2 - px2;\n const y1 = py1 * 2 - py2;\n params.x1 = x1;\n params.y1 = y1;\n return [\"C\", x1, y1].concat(absValues) as CSegment;\n } else if (absCommand === \"T\") {\n const qx = px1 * 2 - (params.qx ? params.qx : /* istanbul ignore next */ 0);\n const qy = py1 * 2 - (params.qy ? params.qy : /* istanbul ignore next */ 0);\n params.qx = qx;\n params.qy = qy;\n return [\"Q\", qx, qy].concat(absValues) as QSegment;\n } else if (absCommand === \"Q\") {\n const [nqx, nqy] = absValues as PointTuple;\n params.qx = nqx;\n params.qy = nqy;\n return [\"Q\" as PathCommand | number].concat(absValues) as QSegment;\n } else if (absCommand === \"Z\") {\n return [\"Z\"] as NormalSegment;\n }\n\n // istanbul ignore next @preserve\n return segment as NormalSegment;\n};\nexport default normalizeSegment;\n","import type { ParserParams } from \"../interface\";\n\nconst paramsParser: ParserParams = {\n x1: 0,\n y1: 0,\n x2: 0,\n y2: 0,\n x: 0,\n y: 0,\n qx: null,\n qy: null,\n};\n\nexport default paramsParser;\n","import segmentToCubic from \"../process/segmentToCubic\";\nimport { AbsoluteCommand, CSegment, CurveArray, PathArray } from \"../types\";\nimport iterate from \"../process/iterate\";\nimport parsePathString from \"../parser/parsePathString\";\nimport normalizeSegment from \"../process/normalizeSegment\";\nimport paramsParser from \"../parser/paramsParser\";\n\n/**\n * Parses a path string value or 'pathArray' and returns a new one\n * in which all segments are converted to cubic-bezier.\n *\n * In addition, un-necessary `Z` segment is removed if previous segment\n * extends to the `M` segment.\n *\n * @param pathInput the string to be parsed or 'pathArray'\n * @returns the resulted `pathArray` converted to cubic-bezier\n */\nconst pathToCurve = (pathInput: string | PathArray): CurveArray => {\n const params = { ...paramsParser };\n const path = parsePathString(pathInput);\n\n return iterate(path, (seg, index, lastX, lastY) => {\n params.x = lastX;\n params.y = lastY;\n const normalSegment = normalizeSegment(seg, params);\n let result = segmentToCubic(normalSegment, params);\n const isLongArc = result[0] === \"C\" && result.length > 7;\n\n if (isLongArc) {\n path.splice(\n index + 1,\n 0,\n [\"C\" as AbsoluteCommand | number].concat(result.slice(7)) as CSegment,\n );\n result = result.slice(0, 7) as CSegment;\n }\n\n const seglen = result.length;\n params.x1 = +result[seglen - 2];\n params.y1 = +result[seglen - 1];\n params.x2 = +result[seglen - 4] || params.x1;\n params.y2 = +result[seglen - 3] || params.y1;\n\n return result;\n });\n};\nexport default pathToCurve;\n","import { Options } from \"../interface\";\n\n/** SVGPathCommander default options */\nconst defaultOptions: Options = {\n origin: [0, 0, 0],\n round: 4,\n};\n\nexport default defaultOptions;\n","const roundTo = (n: number, round: number) => {\n const pow = round >= 1 ? 10 ** round : 1;\n\n return round > 0 ? Math.round(n * pow) / pow : Math.round(n);\n};\n\nexport default roundTo;\n","import type { PathArray, PathSegment } from \"../types\";\nimport defaultOptions from \"../options/options\";\nimport roundTo from \"../math/roundTo\";\n\n/**\n * Returns a valid `d` attribute string value created\n * by rounding values and concatenating the `pathArray` segments.\n *\n * @param path the `pathArray` object\n * @param roundOption amount of decimals to round values to\n * @returns the concatenated path string\n */\nconst pathToString = (\n path: PathArray,\n roundOption?: number | \"off\",\n): string => {\n const pathLen = path.length;\n let { round } = defaultOptions;\n let segment = path[0] as PathSegment;\n let result = \"\";\n\n // allow for ZERO decimals\n round = roundOption === \"off\"\n ? roundOption\n : typeof roundOption === \"number\" && roundOption >= 0\n ? roundOption\n : typeof round === \"number\" && round >= 0\n ? round\n : /* istanbul ignore next @preserve */ \"off\";\n\n for (let i = 0; i < pathLen; i += 1) {\n segment = path[i];\n const [pathCommand] = segment;\n const values = segment.slice(1) as number[];\n result += pathCommand;\n if (round === \"off\") {\n result += values.join(\" \");\n } else {\n let j = 0;\n const valLen = values.length;\n while (j < valLen) {\n result += roundTo(values[j], round);\n if (j !== valLen - 1) result += \" \";\n j += 1;\n }\n }\n }\n\n return result;\n};\n\nexport default pathToString;\n","const DISTANCE_EPSILON = 0.00001;\n\nexport default DISTANCE_EPSILON;\n","import normalizeSegment from \"./normalizeSegment\";\nimport type { NormalArray, PathArray } from \"../types\";\nimport iterate from \"./iterate\";\nimport parsePathString from \"../parser/parsePathString\";\nimport paramsParser from \"../parser/paramsParser\";\n\n/**\n * Normalizes a `pathArray` object for further processing:\n * * convert segments to absolute values\n * * convert shorthand path commands to their non-shorthand notation\n *\n * @param pathInput the string to be parsed or 'pathArray'\n * @returns the normalized `pathArray`\n */\nconst normalizePath = (pathInput: string | PathArray) => {\n const path = parsePathString(pathInput);\n const params = { ...paramsParser };\n\n return iterate(path, (seg, _, lastX, lastY) => {\n params.x = lastX;\n params.y = lastY;\n const result = normalizeSegment(seg, params);\n\n const seglen = result.length;\n params.x1 = +result[seglen - 2];\n params.y1 = +result[seglen - 1];\n params.x2 = +result[seglen - 4] || params.x1;\n params.y2 = +result[seglen - 3] || params.y1;\n\n return result;\n });\n};\nexport default normalizePath;\n","import DISTANCE_EPSILON from \"./distanceEpsilon\";\nimport type { MSegment, PathArray, PointTuple } from \"../types\";\nimport iterate from \"../process/iterate\";\nimport { getLineLength, getPointAtLineLength } from \"../math/lineTools\";\nimport { getArcLength, getPointAtArcLength } from \"../math/arcTools\";\nimport { getCubicLength, getPointAtCubicLength } from \"../math/cubicTools\";\nimport { getPointAtQuadLength, getQuadLength } from \"../math/quadTools\";\nimport normalizePath from \"../process/normalizePath\";\n\n/**\n * Returns [x,y] coordinates of a point at a given length of a shape.\n *\n * @param pathInput the `pathArray` to look into\n * @param distance the length of the shape to look at\n * @returns the requested {x, y} point coordinates\n */\nconst getPointAtLength = (pathInput: string | PathArray, distance?: number) => {\n const path = normalizePath(pathInput);\n let isM = false;\n let data = [] as number[];\n let pathCommand = \"M\";\n let x = 0;\n let y = 0;\n let [mx, my] = path[0].slice(1) as PointTuple;\n const distanceIsNumber = typeof distance === \"number\";\n let point = { x: mx, y: my };\n let length = 0;\n let POINT = point;\n let totalLength = 0;\n\n if (!distanceIsNumber || distance < DISTANCE_EPSILON) return point;\n\n // for (let i = 0; i < pathLen; i += 1) {\n iterate(path, (seg, _, lastX, lastY) => {\n [pathCommand] = seg;\n isM = pathCommand === \"M\";\n data = !isM ? [lastX, lastY].concat(seg.slice(1) as number[]) : data;\n\n // this segment is always ZERO\n /* istanbul ignore else @preserve */\n if (isM) {\n // remember mx, my for Z\n [, mx, my] = seg as MSegment;\n point = { x: mx, y: my };\n length = 0;\n } else if (pathCommand === \"L\") {\n point = getPointAtLineLength(\n data[0],\n data[1],\n data[2],\n data[3],\n distance - totalLength,\n );\n length = getLineLength(data[0], data[1], data[2], data[3]);\n } else if (pathCommand === \"A\") {\n point = getPointAtArcLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n data[6],\n data[7],\n data[8],\n distance - totalLength,\n );\n length = getArcLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n data[6],\n data[7],\n data[8],\n );\n } else if (pathCommand === \"C\") {\n point = getPointAtCubicLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n data[6],\n data[7],\n distance - totalLength,\n );\n length = getCubicLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n data[6],\n data[7],\n );\n } else if (pathCommand === \"Q\") {\n point = getPointAtQuadLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n distance - totalLength,\n );\n length = getQuadLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n );\n } else if (pathCommand === \"Z\") {\n data = [lastX, lastY, mx, my];\n point = { x: mx, y: my };\n\n length = getLineLength(data[0], data[1], data[2], data[3]);\n }\n\n [x, y] = data.slice(-2);\n\n if (totalLength < distance) {\n POINT = point;\n } else {\n // totalLength >= distance\n // stop right here\n // stop iterator now!\n return false;\n }\n\n totalLength += length;\n return;\n });\n\n // native `getPointAtLength` behavior when the given distance\n // is higher than total length\n if (distance > totalLength - DISTANCE_EPSILON) {\n return { x, y };\n }\n\n return POINT;\n};\n\nexport default getPointAtLength;\n","import type { LSegment, MSegment, PathArray, PointTuple } from \"../types\";\nimport { getLineLength } from \"../math/lineTools\";\nimport { getArcLength } from \"../math/arcTools\";\nimport { getCubicLength } from \"../math/cubicTools\";\nimport { getQuadLength } from \"../math/quadTools\";\nimport iterate from \"../process/iterate\";\nimport parsePathString from \"../parser/parsePathString\";\nimport absolutizeSegment from \"../process/absolutizeSegment\";\n\n/**\n * Returns the shape total length, or the equivalent to `shape.getTotalLength()`.\n *\n * @param pathInput the target `pathArray`\n * @returns the shape total length\n */\nconst getTotalLength = (pathInput: string | PathArray) => {\n const path = parsePathString(pathInput);\n let paramX1 = 0;\n let paramY1 = 0;\n let paramX2 = 0;\n let paramY2 = 0;\n let paramQX = 0;\n let paramQY = 0;\n let pathCommand = \"M\";\n let mx = 0;\n let my = 0;\n let totalLength = 0;\n\n iterate(path, (seg, index, lastX, lastY) => {\n [pathCommand] = seg;\n const absCommand = pathCommand.toUpperCase();\n const isRelative = absCommand !== pathCommand;\n const absoluteSegment = isRelative\n ? absolutizeSegment(seg, index, lastX, lastY)\n : (seg.slice(0) as typeof seg);\n\n const normalSegment = absCommand === \"V\"\n ? ([\"L\", lastX, absoluteSegment[1]] as LSegment)\n : absCommand === \"H\"\n ? ([\"L\", absoluteSegment[1], lastY] as LSegment)\n : absoluteSegment;\n [pathCommand] = normalSegment;\n\n if (!\"TQ\".includes(absCommand)) {\n // optional but good to be cautious\n paramQX = 0;\n paramQY = 0;\n }\n\n // this segment is always ZERO\n /* istanbul ignore else @preserve */\n if (pathCommand === \"M\") {\n // remember mx, my for Z\n [, mx, my] = normalSegment as MSegment;\n } else if (pathCommand === \"L\") {\n totalLength += getLineLength(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n );\n } else if (pathCommand === \"A\") {\n totalLength += getArcLength(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n normalSegment[5] as number,\n normalSegment[6] as number,\n normalSegment[7] as number,\n );\n } else if (pathCommand === \"S\") {\n const cp1x = paramX1 * 2 - paramX2;\n const cp1y = paramY1 * 2 - paramY2;\n\n totalLength += getCubicLength(\n lastX,\n lastY,\n cp1x,\n cp1y,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n );\n } else if (pathCommand === \"C\") {\n totalLength += getCubicLength(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n normalSegment[5] as number,\n normalSegment[6] as number,\n );\n } else if (pathCommand === \"T\") {\n paramQX = paramX1 * 2 - paramQX;\n paramQY = paramY1 * 2 - paramQY;\n totalLength += getQuadLength(\n lastX,\n lastY,\n paramQX,\n paramQY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n );\n } else if (pathCommand === \"Q\") {\n paramQX = normalSegment[1] as number;\n paramQY = normalSegment[2] as number;\n totalLength += getQuadLength(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n );\n } else if (pathCommand === \"Z\") {\n totalLength += getLineLength(lastX, lastY, mx, my);\n }\n\n // update params\n [paramX1, paramY1] = pathCommand === \"Z\"\n ? [mx, my]\n : (normalSegment.slice(-2) as PointTuple);\n [paramX2, paramY2] = pathCommand === \"C\"\n ? ([normalSegment[3], normalSegment[4]] as PointTuple)\n : pathCommand === \"S\"\n ? ([normalSegment[1], normalSegment[2]] as PointTuple)\n : [paramX1, paramY1];\n });\n\n return totalLength;\n};\n\nexport default getTotalLength;\n","import type { PathArray, PathSegment } from \"../types\";\nimport type { SegmentProperties } from \"../interface\";\nimport parsePathString from \"../parser/parsePathString\";\nimport getTotalLength from \"./getTotalLength\";\n\n/**\n * Returns the segment, its index and length as well as\n * the length to that segment at a given length in a path.\n *\n * @param pathInput target `pathArray`\n * @param distance the given length\n * @returns the requested properties\n */\nconst getPropertiesAtLength = (\n pathInput: string | PathArray,\n distance?: number,\n): SegmentProperties => {\n const pathArray = parsePathString(pathInput);\n\n let pathTemp = pathArray.slice(0) as PathArray;\n let pathLength = getTotalLength(pathTemp);\n let index = pathTemp.length - 1;\n let lengthAtSegment = 0;\n let length = 0;\n let segment = pathArray[0] as PathSegment;\n\n // If the path is empty, return 0.\n if (index <= 0 || !distance || !Number.isFinite(distance)) {\n return {\n segment,\n index: 0,\n length,\n lengthAtSegment,\n };\n }\n\n if (distance >= pathLength) {\n pathTemp = pathArray.slice(0, -1) as PathArray;\n lengthAtSegment = getTotalLength(pathTemp);\n length = pathLength - lengthAtSegment;\n segment = pathArray[index];\n return {\n segment,\n index,\n length,\n lengthAtSegment,\n };\n }\n\n const segments = [] as SegmentProperties[];\n while (index > 0) {\n segment = pathTemp[index];\n pathTemp = pathTemp.slice(0, -1) as PathArray;\n lengthAtSegment = getTotalLength(pathTemp);\n length = pathLength - lengthAtSegment;\n pathLength = lengthAtSegment;\n\n segments.push({\n segment,\n index,\n length,\n lengthAtSegment,\n });\n index -= 1;\n }\n\n return segments.find(({ lengthAtSegment: l }) =>\n l <= distance\n ) as SegmentProperties;\n};\n\nexport default getPropertiesAtLength;\n","import type { PathArray, Point } from \"../types\";\nimport type { PointProperties } from \"../interface\";\nimport getPointAtLength from \"./getPointAtLength\";\nimport getPropertiesAtLength from \"./getPropertiesAtLength\";\nimport getTotalLength from \"./getTotalLength\";\nimport parsePathString from \"../parser/parsePathString\";\nimport normalizePath from \"../process/normalizePath\";\n\n/**\n * Returns the point and segment in path closest to a given point as well as\n * the distance to the path stroke.\n *\n * @see https://bl.ocks.org/mbostock/8027637\n *\n * @param pathInput target `pathArray`\n * @param point the given point\n * @returns the requested properties\n */\nconst getPropertiesAtPoint = (\n pathInput: string | PathArray,\n point: Point,\n): PointProperties => {\n const path = parsePathString(pathInput);\n const normalPath = normalizePath(path);\n const pathLength = getTotalLength(normalPath);\n const distanceTo = (p: Point) => {\n const dx = p.x - point.x;\n const dy = p.y - point.y;\n return dx * dx + dy * dy;\n };\n let precision = 8;\n let scan: Point;\n let closest = { x: 0, y: 0 }; // make TS happy\n let scanDistance = 0;\n let bestLength = 0;\n let bestDistance = Infinity;\n\n // linear scan for coarse approximation\n for (let scanLength = 0; scanLength <= pathLength; scanLength += precision) {\n scan = getPointAtLength(normalPath, scanLength);\n scanDistance = distanceTo(scan);\n\n if (scanDistance < bestDistance) {\n closest = scan;\n bestLength = scanLength;\n bestDistance = scanDistance;\n }\n }\n\n // binary search for precise estimate\n precision /= 2;\n let before: { x: number; y: number };\n let after: { x: number; y: number };\n let beforeLength = 0;\n let afterLength = 0;\n let beforeDistance = 0;\n let afterDistance = 0;\n\n while (precision > 0.000001) {\n beforeLength = bestLength - precision;\n before = getPointAtLength(normalPath, beforeLength);\n beforeDistance = distanceTo(before);\n afterLength = bestLength + precision;\n after = getPointAtLength(normalPath, afterLength);\n afterDistance = distanceTo(after);\n\n if (beforeLength >= 0 && beforeDistance < bestDistance) {\n closest = before;\n bestLength = beforeLength;\n bestDistance = beforeDistance;\n } else if (afterLength <= pathLength && afterDistance < bestDistance) {\n closest = after;\n bestLength = afterLength;\n bestDistance = afterDistance;\n } else {\n precision /= 2;\n }\n if (precision < 0.00001) break;\n }\n\n const segment = getPropertiesAtLength(path, bestLength);\n const distance = Math.sqrt(bestDistance);\n\n return { closest, distance, segment };\n};\n\nexport default getPropertiesAtPoint;\n","import type { PathArray } from \"../types\";\nimport getPropertiesAtPoint from \"./getPropertiesAtPoint\";\n\n/**\n * Returns the point in path closest to a given point.\n *\n * @param pathInput target `pathArray`\n * @param point the given point\n * @returns the best match\n */\nconst getClosestPoint = (\n pathInput: string | PathArray,\n point: { x: number; y: number },\n) => {\n return getPropertiesAtPoint(pathInput, point).closest;\n};\n\nexport default getClosestPoint;\n","import pathToCurve from \"../convert/pathToCurve\";\nimport type { PathArray, PointTuple } from \"../types\";\n\n/**\n * Returns the area of a single cubic-bezier segment.\n *\n * http://objectmix.com/graphics/133553-area-closed-bezier-curve.html\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the area of the cubic-bezier segment\n */\nconst getCubicSegArea = (\n x1: number,\n y1: number,\n c1x: number,\n c1y: number,\n c2x: number,\n c2y: number,\n x2: number,\n y2: number,\n) => {\n return (\n (3 *\n ((y2 - y1) * (c1x + c2x) -\n (x2 - x1) * (c1y + c2y) +\n c1y * (x1 - c2x) -\n c1x * (y1 - c2y) +\n y2 * (c2x + x1 / 3) -\n x2 * (c2y + y1 / 3))) /\n 20\n );\n};\n\n/**\n * Returns the area of a shape.\n *\n * @author Jürg Lehni & Jonathan Puckey\n *\n * @see https://github.com/paperjs/paper.js/blob/develop/src/path/Path.js\n *\n * @param path the shape `pathArray`\n * @returns the length of the cubic-bezier segment\n */\nconst getPathArea = (path: PathArray) => {\n let x = 0;\n let y = 0;\n let len = 0;\n\n return pathToCurve(path)\n .map((seg) => {\n switch (seg[0]) {\n case \"M\":\n [, x, y] = seg;\n return 0;\n default:\n len = getCubicSegArea(\n x,\n y,\n seg[1],\n seg[2],\n seg[3],\n seg[4],\n seg[5],\n seg[6],\n );\n [x, y] = seg.slice(-2) as PointTuple;\n return len;\n }\n })\n .reduce((a, b) => a + b, 0);\n};\nexport default getPathArea;\n","import getPathArea from \"./getPathArea\";\nimport pathToCurve from \"../convert/pathToCurve\";\nimport type { PathArray } from \"../types\";\n\n/**\n * Check if a path is drawn clockwise and returns true if so,\n * false otherwise.\n *\n * @param path the path string or `pathArray`\n * @returns true when clockwise or false if not\n */\nconst getDrawDirection = (path: string | PathArray) => {\n return getPathArea(pathToCurve(path)) >= 0;\n};\n\nexport default getDrawDirection;\n","import iterate from \"../process/iterate\";\nimport { PathBBox } from \"../interface\";\nimport { LSegment, MSegment, PathArray, PointTuple } from \"../types\";\nimport { getLineBBox } from \"../math/lineTools\";\nimport { getArcBBox } from \"../math/arcTools\";\nimport { getCubicBBox } from \"../math/cubicTools\";\nimport { getQuadBBox } from \"../math/quadTools\";\nimport parsePathString from \"../parser/parsePathString\";\nimport absolutizeSegment from \"../process/absolutizeSegment\";\n\nconst getPathBBox = (pathInput: PathArray | string) => {\n if (!pathInput) {\n return {\n x: 0,\n y: 0,\n width: 0,\n height: 0,\n x2: 0,\n y2: 0,\n cx: 0,\n cy: 0,\n cz: 0,\n };\n }\n\n const path = parsePathString(pathInput);\n let pathCommand = \"M\";\n let mx = 0;\n let my = 0;\n const { max, min } = Math;\n let xMin = Infinity;\n let yMin = Infinity;\n let xMax = -Infinity;\n let yMax = -Infinity;\n let minX = 0;\n let minY = 0;\n let maxX = 0;\n let maxY = 0;\n let paramX1 = 0;\n let paramY1 = 0;\n let paramX2 = 0;\n let paramY2 = 0;\n let paramQX = 0;\n let paramQY = 0;\n\n iterate(path, (seg, index, lastX, lastY) => {\n [pathCommand] = seg;\n const absCommand = pathCommand.toUpperCase();\n const isRelative = absCommand !== pathCommand;\n const absoluteSegment = isRelative\n ? absolutizeSegment(seg, index, lastX, lastY)\n : (seg.slice(0) as typeof seg);\n\n const normalSegment = absCommand === \"V\"\n ? ([\"L\", lastX, absoluteSegment[1]] as LSegment)\n : absCommand === \"H\"\n ? ([\"L\", absoluteSegment[1], lastY] as LSegment)\n : absoluteSegment;\n\n [pathCommand] = normalSegment;\n\n if (!\"TQ\".includes(absCommand)) {\n // optional but good to be cautious\n paramQX = 0;\n paramQY = 0;\n }\n\n // this segment is always ZERO\n /* istanbul ignore else @preserve */\n if (pathCommand === \"M\") {\n [, mx, my] = normalSegment as MSegment;\n minX = mx;\n minY = my;\n maxX = mx;\n maxY = my;\n } else if (pathCommand === \"L\") {\n [minX, minY, maxX, maxY] = getLineBBox(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n );\n } else if (pathCommand === \"A\") {\n [minX, minY, maxX, maxY] = getArcBBox(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n normalSegment[5] as number,\n normalSegment[6] as number,\n normalSegment[7] as number,\n );\n } else if (pathCommand === \"S\") {\n const cp1x = paramX1 * 2 - paramX2;\n const cp1y = paramY1 * 2 - paramY2;\n\n [minX, minY, maxX, maxY] = getCubicBBox(\n lastX,\n lastY,\n cp1x,\n cp1y,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n );\n } else if (pathCommand === \"C\") {\n [minX, minY, maxX, maxY] = getCubicBBox(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n normalSegment[5] as number,\n normalSegment[6] as number,\n );\n } else if (pathCommand === \"T\") {\n paramQX = paramX1 * 2 - paramQX;\n paramQY = paramY1 * 2 - paramQY;\n [minX, minY, maxX, maxY] = getQuadBBox(\n lastX,\n lastY,\n paramQX,\n paramQY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n );\n } else if (pathCommand === \"Q\") {\n paramQX = normalSegment[1] as number;\n paramQY = normalSegment[2] as number;\n [minX, minY, maxX, maxY] = getQuadBBox(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n );\n } else if (pathCommand === \"Z\") {\n [minX, minY, maxX, maxY] = getLineBBox(lastX, lastY, mx, my);\n }\n xMin = min(minX, xMin);\n yMin = min(minY, yMin);\n xMax = max(maxX, xMax);\n yMax = max(maxY, yMax);\n\n // update params\n [paramX1, paramY1] = pathCommand === \"Z\"\n ? [mx, my]\n : (normalSegment.slice(-2) as PointTuple);\n [paramX2, paramY2] = pathCommand === \"C\"\n ? ([normalSegment[3], normalSegment[4]] as PointTuple)\n : pathCommand === \"S\"\n ? ([normalSegment[1], normalSegment[2]] as PointTuple)\n : [paramX1, paramY1];\n });\n\n const width = xMax - xMin;\n const height = yMax - yMin;\n\n return {\n width,\n height,\n x: xMin,\n y: yMin,\n x2: xMax,\n y2: yMax,\n cx: xMin + width / 2,\n cy: yMin + height / 2,\n // an estimated guess\n cz: Math.max(width, height) + Math.min(width, height) / 2,\n } satisfies PathBBox;\n};\n\nexport default getPathBBox;\n","import type { PathArray, PathSegment } from \"../types\";\nimport getPropertiesAtLength from \"./getPropertiesAtLength\";\n\n/**\n * Returns the segment at a given length.\n *\n * @param pathInput the target `pathArray`\n * @param distance the distance in path to look at\n * @returns the requested segment\n */\nconst getSegmentAtLength = (\n pathInput: string | PathArray,\n distance?: number,\n): PathSegment | undefined => {\n return getPropertiesAtLength(pathInput, distance).segment;\n};\n\nexport default getSegmentAtLength;\n","import type { SegmentProperties } from \"../interface\";\nimport type { PathArray } from \"../types\";\nimport getPropertiesAtPoint from \"./getPropertiesAtPoint\";\n\n/**\n * Returns the path segment which contains a given point.\n *\n * @param path the `pathArray` to look into\n * @param point the point of the shape to look for\n * @returns the requested segment\n */\nconst getSegmentOfPoint = (\n path: string | PathArray,\n point: { x: number; y: number },\n): SegmentProperties | undefined => {\n return getPropertiesAtPoint(path, point).segment;\n};\nexport default getSegmentOfPoint;\n","import type { PathArray, PathSegment, RelativeCommand } from \"../types\";\nimport paramsCount from \"../parser/paramsCount\";\n\n/**\n * Iterates an array to check if it's an actual `pathArray`.\n *\n * @param path the `pathArray` to be checked\n * @returns iteration result\n */\nconst isPathArray = (path: unknown): path is PathArray => {\n return (\n Array.isArray(path) &&\n path.every((seg: PathSegment) => {\n const lk = seg[0].toLowerCase() as RelativeCommand;\n return (\n paramsCount[lk] === seg.length - 1 &&\n \"achlmqstvz\".includes(lk) &&\n (seg.slice(1) as unknown[]).every(Number.isFinite)\n );\n }) &&\n path.length > 0\n );\n};\nexport default isPathArray;\n","import type { AbsoluteArray } from \"../types\";\nimport isPathArray from \"./isPathArray\";\n\n/**\n * Iterates an array to check if it's a `pathArray`\n * with all absolute values.\n *\n * @param path the `pathArray` to be checked\n * @returns iteration result\n */\nconst isAbsoluteArray = (path: unknown): path is AbsoluteArray => {\n return (\n isPathArray(path) &&\n // `isPathArray` also checks if it's `Array`\n path.every(([x]) => x === x.toUpperCase())\n );\n};\nexport default isAbsoluteArray;\n","import type { NormalArray } from \"../types\";\nimport isAbsoluteArray from \"./isAbsoluteArray\";\n\n/**\n * Iterates an array to check if it's a `pathArray`\n * with all segments are in non-shorthand notation\n * with absolute values.\n *\n * @param {string | SVGPath.pathArray} path the `pathArray` to be checked\n * @returns {boolean} iteration result\n */\nconst isNormalizedArray = (path: unknown): path is NormalArray => {\n // `isAbsoluteArray` also checks if it's `Array`\n return isAbsoluteArray(path) && path.every(([pc]) => \"ACLMQZ\".includes(pc));\n};\nexport default isNormalizedArray;\n","import { CurveArray } from \"../types\";\nimport isNormalizedArray from \"./isNormalizedArray\";\n\n/**\n * Iterates an array to check if it's a `pathArray`\n * with all C (cubic bezier) segments.\n *\n * @param path the `Array` to be checked\n * @returns iteration result\n */\nconst isCurveArray = (path: unknown): path is CurveArray => {\n // `isPathArray` also checks if it's `Array`\n return isNormalizedArray(path) && path.every(([pc]) => \"MC\".includes(pc));\n};\nexport default isCurveArray;\n","import type { PathArray } from \"../types\";\nimport getPropertiesAtPoint from \"./getPropertiesAtPoint\";\nimport DISTANCE_EPSILON from \"./distanceEpsilon\";\n\n/**\n * Checks if a given point is in the stroke of a path.\n *\n * @param pathInput target path\n * @param point the given `{x,y}` point\n * @returns the query result\n */\nconst isPointInStroke = (\n pathInput: string | PathArray,\n point: { x: number; y: number },\n) => {\n const { distance } = getPropertiesAtPoint(pathInput, point);\n return Math.abs(distance) < DISTANCE_EPSILON; // 0.01 might be more permissive\n};\nexport default isPointInStroke;\n","import type { RelativeArray } from \"../types\";\nimport isPathArray from \"./isPathArray\";\n\n/**\n * Iterates an array to check if it's a `pathArray`\n * with relative values.\n *\n * @param path the `pathArray` to be checked\n * @returns iteration result\n */\nconst isRelativeArray = (path: unknown): path is RelativeArray => {\n return (\n isPathArray(path) &&\n // `isPathArray` checks if it's `Array`\n path.slice(1).every(([pc]) => pc === pc.toLowerCase())\n );\n};\nexport default isRelativeArray;\n","import scanSegment from \"../parser/scanSegment\";\nimport skipSpaces from \"../parser/skipSpaces\";\nimport PathParser from \"../parser/pathParser\";\n\n/**\n * Parses a path string value to determine its validity\n * then returns true if it's valid or false otherwise.\n *\n * @param pathString the path string to be parsed\n * @returns the path string validity\n */\nconst isValidPath = (pathString: string) => {\n if (typeof pathString !== \"string\" || !pathString.length) {\n return false;\n }\n\n const path = new PathParser(pathString);\n\n skipSpaces(path);\n\n while (path.index < path.max && !path.err.length) {\n scanSegment(path);\n }\n\n return !path.err.length && \"mM\".includes(path.segments[0][0]);\n};\nexport default isValidPath;\n","import type { ShapeParams } from \"../interface\";\n\n/**\n * Supported shapes and their specific parameters.\n */\nconst shapeParams: ShapeParams = {\n line: [\"x1\", \"y1\", \"x2\", \"y2\"],\n circle: [\"cx\", \"cy\", \"r\"],\n ellipse: [\"cx\", \"cy\", \"rx\", \"ry\"],\n rect: [\"width\", \"height\", \"x\", \"y\", \"rx\", \"ry\"],\n polygon: [\"points\"],\n polyline: [\"points\"],\n glyph: [\"d\"],\n};\n\nexport default shapeParams;\n","const isElement = (node?: unknown): node is Element =>\n node !== undefined && node !== null &&\n typeof node === \"object\" &&\n (node as Node).nodeType === 1; // ELEMENT_NODE\n\nexport default isElement;\n","import type {\n CircleAttr,\n EllipseAttr,\n GlyphAttr,\n LineAttr,\n PolyAttr,\n RectAttr,\n ShapeParams,\n} from \"../interface\";\nimport type { PathArray, PathSegment, ShapeOps, ShapeTypes } from \"../types\";\nimport error from \"../parser/error\";\nimport parsePathString from \"../parser/parsePathString\";\nimport shapeParams from \"./shapeParams\";\nimport isPathArray from \"./isPathArray\";\nimport isElement from \"./isElement\";\n\n/**\n * Returns a new `pathArray` from line attributes.\n *\n * @param attr shape configuration\n * @returns a new line `pathArray`\n */\nexport const getLinePath = (attr: LineAttr): PathArray => {\n let { x1, y1, x2, y2 } = attr;\n [x1, y1, x2, y2] = [x1, y1, x2, y2].map((a) => +a);\n return [\n [\"M\", x1, y1],\n [\"L\", x2, y2],\n ];\n};\n\n/**\n * Returns a new `pathArray` like from polyline/polygon attributes.\n *\n * @param attr shape configuration\n * @return a new polygon/polyline `pathArray`\n */\nexport const getPolyPath = (attr: PolyAttr): PathArray => {\n const pathArray = [] as PathSegment[];\n const points = (attr.points || \"\")\n .trim()\n .split(/[\\s|,]/)\n .map((a) => +a);\n\n let index = 0;\n while (index < points.length) {\n pathArray.push([index ? \"L\" : \"M\", points[index], points[index + 1]]);\n index += 2;\n }\n\n return (attr.type === \"polygon\"\n ? [...pathArray, [\"z\"]]\n : pathArray) as PathArray;\n};\n\n/**\n * Returns a new `pathArray` from circle attributes.\n *\n * @param attr shape configuration\n * @return a circle `pathArray`\n */\nexport const getCirclePath = (attr: CircleAttr): PathArray => {\n let { cx, cy, r } = attr;\n [cx, cy, r] = [cx, cy, r].map((a) => +a);\n\n return [\n [\"M\", cx - r, cy],\n [\"a\", r, r, 0, 1, 0, 2 * r, 0],\n [\"a\", r, r, 0, 1, 0, -2 * r, 0],\n ];\n};\n\n/**\n * Returns a new `pathArray` from ellipse attributes.\n *\n * @param attr shape configuration\n * @return an ellipse `pathArray`\n */\nexport const getEllipsePath = (attr: EllipseAttr): PathArray => {\n let { cx, cy } = attr;\n let rx = attr.rx || 0;\n let ry = attr.ry || rx;\n [cx, cy, rx, ry] = [cx, cy, rx, ry].map((a) => +a);\n\n return [\n [\"M\", cx - rx, cy],\n [\"a\", rx, ry, 0, 1, 0, 2 * rx, 0],\n [\"a\", rx, ry, 0, 1, 0, -2 * rx, 0],\n ];\n};\n\n/**\n * Returns a new `pathArray` like from rect attributes.\n *\n * @param attr object with properties above\n * @return a new `pathArray` from `` attributes\n */\nexport const getRectanglePath = (attr: RectAttr): PathArray => {\n const x = +attr.x || 0;\n const y = +attr.y || 0;\n const w = +attr.width;\n const h = +attr.height;\n let rx = +(attr.rx || 0);\n let ry = +(attr.ry || rx);\n\n // Validity checks from http://www.w3.org/TR/SVG/shapes.html#RectElement:\n if (rx || ry) {\n // rx = !rx ? ry : rx;\n // ry = !ry ? rx : ry;\n\n /* istanbul ignore else @preserve */\n if (rx * 2 > w) rx -= (rx * 2 - w) / 2;\n /* istanbul ignore else @preserve */\n if (ry * 2 > h) ry -= (ry * 2 - h) / 2;\n\n return [\n [\"M\", x + rx, y],\n [\"h\", w - rx * 2],\n [\"s\", rx, 0, rx, ry],\n [\"v\", h - ry * 2],\n [\"s\", 0, ry, -rx, ry],\n [\"h\", -w + rx * 2],\n [\"s\", -rx, 0, -rx, -ry],\n [\"v\", -h + ry * 2],\n [\"s\", 0, -ry, rx, -ry],\n ];\n }\n\n return [[\"M\", x, y], [\"h\", w], [\"v\", h], [\"H\", x], [\"Z\"]];\n};\n\n/**\n * Returns a new `pathArray` created from attributes of a ``, ``,\n * ``, ``, ``, ``, or ``.\n *\n * It can also work with an options object, see the type below\n * @see ShapeOps\n *\n * @param element target shape\n * @return the newly created `` element\n */\nconst shapeToPathArray = (\n element: ShapeTypes | ShapeOps,\n) => {\n const supportedShapes = Object.keys(shapeParams) as (keyof ShapeParams)[];\n const targetIsElement = isElement(element);\n const tagName = targetIsElement ? element.tagName : null;\n\n if (tagName && [...supportedShapes, \"path\"].every((s) => tagName !== s)) {\n throw TypeError(`${error}: \"${tagName}\" is not SVGElement`);\n }\n\n const type =\n (targetIsElement ? tagName : (element as ShapeOps).type) as ShapeOps[\n \"type\"\n ];\n const shapeAttrs = shapeParams[type] as string[];\n const config = { type } as Record;\n\n if (targetIsElement) {\n shapeAttrs.forEach((p) => {\n config[p] = element.getAttribute(p) as string;\n });\n } else {\n Object.assign(config, element);\n }\n\n // set d\n let pathArray = [] as unknown as PathArray;\n\n /* istanbul ignore else */\n if (type === \"circle\") {\n pathArray = getCirclePath(config as unknown as CircleAttr);\n } else if (type === \"ellipse\") {\n pathArray = getEllipsePath(config as unknown as EllipseAttr);\n } else if ([\"polyline\", \"polygon\"].includes(type)) {\n pathArray = getPolyPath(config as unknown as PolyAttr);\n } else if (type === \"rect\") {\n pathArray = getRectanglePath(config as unknown as RectAttr);\n } else if (type === \"line\") {\n pathArray = getLinePath(config as unknown as LineAttr);\n } else if ([\"glyph\", \"path\"].includes(type)) {\n pathArray = parsePathString(\n targetIsElement\n ? element.getAttribute(\"d\") || /* istanbul ignore next @preserve */ \"\"\n : (element as GlyphAttr).d || \"\",\n );\n }\n\n // replace target element\n if (isPathArray(pathArray) && pathArray.length) {\n return pathArray;\n }\n return false;\n};\nexport default shapeToPathArray;\n","import type { ShapeParams } from \"../interface\";\nimport type { ShapeOps, ShapeTypes } from \"../types\";\nimport pathToString from \"../convert/pathToString\";\nimport defaultOptions from \"../options/options\";\nimport error from \"../parser/error\";\nimport isValidPath from \"./isValidPath\";\nimport isElement from \"./isElement\";\nimport shapeToPathArray from \"./shapeToPathArray\";\nimport shapeParams from \"./shapeParams\";\n\n/**\n * Returns a new `` element created from attributes of a ``, ``,\n * ``, ``, ``, `` or ``. If `replace` parameter\n * is `true`, it will replace the target. The default `ownerDocument` is your current\n * `document` browser page, if you want to use in server-side using `jsdom`, you can\n * pass the `jsdom` `document` to `ownDocument`.\n *\n * It can also work with an options object, see the type below\n * @see ShapeOps\n *\n * The newly created `` element keeps all non-specific\n * attributes like `class`, `fill`, etc.\n *\n * @param element target shape\n * @param replace option to replace target\n * @param ownerDocument document for create element\n * @return the newly created `` element\n */\nconst shapeToPath = (\n element: ShapeTypes | ShapeOps,\n replace?: boolean,\n ownerDocument?: Document,\n): SVGPathElement | false => {\n const doc = ownerDocument || document;\n const supportedShapes = Object.keys(shapeParams) as (keyof ShapeParams)[];\n const targetIsElement = isElement(element);\n const tagName = targetIsElement ? element.tagName : null;\n\n if (tagName === \"path\") {\n throw TypeError(`${error}: \"${tagName}\" is already SVGPathElement`);\n }\n if (tagName && supportedShapes.every((s) => tagName !== s)) {\n throw TypeError(`${error}: \"${tagName}\" is not SVGElement`);\n }\n\n const path = doc.createElementNS(\"http://www.w3.org/2000/svg\", \"path\");\n const type =\n (targetIsElement ? tagName : (element as ShapeOps).type) as ShapeOps[\n \"type\"\n ];\n const shapeAttrs = shapeParams[type] as string[];\n const config = { type } as Record;\n\n // set d\n const round = defaultOptions.round as number;\n const pathArray = shapeToPathArray(element);\n const description = pathArray && pathArray.length\n ? pathToString(pathArray, round)\n : \"\";\n\n if (targetIsElement) {\n shapeAttrs.forEach((p) => {\n config[p] = element.getAttribute(p) as string;\n });\n // set no-specific shape attributes: fill, stroke, etc\n Object.values(element.attributes).forEach(({ name, value }) => {\n if (!shapeAttrs.includes(name)) path.setAttribute(name, value);\n });\n } else {\n Object.assign(config, element);\n // set no-specific shape attributes: fill, stroke, etc\n Object.keys(config).forEach((k) => {\n if (!shapeAttrs.includes(k) && k !== \"type\") {\n path.setAttribute(\n k.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`),\n config[k],\n );\n }\n });\n }\n\n // replace target element\n if (isValidPath(description)) {\n path.setAttribute(\"d\", description);\n if (replace && targetIsElement) {\n element.before(path, element);\n element.remove();\n }\n return path;\n }\n return false;\n};\n\nexport default shapeToPath;\n","import CSSMatrix from \"@thednp/dommatrix\";\n// import type { TransformObject } from '../interface';\nimport type { TransformObjectValues } from \"../types\";\n\n/**\n * Returns a transformation matrix to apply to `` elements.\n *\n * @see TransformObjectValues\n *\n * @param transform the `transformObject`\n * @returns a new transformation matrix\n */\nconst getSVGMatrix = (transform: TransformObjectValues): CSSMatrix => {\n let matrix = new CSSMatrix();\n const { origin } = transform;\n const [originX, originY] = origin as [number, number, number];\n const { translate } = transform;\n const { rotate } = transform;\n const { skew } = transform;\n const { scale } = transform;\n\n // set translate\n if (\n Array.isArray(translate) &&\n translate.length >= 2 &&\n translate.every((x) => !Number.isNaN(+x)) &&\n translate.some((x) => x !== 0)\n ) {\n matrix = matrix.translate(...(translate as [number, number, number?]));\n } else if (typeof translate === \"number\" && !Number.isNaN(translate)) {\n matrix = matrix.translate(translate);\n }\n\n if (rotate || skew || scale) {\n // set SVG transform-origin, always defined\n matrix = matrix.translate(originX, originY);\n\n // set rotation\n if (\n Array.isArray(rotate) &&\n rotate.length >= 2 &&\n rotate.every((x) => !Number.isNaN(+x)) &&\n rotate.some((x) => x !== 0)\n ) {\n matrix = matrix.rotate(...(rotate as [number, number, number?]));\n } else if (typeof rotate === \"number\" && !Number.isNaN(rotate)) {\n matrix = matrix.rotate(rotate);\n }\n\n // set skew(s)\n if (\n Array.isArray(skew) && skew.length === 2 && skew.every((x) =>\n !Number.isNaN(+x)\n ) && skew.some((x) => x !== 0)\n ) {\n matrix = skew[0] ? matrix.skewX(skew[0]) : matrix;\n matrix = skew[1] ? matrix.skewY(skew[1]) : matrix;\n } else if (typeof skew === \"number\" && !Number.isNaN(skew)) {\n matrix = matrix.skewX(skew);\n }\n\n // set scale\n if (\n Array.isArray(scale) && scale.length >= 2 && scale.every((x) =>\n !Number.isNaN(+x)\n ) && scale.some((x) => x !== 1)\n ) {\n matrix = matrix.scale(...(scale as [number, number, number?]));\n } else if (typeof scale === \"number\" && !Number.isNaN(scale)) {\n matrix = matrix.scale(scale);\n }\n // set SVG transform-origin\n matrix = matrix.translate(-originX, -originY);\n }\n\n return matrix;\n};\nexport default getSVGMatrix;\n","import defaultOptions from \"../options/options\";\nimport type { ParserParams } from \"../interface\";\nimport roundTo from \"../math/roundTo\";\nimport type {\n AbsoluteSegment,\n NormalSegment,\n PathCommand,\n ShortSegment,\n SSegment,\n TSegment,\n} from \"../types\";\n\n/**\n * Shorten a single segment of a `pathArray` object.\n *\n * @param segment the `absoluteSegment` object\n * @param normalSegment the `normalSegment` object\n * @param params the coordinates of the previous segment\n * @param prevCommand the path command of the previous segment\n * @returns the shortened segment\n */\nconst shortenSegment = (\n segment: AbsoluteSegment,\n normalSegment: NormalSegment,\n params: ParserParams,\n prevCommand: PathCommand,\n): ShortSegment => {\n const [pathCommand] = segment;\n const { round: defaultRound } = defaultOptions;\n const round = typeof defaultRound === \"number\"\n ? defaultRound\n : /* istanbul ignore next */ 4;\n const normalValues = normalSegment.slice(1) as number[];\n const { x1, y1, x2, y2, x, y } = params;\n const [nx, ny] = normalValues.slice(-2);\n const result = segment;\n\n if (!\"TQ\".includes(pathCommand)) {\n // optional but good to be cautious\n params.qx = null;\n params.qy = null;\n }\n\n if (pathCommand === \"L\") {\n if (roundTo(x, round) === roundTo(nx, round)) {\n return [\"V\", ny];\n } else if (roundTo(y, round) === roundTo(ny, round)) {\n return [\"H\", nx];\n }\n } else if (pathCommand === \"C\") {\n const [nx1, ny1] = normalValues;\n params.x1 = nx1;\n params.y1 = ny1;\n\n if (\n \"CS\".includes(prevCommand) &&\n ((roundTo(nx1, round) === roundTo(x1 * 2 - x2, round) &&\n roundTo(ny1, round) === roundTo(y1 * 2 - y2, round)) ||\n (roundTo(x1, round) === roundTo(x2 * 2 - x, round) &&\n roundTo(y1, round) === roundTo(y2 * 2 - y, round)))\n ) {\n return [\n \"S\",\n normalValues[2],\n normalValues[3],\n normalValues[4],\n normalValues[5],\n ] as SSegment;\n }\n } else if (pathCommand === \"Q\") {\n const [qx, qy] = normalValues;\n params.qx = qx;\n params.qy = qy;\n\n if (\n \"QT\".includes(prevCommand) &&\n roundTo(qx, round) === roundTo(x1 * 2 - x2, round) &&\n roundTo(qy, round) === roundTo(y1 * 2 - y2, round)\n ) {\n return [\"T\", normalValues[2], normalValues[3]] as TSegment;\n }\n }\n\n // ['V', 'H', 'S', 'T', 'Z'].includes(pathCommand)\n return result as ShortSegment;\n};\n\nexport default shortenSegment;\n","import type { PathCommand, PathSegment } from \"../types\";\nimport roundTo from \"../math/roundTo\";\n\nconst roundSegment = (\n segment: T,\n roundOption: number,\n) => {\n const values = (segment.slice(1) as number[]).map((n) =>\n roundTo(n, roundOption)\n );\n return [segment[0] as PathCommand | number].concat(values) as T;\n};\n\nexport default roundSegment;\n","import type { AbsoluteSegment, PathArray, PathCommand } from \"../types\";\nimport pathToAbsolute from \"../convert/pathToAbsolute\";\nimport shortenSegment from \"./shortenSegment\";\nimport paramsParser from \"../parser/paramsParser\";\nimport iterate from \"./iterate\";\nimport normalizeSegment from \"./normalizeSegment\";\nimport relativizeSegment from \"./relativizeSegment\";\nimport roundSegment from \"./roundSegment\";\n\n/**\n * Optimizes a `pathArray` object:\n * * convert segments to shorthand if possible\n * * select shortest segments from absolute and relative `pathArray`s\n *\n * @param pathInput a string or `pathArray`\n * @param roundOption the amount of decimals to round values to\n * @returns the optimized `pathArray`\n */\nconst optimizePath = (pathInput: PathArray, roundOption?: number) => {\n const path = pathToAbsolute(pathInput);\n // allow for ZERO decimals or use an aggressive value of 2\n const round = typeof roundOption === \"number\" && roundOption >= 0\n ? roundOption\n : /* istanbul ignore next @preserve */ 2;\n // this utility overrides the iterator params\n const optimParams = { ...paramsParser };\n\n const allPathCommands = [] as PathCommand[];\n let pathCommand = \"M\" as PathCommand;\n let prevCommand = \"Z\" as PathCommand;\n\n return iterate(path, (seg, i, lastX, lastY) => {\n optimParams.x = lastX;\n optimParams.y = lastY;\n const normalizedSegment = normalizeSegment(seg, optimParams);\n let result = seg;\n [pathCommand] = seg;\n\n // Save current path command\n allPathCommands[i] = pathCommand;\n if (i) {\n // Get previous path command for `shortenSegment`\n prevCommand = allPathCommands[i - 1];\n const shortSegment = shortenSegment(\n seg as AbsoluteSegment,\n normalizedSegment,\n optimParams,\n prevCommand,\n );\n const absSegment = roundSegment(shortSegment, round);\n const absString = absSegment.join(\"\");\n const relativeSegment = relativizeSegment(shortSegment, i, lastX, lastY);\n const relSegment = roundSegment(relativeSegment, round);\n const relString = relSegment.join(\"\");\n result = absString.length < relString.length ? absSegment : relSegment;\n }\n\n const seglen = normalizedSegment.length;\n optimParams.x1 = +normalizedSegment[seglen - 2];\n optimParams.y1 = +normalizedSegment[seglen - 1];\n optimParams.x2 = +normalizedSegment[seglen - 4] || optimParams.x1;\n optimParams.y2 = +normalizedSegment[seglen - 3] || optimParams.y1;\n\n return result;\n });\n};\n\nexport default optimizePath;\n","import CSSMatrix from \"@thednp/dommatrix\";\nimport { type PointTuple } from \"../types\";\n\n/**\n * Transforms a specified point using a matrix, returning a new\n * Tuple *Object* comprising of the transformed point.\n * Neither the matrix nor the original point are altered.\n *\n * @copyright thednp © 2021\n *\n * @param cssm CSSMatrix instance\n * @param v Tuple\n * @return the resulting Tuple\n */\nconst translatePoint = (\n cssm: CSSMatrix,\n v: [number, number, number, number],\n): [number, number, number, number] => {\n let m = CSSMatrix.Translate(v[0], v[1], v[2]);\n\n [, , , m.m44] = v;\n m = cssm.multiply(m);\n\n return [m.m41, m.m42, m.m43, m.m44];\n};\n\n/**\n * Returns the [x,y] projected coordinates for a given an [x,y] point\n * and an [x,y,z] perspective origin point.\n *\n * Equation found here =>\n * http://en.wikipedia.org/wiki/3D_projection#Diagram\n * Details =>\n * https://stackoverflow.com/questions/23792505/predicted-rendering-of-css-3d-transformed-pixel\n *\n * @param m the transformation matrix\n * @param point2D the initial [x,y] coordinates\n * @param origin the [x,y,z] transform origin\n * @returns the projected [x,y] coordinates\n */\nconst projection2d = (\n m: CSSMatrix,\n point2D: PointTuple,\n origin: [number, number, number],\n): PointTuple => {\n const [originX, originY, originZ] = origin;\n const [x, y, z] = translatePoint(m, [point2D[0], point2D[1], 0, 1]);\n\n const relativePositionX = x - originX;\n const relativePositionY = y - originY;\n const relativePositionZ = z - originZ;\n\n return [\n // protect against division by ZERO\n relativePositionX * (Math.abs(originZ) / Math.abs(relativePositionZ) || 1) +\n originX,\n relativePositionY * (Math.abs(originZ) / Math.abs(relativePositionZ) || 1) +\n originY,\n ];\n};\nexport default projection2d;\n","import type { CSegment, CurveArray, MSegment, PathCommand } from \"../types\";\n\n/**\n * Reverses all segments of a `pathArray`\n * which consists of only C (cubic-bezier) path commands.\n *\n * @param path the source `pathArray`\n * @returns the reversed `pathArray`\n */\nconst reverseCurve = (path: CurveArray) => {\n const rotatedCurve = path\n .slice(1)\n .map((x, i, curveOnly) =>\n !i\n ? path[0].slice(1).concat(x.slice(1) as number[])\n : curveOnly[i - 1].slice(-2).concat(x.slice(1))\n )\n .map((x) => x.map((_, i) => x[x.length - i - 2 * (1 - (i % 2))]))\n .reverse() as (MSegment | CSegment)[];\n\n return [[\"M\" as PathCommand | number].concat(rotatedCurve[0].slice(0, 2))]\n .concat(\n rotatedCurve.map((x) => [\"C\" as PathCommand | number].concat(x.slice(2))),\n ) as CurveArray;\n};\n\nexport default reverseCurve;\n","import type {\n ASegment,\n CSegment,\n HSegment,\n MSegment,\n PathArray,\n PathSegment,\n PointTuple,\n QSegment,\n SSegment,\n TSegment,\n VSegment,\n} from \"../types\";\nimport pathToAbsolute from \"../convert/pathToAbsolute\";\nimport normalizePath from \"./normalizePath\";\nimport iterate from \"./iterate\";\n\n/**\n * Reverses all segments of a `pathArray` and returns a new `pathArray` instance\n * with absolute values.\n *\n * @param pathInput the source `pathArray`\n * @returns the reversed `pathArray`\n */\nconst reversePath = (pathInput: PathArray) => {\n const absolutePath = pathToAbsolute(pathInput);\n const normalizedPath = normalizePath(absolutePath);\n const pLen = absolutePath.length;\n const isClosed = absolutePath[pLen - 1][0] === \"Z\";\n\n const reversedPath = iterate(absolutePath, (segment, i) => {\n const normalizedSegment = normalizedPath[i];\n const prevSeg = i && absolutePath[i - 1];\n const prevCommand = prevSeg && prevSeg[0];\n const nextSeg = absolutePath[i + 1];\n const nextCommand = nextSeg && nextSeg[0];\n const [pathCommand] = segment;\n const [x, y] = normalizedPath[i ? i - 1 : pLen - 1].slice(-2) as PointTuple;\n let result = segment;\n\n switch (pathCommand) {\n case \"M\":\n result = (isClosed ? [\"Z\"] : [pathCommand, x, y]) as PathSegment;\n break;\n case \"A\":\n result = [\n pathCommand,\n segment[1],\n segment[2],\n segment[3],\n segment[4],\n segment[5] === 1 ? 0 : 1,\n x,\n y,\n ] as ASegment;\n break;\n case \"C\":\n if (nextSeg && nextCommand === \"S\") {\n result = [\"S\", segment[1], segment[2], x, y] as SSegment;\n } else {\n result = [\n pathCommand,\n segment[3],\n segment[4],\n segment[1],\n segment[2],\n x,\n y,\n ] as CSegment;\n }\n break;\n case \"S\":\n if (\n prevCommand && \"CS\".includes(prevCommand) &&\n (!nextSeg || nextCommand !== \"S\")\n ) {\n result = [\n \"C\",\n normalizedSegment[3],\n normalizedSegment[4],\n normalizedSegment[1],\n normalizedSegment[2],\n x,\n y,\n ] as CSegment;\n } else {\n result = [\n pathCommand,\n normalizedSegment[1],\n normalizedSegment[2],\n x,\n y,\n ] as SSegment;\n }\n break;\n case \"Q\":\n if (nextSeg && nextCommand === \"T\") {\n result = [\"T\", x, y] as TSegment;\n } else {\n result = [pathCommand, segment[1], segment[2], x, y] as QSegment;\n }\n break;\n case \"T\":\n if (\n prevCommand && \"QT\".includes(prevCommand) &&\n (!nextSeg || nextCommand !== \"T\")\n ) {\n result = [\n \"Q\",\n normalizedSegment[1],\n normalizedSegment[2],\n x,\n y,\n ] as QSegment;\n } else {\n result = [pathCommand, x, y] as TSegment;\n }\n break;\n case \"Z\":\n result = [\"M\", x, y] as MSegment;\n break;\n case \"H\":\n result = [pathCommand, x] as HSegment;\n break;\n case \"V\":\n result = [pathCommand, y] as VSegment;\n break;\n default:\n result = [pathCommand as typeof pathCommand | number].concat(\n segment.slice(1, -2),\n x,\n y,\n ) as PathSegment;\n }\n\n return result;\n });\n\n return (\n isClosed\n ? reversedPath.reverse()\n : [reversedPath[0] as PathSegment].concat(reversedPath.slice(1).reverse())\n ) as PathArray;\n};\n\nexport default reversePath;\n","import type { PathArray } from \"../types\";\nimport defaultOptions from \"../options/options\";\nimport iterate from \"./iterate\";\nimport roundSegment from \"./roundSegment\";\n\n/**\n * Rounds the values of a `pathArray` instance to\n * a specified amount of decimals and returns it.\n *\n * @param path the source `pathArray`\n * @param roundOption the amount of decimals to round numbers to\n * @returns the resulted `pathArray` with rounded values\n */\nconst roundPath = (path: PathArray, roundOption?: number | \"off\") => {\n let { round } = defaultOptions;\n // allow for ZERO decimals\n round = roundOption === \"off\"\n ? roundOption\n : typeof roundOption === \"number\" && roundOption >= 0\n ? roundOption\n : typeof round === \"number\" && round >= 0\n ? round\n : /* istanbul ignore next @preserve */ \"off\";\n\n /* istanbul ignore else @preserve */\n if (round === \"off\") return path.slice(0) as PathArray;\n\n return iterate(path, (segment) => {\n return roundSegment(segment, round);\n });\n};\nexport default roundPath;\n","import midPoint from \"../math/midPoint\";\nimport type { CubicSegment, PointTuple } from \"../types\";\n\n/**\n * Split a cubic-bezier segment into two.\n *\n * @param pts the cubic-bezier parameters\n * @param ratio the cubic-bezier parameters\n * @return two new cubic-bezier segments\n */\nconst splitCubic = (\n pts: number[],\n ratio = 0.5,\n): [CubicSegment, CubicSegment] => {\n const t = ratio;\n const p0 = pts.slice(0, 2) as PointTuple;\n const p1 = pts.slice(2, 4) as PointTuple;\n const p2 = pts.slice(4, 6) as PointTuple;\n const p3 = pts.slice(6, 8) as PointTuple;\n const p4 = midPoint(p0, p1, t);\n const p5 = midPoint(p1, p2, t);\n const p6 = midPoint(p2, p3, t);\n const p7 = midPoint(p4, p5, t);\n const p8 = midPoint(p5, p6, t);\n const p9 = midPoint(p7, p8, t);\n\n return [\n [\"C\", p4[0], p4[1], p7[0], p7[1], p9[0], p9[1]],\n [\"C\", p8[0], p8[1], p6[0], p6[1], p3[0], p3[1]],\n ];\n};\nexport default splitCubic;\n","import paramsParser from \"../parser/paramsParser\";\nimport type {\n AbsoluteCommand,\n HSegment,\n MSegment,\n PathArray,\n PointTuple,\n RelativeCommand,\n VSegment,\n} from \"../types\";\n\n/**\n * Split a path into an `Array` of sub-path strings.\n *\n * In the process, values are converted to absolute\n * for visual consistency.\n *\n * @param pathInput the source `pathArray`\n * @return an array with all sub-path strings\n */\nconst splitPath = (pathInput: PathArray): PathArray[] => {\n const composite = [] as PathArray[];\n let path: PathArray;\n let pi = -1;\n let x = 0;\n let y = 0;\n let mx = 0;\n let my = 0;\n const params = { ...paramsParser };\n\n pathInput.forEach((seg) => {\n const [pathCommand] = seg;\n const absCommand = pathCommand.toUpperCase() as AbsoluteCommand;\n const relCommand = pathCommand.toLowerCase() as RelativeCommand;\n const isRelative = pathCommand === relCommand;\n const values = seg.slice(1) as number[];\n\n if (absCommand === \"M\") {\n pi += 1;\n [x, y] = values as PointTuple;\n x += isRelative ? params.x : 0;\n y += isRelative ? params.y : 0;\n mx = x;\n my = y;\n path = [(isRelative ? [absCommand, mx, my] : seg) as MSegment];\n } else {\n if (absCommand === \"Z\") {\n x = mx;\n y = my;\n } else if (absCommand === \"H\") {\n [, x] = seg as HSegment;\n x += isRelative ? params.x : /* istanbul ignore next @preserve */ 0;\n } else if (absCommand === \"V\") {\n [, y] = seg as VSegment;\n y += isRelative ? params.y : /* istanbul ignore next @preserve */ 0;\n } else {\n [x, y] = seg.slice(-2) as PointTuple;\n x += isRelative ? params.x : 0;\n y += isRelative ? params.y : 0;\n }\n path.push(seg);\n }\n\n params.x = x;\n params.y = y;\n composite[pi] = path;\n });\n\n return composite;\n};\nexport default splitPath;\n","import getSVGMatrix from \"./getSVGMatrix\";\nimport projection2d from \"./projection2d\";\nimport defaultOptions from \"../options/options\";\nimport type {\n AbsoluteArray,\n AbsoluteSegment,\n CSegment,\n LSegment,\n PathArray,\n TransformObjectValues,\n} from \"../types\";\nimport type { TransformObject } from \"../interface\";\nimport iterate from \"./iterate\";\nimport parsePathString from \"../parser/parsePathString\";\nimport absolutizeSegment from \"./absolutizeSegment\";\nimport arcToCubic from \"./arcToCubic\";\n\n/**\n * Apply a 2D / 3D transformation to a `pathArray` instance.\n *\n * Since *SVGElement* doesn't support 3D transformation, this function\n * creates a 2D projection of the element.\n *\n * @param path the `pathArray` to apply transformation\n * @param transform the transform functions `Object`\n * @returns the resulted `pathArray`\n */\nconst transformPath = (\n pathInput: PathArray | string,\n transform?: Partial,\n) => {\n // last x and y transformed values\n let x = 0;\n let y = 0;\n // new x and y transformed\n let lx = 0;\n let ly = 0;\n // segment params iteration index and length\n let j = 0;\n let jj = 0;\n let pathCommand = \"M\";\n // transform uses it's own set of params\n const path = parsePathString(pathInput);\n const transformProps = transform && Object.keys(transform);\n\n // when used as a static method, invalidate somehow\n if (!transform || (transformProps && !transformProps.length)) {\n return path.slice(0) as typeof path;\n }\n\n // transform origin is extremely important\n if (!transform.origin) {\n Object.assign(transform, { origin: defaultOptions.origin });\n }\n const origin = transform.origin as [number, number, number];\n const matrixInstance = getSVGMatrix(transform as TransformObjectValues);\n\n if (matrixInstance.isIdentity) return path.slice(0) as typeof path;\n\n return iterate(path, (seg, index, lastX, lastY) => {\n [pathCommand] = seg;\n const absCommand = pathCommand.toUpperCase();\n const isRelative = absCommand !== pathCommand;\n const absoluteSegment = isRelative\n ? absolutizeSegment(seg, index, lastX, lastY)\n : (seg.slice(0) as AbsoluteSegment);\n\n let result = absCommand === \"A\"\n // ? segmentToCubic(absoluteSegment, transformParams)\n ? ([\"C\" as string | number].concat(\n arcToCubic(\n lastX,\n lastY,\n absoluteSegment[1] as number,\n absoluteSegment[2] as number,\n absoluteSegment[3] as number,\n absoluteSegment[4] as number,\n absoluteSegment[5] as number,\n absoluteSegment[6] as number,\n absoluteSegment[7] as number,\n ),\n ) as CSegment)\n : absCommand === \"V\"\n ? ([\"L\", lastX, absoluteSegment[1]] as LSegment)\n : absCommand === \"H\"\n ? ([\"L\", absoluteSegment[1], lastY] as LSegment)\n : absoluteSegment;\n\n // update pathCommand\n pathCommand = result[0];\n const isLongArc = pathCommand === \"C\" && result.length > 7;\n const tempSegment =\n (isLongArc ? result.slice(0, 7) : result.slice(0)) as AbsoluteSegment;\n\n if (isLongArc) {\n path.splice(\n index + 1,\n 0,\n [\"C\" as typeof pathCommand | number].concat(\n result.slice(7),\n ) as CSegment,\n );\n result = tempSegment as CSegment;\n }\n\n if (pathCommand === \"L\") {\n [lx, ly] = projection2d(matrixInstance, [\n (result as LSegment)[1],\n (result as LSegment)[2],\n ], origin);\n\n /* istanbul ignore else @preserve */\n if (x !== lx && y !== ly) {\n result = [\"L\", lx, ly];\n } else if (y === ly) {\n result = [\"H\", lx];\n } else if (x === lx) {\n result = [\"V\", ly];\n }\n } else {\n for (j = 1, jj = result.length; j < jj; j += 2) {\n [lx, ly] = projection2d(\n matrixInstance,\n [+result[j], +result[j + 1]],\n origin,\n );\n result[j] = lx;\n result[j + 1] = ly;\n }\n }\n // now update x and y\n x = lx;\n y = ly;\n\n return result;\n });\n};\n\nexport default transformPath;\n"],"mappings":"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","names":["src_exports","__export","defaultExport","util_exports","__export","y","absolutizeSegment_default","arcToCubic_default","arcTools_exports","bezier_exports","cubicTools_exports","distanceEpsilon_default","distanceSquareRoot_default","finalizeSegment_default","getClosestPoint_default","getDrawDirection_default","getPathArea_default","getPathBBox_default","getPointAtLength_default","getPropertiesAtLength_default","getPropertiesAtPoint_default","getSVGMatrix_default","getSegmentAtLength_default","getSegmentOfPoint_default","getTotalLength_default","invalidPathValue_default","isAbsoluteArray_default","isArcCommand_default","isCurveArray_default","isDigit_default","isDigitStart_default","isMoveCommand_default","isNormalizedArray_default","isPathArray_default","isPathCommand_default","isPointInStroke_default","isRelativeArray_default","isSpace_default","isValidPath_default","iterate_default","lineToCubic_default","lineTools_exports","midPoint_default","normalizePath_default","normalizeSegment_default","optimizePath_default","paramsCount_default","paramsParser_default","parsePathString_default","PathParser","pathToAbsolute_default","pathToCurve_default","pathToRelative_default","pathToString_default","polygonTools_exports","projection2d_default","quadToCubic_default","quadTools_exports","relativizeSegment_default","reverseCurve_default","reversePath_default","rotateVector_default","roundPath_default","roundSegment_default","roundTo_default","scanFlag_default","scanParam_default","scanSegment_default","segmentToCubic_default","shapeParams_default","shapeToPath_default","shapeToPathArray_default","shortenSegment_default","skipSpaces_default","splitCubic_default","splitPath_default","transformPath_default","JSON_MATRIX","isCompatibleArray","array","x","isCompatibleObject","object","CSSMatrix","k","fromArray","m","a","m11","m12","m13","m14","m21","m22","m23","m24","m31","m32","m33","m34","m41","m42","m43","m44","M11","M12","M21","M22","M41","M42","fromMatrix","fromString","source","str","invalidStringError","f","tf","prop","value","components","n","y","z","xyz","xyza","values","sy","p","fn","axis","idx","def","axeValues","toArray","is2D","Translate","Rotate","rx","ry","rz","degToRad","radX","radY","radZ","cosx","sinx","cosy","siny","cosz","sinz","RotateAxisAngle","alpha","length","X","Y","Z","angle","sinA","cosA","sinA2","x2","y2","z2","Scale","Skew","angleX","angleY","tX","tY","SkewX","SkewY","Multiply","m1","m2","init","isIdentity","RX","RY","RZ","t","w","__publicField","arcTools_exports","__export","angleBetween","arcLength","arcPoint","getArcBBox","getArcLength","getArcProps","getPointAtArcLength","lineTools_exports","__export","getLineBBox","getLineLength","getPointAtLineLength","midPoint","a","b","t","ax","ay","bx","by","midPoint_default","distanceSquareRoot","a","b","distanceSquareRoot_default","getLineLength","x1","y1","x2","y2","distanceSquareRoot_default","getPointAtLineLength","distance","point","length","x","y","midPoint_default","getLineBBox","min","max","arcLength","rx","ry","theta","halfTheta","sinHalfTheta","cosHalfTheta","term1","term2","length","arcPoint","cx","cy","alpha","sin","cos","cosA","sinA","x","y","angleBetween","v0","v1","v0x","v0y","v1x","v1y","p","n","getArcProps","x1","y1","RX","RY","angle","LAF","SF","abs","sqrt","PI","xRotRad","dx","dy","transformedPoint","radiiCheck","cSquareNumerator","cSquareRootDenom","cRadicand","cCoef","transformedCenter","center","startVector","startAngle","endVector","sweepAngle","endAngle","getArcLength","getPointAtArcLength","distance","point","getPointAtLineLength","ellipseComponentX","ellipseComponentY","getArcBBox","deltaAngle","min","max","tan","atan2","tangent","angle1","angle2","angle3","angle4","xArray","yArray","xMin","xMax","yMin","yMax","angleAfterStart","pP2","angleBeforeEnd","pP3","p1","p2","p4","p3","bezier_exports","__export","CBEZIER_MINMAX_EPSILON","Cvalues","Tvalues","bezierLength","calculateBezier","computeBezier","deriveBezier","getBezierLength","minmaxC","minmaxQ","points","dpoints","p","d","c","list","j","t","order","mt","mt2","t2","a","b","derivativeFn","l","len","sum","i","curve","idx","step","v1","cp","v2","min","max","E","cp1","cp2","K","T","S","L","R","Q","cubicTools_exports","__export","getCubicBBox","getCubicLength","getPointAtCubicLength","getPointAtCubicSegmentLength","getPointAtCubicSegmentLength","x1","y1","c1x","c1y","c2x","c2y","x2","y2","t","t1","getCubicLength","getBezierLength","getPointAtCubicLength","distance","distanceIsNumber","point","currentLength","getCubicBBox","cxMinMax","minmaxC","cyMinMax","quadTools_exports","__export","getPointAtQuadLength","getPointAtQuadSegmentLength","getQuadBBox","getQuadLength","getPointAtQuadSegmentLength","x1","y1","cx","cy","x2","y2","t","t1","getQuadLength","getBezierLength","getPointAtQuadLength","distance","distanceIsNumber","point","currentLength","getQuadBBox","cxMinMax","minmaxQ","cyMinMax","polygonTools_exports","__export","polygonArea","polygonLength","polygonArea","polygon","n","i","a","b","area","polygonLength","length","point","distanceSquareRoot_default","paramsCount","paramsCount_default","finalizeSegment","path","pathCommand","relativeCommand","data","paramsCount_default","finalizeSegment_default","error","error_default","scanFlag","path","index","pathValue","code","error_default","scanFlag_default","isDigit","code","isDigit_default","invalidPathValue","invalidPathValue_default","scanParam","path","max","pathValue","start","index","zeroFirst","hasCeiling","hasDecimal","hasDot","ch","error_default","invalidPathValue_default","isDigit_default","scanParam_default","isSpace","ch","isSpace_default","skipSpaces","path","pathValue","max","isSpace_default","skipSpaces_default","isPathCommand","code","isPathCommand_default","isDigitStart","code","isDigit_default","isDigitStart_default","isArcCommand","code","isArcCommand_default","isMoveCommand","code","isMoveCommand_default","scanSegment","path","max","pathValue","index","segments","cmdCode","reqParams","paramsCount_default","isPathCommand_default","error_default","invalidPathValue_default","lastSegment","isMoveCommand_default","skipSpaces_default","finalizeSegment_default","i","isArcCommand_default","scanFlag_default","scanParam_default","isDigitStart_default","scanSegment_default","PathParser","pathString","parsePathString","pathInput","path","PathParser","skipSpaces_default","scanSegment_default","parsePathString_default","absolutizeSegment","segment","index","lastX","lastY","pathCommand","absCommand","isAbsolute","absValues","seglen","j","absolutizeSegment_default","iterate","path","iterator","pathLen","segment","pathCommand","absCommand","isRelative","x","y","mx","my","segLen","i","iteratorResult","iterate_default","pathToAbsolute","pathInput","path","parsePathString_default","iterate_default","absolutizeSegment_default","pathToAbsolute_default","relativizeSegment","segment","index","lastX","lastY","pathCommand","relCommand","isRelative","relValues","seglen","j","relativizeSegment_default","pathToRelative","pathInput","path","parsePathString_default","iterate_default","relativizeSegment_default","pathToRelative_default","rotateVector","x","y","rad","sin","cos","X","Y","rotateVector_default","arcToCubic","X1","Y1","RX","RY","angle","LAF","SF","X2","Y2","recursive","x1","y1","rx","ry","x2","y2","d120","rad","res","xy","f1","f2","cx","cy","rotateVector_default","x","y","h","rx2","ry2","k","df","f2old","x2old","y2old","c1","s1","c2","s2","t","hx","hy","m1","m2","m3","m4","newres","i","ii","arcToCubic_default","quadToCubic","x1","y1","qx","qy","x2","y2","r13","r23","quadToCubic_default","lineToCubic","x1","y1","x2","y2","c1","midPoint_default","c2","lineToCubic_default","segmentToCubic","segment","params","pathCommand","values","x","y","px1","py1","px","py","arcToCubic_default","quadToCubic_default","lineToCubic_default","segmentToCubic_default","normalizeSegment","segment","params","pathCommand","absCommand","isRelative","px1","py1","px2","py2","x","y","values","absValues","n","j","x1","y1","qx","qy","nqx","nqy","normalizeSegment_default","paramsParser","paramsParser_default","pathToCurve","pathInput","params","paramsParser_default","path","parsePathString_default","iterate_default","seg","index","lastX","lastY","normalSegment","normalizeSegment_default","result","segmentToCubic_default","seglen","pathToCurve_default","defaultOptions","options_default","roundTo","n","round","pow","roundTo_default","pathToString","path","roundOption","pathLen","round","options_default","segment","result","i","pathCommand","values","j","valLen","roundTo_default","pathToString_default","distanceEpsilon_default","normalizePath","pathInput","path","parsePathString_default","params","paramsParser_default","iterate_default","seg","_","lastX","lastY","result","normalizeSegment_default","seglen","normalizePath_default","getPointAtLength","pathInput","distance","path","normalizePath_default","isM","data","pathCommand","x","y","mx","my","distanceIsNumber","point","length","POINT","totalLength","distanceEpsilon_default","iterate_default","seg","_","lastX","lastY","getPointAtLineLength","getLineLength","getPointAtArcLength","getArcLength","getPointAtCubicLength","getCubicLength","getPointAtQuadLength","getQuadLength","getPointAtLength_default","getTotalLength","pathInput","path","parsePathString_default","paramX1","paramY1","paramX2","paramY2","paramQX","paramQY","pathCommand","mx","my","totalLength","iterate_default","seg","index","lastX","lastY","absCommand","absoluteSegment","absolutizeSegment_default","normalSegment","getLineLength","getArcLength","cp1x","cp1y","getCubicLength","getQuadLength","getTotalLength_default","getPropertiesAtLength","pathInput","distance","pathArray","parsePathString_default","pathTemp","pathLength","getTotalLength_default","index","lengthAtSegment","length","segment","segments","getPropertiesAtLength_default","getPropertiesAtPoint","pathInput","point","path","parsePathString_default","normalPath","normalizePath_default","pathLength","getTotalLength_default","distanceTo","p","dx","dy","precision","scan","closest","scanDistance","bestLength","bestDistance","scanLength","getPointAtLength_default","before","after","beforeLength","afterLength","beforeDistance","afterDistance","segment","getPropertiesAtLength_default","distance","getPropertiesAtPoint_default","getClosestPoint","pathInput","point","getPropertiesAtPoint_default","getClosestPoint_default","getCubicSegArea","x1","y1","c1x","c1y","c2x","c2y","x2","y2","getPathArea","path","x","y","len","pathToCurve_default","seg","a","b","getPathArea_default","getDrawDirection","path","getPathArea_default","pathToCurve_default","getDrawDirection_default","getPathBBox","pathInput","path","parsePathString_default","pathCommand","mx","my","max","min","xMin","yMin","xMax","yMax","minX","minY","maxX","maxY","paramX1","paramY1","paramX2","paramY2","paramQX","paramQY","iterate_default","seg","index","lastX","lastY","absCommand","absoluteSegment","absolutizeSegment_default","normalSegment","getLineBBox","getArcBBox","cp1x","cp1y","getCubicBBox","getQuadBBox","width","height","getPathBBox_default","getSegmentAtLength","pathInput","distance","getPropertiesAtLength_default","getSegmentAtLength_default","getSegmentOfPoint","path","point","getPropertiesAtPoint_default","getSegmentOfPoint_default","isPathArray","path","seg","lk","paramsCount_default","isPathArray_default","isAbsoluteArray","path","isPathArray_default","x","isAbsoluteArray_default","isNormalizedArray","path","isAbsoluteArray_default","pc","isNormalizedArray_default","isCurveArray","path","isNormalizedArray_default","pc","isCurveArray_default","isPointInStroke","pathInput","point","distance","getPropertiesAtPoint_default","distanceEpsilon_default","isPointInStroke_default","isRelativeArray","path","isPathArray_default","pc","isRelativeArray_default","isValidPath","pathString","path","PathParser","skipSpaces_default","scanSegment_default","isValidPath_default","shapeParams","shapeParams_default","isElement","node","isElement_default","getLinePath","attr","x1","y1","x2","y2","getPolyPath","pathArray","points","a","index","getCirclePath","cx","cy","r","getEllipsePath","rx","ry","getRectanglePath","x","y","w","h","shapeToPathArray","element","supportedShapes","shapeParams_default","targetIsElement","isElement_default","tagName","error_default","type","shapeAttrs","config","p","parsePathString_default","isPathArray_default","shapeToPathArray_default","shapeToPath","element","replace","ownerDocument","doc","supportedShapes","shapeParams_default","targetIsElement","isElement_default","tagName","error_default","s","path","type","shapeAttrs","config","round","options_default","pathArray","shapeToPathArray_default","description","pathToString_default","p","name","value","k","m","isValidPath_default","shapeToPath_default","getSVGMatrix","transform","matrix","y","origin","originX","originY","translate","rotate","skew","scale","x","getSVGMatrix_default","shortenSegment","segment","normalSegment","params","prevCommand","pathCommand","defaultRound","options_default","round","normalValues","x1","y1","x2","y2","x","y","nx","ny","result","roundTo_default","nx1","ny1","qx","qy","shortenSegment_default","roundSegment","segment","roundOption","values","n","roundTo_default","roundSegment_default","optimizePath","pathInput","roundOption","path","pathToAbsolute_default","round","optimParams","paramsParser_default","allPathCommands","pathCommand","prevCommand","iterate_default","seg","i","lastX","lastY","normalizedSegment","normalizeSegment_default","result","shortSegment","shortenSegment_default","absSegment","roundSegment_default","absString","relativeSegment","relativizeSegment_default","relSegment","relString","seglen","optimizePath_default","translatePoint","cssm","v","m","y","projection2d","point2D","origin","originX","originY","originZ","x","z","relativePositionX","relativePositionY","relativePositionZ","projection2d_default","reverseCurve","path","rotatedCurve","x","i","curveOnly","_","reverseCurve_default","reversePath","pathInput","absolutePath","pathToAbsolute_default","normalizedPath","normalizePath_default","pLen","isClosed","reversedPath","iterate_default","segment","normalizedSegment","prevSeg","prevCommand","nextSeg","nextCommand","pathCommand","x","y","result","reversePath_default","roundPath","path","roundOption","round","options_default","iterate_default","segment","roundSegment_default","roundPath_default","splitCubic","pts","ratio","t","p0","p1","p2","p3","p4","midPoint_default","p5","p6","p7","p8","p9","splitCubic_default","splitPath","pathInput","composite","path","pi","x","y","mx","my","params","paramsParser_default","seg","pathCommand","absCommand","relCommand","isRelative","values","splitPath_default","transformPath","pathInput","transform","x","y","lx","ly","j","jj","pathCommand","path","parsePathString_default","transformProps","options_default","origin","matrixInstance","getSVGMatrix_default","iterate_default","seg","index","lastX","lastY","absCommand","absoluteSegment","absolutizeSegment_default","result","arcToCubic_default","isLongArc","tempSegment","projection2d_default","transformPath_default","SVGPathCommander","pathValue","config","instanceOptions","undefPath","error_default","parsePathString_default","roundOption","originOption","round","options_default","origin","originX","originY","originZ","getPathBBox_default","getTotalLength_default","length","getPointAtLength_default","segments","pathToAbsolute_default","pathToRelative_default","pathToCurve_default","onlySubpath","split","splitPath_default","subPath","absoluteMultiPath","x","i","reversePath_default","path","normalizePath_default","optimizePath_default","source","cx","cy","cz","transform","k","v","transformPath_default","pathToString_default","key","defaultExport","util_exports"]} \ No newline at end of file diff --git a/dist/svg-path-commander.mjs b/dist/svg-path-commander.mjs index 323a5fa..4cb7366 100644 --- a/dist/svg-path-commander.mjs +++ b/dist/svg-path-commander.mjs @@ -1,2123 +1,2 @@ -var Et = Object.defineProperty, Ot = (t, e, r) => e in t ? Et(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r, I = (t, e, r) => Ot(t, typeof e != "symbol" ? e + "" : e, r); -const Vt = { - a: 1, - b: 0, - c: 0, - d: 1, - e: 0, - f: 0, - m11: 1, - m12: 0, - m13: 0, - m14: 0, - m21: 0, - m22: 1, - m23: 0, - m24: 0, - m31: 0, - m32: 0, - m33: 1, - m34: 0, - m41: 0, - m42: 0, - m43: 0, - m44: 1, - is2D: !0, - isIdentity: !0 -}, Fe = (t) => (t instanceof Float64Array || t instanceof Float32Array || Array.isArray(t) && t.every((e) => typeof e == "number")) && [6, 16].some((e) => t.length === e), Ue = (t) => t instanceof DOMMatrix || t instanceof P || typeof t == "object" && Object.keys(Vt).every((e) => t && e in t), oe = (t) => { - const e = new P(), r = Array.from(t); - if (!Fe(r)) - throw TypeError( - `CSSMatrix: "${r.join(",")}" must be an array with 6/16 numbers.` - ); - if (r.length === 16) { - const [ - s, - n, - o, - i, - l, - c, - a, - m, - h, - f, - y, - u, - g, - p, - b, - M - ] = r; - e.m11 = s, e.a = s, e.m21 = l, e.c = l, e.m31 = h, e.m41 = g, e.e = g, e.m12 = n, e.b = n, e.m22 = c, e.d = c, e.m32 = f, e.m42 = p, e.f = p, e.m13 = o, e.m23 = a, e.m33 = y, e.m43 = b, e.m14 = i, e.m24 = m, e.m34 = u, e.m44 = M; - } else if (r.length === 6) { - const [s, n, o, i, l, c] = r; - e.m11 = s, e.a = s, e.m12 = n, e.b = n, e.m21 = o, e.c = o, e.m22 = i, e.d = i, e.m41 = l, e.e = l, e.m42 = c, e.f = c; - } - return e; -}, Ge = (t) => { - if (Ue(t)) - return oe([ - t.m11, - t.m12, - t.m13, - t.m14, - t.m21, - t.m22, - t.m23, - t.m24, - t.m31, - t.m32, - t.m33, - t.m34, - t.m41, - t.m42, - t.m43, - t.m44 - ]); - throw TypeError( - `CSSMatrix: "${JSON.stringify(t)}" is not a DOMMatrix / CSSMatrix / JSON compatible object.` - ); -}, Je = (t) => { - if (typeof t != "string") - throw TypeError(`CSSMatrix: "${JSON.stringify(t)}" is not a string.`); - const e = String(t).replace(/\s/g, ""); - let r = new P(); - const s = `CSSMatrix: invalid transform string "${t}"`; - return e.split(")").filter((n) => n).forEach((n) => { - const [o, i] = n.split("("); - if (!i) throw TypeError(s); - const l = i.split(",").map( - (u) => u.includes("rad") ? parseFloat(u) * (180 / Math.PI) : parseFloat(u) - ), [c, a, m, h] = l, f = [c, a, m], y = [c, a, m, h]; - if (o === "perspective" && c && [a, m].every((u) => u === void 0)) - r.m34 = -1 / c; - else if (o.includes("matrix") && [6, 16].includes(l.length) && l.every((u) => !Number.isNaN(+u))) { - const u = l.map((g) => Math.abs(g) < 1e-6 ? 0 : g); - r = r.multiply(oe(u)); - } else if (o === "translate3d" && f.every((u) => !Number.isNaN(+u))) - r = r.translate(c, a, m); - else if (o === "translate" && c && m === void 0) - r = r.translate(c, a || 0, 0); - else if (o === "rotate3d" && y.every((u) => !Number.isNaN(+u)) && h) - r = r.rotateAxisAngle(c, a, m, h); - else if (o === "rotate" && c && [a, m].every((u) => u === void 0)) - r = r.rotate(0, 0, c); - else if (o === "scale3d" && f.every((u) => !Number.isNaN(+u)) && f.some((u) => u !== 1)) - r = r.scale(c, a, m); - else if ( - // prop === "scale" && !Number.isNaN(x) && x !== 1 && z === undefined - // prop === "scale" && !Number.isNaN(x) && [x, y].some((n) => n !== 1) && - o === "scale" && !Number.isNaN(c) && (c !== 1 || a !== 1) && m === void 0 - ) { - const u = Number.isNaN(+a) ? c : a; - r = r.scale(c, u, 1); - } else if (o === "skew" && (c || !Number.isNaN(c) && a) && m === void 0) - r = r.skew(c, a || 0); - else if (["translate", "rotate", "scale", "skew"].some( - (u) => o.includes(u) - ) && /[XYZ]/.test(o) && c && [a, m].every((u) => u === void 0)) - if (o === "skewX" || o === "skewY") - r = r[o](c); - else { - const u = o.replace(/[XYZ]/, ""), g = o.replace(u, ""), p = ["X", "Y", "Z"].indexOf(g), b = u === "scale" ? 1 : 0, M = [ - p === 0 ? c : b, - p === 1 ? c : b, - p === 2 ? c : b - ]; - r = r[u](...M); - } - else - throw TypeError(s); - }), r; -}, Le = (t, e) => e ? [t.a, t.b, t.c, t.d, t.e, t.f] : [ - t.m11, - t.m12, - t.m13, - t.m14, - t.m21, - t.m22, - t.m23, - t.m24, - t.m31, - t.m32, - t.m33, - t.m34, - t.m41, - t.m42, - t.m43, - t.m44 -], Ke = (t, e, r) => { - const s = new P(); - return s.m41 = t, s.e = t, s.m42 = e, s.f = e, s.m43 = r, s; -}, We = (t, e, r) => { - const s = new P(), n = Math.PI / 180, o = t * n, i = e * n, l = r * n, c = Math.cos(o), a = -Math.sin(o), m = Math.cos(i), h = -Math.sin(i), f = Math.cos(l), y = -Math.sin(l), u = m * f, g = -m * y; - s.m11 = u, s.a = u, s.m12 = g, s.b = g, s.m13 = h; - const p = a * h * f + c * y; - s.m21 = p, s.c = p; - const b = c * f - a * h * y; - return s.m22 = b, s.d = b, s.m23 = -a * m, s.m31 = a * y - c * h * f, s.m32 = a * f + c * h * y, s.m33 = c * m, s; -}, Xe = (t, e, r, s) => { - const n = new P(), o = Math.sqrt(t * t + e * e + r * r); - if (o === 0) - return n; - const i = t / o, l = e / o, c = r / o, a = s * (Math.PI / 360), m = Math.sin(a), h = Math.cos(a), f = m * m, y = i * i, u = l * l, g = c * c, p = 1 - 2 * (u + g) * f; - n.m11 = p, n.a = p; - const b = 2 * (i * l * f + c * m * h); - n.m12 = b, n.b = b, n.m13 = 2 * (i * c * f - l * m * h); - const M = 2 * (l * i * f - c * m * h); - n.m21 = M, n.c = M; - const d = 1 - 2 * (g + y) * f; - return n.m22 = d, n.d = d, n.m23 = 2 * (l * c * f + i * m * h), n.m31 = 2 * (c * i * f + l * m * h), n.m32 = 2 * (c * l * f - i * m * h), n.m33 = 1 - 2 * (y + u) * f, n; -}, Ye = (t, e, r) => { - const s = new P(); - return s.m11 = t, s.a = t, s.m22 = e, s.d = e, s.m33 = r, s; -}, de = (t, e) => { - const r = new P(); - if (t) { - const s = t * Math.PI / 180, n = Math.tan(s); - r.m21 = n, r.c = n; - } - if (e) { - const s = e * Math.PI / 180, n = Math.tan(s); - r.m12 = n, r.b = n; - } - return r; -}, et = (t) => de(t, 0), tt = (t) => de(0, t), B = (t, e) => { - const r = e.m11 * t.m11 + e.m12 * t.m21 + e.m13 * t.m31 + e.m14 * t.m41, s = e.m11 * t.m12 + e.m12 * t.m22 + e.m13 * t.m32 + e.m14 * t.m42, n = e.m11 * t.m13 + e.m12 * t.m23 + e.m13 * t.m33 + e.m14 * t.m43, o = e.m11 * t.m14 + e.m12 * t.m24 + e.m13 * t.m34 + e.m14 * t.m44, i = e.m21 * t.m11 + e.m22 * t.m21 + e.m23 * t.m31 + e.m24 * t.m41, l = e.m21 * t.m12 + e.m22 * t.m22 + e.m23 * t.m32 + e.m24 * t.m42, c = e.m21 * t.m13 + e.m22 * t.m23 + e.m23 * t.m33 + e.m24 * t.m43, a = e.m21 * t.m14 + e.m22 * t.m24 + e.m23 * t.m34 + e.m24 * t.m44, m = e.m31 * t.m11 + e.m32 * t.m21 + e.m33 * t.m31 + e.m34 * t.m41, h = e.m31 * t.m12 + e.m32 * t.m22 + e.m33 * t.m32 + e.m34 * t.m42, f = e.m31 * t.m13 + e.m32 * t.m23 + e.m33 * t.m33 + e.m34 * t.m43, y = e.m31 * t.m14 + e.m32 * t.m24 + e.m33 * t.m34 + e.m34 * t.m44, u = e.m41 * t.m11 + e.m42 * t.m21 + e.m43 * t.m31 + e.m44 * t.m41, g = e.m41 * t.m12 + e.m42 * t.m22 + e.m43 * t.m32 + e.m44 * t.m42, p = e.m41 * t.m13 + e.m42 * t.m23 + e.m43 * t.m33 + e.m44 * t.m43, b = e.m41 * t.m14 + e.m42 * t.m24 + e.m43 * t.m34 + e.m44 * t.m44; - return oe([ - r, - s, - n, - o, - i, - l, - c, - a, - m, - h, - f, - y, - u, - g, - p, - b - ]); -}; -class P { - /** - * @constructor - * @param init accepts all parameter configurations: - * * valid CSS transform string, - * * CSSMatrix/DOMMatrix instance, - * * a 6/16 elements *Array*. - */ - constructor(e) { - return this.a = 1, this.b = 0, this.c = 0, this.d = 1, this.e = 0, this.f = 0, this.m11 = 1, this.m12 = 0, this.m13 = 0, this.m14 = 0, this.m21 = 0, this.m22 = 1, this.m23 = 0, this.m24 = 0, this.m31 = 0, this.m32 = 0, this.m33 = 1, this.m34 = 0, this.m41 = 0, this.m42 = 0, this.m43 = 0, this.m44 = 1, e ? this.setMatrixValue(e) : this; - } - /** - * A `Boolean` whose value is `true` if the matrix is the identity matrix. The identity - * matrix is one in which every value is 0 except those on the main diagonal from top-left - * to bottom-right corner (in other words, where the offsets in each direction are equal). - * - * @return the current property value - */ - get isIdentity() { - return this.m11 === 1 && this.m12 === 0 && this.m13 === 0 && this.m14 === 0 && this.m21 === 0 && this.m22 === 1 && this.m23 === 0 && this.m24 === 0 && this.m31 === 0 && this.m32 === 0 && this.m33 === 1 && this.m34 === 0 && this.m41 === 0 && this.m42 === 0 && this.m43 === 0 && this.m44 === 1; - } - /** - * A `Boolean` flag whose value is `true` if the matrix was initialized as a 2D matrix - * and `false` if the matrix is 3D. - * - * @return the current property value - */ - get is2D() { - return this.m31 === 0 && this.m32 === 0 && this.m33 === 1 && this.m34 === 0 && this.m43 === 0 && this.m44 === 1; - } - /** - * The `setMatrixValue` method replaces the existing matrix with one computed - * in the browser. EG: `matrix(1,0.25,-0.25,1,0,0)` - * - * The method accepts any *Array* values, the result of - * `DOMMatrix` instance method `toFloat64Array()` / `toFloat32Array()` calls - * or `CSSMatrix` instance method `toArray()`. - * - * This method expects valid *matrix()* / *matrix3d()* string values, as well - * as other transform functions like *translateX(10px)*. - * - * @param source - * @return the matrix instance - */ - setMatrixValue(e) { - return typeof e == "string" && e.length && e !== "none" ? Je(e) : Array.isArray(e) || e instanceof Float64Array || e instanceof Float32Array ? oe(e) : typeof e == "object" ? Ge(e) : this; - } - /** - * Returns a *Float32Array* containing elements which comprise the matrix. - * The method can return either the 16 elements or the 6 elements - * depending on the value of the `is2D` parameter. - * - * @param is2D *Array* representation of the matrix - * @return an *Array* representation of the matrix - */ - toFloat32Array(e) { - return Float32Array.from(Le(this, e)); - } - /** - * Returns a *Float64Array* containing elements which comprise the matrix. - * The method can return either the 16 elements or the 6 elements - * depending on the value of the `is2D` parameter. - * - * @param is2D *Array* representation of the matrix - * @return an *Array* representation of the matrix - */ - toFloat64Array(e) { - return Float64Array.from(Le(this, e)); - } - /** - * Creates and returns a string representation of the matrix in `CSS` matrix syntax, - * using the appropriate `CSS` matrix notation. - * - * matrix3d *matrix3d(m11, m12, m13, m14, m21, ...)* - * matrix *matrix(a, b, c, d, e, f)* - * - * @return a string representation of the matrix - */ - toString() { - const { is2D: e } = this, r = this.toFloat64Array(e).join(", "); - return `${e ? "matrix" : "matrix3d"}(${r})`; - } - /** - * Returns a JSON representation of the `CSSMatrix` instance, a standard *Object* - * that includes `{a,b,c,d,e,f}` and `{m11,m12,m13,..m44}` properties as well - * as the `is2D` & `isIdentity` properties. - * - * The result can also be used as a second parameter for the `fromMatrix` static method - * to load values into another matrix instance. - * - * @return an *Object* with all matrix values. - */ - toJSON() { - const { is2D: e, isIdentity: r } = this; - return { ...this, is2D: e, isIdentity: r }; - } - /** - * The Multiply method returns a new CSSMatrix which is the result of this - * matrix multiplied by the passed matrix, with the passed matrix to the right. - * This matrix is not modified. - * - * @param m2 CSSMatrix - * @return The resulted matrix. - */ - multiply(e) { - return B(this, e); - } - /** - * The translate method returns a new matrix which is this matrix post - * multiplied by a translation matrix containing the passed values. If the z - * component is undefined, a 0 value is used in its place. This matrix is not - * modified. - * - * @param x X component of the translation value. - * @param y Y component of the translation value. - * @param z Z component of the translation value. - * @return The resulted matrix - */ - translate(e, r, s) { - const n = e; - let o = r, i = s; - return typeof o > "u" && (o = 0), typeof i > "u" && (i = 0), B(this, Ke(n, o, i)); - } - /** - * The scale method returns a new matrix which is this matrix post multiplied by - * a scale matrix containing the passed values. If the z component is undefined, - * a 1 value is used in its place. If the y component is undefined, the x - * component value is used in its place. This matrix is not modified. - * - * @param x The X component of the scale value. - * @param y The Y component of the scale value. - * @param z The Z component of the scale value. - * @return The resulted matrix - */ - scale(e, r, s) { - const n = e; - let o = r, i = s; - return typeof o > "u" && (o = e), typeof i > "u" && (i = 1), B(this, Ye(n, o, i)); - } - /** - * The rotate method returns a new matrix which is this matrix post multiplied - * by each of 3 rotation matrices about the major axes, first X, then Y, then Z. - * If the y and z components are undefined, the x value is used to rotate the - * object about the z axis, as though the vector (0,0,x) were passed. All - * rotation values are in degrees. This matrix is not modified. - * - * @param rx The X component of the rotation, or Z if Y and Z are null. - * @param ry The (optional) Y component of the rotation value. - * @param rz The (optional) Z component of the rotation value. - * @return The resulted matrix - */ - rotate(e, r, s) { - let n = e, o = r || 0, i = s || 0; - return typeof e == "number" && typeof r > "u" && typeof s > "u" && (i = n, n = 0, o = 0), B(this, We(n, o, i)); - } - /** - * The rotateAxisAngle method returns a new matrix which is this matrix post - * multiplied by a rotation matrix with the given axis and `angle`. The right-hand - * rule is used to determine the direction of rotation. All rotation values are - * in degrees. This matrix is not modified. - * - * @param x The X component of the axis vector. - * @param y The Y component of the axis vector. - * @param z The Z component of the axis vector. - * @param angle The angle of rotation about the axis vector, in degrees. - * @return The resulted matrix - */ - rotateAxisAngle(e, r, s, n) { - if ([e, r, s, n].some((o) => Number.isNaN(+o))) - throw new TypeError("CSSMatrix: expecting 4 values"); - return B(this, Xe(e, r, s, n)); - } - /** - * Specifies a skew transformation along the `x-axis` by the given angle. - * This matrix is not modified. - * - * @param angle The angle amount in degrees to skew. - * @return The resulted matrix - */ - skewX(e) { - return B(this, et(e)); - } - /** - * Specifies a skew transformation along the `y-axis` by the given angle. - * This matrix is not modified. - * - * @param angle The angle amount in degrees to skew. - * @return The resulted matrix - */ - skewY(e) { - return B(this, tt(e)); - } - /** - * Specifies a skew transformation along both the `x-axis` and `y-axis`. - * This matrix is not modified. - * - * @param angleX The X-angle amount in degrees to skew. - * @param angleY The angle amount in degrees to skew. - * @return The resulted matrix - */ - skew(e, r) { - return B(this, de(e, r)); - } - /** - * Transforms a specified vector using the matrix, returning a new - * {x,y,z,w} Tuple *Object* comprising the transformed vector. - * Neither the matrix nor the original vector are altered. - * - * The method is equivalent with `transformPoint()` method - * of the `DOMMatrix` constructor. - * - * @param t Tuple with `{x,y,z,w}` components - * @return the resulting Tuple - */ - transformPoint(e) { - const r = this.m11 * e.x + this.m21 * e.y + this.m31 * e.z + this.m41 * e.w, s = this.m12 * e.x + this.m22 * e.y + this.m32 * e.z + this.m42 * e.w, n = this.m13 * e.x + this.m23 * e.y + this.m33 * e.z + this.m43 * e.w, o = this.m14 * e.x + this.m24 * e.y + this.m34 * e.z + this.m44 * e.w; - return e instanceof DOMPoint ? new DOMPoint(r, s, n, o) : { - x: r, - y: s, - z: n, - w: o - }; - } -} -I(P, "Translate", Ke), I(P, "Rotate", We), I(P, "RotateAxisAngle", Xe), I(P, "Scale", Ye), I(P, "SkewX", et), I(P, "SkewY", tt), I(P, "Skew", de), I(P, "Multiply", B), I(P, "fromArray", oe), I(P, "fromMatrix", Ge), I(P, "fromString", Je), I(P, "toArray", Le), I(P, "isCompatibleArray", Fe), I(P, "isCompatibleObject", Ue); -const Z = (t, e, r) => { - const [s, n] = t, [o, i] = e; - return [s + (o - s) * r, n + (i - n) * r]; -}, xe = (t, e) => Math.sqrt( - (t[0] - e[0]) * (t[0] - e[0]) + (t[1] - e[1]) * (t[1] - e[1]) -), re = (t, e, r, s) => xe([t, e], [r, s]), Oe = (t, e, r, s, n) => { - let o = { x: t, y: e }; - if (typeof n == "number") { - const i = xe([t, e], [r, s]); - if (n <= 0) - o = { x: t, y: e }; - else if (n >= i) - o = { x: r, y: s }; - else { - const [l, c] = Z([t, e], [r, s], n / i); - o = { x: l, y: c }; - } - } - return o; -}, Te = (t, e, r, s) => { - const { min: n, max: o } = Math; - return [n(t, r), n(e, s), o(t, r), o(e, s)]; -}, _t = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ - __proto__: null, - getLineBBox: Te, - getLineLength: re, - getPointAtLineLength: Oe -}, Symbol.toStringTag, { value: "Module" })), Ve = (t, e, r) => { - const s = r / 2, n = Math.sin(s), o = Math.cos(s), i = t ** 2 * n ** 2, l = e ** 2 * o ** 2, c = Math.sqrt(i + l) * r; - return Math.abs(c); -}, J = (t, e, r, s, n, o) => { - const { sin: i, cos: l } = Math, c = l(n), a = i(n), m = r * l(o), h = s * i(o); - return [t + c * m - a * h, e + a * m + c * h]; -}, ve = (t, e) => { - const { x: r, y: s } = t, { x: n, y: o } = e, i = r * n + s * o, l = Math.sqrt((r ** 2 + s ** 2) * (n ** 2 + o ** 2)); - return (r * o - s * n < 0 ? -1 : 1) * Math.acos(i / l); -}, pe = (t, e, r, s, n, o, i, l, c) => { - const { abs: a, sin: m, cos: h, sqrt: f, PI: y } = Math; - let u = a(r), g = a(s); - const b = (n % 360 + 360) % 360 * (y / 180); - if (t === l && e === c) - return { - rx: u, - ry: g, - startAngle: 0, - endAngle: 0, - center: { x: l, y: c } - }; - if (u === 0 || g === 0) - return { - rx: u, - ry: g, - startAngle: 0, - endAngle: 0, - center: { x: (l + t) / 2, y: (c + e) / 2 } - }; - const M = (t - l) / 2, d = (e - c) / 2, x = { - x: h(b) * M + m(b) * d, - y: -m(b) * M + h(b) * d - }, A = x.x ** 2 / u ** 2 + x.y ** 2 / g ** 2; - A > 1 && (u *= f(A), g *= f(A)); - const S = u ** 2 * g ** 2 - u ** 2 * x.y ** 2 - g ** 2 * x.x ** 2, j = u ** 2 * x.y ** 2 + g ** 2 * x.x ** 2; - let $ = S / j; - $ = $ < 0 ? 0 : $; - const L = (o !== i ? 1 : -1) * f($), N = { - x: L * (u * x.y / g), - y: L * (-(g * x.x) / u) - }, R = { - x: h(b) * N.x - m(b) * N.y + (t + l) / 2, - y: m(b) * N.x + h(b) * N.y + (e + c) / 2 - }, U = { - x: (x.x - N.x) / u, - y: (x.y - N.y) / g - }, z = ve({ x: 1, y: 0 }, U), C = { - x: (-x.x - N.x) / u, - y: (-x.y - N.y) / g - }; - let q = ve(U, C); - !i && q > 0 ? q -= 2 * y : i && q < 0 && (q += 2 * y), q %= 2 * y; - const Q = z + q; - return { - center: R, - startAngle: z, - endAngle: Q, - rx: u, - ry: g - }; -}, _e = (t, e, r, s, n, o, i, l, c) => { - const { rx: a, ry: m, startAngle: h, endAngle: f } = pe( - t, - e, - r, - s, - n, - o, - i, - l, - c - ); - return Ve(a, m, f - h); -}, nt = (t, e, r, s, n, o, i, l, c, a) => { - let m = { x: t, y: e }; - const { center: h, rx: f, ry: y, startAngle: u, endAngle: g } = pe( - t, - e, - r, - s, - n, - o, - i, - l, - c - ); - if (typeof a == "number") { - const p = Ve(f, y, g - u); - if (a <= 0) - m = { x: t, y: e }; - else if (a >= p) - m = { x: l, y: c }; - else { - if (t === l && e === c) - return { x: l, y: c }; - if (f === 0 || y === 0) - return Oe(t, e, l, c, a); - const { PI: b, cos: M, sin: d } = Math, x = g - u, S = (n % 360 + 360) % 360 * (b / 180), j = u + x * (a / p), $ = f * M(j), L = y * d(j); - m = { - x: M(S) * $ - d(S) * L + h.x, - y: d(S) * $ + M(S) * L + h.y - }; - } - } - return m; -}, rt = (t, e, r, s, n, o, i, l, c) => { - const { center: a, rx: m, ry: h, startAngle: f, endAngle: y } = pe( - t, - e, - r, - s, - n, - o, - i, - l, - c - ), u = y - f, { min: g, max: p, tan: b, atan2: M, PI: d } = Math, { x, y: A } = a, S = n * d / 180, j = b(S), $ = M(-h * j, m), L = $, N = $ + d, R = M(h, m * j), U = R + d, z = [l], C = [c]; - let q = g(t, l), Q = p(t, l), E = g(e, c), D = p(e, c); - const W = y - u * 1e-5, G = J(x, A, m, h, S, W), w = y - u * 0.99999, k = J(x, A, m, h, S, w); - if (G[0] > Q || k[0] > Q) { - const T = J(x, A, m, h, S, L); - z.push(T[0]), C.push(T[1]); - } - if (G[0] < q || k[0] < q) { - const T = J(x, A, m, h, S, N); - z.push(T[0]), C.push(T[1]); - } - if (G[1] < E || k[1] < E) { - const T = J(x, A, m, h, S, U); - z.push(T[0]), C.push(T[1]); - } - if (G[1] > D || k[1] > D) { - const T = J(x, A, m, h, S, R); - z.push(T[0]), C.push(T[1]); - } - return q = g.apply([], z), E = g.apply([], C), Q = p.apply([], z), D = p.apply([], C), [q, E, Q, D]; -}, Rt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ - __proto__: null, - angleBetween: ve, - arcLength: Ve, - arcPoint: J, - getArcBBox: rt, - getArcLength: _e, - getArcProps: pe, - getPointAtArcLength: nt -}, Symbol.toStringTag, { value: "Module" })), je = [ - -0.06405689286260563, - 0.06405689286260563, - -0.1911188674736163, - 0.1911188674736163, - -0.3150426796961634, - 0.3150426796961634, - -0.4337935076260451, - 0.4337935076260451, - -0.5454214713888396, - 0.5454214713888396, - -0.6480936519369755, - 0.6480936519369755, - -0.7401241915785544, - 0.7401241915785544, - -0.820001985973903, - 0.820001985973903, - -0.8864155270044011, - 0.8864155270044011, - -0.9382745520027328, - 0.9382745520027328, - -0.9747285559713095, - 0.9747285559713095, - -0.9951872199970213, - 0.9951872199970213 -], st = [ - 0.12793819534675216, - 0.12793819534675216, - 0.1258374563468283, - 0.1258374563468283, - 0.12167047292780339, - 0.12167047292780339, - 0.1155056680537256, - 0.1155056680537256, - 0.10744427011596563, - 0.10744427011596563, - 0.09761865210411388, - 0.09761865210411388, - 0.08619016153195327, - 0.08619016153195327, - 0.0733464814110803, - 0.0733464814110803, - 0.05929858491543678, - 0.05929858491543678, - 0.04427743881741981, - 0.04427743881741981, - 0.028531388628933663, - 0.028531388628933663, - 0.0123412297999872, - 0.0123412297999872 -], ot = (t) => { - const e = []; - for (let r = t, s = r.length, n = s - 1; s > 1; s -= 1, n -= 1) { - const o = []; - for (let i = 0; i < n; i += 1) - o.push({ - x: n * (r[i + 1].x - r[i].x), - y: n * (r[i + 1].y - r[i].y), - t: 0 - }); - e.push(o), r = o; - } - return e; -}, it = (t, e) => { - if (e === 0) - return t[0].t = 0, t[0]; - const r = t.length - 1; - if (e === 1) - return t[r].t = 1, t[r]; - const s = 1 - e; - let n = t; - if (r === 0) - return t[0].t = e, t[0]; - if (r === 1) - return { - x: s * n[0].x + e * n[1].x, - y: s * n[0].y + e * n[1].y, - t: e - }; - const o = s * s, i = e * e; - let l = 0, c = 0, a = 0, m = 0; - return r === 2 ? (n = [n[0], n[1], n[2], { x: 0, y: 0 }], l = o, c = s * e * 2, a = i) : r === 3 && (l = o * s, c = o * e * 3, a = s * i * 3, m = e * i), { - x: l * n[0].x + c * n[1].x + a * n[2].x + m * n[3].x, - y: l * n[0].y + c * n[1].y + a * n[2].y + m * n[3].y, - t: e - }; -}, ct = (t, e) => { - const r = t(e), s = r.x * r.x + r.y * r.y; - return Math.sqrt(s); -}, lt = (t) => { - const r = je.length; - let s = 0; - for (let n = 0, o; n < r; n++) - o = 0.5 * je[n] + 0.5, s += st[n] * ct(t, o); - return 0.5 * s; -}, ie = (t) => { - const e = []; - for (let s = 0, n = t.length, o = 2; s < n; s += o) - e.push({ - x: t[s], - y: t[s + 1] - }); - const r = ot(e); - return lt((s) => it(r[0], s)); -}, at = 1e-8, ue = ([t, e, r]) => { - const s = Math.min(t, r), n = Math.max(t, r); - if (e >= t ? r >= e : r <= e) - return [s, n]; - const o = (t * r - e * e) / (t - 2 * e + r); - return o < s ? [o, n] : [s, o]; -}, $e = ([t, e, r, s]) => { - const n = t - 3 * e + 3 * r - s; - if (Math.abs(n) < at) - return t === s && t === e ? [t, s] : ue([t, -0.5 * t + 1.5 * e, t - 3 * e + 3 * r]); - const o = -t * r + t * s - e * r - e * s + e * e + r * r; - if (o <= 0) - return [Math.min(t, s), Math.max(t, s)]; - const i = Math.sqrt(o); - let l = Math.min(t, s), c = Math.max(t, s); - const a = t - 2 * e + r; - for (let m = (a + i) / n, h = 1; h <= 2; m = (a - i) / n, h++) - if (m > 0 && m < 1) { - const f = t * (1 - m) * (1 - m) * (1 - m) + e * 3 * (1 - m) * (1 - m) * m + r * 3 * (1 - m) * m * m + s * m * m * m; - f < l && (l = f), f > c && (c = f); - } - return [l, c]; -}, Qt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ - __proto__: null, - CBEZIER_MINMAX_EPSILON: at, - Cvalues: st, - Tvalues: je, - bezierLength: lt, - calculateBezier: ct, - computeBezier: it, - deriveBezier: ot, - getBezierLength: ie, - minmaxC: $e, - minmaxQ: ue -}, Symbol.toStringTag, { value: "Module" })), mt = ([t, e, r, s, n, o, i, l], c) => { - const a = 1 - c; - return { - x: a ** 3 * t + 3 * a ** 2 * c * r + 3 * a * c ** 2 * n + c ** 3 * i, - y: a ** 3 * e + 3 * a ** 2 * c * s + 3 * a * c ** 2 * o + c ** 3 * l - }; -}, he = (t, e, r, s, n, o, i, l) => ie([t, e, r, s, n, o, i, l]), ut = (t, e, r, s, n, o, i, l, c) => { - const a = typeof c == "number"; - let m = { x: t, y: e }; - if (a) { - const h = ie([t, e, r, s, n, o, i, l]); - c <= 0 || (c >= h ? m = { x: i, y: l } : m = mt( - [t, e, r, s, n, o, i, l], - c / h - )); - } - return m; -}, ze = (t, e, r, s, n, o, i, l) => { - const c = $e([t, r, n, i]), a = $e([e, s, o, l]); - return [c[0], a[0], c[1], a[1]]; -}, Zt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ - __proto__: null, - getCubicBBox: ze, - getCubicLength: he, - getPointAtCubicLength: ut, - getPointAtCubicSegmentLength: mt -}, Symbol.toStringTag, { value: "Module" })), ht = ([t, e, r, s, n, o], i) => { - const l = 1 - i; - return { - x: l ** 2 * t + 2 * l * i * r + i ** 2 * n, - y: l ** 2 * e + 2 * l * i * s + i ** 2 * o - }; -}, fe = (t, e, r, s, n, o) => ie([t, e, r, s, n, o]), ft = (t, e, r, s, n, o, i) => { - const l = typeof i == "number"; - let c = { x: t, y: e }; - if (l) { - const a = ie([t, e, r, s, n, o]); - i <= 0 || (i >= a ? c = { x: n, y: o } : c = ht( - [t, e, r, s, n, o], - i / a - )); - } - return c; -}, qe = (t, e, r, s, n, o) => { - const i = ue([t, r, n]), l = ue([e, s, o]); - return [i[0], l[0], i[1], l[1]]; -}, Dt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ - __proto__: null, - getPointAtQuadLength: ft, - getPointAtQuadSegmentLength: ht, - getQuadBBox: qe, - getQuadLength: fe -}, Symbol.toStringTag, { value: "Module" })), Bt = (t) => { - const e = t.length; - let r = -1, s, n = t[e - 1], o = 0; - for (; ++r < e; ) - s = n, n = t[r], o += s[1] * n[0] - s[0] * n[1]; - return o / 2; -}, Ht = (t) => t.reduce((e, r, s) => s ? e + xe(t[s - 1], r) : 0, 0), Ft = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ - __proto__: null, - polygonArea: Bt, - polygonLength: Ht -}, Symbol.toStringTag, { value: "Module" })), X = { - a: 7, - c: 6, - h: 1, - l: 2, - m: 2, - r: 4, - q: 4, - s: 4, - t: 2, - v: 1, - z: 0 -}, ke = (t) => { - let e = t.pathValue[t.segmentStart], r = e.toLowerCase(); - const { data: s } = t; - for (; s.length >= X[r] && (r === "m" && s.length > 2 ? (t.segments.push( - [e].concat( - s.splice(0, 2) - ) - ), r = "l", e = e === "m" ? "l" : "L") : t.segments.push( - [e].concat( - s.splice(0, X[r]) - ) - ), !!X[r]); ) - ; -}, O = "SVGPathCommander Error", yt = (t) => { - const { index: e, pathValue: r } = t, s = r.charCodeAt(e); - if (s === 48) { - t.param = 0, t.index += 1; - return; - } - if (s === 49) { - t.param = 1, t.index += 1; - return; - } - t.err = `${O}: invalid Arc flag "${r[e]}", expecting 0 or 1 at index ${e}`; -}, H = (t) => t >= 48 && t <= 57, F = "Invalid path value", gt = (t) => { - const { max: e, pathValue: r, index: s } = t; - let n = s, o = !1, i = !1, l = !1, c = !1, a; - if (n >= e) { - t.err = `${O}: ${F} at index ${n}, "pathValue" is missing param`; - return; - } - if (a = r.charCodeAt(n), (a === 43 || a === 45) && (n += 1, a = r.charCodeAt(n)), !H(a) && a !== 46) { - t.err = `${O}: ${F} at index ${n}, "${r[n]}" is not a number`; - return; - } - if (a !== 46) { - if (o = a === 48, n += 1, a = r.charCodeAt(n), o && n < e && a && H(a)) { - t.err = `${O}: ${F} at index ${s}, "${r[s]}" illegal number`; - return; - } - for (; n < e && H(r.charCodeAt(n)); ) - n += 1, i = !0; - a = r.charCodeAt(n); - } - if (a === 46) { - for (c = !0, n += 1; H(r.charCodeAt(n)); ) - n += 1, l = !0; - a = r.charCodeAt(n); - } - if (a === 101 || a === 69) { - if (c && !i && !l) { - t.err = `${O}: ${F} at index ${n}, "${r[n]}" invalid float exponent`; - return; - } - if (n += 1, a = r.charCodeAt(n), (a === 43 || a === 45) && (n += 1), n < e && H(r.charCodeAt(n))) - for (; n < e && H(r.charCodeAt(n)); ) - n += 1; - else { - t.err = `${O}: ${F} at index ${n}, "${r[n]}" invalid integer exponent`; - return; - } - } - t.index = n, t.param = +t.pathValue.slice(s, n); -}, dt = (t) => [ - // Special spaces - 5760, - 6158, - 8192, - 8193, - 8194, - 8195, - 8196, - 8197, - 8198, - 8199, - 8200, - 8201, - 8202, - 8239, - 8287, - 12288, - 65279, - // Line terminators - 10, - 13, - 8232, - 8233, - // White spaces - 32, - 9, - 11, - 12, - 160 -].includes(t), Y = (t) => { - const { pathValue: e, max: r } = t; - for (; t.index < r && dt(e.charCodeAt(t.index)); ) - t.index += 1; -}, xt = (t) => { - switch (t | 32) { - case 109: - case 122: - case 108: - case 104: - case 118: - case 99: - case 115: - case 113: - case 116: - case 97: - return !0; - default: - return !1; - } -}, pt = (t) => H(t) || t === 43 || t === 45 || t === 46, bt = (t) => (t | 32) === 97, Mt = (t) => { - switch (t | 32) { - case 109: - case 77: - return !0; - default: - return !1; - } -}, Re = (t) => { - var c; - const { max: e, pathValue: r, index: s, segments: n } = t, o = r.charCodeAt(s), i = X[r[s].toLowerCase()]; - if (t.segmentStart = s, !xt(o)) { - t.err = `${O}: ${F} "${r[s]}" is not a path command at index ${s}`; - return; - } - const l = n[n.length - 1]; - if (!Mt(o) && ((c = l == null ? void 0 : l[0]) == null ? void 0 : c.toLocaleLowerCase()) === "z") { - t.err = `${O}: ${F} "${r[s]}" is not a MoveTo path command at index ${s}`; - return; - } - if (t.index += 1, Y(t), t.data = [], !i) { - ke(t); - return; - } - for (; ; ) { - for (let a = i; a > 0; a -= 1) { - if (bt(o) && (a === 3 || a === 4) ? yt(t) : gt(t), t.err.length) - return; - t.data.push(t.param), Y(t), t.index < e && r.charCodeAt(t.index) === 44 && (t.index += 1, Y(t)); - } - if (t.index >= t.max || !pt(r.charCodeAt(t.index))) - break; - } - ke(t); -}; -class Qe { - constructor(e) { - this.segments = [], this.pathValue = e, this.max = e.length, this.index = 0, this.param = 0, this.segmentStart = 0, this.data = [], this.err = ""; - } -} -const V = (t) => { - if (typeof t != "string") - return t.slice(0); - const e = new Qe(t); - for (Y(e); e.index < e.max && !e.err.length; ) - Re(e); - if (!e.err.length) - e.segments.length && (e.segments[0][0] = "M"); - else - throw TypeError(e.err); - return e.segments; -}, ce = (t, e, r, s) => { - const [n] = t, o = n.toUpperCase(); - if (e === 0 || o === n) return t; - if (o === "A") - return [ - o, - t[1], - t[2], - t[3], - t[4], - t[5], - t[6] + r, - t[7] + s - ]; - if (o === "V") - return [o, t[1] + s]; - if (o === "H") - return [o, t[1] + r]; - if (o === "L") - return [ - o, - t[1] + r, - t[2] + s - ]; - { - const l = [], c = t.length; - for (let a = 1; a < c; a += 1) - l.push(t[a] + (a % 2 ? r : s)); - return [o].concat(l); - } -}, _ = (t, e) => { - let r = t.length, s, n = "M", o = "M", i = !1, l = 0, c = 0, a = 0, m = 0, h = 0; - for (let f = 0; f < r; f += 1) { - s = t[f], [n] = s, h = s.length, o = n.toUpperCase(), i = o !== n; - const y = e(s, f, l, c); - if (y === !1) - break; - o === "Z" ? (l = a, c = m) : o === "H" ? l = s[1] + (i ? l : 0) : o === "V" ? c = s[1] + (i ? c : 0) : (l = s[h - 2] + (i ? l : 0), c = s[h - 1] + (i ? c : 0), o === "M" && (a = l, m = c)), y && (t[f] = y, y[0] === "C" && (r = t.length)); - } - return t; -}, be = (t) => { - const e = V(t); - return _(e, ce); -}, Ze = (t, e, r, s) => { - const [n] = t, o = n.toLowerCase(); - if (e === 0 || n === o) return t; - if (o === "a") - return [ - o, - t[1], - t[2], - t[3], - t[4], - t[5], - t[6] - r, - t[7] - s - ]; - if (o === "v") - return [o, t[1] - s]; - if (o === "h") - return [o, t[1] - r]; - if (o === "l") - return [ - o, - t[1] - r, - t[2] - s - ]; - { - const l = [], c = t.length; - for (let a = 1; a < c; a += 1) - l.push(t[a] - (a % 2 ? r : s)); - return [o].concat(l); - } -}, At = (t) => { - const e = V(t); - return _(e, Ze); -}, te = (t, e, r) => { - const { sin: s, cos: n } = Math, o = t * n(r) - e * s(r), i = t * s(r) + e * n(r); - return { x: o, y: i }; -}, Me = (t, e, r, s, n, o, i, l, c, a) => { - let m = t, h = e, f = r, y = s, u = l, g = c; - const p = Math.PI * 120 / 180, b = Math.PI / 180 * (+n || 0); - let M = [], d, x, A, S, j; - if (a) - [x, A, S, j] = a; - else { - d = te(m, h, -b), m = d.x, h = d.y, d = te(u, g, -b), u = d.x, g = d.y; - const w = (m - u) / 2, k = (h - g) / 2; - let T = w * w / (f * f) + k * k / (y * y); - T > 1 && (T = Math.sqrt(T), f *= T, y *= T); - const Ne = f * f, we = y * y, He = (o === i ? -1 : 1) * Math.sqrt( - Math.abs( - (Ne * we - Ne * k * k - we * w * w) / (Ne * k * k + we * w * w) - ) - ); - S = He * f * k / y + (m + u) / 2, j = He * -y * w / f + (h + g) / 2, x = Math.asin(((h - j) / y * 10 ** 9 >> 0) / 10 ** 9), A = Math.asin(((g - j) / y * 10 ** 9 >> 0) / 10 ** 9), x = m < S ? Math.PI - x : x, A = u < S ? Math.PI - A : A, x < 0 && (x = Math.PI * 2 + x), A < 0 && (A = Math.PI * 2 + A), i && x > A && (x -= Math.PI * 2), !i && A > x && (A -= Math.PI * 2); - } - let $ = A - x; - if (Math.abs($) > p) { - const w = A, k = u, T = g; - A = x + p * (i && A > x ? 1 : -1), u = S + f * Math.cos(A), g = j + y * Math.sin(A), M = Me(u, g, f, y, n, 0, i, k, T, [ - A, - w, - S, - j - ]); - } - $ = A - x; - const L = Math.cos(x), N = Math.sin(x), R = Math.cos(A), U = Math.sin(A), z = Math.tan($ / 4), C = 4 / 3 * f * z, q = 4 / 3 * y * z, Q = [m, h], E = [m + C * N, h - q * L], D = [u + C * U, g - q * R], W = [u, g]; - if (E[0] = 2 * Q[0] - E[0], E[1] = 2 * Q[1] - E[1], a) - return [E[0], E[1], D[0], D[1], W[0], W[1]].concat(M); - M = [E[0], E[1], D[0], D[1], W[0], W[1]].concat(M); - const G = []; - for (let w = 0, k = M.length; w < k; w += 1) - G[w] = w % 2 ? te(M[w - 1], M[w], b).y : te(M[w], M[w + 1], b).x; - return G; -}, Ct = (t, e, r, s, n, o) => { - const i = 0.3333333333333333, l = 2 / 3; - return [ - i * t + l * r, - // cpx1 - i * e + l * s, - // cpy1 - i * n + l * r, - // cpx2 - i * o + l * s, - // cpy2 - n, - o - // x,y - ]; -}, Ie = (t, e, r, s) => { - const n = Z([t, e], [r, s], 0.3333333333333333), o = Z([t, e], [r, s], 2 / 3); - return [n[0], n[1], o[0], o[1], r, s]; -}, St = (t, e) => { - const [r] = t, s = t.slice(1).map(Number), [n, o] = s, { x1: i, y1: l, x: c, y: a } = e; - return "TQ".includes(r) || (e.qx = null, e.qy = null), r === "M" ? (e.x = n, e.y = o, t) : r === "A" ? ["C"].concat( - Me( - i, - l, - s[0], - s[1], - s[2], - s[3], - s[4], - s[5], - s[6] - ) - ) : r === "Q" ? (e.qx = n, e.qy = o, ["C"].concat( - Ct(i, l, s[0], s[1], s[2], s[3]) - )) : r === "L" ? ["C"].concat( - Ie(i, l, n, o) - ) : r === "Z" ? ["C"].concat( - Ie(i, l, c, a) - ) : t; -}, Ae = (t, e) => { - const [r] = t, s = r.toUpperCase(), n = r !== s, { x1: o, y1: i, x2: l, y2: c, x: a, y: m } = e, h = t.slice(1); - let f = h.map((y, u) => y + (n ? u % 2 ? m : a : 0)); - if ("TQ".includes(s) || (e.qx = null, e.qy = null), s === "A") - return f = h.slice(0, -2).concat( - h[5] + (n ? a : 0), - h[6] + (n ? m : 0) - ), ["A"].concat(f); - if (s === "H") - return [ - "L", - t[1] + (n ? a : 0), - i - ]; - if (s === "V") - return [ - "L", - o, - t[1] + (n ? m : 0) - ]; - if (s === "L") - return [ - "L", - t[1] + (n ? a : 0), - t[2] + (n ? m : 0) - ]; - if (s === "M") - return [ - "M", - t[1] + (n ? a : 0), - t[2] + (n ? m : 0) - ]; - if (s === "C") - return ["C"].concat(f); - if (s === "S") { - const y = o * 2 - l, u = i * 2 - c; - return e.x1 = y, e.y1 = u, ["C", y, u].concat(f); - } else if (s === "T") { - const y = o * 2 - (e.qx ? e.qx : ( - /* istanbul ignore next */ - 0 - )), u = i * 2 - (e.qy ? e.qy : ( - /* istanbul ignore next */ - 0 - )); - return e.qx = y, e.qy = u, ["Q", y, u].concat(f); - } else if (s === "Q") { - const [y, u] = f; - return e.qx = y, e.qy = u, ["Q"].concat(f); - } else if (s === "Z") - return ["Z"]; - return t; -}, le = { - x1: 0, - y1: 0, - x2: 0, - y2: 0, - x: 0, - y: 0, - qx: null, - qy: null -}, Ce = (t) => { - const e = { ...le }, r = V(t); - return _(r, (s, n, o, i) => { - e.x = o, e.y = i; - const l = Ae(s, e); - let c = St(l, e); - c[0] === "C" && c.length > 7 && (r.splice( - n + 1, - 0, - ["C"].concat(c.slice(7)) - ), c = c.slice(0, 7)); - const m = c.length; - return e.x1 = +c[m - 2], e.y1 = +c[m - 1], e.x2 = +c[m - 4] || e.x1, e.y2 = +c[m - 3] || e.y1, c; - }); -}, K = { - origin: [0, 0, 0], - round: 4 -}, v = (t, e) => { - const r = e >= 1 ? 10 ** e : 1; - return e > 0 ? Math.round(t * r) / r : Math.round(t); -}, De = (t, e) => { - const r = t.length; - let { round: s } = K, n = t[0], o = ""; - s = e === "off" || typeof e == "number" && e >= 0 ? e : typeof s == "number" && s >= 0 ? s : ( - /* istanbul ignore next @preserve */ - "off" - ); - for (let i = 0; i < r; i += 1) { - n = t[i]; - const [l] = n, c = n.slice(1); - if (o += l, s === "off") - o += c.join(" "); - else { - let a = 0; - const m = c.length; - for (; a < m; ) - o += v(c[a], s), a !== m - 1 && (o += " "), a += 1; - } - } - return o; -}, ye = 1e-5, ae = (t) => { - const e = V(t), r = { ...le }; - return _(e, (s, n, o, i) => { - r.x = o, r.y = i; - const l = Ae(s, r), c = l.length; - return r.x1 = +l[c - 2], r.y1 = +l[c - 1], r.x2 = +l[c - 4] || r.x1, r.y2 = +l[c - 3] || r.y1, l; - }); -}, ne = (t, e) => { - const r = ae(t); - let s = !1, n = [], o = "M", i = 0, l = 0, [c, a] = r[0].slice(1); - const m = typeof e == "number"; - let h = { x: c, y: a }, f = 0, y = h, u = 0; - return !m || e < ye ? h : (_(r, (g, p, b, M) => { - if ([o] = g, s = o === "M", n = s ? n : [b, M].concat(g.slice(1)), s ? ([, c, a] = g, h = { x: c, y: a }, f = 0) : o === "L" ? (h = Oe( - n[0], - n[1], - n[2], - n[3], - e - u - ), f = re(n[0], n[1], n[2], n[3])) : o === "A" ? (h = nt( - n[0], - n[1], - n[2], - n[3], - n[4], - n[5], - n[6], - n[7], - n[8], - e - u - ), f = _e( - n[0], - n[1], - n[2], - n[3], - n[4], - n[5], - n[6], - n[7], - n[8] - )) : o === "C" ? (h = ut( - n[0], - n[1], - n[2], - n[3], - n[4], - n[5], - n[6], - n[7], - e - u - ), f = he( - n[0], - n[1], - n[2], - n[3], - n[4], - n[5], - n[6], - n[7] - )) : o === "Q" ? (h = ft( - n[0], - n[1], - n[2], - n[3], - n[4], - n[5], - e - u - ), f = fe( - n[0], - n[1], - n[2], - n[3], - n[4], - n[5] - )) : o === "Z" && (n = [b, M, c, a], h = { x: c, y: a }, f = re(n[0], n[1], n[2], n[3])), [i, l] = n.slice(-2), u < e) - y = h; - else - return !1; - u += f; - }), e > u - ye ? { x: i, y: l } : y); -}, ee = (t) => { - const e = V(t); - let r = 0, s = 0, n = 0, o = 0, i = 0, l = 0, c = "M", a = 0, m = 0, h = 0; - return _(e, (f, y, u, g) => { - [c] = f; - const p = c.toUpperCase(), M = p !== c ? ce(f, y, u, g) : f.slice(0), d = p === "V" ? ["L", u, M[1]] : p === "H" ? ["L", M[1], g] : M; - if ([c] = d, "TQ".includes(p) || (i = 0, l = 0), c === "M") - [, a, m] = d; - else if (c === "L") - h += re( - u, - g, - d[1], - d[2] - ); - else if (c === "A") - h += _e( - u, - g, - d[1], - d[2], - d[3], - d[4], - d[5], - d[6], - d[7] - ); - else if (c === "S") { - const x = r * 2 - n, A = s * 2 - o; - h += he( - u, - g, - x, - A, - d[1], - d[2], - d[3], - d[4] - ); - } else c === "C" ? h += he( - u, - g, - d[1], - d[2], - d[3], - d[4], - d[5], - d[6] - ) : c === "T" ? (i = r * 2 - i, l = s * 2 - l, h += fe( - u, - g, - i, - l, - d[1], - d[2] - )) : c === "Q" ? (i = d[1], l = d[2], h += fe( - u, - g, - d[1], - d[2], - d[3], - d[4] - )) : c === "Z" && (h += re(u, g, a, m)); - [r, s] = c === "Z" ? [a, m] : d.slice(-2), [n, o] = c === "C" ? [d[3], d[4]] : c === "S" ? [d[1], d[2]] : [r, s]; - }), h; -}, Be = (t, e) => { - const r = V(t); - let s = r.slice(0), n = ee(s), o = s.length - 1, i = 0, l = 0, c = r[0]; - if (o <= 0 || !e || !Number.isFinite(e)) - return { - segment: c, - index: 0, - length: l, - lengthAtSegment: i - }; - if (e >= n) - return s = r.slice(0, -1), i = ee(s), l = n - i, c = r[o], { - segment: c, - index: o, - length: l, - lengthAtSegment: i - }; - const a = []; - for (; o > 0; ) - c = s[o], s = s.slice(0, -1), i = ee(s), l = n - i, n = i, a.push({ - segment: c, - index: o, - length: l, - lengthAtSegment: i - }), o -= 1; - return a.find( - ({ lengthAtSegment: m }) => m <= e - ); -}, Se = (t, e) => { - const r = V(t), s = ae(r), n = ee(s), o = (x) => { - const A = x.x - e.x, S = x.y - e.y; - return A * A + S * S; - }; - let i = 8, l, c = { x: 0, y: 0 }, a = 0, m = 0, h = 1 / 0; - for (let x = 0; x <= n; x += i) - l = ne(s, x), a = o(l), a < h && (c = l, m = x, h = a); - i /= 2; - let f, y, u = 0, g = 0, p = 0, b = 0; - for (; i > 1e-6 && (u = m - i, f = ne(s, u), p = o(f), g = m + i, y = ne(s, g), b = o(y), u >= 0 && p < h ? (c = f, m = u, h = p) : g <= n && b < h ? (c = y, m = g, h = b) : i /= 2, !(i < 1e-5)); ) - ; - const M = Be(r, m), d = Math.sqrt(h); - return { closest: c, distance: d, segment: M }; -}, Ut = (t, e) => Se(t, e).closest, Gt = (t, e, r, s, n, o, i, l) => 3 * ((l - e) * (r + n) - (i - t) * (s + o) + s * (t - n) - r * (e - o) + l * (n + t / 3) - i * (o + e / 3)) / 20, Pt = (t) => { - let e = 0, r = 0, s = 0; - return Ce(t).map((n) => { - switch (n[0]) { - case "M": - return [, e, r] = n, 0; - default: - return s = Gt( - e, - r, - n[1], - n[2], - n[3], - n[4], - n[5], - n[6] - ), [e, r] = n.slice(-2), s; - } - }).reduce((n, o) => n + o, 0); -}, Jt = (t) => Pt(Ce(t)) >= 0, Nt = (t) => { - if (!t) - return { - x: 0, - y: 0, - width: 0, - height: 0, - x2: 0, - y2: 0, - cx: 0, - cy: 0, - cz: 0 - }; - const e = V(t); - let r = "M", s = 0, n = 0; - const { max: o, min: i } = Math; - let l = 1 / 0, c = 1 / 0, a = -1 / 0, m = -1 / 0, h = 0, f = 0, y = 0, u = 0, g = 0, p = 0, b = 0, M = 0, d = 0, x = 0; - _(e, (j, $, L, N) => { - [r] = j; - const R = r.toUpperCase(), z = R !== r ? ce(j, $, L, N) : j.slice(0), C = R === "V" ? ["L", L, z[1]] : R === "H" ? ["L", z[1], N] : z; - if ([r] = C, "TQ".includes(R) || (d = 0, x = 0), r === "M") - [, s, n] = C, h = s, f = n, y = s, u = n; - else if (r === "L") - [h, f, y, u] = Te( - L, - N, - C[1], - C[2] - ); - else if (r === "A") - [h, f, y, u] = rt( - L, - N, - C[1], - C[2], - C[3], - C[4], - C[5], - C[6], - C[7] - ); - else if (r === "S") { - const q = g * 2 - b, Q = p * 2 - M; - [h, f, y, u] = ze( - L, - N, - q, - Q, - C[1], - C[2], - C[3], - C[4] - ); - } else r === "C" ? [h, f, y, u] = ze( - L, - N, - C[1], - C[2], - C[3], - C[4], - C[5], - C[6] - ) : r === "T" ? (d = g * 2 - d, x = p * 2 - x, [h, f, y, u] = qe( - L, - N, - d, - x, - C[1], - C[2] - )) : r === "Q" ? (d = C[1], x = C[2], [h, f, y, u] = qe( - L, - N, - C[1], - C[2], - C[3], - C[4] - )) : r === "Z" && ([h, f, y, u] = Te(L, N, s, n)); - l = i(h, l), c = i(f, c), a = o(y, a), m = o(u, m), [g, p] = r === "Z" ? [s, n] : C.slice(-2), [b, M] = r === "C" ? [C[3], C[4]] : r === "S" ? [C[1], C[2]] : [g, p]; - }); - const A = a - l, S = m - c; - return { - width: A, - height: S, - x: l, - y: c, - x2: a, - y2: m, - cx: l + A / 2, - cy: c + S / 2, - // an estimated guess - cz: Math.max(A, S) + Math.min(A, S) / 2 - }; -}, Kt = (t, e) => Be(t, e).segment, Wt = (t, e) => Se(t, e).segment, Pe = (t) => Array.isArray(t) && t.every((e) => { - const r = e[0].toLowerCase(); - return X[r] === e.length - 1 && "achlmqstvz".includes(r) && e.slice(1).every(Number.isFinite); -}) && t.length > 0, wt = (t) => Pe(t) && // `isPathArray` also checks if it's `Array` -t.every(([e]) => e === e.toUpperCase()), Lt = (t) => wt(t) && t.every(([e]) => "ACLMQZ".includes(e)), Xt = (t) => Lt(t) && t.every(([e]) => "MC".includes(e)), Yt = (t, e) => { - const { distance: r } = Se(t, e); - return Math.abs(r) < ye; -}, en = (t) => Pe(t) && // `isPathArray` checks if it's `Array` -t.slice(1).every(([e]) => e === e.toLowerCase()), Tt = (t) => { - if (typeof t != "string" || !t.length) - return !1; - const e = new Qe(t); - for (Y(e); e.index < e.max && !e.err.length; ) - Re(e); - return !e.err.length && "mM".includes(e.segments[0][0]); -}, se = { - line: ["x1", "y1", "x2", "y2"], - circle: ["cx", "cy", "r"], - ellipse: ["cx", "cy", "rx", "ry"], - rect: ["width", "height", "x", "y", "rx", "ry"], - polygon: ["points"], - polyline: ["points"], - glyph: ["d"] -}, vt = (t) => t != null && typeof t == "object" && t.nodeType === 1, tn = (t) => { - let { x1: e, y1: r, x2: s, y2: n } = t; - return [e, r, s, n] = [e, r, s, n].map((o) => +o), [ - ["M", e, r], - ["L", s, n] - ]; -}, nn = (t) => { - const e = [], r = (t.points || "").trim().split(/[\s|,]/).map((n) => +n); - let s = 0; - for (; s < r.length; ) - e.push([s ? "L" : "M", r[s], r[s + 1]]), s += 2; - return t.type === "polygon" ? [...e, ["z"]] : e; -}, rn = (t) => { - let { cx: e, cy: r, r: s } = t; - return [e, r, s] = [e, r, s].map((n) => +n), [ - ["M", e - s, r], - ["a", s, s, 0, 1, 0, 2 * s, 0], - ["a", s, s, 0, 1, 0, -2 * s, 0] - ]; -}, sn = (t) => { - let { cx: e, cy: r } = t, s = t.rx || 0, n = t.ry || s; - return [e, r, s, n] = [e, r, s, n].map((o) => +o), [ - ["M", e - s, r], - ["a", s, n, 0, 1, 0, 2 * s, 0], - ["a", s, n, 0, 1, 0, -2 * s, 0] - ]; -}, on = (t) => { - const e = +t.x || 0, r = +t.y || 0, s = +t.width, n = +t.height; - let o = +(t.rx || 0), i = +(t.ry || o); - return o || i ? (o * 2 > s && (o -= (o * 2 - s) / 2), i * 2 > n && (i -= (i * 2 - n) / 2), [ - ["M", e + o, r], - ["h", s - o * 2], - ["s", o, 0, o, i], - ["v", n - i * 2], - ["s", 0, i, -o, i], - ["h", -s + o * 2], - ["s", -o, 0, -o, -i], - ["v", -n + i * 2], - ["s", 0, -i, o, -i] - ]) : [["M", e, r], ["h", s], ["v", n], ["H", e], ["Z"]]; -}, jt = (t) => { - const e = Object.keys(se), r = vt(t), s = r ? t.tagName : null; - if (s && [...e, "path"].every((c) => s !== c)) - throw TypeError(`${O}: "${s}" is not SVGElement`); - const n = r ? s : t.type, o = se[n], i = { type: n }; - r ? o.forEach((c) => { - i[c] = t.getAttribute(c); - }) : Object.assign(i, t); - let l = []; - return n === "circle" ? l = rn(i) : n === "ellipse" ? l = sn(i) : ["polyline", "polygon"].includes(n) ? l = nn(i) : n === "rect" ? l = on(i) : n === "line" ? l = tn(i) : ["glyph", "path"].includes(n) && (l = V( - r ? t.getAttribute("d") || /* istanbul ignore next @preserve */ - "" : t.d || "" - )), Pe(l) && l.length ? l : !1; -}, cn = (t, e, r) => { - const s = r || document, n = Object.keys(se), o = vt(t), i = o ? t.tagName : null; - if (i === "path") - throw TypeError(`${O}: "${i}" is already SVGPathElement`); - if (i && n.every((u) => i !== u)) - throw TypeError(`${O}: "${i}" is not SVGElement`); - const l = s.createElementNS("http://www.w3.org/2000/svg", "path"), c = o ? i : t.type, a = se[c], m = { type: c }, h = K.round, f = jt(t), y = f && f.length ? De(f, h) : ""; - return o ? (a.forEach((u) => { - m[u] = t.getAttribute(u); - }), Object.values(t.attributes).forEach(({ name: u, value: g }) => { - a.includes(u) || l.setAttribute(u, g); - })) : (Object.assign(m, t), Object.keys(m).forEach((u) => { - !a.includes(u) && u !== "type" && l.setAttribute( - u.replace(/[A-Z]/g, (g) => `-${g.toLowerCase()}`), - m[u] - ); - })), Tt(y) ? (l.setAttribute("d", y), e && o && (t.before(l, t), t.remove()), l) : !1; -}, $t = (t) => { - let e = new P(); - const { origin: r } = t, [s, n] = r, { translate: o } = t, { rotate: i } = t, { skew: l } = t, { scale: c } = t; - return Array.isArray(o) && o.length >= 2 && o.every((a) => !Number.isNaN(+a)) && o.some((a) => a !== 0) ? e = e.translate(...o) : typeof o == "number" && !Number.isNaN(o) && (e = e.translate(o)), (i || l || c) && (e = e.translate(s, n), Array.isArray(i) && i.length >= 2 && i.every((a) => !Number.isNaN(+a)) && i.some((a) => a !== 0) ? e = e.rotate(...i) : typeof i == "number" && !Number.isNaN(i) && (e = e.rotate(i)), Array.isArray(l) && l.length === 2 && l.every( - (a) => !Number.isNaN(+a) - ) && l.some((a) => a !== 0) ? (e = l[0] ? e.skewX(l[0]) : e, e = l[1] ? e.skewY(l[1]) : e) : typeof l == "number" && !Number.isNaN(l) && (e = e.skewX(l)), Array.isArray(c) && c.length >= 2 && c.every( - (a) => !Number.isNaN(+a) - ) && c.some((a) => a !== 1) ? e = e.scale(...c) : typeof c == "number" && !Number.isNaN(c) && (e = e.scale(c)), e = e.translate(-s, -n)), e; -}, zt = (t, e, r, s) => { - const [n] = t, { round: o } = K, i = o, l = e.slice(1), { x1: c, y1: a, x2: m, y2: h, x: f, y } = r, [u, g] = l.slice(-2), p = t; - if ("TQ".includes(n) || (r.qx = null, r.qy = null), n === "L") { - if (v(f, i) === v(u, i)) - return ["V", g]; - if (v(y, i) === v(g, i)) - return ["H", u]; - } else if (n === "C") { - const [b, M] = l; - if (r.x1 = b, r.y1 = M, "CS".includes(s) && (v(b, i) === v(c * 2 - m, i) && v(M, i) === v(a * 2 - h, i) || v(c, i) === v(m * 2 - f, i) && v(a, i) === v(h * 2 - y, i))) - return [ - "S", - l[2], - l[3], - l[4], - l[5] - ]; - } else if (n === "Q") { - const [b, M] = l; - if (r.qx = b, r.qy = M, "QT".includes(s) && v(b, i) === v(c * 2 - m, i) && v(M, i) === v(a * 2 - h, i)) - return ["T", l[2], l[3]]; - } - return p; -}, ge = (t, e) => { - const r = t.slice(1).map( - (s) => v(s, e) - ); - return [t[0]].concat(r); -}, qt = (t, e) => { - const r = be(t), s = typeof e == "number" && e >= 0 ? e : ( - /* istanbul ignore next @preserve */ - 2 - ), n = { ...le }, o = []; - let i = "M", l = "Z"; - return _(r, (c, a, m, h) => { - n.x = m, n.y = h; - const f = Ae(c, n); - let y = c; - if ([i] = c, o[a] = i, a) { - l = o[a - 1]; - const g = zt( - c, - f, - n, - l - ), p = ge(g, s), b = p.join(""), M = Ze(g, a, m, h), d = ge(M, s), x = d.join(""); - y = b.length < x.length ? p : d; - } - const u = f.length; - return n.x1 = +f[u - 2], n.y1 = +f[u - 1], n.x2 = +f[u - 4] || n.x1, n.y2 = +f[u - 3] || n.y1, y; - }); -}, ln = (t, e) => { - let r = P.Translate(e[0], e[1], e[2]); - return [, , , r.m44] = e, r = t.multiply(r), [r.m41, r.m42, r.m43, r.m44]; -}, Ee = (t, e, r) => { - const [s, n, o] = r, [i, l, c] = ln(t, [e[0], e[1], 0, 1]), a = i - s, m = l - n, h = c - o; - return [ - // protect against division by ZERO - a * (Math.abs(o) / Math.abs(h) || 1) + s, - m * (Math.abs(o) / Math.abs(h) || 1) + n - ]; -}, an = (t) => { - const e = t.slice(1).map( - (r, s, n) => s ? n[s - 1].slice(-2).concat(r.slice(1)) : t[0].slice(1).concat(r.slice(1)) - ).map((r) => r.map((s, n) => r[r.length - n - 2 * (1 - n % 2)])).reverse(); - return [["M"].concat(e[0].slice(0, 2))].concat( - e.map((r) => ["C"].concat(r.slice(2))) - ); -}, me = (t) => { - const e = be(t), r = ae(e), s = e.length, n = e[s - 1][0] === "Z", o = _(e, (i, l) => { - const c = r[l], a = l && e[l - 1], m = a && a[0], h = e[l + 1], f = h && h[0], [y] = i, [u, g] = r[l ? l - 1 : s - 1].slice(-2); - let p = i; - switch (y) { - case "M": - p = n ? ["Z"] : [y, u, g]; - break; - case "A": - p = [ - y, - i[1], - i[2], - i[3], - i[4], - i[5] === 1 ? 0 : 1, - u, - g - ]; - break; - case "C": - h && f === "S" ? p = ["S", i[1], i[2], u, g] : p = [ - y, - i[3], - i[4], - i[1], - i[2], - u, - g - ]; - break; - case "S": - m && "CS".includes(m) && (!h || f !== "S") ? p = [ - "C", - c[3], - c[4], - c[1], - c[2], - u, - g - ] : p = [ - y, - c[1], - c[2], - u, - g - ]; - break; - case "Q": - h && f === "T" ? p = ["T", u, g] : p = [y, i[1], i[2], u, g]; - break; - case "T": - m && "QT".includes(m) && (!h || f !== "T") ? p = [ - "Q", - c[1], - c[2], - u, - g - ] : p = [y, u, g]; - break; - case "Z": - p = ["M", u, g]; - break; - case "H": - p = [y, u]; - break; - case "V": - p = [y, g]; - break; - default: - p = [y].concat( - i.slice(1, -2), - u, - g - ); - } - return p; - }); - return n ? o.reverse() : [o[0]].concat(o.slice(1).reverse()); -}, mn = (t, e) => { - let { round: r } = K; - return r = e === "off" || typeof e == "number" && e >= 0 ? e : typeof r == "number" && r >= 0 ? r : ( - /* istanbul ignore next @preserve */ - "off" - ), r === "off" ? t.slice(0) : _(t, (s) => ge(s, r)); -}, un = (t, e = 0.5) => { - const r = e, s = t.slice(0, 2), n = t.slice(2, 4), o = t.slice(4, 6), i = t.slice(6, 8), l = Z(s, n, r), c = Z(n, o, r), a = Z(o, i, r), m = Z(l, c, r), h = Z(c, a, r), f = Z(m, h, r); - return [ - ["C", l[0], l[1], m[0], m[1], f[0], f[1]], - ["C", h[0], h[1], a[0], a[1], i[0], i[1]] - ]; -}, kt = (t) => { - const e = []; - let r, s = -1, n = 0, o = 0, i = 0, l = 0; - const c = { ...le }; - return t.forEach((a) => { - const [m] = a, h = m.toUpperCase(), f = m.toLowerCase(), y = m === f, u = a.slice(1); - h === "M" ? (s += 1, [n, o] = u, n += y ? c.x : 0, o += y ? c.y : 0, i = n, l = o, r = [y ? [h, i, l] : a]) : (h === "Z" ? (n = i, o = l) : h === "H" ? ([, n] = a, n += y ? c.x : ( - /* istanbul ignore next @preserve */ - 0 - )) : h === "V" ? ([, o] = a, o += y ? c.y : ( - /* istanbul ignore next @preserve */ - 0 - )) : ([n, o] = a.slice(-2), n += y ? c.x : 0, o += y ? c.y : 0), r.push(a)), c.x = n, c.y = o, e[s] = r; - }), e; -}, It = (t, e) => { - let r = 0, s = 0, n = 0, o = 0, i = 0, l = 0, c = "M"; - const a = V(t), m = e && Object.keys(e); - if (!e || m && !m.length) - return a.slice(0); - e.origin || Object.assign(e, { origin: K.origin }); - const h = e.origin, f = $t(e); - return f.isIdentity ? a.slice(0) : _(a, (y, u, g, p) => { - [c] = y; - const b = c.toUpperCase(), d = b !== c ? ce(y, u, g, p) : y.slice(0); - let x = b === "A" ? ["C"].concat( - Me( - g, - p, - d[1], - d[2], - d[3], - d[4], - d[5], - d[6], - d[7] - ) - ) : b === "V" ? ["L", g, d[1]] : b === "H" ? ["L", d[1], p] : d; - c = x[0]; - const A = c === "C" && x.length > 7, S = A ? x.slice(0, 7) : x.slice(0); - if (A && (a.splice( - u + 1, - 0, - ["C"].concat( - x.slice(7) - ) - ), x = S), c === "L") - [n, o] = Ee(f, [ - x[1], - x[2] - ], h), r !== n && s !== o ? x = ["L", n, o] : s === o ? x = ["H", n] : r === n && (x = ["V", o]); - else - for (i = 1, l = x.length; i < l; i += 2) - [n, o] = Ee( - f, - [+x[i], +x[i + 1]], - h - ), x[i] = n, x[i + 1] = o; - return r = n, s = o, x; - }); -}, hn = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ - __proto__: null, - CSSMatrix: P, - absolutizeSegment: ce, - arcToCubic: Me, - arcTools: Rt, - bezierTools: Qt, - cubicTools: Zt, - distanceEpsilon: ye, - distanceSquareRoot: xe, - finalizeSegment: ke, - getClosestPoint: Ut, - getDrawDirection: Jt, - getPathArea: Pt, - getPathBBox: Nt, - getPointAtLength: ne, - getPropertiesAtLength: Be, - getPropertiesAtPoint: Se, - getSVGMatrix: $t, - getSegmentAtLength: Kt, - getSegmentOfPoint: Wt, - getTotalLength: ee, - invalidPathValue: F, - isAbsoluteArray: wt, - isArcCommand: bt, - isCurveArray: Xt, - isDigit: H, - isDigitStart: pt, - isMoveCommand: Mt, - isNormalizedArray: Lt, - isPathArray: Pe, - isPathCommand: xt, - isPointInStroke: Yt, - isRelativeArray: en, - isSpace: dt, - isValidPath: Tt, - iterate: _, - lineToCubic: Ie, - lineTools: _t, - midPoint: Z, - normalizePath: ae, - normalizeSegment: Ae, - optimizePath: qt, - paramsCount: X, - paramsParser: le, - parsePathString: V, - pathParser: Qe, - pathToAbsolute: be, - pathToCurve: Ce, - pathToRelative: At, - pathToString: De, - polygonTools: Ft, - projection2d: Ee, - quadToCubic: Ct, - quadTools: Dt, - relativizeSegment: Ze, - reverseCurve: an, - reversePath: me, - rotateVector: te, - roundPath: mn, - roundSegment: ge, - roundTo: v, - scanFlag: yt, - scanParam: gt, - scanSegment: Re, - segmentToCubic: St, - shapeParams: se, - shapeToPath: cn, - shapeToPathArray: jt, - shortenSegment: zt, - skipSpaces: Y, - splitCubic: un, - splitPath: kt, - transformPath: It -}, Symbol.toStringTag, { value: "Module" })); -class fn { - /** - * @constructor - * @param pathValue the path string - * @param config instance options - */ - constructor(e, r) { - const s = r || {}, n = typeof e > "u"; - if (n || !e.length) - throw TypeError( - `${O}: "pathValue" is ${n ? "undefined" : "empty"}` - ); - this.segments = V(e); - const { round: o, origin: i } = s; - let l; - Number.isInteger(o) || o === "off" ? l = o : l = K.round; - let c = K.origin; - if (Array.isArray(i) && i.length >= 2) { - const [a, m, h] = i.map(Number); - c = [ - Number.isNaN(a) ? 0 : a, - Number.isNaN(m) ? 0 : m, - Number.isNaN(h) ? 0 : h - ]; - } - return this.round = l, this.origin = c, this; - } - get bbox() { - return Nt(this.segments); - } - get length() { - return ee(this.segments); - } - /** - * Returns the path bounding box, equivalent to native `path.getBBox()`. - * - * @public - * @returns the pathBBox - */ - getBBox() { - return this.bbox; - } - /** - * Returns the total path length, equivalent to native `path.getTotalLength()`. - * - * @public - * @returns the path total length - */ - getTotalLength() { - return this.length; - } - /** - * Returns an `{x,y}` point in the path stroke at a given length, - * equivalent to the native `path.getPointAtLength()`. - * - * @public - * @param length the length - * @returns the requested point - */ - getPointAtLength(e) { - return ne(this.segments, e); - } - /** - * Convert path to absolute values - * - * @public - */ - toAbsolute() { - const { segments: e } = this; - return this.segments = be(e), this; - } - /** - * Convert path to relative values - * - * @public - */ - toRelative() { - const { segments: e } = this; - return this.segments = At(e), this; - } - /** - * Convert path to cubic-bezier values. In addition, un-necessary `Z` - * segment is removed if previous segment extends to the `M` segment. - * - * @public - */ - toCurve() { - const { segments: e } = this; - return this.segments = Ce(e), this; - } - /** - * Reverse the order of the segments and their values. - * - * @param onlySubpath option to reverse all sub-paths except first - * @public - */ - reverse(e) { - const { segments: r } = this, s = kt(r), n = s.length > 1 ? s : !1, o = n ? n.map((l, c) => e ? c ? me(l) : l.slice(0) : me(l)) : r.slice(0); - let i = []; - return n ? i = o.flat(1) : i = e ? r : me(r), this.segments = i.slice(0), this; - } - /** - * Normalize path in 2 steps: - * * convert `pathArray`(s) to absolute values - * * convert shorthand notation to standard notation - * - * @public - */ - normalize() { - const { segments: e } = this; - return this.segments = ae(e), this; - } - /** - * Optimize `pathArray` values: - * * convert segments to absolute and/or relative values - * * select segments with shortest resulted string - * * round values to the specified `decimals` option value - * - * @public - */ - optimize() { - const { segments: e } = this, r = this.round === "off" ? 2 : this.round; - return this.segments = qt(e, r), this; - } - /** - * Transform path using values from an `Object` defined as `transformObject`. - * - * @see TransformObject for a quick refference - * - * @param source a `transformObject`as described above - * @public - */ - transform(e) { - if (!e || typeof e != "object" || typeof e == "object" && !["translate", "rotate", "skew", "scale"].some((c) => c in e)) - return this; - const { - segments: r, - origin: [s, n, o] - } = this, i = {}; - for (const [c, a] of Object.entries(e)) - c === "skew" && Array.isArray(a) || (c === "rotate" || c === "translate" || c === "origin" || c === "scale") && Array.isArray(a) ? i[c] = a.map(Number) : c !== "origin" && typeof Number(a) == "number" && (i[c] = Number(a)); - const { origin: l } = i; - if (Array.isArray(l) && l.length >= 2) { - const [c, a, m] = l.map(Number); - i.origin = [ - Number.isNaN(c) ? s : c, - Number.isNaN(a) ? n : a, - m || o - ]; - } else - i.origin = [s, n, o]; - return this.segments = It(r, i), this; - } - /** - * Rotate path 180deg vertically - * - * @public - */ - flipX() { - const { cx: e, cy: r } = this.bbox; - return this.transform({ rotate: [0, 180, 0], origin: [e, r, 0] }), this; - } - /** - * Rotate path 180deg horizontally - * - * @public - */ - flipY() { - const { cx: e, cy: r } = this.bbox; - return this.transform({ rotate: [180, 0, 0], origin: [e, r, 0] }), this; - } - /** - * Export the current path to be used - * for the `d` (description) attribute. - * - * @public - * @return the path string - */ - toString() { - return De(this.segments, this.round); - } - /** - * Remove the instance. - * - * @public - * @return void - */ - dispose() { - Object.keys(this).forEach((e) => delete this[e]); - } -} -const yn = Object.assign(fn, hn); -export { - yn as default -}; -//# sourceMappingURL=svg-path-commander.mjs.map +var jt=Object.defineProperty;var me=(t,e)=>{for(var n in e)jt(t,n,{get:e[n],enumerable:!0})};var dt={};me(dt,{CSSMatrix:()=>pn,absolutizeSegment:()=>_,arcToCubic:()=>Pe,arcTools:()=>lt,bezierTools:()=>ct,cubicTools:()=>ht,distanceEpsilon:()=>fe,distanceSquareRoot:()=>ie,finalizeSegment:()=>ve,getClosestPoint:()=>Rt,getDrawDirection:()=>kt,getPathArea:()=>Ge,getPathBBox:()=>_e,getPointAtLength:()=>te,getPropertiesAtLength:()=>Ae,getPropertiesAtPoint:()=>re,getSVGMatrix:()=>Xe,getSegmentAtLength:()=>zt,getSegmentOfPoint:()=>Vt,getTotalLength:()=>F,invalidPathValue:()=>H,isAbsoluteArray:()=>Ue,isArcCommand:()=>$e,isCurveArray:()=>Qt,isDigit:()=>B,isDigitStart:()=>Ie,isMoveCommand:()=>je,isNormalizedArray:()=>Ke,isPathArray:()=>ne,isPathCommand:()=>Oe,isPointInStroke:()=>qt,isRelativeArray:()=>Et,isSpace:()=>De,isValidPath:()=>Fe,iterate:()=>M,lineToCubic:()=>Ne,lineTools:()=>at,midPoint:()=>D,normalizePath:()=>K,normalizeSegment:()=>Y,optimizePath:()=>et,paramsCount:()=>Z,paramsParser:()=>U,parsePathString:()=>T,pathParser:()=>W,pathToAbsolute:()=>X,pathToCurve:()=>ee,pathToRelative:()=>Be,pathToString:()=>Se,polygonTools:()=>yt,projection2d:()=>we,quadToCubic:()=>He,quadTools:()=>gt,relativizeSegment:()=>xe,reverseCurve:()=>Ot,reversePath:()=>Ce,rotateVector:()=>ce,roundPath:()=>It,roundSegment:()=>he,roundTo:()=>L,scanFlag:()=>qe,scanParam:()=>Ee,scanSegment:()=>de,segmentToCubic:()=>Ze,shapeParams:()=>oe,shapeToPath:()=>Dt,shapeToPathArray:()=>We,shortenSegment:()=>Ye,skipSpaces:()=>G,splitCubic:()=>$t,splitPath:()=>tt,transformPath:()=>rt});import{default as pn}from"@thednp/dommatrix";var lt={};me(lt,{angleBetween:()=>st,arcLength:()=>mt,arcPoint:()=>le,getArcBBox:()=>ut,getArcLength:()=>Me,getArcProps:()=>ke,getPointAtArcLength:()=>it});var at={};me(at,{getLineBBox:()=>Re,getLineLength:()=>ue,getPointAtLineLength:()=>Te});var Bt=(t,e,n)=>{let[o,r]=t,[s,a]=e;return[o+(s-o)*n,r+(a-r)*n]},D=Bt;var Ht=(t,e)=>Math.sqrt((t[0]-e[0])*(t[0]-e[0])+(t[1]-e[1])*(t[1]-e[1])),ie=Ht;var ue=(t,e,n,o)=>ie([t,e],[n,o]),Te=(t,e,n,o,r)=>{let s={x:t,y:e};if(typeof r=="number"){let a=ie([t,e],[n,o]);if(r<=0)s={x:t,y:e};else if(r>=a)s={x:n,y:o};else{let[i,m]=D([t,e],[n,o],r/a);s={x:i,y:m}}}return s},Re=(t,e,n,o)=>{let{min:r,max:s}=Math;return[r(t,n),r(e,o),s(t,n),s(e,o)]};var mt=(t,e,n)=>{let o=n/2,r=Math.sin(o),s=Math.cos(o),a=t**2*r**2,i=e**2*s**2,m=Math.sqrt(a+i)*n;return Math.abs(m)},le=(t,e,n,o,r,s)=>{let{sin:a,cos:i}=Math,m=i(r),u=a(r),l=n*i(s),p=o*a(s);return[t+m*l-u*p,e+u*l+m*p]},st=(t,e)=>{let{x:n,y:o}=t,{x:r,y:s}=e,a=n*r+o*s,i=Math.sqrt((n**2+o**2)*(r**2+s**2));return(n*s-o*r<0?-1:1)*Math.acos(a/i)},ke=(t,e,n,o,r,s,a,i,m)=>{let{abs:u,sin:l,cos:p,sqrt:f,PI:h}=Math,c=u(n),b=u(o),S=(r%360+360)%360*(h/180);if(t===i&&e===m)return{rx:c,ry:b,startAngle:0,endAngle:0,center:{x:i,y:m}};if(c===0||b===0)return{rx:c,ry:b,startAngle:0,endAngle:0,center:{x:(i+t)/2,y:(m+e)/2}};let A=(t-i)/2,y=(e-m)/2,g={x:p(S)*A+l(S)*y,y:-l(S)*A+p(S)*y},x=g.x**2/c**2+g.y**2/b**2;x>1&&(c*=f(x),b*=f(x));let C=c**2*b**2-c**2*g.y**2-b**2*g.x**2,k=c**2*g.y**2+b**2*g.x**2,V=C/k;V=V<0?0:V;let w=(s!==a?1:-1)*f(V),v={x:w*(c*g.y/b),y:w*(-(b*g.x)/c)},$={x:p(S)*v.x-l(S)*v.y+(t+i)/2,y:l(S)*v.x+p(S)*v.y+(e+m)/2},ae={x:(g.x-v.x)/c,y:(g.y-v.y)/b},Q=st({x:1,y:0},ae),P={x:(-g.x-v.x)/c,y:(-g.y-v.y)/b},q=st(ae,P);!a&&q>0?q-=2*h:a&&q<0&&(q+=2*h),q%=2*h;let j=Q+q;return{center:$,startAngle:Q,endAngle:j,rx:c,ry:b}},Me=(t,e,n,o,r,s,a,i,m)=>{let{rx:u,ry:l,startAngle:p,endAngle:f}=ke(t,e,n,o,r,s,a,i,m);return mt(u,l,f-p)},it=(t,e,n,o,r,s,a,i,m,u)=>{let l={x:t,y:e},{center:p,rx:f,ry:h,startAngle:c,endAngle:b}=ke(t,e,n,o,r,s,a,i,m);if(typeof u=="number"){let d=mt(f,h,b-c);if(u<=0)l={x:t,y:e};else if(u>=d)l={x:i,y:m};else{if(t===i&&e===m)return{x:i,y:m};if(f===0||h===0)return Te(t,e,i,m,u);let{PI:S,cos:A,sin:y}=Math,g=b-c,C=(r%360+360)%360*(S/180),k=c+g*(u/d),V=f*A(k),w=h*y(k);l={x:A(C)*V-y(C)*w+p.x,y:y(C)*V+A(C)*w+p.y}}}return l},ut=(t,e,n,o,r,s,a,i,m)=>{let{center:u,rx:l,ry:p,startAngle:f,endAngle:h}=ke(t,e,n,o,r,s,a,i,m),c=h-f,{min:b,max:d,tan:S,atan2:A,PI:y}=Math,{x:g,y:x}=u,C=r*y/180,k=S(C),V=A(-p*k,l),w=V,v=V+y,$=A(p,l*k),ae=$+y,Q=[i],P=[m],q=b(t,i),j=d(t,i),O=b(e,m),J=d(e,m),be=h-c*1e-5,se=le(g,x,l,p,C,be),N=h-c*.99999,E=le(g,x,l,p,C,N);if(se[0]>j||E[0]>j){let R=le(g,x,l,p,C,w);Q.push(R[0]),P.push(R[1])}if(se[0]J||E[1]>J){let R=le(g,x,l,p,C,$);Q.push(R[0]),P.push(R[1])}return q=b.apply([],Q),O=b.apply([],P),j=d.apply([],Q),J=d.apply([],P),[q,O,j,J]};var ct={};me(ct,{CBEZIER_MINMAX_EPSILON:()=>Lt,Cvalues:()=>St,Tvalues:()=>pt,bezierLength:()=>Mt,calculateBezier:()=>Tt,computeBezier:()=>Ct,deriveBezier:()=>At,getBezierLength:()=>pe,minmaxC:()=>ze,minmaxQ:()=>Le});var pt=[-.06405689286260563,.06405689286260563,-.1911188674736163,.1911188674736163,-.3150426796961634,.3150426796961634,-.4337935076260451,.4337935076260451,-.5454214713888396,.5454214713888396,-.6480936519369755,.6480936519369755,-.7401241915785544,.7401241915785544,-.820001985973903,.820001985973903,-.8864155270044011,.8864155270044011,-.9382745520027328,.9382745520027328,-.9747285559713095,.9747285559713095,-.9951872199970213,.9951872199970213],St=[.12793819534675216,.12793819534675216,.1258374563468283,.1258374563468283,.12167047292780339,.12167047292780339,.1155056680537256,.1155056680537256,.10744427011596563,.10744427011596563,.09761865210411388,.09761865210411388,.08619016153195327,.08619016153195327,.0733464814110803,.0733464814110803,.05929858491543678,.05929858491543678,.04427743881741981,.04427743881741981,.028531388628933663,.028531388628933663,.0123412297999872,.0123412297999872],At=t=>{let e=[];for(let n=t,o=n.length,r=o-1;o>1;o-=1,r-=1){let s=[];for(let a=0;a{if(e===0)return t[0].t=0,t[0];let n=t.length-1;if(e===1)return t[n].t=1,t[n];let o=1-e,r=t;if(n===0)return t[0].t=e,t[0];if(n===1)return{x:o*r[0].x+e*r[1].x,y:o*r[0].y+e*r[1].y,t:e};let s=o*o,a=e*e,i=0,m=0,u=0,l=0;return n===2?(r=[r[0],r[1],r[2],{x:0,y:0}],i=s,m=o*e*2,u=a):n===3&&(i=s*o,m=s*e*3,u=o*a*3,l=e*a),{x:i*r[0].x+m*r[1].x+u*r[2].x+l*r[3].x,y:i*r[0].y+m*r[1].y+u*r[2].y+l*r[3].y,t:e}},Tt=(t,e)=>{let n=t(e),o=n.x*n.x+n.y*n.y;return Math.sqrt(o)},Mt=t=>{let n=pt.length,o=0;for(let r=0,s;r{let e=[];for(let o=0,r=t.length,s=2;oCt(n[0],o))},Lt=1e-8,Le=([t,e,n])=>{let o=Math.min(t,n),r=Math.max(t,n);if(e>=t?n>=e:n<=e)return[o,r];let s=(t*n-e*e)/(t-2*e+n);return s{let r=t-3*e+3*n-o;if(Math.abs(r)0&&l<1){let f=t*(1-l)*(1-l)*(1-l)+e*3*(1-l)*(1-l)*l+n*3*(1-l)*l*l+o*l*l*l;fm&&(m=f)}}return[i,m]};var ht={};me(ht,{getCubicBBox:()=>Ve,getCubicLength:()=>ge,getPointAtCubicLength:()=>ft,getPointAtCubicSegmentLength:()=>vt});var vt=([t,e,n,o,r,s,a,i],m)=>{let u=1-m;return{x:u**3*t+3*u**2*m*n+3*u*m**2*r+m**3*a,y:u**3*e+3*u**2*m*o+3*u*m**2*s+m**3*i}},ge=(t,e,n,o,r,s,a,i)=>pe([t,e,n,o,r,s,a,i]),ft=(t,e,n,o,r,s,a,i,m)=>{let u=typeof m=="number",l={x:t,y:e};if(u){let p=pe([t,e,n,o,r,s,a,i]);m<=0||(m>=p?l={x:a,y:i}:l=vt([t,e,n,o,r,s,a,i],m/p))}return l},Ve=(t,e,n,o,r,s,a,i)=>{let m=ze([t,n,r,a]),u=ze([e,o,s,i]);return[m[0],u[0],m[1],u[1]]};var gt={};me(gt,{getPointAtQuadLength:()=>bt,getPointAtQuadSegmentLength:()=>Nt,getQuadBBox:()=>Qe,getQuadLength:()=>ye});var Nt=([t,e,n,o,r,s],a)=>{let i=1-a;return{x:i**2*t+2*i*a*n+a**2*r,y:i**2*e+2*i*a*o+a**2*s}},ye=(t,e,n,o,r,s)=>pe([t,e,n,o,r,s]),bt=(t,e,n,o,r,s,a)=>{let i=typeof a=="number",m={x:t,y:e};if(i){let u=pe([t,e,n,o,r,s]);a<=0||(a>=u?m={x:r,y:s}:m=Nt([t,e,n,o,r,s],a/u))}return m},Qe=(t,e,n,o,r,s)=>{let a=Le([t,n,r]),i=Le([e,o,s]);return[a[0],i[0],a[1],i[1]]};var yt={};me(yt,{polygonArea:()=>Zt,polygonLength:()=>Gt});var Zt=t=>{let e=t.length,n=-1,o,r=t[e-1],s=0;for(;++nt.reduce((e,n,o)=>o?e+ie(t[o-1],n):0,0);var _t={a:7,c:6,h:1,l:2,m:2,r:4,q:4,s:4,t:2,v:1,z:0},Z=_t;var Ut=t=>{let e=t.pathValue[t.segmentStart],n=e.toLowerCase(),{data:o}=t;for(;o.length>=Z[n]&&(n==="m"&&o.length>2?(t.segments.push([e].concat(o.splice(0,2))),n="l",e=e==="m"?"l":"L"):t.segments.push([e].concat(o.splice(0,Z[n]))),!!Z[n]););},ve=Ut;var Kt="SVGPathCommander Error",z=Kt;var Ft=t=>{let{index:e,pathValue:n}=t,o=n.charCodeAt(e);if(o===48){t.param=0,t.index+=1;return}if(o===49){t.param=1,t.index+=1;return}t.err=`${z}: invalid Arc flag "${n[e]}", expecting 0 or 1 at index ${e}`},qe=Ft;var Jt=t=>t>=48&&t<=57,B=Jt;var Wt="Invalid path value",H=Wt;var Xt=t=>{let{max:e,pathValue:n,index:o}=t,r=o,s=!1,a=!1,i=!1,m=!1,u;if(r>=e){t.err=`${z}: ${H} at index ${r}, "pathValue" is missing param`;return}if(u=n.charCodeAt(r),(u===43||u===45)&&(r+=1,u=n.charCodeAt(r)),!B(u)&&u!==46){t.err=`${z}: ${H} at index ${r}, "${n[r]}" is not a number`;return}if(u!==46){if(s=u===48,r+=1,u=n.charCodeAt(r),s&&r[5760,6158,8192,8193,8194,8195,8196,8197,8198,8199,8200,8201,8202,8239,8287,12288,65279,10,13,8232,8233,32,9,11,12,160].includes(t),De=Yt;var er=t=>{let{pathValue:e,max:n}=t;for(;t.index{switch(t|32){case 109:case 122:case 108:case 104:case 118:case 99:case 115:case 113:case 116:case 97:return!0;default:return!1}},Oe=tr;var rr=t=>B(t)||t===43||t===45||t===46,Ie=rr;var nr=t=>(t|32)===97,$e=nr;var or=t=>{switch(t|32){case 109:case 77:return!0;default:return!1}},je=or;var ar=t=>{let{max:e,pathValue:n,index:o,segments:r}=t,s=n.charCodeAt(o),a=Z[n[o].toLowerCase()];if(t.segmentStart=o,!Oe(s)){t.err=`${z}: ${H} "${n[o]}" is not a path command at index ${o}`;return}let i=r[r.length-1];if(!je(s)&&i?.[0]?.toLocaleLowerCase()==="z"){t.err=`${z}: ${H} "${n[o]}" is not a MoveTo path command at index ${o}`;return}if(t.index+=1,G(t),t.data=[],!a){ve(t);return}for(;;){for(let m=a;m>0;m-=1){if($e(s)&&(m===3||m===4)?qe(t):Ee(t),t.err.length)return;t.data.push(t.param),G(t),t.index=t.max||!Ie(n.charCodeAt(t.index)))break}ve(t)},de=ar;var W=class{constructor(e){this.segments=[],this.pathValue=e,this.max=e.length,this.index=0,this.param=0,this.segmentStart=0,this.data=[],this.err=""}};var sr=t=>{if(typeof t!="string")return t.slice(0);let e=new W(t);for(G(e);e.index{let[r]=t,s=r.toUpperCase(),a=s===r;if(e===0||a)return t;if(s==="A")return[s,t[1],t[2],t[3],t[4],t[5],t[6]+n,t[7]+o];if(s==="V")return[s,t[1]+o];if(s==="H")return[s,t[1]+n];if(s==="L")return[s,t[1]+n,t[2]+o];{let i=[],m=t.length;for(let u=1;u{let n=t.length,o,r="M",s="M",a=!1,i=0,m=0,u=0,l=0,p=0;for(let f=0;f{let e=T(t);return M(e,_)},X=ur;var lr=(t,e,n,o)=>{let[r]=t,s=r.toLowerCase(),a=r===s;if(e===0||a)return t;if(s==="a")return[s,t[1],t[2],t[3],t[4],t[5],t[6]-n,t[7]-o];if(s==="v")return[s,t[1]-o];if(s==="h")return[s,t[1]-n];if(s==="l")return[s,t[1]-n,t[2]-o];{let i=[],m=t.length;for(let u=1;u{let e=T(t);return M(e,xe)},Be=pr;var cr=(t,e,n)=>{let{sin:o,cos:r}=Math,s=t*r(n)-e*o(n),a=t*o(n)+e*r(n);return{x:s,y:a}},ce=cr;var wt=(t,e,n,o,r,s,a,i,m,u)=>{let l=t,p=e,f=n,h=o,c=i,b=m,d=Math.PI*120/180,S=Math.PI/180*(+r||0),A=[],y,g,x,C,k;if(u)[g,x,C,k]=u;else{y=ce(l,p,-S),l=y.x,p=y.y,y=ce(c,b,-S),c=y.x,b=y.y;let N=(l-c)/2,E=(p-b)/2,R=N*N/(f*f)+E*E/(h*h);R>1&&(R=Math.sqrt(R),f*=R,h*=R);let nt=f*f,ot=h*h,Pt=(s===a?-1:1)*Math.sqrt(Math.abs((nt*ot-nt*E*E-ot*N*N)/(nt*E*E+ot*N*N)));C=Pt*f*E/h+(l+c)/2,k=Pt*-h*N/f+(p+b)/2,g=Math.asin(((p-k)/h*10**9>>0)/10**9),x=Math.asin(((b-k)/h*10**9>>0)/10**9),g=lx&&(g-=Math.PI*2),!a&&x>g&&(x-=Math.PI*2)}let V=x-g;if(Math.abs(V)>d){let N=x,E=c,R=b;x=g+d*(a&&x>g?1:-1),c=C+f*Math.cos(x),b=k+h*Math.sin(x),A=wt(c,b,f,h,r,0,a,E,R,[x,N,C,k])}V=x-g;let w=Math.cos(g),v=Math.sin(g),$=Math.cos(x),ae=Math.sin(x),Q=Math.tan(V/4),P=4/3*f*Q,q=4/3*h*Q,j=[l,p],O=[l+P*v,p-q*w],J=[c+P*ae,b-q*$],be=[c,b];if(O[0]=2*j[0]-O[0],O[1]=2*j[1]-O[1],u)return[O[0],O[1],J[0],J[1],be[0],be[1]].concat(A);A=[O[0],O[1],J[0],J[1],be[0],be[1]].concat(A);let se=[];for(let N=0,E=A.length;N{let a=.3333333333333333,i=2/3;return[a*t+i*n,a*e+i*o,a*r+i*n,a*s+i*o,r,s]},He=fr;var hr=(t,e,n,o)=>{let r=D([t,e],[n,o],.3333333333333333),s=D([t,e],[n,o],2/3);return[r[0],r[1],s[0],s[1],n,o]},Ne=hr;var br=(t,e)=>{let[n]=t,o=t.slice(1).map(Number),[r,s]=o,{x1:a,y1:i,x:m,y:u}=e;return"TQ".includes(n)||(e.qx=null,e.qy=null),n==="M"?(e.x=r,e.y=s,t):n==="A"?["C"].concat(Pe(a,i,o[0],o[1],o[2],o[3],o[4],o[5],o[6])):n==="Q"?(e.qx=r,e.qy=s,["C"].concat(He(a,i,o[0],o[1],o[2],o[3]))):n==="L"?["C"].concat(Ne(a,i,r,s)):n==="Z"?["C"].concat(Ne(a,i,m,u)):t},Ze=br;var gr=(t,e)=>{let[n]=t,o=n.toUpperCase(),r=n!==o,{x1:s,y1:a,x2:i,y2:m,x:u,y:l}=e,p=t.slice(1),f=p.map((h,c)=>h+(r?c%2?l:u:0));"TQ".includes(o)||(e.qx=null,e.qy=null);if(o==="A")return f=p.slice(0,-2).concat(p[5]+(r?u:0),p[6]+(r?l:0)),["A"].concat(f);if(o==="H")return["L",t[1]+(r?u:0),a];if(o==="V")return["L",s,t[1]+(r?l:0)];if(o==="L")return["L",t[1]+(r?u:0),t[2]+(r?l:0)];if(o==="M")return["M",t[1]+(r?u:0),t[2]+(r?l:0)];if(o==="C")return["C"].concat(f);if(o==="S"){let h=s*2-i,c=a*2-m;return e.x1=h,e.y1=c,["C",h,c].concat(f)}else if(o==="T"){let h=s*2-(e.qx?e.qx:0),c=a*2-(e.qy?e.qy:0);return e.qx=h,e.qy=c,["Q",h,c].concat(f)}else if(o==="Q"){let[h,c]=f;return e.qx=h,e.qy=c,["Q"].concat(f)}else if(o==="Z")return["Z"];return t},Y=gr;var yr={x1:0,y1:0,x2:0,y2:0,x:0,y:0,qx:null,qy:null},U=yr;var dr=t=>{let e={...U},n=T(t);return M(n,(o,r,s,a)=>{e.x=s,e.y=a;let i=Y(o,e),m=Ze(i,e);m[0]==="C"&&m.length>7&&(n.splice(r+1,0,["C"].concat(m.slice(7))),m=m.slice(0,7));let l=m.length;return e.x1=+m[l-2],e.y1=+m[l-1],e.x2=+m[l-4]||e.x1,e.y2=+m[l-3]||e.y1,m})},ee=dr;var xr={origin:[0,0,0],round:4},I=xr;var Pr=(t,e)=>{let n=e>=1?10**e:1;return e>0?Math.round(t*n)/n:Math.round(t)},L=Pr;var Sr=(t,e)=>{let n=t.length,{round:o}=I,r=t[0],s="";o=e==="off"||typeof e=="number"&&e>=0?e:typeof o=="number"&&o>=0?o:"off";for(let a=0;a{let e=T(t),n={...U};return M(e,(o,r,s,a)=>{n.x=s,n.y=a;let i=Y(o,n),m=i.length;return n.x1=+i[m-2],n.y1=+i[m-1],n.x2=+i[m-4]||n.x1,n.y2=+i[m-3]||n.y1,i})},K=Ar;var Cr=(t,e)=>{let n=K(t),o=!1,r=[],s="M",a=0,i=0,[m,u]=n[0].slice(1),l=typeof e=="number",p={x:m,y:u},f=0,h=p,c=0;return!l||e{[s]=b,o=s==="M",r=o?r:[S,A].concat(b.slice(1));if(o?([,m,u]=b,p={x:m,y:u},f=0):s==="L"?(p=Te(r[0],r[1],r[2],r[3],e-c),f=ue(r[0],r[1],r[2],r[3])):s==="A"?(p=it(r[0],r[1],r[2],r[3],r[4],r[5],r[6],r[7],r[8],e-c),f=Me(r[0],r[1],r[2],r[3],r[4],r[5],r[6],r[7],r[8])):s==="C"?(p=ft(r[0],r[1],r[2],r[3],r[4],r[5],r[6],r[7],e-c),f=ge(r[0],r[1],r[2],r[3],r[4],r[5],r[6],r[7])):s==="Q"?(p=bt(r[0],r[1],r[2],r[3],r[4],r[5],e-c),f=ye(r[0],r[1],r[2],r[3],r[4],r[5])):s==="Z"&&(r=[S,A,m,u],p={x:m,y:u},f=ue(r[0],r[1],r[2],r[3])),[a,i]=r.slice(-2),cc-fe?{x:a,y:i}:h)},te=Cr;var Tr=t=>{let e=T(t),n=0,o=0,r=0,s=0,a=0,i=0,m="M",u=0,l=0,p=0;return M(e,(f,h,c,b)=>{[m]=f;let d=m.toUpperCase(),A=d!==m?_(f,h,c,b):f.slice(0),y=d==="V"?["L",c,A[1]]:d==="H"?["L",A[1],b]:A;[m]=y,"TQ".includes(d)||(a=0,i=0);if(m==="M")[,u,l]=y;else if(m==="L")p+=ue(c,b,y[1],y[2]);else if(m==="A")p+=Me(c,b,y[1],y[2],y[3],y[4],y[5],y[6],y[7]);else if(m==="S"){let g=n*2-r,x=o*2-s;p+=ge(c,b,g,x,y[1],y[2],y[3],y[4])}else m==="C"?p+=ge(c,b,y[1],y[2],y[3],y[4],y[5],y[6]):m==="T"?(a=n*2-a,i=o*2-i,p+=ye(c,b,a,i,y[1],y[2])):m==="Q"?(a=y[1],i=y[2],p+=ye(c,b,y[1],y[2],y[3],y[4])):m==="Z"&&(p+=ue(c,b,u,l));[n,o]=m==="Z"?[u,l]:y.slice(-2),[r,s]=m==="C"?[y[3],y[4]]:m==="S"?[y[1],y[2]]:[n,o]}),p},F=Tr;var Mr=(t,e)=>{let n=T(t),o=n.slice(0),r=F(o),s=o.length-1,a=0,i=0,m=n[0];if(s<=0||!e||!Number.isFinite(e))return{segment:m,index:0,length:i,lengthAtSegment:a};if(e>=r)return o=n.slice(0,-1),a=F(o),i=r-a,m=n[s],{segment:m,index:s,length:i,lengthAtSegment:a};let u=[];for(;s>0;)m=o[s],o=o.slice(0,-1),a=F(o),i=r-a,r=a,u.push({segment:m,index:s,length:i,lengthAtSegment:a}),s-=1;return u.find(({lengthAtSegment:l})=>l<=e)},Ae=Mr;var Lr=(t,e)=>{let n=T(t),o=K(n),r=F(o),s=g=>{let x=g.x-e.x,C=g.y-e.y;return x*x+C*C},a=8,i,m={x:0,y:0},u=0,l=0,p=1/0;for(let g=0;g<=r;g+=a)i=te(o,g),u=s(i),u1e-6&&(c=l-a,f=te(o,c),d=s(f),b=l+a,h=te(o,b),S=s(h),c>=0&&dre(t,e).closest,Rt=vr;var Nr=(t,e,n,o,r,s,a,i)=>3*((i-e)*(n+r)-(a-t)*(o+s)+o*(t-r)-n*(e-s)+i*(r+t/3)-a*(s+e/3))/20,wr=t=>{let e=0,n=0,o=0;return ee(t).map(r=>{switch(r[0]){case"M":return[,e,n]=r,0;default:return o=Nr(e,n,r[1],r[2],r[3],r[4],r[5],r[6]),[e,n]=r.slice(-2),o}}).reduce((r,s)=>r+s,0)},Ge=wr;var Rr=t=>Ge(ee(t))>=0,kt=Rr;var kr=t=>{if(!t)return{x:0,y:0,width:0,height:0,x2:0,y2:0,cx:0,cy:0,cz:0};let e=T(t),n="M",o=0,r=0,{max:s,min:a}=Math,i=1/0,m=1/0,u=-1/0,l=-1/0,p=0,f=0,h=0,c=0,b=0,d=0,S=0,A=0,y=0,g=0;M(e,(k,V,w,v)=>{[n]=k;let $=n.toUpperCase(),Q=$!==n?_(k,V,w,v):k.slice(0),P=$==="V"?["L",w,Q[1]]:$==="H"?["L",Q[1],v]:Q;[n]=P,"TQ".includes($)||(y=0,g=0);if(n==="M")[,o,r]=P,p=o,f=r,h=o,c=r;else if(n==="L")[p,f,h,c]=Re(w,v,P[1],P[2]);else if(n==="A")[p,f,h,c]=ut(w,v,P[1],P[2],P[3],P[4],P[5],P[6],P[7]);else if(n==="S"){let q=b*2-S,j=d*2-A;[p,f,h,c]=Ve(w,v,q,j,P[1],P[2],P[3],P[4])}else n==="C"?[p,f,h,c]=Ve(w,v,P[1],P[2],P[3],P[4],P[5],P[6]):n==="T"?(y=b*2-y,g=d*2-g,[p,f,h,c]=Qe(w,v,y,g,P[1],P[2])):n==="Q"?(y=P[1],g=P[2],[p,f,h,c]=Qe(w,v,P[1],P[2],P[3],P[4])):n==="Z"&&([p,f,h,c]=Re(w,v,o,r));i=a(p,i),m=a(f,m),u=s(h,u),l=s(c,l),[b,d]=n==="Z"?[o,r]:P.slice(-2),[S,A]=n==="C"?[P[3],P[4]]:n==="S"?[P[1],P[2]]:[b,d]});let x=u-i,C=l-m;return{width:x,height:C,x:i,y:m,x2:u,y2:l,cx:i+x/2,cy:m+C/2,cz:Math.max(x,C)+Math.min(x,C)/2}},_e=kr;var zr=(t,e)=>Ae(t,e).segment,zt=zr;var Vr=(t,e)=>re(t,e).segment,Vt=Vr;var Qr=t=>Array.isArray(t)&&t.every(e=>{let n=e[0].toLowerCase();return Z[n]===e.length-1&&"achlmqstvz".includes(n)&&e.slice(1).every(Number.isFinite)})&&t.length>0,ne=Qr;var qr=t=>ne(t)&&t.every(([e])=>e===e.toUpperCase()),Ue=qr;var Er=t=>Ue(t)&&t.every(([e])=>"ACLMQZ".includes(e)),Ke=Er;var Dr=t=>Ke(t)&&t.every(([e])=>"MC".includes(e)),Qt=Dr;var Or=(t,e)=>{let{distance:n}=re(t,e);return Math.abs(n)ne(t)&&t.slice(1).every(([e])=>e===e.toLowerCase()),Et=Ir;var $r=t=>{if(typeof t!="string"||!t.length)return!1;let e=new W(t);for(G(e);e.indext!=null&&typeof t=="object"&&t.nodeType===1,Je=Br;var Hr=t=>{let{x1:e,y1:n,x2:o,y2:r}=t;return[e,n,o,r]=[e,n,o,r].map(s=>+s),[["M",e,n],["L",o,r]]},Zr=t=>{let e=[],n=(t.points||"").trim().split(/[\s|,]/).map(r=>+r),o=0;for(;o{let{cx:e,cy:n,r:o}=t;return[e,n,o]=[e,n,o].map(r=>+r),[["M",e-o,n],["a",o,o,0,1,0,2*o,0],["a",o,o,0,1,0,-2*o,0]]},_r=t=>{let{cx:e,cy:n}=t,o=t.rx||0,r=t.ry||o;return[e,n,o,r]=[e,n,o,r].map(s=>+s),[["M",e-o,n],["a",o,r,0,1,0,2*o,0],["a",o,r,0,1,0,-2*o,0]]},Ur=t=>{let e=+t.x||0,n=+t.y||0,o=+t.width,r=+t.height,s=+(t.rx||0),a=+(t.ry||s);if(s||a){s*2>o&&(s-=(s*2-o)/2);return a*2>r&&(a-=(a*2-r)/2),[["M",e+s,n],["h",o-s*2],["s",s,0,s,a],["v",r-a*2],["s",0,a,-s,a],["h",-o+s*2],["s",-s,0,-s,-a],["v",-r+a*2],["s",0,-a,s,-a]]}return[["M",e,n],["h",o],["v",r],["H",e],["Z"]]},Kr=t=>{let e=Object.keys(oe),n=Je(t),o=n?t.tagName:null;if(o&&[...e,"path"].every(m=>o!==m))throw TypeError(`${z}: "${o}" is not SVGElement`);let r=n?o:t.type,s=oe[r],a={type:r};n?s.forEach(m=>{a[m]=t.getAttribute(m)}):Object.assign(a,t);let i=[];return r==="circle"?i=Gr(a):r==="ellipse"?i=_r(a):["polyline","polygon"].includes(r)?i=Zr(a):r==="rect"?i=Ur(a):r==="line"?i=Hr(a):["glyph","path"].includes(r)&&(i=T(n?t.getAttribute("d")||"":t.d||"")),ne(i)&&i.length?i:!1},We=Kr;var Fr=(t,e,n)=>{let o=n||document,r=Object.keys(oe),s=Je(t),a=s?t.tagName:null;if(a==="path")throw TypeError(`${z}: "${a}" is already SVGPathElement`);if(a&&r.every(c=>a!==c))throw TypeError(`${z}: "${a}" is not SVGElement`);let i=o.createElementNS("http://www.w3.org/2000/svg","path"),m=s?a:t.type,u=oe[m],l={type:m},p=I.round,f=We(t),h=f&&f.length?Se(f,p):"";return s?(u.forEach(c=>{l[c]=t.getAttribute(c)}),Object.values(t.attributes).forEach(({name:c,value:b})=>{u.includes(c)||i.setAttribute(c,b)})):(Object.assign(l,t),Object.keys(l).forEach(c=>{!u.includes(c)&&c!=="type"&&i.setAttribute(c.replace(/[A-Z]/g,b=>`-${b.toLowerCase()}`),l[c])})),Fe(h)?(i.setAttribute("d",h),e&&s&&(t.before(i,t),t.remove()),i):!1},Dt=Fr;import Jr from"@thednp/dommatrix";var Wr=t=>{let e=new Jr,{origin:n}=t,[o,r]=n,{translate:s}=t,{rotate:a}=t,{skew:i}=t,{scale:m}=t;return Array.isArray(s)&&s.length>=2&&s.every(u=>!Number.isNaN(+u))&&s.some(u=>u!==0)?e=e.translate(...s):typeof s=="number"&&!Number.isNaN(s)&&(e=e.translate(s)),(a||i||m)&&(e=e.translate(o,r),Array.isArray(a)&&a.length>=2&&a.every(u=>!Number.isNaN(+u))&&a.some(u=>u!==0)?e=e.rotate(...a):typeof a=="number"&&!Number.isNaN(a)&&(e=e.rotate(a)),Array.isArray(i)&&i.length===2&&i.every(u=>!Number.isNaN(+u))&&i.some(u=>u!==0)?(e=i[0]?e.skewX(i[0]):e,e=i[1]?e.skewY(i[1]):e):typeof i=="number"&&!Number.isNaN(i)&&(e=e.skewX(i)),Array.isArray(m)&&m.length>=2&&m.every(u=>!Number.isNaN(+u))&&m.some(u=>u!==1)?e=e.scale(...m):typeof m=="number"&&!Number.isNaN(m)&&(e=e.scale(m)),e=e.translate(-o,-r)),e},Xe=Wr;var Xr=(t,e,n,o)=>{let[r]=t,{round:s}=I,a=typeof s=="number"?s:4,i=e.slice(1),{x1:m,y1:u,x2:l,y2:p,x:f,y:h}=n,[c,b]=i.slice(-2),d=t;if("TQ".includes(r)||(n.qx=null,n.qy=null),r==="L"){if(L(f,a)===L(c,a))return["V",b];if(L(h,a)===L(b,a))return["H",c]}else if(r==="C"){let[S,A]=i;if(n.x1=S,n.y1=A,"CS".includes(o)&&(L(S,a)===L(m*2-l,a)&&L(A,a)===L(u*2-p,a)||L(m,a)===L(l*2-f,a)&&L(u,a)===L(p*2-h,a)))return["S",i[2],i[3],i[4],i[5]]}else if(r==="Q"){let[S,A]=i;if(n.qx=S,n.qy=A,"QT".includes(o)&&L(S,a)===L(m*2-l,a)&&L(A,a)===L(u*2-p,a))return["T",i[2],i[3]]}return d},Ye=Xr;var Yr=(t,e)=>{let n=t.slice(1).map(o=>L(o,e));return[t[0]].concat(n)},he=Yr;var en=(t,e)=>{let n=X(t),o=typeof e=="number"&&e>=0?e:2,r={...U},s=[],a="M",i="Z";return M(n,(m,u,l,p)=>{r.x=l,r.y=p;let f=Y(m,r),h=m;if([a]=m,s[u]=a,u){i=s[u-1];let b=Ye(m,f,r,i),d=he(b,o),S=d.join(""),A=xe(b,u,l,p),y=he(A,o),g=y.join("");h=S.length{let n=tn.Translate(e[0],e[1],e[2]);return[,,,n.m44]=e,n=t.multiply(n),[n.m41,n.m42,n.m43,n.m44]},nn=(t,e,n)=>{let[o,r,s]=n,[a,i,m]=rn(t,[e[0],e[1],0,1]),u=a-o,l=i-r,p=m-s;return[u*(Math.abs(s)/Math.abs(p)||1)+o,l*(Math.abs(s)/Math.abs(p)||1)+r]},we=nn;var on=t=>{let e=t.slice(1).map((n,o,r)=>o?r[o-1].slice(-2).concat(n.slice(1)):t[0].slice(1).concat(n.slice(1))).map(n=>n.map((o,r)=>n[n.length-r-2*(1-r%2)])).reverse();return[["M"].concat(e[0].slice(0,2))].concat(e.map(n=>["C"].concat(n.slice(2))))},Ot=on;var an=t=>{let e=X(t),n=K(e),o=e.length,r=e[o-1][0]==="Z",s=M(e,(a,i)=>{let m=n[i],u=i&&e[i-1],l=u&&u[0],p=e[i+1],f=p&&p[0],[h]=a,[c,b]=n[i?i-1:o-1].slice(-2),d=a;switch(h){case"M":d=r?["Z"]:[h,c,b];break;case"A":d=[h,a[1],a[2],a[3],a[4],a[5]===1?0:1,c,b];break;case"C":p&&f==="S"?d=["S",a[1],a[2],c,b]:d=[h,a[3],a[4],a[1],a[2],c,b];break;case"S":l&&"CS".includes(l)&&(!p||f!=="S")?d=["C",m[3],m[4],m[1],m[2],c,b]:d=[h,m[1],m[2],c,b];break;case"Q":p&&f==="T"?d=["T",c,b]:d=[h,a[1],a[2],c,b];break;case"T":l&&"QT".includes(l)&&(!p||f!=="T")?d=["Q",m[1],m[2],c,b]:d=[h,c,b];break;case"Z":d=["M",c,b];break;case"H":d=[h,c];break;case"V":d=[h,b];break;default:d=[h].concat(a.slice(1,-2),c,b)}return d});return r?s.reverse():[s[0]].concat(s.slice(1).reverse())},Ce=an;var sn=(t,e)=>{let{round:n}=I;n=e==="off"||typeof e=="number"&&e>=0?e:typeof n=="number"&&n>=0?n:"off";return n==="off"?t.slice(0):M(t,o=>he(o,n))},It=sn;var mn=(t,e=.5)=>{let n=e,o=t.slice(0,2),r=t.slice(2,4),s=t.slice(4,6),a=t.slice(6,8),i=D(o,r,n),m=D(r,s,n),u=D(s,a,n),l=D(i,m,n),p=D(m,u,n),f=D(l,p,n);return[["C",i[0],i[1],l[0],l[1],f[0],f[1]],["C",p[0],p[1],u[0],u[1],a[0],a[1]]]},$t=mn;var un=t=>{let e=[],n,o=-1,r=0,s=0,a=0,i=0,m={...U};return t.forEach(u=>{let[l]=u,p=l.toUpperCase(),f=l.toLowerCase(),h=l===f,c=u.slice(1);p==="M"?(o+=1,[r,s]=c,r+=h?m.x:0,s+=h?m.y:0,a=r,i=s,n=[h?[p,a,i]:u]):(p==="Z"?(r=a,s=i):p==="H"?([,r]=u,r+=h?m.x:0):p==="V"?([,s]=u,s+=h?m.y:0):([r,s]=u.slice(-2),r+=h?m.x:0,s+=h?m.y:0),n.push(u)),m.x=r,m.y=s,e[o]=n}),e},tt=un;var ln=(t,e)=>{let n=0,o=0,r=0,s=0,a=0,i=0,m="M",u=T(t),l=e&&Object.keys(e);if(!e||l&&!l.length)return u.slice(0);e.origin||Object.assign(e,{origin:I.origin});let p=e.origin,f=Xe(e);return f.isIdentity?u.slice(0):M(u,(h,c,b,d)=>{[m]=h;let S=m.toUpperCase(),y=S!==m?_(h,c,b,d):h.slice(0),g=S==="A"?["C"].concat(Pe(b,d,y[1],y[2],y[3],y[4],y[5],y[6],y[7])):S==="V"?["L",b,y[1]]:S==="H"?["L",y[1],d]:y;m=g[0];let x=m==="C"&&g.length>7,C=x?g.slice(0,7):g.slice(0);if(x&&(u.splice(c+1,0,["C"].concat(g.slice(7))),g=C),m==="L"){[r,s]=we(f,[g[1],g[2]],p);n!==r&&o!==s?g=["L",r,s]:o===s?g=["H",r]:n===r&&(g=["V",s])}else for(a=1,i=g.length;a"u";if(r||!e.length)throw TypeError(`${z}: "pathValue" is ${r?"undefined":"empty"}`);this.segments=T(e);let{round:s,origin:a}=o,i;Number.isInteger(s)||s==="off"?i=s:i=I.round;let m=I.origin;if(Array.isArray(a)&&a.length>=2){let[u,l,p]=a.map(Number);m=[Number.isNaN(u)?0:u,Number.isNaN(l)?0:l,Number.isNaN(p)?0:p]}return this.round=i,this.origin=m,this}get bbox(){return _e(this.segments)}get length(){return F(this.segments)}getBBox(){return this.bbox}getTotalLength(){return this.length}getPointAtLength(e){return te(this.segments,e)}toAbsolute(){let{segments:e}=this;return this.segments=X(e),this}toRelative(){let{segments:e}=this;return this.segments=Be(e),this}toCurve(){let{segments:e}=this;return this.segments=ee(e),this}reverse(e){let{segments:n}=this,o=tt(n),r=o.length>1?o:!1,s=r?r.map((i,m)=>e?m?Ce(i):i.slice(0):Ce(i)):n.slice(0),a=[];return r?a=s.flat(1):a=e?n:Ce(n),this.segments=a.slice(0),this}normalize(){let{segments:e}=this;return this.segments=K(e),this}optimize(){let{segments:e}=this,n=this.round==="off"?2:this.round;return this.segments=et(e,n),this}transform(e){if(!e||typeof e!="object"||typeof e=="object"&&!["translate","rotate","skew","scale"].some(m=>m in e))return this;let{segments:n,origin:[o,r,s]}=this,a={};for(let[m,u]of Object.entries(e)){m==="skew"&&Array.isArray(u)||(m==="rotate"||m==="translate"||m==="origin"||m==="scale")&&Array.isArray(u)?a[m]=u.map(Number):m!=="origin"&&typeof Number(u)=="number"&&(a[m]=Number(u))}let{origin:i}=a;if(Array.isArray(i)&&i.length>=2){let[m,u,l]=i.map(Number);a.origin=[Number.isNaN(m)?o:m,Number.isNaN(u)?r:u,l||s]}else a.origin=[o,r,s];return this.segments=rt(n,a),this}flipX(){let{cx:e,cy:n}=this.bbox;return this.transform({rotate:[0,180,0],origin:[e,n,0]}),this}flipY(){let{cx:e,cy:n}=this.bbox;return this.transform({rotate:[180,0,0],origin:[e,n,0]}),this}toString(){return Se(this.segments,this.round)}dispose(){Object.keys(this).forEach(e=>delete this[e])}},Mi=Object.assign(xt,dt);export{Mi as default}; +//# sourceMappingURL=svg-path-commander.mjs.map \ No newline at end of file diff --git a/dist/svg-path-commander.mjs.map b/dist/svg-path-commander.mjs.map index 3708176..39f4bf5 100644 --- a/dist/svg-path-commander.mjs.map +++ b/dist/svg-path-commander.mjs.map @@ -1 +1 @@ -{"version":3,"file":"svg-path-commander.mjs","sources":["../node_modules/.pnpm/@thednp+dommatrix@2.0.11/node_modules/@thednp/dommatrix/dist/dommatrix.mjs","../src/math/midPoint.ts","../src/math/distanceSquareRoot.ts","../src/math/lineTools.ts","../src/math/arcTools.ts","../src/math/bezier.ts","../src/math/cubicTools.ts","../src/math/quadTools.ts","../src/math/polygonTools.ts","../src/parser/paramsCount.ts","../src/parser/finalizeSegment.ts","../src/parser/error.ts","../src/parser/scanFlag.ts","../src/parser/isDigit.ts","../src/parser/invalidPathValue.ts","../src/parser/scanParam.ts","../src/parser/isSpace.ts","../src/parser/skipSpaces.ts","../src/parser/isPathCommand.ts","../src/parser/isDigitStart.ts","../src/parser/isArcCommand.ts","../src/parser/isMoveCommand.ts","../src/parser/scanSegment.ts","../src/parser/pathParser.ts","../src/parser/parsePathString.ts","../src/process/absolutizeSegment.ts","../src/process/iterate.ts","../src/convert/pathToAbsolute.ts","../src/process/relativizeSegment.ts","../src/convert/pathToRelative.ts","../src/math/rotateVector.ts","../src/process/arcToCubic.ts","../src/process/quadToCubic.ts","../src/process/lineToCubic.ts","../src/process/segmentToCubic.ts","../src/process/normalizeSegment.ts","../src/parser/paramsParser.ts","../src/convert/pathToCurve.ts","../src/options/options.ts","../src/math/roundTo.ts","../src/convert/pathToString.ts","../src/util/distanceEpsilon.ts","../src/process/normalizePath.ts","../src/util/getPointAtLength.ts","../src/util/getTotalLength.ts","../src/util/getPropertiesAtLength.ts","../src/util/getPropertiesAtPoint.ts","../src/util/getClosestPoint.ts","../src/util/getPathArea.ts","../src/util/getDrawDirection.ts","../src/util/getPathBBox.ts","../src/util/getSegmentAtLength.ts","../src/util/getSegmentOfPoint.ts","../src/util/isPathArray.ts","../src/util/isAbsoluteArray.ts","../src/util/isNormalizedArray.ts","../src/util/isCurveArray.ts","../src/util/isPointInStroke.ts","../src/util/isRelativeArray.ts","../src/util/isValidPath.ts","../src/util/shapeParams.ts","../src/util/isElement.ts","../src/util/shapeToPathArray.ts","../src/util/shapeToPath.ts","../src/process/getSVGMatrix.ts","../src/process/shortenSegment.ts","../src/process/roundSegment.ts","../src/process/optimizePath.ts","../src/process/projection2d.ts","../src/process/reverseCurve.ts","../src/process/reversePath.ts","../src/process/roundPath.ts","../src/process/splitCubic.ts","../src/process/splitPath.ts","../src/process/transformPath.ts","../src/index.ts"],"sourcesContent":["var Z = Object.defineProperty;\nvar z = (s, t, e) => t in s ? Z(s, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : s[t] = e;\nvar p = (s, t, e) => z(s, typeof t != \"symbol\" ? t + \"\" : t, e);\nconst $ = {\n a: 1,\n b: 0,\n c: 0,\n d: 1,\n e: 0,\n f: 0,\n m11: 1,\n m12: 0,\n m13: 0,\n m14: 0,\n m21: 0,\n m22: 1,\n m23: 0,\n m24: 0,\n m31: 0,\n m32: 0,\n m33: 1,\n m34: 0,\n m41: 0,\n m42: 0,\n m43: 0,\n m44: 1,\n is2D: !0,\n isIdentity: !0\n}, E = (s) => (s instanceof Float64Array || s instanceof Float32Array || Array.isArray(s) && s.every((t) => typeof t == \"number\")) && [6, 16].some((t) => s.length === t), P = (s) => s instanceof DOMMatrix || s instanceof y || typeof s == \"object\" && Object.keys($).every((t) => s && t in s), g = (s) => {\n const t = new y(), e = Array.from(s);\n if (!E(e))\n throw TypeError(\n `CSSMatrix: \"${e.join(\",\")}\" must be an array with 6/16 numbers.`\n );\n // istanbul ignore else @preserve\n if (e.length === 16) {\n const [\n n,\n i,\n r,\n a,\n l,\n m,\n h,\n c,\n u,\n f,\n w,\n o,\n d,\n A,\n M,\n b\n ] = e;\n t.m11 = n, t.a = n, t.m21 = l, t.c = l, t.m31 = u, t.m41 = d, t.e = d, t.m12 = i, t.b = i, t.m22 = m, t.d = m, t.m32 = f, t.m42 = A, t.f = A, t.m13 = r, t.m23 = h, t.m33 = w, t.m43 = M, t.m14 = a, t.m24 = c, t.m34 = o, t.m44 = b;\n } else if (e.length === 6) {\n const [n, i, r, a, l, m] = e;\n t.m11 = n, t.a = n, t.m12 = i, t.b = i, t.m21 = r, t.c = r, t.m22 = a, t.d = a, t.m41 = l, t.e = l, t.m42 = m, t.f = m;\n }\n return t;\n}, X = (s) => {\n if (P(s))\n return g([\n s.m11,\n s.m12,\n s.m13,\n s.m14,\n s.m21,\n s.m22,\n s.m23,\n s.m24,\n s.m31,\n s.m32,\n s.m33,\n s.m34,\n s.m41,\n s.m42,\n s.m43,\n s.m44\n ]);\n throw TypeError(\n `CSSMatrix: \"${JSON.stringify(s)}\" is not a DOMMatrix / CSSMatrix / JSON compatible object.`\n );\n}, O = (s) => {\n if (typeof s != \"string\")\n throw TypeError(`CSSMatrix: \"${JSON.stringify(s)}\" is not a string.`);\n const t = String(s).replace(/\\s/g, \"\");\n let e = new y();\n const n = `CSSMatrix: invalid transform string \"${s}\"`;\n return t.split(\")\").filter((i) => i).forEach((i) => {\n const [r, a] = i.split(\"(\");\n if (!a) throw TypeError(n);\n const l = a.split(\",\").map(\n (o) => o.includes(\"rad\") ? parseFloat(o) * (180 / Math.PI) : parseFloat(o)\n ), [m, h, c, u] = l, f = [m, h, c], w = [m, h, c, u];\n if (r === \"perspective\" && m && [h, c].every((o) => o === void 0))\n e.m34 = -1 / m;\n else if (r.includes(\"matrix\") && [6, 16].includes(l.length) && l.every((o) => !Number.isNaN(+o))) {\n const o = l.map((d) => Math.abs(d) < 1e-6 ? 0 : d);\n e = e.multiply(g(o));\n } else if (r === \"translate3d\" && f.every((o) => !Number.isNaN(+o)))\n e = e.translate(m, h, c);\n else if (r === \"translate\" && m && c === void 0)\n e = e.translate(m, h || 0, 0);\n else if (r === \"rotate3d\" && w.every((o) => !Number.isNaN(+o)) && u)\n e = e.rotateAxisAngle(m, h, c, u);\n else if (r === \"rotate\" && m && [h, c].every((o) => o === void 0))\n e = e.rotate(0, 0, m);\n else if (r === \"scale3d\" && f.every((o) => !Number.isNaN(+o)) && f.some((o) => o !== 1))\n e = e.scale(m, h, c);\n else if (\n // prop === \"scale\" && !Number.isNaN(x) && x !== 1 && z === undefined\n // prop === \"scale\" && !Number.isNaN(x) && [x, y].some((n) => n !== 1) &&\n r === \"scale\" && !Number.isNaN(m) && (m !== 1 || h !== 1) && c === void 0\n ) {\n const d = Number.isNaN(+h) ? m : h;\n e = e.scale(m, d, 1);\n } else if (r === \"skew\" && (m || !Number.isNaN(m) && h) && c === void 0)\n e = e.skew(m, h || 0);\n else if ([\"translate\", \"rotate\", \"scale\", \"skew\"].some(\n (o) => r.includes(o)\n ) && /[XYZ]/.test(r) && m && [h, c].every((o) => o === void 0))\n if (r === \"skewX\" || r === \"skewY\")\n e = e[r](m);\n else {\n const o = r.replace(/[XYZ]/, \"\"), d = r.replace(o, \"\"), A = [\"X\", \"Y\", \"Z\"].indexOf(d), M = o === \"scale\" ? 1 : 0, b = [\n A === 0 ? m : M,\n A === 1 ? m : M,\n A === 2 ? m : M\n ];\n e = e[o](...b);\n }\n else\n throw TypeError(n);\n }), e;\n}, x = (s, t) => t ? [s.a, s.b, s.c, s.d, s.e, s.f] : [\n s.m11,\n s.m12,\n s.m13,\n s.m14,\n s.m21,\n s.m22,\n s.m23,\n s.m24,\n s.m31,\n s.m32,\n s.m33,\n s.m34,\n s.m41,\n s.m42,\n s.m43,\n s.m44\n], Y = (s, t, e) => {\n const n = new y();\n return n.m41 = s, n.e = s, n.m42 = t, n.f = t, n.m43 = e, n;\n}, F = (s, t, e) => {\n const n = new y(), i = Math.PI / 180, r = s * i, a = t * i, l = e * i, m = Math.cos(r), h = -Math.sin(r), c = Math.cos(a), u = -Math.sin(a), f = Math.cos(l), w = -Math.sin(l), o = c * f, d = -c * w;\n n.m11 = o, n.a = o, n.m12 = d, n.b = d, n.m13 = u;\n const A = h * u * f + m * w;\n n.m21 = A, n.c = A;\n const M = m * f - h * u * w;\n return n.m22 = M, n.d = M, n.m23 = -h * c, n.m31 = h * w - m * u * f, n.m32 = h * f + m * u * w, n.m33 = m * c, n;\n}, T = (s, t, e, n) => {\n const i = new y(), r = Math.sqrt(s * s + t * t + e * e);\n if (r === 0)\n return i;\n const a = s / r, l = t / r, m = e / r, h = n * (Math.PI / 360), c = Math.sin(h), u = Math.cos(h), f = c * c, w = a * a, o = l * l, d = m * m, A = 1 - 2 * (o + d) * f;\n i.m11 = A, i.a = A;\n const M = 2 * (a * l * f + m * c * u);\n i.m12 = M, i.b = M, i.m13 = 2 * (a * m * f - l * c * u);\n const b = 2 * (l * a * f - m * c * u);\n i.m21 = b, i.c = b;\n const k = 1 - 2 * (d + w) * f;\n return i.m22 = k, i.d = k, i.m23 = 2 * (l * m * f + a * c * u), i.m31 = 2 * (m * a * f + l * c * u), i.m32 = 2 * (m * l * f - a * c * u), i.m33 = 1 - 2 * (w + o) * f, i;\n}, I = (s, t, e) => {\n const n = new y();\n return n.m11 = s, n.a = s, n.m22 = t, n.d = t, n.m33 = e, n;\n}, v = (s, t) => {\n const e = new y();\n if (s) {\n const n = s * Math.PI / 180, i = Math.tan(n);\n e.m21 = i, e.c = i;\n }\n if (t) {\n const n = t * Math.PI / 180, i = Math.tan(n);\n e.m12 = i, e.b = i;\n }\n return e;\n}, R = (s) => v(s, 0), D = (s) => v(0, s), N = (s, t) => {\n const e = t.m11 * s.m11 + t.m12 * s.m21 + t.m13 * s.m31 + t.m14 * s.m41, n = t.m11 * s.m12 + t.m12 * s.m22 + t.m13 * s.m32 + t.m14 * s.m42, i = t.m11 * s.m13 + t.m12 * s.m23 + t.m13 * s.m33 + t.m14 * s.m43, r = t.m11 * s.m14 + t.m12 * s.m24 + t.m13 * s.m34 + t.m14 * s.m44, a = t.m21 * s.m11 + t.m22 * s.m21 + t.m23 * s.m31 + t.m24 * s.m41, l = t.m21 * s.m12 + t.m22 * s.m22 + t.m23 * s.m32 + t.m24 * s.m42, m = t.m21 * s.m13 + t.m22 * s.m23 + t.m23 * s.m33 + t.m24 * s.m43, h = t.m21 * s.m14 + t.m22 * s.m24 + t.m23 * s.m34 + t.m24 * s.m44, c = t.m31 * s.m11 + t.m32 * s.m21 + t.m33 * s.m31 + t.m34 * s.m41, u = t.m31 * s.m12 + t.m32 * s.m22 + t.m33 * s.m32 + t.m34 * s.m42, f = t.m31 * s.m13 + t.m32 * s.m23 + t.m33 * s.m33 + t.m34 * s.m43, w = t.m31 * s.m14 + t.m32 * s.m24 + t.m33 * s.m34 + t.m34 * s.m44, o = t.m41 * s.m11 + t.m42 * s.m21 + t.m43 * s.m31 + t.m44 * s.m41, d = t.m41 * s.m12 + t.m42 * s.m22 + t.m43 * s.m32 + t.m44 * s.m42, A = t.m41 * s.m13 + t.m42 * s.m23 + t.m43 * s.m33 + t.m44 * s.m43, M = t.m41 * s.m14 + t.m42 * s.m24 + t.m43 * s.m34 + t.m44 * s.m44;\n return g([\n e,\n n,\n i,\n r,\n a,\n l,\n m,\n h,\n c,\n u,\n f,\n w,\n o,\n d,\n A,\n M\n ]);\n};\nclass y {\n /**\n * @constructor\n * @param init accepts all parameter configurations:\n * * valid CSS transform string,\n * * CSSMatrix/DOMMatrix instance,\n * * a 6/16 elements *Array*.\n */\n constructor(t) {\n return this.a = 1, this.b = 0, this.c = 0, this.d = 1, this.e = 0, this.f = 0, this.m11 = 1, this.m12 = 0, this.m13 = 0, this.m14 = 0, this.m21 = 0, this.m22 = 1, this.m23 = 0, this.m24 = 0, this.m31 = 0, this.m32 = 0, this.m33 = 1, this.m34 = 0, this.m41 = 0, this.m42 = 0, this.m43 = 0, this.m44 = 1, t ? this.setMatrixValue(t) : this;\n }\n /**\n * A `Boolean` whose value is `true` if the matrix is the identity matrix. The identity\n * matrix is one in which every value is 0 except those on the main diagonal from top-left\n * to bottom-right corner (in other words, where the offsets in each direction are equal).\n *\n * @return the current property value\n */\n get isIdentity() {\n return this.m11 === 1 && this.m12 === 0 && this.m13 === 0 && this.m14 === 0 && this.m21 === 0 && this.m22 === 1 && this.m23 === 0 && this.m24 === 0 && this.m31 === 0 && this.m32 === 0 && this.m33 === 1 && this.m34 === 0 && this.m41 === 0 && this.m42 === 0 && this.m43 === 0 && this.m44 === 1;\n }\n /**\n * A `Boolean` flag whose value is `true` if the matrix was initialized as a 2D matrix\n * and `false` if the matrix is 3D.\n *\n * @return the current property value\n */\n get is2D() {\n return this.m31 === 0 && this.m32 === 0 && this.m33 === 1 && this.m34 === 0 && this.m43 === 0 && this.m44 === 1;\n }\n /**\n * The `setMatrixValue` method replaces the existing matrix with one computed\n * in the browser. EG: `matrix(1,0.25,-0.25,1,0,0)`\n *\n * The method accepts any *Array* values, the result of\n * `DOMMatrix` instance method `toFloat64Array()` / `toFloat32Array()` calls\n * or `CSSMatrix` instance method `toArray()`.\n *\n * This method expects valid *matrix()* / *matrix3d()* string values, as well\n * as other transform functions like *translateX(10px)*.\n *\n * @param source\n * @return the matrix instance\n */\n setMatrixValue(t) {\n return typeof t == \"string\" && t.length && t !== \"none\" ? O(t) : Array.isArray(t) || t instanceof Float64Array || t instanceof Float32Array ? g(t) : typeof t == \"object\" ? X(t) : this;\n }\n /**\n * Returns a *Float32Array* containing elements which comprise the matrix.\n * The method can return either the 16 elements or the 6 elements\n * depending on the value of the `is2D` parameter.\n *\n * @param is2D *Array* representation of the matrix\n * @return an *Array* representation of the matrix\n */\n toFloat32Array(t) {\n return Float32Array.from(x(this, t));\n }\n /**\n * Returns a *Float64Array* containing elements which comprise the matrix.\n * The method can return either the 16 elements or the 6 elements\n * depending on the value of the `is2D` parameter.\n *\n * @param is2D *Array* representation of the matrix\n * @return an *Array* representation of the matrix\n */\n toFloat64Array(t) {\n return Float64Array.from(x(this, t));\n }\n /**\n * Creates and returns a string representation of the matrix in `CSS` matrix syntax,\n * using the appropriate `CSS` matrix notation.\n *\n * matrix3d *matrix3d(m11, m12, m13, m14, m21, ...)*\n * matrix *matrix(a, b, c, d, e, f)*\n *\n * @return a string representation of the matrix\n */\n toString() {\n const { is2D: t } = this, e = this.toFloat64Array(t).join(\", \");\n return `${t ? \"matrix\" : \"matrix3d\"}(${e})`;\n }\n /**\n * Returns a JSON representation of the `CSSMatrix` instance, a standard *Object*\n * that includes `{a,b,c,d,e,f}` and `{m11,m12,m13,..m44}` properties as well\n * as the `is2D` & `isIdentity` properties.\n *\n * The result can also be used as a second parameter for the `fromMatrix` static method\n * to load values into another matrix instance.\n *\n * @return an *Object* with all matrix values.\n */\n toJSON() {\n const { is2D: t, isIdentity: e } = this;\n return { ...this, is2D: t, isIdentity: e };\n }\n /**\n * The Multiply method returns a new CSSMatrix which is the result of this\n * matrix multiplied by the passed matrix, with the passed matrix to the right.\n * This matrix is not modified.\n *\n * @param m2 CSSMatrix\n * @return The resulted matrix.\n */\n multiply(t) {\n return N(this, t);\n }\n /**\n * The translate method returns a new matrix which is this matrix post\n * multiplied by a translation matrix containing the passed values. If the z\n * component is undefined, a 0 value is used in its place. This matrix is not\n * modified.\n *\n * @param x X component of the translation value.\n * @param y Y component of the translation value.\n * @param z Z component of the translation value.\n * @return The resulted matrix\n */\n translate(t, e, n) {\n const i = t;\n let r = e, a = n;\n return typeof r > \"u\" && (r = 0), typeof a > \"u\" && (a = 0), N(this, Y(i, r, a));\n }\n /**\n * The scale method returns a new matrix which is this matrix post multiplied by\n * a scale matrix containing the passed values. If the z component is undefined,\n * a 1 value is used in its place. If the y component is undefined, the x\n * component value is used in its place. This matrix is not modified.\n *\n * @param x The X component of the scale value.\n * @param y The Y component of the scale value.\n * @param z The Z component of the scale value.\n * @return The resulted matrix\n */\n scale(t, e, n) {\n const i = t;\n let r = e, a = n;\n return typeof r > \"u\" && (r = t), typeof a > \"u\" && (a = 1), N(this, I(i, r, a));\n }\n /**\n * The rotate method returns a new matrix which is this matrix post multiplied\n * by each of 3 rotation matrices about the major axes, first X, then Y, then Z.\n * If the y and z components are undefined, the x value is used to rotate the\n * object about the z axis, as though the vector (0,0,x) were passed. All\n * rotation values are in degrees. This matrix is not modified.\n *\n * @param rx The X component of the rotation, or Z if Y and Z are null.\n * @param ry The (optional) Y component of the rotation value.\n * @param rz The (optional) Z component of the rotation value.\n * @return The resulted matrix\n */\n rotate(t, e, n) {\n let i = t, r = e || 0, a = n || 0;\n return typeof t == \"number\" && typeof e > \"u\" && typeof n > \"u\" && (a = i, i = 0, r = 0), N(this, F(i, r, a));\n }\n /**\n * The rotateAxisAngle method returns a new matrix which is this matrix post\n * multiplied by a rotation matrix with the given axis and `angle`. The right-hand\n * rule is used to determine the direction of rotation. All rotation values are\n * in degrees. This matrix is not modified.\n *\n * @param x The X component of the axis vector.\n * @param y The Y component of the axis vector.\n * @param z The Z component of the axis vector.\n * @param angle The angle of rotation about the axis vector, in degrees.\n * @return The resulted matrix\n */\n rotateAxisAngle(t, e, n, i) {\n if ([t, e, n, i].some((r) => Number.isNaN(+r)))\n throw new TypeError(\"CSSMatrix: expecting 4 values\");\n return N(this, T(t, e, n, i));\n }\n /**\n * Specifies a skew transformation along the `x-axis` by the given angle.\n * This matrix is not modified.\n *\n * @param angle The angle amount in degrees to skew.\n * @return The resulted matrix\n */\n skewX(t) {\n return N(this, R(t));\n }\n /**\n * Specifies a skew transformation along the `y-axis` by the given angle.\n * This matrix is not modified.\n *\n * @param angle The angle amount in degrees to skew.\n * @return The resulted matrix\n */\n skewY(t) {\n return N(this, D(t));\n }\n /**\n * Specifies a skew transformation along both the `x-axis` and `y-axis`.\n * This matrix is not modified.\n *\n * @param angleX The X-angle amount in degrees to skew.\n * @param angleY The angle amount in degrees to skew.\n * @return The resulted matrix\n */\n skew(t, e) {\n return N(this, v(t, e));\n }\n /**\n * Transforms a specified vector using the matrix, returning a new\n * {x,y,z,w} Tuple *Object* comprising the transformed vector.\n * Neither the matrix nor the original vector are altered.\n *\n * The method is equivalent with `transformPoint()` method\n * of the `DOMMatrix` constructor.\n *\n * @param t Tuple with `{x,y,z,w}` components\n * @return the resulting Tuple\n */\n transformPoint(t) {\n const e = this.m11 * t.x + this.m21 * t.y + this.m31 * t.z + this.m41 * t.w, n = this.m12 * t.x + this.m22 * t.y + this.m32 * t.z + this.m42 * t.w, i = this.m13 * t.x + this.m23 * t.y + this.m33 * t.z + this.m43 * t.w, r = this.m14 * t.x + this.m24 * t.y + this.m34 * t.z + this.m44 * t.w;\n return t instanceof DOMPoint ? new DOMPoint(e, n, i, r) : {\n x: e,\n y: n,\n z: i,\n w: r\n };\n }\n}\np(y, \"Translate\", Y), p(y, \"Rotate\", F), p(y, \"RotateAxisAngle\", T), p(y, \"Scale\", I), p(y, \"SkewX\", R), p(y, \"SkewY\", D), p(y, \"Skew\", v), p(y, \"Multiply\", N), p(y, \"fromArray\", g), p(y, \"fromMatrix\", X), p(y, \"fromString\", O), p(y, \"toArray\", x), p(y, \"isCompatibleArray\", E), p(y, \"isCompatibleObject\", P);\nexport {\n y as default\n};\n//# sourceMappingURL=dommatrix.mjs.map\n","import { PointTuple } from \"../types\";\n\n/**\n * Returns the coordinates of a specified distance\n * ratio between two points.\n *\n * @param a the first point coordinates\n * @param b the second point coordinates\n * @param t the ratio\n * @returns the midpoint coordinates\n */\nconst midPoint = (a: PointTuple, b: PointTuple, t: number): PointTuple => {\n const [ax, ay] = a;\n const [bx, by] = b;\n return [ax + (bx - ax) * t, ay + (by - ay) * t];\n};\n\nexport default midPoint;\n","import { type PointTuple } from \"../types\";\n\n/**\n * Returns the square root of the distance\n * between two given points.\n *\n * @param a the first point coordinates\n * @param b the second point coordinates\n * @returns the distance value\n */\nconst distanceSquareRoot = (a: PointTuple, b: PointTuple) => {\n return Math.sqrt(\n (a[0] - b[0]) * (a[0] - b[0]) + (a[1] - b[1]) * (a[1] - b[1]),\n );\n};\n\nexport default distanceSquareRoot;\n","import midPoint from \"./midPoint\";\nimport distanceSquareRoot from \"./distanceSquareRoot\";\n\n/**\n * Returns length for line segments (MoveTo, LineTo).\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the line segment length\n */\nconst getLineLength = (x1: number, y1: number, x2: number, y2: number) => {\n return distanceSquareRoot([x1, y1], [x2, y2]);\n};\n\n/**\n * Returns a point along the line segments (MoveTo, LineTo).\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance the distance to point in [0-1] range\n * @returns the point at length\n */\nconst getPointAtLineLength = (\n x1: number,\n y1: number,\n x2: number,\n y2: number,\n distance?: number,\n) => {\n let point = { x: x1, y: y1 };\n\n /* istanbul ignore else @preserve */\n if (typeof distance === \"number\") {\n const length = distanceSquareRoot([x1, y1], [x2, y2]);\n if (distance <= 0) {\n point = { x: x1, y: y1 };\n } else if (distance >= length) {\n point = { x: x2, y: y2 };\n } else {\n const [x, y] = midPoint([x1, y1], [x2, y2], distance / length);\n point = { x, y };\n }\n }\n return point;\n};\n\n/**\n * Returns bounding box for line segments (MoveTo, LineTo).\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance the distance to point in [0-1] range\n * @returns the extrema for line segments\n */\nconst getLineBBox = (x1: number, y1: number, x2: number, y2: number) => {\n const { min, max } = Math;\n\n return [min(x1, x2), min(y1, y2), max(x1, x2), max(y1, y2)] as [\n number,\n number,\n number,\n number,\n ];\n};\n\nexport { getLineBBox, getLineLength, getPointAtLineLength };\n","import { getPointAtLineLength } from \"./lineTools\";\nimport type { Point, PointTuple } from \"../types\";\n\n/**\n * Returns the Arc segment length.\n * @param rx radius along X axis\n * @param ry radius along Y axis\n * @param theta the angle in radians\n * @returns the arc length\n */\nconst arcLength = (rx: number, ry: number, theta: number) => {\n const halfTheta = theta / 2;\n const sinHalfTheta = Math.sin(halfTheta);\n const cosHalfTheta = Math.cos(halfTheta);\n const term1 = rx ** 2 * sinHalfTheta ** 2;\n const term2 = ry ** 2 * cosHalfTheta ** 2;\n const length = Math.sqrt(term1 + term2) * theta;\n return Math.abs(length);\n};\n\n/**\n * Find point on ellipse at given angle around ellipse (theta);\n * @param cx the center X\n * @param cy the center Y\n * @param rx the radius X\n * @param ry the radius Y\n * @param alpha the arc rotation angle in radians\n * @param theta the arc sweep angle in radians\n * @returns a point around ellipse at given angle\n */\nconst arcPoint = (\n cx: number,\n cy: number,\n rx: number,\n ry: number,\n alpha: number,\n theta: number,\n) => {\n const { sin, cos } = Math;\n // theta is angle in radians around arc\n // alpha is angle of rotation of ellipse in radians\n const cosA = cos(alpha);\n const sinA = sin(alpha);\n const x = rx * cos(theta);\n const y = ry * sin(theta);\n\n return [cx + cosA * x - sinA * y, cy + sinA * x + cosA * y] as PointTuple;\n};\n\n/**\n * Returns the angle between two points.\n * @param v0 starting point\n * @param v1 ending point\n * @returns the angle in radian\n */\nconst angleBetween = (v0: Point, v1: Point) => {\n const { x: v0x, y: v0y } = v0;\n const { x: v1x, y: v1y } = v1;\n const p = v0x * v1x + v0y * v1y;\n const n = Math.sqrt((v0x ** 2 + v0y ** 2) * (v1x ** 2 + v1y ** 2));\n const sign = v0x * v1y - v0y * v1x < 0 ? -1 : 1;\n return sign * Math.acos(p / n);\n};\n\n/**\n * Returns the following properties for an Arc segment: center, start angle,\n * end angle, and radiuses on X and Y axis.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param RX the radius on X axis\n * @param RY the radius on Y axis\n * @param angle the ellipse rotation in degrees\n * @param LAF the large arc flag\n * @param SF the sweep flag\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns properties specific to Arc segments\n */\nconst getArcProps = (\n x1: number,\n y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n x: number,\n y: number,\n) => {\n const { abs, sin, cos, sqrt, PI } = Math;\n let rx = abs(RX);\n let ry = abs(RY);\n const xRot = ((angle % 360) + 360) % 360;\n const xRotRad = xRot * (PI / 180);\n\n // istanbul ignore next @preserve\n if (x1 === x && y1 === y) {\n return {\n rx,\n ry,\n startAngle: 0,\n endAngle: 0,\n center: { x, y },\n };\n }\n\n if (rx === 0 || ry === 0) {\n return {\n rx,\n ry,\n startAngle: 0,\n endAngle: 0,\n center: { x: (x + x1) / 2, y: (y + y1) / 2 },\n };\n }\n\n const dx = (x1 - x) / 2;\n const dy = (y1 - y) / 2;\n\n const transformedPoint = {\n x: cos(xRotRad) * dx + sin(xRotRad) * dy,\n y: -sin(xRotRad) * dx + cos(xRotRad) * dy,\n };\n\n const radiiCheck = transformedPoint.x ** 2 / rx ** 2 +\n transformedPoint.y ** 2 / ry ** 2;\n\n if (radiiCheck > 1) {\n rx *= sqrt(radiiCheck);\n ry *= sqrt(radiiCheck);\n }\n\n const cSquareNumerator = rx ** 2 * ry ** 2 -\n rx ** 2 * transformedPoint.y ** 2 - ry ** 2 * transformedPoint.x ** 2;\n const cSquareRootDenom = rx ** 2 * transformedPoint.y ** 2 +\n ry ** 2 * transformedPoint.x ** 2;\n\n let cRadicand = cSquareNumerator / cSquareRootDenom;\n /* istanbul ignore next @preserve */\n cRadicand = cRadicand < 0 ? 0 : cRadicand;\n const cCoef = (LAF !== SF ? 1 : -1) * sqrt(cRadicand);\n const transformedCenter = {\n x: cCoef * ((rx * transformedPoint.y) / ry),\n y: cCoef * (-(ry * transformedPoint.x) / rx),\n };\n\n const center = {\n x: cos(xRotRad) * transformedCenter.x - sin(xRotRad) * transformedCenter.y +\n (x1 + x) / 2,\n y: sin(xRotRad) * transformedCenter.x + cos(xRotRad) * transformedCenter.y +\n (y1 + y) / 2,\n };\n\n const startVector = {\n x: (transformedPoint.x - transformedCenter.x) / rx,\n y: (transformedPoint.y - transformedCenter.y) / ry,\n };\n\n const startAngle = angleBetween({ x: 1, y: 0 }, startVector);\n\n const endVector = {\n x: (-transformedPoint.x - transformedCenter.x) / rx,\n y: (-transformedPoint.y - transformedCenter.y) / ry,\n };\n\n let sweepAngle = angleBetween(startVector, endVector);\n if (!SF && sweepAngle > 0) {\n sweepAngle -= 2 * PI;\n } else if (SF && sweepAngle < 0) {\n sweepAngle += 2 * PI;\n }\n sweepAngle %= 2 * PI;\n\n const endAngle = startAngle + sweepAngle;\n\n // point.ellipticalArcStartAngle = startAngle;\n // point.ellipticalArcEndAngle = startAngle + sweepAngle;\n // point.ellipticalArcAngle = alpha;\n\n // point.ellipticalArcCenter = center;\n // point.resultantRx = rx;\n // point.resultantRy = ry;\n\n return {\n center,\n startAngle,\n endAngle,\n rx,\n ry,\n };\n};\n\n/**\n * Returns the length of an Arc segment.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the length of the Arc segment\n */\nconst getArcLength = (\n x1: number,\n y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n x: number,\n y: number,\n) => {\n const { rx, ry, startAngle, endAngle } = getArcProps(\n x1,\n y1,\n RX,\n RY,\n angle,\n LAF,\n SF,\n x,\n y,\n );\n return arcLength(rx, ry, endAngle - startAngle);\n};\n\n/**\n * Returns a point along an Arc segment at a given distance.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param RX the radius on X axis\n * @param RY the radius on Y axis\n * @param angle the ellipse rotation in degrees\n * @param LAF the large arc flag\n * @param SF the sweep flag\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance a [0-1] ratio\n * @returns a point along the Arc segment\n */\nconst getPointAtArcLength = (\n x1: number,\n y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n x: number,\n y: number,\n distance?: number,\n) => {\n let point = { x: x1, y: y1 };\n const { center, rx, ry, startAngle, endAngle } = getArcProps(\n x1,\n y1,\n RX,\n RY,\n angle,\n LAF,\n SF,\n x,\n y,\n );\n\n /* istanbul ignore else @preserve */\n if (typeof distance === \"number\") {\n const length = arcLength(rx, ry, endAngle - startAngle);\n if (distance <= 0) {\n point = { x: x1, y: y1 };\n } else if (distance >= length) {\n point = { x, y };\n } else {\n /* istanbul ignore next @preserve */\n if (x1 === x && y1 === y) {\n return { x, y };\n }\n /* istanbul ignore next @preserve */\n if (rx === 0 || ry === 0) {\n return getPointAtLineLength(x1, y1, x, y, distance);\n }\n const { PI, cos, sin } = Math;\n const sweepAngle = endAngle - startAngle;\n const xRot = ((angle % 360) + 360) % 360;\n const xRotRad = xRot * (PI / 180);\n const alpha = startAngle + sweepAngle * (distance / length);\n const ellipseComponentX = rx * cos(alpha);\n const ellipseComponentY = ry * sin(alpha);\n\n point = {\n x: cos(xRotRad) * ellipseComponentX - sin(xRotRad) * ellipseComponentY +\n center.x,\n y: sin(xRotRad) * ellipseComponentX + cos(xRotRad) * ellipseComponentY +\n center.y,\n };\n }\n }\n\n return point;\n};\n\n/**\n * Returns the extrema for an Arc segment in the following format:\n * [MIN_X, MIN_Y, MAX_X, MAX_Y]\n *\n * @see https://github.com/herrstrietzel/svg-pathdata-getbbox\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param RX the radius on X axis\n * @param RY the radius on Y axis\n * @param angle the ellipse rotation in degrees\n * @param LAF the large arc flag\n * @param SF the sweep flag\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the extrema of the Arc segment\n */\nconst getArcBBox = (\n x1: number,\n y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n x: number,\n y: number,\n) => {\n const { center, rx, ry, startAngle, endAngle } = getArcProps(\n x1,\n y1,\n RX,\n RY,\n angle,\n LAF,\n SF,\n x,\n y,\n );\n const deltaAngle = endAngle - startAngle;\n const { min, max, tan, atan2, PI } = Math;\n\n // circle/elipse center coordinates\n const { x: cx, y: cy } = center;\n\n // rotation to radians\n const alpha = (angle * PI) / 180;\n const tangent = tan(alpha);\n\n /**\n * find min/max from zeroes of directional derivative along x and y\n * along x axis\n */\n const theta = atan2(-ry * tangent, rx);\n const angle1 = theta;\n const angle2 = theta + PI;\n const angle3 = atan2(ry, rx * tangent);\n const angle4 = angle3 + PI;\n const xArray = [x];\n const yArray = [y];\n\n // inner bounding box\n let xMin = min(x1, x);\n let xMax = max(x1, x);\n let yMin = min(y1, y);\n let yMax = max(y1, y);\n\n // on path point close after start\n const angleAfterStart = endAngle - deltaAngle * 0.00001;\n const pP2 = arcPoint(cx, cy, rx, ry, alpha, angleAfterStart);\n\n // on path point close before end\n const angleBeforeEnd = endAngle - deltaAngle * 0.99999;\n const pP3 = arcPoint(cx, cy, rx, ry, alpha, angleBeforeEnd);\n\n /**\n * expected extremes\n * if leaving inner bounding box\n * (between segment start and end point)\n * otherwise exclude elliptic extreme points\n */\n\n // right\n if (pP2[0] > xMax || pP3[0] > xMax) {\n // get point for this theta\n const p1 = arcPoint(cx, cy, rx, ry, alpha, angle1);\n xArray.push(p1[0]);\n yArray.push(p1[1]);\n }\n\n // left\n if (pP2[0] < xMin || pP3[0] < xMin) {\n // get anti-symmetric point\n const p2 = arcPoint(cx, cy, rx, ry, alpha, angle2);\n xArray.push(p2[0]);\n yArray.push(p2[1]);\n }\n\n // top\n if (pP2[1] < yMin || pP3[1] < yMin) {\n // get anti-symmetric point\n const p4 = arcPoint(cx, cy, rx, ry, alpha, angle4);\n xArray.push(p4[0]);\n yArray.push(p4[1]);\n }\n\n // bottom\n if (pP2[1] > yMax || pP3[1] > yMax) {\n // get point for this theta\n const p3 = arcPoint(cx, cy, rx, ry, alpha, angle3);\n xArray.push(p3[0]);\n yArray.push(p3[1]);\n }\n\n xMin = min.apply([], xArray);\n yMin = min.apply([], yArray);\n xMax = max.apply([], xArray);\n yMax = max.apply([], yArray);\n\n return [xMin, yMin, xMax, yMax] as [number, number, number, number];\n};\n\nexport {\n angleBetween,\n arcLength,\n arcPoint,\n getArcBBox,\n getArcLength,\n getArcProps,\n getPointAtArcLength,\n};\n","import type {\n CubicCoordinates,\n CubicPoints,\n DeriveCallback,\n DerivedCubicPoints,\n DerivedPoint,\n DerivedQuadPoints,\n PointTuple,\n QuadCoordinates,\n QuadPoints,\n} from \"../types\";\n\n/**\n * Tools from bezier.js by Mike 'Pomax' Kamermans\n * @see https://github.com/Pomax/bezierjs\n */\n\nconst Tvalues = [\n -0.0640568928626056260850430826247450385909,\n 0.0640568928626056260850430826247450385909,\n -0.1911188674736163091586398207570696318404,\n 0.1911188674736163091586398207570696318404,\n -0.3150426796961633743867932913198102407864,\n 0.3150426796961633743867932913198102407864,\n -0.4337935076260451384870842319133497124524,\n 0.4337935076260451384870842319133497124524,\n -0.5454214713888395356583756172183723700107,\n 0.5454214713888395356583756172183723700107,\n -0.6480936519369755692524957869107476266696,\n 0.6480936519369755692524957869107476266696,\n -0.7401241915785543642438281030999784255232,\n 0.7401241915785543642438281030999784255232,\n -0.8200019859739029219539498726697452080761,\n 0.8200019859739029219539498726697452080761,\n -0.8864155270044010342131543419821967550873,\n 0.8864155270044010342131543419821967550873,\n -0.9382745520027327585236490017087214496548,\n 0.9382745520027327585236490017087214496548,\n -0.9747285559713094981983919930081690617411,\n 0.9747285559713094981983919930081690617411,\n -0.9951872199970213601799974097007368118745,\n 0.9951872199970213601799974097007368118745,\n];\n\nconst Cvalues = [\n 0.1279381953467521569740561652246953718517,\n 0.1279381953467521569740561652246953718517,\n 0.1258374563468282961213753825111836887264,\n 0.1258374563468282961213753825111836887264,\n 0.121670472927803391204463153476262425607,\n 0.121670472927803391204463153476262425607,\n 0.1155056680537256013533444839067835598622,\n 0.1155056680537256013533444839067835598622,\n 0.1074442701159656347825773424466062227946,\n 0.1074442701159656347825773424466062227946,\n 0.0976186521041138882698806644642471544279,\n 0.0976186521041138882698806644642471544279,\n 0.086190161531953275917185202983742667185,\n 0.086190161531953275917185202983742667185,\n 0.0733464814110803057340336152531165181193,\n 0.0733464814110803057340336152531165181193,\n 0.0592985849154367807463677585001085845412,\n 0.0592985849154367807463677585001085845412,\n 0.0442774388174198061686027482113382288593,\n 0.0442774388174198061686027482113382288593,\n 0.0285313886289336631813078159518782864491,\n 0.0285313886289336631813078159518782864491,\n 0.0123412297999871995468056670700372915759,\n 0.0123412297999871995468056670700372915759,\n];\n\n/**\n * @param points\n * @returns\n */\nconst deriveBezier = (points: QuadPoints | CubicPoints) => {\n const dpoints = [] as (DerivedCubicPoints | DerivedQuadPoints)[];\n for (let p = points, d = p.length, c = d - 1; d > 1; d -= 1, c -= 1) {\n const list = [] as unknown as DerivedCubicPoints | DerivedQuadPoints;\n for (let j = 0; j < c; j += 1) {\n list.push({\n x: c * (p[j + 1].x - p[j].x),\n y: c * (p[j + 1].y - p[j].y),\n t: 0,\n });\n }\n dpoints.push(list);\n p = list;\n }\n return dpoints;\n};\n\n/**\n * @param points\n * @param t\n */\nconst computeBezier = (\n points: DerivedQuadPoints | DerivedCubicPoints,\n t: number,\n) => {\n // shortcuts\n /* istanbul ignore next @preserve */\n if (t === 0) {\n points[0].t = 0;\n return points[0];\n }\n\n const order = points.length - 1;\n\n /* istanbul ignore next @preserve */\n if (t === 1) {\n points[order].t = 1;\n return points[order];\n }\n\n const mt = 1 - t;\n let p = points as typeof points | [\n DerivedPoint,\n DerivedPoint,\n DerivedPoint,\n DerivedPoint,\n ];\n\n // constant?\n /* istanbul ignore next @preserve */\n if (order === 0) {\n points[0].t = t;\n return points[0];\n }\n\n // linear?\n /* istanbul ignore else @preserve */\n if (order === 1) {\n return {\n x: mt * p[0].x + t * p[1].x,\n y: mt * p[0].y + t * p[1].y,\n t,\n };\n }\n\n // quadratic/cubic curve?\n const mt2 = mt * mt;\n const t2 = t * t;\n let a = 0;\n let b = 0;\n let c = 0;\n let d = 0;\n /* istanbul ignore else @preserve */\n if (order === 2) {\n p = [p[0], p[1], p[2], { x: 0, y: 0 } as DerivedPoint];\n a = mt2;\n b = mt * t * 2;\n c = t2;\n } else if (order === 3) {\n a = mt2 * mt;\n b = mt2 * t * 3;\n c = mt * t2 * 3;\n d = t * t2;\n }\n return {\n x: a * p[0].x + b * p[1].x + c * p[2].x + d * p[3].x,\n y: a * p[0].y + b * p[1].y + c * p[2].y + d * p[3].y,\n t,\n };\n};\n\nconst calculateBezier = (derivativeFn: DeriveCallback, t: number) => {\n const d = derivativeFn(t);\n const l = d.x * d.x + d.y * d.y;\n\n return Math.sqrt(l);\n};\n\nconst bezierLength = (derivativeFn: DeriveCallback) => {\n const z = 0.5;\n const len = Tvalues.length;\n\n let sum = 0;\n\n for (let i = 0, t; i < len; i++) {\n t = z * Tvalues[i] + z;\n sum += Cvalues[i] * calculateBezier(derivativeFn, t);\n }\n return z * sum;\n};\n\n/**\n * Returns the length of CubicBezier / Quad segment.\n * @param curve cubic / quad bezier segment\n */\nconst getBezierLength = (curve: CubicCoordinates | QuadCoordinates) => {\n const points = [] as unknown as CubicPoints | QuadPoints;\n for (let idx = 0, len = curve.length, step = 2; idx < len; idx += step) {\n points.push({\n x: curve[idx],\n y: curve[idx + 1],\n });\n }\n const dpoints = deriveBezier(points);\n return bezierLength((t: number) => {\n return computeBezier(dpoints[0], t);\n });\n};\n\n// Precision for consider cubic polynom as quadratic one\nconst CBEZIER_MINMAX_EPSILON = 0.00000001;\n\n/**\n * Returns the most extreme points in a Quad Bezier segment.\n * @param A an array which consist of X/Y values\n */\n// https://github.com/kpym/SVGPathy/blob/acd1a50c626b36d81969f6e98e8602e128ba4302/lib/box.js#L89\nconst minmaxQ = ([v1, cp, v2]: [number, number, number]) => {\n const min = Math.min(v1, v2);\n const max = Math.max(v1, v2);\n\n /* istanbul ignore next @preserve */\n if (cp >= v1 ? v2 >= cp : v2 <= cp) {\n // if no extremum in ]0,1[\n return [min, max] as PointTuple;\n }\n\n // check if the extremum E is min or max\n const E = (v1 * v2 - cp * cp) / (v1 - 2 * cp + v2);\n return (E < min ? [E, max] : [min, E]) as PointTuple;\n};\n\n/**\n * Returns the most extreme points in a Cubic Bezier segment.\n * @param A an array which consist of X/Y values\n * @see https://github.com/kpym/SVGPathy/blob/acd1a50c626b36d81969f6e98e8602e128ba4302/lib/box.js#L127\n */\nconst minmaxC = ([v1, cp1, cp2, v2]: [number, number, number, number]) => {\n const K = v1 - 3 * cp1 + 3 * cp2 - v2;\n\n // if the polynomial is (almost) quadratic and not cubic\n /* istanbul ignore next @preserve */\n if (Math.abs(K) < CBEZIER_MINMAX_EPSILON) {\n if (v1 === v2 && v1 === cp1) {\n // no curve, point targeting same location\n return [v1, v2] as PointTuple;\n }\n\n return minmaxQ([v1, -0.5 * v1 + 1.5 * cp1, v1 - 3 * cp1 + 3 * cp2]);\n }\n\n // the reduced discriminant of the derivative\n const T = -v1 * cp2 + v1 * v2 - cp1 * cp2 - cp1 * v2 + cp1 * cp1 + cp2 * cp2;\n\n // if the polynomial is monotone in [0,1]\n if (T <= 0) {\n return [Math.min(v1, v2), Math.max(v1, v2)] as PointTuple;\n }\n const S = Math.sqrt(T);\n\n // potential extrema\n let min = Math.min(v1, v2);\n let max = Math.max(v1, v2);\n\n const L = v1 - 2 * cp1 + cp2;\n // check local extrema\n for (let R = (L + S) / K, i = 1; i <= 2; R = (L - S) / K, i++) {\n // istanbul ignore next @preserve\n if (R > 0 && R < 1) {\n // if the extrema is for R in [0,1]\n const Q = v1 * (1 - R) * (1 - R) * (1 - R) +\n cp1 * 3 * (1 - R) * (1 - R) * R + cp2 * 3 * (1 - R) * R * R +\n v2 * R * R * R;\n if (Q < min) {\n min = Q;\n }\n if (Q > max) {\n max = Q;\n }\n }\n }\n\n return [min, max] as PointTuple;\n};\n\nexport {\n bezierLength,\n calculateBezier,\n CBEZIER_MINMAX_EPSILON,\n computeBezier,\n Cvalues,\n deriveBezier,\n getBezierLength,\n minmaxC,\n minmaxQ,\n Tvalues,\n};\n","import { getBezierLength, minmaxC } from \"./bezier\";\nimport { type CubicCoordinates } from \"../types\";\n\n/**\n * Returns a point at a given length of a CubicBezier segment.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param t a [0-1] ratio\n * @returns the point at cubic-bezier segment length\n */\nconst getPointAtCubicSegmentLength = (\n [x1, y1, c1x, c1y, c2x, c2y, x2, y2]: CubicCoordinates,\n t: number,\n) => {\n const t1 = 1 - t;\n return {\n x: t1 ** 3 * x1 + 3 * t1 ** 2 * t * c1x + 3 * t1 * t ** 2 * c2x +\n t ** 3 * x2,\n y: t1 ** 3 * y1 + 3 * t1 ** 2 * t * c1y + 3 * t1 * t ** 2 * c2y +\n t ** 3 * y2,\n };\n};\n\n/**\n * Returns the length of a CubicBezier segment.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the CubicBezier segment length\n */\nconst getCubicLength = (\n x1: number,\n y1: number,\n c1x: number,\n c1y: number,\n c2x: number,\n c2y: number,\n x2: number,\n y2: number,\n) => {\n return getBezierLength([x1, y1, c1x, c1y, c2x, c2y, x2, y2]);\n};\n\n/**\n * Returns the point along a CubicBezier segment at a given distance.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance the distance to look at\n * @returns the point at CubicBezier length\n */\nconst getPointAtCubicLength = (\n x1: number,\n y1: number,\n c1x: number,\n c1y: number,\n c2x: number,\n c2y: number,\n x2: number,\n y2: number,\n distance?: number,\n) => {\n const distanceIsNumber = typeof distance === \"number\";\n let point = { x: x1, y: y1 };\n /* istanbul ignore else @preserve */\n if (distanceIsNumber) {\n const currentLength = getBezierLength([x1, y1, c1x, c1y, c2x, c2y, x2, y2]);\n if (distance <= 0) {\n // first point already defined\n } else if (distance >= currentLength) {\n point = { x: x2, y: y2 };\n } else {\n point = getPointAtCubicSegmentLength(\n [x1, y1, c1x, c1y, c2x, c2y, x2, y2],\n distance / currentLength,\n );\n }\n }\n return point;\n};\n\n/**\n * Returns the boundig box of a CubicBezier segment in the following format:\n * [MIN_X, MIN_Y, MAX_X, MAX_Y]\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the extrema of the CubicBezier segment\n */\nconst getCubicBBox = (\n x1: number,\n y1: number,\n c1x: number,\n c1y: number,\n c2x: number,\n c2y: number,\n x2: number,\n y2: number,\n) => {\n const cxMinMax = minmaxC([x1, c1x, c2x, x2]);\n const cyMinMax = minmaxC([y1, c1y, c2y, y2]);\n\n return [cxMinMax[0], cyMinMax[0], cxMinMax[1], cyMinMax[1]] as [\n number,\n number,\n number,\n number,\n ];\n};\n\nexport {\n getCubicBBox,\n getCubicLength,\n getPointAtCubicLength,\n getPointAtCubicSegmentLength,\n};\n","import { getBezierLength, minmaxQ } from \"./bezier\";\nimport { type QuadCoordinates } from \"../types\";\n\n/**\n * Returns the {x,y} coordinates of a point at a\n * given length of a quadratic-bezier segment.\n *\n * @see https://github.com/substack/point-at-length\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param cx the control point X\n * @param cy the control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param t a [0-1] ratio\n * @returns the requested {x,y} coordinates\n */\nconst getPointAtQuadSegmentLength = (\n [x1, y1, cx, cy, x2, y2]: QuadCoordinates,\n t: number,\n) => {\n const t1 = 1 - t;\n return {\n x: t1 ** 2 * x1 + 2 * t1 * t * cx + t ** 2 * x2,\n y: t1 ** 2 * y1 + 2 * t1 * t * cy + t ** 2 * y2,\n };\n};\n\n/**\n * Returns the length of a QuadraticBezier segment.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param cx the control point X\n * @param cy the control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the QuadraticBezier segment length\n */\nconst getQuadLength = (\n x1: number,\n y1: number,\n cx: number,\n cy: number,\n x2: number,\n y2: number,\n) => {\n return getBezierLength([x1, y1, cx, cy, x2, y2]);\n};\n\n/**\n * Returns the point along a QuadraticBezier segment at a given distance.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param cx the control point X\n * @param cy the control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance the distance to look at\n * @returns the point at QuadraticBezier length\n */\nconst getPointAtQuadLength = (\n x1: number,\n y1: number,\n cx: number,\n cy: number,\n x2: number,\n y2: number,\n distance?: number,\n) => {\n const distanceIsNumber = typeof distance === \"number\";\n let point = { x: x1, y: y1 };\n\n /* istanbul ignore else @preserve */\n if (distanceIsNumber) {\n const currentLength = getBezierLength([x1, y1, cx, cy, x2, y2]);\n if (distance <= 0) {\n // first point already defined\n } else if (distance >= currentLength) {\n point = { x: x2, y: y2 };\n } else {\n point = getPointAtQuadSegmentLength(\n [x1, y1, cx, cy, x2, y2],\n distance / currentLength,\n );\n }\n }\n return point;\n};\n\n/**\n * Returns the boundig box of a QuadraticBezier segment in the following format:\n * [MIN_X, MIN_Y, MAX_X, MAX_Y]\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param cx the control point X\n * @param cy the control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the extrema of the QuadraticBezier segment\n */\nconst getQuadBBox = (\n x1: number,\n y1: number,\n cx: number,\n cy: number,\n x2: number,\n y2: number,\n) => {\n const cxMinMax = minmaxQ([x1, cx, x2]);\n const cyMinMax = minmaxQ([y1, cy, y2]);\n return [cxMinMax[0], cyMinMax[0], cxMinMax[1], cyMinMax[1]] as [\n number,\n number,\n number,\n number,\n ];\n};\n\nexport {\n getPointAtQuadLength,\n getPointAtQuadSegmentLength,\n getQuadBBox,\n getQuadLength,\n};\n","import distanceSquareRoot from \"./distanceSquareRoot\";\nimport { type PointTuple } from \"../types\";\n\n/**\n * d3-polygon-area\n * https://github.com/d3/d3-polygon\n *\n * Returns the area of a polygon.\n *\n * @param polygon an array of coordinates\n * @returns the polygon area\n */\nconst polygonArea = (polygon: PointTuple[]) => {\n const n = polygon.length;\n let i = -1;\n let a: PointTuple;\n let b = polygon[n - 1];\n let area = 0;\n\n /* eslint-disable-next-line */\n while (++i < n) {\n a = b;\n b = polygon[i];\n area += a[1] * b[0] - a[0] * b[1];\n }\n\n return area / 2;\n};\n\n/**\n * d3-polygon-length\n * https://github.com/d3/d3-polygon\n *\n * Returns the perimeter of a polygon.\n *\n * @param polygon an array of coordinates\n * @returns the polygon length\n */\nconst polygonLength = (polygon: PointTuple[]) => {\n return polygon.reduce((length, point, i) => {\n if (i) {\n return length + distanceSquareRoot(polygon[i - 1], point);\n }\n return 0;\n }, 0);\n};\n\nexport { polygonArea, polygonLength };\n","/** Segment params length */\nconst paramsCount = {\n a: 7,\n c: 6,\n h: 1,\n l: 2,\n m: 2,\n r: 4,\n q: 4,\n s: 4,\n t: 2,\n v: 1,\n z: 0,\n};\n\nexport default paramsCount;\n","import paramsCount from \"./paramsCount\";\nimport PathParser from \"./pathParser\";\nimport type { PathCommand, PathSegment, RelativeCommand } from \"../types\";\n\n/**\n * Breaks the parsing of a pathString once a segment is finalized.\n *\n * @param path the `PathParser` instance\n */\nconst finalizeSegment = (path: PathParser) => {\n let pathCommand = path.pathValue[path.segmentStart] as PathCommand;\n let relativeCommand = pathCommand.toLowerCase() as RelativeCommand;\n const { data } = path;\n\n while (data.length >= paramsCount[relativeCommand]) {\n // overloaded `moveTo`\n // https://github.com/rveciana/svg-path-properties/blob/master/src/parse.ts\n if (relativeCommand === \"m\" && data.length > 2) {\n path.segments.push(\n [pathCommand as PathCommand | number].concat(\n data.splice(0, 2) as number[],\n ) as PathSegment,\n );\n relativeCommand = \"l\";\n pathCommand = pathCommand === \"m\" ? \"l\" : \"L\";\n } else {\n path.segments.push(\n [pathCommand as PathCommand | number].concat(\n data.splice(0, paramsCount[relativeCommand]) as number[],\n ) as PathSegment,\n );\n }\n\n if (!paramsCount[relativeCommand]) {\n break;\n }\n }\n};\nexport default finalizeSegment;\n","const error = \"SVGPathCommander Error\";\nexport default error;\n","import error from \"./error\";\nimport type PathParser from \"./pathParser\";\n\n/**\n * Validates an A (arc-to) specific path command value.\n * Usually a `large-arc-flag` or `sweep-flag`.\n *\n * @param path the `PathParser` instance\n */\nconst scanFlag = (path: PathParser) => {\n const { index, pathValue } = path;\n const code = pathValue.charCodeAt(index);\n\n if (code === 0x30 /* 0 */) {\n path.param = 0;\n path.index += 1;\n return;\n }\n\n if (code === 0x31 /* 1 */) {\n path.param = 1;\n path.index += 1;\n return;\n }\n\n path.err = `${error}: invalid Arc flag \"${\n pathValue[index]\n }\", expecting 0 or 1 at index ${index}`;\n};\n\nexport default scanFlag;\n","import { DigitNumber } from \"../types\";\n\n/**\n * Checks if a character is a digit.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isDigit = (code: number): code is DigitNumber => {\n return code >= 48 && code <= 57; // 0..9\n};\nexport default isDigit;\n","const invalidPathValue = \"Invalid path value\";\nexport default invalidPathValue;\n","import isDigit from \"./isDigit\";\nimport invalidPathValue from \"./invalidPathValue\";\nimport error from \"./error\";\nimport type PathParser from \"./pathParser\";\n\n/**\n * Validates every character of the path string,\n * every path command, negative numbers or floating point numbers.\n *\n * @param path the `PathParser` instance\n */\nconst scanParam = (path: PathParser) => {\n const { max, pathValue, index: start } = path;\n let index = start;\n let zeroFirst = false;\n let hasCeiling = false;\n let hasDecimal = false;\n let hasDot = false;\n let ch;\n\n if (index >= max) {\n path.err =\n `${error}: ${invalidPathValue} at index ${index}, \"pathValue\" is missing param`;\n return;\n }\n ch = pathValue.charCodeAt(index);\n\n if (ch === 0x2b /* + */ || ch === 0x2d /* - */) {\n index += 1;\n // ch = (index < max) ? pathValue.charCodeAt(index) : 0;\n ch = pathValue.charCodeAt(index);\n }\n\n // This logic is shamelessly borrowed from Esprima\n // https://github.com/ariya/esprimas\n if (!isDigit(ch) && ch !== 0x2e /* . */) {\n // path.err = 'SvgPath: param should start with 0..9 or `.` (at pos ' + index + ')';\n path.err = `${error}: ${invalidPathValue} at index ${index}, \"${\n pathValue[index]\n }\" is not a number`;\n return;\n }\n\n if (ch !== 0x2e /* . */) {\n zeroFirst = ch === 0x30 /* 0 */;\n index += 1;\n\n ch = pathValue.charCodeAt(index);\n\n if (zeroFirst && index < max) {\n // decimal number starts with '0' such as '09' is illegal.\n if (ch && isDigit(ch)) {\n // path.err = 'SvgPath: numbers started with `0` such as `09`\n // are illegal (at pos ' + start + ')';\n path.err = `${error}: ${invalidPathValue} at index ${start}, \"${\n pathValue[start]\n }\" illegal number`;\n return;\n }\n }\n\n while (index < max && isDigit(pathValue.charCodeAt(index))) {\n index += 1;\n hasCeiling = true;\n }\n\n ch = pathValue.charCodeAt(index);\n }\n\n if (ch === 0x2e /* . */) {\n hasDot = true;\n index += 1;\n while (isDigit(pathValue.charCodeAt(index))) {\n index += 1;\n hasDecimal = true;\n }\n\n ch = pathValue.charCodeAt(index);\n }\n\n if (ch === 0x65 /* e */ || ch === 0x45 /* E */) {\n if (hasDot && !hasCeiling && !hasDecimal) {\n path.err = `${error}: ${invalidPathValue} at index ${index}, \"${\n pathValue[index]\n }\" invalid float exponent`;\n return;\n }\n\n index += 1;\n\n ch = pathValue.charCodeAt(index);\n\n if (ch === 0x2b /* + */ || ch === 0x2d /* - */) {\n index += 1;\n }\n if (index < max && isDigit(pathValue.charCodeAt(index))) {\n while (index < max && isDigit(pathValue.charCodeAt(index))) {\n index += 1;\n }\n } else {\n path.err = `${error}: ${invalidPathValue} at index ${index}, \"${\n pathValue[index]\n }\" invalid integer exponent`;\n return;\n }\n }\n\n path.index = index;\n path.param = +path.pathValue.slice(start, index);\n};\nexport default scanParam;\n","import type { SpaceNumber } from \"../types\";\n\n/**\n * Checks if the character is a space.\n *\n * @param ch the character to check\n * @returns check result\n */\n\nconst isSpace = (ch: number): ch is SpaceNumber => {\n const allSpaces = [\n // Special spaces\n 0x1680,\n 0x180e,\n 0x2000,\n 0x2001,\n 0x2002,\n 0x2003,\n 0x2004,\n 0x2005,\n 0x2006,\n 0x2007,\n 0x2008,\n 0x2009,\n 0x200a,\n 0x202f,\n 0x205f,\n 0x3000,\n 0xfeff,\n // Line terminators\n 0x0a,\n 0x0d,\n 0x2028,\n 0x2029,\n // White spaces\n 0x20,\n 0x09,\n 0x0b,\n 0x0c,\n 0xa0,\n ];\n\n return allSpaces.includes(ch);\n};\nexport default isSpace;\n","import isSpace from \"./isSpace\";\nimport type PathParser from \"./pathParser\";\n\n/**\n * Points the parser to the next character in the\n * path string every time it encounters any kind of\n * space character.\n *\n * @param path the `PathParser` instance\n */\nconst skipSpaces = (path: PathParser) => {\n const { pathValue, max } = path;\n while (path.index < max && isSpace(pathValue.charCodeAt(path.index))) {\n path.index += 1;\n }\n};\nexport default skipSpaces;\n","import type { PathCommandNumber } from \"../types\";\n\n/**\n * Checks if the character is a path command.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isPathCommand = (code: number): code is PathCommandNumber => {\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy\n switch (code | 0x20) {\n case 0x6d /* m */:\n case 0x7a /* z */:\n case 0x6c /* l */:\n case 0x68 /* h */:\n case 0x76 /* v */:\n case 0x63 /* c */:\n case 0x73 /* s */:\n case 0x71 /* q */:\n case 0x74 /* t */:\n case 0x61 /* a */:\n // case 0x72/* r */:\n return true;\n default:\n return false;\n }\n};\nexport default isPathCommand;\n","import isDigit from \"./isDigit\";\nimport type { DigitNumber } from \"../types\";\n\n/**\n * Checks if the character is or belongs to a number.\n * [0-9]|+|-|.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isDigitStart = (\n code: number,\n): code is DigitNumber | 0x2b | 0x2d | 0x2e => {\n return isDigit(code) /* 0..9 */ || code === 0x2b /* + */ ||\n code === 0x2d /* - */ || code === 0x2e; /* . */\n};\nexport default isDigitStart;\n","/**\n * Checks if the character is an A (arc-to) path command.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isArcCommand = (code: number): code is 0x61 => {\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy\n return (code | 0x20) === 0x61;\n};\nexport default isArcCommand;\n","/**\n * Checks if the character is a MoveTo command.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isMoveCommand = (code: number): code is 0x6d | 0x4d => {\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy\n switch (code | 0x20) {\n case 0x6d /* m */:\n case 0x4d /* M */:\n return true;\n default:\n return false;\n }\n};\nexport default isMoveCommand;\n","import finalizeSegment from \"./finalizeSegment\";\nimport paramCounts from \"./paramsCount\";\nimport scanFlag from \"./scanFlag\";\nimport scanParam from \"./scanParam\";\nimport skipSpaces from \"./skipSpaces\";\nimport isPathCommand from \"./isPathCommand\";\nimport isDigitStart from \"./isDigitStart\";\nimport isArcCommand from \"./isArcCommand\";\nimport isMoveCommand from \"./isMoveCommand\";\nimport invalidPathValue from \"./invalidPathValue\";\nimport error from \"./error\";\n\nimport type PathParser from \"./pathParser\";\nimport type { PathSegment, RelativeCommand } from \"../types\";\n\n/**\n * Scans every character in the path string to determine\n * where a segment starts and where it ends.\n *\n * @param path the `PathParser` instance\n */\nconst scanSegment = (path: PathParser) => {\n const { max, pathValue, index, segments } = path;\n const cmdCode = pathValue.charCodeAt(index);\n const reqParams =\n paramCounts[pathValue[index].toLowerCase() as RelativeCommand];\n\n path.segmentStart = index;\n\n // segments always start with a path command\n if (!isPathCommand(cmdCode)) {\n path.err = `${error}: ${invalidPathValue} \"${\n pathValue[index]\n }\" is not a path command at index ${index}`;\n return;\n }\n\n // after a Z segment, we only expect a MoveTo path command\n const lastSegment = segments[segments.length - 1] as PathSegment | undefined;\n if (\n !isMoveCommand(cmdCode) && lastSegment?.[0]?.toLocaleLowerCase() === \"z\"\n ) {\n path.err = `${error}: ${invalidPathValue} \"${\n pathValue[index]\n }\" is not a MoveTo path command at index ${index}`;\n return;\n }\n\n path.index += 1;\n skipSpaces(path);\n\n path.data = [];\n\n if (!reqParams) {\n // Z\n finalizeSegment(path);\n return;\n }\n\n for (;;) {\n for (let i = reqParams; i > 0; i -= 1) {\n if (isArcCommand(cmdCode) && (i === 3 || i === 4)) scanFlag(path);\n else scanParam(path);\n\n if (path.err.length) {\n return;\n }\n path.data.push(path.param);\n\n skipSpaces(path);\n\n // after ',' param is mandatory\n if (\n path.index < max && pathValue.charCodeAt(path.index) === 0x2c /* , */\n ) {\n path.index += 1;\n skipSpaces(path);\n }\n }\n\n if (path.index >= path.max) {\n break;\n }\n\n // Stop on next segment\n if (!isDigitStart(pathValue.charCodeAt(path.index))) {\n break;\n }\n }\n\n finalizeSegment(path);\n};\nexport default scanSegment;\n","import type { PathArray, PathSegment } from \"../types\";\n\n/**\n * The `PathParser` is used by the `parsePathString` static method\n * to generate a `pathArray`.\n *\n * @param pathString\n */\nexport default class PathParser {\n declare segments: PathArray | PathSegment[];\n declare pathValue: string;\n declare max: number;\n declare index: number;\n declare param: number;\n declare segmentStart: number;\n declare data: (string | number)[];\n declare err: string;\n\n constructor(pathString: string) {\n this.segments = [];\n this.pathValue = pathString;\n this.max = pathString.length;\n this.index = 0;\n this.param = 0.0;\n this.segmentStart = 0;\n this.data = [];\n this.err = \"\";\n }\n}\n","import scanSegment from \"./scanSegment\";\nimport skipSpaces from \"./skipSpaces\";\nimport PathParser from \"./pathParser\";\nimport type { PathArray } from \"../types\";\n\n/**\n * Parses a path string value and returns an array\n * of segments we like to call `pathArray`.\n *\n * @param pathInput the string to be parsed\n * @returns the resulted `pathArray` or error string\n */\nconst parsePathString = (pathInput: string | T) => {\n if (typeof pathInput !== \"string\") {\n return pathInput.slice(0) as typeof pathInput;\n }\n\n const path = new PathParser(pathInput);\n\n skipSpaces(path);\n\n while (path.index < path.max && !path.err.length) {\n scanSegment(path);\n }\n\n // handle valid paths first\n // handle errors second\n if (!path.err.length) {\n if (path.segments.length) {\n /**\n * force absolute first M\n * getPathBBox calculation requires first segment to be absolute\n * @see https://github.com/thednp/svg-path-commander/pull/49\n */\n path.segments[0][0] = \"M\";\n }\n } else {\n throw TypeError(path.err);\n }\n\n return path.segments as PathArray;\n};\n\nexport default parsePathString;\n","import type {\n AbsoluteCommand,\n AbsoluteSegment,\n ASegment,\n CSegment,\n HSegment,\n LSegment,\n MSegment,\n PathSegment,\n QSegment,\n SSegment,\n TSegment,\n VSegment,\n} from \"../types\";\n\n/**\n * Returns an absolute segment of a `PathArray` object.\n *\n * @param segment the segment object\n * @param index the segment index\n * @param lastX the last known X value\n * @param lastY the last known Y value\n * @returns the absolute segment\n */\nconst absolutizeSegment = (\n segment: PathSegment,\n index: number,\n lastX: number,\n lastY: number,\n) => {\n const [pathCommand] = segment;\n const absCommand = pathCommand.toUpperCase() as AbsoluteCommand;\n const isAbsolute = absCommand === pathCommand;\n\n /* istanbul ignore else @preserve */\n if (index === 0 || isAbsolute) return segment as MSegment | AbsoluteSegment;\n // const values = segment.slice(1) as number[];\n if (absCommand === \"A\") {\n return [\n absCommand,\n segment[1],\n segment[2],\n segment[3],\n segment[4],\n segment[5],\n (segment as ASegment)[6] + lastX,\n (segment as ASegment)[7] + lastY,\n ] as ASegment;\n } else if (absCommand === \"V\") {\n return [absCommand, (segment as VSegment)[1] + lastY] as VSegment;\n } else if (absCommand === \"H\") {\n return [absCommand, (segment as HSegment)[1] + lastX] as HSegment;\n } else if (absCommand === \"L\") {\n return [\n absCommand,\n (segment as LSegment)[1] + lastX,\n (segment as LSegment)[2] + lastY,\n ] as LSegment;\n } else {\n // use brakets for `eslint: no-case-declaration`\n // https://stackoverflow.com/a/50753272/803358\n const absValues = [] as number[];\n const seglen = segment.length;\n for (let j = 1; j < seglen; j += 1) {\n absValues.push((segment[j] as number) + (j % 2 ? lastX : lastY));\n }\n // for c, s, q, t\n return [absCommand as typeof absCommand | number].concat(absValues) as\n | MSegment\n | QSegment\n | TSegment\n | SSegment\n | CSegment;\n }\n};\nexport default absolutizeSegment;\n","// import paramsParser from '../parser/paramsParser';\nimport type {\n AbsoluteCommand,\n IteratorCallback,\n PathArray,\n PathCommand,\n PathSegment,\n} from \"../types\";\n\nconst iterate = (\n path: PathArray,\n iterator: IteratorCallback,\n) => {\n let pathLen = path.length;\n let segment: PathSegment;\n let pathCommand = \"M\" as PathCommand;\n let absCommand = \"M\" as AbsoluteCommand;\n let isRelative = false;\n let x = 0;\n let y = 0;\n let mx = 0;\n let my = 0;\n let segLen = 0;\n\n for (let i = 0; i < pathLen; i += 1) {\n segment = path[i];\n [pathCommand] = segment;\n segLen = segment.length;\n absCommand = pathCommand.toUpperCase() as AbsoluteCommand;\n isRelative = absCommand !== pathCommand;\n\n const iteratorResult = iterator(segment, i, x, y);\n // some methods like getPointAtLength would like to break\n // when task is complete\n if (iteratorResult === false) {\n break;\n }\n\n // segment = path[i];\n if (absCommand === \"Z\") {\n x = mx;\n y = my;\n } else if (absCommand === \"H\") {\n x = (segment[1] as number) + (isRelative ? x : 0);\n } else if (absCommand === \"V\") {\n y = (segment[1] as number) + (isRelative ? y : 0);\n } else {\n x = (segment[segLen - 2] as number) + (isRelative ? x : 0);\n y = (segment[segLen - 1] as number) + (isRelative ? y : 0);\n\n if (absCommand === \"M\") {\n mx = x;\n my = y;\n }\n }\n\n if (iteratorResult) {\n path[i] = iteratorResult;\n if (iteratorResult[0] === \"C\") {\n pathLen = path.length;\n }\n }\n }\n return path as T;\n};\n\nexport default iterate;\n","import parsePathString from \"../parser/parsePathString\";\nimport absolutizeSegment from \"../process/absolutizeSegment\";\nimport type { AbsoluteArray, PathArray } from \"../types\";\nimport iterate from \"../process/iterate\";\n\n/**\n * Parses a path string value or object and returns an array\n * of segments, all converted to absolute values.\n *\n * @param pathInput the path string | object\n * @returns the resulted `pathArray` with absolute values\n */\nconst pathToAbsolute = (pathInput: string | PathArray) => {\n const path = parsePathString(pathInput);\n\n return iterate(path, absolutizeSegment);\n};\nexport default pathToAbsolute;\n","import type {\n aSegment,\n cSegment,\n hSegment,\n lSegment,\n MSegment,\n PathSegment,\n qSegment,\n RelativeCommand,\n RelativeSegment,\n sSegment,\n tSegment,\n vSegment,\n} from \"../types\";\n\n/**\n * Returns a relative segment of a `PathArray` object.\n *\n * @param segment the segment object\n * @param index the segment index\n * @param lastX the last known X value\n * @param lastY the last known Y value\n * @returns the relative segment\n */\nconst relativizeSegment = (\n segment: PathSegment,\n index: number,\n lastX: number,\n lastY: number,\n) => {\n const [pathCommand] = segment;\n const relCommand = pathCommand.toLowerCase() as RelativeCommand;\n const isRelative = pathCommand === relCommand;\n\n /* istanbul ignore else @preserve */\n if (index === 0 || isRelative) return segment as MSegment | RelativeSegment;\n\n if (relCommand === \"a\") {\n return [\n relCommand,\n segment[1],\n segment[2],\n segment[3],\n segment[4],\n segment[5],\n (segment as aSegment)[6] - lastX,\n (segment as aSegment)[7] - lastY,\n ] as aSegment;\n } else if (relCommand === \"v\") {\n return [relCommand, (segment as vSegment)[1] - lastY] as vSegment;\n } else if (relCommand === \"h\") {\n return [relCommand, (segment as hSegment)[1] - lastX] as hSegment;\n } else if (relCommand === \"l\") {\n return [\n relCommand,\n (segment as lSegment)[1] - lastX,\n (segment as lSegment)[2] - lastY,\n ] as lSegment;\n } else {\n // use brakets for `eslint: no-case-declaration`\n // https://stackoverflow.com/a/50753272/803358\n const relValues = [] as number[];\n const seglen = segment.length;\n for (let j = 1; j < seglen; j += 1) {\n relValues.push((segment[j] as number) - (j % 2 ? lastX : lastY));\n }\n // for c, s, q, t\n return [relCommand as RelativeCommand | number].concat(relValues) as\n | qSegment\n | tSegment\n | sSegment\n | cSegment;\n }\n};\n\nexport default relativizeSegment;\n","import type { PathArray, RelativeArray } from \"../types\";\nimport parsePathString from \"../parser/parsePathString\";\nimport iterate from \"../process/iterate\";\nimport relativizeSegment from \"../process/relativizeSegment\";\n\n/**\n * Parses a path string value or object and returns an array\n * of segments, all converted to relative values.\n *\n * @param pathInput the path string | object\n * @returns the resulted `pathArray` with relative values\n */\nconst pathToRelative = (pathInput: string | PathArray): RelativeArray => {\n const path = parsePathString(pathInput);\n\n return iterate(path, relativizeSegment);\n};\nexport default pathToRelative;\n","/**\n * Returns an {x,y} vector rotated by a given\n * angle in radian.\n *\n * @param x the initial vector x\n * @param y the initial vector y\n * @param rad the radian vector angle\n * @returns the rotated vector\n */\nconst rotateVector = (\n x: number,\n y: number,\n rad: number,\n): { x: number; y: number } => {\n const { sin, cos } = Math;\n const X = x * cos(rad) - y * sin(rad);\n const Y = x * sin(rad) + y * cos(rad);\n return { x: X, y: Y };\n};\n\nexport default rotateVector;\n","import rotateVector from \"../math/rotateVector\";\n\n/**\n * Converts A (arc-to) segments to C (cubic-bezier-to).\n *\n * For more information of where this math came from visit:\n * http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes\n *\n * @param X1 the starting x position\n * @param Y1 the starting y position\n * @param RX x-radius of the arc\n * @param RY y-radius of the arc\n * @param angle x-axis-rotation of the arc\n * @param LAF large-arc-flag of the arc\n * @param SF sweep-flag of the arc\n * @param X2 the ending x position\n * @param Y2 the ending y position\n * @param recursive the parameters needed to split arc into 2 segments\n * @return the resulting cubic-bezier segment(s)\n */\nconst arcToCubic = (\n X1: number,\n Y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n X2: number,\n Y2: number,\n recursive?: [number, number, number, number],\n): number[] => {\n let x1 = X1;\n let y1 = Y1;\n let rx = RX;\n let ry = RY;\n let x2 = X2;\n let y2 = Y2;\n // for more information of where this Math came from visit:\n // http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes\n const d120 = (Math.PI * 120) / 180;\n\n const rad = (Math.PI / 180) * (+angle || 0);\n let res = [] as number[];\n let xy;\n let f1;\n let f2;\n let cx;\n let cy;\n\n if (!recursive) {\n xy = rotateVector(x1, y1, -rad);\n x1 = xy.x;\n y1 = xy.y;\n xy = rotateVector(x2, y2, -rad);\n x2 = xy.x;\n y2 = xy.y;\n\n const x = (x1 - x2) / 2;\n const y = (y1 - y2) / 2;\n let h = (x * x) / (rx * rx) + (y * y) / (ry * ry);\n if (h > 1) {\n h = Math.sqrt(h);\n rx *= h;\n ry *= h;\n }\n const rx2 = rx * rx;\n const ry2 = ry * ry;\n\n const k = (LAF === SF ? -1 : 1) *\n Math.sqrt(\n Math.abs(\n (rx2 * ry2 - rx2 * y * y - ry2 * x * x) / (rx2 * y * y + ry2 * x * x),\n ),\n );\n\n cx = (k * rx * y) / ry + (x1 + x2) / 2;\n cy = (k * -ry * x) / rx + (y1 + y2) / 2;\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy no-bitwise\n f1 = Math.asin(((((y1 - cy) / ry) * 10 ** 9) >> 0) / 10 ** 9);\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy no-bitwise\n f2 = Math.asin(((((y2 - cy) / ry) * 10 ** 9) >> 0) / 10 ** 9);\n\n f1 = x1 < cx ? Math.PI - f1 : f1;\n f2 = x2 < cx ? Math.PI - f2 : f2;\n if (f1 < 0) f1 = Math.PI * 2 + f1;\n if (f2 < 0) f2 = Math.PI * 2 + f2;\n if (SF && f1 > f2) {\n f1 -= Math.PI * 2;\n }\n if (!SF && f2 > f1) {\n f2 -= Math.PI * 2;\n }\n } else {\n [f1, f2, cx, cy] = recursive;\n }\n let df = f2 - f1;\n if (Math.abs(df) > d120) {\n const f2old = f2;\n const x2old = x2;\n const y2old = y2;\n f2 = f1 + d120 * (SF && f2 > f1 ? 1 : -1);\n x2 = cx + rx * Math.cos(f2);\n y2 = cy + ry * Math.sin(f2);\n res = arcToCubic(x2, y2, rx, ry, angle, 0, SF, x2old, y2old, [\n f2,\n f2old,\n cx,\n cy,\n ]);\n }\n df = f2 - f1;\n const c1 = Math.cos(f1);\n const s1 = Math.sin(f1);\n const c2 = Math.cos(f2);\n const s2 = Math.sin(f2);\n const t = Math.tan(df / 4);\n const hx = (4 / 3) * rx * t;\n const hy = (4 / 3) * ry * t;\n const m1 = [x1, y1];\n const m2 = [x1 + hx * s1, y1 - hy * c1];\n const m3 = [x2 + hx * s2, y2 - hy * c2];\n const m4 = [x2, y2];\n m2[0] = 2 * m1[0] - m2[0];\n m2[1] = 2 * m1[1] - m2[1];\n if (recursive) {\n return [m2[0], m2[1], m3[0], m3[1], m4[0], m4[1]].concat(res);\n }\n res = [m2[0], m2[1], m3[0], m3[1], m4[0], m4[1]].concat(res);\n const newres = [];\n for (let i = 0, ii = res.length; i < ii; i += 1) {\n newres[i] = i % 2\n ? rotateVector(res[i - 1], res[i], rad).y\n : rotateVector(res[i], res[i + 1], rad).x;\n }\n return newres;\n};\nexport default arcToCubic;\n","/**\n * Converts a Q (quadratic-bezier) segment to C (cubic-bezier).\n *\n * @param x1 curve start x\n * @param y1 curve start y\n * @param qx control point x\n * @param qy control point y\n * @param x2 curve end x\n * @param y2 curve end y\n * @returns the cubic-bezier segment\n */\nconst quadToCubic = (\n x1: number,\n y1: number,\n qx: number,\n qy: number,\n x2: number,\n y2: number,\n): [number, number, number, number, number, number] => {\n const r13 = 1 / 3;\n const r23 = 2 / 3;\n return [\n r13 * x1 + r23 * qx, // cpx1\n r13 * y1 + r23 * qy, // cpy1\n r13 * x2 + r23 * qx, // cpx2\n r13 * y2 + r23 * qy, // cpy2\n x2,\n y2, // x,y\n ];\n};\nexport default quadToCubic;\n","import midPoint from \"../math/midPoint\";\n\n/**\n * Converts an L (line-to) segment to C (cubic-bezier).\n *\n * @param x1 line start x\n * @param y1 line start y\n * @param x2 line end x\n * @param y2 line end y\n * @returns the cubic-bezier segment\n */\nconst lineToCubic = (x1: number, y1: number, x2: number, y2: number) => {\n const c1 = midPoint([x1, y1], [x2, y2], 1.0 / 3.0);\n const c2 = midPoint([x1, y1], [x2, y2], 2.0 / 3.0);\n return [c1[0], c1[1], c2[0], c2[1], x2, y2];\n};\nexport default lineToCubic;\n","import arcToCubic from \"./arcToCubic\";\nimport quadToCubic from \"./quadToCubic\";\nimport lineToCubic from \"./lineToCubic\";\nimport type { CSegment, MSegment, PathSegment } from \"../types\";\nimport type { ParserParams } from \"../interface\";\n\n/**\n * Converts any segment to C (cubic-bezier).\n *\n * @param segment the source segment\n * @param params the source segment parameters\n * @returns the cubic-bezier segment\n */\nconst segmentToCubic = (segment: PathSegment, params: ParserParams) => {\n const [pathCommand] = segment;\n const values = segment.slice(1).map(Number);\n const [x, y] = values;\n // let args;\n const { x1: px1, y1: py1, x: px, y: py } = params;\n\n if (!\"TQ\".includes(pathCommand)) {\n params.qx = null;\n params.qy = null;\n }\n\n if (pathCommand === \"M\") {\n params.x = x;\n params.y = y;\n return segment;\n } else if (pathCommand === \"A\") {\n return [\"C\" as string | number].concat(\n arcToCubic(\n px1,\n py1,\n values[0],\n values[1],\n values[2],\n values[3],\n values[4],\n values[5],\n values[6],\n ),\n ) as CSegment;\n } else if (pathCommand === \"Q\") {\n params.qx = x;\n params.qy = y;\n return [\"C\" as string | number].concat(\n quadToCubic(px1, py1, values[0], values[1], values[2], values[3]),\n ) as CSegment;\n } else if (pathCommand === \"L\") {\n return [\"C\" as string | number].concat(\n lineToCubic(px1, py1, x, y),\n ) as CSegment;\n } else if (pathCommand === \"Z\") {\n return [\"C\" as string | number].concat(\n lineToCubic(px1, py1, px, py),\n ) as CSegment;\n }\n\n return segment as MSegment | CSegment;\n};\nexport default segmentToCubic;\n","import type { ParserParams } from \"../interface\";\nimport type {\n ASegment,\n CSegment,\n HSegment,\n LSegment,\n MSegment,\n NormalSegment,\n PathCommand,\n PathSegment,\n PointTuple,\n QSegment,\n VSegment,\n} from \"../types\";\n\n/**\n * Normalizes a single segment of a `pathArray` object.\n *\n * @param segment the segment object\n * @param params the normalization parameters\n * @returns the normalized segment\n */\nconst normalizeSegment = (segment: PathSegment, params: ParserParams) => {\n const [pathCommand] = segment;\n const absCommand = pathCommand.toUpperCase();\n const isRelative = pathCommand !== absCommand;\n const { x1: px1, y1: py1, x2: px2, y2: py2, x, y } = params;\n const values = segment.slice(1) as number[];\n let absValues = values.map((n, j) => n + (isRelative ? (j % 2 ? y : x) : 0));\n\n if (!\"TQ\".includes(absCommand)) {\n // optional but good to be cautious\n params.qx = null;\n params.qy = null;\n }\n\n // istanbul ignore else @preserve\n if (absCommand === \"A\") {\n absValues = values.slice(0, -2).concat(\n values[5] + (isRelative ? x : 0),\n values[6] + (isRelative ? y : 0),\n );\n\n return [\"A\" as PathCommand | number].concat(absValues) as ASegment;\n } else if (absCommand === \"H\") {\n return [\n \"L\",\n (segment as HSegment)[1] + (isRelative ? x : 0),\n py1,\n ] as LSegment;\n } else if (absCommand === \"V\") {\n return [\n \"L\",\n px1,\n (segment as VSegment)[1] + (isRelative ? y : 0),\n ] as LSegment;\n } else if (absCommand === \"L\") {\n return [\n \"L\",\n (segment as LSegment)[1] + (isRelative ? x : 0),\n (segment as LSegment)[2] + (isRelative ? y : 0),\n ] as LSegment;\n } else if (absCommand === \"M\") {\n return [\n \"M\",\n (segment as MSegment)[1] + (isRelative ? x : 0),\n (segment as MSegment)[2] + (isRelative ? y : 0),\n ] as MSegment;\n } else if (absCommand === \"C\") {\n return [\"C\" as PathCommand | number].concat(absValues) as CSegment;\n } else if (absCommand === \"S\") {\n const x1 = px1 * 2 - px2;\n const y1 = py1 * 2 - py2;\n params.x1 = x1;\n params.y1 = y1;\n return [\"C\", x1, y1].concat(absValues) as CSegment;\n } else if (absCommand === \"T\") {\n const qx = px1 * 2 - (params.qx ? params.qx : /* istanbul ignore next */ 0);\n const qy = py1 * 2 - (params.qy ? params.qy : /* istanbul ignore next */ 0);\n params.qx = qx;\n params.qy = qy;\n return [\"Q\", qx, qy].concat(absValues) as QSegment;\n } else if (absCommand === \"Q\") {\n const [nqx, nqy] = absValues as PointTuple;\n params.qx = nqx;\n params.qy = nqy;\n return [\"Q\" as PathCommand | number].concat(absValues) as QSegment;\n } else if (absCommand === \"Z\") {\n return [\"Z\"] as NormalSegment;\n }\n\n // istanbul ignore next @preserve\n return segment as NormalSegment;\n};\nexport default normalizeSegment;\n","import type { ParserParams } from \"../interface\";\n\nconst paramsParser: ParserParams = {\n x1: 0,\n y1: 0,\n x2: 0,\n y2: 0,\n x: 0,\n y: 0,\n qx: null,\n qy: null,\n};\n\nexport default paramsParser;\n","import segmentToCubic from \"../process/segmentToCubic\";\nimport { AbsoluteCommand, CSegment, CurveArray, PathArray } from \"../types\";\nimport iterate from \"../process/iterate\";\nimport parsePathString from \"../parser/parsePathString\";\nimport normalizeSegment from \"../process/normalizeSegment\";\nimport paramsParser from \"../parser/paramsParser\";\n\n/**\n * Parses a path string value or 'pathArray' and returns a new one\n * in which all segments are converted to cubic-bezier.\n *\n * In addition, un-necessary `Z` segment is removed if previous segment\n * extends to the `M` segment.\n *\n * @param pathInput the string to be parsed or 'pathArray'\n * @returns the resulted `pathArray` converted to cubic-bezier\n */\nconst pathToCurve = (pathInput: string | PathArray): CurveArray => {\n const params = { ...paramsParser };\n const path = parsePathString(pathInput);\n\n return iterate(path, (seg, index, lastX, lastY) => {\n params.x = lastX;\n params.y = lastY;\n const normalSegment = normalizeSegment(seg, params);\n let result = segmentToCubic(normalSegment, params);\n const isLongArc = result[0] === \"C\" && result.length > 7;\n\n if (isLongArc) {\n path.splice(\n index + 1,\n 0,\n [\"C\" as AbsoluteCommand | number].concat(result.slice(7)) as CSegment,\n );\n result = result.slice(0, 7) as CSegment;\n }\n\n const seglen = result.length;\n params.x1 = +result[seglen - 2];\n params.y1 = +result[seglen - 1];\n params.x2 = +result[seglen - 4] || params.x1;\n params.y2 = +result[seglen - 3] || params.y1;\n\n return result;\n });\n};\nexport default pathToCurve;\n","import { Options } from \"../interface\";\n\n/** SVGPathCommander default options */\nconst defaultOptions: Options = {\n origin: [0, 0, 0],\n round: 4,\n};\n\nexport default defaultOptions;\n","const roundTo = (n: number, round: number) => {\n const pow = round >= 1 ? 10 ** round : 1;\n\n return round > 0 ? Math.round(n * pow) / pow : Math.round(n);\n};\n\nexport default roundTo;\n","import type { PathArray, PathSegment } from \"../types\";\nimport defaultOptions from \"../options/options\";\nimport roundTo from \"../math/roundTo\";\n\n/**\n * Returns a valid `d` attribute string value created\n * by rounding values and concatenating the `pathArray` segments.\n *\n * @param path the `pathArray` object\n * @param roundOption amount of decimals to round values to\n * @returns the concatenated path string\n */\nconst pathToString = (\n path: PathArray,\n roundOption?: number | \"off\",\n): string => {\n const pathLen = path.length;\n let { round } = defaultOptions;\n let segment = path[0] as PathSegment;\n let result = \"\";\n\n // allow for ZERO decimals\n round = roundOption === \"off\"\n ? roundOption\n : typeof roundOption === \"number\" && roundOption >= 0\n ? roundOption\n : typeof round === \"number\" && round >= 0\n ? round\n : /* istanbul ignore next @preserve */ \"off\";\n\n for (let i = 0; i < pathLen; i += 1) {\n segment = path[i];\n const [pathCommand] = segment;\n const values = segment.slice(1) as number[];\n result += pathCommand;\n if (round === \"off\") {\n result += values.join(\" \");\n } else {\n let j = 0;\n const valLen = values.length;\n while (j < valLen) {\n result += roundTo(values[j], round);\n if (j !== valLen - 1) result += \" \";\n j += 1;\n }\n }\n }\n\n return result;\n};\n\nexport default pathToString;\n","const DISTANCE_EPSILON = 0.00001;\n\nexport default DISTANCE_EPSILON;\n","import normalizeSegment from \"./normalizeSegment\";\nimport type { NormalArray, PathArray } from \"../types\";\nimport iterate from \"./iterate\";\nimport parsePathString from \"../parser/parsePathString\";\nimport paramsParser from \"../parser/paramsParser\";\n\n/**\n * Normalizes a `pathArray` object for further processing:\n * * convert segments to absolute values\n * * convert shorthand path commands to their non-shorthand notation\n *\n * @param pathInput the string to be parsed or 'pathArray'\n * @returns the normalized `pathArray`\n */\nconst normalizePath = (pathInput: string | PathArray) => {\n const path = parsePathString(pathInput);\n const params = { ...paramsParser };\n\n return iterate(path, (seg, _, lastX, lastY) => {\n params.x = lastX;\n params.y = lastY;\n const result = normalizeSegment(seg, params);\n\n const seglen = result.length;\n params.x1 = +result[seglen - 2];\n params.y1 = +result[seglen - 1];\n params.x2 = +result[seglen - 4] || params.x1;\n params.y2 = +result[seglen - 3] || params.y1;\n\n return result;\n });\n};\nexport default normalizePath;\n","import DISTANCE_EPSILON from \"./distanceEpsilon\";\nimport type { MSegment, PathArray, PointTuple } from \"../types\";\nimport iterate from \"../process/iterate\";\nimport { getLineLength, getPointAtLineLength } from \"../math/lineTools\";\nimport { getArcLength, getPointAtArcLength } from \"../math/arcTools\";\nimport { getCubicLength, getPointAtCubicLength } from \"../math/cubicTools\";\nimport { getPointAtQuadLength, getQuadLength } from \"../math/quadTools\";\nimport normalizePath from \"../process/normalizePath\";\n\n/**\n * Returns [x,y] coordinates of a point at a given length of a shape.\n *\n * @param pathInput the `pathArray` to look into\n * @param distance the length of the shape to look at\n * @returns the requested {x, y} point coordinates\n */\nconst getPointAtLength = (pathInput: string | PathArray, distance?: number) => {\n const path = normalizePath(pathInput);\n let isM = false;\n let data = [] as number[];\n let pathCommand = \"M\";\n let x = 0;\n let y = 0;\n let [mx, my] = path[0].slice(1) as PointTuple;\n const distanceIsNumber = typeof distance === \"number\";\n let point = { x: mx, y: my };\n let length = 0;\n let POINT = point;\n let totalLength = 0;\n\n if (!distanceIsNumber || distance < DISTANCE_EPSILON) return point;\n\n // for (let i = 0; i < pathLen; i += 1) {\n iterate(path, (seg, _, lastX, lastY) => {\n [pathCommand] = seg;\n isM = pathCommand === \"M\";\n data = !isM ? [lastX, lastY].concat(seg.slice(1) as number[]) : data;\n\n // this segment is always ZERO\n /* istanbul ignore else @preserve */\n if (isM) {\n // remember mx, my for Z\n [, mx, my] = seg as MSegment;\n point = { x: mx, y: my };\n length = 0;\n } else if (pathCommand === \"L\") {\n point = getPointAtLineLength(\n data[0],\n data[1],\n data[2],\n data[3],\n distance - totalLength,\n );\n length = getLineLength(data[0], data[1], data[2], data[3]);\n } else if (pathCommand === \"A\") {\n point = getPointAtArcLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n data[6],\n data[7],\n data[8],\n distance - totalLength,\n );\n length = getArcLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n data[6],\n data[7],\n data[8],\n );\n } else if (pathCommand === \"C\") {\n point = getPointAtCubicLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n data[6],\n data[7],\n distance - totalLength,\n );\n length = getCubicLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n data[6],\n data[7],\n );\n } else if (pathCommand === \"Q\") {\n point = getPointAtQuadLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n distance - totalLength,\n );\n length = getQuadLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n );\n } else if (pathCommand === \"Z\") {\n data = [lastX, lastY, mx, my];\n point = { x: mx, y: my };\n\n length = getLineLength(data[0], data[1], data[2], data[3]);\n }\n\n [x, y] = data.slice(-2);\n\n if (totalLength < distance) {\n POINT = point;\n } else {\n // totalLength >= distance\n // stop right here\n // stop iterator now!\n return false;\n }\n\n totalLength += length;\n return;\n });\n\n // native `getPointAtLength` behavior when the given distance\n // is higher than total length\n if (distance > totalLength - DISTANCE_EPSILON) {\n return { x, y };\n }\n\n return POINT;\n};\n\nexport default getPointAtLength;\n","import type { LSegment, MSegment, PathArray, PointTuple } from \"../types\";\nimport { getLineLength } from \"../math/lineTools\";\nimport { getArcLength } from \"../math/arcTools\";\nimport { getCubicLength } from \"../math/cubicTools\";\nimport { getQuadLength } from \"../math/quadTools\";\nimport iterate from \"../process/iterate\";\nimport parsePathString from \"../parser/parsePathString\";\nimport absolutizeSegment from \"../process/absolutizeSegment\";\n\n/**\n * Returns the shape total length, or the equivalent to `shape.getTotalLength()`.\n *\n * @param pathInput the target `pathArray`\n * @returns the shape total length\n */\nconst getTotalLength = (pathInput: string | PathArray) => {\n const path = parsePathString(pathInput);\n let paramX1 = 0;\n let paramY1 = 0;\n let paramX2 = 0;\n let paramY2 = 0;\n let paramQX = 0;\n let paramQY = 0;\n let pathCommand = \"M\";\n let mx = 0;\n let my = 0;\n let totalLength = 0;\n\n iterate(path, (seg, index, lastX, lastY) => {\n [pathCommand] = seg;\n const absCommand = pathCommand.toUpperCase();\n const isRelative = absCommand !== pathCommand;\n const absoluteSegment = isRelative\n ? absolutizeSegment(seg, index, lastX, lastY)\n : (seg.slice(0) as typeof seg);\n\n const normalSegment = absCommand === \"V\"\n ? ([\"L\", lastX, absoluteSegment[1]] as LSegment)\n : absCommand === \"H\"\n ? ([\"L\", absoluteSegment[1], lastY] as LSegment)\n : absoluteSegment;\n [pathCommand] = normalSegment;\n\n if (!\"TQ\".includes(absCommand)) {\n // optional but good to be cautious\n paramQX = 0;\n paramQY = 0;\n }\n\n // this segment is always ZERO\n /* istanbul ignore else @preserve */\n if (pathCommand === \"M\") {\n // remember mx, my for Z\n [, mx, my] = normalSegment as MSegment;\n } else if (pathCommand === \"L\") {\n totalLength += getLineLength(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n );\n } else if (pathCommand === \"A\") {\n totalLength += getArcLength(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n normalSegment[5] as number,\n normalSegment[6] as number,\n normalSegment[7] as number,\n );\n } else if (pathCommand === \"S\") {\n const cp1x = paramX1 * 2 - paramX2;\n const cp1y = paramY1 * 2 - paramY2;\n\n totalLength += getCubicLength(\n lastX,\n lastY,\n cp1x,\n cp1y,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n );\n } else if (pathCommand === \"C\") {\n totalLength += getCubicLength(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n normalSegment[5] as number,\n normalSegment[6] as number,\n );\n } else if (pathCommand === \"T\") {\n paramQX = paramX1 * 2 - paramQX;\n paramQY = paramY1 * 2 - paramQY;\n totalLength += getQuadLength(\n lastX,\n lastY,\n paramQX,\n paramQY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n );\n } else if (pathCommand === \"Q\") {\n paramQX = normalSegment[1] as number;\n paramQY = normalSegment[2] as number;\n totalLength += getQuadLength(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n );\n } else if (pathCommand === \"Z\") {\n totalLength += getLineLength(lastX, lastY, mx, my);\n }\n\n // update params\n [paramX1, paramY1] = pathCommand === \"Z\"\n ? [mx, my]\n : (normalSegment.slice(-2) as PointTuple);\n [paramX2, paramY2] = pathCommand === \"C\"\n ? ([normalSegment[3], normalSegment[4]] as PointTuple)\n : pathCommand === \"S\"\n ? ([normalSegment[1], normalSegment[2]] as PointTuple)\n : [paramX1, paramY1];\n });\n\n return totalLength;\n};\n\nexport default getTotalLength;\n","import type { PathArray, PathSegment } from \"../types\";\nimport type { SegmentProperties } from \"../interface\";\nimport parsePathString from \"../parser/parsePathString\";\nimport getTotalLength from \"./getTotalLength\";\n\n/**\n * Returns the segment, its index and length as well as\n * the length to that segment at a given length in a path.\n *\n * @param pathInput target `pathArray`\n * @param distance the given length\n * @returns the requested properties\n */\nconst getPropertiesAtLength = (\n pathInput: string | PathArray,\n distance?: number,\n): SegmentProperties => {\n const pathArray = parsePathString(pathInput);\n\n let pathTemp = pathArray.slice(0) as PathArray;\n let pathLength = getTotalLength(pathTemp);\n let index = pathTemp.length - 1;\n let lengthAtSegment = 0;\n let length = 0;\n let segment = pathArray[0] as PathSegment;\n\n // If the path is empty, return 0.\n if (index <= 0 || !distance || !Number.isFinite(distance)) {\n return {\n segment,\n index: 0,\n length,\n lengthAtSegment,\n };\n }\n\n if (distance >= pathLength) {\n pathTemp = pathArray.slice(0, -1) as PathArray;\n lengthAtSegment = getTotalLength(pathTemp);\n length = pathLength - lengthAtSegment;\n segment = pathArray[index];\n return {\n segment,\n index,\n length,\n lengthAtSegment,\n };\n }\n\n const segments = [] as SegmentProperties[];\n while (index > 0) {\n segment = pathTemp[index];\n pathTemp = pathTemp.slice(0, -1) as PathArray;\n lengthAtSegment = getTotalLength(pathTemp);\n length = pathLength - lengthAtSegment;\n pathLength = lengthAtSegment;\n\n segments.push({\n segment,\n index,\n length,\n lengthAtSegment,\n });\n index -= 1;\n }\n\n return segments.find(({ lengthAtSegment: l }) =>\n l <= distance\n ) as SegmentProperties;\n};\n\nexport default getPropertiesAtLength;\n","import type { PathArray, Point } from \"../types\";\nimport type { PointProperties } from \"../interface\";\nimport getPointAtLength from \"./getPointAtLength\";\nimport getPropertiesAtLength from \"./getPropertiesAtLength\";\nimport getTotalLength from \"./getTotalLength\";\nimport parsePathString from \"../parser/parsePathString\";\nimport normalizePath from \"../process/normalizePath\";\n\n/**\n * Returns the point and segment in path closest to a given point as well as\n * the distance to the path stroke.\n *\n * @see https://bl.ocks.org/mbostock/8027637\n *\n * @param pathInput target `pathArray`\n * @param point the given point\n * @returns the requested properties\n */\nconst getPropertiesAtPoint = (\n pathInput: string | PathArray,\n point: Point,\n): PointProperties => {\n const path = parsePathString(pathInput);\n const normalPath = normalizePath(path);\n const pathLength = getTotalLength(normalPath);\n const distanceTo = (p: Point) => {\n const dx = p.x - point.x;\n const dy = p.y - point.y;\n return dx * dx + dy * dy;\n };\n let precision = 8;\n let scan: Point;\n let closest = { x: 0, y: 0 }; // make TS happy\n let scanDistance = 0;\n let bestLength = 0;\n let bestDistance = Infinity;\n\n // linear scan for coarse approximation\n for (let scanLength = 0; scanLength <= pathLength; scanLength += precision) {\n scan = getPointAtLength(normalPath, scanLength);\n scanDistance = distanceTo(scan);\n\n if (scanDistance < bestDistance) {\n closest = scan;\n bestLength = scanLength;\n bestDistance = scanDistance;\n }\n }\n\n // binary search for precise estimate\n precision /= 2;\n let before: { x: number; y: number };\n let after: { x: number; y: number };\n let beforeLength = 0;\n let afterLength = 0;\n let beforeDistance = 0;\n let afterDistance = 0;\n\n while (precision > 0.000001) {\n beforeLength = bestLength - precision;\n before = getPointAtLength(normalPath, beforeLength);\n beforeDistance = distanceTo(before);\n afterLength = bestLength + precision;\n after = getPointAtLength(normalPath, afterLength);\n afterDistance = distanceTo(after);\n\n if (beforeLength >= 0 && beforeDistance < bestDistance) {\n closest = before;\n bestLength = beforeLength;\n bestDistance = beforeDistance;\n } else if (afterLength <= pathLength && afterDistance < bestDistance) {\n closest = after;\n bestLength = afterLength;\n bestDistance = afterDistance;\n } else {\n precision /= 2;\n }\n if (precision < 0.00001) break;\n }\n\n const segment = getPropertiesAtLength(path, bestLength);\n const distance = Math.sqrt(bestDistance);\n\n return { closest, distance, segment };\n};\n\nexport default getPropertiesAtPoint;\n","import type { PathArray } from \"../types\";\nimport getPropertiesAtPoint from \"./getPropertiesAtPoint\";\n\n/**\n * Returns the point in path closest to a given point.\n *\n * @param pathInput target `pathArray`\n * @param point the given point\n * @returns the best match\n */\nconst getClosestPoint = (\n pathInput: string | PathArray,\n point: { x: number; y: number },\n) => {\n return getPropertiesAtPoint(pathInput, point).closest;\n};\n\nexport default getClosestPoint;\n","import pathToCurve from \"../convert/pathToCurve\";\nimport type { PathArray, PointTuple } from \"../types\";\n\n/**\n * Returns the area of a single cubic-bezier segment.\n *\n * http://objectmix.com/graphics/133553-area-closed-bezier-curve.html\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the area of the cubic-bezier segment\n */\nconst getCubicSegArea = (\n x1: number,\n y1: number,\n c1x: number,\n c1y: number,\n c2x: number,\n c2y: number,\n x2: number,\n y2: number,\n) => {\n return (\n (3 *\n ((y2 - y1) * (c1x + c2x) -\n (x2 - x1) * (c1y + c2y) +\n c1y * (x1 - c2x) -\n c1x * (y1 - c2y) +\n y2 * (c2x + x1 / 3) -\n x2 * (c2y + y1 / 3))) /\n 20\n );\n};\n\n/**\n * Returns the area of a shape.\n *\n * @author Jürg Lehni & Jonathan Puckey\n *\n * @see https://github.com/paperjs/paper.js/blob/develop/src/path/Path.js\n *\n * @param path the shape `pathArray`\n * @returns the length of the cubic-bezier segment\n */\nconst getPathArea = (path: PathArray) => {\n let x = 0;\n let y = 0;\n let len = 0;\n\n return pathToCurve(path)\n .map((seg) => {\n switch (seg[0]) {\n case \"M\":\n [, x, y] = seg;\n return 0;\n default:\n len = getCubicSegArea(\n x,\n y,\n seg[1],\n seg[2],\n seg[3],\n seg[4],\n seg[5],\n seg[6],\n );\n [x, y] = seg.slice(-2) as PointTuple;\n return len;\n }\n })\n .reduce((a, b) => a + b, 0);\n};\nexport default getPathArea;\n","import getPathArea from \"./getPathArea\";\nimport pathToCurve from \"../convert/pathToCurve\";\nimport type { PathArray } from \"../types\";\n\n/**\n * Check if a path is drawn clockwise and returns true if so,\n * false otherwise.\n *\n * @param path the path string or `pathArray`\n * @returns true when clockwise or false if not\n */\nconst getDrawDirection = (path: string | PathArray) => {\n return getPathArea(pathToCurve(path)) >= 0;\n};\n\nexport default getDrawDirection;\n","import iterate from \"../process/iterate\";\nimport { PathBBox } from \"../interface\";\nimport { LSegment, MSegment, PathArray, PointTuple } from \"../types\";\nimport { getLineBBox } from \"../math/lineTools\";\nimport { getArcBBox } from \"../math/arcTools\";\nimport { getCubicBBox } from \"../math/cubicTools\";\nimport { getQuadBBox } from \"../math/quadTools\";\nimport parsePathString from \"../parser/parsePathString\";\nimport absolutizeSegment from \"../process/absolutizeSegment\";\n\nconst getPathBBox = (pathInput: PathArray | string) => {\n if (!pathInput) {\n return {\n x: 0,\n y: 0,\n width: 0,\n height: 0,\n x2: 0,\n y2: 0,\n cx: 0,\n cy: 0,\n cz: 0,\n };\n }\n\n const path = parsePathString(pathInput);\n let pathCommand = \"M\";\n let mx = 0;\n let my = 0;\n const { max, min } = Math;\n let xMin = Infinity;\n let yMin = Infinity;\n let xMax = -Infinity;\n let yMax = -Infinity;\n let minX = 0;\n let minY = 0;\n let maxX = 0;\n let maxY = 0;\n let paramX1 = 0;\n let paramY1 = 0;\n let paramX2 = 0;\n let paramY2 = 0;\n let paramQX = 0;\n let paramQY = 0;\n\n iterate(path, (seg, index, lastX, lastY) => {\n [pathCommand] = seg;\n const absCommand = pathCommand.toUpperCase();\n const isRelative = absCommand !== pathCommand;\n const absoluteSegment = isRelative\n ? absolutizeSegment(seg, index, lastX, lastY)\n : (seg.slice(0) as typeof seg);\n\n const normalSegment = absCommand === \"V\"\n ? ([\"L\", lastX, absoluteSegment[1]] as LSegment)\n : absCommand === \"H\"\n ? ([\"L\", absoluteSegment[1], lastY] as LSegment)\n : absoluteSegment;\n\n [pathCommand] = normalSegment;\n\n if (!\"TQ\".includes(absCommand)) {\n // optional but good to be cautious\n paramQX = 0;\n paramQY = 0;\n }\n\n // this segment is always ZERO\n /* istanbul ignore else @preserve */\n if (pathCommand === \"M\") {\n [, mx, my] = normalSegment as MSegment;\n minX = mx;\n minY = my;\n maxX = mx;\n maxY = my;\n } else if (pathCommand === \"L\") {\n [minX, minY, maxX, maxY] = getLineBBox(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n );\n } else if (pathCommand === \"A\") {\n [minX, minY, maxX, maxY] = getArcBBox(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n normalSegment[5] as number,\n normalSegment[6] as number,\n normalSegment[7] as number,\n );\n } else if (pathCommand === \"S\") {\n const cp1x = paramX1 * 2 - paramX2;\n const cp1y = paramY1 * 2 - paramY2;\n\n [minX, minY, maxX, maxY] = getCubicBBox(\n lastX,\n lastY,\n cp1x,\n cp1y,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n );\n } else if (pathCommand === \"C\") {\n [minX, minY, maxX, maxY] = getCubicBBox(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n normalSegment[5] as number,\n normalSegment[6] as number,\n );\n } else if (pathCommand === \"T\") {\n paramQX = paramX1 * 2 - paramQX;\n paramQY = paramY1 * 2 - paramQY;\n [minX, minY, maxX, maxY] = getQuadBBox(\n lastX,\n lastY,\n paramQX,\n paramQY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n );\n } else if (pathCommand === \"Q\") {\n paramQX = normalSegment[1] as number;\n paramQY = normalSegment[2] as number;\n [minX, minY, maxX, maxY] = getQuadBBox(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n );\n } else if (pathCommand === \"Z\") {\n [minX, minY, maxX, maxY] = getLineBBox(lastX, lastY, mx, my);\n }\n xMin = min(minX, xMin);\n yMin = min(minY, yMin);\n xMax = max(maxX, xMax);\n yMax = max(maxY, yMax);\n\n // update params\n [paramX1, paramY1] = pathCommand === \"Z\"\n ? [mx, my]\n : (normalSegment.slice(-2) as PointTuple);\n [paramX2, paramY2] = pathCommand === \"C\"\n ? ([normalSegment[3], normalSegment[4]] as PointTuple)\n : pathCommand === \"S\"\n ? ([normalSegment[1], normalSegment[2]] as PointTuple)\n : [paramX1, paramY1];\n });\n\n const width = xMax - xMin;\n const height = yMax - yMin;\n\n return {\n width,\n height,\n x: xMin,\n y: yMin,\n x2: xMax,\n y2: yMax,\n cx: xMin + width / 2,\n cy: yMin + height / 2,\n // an estimated guess\n cz: Math.max(width, height) + Math.min(width, height) / 2,\n } satisfies PathBBox;\n};\n\nexport default getPathBBox;\n","import type { PathArray, PathSegment } from \"../types\";\nimport getPropertiesAtLength from \"./getPropertiesAtLength\";\n\n/**\n * Returns the segment at a given length.\n *\n * @param pathInput the target `pathArray`\n * @param distance the distance in path to look at\n * @returns the requested segment\n */\nconst getSegmentAtLength = (\n pathInput: string | PathArray,\n distance?: number,\n): PathSegment | undefined => {\n return getPropertiesAtLength(pathInput, distance).segment;\n};\n\nexport default getSegmentAtLength;\n","import type { SegmentProperties } from \"../interface\";\nimport type { PathArray } from \"../types\";\nimport getPropertiesAtPoint from \"./getPropertiesAtPoint\";\n\n/**\n * Returns the path segment which contains a given point.\n *\n * @param path the `pathArray` to look into\n * @param point the point of the shape to look for\n * @returns the requested segment\n */\nconst getSegmentOfPoint = (\n path: string | PathArray,\n point: { x: number; y: number },\n): SegmentProperties | undefined => {\n return getPropertiesAtPoint(path, point).segment;\n};\nexport default getSegmentOfPoint;\n","import type { PathArray, PathSegment, RelativeCommand } from \"../types\";\nimport paramsCount from \"../parser/paramsCount\";\n\n/**\n * Iterates an array to check if it's an actual `pathArray`.\n *\n * @param path the `pathArray` to be checked\n * @returns iteration result\n */\nconst isPathArray = (path: unknown): path is PathArray => {\n return (\n Array.isArray(path) &&\n path.every((seg: PathSegment) => {\n const lk = seg[0].toLowerCase() as RelativeCommand;\n return (\n paramsCount[lk] === seg.length - 1 &&\n \"achlmqstvz\".includes(lk) &&\n (seg.slice(1) as unknown[]).every(Number.isFinite)\n );\n }) &&\n path.length > 0\n );\n};\nexport default isPathArray;\n","import type { AbsoluteArray } from \"../types\";\nimport isPathArray from \"./isPathArray\";\n\n/**\n * Iterates an array to check if it's a `pathArray`\n * with all absolute values.\n *\n * @param path the `pathArray` to be checked\n * @returns iteration result\n */\nconst isAbsoluteArray = (path: unknown): path is AbsoluteArray => {\n return (\n isPathArray(path) &&\n // `isPathArray` also checks if it's `Array`\n path.every(([x]) => x === x.toUpperCase())\n );\n};\nexport default isAbsoluteArray;\n","import type { NormalArray } from \"../types\";\nimport isAbsoluteArray from \"./isAbsoluteArray\";\n\n/**\n * Iterates an array to check if it's a `pathArray`\n * with all segments are in non-shorthand notation\n * with absolute values.\n *\n * @param {string | SVGPath.pathArray} path the `pathArray` to be checked\n * @returns {boolean} iteration result\n */\nconst isNormalizedArray = (path: unknown): path is NormalArray => {\n // `isAbsoluteArray` also checks if it's `Array`\n return isAbsoluteArray(path) && path.every(([pc]) => \"ACLMQZ\".includes(pc));\n};\nexport default isNormalizedArray;\n","import { CurveArray } from \"../types\";\nimport isNormalizedArray from \"./isNormalizedArray\";\n\n/**\n * Iterates an array to check if it's a `pathArray`\n * with all C (cubic bezier) segments.\n *\n * @param path the `Array` to be checked\n * @returns iteration result\n */\nconst isCurveArray = (path: unknown): path is CurveArray => {\n // `isPathArray` also checks if it's `Array`\n return isNormalizedArray(path) && path.every(([pc]) => \"MC\".includes(pc));\n};\nexport default isCurveArray;\n","import type { PathArray } from \"../types\";\nimport getPropertiesAtPoint from \"./getPropertiesAtPoint\";\nimport DISTANCE_EPSILON from \"./distanceEpsilon\";\n\n/**\n * Checks if a given point is in the stroke of a path.\n *\n * @param pathInput target path\n * @param point the given `{x,y}` point\n * @returns the query result\n */\nconst isPointInStroke = (\n pathInput: string | PathArray,\n point: { x: number; y: number },\n) => {\n const { distance } = getPropertiesAtPoint(pathInput, point);\n return Math.abs(distance) < DISTANCE_EPSILON; // 0.01 might be more permissive\n};\nexport default isPointInStroke;\n","import type { RelativeArray } from \"../types\";\nimport isPathArray from \"./isPathArray\";\n\n/**\n * Iterates an array to check if it's a `pathArray`\n * with relative values.\n *\n * @param path the `pathArray` to be checked\n * @returns iteration result\n */\nconst isRelativeArray = (path: unknown): path is RelativeArray => {\n return (\n isPathArray(path) &&\n // `isPathArray` checks if it's `Array`\n path.slice(1).every(([pc]) => pc === pc.toLowerCase())\n );\n};\nexport default isRelativeArray;\n","import scanSegment from \"../parser/scanSegment\";\nimport skipSpaces from \"../parser/skipSpaces\";\nimport PathParser from \"../parser/pathParser\";\n\n/**\n * Parses a path string value to determine its validity\n * then returns true if it's valid or false otherwise.\n *\n * @param pathString the path string to be parsed\n * @returns the path string validity\n */\nconst isValidPath = (pathString: string) => {\n if (typeof pathString !== \"string\" || !pathString.length) {\n return false;\n }\n\n const path = new PathParser(pathString);\n\n skipSpaces(path);\n\n while (path.index < path.max && !path.err.length) {\n scanSegment(path);\n }\n\n return !path.err.length && \"mM\".includes(path.segments[0][0]);\n};\nexport default isValidPath;\n","import type { ShapeParams } from \"../interface\";\n\n/**\n * Supported shapes and their specific parameters.\n */\nconst shapeParams: ShapeParams = {\n line: [\"x1\", \"y1\", \"x2\", \"y2\"],\n circle: [\"cx\", \"cy\", \"r\"],\n ellipse: [\"cx\", \"cy\", \"rx\", \"ry\"],\n rect: [\"width\", \"height\", \"x\", \"y\", \"rx\", \"ry\"],\n polygon: [\"points\"],\n polyline: [\"points\"],\n glyph: [\"d\"],\n};\n\nexport default shapeParams;\n","const isElement = (node?: unknown): node is Element =>\n node !== undefined && node !== null &&\n typeof node === \"object\" &&\n (node as Node).nodeType === 1; // ELEMENT_NODE\n\nexport default isElement;\n","import type {\n CircleAttr,\n EllipseAttr,\n GlyphAttr,\n LineAttr,\n PolyAttr,\n RectAttr,\n ShapeParams,\n} from \"../interface\";\nimport type { PathArray, PathSegment, ShapeOps, ShapeTypes } from \"../types\";\nimport error from \"../parser/error\";\nimport parsePathString from \"../parser/parsePathString\";\nimport shapeParams from \"./shapeParams\";\nimport isPathArray from \"./isPathArray\";\nimport isElement from \"./isElement\";\n\n/**\n * Returns a new `pathArray` from line attributes.\n *\n * @param attr shape configuration\n * @returns a new line `pathArray`\n */\nexport const getLinePath = (attr: LineAttr): PathArray => {\n let { x1, y1, x2, y2 } = attr;\n [x1, y1, x2, y2] = [x1, y1, x2, y2].map((a) => +a);\n return [\n [\"M\", x1, y1],\n [\"L\", x2, y2],\n ];\n};\n\n/**\n * Returns a new `pathArray` like from polyline/polygon attributes.\n *\n * @param attr shape configuration\n * @return a new polygon/polyline `pathArray`\n */\nexport const getPolyPath = (attr: PolyAttr): PathArray => {\n const pathArray = [] as PathSegment[];\n const points = (attr.points || \"\")\n .trim()\n .split(/[\\s|,]/)\n .map((a) => +a);\n\n let index = 0;\n while (index < points.length) {\n pathArray.push([index ? \"L\" : \"M\", points[index], points[index + 1]]);\n index += 2;\n }\n\n return (attr.type === \"polygon\"\n ? [...pathArray, [\"z\"]]\n : pathArray) as PathArray;\n};\n\n/**\n * Returns a new `pathArray` from circle attributes.\n *\n * @param attr shape configuration\n * @return a circle `pathArray`\n */\nexport const getCirclePath = (attr: CircleAttr): PathArray => {\n let { cx, cy, r } = attr;\n [cx, cy, r] = [cx, cy, r].map((a) => +a);\n\n return [\n [\"M\", cx - r, cy],\n [\"a\", r, r, 0, 1, 0, 2 * r, 0],\n [\"a\", r, r, 0, 1, 0, -2 * r, 0],\n ];\n};\n\n/**\n * Returns a new `pathArray` from ellipse attributes.\n *\n * @param attr shape configuration\n * @return an ellipse `pathArray`\n */\nexport const getEllipsePath = (attr: EllipseAttr): PathArray => {\n let { cx, cy } = attr;\n let rx = attr.rx || 0;\n let ry = attr.ry || rx;\n [cx, cy, rx, ry] = [cx, cy, rx, ry].map((a) => +a);\n\n return [\n [\"M\", cx - rx, cy],\n [\"a\", rx, ry, 0, 1, 0, 2 * rx, 0],\n [\"a\", rx, ry, 0, 1, 0, -2 * rx, 0],\n ];\n};\n\n/**\n * Returns a new `pathArray` like from rect attributes.\n *\n * @param attr object with properties above\n * @return a new `pathArray` from `` attributes\n */\nexport const getRectanglePath = (attr: RectAttr): PathArray => {\n const x = +attr.x || 0;\n const y = +attr.y || 0;\n const w = +attr.width;\n const h = +attr.height;\n let rx = +(attr.rx || 0);\n let ry = +(attr.ry || rx);\n\n // Validity checks from http://www.w3.org/TR/SVG/shapes.html#RectElement:\n if (rx || ry) {\n // rx = !rx ? ry : rx;\n // ry = !ry ? rx : ry;\n\n /* istanbul ignore else @preserve */\n if (rx * 2 > w) rx -= (rx * 2 - w) / 2;\n /* istanbul ignore else @preserve */\n if (ry * 2 > h) ry -= (ry * 2 - h) / 2;\n\n return [\n [\"M\", x + rx, y],\n [\"h\", w - rx * 2],\n [\"s\", rx, 0, rx, ry],\n [\"v\", h - ry * 2],\n [\"s\", 0, ry, -rx, ry],\n [\"h\", -w + rx * 2],\n [\"s\", -rx, 0, -rx, -ry],\n [\"v\", -h + ry * 2],\n [\"s\", 0, -ry, rx, -ry],\n ];\n }\n\n return [[\"M\", x, y], [\"h\", w], [\"v\", h], [\"H\", x], [\"Z\"]];\n};\n\n/**\n * Returns a new `pathArray` created from attributes of a ``, ``,\n * ``, ``, ``, ``, or ``.\n *\n * It can also work with an options object, see the type below\n * @see ShapeOps\n *\n * @param element target shape\n * @return the newly created `` element\n */\nconst shapeToPathArray = (\n element: ShapeTypes | ShapeOps,\n) => {\n const supportedShapes = Object.keys(shapeParams) as (keyof ShapeParams)[];\n const targetIsElement = isElement(element);\n const tagName = targetIsElement ? element.tagName : null;\n\n if (tagName && [...supportedShapes, \"path\"].every((s) => tagName !== s)) {\n throw TypeError(`${error}: \"${tagName}\" is not SVGElement`);\n }\n\n const type =\n (targetIsElement ? tagName : (element as ShapeOps).type) as ShapeOps[\n \"type\"\n ];\n const shapeAttrs = shapeParams[type] as string[];\n const config = { type } as Record;\n\n if (targetIsElement) {\n shapeAttrs.forEach((p) => {\n config[p] = element.getAttribute(p) as string;\n });\n } else {\n Object.assign(config, element);\n }\n\n // set d\n let pathArray = [] as unknown as PathArray;\n\n /* istanbul ignore else */\n if (type === \"circle\") {\n pathArray = getCirclePath(config as unknown as CircleAttr);\n } else if (type === \"ellipse\") {\n pathArray = getEllipsePath(config as unknown as EllipseAttr);\n } else if ([\"polyline\", \"polygon\"].includes(type)) {\n pathArray = getPolyPath(config as unknown as PolyAttr);\n } else if (type === \"rect\") {\n pathArray = getRectanglePath(config as unknown as RectAttr);\n } else if (type === \"line\") {\n pathArray = getLinePath(config as unknown as LineAttr);\n } else if ([\"glyph\", \"path\"].includes(type)) {\n pathArray = parsePathString(\n targetIsElement\n ? element.getAttribute(\"d\") || /* istanbul ignore next @preserve */ \"\"\n : (element as GlyphAttr).d || \"\",\n );\n }\n\n // replace target element\n if (isPathArray(pathArray) && pathArray.length) {\n return pathArray;\n }\n return false;\n};\nexport default shapeToPathArray;\n","import type { ShapeParams } from \"../interface\";\nimport type { ShapeOps, ShapeTypes } from \"../types\";\nimport pathToString from \"../convert/pathToString\";\nimport defaultOptions from \"../options/options\";\nimport error from \"../parser/error\";\nimport isValidPath from \"./isValidPath\";\nimport isElement from \"./isElement\";\nimport shapeToPathArray from \"./shapeToPathArray\";\nimport shapeParams from \"./shapeParams\";\n\n/**\n * Returns a new `` element created from attributes of a ``, ``,\n * ``, ``, ``, `` or ``. If `replace` parameter\n * is `true`, it will replace the target. The default `ownerDocument` is your current\n * `document` browser page, if you want to use in server-side using `jsdom`, you can\n * pass the `jsdom` `document` to `ownDocument`.\n *\n * It can also work with an options object, see the type below\n * @see ShapeOps\n *\n * The newly created `` element keeps all non-specific\n * attributes like `class`, `fill`, etc.\n *\n * @param element target shape\n * @param replace option to replace target\n * @param ownerDocument document for create element\n * @return the newly created `` element\n */\nconst shapeToPath = (\n element: ShapeTypes | ShapeOps,\n replace?: boolean,\n ownerDocument?: Document,\n): SVGPathElement | false => {\n const doc = ownerDocument || document;\n const supportedShapes = Object.keys(shapeParams) as (keyof ShapeParams)[];\n const targetIsElement = isElement(element);\n const tagName = targetIsElement ? element.tagName : null;\n\n if (tagName === \"path\") {\n throw TypeError(`${error}: \"${tagName}\" is already SVGPathElement`);\n }\n if (tagName && supportedShapes.every((s) => tagName !== s)) {\n throw TypeError(`${error}: \"${tagName}\" is not SVGElement`);\n }\n\n const path = doc.createElementNS(\"http://www.w3.org/2000/svg\", \"path\");\n const type =\n (targetIsElement ? tagName : (element as ShapeOps).type) as ShapeOps[\n \"type\"\n ];\n const shapeAttrs = shapeParams[type] as string[];\n const config = { type } as Record;\n\n // set d\n const round = defaultOptions.round as number;\n const pathArray = shapeToPathArray(element);\n const description = pathArray && pathArray.length\n ? pathToString(pathArray, round)\n : \"\";\n\n if (targetIsElement) {\n shapeAttrs.forEach((p) => {\n config[p] = element.getAttribute(p) as string;\n });\n // set no-specific shape attributes: fill, stroke, etc\n Object.values(element.attributes).forEach(({ name, value }) => {\n if (!shapeAttrs.includes(name)) path.setAttribute(name, value);\n });\n } else {\n Object.assign(config, element);\n // set no-specific shape attributes: fill, stroke, etc\n Object.keys(config).forEach((k) => {\n if (!shapeAttrs.includes(k) && k !== \"type\") {\n path.setAttribute(\n k.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`),\n config[k],\n );\n }\n });\n }\n\n // replace target element\n if (isValidPath(description)) {\n path.setAttribute(\"d\", description);\n if (replace && targetIsElement) {\n element.before(path, element);\n element.remove();\n }\n return path;\n }\n return false;\n};\n\nexport default shapeToPath;\n","import CSSMatrix from \"@thednp/dommatrix\";\n// import type { TransformObject } from '../interface';\nimport type { TransformObjectValues } from \"../types\";\n\n/**\n * Returns a transformation matrix to apply to `` elements.\n *\n * @see TransformObjectValues\n *\n * @param transform the `transformObject`\n * @returns a new transformation matrix\n */\nconst getSVGMatrix = (transform: TransformObjectValues): CSSMatrix => {\n let matrix = new CSSMatrix();\n const { origin } = transform;\n const [originX, originY] = origin as [number, number, number];\n const { translate } = transform;\n const { rotate } = transform;\n const { skew } = transform;\n const { scale } = transform;\n\n // set translate\n if (\n Array.isArray(translate) &&\n translate.length >= 2 &&\n translate.every((x) => !Number.isNaN(+x)) &&\n translate.some((x) => x !== 0)\n ) {\n matrix = matrix.translate(...(translate as [number, number, number?]));\n } else if (typeof translate === \"number\" && !Number.isNaN(translate)) {\n matrix = matrix.translate(translate);\n }\n\n if (rotate || skew || scale) {\n // set SVG transform-origin, always defined\n matrix = matrix.translate(originX, originY);\n\n // set rotation\n if (\n Array.isArray(rotate) &&\n rotate.length >= 2 &&\n rotate.every((x) => !Number.isNaN(+x)) &&\n rotate.some((x) => x !== 0)\n ) {\n matrix = matrix.rotate(...(rotate as [number, number, number?]));\n } else if (typeof rotate === \"number\" && !Number.isNaN(rotate)) {\n matrix = matrix.rotate(rotate);\n }\n\n // set skew(s)\n if (\n Array.isArray(skew) && skew.length === 2 && skew.every((x) =>\n !Number.isNaN(+x)\n ) && skew.some((x) => x !== 0)\n ) {\n matrix = skew[0] ? matrix.skewX(skew[0]) : matrix;\n matrix = skew[1] ? matrix.skewY(skew[1]) : matrix;\n } else if (typeof skew === \"number\" && !Number.isNaN(skew)) {\n matrix = matrix.skewX(skew);\n }\n\n // set scale\n if (\n Array.isArray(scale) && scale.length >= 2 && scale.every((x) =>\n !Number.isNaN(+x)\n ) && scale.some((x) => x !== 1)\n ) {\n matrix = matrix.scale(...(scale as [number, number, number?]));\n } else if (typeof scale === \"number\" && !Number.isNaN(scale)) {\n matrix = matrix.scale(scale);\n }\n // set SVG transform-origin\n matrix = matrix.translate(-originX, -originY);\n }\n\n return matrix;\n};\nexport default getSVGMatrix;\n","import defaultOptions from \"../options/options\";\nimport type { ParserParams } from \"../interface\";\nimport roundTo from \"../math/roundTo\";\nimport type {\n AbsoluteSegment,\n NormalSegment,\n PathCommand,\n ShortSegment,\n SSegment,\n TSegment,\n} from \"../types\";\n\n/**\n * Shorten a single segment of a `pathArray` object.\n *\n * @param segment the `absoluteSegment` object\n * @param normalSegment the `normalSegment` object\n * @param params the coordinates of the previous segment\n * @param prevCommand the path command of the previous segment\n * @returns the shortened segment\n */\nconst shortenSegment = (\n segment: AbsoluteSegment,\n normalSegment: NormalSegment,\n params: ParserParams,\n prevCommand: PathCommand,\n): ShortSegment => {\n const [pathCommand] = segment;\n const { round: defaultRound } = defaultOptions;\n const round = typeof defaultRound === \"number\"\n ? defaultRound\n : /* istanbul ignore next */ 4;\n const normalValues = normalSegment.slice(1) as number[];\n const { x1, y1, x2, y2, x, y } = params;\n const [nx, ny] = normalValues.slice(-2);\n const result = segment;\n\n if (!\"TQ\".includes(pathCommand)) {\n // optional but good to be cautious\n params.qx = null;\n params.qy = null;\n }\n\n if (pathCommand === \"L\") {\n if (roundTo(x, round) === roundTo(nx, round)) {\n return [\"V\", ny];\n } else if (roundTo(y, round) === roundTo(ny, round)) {\n return [\"H\", nx];\n }\n } else if (pathCommand === \"C\") {\n const [nx1, ny1] = normalValues;\n params.x1 = nx1;\n params.y1 = ny1;\n\n if (\n \"CS\".includes(prevCommand) &&\n ((roundTo(nx1, round) === roundTo(x1 * 2 - x2, round) &&\n roundTo(ny1, round) === roundTo(y1 * 2 - y2, round)) ||\n (roundTo(x1, round) === roundTo(x2 * 2 - x, round) &&\n roundTo(y1, round) === roundTo(y2 * 2 - y, round)))\n ) {\n return [\n \"S\",\n normalValues[2],\n normalValues[3],\n normalValues[4],\n normalValues[5],\n ] as SSegment;\n }\n } else if (pathCommand === \"Q\") {\n const [qx, qy] = normalValues;\n params.qx = qx;\n params.qy = qy;\n\n if (\n \"QT\".includes(prevCommand) &&\n roundTo(qx, round) === roundTo(x1 * 2 - x2, round) &&\n roundTo(qy, round) === roundTo(y1 * 2 - y2, round)\n ) {\n return [\"T\", normalValues[2], normalValues[3]] as TSegment;\n }\n }\n\n // ['V', 'H', 'S', 'T', 'Z'].includes(pathCommand)\n return result as ShortSegment;\n};\n\nexport default shortenSegment;\n","import type { PathCommand, PathSegment } from \"../types\";\nimport roundTo from \"../math/roundTo\";\n\nconst roundSegment = (\n segment: T,\n roundOption: number,\n) => {\n const values = (segment.slice(1) as number[]).map((n) =>\n roundTo(n, roundOption)\n );\n return [segment[0] as PathCommand | number].concat(values) as T;\n};\n\nexport default roundSegment;\n","import type { AbsoluteSegment, PathArray, PathCommand } from \"../types\";\nimport pathToAbsolute from \"../convert/pathToAbsolute\";\nimport shortenSegment from \"./shortenSegment\";\nimport paramsParser from \"../parser/paramsParser\";\nimport iterate from \"./iterate\";\nimport normalizeSegment from \"./normalizeSegment\";\nimport relativizeSegment from \"./relativizeSegment\";\nimport roundSegment from \"./roundSegment\";\n\n/**\n * Optimizes a `pathArray` object:\n * * convert segments to shorthand if possible\n * * select shortest segments from absolute and relative `pathArray`s\n *\n * @param pathInput a string or `pathArray`\n * @param roundOption the amount of decimals to round values to\n * @returns the optimized `pathArray`\n */\nconst optimizePath = (pathInput: PathArray, roundOption?: number) => {\n const path = pathToAbsolute(pathInput);\n // allow for ZERO decimals or use an aggressive value of 2\n const round = typeof roundOption === \"number\" && roundOption >= 0\n ? roundOption\n : /* istanbul ignore next @preserve */ 2;\n // this utility overrides the iterator params\n const optimParams = { ...paramsParser };\n\n const allPathCommands = [] as PathCommand[];\n let pathCommand = \"M\" as PathCommand;\n let prevCommand = \"Z\" as PathCommand;\n\n return iterate(path, (seg, i, lastX, lastY) => {\n optimParams.x = lastX;\n optimParams.y = lastY;\n const normalizedSegment = normalizeSegment(seg, optimParams);\n let result = seg;\n [pathCommand] = seg;\n\n // Save current path command\n allPathCommands[i] = pathCommand;\n if (i) {\n // Get previous path command for `shortenSegment`\n prevCommand = allPathCommands[i - 1];\n const shortSegment = shortenSegment(\n seg as AbsoluteSegment,\n normalizedSegment,\n optimParams,\n prevCommand,\n );\n const absSegment = roundSegment(shortSegment, round);\n const absString = absSegment.join(\"\");\n const relativeSegment = relativizeSegment(shortSegment, i, lastX, lastY);\n const relSegment = roundSegment(relativeSegment, round);\n const relString = relSegment.join(\"\");\n result = absString.length < relString.length ? absSegment : relSegment;\n }\n\n const seglen = normalizedSegment.length;\n optimParams.x1 = +normalizedSegment[seglen - 2];\n optimParams.y1 = +normalizedSegment[seglen - 1];\n optimParams.x2 = +normalizedSegment[seglen - 4] || optimParams.x1;\n optimParams.y2 = +normalizedSegment[seglen - 3] || optimParams.y1;\n\n return result;\n });\n};\n\nexport default optimizePath;\n","import CSSMatrix from \"@thednp/dommatrix\";\nimport { type PointTuple } from \"../types\";\n\n/**\n * Transforms a specified point using a matrix, returning a new\n * Tuple *Object* comprising of the transformed point.\n * Neither the matrix nor the original point are altered.\n *\n * @copyright thednp © 2021\n *\n * @param cssm CSSMatrix instance\n * @param v Tuple\n * @return the resulting Tuple\n */\nconst translatePoint = (\n cssm: CSSMatrix,\n v: [number, number, number, number],\n): [number, number, number, number] => {\n let m = CSSMatrix.Translate(v[0], v[1], v[2]);\n\n [, , , m.m44] = v;\n m = cssm.multiply(m);\n\n return [m.m41, m.m42, m.m43, m.m44];\n};\n\n/**\n * Returns the [x,y] projected coordinates for a given an [x,y] point\n * and an [x,y,z] perspective origin point.\n *\n * Equation found here =>\n * http://en.wikipedia.org/wiki/3D_projection#Diagram\n * Details =>\n * https://stackoverflow.com/questions/23792505/predicted-rendering-of-css-3d-transformed-pixel\n *\n * @param m the transformation matrix\n * @param point2D the initial [x,y] coordinates\n * @param origin the [x,y,z] transform origin\n * @returns the projected [x,y] coordinates\n */\nconst projection2d = (\n m: CSSMatrix,\n point2D: PointTuple,\n origin: [number, number, number],\n): PointTuple => {\n const [originX, originY, originZ] = origin;\n const [x, y, z] = translatePoint(m, [point2D[0], point2D[1], 0, 1]);\n\n const relativePositionX = x - originX;\n const relativePositionY = y - originY;\n const relativePositionZ = z - originZ;\n\n return [\n // protect against division by ZERO\n relativePositionX * (Math.abs(originZ) / Math.abs(relativePositionZ) || 1) +\n originX,\n relativePositionY * (Math.abs(originZ) / Math.abs(relativePositionZ) || 1) +\n originY,\n ];\n};\nexport default projection2d;\n","import type { CSegment, CurveArray, MSegment, PathCommand } from \"../types\";\n\n/**\n * Reverses all segments of a `pathArray`\n * which consists of only C (cubic-bezier) path commands.\n *\n * @param path the source `pathArray`\n * @returns the reversed `pathArray`\n */\nconst reverseCurve = (path: CurveArray) => {\n const rotatedCurve = path\n .slice(1)\n .map((x, i, curveOnly) =>\n !i\n ? path[0].slice(1).concat(x.slice(1) as number[])\n : curveOnly[i - 1].slice(-2).concat(x.slice(1))\n )\n .map((x) => x.map((_, i) => x[x.length - i - 2 * (1 - (i % 2))]))\n .reverse() as (MSegment | CSegment)[];\n\n return [[\"M\" as PathCommand | number].concat(rotatedCurve[0].slice(0, 2))]\n .concat(\n rotatedCurve.map((x) => [\"C\" as PathCommand | number].concat(x.slice(2))),\n ) as CurveArray;\n};\n\nexport default reverseCurve;\n","import type {\n ASegment,\n CSegment,\n HSegment,\n MSegment,\n PathArray,\n PathSegment,\n PointTuple,\n QSegment,\n SSegment,\n TSegment,\n VSegment,\n} from \"../types\";\nimport pathToAbsolute from \"../convert/pathToAbsolute\";\nimport normalizePath from \"./normalizePath\";\nimport iterate from \"./iterate\";\n\n/**\n * Reverses all segments of a `pathArray` and returns a new `pathArray` instance\n * with absolute values.\n *\n * @param pathInput the source `pathArray`\n * @returns the reversed `pathArray`\n */\nconst reversePath = (pathInput: PathArray) => {\n const absolutePath = pathToAbsolute(pathInput);\n const normalizedPath = normalizePath(absolutePath);\n const pLen = absolutePath.length;\n const isClosed = absolutePath[pLen - 1][0] === \"Z\";\n\n const reversedPath = iterate(absolutePath, (segment, i) => {\n const normalizedSegment = normalizedPath[i];\n const prevSeg = i && absolutePath[i - 1];\n const prevCommand = prevSeg && prevSeg[0];\n const nextSeg = absolutePath[i + 1];\n const nextCommand = nextSeg && nextSeg[0];\n const [pathCommand] = segment;\n const [x, y] = normalizedPath[i ? i - 1 : pLen - 1].slice(-2) as PointTuple;\n let result = segment;\n\n switch (pathCommand) {\n case \"M\":\n result = (isClosed ? [\"Z\"] : [pathCommand, x, y]) as PathSegment;\n break;\n case \"A\":\n result = [\n pathCommand,\n segment[1],\n segment[2],\n segment[3],\n segment[4],\n segment[5] === 1 ? 0 : 1,\n x,\n y,\n ] as ASegment;\n break;\n case \"C\":\n if (nextSeg && nextCommand === \"S\") {\n result = [\"S\", segment[1], segment[2], x, y] as SSegment;\n } else {\n result = [\n pathCommand,\n segment[3],\n segment[4],\n segment[1],\n segment[2],\n x,\n y,\n ] as CSegment;\n }\n break;\n case \"S\":\n if (\n prevCommand && \"CS\".includes(prevCommand) &&\n (!nextSeg || nextCommand !== \"S\")\n ) {\n result = [\n \"C\",\n normalizedSegment[3],\n normalizedSegment[4],\n normalizedSegment[1],\n normalizedSegment[2],\n x,\n y,\n ] as CSegment;\n } else {\n result = [\n pathCommand,\n normalizedSegment[1],\n normalizedSegment[2],\n x,\n y,\n ] as SSegment;\n }\n break;\n case \"Q\":\n if (nextSeg && nextCommand === \"T\") {\n result = [\"T\", x, y] as TSegment;\n } else {\n result = [pathCommand, segment[1], segment[2], x, y] as QSegment;\n }\n break;\n case \"T\":\n if (\n prevCommand && \"QT\".includes(prevCommand) &&\n (!nextSeg || nextCommand !== \"T\")\n ) {\n result = [\n \"Q\",\n normalizedSegment[1],\n normalizedSegment[2],\n x,\n y,\n ] as QSegment;\n } else {\n result = [pathCommand, x, y] as TSegment;\n }\n break;\n case \"Z\":\n result = [\"M\", x, y] as MSegment;\n break;\n case \"H\":\n result = [pathCommand, x] as HSegment;\n break;\n case \"V\":\n result = [pathCommand, y] as VSegment;\n break;\n default:\n result = [pathCommand as typeof pathCommand | number].concat(\n segment.slice(1, -2),\n x,\n y,\n ) as PathSegment;\n }\n\n return result;\n });\n\n return (\n isClosed\n ? reversedPath.reverse()\n : [reversedPath[0] as PathSegment].concat(reversedPath.slice(1).reverse())\n ) as PathArray;\n};\n\nexport default reversePath;\n","import type { PathArray } from \"../types\";\nimport defaultOptions from \"../options/options\";\nimport iterate from \"./iterate\";\nimport roundSegment from \"./roundSegment\";\n\n/**\n * Rounds the values of a `pathArray` instance to\n * a specified amount of decimals and returns it.\n *\n * @param path the source `pathArray`\n * @param roundOption the amount of decimals to round numbers to\n * @returns the resulted `pathArray` with rounded values\n */\nconst roundPath = (path: PathArray, roundOption?: number | \"off\") => {\n let { round } = defaultOptions;\n // allow for ZERO decimals\n round = roundOption === \"off\"\n ? roundOption\n : typeof roundOption === \"number\" && roundOption >= 0\n ? roundOption\n : typeof round === \"number\" && round >= 0\n ? round\n : /* istanbul ignore next @preserve */ \"off\";\n\n /* istanbul ignore else @preserve */\n if (round === \"off\") return path.slice(0) as PathArray;\n\n return iterate(path, (segment) => {\n return roundSegment(segment, round);\n });\n};\nexport default roundPath;\n","import midPoint from \"../math/midPoint\";\nimport type { CubicSegment, PointTuple } from \"../types\";\n\n/**\n * Split a cubic-bezier segment into two.\n *\n * @param pts the cubic-bezier parameters\n * @param ratio the cubic-bezier parameters\n * @return two new cubic-bezier segments\n */\nconst splitCubic = (\n pts: number[],\n ratio = 0.5,\n): [CubicSegment, CubicSegment] => {\n const t = ratio;\n const p0 = pts.slice(0, 2) as PointTuple;\n const p1 = pts.slice(2, 4) as PointTuple;\n const p2 = pts.slice(4, 6) as PointTuple;\n const p3 = pts.slice(6, 8) as PointTuple;\n const p4 = midPoint(p0, p1, t);\n const p5 = midPoint(p1, p2, t);\n const p6 = midPoint(p2, p3, t);\n const p7 = midPoint(p4, p5, t);\n const p8 = midPoint(p5, p6, t);\n const p9 = midPoint(p7, p8, t);\n\n return [\n [\"C\", p4[0], p4[1], p7[0], p7[1], p9[0], p9[1]],\n [\"C\", p8[0], p8[1], p6[0], p6[1], p3[0], p3[1]],\n ];\n};\nexport default splitCubic;\n","import paramsParser from \"../parser/paramsParser\";\nimport type {\n AbsoluteCommand,\n HSegment,\n MSegment,\n PathArray,\n PointTuple,\n RelativeCommand,\n VSegment,\n} from \"../types\";\n\n/**\n * Split a path into an `Array` of sub-path strings.\n *\n * In the process, values are converted to absolute\n * for visual consistency.\n *\n * @param pathInput the source `pathArray`\n * @return an array with all sub-path strings\n */\nconst splitPath = (pathInput: PathArray): PathArray[] => {\n const composite = [] as PathArray[];\n let path: PathArray;\n let pi = -1;\n let x = 0;\n let y = 0;\n let mx = 0;\n let my = 0;\n const params = { ...paramsParser };\n\n pathInput.forEach((seg) => {\n const [pathCommand] = seg;\n const absCommand = pathCommand.toUpperCase() as AbsoluteCommand;\n const relCommand = pathCommand.toLowerCase() as RelativeCommand;\n const isRelative = pathCommand === relCommand;\n const values = seg.slice(1) as number[];\n\n if (absCommand === \"M\") {\n pi += 1;\n [x, y] = values as PointTuple;\n x += isRelative ? params.x : 0;\n y += isRelative ? params.y : 0;\n mx = x;\n my = y;\n path = [(isRelative ? [absCommand, mx, my] : seg) as MSegment];\n } else {\n if (absCommand === \"Z\") {\n x = mx;\n y = my;\n } else if (absCommand === \"H\") {\n [, x] = seg as HSegment;\n x += isRelative ? params.x : /* istanbul ignore next @preserve */ 0;\n } else if (absCommand === \"V\") {\n [, y] = seg as VSegment;\n y += isRelative ? params.y : /* istanbul ignore next @preserve */ 0;\n } else {\n [x, y] = seg.slice(-2) as PointTuple;\n x += isRelative ? params.x : 0;\n y += isRelative ? params.y : 0;\n }\n path.push(seg);\n }\n\n params.x = x;\n params.y = y;\n composite[pi] = path;\n });\n\n return composite;\n};\nexport default splitPath;\n","import getSVGMatrix from \"./getSVGMatrix\";\nimport projection2d from \"./projection2d\";\nimport defaultOptions from \"../options/options\";\nimport type {\n AbsoluteArray,\n AbsoluteSegment,\n CSegment,\n LSegment,\n PathArray,\n TransformObjectValues,\n} from \"../types\";\nimport type { TransformObject } from \"../interface\";\nimport iterate from \"./iterate\";\nimport parsePathString from \"../parser/parsePathString\";\nimport absolutizeSegment from \"./absolutizeSegment\";\nimport arcToCubic from \"./arcToCubic\";\n\n/**\n * Apply a 2D / 3D transformation to a `pathArray` instance.\n *\n * Since *SVGElement* doesn't support 3D transformation, this function\n * creates a 2D projection of the element.\n *\n * @param path the `pathArray` to apply transformation\n * @param transform the transform functions `Object`\n * @returns the resulted `pathArray`\n */\nconst transformPath = (\n pathInput: PathArray | string,\n transform?: Partial,\n) => {\n // last x and y transformed values\n let x = 0;\n let y = 0;\n // new x and y transformed\n let lx = 0;\n let ly = 0;\n // segment params iteration index and length\n let j = 0;\n let jj = 0;\n let pathCommand = \"M\";\n // transform uses it's own set of params\n const path = parsePathString(pathInput);\n const transformProps = transform && Object.keys(transform);\n\n // when used as a static method, invalidate somehow\n if (!transform || (transformProps && !transformProps.length)) {\n return path.slice(0) as typeof path;\n }\n\n // transform origin is extremely important\n if (!transform.origin) {\n Object.assign(transform, { origin: defaultOptions.origin });\n }\n const origin = transform.origin as [number, number, number];\n const matrixInstance = getSVGMatrix(transform as TransformObjectValues);\n\n if (matrixInstance.isIdentity) return path.slice(0) as typeof path;\n\n return iterate(path, (seg, index, lastX, lastY) => {\n [pathCommand] = seg;\n const absCommand = pathCommand.toUpperCase();\n const isRelative = absCommand !== pathCommand;\n const absoluteSegment = isRelative\n ? absolutizeSegment(seg, index, lastX, lastY)\n : (seg.slice(0) as AbsoluteSegment);\n\n let result = absCommand === \"A\"\n // ? segmentToCubic(absoluteSegment, transformParams)\n ? ([\"C\" as string | number].concat(\n arcToCubic(\n lastX,\n lastY,\n absoluteSegment[1] as number,\n absoluteSegment[2] as number,\n absoluteSegment[3] as number,\n absoluteSegment[4] as number,\n absoluteSegment[5] as number,\n absoluteSegment[6] as number,\n absoluteSegment[7] as number,\n ),\n ) as CSegment)\n : absCommand === \"V\"\n ? ([\"L\", lastX, absoluteSegment[1]] as LSegment)\n : absCommand === \"H\"\n ? ([\"L\", absoluteSegment[1], lastY] as LSegment)\n : absoluteSegment;\n\n // update pathCommand\n pathCommand = result[0];\n const isLongArc = pathCommand === \"C\" && result.length > 7;\n const tempSegment =\n (isLongArc ? result.slice(0, 7) : result.slice(0)) as AbsoluteSegment;\n\n if (isLongArc) {\n path.splice(\n index + 1,\n 0,\n [\"C\" as typeof pathCommand | number].concat(\n result.slice(7),\n ) as CSegment,\n );\n result = tempSegment as CSegment;\n }\n\n if (pathCommand === \"L\") {\n [lx, ly] = projection2d(matrixInstance, [\n (result as LSegment)[1],\n (result as LSegment)[2],\n ], origin);\n\n /* istanbul ignore else @preserve */\n if (x !== lx && y !== ly) {\n result = [\"L\", lx, ly];\n } else if (y === ly) {\n result = [\"H\", lx];\n } else if (x === lx) {\n result = [\"V\", ly];\n }\n } else {\n for (j = 1, jj = result.length; j < jj; j += 2) {\n [lx, ly] = projection2d(\n matrixInstance,\n [+result[j], +result[j + 1]],\n origin,\n );\n result[j] = lx;\n result[j + 1] = ly;\n }\n }\n // now update x and y\n x = lx;\n y = ly;\n\n return result;\n });\n};\n\nexport default transformPath;\n","\"use strict\";\nimport * as util from \"./util\";\n// import CSSMatrix from \"@thednp/dommatrix\";\nimport type { PathArray, PointTuple, TransformObjectValues } from \"./types\";\nimport type { Options, TransformEntries, TransformObject } from \"./interface\";\nexport * from \"./types\";\nexport * from \"./interface\";\nimport defaultOptions from \"./options/options\";\n\nimport pathToAbsolute from \"./convert/pathToAbsolute\";\nimport pathToRelative from \"./convert/pathToRelative\";\nimport pathToCurve from \"./convert/pathToCurve\";\nimport pathToString from \"./convert/pathToString\";\n// import * as arcTools from \"./math/arcTools\";\n// import * as bezierTools from \"./math/bezier\";\n// import * as cubicTools from \"./math/cubicTools\";\n// import * as lineTools from \"./math/lineTools\";\n// import * as quadTools from \"./math/quadTools\";\n// import * as polygonTools from \"./math/polygonTools\";\n\n// import distanceSquareRoot from \"./math/distanceSquareRoot\";\n// import midPoint from \"./math/midPoint\";\n// import rotateVector from \"./math/rotateVector\";\n// import roundTo from \"./math/roundTo\";\n\nimport error from \"./parser/error\";\nimport parsePathString from \"./parser/parsePathString\";\n// import finalizeSegment from \"./parser/finalizeSegment\";\n// import invalidPathValue from \"./parser/invalidPathValue\";\n// import isArcCommand from \"./parser/isArcCommand\";\n// import isDigit from \"./parser/isDigit\";\n// import isDigitStart from \"./parser/isDigitStart\";\n// import isMoveCommand from \"./parser/isMoveCommand\";\n// import isPathCommand from \"./parser/isPathCommand\";\n// import isSpace from \"./parser/isSpace\";\n// import paramsCount from \"./parser/paramsCount\";\n// import paramsParser from \"./parser/paramsParser\";\n// import pathParser from \"./parser/pathParser\";\n// import scanFlag from \"./parser/scanFlag\";\n// import scanParam from \"./parser/scanParam\";\n// import scanSegment from \"./parser/scanSegment\";\n// import skipSpaces from \"./parser/skipSpaces\";\n\n// import distanceEpsilon from \"./util/distanceEpsilon\";\n// import getClosestPoint from \"./util/getClosestPoint\";\n// import getDrawDirection from \"./util/getDrawDirection\";\n// import getPathArea from \"./util/getPathArea\";\nimport getPathBBox from \"./util/getPathBBox\";\nimport getPointAtLength from \"./util/getPointAtLength\";\n// import getPropertiesAtLength from \"./util/getPropertiesAtLength\";\n// import getPropertiesAtPoint from \"./util/getPropertiesAtPoint\";\n// import getSegmentAtLength from \"./util/getSegmentAtLength\";\n// import getSegmentOfPoint from \"./util/getSegmentOfPoint\";\nimport getTotalLength from \"./util/getTotalLength\";\n\n// import isAbsoluteArray from \"./util/isAbsoluteArray\";\n// import isCurveArray from \"./util/isCurveArray\";\n// import isNormalizedArray from \"./util/isNormalizedArray\";\n// import isPathArray from \"./util/isPathArray\";\n// import isPointInStroke from \"./util/isPointInStroke\";\n// import isRelativeArray from \"./util/isRelativeArray\";\n// import isValidPath from \"./util/isValidPath\";\n// import shapeParams from \"./util/shapeParams\";\n// import shapeToPath from \"./util/shapeToPath\";\n// import shapeToPathArray from \"./util/shapeToPathArray\";\n\n// import absolutizeSegment from \"./process/absolutizeSegment\";\n// import arcToCubic from \"./process/arcToCubic\";\n// import getSVGMatrix from \"./process/getSVGMatrix\";\n// import iterate from \"./process/iterate\";\n// import lineToCubic from \"./process/lineToCubic\";\nimport normalizePath from \"./process/normalizePath\";\n// import normalizeSegment from \"./process/normalizeSegment\";\nimport optimizePath from \"./process/optimizePath\";\n// import projection2d from \"./process/projection2d\";\n// import quadToCubic from \"./process/quadToCubic\";\n// import relativizeSegment from \"./process/relativizeSegment\";\n// import reverseCurve from \"./process/reverseCurve\";\nimport reversePath from \"./process/reversePath\";\n// import roundPath from \"./process/roundPath\";\n// import roundSegment from \"./process/roundSegment\";\n// import segmentToCubic from \"./process/segmentToCubic\";\n// import shortenSegment from \"./process/shortenSegment\";\n// import splitCubic from \"./process/splitCubic\";\nimport splitPath from \"./process/splitPath\";\nimport transformPath from \"./process/transformPath\";\n\n/**\n * Creates a new SVGPathCommander instance with the following properties:\n * * segments: `pathArray`\n * * round: number\n * * origin: [number, number, number?]\n *\n * @class\n * @author thednp \n * @returns a new SVGPathCommander instance\n */\nclass SVGPathCommander {\n // declare class properties\n declare segments: PathArray;\n declare round: number | \"off\";\n declare origin: [number, number, number];\n\n /**\n * @constructor\n * @param pathValue the path string\n * @param config instance options\n */\n constructor(pathValue: string, config?: Partial) {\n const instanceOptions = config || {};\n const undefPath = typeof pathValue === \"undefined\";\n\n if (undefPath || !pathValue.length) {\n throw TypeError(\n `${error}: \"pathValue\" is ${undefPath ? \"undefined\" : \"empty\"}`,\n );\n }\n\n this.segments = parsePathString(pathValue);\n\n // // set instance options.round\n const { round: roundOption, origin: originOption } = instanceOptions;\n let round: number | \"off\";\n\n if (Number.isInteger(roundOption) || roundOption === \"off\") {\n round = roundOption as number | \"off\";\n } else {\n round = defaultOptions.round as number;\n }\n\n // set instance options.origin\n // the SVGPathCommander class will always override the default origin\n let origin = defaultOptions.origin as [number, number, number];\n /* istanbul ignore else @preserve */\n if (Array.isArray(originOption) && originOption.length >= 2) {\n const [originX, originY, originZ] = originOption.map(Number);\n origin = [\n !Number.isNaN(originX) ? originX : 0,\n !Number.isNaN(originY) ? originY : 0,\n !Number.isNaN(originZ) ? originZ : 0,\n ];\n }\n\n this.round = round;\n this.origin = origin;\n\n return this;\n }\n get bbox() {\n return getPathBBox(this.segments);\n }\n get length() {\n return getTotalLength(this.segments);\n }\n\n /**\n * Returns the path bounding box, equivalent to native `path.getBBox()`.\n *\n * @public\n * @returns the pathBBox\n */\n getBBox() {\n return this.bbox;\n }\n\n /**\n * Returns the total path length, equivalent to native `path.getTotalLength()`.\n *\n * @public\n * @returns the path total length\n */\n getTotalLength() {\n return this.length;\n }\n\n /**\n * Returns an `{x,y}` point in the path stroke at a given length,\n * equivalent to the native `path.getPointAtLength()`.\n *\n * @public\n * @param length the length\n * @returns the requested point\n */\n getPointAtLength(length: number) {\n return getPointAtLength(this.segments, length);\n }\n\n /**\n * Convert path to absolute values\n *\n * @public\n */\n toAbsolute() {\n const { segments } = this;\n this.segments = pathToAbsolute(segments);\n return this;\n }\n\n /**\n * Convert path to relative values\n *\n * @public\n */\n toRelative() {\n const { segments } = this;\n this.segments = pathToRelative(segments);\n return this;\n }\n\n /**\n * Convert path to cubic-bezier values. In addition, un-necessary `Z`\n * segment is removed if previous segment extends to the `M` segment.\n *\n * @public\n */\n toCurve() {\n const { segments } = this;\n this.segments = pathToCurve(segments);\n return this;\n }\n\n /**\n * Reverse the order of the segments and their values.\n *\n * @param onlySubpath option to reverse all sub-paths except first\n * @public\n */\n reverse(onlySubpath?: boolean) {\n const { segments } = this;\n const split = splitPath(segments);\n const subPath = split.length > 1 ? split : false;\n\n const absoluteMultiPath = subPath\n ? subPath.map((x, i) => {\n if (onlySubpath) {\n return i ? reversePath(x) : x.slice(0);\n }\n return reversePath(x);\n })\n : segments.slice(0);\n\n let path = [] as unknown as PathArray;\n if (subPath) {\n path = absoluteMultiPath.flat(1) as PathArray;\n } else {\n path = onlySubpath ? segments : reversePath(segments);\n }\n\n this.segments = path.slice(0) as PathArray;\n return this;\n }\n\n /**\n * Normalize path in 2 steps:\n * * convert `pathArray`(s) to absolute values\n * * convert shorthand notation to standard notation\n *\n * @public\n */\n normalize() {\n const { segments } = this;\n this.segments = normalizePath(segments);\n return this;\n }\n\n /**\n * Optimize `pathArray` values:\n * * convert segments to absolute and/or relative values\n * * select segments with shortest resulted string\n * * round values to the specified `decimals` option value\n *\n * @public\n */\n optimize() {\n const { segments } = this;\n const round = this.round === \"off\" ? 2 : this.round;\n\n this.segments = optimizePath(segments, round);\n return this;\n }\n\n /**\n * Transform path using values from an `Object` defined as `transformObject`.\n *\n * @see TransformObject for a quick refference\n *\n * @param source a `transformObject`as described above\n * @public\n */\n transform(source?: Partial) {\n if (\n !source ||\n typeof source !== \"object\" ||\n (typeof source === \"object\" &&\n ![\"translate\", \"rotate\", \"skew\", \"scale\"].some((x) => x in source))\n ) {\n return this;\n }\n\n const {\n segments,\n origin: [cx, cy, cz],\n } = this;\n const transform = {} as TransformObjectValues;\n for (const [k, v] of Object.entries(source) as TransformEntries) {\n // istanbul ignore else @preserve\n if (k === \"skew\" && Array.isArray(v)) {\n transform[k] = v.map(Number) as PointTuple;\n } else if (\n (k === \"rotate\" || k === \"translate\" || k === \"origin\" ||\n k === \"scale\") && Array.isArray(v)\n ) {\n transform[k] = v.map(Number) as [number, number, number];\n } else if (k !== \"origin\" && typeof Number(v) === \"number\") {\n transform[k] = Number(v);\n }\n }\n\n // if origin is not specified\n // it's important that we have one\n const { origin } = transform;\n\n if (Array.isArray(origin) && origin.length >= 2) {\n const [originX, originY, originZ] = origin.map(Number);\n transform.origin = [\n !Number.isNaN(originX) ? originX : cx,\n !Number.isNaN(originY) ? originY : cy,\n originZ || cz,\n ];\n } else {\n transform.origin = [cx, cy, cz];\n }\n\n this.segments = transformPath(segments, transform);\n return this;\n }\n\n /**\n * Rotate path 180deg vertically\n *\n * @public\n */\n flipX() {\n const { cx, cy } = this.bbox;\n this.transform({ rotate: [0, 180, 0], origin: [cx, cy, 0] });\n return this;\n }\n\n /**\n * Rotate path 180deg horizontally\n *\n * @public\n */\n flipY() {\n const { cx, cy } = this.bbox;\n this.transform({ rotate: [180, 0, 0], origin: [cx, cy, 0] });\n return this;\n }\n\n /**\n * Export the current path to be used\n * for the `d` (description) attribute.\n *\n * @public\n * @return the path string\n */\n toString() {\n return pathToString(this.segments, this.round);\n }\n\n /**\n * Remove the instance.\n *\n * @public\n * @return void\n */\n dispose() {\n Object.keys(this).forEach((key) => delete this[key as keyof typeof this]);\n }\n}\n\n// export {\n// absolutizeSegment,\n// arcToCubic,\n// arcTools,\n// bezierTools,\n// CSSMatrix,\n// cubicTools,\n// distanceEpsilon,\n// distanceSquareRoot,\n// finalizeSegment,\n// getClosestPoint,\n// getDrawDirection,\n// getPathArea,\n// getPathBBox,\n// getPointAtLength,\n// getPropertiesAtLength,\n// getPropertiesAtPoint,\n// getSegmentAtLength,\n// getSegmentOfPoint,\n// getSVGMatrix,\n// getTotalLength,\n// invalidPathValue,\n// isAbsoluteArray,\n// isArcCommand,\n// isCurveArray,\n// isDigit,\n// isDigitStart,\n// isMoveCommand,\n// isNormalizedArray,\n// isPathArray,\n// isPathCommand,\n// isPointInStroke,\n// isRelativeArray,\n// isSpace,\n// isValidPath,\n// iterate,\n// lineToCubic,\n// lineTools,\n// midPoint,\n// normalizePath,\n// normalizeSegment,\n// optimizePath,\n// paramsCount,\n// paramsParser,\n// parsePathString,\n// pathParser,\n// pathToAbsolute,\n// pathToCurve,\n// pathToRelative,\n// pathToString,\n// polygonTools,\n// projection2d,\n// quadToCubic,\n// quadTools,\n// relativizeSegment,\n// reverseCurve,\n// reversePath,\n// rotateVector,\n// roundPath,\n// roundSegment,\n// roundTo,\n// scanFlag,\n// scanParam,\n// scanSegment,\n// segmentToCubic,\n// shapeParams,\n// shapeToPath,\n// shapeToPathArray,\n// shortenSegment,\n// skipSpaces,\n// splitCubic,\n// splitPath,\n// // SVGPathCommander as default,\n// transformPath,\n// };\n\n// const index = {\n// absolutizeSegment,\n// arcToCubic,\n// arcTools,\n// bezierTools,\n// CSSMatrix,\n// cubicTools,\n// distanceEpsilon,\n// distanceSquareRoot,\n// finalizeSegment,\n// getClosestPoint,\n// getDrawDirection,\n// getPathArea,\n// getPathBBox,\n// getPointAtLength,\n// getPropertiesAtLength,\n// getPropertiesAtPoint,\n// getSegmentAtLength,\n// getSegmentOfPoint,\n// getSVGMatrix,\n// getTotalLength,\n// invalidPathValue,\n// isAbsoluteArray,\n// isArcCommand,\n// isCurveArray,\n// isDigit,\n// isDigitStart,\n// isMoveCommand,\n// isNormalizedArray,\n// isPathArray,\n// isPathCommand,\n// isPointInStroke,\n// isRelativeArray,\n// isSpace,\n// isValidPath,\n// iterate,\n// lineToCubic,\n// lineTools,\n// midPoint,\n// normalizePath,\n// normalizeSegment,\n// optimizePath,\n// paramsCount,\n// paramsParser,\n// parsePathString,\n// pathParser,\n// pathToAbsolute,\n// pathToCurve,\n// pathToRelative,\n// pathToString,\n// polygonTools,\n// projection2d,\n// quadToCubic,\n// quadTools,\n// relativizeSegment,\n// reverseCurve,\n// reversePath,\n// rotateVector,\n// roundPath,\n// roundSegment,\n// roundTo,\n// scanFlag,\n// scanParam,\n// scanSegment,\n// segmentToCubic,\n// shapeParams,\n// shapeToPath,\n// shapeToPathArray,\n// shortenSegment,\n// skipSpaces,\n// splitCubic,\n// splitPath,\n// transformPath,\n// };\n\n// export { absolutizeSegment }\n// export { arcToCubic }\n// export { arcTools }\n// export { bezierTools }\n// export { CSSMatrix }\n// export { cubicTools }\n// export { distanceEpsilon }\n// export { distanceSquareRoot }\n// export { finalizeSegment }\n// export { getClosestPoint }\n// export { getDrawDirection }\n// export { getPathArea }\n// export { getPathBBox }\n// export { getPointAtLength }\n// export { getPropertiesAtLength }\n// export { getPropertiesAtPoint }\n// export { getSegmentAtLength }\n// export { getSegmentOfPoint }\n// export { getSVGMatrix }\n// export { getTotalLength }\n// export { invalidPathValue }\n// export { isAbsoluteArray }\n// export { isArcCommand }\n// export { isCurveArray }\n// export { isDigit }\n// export { isDigitStart }\n// export { isMoveCommand }\n// export { isNormalizedArray }\n// export { isPathArray }\n// export { isPathCommand }\n// export { isPointInStroke }\n// export { isRelativeArray }\n// export { isSpace }\n// export { isValidPath }\n// export { iterate }\n// export { lineToCubic }\n// export { lineTools }\n// export { midPoint }\n// export { normalizePath }\n// export { normalizeSegment }\n// export { optimizePath }\n// export { paramsCount }\n// export { paramsParser }\n// export { parsePathString }\n// export { pathParser }\n// export { pathToAbsolute }\n// export { pathToCurve }\n// export { pathToRelative }\n// export { pathToString }\n// export { polygonTools }\n// export { projection2d }\n// export { quadToCubic }\n// export { quadTools }\n// export { relativizeSegment }\n// export { reverseCurve }\n// export { reversePath }\n// export { rotateVector }\n// export { roundPath }\n// export { roundSegment }\n// export { roundTo }\n// export { scanFlag }\n// export { scanParam }\n// export { scanSegment }\n// export { segmentToCubic }\n// export { shapeParams }\n// export { shapeToPath }\n// export { shapeToPathArray }\n// export { shortenSegment }\n// export { skipSpaces }\n// export { splitCubic }\n// export { splitPath }\n// export { transformPath }\n// export { SVGPathCommander as default }\n// export default SVGPathCommander;\nconst defaultExport = Object.assign(SVGPathCommander, util);\n\nexport { defaultExport as default };\n// export default Object.assign(SVGPathCommander, index);\n"],"names":["Z","z","s","t","e","p","$","E","P","y","g","n","i","r","a","m","h","c","u","w","o","d","A","M","b","X","O","x","Y","F","T","k","I","v","R","D","N","midPoint","ax","ay","bx","by","distanceSquareRoot","getLineLength","x1","y1","x2","y2","getPointAtLineLength","distance","point","length","getLineBBox","min","max","arcLength","rx","ry","theta","halfTheta","sinHalfTheta","cosHalfTheta","term1","term2","arcPoint","cx","cy","alpha","sin","cos","cosA","sinA","angleBetween","v0","v1","v0x","v0y","v1x","v1y","getArcProps","RX","RY","angle","LAF","SF","abs","sqrt","PI","xRotRad","dx","dy","transformedPoint","radiiCheck","cSquareNumerator","cSquareRootDenom","cRadicand","cCoef","transformedCenter","center","startVector","startAngle","endVector","sweepAngle","endAngle","getArcLength","getPointAtArcLength","ellipseComponentX","ellipseComponentY","getArcBBox","deltaAngle","tan","atan2","tangent","angle1","angle2","angle3","angle4","xArray","yArray","xMin","xMax","yMin","yMax","angleAfterStart","pP2","angleBeforeEnd","pP3","p1","p2","p4","p3","Tvalues","Cvalues","deriveBezier","points","dpoints","list","j","computeBezier","order","mt","mt2","t2","calculateBezier","derivativeFn","l","bezierLength","len","sum","getBezierLength","curve","idx","step","CBEZIER_MINMAX_EPSILON","minmaxQ","cp","v2","minmaxC","cp1","cp2","K","S","L","Q","getPointAtCubicSegmentLength","c1x","c1y","c2x","c2y","t1","getCubicLength","getPointAtCubicLength","distanceIsNumber","currentLength","getCubicBBox","cxMinMax","cyMinMax","getPointAtQuadSegmentLength","getQuadLength","getPointAtQuadLength","getQuadBBox","polygonArea","polygon","area","polygonLength","paramsCount","finalizeSegment","path","pathCommand","relativeCommand","data","error","scanFlag","index","pathValue","code","isDigit","invalidPathValue","scanParam","start","zeroFirst","hasCeiling","hasDecimal","hasDot","ch","isSpace","skipSpaces","isPathCommand","isDigitStart","isArcCommand","isMoveCommand","scanSegment","_a","segments","cmdCode","reqParams","paramCounts","lastSegment","PathParser","pathString","parsePathString","pathInput","absolutizeSegment","segment","lastX","lastY","absCommand","absValues","seglen","iterate","iterator","pathLen","isRelative","mx","my","segLen","iteratorResult","pathToAbsolute","relativizeSegment","relCommand","relValues","pathToRelative","rotateVector","rad","arcToCubic","X1","Y1","X2","Y2","recursive","d120","res","xy","f1","f2","rx2","ry2","df","f2old","x2old","y2old","c1","s1","c2","s2","hx","hy","m1","m2","m3","m4","newres","ii","quadToCubic","qx","qy","r13","r23","lineToCubic","segmentToCubic","params","values","px1","py1","px","py","normalizeSegment","px2","py2","nqx","nqy","paramsParser","pathToCurve","seg","normalSegment","result","defaultOptions","roundTo","round","pow","pathToString","roundOption","valLen","DISTANCE_EPSILON","normalizePath","_","getPointAtLength","isM","POINT","totalLength","getTotalLength","paramX1","paramY1","paramX2","paramY2","paramQX","paramQY","absoluteSegment","cp1x","cp1y","getPropertiesAtLength","pathArray","pathTemp","pathLength","lengthAtSegment","getPropertiesAtPoint","normalPath","distanceTo","precision","scan","closest","scanDistance","bestLength","bestDistance","scanLength","before","after","beforeLength","afterLength","beforeDistance","afterDistance","getClosestPoint","getCubicSegArea","getPathArea","getDrawDirection","getPathBBox","minX","minY","maxX","maxY","width","height","getSegmentAtLength","getSegmentOfPoint","isPathArray","lk","isAbsoluteArray","isNormalizedArray","pc","isCurveArray","isPointInStroke","isRelativeArray","isValidPath","shapeParams","isElement","node","getLinePath","attr","getPolyPath","getCirclePath","getEllipsePath","getRectanglePath","shapeToPathArray","element","supportedShapes","targetIsElement","tagName","type","shapeAttrs","config","shapeToPath","replace","ownerDocument","doc","description","name","value","getSVGMatrix","transform","matrix","CSSMatrix","origin","originX","originY","translate","rotate","skew","scale","shortenSegment","prevCommand","defaultRound","normalValues","nx","ny","nx1","ny1","roundSegment","optimizePath","optimParams","allPathCommands","normalizedSegment","shortSegment","absSegment","absString","relativeSegment","relSegment","relString","translatePoint","cssm","projection2d","point2D","originZ","relativePositionX","relativePositionY","relativePositionZ","reverseCurve","rotatedCurve","curveOnly","reversePath","absolutePath","normalizedPath","pLen","isClosed","reversedPath","prevSeg","nextSeg","nextCommand","roundPath","splitCubic","pts","ratio","p0","p5","p6","p7","p8","p9","splitPath","composite","pi","transformPath","lx","ly","jj","transformProps","matrixInstance","isLongArc","tempSegment","SVGPathCommander","instanceOptions","undefPath","originOption","onlySubpath","split","subPath","absoluteMultiPath","source","cz","key","defaultExport","util"],"mappings":"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","x_google_ignoreList":[0]} \ No newline at end of file +{"version":3,"sources":["../src/util.ts","../src/math/arcTools.ts","../src/math/lineTools.ts","../src/math/midPoint.ts","../src/math/distanceSquareRoot.ts","../src/math/bezier.ts","../src/math/cubicTools.ts","../src/math/quadTools.ts","../src/math/polygonTools.ts","../src/parser/paramsCount.ts","../src/parser/finalizeSegment.ts","../src/parser/error.ts","../src/parser/scanFlag.ts","../src/parser/isDigit.ts","../src/parser/invalidPathValue.ts","../src/parser/scanParam.ts","../src/parser/isSpace.ts","../src/parser/skipSpaces.ts","../src/parser/isPathCommand.ts","../src/parser/isDigitStart.ts","../src/parser/isArcCommand.ts","../src/parser/isMoveCommand.ts","../src/parser/scanSegment.ts","../src/parser/pathParser.ts","../src/parser/parsePathString.ts","../src/process/absolutizeSegment.ts","../src/process/iterate.ts","../src/convert/pathToAbsolute.ts","../src/process/relativizeSegment.ts","../src/convert/pathToRelative.ts","../src/math/rotateVector.ts","../src/process/arcToCubic.ts","../src/process/quadToCubic.ts","../src/process/lineToCubic.ts","../src/process/segmentToCubic.ts","../src/process/normalizeSegment.ts","../src/parser/paramsParser.ts","../src/convert/pathToCurve.ts","../src/options/options.ts","../src/math/roundTo.ts","../src/convert/pathToString.ts","../src/util/distanceEpsilon.ts","../src/process/normalizePath.ts","../src/util/getPointAtLength.ts","../src/util/getTotalLength.ts","../src/util/getPropertiesAtLength.ts","../src/util/getPropertiesAtPoint.ts","../src/util/getClosestPoint.ts","../src/util/getPathArea.ts","../src/util/getDrawDirection.ts","../src/util/getPathBBox.ts","../src/util/getSegmentAtLength.ts","../src/util/getSegmentOfPoint.ts","../src/util/isPathArray.ts","../src/util/isAbsoluteArray.ts","../src/util/isNormalizedArray.ts","../src/util/isCurveArray.ts","../src/util/isPointInStroke.ts","../src/util/isRelativeArray.ts","../src/util/isValidPath.ts","../src/util/shapeParams.ts","../src/util/isElement.ts","../src/util/shapeToPathArray.ts","../src/util/shapeToPath.ts","../src/process/getSVGMatrix.ts","../src/process/shortenSegment.ts","../src/process/roundSegment.ts","../src/process/optimizePath.ts","../src/process/projection2d.ts","../src/process/reverseCurve.ts","../src/process/reversePath.ts","../src/process/roundPath.ts","../src/process/splitCubic.ts","../src/process/splitPath.ts","../src/process/transformPath.ts","../src/index.ts"],"sourcesContent":["export { default as CSSMatrix } from \"@thednp/dommatrix\";\n// export type { PathArray, PointTuple, TransformObjectValues } from \"./types\";\n// export type { Options, TransformEntries, TransformObject } from \"./interface\";\n// export * from \"./types\";\n// export * from \"./interface\";\n\nimport * as arcTools from \"./math/arcTools\";\nimport * as bezierTools from \"./math/bezier\";\nimport * as cubicTools from \"./math/cubicTools\";\nimport * as lineTools from \"./math/lineTools\";\nimport * as quadTools from \"./math/quadTools\";\nimport * as polygonTools from \"./math/polygonTools\";\nexport { arcTools, bezierTools, cubicTools, lineTools, quadTools, polygonTools };\n\n// export * from \"./math/arcTools\";\n// export * from \"./math/bezier\";\n// export * from \"./math/cubicTools\";\n// export * from \"./math/lineTools\";\n// export * from \"./math/quadTools\";\n// export * from \"./math/polygonTools\";\n\nexport { default as pathToAbsolute } from \"./convert/pathToAbsolute\";\nexport { default as pathToRelative } from \"./convert/pathToRelative\";\nexport { default as pathToCurve } from \"./convert/pathToCurve\";\nexport { default as pathToString } from \"./convert/pathToString\";\n\nexport { default as distanceSquareRoot } from \"./math/distanceSquareRoot\";\nexport { default as midPoint } from \"./math/midPoint\";\nexport { default as rotateVector } from \"./math/rotateVector\";\nexport { default as roundTo } from \"./math/roundTo\";\n\nexport { default as parsePathString } from \"./parser/parsePathString\";\nexport { default as finalizeSegment } from \"./parser/finalizeSegment\";\nexport { default as invalidPathValue } from \"./parser/invalidPathValue\";\nexport { default as isArcCommand } from \"./parser/isArcCommand\";\nexport { default as isDigit } from \"./parser/isDigit\";\nexport { default as isDigitStart } from \"./parser/isDigitStart\";\nexport { default as isMoveCommand } from \"./parser/isMoveCommand\";\nexport { default as isPathCommand } from \"./parser/isPathCommand\";\nexport { default as isSpace } from \"./parser/isSpace\";\nexport { default as paramsCount } from \"./parser/paramsCount\";\nexport { default as paramsParser } from \"./parser/paramsParser\";\nexport { default as pathParser } from \"./parser/pathParser\";\nexport { default as scanFlag } from \"./parser/scanFlag\";\nexport { default as scanParam } from \"./parser/scanParam\";\nexport { default as scanSegment } from \"./parser/scanSegment\";\nexport { default as skipSpaces } from \"./parser/skipSpaces\";\n\nexport { default as distanceEpsilon } from \"./util/distanceEpsilon\";\nexport { default as getClosestPoint } from \"./util/getClosestPoint\";\nexport { default as getDrawDirection } from \"./util/getDrawDirection\";\nexport { default as getPathArea } from \"./util/getPathArea\";\nexport { default as getPathBBox } from \"./util/getPathBBox\";\nexport { default as getPointAtLength } from \"./util/getPointAtLength\";\nexport { default as getPropertiesAtLength } from \"./util/getPropertiesAtLength\";\nexport { default as getPropertiesAtPoint } from \"./util/getPropertiesAtPoint\";\nexport { default as getSegmentAtLength } from \"./util/getSegmentAtLength\";\nexport { default as getSegmentOfPoint } from \"./util/getSegmentOfPoint\";\nexport { default as getTotalLength } from \"./util/getTotalLength\";\n\nexport { default as isAbsoluteArray } from \"./util/isAbsoluteArray\";\nexport { default as isCurveArray } from \"./util/isCurveArray\";\nexport { default as isNormalizedArray } from \"./util/isNormalizedArray\";\nexport { default as isPathArray } from \"./util/isPathArray\";\nexport { default as isPointInStroke } from \"./util/isPointInStroke\";\nexport { default as isRelativeArray } from \"./util/isRelativeArray\";\nexport { default as isValidPath } from \"./util/isValidPath\";\nexport { default as shapeParams } from \"./util/shapeParams\";\nexport { default as shapeToPath } from \"./util/shapeToPath\";\nexport { default as shapeToPathArray } from \"./util/shapeToPathArray\";\n\nexport { default as absolutizeSegment } from \"./process/absolutizeSegment\";\nexport { default as arcToCubic } from \"./process/arcToCubic\";\nexport { default as getSVGMatrix } from \"./process/getSVGMatrix\";\nexport { default as iterate } from \"./process/iterate\";\nexport { default as lineToCubic } from \"./process/lineToCubic\";\nexport { default as normalizePath } from \"./process/normalizePath\";\nexport { default as normalizeSegment } from \"./process/normalizeSegment\";\nexport { default as optimizePath } from \"./process/optimizePath\";\nexport { default as projection2d } from \"./process/projection2d\";\nexport { default as quadToCubic } from \"./process/quadToCubic\";\nexport { default as relativizeSegment } from \"./process/relativizeSegment\";\nexport { default as reverseCurve } from \"./process/reverseCurve\";\nexport { default as reversePath } from \"./process/reversePath\";\nexport { default as roundPath } from \"./process/roundPath\";\nexport { default as roundSegment } from \"./process/roundSegment\";\nexport { default as segmentToCubic } from \"./process/segmentToCubic\";\nexport { default as shortenSegment } from \"./process/shortenSegment\";\nexport { default as splitCubic } from \"./process/splitCubic\";\nexport { default as splitPath } from \"./process/splitPath\";\nexport { default as transformPath } from \"./process/transformPath\";\n","import { getPointAtLineLength } from \"./lineTools\";\nimport type { Point, PointTuple } from \"../types\";\n\n/**\n * Returns the Arc segment length.\n * @param rx radius along X axis\n * @param ry radius along Y axis\n * @param theta the angle in radians\n * @returns the arc length\n */\nconst arcLength = (rx: number, ry: number, theta: number) => {\n const halfTheta = theta / 2;\n const sinHalfTheta = Math.sin(halfTheta);\n const cosHalfTheta = Math.cos(halfTheta);\n const term1 = rx ** 2 * sinHalfTheta ** 2;\n const term2 = ry ** 2 * cosHalfTheta ** 2;\n const length = Math.sqrt(term1 + term2) * theta;\n return Math.abs(length);\n};\n\n/**\n * Find point on ellipse at given angle around ellipse (theta);\n * @param cx the center X\n * @param cy the center Y\n * @param rx the radius X\n * @param ry the radius Y\n * @param alpha the arc rotation angle in radians\n * @param theta the arc sweep angle in radians\n * @returns a point around ellipse at given angle\n */\nconst arcPoint = (\n cx: number,\n cy: number,\n rx: number,\n ry: number,\n alpha: number,\n theta: number,\n) => {\n const { sin, cos } = Math;\n // theta is angle in radians around arc\n // alpha is angle of rotation of ellipse in radians\n const cosA = cos(alpha);\n const sinA = sin(alpha);\n const x = rx * cos(theta);\n const y = ry * sin(theta);\n\n return [cx + cosA * x - sinA * y, cy + sinA * x + cosA * y] as PointTuple;\n};\n\n/**\n * Returns the angle between two points.\n * @param v0 starting point\n * @param v1 ending point\n * @returns the angle in radian\n */\nconst angleBetween = (v0: Point, v1: Point) => {\n const { x: v0x, y: v0y } = v0;\n const { x: v1x, y: v1y } = v1;\n const p = v0x * v1x + v0y * v1y;\n const n = Math.sqrt((v0x ** 2 + v0y ** 2) * (v1x ** 2 + v1y ** 2));\n const sign = v0x * v1y - v0y * v1x < 0 ? -1 : 1;\n return sign * Math.acos(p / n);\n};\n\n/**\n * Returns the following properties for an Arc segment: center, start angle,\n * end angle, and radiuses on X and Y axis.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param RX the radius on X axis\n * @param RY the radius on Y axis\n * @param angle the ellipse rotation in degrees\n * @param LAF the large arc flag\n * @param SF the sweep flag\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns properties specific to Arc segments\n */\nconst getArcProps = (\n x1: number,\n y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n x: number,\n y: number,\n) => {\n const { abs, sin, cos, sqrt, PI } = Math;\n let rx = abs(RX);\n let ry = abs(RY);\n const xRot = ((angle % 360) + 360) % 360;\n const xRotRad = xRot * (PI / 180);\n\n // istanbul ignore next @preserve\n if (x1 === x && y1 === y) {\n return {\n rx,\n ry,\n startAngle: 0,\n endAngle: 0,\n center: { x, y },\n };\n }\n\n if (rx === 0 || ry === 0) {\n return {\n rx,\n ry,\n startAngle: 0,\n endAngle: 0,\n center: { x: (x + x1) / 2, y: (y + y1) / 2 },\n };\n }\n\n const dx = (x1 - x) / 2;\n const dy = (y1 - y) / 2;\n\n const transformedPoint = {\n x: cos(xRotRad) * dx + sin(xRotRad) * dy,\n y: -sin(xRotRad) * dx + cos(xRotRad) * dy,\n };\n\n const radiiCheck = transformedPoint.x ** 2 / rx ** 2 +\n transformedPoint.y ** 2 / ry ** 2;\n\n if (radiiCheck > 1) {\n rx *= sqrt(radiiCheck);\n ry *= sqrt(radiiCheck);\n }\n\n const cSquareNumerator = rx ** 2 * ry ** 2 -\n rx ** 2 * transformedPoint.y ** 2 - ry ** 2 * transformedPoint.x ** 2;\n const cSquareRootDenom = rx ** 2 * transformedPoint.y ** 2 +\n ry ** 2 * transformedPoint.x ** 2;\n\n let cRadicand = cSquareNumerator / cSquareRootDenom;\n /* istanbul ignore next @preserve */\n cRadicand = cRadicand < 0 ? 0 : cRadicand;\n const cCoef = (LAF !== SF ? 1 : -1) * sqrt(cRadicand);\n const transformedCenter = {\n x: cCoef * ((rx * transformedPoint.y) / ry),\n y: cCoef * (-(ry * transformedPoint.x) / rx),\n };\n\n const center = {\n x: cos(xRotRad) * transformedCenter.x - sin(xRotRad) * transformedCenter.y +\n (x1 + x) / 2,\n y: sin(xRotRad) * transformedCenter.x + cos(xRotRad) * transformedCenter.y +\n (y1 + y) / 2,\n };\n\n const startVector = {\n x: (transformedPoint.x - transformedCenter.x) / rx,\n y: (transformedPoint.y - transformedCenter.y) / ry,\n };\n\n const startAngle = angleBetween({ x: 1, y: 0 }, startVector);\n\n const endVector = {\n x: (-transformedPoint.x - transformedCenter.x) / rx,\n y: (-transformedPoint.y - transformedCenter.y) / ry,\n };\n\n let sweepAngle = angleBetween(startVector, endVector);\n if (!SF && sweepAngle > 0) {\n sweepAngle -= 2 * PI;\n } else if (SF && sweepAngle < 0) {\n sweepAngle += 2 * PI;\n }\n sweepAngle %= 2 * PI;\n\n const endAngle = startAngle + sweepAngle;\n\n // point.ellipticalArcStartAngle = startAngle;\n // point.ellipticalArcEndAngle = startAngle + sweepAngle;\n // point.ellipticalArcAngle = alpha;\n\n // point.ellipticalArcCenter = center;\n // point.resultantRx = rx;\n // point.resultantRy = ry;\n\n return {\n center,\n startAngle,\n endAngle,\n rx,\n ry,\n };\n};\n\n/**\n * Returns the length of an Arc segment.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the length of the Arc segment\n */\nconst getArcLength = (\n x1: number,\n y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n x: number,\n y: number,\n) => {\n const { rx, ry, startAngle, endAngle } = getArcProps(\n x1,\n y1,\n RX,\n RY,\n angle,\n LAF,\n SF,\n x,\n y,\n );\n return arcLength(rx, ry, endAngle - startAngle);\n};\n\n/**\n * Returns a point along an Arc segment at a given distance.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param RX the radius on X axis\n * @param RY the radius on Y axis\n * @param angle the ellipse rotation in degrees\n * @param LAF the large arc flag\n * @param SF the sweep flag\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance a [0-1] ratio\n * @returns a point along the Arc segment\n */\nconst getPointAtArcLength = (\n x1: number,\n y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n x: number,\n y: number,\n distance?: number,\n) => {\n let point = { x: x1, y: y1 };\n const { center, rx, ry, startAngle, endAngle } = getArcProps(\n x1,\n y1,\n RX,\n RY,\n angle,\n LAF,\n SF,\n x,\n y,\n );\n\n /* istanbul ignore else @preserve */\n if (typeof distance === \"number\") {\n const length = arcLength(rx, ry, endAngle - startAngle);\n if (distance <= 0) {\n point = { x: x1, y: y1 };\n } else if (distance >= length) {\n point = { x, y };\n } else {\n /* istanbul ignore next @preserve */\n if (x1 === x && y1 === y) {\n return { x, y };\n }\n /* istanbul ignore next @preserve */\n if (rx === 0 || ry === 0) {\n return getPointAtLineLength(x1, y1, x, y, distance);\n }\n const { PI, cos, sin } = Math;\n const sweepAngle = endAngle - startAngle;\n const xRot = ((angle % 360) + 360) % 360;\n const xRotRad = xRot * (PI / 180);\n const alpha = startAngle + sweepAngle * (distance / length);\n const ellipseComponentX = rx * cos(alpha);\n const ellipseComponentY = ry * sin(alpha);\n\n point = {\n x: cos(xRotRad) * ellipseComponentX - sin(xRotRad) * ellipseComponentY +\n center.x,\n y: sin(xRotRad) * ellipseComponentX + cos(xRotRad) * ellipseComponentY +\n center.y,\n };\n }\n }\n\n return point;\n};\n\n/**\n * Returns the extrema for an Arc segment in the following format:\n * [MIN_X, MIN_Y, MAX_X, MAX_Y]\n *\n * @see https://github.com/herrstrietzel/svg-pathdata-getbbox\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param RX the radius on X axis\n * @param RY the radius on Y axis\n * @param angle the ellipse rotation in degrees\n * @param LAF the large arc flag\n * @param SF the sweep flag\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the extrema of the Arc segment\n */\nconst getArcBBox = (\n x1: number,\n y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n x: number,\n y: number,\n) => {\n const { center, rx, ry, startAngle, endAngle } = getArcProps(\n x1,\n y1,\n RX,\n RY,\n angle,\n LAF,\n SF,\n x,\n y,\n );\n const deltaAngle = endAngle - startAngle;\n const { min, max, tan, atan2, PI } = Math;\n\n // circle/elipse center coordinates\n const { x: cx, y: cy } = center;\n\n // rotation to radians\n const alpha = (angle * PI) / 180;\n const tangent = tan(alpha);\n\n /**\n * find min/max from zeroes of directional derivative along x and y\n * along x axis\n */\n const theta = atan2(-ry * tangent, rx);\n const angle1 = theta;\n const angle2 = theta + PI;\n const angle3 = atan2(ry, rx * tangent);\n const angle4 = angle3 + PI;\n const xArray = [x];\n const yArray = [y];\n\n // inner bounding box\n let xMin = min(x1, x);\n let xMax = max(x1, x);\n let yMin = min(y1, y);\n let yMax = max(y1, y);\n\n // on path point close after start\n const angleAfterStart = endAngle - deltaAngle * 0.00001;\n const pP2 = arcPoint(cx, cy, rx, ry, alpha, angleAfterStart);\n\n // on path point close before end\n const angleBeforeEnd = endAngle - deltaAngle * 0.99999;\n const pP3 = arcPoint(cx, cy, rx, ry, alpha, angleBeforeEnd);\n\n /**\n * expected extremes\n * if leaving inner bounding box\n * (between segment start and end point)\n * otherwise exclude elliptic extreme points\n */\n\n // right\n if (pP2[0] > xMax || pP3[0] > xMax) {\n // get point for this theta\n const p1 = arcPoint(cx, cy, rx, ry, alpha, angle1);\n xArray.push(p1[0]);\n yArray.push(p1[1]);\n }\n\n // left\n if (pP2[0] < xMin || pP3[0] < xMin) {\n // get anti-symmetric point\n const p2 = arcPoint(cx, cy, rx, ry, alpha, angle2);\n xArray.push(p2[0]);\n yArray.push(p2[1]);\n }\n\n // top\n if (pP2[1] < yMin || pP3[1] < yMin) {\n // get anti-symmetric point\n const p4 = arcPoint(cx, cy, rx, ry, alpha, angle4);\n xArray.push(p4[0]);\n yArray.push(p4[1]);\n }\n\n // bottom\n if (pP2[1] > yMax || pP3[1] > yMax) {\n // get point for this theta\n const p3 = arcPoint(cx, cy, rx, ry, alpha, angle3);\n xArray.push(p3[0]);\n yArray.push(p3[1]);\n }\n\n xMin = min.apply([], xArray);\n yMin = min.apply([], yArray);\n xMax = max.apply([], xArray);\n yMax = max.apply([], yArray);\n\n return [xMin, yMin, xMax, yMax] as [number, number, number, number];\n};\n\nexport {\n angleBetween,\n arcLength,\n arcPoint,\n getArcBBox,\n getArcLength,\n getArcProps,\n getPointAtArcLength,\n};\n","import midPoint from \"./midPoint\";\nimport distanceSquareRoot from \"./distanceSquareRoot\";\n\n/**\n * Returns length for line segments (MoveTo, LineTo).\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the line segment length\n */\nconst getLineLength = (x1: number, y1: number, x2: number, y2: number) => {\n return distanceSquareRoot([x1, y1], [x2, y2]);\n};\n\n/**\n * Returns a point along the line segments (MoveTo, LineTo).\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance the distance to point in [0-1] range\n * @returns the point at length\n */\nconst getPointAtLineLength = (\n x1: number,\n y1: number,\n x2: number,\n y2: number,\n distance?: number,\n) => {\n let point = { x: x1, y: y1 };\n\n /* istanbul ignore else @preserve */\n if (typeof distance === \"number\") {\n const length = distanceSquareRoot([x1, y1], [x2, y2]);\n if (distance <= 0) {\n point = { x: x1, y: y1 };\n } else if (distance >= length) {\n point = { x: x2, y: y2 };\n } else {\n const [x, y] = midPoint([x1, y1], [x2, y2], distance / length);\n point = { x, y };\n }\n }\n return point;\n};\n\n/**\n * Returns bounding box for line segments (MoveTo, LineTo).\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance the distance to point in [0-1] range\n * @returns the extrema for line segments\n */\nconst getLineBBox = (x1: number, y1: number, x2: number, y2: number) => {\n const { min, max } = Math;\n\n return [min(x1, x2), min(y1, y2), max(x1, x2), max(y1, y2)] as [\n number,\n number,\n number,\n number,\n ];\n};\n\nexport { getLineBBox, getLineLength, getPointAtLineLength };\n","import { PointTuple } from \"../types\";\n\n/**\n * Returns the coordinates of a specified distance\n * ratio between two points.\n *\n * @param a the first point coordinates\n * @param b the second point coordinates\n * @param t the ratio\n * @returns the midpoint coordinates\n */\nconst midPoint = (a: PointTuple, b: PointTuple, t: number): PointTuple => {\n const [ax, ay] = a;\n const [bx, by] = b;\n return [ax + (bx - ax) * t, ay + (by - ay) * t];\n};\n\nexport default midPoint;\n","import { type PointTuple } from \"../types\";\n\n/**\n * Returns the square root of the distance\n * between two given points.\n *\n * @param a the first point coordinates\n * @param b the second point coordinates\n * @returns the distance value\n */\nconst distanceSquareRoot = (a: PointTuple, b: PointTuple) => {\n return Math.sqrt(\n (a[0] - b[0]) * (a[0] - b[0]) + (a[1] - b[1]) * (a[1] - b[1]),\n );\n};\n\nexport default distanceSquareRoot;\n","import type {\n CubicCoordinates,\n CubicPoints,\n DeriveCallback,\n DerivedCubicPoints,\n DerivedPoint,\n DerivedQuadPoints,\n PointTuple,\n QuadCoordinates,\n QuadPoints,\n} from \"../types\";\n\n/**\n * Tools from bezier.js by Mike 'Pomax' Kamermans\n * @see https://github.com/Pomax/bezierjs\n */\n\nconst Tvalues = [\n -0.0640568928626056260850430826247450385909,\n 0.0640568928626056260850430826247450385909,\n -0.1911188674736163091586398207570696318404,\n 0.1911188674736163091586398207570696318404,\n -0.3150426796961633743867932913198102407864,\n 0.3150426796961633743867932913198102407864,\n -0.4337935076260451384870842319133497124524,\n 0.4337935076260451384870842319133497124524,\n -0.5454214713888395356583756172183723700107,\n 0.5454214713888395356583756172183723700107,\n -0.6480936519369755692524957869107476266696,\n 0.6480936519369755692524957869107476266696,\n -0.7401241915785543642438281030999784255232,\n 0.7401241915785543642438281030999784255232,\n -0.8200019859739029219539498726697452080761,\n 0.8200019859739029219539498726697452080761,\n -0.8864155270044010342131543419821967550873,\n 0.8864155270044010342131543419821967550873,\n -0.9382745520027327585236490017087214496548,\n 0.9382745520027327585236490017087214496548,\n -0.9747285559713094981983919930081690617411,\n 0.9747285559713094981983919930081690617411,\n -0.9951872199970213601799974097007368118745,\n 0.9951872199970213601799974097007368118745,\n];\n\nconst Cvalues = [\n 0.1279381953467521569740561652246953718517,\n 0.1279381953467521569740561652246953718517,\n 0.1258374563468282961213753825111836887264,\n 0.1258374563468282961213753825111836887264,\n 0.121670472927803391204463153476262425607,\n 0.121670472927803391204463153476262425607,\n 0.1155056680537256013533444839067835598622,\n 0.1155056680537256013533444839067835598622,\n 0.1074442701159656347825773424466062227946,\n 0.1074442701159656347825773424466062227946,\n 0.0976186521041138882698806644642471544279,\n 0.0976186521041138882698806644642471544279,\n 0.086190161531953275917185202983742667185,\n 0.086190161531953275917185202983742667185,\n 0.0733464814110803057340336152531165181193,\n 0.0733464814110803057340336152531165181193,\n 0.0592985849154367807463677585001085845412,\n 0.0592985849154367807463677585001085845412,\n 0.0442774388174198061686027482113382288593,\n 0.0442774388174198061686027482113382288593,\n 0.0285313886289336631813078159518782864491,\n 0.0285313886289336631813078159518782864491,\n 0.0123412297999871995468056670700372915759,\n 0.0123412297999871995468056670700372915759,\n];\n\n/**\n * @param points\n * @returns\n */\nconst deriveBezier = (points: QuadPoints | CubicPoints) => {\n const dpoints = [] as (DerivedCubicPoints | DerivedQuadPoints)[];\n for (let p = points, d = p.length, c = d - 1; d > 1; d -= 1, c -= 1) {\n const list = [] as unknown as DerivedCubicPoints | DerivedQuadPoints;\n for (let j = 0; j < c; j += 1) {\n list.push({\n x: c * (p[j + 1].x - p[j].x),\n y: c * (p[j + 1].y - p[j].y),\n t: 0,\n });\n }\n dpoints.push(list);\n p = list;\n }\n return dpoints;\n};\n\n/**\n * @param points\n * @param t\n */\nconst computeBezier = (\n points: DerivedQuadPoints | DerivedCubicPoints,\n t: number,\n) => {\n // shortcuts\n /* istanbul ignore next @preserve */\n if (t === 0) {\n points[0].t = 0;\n return points[0];\n }\n\n const order = points.length - 1;\n\n /* istanbul ignore next @preserve */\n if (t === 1) {\n points[order].t = 1;\n return points[order];\n }\n\n const mt = 1 - t;\n let p = points as typeof points | [\n DerivedPoint,\n DerivedPoint,\n DerivedPoint,\n DerivedPoint,\n ];\n\n // constant?\n /* istanbul ignore next @preserve */\n if (order === 0) {\n points[0].t = t;\n return points[0];\n }\n\n // linear?\n /* istanbul ignore else @preserve */\n if (order === 1) {\n return {\n x: mt * p[0].x + t * p[1].x,\n y: mt * p[0].y + t * p[1].y,\n t,\n };\n }\n\n // quadratic/cubic curve?\n const mt2 = mt * mt;\n const t2 = t * t;\n let a = 0;\n let b = 0;\n let c = 0;\n let d = 0;\n /* istanbul ignore else @preserve */\n if (order === 2) {\n p = [p[0], p[1], p[2], { x: 0, y: 0 } as DerivedPoint];\n a = mt2;\n b = mt * t * 2;\n c = t2;\n } else if (order === 3) {\n a = mt2 * mt;\n b = mt2 * t * 3;\n c = mt * t2 * 3;\n d = t * t2;\n }\n return {\n x: a * p[0].x + b * p[1].x + c * p[2].x + d * p[3].x,\n y: a * p[0].y + b * p[1].y + c * p[2].y + d * p[3].y,\n t,\n };\n};\n\nconst calculateBezier = (derivativeFn: DeriveCallback, t: number) => {\n const d = derivativeFn(t);\n const l = d.x * d.x + d.y * d.y;\n\n return Math.sqrt(l);\n};\n\nconst bezierLength = (derivativeFn: DeriveCallback) => {\n const z = 0.5;\n const len = Tvalues.length;\n\n let sum = 0;\n\n for (let i = 0, t; i < len; i++) {\n t = z * Tvalues[i] + z;\n sum += Cvalues[i] * calculateBezier(derivativeFn, t);\n }\n return z * sum;\n};\n\n/**\n * Returns the length of CubicBezier / Quad segment.\n * @param curve cubic / quad bezier segment\n */\nconst getBezierLength = (curve: CubicCoordinates | QuadCoordinates) => {\n const points = [] as unknown as CubicPoints | QuadPoints;\n for (let idx = 0, len = curve.length, step = 2; idx < len; idx += step) {\n points.push({\n x: curve[idx],\n y: curve[idx + 1],\n });\n }\n const dpoints = deriveBezier(points);\n return bezierLength((t: number) => {\n return computeBezier(dpoints[0], t);\n });\n};\n\n// Precision for consider cubic polynom as quadratic one\nconst CBEZIER_MINMAX_EPSILON = 0.00000001;\n\n/**\n * Returns the most extreme points in a Quad Bezier segment.\n * @param A an array which consist of X/Y values\n */\n// https://github.com/kpym/SVGPathy/blob/acd1a50c626b36d81969f6e98e8602e128ba4302/lib/box.js#L89\nconst minmaxQ = ([v1, cp, v2]: [number, number, number]) => {\n const min = Math.min(v1, v2);\n const max = Math.max(v1, v2);\n\n /* istanbul ignore next @preserve */\n if (cp >= v1 ? v2 >= cp : v2 <= cp) {\n // if no extremum in ]0,1[\n return [min, max] as PointTuple;\n }\n\n // check if the extremum E is min or max\n const E = (v1 * v2 - cp * cp) / (v1 - 2 * cp + v2);\n return (E < min ? [E, max] : [min, E]) as PointTuple;\n};\n\n/**\n * Returns the most extreme points in a Cubic Bezier segment.\n * @param A an array which consist of X/Y values\n * @see https://github.com/kpym/SVGPathy/blob/acd1a50c626b36d81969f6e98e8602e128ba4302/lib/box.js#L127\n */\nconst minmaxC = ([v1, cp1, cp2, v2]: [number, number, number, number]) => {\n const K = v1 - 3 * cp1 + 3 * cp2 - v2;\n\n // if the polynomial is (almost) quadratic and not cubic\n /* istanbul ignore next @preserve */\n if (Math.abs(K) < CBEZIER_MINMAX_EPSILON) {\n if (v1 === v2 && v1 === cp1) {\n // no curve, point targeting same location\n return [v1, v2] as PointTuple;\n }\n\n return minmaxQ([v1, -0.5 * v1 + 1.5 * cp1, v1 - 3 * cp1 + 3 * cp2]);\n }\n\n // the reduced discriminant of the derivative\n const T = -v1 * cp2 + v1 * v2 - cp1 * cp2 - cp1 * v2 + cp1 * cp1 + cp2 * cp2;\n\n // if the polynomial is monotone in [0,1]\n if (T <= 0) {\n return [Math.min(v1, v2), Math.max(v1, v2)] as PointTuple;\n }\n const S = Math.sqrt(T);\n\n // potential extrema\n let min = Math.min(v1, v2);\n let max = Math.max(v1, v2);\n\n const L = v1 - 2 * cp1 + cp2;\n // check local extrema\n for (let R = (L + S) / K, i = 1; i <= 2; R = (L - S) / K, i++) {\n // istanbul ignore next @preserve\n if (R > 0 && R < 1) {\n // if the extrema is for R in [0,1]\n const Q = v1 * (1 - R) * (1 - R) * (1 - R) +\n cp1 * 3 * (1 - R) * (1 - R) * R + cp2 * 3 * (1 - R) * R * R +\n v2 * R * R * R;\n if (Q < min) {\n min = Q;\n }\n if (Q > max) {\n max = Q;\n }\n }\n }\n\n return [min, max] as PointTuple;\n};\n\nexport {\n bezierLength,\n calculateBezier,\n CBEZIER_MINMAX_EPSILON,\n computeBezier,\n Cvalues,\n deriveBezier,\n getBezierLength,\n minmaxC,\n minmaxQ,\n Tvalues,\n};\n","import { getBezierLength, minmaxC } from \"./bezier\";\nimport { type CubicCoordinates } from \"../types\";\n\n/**\n * Returns a point at a given length of a CubicBezier segment.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param t a [0-1] ratio\n * @returns the point at cubic-bezier segment length\n */\nconst getPointAtCubicSegmentLength = (\n [x1, y1, c1x, c1y, c2x, c2y, x2, y2]: CubicCoordinates,\n t: number,\n) => {\n const t1 = 1 - t;\n return {\n x: t1 ** 3 * x1 + 3 * t1 ** 2 * t * c1x + 3 * t1 * t ** 2 * c2x +\n t ** 3 * x2,\n y: t1 ** 3 * y1 + 3 * t1 ** 2 * t * c1y + 3 * t1 * t ** 2 * c2y +\n t ** 3 * y2,\n };\n};\n\n/**\n * Returns the length of a CubicBezier segment.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the CubicBezier segment length\n */\nconst getCubicLength = (\n x1: number,\n y1: number,\n c1x: number,\n c1y: number,\n c2x: number,\n c2y: number,\n x2: number,\n y2: number,\n) => {\n return getBezierLength([x1, y1, c1x, c1y, c2x, c2y, x2, y2]);\n};\n\n/**\n * Returns the point along a CubicBezier segment at a given distance.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance the distance to look at\n * @returns the point at CubicBezier length\n */\nconst getPointAtCubicLength = (\n x1: number,\n y1: number,\n c1x: number,\n c1y: number,\n c2x: number,\n c2y: number,\n x2: number,\n y2: number,\n distance?: number,\n) => {\n const distanceIsNumber = typeof distance === \"number\";\n let point = { x: x1, y: y1 };\n /* istanbul ignore else @preserve */\n if (distanceIsNumber) {\n const currentLength = getBezierLength([x1, y1, c1x, c1y, c2x, c2y, x2, y2]);\n if (distance <= 0) {\n // first point already defined\n } else if (distance >= currentLength) {\n point = { x: x2, y: y2 };\n } else {\n point = getPointAtCubicSegmentLength(\n [x1, y1, c1x, c1y, c2x, c2y, x2, y2],\n distance / currentLength,\n );\n }\n }\n return point;\n};\n\n/**\n * Returns the boundig box of a CubicBezier segment in the following format:\n * [MIN_X, MIN_Y, MAX_X, MAX_Y]\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the extrema of the CubicBezier segment\n */\nconst getCubicBBox = (\n x1: number,\n y1: number,\n c1x: number,\n c1y: number,\n c2x: number,\n c2y: number,\n x2: number,\n y2: number,\n) => {\n const cxMinMax = minmaxC([x1, c1x, c2x, x2]);\n const cyMinMax = minmaxC([y1, c1y, c2y, y2]);\n\n return [cxMinMax[0], cyMinMax[0], cxMinMax[1], cyMinMax[1]] as [\n number,\n number,\n number,\n number,\n ];\n};\n\nexport {\n getCubicBBox,\n getCubicLength,\n getPointAtCubicLength,\n getPointAtCubicSegmentLength,\n};\n","import { getBezierLength, minmaxQ } from \"./bezier\";\nimport { type QuadCoordinates } from \"../types\";\n\n/**\n * Returns the {x,y} coordinates of a point at a\n * given length of a quadratic-bezier segment.\n *\n * @see https://github.com/substack/point-at-length\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param cx the control point X\n * @param cy the control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param t a [0-1] ratio\n * @returns the requested {x,y} coordinates\n */\nconst getPointAtQuadSegmentLength = (\n [x1, y1, cx, cy, x2, y2]: QuadCoordinates,\n t: number,\n) => {\n const t1 = 1 - t;\n return {\n x: t1 ** 2 * x1 + 2 * t1 * t * cx + t ** 2 * x2,\n y: t1 ** 2 * y1 + 2 * t1 * t * cy + t ** 2 * y2,\n };\n};\n\n/**\n * Returns the length of a QuadraticBezier segment.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param cx the control point X\n * @param cy the control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the QuadraticBezier segment length\n */\nconst getQuadLength = (\n x1: number,\n y1: number,\n cx: number,\n cy: number,\n x2: number,\n y2: number,\n) => {\n return getBezierLength([x1, y1, cx, cy, x2, y2]);\n};\n\n/**\n * Returns the point along a QuadraticBezier segment at a given distance.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param cx the control point X\n * @param cy the control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance the distance to look at\n * @returns the point at QuadraticBezier length\n */\nconst getPointAtQuadLength = (\n x1: number,\n y1: number,\n cx: number,\n cy: number,\n x2: number,\n y2: number,\n distance?: number,\n) => {\n const distanceIsNumber = typeof distance === \"number\";\n let point = { x: x1, y: y1 };\n\n /* istanbul ignore else @preserve */\n if (distanceIsNumber) {\n const currentLength = getBezierLength([x1, y1, cx, cy, x2, y2]);\n if (distance <= 0) {\n // first point already defined\n } else if (distance >= currentLength) {\n point = { x: x2, y: y2 };\n } else {\n point = getPointAtQuadSegmentLength(\n [x1, y1, cx, cy, x2, y2],\n distance / currentLength,\n );\n }\n }\n return point;\n};\n\n/**\n * Returns the boundig box of a QuadraticBezier segment in the following format:\n * [MIN_X, MIN_Y, MAX_X, MAX_Y]\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param cx the control point X\n * @param cy the control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the extrema of the QuadraticBezier segment\n */\nconst getQuadBBox = (\n x1: number,\n y1: number,\n cx: number,\n cy: number,\n x2: number,\n y2: number,\n) => {\n const cxMinMax = minmaxQ([x1, cx, x2]);\n const cyMinMax = minmaxQ([y1, cy, y2]);\n return [cxMinMax[0], cyMinMax[0], cxMinMax[1], cyMinMax[1]] as [\n number,\n number,\n number,\n number,\n ];\n};\n\nexport {\n getPointAtQuadLength,\n getPointAtQuadSegmentLength,\n getQuadBBox,\n getQuadLength,\n};\n","import distanceSquareRoot from \"./distanceSquareRoot\";\nimport { type PointTuple } from \"../types\";\n\n/**\n * d3-polygon-area\n * https://github.com/d3/d3-polygon\n *\n * Returns the area of a polygon.\n *\n * @param polygon an array of coordinates\n * @returns the polygon area\n */\nconst polygonArea = (polygon: PointTuple[]) => {\n const n = polygon.length;\n let i = -1;\n let a: PointTuple;\n let b = polygon[n - 1];\n let area = 0;\n\n /* eslint-disable-next-line */\n while (++i < n) {\n a = b;\n b = polygon[i];\n area += a[1] * b[0] - a[0] * b[1];\n }\n\n return area / 2;\n};\n\n/**\n * d3-polygon-length\n * https://github.com/d3/d3-polygon\n *\n * Returns the perimeter of a polygon.\n *\n * @param polygon an array of coordinates\n * @returns the polygon length\n */\nconst polygonLength = (polygon: PointTuple[]) => {\n return polygon.reduce((length, point, i) => {\n if (i) {\n return length + distanceSquareRoot(polygon[i - 1], point);\n }\n return 0;\n }, 0);\n};\n\nexport { polygonArea, polygonLength };\n","/** Segment params length */\nconst paramsCount = {\n a: 7,\n c: 6,\n h: 1,\n l: 2,\n m: 2,\n r: 4,\n q: 4,\n s: 4,\n t: 2,\n v: 1,\n z: 0,\n};\n\nexport default paramsCount;\n","import paramsCount from \"./paramsCount\";\nimport PathParser from \"./pathParser\";\nimport type { PathCommand, PathSegment, RelativeCommand } from \"../types\";\n\n/**\n * Breaks the parsing of a pathString once a segment is finalized.\n *\n * @param path the `PathParser` instance\n */\nconst finalizeSegment = (path: PathParser) => {\n let pathCommand = path.pathValue[path.segmentStart] as PathCommand;\n let relativeCommand = pathCommand.toLowerCase() as RelativeCommand;\n const { data } = path;\n\n while (data.length >= paramsCount[relativeCommand]) {\n // overloaded `moveTo`\n // https://github.com/rveciana/svg-path-properties/blob/master/src/parse.ts\n if (relativeCommand === \"m\" && data.length > 2) {\n path.segments.push(\n [pathCommand as PathCommand | number].concat(\n data.splice(0, 2) as number[],\n ) as PathSegment,\n );\n relativeCommand = \"l\";\n pathCommand = pathCommand === \"m\" ? \"l\" : \"L\";\n } else {\n path.segments.push(\n [pathCommand as PathCommand | number].concat(\n data.splice(0, paramsCount[relativeCommand]) as number[],\n ) as PathSegment,\n );\n }\n\n if (!paramsCount[relativeCommand]) {\n break;\n }\n }\n};\nexport default finalizeSegment;\n","const error = \"SVGPathCommander Error\";\nexport default error;\n","import error from \"./error\";\nimport type PathParser from \"./pathParser\";\n\n/**\n * Validates an A (arc-to) specific path command value.\n * Usually a `large-arc-flag` or `sweep-flag`.\n *\n * @param path the `PathParser` instance\n */\nconst scanFlag = (path: PathParser) => {\n const { index, pathValue } = path;\n const code = pathValue.charCodeAt(index);\n\n if (code === 0x30 /* 0 */) {\n path.param = 0;\n path.index += 1;\n return;\n }\n\n if (code === 0x31 /* 1 */) {\n path.param = 1;\n path.index += 1;\n return;\n }\n\n path.err = `${error}: invalid Arc flag \"${\n pathValue[index]\n }\", expecting 0 or 1 at index ${index}`;\n};\n\nexport default scanFlag;\n","import { DigitNumber } from \"../types\";\n\n/**\n * Checks if a character is a digit.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isDigit = (code: number): code is DigitNumber => {\n return code >= 48 && code <= 57; // 0..9\n};\nexport default isDigit;\n","const invalidPathValue = \"Invalid path value\";\nexport default invalidPathValue;\n","import isDigit from \"./isDigit\";\nimport invalidPathValue from \"./invalidPathValue\";\nimport error from \"./error\";\nimport type PathParser from \"./pathParser\";\n\n/**\n * Validates every character of the path string,\n * every path command, negative numbers or floating point numbers.\n *\n * @param path the `PathParser` instance\n */\nconst scanParam = (path: PathParser) => {\n const { max, pathValue, index: start } = path;\n let index = start;\n let zeroFirst = false;\n let hasCeiling = false;\n let hasDecimal = false;\n let hasDot = false;\n let ch;\n\n if (index >= max) {\n path.err =\n `${error}: ${invalidPathValue} at index ${index}, \"pathValue\" is missing param`;\n return;\n }\n ch = pathValue.charCodeAt(index);\n\n if (ch === 0x2b /* + */ || ch === 0x2d /* - */) {\n index += 1;\n // ch = (index < max) ? pathValue.charCodeAt(index) : 0;\n ch = pathValue.charCodeAt(index);\n }\n\n // This logic is shamelessly borrowed from Esprima\n // https://github.com/ariya/esprimas\n if (!isDigit(ch) && ch !== 0x2e /* . */) {\n // path.err = 'SvgPath: param should start with 0..9 or `.` (at pos ' + index + ')';\n path.err = `${error}: ${invalidPathValue} at index ${index}, \"${\n pathValue[index]\n }\" is not a number`;\n return;\n }\n\n if (ch !== 0x2e /* . */) {\n zeroFirst = ch === 0x30 /* 0 */;\n index += 1;\n\n ch = pathValue.charCodeAt(index);\n\n if (zeroFirst && index < max) {\n // decimal number starts with '0' such as '09' is illegal.\n if (ch && isDigit(ch)) {\n // path.err = 'SvgPath: numbers started with `0` such as `09`\n // are illegal (at pos ' + start + ')';\n path.err = `${error}: ${invalidPathValue} at index ${start}, \"${\n pathValue[start]\n }\" illegal number`;\n return;\n }\n }\n\n while (index < max && isDigit(pathValue.charCodeAt(index))) {\n index += 1;\n hasCeiling = true;\n }\n\n ch = pathValue.charCodeAt(index);\n }\n\n if (ch === 0x2e /* . */) {\n hasDot = true;\n index += 1;\n while (isDigit(pathValue.charCodeAt(index))) {\n index += 1;\n hasDecimal = true;\n }\n\n ch = pathValue.charCodeAt(index);\n }\n\n if (ch === 0x65 /* e */ || ch === 0x45 /* E */) {\n if (hasDot && !hasCeiling && !hasDecimal) {\n path.err = `${error}: ${invalidPathValue} at index ${index}, \"${\n pathValue[index]\n }\" invalid float exponent`;\n return;\n }\n\n index += 1;\n\n ch = pathValue.charCodeAt(index);\n\n if (ch === 0x2b /* + */ || ch === 0x2d /* - */) {\n index += 1;\n }\n if (index < max && isDigit(pathValue.charCodeAt(index))) {\n while (index < max && isDigit(pathValue.charCodeAt(index))) {\n index += 1;\n }\n } else {\n path.err = `${error}: ${invalidPathValue} at index ${index}, \"${\n pathValue[index]\n }\" invalid integer exponent`;\n return;\n }\n }\n\n path.index = index;\n path.param = +path.pathValue.slice(start, index);\n};\nexport default scanParam;\n","import type { SpaceNumber } from \"../types\";\n\n/**\n * Checks if the character is a space.\n *\n * @param ch the character to check\n * @returns check result\n */\n\nconst isSpace = (ch: number): ch is SpaceNumber => {\n const allSpaces = [\n // Special spaces\n 0x1680,\n 0x180e,\n 0x2000,\n 0x2001,\n 0x2002,\n 0x2003,\n 0x2004,\n 0x2005,\n 0x2006,\n 0x2007,\n 0x2008,\n 0x2009,\n 0x200a,\n 0x202f,\n 0x205f,\n 0x3000,\n 0xfeff,\n // Line terminators\n 0x0a,\n 0x0d,\n 0x2028,\n 0x2029,\n // White spaces\n 0x20,\n 0x09,\n 0x0b,\n 0x0c,\n 0xa0,\n ];\n\n return allSpaces.includes(ch);\n};\nexport default isSpace;\n","import isSpace from \"./isSpace\";\nimport type PathParser from \"./pathParser\";\n\n/**\n * Points the parser to the next character in the\n * path string every time it encounters any kind of\n * space character.\n *\n * @param path the `PathParser` instance\n */\nconst skipSpaces = (path: PathParser) => {\n const { pathValue, max } = path;\n while (path.index < max && isSpace(pathValue.charCodeAt(path.index))) {\n path.index += 1;\n }\n};\nexport default skipSpaces;\n","import type { PathCommandNumber } from \"../types\";\n\n/**\n * Checks if the character is a path command.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isPathCommand = (code: number): code is PathCommandNumber => {\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy\n switch (code | 0x20) {\n case 0x6d /* m */:\n case 0x7a /* z */:\n case 0x6c /* l */:\n case 0x68 /* h */:\n case 0x76 /* v */:\n case 0x63 /* c */:\n case 0x73 /* s */:\n case 0x71 /* q */:\n case 0x74 /* t */:\n case 0x61 /* a */:\n // case 0x72/* r */:\n return true;\n default:\n return false;\n }\n};\nexport default isPathCommand;\n","import isDigit from \"./isDigit\";\nimport type { DigitNumber } from \"../types\";\n\n/**\n * Checks if the character is or belongs to a number.\n * [0-9]|+|-|.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isDigitStart = (\n code: number,\n): code is DigitNumber | 0x2b | 0x2d | 0x2e => {\n return isDigit(code) /* 0..9 */ || code === 0x2b /* + */ ||\n code === 0x2d /* - */ || code === 0x2e; /* . */\n};\nexport default isDigitStart;\n","/**\n * Checks if the character is an A (arc-to) path command.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isArcCommand = (code: number): code is 0x61 => {\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy\n return (code | 0x20) === 0x61;\n};\nexport default isArcCommand;\n","/**\n * Checks if the character is a MoveTo command.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isMoveCommand = (code: number): code is 0x6d | 0x4d => {\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy\n switch (code | 0x20) {\n case 0x6d /* m */:\n case 0x4d /* M */:\n return true;\n default:\n return false;\n }\n};\nexport default isMoveCommand;\n","import finalizeSegment from \"./finalizeSegment\";\nimport paramCounts from \"./paramsCount\";\nimport scanFlag from \"./scanFlag\";\nimport scanParam from \"./scanParam\";\nimport skipSpaces from \"./skipSpaces\";\nimport isPathCommand from \"./isPathCommand\";\nimport isDigitStart from \"./isDigitStart\";\nimport isArcCommand from \"./isArcCommand\";\nimport isMoveCommand from \"./isMoveCommand\";\nimport invalidPathValue from \"./invalidPathValue\";\nimport error from \"./error\";\n\nimport type PathParser from \"./pathParser\";\nimport type { PathSegment, RelativeCommand } from \"../types\";\n\n/**\n * Scans every character in the path string to determine\n * where a segment starts and where it ends.\n *\n * @param path the `PathParser` instance\n */\nconst scanSegment = (path: PathParser) => {\n const { max, pathValue, index, segments } = path;\n const cmdCode = pathValue.charCodeAt(index);\n const reqParams =\n paramCounts[pathValue[index].toLowerCase() as RelativeCommand];\n\n path.segmentStart = index;\n\n // segments always start with a path command\n if (!isPathCommand(cmdCode)) {\n path.err = `${error}: ${invalidPathValue} \"${\n pathValue[index]\n }\" is not a path command at index ${index}`;\n return;\n }\n\n // after a Z segment, we only expect a MoveTo path command\n const lastSegment = segments[segments.length - 1] as PathSegment | undefined;\n if (\n !isMoveCommand(cmdCode) && lastSegment?.[0]?.toLocaleLowerCase() === \"z\"\n ) {\n path.err = `${error}: ${invalidPathValue} \"${\n pathValue[index]\n }\" is not a MoveTo path command at index ${index}`;\n return;\n }\n\n path.index += 1;\n skipSpaces(path);\n\n path.data = [];\n\n if (!reqParams) {\n // Z\n finalizeSegment(path);\n return;\n }\n\n for (;;) {\n for (let i = reqParams; i > 0; i -= 1) {\n if (isArcCommand(cmdCode) && (i === 3 || i === 4)) scanFlag(path);\n else scanParam(path);\n\n if (path.err.length) {\n return;\n }\n path.data.push(path.param);\n\n skipSpaces(path);\n\n // after ',' param is mandatory\n if (\n path.index < max && pathValue.charCodeAt(path.index) === 0x2c /* , */\n ) {\n path.index += 1;\n skipSpaces(path);\n }\n }\n\n if (path.index >= path.max) {\n break;\n }\n\n // Stop on next segment\n if (!isDigitStart(pathValue.charCodeAt(path.index))) {\n break;\n }\n }\n\n finalizeSegment(path);\n};\nexport default scanSegment;\n","import type { PathArray, PathSegment } from \"../types\";\n\n/**\n * The `PathParser` is used by the `parsePathString` static method\n * to generate a `pathArray`.\n *\n * @param pathString\n */\nexport default class PathParser {\n declare segments: PathArray | PathSegment[];\n declare pathValue: string;\n declare max: number;\n declare index: number;\n declare param: number;\n declare segmentStart: number;\n declare data: (string | number)[];\n declare err: string;\n\n constructor(pathString: string) {\n this.segments = [];\n this.pathValue = pathString;\n this.max = pathString.length;\n this.index = 0;\n this.param = 0.0;\n this.segmentStart = 0;\n this.data = [];\n this.err = \"\";\n }\n}\n","import scanSegment from \"./scanSegment\";\nimport skipSpaces from \"./skipSpaces\";\nimport PathParser from \"./pathParser\";\nimport type { PathArray } from \"../types\";\n\n/**\n * Parses a path string value and returns an array\n * of segments we like to call `pathArray`.\n *\n * @param pathInput the string to be parsed\n * @returns the resulted `pathArray` or error string\n */\nconst parsePathString = (pathInput: string | T) => {\n if (typeof pathInput !== \"string\") {\n return pathInput.slice(0) as typeof pathInput;\n }\n\n const path = new PathParser(pathInput);\n\n skipSpaces(path);\n\n while (path.index < path.max && !path.err.length) {\n scanSegment(path);\n }\n\n // handle valid paths first\n // handle errors second\n if (!path.err.length) {\n if (path.segments.length) {\n /**\n * force absolute first M\n * getPathBBox calculation requires first segment to be absolute\n * @see https://github.com/thednp/svg-path-commander/pull/49\n */\n path.segments[0][0] = \"M\";\n }\n } else {\n throw TypeError(path.err);\n }\n\n return path.segments as PathArray;\n};\n\nexport default parsePathString;\n","import type {\n AbsoluteCommand,\n AbsoluteSegment,\n ASegment,\n CSegment,\n HSegment,\n LSegment,\n MSegment,\n PathSegment,\n QSegment,\n SSegment,\n TSegment,\n VSegment,\n} from \"../types\";\n\n/**\n * Returns an absolute segment of a `PathArray` object.\n *\n * @param segment the segment object\n * @param index the segment index\n * @param lastX the last known X value\n * @param lastY the last known Y value\n * @returns the absolute segment\n */\nconst absolutizeSegment = (\n segment: PathSegment,\n index: number,\n lastX: number,\n lastY: number,\n) => {\n const [pathCommand] = segment;\n const absCommand = pathCommand.toUpperCase() as AbsoluteCommand;\n const isAbsolute = absCommand === pathCommand;\n\n /* istanbul ignore else @preserve */\n if (index === 0 || isAbsolute) return segment as MSegment | AbsoluteSegment;\n // const values = segment.slice(1) as number[];\n if (absCommand === \"A\") {\n return [\n absCommand,\n segment[1],\n segment[2],\n segment[3],\n segment[4],\n segment[5],\n (segment as ASegment)[6] + lastX,\n (segment as ASegment)[7] + lastY,\n ] as ASegment;\n } else if (absCommand === \"V\") {\n return [absCommand, (segment as VSegment)[1] + lastY] as VSegment;\n } else if (absCommand === \"H\") {\n return [absCommand, (segment as HSegment)[1] + lastX] as HSegment;\n } else if (absCommand === \"L\") {\n return [\n absCommand,\n (segment as LSegment)[1] + lastX,\n (segment as LSegment)[2] + lastY,\n ] as LSegment;\n } else {\n // use brakets for `eslint: no-case-declaration`\n // https://stackoverflow.com/a/50753272/803358\n const absValues = [] as number[];\n const seglen = segment.length;\n for (let j = 1; j < seglen; j += 1) {\n absValues.push((segment[j] as number) + (j % 2 ? lastX : lastY));\n }\n // for c, s, q, t\n return [absCommand as typeof absCommand | number].concat(absValues) as\n | MSegment\n | QSegment\n | TSegment\n | SSegment\n | CSegment;\n }\n};\nexport default absolutizeSegment;\n","// import paramsParser from '../parser/paramsParser';\nimport type {\n AbsoluteCommand,\n IteratorCallback,\n PathArray,\n PathCommand,\n PathSegment,\n} from \"../types\";\n\nconst iterate = (\n path: PathArray,\n iterator: IteratorCallback,\n) => {\n let pathLen = path.length;\n let segment: PathSegment;\n let pathCommand = \"M\" as PathCommand;\n let absCommand = \"M\" as AbsoluteCommand;\n let isRelative = false;\n let x = 0;\n let y = 0;\n let mx = 0;\n let my = 0;\n let segLen = 0;\n\n for (let i = 0; i < pathLen; i += 1) {\n segment = path[i];\n [pathCommand] = segment;\n segLen = segment.length;\n absCommand = pathCommand.toUpperCase() as AbsoluteCommand;\n isRelative = absCommand !== pathCommand;\n\n const iteratorResult = iterator(segment, i, x, y);\n // some methods like getPointAtLength would like to break\n // when task is complete\n if (iteratorResult === false) {\n break;\n }\n\n // segment = path[i];\n if (absCommand === \"Z\") {\n x = mx;\n y = my;\n } else if (absCommand === \"H\") {\n x = (segment[1] as number) + (isRelative ? x : 0);\n } else if (absCommand === \"V\") {\n y = (segment[1] as number) + (isRelative ? y : 0);\n } else {\n x = (segment[segLen - 2] as number) + (isRelative ? x : 0);\n y = (segment[segLen - 1] as number) + (isRelative ? y : 0);\n\n if (absCommand === \"M\") {\n mx = x;\n my = y;\n }\n }\n\n if (iteratorResult) {\n path[i] = iteratorResult;\n if (iteratorResult[0] === \"C\") {\n pathLen = path.length;\n }\n }\n }\n return path as T;\n};\n\nexport default iterate;\n","import parsePathString from \"../parser/parsePathString\";\nimport absolutizeSegment from \"../process/absolutizeSegment\";\nimport type { AbsoluteArray, PathArray } from \"../types\";\nimport iterate from \"../process/iterate\";\n\n/**\n * Parses a path string value or object and returns an array\n * of segments, all converted to absolute values.\n *\n * @param pathInput the path string | object\n * @returns the resulted `pathArray` with absolute values\n */\nconst pathToAbsolute = (pathInput: string | PathArray) => {\n const path = parsePathString(pathInput);\n\n return iterate(path, absolutizeSegment);\n};\nexport default pathToAbsolute;\n","import type {\n aSegment,\n cSegment,\n hSegment,\n lSegment,\n MSegment,\n PathSegment,\n qSegment,\n RelativeCommand,\n RelativeSegment,\n sSegment,\n tSegment,\n vSegment,\n} from \"../types\";\n\n/**\n * Returns a relative segment of a `PathArray` object.\n *\n * @param segment the segment object\n * @param index the segment index\n * @param lastX the last known X value\n * @param lastY the last known Y value\n * @returns the relative segment\n */\nconst relativizeSegment = (\n segment: PathSegment,\n index: number,\n lastX: number,\n lastY: number,\n) => {\n const [pathCommand] = segment;\n const relCommand = pathCommand.toLowerCase() as RelativeCommand;\n const isRelative = pathCommand === relCommand;\n\n /* istanbul ignore else @preserve */\n if (index === 0 || isRelative) return segment as MSegment | RelativeSegment;\n\n if (relCommand === \"a\") {\n return [\n relCommand,\n segment[1],\n segment[2],\n segment[3],\n segment[4],\n segment[5],\n (segment as aSegment)[6] - lastX,\n (segment as aSegment)[7] - lastY,\n ] as aSegment;\n } else if (relCommand === \"v\") {\n return [relCommand, (segment as vSegment)[1] - lastY] as vSegment;\n } else if (relCommand === \"h\") {\n return [relCommand, (segment as hSegment)[1] - lastX] as hSegment;\n } else if (relCommand === \"l\") {\n return [\n relCommand,\n (segment as lSegment)[1] - lastX,\n (segment as lSegment)[2] - lastY,\n ] as lSegment;\n } else {\n // use brakets for `eslint: no-case-declaration`\n // https://stackoverflow.com/a/50753272/803358\n const relValues = [] as number[];\n const seglen = segment.length;\n for (let j = 1; j < seglen; j += 1) {\n relValues.push((segment[j] as number) - (j % 2 ? lastX : lastY));\n }\n // for c, s, q, t\n return [relCommand as RelativeCommand | number].concat(relValues) as\n | qSegment\n | tSegment\n | sSegment\n | cSegment;\n }\n};\n\nexport default relativizeSegment;\n","import type { PathArray, RelativeArray } from \"../types\";\nimport parsePathString from \"../parser/parsePathString\";\nimport iterate from \"../process/iterate\";\nimport relativizeSegment from \"../process/relativizeSegment\";\n\n/**\n * Parses a path string value or object and returns an array\n * of segments, all converted to relative values.\n *\n * @param pathInput the path string | object\n * @returns the resulted `pathArray` with relative values\n */\nconst pathToRelative = (pathInput: string | PathArray): RelativeArray => {\n const path = parsePathString(pathInput);\n\n return iterate(path, relativizeSegment);\n};\nexport default pathToRelative;\n","/**\n * Returns an {x,y} vector rotated by a given\n * angle in radian.\n *\n * @param x the initial vector x\n * @param y the initial vector y\n * @param rad the radian vector angle\n * @returns the rotated vector\n */\nconst rotateVector = (\n x: number,\n y: number,\n rad: number,\n): { x: number; y: number } => {\n const { sin, cos } = Math;\n const X = x * cos(rad) - y * sin(rad);\n const Y = x * sin(rad) + y * cos(rad);\n return { x: X, y: Y };\n};\n\nexport default rotateVector;\n","import rotateVector from \"../math/rotateVector\";\n\n/**\n * Converts A (arc-to) segments to C (cubic-bezier-to).\n *\n * For more information of where this math came from visit:\n * http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes\n *\n * @param X1 the starting x position\n * @param Y1 the starting y position\n * @param RX x-radius of the arc\n * @param RY y-radius of the arc\n * @param angle x-axis-rotation of the arc\n * @param LAF large-arc-flag of the arc\n * @param SF sweep-flag of the arc\n * @param X2 the ending x position\n * @param Y2 the ending y position\n * @param recursive the parameters needed to split arc into 2 segments\n * @return the resulting cubic-bezier segment(s)\n */\nconst arcToCubic = (\n X1: number,\n Y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n X2: number,\n Y2: number,\n recursive?: [number, number, number, number],\n): number[] => {\n let x1 = X1;\n let y1 = Y1;\n let rx = RX;\n let ry = RY;\n let x2 = X2;\n let y2 = Y2;\n // for more information of where this Math came from visit:\n // http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes\n const d120 = (Math.PI * 120) / 180;\n\n const rad = (Math.PI / 180) * (+angle || 0);\n let res = [] as number[];\n let xy;\n let f1;\n let f2;\n let cx;\n let cy;\n\n if (!recursive) {\n xy = rotateVector(x1, y1, -rad);\n x1 = xy.x;\n y1 = xy.y;\n xy = rotateVector(x2, y2, -rad);\n x2 = xy.x;\n y2 = xy.y;\n\n const x = (x1 - x2) / 2;\n const y = (y1 - y2) / 2;\n let h = (x * x) / (rx * rx) + (y * y) / (ry * ry);\n if (h > 1) {\n h = Math.sqrt(h);\n rx *= h;\n ry *= h;\n }\n const rx2 = rx * rx;\n const ry2 = ry * ry;\n\n const k = (LAF === SF ? -1 : 1) *\n Math.sqrt(\n Math.abs(\n (rx2 * ry2 - rx2 * y * y - ry2 * x * x) / (rx2 * y * y + ry2 * x * x),\n ),\n );\n\n cx = (k * rx * y) / ry + (x1 + x2) / 2;\n cy = (k * -ry * x) / rx + (y1 + y2) / 2;\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy no-bitwise\n f1 = Math.asin(((((y1 - cy) / ry) * 10 ** 9) >> 0) / 10 ** 9);\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy no-bitwise\n f2 = Math.asin(((((y2 - cy) / ry) * 10 ** 9) >> 0) / 10 ** 9);\n\n f1 = x1 < cx ? Math.PI - f1 : f1;\n f2 = x2 < cx ? Math.PI - f2 : f2;\n if (f1 < 0) f1 = Math.PI * 2 + f1;\n if (f2 < 0) f2 = Math.PI * 2 + f2;\n if (SF && f1 > f2) {\n f1 -= Math.PI * 2;\n }\n if (!SF && f2 > f1) {\n f2 -= Math.PI * 2;\n }\n } else {\n [f1, f2, cx, cy] = recursive;\n }\n let df = f2 - f1;\n if (Math.abs(df) > d120) {\n const f2old = f2;\n const x2old = x2;\n const y2old = y2;\n f2 = f1 + d120 * (SF && f2 > f1 ? 1 : -1);\n x2 = cx + rx * Math.cos(f2);\n y2 = cy + ry * Math.sin(f2);\n res = arcToCubic(x2, y2, rx, ry, angle, 0, SF, x2old, y2old, [\n f2,\n f2old,\n cx,\n cy,\n ]);\n }\n df = f2 - f1;\n const c1 = Math.cos(f1);\n const s1 = Math.sin(f1);\n const c2 = Math.cos(f2);\n const s2 = Math.sin(f2);\n const t = Math.tan(df / 4);\n const hx = (4 / 3) * rx * t;\n const hy = (4 / 3) * ry * t;\n const m1 = [x1, y1];\n const m2 = [x1 + hx * s1, y1 - hy * c1];\n const m3 = [x2 + hx * s2, y2 - hy * c2];\n const m4 = [x2, y2];\n m2[0] = 2 * m1[0] - m2[0];\n m2[1] = 2 * m1[1] - m2[1];\n if (recursive) {\n return [m2[0], m2[1], m3[0], m3[1], m4[0], m4[1]].concat(res);\n }\n res = [m2[0], m2[1], m3[0], m3[1], m4[0], m4[1]].concat(res);\n const newres = [];\n for (let i = 0, ii = res.length; i < ii; i += 1) {\n newres[i] = i % 2\n ? rotateVector(res[i - 1], res[i], rad).y\n : rotateVector(res[i], res[i + 1], rad).x;\n }\n return newres;\n};\nexport default arcToCubic;\n","/**\n * Converts a Q (quadratic-bezier) segment to C (cubic-bezier).\n *\n * @param x1 curve start x\n * @param y1 curve start y\n * @param qx control point x\n * @param qy control point y\n * @param x2 curve end x\n * @param y2 curve end y\n * @returns the cubic-bezier segment\n */\nconst quadToCubic = (\n x1: number,\n y1: number,\n qx: number,\n qy: number,\n x2: number,\n y2: number,\n): [number, number, number, number, number, number] => {\n const r13 = 1 / 3;\n const r23 = 2 / 3;\n return [\n r13 * x1 + r23 * qx, // cpx1\n r13 * y1 + r23 * qy, // cpy1\n r13 * x2 + r23 * qx, // cpx2\n r13 * y2 + r23 * qy, // cpy2\n x2,\n y2, // x,y\n ];\n};\nexport default quadToCubic;\n","import midPoint from \"../math/midPoint\";\n\n/**\n * Converts an L (line-to) segment to C (cubic-bezier).\n *\n * @param x1 line start x\n * @param y1 line start y\n * @param x2 line end x\n * @param y2 line end y\n * @returns the cubic-bezier segment\n */\nconst lineToCubic = (x1: number, y1: number, x2: number, y2: number) => {\n const c1 = midPoint([x1, y1], [x2, y2], 1.0 / 3.0);\n const c2 = midPoint([x1, y1], [x2, y2], 2.0 / 3.0);\n return [c1[0], c1[1], c2[0], c2[1], x2, y2];\n};\nexport default lineToCubic;\n","import arcToCubic from \"./arcToCubic\";\nimport quadToCubic from \"./quadToCubic\";\nimport lineToCubic from \"./lineToCubic\";\nimport type { CSegment, MSegment, PathSegment } from \"../types\";\nimport type { ParserParams } from \"../interface\";\n\n/**\n * Converts any segment to C (cubic-bezier).\n *\n * @param segment the source segment\n * @param params the source segment parameters\n * @returns the cubic-bezier segment\n */\nconst segmentToCubic = (segment: PathSegment, params: ParserParams) => {\n const [pathCommand] = segment;\n const values = segment.slice(1).map(Number);\n const [x, y] = values;\n // let args;\n const { x1: px1, y1: py1, x: px, y: py } = params;\n\n if (!\"TQ\".includes(pathCommand)) {\n params.qx = null;\n params.qy = null;\n }\n\n if (pathCommand === \"M\") {\n params.x = x;\n params.y = y;\n return segment;\n } else if (pathCommand === \"A\") {\n return [\"C\" as string | number].concat(\n arcToCubic(\n px1,\n py1,\n values[0],\n values[1],\n values[2],\n values[3],\n values[4],\n values[5],\n values[6],\n ),\n ) as CSegment;\n } else if (pathCommand === \"Q\") {\n params.qx = x;\n params.qy = y;\n return [\"C\" as string | number].concat(\n quadToCubic(px1, py1, values[0], values[1], values[2], values[3]),\n ) as CSegment;\n } else if (pathCommand === \"L\") {\n return [\"C\" as string | number].concat(\n lineToCubic(px1, py1, x, y),\n ) as CSegment;\n } else if (pathCommand === \"Z\") {\n return [\"C\" as string | number].concat(\n lineToCubic(px1, py1, px, py),\n ) as CSegment;\n }\n\n return segment as MSegment | CSegment;\n};\nexport default segmentToCubic;\n","import type { ParserParams } from \"../interface\";\nimport type {\n ASegment,\n CSegment,\n HSegment,\n LSegment,\n MSegment,\n NormalSegment,\n PathCommand,\n PathSegment,\n PointTuple,\n QSegment,\n VSegment,\n} from \"../types\";\n\n/**\n * Normalizes a single segment of a `pathArray` object.\n *\n * @param segment the segment object\n * @param params the normalization parameters\n * @returns the normalized segment\n */\nconst normalizeSegment = (segment: PathSegment, params: ParserParams) => {\n const [pathCommand] = segment;\n const absCommand = pathCommand.toUpperCase();\n const isRelative = pathCommand !== absCommand;\n const { x1: px1, y1: py1, x2: px2, y2: py2, x, y } = params;\n const values = segment.slice(1) as number[];\n let absValues = values.map((n, j) => n + (isRelative ? (j % 2 ? y : x) : 0));\n\n if (!\"TQ\".includes(absCommand)) {\n // optional but good to be cautious\n params.qx = null;\n params.qy = null;\n }\n\n // istanbul ignore else @preserve\n if (absCommand === \"A\") {\n absValues = values.slice(0, -2).concat(\n values[5] + (isRelative ? x : 0),\n values[6] + (isRelative ? y : 0),\n );\n\n return [\"A\" as PathCommand | number].concat(absValues) as ASegment;\n } else if (absCommand === \"H\") {\n return [\n \"L\",\n (segment as HSegment)[1] + (isRelative ? x : 0),\n py1,\n ] as LSegment;\n } else if (absCommand === \"V\") {\n return [\n \"L\",\n px1,\n (segment as VSegment)[1] + (isRelative ? y : 0),\n ] as LSegment;\n } else if (absCommand === \"L\") {\n return [\n \"L\",\n (segment as LSegment)[1] + (isRelative ? x : 0),\n (segment as LSegment)[2] + (isRelative ? y : 0),\n ] as LSegment;\n } else if (absCommand === \"M\") {\n return [\n \"M\",\n (segment as MSegment)[1] + (isRelative ? x : 0),\n (segment as MSegment)[2] + (isRelative ? y : 0),\n ] as MSegment;\n } else if (absCommand === \"C\") {\n return [\"C\" as PathCommand | number].concat(absValues) as CSegment;\n } else if (absCommand === \"S\") {\n const x1 = px1 * 2 - px2;\n const y1 = py1 * 2 - py2;\n params.x1 = x1;\n params.y1 = y1;\n return [\"C\", x1, y1].concat(absValues) as CSegment;\n } else if (absCommand === \"T\") {\n const qx = px1 * 2 - (params.qx ? params.qx : /* istanbul ignore next */ 0);\n const qy = py1 * 2 - (params.qy ? params.qy : /* istanbul ignore next */ 0);\n params.qx = qx;\n params.qy = qy;\n return [\"Q\", qx, qy].concat(absValues) as QSegment;\n } else if (absCommand === \"Q\") {\n const [nqx, nqy] = absValues as PointTuple;\n params.qx = nqx;\n params.qy = nqy;\n return [\"Q\" as PathCommand | number].concat(absValues) as QSegment;\n } else if (absCommand === \"Z\") {\n return [\"Z\"] as NormalSegment;\n }\n\n // istanbul ignore next @preserve\n return segment as NormalSegment;\n};\nexport default normalizeSegment;\n","import type { ParserParams } from \"../interface\";\n\nconst paramsParser: ParserParams = {\n x1: 0,\n y1: 0,\n x2: 0,\n y2: 0,\n x: 0,\n y: 0,\n qx: null,\n qy: null,\n};\n\nexport default paramsParser;\n","import segmentToCubic from \"../process/segmentToCubic\";\nimport { AbsoluteCommand, CSegment, CurveArray, PathArray } from \"../types\";\nimport iterate from \"../process/iterate\";\nimport parsePathString from \"../parser/parsePathString\";\nimport normalizeSegment from \"../process/normalizeSegment\";\nimport paramsParser from \"../parser/paramsParser\";\n\n/**\n * Parses a path string value or 'pathArray' and returns a new one\n * in which all segments are converted to cubic-bezier.\n *\n * In addition, un-necessary `Z` segment is removed if previous segment\n * extends to the `M` segment.\n *\n * @param pathInput the string to be parsed or 'pathArray'\n * @returns the resulted `pathArray` converted to cubic-bezier\n */\nconst pathToCurve = (pathInput: string | PathArray): CurveArray => {\n const params = { ...paramsParser };\n const path = parsePathString(pathInput);\n\n return iterate(path, (seg, index, lastX, lastY) => {\n params.x = lastX;\n params.y = lastY;\n const normalSegment = normalizeSegment(seg, params);\n let result = segmentToCubic(normalSegment, params);\n const isLongArc = result[0] === \"C\" && result.length > 7;\n\n if (isLongArc) {\n path.splice(\n index + 1,\n 0,\n [\"C\" as AbsoluteCommand | number].concat(result.slice(7)) as CSegment,\n );\n result = result.slice(0, 7) as CSegment;\n }\n\n const seglen = result.length;\n params.x1 = +result[seglen - 2];\n params.y1 = +result[seglen - 1];\n params.x2 = +result[seglen - 4] || params.x1;\n params.y2 = +result[seglen - 3] || params.y1;\n\n return result;\n });\n};\nexport default pathToCurve;\n","import { Options } from \"../interface\";\n\n/** SVGPathCommander default options */\nconst defaultOptions: Options = {\n origin: [0, 0, 0],\n round: 4,\n};\n\nexport default defaultOptions;\n","const roundTo = (n: number, round: number) => {\n const pow = round >= 1 ? 10 ** round : 1;\n\n return round > 0 ? Math.round(n * pow) / pow : Math.round(n);\n};\n\nexport default roundTo;\n","import type { PathArray, PathSegment } from \"../types\";\nimport defaultOptions from \"../options/options\";\nimport roundTo from \"../math/roundTo\";\n\n/**\n * Returns a valid `d` attribute string value created\n * by rounding values and concatenating the `pathArray` segments.\n *\n * @param path the `pathArray` object\n * @param roundOption amount of decimals to round values to\n * @returns the concatenated path string\n */\nconst pathToString = (\n path: PathArray,\n roundOption?: number | \"off\",\n): string => {\n const pathLen = path.length;\n let { round } = defaultOptions;\n let segment = path[0] as PathSegment;\n let result = \"\";\n\n // allow for ZERO decimals\n round = roundOption === \"off\"\n ? roundOption\n : typeof roundOption === \"number\" && roundOption >= 0\n ? roundOption\n : typeof round === \"number\" && round >= 0\n ? round\n : /* istanbul ignore next @preserve */ \"off\";\n\n for (let i = 0; i < pathLen; i += 1) {\n segment = path[i];\n const [pathCommand] = segment;\n const values = segment.slice(1) as number[];\n result += pathCommand;\n if (round === \"off\") {\n result += values.join(\" \");\n } else {\n let j = 0;\n const valLen = values.length;\n while (j < valLen) {\n result += roundTo(values[j], round);\n if (j !== valLen - 1) result += \" \";\n j += 1;\n }\n }\n }\n\n return result;\n};\n\nexport default pathToString;\n","const DISTANCE_EPSILON = 0.00001;\n\nexport default DISTANCE_EPSILON;\n","import normalizeSegment from \"./normalizeSegment\";\nimport type { NormalArray, PathArray } from \"../types\";\nimport iterate from \"./iterate\";\nimport parsePathString from \"../parser/parsePathString\";\nimport paramsParser from \"../parser/paramsParser\";\n\n/**\n * Normalizes a `pathArray` object for further processing:\n * * convert segments to absolute values\n * * convert shorthand path commands to their non-shorthand notation\n *\n * @param pathInput the string to be parsed or 'pathArray'\n * @returns the normalized `pathArray`\n */\nconst normalizePath = (pathInput: string | PathArray) => {\n const path = parsePathString(pathInput);\n const params = { ...paramsParser };\n\n return iterate(path, (seg, _, lastX, lastY) => {\n params.x = lastX;\n params.y = lastY;\n const result = normalizeSegment(seg, params);\n\n const seglen = result.length;\n params.x1 = +result[seglen - 2];\n params.y1 = +result[seglen - 1];\n params.x2 = +result[seglen - 4] || params.x1;\n params.y2 = +result[seglen - 3] || params.y1;\n\n return result;\n });\n};\nexport default normalizePath;\n","import DISTANCE_EPSILON from \"./distanceEpsilon\";\nimport type { MSegment, PathArray, PointTuple } from \"../types\";\nimport iterate from \"../process/iterate\";\nimport { getLineLength, getPointAtLineLength } from \"../math/lineTools\";\nimport { getArcLength, getPointAtArcLength } from \"../math/arcTools\";\nimport { getCubicLength, getPointAtCubicLength } from \"../math/cubicTools\";\nimport { getPointAtQuadLength, getQuadLength } from \"../math/quadTools\";\nimport normalizePath from \"../process/normalizePath\";\n\n/**\n * Returns [x,y] coordinates of a point at a given length of a shape.\n *\n * @param pathInput the `pathArray` to look into\n * @param distance the length of the shape to look at\n * @returns the requested {x, y} point coordinates\n */\nconst getPointAtLength = (pathInput: string | PathArray, distance?: number) => {\n const path = normalizePath(pathInput);\n let isM = false;\n let data = [] as number[];\n let pathCommand = \"M\";\n let x = 0;\n let y = 0;\n let [mx, my] = path[0].slice(1) as PointTuple;\n const distanceIsNumber = typeof distance === \"number\";\n let point = { x: mx, y: my };\n let length = 0;\n let POINT = point;\n let totalLength = 0;\n\n if (!distanceIsNumber || distance < DISTANCE_EPSILON) return point;\n\n // for (let i = 0; i < pathLen; i += 1) {\n iterate(path, (seg, _, lastX, lastY) => {\n [pathCommand] = seg;\n isM = pathCommand === \"M\";\n data = !isM ? [lastX, lastY].concat(seg.slice(1) as number[]) : data;\n\n // this segment is always ZERO\n /* istanbul ignore else @preserve */\n if (isM) {\n // remember mx, my for Z\n [, mx, my] = seg as MSegment;\n point = { x: mx, y: my };\n length = 0;\n } else if (pathCommand === \"L\") {\n point = getPointAtLineLength(\n data[0],\n data[1],\n data[2],\n data[3],\n distance - totalLength,\n );\n length = getLineLength(data[0], data[1], data[2], data[3]);\n } else if (pathCommand === \"A\") {\n point = getPointAtArcLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n data[6],\n data[7],\n data[8],\n distance - totalLength,\n );\n length = getArcLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n data[6],\n data[7],\n data[8],\n );\n } else if (pathCommand === \"C\") {\n point = getPointAtCubicLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n data[6],\n data[7],\n distance - totalLength,\n );\n length = getCubicLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n data[6],\n data[7],\n );\n } else if (pathCommand === \"Q\") {\n point = getPointAtQuadLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n distance - totalLength,\n );\n length = getQuadLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n );\n } else if (pathCommand === \"Z\") {\n data = [lastX, lastY, mx, my];\n point = { x: mx, y: my };\n\n length = getLineLength(data[0], data[1], data[2], data[3]);\n }\n\n [x, y] = data.slice(-2);\n\n if (totalLength < distance) {\n POINT = point;\n } else {\n // totalLength >= distance\n // stop right here\n // stop iterator now!\n return false;\n }\n\n totalLength += length;\n return;\n });\n\n // native `getPointAtLength` behavior when the given distance\n // is higher than total length\n if (distance > totalLength - DISTANCE_EPSILON) {\n return { x, y };\n }\n\n return POINT;\n};\n\nexport default getPointAtLength;\n","import type { LSegment, MSegment, PathArray, PointTuple } from \"../types\";\nimport { getLineLength } from \"../math/lineTools\";\nimport { getArcLength } from \"../math/arcTools\";\nimport { getCubicLength } from \"../math/cubicTools\";\nimport { getQuadLength } from \"../math/quadTools\";\nimport iterate from \"../process/iterate\";\nimport parsePathString from \"../parser/parsePathString\";\nimport absolutizeSegment from \"../process/absolutizeSegment\";\n\n/**\n * Returns the shape total length, or the equivalent to `shape.getTotalLength()`.\n *\n * @param pathInput the target `pathArray`\n * @returns the shape total length\n */\nconst getTotalLength = (pathInput: string | PathArray) => {\n const path = parsePathString(pathInput);\n let paramX1 = 0;\n let paramY1 = 0;\n let paramX2 = 0;\n let paramY2 = 0;\n let paramQX = 0;\n let paramQY = 0;\n let pathCommand = \"M\";\n let mx = 0;\n let my = 0;\n let totalLength = 0;\n\n iterate(path, (seg, index, lastX, lastY) => {\n [pathCommand] = seg;\n const absCommand = pathCommand.toUpperCase();\n const isRelative = absCommand !== pathCommand;\n const absoluteSegment = isRelative\n ? absolutizeSegment(seg, index, lastX, lastY)\n : (seg.slice(0) as typeof seg);\n\n const normalSegment = absCommand === \"V\"\n ? ([\"L\", lastX, absoluteSegment[1]] as LSegment)\n : absCommand === \"H\"\n ? ([\"L\", absoluteSegment[1], lastY] as LSegment)\n : absoluteSegment;\n [pathCommand] = normalSegment;\n\n if (!\"TQ\".includes(absCommand)) {\n // optional but good to be cautious\n paramQX = 0;\n paramQY = 0;\n }\n\n // this segment is always ZERO\n /* istanbul ignore else @preserve */\n if (pathCommand === \"M\") {\n // remember mx, my for Z\n [, mx, my] = normalSegment as MSegment;\n } else if (pathCommand === \"L\") {\n totalLength += getLineLength(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n );\n } else if (pathCommand === \"A\") {\n totalLength += getArcLength(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n normalSegment[5] as number,\n normalSegment[6] as number,\n normalSegment[7] as number,\n );\n } else if (pathCommand === \"S\") {\n const cp1x = paramX1 * 2 - paramX2;\n const cp1y = paramY1 * 2 - paramY2;\n\n totalLength += getCubicLength(\n lastX,\n lastY,\n cp1x,\n cp1y,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n );\n } else if (pathCommand === \"C\") {\n totalLength += getCubicLength(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n normalSegment[5] as number,\n normalSegment[6] as number,\n );\n } else if (pathCommand === \"T\") {\n paramQX = paramX1 * 2 - paramQX;\n paramQY = paramY1 * 2 - paramQY;\n totalLength += getQuadLength(\n lastX,\n lastY,\n paramQX,\n paramQY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n );\n } else if (pathCommand === \"Q\") {\n paramQX = normalSegment[1] as number;\n paramQY = normalSegment[2] as number;\n totalLength += getQuadLength(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n );\n } else if (pathCommand === \"Z\") {\n totalLength += getLineLength(lastX, lastY, mx, my);\n }\n\n // update params\n [paramX1, paramY1] = pathCommand === \"Z\"\n ? [mx, my]\n : (normalSegment.slice(-2) as PointTuple);\n [paramX2, paramY2] = pathCommand === \"C\"\n ? ([normalSegment[3], normalSegment[4]] as PointTuple)\n : pathCommand === \"S\"\n ? ([normalSegment[1], normalSegment[2]] as PointTuple)\n : [paramX1, paramY1];\n });\n\n return totalLength;\n};\n\nexport default getTotalLength;\n","import type { PathArray, PathSegment } from \"../types\";\nimport type { SegmentProperties } from \"../interface\";\nimport parsePathString from \"../parser/parsePathString\";\nimport getTotalLength from \"./getTotalLength\";\n\n/**\n * Returns the segment, its index and length as well as\n * the length to that segment at a given length in a path.\n *\n * @param pathInput target `pathArray`\n * @param distance the given length\n * @returns the requested properties\n */\nconst getPropertiesAtLength = (\n pathInput: string | PathArray,\n distance?: number,\n): SegmentProperties => {\n const pathArray = parsePathString(pathInput);\n\n let pathTemp = pathArray.slice(0) as PathArray;\n let pathLength = getTotalLength(pathTemp);\n let index = pathTemp.length - 1;\n let lengthAtSegment = 0;\n let length = 0;\n let segment = pathArray[0] as PathSegment;\n\n // If the path is empty, return 0.\n if (index <= 0 || !distance || !Number.isFinite(distance)) {\n return {\n segment,\n index: 0,\n length,\n lengthAtSegment,\n };\n }\n\n if (distance >= pathLength) {\n pathTemp = pathArray.slice(0, -1) as PathArray;\n lengthAtSegment = getTotalLength(pathTemp);\n length = pathLength - lengthAtSegment;\n segment = pathArray[index];\n return {\n segment,\n index,\n length,\n lengthAtSegment,\n };\n }\n\n const segments = [] as SegmentProperties[];\n while (index > 0) {\n segment = pathTemp[index];\n pathTemp = pathTemp.slice(0, -1) as PathArray;\n lengthAtSegment = getTotalLength(pathTemp);\n length = pathLength - lengthAtSegment;\n pathLength = lengthAtSegment;\n\n segments.push({\n segment,\n index,\n length,\n lengthAtSegment,\n });\n index -= 1;\n }\n\n return segments.find(({ lengthAtSegment: l }) =>\n l <= distance\n ) as SegmentProperties;\n};\n\nexport default getPropertiesAtLength;\n","import type { PathArray, Point } from \"../types\";\nimport type { PointProperties } from \"../interface\";\nimport getPointAtLength from \"./getPointAtLength\";\nimport getPropertiesAtLength from \"./getPropertiesAtLength\";\nimport getTotalLength from \"./getTotalLength\";\nimport parsePathString from \"../parser/parsePathString\";\nimport normalizePath from \"../process/normalizePath\";\n\n/**\n * Returns the point and segment in path closest to a given point as well as\n * the distance to the path stroke.\n *\n * @see https://bl.ocks.org/mbostock/8027637\n *\n * @param pathInput target `pathArray`\n * @param point the given point\n * @returns the requested properties\n */\nconst getPropertiesAtPoint = (\n pathInput: string | PathArray,\n point: Point,\n): PointProperties => {\n const path = parsePathString(pathInput);\n const normalPath = normalizePath(path);\n const pathLength = getTotalLength(normalPath);\n const distanceTo = (p: Point) => {\n const dx = p.x - point.x;\n const dy = p.y - point.y;\n return dx * dx + dy * dy;\n };\n let precision = 8;\n let scan: Point;\n let closest = { x: 0, y: 0 }; // make TS happy\n let scanDistance = 0;\n let bestLength = 0;\n let bestDistance = Infinity;\n\n // linear scan for coarse approximation\n for (let scanLength = 0; scanLength <= pathLength; scanLength += precision) {\n scan = getPointAtLength(normalPath, scanLength);\n scanDistance = distanceTo(scan);\n\n if (scanDistance < bestDistance) {\n closest = scan;\n bestLength = scanLength;\n bestDistance = scanDistance;\n }\n }\n\n // binary search for precise estimate\n precision /= 2;\n let before: { x: number; y: number };\n let after: { x: number; y: number };\n let beforeLength = 0;\n let afterLength = 0;\n let beforeDistance = 0;\n let afterDistance = 0;\n\n while (precision > 0.000001) {\n beforeLength = bestLength - precision;\n before = getPointAtLength(normalPath, beforeLength);\n beforeDistance = distanceTo(before);\n afterLength = bestLength + precision;\n after = getPointAtLength(normalPath, afterLength);\n afterDistance = distanceTo(after);\n\n if (beforeLength >= 0 && beforeDistance < bestDistance) {\n closest = before;\n bestLength = beforeLength;\n bestDistance = beforeDistance;\n } else if (afterLength <= pathLength && afterDistance < bestDistance) {\n closest = after;\n bestLength = afterLength;\n bestDistance = afterDistance;\n } else {\n precision /= 2;\n }\n if (precision < 0.00001) break;\n }\n\n const segment = getPropertiesAtLength(path, bestLength);\n const distance = Math.sqrt(bestDistance);\n\n return { closest, distance, segment };\n};\n\nexport default getPropertiesAtPoint;\n","import type { PathArray } from \"../types\";\nimport getPropertiesAtPoint from \"./getPropertiesAtPoint\";\n\n/**\n * Returns the point in path closest to a given point.\n *\n * @param pathInput target `pathArray`\n * @param point the given point\n * @returns the best match\n */\nconst getClosestPoint = (\n pathInput: string | PathArray,\n point: { x: number; y: number },\n) => {\n return getPropertiesAtPoint(pathInput, point).closest;\n};\n\nexport default getClosestPoint;\n","import pathToCurve from \"../convert/pathToCurve\";\nimport type { PathArray, PointTuple } from \"../types\";\n\n/**\n * Returns the area of a single cubic-bezier segment.\n *\n * http://objectmix.com/graphics/133553-area-closed-bezier-curve.html\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the area of the cubic-bezier segment\n */\nconst getCubicSegArea = (\n x1: number,\n y1: number,\n c1x: number,\n c1y: number,\n c2x: number,\n c2y: number,\n x2: number,\n y2: number,\n) => {\n return (\n (3 *\n ((y2 - y1) * (c1x + c2x) -\n (x2 - x1) * (c1y + c2y) +\n c1y * (x1 - c2x) -\n c1x * (y1 - c2y) +\n y2 * (c2x + x1 / 3) -\n x2 * (c2y + y1 / 3))) /\n 20\n );\n};\n\n/**\n * Returns the area of a shape.\n *\n * @author Jürg Lehni & Jonathan Puckey\n *\n * @see https://github.com/paperjs/paper.js/blob/develop/src/path/Path.js\n *\n * @param path the shape `pathArray`\n * @returns the length of the cubic-bezier segment\n */\nconst getPathArea = (path: PathArray) => {\n let x = 0;\n let y = 0;\n let len = 0;\n\n return pathToCurve(path)\n .map((seg) => {\n switch (seg[0]) {\n case \"M\":\n [, x, y] = seg;\n return 0;\n default:\n len = getCubicSegArea(\n x,\n y,\n seg[1],\n seg[2],\n seg[3],\n seg[4],\n seg[5],\n seg[6],\n );\n [x, y] = seg.slice(-2) as PointTuple;\n return len;\n }\n })\n .reduce((a, b) => a + b, 0);\n};\nexport default getPathArea;\n","import getPathArea from \"./getPathArea\";\nimport pathToCurve from \"../convert/pathToCurve\";\nimport type { PathArray } from \"../types\";\n\n/**\n * Check if a path is drawn clockwise and returns true if so,\n * false otherwise.\n *\n * @param path the path string or `pathArray`\n * @returns true when clockwise or false if not\n */\nconst getDrawDirection = (path: string | PathArray) => {\n return getPathArea(pathToCurve(path)) >= 0;\n};\n\nexport default getDrawDirection;\n","import iterate from \"../process/iterate\";\nimport { PathBBox } from \"../interface\";\nimport { LSegment, MSegment, PathArray, PointTuple } from \"../types\";\nimport { getLineBBox } from \"../math/lineTools\";\nimport { getArcBBox } from \"../math/arcTools\";\nimport { getCubicBBox } from \"../math/cubicTools\";\nimport { getQuadBBox } from \"../math/quadTools\";\nimport parsePathString from \"../parser/parsePathString\";\nimport absolutizeSegment from \"../process/absolutizeSegment\";\n\nconst getPathBBox = (pathInput: PathArray | string) => {\n if (!pathInput) {\n return {\n x: 0,\n y: 0,\n width: 0,\n height: 0,\n x2: 0,\n y2: 0,\n cx: 0,\n cy: 0,\n cz: 0,\n };\n }\n\n const path = parsePathString(pathInput);\n let pathCommand = \"M\";\n let mx = 0;\n let my = 0;\n const { max, min } = Math;\n let xMin = Infinity;\n let yMin = Infinity;\n let xMax = -Infinity;\n let yMax = -Infinity;\n let minX = 0;\n let minY = 0;\n let maxX = 0;\n let maxY = 0;\n let paramX1 = 0;\n let paramY1 = 0;\n let paramX2 = 0;\n let paramY2 = 0;\n let paramQX = 0;\n let paramQY = 0;\n\n iterate(path, (seg, index, lastX, lastY) => {\n [pathCommand] = seg;\n const absCommand = pathCommand.toUpperCase();\n const isRelative = absCommand !== pathCommand;\n const absoluteSegment = isRelative\n ? absolutizeSegment(seg, index, lastX, lastY)\n : (seg.slice(0) as typeof seg);\n\n const normalSegment = absCommand === \"V\"\n ? ([\"L\", lastX, absoluteSegment[1]] as LSegment)\n : absCommand === \"H\"\n ? ([\"L\", absoluteSegment[1], lastY] as LSegment)\n : absoluteSegment;\n\n [pathCommand] = normalSegment;\n\n if (!\"TQ\".includes(absCommand)) {\n // optional but good to be cautious\n paramQX = 0;\n paramQY = 0;\n }\n\n // this segment is always ZERO\n /* istanbul ignore else @preserve */\n if (pathCommand === \"M\") {\n [, mx, my] = normalSegment as MSegment;\n minX = mx;\n minY = my;\n maxX = mx;\n maxY = my;\n } else if (pathCommand === \"L\") {\n [minX, minY, maxX, maxY] = getLineBBox(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n );\n } else if (pathCommand === \"A\") {\n [minX, minY, maxX, maxY] = getArcBBox(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n normalSegment[5] as number,\n normalSegment[6] as number,\n normalSegment[7] as number,\n );\n } else if (pathCommand === \"S\") {\n const cp1x = paramX1 * 2 - paramX2;\n const cp1y = paramY1 * 2 - paramY2;\n\n [minX, minY, maxX, maxY] = getCubicBBox(\n lastX,\n lastY,\n cp1x,\n cp1y,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n );\n } else if (pathCommand === \"C\") {\n [minX, minY, maxX, maxY] = getCubicBBox(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n normalSegment[5] as number,\n normalSegment[6] as number,\n );\n } else if (pathCommand === \"T\") {\n paramQX = paramX1 * 2 - paramQX;\n paramQY = paramY1 * 2 - paramQY;\n [minX, minY, maxX, maxY] = getQuadBBox(\n lastX,\n lastY,\n paramQX,\n paramQY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n );\n } else if (pathCommand === \"Q\") {\n paramQX = normalSegment[1] as number;\n paramQY = normalSegment[2] as number;\n [minX, minY, maxX, maxY] = getQuadBBox(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n );\n } else if (pathCommand === \"Z\") {\n [minX, minY, maxX, maxY] = getLineBBox(lastX, lastY, mx, my);\n }\n xMin = min(minX, xMin);\n yMin = min(minY, yMin);\n xMax = max(maxX, xMax);\n yMax = max(maxY, yMax);\n\n // update params\n [paramX1, paramY1] = pathCommand === \"Z\"\n ? [mx, my]\n : (normalSegment.slice(-2) as PointTuple);\n [paramX2, paramY2] = pathCommand === \"C\"\n ? ([normalSegment[3], normalSegment[4]] as PointTuple)\n : pathCommand === \"S\"\n ? ([normalSegment[1], normalSegment[2]] as PointTuple)\n : [paramX1, paramY1];\n });\n\n const width = xMax - xMin;\n const height = yMax - yMin;\n\n return {\n width,\n height,\n x: xMin,\n y: yMin,\n x2: xMax,\n y2: yMax,\n cx: xMin + width / 2,\n cy: yMin + height / 2,\n // an estimated guess\n cz: Math.max(width, height) + Math.min(width, height) / 2,\n } satisfies PathBBox;\n};\n\nexport default getPathBBox;\n","import type { PathArray, PathSegment } from \"../types\";\nimport getPropertiesAtLength from \"./getPropertiesAtLength\";\n\n/**\n * Returns the segment at a given length.\n *\n * @param pathInput the target `pathArray`\n * @param distance the distance in path to look at\n * @returns the requested segment\n */\nconst getSegmentAtLength = (\n pathInput: string | PathArray,\n distance?: number,\n): PathSegment | undefined => {\n return getPropertiesAtLength(pathInput, distance).segment;\n};\n\nexport default getSegmentAtLength;\n","import type { SegmentProperties } from \"../interface\";\nimport type { PathArray } from \"../types\";\nimport getPropertiesAtPoint from \"./getPropertiesAtPoint\";\n\n/**\n * Returns the path segment which contains a given point.\n *\n * @param path the `pathArray` to look into\n * @param point the point of the shape to look for\n * @returns the requested segment\n */\nconst getSegmentOfPoint = (\n path: string | PathArray,\n point: { x: number; y: number },\n): SegmentProperties | undefined => {\n return getPropertiesAtPoint(path, point).segment;\n};\nexport default getSegmentOfPoint;\n","import type { PathArray, PathSegment, RelativeCommand } from \"../types\";\nimport paramsCount from \"../parser/paramsCount\";\n\n/**\n * Iterates an array to check if it's an actual `pathArray`.\n *\n * @param path the `pathArray` to be checked\n * @returns iteration result\n */\nconst isPathArray = (path: unknown): path is PathArray => {\n return (\n Array.isArray(path) &&\n path.every((seg: PathSegment) => {\n const lk = seg[0].toLowerCase() as RelativeCommand;\n return (\n paramsCount[lk] === seg.length - 1 &&\n \"achlmqstvz\".includes(lk) &&\n (seg.slice(1) as unknown[]).every(Number.isFinite)\n );\n }) &&\n path.length > 0\n );\n};\nexport default isPathArray;\n","import type { AbsoluteArray } from \"../types\";\nimport isPathArray from \"./isPathArray\";\n\n/**\n * Iterates an array to check if it's a `pathArray`\n * with all absolute values.\n *\n * @param path the `pathArray` to be checked\n * @returns iteration result\n */\nconst isAbsoluteArray = (path: unknown): path is AbsoluteArray => {\n return (\n isPathArray(path) &&\n // `isPathArray` also checks if it's `Array`\n path.every(([x]) => x === x.toUpperCase())\n );\n};\nexport default isAbsoluteArray;\n","import type { NormalArray } from \"../types\";\nimport isAbsoluteArray from \"./isAbsoluteArray\";\n\n/**\n * Iterates an array to check if it's a `pathArray`\n * with all segments are in non-shorthand notation\n * with absolute values.\n *\n * @param {string | SVGPath.pathArray} path the `pathArray` to be checked\n * @returns {boolean} iteration result\n */\nconst isNormalizedArray = (path: unknown): path is NormalArray => {\n // `isAbsoluteArray` also checks if it's `Array`\n return isAbsoluteArray(path) && path.every(([pc]) => \"ACLMQZ\".includes(pc));\n};\nexport default isNormalizedArray;\n","import { CurveArray } from \"../types\";\nimport isNormalizedArray from \"./isNormalizedArray\";\n\n/**\n * Iterates an array to check if it's a `pathArray`\n * with all C (cubic bezier) segments.\n *\n * @param path the `Array` to be checked\n * @returns iteration result\n */\nconst isCurveArray = (path: unknown): path is CurveArray => {\n // `isPathArray` also checks if it's `Array`\n return isNormalizedArray(path) && path.every(([pc]) => \"MC\".includes(pc));\n};\nexport default isCurveArray;\n","import type { PathArray } from \"../types\";\nimport getPropertiesAtPoint from \"./getPropertiesAtPoint\";\nimport DISTANCE_EPSILON from \"./distanceEpsilon\";\n\n/**\n * Checks if a given point is in the stroke of a path.\n *\n * @param pathInput target path\n * @param point the given `{x,y}` point\n * @returns the query result\n */\nconst isPointInStroke = (\n pathInput: string | PathArray,\n point: { x: number; y: number },\n) => {\n const { distance } = getPropertiesAtPoint(pathInput, point);\n return Math.abs(distance) < DISTANCE_EPSILON; // 0.01 might be more permissive\n};\nexport default isPointInStroke;\n","import type { RelativeArray } from \"../types\";\nimport isPathArray from \"./isPathArray\";\n\n/**\n * Iterates an array to check if it's a `pathArray`\n * with relative values.\n *\n * @param path the `pathArray` to be checked\n * @returns iteration result\n */\nconst isRelativeArray = (path: unknown): path is RelativeArray => {\n return (\n isPathArray(path) &&\n // `isPathArray` checks if it's `Array`\n path.slice(1).every(([pc]) => pc === pc.toLowerCase())\n );\n};\nexport default isRelativeArray;\n","import scanSegment from \"../parser/scanSegment\";\nimport skipSpaces from \"../parser/skipSpaces\";\nimport PathParser from \"../parser/pathParser\";\n\n/**\n * Parses a path string value to determine its validity\n * then returns true if it's valid or false otherwise.\n *\n * @param pathString the path string to be parsed\n * @returns the path string validity\n */\nconst isValidPath = (pathString: string) => {\n if (typeof pathString !== \"string\" || !pathString.length) {\n return false;\n }\n\n const path = new PathParser(pathString);\n\n skipSpaces(path);\n\n while (path.index < path.max && !path.err.length) {\n scanSegment(path);\n }\n\n return !path.err.length && \"mM\".includes(path.segments[0][0]);\n};\nexport default isValidPath;\n","import type { ShapeParams } from \"../interface\";\n\n/**\n * Supported shapes and their specific parameters.\n */\nconst shapeParams: ShapeParams = {\n line: [\"x1\", \"y1\", \"x2\", \"y2\"],\n circle: [\"cx\", \"cy\", \"r\"],\n ellipse: [\"cx\", \"cy\", \"rx\", \"ry\"],\n rect: [\"width\", \"height\", \"x\", \"y\", \"rx\", \"ry\"],\n polygon: [\"points\"],\n polyline: [\"points\"],\n glyph: [\"d\"],\n};\n\nexport default shapeParams;\n","const isElement = (node?: unknown): node is Element =>\n node !== undefined && node !== null &&\n typeof node === \"object\" &&\n (node as Node).nodeType === 1; // ELEMENT_NODE\n\nexport default isElement;\n","import type {\n CircleAttr,\n EllipseAttr,\n GlyphAttr,\n LineAttr,\n PolyAttr,\n RectAttr,\n ShapeParams,\n} from \"../interface\";\nimport type { PathArray, PathSegment, ShapeOps, ShapeTypes } from \"../types\";\nimport error from \"../parser/error\";\nimport parsePathString from \"../parser/parsePathString\";\nimport shapeParams from \"./shapeParams\";\nimport isPathArray from \"./isPathArray\";\nimport isElement from \"./isElement\";\n\n/**\n * Returns a new `pathArray` from line attributes.\n *\n * @param attr shape configuration\n * @returns a new line `pathArray`\n */\nexport const getLinePath = (attr: LineAttr): PathArray => {\n let { x1, y1, x2, y2 } = attr;\n [x1, y1, x2, y2] = [x1, y1, x2, y2].map((a) => +a);\n return [\n [\"M\", x1, y1],\n [\"L\", x2, y2],\n ];\n};\n\n/**\n * Returns a new `pathArray` like from polyline/polygon attributes.\n *\n * @param attr shape configuration\n * @return a new polygon/polyline `pathArray`\n */\nexport const getPolyPath = (attr: PolyAttr): PathArray => {\n const pathArray = [] as PathSegment[];\n const points = (attr.points || \"\")\n .trim()\n .split(/[\\s|,]/)\n .map((a) => +a);\n\n let index = 0;\n while (index < points.length) {\n pathArray.push([index ? \"L\" : \"M\", points[index], points[index + 1]]);\n index += 2;\n }\n\n return (attr.type === \"polygon\"\n ? [...pathArray, [\"z\"]]\n : pathArray) as PathArray;\n};\n\n/**\n * Returns a new `pathArray` from circle attributes.\n *\n * @param attr shape configuration\n * @return a circle `pathArray`\n */\nexport const getCirclePath = (attr: CircleAttr): PathArray => {\n let { cx, cy, r } = attr;\n [cx, cy, r] = [cx, cy, r].map((a) => +a);\n\n return [\n [\"M\", cx - r, cy],\n [\"a\", r, r, 0, 1, 0, 2 * r, 0],\n [\"a\", r, r, 0, 1, 0, -2 * r, 0],\n ];\n};\n\n/**\n * Returns a new `pathArray` from ellipse attributes.\n *\n * @param attr shape configuration\n * @return an ellipse `pathArray`\n */\nexport const getEllipsePath = (attr: EllipseAttr): PathArray => {\n let { cx, cy } = attr;\n let rx = attr.rx || 0;\n let ry = attr.ry || rx;\n [cx, cy, rx, ry] = [cx, cy, rx, ry].map((a) => +a);\n\n return [\n [\"M\", cx - rx, cy],\n [\"a\", rx, ry, 0, 1, 0, 2 * rx, 0],\n [\"a\", rx, ry, 0, 1, 0, -2 * rx, 0],\n ];\n};\n\n/**\n * Returns a new `pathArray` like from rect attributes.\n *\n * @param attr object with properties above\n * @return a new `pathArray` from `` attributes\n */\nexport const getRectanglePath = (attr: RectAttr): PathArray => {\n const x = +attr.x || 0;\n const y = +attr.y || 0;\n const w = +attr.width;\n const h = +attr.height;\n let rx = +(attr.rx || 0);\n let ry = +(attr.ry || rx);\n\n // Validity checks from http://www.w3.org/TR/SVG/shapes.html#RectElement:\n if (rx || ry) {\n // rx = !rx ? ry : rx;\n // ry = !ry ? rx : ry;\n\n /* istanbul ignore else @preserve */\n if (rx * 2 > w) rx -= (rx * 2 - w) / 2;\n /* istanbul ignore else @preserve */\n if (ry * 2 > h) ry -= (ry * 2 - h) / 2;\n\n return [\n [\"M\", x + rx, y],\n [\"h\", w - rx * 2],\n [\"s\", rx, 0, rx, ry],\n [\"v\", h - ry * 2],\n [\"s\", 0, ry, -rx, ry],\n [\"h\", -w + rx * 2],\n [\"s\", -rx, 0, -rx, -ry],\n [\"v\", -h + ry * 2],\n [\"s\", 0, -ry, rx, -ry],\n ];\n }\n\n return [[\"M\", x, y], [\"h\", w], [\"v\", h], [\"H\", x], [\"Z\"]];\n};\n\n/**\n * Returns a new `pathArray` created from attributes of a ``, ``,\n * ``, ``, ``, ``, or ``.\n *\n * It can also work with an options object, see the type below\n * @see ShapeOps\n *\n * @param element target shape\n * @return the newly created `` element\n */\nconst shapeToPathArray = (\n element: ShapeTypes | ShapeOps,\n) => {\n const supportedShapes = Object.keys(shapeParams) as (keyof ShapeParams)[];\n const targetIsElement = isElement(element);\n const tagName = targetIsElement ? element.tagName : null;\n\n if (tagName && [...supportedShapes, \"path\"].every((s) => tagName !== s)) {\n throw TypeError(`${error}: \"${tagName}\" is not SVGElement`);\n }\n\n const type =\n (targetIsElement ? tagName : (element as ShapeOps).type) as ShapeOps[\n \"type\"\n ];\n const shapeAttrs = shapeParams[type] as string[];\n const config = { type } as Record;\n\n if (targetIsElement) {\n shapeAttrs.forEach((p) => {\n config[p] = element.getAttribute(p) as string;\n });\n } else {\n Object.assign(config, element);\n }\n\n // set d\n let pathArray = [] as unknown as PathArray;\n\n /* istanbul ignore else */\n if (type === \"circle\") {\n pathArray = getCirclePath(config as unknown as CircleAttr);\n } else if (type === \"ellipse\") {\n pathArray = getEllipsePath(config as unknown as EllipseAttr);\n } else if ([\"polyline\", \"polygon\"].includes(type)) {\n pathArray = getPolyPath(config as unknown as PolyAttr);\n } else if (type === \"rect\") {\n pathArray = getRectanglePath(config as unknown as RectAttr);\n } else if (type === \"line\") {\n pathArray = getLinePath(config as unknown as LineAttr);\n } else if ([\"glyph\", \"path\"].includes(type)) {\n pathArray = parsePathString(\n targetIsElement\n ? element.getAttribute(\"d\") || /* istanbul ignore next @preserve */ \"\"\n : (element as GlyphAttr).d || \"\",\n );\n }\n\n // replace target element\n if (isPathArray(pathArray) && pathArray.length) {\n return pathArray;\n }\n return false;\n};\nexport default shapeToPathArray;\n","import type { ShapeParams } from \"../interface\";\nimport type { ShapeOps, ShapeTypes } from \"../types\";\nimport pathToString from \"../convert/pathToString\";\nimport defaultOptions from \"../options/options\";\nimport error from \"../parser/error\";\nimport isValidPath from \"./isValidPath\";\nimport isElement from \"./isElement\";\nimport shapeToPathArray from \"./shapeToPathArray\";\nimport shapeParams from \"./shapeParams\";\n\n/**\n * Returns a new `` element created from attributes of a ``, ``,\n * ``, ``, ``, `` or ``. If `replace` parameter\n * is `true`, it will replace the target. The default `ownerDocument` is your current\n * `document` browser page, if you want to use in server-side using `jsdom`, you can\n * pass the `jsdom` `document` to `ownDocument`.\n *\n * It can also work with an options object, see the type below\n * @see ShapeOps\n *\n * The newly created `` element keeps all non-specific\n * attributes like `class`, `fill`, etc.\n *\n * @param element target shape\n * @param replace option to replace target\n * @param ownerDocument document for create element\n * @return the newly created `` element\n */\nconst shapeToPath = (\n element: ShapeTypes | ShapeOps,\n replace?: boolean,\n ownerDocument?: Document,\n): SVGPathElement | false => {\n const doc = ownerDocument || document;\n const supportedShapes = Object.keys(shapeParams) as (keyof ShapeParams)[];\n const targetIsElement = isElement(element);\n const tagName = targetIsElement ? element.tagName : null;\n\n if (tagName === \"path\") {\n throw TypeError(`${error}: \"${tagName}\" is already SVGPathElement`);\n }\n if (tagName && supportedShapes.every((s) => tagName !== s)) {\n throw TypeError(`${error}: \"${tagName}\" is not SVGElement`);\n }\n\n const path = doc.createElementNS(\"http://www.w3.org/2000/svg\", \"path\");\n const type =\n (targetIsElement ? tagName : (element as ShapeOps).type) as ShapeOps[\n \"type\"\n ];\n const shapeAttrs = shapeParams[type] as string[];\n const config = { type } as Record;\n\n // set d\n const round = defaultOptions.round as number;\n const pathArray = shapeToPathArray(element);\n const description = pathArray && pathArray.length\n ? pathToString(pathArray, round)\n : \"\";\n\n if (targetIsElement) {\n shapeAttrs.forEach((p) => {\n config[p] = element.getAttribute(p) as string;\n });\n // set no-specific shape attributes: fill, stroke, etc\n Object.values(element.attributes).forEach(({ name, value }) => {\n if (!shapeAttrs.includes(name)) path.setAttribute(name, value);\n });\n } else {\n Object.assign(config, element);\n // set no-specific shape attributes: fill, stroke, etc\n Object.keys(config).forEach((k) => {\n if (!shapeAttrs.includes(k) && k !== \"type\") {\n path.setAttribute(\n k.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`),\n config[k],\n );\n }\n });\n }\n\n // replace target element\n if (isValidPath(description)) {\n path.setAttribute(\"d\", description);\n if (replace && targetIsElement) {\n element.before(path, element);\n element.remove();\n }\n return path;\n }\n return false;\n};\n\nexport default shapeToPath;\n","import CSSMatrix from \"@thednp/dommatrix\";\n// import type { TransformObject } from '../interface';\nimport type { TransformObjectValues } from \"../types\";\n\n/**\n * Returns a transformation matrix to apply to `` elements.\n *\n * @see TransformObjectValues\n *\n * @param transform the `transformObject`\n * @returns a new transformation matrix\n */\nconst getSVGMatrix = (transform: TransformObjectValues): CSSMatrix => {\n let matrix = new CSSMatrix();\n const { origin } = transform;\n const [originX, originY] = origin as [number, number, number];\n const { translate } = transform;\n const { rotate } = transform;\n const { skew } = transform;\n const { scale } = transform;\n\n // set translate\n if (\n Array.isArray(translate) &&\n translate.length >= 2 &&\n translate.every((x) => !Number.isNaN(+x)) &&\n translate.some((x) => x !== 0)\n ) {\n matrix = matrix.translate(...(translate as [number, number, number?]));\n } else if (typeof translate === \"number\" && !Number.isNaN(translate)) {\n matrix = matrix.translate(translate);\n }\n\n if (rotate || skew || scale) {\n // set SVG transform-origin, always defined\n matrix = matrix.translate(originX, originY);\n\n // set rotation\n if (\n Array.isArray(rotate) &&\n rotate.length >= 2 &&\n rotate.every((x) => !Number.isNaN(+x)) &&\n rotate.some((x) => x !== 0)\n ) {\n matrix = matrix.rotate(...(rotate as [number, number, number?]));\n } else if (typeof rotate === \"number\" && !Number.isNaN(rotate)) {\n matrix = matrix.rotate(rotate);\n }\n\n // set skew(s)\n if (\n Array.isArray(skew) && skew.length === 2 && skew.every((x) =>\n !Number.isNaN(+x)\n ) && skew.some((x) => x !== 0)\n ) {\n matrix = skew[0] ? matrix.skewX(skew[0]) : matrix;\n matrix = skew[1] ? matrix.skewY(skew[1]) : matrix;\n } else if (typeof skew === \"number\" && !Number.isNaN(skew)) {\n matrix = matrix.skewX(skew);\n }\n\n // set scale\n if (\n Array.isArray(scale) && scale.length >= 2 && scale.every((x) =>\n !Number.isNaN(+x)\n ) && scale.some((x) => x !== 1)\n ) {\n matrix = matrix.scale(...(scale as [number, number, number?]));\n } else if (typeof scale === \"number\" && !Number.isNaN(scale)) {\n matrix = matrix.scale(scale);\n }\n // set SVG transform-origin\n matrix = matrix.translate(-originX, -originY);\n }\n\n return matrix;\n};\nexport default getSVGMatrix;\n","import defaultOptions from \"../options/options\";\nimport type { ParserParams } from \"../interface\";\nimport roundTo from \"../math/roundTo\";\nimport type {\n AbsoluteSegment,\n NormalSegment,\n PathCommand,\n ShortSegment,\n SSegment,\n TSegment,\n} from \"../types\";\n\n/**\n * Shorten a single segment of a `pathArray` object.\n *\n * @param segment the `absoluteSegment` object\n * @param normalSegment the `normalSegment` object\n * @param params the coordinates of the previous segment\n * @param prevCommand the path command of the previous segment\n * @returns the shortened segment\n */\nconst shortenSegment = (\n segment: AbsoluteSegment,\n normalSegment: NormalSegment,\n params: ParserParams,\n prevCommand: PathCommand,\n): ShortSegment => {\n const [pathCommand] = segment;\n const { round: defaultRound } = defaultOptions;\n const round = typeof defaultRound === \"number\"\n ? defaultRound\n : /* istanbul ignore next */ 4;\n const normalValues = normalSegment.slice(1) as number[];\n const { x1, y1, x2, y2, x, y } = params;\n const [nx, ny] = normalValues.slice(-2);\n const result = segment;\n\n if (!\"TQ\".includes(pathCommand)) {\n // optional but good to be cautious\n params.qx = null;\n params.qy = null;\n }\n\n if (pathCommand === \"L\") {\n if (roundTo(x, round) === roundTo(nx, round)) {\n return [\"V\", ny];\n } else if (roundTo(y, round) === roundTo(ny, round)) {\n return [\"H\", nx];\n }\n } else if (pathCommand === \"C\") {\n const [nx1, ny1] = normalValues;\n params.x1 = nx1;\n params.y1 = ny1;\n\n if (\n \"CS\".includes(prevCommand) &&\n ((roundTo(nx1, round) === roundTo(x1 * 2 - x2, round) &&\n roundTo(ny1, round) === roundTo(y1 * 2 - y2, round)) ||\n (roundTo(x1, round) === roundTo(x2 * 2 - x, round) &&\n roundTo(y1, round) === roundTo(y2 * 2 - y, round)))\n ) {\n return [\n \"S\",\n normalValues[2],\n normalValues[3],\n normalValues[4],\n normalValues[5],\n ] as SSegment;\n }\n } else if (pathCommand === \"Q\") {\n const [qx, qy] = normalValues;\n params.qx = qx;\n params.qy = qy;\n\n if (\n \"QT\".includes(prevCommand) &&\n roundTo(qx, round) === roundTo(x1 * 2 - x2, round) &&\n roundTo(qy, round) === roundTo(y1 * 2 - y2, round)\n ) {\n return [\"T\", normalValues[2], normalValues[3]] as TSegment;\n }\n }\n\n // ['V', 'H', 'S', 'T', 'Z'].includes(pathCommand)\n return result as ShortSegment;\n};\n\nexport default shortenSegment;\n","import type { PathCommand, PathSegment } from \"../types\";\nimport roundTo from \"../math/roundTo\";\n\nconst roundSegment = (\n segment: T,\n roundOption: number,\n) => {\n const values = (segment.slice(1) as number[]).map((n) =>\n roundTo(n, roundOption)\n );\n return [segment[0] as PathCommand | number].concat(values) as T;\n};\n\nexport default roundSegment;\n","import type { AbsoluteSegment, PathArray, PathCommand } from \"../types\";\nimport pathToAbsolute from \"../convert/pathToAbsolute\";\nimport shortenSegment from \"./shortenSegment\";\nimport paramsParser from \"../parser/paramsParser\";\nimport iterate from \"./iterate\";\nimport normalizeSegment from \"./normalizeSegment\";\nimport relativizeSegment from \"./relativizeSegment\";\nimport roundSegment from \"./roundSegment\";\n\n/**\n * Optimizes a `pathArray` object:\n * * convert segments to shorthand if possible\n * * select shortest segments from absolute and relative `pathArray`s\n *\n * @param pathInput a string or `pathArray`\n * @param roundOption the amount of decimals to round values to\n * @returns the optimized `pathArray`\n */\nconst optimizePath = (pathInput: PathArray, roundOption?: number) => {\n const path = pathToAbsolute(pathInput);\n // allow for ZERO decimals or use an aggressive value of 2\n const round = typeof roundOption === \"number\" && roundOption >= 0\n ? roundOption\n : /* istanbul ignore next @preserve */ 2;\n // this utility overrides the iterator params\n const optimParams = { ...paramsParser };\n\n const allPathCommands = [] as PathCommand[];\n let pathCommand = \"M\" as PathCommand;\n let prevCommand = \"Z\" as PathCommand;\n\n return iterate(path, (seg, i, lastX, lastY) => {\n optimParams.x = lastX;\n optimParams.y = lastY;\n const normalizedSegment = normalizeSegment(seg, optimParams);\n let result = seg;\n [pathCommand] = seg;\n\n // Save current path command\n allPathCommands[i] = pathCommand;\n if (i) {\n // Get previous path command for `shortenSegment`\n prevCommand = allPathCommands[i - 1];\n const shortSegment = shortenSegment(\n seg as AbsoluteSegment,\n normalizedSegment,\n optimParams,\n prevCommand,\n );\n const absSegment = roundSegment(shortSegment, round);\n const absString = absSegment.join(\"\");\n const relativeSegment = relativizeSegment(shortSegment, i, lastX, lastY);\n const relSegment = roundSegment(relativeSegment, round);\n const relString = relSegment.join(\"\");\n result = absString.length < relString.length ? absSegment : relSegment;\n }\n\n const seglen = normalizedSegment.length;\n optimParams.x1 = +normalizedSegment[seglen - 2];\n optimParams.y1 = +normalizedSegment[seglen - 1];\n optimParams.x2 = +normalizedSegment[seglen - 4] || optimParams.x1;\n optimParams.y2 = +normalizedSegment[seglen - 3] || optimParams.y1;\n\n return result;\n });\n};\n\nexport default optimizePath;\n","import CSSMatrix from \"@thednp/dommatrix\";\nimport { type PointTuple } from \"../types\";\n\n/**\n * Transforms a specified point using a matrix, returning a new\n * Tuple *Object* comprising of the transformed point.\n * Neither the matrix nor the original point are altered.\n *\n * @copyright thednp © 2021\n *\n * @param cssm CSSMatrix instance\n * @param v Tuple\n * @return the resulting Tuple\n */\nconst translatePoint = (\n cssm: CSSMatrix,\n v: [number, number, number, number],\n): [number, number, number, number] => {\n let m = CSSMatrix.Translate(v[0], v[1], v[2]);\n\n [, , , m.m44] = v;\n m = cssm.multiply(m);\n\n return [m.m41, m.m42, m.m43, m.m44];\n};\n\n/**\n * Returns the [x,y] projected coordinates for a given an [x,y] point\n * and an [x,y,z] perspective origin point.\n *\n * Equation found here =>\n * http://en.wikipedia.org/wiki/3D_projection#Diagram\n * Details =>\n * https://stackoverflow.com/questions/23792505/predicted-rendering-of-css-3d-transformed-pixel\n *\n * @param m the transformation matrix\n * @param point2D the initial [x,y] coordinates\n * @param origin the [x,y,z] transform origin\n * @returns the projected [x,y] coordinates\n */\nconst projection2d = (\n m: CSSMatrix,\n point2D: PointTuple,\n origin: [number, number, number],\n): PointTuple => {\n const [originX, originY, originZ] = origin;\n const [x, y, z] = translatePoint(m, [point2D[0], point2D[1], 0, 1]);\n\n const relativePositionX = x - originX;\n const relativePositionY = y - originY;\n const relativePositionZ = z - originZ;\n\n return [\n // protect against division by ZERO\n relativePositionX * (Math.abs(originZ) / Math.abs(relativePositionZ) || 1) +\n originX,\n relativePositionY * (Math.abs(originZ) / Math.abs(relativePositionZ) || 1) +\n originY,\n ];\n};\nexport default projection2d;\n","import type { CSegment, CurveArray, MSegment, PathCommand } from \"../types\";\n\n/**\n * Reverses all segments of a `pathArray`\n * which consists of only C (cubic-bezier) path commands.\n *\n * @param path the source `pathArray`\n * @returns the reversed `pathArray`\n */\nconst reverseCurve = (path: CurveArray) => {\n const rotatedCurve = path\n .slice(1)\n .map((x, i, curveOnly) =>\n !i\n ? path[0].slice(1).concat(x.slice(1) as number[])\n : curveOnly[i - 1].slice(-2).concat(x.slice(1))\n )\n .map((x) => x.map((_, i) => x[x.length - i - 2 * (1 - (i % 2))]))\n .reverse() as (MSegment | CSegment)[];\n\n return [[\"M\" as PathCommand | number].concat(rotatedCurve[0].slice(0, 2))]\n .concat(\n rotatedCurve.map((x) => [\"C\" as PathCommand | number].concat(x.slice(2))),\n ) as CurveArray;\n};\n\nexport default reverseCurve;\n","import type {\n ASegment,\n CSegment,\n HSegment,\n MSegment,\n PathArray,\n PathSegment,\n PointTuple,\n QSegment,\n SSegment,\n TSegment,\n VSegment,\n} from \"../types\";\nimport pathToAbsolute from \"../convert/pathToAbsolute\";\nimport normalizePath from \"./normalizePath\";\nimport iterate from \"./iterate\";\n\n/**\n * Reverses all segments of a `pathArray` and returns a new `pathArray` instance\n * with absolute values.\n *\n * @param pathInput the source `pathArray`\n * @returns the reversed `pathArray`\n */\nconst reversePath = (pathInput: PathArray) => {\n const absolutePath = pathToAbsolute(pathInput);\n const normalizedPath = normalizePath(absolutePath);\n const pLen = absolutePath.length;\n const isClosed = absolutePath[pLen - 1][0] === \"Z\";\n\n const reversedPath = iterate(absolutePath, (segment, i) => {\n const normalizedSegment = normalizedPath[i];\n const prevSeg = i && absolutePath[i - 1];\n const prevCommand = prevSeg && prevSeg[0];\n const nextSeg = absolutePath[i + 1];\n const nextCommand = nextSeg && nextSeg[0];\n const [pathCommand] = segment;\n const [x, y] = normalizedPath[i ? i - 1 : pLen - 1].slice(-2) as PointTuple;\n let result = segment;\n\n switch (pathCommand) {\n case \"M\":\n result = (isClosed ? [\"Z\"] : [pathCommand, x, y]) as PathSegment;\n break;\n case \"A\":\n result = [\n pathCommand,\n segment[1],\n segment[2],\n segment[3],\n segment[4],\n segment[5] === 1 ? 0 : 1,\n x,\n y,\n ] as ASegment;\n break;\n case \"C\":\n if (nextSeg && nextCommand === \"S\") {\n result = [\"S\", segment[1], segment[2], x, y] as SSegment;\n } else {\n result = [\n pathCommand,\n segment[3],\n segment[4],\n segment[1],\n segment[2],\n x,\n y,\n ] as CSegment;\n }\n break;\n case \"S\":\n if (\n prevCommand && \"CS\".includes(prevCommand) &&\n (!nextSeg || nextCommand !== \"S\")\n ) {\n result = [\n \"C\",\n normalizedSegment[3],\n normalizedSegment[4],\n normalizedSegment[1],\n normalizedSegment[2],\n x,\n y,\n ] as CSegment;\n } else {\n result = [\n pathCommand,\n normalizedSegment[1],\n normalizedSegment[2],\n x,\n y,\n ] as SSegment;\n }\n break;\n case \"Q\":\n if (nextSeg && nextCommand === \"T\") {\n result = [\"T\", x, y] as TSegment;\n } else {\n result = [pathCommand, segment[1], segment[2], x, y] as QSegment;\n }\n break;\n case \"T\":\n if (\n prevCommand && \"QT\".includes(prevCommand) &&\n (!nextSeg || nextCommand !== \"T\")\n ) {\n result = [\n \"Q\",\n normalizedSegment[1],\n normalizedSegment[2],\n x,\n y,\n ] as QSegment;\n } else {\n result = [pathCommand, x, y] as TSegment;\n }\n break;\n case \"Z\":\n result = [\"M\", x, y] as MSegment;\n break;\n case \"H\":\n result = [pathCommand, x] as HSegment;\n break;\n case \"V\":\n result = [pathCommand, y] as VSegment;\n break;\n default:\n result = [pathCommand as typeof pathCommand | number].concat(\n segment.slice(1, -2),\n x,\n y,\n ) as PathSegment;\n }\n\n return result;\n });\n\n return (\n isClosed\n ? reversedPath.reverse()\n : [reversedPath[0] as PathSegment].concat(reversedPath.slice(1).reverse())\n ) as PathArray;\n};\n\nexport default reversePath;\n","import type { PathArray } from \"../types\";\nimport defaultOptions from \"../options/options\";\nimport iterate from \"./iterate\";\nimport roundSegment from \"./roundSegment\";\n\n/**\n * Rounds the values of a `pathArray` instance to\n * a specified amount of decimals and returns it.\n *\n * @param path the source `pathArray`\n * @param roundOption the amount of decimals to round numbers to\n * @returns the resulted `pathArray` with rounded values\n */\nconst roundPath = (path: PathArray, roundOption?: number | \"off\") => {\n let { round } = defaultOptions;\n // allow for ZERO decimals\n round = roundOption === \"off\"\n ? roundOption\n : typeof roundOption === \"number\" && roundOption >= 0\n ? roundOption\n : typeof round === \"number\" && round >= 0\n ? round\n : /* istanbul ignore next @preserve */ \"off\";\n\n /* istanbul ignore else @preserve */\n if (round === \"off\") return path.slice(0) as PathArray;\n\n return iterate(path, (segment) => {\n return roundSegment(segment, round);\n });\n};\nexport default roundPath;\n","import midPoint from \"../math/midPoint\";\nimport type { CubicSegment, PointTuple } from \"../types\";\n\n/**\n * Split a cubic-bezier segment into two.\n *\n * @param pts the cubic-bezier parameters\n * @param ratio the cubic-bezier parameters\n * @return two new cubic-bezier segments\n */\nconst splitCubic = (\n pts: number[],\n ratio = 0.5,\n): [CubicSegment, CubicSegment] => {\n const t = ratio;\n const p0 = pts.slice(0, 2) as PointTuple;\n const p1 = pts.slice(2, 4) as PointTuple;\n const p2 = pts.slice(4, 6) as PointTuple;\n const p3 = pts.slice(6, 8) as PointTuple;\n const p4 = midPoint(p0, p1, t);\n const p5 = midPoint(p1, p2, t);\n const p6 = midPoint(p2, p3, t);\n const p7 = midPoint(p4, p5, t);\n const p8 = midPoint(p5, p6, t);\n const p9 = midPoint(p7, p8, t);\n\n return [\n [\"C\", p4[0], p4[1], p7[0], p7[1], p9[0], p9[1]],\n [\"C\", p8[0], p8[1], p6[0], p6[1], p3[0], p3[1]],\n ];\n};\nexport default splitCubic;\n","import paramsParser from \"../parser/paramsParser\";\nimport type {\n AbsoluteCommand,\n HSegment,\n MSegment,\n PathArray,\n PointTuple,\n RelativeCommand,\n VSegment,\n} from \"../types\";\n\n/**\n * Split a path into an `Array` of sub-path strings.\n *\n * In the process, values are converted to absolute\n * for visual consistency.\n *\n * @param pathInput the source `pathArray`\n * @return an array with all sub-path strings\n */\nconst splitPath = (pathInput: PathArray): PathArray[] => {\n const composite = [] as PathArray[];\n let path: PathArray;\n let pi = -1;\n let x = 0;\n let y = 0;\n let mx = 0;\n let my = 0;\n const params = { ...paramsParser };\n\n pathInput.forEach((seg) => {\n const [pathCommand] = seg;\n const absCommand = pathCommand.toUpperCase() as AbsoluteCommand;\n const relCommand = pathCommand.toLowerCase() as RelativeCommand;\n const isRelative = pathCommand === relCommand;\n const values = seg.slice(1) as number[];\n\n if (absCommand === \"M\") {\n pi += 1;\n [x, y] = values as PointTuple;\n x += isRelative ? params.x : 0;\n y += isRelative ? params.y : 0;\n mx = x;\n my = y;\n path = [(isRelative ? [absCommand, mx, my] : seg) as MSegment];\n } else {\n if (absCommand === \"Z\") {\n x = mx;\n y = my;\n } else if (absCommand === \"H\") {\n [, x] = seg as HSegment;\n x += isRelative ? params.x : /* istanbul ignore next @preserve */ 0;\n } else if (absCommand === \"V\") {\n [, y] = seg as VSegment;\n y += isRelative ? params.y : /* istanbul ignore next @preserve */ 0;\n } else {\n [x, y] = seg.slice(-2) as PointTuple;\n x += isRelative ? params.x : 0;\n y += isRelative ? params.y : 0;\n }\n path.push(seg);\n }\n\n params.x = x;\n params.y = y;\n composite[pi] = path;\n });\n\n return composite;\n};\nexport default splitPath;\n","import getSVGMatrix from \"./getSVGMatrix\";\nimport projection2d from \"./projection2d\";\nimport defaultOptions from \"../options/options\";\nimport type {\n AbsoluteArray,\n AbsoluteSegment,\n CSegment,\n LSegment,\n PathArray,\n TransformObjectValues,\n} from \"../types\";\nimport type { TransformObject } from \"../interface\";\nimport iterate from \"./iterate\";\nimport parsePathString from \"../parser/parsePathString\";\nimport absolutizeSegment from \"./absolutizeSegment\";\nimport arcToCubic from \"./arcToCubic\";\n\n/**\n * Apply a 2D / 3D transformation to a `pathArray` instance.\n *\n * Since *SVGElement* doesn't support 3D transformation, this function\n * creates a 2D projection of the element.\n *\n * @param path the `pathArray` to apply transformation\n * @param transform the transform functions `Object`\n * @returns the resulted `pathArray`\n */\nconst transformPath = (\n pathInput: PathArray | string,\n transform?: Partial,\n) => {\n // last x and y transformed values\n let x = 0;\n let y = 0;\n // new x and y transformed\n let lx = 0;\n let ly = 0;\n // segment params iteration index and length\n let j = 0;\n let jj = 0;\n let pathCommand = \"M\";\n // transform uses it's own set of params\n const path = parsePathString(pathInput);\n const transformProps = transform && Object.keys(transform);\n\n // when used as a static method, invalidate somehow\n if (!transform || (transformProps && !transformProps.length)) {\n return path.slice(0) as typeof path;\n }\n\n // transform origin is extremely important\n if (!transform.origin) {\n Object.assign(transform, { origin: defaultOptions.origin });\n }\n const origin = transform.origin as [number, number, number];\n const matrixInstance = getSVGMatrix(transform as TransformObjectValues);\n\n if (matrixInstance.isIdentity) return path.slice(0) as typeof path;\n\n return iterate(path, (seg, index, lastX, lastY) => {\n [pathCommand] = seg;\n const absCommand = pathCommand.toUpperCase();\n const isRelative = absCommand !== pathCommand;\n const absoluteSegment = isRelative\n ? absolutizeSegment(seg, index, lastX, lastY)\n : (seg.slice(0) as AbsoluteSegment);\n\n let result = absCommand === \"A\"\n // ? segmentToCubic(absoluteSegment, transformParams)\n ? ([\"C\" as string | number].concat(\n arcToCubic(\n lastX,\n lastY,\n absoluteSegment[1] as number,\n absoluteSegment[2] as number,\n absoluteSegment[3] as number,\n absoluteSegment[4] as number,\n absoluteSegment[5] as number,\n absoluteSegment[6] as number,\n absoluteSegment[7] as number,\n ),\n ) as CSegment)\n : absCommand === \"V\"\n ? ([\"L\", lastX, absoluteSegment[1]] as LSegment)\n : absCommand === \"H\"\n ? ([\"L\", absoluteSegment[1], lastY] as LSegment)\n : absoluteSegment;\n\n // update pathCommand\n pathCommand = result[0];\n const isLongArc = pathCommand === \"C\" && result.length > 7;\n const tempSegment =\n (isLongArc ? result.slice(0, 7) : result.slice(0)) as AbsoluteSegment;\n\n if (isLongArc) {\n path.splice(\n index + 1,\n 0,\n [\"C\" as typeof pathCommand | number].concat(\n result.slice(7),\n ) as CSegment,\n );\n result = tempSegment as CSegment;\n }\n\n if (pathCommand === \"L\") {\n [lx, ly] = projection2d(matrixInstance, [\n (result as LSegment)[1],\n (result as LSegment)[2],\n ], origin);\n\n /* istanbul ignore else @preserve */\n if (x !== lx && y !== ly) {\n result = [\"L\", lx, ly];\n } else if (y === ly) {\n result = [\"H\", lx];\n } else if (x === lx) {\n result = [\"V\", ly];\n }\n } else {\n for (j = 1, jj = result.length; j < jj; j += 2) {\n [lx, ly] = projection2d(\n matrixInstance,\n [+result[j], +result[j + 1]],\n origin,\n );\n result[j] = lx;\n result[j + 1] = ly;\n }\n }\n // now update x and y\n x = lx;\n y = ly;\n\n return result;\n });\n};\n\nexport default transformPath;\n","\"use strict\";\nimport * as util from \"./util\";\n// import CSSMatrix from \"@thednp/dommatrix\";\nimport type { PathArray, PointTuple, TransformObjectValues } from \"./types\";\nimport type { Options, TransformEntries, TransformObject } from \"./interface\";\nexport * from \"./types\";\nexport * from \"./interface\";\nimport defaultOptions from \"./options/options\";\n\nimport pathToAbsolute from \"./convert/pathToAbsolute\";\nimport pathToRelative from \"./convert/pathToRelative\";\nimport pathToCurve from \"./convert/pathToCurve\";\nimport pathToString from \"./convert/pathToString\";\n// import * as arcTools from \"./math/arcTools\";\n// import * as bezierTools from \"./math/bezier\";\n// import * as cubicTools from \"./math/cubicTools\";\n// import * as lineTools from \"./math/lineTools\";\n// import * as quadTools from \"./math/quadTools\";\n// import * as polygonTools from \"./math/polygonTools\";\n\n// import distanceSquareRoot from \"./math/distanceSquareRoot\";\n// import midPoint from \"./math/midPoint\";\n// import rotateVector from \"./math/rotateVector\";\n// import roundTo from \"./math/roundTo\";\n\nimport error from \"./parser/error\";\nimport parsePathString from \"./parser/parsePathString\";\n// import finalizeSegment from \"./parser/finalizeSegment\";\n// import invalidPathValue from \"./parser/invalidPathValue\";\n// import isArcCommand from \"./parser/isArcCommand\";\n// import isDigit from \"./parser/isDigit\";\n// import isDigitStart from \"./parser/isDigitStart\";\n// import isMoveCommand from \"./parser/isMoveCommand\";\n// import isPathCommand from \"./parser/isPathCommand\";\n// import isSpace from \"./parser/isSpace\";\n// import paramsCount from \"./parser/paramsCount\";\n// import paramsParser from \"./parser/paramsParser\";\n// import pathParser from \"./parser/pathParser\";\n// import scanFlag from \"./parser/scanFlag\";\n// import scanParam from \"./parser/scanParam\";\n// import scanSegment from \"./parser/scanSegment\";\n// import skipSpaces from \"./parser/skipSpaces\";\n\n// import distanceEpsilon from \"./util/distanceEpsilon\";\n// import getClosestPoint from \"./util/getClosestPoint\";\n// import getDrawDirection from \"./util/getDrawDirection\";\n// import getPathArea from \"./util/getPathArea\";\nimport getPathBBox from \"./util/getPathBBox\";\nimport getPointAtLength from \"./util/getPointAtLength\";\n// import getPropertiesAtLength from \"./util/getPropertiesAtLength\";\n// import getPropertiesAtPoint from \"./util/getPropertiesAtPoint\";\n// import getSegmentAtLength from \"./util/getSegmentAtLength\";\n// import getSegmentOfPoint from \"./util/getSegmentOfPoint\";\nimport getTotalLength from \"./util/getTotalLength\";\n\n// import isAbsoluteArray from \"./util/isAbsoluteArray\";\n// import isCurveArray from \"./util/isCurveArray\";\n// import isNormalizedArray from \"./util/isNormalizedArray\";\n// import isPathArray from \"./util/isPathArray\";\n// import isPointInStroke from \"./util/isPointInStroke\";\n// import isRelativeArray from \"./util/isRelativeArray\";\n// import isValidPath from \"./util/isValidPath\";\n// import shapeParams from \"./util/shapeParams\";\n// import shapeToPath from \"./util/shapeToPath\";\n// import shapeToPathArray from \"./util/shapeToPathArray\";\n\n// import absolutizeSegment from \"./process/absolutizeSegment\";\n// import arcToCubic from \"./process/arcToCubic\";\n// import getSVGMatrix from \"./process/getSVGMatrix\";\n// import iterate from \"./process/iterate\";\n// import lineToCubic from \"./process/lineToCubic\";\nimport normalizePath from \"./process/normalizePath\";\n// import normalizeSegment from \"./process/normalizeSegment\";\nimport optimizePath from \"./process/optimizePath\";\n// import projection2d from \"./process/projection2d\";\n// import quadToCubic from \"./process/quadToCubic\";\n// import relativizeSegment from \"./process/relativizeSegment\";\n// import reverseCurve from \"./process/reverseCurve\";\nimport reversePath from \"./process/reversePath\";\n// import roundPath from \"./process/roundPath\";\n// import roundSegment from \"./process/roundSegment\";\n// import segmentToCubic from \"./process/segmentToCubic\";\n// import shortenSegment from \"./process/shortenSegment\";\n// import splitCubic from \"./process/splitCubic\";\nimport splitPath from \"./process/splitPath\";\nimport transformPath from \"./process/transformPath\";\n\n/**\n * Creates a new SVGPathCommander instance with the following properties:\n * * segments: `pathArray`\n * * round: number\n * * origin: [number, number, number?]\n *\n * @class\n * @author thednp \n * @returns a new SVGPathCommander instance\n */\nclass SVGPathCommander {\n // declare class properties\n declare segments: PathArray;\n declare round: number | \"off\";\n declare origin: [number, number, number];\n\n /**\n * @constructor\n * @param pathValue the path string\n * @param config instance options\n */\n constructor(pathValue: string, config?: Partial) {\n const instanceOptions = config || {};\n const undefPath = typeof pathValue === \"undefined\";\n\n if (undefPath || !pathValue.length) {\n throw TypeError(\n `${error}: \"pathValue\" is ${undefPath ? \"undefined\" : \"empty\"}`,\n );\n }\n\n this.segments = parsePathString(pathValue);\n\n // // set instance options.round\n const { round: roundOption, origin: originOption } = instanceOptions;\n let round: number | \"off\";\n\n if (Number.isInteger(roundOption) || roundOption === \"off\") {\n round = roundOption as number | \"off\";\n } else {\n round = defaultOptions.round as number;\n }\n\n // set instance options.origin\n // the SVGPathCommander class will always override the default origin\n let origin = defaultOptions.origin as [number, number, number];\n /* istanbul ignore else @preserve */\n if (Array.isArray(originOption) && originOption.length >= 2) {\n const [originX, originY, originZ] = originOption.map(Number);\n origin = [\n !Number.isNaN(originX) ? originX : 0,\n !Number.isNaN(originY) ? originY : 0,\n !Number.isNaN(originZ) ? originZ : 0,\n ];\n }\n\n this.round = round;\n this.origin = origin;\n\n return this;\n }\n get bbox() {\n return getPathBBox(this.segments);\n }\n get length() {\n return getTotalLength(this.segments);\n }\n\n /**\n * Returns the path bounding box, equivalent to native `path.getBBox()`.\n *\n * @public\n * @returns the pathBBox\n */\n getBBox() {\n return this.bbox;\n }\n\n /**\n * Returns the total path length, equivalent to native `path.getTotalLength()`.\n *\n * @public\n * @returns the path total length\n */\n getTotalLength() {\n return this.length;\n }\n\n /**\n * Returns an `{x,y}` point in the path stroke at a given length,\n * equivalent to the native `path.getPointAtLength()`.\n *\n * @public\n * @param length the length\n * @returns the requested point\n */\n getPointAtLength(length: number) {\n return getPointAtLength(this.segments, length);\n }\n\n /**\n * Convert path to absolute values\n *\n * @public\n */\n toAbsolute() {\n const { segments } = this;\n this.segments = pathToAbsolute(segments);\n return this;\n }\n\n /**\n * Convert path to relative values\n *\n * @public\n */\n toRelative() {\n const { segments } = this;\n this.segments = pathToRelative(segments);\n return this;\n }\n\n /**\n * Convert path to cubic-bezier values. In addition, un-necessary `Z`\n * segment is removed if previous segment extends to the `M` segment.\n *\n * @public\n */\n toCurve() {\n const { segments } = this;\n this.segments = pathToCurve(segments);\n return this;\n }\n\n /**\n * Reverse the order of the segments and their values.\n *\n * @param onlySubpath option to reverse all sub-paths except first\n * @public\n */\n reverse(onlySubpath?: boolean) {\n const { segments } = this;\n const split = splitPath(segments);\n const subPath = split.length > 1 ? split : false;\n\n const absoluteMultiPath = subPath\n ? subPath.map((x, i) => {\n if (onlySubpath) {\n return i ? reversePath(x) : x.slice(0);\n }\n return reversePath(x);\n })\n : segments.slice(0);\n\n let path = [] as unknown as PathArray;\n if (subPath) {\n path = absoluteMultiPath.flat(1) as PathArray;\n } else {\n path = onlySubpath ? segments : reversePath(segments);\n }\n\n this.segments = path.slice(0) as PathArray;\n return this;\n }\n\n /**\n * Normalize path in 2 steps:\n * * convert `pathArray`(s) to absolute values\n * * convert shorthand notation to standard notation\n *\n * @public\n */\n normalize() {\n const { segments } = this;\n this.segments = normalizePath(segments);\n return this;\n }\n\n /**\n * Optimize `pathArray` values:\n * * convert segments to absolute and/or relative values\n * * select segments with shortest resulted string\n * * round values to the specified `decimals` option value\n *\n * @public\n */\n optimize() {\n const { segments } = this;\n const round = this.round === \"off\" ? 2 : this.round;\n\n this.segments = optimizePath(segments, round);\n return this;\n }\n\n /**\n * Transform path using values from an `Object` defined as `transformObject`.\n *\n * @see TransformObject for a quick refference\n *\n * @param source a `transformObject`as described above\n * @public\n */\n transform(source?: Partial) {\n if (\n !source ||\n typeof source !== \"object\" ||\n (typeof source === \"object\" &&\n ![\"translate\", \"rotate\", \"skew\", \"scale\"].some((x) => x in source))\n ) {\n return this;\n }\n\n const {\n segments,\n origin: [cx, cy, cz],\n } = this;\n const transform = {} as TransformObjectValues;\n for (const [k, v] of Object.entries(source) as TransformEntries) {\n // istanbul ignore else @preserve\n if (k === \"skew\" && Array.isArray(v)) {\n transform[k] = v.map(Number) as PointTuple;\n } else if (\n (k === \"rotate\" || k === \"translate\" || k === \"origin\" ||\n k === \"scale\") && Array.isArray(v)\n ) {\n transform[k] = v.map(Number) as [number, number, number];\n } else if (k !== \"origin\" && typeof Number(v) === \"number\") {\n transform[k] = Number(v);\n }\n }\n\n // if origin is not specified\n // it's important that we have one\n const { origin } = transform;\n\n if (Array.isArray(origin) && origin.length >= 2) {\n const [originX, originY, originZ] = origin.map(Number);\n transform.origin = [\n !Number.isNaN(originX) ? originX : cx,\n !Number.isNaN(originY) ? originY : cy,\n originZ || cz,\n ];\n } else {\n transform.origin = [cx, cy, cz];\n }\n\n this.segments = transformPath(segments, transform);\n return this;\n }\n\n /**\n * Rotate path 180deg vertically\n *\n * @public\n */\n flipX() {\n const { cx, cy } = this.bbox;\n this.transform({ rotate: [0, 180, 0], origin: [cx, cy, 0] });\n return this;\n }\n\n /**\n * Rotate path 180deg horizontally\n *\n * @public\n */\n flipY() {\n const { cx, cy } = this.bbox;\n this.transform({ rotate: [180, 0, 0], origin: [cx, cy, 0] });\n return this;\n }\n\n /**\n * Export the current path to be used\n * for the `d` (description) attribute.\n *\n * @public\n * @return the path string\n */\n toString() {\n return pathToString(this.segments, this.round);\n }\n\n /**\n * Remove the instance.\n *\n * @public\n * @return void\n */\n dispose() {\n Object.keys(this).forEach((key) => delete this[key as keyof typeof this]);\n }\n}\n\n// export {\n// absolutizeSegment,\n// arcToCubic,\n// arcTools,\n// bezierTools,\n// CSSMatrix,\n// cubicTools,\n// distanceEpsilon,\n// distanceSquareRoot,\n// finalizeSegment,\n// getClosestPoint,\n// getDrawDirection,\n// getPathArea,\n// getPathBBox,\n// getPointAtLength,\n// getPropertiesAtLength,\n// getPropertiesAtPoint,\n// getSegmentAtLength,\n// getSegmentOfPoint,\n// getSVGMatrix,\n// getTotalLength,\n// invalidPathValue,\n// isAbsoluteArray,\n// isArcCommand,\n// isCurveArray,\n// isDigit,\n// isDigitStart,\n// isMoveCommand,\n// isNormalizedArray,\n// isPathArray,\n// isPathCommand,\n// isPointInStroke,\n// isRelativeArray,\n// isSpace,\n// isValidPath,\n// iterate,\n// lineToCubic,\n// lineTools,\n// midPoint,\n// normalizePath,\n// normalizeSegment,\n// optimizePath,\n// paramsCount,\n// paramsParser,\n// parsePathString,\n// pathParser,\n// pathToAbsolute,\n// pathToCurve,\n// pathToRelative,\n// pathToString,\n// polygonTools,\n// projection2d,\n// quadToCubic,\n// quadTools,\n// relativizeSegment,\n// reverseCurve,\n// reversePath,\n// rotateVector,\n// roundPath,\n// roundSegment,\n// roundTo,\n// scanFlag,\n// scanParam,\n// scanSegment,\n// segmentToCubic,\n// shapeParams,\n// shapeToPath,\n// shapeToPathArray,\n// shortenSegment,\n// skipSpaces,\n// splitCubic,\n// splitPath,\n// // SVGPathCommander as default,\n// transformPath,\n// };\n\n// const index = {\n// absolutizeSegment,\n// arcToCubic,\n// arcTools,\n// bezierTools,\n// CSSMatrix,\n// cubicTools,\n// distanceEpsilon,\n// distanceSquareRoot,\n// finalizeSegment,\n// getClosestPoint,\n// getDrawDirection,\n// getPathArea,\n// getPathBBox,\n// getPointAtLength,\n// getPropertiesAtLength,\n// getPropertiesAtPoint,\n// getSegmentAtLength,\n// getSegmentOfPoint,\n// getSVGMatrix,\n// getTotalLength,\n// invalidPathValue,\n// isAbsoluteArray,\n// isArcCommand,\n// isCurveArray,\n// isDigit,\n// isDigitStart,\n// isMoveCommand,\n// isNormalizedArray,\n// isPathArray,\n// isPathCommand,\n// isPointInStroke,\n// isRelativeArray,\n// isSpace,\n// isValidPath,\n// iterate,\n// lineToCubic,\n// lineTools,\n// midPoint,\n// normalizePath,\n// normalizeSegment,\n// optimizePath,\n// paramsCount,\n// paramsParser,\n// parsePathString,\n// pathParser,\n// pathToAbsolute,\n// pathToCurve,\n// pathToRelative,\n// pathToString,\n// polygonTools,\n// projection2d,\n// quadToCubic,\n// quadTools,\n// relativizeSegment,\n// reverseCurve,\n// reversePath,\n// rotateVector,\n// roundPath,\n// roundSegment,\n// roundTo,\n// scanFlag,\n// scanParam,\n// scanSegment,\n// segmentToCubic,\n// shapeParams,\n// shapeToPath,\n// shapeToPathArray,\n// shortenSegment,\n// skipSpaces,\n// splitCubic,\n// splitPath,\n// transformPath,\n// };\n\n// export { absolutizeSegment }\n// export { arcToCubic }\n// export { arcTools }\n// export { bezierTools }\n// export { CSSMatrix }\n// export { cubicTools }\n// export { distanceEpsilon }\n// export { distanceSquareRoot }\n// export { finalizeSegment }\n// export { getClosestPoint }\n// export { getDrawDirection }\n// export { getPathArea }\n// export { getPathBBox }\n// export { getPointAtLength }\n// export { getPropertiesAtLength }\n// export { getPropertiesAtPoint }\n// export { getSegmentAtLength }\n// export { getSegmentOfPoint }\n// export { getSVGMatrix }\n// export { getTotalLength }\n// export { invalidPathValue }\n// export { isAbsoluteArray }\n// export { isArcCommand }\n// export { isCurveArray }\n// export { isDigit }\n// export { isDigitStart }\n// export { isMoveCommand }\n// export { isNormalizedArray }\n// export { isPathArray }\n// export { isPathCommand }\n// export { isPointInStroke }\n// export { isRelativeArray }\n// export { isSpace }\n// export { isValidPath }\n// export { iterate }\n// export { lineToCubic }\n// export { lineTools }\n// export { midPoint }\n// export { normalizePath }\n// export { normalizeSegment }\n// export { optimizePath }\n// export { paramsCount }\n// export { paramsParser }\n// export { parsePathString }\n// export { pathParser }\n// export { pathToAbsolute }\n// export { pathToCurve }\n// export { pathToRelative }\n// export { pathToString }\n// export { polygonTools }\n// export { projection2d }\n// export { quadToCubic }\n// export { quadTools }\n// export { relativizeSegment }\n// export { reverseCurve }\n// export { reversePath }\n// export { rotateVector }\n// export { roundPath }\n// export { roundSegment }\n// export { roundTo }\n// export { scanFlag }\n// export { scanParam }\n// export { scanSegment }\n// export { segmentToCubic }\n// export { shapeParams }\n// export { shapeToPath }\n// export { shapeToPathArray }\n// export { shortenSegment }\n// export { skipSpaces }\n// export { splitCubic }\n// export { splitPath }\n// export { transformPath }\n// export { SVGPathCommander as default }\n// export default SVGPathCommander;\nconst defaultExport = Object.assign(SVGPathCommander, util);\n\nexport { defaultExport as default };\n// export default Object.assign(SVGPathCommander, index);\n"],"mappings":"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","names":["util_exports","__export","default","absolutizeSegment_default","arcToCubic_default","arcTools_exports","bezier_exports","cubicTools_exports","distanceEpsilon_default","distanceSquareRoot_default","finalizeSegment_default","getClosestPoint_default","getDrawDirection_default","getPathArea_default","getPathBBox_default","getPointAtLength_default","getPropertiesAtLength_default","getPropertiesAtPoint_default","getSVGMatrix_default","getSegmentAtLength_default","getSegmentOfPoint_default","getTotalLength_default","invalidPathValue_default","isAbsoluteArray_default","isArcCommand_default","isCurveArray_default","isDigit_default","isDigitStart_default","isMoveCommand_default","isNormalizedArray_default","isPathArray_default","isPathCommand_default","isPointInStroke_default","isRelativeArray_default","isSpace_default","isValidPath_default","iterate_default","lineToCubic_default","lineTools_exports","midPoint_default","normalizePath_default","normalizeSegment_default","optimizePath_default","paramsCount_default","paramsParser_default","parsePathString_default","PathParser","pathToAbsolute_default","pathToCurve_default","pathToRelative_default","pathToString_default","polygonTools_exports","projection2d_default","quadToCubic_default","quadTools_exports","relativizeSegment_default","reverseCurve_default","reversePath_default","rotateVector_default","roundPath_default","roundSegment_default","roundTo_default","scanFlag_default","scanParam_default","scanSegment_default","segmentToCubic_default","shapeParams_default","shapeToPath_default","shapeToPathArray_default","shortenSegment_default","skipSpaces_default","splitCubic_default","splitPath_default","transformPath_default","arcTools_exports","__export","angleBetween","arcLength","arcPoint","getArcBBox","getArcLength","getArcProps","getPointAtArcLength","lineTools_exports","__export","getLineBBox","getLineLength","getPointAtLineLength","midPoint","a","b","t","ax","ay","bx","by","midPoint_default","distanceSquareRoot","a","b","distanceSquareRoot_default","getLineLength","x1","y1","x2","y2","distanceSquareRoot_default","getPointAtLineLength","distance","point","length","x","y","midPoint_default","getLineBBox","min","max","arcLength","rx","ry","theta","halfTheta","sinHalfTheta","cosHalfTheta","term1","term2","length","arcPoint","cx","cy","alpha","sin","cos","cosA","sinA","x","y","angleBetween","v0","v1","v0x","v0y","v1x","v1y","p","n","getArcProps","x1","y1","RX","RY","angle","LAF","SF","abs","sqrt","PI","xRotRad","dx","dy","transformedPoint","radiiCheck","cSquareNumerator","cSquareRootDenom","cRadicand","cCoef","transformedCenter","center","startVector","startAngle","endVector","sweepAngle","endAngle","getArcLength","getPointAtArcLength","distance","point","getPointAtLineLength","ellipseComponentX","ellipseComponentY","getArcBBox","deltaAngle","min","max","tan","atan2","tangent","angle1","angle2","angle3","angle4","xArray","yArray","xMin","xMax","yMin","yMax","angleAfterStart","pP2","angleBeforeEnd","pP3","p1","p2","p4","p3","bezier_exports","__export","CBEZIER_MINMAX_EPSILON","Cvalues","Tvalues","bezierLength","calculateBezier","computeBezier","deriveBezier","getBezierLength","minmaxC","minmaxQ","points","dpoints","p","d","c","list","j","t","order","mt","mt2","t2","a","b","derivativeFn","l","len","sum","i","curve","idx","step","v1","cp","v2","min","max","E","cp1","cp2","K","T","S","L","R","Q","cubicTools_exports","__export","getCubicBBox","getCubicLength","getPointAtCubicLength","getPointAtCubicSegmentLength","getPointAtCubicSegmentLength","x1","y1","c1x","c1y","c2x","c2y","x2","y2","t","t1","getCubicLength","getBezierLength","getPointAtCubicLength","distance","distanceIsNumber","point","currentLength","getCubicBBox","cxMinMax","minmaxC","cyMinMax","quadTools_exports","__export","getPointAtQuadLength","getPointAtQuadSegmentLength","getQuadBBox","getQuadLength","getPointAtQuadSegmentLength","x1","y1","cx","cy","x2","y2","t","t1","getQuadLength","getBezierLength","getPointAtQuadLength","distance","distanceIsNumber","point","currentLength","getQuadBBox","cxMinMax","minmaxQ","cyMinMax","polygonTools_exports","__export","polygonArea","polygonLength","polygonArea","polygon","n","i","a","b","area","polygonLength","length","point","distanceSquareRoot_default","paramsCount","paramsCount_default","finalizeSegment","path","pathCommand","relativeCommand","data","paramsCount_default","finalizeSegment_default","error","error_default","scanFlag","path","index","pathValue","code","error_default","scanFlag_default","isDigit","code","isDigit_default","invalidPathValue","invalidPathValue_default","scanParam","path","max","pathValue","start","index","zeroFirst","hasCeiling","hasDecimal","hasDot","ch","error_default","invalidPathValue_default","isDigit_default","scanParam_default","isSpace","ch","isSpace_default","skipSpaces","path","pathValue","max","isSpace_default","skipSpaces_default","isPathCommand","code","isPathCommand_default","isDigitStart","code","isDigit_default","isDigitStart_default","isArcCommand","code","isArcCommand_default","isMoveCommand","code","isMoveCommand_default","scanSegment","path","max","pathValue","index","segments","cmdCode","reqParams","paramsCount_default","isPathCommand_default","error_default","invalidPathValue_default","lastSegment","isMoveCommand_default","skipSpaces_default","finalizeSegment_default","i","isArcCommand_default","scanFlag_default","scanParam_default","isDigitStart_default","scanSegment_default","PathParser","pathString","parsePathString","pathInput","path","PathParser","skipSpaces_default","scanSegment_default","parsePathString_default","absolutizeSegment","segment","index","lastX","lastY","pathCommand","absCommand","isAbsolute","absValues","seglen","j","absolutizeSegment_default","iterate","path","iterator","pathLen","segment","pathCommand","absCommand","isRelative","x","y","mx","my","segLen","i","iteratorResult","iterate_default","pathToAbsolute","pathInput","path","parsePathString_default","iterate_default","absolutizeSegment_default","pathToAbsolute_default","relativizeSegment","segment","index","lastX","lastY","pathCommand","relCommand","isRelative","relValues","seglen","j","relativizeSegment_default","pathToRelative","pathInput","path","parsePathString_default","iterate_default","relativizeSegment_default","pathToRelative_default","rotateVector","x","y","rad","sin","cos","X","Y","rotateVector_default","arcToCubic","X1","Y1","RX","RY","angle","LAF","SF","X2","Y2","recursive","x1","y1","rx","ry","x2","y2","d120","rad","res","xy","f1","f2","cx","cy","rotateVector_default","x","y","h","rx2","ry2","k","df","f2old","x2old","y2old","c1","s1","c2","s2","t","hx","hy","m1","m2","m3","m4","newres","i","ii","arcToCubic_default","quadToCubic","x1","y1","qx","qy","x2","y2","r13","r23","quadToCubic_default","lineToCubic","x1","y1","x2","y2","c1","midPoint_default","c2","lineToCubic_default","segmentToCubic","segment","params","pathCommand","values","x","y","px1","py1","px","py","arcToCubic_default","quadToCubic_default","lineToCubic_default","segmentToCubic_default","normalizeSegment","segment","params","pathCommand","absCommand","isRelative","px1","py1","px2","py2","x","y","values","absValues","n","j","x1","y1","qx","qy","nqx","nqy","normalizeSegment_default","paramsParser","paramsParser_default","pathToCurve","pathInput","params","paramsParser_default","path","parsePathString_default","iterate_default","seg","index","lastX","lastY","normalSegment","normalizeSegment_default","result","segmentToCubic_default","seglen","pathToCurve_default","defaultOptions","options_default","roundTo","n","round","pow","roundTo_default","pathToString","path","roundOption","pathLen","round","options_default","segment","result","i","pathCommand","values","j","valLen","roundTo_default","pathToString_default","distanceEpsilon_default","normalizePath","pathInput","path","parsePathString_default","params","paramsParser_default","iterate_default","seg","_","lastX","lastY","result","normalizeSegment_default","seglen","normalizePath_default","getPointAtLength","pathInput","distance","path","normalizePath_default","isM","data","pathCommand","x","y","mx","my","distanceIsNumber","point","length","POINT","totalLength","distanceEpsilon_default","iterate_default","seg","_","lastX","lastY","getPointAtLineLength","getLineLength","getPointAtArcLength","getArcLength","getPointAtCubicLength","getCubicLength","getPointAtQuadLength","getQuadLength","getPointAtLength_default","getTotalLength","pathInput","path","parsePathString_default","paramX1","paramY1","paramX2","paramY2","paramQX","paramQY","pathCommand","mx","my","totalLength","iterate_default","seg","index","lastX","lastY","absCommand","absoluteSegment","absolutizeSegment_default","normalSegment","getLineLength","getArcLength","cp1x","cp1y","getCubicLength","getQuadLength","getTotalLength_default","getPropertiesAtLength","pathInput","distance","pathArray","parsePathString_default","pathTemp","pathLength","getTotalLength_default","index","lengthAtSegment","length","segment","segments","getPropertiesAtLength_default","getPropertiesAtPoint","pathInput","point","path","parsePathString_default","normalPath","normalizePath_default","pathLength","getTotalLength_default","distanceTo","p","dx","dy","precision","scan","closest","scanDistance","bestLength","bestDistance","scanLength","getPointAtLength_default","before","after","beforeLength","afterLength","beforeDistance","afterDistance","segment","getPropertiesAtLength_default","distance","getPropertiesAtPoint_default","getClosestPoint","pathInput","point","getPropertiesAtPoint_default","getClosestPoint_default","getCubicSegArea","x1","y1","c1x","c1y","c2x","c2y","x2","y2","getPathArea","path","x","y","len","pathToCurve_default","seg","a","b","getPathArea_default","getDrawDirection","path","getPathArea_default","pathToCurve_default","getDrawDirection_default","getPathBBox","pathInput","path","parsePathString_default","pathCommand","mx","my","max","min","xMin","yMin","xMax","yMax","minX","minY","maxX","maxY","paramX1","paramY1","paramX2","paramY2","paramQX","paramQY","iterate_default","seg","index","lastX","lastY","absCommand","absoluteSegment","absolutizeSegment_default","normalSegment","getLineBBox","getArcBBox","cp1x","cp1y","getCubicBBox","getQuadBBox","width","height","getPathBBox_default","getSegmentAtLength","pathInput","distance","getPropertiesAtLength_default","getSegmentAtLength_default","getSegmentOfPoint","path","point","getPropertiesAtPoint_default","getSegmentOfPoint_default","isPathArray","path","seg","lk","paramsCount_default","isPathArray_default","isAbsoluteArray","path","isPathArray_default","x","isAbsoluteArray_default","isNormalizedArray","path","isAbsoluteArray_default","pc","isNormalizedArray_default","isCurveArray","path","isNormalizedArray_default","pc","isCurveArray_default","isPointInStroke","pathInput","point","distance","getPropertiesAtPoint_default","distanceEpsilon_default","isPointInStroke_default","isRelativeArray","path","isPathArray_default","pc","isRelativeArray_default","isValidPath","pathString","path","PathParser","skipSpaces_default","scanSegment_default","isValidPath_default","shapeParams","shapeParams_default","isElement","node","isElement_default","getLinePath","attr","x1","y1","x2","y2","a","getPolyPath","pathArray","points","index","getCirclePath","cx","cy","r","getEllipsePath","rx","ry","getRectanglePath","x","y","w","h","shapeToPathArray","element","supportedShapes","shapeParams_default","targetIsElement","isElement_default","tagName","s","error_default","type","shapeAttrs","config","p","parsePathString_default","isPathArray_default","shapeToPathArray_default","shapeToPath","element","replace","ownerDocument","doc","supportedShapes","shapeParams_default","targetIsElement","isElement_default","tagName","error_default","s","path","type","shapeAttrs","config","round","options_default","pathArray","shapeToPathArray_default","description","pathToString_default","p","name","value","k","m","isValidPath_default","shapeToPath_default","CSSMatrix","getSVGMatrix","transform","matrix","origin","originX","originY","translate","rotate","skew","scale","x","getSVGMatrix_default","shortenSegment","segment","normalSegment","params","prevCommand","pathCommand","defaultRound","options_default","round","normalValues","x1","y1","x2","y2","x","y","nx","ny","result","roundTo_default","nx1","ny1","qx","qy","shortenSegment_default","roundSegment","segment","roundOption","values","n","roundTo_default","roundSegment_default","optimizePath","pathInput","roundOption","path","pathToAbsolute_default","round","optimParams","paramsParser_default","allPathCommands","pathCommand","prevCommand","iterate_default","seg","i","lastX","lastY","normalizedSegment","normalizeSegment_default","result","shortSegment","shortenSegment_default","absSegment","roundSegment_default","absString","relativeSegment","relativizeSegment_default","relSegment","relString","seglen","optimizePath_default","CSSMatrix","translatePoint","cssm","v","m","projection2d","point2D","origin","originX","originY","originZ","x","y","z","relativePositionX","relativePositionY","relativePositionZ","projection2d_default","reverseCurve","path","rotatedCurve","x","i","curveOnly","_","reverseCurve_default","reversePath","pathInput","absolutePath","pathToAbsolute_default","normalizedPath","normalizePath_default","pLen","isClosed","reversedPath","iterate_default","segment","normalizedSegment","prevSeg","prevCommand","nextSeg","nextCommand","pathCommand","x","y","result","reversePath_default","roundPath","path","roundOption","round","options_default","iterate_default","segment","roundSegment_default","roundPath_default","splitCubic","pts","ratio","t","p0","p1","p2","p3","p4","midPoint_default","p5","p6","p7","p8","p9","splitCubic_default","splitPath","pathInput","composite","path","pi","x","y","mx","my","params","paramsParser_default","seg","pathCommand","absCommand","relCommand","isRelative","values","splitPath_default","transformPath","pathInput","transform","x","y","lx","ly","j","jj","pathCommand","path","parsePathString_default","transformProps","options_default","origin","matrixInstance","getSVGMatrix_default","iterate_default","seg","index","lastX","lastY","absCommand","absoluteSegment","absolutizeSegment_default","result","arcToCubic_default","isLongArc","tempSegment","projection2d_default","transformPath_default","SVGPathCommander","pathValue","config","instanceOptions","undefPath","error_default","parsePathString_default","roundOption","originOption","round","options_default","origin","originX","originY","originZ","getPathBBox_default","getTotalLength_default","length","getPointAtLength_default","segments","pathToAbsolute_default","pathToRelative_default","pathToCurve_default","onlySubpath","split","splitPath_default","subPath","absoluteMultiPath","x","i","reversePath_default","path","normalizePath_default","optimizePath_default","source","cx","cy","cz","transform","k","v","transformPath_default","pathToString_default","key","defaultExport","util_exports"]} \ No newline at end of file diff --git a/dist/util/util.cjs b/dist/util/util.cjs index 06bac33..c615acc 100644 --- a/dist/util/util.cjs +++ b/dist/util/util.cjs @@ -1,2 +1,2 @@ -"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});var zt=Object.defineProperty,qt=(t,e,r)=>e in t?zt(t,e,{enumerable:!0,configurable:!0,writable:!0,value:r}):t[e]=r,I=(t,e,r)=>qt(t,typeof e!="symbol"?e+"":e,r);const $t={a:1,b:0,c:0,d:1,e:0,f:0,m11:1,m12:0,m13:0,m14:0,m21:0,m22:1,m23:0,m24:0,m31:0,m32:0,m33:1,m34:0,m41:0,m42:0,m43:0,m44:1,is2D:!0,isIdentity:!0},Be=t=>(t instanceof Float64Array||t instanceof Float32Array||Array.isArray(t)&&t.every(e=>typeof e=="number"))&&[6,16].some(e=>t.length===e),He=t=>t instanceof DOMMatrix||t instanceof S||typeof t=="object"&&Object.keys($t).every(e=>t&&e in t),re=t=>{const e=new S,r=Array.from(t);if(!Be(r))throw TypeError(`CSSMatrix: "${r.join(",")}" must be an array with 6/16 numbers.`);if(r.length===16){const[o,n,s,i,a,c,l,u,h,f,y,m,d,p,b,M]=r;e.m11=o,e.a=o,e.m21=a,e.c=a,e.m31=h,e.m41=d,e.e=d,e.m12=n,e.b=n,e.m22=c,e.d=c,e.m32=f,e.m42=p,e.f=p,e.m13=s,e.m23=l,e.m33=y,e.m43=b,e.m14=i,e.m24=u,e.m34=m,e.m44=M}else if(r.length===6){const[o,n,s,i,a,c]=r;e.m11=o,e.a=o,e.m12=n,e.b=n,e.m21=s,e.c=s,e.m22=i,e.d=i,e.m41=a,e.e=a,e.m42=c,e.f=c}return e},Fe=t=>{if(He(t))return re([t.m11,t.m12,t.m13,t.m14,t.m21,t.m22,t.m23,t.m24,t.m31,t.m32,t.m33,t.m34,t.m41,t.m42,t.m43,t.m44]);throw TypeError(`CSSMatrix: "${JSON.stringify(t)}" is not a DOMMatrix / CSSMatrix / JSON compatible object.`)},Ue=t=>{if(typeof t!="string")throw TypeError(`CSSMatrix: "${JSON.stringify(t)}" is not a string.`);const e=String(t).replace(/\s/g,"");let r=new S;const o=`CSSMatrix: invalid transform string "${t}"`;return e.split(")").filter(n=>n).forEach(n=>{const[s,i]=n.split("(");if(!i)throw TypeError(o);const a=i.split(",").map(m=>m.includes("rad")?parseFloat(m)*(180/Math.PI):parseFloat(m)),[c,l,u,h]=a,f=[c,l,u],y=[c,l,u,h];if(s==="perspective"&&c&&[l,u].every(m=>m===void 0))r.m34=-1/c;else if(s.includes("matrix")&&[6,16].includes(a.length)&&a.every(m=>!Number.isNaN(+m))){const m=a.map(d=>Math.abs(d)<1e-6?0:d);r=r.multiply(re(m))}else if(s==="translate3d"&&f.every(m=>!Number.isNaN(+m)))r=r.translate(c,l,u);else if(s==="translate"&&c&&u===void 0)r=r.translate(c,l||0,0);else if(s==="rotate3d"&&y.every(m=>!Number.isNaN(+m))&&h)r=r.rotateAxisAngle(c,l,u,h);else if(s==="rotate"&&c&&[l,u].every(m=>m===void 0))r=r.rotate(0,0,c);else if(s==="scale3d"&&f.every(m=>!Number.isNaN(+m))&&f.some(m=>m!==1))r=r.scale(c,l,u);else if(s==="scale"&&!Number.isNaN(c)&&(c!==1||l!==1)&&u===void 0){const m=Number.isNaN(+l)?c:l;r=r.scale(c,m,1)}else if(s==="skew"&&(c||!Number.isNaN(c)&&l)&&u===void 0)r=r.skew(c,l||0);else if(["translate","rotate","scale","skew"].some(m=>s.includes(m))&&/[XYZ]/.test(s)&&c&&[l,u].every(m=>m===void 0))if(s==="skewX"||s==="skewY")r=r[s](c);else{const m=s.replace(/[XYZ]/,""),d=s.replace(m,""),p=["X","Y","Z"].indexOf(d),b=m==="scale"?1:0,M=[p===0?c:b,p===1?c:b,p===2?c:b];r=r[m](...M)}else throw TypeError(o)}),r},Se=(t,e)=>e?[t.a,t.b,t.c,t.d,t.e,t.f]:[t.m11,t.m12,t.m13,t.m14,t.m21,t.m22,t.m23,t.m24,t.m31,t.m32,t.m33,t.m34,t.m41,t.m42,t.m43,t.m44],Ge=(t,e,r)=>{const o=new S;return o.m41=t,o.e=t,o.m42=e,o.f=e,o.m43=r,o},Je=(t,e,r)=>{const o=new S,n=Math.PI/180,s=t*n,i=e*n,a=r*n,c=Math.cos(s),l=-Math.sin(s),u=Math.cos(i),h=-Math.sin(i),f=Math.cos(a),y=-Math.sin(a),m=u*f,d=-u*y;o.m11=m,o.a=m,o.m12=d,o.b=d,o.m13=h;const p=l*h*f+c*y;o.m21=p,o.c=p;const b=c*f-l*h*y;return o.m22=b,o.d=b,o.m23=-l*u,o.m31=l*y-c*h*f,o.m32=l*f+c*h*y,o.m33=c*u,o},Ke=(t,e,r,o)=>{const n=new S,s=Math.sqrt(t*t+e*e+r*r);if(s===0)return n;const i=t/s,a=e/s,c=r/s,l=o*(Math.PI/360),u=Math.sin(l),h=Math.cos(l),f=u*u,y=i*i,m=a*a,d=c*c,p=1-2*(m+d)*f;n.m11=p,n.a=p;const b=2*(i*a*f+c*u*h);n.m12=b,n.b=b,n.m13=2*(i*c*f-a*u*h);const M=2*(a*i*f-c*u*h);n.m21=M,n.c=M;const g=1-2*(d+y)*f;return n.m22=g,n.d=g,n.m23=2*(a*c*f+i*u*h),n.m31=2*(c*i*f+a*u*h),n.m32=2*(c*a*f-i*u*h),n.m33=1-2*(y+m)*f,n},We=(t,e,r)=>{const o=new S;return o.m11=t,o.a=t,o.m22=e,o.d=e,o.m33=r,o},ye=(t,e)=>{const r=new S;if(t){const o=t*Math.PI/180,n=Math.tan(o);r.m21=n,r.c=n}if(e){const o=e*Math.PI/180,n=Math.tan(o);r.m12=n,r.b=n}return r},Xe=t=>ye(t,0),Ye=t=>ye(0,t),B=(t,e)=>{const r=e.m11*t.m11+e.m12*t.m21+e.m13*t.m31+e.m14*t.m41,o=e.m11*t.m12+e.m12*t.m22+e.m13*t.m32+e.m14*t.m42,n=e.m11*t.m13+e.m12*t.m23+e.m13*t.m33+e.m14*t.m43,s=e.m11*t.m14+e.m12*t.m24+e.m13*t.m34+e.m14*t.m44,i=e.m21*t.m11+e.m22*t.m21+e.m23*t.m31+e.m24*t.m41,a=e.m21*t.m12+e.m22*t.m22+e.m23*t.m32+e.m24*t.m42,c=e.m21*t.m13+e.m22*t.m23+e.m23*t.m33+e.m24*t.m43,l=e.m21*t.m14+e.m22*t.m24+e.m23*t.m34+e.m24*t.m44,u=e.m31*t.m11+e.m32*t.m21+e.m33*t.m31+e.m34*t.m41,h=e.m31*t.m12+e.m32*t.m22+e.m33*t.m32+e.m34*t.m42,f=e.m31*t.m13+e.m32*t.m23+e.m33*t.m33+e.m34*t.m43,y=e.m31*t.m14+e.m32*t.m24+e.m33*t.m34+e.m34*t.m44,m=e.m41*t.m11+e.m42*t.m21+e.m43*t.m31+e.m44*t.m41,d=e.m41*t.m12+e.m42*t.m22+e.m43*t.m32+e.m44*t.m42,p=e.m41*t.m13+e.m42*t.m23+e.m43*t.m33+e.m44*t.m43,b=e.m41*t.m14+e.m42*t.m24+e.m43*t.m34+e.m44*t.m44;return re([r,o,n,s,i,a,c,l,u,h,f,y,m,d,p,b])};class S{constructor(e){return this.a=1,this.b=0,this.c=0,this.d=1,this.e=0,this.f=0,this.m11=1,this.m12=0,this.m13=0,this.m14=0,this.m21=0,this.m22=1,this.m23=0,this.m24=0,this.m31=0,this.m32=0,this.m33=1,this.m34=0,this.m41=0,this.m42=0,this.m43=0,this.m44=1,e?this.setMatrixValue(e):this}get isIdentity(){return this.m11===1&&this.m12===0&&this.m13===0&&this.m14===0&&this.m21===0&&this.m22===1&&this.m23===0&&this.m24===0&&this.m31===0&&this.m32===0&&this.m33===1&&this.m34===0&&this.m41===0&&this.m42===0&&this.m43===0&&this.m44===1}get is2D(){return this.m31===0&&this.m32===0&&this.m33===1&&this.m34===0&&this.m43===0&&this.m44===1}setMatrixValue(e){return typeof e=="string"&&e.length&&e!=="none"?Ue(e):Array.isArray(e)||e instanceof Float64Array||e instanceof Float32Array?re(e):typeof e=="object"?Fe(e):this}toFloat32Array(e){return Float32Array.from(Se(this,e))}toFloat64Array(e){return Float64Array.from(Se(this,e))}toString(){const{is2D:e}=this,r=this.toFloat64Array(e).join(", ");return`${e?"matrix":"matrix3d"}(${r})`}toJSON(){const{is2D:e,isIdentity:r}=this;return{...this,is2D:e,isIdentity:r}}multiply(e){return B(this,e)}translate(e,r,o){const n=e;let s=r,i=o;return typeof s>"u"&&(s=0),typeof i>"u"&&(i=0),B(this,Ge(n,s,i))}scale(e,r,o){const n=e;let s=r,i=o;return typeof s>"u"&&(s=e),typeof i>"u"&&(i=1),B(this,We(n,s,i))}rotate(e,r,o){let n=e,s=r||0,i=o||0;return typeof e=="number"&&typeof r>"u"&&typeof o>"u"&&(i=n,n=0,s=0),B(this,Je(n,s,i))}rotateAxisAngle(e,r,o,n){if([e,r,o,n].some(s=>Number.isNaN(+s)))throw new TypeError("CSSMatrix: expecting 4 values");return B(this,Ke(e,r,o,n))}skewX(e){return B(this,Xe(e))}skewY(e){return B(this,Ye(e))}skew(e,r){return B(this,ye(e,r))}transformPoint(e){const r=this.m11*e.x+this.m21*e.y+this.m31*e.z+this.m41*e.w,o=this.m12*e.x+this.m22*e.y+this.m32*e.z+this.m42*e.w,n=this.m13*e.x+this.m23*e.y+this.m33*e.z+this.m43*e.w,s=this.m14*e.x+this.m24*e.y+this.m34*e.z+this.m44*e.w;return e instanceof DOMPoint?new DOMPoint(r,o,n,s):{x:r,y:o,z:n,w:s}}}I(S,"Translate",Ge),I(S,"Rotate",Je),I(S,"RotateAxisAngle",Ke),I(S,"Scale",We),I(S,"SkewX",Xe),I(S,"SkewY",Ye),I(S,"Skew",ye),I(S,"Multiply",B),I(S,"fromArray",re),I(S,"fromMatrix",Fe),I(S,"fromString",Ue),I(S,"toArray",Se),I(S,"isCompatibleArray",Be),I(S,"isCompatibleObject",He);const D=(t,e,r)=>{const[o,n]=t,[s,i]=e;return[o+(s-o)*r,n+(i-n)*r]},de=(t,e)=>Math.sqrt((t[0]-e[0])*(t[0]-e[0])+(t[1]-e[1])*(t[1]-e[1])),te=(t,e,r,o)=>de([t,e],[r,o]),ke=(t,e,r,o,n)=>{let s={x:t,y:e};if(typeof n=="number"){const i=de([t,e],[r,o]);if(n<=0)s={x:t,y:e};else if(n>=i)s={x:r,y:o};else{const[a,c]=D([t,e],[r,o],n/i);s={x:a,y:c}}}return s},we=(t,e,r,o)=>{const{min:n,max:s}=Math;return[n(t,r),n(e,o),s(t,r),s(e,o)]},jt=Object.freeze(Object.defineProperty({__proto__:null,getLineBBox:we,getLineLength:te,getPointAtLineLength:ke},Symbol.toStringTag,{value:"Module"})),Ie=(t,e,r)=>{const o=r/2,n=Math.sin(o),s=Math.cos(o),i=t**2*n**2,a=e**2*s**2,c=Math.sqrt(i+a)*r;return Math.abs(c)},J=(t,e,r,o,n,s)=>{const{sin:i,cos:a}=Math,c=a(n),l=i(n),u=r*a(s),h=o*i(s);return[t+c*u-l*h,e+l*u+c*h]},Te=(t,e)=>{const{x:r,y:o}=t,{x:n,y:s}=e,i=r*n+o*s,a=Math.sqrt((r**2+o**2)*(n**2+s**2));return(r*s-o*n<0?-1:1)*Math.acos(i/a)},ge=(t,e,r,o,n,s,i,a,c)=>{const{abs:l,sin:u,cos:h,sqrt:f,PI:y}=Math;let m=l(r),d=l(o);const b=(n%360+360)%360*(y/180);if(t===a&&e===c)return{rx:m,ry:d,startAngle:0,endAngle:0,center:{x:a,y:c}};if(m===0||d===0)return{rx:m,ry:d,startAngle:0,endAngle:0,center:{x:(a+t)/2,y:(c+e)/2}};const M=(t-a)/2,g=(e-c)/2,x={x:h(b)*M+u(b)*g,y:-u(b)*M+h(b)*g},A=x.x**2/m**2+x.y**2/d**2;A>1&&(m*=f(A),d*=f(A));const P=m**2*d**2-m**2*x.y**2-d**2*x.x**2,z=m**2*x.y**2+d**2*x.x**2;let q=P/z;q=q<0?0:q;const L=(s!==i?1:-1)*f(q),w={x:L*(m*x.y/d),y:L*(-(d*x.x)/m)},E={x:h(b)*w.x-u(b)*w.y+(t+a)/2,y:u(b)*w.x+h(b)*w.y+(e+c)/2},U={x:(x.x-w.x)/m,y:(x.y-w.y)/d},$=Te({x:1,y:0},U),C={x:(-x.x-w.x)/m,y:(-x.y-w.y)/d};let j=Te(U,C);!i&&j>0?j-=2*y:i&&j<0&&(j+=2*y),j%=2*y;const O=$+j;return{center:E,startAngle:$,endAngle:O,rx:m,ry:d}},Ve=(t,e,r,o,n,s,i,a,c)=>{const{rx:l,ry:u,startAngle:h,endAngle:f}=ge(t,e,r,o,n,s,i,a,c);return Ie(l,u,f-h)},et=(t,e,r,o,n,s,i,a,c,l)=>{let u={x:t,y:e};const{center:h,rx:f,ry:y,startAngle:m,endAngle:d}=ge(t,e,r,o,n,s,i,a,c);if(typeof l=="number"){const p=Ie(f,y,d-m);if(l<=0)u={x:t,y:e};else if(l>=p)u={x:a,y:c};else{if(t===a&&e===c)return{x:a,y:c};if(f===0||y===0)return ke(t,e,a,c,l);const{PI:b,cos:M,sin:g}=Math,x=d-m,P=(n%360+360)%360*(b/180),z=m+x*(l/p),q=f*M(z),L=y*g(z);u={x:M(P)*q-g(P)*L+h.x,y:g(P)*q+M(P)*L+h.y}}}return u},tt=(t,e,r,o,n,s,i,a,c)=>{const{center:l,rx:u,ry:h,startAngle:f,endAngle:y}=ge(t,e,r,o,n,s,i,a,c),m=y-f,{min:d,max:p,tan:b,atan2:M,PI:g}=Math,{x,y:A}=l,P=n*g/180,z=b(P),q=M(-h*z,u),L=q,w=q+g,E=M(h,u*z),U=E+g,$=[a],C=[c];let j=d(t,a),O=p(t,a),V=d(e,c),Z=p(e,c);const K=y-m*1e-5,G=J(x,A,u,h,P,K),T=y-m*.99999,k=J(x,A,u,h,P,T);if(G[0]>O||k[0]>O){const N=J(x,A,u,h,P,L);$.push(N[0]),C.push(N[1])}if(G[0]Z||k[1]>Z){const N=J(x,A,u,h,P,E);$.push(N[0]),C.push(N[1])}return j=d.apply([],$),V=d.apply([],C),O=p.apply([],$),Z=p.apply([],C),[j,V,O,Z]},kt=Object.freeze(Object.defineProperty({__proto__:null,angleBetween:Te,arcLength:Ie,arcPoint:J,getArcBBox:tt,getArcLength:Ve,getArcProps:ge,getPointAtArcLength:et},Symbol.toStringTag,{value:"Module"})),Le=[-.06405689286260563,.06405689286260563,-.1911188674736163,.1911188674736163,-.3150426796961634,.3150426796961634,-.4337935076260451,.4337935076260451,-.5454214713888396,.5454214713888396,-.6480936519369755,.6480936519369755,-.7401241915785544,.7401241915785544,-.820001985973903,.820001985973903,-.8864155270044011,.8864155270044011,-.9382745520027328,.9382745520027328,-.9747285559713095,.9747285559713095,-.9951872199970213,.9951872199970213],nt=[.12793819534675216,.12793819534675216,.1258374563468283,.1258374563468283,.12167047292780339,.12167047292780339,.1155056680537256,.1155056680537256,.10744427011596563,.10744427011596563,.09761865210411388,.09761865210411388,.08619016153195327,.08619016153195327,.0733464814110803,.0733464814110803,.05929858491543678,.05929858491543678,.04427743881741981,.04427743881741981,.028531388628933663,.028531388628933663,.0123412297999872,.0123412297999872],rt=t=>{const e=[];for(let r=t,o=r.length,n=o-1;o>1;o-=1,n-=1){const s=[];for(let i=0;i{if(e===0)return t[0].t=0,t[0];const r=t.length-1;if(e===1)return t[r].t=1,t[r];const o=1-e;let n=t;if(r===0)return t[0].t=e,t[0];if(r===1)return{x:o*n[0].x+e*n[1].x,y:o*n[0].y+e*n[1].y,t:e};const s=o*o,i=e*e;let a=0,c=0,l=0,u=0;return r===2?(n=[n[0],n[1],n[2],{x:0,y:0}],a=s,c=o*e*2,l=i):r===3&&(a=s*o,c=s*e*3,l=o*i*3,u=e*i),{x:a*n[0].x+c*n[1].x+l*n[2].x+u*n[3].x,y:a*n[0].y+c*n[1].y+l*n[2].y+u*n[3].y,t:e}},st=(t,e)=>{const r=t(e),o=r.x*r.x+r.y*r.y;return Math.sqrt(o)},it=t=>{const r=Le.length;let o=0;for(let n=0,s;n{const e=[];for(let o=0,n=t.length,s=2;oot(r[0],o))},ct=1e-8,le=([t,e,r])=>{const o=Math.min(t,r),n=Math.max(t,r);if(e>=t?r>=e:r<=e)return[o,n];const s=(t*r-e*e)/(t-2*e+r);return s{const n=t-3*e+3*r-o;if(Math.abs(n)0&&u<1){const f=t*(1-u)*(1-u)*(1-u)+e*3*(1-u)*(1-u)*u+r*3*(1-u)*u*u+o*u*u*u;fc&&(c=f)}return[a,c]},It=Object.freeze(Object.defineProperty({__proto__:null,CBEZIER_MINMAX_EPSILON:ct,Cvalues:nt,Tvalues:Le,bezierLength:it,calculateBezier:st,computeBezier:ot,deriveBezier:rt,getBezierLength:oe,minmaxC:Ne,minmaxQ:le},Symbol.toStringTag,{value:"Module"})),at=([t,e,r,o,n,s,i,a],c)=>{const l=1-c;return{x:l**3*t+3*l**2*c*r+3*l*c**2*n+c**3*i,y:l**3*e+3*l**2*c*o+3*l*c**2*s+c**3*a}},me=(t,e,r,o,n,s,i,a)=>oe([t,e,r,o,n,s,i,a]),lt=(t,e,r,o,n,s,i,a,c)=>{const l=typeof c=="number";let u={x:t,y:e};if(l){const h=oe([t,e,r,o,n,s,i,a]);c<=0||(c>=h?u={x:i,y:a}:u=at([t,e,r,o,n,s,i,a],c/h))}return u},ve=(t,e,r,o,n,s,i,a)=>{const c=Ne([t,r,n,i]),l=Ne([e,o,s,a]);return[c[0],l[0],c[1],l[1]]},Vt=Object.freeze(Object.defineProperty({__proto__:null,getCubicBBox:ve,getCubicLength:me,getPointAtCubicLength:lt,getPointAtCubicSegmentLength:at},Symbol.toStringTag,{value:"Module"})),mt=([t,e,r,o,n,s],i)=>{const a=1-i;return{x:a**2*t+2*a*i*r+i**2*n,y:a**2*e+2*a*i*o+i**2*s}},ue=(t,e,r,o,n,s)=>oe([t,e,r,o,n,s]),ut=(t,e,r,o,n,s,i)=>{const a=typeof i=="number";let c={x:t,y:e};if(a){const l=oe([t,e,r,o,n,s]);i<=0||(i>=l?c={x:n,y:s}:c=mt([t,e,r,o,n,s],i/l))}return c},ze=(t,e,r,o,n,s)=>{const i=le([t,r,n]),a=le([e,o,s]);return[i[0],a[0],i[1],a[1]]},Rt=Object.freeze(Object.defineProperty({__proto__:null,getPointAtQuadLength:ut,getPointAtQuadSegmentLength:mt,getQuadBBox:ze,getQuadLength:ue},Symbol.toStringTag,{value:"Module"})),Et=t=>{const e=t.length;let r=-1,o,n=t[e-1],s=0;for(;++rt.reduce((e,r,o)=>o?e+de(t[o-1],r):0,0),_t=Object.freeze(Object.defineProperty({__proto__:null,polygonArea:Et,polygonLength:Ot},Symbol.toStringTag,{value:"Module"})),W={a:7,c:6,h:1,l:2,m:2,r:4,q:4,s:4,t:2,v:1,z:0},qe=t=>{let e=t.pathValue[t.segmentStart],r=e.toLowerCase();const{data:o}=t;for(;o.length>=W[r]&&(r==="m"&&o.length>2?(t.segments.push([e].concat(o.splice(0,2))),r="l",e=e==="m"?"l":"L"):t.segments.push([e].concat(o.splice(0,W[r]))),!!W[r]););},_="SVGPathCommander Error",ht=t=>{const{index:e,pathValue:r}=t,o=r.charCodeAt(e);if(o===48){t.param=0,t.index+=1;return}if(o===49){t.param=1,t.index+=1;return}t.err=`${_}: invalid Arc flag "${r[e]}", expecting 0 or 1 at index ${e}`},H=t=>t>=48&&t<=57,F="Invalid path value",ft=t=>{const{max:e,pathValue:r,index:o}=t;let n=o,s=!1,i=!1,a=!1,c=!1,l;if(n>=e){t.err=`${_}: ${F} at index ${n}, "pathValue" is missing param`;return}if(l=r.charCodeAt(n),(l===43||l===45)&&(n+=1,l=r.charCodeAt(n)),!H(l)&&l!==46){t.err=`${_}: ${F} at index ${n}, "${r[n]}" is not a number`;return}if(l!==46){if(s=l===48,n+=1,l=r.charCodeAt(n),s&&n[5760,6158,8192,8193,8194,8195,8196,8197,8198,8199,8200,8201,8202,8239,8287,12288,65279,10,13,8232,8233,32,9,11,12,160].includes(t),X=t=>{const{pathValue:e,max:r}=t;for(;t.index{switch(t|32){case 109:case 122:case 108:case 104:case 118:case 99:case 115:case 113:case 116:case 97:return!0;default:return!1}},gt=t=>H(t)||t===43||t===45||t===46,xt=t=>(t|32)===97,pt=t=>{switch(t|32){case 109:case 77:return!0;default:return!1}},Re=t=>{var c;const{max:e,pathValue:r,index:o,segments:n}=t,s=r.charCodeAt(o),i=W[r[o].toLowerCase()];if(t.segmentStart=o,!dt(s)){t.err=`${_}: ${F} "${r[o]}" is not a path command at index ${o}`;return}const a=n[n.length-1];if(!pt(s)&&((c=a==null?void 0:a[0])==null?void 0:c.toLocaleLowerCase())==="z"){t.err=`${_}: ${F} "${r[o]}" is not a MoveTo path command at index ${o}`;return}if(t.index+=1,X(t),t.data=[],!i){qe(t);return}for(;;){for(let l=i;l>0;l-=1){if(xt(s)&&(l===3||l===4)?ht(t):ft(t),t.err.length)return;t.data.push(t.param),X(t),t.index=t.max||!gt(r.charCodeAt(t.index)))break}qe(t)};class Ee{constructor(e){this.segments=[],this.pathValue=e,this.max=e.length,this.index=0,this.param=0,this.segmentStart=0,this.data=[],this.err=""}}const Q=t=>{if(typeof t!="string")return t.slice(0);const e=new Ee(t);for(X(e);e.index{const[n]=t,s=n.toUpperCase();if(e===0||s===n)return t;if(s==="A")return[s,t[1],t[2],t[3],t[4],t[5],t[6]+r,t[7]+o];if(s==="V")return[s,t[1]+o];if(s==="H")return[s,t[1]+r];if(s==="L")return[s,t[1]+r,t[2]+o];{const a=[],c=t.length;for(let l=1;l{let r=t.length,o,n="M",s="M",i=!1,a=0,c=0,l=0,u=0,h=0;for(let f=0;f{const e=Q(t);return R(e,se)},_e=(t,e,r,o)=>{const[n]=t,s=n.toLowerCase();if(e===0||n===s)return t;if(s==="a")return[s,t[1],t[2],t[3],t[4],t[5],t[6]-r,t[7]-o];if(s==="v")return[s,t[1]-o];if(s==="h")return[s,t[1]-r];if(s==="l")return[s,t[1]-r,t[2]-o];{const a=[],c=t.length;for(let l=1;l{const e=Q(t);return R(e,_e)},Y=(t,e,r)=>{const{sin:o,cos:n}=Math,s=t*n(r)-e*o(r),i=t*o(r)+e*n(r);return{x:s,y:i}},xe=(t,e,r,o,n,s,i,a,c,l)=>{let u=t,h=e,f=r,y=o,m=a,d=c;const p=Math.PI*120/180,b=Math.PI/180*(+n||0);let M=[],g,x,A,P,z;if(l)[x,A,P,z]=l;else{g=Y(u,h,-b),u=g.x,h=g.y,g=Y(m,d,-b),m=g.x,d=g.y;const T=(u-m)/2,k=(h-d)/2;let N=T*T/(f*f)+k*k/(y*y);N>1&&(N=Math.sqrt(N),f*=N,y*=N);const Ce=f*f,Pe=y*y,Ze=(s===i?-1:1)*Math.sqrt(Math.abs((Ce*Pe-Ce*k*k-Pe*T*T)/(Ce*k*k+Pe*T*T)));P=Ze*f*k/y+(u+m)/2,z=Ze*-y*T/f+(h+d)/2,x=Math.asin(((h-z)/y*10**9>>0)/10**9),A=Math.asin(((d-z)/y*10**9>>0)/10**9),x=uA&&(x-=Math.PI*2),!i&&A>x&&(A-=Math.PI*2)}let q=A-x;if(Math.abs(q)>p){const T=A,k=m,N=d;A=x+p*(i&&A>x?1:-1),m=P+f*Math.cos(A),d=z+y*Math.sin(A),M=xe(m,d,f,y,n,0,i,k,N,[A,T,P,z])}q=A-x;const L=Math.cos(x),w=Math.sin(x),E=Math.cos(A),U=Math.sin(A),$=Math.tan(q/4),C=4/3*f*$,j=4/3*y*$,O=[u,h],V=[u+C*w,h-j*L],Z=[m+C*U,d-j*E],K=[m,d];if(V[0]=2*O[0]-V[0],V[1]=2*O[1]-V[1],l)return[V[0],V[1],Z[0],Z[1],K[0],K[1]].concat(M);M=[V[0],V[1],Z[0],Z[1],K[0],K[1]].concat(M);const G=[];for(let T=0,k=M.length;T{const i=.3333333333333333,a=2/3;return[i*t+a*r,i*e+a*o,i*n+a*r,i*s+a*o,n,s]},$e=(t,e,r,o)=>{const n=D([t,e],[r,o],.3333333333333333),s=D([t,e],[r,o],2/3);return[n[0],n[1],s[0],s[1],r,o]},Mt=(t,e)=>{const[r]=t,o=t.slice(1).map(Number),[n,s]=o,{x1:i,y1:a,x:c,y:l}=e;return"TQ".includes(r)||(e.qx=null,e.qy=null),r==="M"?(e.x=n,e.y=s,t):r==="A"?["C"].concat(xe(i,a,o[0],o[1],o[2],o[3],o[4],o[5],o[6])):r==="Q"?(e.qx=n,e.qy=s,["C"].concat(bt(i,a,o[0],o[1],o[2],o[3]))):r==="L"?["C"].concat($e(i,a,n,s)):r==="Z"?["C"].concat($e(i,a,c,l)):t},pe=(t,e)=>{const[r]=t,o=r.toUpperCase(),n=r!==o,{x1:s,y1:i,x2:a,y2:c,x:l,y:u}=e,h=t.slice(1);let f=h.map((y,m)=>y+(n?m%2?u:l:0));if("TQ".includes(o)||(e.qx=null,e.qy=null),o==="A")return f=h.slice(0,-2).concat(h[5]+(n?l:0),h[6]+(n?u:0)),["A"].concat(f);if(o==="H")return["L",t[1]+(n?l:0),i];if(o==="V")return["L",s,t[1]+(n?u:0)];if(o==="L")return["L",t[1]+(n?l:0),t[2]+(n?u:0)];if(o==="M")return["M",t[1]+(n?l:0),t[2]+(n?u:0)];if(o==="C")return["C"].concat(f);if(o==="S"){const y=s*2-a,m=i*2-c;return e.x1=y,e.y1=m,["C",y,m].concat(f)}else if(o==="T"){const y=s*2-(e.qx?e.qx:0),m=i*2-(e.qy?e.qy:0);return e.qx=y,e.qy=m,["Q",y,m].concat(f)}else if(o==="Q"){const[y,m]=f;return e.qx=y,e.qy=m,["Q"].concat(f)}else if(o==="Z")return["Z"];return t},ie={x1:0,y1:0,x2:0,y2:0,x:0,y:0,qx:null,qy:null},Qe=t=>{const e={...ie},r=Q(t);return R(r,(o,n,s,i)=>{e.x=s,e.y=i;const a=pe(o,e);let c=Mt(a,e);c[0]==="C"&&c.length>7&&(r.splice(n+1,0,["C"].concat(c.slice(7))),c=c.slice(0,7));const u=c.length;return e.x1=+c[u-2],e.y1=+c[u-1],e.x2=+c[u-4]||e.x1,e.y2=+c[u-3]||e.y1,c})},ce={origin:[0,0,0],round:4},v=(t,e)=>{const r=e>=1?10**e:1;return e>0?Math.round(t*r)/r:Math.round(t)},At=(t,e)=>{const r=t.length;let{round:o}=ce,n=t[0],s="";o=e==="off"||typeof e=="number"&&e>=0?e:typeof o=="number"&&o>=0?o:"off";for(let i=0;i{const e=Q(t),r={...ie};return R(e,(o,n,s,i)=>{r.x=s,r.y=i;const a=pe(o,r),c=a.length;return r.x1=+a[c-2],r.y1=+a[c-1],r.x2=+a[c-4]||r.x1,r.y2=+a[c-3]||r.y1,a})},ae=(t,e)=>{const r=be(t);let o=!1,n=[],s="M",i=0,a=0,[c,l]=r[0].slice(1);const u=typeof e=="number";let h={x:c,y:l},f=0,y=h,m=0;return!u||e{if([s]=d,o=s==="M",n=o?n:[b,M].concat(d.slice(1)),o?([,c,l]=d,h={x:c,y:l},f=0):s==="L"?(h=ke(n[0],n[1],n[2],n[3],e-m),f=te(n[0],n[1],n[2],n[3])):s==="A"?(h=et(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7],n[8],e-m),f=Ve(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7],n[8])):s==="C"?(h=lt(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7],e-m),f=me(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7])):s==="Q"?(h=ut(n[0],n[1],n[2],n[3],n[4],n[5],e-m),f=ue(n[0],n[1],n[2],n[3],n[4],n[5])):s==="Z"&&(n=[b,M,c,l],h={x:c,y:l},f=te(n[0],n[1],n[2],n[3])),[i,a]=n.slice(-2),mm-he?{x:i,y:a}:y)},ee=t=>{const e=Q(t);let r=0,o=0,n=0,s=0,i=0,a=0,c="M",l=0,u=0,h=0;return R(e,(f,y,m,d)=>{[c]=f;const p=c.toUpperCase(),M=p!==c?se(f,y,m,d):f.slice(0),g=p==="V"?["L",m,M[1]]:p==="H"?["L",M[1],d]:M;if([c]=g,"TQ".includes(p)||(i=0,a=0),c==="M")[,l,u]=g;else if(c==="L")h+=te(m,d,g[1],g[2]);else if(c==="A")h+=Ve(m,d,g[1],g[2],g[3],g[4],g[5],g[6],g[7]);else if(c==="S"){const x=r*2-n,A=o*2-s;h+=me(m,d,x,A,g[1],g[2],g[3],g[4])}else c==="C"?h+=me(m,d,g[1],g[2],g[3],g[4],g[5],g[6]):c==="T"?(i=r*2-i,a=o*2-a,h+=ue(m,d,i,a,g[1],g[2])):c==="Q"?(i=g[1],a=g[2],h+=ue(m,d,g[1],g[2],g[3],g[4])):c==="Z"&&(h+=te(m,d,l,u));[r,o]=c==="Z"?[l,u]:g.slice(-2),[n,s]=c==="C"?[g[3],g[4]]:c==="S"?[g[1],g[2]]:[r,o]}),h},De=(t,e)=>{const r=Q(t);let o=r.slice(0),n=ee(o),s=o.length-1,i=0,a=0,c=r[0];if(s<=0||!e||!Number.isFinite(e))return{segment:c,index:0,length:a,lengthAtSegment:i};if(e>=n)return o=r.slice(0,-1),i=ee(o),a=n-i,c=r[s],{segment:c,index:s,length:a,lengthAtSegment:i};const l=[];for(;s>0;)c=o[s],o=o.slice(0,-1),i=ee(o),a=n-i,n=i,l.push({segment:c,index:s,length:a,lengthAtSegment:i}),s-=1;return l.find(({lengthAtSegment:u})=>u<=e)},Me=(t,e)=>{const r=Q(t),o=be(r),n=ee(o),s=x=>{const A=x.x-e.x,P=x.y-e.y;return A*A+P*P};let i=8,a,c={x:0,y:0},l=0,u=0,h=1/0;for(let x=0;x<=n;x+=i)a=ae(o,x),l=s(a),l1e-6&&(m=u-i,f=ae(o,m),p=s(f),d=u+i,y=ae(o,d),b=s(y),m>=0&&pMe(t,e).closest,Zt=(t,e,r,o,n,s,i,a)=>3*((a-e)*(r+n)-(i-t)*(o+s)+o*(t-n)-r*(e-s)+a*(n+t/3)-i*(s+e/3))/20,Ct=t=>{let e=0,r=0,o=0;return Qe(t).map(n=>{switch(n[0]){case"M":return[,e,r]=n,0;default:return o=Zt(e,r,n[1],n[2],n[3],n[4],n[5],n[6]),[e,r]=n.slice(-2),o}}).reduce((n,s)=>n+s,0)},Bt=t=>Ct(Qe(t))>=0,Ht=t=>{if(!t)return{x:0,y:0,width:0,height:0,x2:0,y2:0,cx:0,cy:0,cz:0};const e=Q(t);let r="M",o=0,n=0;const{max:s,min:i}=Math;let a=1/0,c=1/0,l=-1/0,u=-1/0,h=0,f=0,y=0,m=0,d=0,p=0,b=0,M=0,g=0,x=0;R(e,(z,q,L,w)=>{[r]=z;const E=r.toUpperCase(),$=E!==r?se(z,q,L,w):z.slice(0),C=E==="V"?["L",L,$[1]]:E==="H"?["L",$[1],w]:$;if([r]=C,"TQ".includes(E)||(g=0,x=0),r==="M")[,o,n]=C,h=o,f=n,y=o,m=n;else if(r==="L")[h,f,y,m]=we(L,w,C[1],C[2]);else if(r==="A")[h,f,y,m]=tt(L,w,C[1],C[2],C[3],C[4],C[5],C[6],C[7]);else if(r==="S"){const j=d*2-b,O=p*2-M;[h,f,y,m]=ve(L,w,j,O,C[1],C[2],C[3],C[4])}else r==="C"?[h,f,y,m]=ve(L,w,C[1],C[2],C[3],C[4],C[5],C[6]):r==="T"?(g=d*2-g,x=p*2-x,[h,f,y,m]=ze(L,w,g,x,C[1],C[2])):r==="Q"?(g=C[1],x=C[2],[h,f,y,m]=ze(L,w,C[1],C[2],C[3],C[4])):r==="Z"&&([h,f,y,m]=we(L,w,o,n));a=i(h,a),c=i(f,c),l=s(y,l),u=s(m,u),[d,p]=r==="Z"?[o,n]:C.slice(-2),[b,M]=r==="C"?[C[3],C[4]]:r==="S"?[C[1],C[2]]:[d,p]});const A=l-a,P=u-c;return{width:A,height:P,x:a,y:c,x2:l,y2:u,cx:a+A/2,cy:c+P/2,cz:Math.max(A,P)+Math.min(A,P)/2}},Ft=(t,e)=>De(t,e).segment,Ut=(t,e)=>Me(t,e).segment,Ae=t=>Array.isArray(t)&&t.every(e=>{const r=e[0].toLowerCase();return W[r]===e.length-1&&"achlmqstvz".includes(r)&&e.slice(1).every(Number.isFinite)})&&t.length>0,Pt=t=>Ae(t)&&t.every(([e])=>e===e.toUpperCase()),St=t=>Pt(t)&&t.every(([e])=>"ACLMQZ".includes(e)),Gt=t=>St(t)&&t.every(([e])=>"MC".includes(e)),Jt=(t,e)=>{const{distance:r}=Me(t,e);return Math.abs(r)Ae(t)&&t.slice(1).every(([e])=>e===e.toLowerCase()),wt=t=>{if(typeof t!="string"||!t.length)return!1;const e=new Ee(t);for(X(e);e.indext!=null&&typeof t=="object"&&t.nodeType===1,Wt=t=>{let{x1:e,y1:r,x2:o,y2:n}=t;return[e,r,o,n]=[e,r,o,n].map(s=>+s),[["M",e,r],["L",o,n]]},Xt=t=>{const e=[],r=(t.points||"").trim().split(/[\s|,]/).map(n=>+n);let o=0;for(;o{let{cx:e,cy:r,r:o}=t;return[e,r,o]=[e,r,o].map(n=>+n),[["M",e-o,r],["a",o,o,0,1,0,2*o,0],["a",o,o,0,1,0,-2*o,0]]},en=t=>{let{cx:e,cy:r}=t,o=t.rx||0,n=t.ry||o;return[e,r,o,n]=[e,r,o,n].map(s=>+s),[["M",e-o,r],["a",o,n,0,1,0,2*o,0],["a",o,n,0,1,0,-2*o,0]]},tn=t=>{const e=+t.x||0,r=+t.y||0,o=+t.width,n=+t.height;let s=+(t.rx||0),i=+(t.ry||s);return s||i?(s*2>o&&(s-=(s*2-o)/2),i*2>n&&(i-=(i*2-n)/2),[["M",e+s,r],["h",o-s*2],["s",s,0,s,i],["v",n-i*2],["s",0,i,-s,i],["h",-o+s*2],["s",-s,0,-s,-i],["v",-n+i*2],["s",0,-i,s,-i]]):[["M",e,r],["h",o],["v",n],["H",e],["Z"]]},Lt=t=>{const e=Object.keys(ne),r=Tt(t),o=r?t.tagName:null;if(o&&[...e,"path"].every(c=>o!==c))throw TypeError(`${_}: "${o}" is not SVGElement`);const n=r?o:t.type,s=ne[n],i={type:n};r?s.forEach(c=>{i[c]=t.getAttribute(c)}):Object.assign(i,t);let a=[];return n==="circle"?a=Yt(i):n==="ellipse"?a=en(i):["polyline","polygon"].includes(n)?a=Xt(i):n==="rect"?a=tn(i):n==="line"?a=Wt(i):["glyph","path"].includes(n)&&(a=Q(r?t.getAttribute("d")||"":t.d||"")),Ae(a)&&a.length?a:!1},nn=(t,e,r)=>{const o=r||document,n=Object.keys(ne),s=Tt(t),i=s?t.tagName:null;if(i==="path")throw TypeError(`${_}: "${i}" is already SVGPathElement`);if(i&&n.every(m=>i!==m))throw TypeError(`${_}: "${i}" is not SVGElement`);const a=o.createElementNS("http://www.w3.org/2000/svg","path"),c=s?i:t.type,l=ne[c],u={type:c},h=ce.round,f=Lt(t),y=f&&f.length?At(f,h):"";return s?(l.forEach(m=>{u[m]=t.getAttribute(m)}),Object.values(t.attributes).forEach(({name:m,value:d})=>{l.includes(m)||a.setAttribute(m,d)})):(Object.assign(u,t),Object.keys(u).forEach(m=>{!l.includes(m)&&m!=="type"&&a.setAttribute(m.replace(/[A-Z]/g,d=>`-${d.toLowerCase()}`),u[m])})),wt(y)?(a.setAttribute("d",y),e&&s&&(t.before(a,t),t.remove()),a):!1},Nt=t=>{let e=new S;const{origin:r}=t,[o,n]=r,{translate:s}=t,{rotate:i}=t,{skew:a}=t,{scale:c}=t;return Array.isArray(s)&&s.length>=2&&s.every(l=>!Number.isNaN(+l))&&s.some(l=>l!==0)?e=e.translate(...s):typeof s=="number"&&!Number.isNaN(s)&&(e=e.translate(s)),(i||a||c)&&(e=e.translate(o,n),Array.isArray(i)&&i.length>=2&&i.every(l=>!Number.isNaN(+l))&&i.some(l=>l!==0)?e=e.rotate(...i):typeof i=="number"&&!Number.isNaN(i)&&(e=e.rotate(i)),Array.isArray(a)&&a.length===2&&a.every(l=>!Number.isNaN(+l))&&a.some(l=>l!==0)?(e=a[0]?e.skewX(a[0]):e,e=a[1]?e.skewY(a[1]):e):typeof a=="number"&&!Number.isNaN(a)&&(e=e.skewX(a)),Array.isArray(c)&&c.length>=2&&c.every(l=>!Number.isNaN(+l))&&c.some(l=>l!==1)?e=e.scale(...c):typeof c=="number"&&!Number.isNaN(c)&&(e=e.scale(c)),e=e.translate(-o,-n)),e},vt=(t,e,r,o)=>{const[n]=t,{round:s}=ce,i=s,a=e.slice(1),{x1:c,y1:l,x2:u,y2:h,x:f,y}=r,[m,d]=a.slice(-2),p=t;if("TQ".includes(n)||(r.qx=null,r.qy=null),n==="L"){if(v(f,i)===v(m,i))return["V",d];if(v(y,i)===v(d,i))return["H",m]}else if(n==="C"){const[b,M]=a;if(r.x1=b,r.y1=M,"CS".includes(o)&&(v(b,i)===v(c*2-u,i)&&v(M,i)===v(l*2-h,i)||v(c,i)===v(u*2-f,i)&&v(l,i)===v(h*2-y,i)))return["S",a[2],a[3],a[4],a[5]]}else if(n==="Q"){const[b,M]=a;if(r.qx=b,r.qy=M,"QT".includes(o)&&v(b,i)===v(c*2-u,i)&&v(M,i)===v(l*2-h,i))return["T",a[2],a[3]]}return p},fe=(t,e)=>{const r=t.slice(1).map(o=>v(o,e));return[t[0]].concat(r)},rn=(t,e)=>{const r=Oe(t),o=typeof e=="number"&&e>=0?e:2,n={...ie},s=[];let i="M",a="Z";return R(r,(c,l,u,h)=>{n.x=u,n.y=h;const f=pe(c,n);let y=c;if([i]=c,s[l]=i,l){a=s[l-1];const d=vt(c,f,n,a),p=fe(d,o),b=p.join(""),M=_e(d,l,u,h),g=fe(M,o),x=g.join("");y=b.length{let r=S.Translate(e[0],e[1],e[2]);return[,,,r.m44]=e,r=t.multiply(r),[r.m41,r.m42,r.m43,r.m44]},je=(t,e,r)=>{const[o,n,s]=r,[i,a,c]=on(t,[e[0],e[1],0,1]),l=i-o,u=a-n,h=c-s;return[l*(Math.abs(s)/Math.abs(h)||1)+o,u*(Math.abs(s)/Math.abs(h)||1)+n]},sn=t=>{const e=t.slice(1).map((r,o,n)=>o?n[o-1].slice(-2).concat(r.slice(1)):t[0].slice(1).concat(r.slice(1))).map(r=>r.map((o,n)=>r[r.length-n-2*(1-n%2)])).reverse();return[["M"].concat(e[0].slice(0,2))].concat(e.map(r=>["C"].concat(r.slice(2))))},cn=t=>{const e=Oe(t),r=be(e),o=e.length,n=e[o-1][0]==="Z",s=R(e,(i,a)=>{const c=r[a],l=a&&e[a-1],u=l&&l[0],h=e[a+1],f=h&&h[0],[y]=i,[m,d]=r[a?a-1:o-1].slice(-2);let p=i;switch(y){case"M":p=n?["Z"]:[y,m,d];break;case"A":p=[y,i[1],i[2],i[3],i[4],i[5]===1?0:1,m,d];break;case"C":h&&f==="S"?p=["S",i[1],i[2],m,d]:p=[y,i[3],i[4],i[1],i[2],m,d];break;case"S":u&&"CS".includes(u)&&(!h||f!=="S")?p=["C",c[3],c[4],c[1],c[2],m,d]:p=[y,c[1],c[2],m,d];break;case"Q":h&&f==="T"?p=["T",m,d]:p=[y,i[1],i[2],m,d];break;case"T":u&&"QT".includes(u)&&(!h||f!=="T")?p=["Q",c[1],c[2],m,d]:p=[y,m,d];break;case"Z":p=["M",m,d];break;case"H":p=[y,m];break;case"V":p=[y,d];break;default:p=[y].concat(i.slice(1,-2),m,d)}return p});return n?s.reverse():[s[0]].concat(s.slice(1).reverse())},an=(t,e)=>{let{round:r}=ce;return r=e==="off"||typeof e=="number"&&e>=0?e:typeof r=="number"&&r>=0?r:"off",r==="off"?t.slice(0):R(t,o=>fe(o,r))},ln=(t,e=.5)=>{const r=e,o=t.slice(0,2),n=t.slice(2,4),s=t.slice(4,6),i=t.slice(6,8),a=D(o,n,r),c=D(n,s,r),l=D(s,i,r),u=D(a,c,r),h=D(c,l,r),f=D(u,h,r);return[["C",a[0],a[1],u[0],u[1],f[0],f[1]],["C",h[0],h[1],l[0],l[1],i[0],i[1]]]},mn=t=>{const e=[];let r,o=-1,n=0,s=0,i=0,a=0;const c={...ie};return t.forEach(l=>{const[u]=l,h=u.toUpperCase(),f=u.toLowerCase(),y=u===f,m=l.slice(1);h==="M"?(o+=1,[n,s]=m,n+=y?c.x:0,s+=y?c.y:0,i=n,a=s,r=[y?[h,i,a]:l]):(h==="Z"?(n=i,s=a):h==="H"?([,n]=l,n+=y?c.x:0):h==="V"?([,s]=l,s+=y?c.y:0):([n,s]=l.slice(-2),n+=y?c.x:0,s+=y?c.y:0),r.push(l)),c.x=n,c.y=s,e[o]=r}),e},un=(t,e)=>{let r=0,o=0,n=0,s=0,i=0,a=0,c="M";const l=Q(t),u=e&&Object.keys(e);if(!e||u&&!u.length)return l.slice(0);e.origin||Object.assign(e,{origin:ce.origin});const h=e.origin,f=Nt(e);return f.isIdentity?l.slice(0):R(l,(y,m,d,p)=>{[c]=y;const b=c.toUpperCase(),g=b!==c?se(y,m,d,p):y.slice(0);let x=b==="A"?["C"].concat(xe(d,p,g[1],g[2],g[3],g[4],g[5],g[6],g[7])):b==="V"?["L",d,g[1]]:b==="H"?["L",g[1],p]:g;c=x[0];const A=c==="C"&&x.length>7,P=A?x.slice(0,7):x.slice(0);if(A&&(l.splice(m+1,0,["C"].concat(x.slice(7))),x=P),c==="L")[n,s]=je(f,[x[1],x[2]],h),r!==n&&o!==s?x=["L",n,s]:o===s?x=["H",n]:r===n&&(x=["V",s]);else for(i=1,a=x.length;i{for(var n in t)Ne(e,n,{get:t[n],enumerable:!0})},ht=(e,t,n,o)=>{if(t&&typeof t=="object"||typeof t=="function")for(let r of Ut(t))!Ft.call(e,r)&&r!==n&&Ne(e,r,{get:()=>t[r],enumerable:!(o=_t(t,r))||o.enumerable});return e};var et=(e,t,n)=>(n=e!=null?Gt(Kt(e)):{},ht(t||!e||!e.__esModule?Ne(n,"default",{value:e,enumerable:!0}):n,e)),Jt=e=>ht(Ne({},"__esModule",{value:!0}),e);var yn={};oe(yn,{CSSMatrix:()=>Zt.default,absolutizeSegment:()=>G,arcToCubic:()=>ye,arcTools:()=>st,bezierTools:()=>it,cubicTools:()=>lt,distanceEpsilon:()=>le,distanceSquareRoot:()=>ae,finalizeSegment:()=>Me,getClosestPoint:()=>Lt,getDrawDirection:()=>vt,getPathArea:()=>Ze,getPathBBox:()=>Nt,getPointAtLength:()=>Pe,getPropertiesAtLength:()=>Se,getPropertiesAtPoint:()=>Y,getSVGMatrix:()=>Je,getSegmentAtLength:()=>wt,getSegmentOfPoint:()=>Rt,getTotalLength:()=>X,invalidPathValue:()=>O,isAbsoluteArray:()=>Ge,isArcCommand:()=>$e,isCurveArray:()=>Vt,isDigit:()=>j,isDigitStart:()=>Ie,isMoveCommand:()=>Be,isNormalizedArray:()=>_e,isPathArray:()=>ee,isPathCommand:()=>Ee,isPointInStroke:()=>Qt,isRelativeArray:()=>kt,isSpace:()=>De,isValidPath:()=>Ue,iterate:()=>T,lineToCubic:()=>Le,lineTools:()=>tt,midPoint:()=>E,normalizePath:()=>W,normalizeSegment:()=>J,optimizePath:()=>Dt,paramsCount:()=>H,paramsParser:()=>_,parsePathString:()=>v,pathParser:()=>F,pathToAbsolute:()=>ge,pathToCurve:()=>xe,pathToRelative:()=>Tt,pathToString:()=>He,polygonTools:()=>ft,projection2d:()=>ve,quadToCubic:()=>je,quadTools:()=>ct,relativizeSegment:()=>de,reverseCurve:()=>It,reversePath:()=>$t,rotateVector:()=>ue,roundPath:()=>Bt,roundSegment:()=>pe,roundTo:()=>M,scanFlag:()=>ze,scanParam:()=>qe,scanSegment:()=>he,segmentToCubic:()=>Oe,shapeParams:()=>te,shapeToPath:()=>zt,shapeToPathArray:()=>Fe,shortenSegment:()=>We,skipSpaces:()=>Z,splitCubic:()=>jt,splitPath:()=>Ot,transformPath:()=>Ht});module.exports=Jt(yn);var Zt=et(require("@thednp/dommatrix"),1);var st={};oe(st,{angleBetween:()=>rt,arcLength:()=>nt,arcPoint:()=>me,getArcBBox:()=>at,getArcLength:()=>Ce,getArcProps:()=>Re,getPointAtArcLength:()=>ot});var tt={};oe(tt,{getLineBBox:()=>we,getLineLength:()=>se,getPointAtLineLength:()=>Ae});var Wt=(e,t,n)=>{let[o,r]=e,[a,s]=t;return[o+(a-o)*n,r+(s-r)*n]},E=Wt;var Xt=(e,t)=>Math.sqrt((e[0]-t[0])*(e[0]-t[0])+(e[1]-t[1])*(e[1]-t[1])),ae=Xt;var se=(e,t,n,o)=>ae([e,t],[n,o]),Ae=(e,t,n,o,r)=>{let a={x:e,y:t};if(typeof r=="number"){let s=ae([e,t],[n,o]);if(r<=0)a={x:e,y:t};else if(r>=s)a={x:n,y:o};else{let[i,m]=E([e,t],[n,o],r/s);a={x:i,y:m}}}return a},we=(e,t,n,o)=>{let{min:r,max:a}=Math;return[r(e,n),r(t,o),a(e,n),a(t,o)]};var nt=(e,t,n)=>{let o=n/2,r=Math.sin(o),a=Math.cos(o),s=e**2*r**2,i=t**2*a**2,m=Math.sqrt(s+i)*n;return Math.abs(m)},me=(e,t,n,o,r,a)=>{let{sin:s,cos:i}=Math,m=i(r),u=s(r),l=n*i(a),c=o*s(a);return[e+m*l-u*c,t+u*l+m*c]},rt=(e,t)=>{let{x:n,y:o}=e,{x:r,y:a}=t,s=n*r+o*a,i=Math.sqrt((n**2+o**2)*(r**2+a**2));return(n*a-o*r<0?-1:1)*Math.acos(s/i)},Re=(e,t,n,o,r,a,s,i,m)=>{let{abs:u,sin:l,cos:c,sqrt:f,PI:b}=Math,p=u(n),h=u(o),S=(r%360+360)%360*(b/180);if(e===i&&t===m)return{rx:p,ry:h,startAngle:0,endAngle:0,center:{x:i,y:m}};if(p===0||h===0)return{rx:p,ry:h,startAngle:0,endAngle:0,center:{x:(i+e)/2,y:(m+t)/2}};let A=(e-i)/2,d=(t-m)/2,g={x:c(S)*A+l(S)*d,y:-l(S)*A+c(S)*d},x=g.x**2/p**2+g.y**2/h**2;x>1&&(p*=f(x),h*=f(x));let C=p**2*h**2-p**2*g.y**2-h**2*g.x**2,V=p**2*g.y**2+h**2*g.x**2,Q=C/V;Q=Q<0?0:Q;let w=(a!==s?1:-1)*f(Q),L={x:w*(p*g.y/h),y:w*(-(h*g.x)/p)},$={x:c(S)*L.x-l(S)*L.y+(e+i)/2,y:l(S)*L.x+c(S)*L.y+(t+m)/2},re={x:(g.x-L.x)/p,y:(g.y-L.y)/h},k=rt({x:1,y:0},re),P={x:(-g.x-L.x)/p,y:(-g.y-L.y)/h},z=rt(re,P);!s&&z>0?z-=2*b:s&&z<0&&(z+=2*b),z%=2*b;let B=k+z;return{center:$,startAngle:k,endAngle:B,rx:p,ry:h}},Ce=(e,t,n,o,r,a,s,i,m)=>{let{rx:u,ry:l,startAngle:c,endAngle:f}=Re(e,t,n,o,r,a,s,i,m);return nt(u,l,f-c)},ot=(e,t,n,o,r,a,s,i,m,u)=>{let l={x:e,y:t},{center:c,rx:f,ry:b,startAngle:p,endAngle:h}=Re(e,t,n,o,r,a,s,i,m);if(typeof u=="number"){let y=nt(f,b,h-p);if(u<=0)l={x:e,y:t};else if(u>=y)l={x:i,y:m};else{if(e===i&&t===m)return{x:i,y:m};if(f===0||b===0)return Ae(e,t,i,m,u);let{PI:S,cos:A,sin:d}=Math,g=h-p,C=(r%360+360)%360*(S/180),V=p+g*(u/y),Q=f*A(V),w=b*d(V);l={x:A(C)*Q-d(C)*w+c.x,y:d(C)*Q+A(C)*w+c.y}}}return l},at=(e,t,n,o,r,a,s,i,m)=>{let{center:u,rx:l,ry:c,startAngle:f,endAngle:b}=Re(e,t,n,o,r,a,s,i,m),p=b-f,{min:h,max:y,tan:S,atan2:A,PI:d}=Math,{x:g,y:x}=u,C=r*d/180,V=S(C),Q=A(-c*V,l),w=Q,L=Q+d,$=A(c,l*V),re=$+d,k=[i],P=[m],z=h(e,i),B=y(e,i),I=h(t,m),K=y(t,m),ce=b-p*1e-5,ne=me(g,x,l,c,C,ce),N=b-p*.99999,q=me(g,x,l,c,C,N);if(ne[0]>B||q[0]>B){let R=me(g,x,l,c,C,w);k.push(R[0]),P.push(R[1])}if(ne[0]K||q[1]>K){let R=me(g,x,l,c,C,$);k.push(R[0]),P.push(R[1])}return z=h.apply([],k),I=h.apply([],P),B=y.apply([],k),K=y.apply([],P),[z,I,B,K]};var it={};oe(it,{CBEZIER_MINMAX_EPSILON:()=>St,Cvalues:()=>gt,Tvalues:()=>mt,bezierLength:()=>Pt,calculateBezier:()=>xt,computeBezier:()=>yt,deriveBezier:()=>dt,getBezierLength:()=>ie,minmaxC:()=>Ve,minmaxQ:()=>Te});var mt=[-.06405689286260563,.06405689286260563,-.1911188674736163,.1911188674736163,-.3150426796961634,.3150426796961634,-.4337935076260451,.4337935076260451,-.5454214713888396,.5454214713888396,-.6480936519369755,.6480936519369755,-.7401241915785544,.7401241915785544,-.820001985973903,.820001985973903,-.8864155270044011,.8864155270044011,-.9382745520027328,.9382745520027328,-.9747285559713095,.9747285559713095,-.9951872199970213,.9951872199970213],gt=[.12793819534675216,.12793819534675216,.1258374563468283,.1258374563468283,.12167047292780339,.12167047292780339,.1155056680537256,.1155056680537256,.10744427011596563,.10744427011596563,.09761865210411388,.09761865210411388,.08619016153195327,.08619016153195327,.0733464814110803,.0733464814110803,.05929858491543678,.05929858491543678,.04427743881741981,.04427743881741981,.028531388628933663,.028531388628933663,.0123412297999872,.0123412297999872],dt=e=>{let t=[];for(let n=e,o=n.length,r=o-1;o>1;o-=1,r-=1){let a=[];for(let s=0;s{if(t===0)return e[0].t=0,e[0];let n=e.length-1;if(t===1)return e[n].t=1,e[n];let o=1-t,r=e;if(n===0)return e[0].t=t,e[0];if(n===1)return{x:o*r[0].x+t*r[1].x,y:o*r[0].y+t*r[1].y,t};let a=o*o,s=t*t,i=0,m=0,u=0,l=0;return n===2?(r=[r[0],r[1],r[2],{x:0,y:0}],i=a,m=o*t*2,u=s):n===3&&(i=a*o,m=a*t*3,u=o*s*3,l=t*s),{x:i*r[0].x+m*r[1].x+u*r[2].x+l*r[3].x,y:i*r[0].y+m*r[1].y+u*r[2].y+l*r[3].y,t}},xt=(e,t)=>{let n=e(t),o=n.x*n.x+n.y*n.y;return Math.sqrt(o)},Pt=e=>{let n=mt.length,o=0;for(let r=0,a;r{let t=[];for(let o=0,r=e.length,a=2;oyt(n[0],o))},St=1e-8,Te=([e,t,n])=>{let o=Math.min(e,n),r=Math.max(e,n);if(t>=e?n>=t:n<=t)return[o,r];let a=(e*n-t*t)/(e-2*t+n);return a{let r=e-3*t+3*n-o;if(Math.abs(r)0&&l<1){let f=e*(1-l)*(1-l)*(1-l)+t*3*(1-l)*(1-l)*l+n*3*(1-l)*l*l+o*l*l*l;fm&&(m=f)}}return[i,m]};var lt={};oe(lt,{getCubicBBox:()=>Qe,getCubicLength:()=>fe,getPointAtCubicLength:()=>ut,getPointAtCubicSegmentLength:()=>At});var At=([e,t,n,o,r,a,s,i],m)=>{let u=1-m;return{x:u**3*e+3*u**2*m*n+3*u*m**2*r+m**3*s,y:u**3*t+3*u**2*m*o+3*u*m**2*a+m**3*i}},fe=(e,t,n,o,r,a,s,i)=>ie([e,t,n,o,r,a,s,i]),ut=(e,t,n,o,r,a,s,i,m)=>{let u=typeof m=="number",l={x:e,y:t};if(u){let c=ie([e,t,n,o,r,a,s,i]);m<=0||(m>=c?l={x:s,y:i}:l=At([e,t,n,o,r,a,s,i],m/c))}return l},Qe=(e,t,n,o,r,a,s,i)=>{let m=Ve([e,n,r,s]),u=Ve([t,o,a,i]);return[m[0],u[0],m[1],u[1]]};var ct={};oe(ct,{getPointAtQuadLength:()=>pt,getPointAtQuadSegmentLength:()=>Ct,getQuadBBox:()=>ke,getQuadLength:()=>be});var Ct=([e,t,n,o,r,a],s)=>{let i=1-s;return{x:i**2*e+2*i*s*n+s**2*r,y:i**2*t+2*i*s*o+s**2*a}},be=(e,t,n,o,r,a)=>ie([e,t,n,o,r,a]),pt=(e,t,n,o,r,a,s)=>{let i=typeof s=="number",m={x:e,y:t};if(i){let u=ie([e,t,n,o,r,a]);s<=0||(s>=u?m={x:r,y:a}:m=Ct([e,t,n,o,r,a],s/u))}return m},ke=(e,t,n,o,r,a)=>{let s=Te([e,n,r]),i=Te([t,o,a]);return[s[0],i[0],s[1],i[1]]};var ft={};oe(ft,{polygonArea:()=>Yt,polygonLength:()=>er});var Yt=e=>{let t=e.length,n=-1,o,r=e[t-1],a=0;for(;++ne.reduce((t,n,o)=>o?t+ae(e[o-1],n):0,0);var tr={a:7,c:6,h:1,l:2,m:2,r:4,q:4,s:4,t:2,v:1,z:0},H=tr;var rr=e=>{let t=e.pathValue[e.segmentStart],n=t.toLowerCase(),{data:o}=e;for(;o.length>=H[n]&&(n==="m"&&o.length>2?(e.segments.push([t].concat(o.splice(0,2))),n="l",t=t==="m"?"l":"L"):e.segments.push([t].concat(o.splice(0,H[n]))),!!H[n]););},Me=rr;var nr="SVGPathCommander Error",D=nr;var or=e=>{let{index:t,pathValue:n}=e,o=n.charCodeAt(t);if(o===48){e.param=0,e.index+=1;return}if(o===49){e.param=1,e.index+=1;return}e.err=`${D}: invalid Arc flag "${n[t]}", expecting 0 or 1 at index ${t}`},ze=or;var ar=e=>e>=48&&e<=57,j=ar;var sr="Invalid path value",O=sr;var mr=e=>{let{max:t,pathValue:n,index:o}=e,r=o,a=!1,s=!1,i=!1,m=!1,u;if(r>=t){e.err=`${D}: ${O} at index ${r}, "pathValue" is missing param`;return}if(u=n.charCodeAt(r),(u===43||u===45)&&(r+=1,u=n.charCodeAt(r)),!j(u)&&u!==46){e.err=`${D}: ${O} at index ${r}, "${n[r]}" is not a number`;return}if(u!==46){if(a=u===48,r+=1,u=n.charCodeAt(r),a&&r[5760,6158,8192,8193,8194,8195,8196,8197,8198,8199,8200,8201,8202,8239,8287,12288,65279,10,13,8232,8233,32,9,11,12,160].includes(e),De=ir;var ur=e=>{let{pathValue:t,max:n}=e;for(;e.index{switch(e|32){case 109:case 122:case 108:case 104:case 118:case 99:case 115:case 113:case 116:case 97:return!0;default:return!1}},Ee=lr;var pr=e=>j(e)||e===43||e===45||e===46,Ie=pr;var cr=e=>(e|32)===97,$e=cr;var fr=e=>{switch(e|32){case 109:case 77:return!0;default:return!1}},Be=fr;var br=e=>{let{max:t,pathValue:n,index:o,segments:r}=e,a=n.charCodeAt(o),s=H[n[o].toLowerCase()];if(e.segmentStart=o,!Ee(a)){e.err=`${D}: ${O} "${n[o]}" is not a path command at index ${o}`;return}let i=r[r.length-1];if(!Be(a)&&i?.[0]?.toLocaleLowerCase()==="z"){e.err=`${D}: ${O} "${n[o]}" is not a MoveTo path command at index ${o}`;return}if(e.index+=1,Z(e),e.data=[],!s){Me(e);return}for(;;){for(let m=s;m>0;m-=1){if($e(a)&&(m===3||m===4)?ze(e):qe(e),e.err.length)return;e.data.push(e.param),Z(e),e.index=e.max||!Ie(n.charCodeAt(e.index)))break}Me(e)},he=br;var F=class{constructor(t){this.segments=[],this.pathValue=t,this.max=t.length,this.index=0,this.param=0,this.segmentStart=0,this.data=[],this.err=""}};var hr=e=>{if(typeof e!="string")return e.slice(0);let t=new F(e);for(Z(t);t.index{let[r]=e,a=r.toUpperCase(),s=a===r;if(t===0||s)return e;if(a==="A")return[a,e[1],e[2],e[3],e[4],e[5],e[6]+n,e[7]+o];if(a==="V")return[a,e[1]+o];if(a==="H")return[a,e[1]+n];if(a==="L")return[a,e[1]+n,e[2]+o];{let i=[],m=e.length;for(let u=1;u{let n=e.length,o,r="M",a="M",s=!1,i=0,m=0,u=0,l=0,c=0;for(let f=0;f{let t=v(e);return T(t,G)},ge=yr;var xr=(e,t,n,o)=>{let[r]=e,a=r.toLowerCase(),s=r===a;if(t===0||s)return e;if(a==="a")return[a,e[1],e[2],e[3],e[4],e[5],e[6]-n,e[7]-o];if(a==="v")return[a,e[1]-o];if(a==="h")return[a,e[1]-n];if(a==="l")return[a,e[1]-n,e[2]-o];{let i=[],m=e.length;for(let u=1;u{let t=v(e);return T(t,de)},Tt=Pr;var Sr=(e,t,n)=>{let{sin:o,cos:r}=Math,a=e*r(n)-t*o(n),s=e*o(n)+t*r(n);return{x:a,y:s}},ue=Sr;var Mt=(e,t,n,o,r,a,s,i,m,u)=>{let l=e,c=t,f=n,b=o,p=i,h=m,y=Math.PI*120/180,S=Math.PI/180*(+r||0),A=[],d,g,x,C,V;if(u)[g,x,C,V]=u;else{d=ue(l,c,-S),l=d.x,c=d.y,d=ue(p,h,-S),p=d.x,h=d.y;let N=(l-p)/2,q=(c-h)/2,R=N*N/(f*f)+q*q/(b*b);R>1&&(R=Math.sqrt(R),f*=R,b*=R);let Xe=f*f,Ye=b*b,bt=(a===s?-1:1)*Math.sqrt(Math.abs((Xe*Ye-Xe*q*q-Ye*N*N)/(Xe*q*q+Ye*N*N)));C=bt*f*q/b+(l+p)/2,V=bt*-b*N/f+(c+h)/2,g=Math.asin(((c-V)/b*10**9>>0)/10**9),x=Math.asin(((h-V)/b*10**9>>0)/10**9),g=lx&&(g-=Math.PI*2),!s&&x>g&&(x-=Math.PI*2)}let Q=x-g;if(Math.abs(Q)>y){let N=x,q=p,R=h;x=g+y*(s&&x>g?1:-1),p=C+f*Math.cos(x),h=V+b*Math.sin(x),A=Mt(p,h,f,b,r,0,s,q,R,[x,N,C,V])}Q=x-g;let w=Math.cos(g),L=Math.sin(g),$=Math.cos(x),re=Math.sin(x),k=Math.tan(Q/4),P=4/3*f*k,z=4/3*b*k,B=[l,c],I=[l+P*L,c-z*w],K=[p+P*re,h-z*$],ce=[p,h];if(I[0]=2*B[0]-I[0],I[1]=2*B[1]-I[1],u)return[I[0],I[1],K[0],K[1],ce[0],ce[1]].concat(A);A=[I[0],I[1],K[0],K[1],ce[0],ce[1]].concat(A);let ne=[];for(let N=0,q=A.length;N{let s=.3333333333333333,i=2/3;return[s*e+i*n,s*t+i*o,s*r+i*n,s*a+i*o,r,a]},je=Ar;var Cr=(e,t,n,o)=>{let r=E([e,t],[n,o],.3333333333333333),a=E([e,t],[n,o],2/3);return[r[0],r[1],a[0],a[1],n,o]},Le=Cr;var Tr=(e,t)=>{let[n]=e,o=e.slice(1).map(Number),[r,a]=o,{x1:s,y1:i,x:m,y:u}=t;return"TQ".includes(n)||(t.qx=null,t.qy=null),n==="M"?(t.x=r,t.y=a,e):n==="A"?["C"].concat(ye(s,i,o[0],o[1],o[2],o[3],o[4],o[5],o[6])):n==="Q"?(t.qx=r,t.qy=a,["C"].concat(je(s,i,o[0],o[1],o[2],o[3]))):n==="L"?["C"].concat(Le(s,i,r,a)):n==="Z"?["C"].concat(Le(s,i,m,u)):e},Oe=Tr;var Mr=(e,t)=>{let[n]=e,o=n.toUpperCase(),r=n!==o,{x1:a,y1:s,x2:i,y2:m,x:u,y:l}=t,c=e.slice(1),f=c.map((b,p)=>b+(r?p%2?l:u:0));"TQ".includes(o)||(t.qx=null,t.qy=null);if(o==="A")return f=c.slice(0,-2).concat(c[5]+(r?u:0),c[6]+(r?l:0)),["A"].concat(f);if(o==="H")return["L",e[1]+(r?u:0),s];if(o==="V")return["L",a,e[1]+(r?l:0)];if(o==="L")return["L",e[1]+(r?u:0),e[2]+(r?l:0)];if(o==="M")return["M",e[1]+(r?u:0),e[2]+(r?l:0)];if(o==="C")return["C"].concat(f);if(o==="S"){let b=a*2-i,p=s*2-m;return t.x1=b,t.y1=p,["C",b,p].concat(f)}else if(o==="T"){let b=a*2-(t.qx?t.qx:0),p=s*2-(t.qy?t.qy:0);return t.qx=b,t.qy=p,["Q",b,p].concat(f)}else if(o==="Q"){let[b,p]=f;return t.qx=b,t.qy=p,["Q"].concat(f)}else if(o==="Z")return["Z"];return e},J=Mr;var Lr={x1:0,y1:0,x2:0,y2:0,x:0,y:0,qx:null,qy:null},_=Lr;var vr=e=>{let t={..._},n=v(e);return T(n,(o,r,a,s)=>{t.x=a,t.y=s;let i=J(o,t),m=Oe(i,t);m[0]==="C"&&m.length>7&&(n.splice(r+1,0,["C"].concat(m.slice(7))),m=m.slice(0,7));let l=m.length;return t.x1=+m[l-2],t.y1=+m[l-1],t.x2=+m[l-4]||t.x1,t.y2=+m[l-3]||t.y1,m})},xe=vr;var Nr={origin:[0,0,0],round:4},U=Nr;var wr=(e,t)=>{let n=t>=1?10**t:1;return t>0?Math.round(e*n)/n:Math.round(e)},M=wr;var Rr=(e,t)=>{let n=e.length,{round:o}=U,r=e[0],a="";o=t==="off"||typeof t=="number"&&t>=0?t:typeof o=="number"&&o>=0?o:"off";for(let s=0;s{let t=v(e),n={..._};return T(t,(o,r,a,s)=>{n.x=a,n.y=s;let i=J(o,n),m=i.length;return n.x1=+i[m-2],n.y1=+i[m-1],n.x2=+i[m-4]||n.x1,n.y2=+i[m-3]||n.y1,i})},W=Vr;var Qr=(e,t)=>{let n=W(e),o=!1,r=[],a="M",s=0,i=0,[m,u]=n[0].slice(1),l=typeof t=="number",c={x:m,y:u},f=0,b=c,p=0;return!l||t{[a]=h,o=a==="M",r=o?r:[S,A].concat(h.slice(1));if(o?([,m,u]=h,c={x:m,y:u},f=0):a==="L"?(c=Ae(r[0],r[1],r[2],r[3],t-p),f=se(r[0],r[1],r[2],r[3])):a==="A"?(c=ot(r[0],r[1],r[2],r[3],r[4],r[5],r[6],r[7],r[8],t-p),f=Ce(r[0],r[1],r[2],r[3],r[4],r[5],r[6],r[7],r[8])):a==="C"?(c=ut(r[0],r[1],r[2],r[3],r[4],r[5],r[6],r[7],t-p),f=fe(r[0],r[1],r[2],r[3],r[4],r[5],r[6],r[7])):a==="Q"?(c=pt(r[0],r[1],r[2],r[3],r[4],r[5],t-p),f=be(r[0],r[1],r[2],r[3],r[4],r[5])):a==="Z"&&(r=[S,A,m,u],c={x:m,y:u},f=se(r[0],r[1],r[2],r[3])),[s,i]=r.slice(-2),pp-le?{x:s,y:i}:b)},Pe=Qr;var kr=e=>{let t=v(e),n=0,o=0,r=0,a=0,s=0,i=0,m="M",u=0,l=0,c=0;return T(t,(f,b,p,h)=>{[m]=f;let y=m.toUpperCase(),A=y!==m?G(f,b,p,h):f.slice(0),d=y==="V"?["L",p,A[1]]:y==="H"?["L",A[1],h]:A;[m]=d,"TQ".includes(y)||(s=0,i=0);if(m==="M")[,u,l]=d;else if(m==="L")c+=se(p,h,d[1],d[2]);else if(m==="A")c+=Ce(p,h,d[1],d[2],d[3],d[4],d[5],d[6],d[7]);else if(m==="S"){let g=n*2-r,x=o*2-a;c+=fe(p,h,g,x,d[1],d[2],d[3],d[4])}else m==="C"?c+=fe(p,h,d[1],d[2],d[3],d[4],d[5],d[6]):m==="T"?(s=n*2-s,i=o*2-i,c+=be(p,h,s,i,d[1],d[2])):m==="Q"?(s=d[1],i=d[2],c+=be(p,h,d[1],d[2],d[3],d[4])):m==="Z"&&(c+=se(p,h,u,l));[n,o]=m==="Z"?[u,l]:d.slice(-2),[r,a]=m==="C"?[d[3],d[4]]:m==="S"?[d[1],d[2]]:[n,o]}),c},X=kr;var zr=(e,t)=>{let n=v(e),o=n.slice(0),r=X(o),a=o.length-1,s=0,i=0,m=n[0];if(a<=0||!t||!Number.isFinite(t))return{segment:m,index:0,length:i,lengthAtSegment:s};if(t>=r)return o=n.slice(0,-1),s=X(o),i=r-s,m=n[a],{segment:m,index:a,length:i,lengthAtSegment:s};let u=[];for(;a>0;)m=o[a],o=o.slice(0,-1),s=X(o),i=r-s,r=s,u.push({segment:m,index:a,length:i,lengthAtSegment:s}),a-=1;return u.find(({lengthAtSegment:l})=>l<=t)},Se=zr;var qr=(e,t)=>{let n=v(e),o=W(n),r=X(o),a=g=>{let x=g.x-t.x,C=g.y-t.y;return x*x+C*C},s=8,i,m={x:0,y:0},u=0,l=0,c=1/0;for(let g=0;g<=r;g+=s)i=Pe(o,g),u=a(i),u1e-6&&(p=l-s,f=Pe(o,p),y=a(f),h=l+s,b=Pe(o,h),S=a(b),p>=0&&yY(e,t).closest,Lt=Dr;var Er=(e,t,n,o,r,a,s,i)=>3*((i-t)*(n+r)-(s-e)*(o+a)+o*(e-r)-n*(t-a)+i*(r+e/3)-s*(a+t/3))/20,Ir=e=>{let t=0,n=0,o=0;return xe(e).map(r=>{switch(r[0]){case"M":return[,t,n]=r,0;default:return o=Er(t,n,r[1],r[2],r[3],r[4],r[5],r[6]),[t,n]=r.slice(-2),o}}).reduce((r,a)=>r+a,0)},Ze=Ir;var $r=e=>Ze(xe(e))>=0,vt=$r;var Br=e=>{if(!e)return{x:0,y:0,width:0,height:0,x2:0,y2:0,cx:0,cy:0,cz:0};let t=v(e),n="M",o=0,r=0,{max:a,min:s}=Math,i=1/0,m=1/0,u=-1/0,l=-1/0,c=0,f=0,b=0,p=0,h=0,y=0,S=0,A=0,d=0,g=0;T(t,(V,Q,w,L)=>{[n]=V;let $=n.toUpperCase(),k=$!==n?G(V,Q,w,L):V.slice(0),P=$==="V"?["L",w,k[1]]:$==="H"?["L",k[1],L]:k;[n]=P,"TQ".includes($)||(d=0,g=0);if(n==="M")[,o,r]=P,c=o,f=r,b=o,p=r;else if(n==="L")[c,f,b,p]=we(w,L,P[1],P[2]);else if(n==="A")[c,f,b,p]=at(w,L,P[1],P[2],P[3],P[4],P[5],P[6],P[7]);else if(n==="S"){let z=h*2-S,B=y*2-A;[c,f,b,p]=Qe(w,L,z,B,P[1],P[2],P[3],P[4])}else n==="C"?[c,f,b,p]=Qe(w,L,P[1],P[2],P[3],P[4],P[5],P[6]):n==="T"?(d=h*2-d,g=y*2-g,[c,f,b,p]=ke(w,L,d,g,P[1],P[2])):n==="Q"?(d=P[1],g=P[2],[c,f,b,p]=ke(w,L,P[1],P[2],P[3],P[4])):n==="Z"&&([c,f,b,p]=we(w,L,o,r));i=s(c,i),m=s(f,m),u=a(b,u),l=a(p,l),[h,y]=n==="Z"?[o,r]:P.slice(-2),[S,A]=n==="C"?[P[3],P[4]]:n==="S"?[P[1],P[2]]:[h,y]});let x=u-i,C=l-m;return{width:x,height:C,x:i,y:m,x2:u,y2:l,cx:i+x/2,cy:m+C/2,cz:Math.max(x,C)+Math.min(x,C)/2}},Nt=Br;var jr=(e,t)=>Se(e,t).segment,wt=jr;var Or=(e,t)=>Y(e,t).segment,Rt=Or;var Hr=e=>Array.isArray(e)&&e.every(t=>{let n=t[0].toLowerCase();return H[n]===t.length-1&&"achlmqstvz".includes(n)&&t.slice(1).every(Number.isFinite)})&&e.length>0,ee=Hr;var Zr=e=>ee(e)&&e.every(([t])=>t===t.toUpperCase()),Ge=Zr;var Gr=e=>Ge(e)&&e.every(([t])=>"ACLMQZ".includes(t)),_e=Gr;var _r=e=>_e(e)&&e.every(([t])=>"MC".includes(t)),Vt=_r;var Ur=(e,t)=>{let{distance:n}=Y(e,t);return Math.abs(n)ee(e)&&e.slice(1).every(([t])=>t===t.toLowerCase()),kt=Kr;var Fr=e=>{if(typeof e!="string"||!e.length)return!1;let t=new F(e);for(Z(t);t.indexe!=null&&typeof e=="object"&&e.nodeType===1,Ke=Wr;var Xr=e=>{let{x1:t,y1:n,x2:o,y2:r}=e;return[t,n,o,r]=[t,n,o,r].map(a=>+a),[["M",t,n],["L",o,r]]},Yr=e=>{let t=[],n=(e.points||"").trim().split(/[\s|,]/).map(r=>+r),o=0;for(;o{let{cx:t,cy:n,r:o}=e;return[t,n,o]=[t,n,o].map(r=>+r),[["M",t-o,n],["a",o,o,0,1,0,2*o,0],["a",o,o,0,1,0,-2*o,0]]},tn=e=>{let{cx:t,cy:n}=e,o=e.rx||0,r=e.ry||o;return[t,n,o,r]=[t,n,o,r].map(a=>+a),[["M",t-o,n],["a",o,r,0,1,0,2*o,0],["a",o,r,0,1,0,-2*o,0]]},rn=e=>{let t=+e.x||0,n=+e.y||0,o=+e.width,r=+e.height,a=+(e.rx||0),s=+(e.ry||a);if(a||s){a*2>o&&(a-=(a*2-o)/2);return s*2>r&&(s-=(s*2-r)/2),[["M",t+a,n],["h",o-a*2],["s",a,0,a,s],["v",r-s*2],["s",0,s,-a,s],["h",-o+a*2],["s",-a,0,-a,-s],["v",-r+s*2],["s",0,-s,a,-s]]}return[["M",t,n],["h",o],["v",r],["H",t],["Z"]]},nn=e=>{let t=Object.keys(te),n=Ke(e),o=n?e.tagName:null;if(o&&[...t,"path"].every(m=>o!==m))throw TypeError(`${D}: "${o}" is not SVGElement`);let r=n?o:e.type,a=te[r],s={type:r};n?a.forEach(m=>{s[m]=e.getAttribute(m)}):Object.assign(s,e);let i=[];return r==="circle"?i=en(s):r==="ellipse"?i=tn(s):["polyline","polygon"].includes(r)?i=Yr(s):r==="rect"?i=rn(s):r==="line"?i=Xr(s):["glyph","path"].includes(r)&&(i=v(n?e.getAttribute("d")||"":e.d||"")),ee(i)&&i.length?i:!1},Fe=nn;var on=(e,t,n)=>{let o=n||document,r=Object.keys(te),a=Ke(e),s=a?e.tagName:null;if(s==="path")throw TypeError(`${D}: "${s}" is already SVGPathElement`);if(s&&r.every(p=>s!==p))throw TypeError(`${D}: "${s}" is not SVGElement`);let i=o.createElementNS("http://www.w3.org/2000/svg","path"),m=a?s:e.type,u=te[m],l={type:m},c=U.round,f=Fe(e),b=f&&f.length?He(f,c):"";return a?(u.forEach(p=>{l[p]=e.getAttribute(p)}),Object.values(e.attributes).forEach(({name:p,value:h})=>{u.includes(p)||i.setAttribute(p,h)})):(Object.assign(l,e),Object.keys(l).forEach(p=>{!u.includes(p)&&p!=="type"&&i.setAttribute(p.replace(/[A-Z]/g,h=>`-${h.toLowerCase()}`),l[p])})),Ue(b)?(i.setAttribute("d",b),t&&a&&(e.before(i,e),e.remove()),i):!1},zt=on;var qt=et(require("@thednp/dommatrix"),1),an=e=>{let t=new qt.default,{origin:n}=e,[o,r]=n,{translate:a}=e,{rotate:s}=e,{skew:i}=e,{scale:m}=e;return Array.isArray(a)&&a.length>=2&&a.every(u=>!Number.isNaN(+u))&&a.some(u=>u!==0)?t=t.translate(...a):typeof a=="number"&&!Number.isNaN(a)&&(t=t.translate(a)),(s||i||m)&&(t=t.translate(o,r),Array.isArray(s)&&s.length>=2&&s.every(u=>!Number.isNaN(+u))&&s.some(u=>u!==0)?t=t.rotate(...s):typeof s=="number"&&!Number.isNaN(s)&&(t=t.rotate(s)),Array.isArray(i)&&i.length===2&&i.every(u=>!Number.isNaN(+u))&&i.some(u=>u!==0)?(t=i[0]?t.skewX(i[0]):t,t=i[1]?t.skewY(i[1]):t):typeof i=="number"&&!Number.isNaN(i)&&(t=t.skewX(i)),Array.isArray(m)&&m.length>=2&&m.every(u=>!Number.isNaN(+u))&&m.some(u=>u!==1)?t=t.scale(...m):typeof m=="number"&&!Number.isNaN(m)&&(t=t.scale(m)),t=t.translate(-o,-r)),t},Je=an;var sn=(e,t,n,o)=>{let[r]=e,{round:a}=U,s=typeof a=="number"?a:4,i=t.slice(1),{x1:m,y1:u,x2:l,y2:c,x:f,y:b}=n,[p,h]=i.slice(-2),y=e;if("TQ".includes(r)||(n.qx=null,n.qy=null),r==="L"){if(M(f,s)===M(p,s))return["V",h];if(M(b,s)===M(h,s))return["H",p]}else if(r==="C"){let[S,A]=i;if(n.x1=S,n.y1=A,"CS".includes(o)&&(M(S,s)===M(m*2-l,s)&&M(A,s)===M(u*2-c,s)||M(m,s)===M(l*2-f,s)&&M(u,s)===M(c*2-b,s)))return["S",i[2],i[3],i[4],i[5]]}else if(r==="Q"){let[S,A]=i;if(n.qx=S,n.qy=A,"QT".includes(o)&&M(S,s)===M(m*2-l,s)&&M(A,s)===M(u*2-c,s))return["T",i[2],i[3]]}return y},We=sn;var mn=(e,t)=>{let n=e.slice(1).map(o=>M(o,t));return[e[0]].concat(n)},pe=mn;var un=(e,t)=>{let n=ge(e),o=typeof t=="number"&&t>=0?t:2,r={..._},a=[],s="M",i="Z";return T(n,(m,u,l,c)=>{r.x=l,r.y=c;let f=J(m,r),b=m;if([s]=m,a[u]=s,u){i=a[u-1];let h=We(m,f,r,i),y=pe(h,o),S=y.join(""),A=de(h,u,l,c),d=pe(A,o),g=d.join("");b=S.length{let n=Et.default.Translate(t[0],t[1],t[2]);return[,,,n.m44]=t,n=e.multiply(n),[n.m41,n.m42,n.m43,n.m44]},pn=(e,t,n)=>{let[o,r,a]=n,[s,i,m]=ln(e,[t[0],t[1],0,1]),u=s-o,l=i-r,c=m-a;return[u*(Math.abs(a)/Math.abs(c)||1)+o,l*(Math.abs(a)/Math.abs(c)||1)+r]},ve=pn;var cn=e=>{let t=e.slice(1).map((n,o,r)=>o?r[o-1].slice(-2).concat(n.slice(1)):e[0].slice(1).concat(n.slice(1))).map(n=>n.map((o,r)=>n[n.length-r-2*(1-r%2)])).reverse();return[["M"].concat(t[0].slice(0,2))].concat(t.map(n=>["C"].concat(n.slice(2))))},It=cn;var fn=e=>{let t=ge(e),n=W(t),o=t.length,r=t[o-1][0]==="Z",a=T(t,(s,i)=>{let m=n[i],u=i&&t[i-1],l=u&&u[0],c=t[i+1],f=c&&c[0],[b]=s,[p,h]=n[i?i-1:o-1].slice(-2),y=s;switch(b){case"M":y=r?["Z"]:[b,p,h];break;case"A":y=[b,s[1],s[2],s[3],s[4],s[5]===1?0:1,p,h];break;case"C":c&&f==="S"?y=["S",s[1],s[2],p,h]:y=[b,s[3],s[4],s[1],s[2],p,h];break;case"S":l&&"CS".includes(l)&&(!c||f!=="S")?y=["C",m[3],m[4],m[1],m[2],p,h]:y=[b,m[1],m[2],p,h];break;case"Q":c&&f==="T"?y=["T",p,h]:y=[b,s[1],s[2],p,h];break;case"T":l&&"QT".includes(l)&&(!c||f!=="T")?y=["Q",m[1],m[2],p,h]:y=[b,p,h];break;case"Z":y=["M",p,h];break;case"H":y=[b,p];break;case"V":y=[b,h];break;default:y=[b].concat(s.slice(1,-2),p,h)}return y});return r?a.reverse():[a[0]].concat(a.slice(1).reverse())},$t=fn;var bn=(e,t)=>{let{round:n}=U;n=t==="off"||typeof t=="number"&&t>=0?t:typeof n=="number"&&n>=0?n:"off";return n==="off"?e.slice(0):T(e,o=>pe(o,n))},Bt=bn;var hn=(e,t=.5)=>{let n=t,o=e.slice(0,2),r=e.slice(2,4),a=e.slice(4,6),s=e.slice(6,8),i=E(o,r,n),m=E(r,a,n),u=E(a,s,n),l=E(i,m,n),c=E(m,u,n),f=E(l,c,n);return[["C",i[0],i[1],l[0],l[1],f[0],f[1]],["C",c[0],c[1],u[0],u[1],s[0],s[1]]]},jt=hn;var gn=e=>{let t=[],n,o=-1,r=0,a=0,s=0,i=0,m={..._};return e.forEach(u=>{let[l]=u,c=l.toUpperCase(),f=l.toLowerCase(),b=l===f,p=u.slice(1);c==="M"?(o+=1,[r,a]=p,r+=b?m.x:0,a+=b?m.y:0,s=r,i=a,n=[b?[c,s,i]:u]):(c==="Z"?(r=s,a=i):c==="H"?([,r]=u,r+=b?m.x:0):c==="V"?([,a]=u,a+=b?m.y:0):([r,a]=u.slice(-2),r+=b?m.x:0,a+=b?m.y:0),n.push(u)),m.x=r,m.y=a,t[o]=n}),t},Ot=gn;var dn=(e,t)=>{let n=0,o=0,r=0,a=0,s=0,i=0,m="M",u=v(e),l=t&&Object.keys(t);if(!t||l&&!l.length)return u.slice(0);t.origin||Object.assign(t,{origin:U.origin});let c=t.origin,f=Je(t);return f.isIdentity?u.slice(0):T(u,(b,p,h,y)=>{[m]=b;let S=m.toUpperCase(),d=S!==m?G(b,p,h,y):b.slice(0),g=S==="A"?["C"].concat(ye(h,y,d[1],d[2],d[3],d[4],d[5],d[6],d[7])):S==="V"?["L",h,d[1]]:S==="H"?["L",d[1],y]:d;m=g[0];let x=m==="C"&&g.length>7,C=x?g.slice(0,7):g.slice(0);if(x&&(u.splice(p+1,0,["C"].concat(g.slice(7))),g=C),m==="L"){[r,a]=ve(f,[g[1],g[2]],c);n!==r&&o!==a?g=["L",r,a]:o===a?g=["H",r]:n===r&&(g=["V",a])}else for(s=1,i=g.length;s t in s ? Z(s, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : s[t] = e;\nvar p = (s, t, e) => z(s, typeof t != \"symbol\" ? t + \"\" : t, e);\nconst $ = {\n a: 1,\n b: 0,\n c: 0,\n d: 1,\n e: 0,\n f: 0,\n m11: 1,\n m12: 0,\n m13: 0,\n m14: 0,\n m21: 0,\n m22: 1,\n m23: 0,\n m24: 0,\n m31: 0,\n m32: 0,\n m33: 1,\n m34: 0,\n m41: 0,\n m42: 0,\n m43: 0,\n m44: 1,\n is2D: !0,\n isIdentity: !0\n}, E = (s) => (s instanceof Float64Array || s instanceof Float32Array || Array.isArray(s) && s.every((t) => typeof t == \"number\")) && [6, 16].some((t) => s.length === t), P = (s) => s instanceof DOMMatrix || s instanceof y || typeof s == \"object\" && Object.keys($).every((t) => s && t in s), g = (s) => {\n const t = new y(), e = Array.from(s);\n if (!E(e))\n throw TypeError(\n `CSSMatrix: \"${e.join(\",\")}\" must be an array with 6/16 numbers.`\n );\n // istanbul ignore else @preserve\n if (e.length === 16) {\n const [\n n,\n i,\n r,\n a,\n l,\n m,\n h,\n c,\n u,\n f,\n w,\n o,\n d,\n A,\n M,\n b\n ] = e;\n t.m11 = n, t.a = n, t.m21 = l, t.c = l, t.m31 = u, t.m41 = d, t.e = d, t.m12 = i, t.b = i, t.m22 = m, t.d = m, t.m32 = f, t.m42 = A, t.f = A, t.m13 = r, t.m23 = h, t.m33 = w, t.m43 = M, t.m14 = a, t.m24 = c, t.m34 = o, t.m44 = b;\n } else if (e.length === 6) {\n const [n, i, r, a, l, m] = e;\n t.m11 = n, t.a = n, t.m12 = i, t.b = i, t.m21 = r, t.c = r, t.m22 = a, t.d = a, t.m41 = l, t.e = l, t.m42 = m, t.f = m;\n }\n return t;\n}, X = (s) => {\n if (P(s))\n return g([\n s.m11,\n s.m12,\n s.m13,\n s.m14,\n s.m21,\n s.m22,\n s.m23,\n s.m24,\n s.m31,\n s.m32,\n s.m33,\n s.m34,\n s.m41,\n s.m42,\n s.m43,\n s.m44\n ]);\n throw TypeError(\n `CSSMatrix: \"${JSON.stringify(s)}\" is not a DOMMatrix / CSSMatrix / JSON compatible object.`\n );\n}, O = (s) => {\n if (typeof s != \"string\")\n throw TypeError(`CSSMatrix: \"${JSON.stringify(s)}\" is not a string.`);\n const t = String(s).replace(/\\s/g, \"\");\n let e = new y();\n const n = `CSSMatrix: invalid transform string \"${s}\"`;\n return t.split(\")\").filter((i) => i).forEach((i) => {\n const [r, a] = i.split(\"(\");\n if (!a) throw TypeError(n);\n const l = a.split(\",\").map(\n (o) => o.includes(\"rad\") ? parseFloat(o) * (180 / Math.PI) : parseFloat(o)\n ), [m, h, c, u] = l, f = [m, h, c], w = [m, h, c, u];\n if (r === \"perspective\" && m && [h, c].every((o) => o === void 0))\n e.m34 = -1 / m;\n else if (r.includes(\"matrix\") && [6, 16].includes(l.length) && l.every((o) => !Number.isNaN(+o))) {\n const o = l.map((d) => Math.abs(d) < 1e-6 ? 0 : d);\n e = e.multiply(g(o));\n } else if (r === \"translate3d\" && f.every((o) => !Number.isNaN(+o)))\n e = e.translate(m, h, c);\n else if (r === \"translate\" && m && c === void 0)\n e = e.translate(m, h || 0, 0);\n else if (r === \"rotate3d\" && w.every((o) => !Number.isNaN(+o)) && u)\n e = e.rotateAxisAngle(m, h, c, u);\n else if (r === \"rotate\" && m && [h, c].every((o) => o === void 0))\n e = e.rotate(0, 0, m);\n else if (r === \"scale3d\" && f.every((o) => !Number.isNaN(+o)) && f.some((o) => o !== 1))\n e = e.scale(m, h, c);\n else if (\n // prop === \"scale\" && !Number.isNaN(x) && x !== 1 && z === undefined\n // prop === \"scale\" && !Number.isNaN(x) && [x, y].some((n) => n !== 1) &&\n r === \"scale\" && !Number.isNaN(m) && (m !== 1 || h !== 1) && c === void 0\n ) {\n const d = Number.isNaN(+h) ? m : h;\n e = e.scale(m, d, 1);\n } else if (r === \"skew\" && (m || !Number.isNaN(m) && h) && c === void 0)\n e = e.skew(m, h || 0);\n else if ([\"translate\", \"rotate\", \"scale\", \"skew\"].some(\n (o) => r.includes(o)\n ) && /[XYZ]/.test(r) && m && [h, c].every((o) => o === void 0))\n if (r === \"skewX\" || r === \"skewY\")\n e = e[r](m);\n else {\n const o = r.replace(/[XYZ]/, \"\"), d = r.replace(o, \"\"), A = [\"X\", \"Y\", \"Z\"].indexOf(d), M = o === \"scale\" ? 1 : 0, b = [\n A === 0 ? m : M,\n A === 1 ? m : M,\n A === 2 ? m : M\n ];\n e = e[o](...b);\n }\n else\n throw TypeError(n);\n }), e;\n}, x = (s, t) => t ? [s.a, s.b, s.c, s.d, s.e, s.f] : [\n s.m11,\n s.m12,\n s.m13,\n s.m14,\n s.m21,\n s.m22,\n s.m23,\n s.m24,\n s.m31,\n s.m32,\n s.m33,\n s.m34,\n s.m41,\n s.m42,\n s.m43,\n s.m44\n], Y = (s, t, e) => {\n const n = new y();\n return n.m41 = s, n.e = s, n.m42 = t, n.f = t, n.m43 = e, n;\n}, F = (s, t, e) => {\n const n = new y(), i = Math.PI / 180, r = s * i, a = t * i, l = e * i, m = Math.cos(r), h = -Math.sin(r), c = Math.cos(a), u = -Math.sin(a), f = Math.cos(l), w = -Math.sin(l), o = c * f, d = -c * w;\n n.m11 = o, n.a = o, n.m12 = d, n.b = d, n.m13 = u;\n const A = h * u * f + m * w;\n n.m21 = A, n.c = A;\n const M = m * f - h * u * w;\n return n.m22 = M, n.d = M, n.m23 = -h * c, n.m31 = h * w - m * u * f, n.m32 = h * f + m * u * w, n.m33 = m * c, n;\n}, T = (s, t, e, n) => {\n const i = new y(), r = Math.sqrt(s * s + t * t + e * e);\n if (r === 0)\n return i;\n const a = s / r, l = t / r, m = e / r, h = n * (Math.PI / 360), c = Math.sin(h), u = Math.cos(h), f = c * c, w = a * a, o = l * l, d = m * m, A = 1 - 2 * (o + d) * f;\n i.m11 = A, i.a = A;\n const M = 2 * (a * l * f + m * c * u);\n i.m12 = M, i.b = M, i.m13 = 2 * (a * m * f - l * c * u);\n const b = 2 * (l * a * f - m * c * u);\n i.m21 = b, i.c = b;\n const k = 1 - 2 * (d + w) * f;\n return i.m22 = k, i.d = k, i.m23 = 2 * (l * m * f + a * c * u), i.m31 = 2 * (m * a * f + l * c * u), i.m32 = 2 * (m * l * f - a * c * u), i.m33 = 1 - 2 * (w + o) * f, i;\n}, I = (s, t, e) => {\n const n = new y();\n return n.m11 = s, n.a = s, n.m22 = t, n.d = t, n.m33 = e, n;\n}, v = (s, t) => {\n const e = new y();\n if (s) {\n const n = s * Math.PI / 180, i = Math.tan(n);\n e.m21 = i, e.c = i;\n }\n if (t) {\n const n = t * Math.PI / 180, i = Math.tan(n);\n e.m12 = i, e.b = i;\n }\n return e;\n}, R = (s) => v(s, 0), D = (s) => v(0, s), N = (s, t) => {\n const e = t.m11 * s.m11 + t.m12 * s.m21 + t.m13 * s.m31 + t.m14 * s.m41, n = t.m11 * s.m12 + t.m12 * s.m22 + t.m13 * s.m32 + t.m14 * s.m42, i = t.m11 * s.m13 + t.m12 * s.m23 + t.m13 * s.m33 + t.m14 * s.m43, r = t.m11 * s.m14 + t.m12 * s.m24 + t.m13 * s.m34 + t.m14 * s.m44, a = t.m21 * s.m11 + t.m22 * s.m21 + t.m23 * s.m31 + t.m24 * s.m41, l = t.m21 * s.m12 + t.m22 * s.m22 + t.m23 * s.m32 + t.m24 * s.m42, m = t.m21 * s.m13 + t.m22 * s.m23 + t.m23 * s.m33 + t.m24 * s.m43, h = t.m21 * s.m14 + t.m22 * s.m24 + t.m23 * s.m34 + t.m24 * s.m44, c = t.m31 * s.m11 + t.m32 * s.m21 + t.m33 * s.m31 + t.m34 * s.m41, u = t.m31 * s.m12 + t.m32 * s.m22 + t.m33 * s.m32 + t.m34 * s.m42, f = t.m31 * s.m13 + t.m32 * s.m23 + t.m33 * s.m33 + t.m34 * s.m43, w = t.m31 * s.m14 + t.m32 * s.m24 + t.m33 * s.m34 + t.m34 * s.m44, o = t.m41 * s.m11 + t.m42 * s.m21 + t.m43 * s.m31 + t.m44 * s.m41, d = t.m41 * s.m12 + t.m42 * s.m22 + t.m43 * s.m32 + t.m44 * s.m42, A = t.m41 * s.m13 + t.m42 * s.m23 + t.m43 * s.m33 + t.m44 * s.m43, M = t.m41 * s.m14 + t.m42 * s.m24 + t.m43 * s.m34 + t.m44 * s.m44;\n return g([\n e,\n n,\n i,\n r,\n a,\n l,\n m,\n h,\n c,\n u,\n f,\n w,\n o,\n d,\n A,\n M\n ]);\n};\nclass y {\n /**\n * @constructor\n * @param init accepts all parameter configurations:\n * * valid CSS transform string,\n * * CSSMatrix/DOMMatrix instance,\n * * a 6/16 elements *Array*.\n */\n constructor(t) {\n return this.a = 1, this.b = 0, this.c = 0, this.d = 1, this.e = 0, this.f = 0, this.m11 = 1, this.m12 = 0, this.m13 = 0, this.m14 = 0, this.m21 = 0, this.m22 = 1, this.m23 = 0, this.m24 = 0, this.m31 = 0, this.m32 = 0, this.m33 = 1, this.m34 = 0, this.m41 = 0, this.m42 = 0, this.m43 = 0, this.m44 = 1, t ? this.setMatrixValue(t) : this;\n }\n /**\n * A `Boolean` whose value is `true` if the matrix is the identity matrix. The identity\n * matrix is one in which every value is 0 except those on the main diagonal from top-left\n * to bottom-right corner (in other words, where the offsets in each direction are equal).\n *\n * @return the current property value\n */\n get isIdentity() {\n return this.m11 === 1 && this.m12 === 0 && this.m13 === 0 && this.m14 === 0 && this.m21 === 0 && this.m22 === 1 && this.m23 === 0 && this.m24 === 0 && this.m31 === 0 && this.m32 === 0 && this.m33 === 1 && this.m34 === 0 && this.m41 === 0 && this.m42 === 0 && this.m43 === 0 && this.m44 === 1;\n }\n /**\n * A `Boolean` flag whose value is `true` if the matrix was initialized as a 2D matrix\n * and `false` if the matrix is 3D.\n *\n * @return the current property value\n */\n get is2D() {\n return this.m31 === 0 && this.m32 === 0 && this.m33 === 1 && this.m34 === 0 && this.m43 === 0 && this.m44 === 1;\n }\n /**\n * The `setMatrixValue` method replaces the existing matrix with one computed\n * in the browser. EG: `matrix(1,0.25,-0.25,1,0,0)`\n *\n * The method accepts any *Array* values, the result of\n * `DOMMatrix` instance method `toFloat64Array()` / `toFloat32Array()` calls\n * or `CSSMatrix` instance method `toArray()`.\n *\n * This method expects valid *matrix()* / *matrix3d()* string values, as well\n * as other transform functions like *translateX(10px)*.\n *\n * @param source\n * @return the matrix instance\n */\n setMatrixValue(t) {\n return typeof t == \"string\" && t.length && t !== \"none\" ? O(t) : Array.isArray(t) || t instanceof Float64Array || t instanceof Float32Array ? g(t) : typeof t == \"object\" ? X(t) : this;\n }\n /**\n * Returns a *Float32Array* containing elements which comprise the matrix.\n * The method can return either the 16 elements or the 6 elements\n * depending on the value of the `is2D` parameter.\n *\n * @param is2D *Array* representation of the matrix\n * @return an *Array* representation of the matrix\n */\n toFloat32Array(t) {\n return Float32Array.from(x(this, t));\n }\n /**\n * Returns a *Float64Array* containing elements which comprise the matrix.\n * The method can return either the 16 elements or the 6 elements\n * depending on the value of the `is2D` parameter.\n *\n * @param is2D *Array* representation of the matrix\n * @return an *Array* representation of the matrix\n */\n toFloat64Array(t) {\n return Float64Array.from(x(this, t));\n }\n /**\n * Creates and returns a string representation of the matrix in `CSS` matrix syntax,\n * using the appropriate `CSS` matrix notation.\n *\n * matrix3d *matrix3d(m11, m12, m13, m14, m21, ...)*\n * matrix *matrix(a, b, c, d, e, f)*\n *\n * @return a string representation of the matrix\n */\n toString() {\n const { is2D: t } = this, e = this.toFloat64Array(t).join(\", \");\n return `${t ? \"matrix\" : \"matrix3d\"}(${e})`;\n }\n /**\n * Returns a JSON representation of the `CSSMatrix` instance, a standard *Object*\n * that includes `{a,b,c,d,e,f}` and `{m11,m12,m13,..m44}` properties as well\n * as the `is2D` & `isIdentity` properties.\n *\n * The result can also be used as a second parameter for the `fromMatrix` static method\n * to load values into another matrix instance.\n *\n * @return an *Object* with all matrix values.\n */\n toJSON() {\n const { is2D: t, isIdentity: e } = this;\n return { ...this, is2D: t, isIdentity: e };\n }\n /**\n * The Multiply method returns a new CSSMatrix which is the result of this\n * matrix multiplied by the passed matrix, with the passed matrix to the right.\n * This matrix is not modified.\n *\n * @param m2 CSSMatrix\n * @return The resulted matrix.\n */\n multiply(t) {\n return N(this, t);\n }\n /**\n * The translate method returns a new matrix which is this matrix post\n * multiplied by a translation matrix containing the passed values. If the z\n * component is undefined, a 0 value is used in its place. This matrix is not\n * modified.\n *\n * @param x X component of the translation value.\n * @param y Y component of the translation value.\n * @param z Z component of the translation value.\n * @return The resulted matrix\n */\n translate(t, e, n) {\n const i = t;\n let r = e, a = n;\n return typeof r > \"u\" && (r = 0), typeof a > \"u\" && (a = 0), N(this, Y(i, r, a));\n }\n /**\n * The scale method returns a new matrix which is this matrix post multiplied by\n * a scale matrix containing the passed values. If the z component is undefined,\n * a 1 value is used in its place. If the y component is undefined, the x\n * component value is used in its place. This matrix is not modified.\n *\n * @param x The X component of the scale value.\n * @param y The Y component of the scale value.\n * @param z The Z component of the scale value.\n * @return The resulted matrix\n */\n scale(t, e, n) {\n const i = t;\n let r = e, a = n;\n return typeof r > \"u\" && (r = t), typeof a > \"u\" && (a = 1), N(this, I(i, r, a));\n }\n /**\n * The rotate method returns a new matrix which is this matrix post multiplied\n * by each of 3 rotation matrices about the major axes, first X, then Y, then Z.\n * If the y and z components are undefined, the x value is used to rotate the\n * object about the z axis, as though the vector (0,0,x) were passed. All\n * rotation values are in degrees. This matrix is not modified.\n *\n * @param rx The X component of the rotation, or Z if Y and Z are null.\n * @param ry The (optional) Y component of the rotation value.\n * @param rz The (optional) Z component of the rotation value.\n * @return The resulted matrix\n */\n rotate(t, e, n) {\n let i = t, r = e || 0, a = n || 0;\n return typeof t == \"number\" && typeof e > \"u\" && typeof n > \"u\" && (a = i, i = 0, r = 0), N(this, F(i, r, a));\n }\n /**\n * The rotateAxisAngle method returns a new matrix which is this matrix post\n * multiplied by a rotation matrix with the given axis and `angle`. The right-hand\n * rule is used to determine the direction of rotation. All rotation values are\n * in degrees. This matrix is not modified.\n *\n * @param x The X component of the axis vector.\n * @param y The Y component of the axis vector.\n * @param z The Z component of the axis vector.\n * @param angle The angle of rotation about the axis vector, in degrees.\n * @return The resulted matrix\n */\n rotateAxisAngle(t, e, n, i) {\n if ([t, e, n, i].some((r) => Number.isNaN(+r)))\n throw new TypeError(\"CSSMatrix: expecting 4 values\");\n return N(this, T(t, e, n, i));\n }\n /**\n * Specifies a skew transformation along the `x-axis` by the given angle.\n * This matrix is not modified.\n *\n * @param angle The angle amount in degrees to skew.\n * @return The resulted matrix\n */\n skewX(t) {\n return N(this, R(t));\n }\n /**\n * Specifies a skew transformation along the `y-axis` by the given angle.\n * This matrix is not modified.\n *\n * @param angle The angle amount in degrees to skew.\n * @return The resulted matrix\n */\n skewY(t) {\n return N(this, D(t));\n }\n /**\n * Specifies a skew transformation along both the `x-axis` and `y-axis`.\n * This matrix is not modified.\n *\n * @param angleX The X-angle amount in degrees to skew.\n * @param angleY The angle amount in degrees to skew.\n * @return The resulted matrix\n */\n skew(t, e) {\n return N(this, v(t, e));\n }\n /**\n * Transforms a specified vector using the matrix, returning a new\n * {x,y,z,w} Tuple *Object* comprising the transformed vector.\n * Neither the matrix nor the original vector are altered.\n *\n * The method is equivalent with `transformPoint()` method\n * of the `DOMMatrix` constructor.\n *\n * @param t Tuple with `{x,y,z,w}` components\n * @return the resulting Tuple\n */\n transformPoint(t) {\n const e = this.m11 * t.x + this.m21 * t.y + this.m31 * t.z + this.m41 * t.w, n = this.m12 * t.x + this.m22 * t.y + this.m32 * t.z + this.m42 * t.w, i = this.m13 * t.x + this.m23 * t.y + this.m33 * t.z + this.m43 * t.w, r = this.m14 * t.x + this.m24 * t.y + this.m34 * t.z + this.m44 * t.w;\n return t instanceof DOMPoint ? new DOMPoint(e, n, i, r) : {\n x: e,\n y: n,\n z: i,\n w: r\n };\n }\n}\np(y, \"Translate\", Y), p(y, \"Rotate\", F), p(y, \"RotateAxisAngle\", T), p(y, \"Scale\", I), p(y, \"SkewX\", R), p(y, \"SkewY\", D), p(y, \"Skew\", v), p(y, \"Multiply\", N), p(y, \"fromArray\", g), p(y, \"fromMatrix\", X), p(y, \"fromString\", O), p(y, \"toArray\", x), p(y, \"isCompatibleArray\", E), p(y, \"isCompatibleObject\", P);\nexport {\n y as default\n};\n//# sourceMappingURL=dommatrix.mjs.map\n","import { PointTuple } from \"../types\";\n\n/**\n * Returns the coordinates of a specified distance\n * ratio between two points.\n *\n * @param a the first point coordinates\n * @param b the second point coordinates\n * @param t the ratio\n * @returns the midpoint coordinates\n */\nconst midPoint = (a: PointTuple, b: PointTuple, t: number): PointTuple => {\n const [ax, ay] = a;\n const [bx, by] = b;\n return [ax + (bx - ax) * t, ay + (by - ay) * t];\n};\n\nexport default midPoint;\n","import { type PointTuple } from \"../types\";\n\n/**\n * Returns the square root of the distance\n * between two given points.\n *\n * @param a the first point coordinates\n * @param b the second point coordinates\n * @returns the distance value\n */\nconst distanceSquareRoot = (a: PointTuple, b: PointTuple) => {\n return Math.sqrt(\n (a[0] - b[0]) * (a[0] - b[0]) + (a[1] - b[1]) * (a[1] - b[1]),\n );\n};\n\nexport default distanceSquareRoot;\n","import midPoint from \"./midPoint\";\nimport distanceSquareRoot from \"./distanceSquareRoot\";\n\n/**\n * Returns length for line segments (MoveTo, LineTo).\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the line segment length\n */\nconst getLineLength = (x1: number, y1: number, x2: number, y2: number) => {\n return distanceSquareRoot([x1, y1], [x2, y2]);\n};\n\n/**\n * Returns a point along the line segments (MoveTo, LineTo).\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance the distance to point in [0-1] range\n * @returns the point at length\n */\nconst getPointAtLineLength = (\n x1: number,\n y1: number,\n x2: number,\n y2: number,\n distance?: number,\n) => {\n let point = { x: x1, y: y1 };\n\n /* istanbul ignore else @preserve */\n if (typeof distance === \"number\") {\n const length = distanceSquareRoot([x1, y1], [x2, y2]);\n if (distance <= 0) {\n point = { x: x1, y: y1 };\n } else if (distance >= length) {\n point = { x: x2, y: y2 };\n } else {\n const [x, y] = midPoint([x1, y1], [x2, y2], distance / length);\n point = { x, y };\n }\n }\n return point;\n};\n\n/**\n * Returns bounding box for line segments (MoveTo, LineTo).\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance the distance to point in [0-1] range\n * @returns the extrema for line segments\n */\nconst getLineBBox = (x1: number, y1: number, x2: number, y2: number) => {\n const { min, max } = Math;\n\n return [min(x1, x2), min(y1, y2), max(x1, x2), max(y1, y2)] as [\n number,\n number,\n number,\n number,\n ];\n};\n\nexport { getLineBBox, getLineLength, getPointAtLineLength };\n","import { getPointAtLineLength } from \"./lineTools\";\nimport type { Point, PointTuple } from \"../types\";\n\n/**\n * Returns the Arc segment length.\n * @param rx radius along X axis\n * @param ry radius along Y axis\n * @param theta the angle in radians\n * @returns the arc length\n */\nconst arcLength = (rx: number, ry: number, theta: number) => {\n const halfTheta = theta / 2;\n const sinHalfTheta = Math.sin(halfTheta);\n const cosHalfTheta = Math.cos(halfTheta);\n const term1 = rx ** 2 * sinHalfTheta ** 2;\n const term2 = ry ** 2 * cosHalfTheta ** 2;\n const length = Math.sqrt(term1 + term2) * theta;\n return Math.abs(length);\n};\n\n/**\n * Find point on ellipse at given angle around ellipse (theta);\n * @param cx the center X\n * @param cy the center Y\n * @param rx the radius X\n * @param ry the radius Y\n * @param alpha the arc rotation angle in radians\n * @param theta the arc sweep angle in radians\n * @returns a point around ellipse at given angle\n */\nconst arcPoint = (\n cx: number,\n cy: number,\n rx: number,\n ry: number,\n alpha: number,\n theta: number,\n) => {\n const { sin, cos } = Math;\n // theta is angle in radians around arc\n // alpha is angle of rotation of ellipse in radians\n const cosA = cos(alpha);\n const sinA = sin(alpha);\n const x = rx * cos(theta);\n const y = ry * sin(theta);\n\n return [cx + cosA * x - sinA * y, cy + sinA * x + cosA * y] as PointTuple;\n};\n\n/**\n * Returns the angle between two points.\n * @param v0 starting point\n * @param v1 ending point\n * @returns the angle in radian\n */\nconst angleBetween = (v0: Point, v1: Point) => {\n const { x: v0x, y: v0y } = v0;\n const { x: v1x, y: v1y } = v1;\n const p = v0x * v1x + v0y * v1y;\n const n = Math.sqrt((v0x ** 2 + v0y ** 2) * (v1x ** 2 + v1y ** 2));\n const sign = v0x * v1y - v0y * v1x < 0 ? -1 : 1;\n return sign * Math.acos(p / n);\n};\n\n/**\n * Returns the following properties for an Arc segment: center, start angle,\n * end angle, and radiuses on X and Y axis.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param RX the radius on X axis\n * @param RY the radius on Y axis\n * @param angle the ellipse rotation in degrees\n * @param LAF the large arc flag\n * @param SF the sweep flag\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns properties specific to Arc segments\n */\nconst getArcProps = (\n x1: number,\n y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n x: number,\n y: number,\n) => {\n const { abs, sin, cos, sqrt, PI } = Math;\n let rx = abs(RX);\n let ry = abs(RY);\n const xRot = ((angle % 360) + 360) % 360;\n const xRotRad = xRot * (PI / 180);\n\n // istanbul ignore next @preserve\n if (x1 === x && y1 === y) {\n return {\n rx,\n ry,\n startAngle: 0,\n endAngle: 0,\n center: { x, y },\n };\n }\n\n if (rx === 0 || ry === 0) {\n return {\n rx,\n ry,\n startAngle: 0,\n endAngle: 0,\n center: { x: (x + x1) / 2, y: (y + y1) / 2 },\n };\n }\n\n const dx = (x1 - x) / 2;\n const dy = (y1 - y) / 2;\n\n const transformedPoint = {\n x: cos(xRotRad) * dx + sin(xRotRad) * dy,\n y: -sin(xRotRad) * dx + cos(xRotRad) * dy,\n };\n\n const radiiCheck = transformedPoint.x ** 2 / rx ** 2 +\n transformedPoint.y ** 2 / ry ** 2;\n\n if (radiiCheck > 1) {\n rx *= sqrt(radiiCheck);\n ry *= sqrt(radiiCheck);\n }\n\n const cSquareNumerator = rx ** 2 * ry ** 2 -\n rx ** 2 * transformedPoint.y ** 2 - ry ** 2 * transformedPoint.x ** 2;\n const cSquareRootDenom = rx ** 2 * transformedPoint.y ** 2 +\n ry ** 2 * transformedPoint.x ** 2;\n\n let cRadicand = cSquareNumerator / cSquareRootDenom;\n /* istanbul ignore next @preserve */\n cRadicand = cRadicand < 0 ? 0 : cRadicand;\n const cCoef = (LAF !== SF ? 1 : -1) * sqrt(cRadicand);\n const transformedCenter = {\n x: cCoef * ((rx * transformedPoint.y) / ry),\n y: cCoef * (-(ry * transformedPoint.x) / rx),\n };\n\n const center = {\n x: cos(xRotRad) * transformedCenter.x - sin(xRotRad) * transformedCenter.y +\n (x1 + x) / 2,\n y: sin(xRotRad) * transformedCenter.x + cos(xRotRad) * transformedCenter.y +\n (y1 + y) / 2,\n };\n\n const startVector = {\n x: (transformedPoint.x - transformedCenter.x) / rx,\n y: (transformedPoint.y - transformedCenter.y) / ry,\n };\n\n const startAngle = angleBetween({ x: 1, y: 0 }, startVector);\n\n const endVector = {\n x: (-transformedPoint.x - transformedCenter.x) / rx,\n y: (-transformedPoint.y - transformedCenter.y) / ry,\n };\n\n let sweepAngle = angleBetween(startVector, endVector);\n if (!SF && sweepAngle > 0) {\n sweepAngle -= 2 * PI;\n } else if (SF && sweepAngle < 0) {\n sweepAngle += 2 * PI;\n }\n sweepAngle %= 2 * PI;\n\n const endAngle = startAngle + sweepAngle;\n\n // point.ellipticalArcStartAngle = startAngle;\n // point.ellipticalArcEndAngle = startAngle + sweepAngle;\n // point.ellipticalArcAngle = alpha;\n\n // point.ellipticalArcCenter = center;\n // point.resultantRx = rx;\n // point.resultantRy = ry;\n\n return {\n center,\n startAngle,\n endAngle,\n rx,\n ry,\n };\n};\n\n/**\n * Returns the length of an Arc segment.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the length of the Arc segment\n */\nconst getArcLength = (\n x1: number,\n y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n x: number,\n y: number,\n) => {\n const { rx, ry, startAngle, endAngle } = getArcProps(\n x1,\n y1,\n RX,\n RY,\n angle,\n LAF,\n SF,\n x,\n y,\n );\n return arcLength(rx, ry, endAngle - startAngle);\n};\n\n/**\n * Returns a point along an Arc segment at a given distance.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param RX the radius on X axis\n * @param RY the radius on Y axis\n * @param angle the ellipse rotation in degrees\n * @param LAF the large arc flag\n * @param SF the sweep flag\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance a [0-1] ratio\n * @returns a point along the Arc segment\n */\nconst getPointAtArcLength = (\n x1: number,\n y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n x: number,\n y: number,\n distance?: number,\n) => {\n let point = { x: x1, y: y1 };\n const { center, rx, ry, startAngle, endAngle } = getArcProps(\n x1,\n y1,\n RX,\n RY,\n angle,\n LAF,\n SF,\n x,\n y,\n );\n\n /* istanbul ignore else @preserve */\n if (typeof distance === \"number\") {\n const length = arcLength(rx, ry, endAngle - startAngle);\n if (distance <= 0) {\n point = { x: x1, y: y1 };\n } else if (distance >= length) {\n point = { x, y };\n } else {\n /* istanbul ignore next @preserve */\n if (x1 === x && y1 === y) {\n return { x, y };\n }\n /* istanbul ignore next @preserve */\n if (rx === 0 || ry === 0) {\n return getPointAtLineLength(x1, y1, x, y, distance);\n }\n const { PI, cos, sin } = Math;\n const sweepAngle = endAngle - startAngle;\n const xRot = ((angle % 360) + 360) % 360;\n const xRotRad = xRot * (PI / 180);\n const alpha = startAngle + sweepAngle * (distance / length);\n const ellipseComponentX = rx * cos(alpha);\n const ellipseComponentY = ry * sin(alpha);\n\n point = {\n x: cos(xRotRad) * ellipseComponentX - sin(xRotRad) * ellipseComponentY +\n center.x,\n y: sin(xRotRad) * ellipseComponentX + cos(xRotRad) * ellipseComponentY +\n center.y,\n };\n }\n }\n\n return point;\n};\n\n/**\n * Returns the extrema for an Arc segment in the following format:\n * [MIN_X, MIN_Y, MAX_X, MAX_Y]\n *\n * @see https://github.com/herrstrietzel/svg-pathdata-getbbox\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param RX the radius on X axis\n * @param RY the radius on Y axis\n * @param angle the ellipse rotation in degrees\n * @param LAF the large arc flag\n * @param SF the sweep flag\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the extrema of the Arc segment\n */\nconst getArcBBox = (\n x1: number,\n y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n x: number,\n y: number,\n) => {\n const { center, rx, ry, startAngle, endAngle } = getArcProps(\n x1,\n y1,\n RX,\n RY,\n angle,\n LAF,\n SF,\n x,\n y,\n );\n const deltaAngle = endAngle - startAngle;\n const { min, max, tan, atan2, PI } = Math;\n\n // circle/elipse center coordinates\n const { x: cx, y: cy } = center;\n\n // rotation to radians\n const alpha = (angle * PI) / 180;\n const tangent = tan(alpha);\n\n /**\n * find min/max from zeroes of directional derivative along x and y\n * along x axis\n */\n const theta = atan2(-ry * tangent, rx);\n const angle1 = theta;\n const angle2 = theta + PI;\n const angle3 = atan2(ry, rx * tangent);\n const angle4 = angle3 + PI;\n const xArray = [x];\n const yArray = [y];\n\n // inner bounding box\n let xMin = min(x1, x);\n let xMax = max(x1, x);\n let yMin = min(y1, y);\n let yMax = max(y1, y);\n\n // on path point close after start\n const angleAfterStart = endAngle - deltaAngle * 0.00001;\n const pP2 = arcPoint(cx, cy, rx, ry, alpha, angleAfterStart);\n\n // on path point close before end\n const angleBeforeEnd = endAngle - deltaAngle * 0.99999;\n const pP3 = arcPoint(cx, cy, rx, ry, alpha, angleBeforeEnd);\n\n /**\n * expected extremes\n * if leaving inner bounding box\n * (between segment start and end point)\n * otherwise exclude elliptic extreme points\n */\n\n // right\n if (pP2[0] > xMax || pP3[0] > xMax) {\n // get point for this theta\n const p1 = arcPoint(cx, cy, rx, ry, alpha, angle1);\n xArray.push(p1[0]);\n yArray.push(p1[1]);\n }\n\n // left\n if (pP2[0] < xMin || pP3[0] < xMin) {\n // get anti-symmetric point\n const p2 = arcPoint(cx, cy, rx, ry, alpha, angle2);\n xArray.push(p2[0]);\n yArray.push(p2[1]);\n }\n\n // top\n if (pP2[1] < yMin || pP3[1] < yMin) {\n // get anti-symmetric point\n const p4 = arcPoint(cx, cy, rx, ry, alpha, angle4);\n xArray.push(p4[0]);\n yArray.push(p4[1]);\n }\n\n // bottom\n if (pP2[1] > yMax || pP3[1] > yMax) {\n // get point for this theta\n const p3 = arcPoint(cx, cy, rx, ry, alpha, angle3);\n xArray.push(p3[0]);\n yArray.push(p3[1]);\n }\n\n xMin = min.apply([], xArray);\n yMin = min.apply([], yArray);\n xMax = max.apply([], xArray);\n yMax = max.apply([], yArray);\n\n return [xMin, yMin, xMax, yMax] as [number, number, number, number];\n};\n\nexport {\n angleBetween,\n arcLength,\n arcPoint,\n getArcBBox,\n getArcLength,\n getArcProps,\n getPointAtArcLength,\n};\n","import type {\n CubicCoordinates,\n CubicPoints,\n DeriveCallback,\n DerivedCubicPoints,\n DerivedPoint,\n DerivedQuadPoints,\n PointTuple,\n QuadCoordinates,\n QuadPoints,\n} from \"../types\";\n\n/**\n * Tools from bezier.js by Mike 'Pomax' Kamermans\n * @see https://github.com/Pomax/bezierjs\n */\n\nconst Tvalues = [\n -0.0640568928626056260850430826247450385909,\n 0.0640568928626056260850430826247450385909,\n -0.1911188674736163091586398207570696318404,\n 0.1911188674736163091586398207570696318404,\n -0.3150426796961633743867932913198102407864,\n 0.3150426796961633743867932913198102407864,\n -0.4337935076260451384870842319133497124524,\n 0.4337935076260451384870842319133497124524,\n -0.5454214713888395356583756172183723700107,\n 0.5454214713888395356583756172183723700107,\n -0.6480936519369755692524957869107476266696,\n 0.6480936519369755692524957869107476266696,\n -0.7401241915785543642438281030999784255232,\n 0.7401241915785543642438281030999784255232,\n -0.8200019859739029219539498726697452080761,\n 0.8200019859739029219539498726697452080761,\n -0.8864155270044010342131543419821967550873,\n 0.8864155270044010342131543419821967550873,\n -0.9382745520027327585236490017087214496548,\n 0.9382745520027327585236490017087214496548,\n -0.9747285559713094981983919930081690617411,\n 0.9747285559713094981983919930081690617411,\n -0.9951872199970213601799974097007368118745,\n 0.9951872199970213601799974097007368118745,\n];\n\nconst Cvalues = [\n 0.1279381953467521569740561652246953718517,\n 0.1279381953467521569740561652246953718517,\n 0.1258374563468282961213753825111836887264,\n 0.1258374563468282961213753825111836887264,\n 0.121670472927803391204463153476262425607,\n 0.121670472927803391204463153476262425607,\n 0.1155056680537256013533444839067835598622,\n 0.1155056680537256013533444839067835598622,\n 0.1074442701159656347825773424466062227946,\n 0.1074442701159656347825773424466062227946,\n 0.0976186521041138882698806644642471544279,\n 0.0976186521041138882698806644642471544279,\n 0.086190161531953275917185202983742667185,\n 0.086190161531953275917185202983742667185,\n 0.0733464814110803057340336152531165181193,\n 0.0733464814110803057340336152531165181193,\n 0.0592985849154367807463677585001085845412,\n 0.0592985849154367807463677585001085845412,\n 0.0442774388174198061686027482113382288593,\n 0.0442774388174198061686027482113382288593,\n 0.0285313886289336631813078159518782864491,\n 0.0285313886289336631813078159518782864491,\n 0.0123412297999871995468056670700372915759,\n 0.0123412297999871995468056670700372915759,\n];\n\n/**\n * @param points\n * @returns\n */\nconst deriveBezier = (points: QuadPoints | CubicPoints) => {\n const dpoints = [] as (DerivedCubicPoints | DerivedQuadPoints)[];\n for (let p = points, d = p.length, c = d - 1; d > 1; d -= 1, c -= 1) {\n const list = [] as unknown as DerivedCubicPoints | DerivedQuadPoints;\n for (let j = 0; j < c; j += 1) {\n list.push({\n x: c * (p[j + 1].x - p[j].x),\n y: c * (p[j + 1].y - p[j].y),\n t: 0,\n });\n }\n dpoints.push(list);\n p = list;\n }\n return dpoints;\n};\n\n/**\n * @param points\n * @param t\n */\nconst computeBezier = (\n points: DerivedQuadPoints | DerivedCubicPoints,\n t: number,\n) => {\n // shortcuts\n /* istanbul ignore next @preserve */\n if (t === 0) {\n points[0].t = 0;\n return points[0];\n }\n\n const order = points.length - 1;\n\n /* istanbul ignore next @preserve */\n if (t === 1) {\n points[order].t = 1;\n return points[order];\n }\n\n const mt = 1 - t;\n let p = points as typeof points | [\n DerivedPoint,\n DerivedPoint,\n DerivedPoint,\n DerivedPoint,\n ];\n\n // constant?\n /* istanbul ignore next @preserve */\n if (order === 0) {\n points[0].t = t;\n return points[0];\n }\n\n // linear?\n /* istanbul ignore else @preserve */\n if (order === 1) {\n return {\n x: mt * p[0].x + t * p[1].x,\n y: mt * p[0].y + t * p[1].y,\n t,\n };\n }\n\n // quadratic/cubic curve?\n const mt2 = mt * mt;\n const t2 = t * t;\n let a = 0;\n let b = 0;\n let c = 0;\n let d = 0;\n /* istanbul ignore else @preserve */\n if (order === 2) {\n p = [p[0], p[1], p[2], { x: 0, y: 0 } as DerivedPoint];\n a = mt2;\n b = mt * t * 2;\n c = t2;\n } else if (order === 3) {\n a = mt2 * mt;\n b = mt2 * t * 3;\n c = mt * t2 * 3;\n d = t * t2;\n }\n return {\n x: a * p[0].x + b * p[1].x + c * p[2].x + d * p[3].x,\n y: a * p[0].y + b * p[1].y + c * p[2].y + d * p[3].y,\n t,\n };\n};\n\nconst calculateBezier = (derivativeFn: DeriveCallback, t: number) => {\n const d = derivativeFn(t);\n const l = d.x * d.x + d.y * d.y;\n\n return Math.sqrt(l);\n};\n\nconst bezierLength = (derivativeFn: DeriveCallback) => {\n const z = 0.5;\n const len = Tvalues.length;\n\n let sum = 0;\n\n for (let i = 0, t; i < len; i++) {\n t = z * Tvalues[i] + z;\n sum += Cvalues[i] * calculateBezier(derivativeFn, t);\n }\n return z * sum;\n};\n\n/**\n * Returns the length of CubicBezier / Quad segment.\n * @param curve cubic / quad bezier segment\n */\nconst getBezierLength = (curve: CubicCoordinates | QuadCoordinates) => {\n const points = [] as unknown as CubicPoints | QuadPoints;\n for (let idx = 0, len = curve.length, step = 2; idx < len; idx += step) {\n points.push({\n x: curve[idx],\n y: curve[idx + 1],\n });\n }\n const dpoints = deriveBezier(points);\n return bezierLength((t: number) => {\n return computeBezier(dpoints[0], t);\n });\n};\n\n// Precision for consider cubic polynom as quadratic one\nconst CBEZIER_MINMAX_EPSILON = 0.00000001;\n\n/**\n * Returns the most extreme points in a Quad Bezier segment.\n * @param A an array which consist of X/Y values\n */\n// https://github.com/kpym/SVGPathy/blob/acd1a50c626b36d81969f6e98e8602e128ba4302/lib/box.js#L89\nconst minmaxQ = ([v1, cp, v2]: [number, number, number]) => {\n const min = Math.min(v1, v2);\n const max = Math.max(v1, v2);\n\n /* istanbul ignore next @preserve */\n if (cp >= v1 ? v2 >= cp : v2 <= cp) {\n // if no extremum in ]0,1[\n return [min, max] as PointTuple;\n }\n\n // check if the extremum E is min or max\n const E = (v1 * v2 - cp * cp) / (v1 - 2 * cp + v2);\n return (E < min ? [E, max] : [min, E]) as PointTuple;\n};\n\n/**\n * Returns the most extreme points in a Cubic Bezier segment.\n * @param A an array which consist of X/Y values\n * @see https://github.com/kpym/SVGPathy/blob/acd1a50c626b36d81969f6e98e8602e128ba4302/lib/box.js#L127\n */\nconst minmaxC = ([v1, cp1, cp2, v2]: [number, number, number, number]) => {\n const K = v1 - 3 * cp1 + 3 * cp2 - v2;\n\n // if the polynomial is (almost) quadratic and not cubic\n /* istanbul ignore next @preserve */\n if (Math.abs(K) < CBEZIER_MINMAX_EPSILON) {\n if (v1 === v2 && v1 === cp1) {\n // no curve, point targeting same location\n return [v1, v2] as PointTuple;\n }\n\n return minmaxQ([v1, -0.5 * v1 + 1.5 * cp1, v1 - 3 * cp1 + 3 * cp2]);\n }\n\n // the reduced discriminant of the derivative\n const T = -v1 * cp2 + v1 * v2 - cp1 * cp2 - cp1 * v2 + cp1 * cp1 + cp2 * cp2;\n\n // if the polynomial is monotone in [0,1]\n if (T <= 0) {\n return [Math.min(v1, v2), Math.max(v1, v2)] as PointTuple;\n }\n const S = Math.sqrt(T);\n\n // potential extrema\n let min = Math.min(v1, v2);\n let max = Math.max(v1, v2);\n\n const L = v1 - 2 * cp1 + cp2;\n // check local extrema\n for (let R = (L + S) / K, i = 1; i <= 2; R = (L - S) / K, i++) {\n // istanbul ignore next @preserve\n if (R > 0 && R < 1) {\n // if the extrema is for R in [0,1]\n const Q = v1 * (1 - R) * (1 - R) * (1 - R) +\n cp1 * 3 * (1 - R) * (1 - R) * R + cp2 * 3 * (1 - R) * R * R +\n v2 * R * R * R;\n if (Q < min) {\n min = Q;\n }\n if (Q > max) {\n max = Q;\n }\n }\n }\n\n return [min, max] as PointTuple;\n};\n\nexport {\n bezierLength,\n calculateBezier,\n CBEZIER_MINMAX_EPSILON,\n computeBezier,\n Cvalues,\n deriveBezier,\n getBezierLength,\n minmaxC,\n minmaxQ,\n Tvalues,\n};\n","import { getBezierLength, minmaxC } from \"./bezier\";\nimport { type CubicCoordinates } from \"../types\";\n\n/**\n * Returns a point at a given length of a CubicBezier segment.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param t a [0-1] ratio\n * @returns the point at cubic-bezier segment length\n */\nconst getPointAtCubicSegmentLength = (\n [x1, y1, c1x, c1y, c2x, c2y, x2, y2]: CubicCoordinates,\n t: number,\n) => {\n const t1 = 1 - t;\n return {\n x: t1 ** 3 * x1 + 3 * t1 ** 2 * t * c1x + 3 * t1 * t ** 2 * c2x +\n t ** 3 * x2,\n y: t1 ** 3 * y1 + 3 * t1 ** 2 * t * c1y + 3 * t1 * t ** 2 * c2y +\n t ** 3 * y2,\n };\n};\n\n/**\n * Returns the length of a CubicBezier segment.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the CubicBezier segment length\n */\nconst getCubicLength = (\n x1: number,\n y1: number,\n c1x: number,\n c1y: number,\n c2x: number,\n c2y: number,\n x2: number,\n y2: number,\n) => {\n return getBezierLength([x1, y1, c1x, c1y, c2x, c2y, x2, y2]);\n};\n\n/**\n * Returns the point along a CubicBezier segment at a given distance.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance the distance to look at\n * @returns the point at CubicBezier length\n */\nconst getPointAtCubicLength = (\n x1: number,\n y1: number,\n c1x: number,\n c1y: number,\n c2x: number,\n c2y: number,\n x2: number,\n y2: number,\n distance?: number,\n) => {\n const distanceIsNumber = typeof distance === \"number\";\n let point = { x: x1, y: y1 };\n /* istanbul ignore else @preserve */\n if (distanceIsNumber) {\n const currentLength = getBezierLength([x1, y1, c1x, c1y, c2x, c2y, x2, y2]);\n if (distance <= 0) {\n // first point already defined\n } else if (distance >= currentLength) {\n point = { x: x2, y: y2 };\n } else {\n point = getPointAtCubicSegmentLength(\n [x1, y1, c1x, c1y, c2x, c2y, x2, y2],\n distance / currentLength,\n );\n }\n }\n return point;\n};\n\n/**\n * Returns the boundig box of a CubicBezier segment in the following format:\n * [MIN_X, MIN_Y, MAX_X, MAX_Y]\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the extrema of the CubicBezier segment\n */\nconst getCubicBBox = (\n x1: number,\n y1: number,\n c1x: number,\n c1y: number,\n c2x: number,\n c2y: number,\n x2: number,\n y2: number,\n) => {\n const cxMinMax = minmaxC([x1, c1x, c2x, x2]);\n const cyMinMax = minmaxC([y1, c1y, c2y, y2]);\n\n return [cxMinMax[0], cyMinMax[0], cxMinMax[1], cyMinMax[1]] as [\n number,\n number,\n number,\n number,\n ];\n};\n\nexport {\n getCubicBBox,\n getCubicLength,\n getPointAtCubicLength,\n getPointAtCubicSegmentLength,\n};\n","import { getBezierLength, minmaxQ } from \"./bezier\";\nimport { type QuadCoordinates } from \"../types\";\n\n/**\n * Returns the {x,y} coordinates of a point at a\n * given length of a quadratic-bezier segment.\n *\n * @see https://github.com/substack/point-at-length\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param cx the control point X\n * @param cy the control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param t a [0-1] ratio\n * @returns the requested {x,y} coordinates\n */\nconst getPointAtQuadSegmentLength = (\n [x1, y1, cx, cy, x2, y2]: QuadCoordinates,\n t: number,\n) => {\n const t1 = 1 - t;\n return {\n x: t1 ** 2 * x1 + 2 * t1 * t * cx + t ** 2 * x2,\n y: t1 ** 2 * y1 + 2 * t1 * t * cy + t ** 2 * y2,\n };\n};\n\n/**\n * Returns the length of a QuadraticBezier segment.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param cx the control point X\n * @param cy the control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the QuadraticBezier segment length\n */\nconst getQuadLength = (\n x1: number,\n y1: number,\n cx: number,\n cy: number,\n x2: number,\n y2: number,\n) => {\n return getBezierLength([x1, y1, cx, cy, x2, y2]);\n};\n\n/**\n * Returns the point along a QuadraticBezier segment at a given distance.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param cx the control point X\n * @param cy the control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance the distance to look at\n * @returns the point at QuadraticBezier length\n */\nconst getPointAtQuadLength = (\n x1: number,\n y1: number,\n cx: number,\n cy: number,\n x2: number,\n y2: number,\n distance?: number,\n) => {\n const distanceIsNumber = typeof distance === \"number\";\n let point = { x: x1, y: y1 };\n\n /* istanbul ignore else @preserve */\n if (distanceIsNumber) {\n const currentLength = getBezierLength([x1, y1, cx, cy, x2, y2]);\n if (distance <= 0) {\n // first point already defined\n } else if (distance >= currentLength) {\n point = { x: x2, y: y2 };\n } else {\n point = getPointAtQuadSegmentLength(\n [x1, y1, cx, cy, x2, y2],\n distance / currentLength,\n );\n }\n }\n return point;\n};\n\n/**\n * Returns the boundig box of a QuadraticBezier segment in the following format:\n * [MIN_X, MIN_Y, MAX_X, MAX_Y]\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param cx the control point X\n * @param cy the control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the extrema of the QuadraticBezier segment\n */\nconst getQuadBBox = (\n x1: number,\n y1: number,\n cx: number,\n cy: number,\n x2: number,\n y2: number,\n) => {\n const cxMinMax = minmaxQ([x1, cx, x2]);\n const cyMinMax = minmaxQ([y1, cy, y2]);\n return [cxMinMax[0], cyMinMax[0], cxMinMax[1], cyMinMax[1]] as [\n number,\n number,\n number,\n number,\n ];\n};\n\nexport {\n getPointAtQuadLength,\n getPointAtQuadSegmentLength,\n getQuadBBox,\n getQuadLength,\n};\n","import distanceSquareRoot from \"./distanceSquareRoot\";\nimport { type PointTuple } from \"../types\";\n\n/**\n * d3-polygon-area\n * https://github.com/d3/d3-polygon\n *\n * Returns the area of a polygon.\n *\n * @param polygon an array of coordinates\n * @returns the polygon area\n */\nconst polygonArea = (polygon: PointTuple[]) => {\n const n = polygon.length;\n let i = -1;\n let a: PointTuple;\n let b = polygon[n - 1];\n let area = 0;\n\n /* eslint-disable-next-line */\n while (++i < n) {\n a = b;\n b = polygon[i];\n area += a[1] * b[0] - a[0] * b[1];\n }\n\n return area / 2;\n};\n\n/**\n * d3-polygon-length\n * https://github.com/d3/d3-polygon\n *\n * Returns the perimeter of a polygon.\n *\n * @param polygon an array of coordinates\n * @returns the polygon length\n */\nconst polygonLength = (polygon: PointTuple[]) => {\n return polygon.reduce((length, point, i) => {\n if (i) {\n return length + distanceSquareRoot(polygon[i - 1], point);\n }\n return 0;\n }, 0);\n};\n\nexport { polygonArea, polygonLength };\n","/** Segment params length */\nconst paramsCount = {\n a: 7,\n c: 6,\n h: 1,\n l: 2,\n m: 2,\n r: 4,\n q: 4,\n s: 4,\n t: 2,\n v: 1,\n z: 0,\n};\n\nexport default paramsCount;\n","import paramsCount from \"./paramsCount\";\nimport PathParser from \"./pathParser\";\nimport type { PathCommand, PathSegment, RelativeCommand } from \"../types\";\n\n/**\n * Breaks the parsing of a pathString once a segment is finalized.\n *\n * @param path the `PathParser` instance\n */\nconst finalizeSegment = (path: PathParser) => {\n let pathCommand = path.pathValue[path.segmentStart] as PathCommand;\n let relativeCommand = pathCommand.toLowerCase() as RelativeCommand;\n const { data } = path;\n\n while (data.length >= paramsCount[relativeCommand]) {\n // overloaded `moveTo`\n // https://github.com/rveciana/svg-path-properties/blob/master/src/parse.ts\n if (relativeCommand === \"m\" && data.length > 2) {\n path.segments.push(\n [pathCommand as PathCommand | number].concat(\n data.splice(0, 2) as number[],\n ) as PathSegment,\n );\n relativeCommand = \"l\";\n pathCommand = pathCommand === \"m\" ? \"l\" : \"L\";\n } else {\n path.segments.push(\n [pathCommand as PathCommand | number].concat(\n data.splice(0, paramsCount[relativeCommand]) as number[],\n ) as PathSegment,\n );\n }\n\n if (!paramsCount[relativeCommand]) {\n break;\n }\n }\n};\nexport default finalizeSegment;\n","const error = \"SVGPathCommander Error\";\nexport default error;\n","import error from \"./error\";\nimport type PathParser from \"./pathParser\";\n\n/**\n * Validates an A (arc-to) specific path command value.\n * Usually a `large-arc-flag` or `sweep-flag`.\n *\n * @param path the `PathParser` instance\n */\nconst scanFlag = (path: PathParser) => {\n const { index, pathValue } = path;\n const code = pathValue.charCodeAt(index);\n\n if (code === 0x30 /* 0 */) {\n path.param = 0;\n path.index += 1;\n return;\n }\n\n if (code === 0x31 /* 1 */) {\n path.param = 1;\n path.index += 1;\n return;\n }\n\n path.err = `${error}: invalid Arc flag \"${\n pathValue[index]\n }\", expecting 0 or 1 at index ${index}`;\n};\n\nexport default scanFlag;\n","import { DigitNumber } from \"../types\";\n\n/**\n * Checks if a character is a digit.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isDigit = (code: number): code is DigitNumber => {\n return code >= 48 && code <= 57; // 0..9\n};\nexport default isDigit;\n","const invalidPathValue = \"Invalid path value\";\nexport default invalidPathValue;\n","import isDigit from \"./isDigit\";\nimport invalidPathValue from \"./invalidPathValue\";\nimport error from \"./error\";\nimport type PathParser from \"./pathParser\";\n\n/**\n * Validates every character of the path string,\n * every path command, negative numbers or floating point numbers.\n *\n * @param path the `PathParser` instance\n */\nconst scanParam = (path: PathParser) => {\n const { max, pathValue, index: start } = path;\n let index = start;\n let zeroFirst = false;\n let hasCeiling = false;\n let hasDecimal = false;\n let hasDot = false;\n let ch;\n\n if (index >= max) {\n path.err =\n `${error}: ${invalidPathValue} at index ${index}, \"pathValue\" is missing param`;\n return;\n }\n ch = pathValue.charCodeAt(index);\n\n if (ch === 0x2b /* + */ || ch === 0x2d /* - */) {\n index += 1;\n // ch = (index < max) ? pathValue.charCodeAt(index) : 0;\n ch = pathValue.charCodeAt(index);\n }\n\n // This logic is shamelessly borrowed from Esprima\n // https://github.com/ariya/esprimas\n if (!isDigit(ch) && ch !== 0x2e /* . */) {\n // path.err = 'SvgPath: param should start with 0..9 or `.` (at pos ' + index + ')';\n path.err = `${error}: ${invalidPathValue} at index ${index}, \"${\n pathValue[index]\n }\" is not a number`;\n return;\n }\n\n if (ch !== 0x2e /* . */) {\n zeroFirst = ch === 0x30 /* 0 */;\n index += 1;\n\n ch = pathValue.charCodeAt(index);\n\n if (zeroFirst && index < max) {\n // decimal number starts with '0' such as '09' is illegal.\n if (ch && isDigit(ch)) {\n // path.err = 'SvgPath: numbers started with `0` such as `09`\n // are illegal (at pos ' + start + ')';\n path.err = `${error}: ${invalidPathValue} at index ${start}, \"${\n pathValue[start]\n }\" illegal number`;\n return;\n }\n }\n\n while (index < max && isDigit(pathValue.charCodeAt(index))) {\n index += 1;\n hasCeiling = true;\n }\n\n ch = pathValue.charCodeAt(index);\n }\n\n if (ch === 0x2e /* . */) {\n hasDot = true;\n index += 1;\n while (isDigit(pathValue.charCodeAt(index))) {\n index += 1;\n hasDecimal = true;\n }\n\n ch = pathValue.charCodeAt(index);\n }\n\n if (ch === 0x65 /* e */ || ch === 0x45 /* E */) {\n if (hasDot && !hasCeiling && !hasDecimal) {\n path.err = `${error}: ${invalidPathValue} at index ${index}, \"${\n pathValue[index]\n }\" invalid float exponent`;\n return;\n }\n\n index += 1;\n\n ch = pathValue.charCodeAt(index);\n\n if (ch === 0x2b /* + */ || ch === 0x2d /* - */) {\n index += 1;\n }\n if (index < max && isDigit(pathValue.charCodeAt(index))) {\n while (index < max && isDigit(pathValue.charCodeAt(index))) {\n index += 1;\n }\n } else {\n path.err = `${error}: ${invalidPathValue} at index ${index}, \"${\n pathValue[index]\n }\" invalid integer exponent`;\n return;\n }\n }\n\n path.index = index;\n path.param = +path.pathValue.slice(start, index);\n};\nexport default scanParam;\n","import type { SpaceNumber } from \"../types\";\n\n/**\n * Checks if the character is a space.\n *\n * @param ch the character to check\n * @returns check result\n */\n\nconst isSpace = (ch: number): ch is SpaceNumber => {\n const allSpaces = [\n // Special spaces\n 0x1680,\n 0x180e,\n 0x2000,\n 0x2001,\n 0x2002,\n 0x2003,\n 0x2004,\n 0x2005,\n 0x2006,\n 0x2007,\n 0x2008,\n 0x2009,\n 0x200a,\n 0x202f,\n 0x205f,\n 0x3000,\n 0xfeff,\n // Line terminators\n 0x0a,\n 0x0d,\n 0x2028,\n 0x2029,\n // White spaces\n 0x20,\n 0x09,\n 0x0b,\n 0x0c,\n 0xa0,\n ];\n\n return allSpaces.includes(ch);\n};\nexport default isSpace;\n","import isSpace from \"./isSpace\";\nimport type PathParser from \"./pathParser\";\n\n/**\n * Points the parser to the next character in the\n * path string every time it encounters any kind of\n * space character.\n *\n * @param path the `PathParser` instance\n */\nconst skipSpaces = (path: PathParser) => {\n const { pathValue, max } = path;\n while (path.index < max && isSpace(pathValue.charCodeAt(path.index))) {\n path.index += 1;\n }\n};\nexport default skipSpaces;\n","import type { PathCommandNumber } from \"../types\";\n\n/**\n * Checks if the character is a path command.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isPathCommand = (code: number): code is PathCommandNumber => {\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy\n switch (code | 0x20) {\n case 0x6d /* m */:\n case 0x7a /* z */:\n case 0x6c /* l */:\n case 0x68 /* h */:\n case 0x76 /* v */:\n case 0x63 /* c */:\n case 0x73 /* s */:\n case 0x71 /* q */:\n case 0x74 /* t */:\n case 0x61 /* a */:\n // case 0x72/* r */:\n return true;\n default:\n return false;\n }\n};\nexport default isPathCommand;\n","import isDigit from \"./isDigit\";\nimport type { DigitNumber } from \"../types\";\n\n/**\n * Checks if the character is or belongs to a number.\n * [0-9]|+|-|.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isDigitStart = (\n code: number,\n): code is DigitNumber | 0x2b | 0x2d | 0x2e => {\n return isDigit(code) /* 0..9 */ || code === 0x2b /* + */ ||\n code === 0x2d /* - */ || code === 0x2e; /* . */\n};\nexport default isDigitStart;\n","/**\n * Checks if the character is an A (arc-to) path command.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isArcCommand = (code: number): code is 0x61 => {\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy\n return (code | 0x20) === 0x61;\n};\nexport default isArcCommand;\n","/**\n * Checks if the character is a MoveTo command.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isMoveCommand = (code: number): code is 0x6d | 0x4d => {\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy\n switch (code | 0x20) {\n case 0x6d /* m */:\n case 0x4d /* M */:\n return true;\n default:\n return false;\n }\n};\nexport default isMoveCommand;\n","import finalizeSegment from \"./finalizeSegment\";\nimport paramCounts from \"./paramsCount\";\nimport scanFlag from \"./scanFlag\";\nimport scanParam from \"./scanParam\";\nimport skipSpaces from \"./skipSpaces\";\nimport isPathCommand from \"./isPathCommand\";\nimport isDigitStart from \"./isDigitStart\";\nimport isArcCommand from \"./isArcCommand\";\nimport isMoveCommand from \"./isMoveCommand\";\nimport invalidPathValue from \"./invalidPathValue\";\nimport error from \"./error\";\n\nimport type PathParser from \"./pathParser\";\nimport type { PathSegment, RelativeCommand } from \"../types\";\n\n/**\n * Scans every character in the path string to determine\n * where a segment starts and where it ends.\n *\n * @param path the `PathParser` instance\n */\nconst scanSegment = (path: PathParser) => {\n const { max, pathValue, index, segments } = path;\n const cmdCode = pathValue.charCodeAt(index);\n const reqParams =\n paramCounts[pathValue[index].toLowerCase() as RelativeCommand];\n\n path.segmentStart = index;\n\n // segments always start with a path command\n if (!isPathCommand(cmdCode)) {\n path.err = `${error}: ${invalidPathValue} \"${\n pathValue[index]\n }\" is not a path command at index ${index}`;\n return;\n }\n\n // after a Z segment, we only expect a MoveTo path command\n const lastSegment = segments[segments.length - 1] as PathSegment | undefined;\n if (\n !isMoveCommand(cmdCode) && lastSegment?.[0]?.toLocaleLowerCase() === \"z\"\n ) {\n path.err = `${error}: ${invalidPathValue} \"${\n pathValue[index]\n }\" is not a MoveTo path command at index ${index}`;\n return;\n }\n\n path.index += 1;\n skipSpaces(path);\n\n path.data = [];\n\n if (!reqParams) {\n // Z\n finalizeSegment(path);\n return;\n }\n\n for (;;) {\n for (let i = reqParams; i > 0; i -= 1) {\n if (isArcCommand(cmdCode) && (i === 3 || i === 4)) scanFlag(path);\n else scanParam(path);\n\n if (path.err.length) {\n return;\n }\n path.data.push(path.param);\n\n skipSpaces(path);\n\n // after ',' param is mandatory\n if (\n path.index < max && pathValue.charCodeAt(path.index) === 0x2c /* , */\n ) {\n path.index += 1;\n skipSpaces(path);\n }\n }\n\n if (path.index >= path.max) {\n break;\n }\n\n // Stop on next segment\n if (!isDigitStart(pathValue.charCodeAt(path.index))) {\n break;\n }\n }\n\n finalizeSegment(path);\n};\nexport default scanSegment;\n","import type { PathArray, PathSegment } from \"../types\";\n\n/**\n * The `PathParser` is used by the `parsePathString` static method\n * to generate a `pathArray`.\n *\n * @param pathString\n */\nexport default class PathParser {\n declare segments: PathArray | PathSegment[];\n declare pathValue: string;\n declare max: number;\n declare index: number;\n declare param: number;\n declare segmentStart: number;\n declare data: (string | number)[];\n declare err: string;\n\n constructor(pathString: string) {\n this.segments = [];\n this.pathValue = pathString;\n this.max = pathString.length;\n this.index = 0;\n this.param = 0.0;\n this.segmentStart = 0;\n this.data = [];\n this.err = \"\";\n }\n}\n","import scanSegment from \"./scanSegment\";\nimport skipSpaces from \"./skipSpaces\";\nimport PathParser from \"./pathParser\";\nimport type { PathArray } from \"../types\";\n\n/**\n * Parses a path string value and returns an array\n * of segments we like to call `pathArray`.\n *\n * @param pathInput the string to be parsed\n * @returns the resulted `pathArray` or error string\n */\nconst parsePathString = (pathInput: string | T) => {\n if (typeof pathInput !== \"string\") {\n return pathInput.slice(0) as typeof pathInput;\n }\n\n const path = new PathParser(pathInput);\n\n skipSpaces(path);\n\n while (path.index < path.max && !path.err.length) {\n scanSegment(path);\n }\n\n // handle valid paths first\n // handle errors second\n if (!path.err.length) {\n if (path.segments.length) {\n /**\n * force absolute first M\n * getPathBBox calculation requires first segment to be absolute\n * @see https://github.com/thednp/svg-path-commander/pull/49\n */\n path.segments[0][0] = \"M\";\n }\n } else {\n throw TypeError(path.err);\n }\n\n return path.segments as PathArray;\n};\n\nexport default parsePathString;\n","import type {\n AbsoluteCommand,\n AbsoluteSegment,\n ASegment,\n CSegment,\n HSegment,\n LSegment,\n MSegment,\n PathSegment,\n QSegment,\n SSegment,\n TSegment,\n VSegment,\n} from \"../types\";\n\n/**\n * Returns an absolute segment of a `PathArray` object.\n *\n * @param segment the segment object\n * @param index the segment index\n * @param lastX the last known X value\n * @param lastY the last known Y value\n * @returns the absolute segment\n */\nconst absolutizeSegment = (\n segment: PathSegment,\n index: number,\n lastX: number,\n lastY: number,\n) => {\n const [pathCommand] = segment;\n const absCommand = pathCommand.toUpperCase() as AbsoluteCommand;\n const isAbsolute = absCommand === pathCommand;\n\n /* istanbul ignore else @preserve */\n if (index === 0 || isAbsolute) return segment as MSegment | AbsoluteSegment;\n // const values = segment.slice(1) as number[];\n if (absCommand === \"A\") {\n return [\n absCommand,\n segment[1],\n segment[2],\n segment[3],\n segment[4],\n segment[5],\n (segment as ASegment)[6] + lastX,\n (segment as ASegment)[7] + lastY,\n ] as ASegment;\n } else if (absCommand === \"V\") {\n return [absCommand, (segment as VSegment)[1] + lastY] as VSegment;\n } else if (absCommand === \"H\") {\n return [absCommand, (segment as HSegment)[1] + lastX] as HSegment;\n } else if (absCommand === \"L\") {\n return [\n absCommand,\n (segment as LSegment)[1] + lastX,\n (segment as LSegment)[2] + lastY,\n ] as LSegment;\n } else {\n // use brakets for `eslint: no-case-declaration`\n // https://stackoverflow.com/a/50753272/803358\n const absValues = [] as number[];\n const seglen = segment.length;\n for (let j = 1; j < seglen; j += 1) {\n absValues.push((segment[j] as number) + (j % 2 ? lastX : lastY));\n }\n // for c, s, q, t\n return [absCommand as typeof absCommand | number].concat(absValues) as\n | MSegment\n | QSegment\n | TSegment\n | SSegment\n | CSegment;\n }\n};\nexport default absolutizeSegment;\n","// import paramsParser from '../parser/paramsParser';\nimport type {\n AbsoluteCommand,\n IteratorCallback,\n PathArray,\n PathCommand,\n PathSegment,\n} from \"../types\";\n\nconst iterate = (\n path: PathArray,\n iterator: IteratorCallback,\n) => {\n let pathLen = path.length;\n let segment: PathSegment;\n let pathCommand = \"M\" as PathCommand;\n let absCommand = \"M\" as AbsoluteCommand;\n let isRelative = false;\n let x = 0;\n let y = 0;\n let mx = 0;\n let my = 0;\n let segLen = 0;\n\n for (let i = 0; i < pathLen; i += 1) {\n segment = path[i];\n [pathCommand] = segment;\n segLen = segment.length;\n absCommand = pathCommand.toUpperCase() as AbsoluteCommand;\n isRelative = absCommand !== pathCommand;\n\n const iteratorResult = iterator(segment, i, x, y);\n // some methods like getPointAtLength would like to break\n // when task is complete\n if (iteratorResult === false) {\n break;\n }\n\n // segment = path[i];\n if (absCommand === \"Z\") {\n x = mx;\n y = my;\n } else if (absCommand === \"H\") {\n x = (segment[1] as number) + (isRelative ? x : 0);\n } else if (absCommand === \"V\") {\n y = (segment[1] as number) + (isRelative ? y : 0);\n } else {\n x = (segment[segLen - 2] as number) + (isRelative ? x : 0);\n y = (segment[segLen - 1] as number) + (isRelative ? y : 0);\n\n if (absCommand === \"M\") {\n mx = x;\n my = y;\n }\n }\n\n if (iteratorResult) {\n path[i] = iteratorResult;\n if (iteratorResult[0] === \"C\") {\n pathLen = path.length;\n }\n }\n }\n return path as T;\n};\n\nexport default iterate;\n","import parsePathString from \"../parser/parsePathString\";\nimport absolutizeSegment from \"../process/absolutizeSegment\";\nimport type { AbsoluteArray, PathArray } from \"../types\";\nimport iterate from \"../process/iterate\";\n\n/**\n * Parses a path string value or object and returns an array\n * of segments, all converted to absolute values.\n *\n * @param pathInput the path string | object\n * @returns the resulted `pathArray` with absolute values\n */\nconst pathToAbsolute = (pathInput: string | PathArray) => {\n const path = parsePathString(pathInput);\n\n return iterate(path, absolutizeSegment);\n};\nexport default pathToAbsolute;\n","import type {\n aSegment,\n cSegment,\n hSegment,\n lSegment,\n MSegment,\n PathSegment,\n qSegment,\n RelativeCommand,\n RelativeSegment,\n sSegment,\n tSegment,\n vSegment,\n} from \"../types\";\n\n/**\n * Returns a relative segment of a `PathArray` object.\n *\n * @param segment the segment object\n * @param index the segment index\n * @param lastX the last known X value\n * @param lastY the last known Y value\n * @returns the relative segment\n */\nconst relativizeSegment = (\n segment: PathSegment,\n index: number,\n lastX: number,\n lastY: number,\n) => {\n const [pathCommand] = segment;\n const relCommand = pathCommand.toLowerCase() as RelativeCommand;\n const isRelative = pathCommand === relCommand;\n\n /* istanbul ignore else @preserve */\n if (index === 0 || isRelative) return segment as MSegment | RelativeSegment;\n\n if (relCommand === \"a\") {\n return [\n relCommand,\n segment[1],\n segment[2],\n segment[3],\n segment[4],\n segment[5],\n (segment as aSegment)[6] - lastX,\n (segment as aSegment)[7] - lastY,\n ] as aSegment;\n } else if (relCommand === \"v\") {\n return [relCommand, (segment as vSegment)[1] - lastY] as vSegment;\n } else if (relCommand === \"h\") {\n return [relCommand, (segment as hSegment)[1] - lastX] as hSegment;\n } else if (relCommand === \"l\") {\n return [\n relCommand,\n (segment as lSegment)[1] - lastX,\n (segment as lSegment)[2] - lastY,\n ] as lSegment;\n } else {\n // use brakets for `eslint: no-case-declaration`\n // https://stackoverflow.com/a/50753272/803358\n const relValues = [] as number[];\n const seglen = segment.length;\n for (let j = 1; j < seglen; j += 1) {\n relValues.push((segment[j] as number) - (j % 2 ? lastX : lastY));\n }\n // for c, s, q, t\n return [relCommand as RelativeCommand | number].concat(relValues) as\n | qSegment\n | tSegment\n | sSegment\n | cSegment;\n }\n};\n\nexport default relativizeSegment;\n","import type { PathArray, RelativeArray } from \"../types\";\nimport parsePathString from \"../parser/parsePathString\";\nimport iterate from \"../process/iterate\";\nimport relativizeSegment from \"../process/relativizeSegment\";\n\n/**\n * Parses a path string value or object and returns an array\n * of segments, all converted to relative values.\n *\n * @param pathInput the path string | object\n * @returns the resulted `pathArray` with relative values\n */\nconst pathToRelative = (pathInput: string | PathArray): RelativeArray => {\n const path = parsePathString(pathInput);\n\n return iterate(path, relativizeSegment);\n};\nexport default pathToRelative;\n","/**\n * Returns an {x,y} vector rotated by a given\n * angle in radian.\n *\n * @param x the initial vector x\n * @param y the initial vector y\n * @param rad the radian vector angle\n * @returns the rotated vector\n */\nconst rotateVector = (\n x: number,\n y: number,\n rad: number,\n): { x: number; y: number } => {\n const { sin, cos } = Math;\n const X = x * cos(rad) - y * sin(rad);\n const Y = x * sin(rad) + y * cos(rad);\n return { x: X, y: Y };\n};\n\nexport default rotateVector;\n","import rotateVector from \"../math/rotateVector\";\n\n/**\n * Converts A (arc-to) segments to C (cubic-bezier-to).\n *\n * For more information of where this math came from visit:\n * http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes\n *\n * @param X1 the starting x position\n * @param Y1 the starting y position\n * @param RX x-radius of the arc\n * @param RY y-radius of the arc\n * @param angle x-axis-rotation of the arc\n * @param LAF large-arc-flag of the arc\n * @param SF sweep-flag of the arc\n * @param X2 the ending x position\n * @param Y2 the ending y position\n * @param recursive the parameters needed to split arc into 2 segments\n * @return the resulting cubic-bezier segment(s)\n */\nconst arcToCubic = (\n X1: number,\n Y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n X2: number,\n Y2: number,\n recursive?: [number, number, number, number],\n): number[] => {\n let x1 = X1;\n let y1 = Y1;\n let rx = RX;\n let ry = RY;\n let x2 = X2;\n let y2 = Y2;\n // for more information of where this Math came from visit:\n // http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes\n const d120 = (Math.PI * 120) / 180;\n\n const rad = (Math.PI / 180) * (+angle || 0);\n let res = [] as number[];\n let xy;\n let f1;\n let f2;\n let cx;\n let cy;\n\n if (!recursive) {\n xy = rotateVector(x1, y1, -rad);\n x1 = xy.x;\n y1 = xy.y;\n xy = rotateVector(x2, y2, -rad);\n x2 = xy.x;\n y2 = xy.y;\n\n const x = (x1 - x2) / 2;\n const y = (y1 - y2) / 2;\n let h = (x * x) / (rx * rx) + (y * y) / (ry * ry);\n if (h > 1) {\n h = Math.sqrt(h);\n rx *= h;\n ry *= h;\n }\n const rx2 = rx * rx;\n const ry2 = ry * ry;\n\n const k = (LAF === SF ? -1 : 1) *\n Math.sqrt(\n Math.abs(\n (rx2 * ry2 - rx2 * y * y - ry2 * x * x) / (rx2 * y * y + ry2 * x * x),\n ),\n );\n\n cx = (k * rx * y) / ry + (x1 + x2) / 2;\n cy = (k * -ry * x) / rx + (y1 + y2) / 2;\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy no-bitwise\n f1 = Math.asin(((((y1 - cy) / ry) * 10 ** 9) >> 0) / 10 ** 9);\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy no-bitwise\n f2 = Math.asin(((((y2 - cy) / ry) * 10 ** 9) >> 0) / 10 ** 9);\n\n f1 = x1 < cx ? Math.PI - f1 : f1;\n f2 = x2 < cx ? Math.PI - f2 : f2;\n if (f1 < 0) f1 = Math.PI * 2 + f1;\n if (f2 < 0) f2 = Math.PI * 2 + f2;\n if (SF && f1 > f2) {\n f1 -= Math.PI * 2;\n }\n if (!SF && f2 > f1) {\n f2 -= Math.PI * 2;\n }\n } else {\n [f1, f2, cx, cy] = recursive;\n }\n let df = f2 - f1;\n if (Math.abs(df) > d120) {\n const f2old = f2;\n const x2old = x2;\n const y2old = y2;\n f2 = f1 + d120 * (SF && f2 > f1 ? 1 : -1);\n x2 = cx + rx * Math.cos(f2);\n y2 = cy + ry * Math.sin(f2);\n res = arcToCubic(x2, y2, rx, ry, angle, 0, SF, x2old, y2old, [\n f2,\n f2old,\n cx,\n cy,\n ]);\n }\n df = f2 - f1;\n const c1 = Math.cos(f1);\n const s1 = Math.sin(f1);\n const c2 = Math.cos(f2);\n const s2 = Math.sin(f2);\n const t = Math.tan(df / 4);\n const hx = (4 / 3) * rx * t;\n const hy = (4 / 3) * ry * t;\n const m1 = [x1, y1];\n const m2 = [x1 + hx * s1, y1 - hy * c1];\n const m3 = [x2 + hx * s2, y2 - hy * c2];\n const m4 = [x2, y2];\n m2[0] = 2 * m1[0] - m2[0];\n m2[1] = 2 * m1[1] - m2[1];\n if (recursive) {\n return [m2[0], m2[1], m3[0], m3[1], m4[0], m4[1]].concat(res);\n }\n res = [m2[0], m2[1], m3[0], m3[1], m4[0], m4[1]].concat(res);\n const newres = [];\n for (let i = 0, ii = res.length; i < ii; i += 1) {\n newres[i] = i % 2\n ? rotateVector(res[i - 1], res[i], rad).y\n : rotateVector(res[i], res[i + 1], rad).x;\n }\n return newres;\n};\nexport default arcToCubic;\n","/**\n * Converts a Q (quadratic-bezier) segment to C (cubic-bezier).\n *\n * @param x1 curve start x\n * @param y1 curve start y\n * @param qx control point x\n * @param qy control point y\n * @param x2 curve end x\n * @param y2 curve end y\n * @returns the cubic-bezier segment\n */\nconst quadToCubic = (\n x1: number,\n y1: number,\n qx: number,\n qy: number,\n x2: number,\n y2: number,\n): [number, number, number, number, number, number] => {\n const r13 = 1 / 3;\n const r23 = 2 / 3;\n return [\n r13 * x1 + r23 * qx, // cpx1\n r13 * y1 + r23 * qy, // cpy1\n r13 * x2 + r23 * qx, // cpx2\n r13 * y2 + r23 * qy, // cpy2\n x2,\n y2, // x,y\n ];\n};\nexport default quadToCubic;\n","import midPoint from \"../math/midPoint\";\n\n/**\n * Converts an L (line-to) segment to C (cubic-bezier).\n *\n * @param x1 line start x\n * @param y1 line start y\n * @param x2 line end x\n * @param y2 line end y\n * @returns the cubic-bezier segment\n */\nconst lineToCubic = (x1: number, y1: number, x2: number, y2: number) => {\n const c1 = midPoint([x1, y1], [x2, y2], 1.0 / 3.0);\n const c2 = midPoint([x1, y1], [x2, y2], 2.0 / 3.0);\n return [c1[0], c1[1], c2[0], c2[1], x2, y2];\n};\nexport default lineToCubic;\n","import arcToCubic from \"./arcToCubic\";\nimport quadToCubic from \"./quadToCubic\";\nimport lineToCubic from \"./lineToCubic\";\nimport type { CSegment, MSegment, PathSegment } from \"../types\";\nimport type { ParserParams } from \"../interface\";\n\n/**\n * Converts any segment to C (cubic-bezier).\n *\n * @param segment the source segment\n * @param params the source segment parameters\n * @returns the cubic-bezier segment\n */\nconst segmentToCubic = (segment: PathSegment, params: ParserParams) => {\n const [pathCommand] = segment;\n const values = segment.slice(1).map(Number);\n const [x, y] = values;\n // let args;\n const { x1: px1, y1: py1, x: px, y: py } = params;\n\n if (!\"TQ\".includes(pathCommand)) {\n params.qx = null;\n params.qy = null;\n }\n\n if (pathCommand === \"M\") {\n params.x = x;\n params.y = y;\n return segment;\n } else if (pathCommand === \"A\") {\n return [\"C\" as string | number].concat(\n arcToCubic(\n px1,\n py1,\n values[0],\n values[1],\n values[2],\n values[3],\n values[4],\n values[5],\n values[6],\n ),\n ) as CSegment;\n } else if (pathCommand === \"Q\") {\n params.qx = x;\n params.qy = y;\n return [\"C\" as string | number].concat(\n quadToCubic(px1, py1, values[0], values[1], values[2], values[3]),\n ) as CSegment;\n } else if (pathCommand === \"L\") {\n return [\"C\" as string | number].concat(\n lineToCubic(px1, py1, x, y),\n ) as CSegment;\n } else if (pathCommand === \"Z\") {\n return [\"C\" as string | number].concat(\n lineToCubic(px1, py1, px, py),\n ) as CSegment;\n }\n\n return segment as MSegment | CSegment;\n};\nexport default segmentToCubic;\n","import type { ParserParams } from \"../interface\";\nimport type {\n ASegment,\n CSegment,\n HSegment,\n LSegment,\n MSegment,\n NormalSegment,\n PathCommand,\n PathSegment,\n PointTuple,\n QSegment,\n VSegment,\n} from \"../types\";\n\n/**\n * Normalizes a single segment of a `pathArray` object.\n *\n * @param segment the segment object\n * @param params the normalization parameters\n * @returns the normalized segment\n */\nconst normalizeSegment = (segment: PathSegment, params: ParserParams) => {\n const [pathCommand] = segment;\n const absCommand = pathCommand.toUpperCase();\n const isRelative = pathCommand !== absCommand;\n const { x1: px1, y1: py1, x2: px2, y2: py2, x, y } = params;\n const values = segment.slice(1) as number[];\n let absValues = values.map((n, j) => n + (isRelative ? (j % 2 ? y : x) : 0));\n\n if (!\"TQ\".includes(absCommand)) {\n // optional but good to be cautious\n params.qx = null;\n params.qy = null;\n }\n\n // istanbul ignore else @preserve\n if (absCommand === \"A\") {\n absValues = values.slice(0, -2).concat(\n values[5] + (isRelative ? x : 0),\n values[6] + (isRelative ? y : 0),\n );\n\n return [\"A\" as PathCommand | number].concat(absValues) as ASegment;\n } else if (absCommand === \"H\") {\n return [\n \"L\",\n (segment as HSegment)[1] + (isRelative ? x : 0),\n py1,\n ] as LSegment;\n } else if (absCommand === \"V\") {\n return [\n \"L\",\n px1,\n (segment as VSegment)[1] + (isRelative ? y : 0),\n ] as LSegment;\n } else if (absCommand === \"L\") {\n return [\n \"L\",\n (segment as LSegment)[1] + (isRelative ? x : 0),\n (segment as LSegment)[2] + (isRelative ? y : 0),\n ] as LSegment;\n } else if (absCommand === \"M\") {\n return [\n \"M\",\n (segment as MSegment)[1] + (isRelative ? x : 0),\n (segment as MSegment)[2] + (isRelative ? y : 0),\n ] as MSegment;\n } else if (absCommand === \"C\") {\n return [\"C\" as PathCommand | number].concat(absValues) as CSegment;\n } else if (absCommand === \"S\") {\n const x1 = px1 * 2 - px2;\n const y1 = py1 * 2 - py2;\n params.x1 = x1;\n params.y1 = y1;\n return [\"C\", x1, y1].concat(absValues) as CSegment;\n } else if (absCommand === \"T\") {\n const qx = px1 * 2 - (params.qx ? params.qx : /* istanbul ignore next */ 0);\n const qy = py1 * 2 - (params.qy ? params.qy : /* istanbul ignore next */ 0);\n params.qx = qx;\n params.qy = qy;\n return [\"Q\", qx, qy].concat(absValues) as QSegment;\n } else if (absCommand === \"Q\") {\n const [nqx, nqy] = absValues as PointTuple;\n params.qx = nqx;\n params.qy = nqy;\n return [\"Q\" as PathCommand | number].concat(absValues) as QSegment;\n } else if (absCommand === \"Z\") {\n return [\"Z\"] as NormalSegment;\n }\n\n // istanbul ignore next @preserve\n return segment as NormalSegment;\n};\nexport default normalizeSegment;\n","import type { ParserParams } from \"../interface\";\n\nconst paramsParser: ParserParams = {\n x1: 0,\n y1: 0,\n x2: 0,\n y2: 0,\n x: 0,\n y: 0,\n qx: null,\n qy: null,\n};\n\nexport default paramsParser;\n","import segmentToCubic from \"../process/segmentToCubic\";\nimport { AbsoluteCommand, CSegment, CurveArray, PathArray } from \"../types\";\nimport iterate from \"../process/iterate\";\nimport parsePathString from \"../parser/parsePathString\";\nimport normalizeSegment from \"../process/normalizeSegment\";\nimport paramsParser from \"../parser/paramsParser\";\n\n/**\n * Parses a path string value or 'pathArray' and returns a new one\n * in which all segments are converted to cubic-bezier.\n *\n * In addition, un-necessary `Z` segment is removed if previous segment\n * extends to the `M` segment.\n *\n * @param pathInput the string to be parsed or 'pathArray'\n * @returns the resulted `pathArray` converted to cubic-bezier\n */\nconst pathToCurve = (pathInput: string | PathArray): CurveArray => {\n const params = { ...paramsParser };\n const path = parsePathString(pathInput);\n\n return iterate(path, (seg, index, lastX, lastY) => {\n params.x = lastX;\n params.y = lastY;\n const normalSegment = normalizeSegment(seg, params);\n let result = segmentToCubic(normalSegment, params);\n const isLongArc = result[0] === \"C\" && result.length > 7;\n\n if (isLongArc) {\n path.splice(\n index + 1,\n 0,\n [\"C\" as AbsoluteCommand | number].concat(result.slice(7)) as CSegment,\n );\n result = result.slice(0, 7) as CSegment;\n }\n\n const seglen = result.length;\n params.x1 = +result[seglen - 2];\n params.y1 = +result[seglen - 1];\n params.x2 = +result[seglen - 4] || params.x1;\n params.y2 = +result[seglen - 3] || params.y1;\n\n return result;\n });\n};\nexport default pathToCurve;\n","import { Options } from \"../interface\";\n\n/** SVGPathCommander default options */\nconst defaultOptions: Options = {\n origin: [0, 0, 0],\n round: 4,\n};\n\nexport default defaultOptions;\n","const roundTo = (n: number, round: number) => {\n const pow = round >= 1 ? 10 ** round : 1;\n\n return round > 0 ? Math.round(n * pow) / pow : Math.round(n);\n};\n\nexport default roundTo;\n","import type { PathArray, PathSegment } from \"../types\";\nimport defaultOptions from \"../options/options\";\nimport roundTo from \"../math/roundTo\";\n\n/**\n * Returns a valid `d` attribute string value created\n * by rounding values and concatenating the `pathArray` segments.\n *\n * @param path the `pathArray` object\n * @param roundOption amount of decimals to round values to\n * @returns the concatenated path string\n */\nconst pathToString = (\n path: PathArray,\n roundOption?: number | \"off\",\n): string => {\n const pathLen = path.length;\n let { round } = defaultOptions;\n let segment = path[0] as PathSegment;\n let result = \"\";\n\n // allow for ZERO decimals\n round = roundOption === \"off\"\n ? roundOption\n : typeof roundOption === \"number\" && roundOption >= 0\n ? roundOption\n : typeof round === \"number\" && round >= 0\n ? round\n : /* istanbul ignore next @preserve */ \"off\";\n\n for (let i = 0; i < pathLen; i += 1) {\n segment = path[i];\n const [pathCommand] = segment;\n const values = segment.slice(1) as number[];\n result += pathCommand;\n if (round === \"off\") {\n result += values.join(\" \");\n } else {\n let j = 0;\n const valLen = values.length;\n while (j < valLen) {\n result += roundTo(values[j], round);\n if (j !== valLen - 1) result += \" \";\n j += 1;\n }\n }\n }\n\n return result;\n};\n\nexport default pathToString;\n","const DISTANCE_EPSILON = 0.00001;\n\nexport default DISTANCE_EPSILON;\n","import normalizeSegment from \"./normalizeSegment\";\nimport type { NormalArray, PathArray } from \"../types\";\nimport iterate from \"./iterate\";\nimport parsePathString from \"../parser/parsePathString\";\nimport paramsParser from \"../parser/paramsParser\";\n\n/**\n * Normalizes a `pathArray` object for further processing:\n * * convert segments to absolute values\n * * convert shorthand path commands to their non-shorthand notation\n *\n * @param pathInput the string to be parsed or 'pathArray'\n * @returns the normalized `pathArray`\n */\nconst normalizePath = (pathInput: string | PathArray) => {\n const path = parsePathString(pathInput);\n const params = { ...paramsParser };\n\n return iterate(path, (seg, _, lastX, lastY) => {\n params.x = lastX;\n params.y = lastY;\n const result = normalizeSegment(seg, params);\n\n const seglen = result.length;\n params.x1 = +result[seglen - 2];\n params.y1 = +result[seglen - 1];\n params.x2 = +result[seglen - 4] || params.x1;\n params.y2 = +result[seglen - 3] || params.y1;\n\n return result;\n });\n};\nexport default normalizePath;\n","import DISTANCE_EPSILON from \"./distanceEpsilon\";\nimport type { MSegment, PathArray, PointTuple } from \"../types\";\nimport iterate from \"../process/iterate\";\nimport { getLineLength, getPointAtLineLength } from \"../math/lineTools\";\nimport { getArcLength, getPointAtArcLength } from \"../math/arcTools\";\nimport { getCubicLength, getPointAtCubicLength } from \"../math/cubicTools\";\nimport { getPointAtQuadLength, getQuadLength } from \"../math/quadTools\";\nimport normalizePath from \"../process/normalizePath\";\n\n/**\n * Returns [x,y] coordinates of a point at a given length of a shape.\n *\n * @param pathInput the `pathArray` to look into\n * @param distance the length of the shape to look at\n * @returns the requested {x, y} point coordinates\n */\nconst getPointAtLength = (pathInput: string | PathArray, distance?: number) => {\n const path = normalizePath(pathInput);\n let isM = false;\n let data = [] as number[];\n let pathCommand = \"M\";\n let x = 0;\n let y = 0;\n let [mx, my] = path[0].slice(1) as PointTuple;\n const distanceIsNumber = typeof distance === \"number\";\n let point = { x: mx, y: my };\n let length = 0;\n let POINT = point;\n let totalLength = 0;\n\n if (!distanceIsNumber || distance < DISTANCE_EPSILON) return point;\n\n // for (let i = 0; i < pathLen; i += 1) {\n iterate(path, (seg, _, lastX, lastY) => {\n [pathCommand] = seg;\n isM = pathCommand === \"M\";\n data = !isM ? [lastX, lastY].concat(seg.slice(1) as number[]) : data;\n\n // this segment is always ZERO\n /* istanbul ignore else @preserve */\n if (isM) {\n // remember mx, my for Z\n [, mx, my] = seg as MSegment;\n point = { x: mx, y: my };\n length = 0;\n } else if (pathCommand === \"L\") {\n point = getPointAtLineLength(\n data[0],\n data[1],\n data[2],\n data[3],\n distance - totalLength,\n );\n length = getLineLength(data[0], data[1], data[2], data[3]);\n } else if (pathCommand === \"A\") {\n point = getPointAtArcLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n data[6],\n data[7],\n data[8],\n distance - totalLength,\n );\n length = getArcLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n data[6],\n data[7],\n data[8],\n );\n } else if (pathCommand === \"C\") {\n point = getPointAtCubicLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n data[6],\n data[7],\n distance - totalLength,\n );\n length = getCubicLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n data[6],\n data[7],\n );\n } else if (pathCommand === \"Q\") {\n point = getPointAtQuadLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n distance - totalLength,\n );\n length = getQuadLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n );\n } else if (pathCommand === \"Z\") {\n data = [lastX, lastY, mx, my];\n point = { x: mx, y: my };\n\n length = getLineLength(data[0], data[1], data[2], data[3]);\n }\n\n [x, y] = data.slice(-2);\n\n if (totalLength < distance) {\n POINT = point;\n } else {\n // totalLength >= distance\n // stop right here\n // stop iterator now!\n return false;\n }\n\n totalLength += length;\n return;\n });\n\n // native `getPointAtLength` behavior when the given distance\n // is higher than total length\n if (distance > totalLength - DISTANCE_EPSILON) {\n return { x, y };\n }\n\n return POINT;\n};\n\nexport default getPointAtLength;\n","import type { LSegment, MSegment, PathArray, PointTuple } from \"../types\";\nimport { getLineLength } from \"../math/lineTools\";\nimport { getArcLength } from \"../math/arcTools\";\nimport { getCubicLength } from \"../math/cubicTools\";\nimport { getQuadLength } from \"../math/quadTools\";\nimport iterate from \"../process/iterate\";\nimport parsePathString from \"../parser/parsePathString\";\nimport absolutizeSegment from \"../process/absolutizeSegment\";\n\n/**\n * Returns the shape total length, or the equivalent to `shape.getTotalLength()`.\n *\n * @param pathInput the target `pathArray`\n * @returns the shape total length\n */\nconst getTotalLength = (pathInput: string | PathArray) => {\n const path = parsePathString(pathInput);\n let paramX1 = 0;\n let paramY1 = 0;\n let paramX2 = 0;\n let paramY2 = 0;\n let paramQX = 0;\n let paramQY = 0;\n let pathCommand = \"M\";\n let mx = 0;\n let my = 0;\n let totalLength = 0;\n\n iterate(path, (seg, index, lastX, lastY) => {\n [pathCommand] = seg;\n const absCommand = pathCommand.toUpperCase();\n const isRelative = absCommand !== pathCommand;\n const absoluteSegment = isRelative\n ? absolutizeSegment(seg, index, lastX, lastY)\n : (seg.slice(0) as typeof seg);\n\n const normalSegment = absCommand === \"V\"\n ? ([\"L\", lastX, absoluteSegment[1]] as LSegment)\n : absCommand === \"H\"\n ? ([\"L\", absoluteSegment[1], lastY] as LSegment)\n : absoluteSegment;\n [pathCommand] = normalSegment;\n\n if (!\"TQ\".includes(absCommand)) {\n // optional but good to be cautious\n paramQX = 0;\n paramQY = 0;\n }\n\n // this segment is always ZERO\n /* istanbul ignore else @preserve */\n if (pathCommand === \"M\") {\n // remember mx, my for Z\n [, mx, my] = normalSegment as MSegment;\n } else if (pathCommand === \"L\") {\n totalLength += getLineLength(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n );\n } else if (pathCommand === \"A\") {\n totalLength += getArcLength(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n normalSegment[5] as number,\n normalSegment[6] as number,\n normalSegment[7] as number,\n );\n } else if (pathCommand === \"S\") {\n const cp1x = paramX1 * 2 - paramX2;\n const cp1y = paramY1 * 2 - paramY2;\n\n totalLength += getCubicLength(\n lastX,\n lastY,\n cp1x,\n cp1y,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n );\n } else if (pathCommand === \"C\") {\n totalLength += getCubicLength(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n normalSegment[5] as number,\n normalSegment[6] as number,\n );\n } else if (pathCommand === \"T\") {\n paramQX = paramX1 * 2 - paramQX;\n paramQY = paramY1 * 2 - paramQY;\n totalLength += getQuadLength(\n lastX,\n lastY,\n paramQX,\n paramQY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n );\n } else if (pathCommand === \"Q\") {\n paramQX = normalSegment[1] as number;\n paramQY = normalSegment[2] as number;\n totalLength += getQuadLength(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n );\n } else if (pathCommand === \"Z\") {\n totalLength += getLineLength(lastX, lastY, mx, my);\n }\n\n // update params\n [paramX1, paramY1] = pathCommand === \"Z\"\n ? [mx, my]\n : (normalSegment.slice(-2) as PointTuple);\n [paramX2, paramY2] = pathCommand === \"C\"\n ? ([normalSegment[3], normalSegment[4]] as PointTuple)\n : pathCommand === \"S\"\n ? ([normalSegment[1], normalSegment[2]] as PointTuple)\n : [paramX1, paramY1];\n });\n\n return totalLength;\n};\n\nexport default getTotalLength;\n","import type { PathArray, PathSegment } from \"../types\";\nimport type { SegmentProperties } from \"../interface\";\nimport parsePathString from \"../parser/parsePathString\";\nimport getTotalLength from \"./getTotalLength\";\n\n/**\n * Returns the segment, its index and length as well as\n * the length to that segment at a given length in a path.\n *\n * @param pathInput target `pathArray`\n * @param distance the given length\n * @returns the requested properties\n */\nconst getPropertiesAtLength = (\n pathInput: string | PathArray,\n distance?: number,\n): SegmentProperties => {\n const pathArray = parsePathString(pathInput);\n\n let pathTemp = pathArray.slice(0) as PathArray;\n let pathLength = getTotalLength(pathTemp);\n let index = pathTemp.length - 1;\n let lengthAtSegment = 0;\n let length = 0;\n let segment = pathArray[0] as PathSegment;\n\n // If the path is empty, return 0.\n if (index <= 0 || !distance || !Number.isFinite(distance)) {\n return {\n segment,\n index: 0,\n length,\n lengthAtSegment,\n };\n }\n\n if (distance >= pathLength) {\n pathTemp = pathArray.slice(0, -1) as PathArray;\n lengthAtSegment = getTotalLength(pathTemp);\n length = pathLength - lengthAtSegment;\n segment = pathArray[index];\n return {\n segment,\n index,\n length,\n lengthAtSegment,\n };\n }\n\n const segments = [] as SegmentProperties[];\n while (index > 0) {\n segment = pathTemp[index];\n pathTemp = pathTemp.slice(0, -1) as PathArray;\n lengthAtSegment = getTotalLength(pathTemp);\n length = pathLength - lengthAtSegment;\n pathLength = lengthAtSegment;\n\n segments.push({\n segment,\n index,\n length,\n lengthAtSegment,\n });\n index -= 1;\n }\n\n return segments.find(({ lengthAtSegment: l }) =>\n l <= distance\n ) as SegmentProperties;\n};\n\nexport default getPropertiesAtLength;\n","import type { PathArray, Point } from \"../types\";\nimport type { PointProperties } from \"../interface\";\nimport getPointAtLength from \"./getPointAtLength\";\nimport getPropertiesAtLength from \"./getPropertiesAtLength\";\nimport getTotalLength from \"./getTotalLength\";\nimport parsePathString from \"../parser/parsePathString\";\nimport normalizePath from \"../process/normalizePath\";\n\n/**\n * Returns the point and segment in path closest to a given point as well as\n * the distance to the path stroke.\n *\n * @see https://bl.ocks.org/mbostock/8027637\n *\n * @param pathInput target `pathArray`\n * @param point the given point\n * @returns the requested properties\n */\nconst getPropertiesAtPoint = (\n pathInput: string | PathArray,\n point: Point,\n): PointProperties => {\n const path = parsePathString(pathInput);\n const normalPath = normalizePath(path);\n const pathLength = getTotalLength(normalPath);\n const distanceTo = (p: Point) => {\n const dx = p.x - point.x;\n const dy = p.y - point.y;\n return dx * dx + dy * dy;\n };\n let precision = 8;\n let scan: Point;\n let closest = { x: 0, y: 0 }; // make TS happy\n let scanDistance = 0;\n let bestLength = 0;\n let bestDistance = Infinity;\n\n // linear scan for coarse approximation\n for (let scanLength = 0; scanLength <= pathLength; scanLength += precision) {\n scan = getPointAtLength(normalPath, scanLength);\n scanDistance = distanceTo(scan);\n\n if (scanDistance < bestDistance) {\n closest = scan;\n bestLength = scanLength;\n bestDistance = scanDistance;\n }\n }\n\n // binary search for precise estimate\n precision /= 2;\n let before: { x: number; y: number };\n let after: { x: number; y: number };\n let beforeLength = 0;\n let afterLength = 0;\n let beforeDistance = 0;\n let afterDistance = 0;\n\n while (precision > 0.000001) {\n beforeLength = bestLength - precision;\n before = getPointAtLength(normalPath, beforeLength);\n beforeDistance = distanceTo(before);\n afterLength = bestLength + precision;\n after = getPointAtLength(normalPath, afterLength);\n afterDistance = distanceTo(after);\n\n if (beforeLength >= 0 && beforeDistance < bestDistance) {\n closest = before;\n bestLength = beforeLength;\n bestDistance = beforeDistance;\n } else if (afterLength <= pathLength && afterDistance < bestDistance) {\n closest = after;\n bestLength = afterLength;\n bestDistance = afterDistance;\n } else {\n precision /= 2;\n }\n if (precision < 0.00001) break;\n }\n\n const segment = getPropertiesAtLength(path, bestLength);\n const distance = Math.sqrt(bestDistance);\n\n return { closest, distance, segment };\n};\n\nexport default getPropertiesAtPoint;\n","import type { PathArray } from \"../types\";\nimport getPropertiesAtPoint from \"./getPropertiesAtPoint\";\n\n/**\n * Returns the point in path closest to a given point.\n *\n * @param pathInput target `pathArray`\n * @param point the given point\n * @returns the best match\n */\nconst getClosestPoint = (\n pathInput: string | PathArray,\n point: { x: number; y: number },\n) => {\n return getPropertiesAtPoint(pathInput, point).closest;\n};\n\nexport default getClosestPoint;\n","import pathToCurve from \"../convert/pathToCurve\";\nimport type { PathArray, PointTuple } from \"../types\";\n\n/**\n * Returns the area of a single cubic-bezier segment.\n *\n * http://objectmix.com/graphics/133553-area-closed-bezier-curve.html\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the area of the cubic-bezier segment\n */\nconst getCubicSegArea = (\n x1: number,\n y1: number,\n c1x: number,\n c1y: number,\n c2x: number,\n c2y: number,\n x2: number,\n y2: number,\n) => {\n return (\n (3 *\n ((y2 - y1) * (c1x + c2x) -\n (x2 - x1) * (c1y + c2y) +\n c1y * (x1 - c2x) -\n c1x * (y1 - c2y) +\n y2 * (c2x + x1 / 3) -\n x2 * (c2y + y1 / 3))) /\n 20\n );\n};\n\n/**\n * Returns the area of a shape.\n *\n * @author Jürg Lehni & Jonathan Puckey\n *\n * @see https://github.com/paperjs/paper.js/blob/develop/src/path/Path.js\n *\n * @param path the shape `pathArray`\n * @returns the length of the cubic-bezier segment\n */\nconst getPathArea = (path: PathArray) => {\n let x = 0;\n let y = 0;\n let len = 0;\n\n return pathToCurve(path)\n .map((seg) => {\n switch (seg[0]) {\n case \"M\":\n [, x, y] = seg;\n return 0;\n default:\n len = getCubicSegArea(\n x,\n y,\n seg[1],\n seg[2],\n seg[3],\n seg[4],\n seg[5],\n seg[6],\n );\n [x, y] = seg.slice(-2) as PointTuple;\n return len;\n }\n })\n .reduce((a, b) => a + b, 0);\n};\nexport default getPathArea;\n","import getPathArea from \"./getPathArea\";\nimport pathToCurve from \"../convert/pathToCurve\";\nimport type { PathArray } from \"../types\";\n\n/**\n * Check if a path is drawn clockwise and returns true if so,\n * false otherwise.\n *\n * @param path the path string or `pathArray`\n * @returns true when clockwise or false if not\n */\nconst getDrawDirection = (path: string | PathArray) => {\n return getPathArea(pathToCurve(path)) >= 0;\n};\n\nexport default getDrawDirection;\n","import iterate from \"../process/iterate\";\nimport { PathBBox } from \"../interface\";\nimport { LSegment, MSegment, PathArray, PointTuple } from \"../types\";\nimport { getLineBBox } from \"../math/lineTools\";\nimport { getArcBBox } from \"../math/arcTools\";\nimport { getCubicBBox } from \"../math/cubicTools\";\nimport { getQuadBBox } from \"../math/quadTools\";\nimport parsePathString from \"../parser/parsePathString\";\nimport absolutizeSegment from \"../process/absolutizeSegment\";\n\nconst getPathBBox = (pathInput: PathArray | string) => {\n if (!pathInput) {\n return {\n x: 0,\n y: 0,\n width: 0,\n height: 0,\n x2: 0,\n y2: 0,\n cx: 0,\n cy: 0,\n cz: 0,\n };\n }\n\n const path = parsePathString(pathInput);\n let pathCommand = \"M\";\n let mx = 0;\n let my = 0;\n const { max, min } = Math;\n let xMin = Infinity;\n let yMin = Infinity;\n let xMax = -Infinity;\n let yMax = -Infinity;\n let minX = 0;\n let minY = 0;\n let maxX = 0;\n let maxY = 0;\n let paramX1 = 0;\n let paramY1 = 0;\n let paramX2 = 0;\n let paramY2 = 0;\n let paramQX = 0;\n let paramQY = 0;\n\n iterate(path, (seg, index, lastX, lastY) => {\n [pathCommand] = seg;\n const absCommand = pathCommand.toUpperCase();\n const isRelative = absCommand !== pathCommand;\n const absoluteSegment = isRelative\n ? absolutizeSegment(seg, index, lastX, lastY)\n : (seg.slice(0) as typeof seg);\n\n const normalSegment = absCommand === \"V\"\n ? ([\"L\", lastX, absoluteSegment[1]] as LSegment)\n : absCommand === \"H\"\n ? ([\"L\", absoluteSegment[1], lastY] as LSegment)\n : absoluteSegment;\n\n [pathCommand] = normalSegment;\n\n if (!\"TQ\".includes(absCommand)) {\n // optional but good to be cautious\n paramQX = 0;\n paramQY = 0;\n }\n\n // this segment is always ZERO\n /* istanbul ignore else @preserve */\n if (pathCommand === \"M\") {\n [, mx, my] = normalSegment as MSegment;\n minX = mx;\n minY = my;\n maxX = mx;\n maxY = my;\n } else if (pathCommand === \"L\") {\n [minX, minY, maxX, maxY] = getLineBBox(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n );\n } else if (pathCommand === \"A\") {\n [minX, minY, maxX, maxY] = getArcBBox(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n normalSegment[5] as number,\n normalSegment[6] as number,\n normalSegment[7] as number,\n );\n } else if (pathCommand === \"S\") {\n const cp1x = paramX1 * 2 - paramX2;\n const cp1y = paramY1 * 2 - paramY2;\n\n [minX, minY, maxX, maxY] = getCubicBBox(\n lastX,\n lastY,\n cp1x,\n cp1y,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n );\n } else if (pathCommand === \"C\") {\n [minX, minY, maxX, maxY] = getCubicBBox(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n normalSegment[5] as number,\n normalSegment[6] as number,\n );\n } else if (pathCommand === \"T\") {\n paramQX = paramX1 * 2 - paramQX;\n paramQY = paramY1 * 2 - paramQY;\n [minX, minY, maxX, maxY] = getQuadBBox(\n lastX,\n lastY,\n paramQX,\n paramQY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n );\n } else if (pathCommand === \"Q\") {\n paramQX = normalSegment[1] as number;\n paramQY = normalSegment[2] as number;\n [minX, minY, maxX, maxY] = getQuadBBox(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n );\n } else if (pathCommand === \"Z\") {\n [minX, minY, maxX, maxY] = getLineBBox(lastX, lastY, mx, my);\n }\n xMin = min(minX, xMin);\n yMin = min(minY, yMin);\n xMax = max(maxX, xMax);\n yMax = max(maxY, yMax);\n\n // update params\n [paramX1, paramY1] = pathCommand === \"Z\"\n ? [mx, my]\n : (normalSegment.slice(-2) as PointTuple);\n [paramX2, paramY2] = pathCommand === \"C\"\n ? ([normalSegment[3], normalSegment[4]] as PointTuple)\n : pathCommand === \"S\"\n ? ([normalSegment[1], normalSegment[2]] as PointTuple)\n : [paramX1, paramY1];\n });\n\n const width = xMax - xMin;\n const height = yMax - yMin;\n\n return {\n width,\n height,\n x: xMin,\n y: yMin,\n x2: xMax,\n y2: yMax,\n cx: xMin + width / 2,\n cy: yMin + height / 2,\n // an estimated guess\n cz: Math.max(width, height) + Math.min(width, height) / 2,\n } satisfies PathBBox;\n};\n\nexport default getPathBBox;\n","import type { PathArray, PathSegment } from \"../types\";\nimport getPropertiesAtLength from \"./getPropertiesAtLength\";\n\n/**\n * Returns the segment at a given length.\n *\n * @param pathInput the target `pathArray`\n * @param distance the distance in path to look at\n * @returns the requested segment\n */\nconst getSegmentAtLength = (\n pathInput: string | PathArray,\n distance?: number,\n): PathSegment | undefined => {\n return getPropertiesAtLength(pathInput, distance).segment;\n};\n\nexport default getSegmentAtLength;\n","import type { SegmentProperties } from \"../interface\";\nimport type { PathArray } from \"../types\";\nimport getPropertiesAtPoint from \"./getPropertiesAtPoint\";\n\n/**\n * Returns the path segment which contains a given point.\n *\n * @param path the `pathArray` to look into\n * @param point the point of the shape to look for\n * @returns the requested segment\n */\nconst getSegmentOfPoint = (\n path: string | PathArray,\n point: { x: number; y: number },\n): SegmentProperties | undefined => {\n return getPropertiesAtPoint(path, point).segment;\n};\nexport default getSegmentOfPoint;\n","import type { PathArray, PathSegment, RelativeCommand } from \"../types\";\nimport paramsCount from \"../parser/paramsCount\";\n\n/**\n * Iterates an array to check if it's an actual `pathArray`.\n *\n * @param path the `pathArray` to be checked\n * @returns iteration result\n */\nconst isPathArray = (path: unknown): path is PathArray => {\n return (\n Array.isArray(path) &&\n path.every((seg: PathSegment) => {\n const lk = seg[0].toLowerCase() as RelativeCommand;\n return (\n paramsCount[lk] === seg.length - 1 &&\n \"achlmqstvz\".includes(lk) &&\n (seg.slice(1) as unknown[]).every(Number.isFinite)\n );\n }) &&\n path.length > 0\n );\n};\nexport default isPathArray;\n","import type { AbsoluteArray } from \"../types\";\nimport isPathArray from \"./isPathArray\";\n\n/**\n * Iterates an array to check if it's a `pathArray`\n * with all absolute values.\n *\n * @param path the `pathArray` to be checked\n * @returns iteration result\n */\nconst isAbsoluteArray = (path: unknown): path is AbsoluteArray => {\n return (\n isPathArray(path) &&\n // `isPathArray` also checks if it's `Array`\n path.every(([x]) => x === x.toUpperCase())\n );\n};\nexport default isAbsoluteArray;\n","import type { NormalArray } from \"../types\";\nimport isAbsoluteArray from \"./isAbsoluteArray\";\n\n/**\n * Iterates an array to check if it's a `pathArray`\n * with all segments are in non-shorthand notation\n * with absolute values.\n *\n * @param {string | SVGPath.pathArray} path the `pathArray` to be checked\n * @returns {boolean} iteration result\n */\nconst isNormalizedArray = (path: unknown): path is NormalArray => {\n // `isAbsoluteArray` also checks if it's `Array`\n return isAbsoluteArray(path) && path.every(([pc]) => \"ACLMQZ\".includes(pc));\n};\nexport default isNormalizedArray;\n","import { CurveArray } from \"../types\";\nimport isNormalizedArray from \"./isNormalizedArray\";\n\n/**\n * Iterates an array to check if it's a `pathArray`\n * with all C (cubic bezier) segments.\n *\n * @param path the `Array` to be checked\n * @returns iteration result\n */\nconst isCurveArray = (path: unknown): path is CurveArray => {\n // `isPathArray` also checks if it's `Array`\n return isNormalizedArray(path) && path.every(([pc]) => \"MC\".includes(pc));\n};\nexport default isCurveArray;\n","import type { PathArray } from \"../types\";\nimport getPropertiesAtPoint from \"./getPropertiesAtPoint\";\nimport DISTANCE_EPSILON from \"./distanceEpsilon\";\n\n/**\n * Checks if a given point is in the stroke of a path.\n *\n * @param pathInput target path\n * @param point the given `{x,y}` point\n * @returns the query result\n */\nconst isPointInStroke = (\n pathInput: string | PathArray,\n point: { x: number; y: number },\n) => {\n const { distance } = getPropertiesAtPoint(pathInput, point);\n return Math.abs(distance) < DISTANCE_EPSILON; // 0.01 might be more permissive\n};\nexport default isPointInStroke;\n","import type { RelativeArray } from \"../types\";\nimport isPathArray from \"./isPathArray\";\n\n/**\n * Iterates an array to check if it's a `pathArray`\n * with relative values.\n *\n * @param path the `pathArray` to be checked\n * @returns iteration result\n */\nconst isRelativeArray = (path: unknown): path is RelativeArray => {\n return (\n isPathArray(path) &&\n // `isPathArray` checks if it's `Array`\n path.slice(1).every(([pc]) => pc === pc.toLowerCase())\n );\n};\nexport default isRelativeArray;\n","import scanSegment from \"../parser/scanSegment\";\nimport skipSpaces from \"../parser/skipSpaces\";\nimport PathParser from \"../parser/pathParser\";\n\n/**\n * Parses a path string value to determine its validity\n * then returns true if it's valid or false otherwise.\n *\n * @param pathString the path string to be parsed\n * @returns the path string validity\n */\nconst isValidPath = (pathString: string) => {\n if (typeof pathString !== \"string\" || !pathString.length) {\n return false;\n }\n\n const path = new PathParser(pathString);\n\n skipSpaces(path);\n\n while (path.index < path.max && !path.err.length) {\n scanSegment(path);\n }\n\n return !path.err.length && \"mM\".includes(path.segments[0][0]);\n};\nexport default isValidPath;\n","import type { ShapeParams } from \"../interface\";\n\n/**\n * Supported shapes and their specific parameters.\n */\nconst shapeParams: ShapeParams = {\n line: [\"x1\", \"y1\", \"x2\", \"y2\"],\n circle: [\"cx\", \"cy\", \"r\"],\n ellipse: [\"cx\", \"cy\", \"rx\", \"ry\"],\n rect: [\"width\", \"height\", \"x\", \"y\", \"rx\", \"ry\"],\n polygon: [\"points\"],\n polyline: [\"points\"],\n glyph: [\"d\"],\n};\n\nexport default shapeParams;\n","const isElement = (node?: unknown): node is Element =>\n node !== undefined && node !== null &&\n typeof node === \"object\" &&\n (node as Node).nodeType === 1; // ELEMENT_NODE\n\nexport default isElement;\n","import type {\n CircleAttr,\n EllipseAttr,\n GlyphAttr,\n LineAttr,\n PolyAttr,\n RectAttr,\n ShapeParams,\n} from \"../interface\";\nimport type { PathArray, PathSegment, ShapeOps, ShapeTypes } from \"../types\";\nimport error from \"../parser/error\";\nimport parsePathString from \"../parser/parsePathString\";\nimport shapeParams from \"./shapeParams\";\nimport isPathArray from \"./isPathArray\";\nimport isElement from \"./isElement\";\n\n/**\n * Returns a new `pathArray` from line attributes.\n *\n * @param attr shape configuration\n * @returns a new line `pathArray`\n */\nexport const getLinePath = (attr: LineAttr): PathArray => {\n let { x1, y1, x2, y2 } = attr;\n [x1, y1, x2, y2] = [x1, y1, x2, y2].map((a) => +a);\n return [\n [\"M\", x1, y1],\n [\"L\", x2, y2],\n ];\n};\n\n/**\n * Returns a new `pathArray` like from polyline/polygon attributes.\n *\n * @param attr shape configuration\n * @return a new polygon/polyline `pathArray`\n */\nexport const getPolyPath = (attr: PolyAttr): PathArray => {\n const pathArray = [] as PathSegment[];\n const points = (attr.points || \"\")\n .trim()\n .split(/[\\s|,]/)\n .map((a) => +a);\n\n let index = 0;\n while (index < points.length) {\n pathArray.push([index ? \"L\" : \"M\", points[index], points[index + 1]]);\n index += 2;\n }\n\n return (attr.type === \"polygon\"\n ? [...pathArray, [\"z\"]]\n : pathArray) as PathArray;\n};\n\n/**\n * Returns a new `pathArray` from circle attributes.\n *\n * @param attr shape configuration\n * @return a circle `pathArray`\n */\nexport const getCirclePath = (attr: CircleAttr): PathArray => {\n let { cx, cy, r } = attr;\n [cx, cy, r] = [cx, cy, r].map((a) => +a);\n\n return [\n [\"M\", cx - r, cy],\n [\"a\", r, r, 0, 1, 0, 2 * r, 0],\n [\"a\", r, r, 0, 1, 0, -2 * r, 0],\n ];\n};\n\n/**\n * Returns a new `pathArray` from ellipse attributes.\n *\n * @param attr shape configuration\n * @return an ellipse `pathArray`\n */\nexport const getEllipsePath = (attr: EllipseAttr): PathArray => {\n let { cx, cy } = attr;\n let rx = attr.rx || 0;\n let ry = attr.ry || rx;\n [cx, cy, rx, ry] = [cx, cy, rx, ry].map((a) => +a);\n\n return [\n [\"M\", cx - rx, cy],\n [\"a\", rx, ry, 0, 1, 0, 2 * rx, 0],\n [\"a\", rx, ry, 0, 1, 0, -2 * rx, 0],\n ];\n};\n\n/**\n * Returns a new `pathArray` like from rect attributes.\n *\n * @param attr object with properties above\n * @return a new `pathArray` from `` attributes\n */\nexport const getRectanglePath = (attr: RectAttr): PathArray => {\n const x = +attr.x || 0;\n const y = +attr.y || 0;\n const w = +attr.width;\n const h = +attr.height;\n let rx = +(attr.rx || 0);\n let ry = +(attr.ry || rx);\n\n // Validity checks from http://www.w3.org/TR/SVG/shapes.html#RectElement:\n if (rx || ry) {\n // rx = !rx ? ry : rx;\n // ry = !ry ? rx : ry;\n\n /* istanbul ignore else @preserve */\n if (rx * 2 > w) rx -= (rx * 2 - w) / 2;\n /* istanbul ignore else @preserve */\n if (ry * 2 > h) ry -= (ry * 2 - h) / 2;\n\n return [\n [\"M\", x + rx, y],\n [\"h\", w - rx * 2],\n [\"s\", rx, 0, rx, ry],\n [\"v\", h - ry * 2],\n [\"s\", 0, ry, -rx, ry],\n [\"h\", -w + rx * 2],\n [\"s\", -rx, 0, -rx, -ry],\n [\"v\", -h + ry * 2],\n [\"s\", 0, -ry, rx, -ry],\n ];\n }\n\n return [[\"M\", x, y], [\"h\", w], [\"v\", h], [\"H\", x], [\"Z\"]];\n};\n\n/**\n * Returns a new `pathArray` created from attributes of a ``, ``,\n * ``, ``, ``, ``, or ``.\n *\n * It can also work with an options object, see the type below\n * @see ShapeOps\n *\n * @param element target shape\n * @return the newly created `` element\n */\nconst shapeToPathArray = (\n element: ShapeTypes | ShapeOps,\n) => {\n const supportedShapes = Object.keys(shapeParams) as (keyof ShapeParams)[];\n const targetIsElement = isElement(element);\n const tagName = targetIsElement ? element.tagName : null;\n\n if (tagName && [...supportedShapes, \"path\"].every((s) => tagName !== s)) {\n throw TypeError(`${error}: \"${tagName}\" is not SVGElement`);\n }\n\n const type =\n (targetIsElement ? tagName : (element as ShapeOps).type) as ShapeOps[\n \"type\"\n ];\n const shapeAttrs = shapeParams[type] as string[];\n const config = { type } as Record;\n\n if (targetIsElement) {\n shapeAttrs.forEach((p) => {\n config[p] = element.getAttribute(p) as string;\n });\n } else {\n Object.assign(config, element);\n }\n\n // set d\n let pathArray = [] as unknown as PathArray;\n\n /* istanbul ignore else */\n if (type === \"circle\") {\n pathArray = getCirclePath(config as unknown as CircleAttr);\n } else if (type === \"ellipse\") {\n pathArray = getEllipsePath(config as unknown as EllipseAttr);\n } else if ([\"polyline\", \"polygon\"].includes(type)) {\n pathArray = getPolyPath(config as unknown as PolyAttr);\n } else if (type === \"rect\") {\n pathArray = getRectanglePath(config as unknown as RectAttr);\n } else if (type === \"line\") {\n pathArray = getLinePath(config as unknown as LineAttr);\n } else if ([\"glyph\", \"path\"].includes(type)) {\n pathArray = parsePathString(\n targetIsElement\n ? element.getAttribute(\"d\") || /* istanbul ignore next @preserve */ \"\"\n : (element as GlyphAttr).d || \"\",\n );\n }\n\n // replace target element\n if (isPathArray(pathArray) && pathArray.length) {\n return pathArray;\n }\n return false;\n};\nexport default shapeToPathArray;\n","import type { ShapeParams } from \"../interface\";\nimport type { ShapeOps, ShapeTypes } from \"../types\";\nimport pathToString from \"../convert/pathToString\";\nimport defaultOptions from \"../options/options\";\nimport error from \"../parser/error\";\nimport isValidPath from \"./isValidPath\";\nimport isElement from \"./isElement\";\nimport shapeToPathArray from \"./shapeToPathArray\";\nimport shapeParams from \"./shapeParams\";\n\n/**\n * Returns a new `` element created from attributes of a ``, ``,\n * ``, ``, ``, `` or ``. If `replace` parameter\n * is `true`, it will replace the target. The default `ownerDocument` is your current\n * `document` browser page, if you want to use in server-side using `jsdom`, you can\n * pass the `jsdom` `document` to `ownDocument`.\n *\n * It can also work with an options object, see the type below\n * @see ShapeOps\n *\n * The newly created `` element keeps all non-specific\n * attributes like `class`, `fill`, etc.\n *\n * @param element target shape\n * @param replace option to replace target\n * @param ownerDocument document for create element\n * @return the newly created `` element\n */\nconst shapeToPath = (\n element: ShapeTypes | ShapeOps,\n replace?: boolean,\n ownerDocument?: Document,\n): SVGPathElement | false => {\n const doc = ownerDocument || document;\n const supportedShapes = Object.keys(shapeParams) as (keyof ShapeParams)[];\n const targetIsElement = isElement(element);\n const tagName = targetIsElement ? element.tagName : null;\n\n if (tagName === \"path\") {\n throw TypeError(`${error}: \"${tagName}\" is already SVGPathElement`);\n }\n if (tagName && supportedShapes.every((s) => tagName !== s)) {\n throw TypeError(`${error}: \"${tagName}\" is not SVGElement`);\n }\n\n const path = doc.createElementNS(\"http://www.w3.org/2000/svg\", \"path\");\n const type =\n (targetIsElement ? tagName : (element as ShapeOps).type) as ShapeOps[\n \"type\"\n ];\n const shapeAttrs = shapeParams[type] as string[];\n const config = { type } as Record;\n\n // set d\n const round = defaultOptions.round as number;\n const pathArray = shapeToPathArray(element);\n const description = pathArray && pathArray.length\n ? pathToString(pathArray, round)\n : \"\";\n\n if (targetIsElement) {\n shapeAttrs.forEach((p) => {\n config[p] = element.getAttribute(p) as string;\n });\n // set no-specific shape attributes: fill, stroke, etc\n Object.values(element.attributes).forEach(({ name, value }) => {\n if (!shapeAttrs.includes(name)) path.setAttribute(name, value);\n });\n } else {\n Object.assign(config, element);\n // set no-specific shape attributes: fill, stroke, etc\n Object.keys(config).forEach((k) => {\n if (!shapeAttrs.includes(k) && k !== \"type\") {\n path.setAttribute(\n k.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`),\n config[k],\n );\n }\n });\n }\n\n // replace target element\n if (isValidPath(description)) {\n path.setAttribute(\"d\", description);\n if (replace && targetIsElement) {\n element.before(path, element);\n element.remove();\n }\n return path;\n }\n return false;\n};\n\nexport default shapeToPath;\n","import CSSMatrix from \"@thednp/dommatrix\";\n// import type { TransformObject } from '../interface';\nimport type { TransformObjectValues } from \"../types\";\n\n/**\n * Returns a transformation matrix to apply to `` elements.\n *\n * @see TransformObjectValues\n *\n * @param transform the `transformObject`\n * @returns a new transformation matrix\n */\nconst getSVGMatrix = (transform: TransformObjectValues): CSSMatrix => {\n let matrix = new CSSMatrix();\n const { origin } = transform;\n const [originX, originY] = origin as [number, number, number];\n const { translate } = transform;\n const { rotate } = transform;\n const { skew } = transform;\n const { scale } = transform;\n\n // set translate\n if (\n Array.isArray(translate) &&\n translate.length >= 2 &&\n translate.every((x) => !Number.isNaN(+x)) &&\n translate.some((x) => x !== 0)\n ) {\n matrix = matrix.translate(...(translate as [number, number, number?]));\n } else if (typeof translate === \"number\" && !Number.isNaN(translate)) {\n matrix = matrix.translate(translate);\n }\n\n if (rotate || skew || scale) {\n // set SVG transform-origin, always defined\n matrix = matrix.translate(originX, originY);\n\n // set rotation\n if (\n Array.isArray(rotate) &&\n rotate.length >= 2 &&\n rotate.every((x) => !Number.isNaN(+x)) &&\n rotate.some((x) => x !== 0)\n ) {\n matrix = matrix.rotate(...(rotate as [number, number, number?]));\n } else if (typeof rotate === \"number\" && !Number.isNaN(rotate)) {\n matrix = matrix.rotate(rotate);\n }\n\n // set skew(s)\n if (\n Array.isArray(skew) && skew.length === 2 && skew.every((x) =>\n !Number.isNaN(+x)\n ) && skew.some((x) => x !== 0)\n ) {\n matrix = skew[0] ? matrix.skewX(skew[0]) : matrix;\n matrix = skew[1] ? matrix.skewY(skew[1]) : matrix;\n } else if (typeof skew === \"number\" && !Number.isNaN(skew)) {\n matrix = matrix.skewX(skew);\n }\n\n // set scale\n if (\n Array.isArray(scale) && scale.length >= 2 && scale.every((x) =>\n !Number.isNaN(+x)\n ) && scale.some((x) => x !== 1)\n ) {\n matrix = matrix.scale(...(scale as [number, number, number?]));\n } else if (typeof scale === \"number\" && !Number.isNaN(scale)) {\n matrix = matrix.scale(scale);\n }\n // set SVG transform-origin\n matrix = matrix.translate(-originX, -originY);\n }\n\n return matrix;\n};\nexport default getSVGMatrix;\n","import defaultOptions from \"../options/options\";\nimport type { ParserParams } from \"../interface\";\nimport roundTo from \"../math/roundTo\";\nimport type {\n AbsoluteSegment,\n NormalSegment,\n PathCommand,\n ShortSegment,\n SSegment,\n TSegment,\n} from \"../types\";\n\n/**\n * Shorten a single segment of a `pathArray` object.\n *\n * @param segment the `absoluteSegment` object\n * @param normalSegment the `normalSegment` object\n * @param params the coordinates of the previous segment\n * @param prevCommand the path command of the previous segment\n * @returns the shortened segment\n */\nconst shortenSegment = (\n segment: AbsoluteSegment,\n normalSegment: NormalSegment,\n params: ParserParams,\n prevCommand: PathCommand,\n): ShortSegment => {\n const [pathCommand] = segment;\n const { round: defaultRound } = defaultOptions;\n const round = typeof defaultRound === \"number\"\n ? defaultRound\n : /* istanbul ignore next */ 4;\n const normalValues = normalSegment.slice(1) as number[];\n const { x1, y1, x2, y2, x, y } = params;\n const [nx, ny] = normalValues.slice(-2);\n const result = segment;\n\n if (!\"TQ\".includes(pathCommand)) {\n // optional but good to be cautious\n params.qx = null;\n params.qy = null;\n }\n\n if (pathCommand === \"L\") {\n if (roundTo(x, round) === roundTo(nx, round)) {\n return [\"V\", ny];\n } else if (roundTo(y, round) === roundTo(ny, round)) {\n return [\"H\", nx];\n }\n } else if (pathCommand === \"C\") {\n const [nx1, ny1] = normalValues;\n params.x1 = nx1;\n params.y1 = ny1;\n\n if (\n \"CS\".includes(prevCommand) &&\n ((roundTo(nx1, round) === roundTo(x1 * 2 - x2, round) &&\n roundTo(ny1, round) === roundTo(y1 * 2 - y2, round)) ||\n (roundTo(x1, round) === roundTo(x2 * 2 - x, round) &&\n roundTo(y1, round) === roundTo(y2 * 2 - y, round)))\n ) {\n return [\n \"S\",\n normalValues[2],\n normalValues[3],\n normalValues[4],\n normalValues[5],\n ] as SSegment;\n }\n } else if (pathCommand === \"Q\") {\n const [qx, qy] = normalValues;\n params.qx = qx;\n params.qy = qy;\n\n if (\n \"QT\".includes(prevCommand) &&\n roundTo(qx, round) === roundTo(x1 * 2 - x2, round) &&\n roundTo(qy, round) === roundTo(y1 * 2 - y2, round)\n ) {\n return [\"T\", normalValues[2], normalValues[3]] as TSegment;\n }\n }\n\n // ['V', 'H', 'S', 'T', 'Z'].includes(pathCommand)\n return result as ShortSegment;\n};\n\nexport default shortenSegment;\n","import type { PathCommand, PathSegment } from \"../types\";\nimport roundTo from \"../math/roundTo\";\n\nconst roundSegment = (\n segment: T,\n roundOption: number,\n) => {\n const values = (segment.slice(1) as number[]).map((n) =>\n roundTo(n, roundOption)\n );\n return [segment[0] as PathCommand | number].concat(values) as T;\n};\n\nexport default roundSegment;\n","import type { AbsoluteSegment, PathArray, PathCommand } from \"../types\";\nimport pathToAbsolute from \"../convert/pathToAbsolute\";\nimport shortenSegment from \"./shortenSegment\";\nimport paramsParser from \"../parser/paramsParser\";\nimport iterate from \"./iterate\";\nimport normalizeSegment from \"./normalizeSegment\";\nimport relativizeSegment from \"./relativizeSegment\";\nimport roundSegment from \"./roundSegment\";\n\n/**\n * Optimizes a `pathArray` object:\n * * convert segments to shorthand if possible\n * * select shortest segments from absolute and relative `pathArray`s\n *\n * @param pathInput a string or `pathArray`\n * @param roundOption the amount of decimals to round values to\n * @returns the optimized `pathArray`\n */\nconst optimizePath = (pathInput: PathArray, roundOption?: number) => {\n const path = pathToAbsolute(pathInput);\n // allow for ZERO decimals or use an aggressive value of 2\n const round = typeof roundOption === \"number\" && roundOption >= 0\n ? roundOption\n : /* istanbul ignore next @preserve */ 2;\n // this utility overrides the iterator params\n const optimParams = { ...paramsParser };\n\n const allPathCommands = [] as PathCommand[];\n let pathCommand = \"M\" as PathCommand;\n let prevCommand = \"Z\" as PathCommand;\n\n return iterate(path, (seg, i, lastX, lastY) => {\n optimParams.x = lastX;\n optimParams.y = lastY;\n const normalizedSegment = normalizeSegment(seg, optimParams);\n let result = seg;\n [pathCommand] = seg;\n\n // Save current path command\n allPathCommands[i] = pathCommand;\n if (i) {\n // Get previous path command for `shortenSegment`\n prevCommand = allPathCommands[i - 1];\n const shortSegment = shortenSegment(\n seg as AbsoluteSegment,\n normalizedSegment,\n optimParams,\n prevCommand,\n );\n const absSegment = roundSegment(shortSegment, round);\n const absString = absSegment.join(\"\");\n const relativeSegment = relativizeSegment(shortSegment, i, lastX, lastY);\n const relSegment = roundSegment(relativeSegment, round);\n const relString = relSegment.join(\"\");\n result = absString.length < relString.length ? absSegment : relSegment;\n }\n\n const seglen = normalizedSegment.length;\n optimParams.x1 = +normalizedSegment[seglen - 2];\n optimParams.y1 = +normalizedSegment[seglen - 1];\n optimParams.x2 = +normalizedSegment[seglen - 4] || optimParams.x1;\n optimParams.y2 = +normalizedSegment[seglen - 3] || optimParams.y1;\n\n return result;\n });\n};\n\nexport default optimizePath;\n","import CSSMatrix from \"@thednp/dommatrix\";\nimport { type PointTuple } from \"../types\";\n\n/**\n * Transforms a specified point using a matrix, returning a new\n * Tuple *Object* comprising of the transformed point.\n * Neither the matrix nor the original point are altered.\n *\n * @copyright thednp © 2021\n *\n * @param cssm CSSMatrix instance\n * @param v Tuple\n * @return the resulting Tuple\n */\nconst translatePoint = (\n cssm: CSSMatrix,\n v: [number, number, number, number],\n): [number, number, number, number] => {\n let m = CSSMatrix.Translate(v[0], v[1], v[2]);\n\n [, , , m.m44] = v;\n m = cssm.multiply(m);\n\n return [m.m41, m.m42, m.m43, m.m44];\n};\n\n/**\n * Returns the [x,y] projected coordinates for a given an [x,y] point\n * and an [x,y,z] perspective origin point.\n *\n * Equation found here =>\n * http://en.wikipedia.org/wiki/3D_projection#Diagram\n * Details =>\n * https://stackoverflow.com/questions/23792505/predicted-rendering-of-css-3d-transformed-pixel\n *\n * @param m the transformation matrix\n * @param point2D the initial [x,y] coordinates\n * @param origin the [x,y,z] transform origin\n * @returns the projected [x,y] coordinates\n */\nconst projection2d = (\n m: CSSMatrix,\n point2D: PointTuple,\n origin: [number, number, number],\n): PointTuple => {\n const [originX, originY, originZ] = origin;\n const [x, y, z] = translatePoint(m, [point2D[0], point2D[1], 0, 1]);\n\n const relativePositionX = x - originX;\n const relativePositionY = y - originY;\n const relativePositionZ = z - originZ;\n\n return [\n // protect against division by ZERO\n relativePositionX * (Math.abs(originZ) / Math.abs(relativePositionZ) || 1) +\n originX,\n relativePositionY * (Math.abs(originZ) / Math.abs(relativePositionZ) || 1) +\n originY,\n ];\n};\nexport default projection2d;\n","import type { CSegment, CurveArray, MSegment, PathCommand } from \"../types\";\n\n/**\n * Reverses all segments of a `pathArray`\n * which consists of only C (cubic-bezier) path commands.\n *\n * @param path the source `pathArray`\n * @returns the reversed `pathArray`\n */\nconst reverseCurve = (path: CurveArray) => {\n const rotatedCurve = path\n .slice(1)\n .map((x, i, curveOnly) =>\n !i\n ? path[0].slice(1).concat(x.slice(1) as number[])\n : curveOnly[i - 1].slice(-2).concat(x.slice(1))\n )\n .map((x) => x.map((_, i) => x[x.length - i - 2 * (1 - (i % 2))]))\n .reverse() as (MSegment | CSegment)[];\n\n return [[\"M\" as PathCommand | number].concat(rotatedCurve[0].slice(0, 2))]\n .concat(\n rotatedCurve.map((x) => [\"C\" as PathCommand | number].concat(x.slice(2))),\n ) as CurveArray;\n};\n\nexport default reverseCurve;\n","import type {\n ASegment,\n CSegment,\n HSegment,\n MSegment,\n PathArray,\n PathSegment,\n PointTuple,\n QSegment,\n SSegment,\n TSegment,\n VSegment,\n} from \"../types\";\nimport pathToAbsolute from \"../convert/pathToAbsolute\";\nimport normalizePath from \"./normalizePath\";\nimport iterate from \"./iterate\";\n\n/**\n * Reverses all segments of a `pathArray` and returns a new `pathArray` instance\n * with absolute values.\n *\n * @param pathInput the source `pathArray`\n * @returns the reversed `pathArray`\n */\nconst reversePath = (pathInput: PathArray) => {\n const absolutePath = pathToAbsolute(pathInput);\n const normalizedPath = normalizePath(absolutePath);\n const pLen = absolutePath.length;\n const isClosed = absolutePath[pLen - 1][0] === \"Z\";\n\n const reversedPath = iterate(absolutePath, (segment, i) => {\n const normalizedSegment = normalizedPath[i];\n const prevSeg = i && absolutePath[i - 1];\n const prevCommand = prevSeg && prevSeg[0];\n const nextSeg = absolutePath[i + 1];\n const nextCommand = nextSeg && nextSeg[0];\n const [pathCommand] = segment;\n const [x, y] = normalizedPath[i ? i - 1 : pLen - 1].slice(-2) as PointTuple;\n let result = segment;\n\n switch (pathCommand) {\n case \"M\":\n result = (isClosed ? [\"Z\"] : [pathCommand, x, y]) as PathSegment;\n break;\n case \"A\":\n result = [\n pathCommand,\n segment[1],\n segment[2],\n segment[3],\n segment[4],\n segment[5] === 1 ? 0 : 1,\n x,\n y,\n ] as ASegment;\n break;\n case \"C\":\n if (nextSeg && nextCommand === \"S\") {\n result = [\"S\", segment[1], segment[2], x, y] as SSegment;\n } else {\n result = [\n pathCommand,\n segment[3],\n segment[4],\n segment[1],\n segment[2],\n x,\n y,\n ] as CSegment;\n }\n break;\n case \"S\":\n if (\n prevCommand && \"CS\".includes(prevCommand) &&\n (!nextSeg || nextCommand !== \"S\")\n ) {\n result = [\n \"C\",\n normalizedSegment[3],\n normalizedSegment[4],\n normalizedSegment[1],\n normalizedSegment[2],\n x,\n y,\n ] as CSegment;\n } else {\n result = [\n pathCommand,\n normalizedSegment[1],\n normalizedSegment[2],\n x,\n y,\n ] as SSegment;\n }\n break;\n case \"Q\":\n if (nextSeg && nextCommand === \"T\") {\n result = [\"T\", x, y] as TSegment;\n } else {\n result = [pathCommand, segment[1], segment[2], x, y] as QSegment;\n }\n break;\n case \"T\":\n if (\n prevCommand && \"QT\".includes(prevCommand) &&\n (!nextSeg || nextCommand !== \"T\")\n ) {\n result = [\n \"Q\",\n normalizedSegment[1],\n normalizedSegment[2],\n x,\n y,\n ] as QSegment;\n } else {\n result = [pathCommand, x, y] as TSegment;\n }\n break;\n case \"Z\":\n result = [\"M\", x, y] as MSegment;\n break;\n case \"H\":\n result = [pathCommand, x] as HSegment;\n break;\n case \"V\":\n result = [pathCommand, y] as VSegment;\n break;\n default:\n result = [pathCommand as typeof pathCommand | number].concat(\n segment.slice(1, -2),\n x,\n y,\n ) as PathSegment;\n }\n\n return result;\n });\n\n return (\n isClosed\n ? reversedPath.reverse()\n : [reversedPath[0] as PathSegment].concat(reversedPath.slice(1).reverse())\n ) as PathArray;\n};\n\nexport default reversePath;\n","import type { PathArray } from \"../types\";\nimport defaultOptions from \"../options/options\";\nimport iterate from \"./iterate\";\nimport roundSegment from \"./roundSegment\";\n\n/**\n * Rounds the values of a `pathArray` instance to\n * a specified amount of decimals and returns it.\n *\n * @param path the source `pathArray`\n * @param roundOption the amount of decimals to round numbers to\n * @returns the resulted `pathArray` with rounded values\n */\nconst roundPath = (path: PathArray, roundOption?: number | \"off\") => {\n let { round } = defaultOptions;\n // allow for ZERO decimals\n round = roundOption === \"off\"\n ? roundOption\n : typeof roundOption === \"number\" && roundOption >= 0\n ? roundOption\n : typeof round === \"number\" && round >= 0\n ? round\n : /* istanbul ignore next @preserve */ \"off\";\n\n /* istanbul ignore else @preserve */\n if (round === \"off\") return path.slice(0) as PathArray;\n\n return iterate(path, (segment) => {\n return roundSegment(segment, round);\n });\n};\nexport default roundPath;\n","import midPoint from \"../math/midPoint\";\nimport type { CubicSegment, PointTuple } from \"../types\";\n\n/**\n * Split a cubic-bezier segment into two.\n *\n * @param pts the cubic-bezier parameters\n * @param ratio the cubic-bezier parameters\n * @return two new cubic-bezier segments\n */\nconst splitCubic = (\n pts: number[],\n ratio = 0.5,\n): [CubicSegment, CubicSegment] => {\n const t = ratio;\n const p0 = pts.slice(0, 2) as PointTuple;\n const p1 = pts.slice(2, 4) as PointTuple;\n const p2 = pts.slice(4, 6) as PointTuple;\n const p3 = pts.slice(6, 8) as PointTuple;\n const p4 = midPoint(p0, p1, t);\n const p5 = midPoint(p1, p2, t);\n const p6 = midPoint(p2, p3, t);\n const p7 = midPoint(p4, p5, t);\n const p8 = midPoint(p5, p6, t);\n const p9 = midPoint(p7, p8, t);\n\n return [\n [\"C\", p4[0], p4[1], p7[0], p7[1], p9[0], p9[1]],\n [\"C\", p8[0], p8[1], p6[0], p6[1], p3[0], p3[1]],\n ];\n};\nexport default splitCubic;\n","import paramsParser from \"../parser/paramsParser\";\nimport type {\n AbsoluteCommand,\n HSegment,\n MSegment,\n PathArray,\n PointTuple,\n RelativeCommand,\n VSegment,\n} from \"../types\";\n\n/**\n * Split a path into an `Array` of sub-path strings.\n *\n * In the process, values are converted to absolute\n * for visual consistency.\n *\n * @param pathInput the source `pathArray`\n * @return an array with all sub-path strings\n */\nconst splitPath = (pathInput: PathArray): PathArray[] => {\n const composite = [] as PathArray[];\n let path: PathArray;\n let pi = -1;\n let x = 0;\n let y = 0;\n let mx = 0;\n let my = 0;\n const params = { ...paramsParser };\n\n pathInput.forEach((seg) => {\n const [pathCommand] = seg;\n const absCommand = pathCommand.toUpperCase() as AbsoluteCommand;\n const relCommand = pathCommand.toLowerCase() as RelativeCommand;\n const isRelative = pathCommand === relCommand;\n const values = seg.slice(1) as number[];\n\n if (absCommand === \"M\") {\n pi += 1;\n [x, y] = values as PointTuple;\n x += isRelative ? params.x : 0;\n y += isRelative ? params.y : 0;\n mx = x;\n my = y;\n path = [(isRelative ? [absCommand, mx, my] : seg) as MSegment];\n } else {\n if (absCommand === \"Z\") {\n x = mx;\n y = my;\n } else if (absCommand === \"H\") {\n [, x] = seg as HSegment;\n x += isRelative ? params.x : /* istanbul ignore next @preserve */ 0;\n } else if (absCommand === \"V\") {\n [, y] = seg as VSegment;\n y += isRelative ? params.y : /* istanbul ignore next @preserve */ 0;\n } else {\n [x, y] = seg.slice(-2) as PointTuple;\n x += isRelative ? params.x : 0;\n y += isRelative ? params.y : 0;\n }\n path.push(seg);\n }\n\n params.x = x;\n params.y = y;\n composite[pi] = path;\n });\n\n return composite;\n};\nexport default splitPath;\n","import getSVGMatrix from \"./getSVGMatrix\";\nimport projection2d from \"./projection2d\";\nimport defaultOptions from \"../options/options\";\nimport type {\n AbsoluteArray,\n AbsoluteSegment,\n CSegment,\n LSegment,\n PathArray,\n TransformObjectValues,\n} from \"../types\";\nimport type { TransformObject } from \"../interface\";\nimport iterate from \"./iterate\";\nimport parsePathString from \"../parser/parsePathString\";\nimport absolutizeSegment from \"./absolutizeSegment\";\nimport arcToCubic from \"./arcToCubic\";\n\n/**\n * Apply a 2D / 3D transformation to a `pathArray` instance.\n *\n * Since *SVGElement* doesn't support 3D transformation, this function\n * creates a 2D projection of the element.\n *\n * @param path the `pathArray` to apply transformation\n * @param transform the transform functions `Object`\n * @returns the resulted `pathArray`\n */\nconst transformPath = (\n pathInput: PathArray | string,\n transform?: Partial,\n) => {\n // last x and y transformed values\n let x = 0;\n let y = 0;\n // new x and y transformed\n let lx = 0;\n let ly = 0;\n // segment params iteration index and length\n let j = 0;\n let jj = 0;\n let pathCommand = \"M\";\n // transform uses it's own set of params\n const path = parsePathString(pathInput);\n const transformProps = transform && Object.keys(transform);\n\n // when used as a static method, invalidate somehow\n if (!transform || (transformProps && !transformProps.length)) {\n return path.slice(0) as typeof path;\n }\n\n // transform origin is extremely important\n if (!transform.origin) {\n Object.assign(transform, { origin: defaultOptions.origin });\n }\n const origin = transform.origin as [number, number, number];\n const matrixInstance = getSVGMatrix(transform as TransformObjectValues);\n\n if (matrixInstance.isIdentity) return path.slice(0) as typeof path;\n\n return iterate(path, (seg, index, lastX, lastY) => {\n [pathCommand] = seg;\n const absCommand = pathCommand.toUpperCase();\n const isRelative = absCommand !== pathCommand;\n const absoluteSegment = isRelative\n ? absolutizeSegment(seg, index, lastX, lastY)\n : (seg.slice(0) as AbsoluteSegment);\n\n let result = absCommand === \"A\"\n // ? segmentToCubic(absoluteSegment, transformParams)\n ? ([\"C\" as string | number].concat(\n arcToCubic(\n lastX,\n lastY,\n absoluteSegment[1] as number,\n absoluteSegment[2] as number,\n absoluteSegment[3] as number,\n absoluteSegment[4] as number,\n absoluteSegment[5] as number,\n absoluteSegment[6] as number,\n absoluteSegment[7] as number,\n ),\n ) as CSegment)\n : absCommand === \"V\"\n ? ([\"L\", lastX, absoluteSegment[1]] as LSegment)\n : absCommand === \"H\"\n ? ([\"L\", absoluteSegment[1], lastY] as LSegment)\n : absoluteSegment;\n\n // update pathCommand\n pathCommand = result[0];\n const isLongArc = pathCommand === \"C\" && result.length > 7;\n const tempSegment =\n (isLongArc ? result.slice(0, 7) : result.slice(0)) as AbsoluteSegment;\n\n if (isLongArc) {\n path.splice(\n index + 1,\n 0,\n [\"C\" as typeof pathCommand | number].concat(\n result.slice(7),\n ) as CSegment,\n );\n result = tempSegment as CSegment;\n }\n\n if (pathCommand === \"L\") {\n [lx, ly] = projection2d(matrixInstance, [\n (result as LSegment)[1],\n (result as LSegment)[2],\n ], origin);\n\n /* istanbul ignore else @preserve */\n if (x !== lx && y !== ly) {\n result = [\"L\", lx, ly];\n } else if (y === ly) {\n result = [\"H\", lx];\n } else if (x === lx) {\n result = [\"V\", ly];\n }\n } else {\n for (j = 1, jj = result.length; j < jj; j += 2) {\n [lx, ly] = projection2d(\n matrixInstance,\n [+result[j], +result[j + 1]],\n origin,\n );\n result[j] = lx;\n result[j + 1] = ly;\n }\n }\n // now update x and y\n x = lx;\n y = ly;\n\n return result;\n });\n};\n\nexport default transformPath;\n"],"names":["Z","z","s","t","e","p","$","E","P","y","g","n","i","r","a","l","m","h","c","u","w","o","A","M","b","X","O","d","x","Y","F","T","k","I","v","R","D","N","midPoint","ax","ay","bx","by","distanceSquareRoot","getLineLength","x1","y1","x2","y2","getPointAtLineLength","distance","point","length","getLineBBox","min","max","arcLength","rx","ry","theta","halfTheta","sinHalfTheta","cosHalfTheta","term1","term2","arcPoint","cx","cy","alpha","sin","cos","cosA","sinA","angleBetween","v0","v1","v0x","v0y","v1x","v1y","getArcProps","RX","RY","angle","LAF","SF","abs","sqrt","PI","xRotRad","dx","dy","transformedPoint","radiiCheck","cSquareNumerator","cSquareRootDenom","cRadicand","cCoef","transformedCenter","center","startVector","startAngle","endVector","sweepAngle","endAngle","getArcLength","getPointAtArcLength","ellipseComponentX","ellipseComponentY","getArcBBox","deltaAngle","tan","atan2","tangent","angle1","angle2","angle3","angle4","xArray","yArray","xMin","xMax","yMin","yMax","angleAfterStart","pP2","angleBeforeEnd","pP3","p1","p2","p4","p3","Tvalues","Cvalues","deriveBezier","points","dpoints","list","j","computeBezier","order","mt","mt2","t2","calculateBezier","derivativeFn","bezierLength","len","sum","getBezierLength","curve","idx","step","CBEZIER_MINMAX_EPSILON","minmaxQ","cp","v2","minmaxC","cp1","cp2","K","S","L","Q","getPointAtCubicSegmentLength","c1x","c1y","c2x","c2y","t1","getCubicLength","getPointAtCubicLength","distanceIsNumber","currentLength","getCubicBBox","cxMinMax","cyMinMax","getPointAtQuadSegmentLength","getQuadLength","getPointAtQuadLength","getQuadBBox","polygonArea","polygon","area","polygonLength","paramsCount","finalizeSegment","path","pathCommand","relativeCommand","data","error","scanFlag","index","pathValue","code","isDigit","invalidPathValue","scanParam","start","zeroFirst","hasCeiling","hasDecimal","hasDot","ch","isSpace","skipSpaces","isPathCommand","isDigitStart","isArcCommand","isMoveCommand","scanSegment","segments","cmdCode","reqParams","paramCounts","lastSegment","_a","PathParser","pathString","parsePathString","pathInput","absolutizeSegment","segment","lastX","lastY","absCommand","absValues","seglen","iterate","iterator","pathLen","isRelative","mx","my","segLen","iteratorResult","pathToAbsolute","relativizeSegment","relCommand","relValues","pathToRelative","rotateVector","rad","arcToCubic","X1","Y1","X2","Y2","recursive","d120","res","xy","f1","f2","rx2","ry2","df","f2old","x2old","y2old","c1","s1","c2","s2","hx","hy","m1","m2","m3","m4","newres","ii","quadToCubic","qx","qy","r13","r23","lineToCubic","segmentToCubic","params","values","px1","py1","px","py","normalizeSegment","px2","py2","nqx","nqy","paramsParser","pathToCurve","seg","normalSegment","result","defaultOptions","roundTo","round","pow","pathToString","roundOption","valLen","DISTANCE_EPSILON","normalizePath","_","getPointAtLength","isM","POINT","totalLength","getTotalLength","paramX1","paramY1","paramX2","paramY2","paramQX","paramQY","absoluteSegment","cp1x","cp1y","getPropertiesAtLength","pathArray","pathTemp","pathLength","lengthAtSegment","getPropertiesAtPoint","normalPath","distanceTo","precision","scan","closest","scanDistance","bestLength","bestDistance","scanLength","before","after","beforeLength","afterLength","beforeDistance","afterDistance","getClosestPoint","getCubicSegArea","getPathArea","getDrawDirection","getPathBBox","minX","minY","maxX","maxY","width","height","getSegmentAtLength","getSegmentOfPoint","isPathArray","lk","isAbsoluteArray","isNormalizedArray","pc","isCurveArray","isPointInStroke","isRelativeArray","isValidPath","shapeParams","isElement","node","getLinePath","attr","getPolyPath","getCirclePath","getEllipsePath","getRectanglePath","shapeToPathArray","element","supportedShapes","targetIsElement","tagName","type","shapeAttrs","config","shapeToPath","replace","ownerDocument","doc","description","name","value","getSVGMatrix","transform","matrix","CSSMatrix","origin","originX","originY","translate","rotate","skew","scale","shortenSegment","prevCommand","defaultRound","normalValues","nx","ny","nx1","ny1","roundSegment","optimizePath","optimParams","allPathCommands","normalizedSegment","shortSegment","absSegment","absString","relativeSegment","relSegment","relString","translatePoint","cssm","projection2d","point2D","originZ","relativePositionX","relativePositionY","relativePositionZ","reverseCurve","rotatedCurve","curveOnly","reversePath","absolutePath","normalizedPath","pLen","isClosed","reversedPath","prevSeg","nextSeg","nextCommand","roundPath","splitCubic","pts","ratio","p0","p5","p6","p7","p8","p9","splitPath","composite","pi","transformPath","lx","ly","jj","transformProps","matrixInstance","isLongArc","tempSegment"],"mappings":"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","x_google_ignoreList":[0]} \ No newline at end of file +{"version":3,"sources":["../../src/util.ts","../../src/math/arcTools.ts","../../src/math/lineTools.ts","../../src/math/midPoint.ts","../../src/math/distanceSquareRoot.ts","../../src/math/bezier.ts","../../src/math/cubicTools.ts","../../src/math/quadTools.ts","../../src/math/polygonTools.ts","../../src/parser/paramsCount.ts","../../src/parser/finalizeSegment.ts","../../src/parser/error.ts","../../src/parser/scanFlag.ts","../../src/parser/isDigit.ts","../../src/parser/invalidPathValue.ts","../../src/parser/scanParam.ts","../../src/parser/isSpace.ts","../../src/parser/skipSpaces.ts","../../src/parser/isPathCommand.ts","../../src/parser/isDigitStart.ts","../../src/parser/isArcCommand.ts","../../src/parser/isMoveCommand.ts","../../src/parser/scanSegment.ts","../../src/parser/pathParser.ts","../../src/parser/parsePathString.ts","../../src/process/absolutizeSegment.ts","../../src/process/iterate.ts","../../src/convert/pathToAbsolute.ts","../../src/process/relativizeSegment.ts","../../src/convert/pathToRelative.ts","../../src/math/rotateVector.ts","../../src/process/arcToCubic.ts","../../src/process/quadToCubic.ts","../../src/process/lineToCubic.ts","../../src/process/segmentToCubic.ts","../../src/process/normalizeSegment.ts","../../src/parser/paramsParser.ts","../../src/convert/pathToCurve.ts","../../src/options/options.ts","../../src/math/roundTo.ts","../../src/convert/pathToString.ts","../../src/util/distanceEpsilon.ts","../../src/process/normalizePath.ts","../../src/util/getPointAtLength.ts","../../src/util/getTotalLength.ts","../../src/util/getPropertiesAtLength.ts","../../src/util/getPropertiesAtPoint.ts","../../src/util/getClosestPoint.ts","../../src/util/getPathArea.ts","../../src/util/getDrawDirection.ts","../../src/util/getPathBBox.ts","../../src/util/getSegmentAtLength.ts","../../src/util/getSegmentOfPoint.ts","../../src/util/isPathArray.ts","../../src/util/isAbsoluteArray.ts","../../src/util/isNormalizedArray.ts","../../src/util/isCurveArray.ts","../../src/util/isPointInStroke.ts","../../src/util/isRelativeArray.ts","../../src/util/isValidPath.ts","../../src/util/shapeParams.ts","../../src/util/isElement.ts","../../src/util/shapeToPathArray.ts","../../src/util/shapeToPath.ts","../../src/process/getSVGMatrix.ts","../../src/process/shortenSegment.ts","../../src/process/roundSegment.ts","../../src/process/optimizePath.ts","../../src/process/projection2d.ts","../../src/process/reverseCurve.ts","../../src/process/reversePath.ts","../../src/process/roundPath.ts","../../src/process/splitCubic.ts","../../src/process/splitPath.ts","../../src/process/transformPath.ts"],"sourcesContent":["export { default as CSSMatrix } from \"@thednp/dommatrix\";\n// export type { PathArray, PointTuple, TransformObjectValues } from \"./types\";\n// export type { Options, TransformEntries, TransformObject } from \"./interface\";\n// export * from \"./types\";\n// export * from \"./interface\";\n\nimport * as arcTools from \"./math/arcTools\";\nimport * as bezierTools from \"./math/bezier\";\nimport * as cubicTools from \"./math/cubicTools\";\nimport * as lineTools from \"./math/lineTools\";\nimport * as quadTools from \"./math/quadTools\";\nimport * as polygonTools from \"./math/polygonTools\";\nexport { arcTools, bezierTools, cubicTools, lineTools, quadTools, polygonTools };\n\n// export * from \"./math/arcTools\";\n// export * from \"./math/bezier\";\n// export * from \"./math/cubicTools\";\n// export * from \"./math/lineTools\";\n// export * from \"./math/quadTools\";\n// export * from \"./math/polygonTools\";\n\nexport { default as pathToAbsolute } from \"./convert/pathToAbsolute\";\nexport { default as pathToRelative } from \"./convert/pathToRelative\";\nexport { default as pathToCurve } from \"./convert/pathToCurve\";\nexport { default as pathToString } from \"./convert/pathToString\";\n\nexport { default as distanceSquareRoot } from \"./math/distanceSquareRoot\";\nexport { default as midPoint } from \"./math/midPoint\";\nexport { default as rotateVector } from \"./math/rotateVector\";\nexport { default as roundTo } from \"./math/roundTo\";\n\nexport { default as parsePathString } from \"./parser/parsePathString\";\nexport { default as finalizeSegment } from \"./parser/finalizeSegment\";\nexport { default as invalidPathValue } from \"./parser/invalidPathValue\";\nexport { default as isArcCommand } from \"./parser/isArcCommand\";\nexport { default as isDigit } from \"./parser/isDigit\";\nexport { default as isDigitStart } from \"./parser/isDigitStart\";\nexport { default as isMoveCommand } from \"./parser/isMoveCommand\";\nexport { default as isPathCommand } from \"./parser/isPathCommand\";\nexport { default as isSpace } from \"./parser/isSpace\";\nexport { default as paramsCount } from \"./parser/paramsCount\";\nexport { default as paramsParser } from \"./parser/paramsParser\";\nexport { default as pathParser } from \"./parser/pathParser\";\nexport { default as scanFlag } from \"./parser/scanFlag\";\nexport { default as scanParam } from \"./parser/scanParam\";\nexport { default as scanSegment } from \"./parser/scanSegment\";\nexport { default as skipSpaces } from \"./parser/skipSpaces\";\n\nexport { default as distanceEpsilon } from \"./util/distanceEpsilon\";\nexport { default as getClosestPoint } from \"./util/getClosestPoint\";\nexport { default as getDrawDirection } from \"./util/getDrawDirection\";\nexport { default as getPathArea } from \"./util/getPathArea\";\nexport { default as getPathBBox } from \"./util/getPathBBox\";\nexport { default as getPointAtLength } from \"./util/getPointAtLength\";\nexport { default as getPropertiesAtLength } from \"./util/getPropertiesAtLength\";\nexport { default as getPropertiesAtPoint } from \"./util/getPropertiesAtPoint\";\nexport { default as getSegmentAtLength } from \"./util/getSegmentAtLength\";\nexport { default as getSegmentOfPoint } from \"./util/getSegmentOfPoint\";\nexport { default as getTotalLength } from \"./util/getTotalLength\";\n\nexport { default as isAbsoluteArray } from \"./util/isAbsoluteArray\";\nexport { default as isCurveArray } from \"./util/isCurveArray\";\nexport { default as isNormalizedArray } from \"./util/isNormalizedArray\";\nexport { default as isPathArray } from \"./util/isPathArray\";\nexport { default as isPointInStroke } from \"./util/isPointInStroke\";\nexport { default as isRelativeArray } from \"./util/isRelativeArray\";\nexport { default as isValidPath } from \"./util/isValidPath\";\nexport { default as shapeParams } from \"./util/shapeParams\";\nexport { default as shapeToPath } from \"./util/shapeToPath\";\nexport { default as shapeToPathArray } from \"./util/shapeToPathArray\";\n\nexport { default as absolutizeSegment } from \"./process/absolutizeSegment\";\nexport { default as arcToCubic } from \"./process/arcToCubic\";\nexport { default as getSVGMatrix } from \"./process/getSVGMatrix\";\nexport { default as iterate } from \"./process/iterate\";\nexport { default as lineToCubic } from \"./process/lineToCubic\";\nexport { default as normalizePath } from \"./process/normalizePath\";\nexport { default as normalizeSegment } from \"./process/normalizeSegment\";\nexport { default as optimizePath } from \"./process/optimizePath\";\nexport { default as projection2d } from \"./process/projection2d\";\nexport { default as quadToCubic } from \"./process/quadToCubic\";\nexport { default as relativizeSegment } from \"./process/relativizeSegment\";\nexport { default as reverseCurve } from \"./process/reverseCurve\";\nexport { default as reversePath } from \"./process/reversePath\";\nexport { default as roundPath } from \"./process/roundPath\";\nexport { default as roundSegment } from \"./process/roundSegment\";\nexport { default as segmentToCubic } from \"./process/segmentToCubic\";\nexport { default as shortenSegment } from \"./process/shortenSegment\";\nexport { default as splitCubic } from \"./process/splitCubic\";\nexport { default as splitPath } from \"./process/splitPath\";\nexport { default as transformPath } from \"./process/transformPath\";\n","import { getPointAtLineLength } from \"./lineTools\";\nimport type { Point, PointTuple } from \"../types\";\n\n/**\n * Returns the Arc segment length.\n * @param rx radius along X axis\n * @param ry radius along Y axis\n * @param theta the angle in radians\n * @returns the arc length\n */\nconst arcLength = (rx: number, ry: number, theta: number) => {\n const halfTheta = theta / 2;\n const sinHalfTheta = Math.sin(halfTheta);\n const cosHalfTheta = Math.cos(halfTheta);\n const term1 = rx ** 2 * sinHalfTheta ** 2;\n const term2 = ry ** 2 * cosHalfTheta ** 2;\n const length = Math.sqrt(term1 + term2) * theta;\n return Math.abs(length);\n};\n\n/**\n * Find point on ellipse at given angle around ellipse (theta);\n * @param cx the center X\n * @param cy the center Y\n * @param rx the radius X\n * @param ry the radius Y\n * @param alpha the arc rotation angle in radians\n * @param theta the arc sweep angle in radians\n * @returns a point around ellipse at given angle\n */\nconst arcPoint = (\n cx: number,\n cy: number,\n rx: number,\n ry: number,\n alpha: number,\n theta: number,\n) => {\n const { sin, cos } = Math;\n // theta is angle in radians around arc\n // alpha is angle of rotation of ellipse in radians\n const cosA = cos(alpha);\n const sinA = sin(alpha);\n const x = rx * cos(theta);\n const y = ry * sin(theta);\n\n return [cx + cosA * x - sinA * y, cy + sinA * x + cosA * y] as PointTuple;\n};\n\n/**\n * Returns the angle between two points.\n * @param v0 starting point\n * @param v1 ending point\n * @returns the angle in radian\n */\nconst angleBetween = (v0: Point, v1: Point) => {\n const { x: v0x, y: v0y } = v0;\n const { x: v1x, y: v1y } = v1;\n const p = v0x * v1x + v0y * v1y;\n const n = Math.sqrt((v0x ** 2 + v0y ** 2) * (v1x ** 2 + v1y ** 2));\n const sign = v0x * v1y - v0y * v1x < 0 ? -1 : 1;\n return sign * Math.acos(p / n);\n};\n\n/**\n * Returns the following properties for an Arc segment: center, start angle,\n * end angle, and radiuses on X and Y axis.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param RX the radius on X axis\n * @param RY the radius on Y axis\n * @param angle the ellipse rotation in degrees\n * @param LAF the large arc flag\n * @param SF the sweep flag\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns properties specific to Arc segments\n */\nconst getArcProps = (\n x1: number,\n y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n x: number,\n y: number,\n) => {\n const { abs, sin, cos, sqrt, PI } = Math;\n let rx = abs(RX);\n let ry = abs(RY);\n const xRot = ((angle % 360) + 360) % 360;\n const xRotRad = xRot * (PI / 180);\n\n // istanbul ignore next @preserve\n if (x1 === x && y1 === y) {\n return {\n rx,\n ry,\n startAngle: 0,\n endAngle: 0,\n center: { x, y },\n };\n }\n\n if (rx === 0 || ry === 0) {\n return {\n rx,\n ry,\n startAngle: 0,\n endAngle: 0,\n center: { x: (x + x1) / 2, y: (y + y1) / 2 },\n };\n }\n\n const dx = (x1 - x) / 2;\n const dy = (y1 - y) / 2;\n\n const transformedPoint = {\n x: cos(xRotRad) * dx + sin(xRotRad) * dy,\n y: -sin(xRotRad) * dx + cos(xRotRad) * dy,\n };\n\n const radiiCheck = transformedPoint.x ** 2 / rx ** 2 +\n transformedPoint.y ** 2 / ry ** 2;\n\n if (radiiCheck > 1) {\n rx *= sqrt(radiiCheck);\n ry *= sqrt(radiiCheck);\n }\n\n const cSquareNumerator = rx ** 2 * ry ** 2 -\n rx ** 2 * transformedPoint.y ** 2 - ry ** 2 * transformedPoint.x ** 2;\n const cSquareRootDenom = rx ** 2 * transformedPoint.y ** 2 +\n ry ** 2 * transformedPoint.x ** 2;\n\n let cRadicand = cSquareNumerator / cSquareRootDenom;\n /* istanbul ignore next @preserve */\n cRadicand = cRadicand < 0 ? 0 : cRadicand;\n const cCoef = (LAF !== SF ? 1 : -1) * sqrt(cRadicand);\n const transformedCenter = {\n x: cCoef * ((rx * transformedPoint.y) / ry),\n y: cCoef * (-(ry * transformedPoint.x) / rx),\n };\n\n const center = {\n x: cos(xRotRad) * transformedCenter.x - sin(xRotRad) * transformedCenter.y +\n (x1 + x) / 2,\n y: sin(xRotRad) * transformedCenter.x + cos(xRotRad) * transformedCenter.y +\n (y1 + y) / 2,\n };\n\n const startVector = {\n x: (transformedPoint.x - transformedCenter.x) / rx,\n y: (transformedPoint.y - transformedCenter.y) / ry,\n };\n\n const startAngle = angleBetween({ x: 1, y: 0 }, startVector);\n\n const endVector = {\n x: (-transformedPoint.x - transformedCenter.x) / rx,\n y: (-transformedPoint.y - transformedCenter.y) / ry,\n };\n\n let sweepAngle = angleBetween(startVector, endVector);\n if (!SF && sweepAngle > 0) {\n sweepAngle -= 2 * PI;\n } else if (SF && sweepAngle < 0) {\n sweepAngle += 2 * PI;\n }\n sweepAngle %= 2 * PI;\n\n const endAngle = startAngle + sweepAngle;\n\n // point.ellipticalArcStartAngle = startAngle;\n // point.ellipticalArcEndAngle = startAngle + sweepAngle;\n // point.ellipticalArcAngle = alpha;\n\n // point.ellipticalArcCenter = center;\n // point.resultantRx = rx;\n // point.resultantRy = ry;\n\n return {\n center,\n startAngle,\n endAngle,\n rx,\n ry,\n };\n};\n\n/**\n * Returns the length of an Arc segment.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the length of the Arc segment\n */\nconst getArcLength = (\n x1: number,\n y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n x: number,\n y: number,\n) => {\n const { rx, ry, startAngle, endAngle } = getArcProps(\n x1,\n y1,\n RX,\n RY,\n angle,\n LAF,\n SF,\n x,\n y,\n );\n return arcLength(rx, ry, endAngle - startAngle);\n};\n\n/**\n * Returns a point along an Arc segment at a given distance.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param RX the radius on X axis\n * @param RY the radius on Y axis\n * @param angle the ellipse rotation in degrees\n * @param LAF the large arc flag\n * @param SF the sweep flag\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance a [0-1] ratio\n * @returns a point along the Arc segment\n */\nconst getPointAtArcLength = (\n x1: number,\n y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n x: number,\n y: number,\n distance?: number,\n) => {\n let point = { x: x1, y: y1 };\n const { center, rx, ry, startAngle, endAngle } = getArcProps(\n x1,\n y1,\n RX,\n RY,\n angle,\n LAF,\n SF,\n x,\n y,\n );\n\n /* istanbul ignore else @preserve */\n if (typeof distance === \"number\") {\n const length = arcLength(rx, ry, endAngle - startAngle);\n if (distance <= 0) {\n point = { x: x1, y: y1 };\n } else if (distance >= length) {\n point = { x, y };\n } else {\n /* istanbul ignore next @preserve */\n if (x1 === x && y1 === y) {\n return { x, y };\n }\n /* istanbul ignore next @preserve */\n if (rx === 0 || ry === 0) {\n return getPointAtLineLength(x1, y1, x, y, distance);\n }\n const { PI, cos, sin } = Math;\n const sweepAngle = endAngle - startAngle;\n const xRot = ((angle % 360) + 360) % 360;\n const xRotRad = xRot * (PI / 180);\n const alpha = startAngle + sweepAngle * (distance / length);\n const ellipseComponentX = rx * cos(alpha);\n const ellipseComponentY = ry * sin(alpha);\n\n point = {\n x: cos(xRotRad) * ellipseComponentX - sin(xRotRad) * ellipseComponentY +\n center.x,\n y: sin(xRotRad) * ellipseComponentX + cos(xRotRad) * ellipseComponentY +\n center.y,\n };\n }\n }\n\n return point;\n};\n\n/**\n * Returns the extrema for an Arc segment in the following format:\n * [MIN_X, MIN_Y, MAX_X, MAX_Y]\n *\n * @see https://github.com/herrstrietzel/svg-pathdata-getbbox\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param RX the radius on X axis\n * @param RY the radius on Y axis\n * @param angle the ellipse rotation in degrees\n * @param LAF the large arc flag\n * @param SF the sweep flag\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the extrema of the Arc segment\n */\nconst getArcBBox = (\n x1: number,\n y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n x: number,\n y: number,\n) => {\n const { center, rx, ry, startAngle, endAngle } = getArcProps(\n x1,\n y1,\n RX,\n RY,\n angle,\n LAF,\n SF,\n x,\n y,\n );\n const deltaAngle = endAngle - startAngle;\n const { min, max, tan, atan2, PI } = Math;\n\n // circle/elipse center coordinates\n const { x: cx, y: cy } = center;\n\n // rotation to radians\n const alpha = (angle * PI) / 180;\n const tangent = tan(alpha);\n\n /**\n * find min/max from zeroes of directional derivative along x and y\n * along x axis\n */\n const theta = atan2(-ry * tangent, rx);\n const angle1 = theta;\n const angle2 = theta + PI;\n const angle3 = atan2(ry, rx * tangent);\n const angle4 = angle3 + PI;\n const xArray = [x];\n const yArray = [y];\n\n // inner bounding box\n let xMin = min(x1, x);\n let xMax = max(x1, x);\n let yMin = min(y1, y);\n let yMax = max(y1, y);\n\n // on path point close after start\n const angleAfterStart = endAngle - deltaAngle * 0.00001;\n const pP2 = arcPoint(cx, cy, rx, ry, alpha, angleAfterStart);\n\n // on path point close before end\n const angleBeforeEnd = endAngle - deltaAngle * 0.99999;\n const pP3 = arcPoint(cx, cy, rx, ry, alpha, angleBeforeEnd);\n\n /**\n * expected extremes\n * if leaving inner bounding box\n * (between segment start and end point)\n * otherwise exclude elliptic extreme points\n */\n\n // right\n if (pP2[0] > xMax || pP3[0] > xMax) {\n // get point for this theta\n const p1 = arcPoint(cx, cy, rx, ry, alpha, angle1);\n xArray.push(p1[0]);\n yArray.push(p1[1]);\n }\n\n // left\n if (pP2[0] < xMin || pP3[0] < xMin) {\n // get anti-symmetric point\n const p2 = arcPoint(cx, cy, rx, ry, alpha, angle2);\n xArray.push(p2[0]);\n yArray.push(p2[1]);\n }\n\n // top\n if (pP2[1] < yMin || pP3[1] < yMin) {\n // get anti-symmetric point\n const p4 = arcPoint(cx, cy, rx, ry, alpha, angle4);\n xArray.push(p4[0]);\n yArray.push(p4[1]);\n }\n\n // bottom\n if (pP2[1] > yMax || pP3[1] > yMax) {\n // get point for this theta\n const p3 = arcPoint(cx, cy, rx, ry, alpha, angle3);\n xArray.push(p3[0]);\n yArray.push(p3[1]);\n }\n\n xMin = min.apply([], xArray);\n yMin = min.apply([], yArray);\n xMax = max.apply([], xArray);\n yMax = max.apply([], yArray);\n\n return [xMin, yMin, xMax, yMax] as [number, number, number, number];\n};\n\nexport {\n angleBetween,\n arcLength,\n arcPoint,\n getArcBBox,\n getArcLength,\n getArcProps,\n getPointAtArcLength,\n};\n","import midPoint from \"./midPoint\";\nimport distanceSquareRoot from \"./distanceSquareRoot\";\n\n/**\n * Returns length for line segments (MoveTo, LineTo).\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the line segment length\n */\nconst getLineLength = (x1: number, y1: number, x2: number, y2: number) => {\n return distanceSquareRoot([x1, y1], [x2, y2]);\n};\n\n/**\n * Returns a point along the line segments (MoveTo, LineTo).\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance the distance to point in [0-1] range\n * @returns the point at length\n */\nconst getPointAtLineLength = (\n x1: number,\n y1: number,\n x2: number,\n y2: number,\n distance?: number,\n) => {\n let point = { x: x1, y: y1 };\n\n /* istanbul ignore else @preserve */\n if (typeof distance === \"number\") {\n const length = distanceSquareRoot([x1, y1], [x2, y2]);\n if (distance <= 0) {\n point = { x: x1, y: y1 };\n } else if (distance >= length) {\n point = { x: x2, y: y2 };\n } else {\n const [x, y] = midPoint([x1, y1], [x2, y2], distance / length);\n point = { x, y };\n }\n }\n return point;\n};\n\n/**\n * Returns bounding box for line segments (MoveTo, LineTo).\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance the distance to point in [0-1] range\n * @returns the extrema for line segments\n */\nconst getLineBBox = (x1: number, y1: number, x2: number, y2: number) => {\n const { min, max } = Math;\n\n return [min(x1, x2), min(y1, y2), max(x1, x2), max(y1, y2)] as [\n number,\n number,\n number,\n number,\n ];\n};\n\nexport { getLineBBox, getLineLength, getPointAtLineLength };\n","import { PointTuple } from \"../types\";\n\n/**\n * Returns the coordinates of a specified distance\n * ratio between two points.\n *\n * @param a the first point coordinates\n * @param b the second point coordinates\n * @param t the ratio\n * @returns the midpoint coordinates\n */\nconst midPoint = (a: PointTuple, b: PointTuple, t: number): PointTuple => {\n const [ax, ay] = a;\n const [bx, by] = b;\n return [ax + (bx - ax) * t, ay + (by - ay) * t];\n};\n\nexport default midPoint;\n","import { type PointTuple } from \"../types\";\n\n/**\n * Returns the square root of the distance\n * between two given points.\n *\n * @param a the first point coordinates\n * @param b the second point coordinates\n * @returns the distance value\n */\nconst distanceSquareRoot = (a: PointTuple, b: PointTuple) => {\n return Math.sqrt(\n (a[0] - b[0]) * (a[0] - b[0]) + (a[1] - b[1]) * (a[1] - b[1]),\n );\n};\n\nexport default distanceSquareRoot;\n","import type {\n CubicCoordinates,\n CubicPoints,\n DeriveCallback,\n DerivedCubicPoints,\n DerivedPoint,\n DerivedQuadPoints,\n PointTuple,\n QuadCoordinates,\n QuadPoints,\n} from \"../types\";\n\n/**\n * Tools from bezier.js by Mike 'Pomax' Kamermans\n * @see https://github.com/Pomax/bezierjs\n */\n\nconst Tvalues = [\n -0.0640568928626056260850430826247450385909,\n 0.0640568928626056260850430826247450385909,\n -0.1911188674736163091586398207570696318404,\n 0.1911188674736163091586398207570696318404,\n -0.3150426796961633743867932913198102407864,\n 0.3150426796961633743867932913198102407864,\n -0.4337935076260451384870842319133497124524,\n 0.4337935076260451384870842319133497124524,\n -0.5454214713888395356583756172183723700107,\n 0.5454214713888395356583756172183723700107,\n -0.6480936519369755692524957869107476266696,\n 0.6480936519369755692524957869107476266696,\n -0.7401241915785543642438281030999784255232,\n 0.7401241915785543642438281030999784255232,\n -0.8200019859739029219539498726697452080761,\n 0.8200019859739029219539498726697452080761,\n -0.8864155270044010342131543419821967550873,\n 0.8864155270044010342131543419821967550873,\n -0.9382745520027327585236490017087214496548,\n 0.9382745520027327585236490017087214496548,\n -0.9747285559713094981983919930081690617411,\n 0.9747285559713094981983919930081690617411,\n -0.9951872199970213601799974097007368118745,\n 0.9951872199970213601799974097007368118745,\n];\n\nconst Cvalues = [\n 0.1279381953467521569740561652246953718517,\n 0.1279381953467521569740561652246953718517,\n 0.1258374563468282961213753825111836887264,\n 0.1258374563468282961213753825111836887264,\n 0.121670472927803391204463153476262425607,\n 0.121670472927803391204463153476262425607,\n 0.1155056680537256013533444839067835598622,\n 0.1155056680537256013533444839067835598622,\n 0.1074442701159656347825773424466062227946,\n 0.1074442701159656347825773424466062227946,\n 0.0976186521041138882698806644642471544279,\n 0.0976186521041138882698806644642471544279,\n 0.086190161531953275917185202983742667185,\n 0.086190161531953275917185202983742667185,\n 0.0733464814110803057340336152531165181193,\n 0.0733464814110803057340336152531165181193,\n 0.0592985849154367807463677585001085845412,\n 0.0592985849154367807463677585001085845412,\n 0.0442774388174198061686027482113382288593,\n 0.0442774388174198061686027482113382288593,\n 0.0285313886289336631813078159518782864491,\n 0.0285313886289336631813078159518782864491,\n 0.0123412297999871995468056670700372915759,\n 0.0123412297999871995468056670700372915759,\n];\n\n/**\n * @param points\n * @returns\n */\nconst deriveBezier = (points: QuadPoints | CubicPoints) => {\n const dpoints = [] as (DerivedCubicPoints | DerivedQuadPoints)[];\n for (let p = points, d = p.length, c = d - 1; d > 1; d -= 1, c -= 1) {\n const list = [] as unknown as DerivedCubicPoints | DerivedQuadPoints;\n for (let j = 0; j < c; j += 1) {\n list.push({\n x: c * (p[j + 1].x - p[j].x),\n y: c * (p[j + 1].y - p[j].y),\n t: 0,\n });\n }\n dpoints.push(list);\n p = list;\n }\n return dpoints;\n};\n\n/**\n * @param points\n * @param t\n */\nconst computeBezier = (\n points: DerivedQuadPoints | DerivedCubicPoints,\n t: number,\n) => {\n // shortcuts\n /* istanbul ignore next @preserve */\n if (t === 0) {\n points[0].t = 0;\n return points[0];\n }\n\n const order = points.length - 1;\n\n /* istanbul ignore next @preserve */\n if (t === 1) {\n points[order].t = 1;\n return points[order];\n }\n\n const mt = 1 - t;\n let p = points as typeof points | [\n DerivedPoint,\n DerivedPoint,\n DerivedPoint,\n DerivedPoint,\n ];\n\n // constant?\n /* istanbul ignore next @preserve */\n if (order === 0) {\n points[0].t = t;\n return points[0];\n }\n\n // linear?\n /* istanbul ignore else @preserve */\n if (order === 1) {\n return {\n x: mt * p[0].x + t * p[1].x,\n y: mt * p[0].y + t * p[1].y,\n t,\n };\n }\n\n // quadratic/cubic curve?\n const mt2 = mt * mt;\n const t2 = t * t;\n let a = 0;\n let b = 0;\n let c = 0;\n let d = 0;\n /* istanbul ignore else @preserve */\n if (order === 2) {\n p = [p[0], p[1], p[2], { x: 0, y: 0 } as DerivedPoint];\n a = mt2;\n b = mt * t * 2;\n c = t2;\n } else if (order === 3) {\n a = mt2 * mt;\n b = mt2 * t * 3;\n c = mt * t2 * 3;\n d = t * t2;\n }\n return {\n x: a * p[0].x + b * p[1].x + c * p[2].x + d * p[3].x,\n y: a * p[0].y + b * p[1].y + c * p[2].y + d * p[3].y,\n t,\n };\n};\n\nconst calculateBezier = (derivativeFn: DeriveCallback, t: number) => {\n const d = derivativeFn(t);\n const l = d.x * d.x + d.y * d.y;\n\n return Math.sqrt(l);\n};\n\nconst bezierLength = (derivativeFn: DeriveCallback) => {\n const z = 0.5;\n const len = Tvalues.length;\n\n let sum = 0;\n\n for (let i = 0, t; i < len; i++) {\n t = z * Tvalues[i] + z;\n sum += Cvalues[i] * calculateBezier(derivativeFn, t);\n }\n return z * sum;\n};\n\n/**\n * Returns the length of CubicBezier / Quad segment.\n * @param curve cubic / quad bezier segment\n */\nconst getBezierLength = (curve: CubicCoordinates | QuadCoordinates) => {\n const points = [] as unknown as CubicPoints | QuadPoints;\n for (let idx = 0, len = curve.length, step = 2; idx < len; idx += step) {\n points.push({\n x: curve[idx],\n y: curve[idx + 1],\n });\n }\n const dpoints = deriveBezier(points);\n return bezierLength((t: number) => {\n return computeBezier(dpoints[0], t);\n });\n};\n\n// Precision for consider cubic polynom as quadratic one\nconst CBEZIER_MINMAX_EPSILON = 0.00000001;\n\n/**\n * Returns the most extreme points in a Quad Bezier segment.\n * @param A an array which consist of X/Y values\n */\n// https://github.com/kpym/SVGPathy/blob/acd1a50c626b36d81969f6e98e8602e128ba4302/lib/box.js#L89\nconst minmaxQ = ([v1, cp, v2]: [number, number, number]) => {\n const min = Math.min(v1, v2);\n const max = Math.max(v1, v2);\n\n /* istanbul ignore next @preserve */\n if (cp >= v1 ? v2 >= cp : v2 <= cp) {\n // if no extremum in ]0,1[\n return [min, max] as PointTuple;\n }\n\n // check if the extremum E is min or max\n const E = (v1 * v2 - cp * cp) / (v1 - 2 * cp + v2);\n return (E < min ? [E, max] : [min, E]) as PointTuple;\n};\n\n/**\n * Returns the most extreme points in a Cubic Bezier segment.\n * @param A an array which consist of X/Y values\n * @see https://github.com/kpym/SVGPathy/blob/acd1a50c626b36d81969f6e98e8602e128ba4302/lib/box.js#L127\n */\nconst minmaxC = ([v1, cp1, cp2, v2]: [number, number, number, number]) => {\n const K = v1 - 3 * cp1 + 3 * cp2 - v2;\n\n // if the polynomial is (almost) quadratic and not cubic\n /* istanbul ignore next @preserve */\n if (Math.abs(K) < CBEZIER_MINMAX_EPSILON) {\n if (v1 === v2 && v1 === cp1) {\n // no curve, point targeting same location\n return [v1, v2] as PointTuple;\n }\n\n return minmaxQ([v1, -0.5 * v1 + 1.5 * cp1, v1 - 3 * cp1 + 3 * cp2]);\n }\n\n // the reduced discriminant of the derivative\n const T = -v1 * cp2 + v1 * v2 - cp1 * cp2 - cp1 * v2 + cp1 * cp1 + cp2 * cp2;\n\n // if the polynomial is monotone in [0,1]\n if (T <= 0) {\n return [Math.min(v1, v2), Math.max(v1, v2)] as PointTuple;\n }\n const S = Math.sqrt(T);\n\n // potential extrema\n let min = Math.min(v1, v2);\n let max = Math.max(v1, v2);\n\n const L = v1 - 2 * cp1 + cp2;\n // check local extrema\n for (let R = (L + S) / K, i = 1; i <= 2; R = (L - S) / K, i++) {\n // istanbul ignore next @preserve\n if (R > 0 && R < 1) {\n // if the extrema is for R in [0,1]\n const Q = v1 * (1 - R) * (1 - R) * (1 - R) +\n cp1 * 3 * (1 - R) * (1 - R) * R + cp2 * 3 * (1 - R) * R * R +\n v2 * R * R * R;\n if (Q < min) {\n min = Q;\n }\n if (Q > max) {\n max = Q;\n }\n }\n }\n\n return [min, max] as PointTuple;\n};\n\nexport {\n bezierLength,\n calculateBezier,\n CBEZIER_MINMAX_EPSILON,\n computeBezier,\n Cvalues,\n deriveBezier,\n getBezierLength,\n minmaxC,\n minmaxQ,\n Tvalues,\n};\n","import { getBezierLength, minmaxC } from \"./bezier\";\nimport { type CubicCoordinates } from \"../types\";\n\n/**\n * Returns a point at a given length of a CubicBezier segment.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param t a [0-1] ratio\n * @returns the point at cubic-bezier segment length\n */\nconst getPointAtCubicSegmentLength = (\n [x1, y1, c1x, c1y, c2x, c2y, x2, y2]: CubicCoordinates,\n t: number,\n) => {\n const t1 = 1 - t;\n return {\n x: t1 ** 3 * x1 + 3 * t1 ** 2 * t * c1x + 3 * t1 * t ** 2 * c2x +\n t ** 3 * x2,\n y: t1 ** 3 * y1 + 3 * t1 ** 2 * t * c1y + 3 * t1 * t ** 2 * c2y +\n t ** 3 * y2,\n };\n};\n\n/**\n * Returns the length of a CubicBezier segment.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the CubicBezier segment length\n */\nconst getCubicLength = (\n x1: number,\n y1: number,\n c1x: number,\n c1y: number,\n c2x: number,\n c2y: number,\n x2: number,\n y2: number,\n) => {\n return getBezierLength([x1, y1, c1x, c1y, c2x, c2y, x2, y2]);\n};\n\n/**\n * Returns the point along a CubicBezier segment at a given distance.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance the distance to look at\n * @returns the point at CubicBezier length\n */\nconst getPointAtCubicLength = (\n x1: number,\n y1: number,\n c1x: number,\n c1y: number,\n c2x: number,\n c2y: number,\n x2: number,\n y2: number,\n distance?: number,\n) => {\n const distanceIsNumber = typeof distance === \"number\";\n let point = { x: x1, y: y1 };\n /* istanbul ignore else @preserve */\n if (distanceIsNumber) {\n const currentLength = getBezierLength([x1, y1, c1x, c1y, c2x, c2y, x2, y2]);\n if (distance <= 0) {\n // first point already defined\n } else if (distance >= currentLength) {\n point = { x: x2, y: y2 };\n } else {\n point = getPointAtCubicSegmentLength(\n [x1, y1, c1x, c1y, c2x, c2y, x2, y2],\n distance / currentLength,\n );\n }\n }\n return point;\n};\n\n/**\n * Returns the boundig box of a CubicBezier segment in the following format:\n * [MIN_X, MIN_Y, MAX_X, MAX_Y]\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the extrema of the CubicBezier segment\n */\nconst getCubicBBox = (\n x1: number,\n y1: number,\n c1x: number,\n c1y: number,\n c2x: number,\n c2y: number,\n x2: number,\n y2: number,\n) => {\n const cxMinMax = minmaxC([x1, c1x, c2x, x2]);\n const cyMinMax = minmaxC([y1, c1y, c2y, y2]);\n\n return [cxMinMax[0], cyMinMax[0], cxMinMax[1], cyMinMax[1]] as [\n number,\n number,\n number,\n number,\n ];\n};\n\nexport {\n getCubicBBox,\n getCubicLength,\n getPointAtCubicLength,\n getPointAtCubicSegmentLength,\n};\n","import { getBezierLength, minmaxQ } from \"./bezier\";\nimport { type QuadCoordinates } from \"../types\";\n\n/**\n * Returns the {x,y} coordinates of a point at a\n * given length of a quadratic-bezier segment.\n *\n * @see https://github.com/substack/point-at-length\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param cx the control point X\n * @param cy the control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param t a [0-1] ratio\n * @returns the requested {x,y} coordinates\n */\nconst getPointAtQuadSegmentLength = (\n [x1, y1, cx, cy, x2, y2]: QuadCoordinates,\n t: number,\n) => {\n const t1 = 1 - t;\n return {\n x: t1 ** 2 * x1 + 2 * t1 * t * cx + t ** 2 * x2,\n y: t1 ** 2 * y1 + 2 * t1 * t * cy + t ** 2 * y2,\n };\n};\n\n/**\n * Returns the length of a QuadraticBezier segment.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param cx the control point X\n * @param cy the control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the QuadraticBezier segment length\n */\nconst getQuadLength = (\n x1: number,\n y1: number,\n cx: number,\n cy: number,\n x2: number,\n y2: number,\n) => {\n return getBezierLength([x1, y1, cx, cy, x2, y2]);\n};\n\n/**\n * Returns the point along a QuadraticBezier segment at a given distance.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param cx the control point X\n * @param cy the control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance the distance to look at\n * @returns the point at QuadraticBezier length\n */\nconst getPointAtQuadLength = (\n x1: number,\n y1: number,\n cx: number,\n cy: number,\n x2: number,\n y2: number,\n distance?: number,\n) => {\n const distanceIsNumber = typeof distance === \"number\";\n let point = { x: x1, y: y1 };\n\n /* istanbul ignore else @preserve */\n if (distanceIsNumber) {\n const currentLength = getBezierLength([x1, y1, cx, cy, x2, y2]);\n if (distance <= 0) {\n // first point already defined\n } else if (distance >= currentLength) {\n point = { x: x2, y: y2 };\n } else {\n point = getPointAtQuadSegmentLength(\n [x1, y1, cx, cy, x2, y2],\n distance / currentLength,\n );\n }\n }\n return point;\n};\n\n/**\n * Returns the boundig box of a QuadraticBezier segment in the following format:\n * [MIN_X, MIN_Y, MAX_X, MAX_Y]\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param cx the control point X\n * @param cy the control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the extrema of the QuadraticBezier segment\n */\nconst getQuadBBox = (\n x1: number,\n y1: number,\n cx: number,\n cy: number,\n x2: number,\n y2: number,\n) => {\n const cxMinMax = minmaxQ([x1, cx, x2]);\n const cyMinMax = minmaxQ([y1, cy, y2]);\n return [cxMinMax[0], cyMinMax[0], cxMinMax[1], cyMinMax[1]] as [\n number,\n number,\n number,\n number,\n ];\n};\n\nexport {\n getPointAtQuadLength,\n getPointAtQuadSegmentLength,\n getQuadBBox,\n getQuadLength,\n};\n","import distanceSquareRoot from \"./distanceSquareRoot\";\nimport { type PointTuple } from \"../types\";\n\n/**\n * d3-polygon-area\n * https://github.com/d3/d3-polygon\n *\n * Returns the area of a polygon.\n *\n * @param polygon an array of coordinates\n * @returns the polygon area\n */\nconst polygonArea = (polygon: PointTuple[]) => {\n const n = polygon.length;\n let i = -1;\n let a: PointTuple;\n let b = polygon[n - 1];\n let area = 0;\n\n /* eslint-disable-next-line */\n while (++i < n) {\n a = b;\n b = polygon[i];\n area += a[1] * b[0] - a[0] * b[1];\n }\n\n return area / 2;\n};\n\n/**\n * d3-polygon-length\n * https://github.com/d3/d3-polygon\n *\n * Returns the perimeter of a polygon.\n *\n * @param polygon an array of coordinates\n * @returns the polygon length\n */\nconst polygonLength = (polygon: PointTuple[]) => {\n return polygon.reduce((length, point, i) => {\n if (i) {\n return length + distanceSquareRoot(polygon[i - 1], point);\n }\n return 0;\n }, 0);\n};\n\nexport { polygonArea, polygonLength };\n","/** Segment params length */\nconst paramsCount = {\n a: 7,\n c: 6,\n h: 1,\n l: 2,\n m: 2,\n r: 4,\n q: 4,\n s: 4,\n t: 2,\n v: 1,\n z: 0,\n};\n\nexport default paramsCount;\n","import paramsCount from \"./paramsCount\";\nimport PathParser from \"./pathParser\";\nimport type { PathCommand, PathSegment, RelativeCommand } from \"../types\";\n\n/**\n * Breaks the parsing of a pathString once a segment is finalized.\n *\n * @param path the `PathParser` instance\n */\nconst finalizeSegment = (path: PathParser) => {\n let pathCommand = path.pathValue[path.segmentStart] as PathCommand;\n let relativeCommand = pathCommand.toLowerCase() as RelativeCommand;\n const { data } = path;\n\n while (data.length >= paramsCount[relativeCommand]) {\n // overloaded `moveTo`\n // https://github.com/rveciana/svg-path-properties/blob/master/src/parse.ts\n if (relativeCommand === \"m\" && data.length > 2) {\n path.segments.push(\n [pathCommand as PathCommand | number].concat(\n data.splice(0, 2) as number[],\n ) as PathSegment,\n );\n relativeCommand = \"l\";\n pathCommand = pathCommand === \"m\" ? \"l\" : \"L\";\n } else {\n path.segments.push(\n [pathCommand as PathCommand | number].concat(\n data.splice(0, paramsCount[relativeCommand]) as number[],\n ) as PathSegment,\n );\n }\n\n if (!paramsCount[relativeCommand]) {\n break;\n }\n }\n};\nexport default finalizeSegment;\n","const error = \"SVGPathCommander Error\";\nexport default error;\n","import error from \"./error\";\nimport type PathParser from \"./pathParser\";\n\n/**\n * Validates an A (arc-to) specific path command value.\n * Usually a `large-arc-flag` or `sweep-flag`.\n *\n * @param path the `PathParser` instance\n */\nconst scanFlag = (path: PathParser) => {\n const { index, pathValue } = path;\n const code = pathValue.charCodeAt(index);\n\n if (code === 0x30 /* 0 */) {\n path.param = 0;\n path.index += 1;\n return;\n }\n\n if (code === 0x31 /* 1 */) {\n path.param = 1;\n path.index += 1;\n return;\n }\n\n path.err = `${error}: invalid Arc flag \"${\n pathValue[index]\n }\", expecting 0 or 1 at index ${index}`;\n};\n\nexport default scanFlag;\n","import { DigitNumber } from \"../types\";\n\n/**\n * Checks if a character is a digit.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isDigit = (code: number): code is DigitNumber => {\n return code >= 48 && code <= 57; // 0..9\n};\nexport default isDigit;\n","const invalidPathValue = \"Invalid path value\";\nexport default invalidPathValue;\n","import isDigit from \"./isDigit\";\nimport invalidPathValue from \"./invalidPathValue\";\nimport error from \"./error\";\nimport type PathParser from \"./pathParser\";\n\n/**\n * Validates every character of the path string,\n * every path command, negative numbers or floating point numbers.\n *\n * @param path the `PathParser` instance\n */\nconst scanParam = (path: PathParser) => {\n const { max, pathValue, index: start } = path;\n let index = start;\n let zeroFirst = false;\n let hasCeiling = false;\n let hasDecimal = false;\n let hasDot = false;\n let ch;\n\n if (index >= max) {\n path.err =\n `${error}: ${invalidPathValue} at index ${index}, \"pathValue\" is missing param`;\n return;\n }\n ch = pathValue.charCodeAt(index);\n\n if (ch === 0x2b /* + */ || ch === 0x2d /* - */) {\n index += 1;\n // ch = (index < max) ? pathValue.charCodeAt(index) : 0;\n ch = pathValue.charCodeAt(index);\n }\n\n // This logic is shamelessly borrowed from Esprima\n // https://github.com/ariya/esprimas\n if (!isDigit(ch) && ch !== 0x2e /* . */) {\n // path.err = 'SvgPath: param should start with 0..9 or `.` (at pos ' + index + ')';\n path.err = `${error}: ${invalidPathValue} at index ${index}, \"${\n pathValue[index]\n }\" is not a number`;\n return;\n }\n\n if (ch !== 0x2e /* . */) {\n zeroFirst = ch === 0x30 /* 0 */;\n index += 1;\n\n ch = pathValue.charCodeAt(index);\n\n if (zeroFirst && index < max) {\n // decimal number starts with '0' such as '09' is illegal.\n if (ch && isDigit(ch)) {\n // path.err = 'SvgPath: numbers started with `0` such as `09`\n // are illegal (at pos ' + start + ')';\n path.err = `${error}: ${invalidPathValue} at index ${start}, \"${\n pathValue[start]\n }\" illegal number`;\n return;\n }\n }\n\n while (index < max && isDigit(pathValue.charCodeAt(index))) {\n index += 1;\n hasCeiling = true;\n }\n\n ch = pathValue.charCodeAt(index);\n }\n\n if (ch === 0x2e /* . */) {\n hasDot = true;\n index += 1;\n while (isDigit(pathValue.charCodeAt(index))) {\n index += 1;\n hasDecimal = true;\n }\n\n ch = pathValue.charCodeAt(index);\n }\n\n if (ch === 0x65 /* e */ || ch === 0x45 /* E */) {\n if (hasDot && !hasCeiling && !hasDecimal) {\n path.err = `${error}: ${invalidPathValue} at index ${index}, \"${\n pathValue[index]\n }\" invalid float exponent`;\n return;\n }\n\n index += 1;\n\n ch = pathValue.charCodeAt(index);\n\n if (ch === 0x2b /* + */ || ch === 0x2d /* - */) {\n index += 1;\n }\n if (index < max && isDigit(pathValue.charCodeAt(index))) {\n while (index < max && isDigit(pathValue.charCodeAt(index))) {\n index += 1;\n }\n } else {\n path.err = `${error}: ${invalidPathValue} at index ${index}, \"${\n pathValue[index]\n }\" invalid integer exponent`;\n return;\n }\n }\n\n path.index = index;\n path.param = +path.pathValue.slice(start, index);\n};\nexport default scanParam;\n","import type { SpaceNumber } from \"../types\";\n\n/**\n * Checks if the character is a space.\n *\n * @param ch the character to check\n * @returns check result\n */\n\nconst isSpace = (ch: number): ch is SpaceNumber => {\n const allSpaces = [\n // Special spaces\n 0x1680,\n 0x180e,\n 0x2000,\n 0x2001,\n 0x2002,\n 0x2003,\n 0x2004,\n 0x2005,\n 0x2006,\n 0x2007,\n 0x2008,\n 0x2009,\n 0x200a,\n 0x202f,\n 0x205f,\n 0x3000,\n 0xfeff,\n // Line terminators\n 0x0a,\n 0x0d,\n 0x2028,\n 0x2029,\n // White spaces\n 0x20,\n 0x09,\n 0x0b,\n 0x0c,\n 0xa0,\n ];\n\n return allSpaces.includes(ch);\n};\nexport default isSpace;\n","import isSpace from \"./isSpace\";\nimport type PathParser from \"./pathParser\";\n\n/**\n * Points the parser to the next character in the\n * path string every time it encounters any kind of\n * space character.\n *\n * @param path the `PathParser` instance\n */\nconst skipSpaces = (path: PathParser) => {\n const { pathValue, max } = path;\n while (path.index < max && isSpace(pathValue.charCodeAt(path.index))) {\n path.index += 1;\n }\n};\nexport default skipSpaces;\n","import type { PathCommandNumber } from \"../types\";\n\n/**\n * Checks if the character is a path command.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isPathCommand = (code: number): code is PathCommandNumber => {\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy\n switch (code | 0x20) {\n case 0x6d /* m */:\n case 0x7a /* z */:\n case 0x6c /* l */:\n case 0x68 /* h */:\n case 0x76 /* v */:\n case 0x63 /* c */:\n case 0x73 /* s */:\n case 0x71 /* q */:\n case 0x74 /* t */:\n case 0x61 /* a */:\n // case 0x72/* r */:\n return true;\n default:\n return false;\n }\n};\nexport default isPathCommand;\n","import isDigit from \"./isDigit\";\nimport type { DigitNumber } from \"../types\";\n\n/**\n * Checks if the character is or belongs to a number.\n * [0-9]|+|-|.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isDigitStart = (\n code: number,\n): code is DigitNumber | 0x2b | 0x2d | 0x2e => {\n return isDigit(code) /* 0..9 */ || code === 0x2b /* + */ ||\n code === 0x2d /* - */ || code === 0x2e; /* . */\n};\nexport default isDigitStart;\n","/**\n * Checks if the character is an A (arc-to) path command.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isArcCommand = (code: number): code is 0x61 => {\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy\n return (code | 0x20) === 0x61;\n};\nexport default isArcCommand;\n","/**\n * Checks if the character is a MoveTo command.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isMoveCommand = (code: number): code is 0x6d | 0x4d => {\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy\n switch (code | 0x20) {\n case 0x6d /* m */:\n case 0x4d /* M */:\n return true;\n default:\n return false;\n }\n};\nexport default isMoveCommand;\n","import finalizeSegment from \"./finalizeSegment\";\nimport paramCounts from \"./paramsCount\";\nimport scanFlag from \"./scanFlag\";\nimport scanParam from \"./scanParam\";\nimport skipSpaces from \"./skipSpaces\";\nimport isPathCommand from \"./isPathCommand\";\nimport isDigitStart from \"./isDigitStart\";\nimport isArcCommand from \"./isArcCommand\";\nimport isMoveCommand from \"./isMoveCommand\";\nimport invalidPathValue from \"./invalidPathValue\";\nimport error from \"./error\";\n\nimport type PathParser from \"./pathParser\";\nimport type { PathSegment, RelativeCommand } from \"../types\";\n\n/**\n * Scans every character in the path string to determine\n * where a segment starts and where it ends.\n *\n * @param path the `PathParser` instance\n */\nconst scanSegment = (path: PathParser) => {\n const { max, pathValue, index, segments } = path;\n const cmdCode = pathValue.charCodeAt(index);\n const reqParams =\n paramCounts[pathValue[index].toLowerCase() as RelativeCommand];\n\n path.segmentStart = index;\n\n // segments always start with a path command\n if (!isPathCommand(cmdCode)) {\n path.err = `${error}: ${invalidPathValue} \"${\n pathValue[index]\n }\" is not a path command at index ${index}`;\n return;\n }\n\n // after a Z segment, we only expect a MoveTo path command\n const lastSegment = segments[segments.length - 1] as PathSegment | undefined;\n if (\n !isMoveCommand(cmdCode) && lastSegment?.[0]?.toLocaleLowerCase() === \"z\"\n ) {\n path.err = `${error}: ${invalidPathValue} \"${\n pathValue[index]\n }\" is not a MoveTo path command at index ${index}`;\n return;\n }\n\n path.index += 1;\n skipSpaces(path);\n\n path.data = [];\n\n if (!reqParams) {\n // Z\n finalizeSegment(path);\n return;\n }\n\n for (;;) {\n for (let i = reqParams; i > 0; i -= 1) {\n if (isArcCommand(cmdCode) && (i === 3 || i === 4)) scanFlag(path);\n else scanParam(path);\n\n if (path.err.length) {\n return;\n }\n path.data.push(path.param);\n\n skipSpaces(path);\n\n // after ',' param is mandatory\n if (\n path.index < max && pathValue.charCodeAt(path.index) === 0x2c /* , */\n ) {\n path.index += 1;\n skipSpaces(path);\n }\n }\n\n if (path.index >= path.max) {\n break;\n }\n\n // Stop on next segment\n if (!isDigitStart(pathValue.charCodeAt(path.index))) {\n break;\n }\n }\n\n finalizeSegment(path);\n};\nexport default scanSegment;\n","import type { PathArray, PathSegment } from \"../types\";\n\n/**\n * The `PathParser` is used by the `parsePathString` static method\n * to generate a `pathArray`.\n *\n * @param pathString\n */\nexport default class PathParser {\n declare segments: PathArray | PathSegment[];\n declare pathValue: string;\n declare max: number;\n declare index: number;\n declare param: number;\n declare segmentStart: number;\n declare data: (string | number)[];\n declare err: string;\n\n constructor(pathString: string) {\n this.segments = [];\n this.pathValue = pathString;\n this.max = pathString.length;\n this.index = 0;\n this.param = 0.0;\n this.segmentStart = 0;\n this.data = [];\n this.err = \"\";\n }\n}\n","import scanSegment from \"./scanSegment\";\nimport skipSpaces from \"./skipSpaces\";\nimport PathParser from \"./pathParser\";\nimport type { PathArray } from \"../types\";\n\n/**\n * Parses a path string value and returns an array\n * of segments we like to call `pathArray`.\n *\n * @param pathInput the string to be parsed\n * @returns the resulted `pathArray` or error string\n */\nconst parsePathString = (pathInput: string | T) => {\n if (typeof pathInput !== \"string\") {\n return pathInput.slice(0) as typeof pathInput;\n }\n\n const path = new PathParser(pathInput);\n\n skipSpaces(path);\n\n while (path.index < path.max && !path.err.length) {\n scanSegment(path);\n }\n\n // handle valid paths first\n // handle errors second\n if (!path.err.length) {\n if (path.segments.length) {\n /**\n * force absolute first M\n * getPathBBox calculation requires first segment to be absolute\n * @see https://github.com/thednp/svg-path-commander/pull/49\n */\n path.segments[0][0] = \"M\";\n }\n } else {\n throw TypeError(path.err);\n }\n\n return path.segments as PathArray;\n};\n\nexport default parsePathString;\n","import type {\n AbsoluteCommand,\n AbsoluteSegment,\n ASegment,\n CSegment,\n HSegment,\n LSegment,\n MSegment,\n PathSegment,\n QSegment,\n SSegment,\n TSegment,\n VSegment,\n} from \"../types\";\n\n/**\n * Returns an absolute segment of a `PathArray` object.\n *\n * @param segment the segment object\n * @param index the segment index\n * @param lastX the last known X value\n * @param lastY the last known Y value\n * @returns the absolute segment\n */\nconst absolutizeSegment = (\n segment: PathSegment,\n index: number,\n lastX: number,\n lastY: number,\n) => {\n const [pathCommand] = segment;\n const absCommand = pathCommand.toUpperCase() as AbsoluteCommand;\n const isAbsolute = absCommand === pathCommand;\n\n /* istanbul ignore else @preserve */\n if (index === 0 || isAbsolute) return segment as MSegment | AbsoluteSegment;\n // const values = segment.slice(1) as number[];\n if (absCommand === \"A\") {\n return [\n absCommand,\n segment[1],\n segment[2],\n segment[3],\n segment[4],\n segment[5],\n (segment as ASegment)[6] + lastX,\n (segment as ASegment)[7] + lastY,\n ] as ASegment;\n } else if (absCommand === \"V\") {\n return [absCommand, (segment as VSegment)[1] + lastY] as VSegment;\n } else if (absCommand === \"H\") {\n return [absCommand, (segment as HSegment)[1] + lastX] as HSegment;\n } else if (absCommand === \"L\") {\n return [\n absCommand,\n (segment as LSegment)[1] + lastX,\n (segment as LSegment)[2] + lastY,\n ] as LSegment;\n } else {\n // use brakets for `eslint: no-case-declaration`\n // https://stackoverflow.com/a/50753272/803358\n const absValues = [] as number[];\n const seglen = segment.length;\n for (let j = 1; j < seglen; j += 1) {\n absValues.push((segment[j] as number) + (j % 2 ? lastX : lastY));\n }\n // for c, s, q, t\n return [absCommand as typeof absCommand | number].concat(absValues) as\n | MSegment\n | QSegment\n | TSegment\n | SSegment\n | CSegment;\n }\n};\nexport default absolutizeSegment;\n","// import paramsParser from '../parser/paramsParser';\nimport type {\n AbsoluteCommand,\n IteratorCallback,\n PathArray,\n PathCommand,\n PathSegment,\n} from \"../types\";\n\nconst iterate = (\n path: PathArray,\n iterator: IteratorCallback,\n) => {\n let pathLen = path.length;\n let segment: PathSegment;\n let pathCommand = \"M\" as PathCommand;\n let absCommand = \"M\" as AbsoluteCommand;\n let isRelative = false;\n let x = 0;\n let y = 0;\n let mx = 0;\n let my = 0;\n let segLen = 0;\n\n for (let i = 0; i < pathLen; i += 1) {\n segment = path[i];\n [pathCommand] = segment;\n segLen = segment.length;\n absCommand = pathCommand.toUpperCase() as AbsoluteCommand;\n isRelative = absCommand !== pathCommand;\n\n const iteratorResult = iterator(segment, i, x, y);\n // some methods like getPointAtLength would like to break\n // when task is complete\n if (iteratorResult === false) {\n break;\n }\n\n // segment = path[i];\n if (absCommand === \"Z\") {\n x = mx;\n y = my;\n } else if (absCommand === \"H\") {\n x = (segment[1] as number) + (isRelative ? x : 0);\n } else if (absCommand === \"V\") {\n y = (segment[1] as number) + (isRelative ? y : 0);\n } else {\n x = (segment[segLen - 2] as number) + (isRelative ? x : 0);\n y = (segment[segLen - 1] as number) + (isRelative ? y : 0);\n\n if (absCommand === \"M\") {\n mx = x;\n my = y;\n }\n }\n\n if (iteratorResult) {\n path[i] = iteratorResult;\n if (iteratorResult[0] === \"C\") {\n pathLen = path.length;\n }\n }\n }\n return path as T;\n};\n\nexport default iterate;\n","import parsePathString from \"../parser/parsePathString\";\nimport absolutizeSegment from \"../process/absolutizeSegment\";\nimport type { AbsoluteArray, PathArray } from \"../types\";\nimport iterate from \"../process/iterate\";\n\n/**\n * Parses a path string value or object and returns an array\n * of segments, all converted to absolute values.\n *\n * @param pathInput the path string | object\n * @returns the resulted `pathArray` with absolute values\n */\nconst pathToAbsolute = (pathInput: string | PathArray) => {\n const path = parsePathString(pathInput);\n\n return iterate(path, absolutizeSegment);\n};\nexport default pathToAbsolute;\n","import type {\n aSegment,\n cSegment,\n hSegment,\n lSegment,\n MSegment,\n PathSegment,\n qSegment,\n RelativeCommand,\n RelativeSegment,\n sSegment,\n tSegment,\n vSegment,\n} from \"../types\";\n\n/**\n * Returns a relative segment of a `PathArray` object.\n *\n * @param segment the segment object\n * @param index the segment index\n * @param lastX the last known X value\n * @param lastY the last known Y value\n * @returns the relative segment\n */\nconst relativizeSegment = (\n segment: PathSegment,\n index: number,\n lastX: number,\n lastY: number,\n) => {\n const [pathCommand] = segment;\n const relCommand = pathCommand.toLowerCase() as RelativeCommand;\n const isRelative = pathCommand === relCommand;\n\n /* istanbul ignore else @preserve */\n if (index === 0 || isRelative) return segment as MSegment | RelativeSegment;\n\n if (relCommand === \"a\") {\n return [\n relCommand,\n segment[1],\n segment[2],\n segment[3],\n segment[4],\n segment[5],\n (segment as aSegment)[6] - lastX,\n (segment as aSegment)[7] - lastY,\n ] as aSegment;\n } else if (relCommand === \"v\") {\n return [relCommand, (segment as vSegment)[1] - lastY] as vSegment;\n } else if (relCommand === \"h\") {\n return [relCommand, (segment as hSegment)[1] - lastX] as hSegment;\n } else if (relCommand === \"l\") {\n return [\n relCommand,\n (segment as lSegment)[1] - lastX,\n (segment as lSegment)[2] - lastY,\n ] as lSegment;\n } else {\n // use brakets for `eslint: no-case-declaration`\n // https://stackoverflow.com/a/50753272/803358\n const relValues = [] as number[];\n const seglen = segment.length;\n for (let j = 1; j < seglen; j += 1) {\n relValues.push((segment[j] as number) - (j % 2 ? lastX : lastY));\n }\n // for c, s, q, t\n return [relCommand as RelativeCommand | number].concat(relValues) as\n | qSegment\n | tSegment\n | sSegment\n | cSegment;\n }\n};\n\nexport default relativizeSegment;\n","import type { PathArray, RelativeArray } from \"../types\";\nimport parsePathString from \"../parser/parsePathString\";\nimport iterate from \"../process/iterate\";\nimport relativizeSegment from \"../process/relativizeSegment\";\n\n/**\n * Parses a path string value or object and returns an array\n * of segments, all converted to relative values.\n *\n * @param pathInput the path string | object\n * @returns the resulted `pathArray` with relative values\n */\nconst pathToRelative = (pathInput: string | PathArray): RelativeArray => {\n const path = parsePathString(pathInput);\n\n return iterate(path, relativizeSegment);\n};\nexport default pathToRelative;\n","/**\n * Returns an {x,y} vector rotated by a given\n * angle in radian.\n *\n * @param x the initial vector x\n * @param y the initial vector y\n * @param rad the radian vector angle\n * @returns the rotated vector\n */\nconst rotateVector = (\n x: number,\n y: number,\n rad: number,\n): { x: number; y: number } => {\n const { sin, cos } = Math;\n const X = x * cos(rad) - y * sin(rad);\n const Y = x * sin(rad) + y * cos(rad);\n return { x: X, y: Y };\n};\n\nexport default rotateVector;\n","import rotateVector from \"../math/rotateVector\";\n\n/**\n * Converts A (arc-to) segments to C (cubic-bezier-to).\n *\n * For more information of where this math came from visit:\n * http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes\n *\n * @param X1 the starting x position\n * @param Y1 the starting y position\n * @param RX x-radius of the arc\n * @param RY y-radius of the arc\n * @param angle x-axis-rotation of the arc\n * @param LAF large-arc-flag of the arc\n * @param SF sweep-flag of the arc\n * @param X2 the ending x position\n * @param Y2 the ending y position\n * @param recursive the parameters needed to split arc into 2 segments\n * @return the resulting cubic-bezier segment(s)\n */\nconst arcToCubic = (\n X1: number,\n Y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n X2: number,\n Y2: number,\n recursive?: [number, number, number, number],\n): number[] => {\n let x1 = X1;\n let y1 = Y1;\n let rx = RX;\n let ry = RY;\n let x2 = X2;\n let y2 = Y2;\n // for more information of where this Math came from visit:\n // http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes\n const d120 = (Math.PI * 120) / 180;\n\n const rad = (Math.PI / 180) * (+angle || 0);\n let res = [] as number[];\n let xy;\n let f1;\n let f2;\n let cx;\n let cy;\n\n if (!recursive) {\n xy = rotateVector(x1, y1, -rad);\n x1 = xy.x;\n y1 = xy.y;\n xy = rotateVector(x2, y2, -rad);\n x2 = xy.x;\n y2 = xy.y;\n\n const x = (x1 - x2) / 2;\n const y = (y1 - y2) / 2;\n let h = (x * x) / (rx * rx) + (y * y) / (ry * ry);\n if (h > 1) {\n h = Math.sqrt(h);\n rx *= h;\n ry *= h;\n }\n const rx2 = rx * rx;\n const ry2 = ry * ry;\n\n const k = (LAF === SF ? -1 : 1) *\n Math.sqrt(\n Math.abs(\n (rx2 * ry2 - rx2 * y * y - ry2 * x * x) / (rx2 * y * y + ry2 * x * x),\n ),\n );\n\n cx = (k * rx * y) / ry + (x1 + x2) / 2;\n cy = (k * -ry * x) / rx + (y1 + y2) / 2;\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy no-bitwise\n f1 = Math.asin(((((y1 - cy) / ry) * 10 ** 9) >> 0) / 10 ** 9);\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy no-bitwise\n f2 = Math.asin(((((y2 - cy) / ry) * 10 ** 9) >> 0) / 10 ** 9);\n\n f1 = x1 < cx ? Math.PI - f1 : f1;\n f2 = x2 < cx ? Math.PI - f2 : f2;\n if (f1 < 0) f1 = Math.PI * 2 + f1;\n if (f2 < 0) f2 = Math.PI * 2 + f2;\n if (SF && f1 > f2) {\n f1 -= Math.PI * 2;\n }\n if (!SF && f2 > f1) {\n f2 -= Math.PI * 2;\n }\n } else {\n [f1, f2, cx, cy] = recursive;\n }\n let df = f2 - f1;\n if (Math.abs(df) > d120) {\n const f2old = f2;\n const x2old = x2;\n const y2old = y2;\n f2 = f1 + d120 * (SF && f2 > f1 ? 1 : -1);\n x2 = cx + rx * Math.cos(f2);\n y2 = cy + ry * Math.sin(f2);\n res = arcToCubic(x2, y2, rx, ry, angle, 0, SF, x2old, y2old, [\n f2,\n f2old,\n cx,\n cy,\n ]);\n }\n df = f2 - f1;\n const c1 = Math.cos(f1);\n const s1 = Math.sin(f1);\n const c2 = Math.cos(f2);\n const s2 = Math.sin(f2);\n const t = Math.tan(df / 4);\n const hx = (4 / 3) * rx * t;\n const hy = (4 / 3) * ry * t;\n const m1 = [x1, y1];\n const m2 = [x1 + hx * s1, y1 - hy * c1];\n const m3 = [x2 + hx * s2, y2 - hy * c2];\n const m4 = [x2, y2];\n m2[0] = 2 * m1[0] - m2[0];\n m2[1] = 2 * m1[1] - m2[1];\n if (recursive) {\n return [m2[0], m2[1], m3[0], m3[1], m4[0], m4[1]].concat(res);\n }\n res = [m2[0], m2[1], m3[0], m3[1], m4[0], m4[1]].concat(res);\n const newres = [];\n for (let i = 0, ii = res.length; i < ii; i += 1) {\n newres[i] = i % 2\n ? rotateVector(res[i - 1], res[i], rad).y\n : rotateVector(res[i], res[i + 1], rad).x;\n }\n return newres;\n};\nexport default arcToCubic;\n","/**\n * Converts a Q (quadratic-bezier) segment to C (cubic-bezier).\n *\n * @param x1 curve start x\n * @param y1 curve start y\n * @param qx control point x\n * @param qy control point y\n * @param x2 curve end x\n * @param y2 curve end y\n * @returns the cubic-bezier segment\n */\nconst quadToCubic = (\n x1: number,\n y1: number,\n qx: number,\n qy: number,\n x2: number,\n y2: number,\n): [number, number, number, number, number, number] => {\n const r13 = 1 / 3;\n const r23 = 2 / 3;\n return [\n r13 * x1 + r23 * qx, // cpx1\n r13 * y1 + r23 * qy, // cpy1\n r13 * x2 + r23 * qx, // cpx2\n r13 * y2 + r23 * qy, // cpy2\n x2,\n y2, // x,y\n ];\n};\nexport default quadToCubic;\n","import midPoint from \"../math/midPoint\";\n\n/**\n * Converts an L (line-to) segment to C (cubic-bezier).\n *\n * @param x1 line start x\n * @param y1 line start y\n * @param x2 line end x\n * @param y2 line end y\n * @returns the cubic-bezier segment\n */\nconst lineToCubic = (x1: number, y1: number, x2: number, y2: number) => {\n const c1 = midPoint([x1, y1], [x2, y2], 1.0 / 3.0);\n const c2 = midPoint([x1, y1], [x2, y2], 2.0 / 3.0);\n return [c1[0], c1[1], c2[0], c2[1], x2, y2];\n};\nexport default lineToCubic;\n","import arcToCubic from \"./arcToCubic\";\nimport quadToCubic from \"./quadToCubic\";\nimport lineToCubic from \"./lineToCubic\";\nimport type { CSegment, MSegment, PathSegment } from \"../types\";\nimport type { ParserParams } from \"../interface\";\n\n/**\n * Converts any segment to C (cubic-bezier).\n *\n * @param segment the source segment\n * @param params the source segment parameters\n * @returns the cubic-bezier segment\n */\nconst segmentToCubic = (segment: PathSegment, params: ParserParams) => {\n const [pathCommand] = segment;\n const values = segment.slice(1).map(Number);\n const [x, y] = values;\n // let args;\n const { x1: px1, y1: py1, x: px, y: py } = params;\n\n if (!\"TQ\".includes(pathCommand)) {\n params.qx = null;\n params.qy = null;\n }\n\n if (pathCommand === \"M\") {\n params.x = x;\n params.y = y;\n return segment;\n } else if (pathCommand === \"A\") {\n return [\"C\" as string | number].concat(\n arcToCubic(\n px1,\n py1,\n values[0],\n values[1],\n values[2],\n values[3],\n values[4],\n values[5],\n values[6],\n ),\n ) as CSegment;\n } else if (pathCommand === \"Q\") {\n params.qx = x;\n params.qy = y;\n return [\"C\" as string | number].concat(\n quadToCubic(px1, py1, values[0], values[1], values[2], values[3]),\n ) as CSegment;\n } else if (pathCommand === \"L\") {\n return [\"C\" as string | number].concat(\n lineToCubic(px1, py1, x, y),\n ) as CSegment;\n } else if (pathCommand === \"Z\") {\n return [\"C\" as string | number].concat(\n lineToCubic(px1, py1, px, py),\n ) as CSegment;\n }\n\n return segment as MSegment | CSegment;\n};\nexport default segmentToCubic;\n","import type { ParserParams } from \"../interface\";\nimport type {\n ASegment,\n CSegment,\n HSegment,\n LSegment,\n MSegment,\n NormalSegment,\n PathCommand,\n PathSegment,\n PointTuple,\n QSegment,\n VSegment,\n} from \"../types\";\n\n/**\n * Normalizes a single segment of a `pathArray` object.\n *\n * @param segment the segment object\n * @param params the normalization parameters\n * @returns the normalized segment\n */\nconst normalizeSegment = (segment: PathSegment, params: ParserParams) => {\n const [pathCommand] = segment;\n const absCommand = pathCommand.toUpperCase();\n const isRelative = pathCommand !== absCommand;\n const { x1: px1, y1: py1, x2: px2, y2: py2, x, y } = params;\n const values = segment.slice(1) as number[];\n let absValues = values.map((n, j) => n + (isRelative ? (j % 2 ? y : x) : 0));\n\n if (!\"TQ\".includes(absCommand)) {\n // optional but good to be cautious\n params.qx = null;\n params.qy = null;\n }\n\n // istanbul ignore else @preserve\n if (absCommand === \"A\") {\n absValues = values.slice(0, -2).concat(\n values[5] + (isRelative ? x : 0),\n values[6] + (isRelative ? y : 0),\n );\n\n return [\"A\" as PathCommand | number].concat(absValues) as ASegment;\n } else if (absCommand === \"H\") {\n return [\n \"L\",\n (segment as HSegment)[1] + (isRelative ? x : 0),\n py1,\n ] as LSegment;\n } else if (absCommand === \"V\") {\n return [\n \"L\",\n px1,\n (segment as VSegment)[1] + (isRelative ? y : 0),\n ] as LSegment;\n } else if (absCommand === \"L\") {\n return [\n \"L\",\n (segment as LSegment)[1] + (isRelative ? x : 0),\n (segment as LSegment)[2] + (isRelative ? y : 0),\n ] as LSegment;\n } else if (absCommand === \"M\") {\n return [\n \"M\",\n (segment as MSegment)[1] + (isRelative ? x : 0),\n (segment as MSegment)[2] + (isRelative ? y : 0),\n ] as MSegment;\n } else if (absCommand === \"C\") {\n return [\"C\" as PathCommand | number].concat(absValues) as CSegment;\n } else if (absCommand === \"S\") {\n const x1 = px1 * 2 - px2;\n const y1 = py1 * 2 - py2;\n params.x1 = x1;\n params.y1 = y1;\n return [\"C\", x1, y1].concat(absValues) as CSegment;\n } else if (absCommand === \"T\") {\n const qx = px1 * 2 - (params.qx ? params.qx : /* istanbul ignore next */ 0);\n const qy = py1 * 2 - (params.qy ? params.qy : /* istanbul ignore next */ 0);\n params.qx = qx;\n params.qy = qy;\n return [\"Q\", qx, qy].concat(absValues) as QSegment;\n } else if (absCommand === \"Q\") {\n const [nqx, nqy] = absValues as PointTuple;\n params.qx = nqx;\n params.qy = nqy;\n return [\"Q\" as PathCommand | number].concat(absValues) as QSegment;\n } else if (absCommand === \"Z\") {\n return [\"Z\"] as NormalSegment;\n }\n\n // istanbul ignore next @preserve\n return segment as NormalSegment;\n};\nexport default normalizeSegment;\n","import type { ParserParams } from \"../interface\";\n\nconst paramsParser: ParserParams = {\n x1: 0,\n y1: 0,\n x2: 0,\n y2: 0,\n x: 0,\n y: 0,\n qx: null,\n qy: null,\n};\n\nexport default paramsParser;\n","import segmentToCubic from \"../process/segmentToCubic\";\nimport { AbsoluteCommand, CSegment, CurveArray, PathArray } from \"../types\";\nimport iterate from \"../process/iterate\";\nimport parsePathString from \"../parser/parsePathString\";\nimport normalizeSegment from \"../process/normalizeSegment\";\nimport paramsParser from \"../parser/paramsParser\";\n\n/**\n * Parses a path string value or 'pathArray' and returns a new one\n * in which all segments are converted to cubic-bezier.\n *\n * In addition, un-necessary `Z` segment is removed if previous segment\n * extends to the `M` segment.\n *\n * @param pathInput the string to be parsed or 'pathArray'\n * @returns the resulted `pathArray` converted to cubic-bezier\n */\nconst pathToCurve = (pathInput: string | PathArray): CurveArray => {\n const params = { ...paramsParser };\n const path = parsePathString(pathInput);\n\n return iterate(path, (seg, index, lastX, lastY) => {\n params.x = lastX;\n params.y = lastY;\n const normalSegment = normalizeSegment(seg, params);\n let result = segmentToCubic(normalSegment, params);\n const isLongArc = result[0] === \"C\" && result.length > 7;\n\n if (isLongArc) {\n path.splice(\n index + 1,\n 0,\n [\"C\" as AbsoluteCommand | number].concat(result.slice(7)) as CSegment,\n );\n result = result.slice(0, 7) as CSegment;\n }\n\n const seglen = result.length;\n params.x1 = +result[seglen - 2];\n params.y1 = +result[seglen - 1];\n params.x2 = +result[seglen - 4] || params.x1;\n params.y2 = +result[seglen - 3] || params.y1;\n\n return result;\n });\n};\nexport default pathToCurve;\n","import { Options } from \"../interface\";\n\n/** SVGPathCommander default options */\nconst defaultOptions: Options = {\n origin: [0, 0, 0],\n round: 4,\n};\n\nexport default defaultOptions;\n","const roundTo = (n: number, round: number) => {\n const pow = round >= 1 ? 10 ** round : 1;\n\n return round > 0 ? Math.round(n * pow) / pow : Math.round(n);\n};\n\nexport default roundTo;\n","import type { PathArray, PathSegment } from \"../types\";\nimport defaultOptions from \"../options/options\";\nimport roundTo from \"../math/roundTo\";\n\n/**\n * Returns a valid `d` attribute string value created\n * by rounding values and concatenating the `pathArray` segments.\n *\n * @param path the `pathArray` object\n * @param roundOption amount of decimals to round values to\n * @returns the concatenated path string\n */\nconst pathToString = (\n path: PathArray,\n roundOption?: number | \"off\",\n): string => {\n const pathLen = path.length;\n let { round } = defaultOptions;\n let segment = path[0] as PathSegment;\n let result = \"\";\n\n // allow for ZERO decimals\n round = roundOption === \"off\"\n ? roundOption\n : typeof roundOption === \"number\" && roundOption >= 0\n ? roundOption\n : typeof round === \"number\" && round >= 0\n ? round\n : /* istanbul ignore next @preserve */ \"off\";\n\n for (let i = 0; i < pathLen; i += 1) {\n segment = path[i];\n const [pathCommand] = segment;\n const values = segment.slice(1) as number[];\n result += pathCommand;\n if (round === \"off\") {\n result += values.join(\" \");\n } else {\n let j = 0;\n const valLen = values.length;\n while (j < valLen) {\n result += roundTo(values[j], round);\n if (j !== valLen - 1) result += \" \";\n j += 1;\n }\n }\n }\n\n return result;\n};\n\nexport default pathToString;\n","const DISTANCE_EPSILON = 0.00001;\n\nexport default DISTANCE_EPSILON;\n","import normalizeSegment from \"./normalizeSegment\";\nimport type { NormalArray, PathArray } from \"../types\";\nimport iterate from \"./iterate\";\nimport parsePathString from \"../parser/parsePathString\";\nimport paramsParser from \"../parser/paramsParser\";\n\n/**\n * Normalizes a `pathArray` object for further processing:\n * * convert segments to absolute values\n * * convert shorthand path commands to their non-shorthand notation\n *\n * @param pathInput the string to be parsed or 'pathArray'\n * @returns the normalized `pathArray`\n */\nconst normalizePath = (pathInput: string | PathArray) => {\n const path = parsePathString(pathInput);\n const params = { ...paramsParser };\n\n return iterate(path, (seg, _, lastX, lastY) => {\n params.x = lastX;\n params.y = lastY;\n const result = normalizeSegment(seg, params);\n\n const seglen = result.length;\n params.x1 = +result[seglen - 2];\n params.y1 = +result[seglen - 1];\n params.x2 = +result[seglen - 4] || params.x1;\n params.y2 = +result[seglen - 3] || params.y1;\n\n return result;\n });\n};\nexport default normalizePath;\n","import DISTANCE_EPSILON from \"./distanceEpsilon\";\nimport type { MSegment, PathArray, PointTuple } from \"../types\";\nimport iterate from \"../process/iterate\";\nimport { getLineLength, getPointAtLineLength } from \"../math/lineTools\";\nimport { getArcLength, getPointAtArcLength } from \"../math/arcTools\";\nimport { getCubicLength, getPointAtCubicLength } from \"../math/cubicTools\";\nimport { getPointAtQuadLength, getQuadLength } from \"../math/quadTools\";\nimport normalizePath from \"../process/normalizePath\";\n\n/**\n * Returns [x,y] coordinates of a point at a given length of a shape.\n *\n * @param pathInput the `pathArray` to look into\n * @param distance the length of the shape to look at\n * @returns the requested {x, y} point coordinates\n */\nconst getPointAtLength = (pathInput: string | PathArray, distance?: number) => {\n const path = normalizePath(pathInput);\n let isM = false;\n let data = [] as number[];\n let pathCommand = \"M\";\n let x = 0;\n let y = 0;\n let [mx, my] = path[0].slice(1) as PointTuple;\n const distanceIsNumber = typeof distance === \"number\";\n let point = { x: mx, y: my };\n let length = 0;\n let POINT = point;\n let totalLength = 0;\n\n if (!distanceIsNumber || distance < DISTANCE_EPSILON) return point;\n\n // for (let i = 0; i < pathLen; i += 1) {\n iterate(path, (seg, _, lastX, lastY) => {\n [pathCommand] = seg;\n isM = pathCommand === \"M\";\n data = !isM ? [lastX, lastY].concat(seg.slice(1) as number[]) : data;\n\n // this segment is always ZERO\n /* istanbul ignore else @preserve */\n if (isM) {\n // remember mx, my for Z\n [, mx, my] = seg as MSegment;\n point = { x: mx, y: my };\n length = 0;\n } else if (pathCommand === \"L\") {\n point = getPointAtLineLength(\n data[0],\n data[1],\n data[2],\n data[3],\n distance - totalLength,\n );\n length = getLineLength(data[0], data[1], data[2], data[3]);\n } else if (pathCommand === \"A\") {\n point = getPointAtArcLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n data[6],\n data[7],\n data[8],\n distance - totalLength,\n );\n length = getArcLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n data[6],\n data[7],\n data[8],\n );\n } else if (pathCommand === \"C\") {\n point = getPointAtCubicLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n data[6],\n data[7],\n distance - totalLength,\n );\n length = getCubicLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n data[6],\n data[7],\n );\n } else if (pathCommand === \"Q\") {\n point = getPointAtQuadLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n distance - totalLength,\n );\n length = getQuadLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n );\n } else if (pathCommand === \"Z\") {\n data = [lastX, lastY, mx, my];\n point = { x: mx, y: my };\n\n length = getLineLength(data[0], data[1], data[2], data[3]);\n }\n\n [x, y] = data.slice(-2);\n\n if (totalLength < distance) {\n POINT = point;\n } else {\n // totalLength >= distance\n // stop right here\n // stop iterator now!\n return false;\n }\n\n totalLength += length;\n return;\n });\n\n // native `getPointAtLength` behavior when the given distance\n // is higher than total length\n if (distance > totalLength - DISTANCE_EPSILON) {\n return { x, y };\n }\n\n return POINT;\n};\n\nexport default getPointAtLength;\n","import type { LSegment, MSegment, PathArray, PointTuple } from \"../types\";\nimport { getLineLength } from \"../math/lineTools\";\nimport { getArcLength } from \"../math/arcTools\";\nimport { getCubicLength } from \"../math/cubicTools\";\nimport { getQuadLength } from \"../math/quadTools\";\nimport iterate from \"../process/iterate\";\nimport parsePathString from \"../parser/parsePathString\";\nimport absolutizeSegment from \"../process/absolutizeSegment\";\n\n/**\n * Returns the shape total length, or the equivalent to `shape.getTotalLength()`.\n *\n * @param pathInput the target `pathArray`\n * @returns the shape total length\n */\nconst getTotalLength = (pathInput: string | PathArray) => {\n const path = parsePathString(pathInput);\n let paramX1 = 0;\n let paramY1 = 0;\n let paramX2 = 0;\n let paramY2 = 0;\n let paramQX = 0;\n let paramQY = 0;\n let pathCommand = \"M\";\n let mx = 0;\n let my = 0;\n let totalLength = 0;\n\n iterate(path, (seg, index, lastX, lastY) => {\n [pathCommand] = seg;\n const absCommand = pathCommand.toUpperCase();\n const isRelative = absCommand !== pathCommand;\n const absoluteSegment = isRelative\n ? absolutizeSegment(seg, index, lastX, lastY)\n : (seg.slice(0) as typeof seg);\n\n const normalSegment = absCommand === \"V\"\n ? ([\"L\", lastX, absoluteSegment[1]] as LSegment)\n : absCommand === \"H\"\n ? ([\"L\", absoluteSegment[1], lastY] as LSegment)\n : absoluteSegment;\n [pathCommand] = normalSegment;\n\n if (!\"TQ\".includes(absCommand)) {\n // optional but good to be cautious\n paramQX = 0;\n paramQY = 0;\n }\n\n // this segment is always ZERO\n /* istanbul ignore else @preserve */\n if (pathCommand === \"M\") {\n // remember mx, my for Z\n [, mx, my] = normalSegment as MSegment;\n } else if (pathCommand === \"L\") {\n totalLength += getLineLength(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n );\n } else if (pathCommand === \"A\") {\n totalLength += getArcLength(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n normalSegment[5] as number,\n normalSegment[6] as number,\n normalSegment[7] as number,\n );\n } else if (pathCommand === \"S\") {\n const cp1x = paramX1 * 2 - paramX2;\n const cp1y = paramY1 * 2 - paramY2;\n\n totalLength += getCubicLength(\n lastX,\n lastY,\n cp1x,\n cp1y,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n );\n } else if (pathCommand === \"C\") {\n totalLength += getCubicLength(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n normalSegment[5] as number,\n normalSegment[6] as number,\n );\n } else if (pathCommand === \"T\") {\n paramQX = paramX1 * 2 - paramQX;\n paramQY = paramY1 * 2 - paramQY;\n totalLength += getQuadLength(\n lastX,\n lastY,\n paramQX,\n paramQY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n );\n } else if (pathCommand === \"Q\") {\n paramQX = normalSegment[1] as number;\n paramQY = normalSegment[2] as number;\n totalLength += getQuadLength(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n );\n } else if (pathCommand === \"Z\") {\n totalLength += getLineLength(lastX, lastY, mx, my);\n }\n\n // update params\n [paramX1, paramY1] = pathCommand === \"Z\"\n ? [mx, my]\n : (normalSegment.slice(-2) as PointTuple);\n [paramX2, paramY2] = pathCommand === \"C\"\n ? ([normalSegment[3], normalSegment[4]] as PointTuple)\n : pathCommand === \"S\"\n ? ([normalSegment[1], normalSegment[2]] as PointTuple)\n : [paramX1, paramY1];\n });\n\n return totalLength;\n};\n\nexport default getTotalLength;\n","import type { PathArray, PathSegment } from \"../types\";\nimport type { SegmentProperties } from \"../interface\";\nimport parsePathString from \"../parser/parsePathString\";\nimport getTotalLength from \"./getTotalLength\";\n\n/**\n * Returns the segment, its index and length as well as\n * the length to that segment at a given length in a path.\n *\n * @param pathInput target `pathArray`\n * @param distance the given length\n * @returns the requested properties\n */\nconst getPropertiesAtLength = (\n pathInput: string | PathArray,\n distance?: number,\n): SegmentProperties => {\n const pathArray = parsePathString(pathInput);\n\n let pathTemp = pathArray.slice(0) as PathArray;\n let pathLength = getTotalLength(pathTemp);\n let index = pathTemp.length - 1;\n let lengthAtSegment = 0;\n let length = 0;\n let segment = pathArray[0] as PathSegment;\n\n // If the path is empty, return 0.\n if (index <= 0 || !distance || !Number.isFinite(distance)) {\n return {\n segment,\n index: 0,\n length,\n lengthAtSegment,\n };\n }\n\n if (distance >= pathLength) {\n pathTemp = pathArray.slice(0, -1) as PathArray;\n lengthAtSegment = getTotalLength(pathTemp);\n length = pathLength - lengthAtSegment;\n segment = pathArray[index];\n return {\n segment,\n index,\n length,\n lengthAtSegment,\n };\n }\n\n const segments = [] as SegmentProperties[];\n while (index > 0) {\n segment = pathTemp[index];\n pathTemp = pathTemp.slice(0, -1) as PathArray;\n lengthAtSegment = getTotalLength(pathTemp);\n length = pathLength - lengthAtSegment;\n pathLength = lengthAtSegment;\n\n segments.push({\n segment,\n index,\n length,\n lengthAtSegment,\n });\n index -= 1;\n }\n\n return segments.find(({ lengthAtSegment: l }) =>\n l <= distance\n ) as SegmentProperties;\n};\n\nexport default getPropertiesAtLength;\n","import type { PathArray, Point } from \"../types\";\nimport type { PointProperties } from \"../interface\";\nimport getPointAtLength from \"./getPointAtLength\";\nimport getPropertiesAtLength from \"./getPropertiesAtLength\";\nimport getTotalLength from \"./getTotalLength\";\nimport parsePathString from \"../parser/parsePathString\";\nimport normalizePath from \"../process/normalizePath\";\n\n/**\n * Returns the point and segment in path closest to a given point as well as\n * the distance to the path stroke.\n *\n * @see https://bl.ocks.org/mbostock/8027637\n *\n * @param pathInput target `pathArray`\n * @param point the given point\n * @returns the requested properties\n */\nconst getPropertiesAtPoint = (\n pathInput: string | PathArray,\n point: Point,\n): PointProperties => {\n const path = parsePathString(pathInput);\n const normalPath = normalizePath(path);\n const pathLength = getTotalLength(normalPath);\n const distanceTo = (p: Point) => {\n const dx = p.x - point.x;\n const dy = p.y - point.y;\n return dx * dx + dy * dy;\n };\n let precision = 8;\n let scan: Point;\n let closest = { x: 0, y: 0 }; // make TS happy\n let scanDistance = 0;\n let bestLength = 0;\n let bestDistance = Infinity;\n\n // linear scan for coarse approximation\n for (let scanLength = 0; scanLength <= pathLength; scanLength += precision) {\n scan = getPointAtLength(normalPath, scanLength);\n scanDistance = distanceTo(scan);\n\n if (scanDistance < bestDistance) {\n closest = scan;\n bestLength = scanLength;\n bestDistance = scanDistance;\n }\n }\n\n // binary search for precise estimate\n precision /= 2;\n let before: { x: number; y: number };\n let after: { x: number; y: number };\n let beforeLength = 0;\n let afterLength = 0;\n let beforeDistance = 0;\n let afterDistance = 0;\n\n while (precision > 0.000001) {\n beforeLength = bestLength - precision;\n before = getPointAtLength(normalPath, beforeLength);\n beforeDistance = distanceTo(before);\n afterLength = bestLength + precision;\n after = getPointAtLength(normalPath, afterLength);\n afterDistance = distanceTo(after);\n\n if (beforeLength >= 0 && beforeDistance < bestDistance) {\n closest = before;\n bestLength = beforeLength;\n bestDistance = beforeDistance;\n } else if (afterLength <= pathLength && afterDistance < bestDistance) {\n closest = after;\n bestLength = afterLength;\n bestDistance = afterDistance;\n } else {\n precision /= 2;\n }\n if (precision < 0.00001) break;\n }\n\n const segment = getPropertiesAtLength(path, bestLength);\n const distance = Math.sqrt(bestDistance);\n\n return { closest, distance, segment };\n};\n\nexport default getPropertiesAtPoint;\n","import type { PathArray } from \"../types\";\nimport getPropertiesAtPoint from \"./getPropertiesAtPoint\";\n\n/**\n * Returns the point in path closest to a given point.\n *\n * @param pathInput target `pathArray`\n * @param point the given point\n * @returns the best match\n */\nconst getClosestPoint = (\n pathInput: string | PathArray,\n point: { x: number; y: number },\n) => {\n return getPropertiesAtPoint(pathInput, point).closest;\n};\n\nexport default getClosestPoint;\n","import pathToCurve from \"../convert/pathToCurve\";\nimport type { PathArray, PointTuple } from \"../types\";\n\n/**\n * Returns the area of a single cubic-bezier segment.\n *\n * http://objectmix.com/graphics/133553-area-closed-bezier-curve.html\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the area of the cubic-bezier segment\n */\nconst getCubicSegArea = (\n x1: number,\n y1: number,\n c1x: number,\n c1y: number,\n c2x: number,\n c2y: number,\n x2: number,\n y2: number,\n) => {\n return (\n (3 *\n ((y2 - y1) * (c1x + c2x) -\n (x2 - x1) * (c1y + c2y) +\n c1y * (x1 - c2x) -\n c1x * (y1 - c2y) +\n y2 * (c2x + x1 / 3) -\n x2 * (c2y + y1 / 3))) /\n 20\n );\n};\n\n/**\n * Returns the area of a shape.\n *\n * @author Jürg Lehni & Jonathan Puckey\n *\n * @see https://github.com/paperjs/paper.js/blob/develop/src/path/Path.js\n *\n * @param path the shape `pathArray`\n * @returns the length of the cubic-bezier segment\n */\nconst getPathArea = (path: PathArray) => {\n let x = 0;\n let y = 0;\n let len = 0;\n\n return pathToCurve(path)\n .map((seg) => {\n switch (seg[0]) {\n case \"M\":\n [, x, y] = seg;\n return 0;\n default:\n len = getCubicSegArea(\n x,\n y,\n seg[1],\n seg[2],\n seg[3],\n seg[4],\n seg[5],\n seg[6],\n );\n [x, y] = seg.slice(-2) as PointTuple;\n return len;\n }\n })\n .reduce((a, b) => a + b, 0);\n};\nexport default getPathArea;\n","import getPathArea from \"./getPathArea\";\nimport pathToCurve from \"../convert/pathToCurve\";\nimport type { PathArray } from \"../types\";\n\n/**\n * Check if a path is drawn clockwise and returns true if so,\n * false otherwise.\n *\n * @param path the path string or `pathArray`\n * @returns true when clockwise or false if not\n */\nconst getDrawDirection = (path: string | PathArray) => {\n return getPathArea(pathToCurve(path)) >= 0;\n};\n\nexport default getDrawDirection;\n","import iterate from \"../process/iterate\";\nimport { PathBBox } from \"../interface\";\nimport { LSegment, MSegment, PathArray, PointTuple } from \"../types\";\nimport { getLineBBox } from \"../math/lineTools\";\nimport { getArcBBox } from \"../math/arcTools\";\nimport { getCubicBBox } from \"../math/cubicTools\";\nimport { getQuadBBox } from \"../math/quadTools\";\nimport parsePathString from \"../parser/parsePathString\";\nimport absolutizeSegment from \"../process/absolutizeSegment\";\n\nconst getPathBBox = (pathInput: PathArray | string) => {\n if (!pathInput) {\n return {\n x: 0,\n y: 0,\n width: 0,\n height: 0,\n x2: 0,\n y2: 0,\n cx: 0,\n cy: 0,\n cz: 0,\n };\n }\n\n const path = parsePathString(pathInput);\n let pathCommand = \"M\";\n let mx = 0;\n let my = 0;\n const { max, min } = Math;\n let xMin = Infinity;\n let yMin = Infinity;\n let xMax = -Infinity;\n let yMax = -Infinity;\n let minX = 0;\n let minY = 0;\n let maxX = 0;\n let maxY = 0;\n let paramX1 = 0;\n let paramY1 = 0;\n let paramX2 = 0;\n let paramY2 = 0;\n let paramQX = 0;\n let paramQY = 0;\n\n iterate(path, (seg, index, lastX, lastY) => {\n [pathCommand] = seg;\n const absCommand = pathCommand.toUpperCase();\n const isRelative = absCommand !== pathCommand;\n const absoluteSegment = isRelative\n ? absolutizeSegment(seg, index, lastX, lastY)\n : (seg.slice(0) as typeof seg);\n\n const normalSegment = absCommand === \"V\"\n ? ([\"L\", lastX, absoluteSegment[1]] as LSegment)\n : absCommand === \"H\"\n ? ([\"L\", absoluteSegment[1], lastY] as LSegment)\n : absoluteSegment;\n\n [pathCommand] = normalSegment;\n\n if (!\"TQ\".includes(absCommand)) {\n // optional but good to be cautious\n paramQX = 0;\n paramQY = 0;\n }\n\n // this segment is always ZERO\n /* istanbul ignore else @preserve */\n if (pathCommand === \"M\") {\n [, mx, my] = normalSegment as MSegment;\n minX = mx;\n minY = my;\n maxX = mx;\n maxY = my;\n } else if (pathCommand === \"L\") {\n [minX, minY, maxX, maxY] = getLineBBox(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n );\n } else if (pathCommand === \"A\") {\n [minX, minY, maxX, maxY] = getArcBBox(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n normalSegment[5] as number,\n normalSegment[6] as number,\n normalSegment[7] as number,\n );\n } else if (pathCommand === \"S\") {\n const cp1x = paramX1 * 2 - paramX2;\n const cp1y = paramY1 * 2 - paramY2;\n\n [minX, minY, maxX, maxY] = getCubicBBox(\n lastX,\n lastY,\n cp1x,\n cp1y,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n );\n } else if (pathCommand === \"C\") {\n [minX, minY, maxX, maxY] = getCubicBBox(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n normalSegment[5] as number,\n normalSegment[6] as number,\n );\n } else if (pathCommand === \"T\") {\n paramQX = paramX1 * 2 - paramQX;\n paramQY = paramY1 * 2 - paramQY;\n [minX, minY, maxX, maxY] = getQuadBBox(\n lastX,\n lastY,\n paramQX,\n paramQY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n );\n } else if (pathCommand === \"Q\") {\n paramQX = normalSegment[1] as number;\n paramQY = normalSegment[2] as number;\n [minX, minY, maxX, maxY] = getQuadBBox(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n );\n } else if (pathCommand === \"Z\") {\n [minX, minY, maxX, maxY] = getLineBBox(lastX, lastY, mx, my);\n }\n xMin = min(minX, xMin);\n yMin = min(minY, yMin);\n xMax = max(maxX, xMax);\n yMax = max(maxY, yMax);\n\n // update params\n [paramX1, paramY1] = pathCommand === \"Z\"\n ? [mx, my]\n : (normalSegment.slice(-2) as PointTuple);\n [paramX2, paramY2] = pathCommand === \"C\"\n ? ([normalSegment[3], normalSegment[4]] as PointTuple)\n : pathCommand === \"S\"\n ? ([normalSegment[1], normalSegment[2]] as PointTuple)\n : [paramX1, paramY1];\n });\n\n const width = xMax - xMin;\n const height = yMax - yMin;\n\n return {\n width,\n height,\n x: xMin,\n y: yMin,\n x2: xMax,\n y2: yMax,\n cx: xMin + width / 2,\n cy: yMin + height / 2,\n // an estimated guess\n cz: Math.max(width, height) + Math.min(width, height) / 2,\n } satisfies PathBBox;\n};\n\nexport default getPathBBox;\n","import type { PathArray, PathSegment } from \"../types\";\nimport getPropertiesAtLength from \"./getPropertiesAtLength\";\n\n/**\n * Returns the segment at a given length.\n *\n * @param pathInput the target `pathArray`\n * @param distance the distance in path to look at\n * @returns the requested segment\n */\nconst getSegmentAtLength = (\n pathInput: string | PathArray,\n distance?: number,\n): PathSegment | undefined => {\n return getPropertiesAtLength(pathInput, distance).segment;\n};\n\nexport default getSegmentAtLength;\n","import type { SegmentProperties } from \"../interface\";\nimport type { PathArray } from \"../types\";\nimport getPropertiesAtPoint from \"./getPropertiesAtPoint\";\n\n/**\n * Returns the path segment which contains a given point.\n *\n * @param path the `pathArray` to look into\n * @param point the point of the shape to look for\n * @returns the requested segment\n */\nconst getSegmentOfPoint = (\n path: string | PathArray,\n point: { x: number; y: number },\n): SegmentProperties | undefined => {\n return getPropertiesAtPoint(path, point).segment;\n};\nexport default getSegmentOfPoint;\n","import type { PathArray, PathSegment, RelativeCommand } from \"../types\";\nimport paramsCount from \"../parser/paramsCount\";\n\n/**\n * Iterates an array to check if it's an actual `pathArray`.\n *\n * @param path the `pathArray` to be checked\n * @returns iteration result\n */\nconst isPathArray = (path: unknown): path is PathArray => {\n return (\n Array.isArray(path) &&\n path.every((seg: PathSegment) => {\n const lk = seg[0].toLowerCase() as RelativeCommand;\n return (\n paramsCount[lk] === seg.length - 1 &&\n \"achlmqstvz\".includes(lk) &&\n (seg.slice(1) as unknown[]).every(Number.isFinite)\n );\n }) &&\n path.length > 0\n );\n};\nexport default isPathArray;\n","import type { AbsoluteArray } from \"../types\";\nimport isPathArray from \"./isPathArray\";\n\n/**\n * Iterates an array to check if it's a `pathArray`\n * with all absolute values.\n *\n * @param path the `pathArray` to be checked\n * @returns iteration result\n */\nconst isAbsoluteArray = (path: unknown): path is AbsoluteArray => {\n return (\n isPathArray(path) &&\n // `isPathArray` also checks if it's `Array`\n path.every(([x]) => x === x.toUpperCase())\n );\n};\nexport default isAbsoluteArray;\n","import type { NormalArray } from \"../types\";\nimport isAbsoluteArray from \"./isAbsoluteArray\";\n\n/**\n * Iterates an array to check if it's a `pathArray`\n * with all segments are in non-shorthand notation\n * with absolute values.\n *\n * @param {string | SVGPath.pathArray} path the `pathArray` to be checked\n * @returns {boolean} iteration result\n */\nconst isNormalizedArray = (path: unknown): path is NormalArray => {\n // `isAbsoluteArray` also checks if it's `Array`\n return isAbsoluteArray(path) && path.every(([pc]) => \"ACLMQZ\".includes(pc));\n};\nexport default isNormalizedArray;\n","import { CurveArray } from \"../types\";\nimport isNormalizedArray from \"./isNormalizedArray\";\n\n/**\n * Iterates an array to check if it's a `pathArray`\n * with all C (cubic bezier) segments.\n *\n * @param path the `Array` to be checked\n * @returns iteration result\n */\nconst isCurveArray = (path: unknown): path is CurveArray => {\n // `isPathArray` also checks if it's `Array`\n return isNormalizedArray(path) && path.every(([pc]) => \"MC\".includes(pc));\n};\nexport default isCurveArray;\n","import type { PathArray } from \"../types\";\nimport getPropertiesAtPoint from \"./getPropertiesAtPoint\";\nimport DISTANCE_EPSILON from \"./distanceEpsilon\";\n\n/**\n * Checks if a given point is in the stroke of a path.\n *\n * @param pathInput target path\n * @param point the given `{x,y}` point\n * @returns the query result\n */\nconst isPointInStroke = (\n pathInput: string | PathArray,\n point: { x: number; y: number },\n) => {\n const { distance } = getPropertiesAtPoint(pathInput, point);\n return Math.abs(distance) < DISTANCE_EPSILON; // 0.01 might be more permissive\n};\nexport default isPointInStroke;\n","import type { RelativeArray } from \"../types\";\nimport isPathArray from \"./isPathArray\";\n\n/**\n * Iterates an array to check if it's a `pathArray`\n * with relative values.\n *\n * @param path the `pathArray` to be checked\n * @returns iteration result\n */\nconst isRelativeArray = (path: unknown): path is RelativeArray => {\n return (\n isPathArray(path) &&\n // `isPathArray` checks if it's `Array`\n path.slice(1).every(([pc]) => pc === pc.toLowerCase())\n );\n};\nexport default isRelativeArray;\n","import scanSegment from \"../parser/scanSegment\";\nimport skipSpaces from \"../parser/skipSpaces\";\nimport PathParser from \"../parser/pathParser\";\n\n/**\n * Parses a path string value to determine its validity\n * then returns true if it's valid or false otherwise.\n *\n * @param pathString the path string to be parsed\n * @returns the path string validity\n */\nconst isValidPath = (pathString: string) => {\n if (typeof pathString !== \"string\" || !pathString.length) {\n return false;\n }\n\n const path = new PathParser(pathString);\n\n skipSpaces(path);\n\n while (path.index < path.max && !path.err.length) {\n scanSegment(path);\n }\n\n return !path.err.length && \"mM\".includes(path.segments[0][0]);\n};\nexport default isValidPath;\n","import type { ShapeParams } from \"../interface\";\n\n/**\n * Supported shapes and their specific parameters.\n */\nconst shapeParams: ShapeParams = {\n line: [\"x1\", \"y1\", \"x2\", \"y2\"],\n circle: [\"cx\", \"cy\", \"r\"],\n ellipse: [\"cx\", \"cy\", \"rx\", \"ry\"],\n rect: [\"width\", \"height\", \"x\", \"y\", \"rx\", \"ry\"],\n polygon: [\"points\"],\n polyline: [\"points\"],\n glyph: [\"d\"],\n};\n\nexport default shapeParams;\n","const isElement = (node?: unknown): node is Element =>\n node !== undefined && node !== null &&\n typeof node === \"object\" &&\n (node as Node).nodeType === 1; // ELEMENT_NODE\n\nexport default isElement;\n","import type {\n CircleAttr,\n EllipseAttr,\n GlyphAttr,\n LineAttr,\n PolyAttr,\n RectAttr,\n ShapeParams,\n} from \"../interface\";\nimport type { PathArray, PathSegment, ShapeOps, ShapeTypes } from \"../types\";\nimport error from \"../parser/error\";\nimport parsePathString from \"../parser/parsePathString\";\nimport shapeParams from \"./shapeParams\";\nimport isPathArray from \"./isPathArray\";\nimport isElement from \"./isElement\";\n\n/**\n * Returns a new `pathArray` from line attributes.\n *\n * @param attr shape configuration\n * @returns a new line `pathArray`\n */\nexport const getLinePath = (attr: LineAttr): PathArray => {\n let { x1, y1, x2, y2 } = attr;\n [x1, y1, x2, y2] = [x1, y1, x2, y2].map((a) => +a);\n return [\n [\"M\", x1, y1],\n [\"L\", x2, y2],\n ];\n};\n\n/**\n * Returns a new `pathArray` like from polyline/polygon attributes.\n *\n * @param attr shape configuration\n * @return a new polygon/polyline `pathArray`\n */\nexport const getPolyPath = (attr: PolyAttr): PathArray => {\n const pathArray = [] as PathSegment[];\n const points = (attr.points || \"\")\n .trim()\n .split(/[\\s|,]/)\n .map((a) => +a);\n\n let index = 0;\n while (index < points.length) {\n pathArray.push([index ? \"L\" : \"M\", points[index], points[index + 1]]);\n index += 2;\n }\n\n return (attr.type === \"polygon\"\n ? [...pathArray, [\"z\"]]\n : pathArray) as PathArray;\n};\n\n/**\n * Returns a new `pathArray` from circle attributes.\n *\n * @param attr shape configuration\n * @return a circle `pathArray`\n */\nexport const getCirclePath = (attr: CircleAttr): PathArray => {\n let { cx, cy, r } = attr;\n [cx, cy, r] = [cx, cy, r].map((a) => +a);\n\n return [\n [\"M\", cx - r, cy],\n [\"a\", r, r, 0, 1, 0, 2 * r, 0],\n [\"a\", r, r, 0, 1, 0, -2 * r, 0],\n ];\n};\n\n/**\n * Returns a new `pathArray` from ellipse attributes.\n *\n * @param attr shape configuration\n * @return an ellipse `pathArray`\n */\nexport const getEllipsePath = (attr: EllipseAttr): PathArray => {\n let { cx, cy } = attr;\n let rx = attr.rx || 0;\n let ry = attr.ry || rx;\n [cx, cy, rx, ry] = [cx, cy, rx, ry].map((a) => +a);\n\n return [\n [\"M\", cx - rx, cy],\n [\"a\", rx, ry, 0, 1, 0, 2 * rx, 0],\n [\"a\", rx, ry, 0, 1, 0, -2 * rx, 0],\n ];\n};\n\n/**\n * Returns a new `pathArray` like from rect attributes.\n *\n * @param attr object with properties above\n * @return a new `pathArray` from `` attributes\n */\nexport const getRectanglePath = (attr: RectAttr): PathArray => {\n const x = +attr.x || 0;\n const y = +attr.y || 0;\n const w = +attr.width;\n const h = +attr.height;\n let rx = +(attr.rx || 0);\n let ry = +(attr.ry || rx);\n\n // Validity checks from http://www.w3.org/TR/SVG/shapes.html#RectElement:\n if (rx || ry) {\n // rx = !rx ? ry : rx;\n // ry = !ry ? rx : ry;\n\n /* istanbul ignore else @preserve */\n if (rx * 2 > w) rx -= (rx * 2 - w) / 2;\n /* istanbul ignore else @preserve */\n if (ry * 2 > h) ry -= (ry * 2 - h) / 2;\n\n return [\n [\"M\", x + rx, y],\n [\"h\", w - rx * 2],\n [\"s\", rx, 0, rx, ry],\n [\"v\", h - ry * 2],\n [\"s\", 0, ry, -rx, ry],\n [\"h\", -w + rx * 2],\n [\"s\", -rx, 0, -rx, -ry],\n [\"v\", -h + ry * 2],\n [\"s\", 0, -ry, rx, -ry],\n ];\n }\n\n return [[\"M\", x, y], [\"h\", w], [\"v\", h], [\"H\", x], [\"Z\"]];\n};\n\n/**\n * Returns a new `pathArray` created from attributes of a ``, ``,\n * ``, ``, ``, ``, or ``.\n *\n * It can also work with an options object, see the type below\n * @see ShapeOps\n *\n * @param element target shape\n * @return the newly created `` element\n */\nconst shapeToPathArray = (\n element: ShapeTypes | ShapeOps,\n) => {\n const supportedShapes = Object.keys(shapeParams) as (keyof ShapeParams)[];\n const targetIsElement = isElement(element);\n const tagName = targetIsElement ? element.tagName : null;\n\n if (tagName && [...supportedShapes, \"path\"].every((s) => tagName !== s)) {\n throw TypeError(`${error}: \"${tagName}\" is not SVGElement`);\n }\n\n const type =\n (targetIsElement ? tagName : (element as ShapeOps).type) as ShapeOps[\n \"type\"\n ];\n const shapeAttrs = shapeParams[type] as string[];\n const config = { type } as Record;\n\n if (targetIsElement) {\n shapeAttrs.forEach((p) => {\n config[p] = element.getAttribute(p) as string;\n });\n } else {\n Object.assign(config, element);\n }\n\n // set d\n let pathArray = [] as unknown as PathArray;\n\n /* istanbul ignore else */\n if (type === \"circle\") {\n pathArray = getCirclePath(config as unknown as CircleAttr);\n } else if (type === \"ellipse\") {\n pathArray = getEllipsePath(config as unknown as EllipseAttr);\n } else if ([\"polyline\", \"polygon\"].includes(type)) {\n pathArray = getPolyPath(config as unknown as PolyAttr);\n } else if (type === \"rect\") {\n pathArray = getRectanglePath(config as unknown as RectAttr);\n } else if (type === \"line\") {\n pathArray = getLinePath(config as unknown as LineAttr);\n } else if ([\"glyph\", \"path\"].includes(type)) {\n pathArray = parsePathString(\n targetIsElement\n ? element.getAttribute(\"d\") || /* istanbul ignore next @preserve */ \"\"\n : (element as GlyphAttr).d || \"\",\n );\n }\n\n // replace target element\n if (isPathArray(pathArray) && pathArray.length) {\n return pathArray;\n }\n return false;\n};\nexport default shapeToPathArray;\n","import type { ShapeParams } from \"../interface\";\nimport type { ShapeOps, ShapeTypes } from \"../types\";\nimport pathToString from \"../convert/pathToString\";\nimport defaultOptions from \"../options/options\";\nimport error from \"../parser/error\";\nimport isValidPath from \"./isValidPath\";\nimport isElement from \"./isElement\";\nimport shapeToPathArray from \"./shapeToPathArray\";\nimport shapeParams from \"./shapeParams\";\n\n/**\n * Returns a new `` element created from attributes of a ``, ``,\n * ``, ``, ``, `` or ``. If `replace` parameter\n * is `true`, it will replace the target. The default `ownerDocument` is your current\n * `document` browser page, if you want to use in server-side using `jsdom`, you can\n * pass the `jsdom` `document` to `ownDocument`.\n *\n * It can also work with an options object, see the type below\n * @see ShapeOps\n *\n * The newly created `` element keeps all non-specific\n * attributes like `class`, `fill`, etc.\n *\n * @param element target shape\n * @param replace option to replace target\n * @param ownerDocument document for create element\n * @return the newly created `` element\n */\nconst shapeToPath = (\n element: ShapeTypes | ShapeOps,\n replace?: boolean,\n ownerDocument?: Document,\n): SVGPathElement | false => {\n const doc = ownerDocument || document;\n const supportedShapes = Object.keys(shapeParams) as (keyof ShapeParams)[];\n const targetIsElement = isElement(element);\n const tagName = targetIsElement ? element.tagName : null;\n\n if (tagName === \"path\") {\n throw TypeError(`${error}: \"${tagName}\" is already SVGPathElement`);\n }\n if (tagName && supportedShapes.every((s) => tagName !== s)) {\n throw TypeError(`${error}: \"${tagName}\" is not SVGElement`);\n }\n\n const path = doc.createElementNS(\"http://www.w3.org/2000/svg\", \"path\");\n const type =\n (targetIsElement ? tagName : (element as ShapeOps).type) as ShapeOps[\n \"type\"\n ];\n const shapeAttrs = shapeParams[type] as string[];\n const config = { type } as Record;\n\n // set d\n const round = defaultOptions.round as number;\n const pathArray = shapeToPathArray(element);\n const description = pathArray && pathArray.length\n ? pathToString(pathArray, round)\n : \"\";\n\n if (targetIsElement) {\n shapeAttrs.forEach((p) => {\n config[p] = element.getAttribute(p) as string;\n });\n // set no-specific shape attributes: fill, stroke, etc\n Object.values(element.attributes).forEach(({ name, value }) => {\n if (!shapeAttrs.includes(name)) path.setAttribute(name, value);\n });\n } else {\n Object.assign(config, element);\n // set no-specific shape attributes: fill, stroke, etc\n Object.keys(config).forEach((k) => {\n if (!shapeAttrs.includes(k) && k !== \"type\") {\n path.setAttribute(\n k.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`),\n config[k],\n );\n }\n });\n }\n\n // replace target element\n if (isValidPath(description)) {\n path.setAttribute(\"d\", description);\n if (replace && targetIsElement) {\n element.before(path, element);\n element.remove();\n }\n return path;\n }\n return false;\n};\n\nexport default shapeToPath;\n","import CSSMatrix from \"@thednp/dommatrix\";\n// import type { TransformObject } from '../interface';\nimport type { TransformObjectValues } from \"../types\";\n\n/**\n * Returns a transformation matrix to apply to `` elements.\n *\n * @see TransformObjectValues\n *\n * @param transform the `transformObject`\n * @returns a new transformation matrix\n */\nconst getSVGMatrix = (transform: TransformObjectValues): CSSMatrix => {\n let matrix = new CSSMatrix();\n const { origin } = transform;\n const [originX, originY] = origin as [number, number, number];\n const { translate } = transform;\n const { rotate } = transform;\n const { skew } = transform;\n const { scale } = transform;\n\n // set translate\n if (\n Array.isArray(translate) &&\n translate.length >= 2 &&\n translate.every((x) => !Number.isNaN(+x)) &&\n translate.some((x) => x !== 0)\n ) {\n matrix = matrix.translate(...(translate as [number, number, number?]));\n } else if (typeof translate === \"number\" && !Number.isNaN(translate)) {\n matrix = matrix.translate(translate);\n }\n\n if (rotate || skew || scale) {\n // set SVG transform-origin, always defined\n matrix = matrix.translate(originX, originY);\n\n // set rotation\n if (\n Array.isArray(rotate) &&\n rotate.length >= 2 &&\n rotate.every((x) => !Number.isNaN(+x)) &&\n rotate.some((x) => x !== 0)\n ) {\n matrix = matrix.rotate(...(rotate as [number, number, number?]));\n } else if (typeof rotate === \"number\" && !Number.isNaN(rotate)) {\n matrix = matrix.rotate(rotate);\n }\n\n // set skew(s)\n if (\n Array.isArray(skew) && skew.length === 2 && skew.every((x) =>\n !Number.isNaN(+x)\n ) && skew.some((x) => x !== 0)\n ) {\n matrix = skew[0] ? matrix.skewX(skew[0]) : matrix;\n matrix = skew[1] ? matrix.skewY(skew[1]) : matrix;\n } else if (typeof skew === \"number\" && !Number.isNaN(skew)) {\n matrix = matrix.skewX(skew);\n }\n\n // set scale\n if (\n Array.isArray(scale) && scale.length >= 2 && scale.every((x) =>\n !Number.isNaN(+x)\n ) && scale.some((x) => x !== 1)\n ) {\n matrix = matrix.scale(...(scale as [number, number, number?]));\n } else if (typeof scale === \"number\" && !Number.isNaN(scale)) {\n matrix = matrix.scale(scale);\n }\n // set SVG transform-origin\n matrix = matrix.translate(-originX, -originY);\n }\n\n return matrix;\n};\nexport default getSVGMatrix;\n","import defaultOptions from \"../options/options\";\nimport type { ParserParams } from \"../interface\";\nimport roundTo from \"../math/roundTo\";\nimport type {\n AbsoluteSegment,\n NormalSegment,\n PathCommand,\n ShortSegment,\n SSegment,\n TSegment,\n} from \"../types\";\n\n/**\n * Shorten a single segment of a `pathArray` object.\n *\n * @param segment the `absoluteSegment` object\n * @param normalSegment the `normalSegment` object\n * @param params the coordinates of the previous segment\n * @param prevCommand the path command of the previous segment\n * @returns the shortened segment\n */\nconst shortenSegment = (\n segment: AbsoluteSegment,\n normalSegment: NormalSegment,\n params: ParserParams,\n prevCommand: PathCommand,\n): ShortSegment => {\n const [pathCommand] = segment;\n const { round: defaultRound } = defaultOptions;\n const round = typeof defaultRound === \"number\"\n ? defaultRound\n : /* istanbul ignore next */ 4;\n const normalValues = normalSegment.slice(1) as number[];\n const { x1, y1, x2, y2, x, y } = params;\n const [nx, ny] = normalValues.slice(-2);\n const result = segment;\n\n if (!\"TQ\".includes(pathCommand)) {\n // optional but good to be cautious\n params.qx = null;\n params.qy = null;\n }\n\n if (pathCommand === \"L\") {\n if (roundTo(x, round) === roundTo(nx, round)) {\n return [\"V\", ny];\n } else if (roundTo(y, round) === roundTo(ny, round)) {\n return [\"H\", nx];\n }\n } else if (pathCommand === \"C\") {\n const [nx1, ny1] = normalValues;\n params.x1 = nx1;\n params.y1 = ny1;\n\n if (\n \"CS\".includes(prevCommand) &&\n ((roundTo(nx1, round) === roundTo(x1 * 2 - x2, round) &&\n roundTo(ny1, round) === roundTo(y1 * 2 - y2, round)) ||\n (roundTo(x1, round) === roundTo(x2 * 2 - x, round) &&\n roundTo(y1, round) === roundTo(y2 * 2 - y, round)))\n ) {\n return [\n \"S\",\n normalValues[2],\n normalValues[3],\n normalValues[4],\n normalValues[5],\n ] as SSegment;\n }\n } else if (pathCommand === \"Q\") {\n const [qx, qy] = normalValues;\n params.qx = qx;\n params.qy = qy;\n\n if (\n \"QT\".includes(prevCommand) &&\n roundTo(qx, round) === roundTo(x1 * 2 - x2, round) &&\n roundTo(qy, round) === roundTo(y1 * 2 - y2, round)\n ) {\n return [\"T\", normalValues[2], normalValues[3]] as TSegment;\n }\n }\n\n // ['V', 'H', 'S', 'T', 'Z'].includes(pathCommand)\n return result as ShortSegment;\n};\n\nexport default shortenSegment;\n","import type { PathCommand, PathSegment } from \"../types\";\nimport roundTo from \"../math/roundTo\";\n\nconst roundSegment = (\n segment: T,\n roundOption: number,\n) => {\n const values = (segment.slice(1) as number[]).map((n) =>\n roundTo(n, roundOption)\n );\n return [segment[0] as PathCommand | number].concat(values) as T;\n};\n\nexport default roundSegment;\n","import type { AbsoluteSegment, PathArray, PathCommand } from \"../types\";\nimport pathToAbsolute from \"../convert/pathToAbsolute\";\nimport shortenSegment from \"./shortenSegment\";\nimport paramsParser from \"../parser/paramsParser\";\nimport iterate from \"./iterate\";\nimport normalizeSegment from \"./normalizeSegment\";\nimport relativizeSegment from \"./relativizeSegment\";\nimport roundSegment from \"./roundSegment\";\n\n/**\n * Optimizes a `pathArray` object:\n * * convert segments to shorthand if possible\n * * select shortest segments from absolute and relative `pathArray`s\n *\n * @param pathInput a string or `pathArray`\n * @param roundOption the amount of decimals to round values to\n * @returns the optimized `pathArray`\n */\nconst optimizePath = (pathInput: PathArray, roundOption?: number) => {\n const path = pathToAbsolute(pathInput);\n // allow for ZERO decimals or use an aggressive value of 2\n const round = typeof roundOption === \"number\" && roundOption >= 0\n ? roundOption\n : /* istanbul ignore next @preserve */ 2;\n // this utility overrides the iterator params\n const optimParams = { ...paramsParser };\n\n const allPathCommands = [] as PathCommand[];\n let pathCommand = \"M\" as PathCommand;\n let prevCommand = \"Z\" as PathCommand;\n\n return iterate(path, (seg, i, lastX, lastY) => {\n optimParams.x = lastX;\n optimParams.y = lastY;\n const normalizedSegment = normalizeSegment(seg, optimParams);\n let result = seg;\n [pathCommand] = seg;\n\n // Save current path command\n allPathCommands[i] = pathCommand;\n if (i) {\n // Get previous path command for `shortenSegment`\n prevCommand = allPathCommands[i - 1];\n const shortSegment = shortenSegment(\n seg as AbsoluteSegment,\n normalizedSegment,\n optimParams,\n prevCommand,\n );\n const absSegment = roundSegment(shortSegment, round);\n const absString = absSegment.join(\"\");\n const relativeSegment = relativizeSegment(shortSegment, i, lastX, lastY);\n const relSegment = roundSegment(relativeSegment, round);\n const relString = relSegment.join(\"\");\n result = absString.length < relString.length ? absSegment : relSegment;\n }\n\n const seglen = normalizedSegment.length;\n optimParams.x1 = +normalizedSegment[seglen - 2];\n optimParams.y1 = +normalizedSegment[seglen - 1];\n optimParams.x2 = +normalizedSegment[seglen - 4] || optimParams.x1;\n optimParams.y2 = +normalizedSegment[seglen - 3] || optimParams.y1;\n\n return result;\n });\n};\n\nexport default optimizePath;\n","import CSSMatrix from \"@thednp/dommatrix\";\nimport { type PointTuple } from \"../types\";\n\n/**\n * Transforms a specified point using a matrix, returning a new\n * Tuple *Object* comprising of the transformed point.\n * Neither the matrix nor the original point are altered.\n *\n * @copyright thednp © 2021\n *\n * @param cssm CSSMatrix instance\n * @param v Tuple\n * @return the resulting Tuple\n */\nconst translatePoint = (\n cssm: CSSMatrix,\n v: [number, number, number, number],\n): [number, number, number, number] => {\n let m = CSSMatrix.Translate(v[0], v[1], v[2]);\n\n [, , , m.m44] = v;\n m = cssm.multiply(m);\n\n return [m.m41, m.m42, m.m43, m.m44];\n};\n\n/**\n * Returns the [x,y] projected coordinates for a given an [x,y] point\n * and an [x,y,z] perspective origin point.\n *\n * Equation found here =>\n * http://en.wikipedia.org/wiki/3D_projection#Diagram\n * Details =>\n * https://stackoverflow.com/questions/23792505/predicted-rendering-of-css-3d-transformed-pixel\n *\n * @param m the transformation matrix\n * @param point2D the initial [x,y] coordinates\n * @param origin the [x,y,z] transform origin\n * @returns the projected [x,y] coordinates\n */\nconst projection2d = (\n m: CSSMatrix,\n point2D: PointTuple,\n origin: [number, number, number],\n): PointTuple => {\n const [originX, originY, originZ] = origin;\n const [x, y, z] = translatePoint(m, [point2D[0], point2D[1], 0, 1]);\n\n const relativePositionX = x - originX;\n const relativePositionY = y - originY;\n const relativePositionZ = z - originZ;\n\n return [\n // protect against division by ZERO\n relativePositionX * (Math.abs(originZ) / Math.abs(relativePositionZ) || 1) +\n originX,\n relativePositionY * (Math.abs(originZ) / Math.abs(relativePositionZ) || 1) +\n originY,\n ];\n};\nexport default projection2d;\n","import type { CSegment, CurveArray, MSegment, PathCommand } from \"../types\";\n\n/**\n * Reverses all segments of a `pathArray`\n * which consists of only C (cubic-bezier) path commands.\n *\n * @param path the source `pathArray`\n * @returns the reversed `pathArray`\n */\nconst reverseCurve = (path: CurveArray) => {\n const rotatedCurve = path\n .slice(1)\n .map((x, i, curveOnly) =>\n !i\n ? path[0].slice(1).concat(x.slice(1) as number[])\n : curveOnly[i - 1].slice(-2).concat(x.slice(1))\n )\n .map((x) => x.map((_, i) => x[x.length - i - 2 * (1 - (i % 2))]))\n .reverse() as (MSegment | CSegment)[];\n\n return [[\"M\" as PathCommand | number].concat(rotatedCurve[0].slice(0, 2))]\n .concat(\n rotatedCurve.map((x) => [\"C\" as PathCommand | number].concat(x.slice(2))),\n ) as CurveArray;\n};\n\nexport default reverseCurve;\n","import type {\n ASegment,\n CSegment,\n HSegment,\n MSegment,\n PathArray,\n PathSegment,\n PointTuple,\n QSegment,\n SSegment,\n TSegment,\n VSegment,\n} from \"../types\";\nimport pathToAbsolute from \"../convert/pathToAbsolute\";\nimport normalizePath from \"./normalizePath\";\nimport iterate from \"./iterate\";\n\n/**\n * Reverses all segments of a `pathArray` and returns a new `pathArray` instance\n * with absolute values.\n *\n * @param pathInput the source `pathArray`\n * @returns the reversed `pathArray`\n */\nconst reversePath = (pathInput: PathArray) => {\n const absolutePath = pathToAbsolute(pathInput);\n const normalizedPath = normalizePath(absolutePath);\n const pLen = absolutePath.length;\n const isClosed = absolutePath[pLen - 1][0] === \"Z\";\n\n const reversedPath = iterate(absolutePath, (segment, i) => {\n const normalizedSegment = normalizedPath[i];\n const prevSeg = i && absolutePath[i - 1];\n const prevCommand = prevSeg && prevSeg[0];\n const nextSeg = absolutePath[i + 1];\n const nextCommand = nextSeg && nextSeg[0];\n const [pathCommand] = segment;\n const [x, y] = normalizedPath[i ? i - 1 : pLen - 1].slice(-2) as PointTuple;\n let result = segment;\n\n switch (pathCommand) {\n case \"M\":\n result = (isClosed ? [\"Z\"] : [pathCommand, x, y]) as PathSegment;\n break;\n case \"A\":\n result = [\n pathCommand,\n segment[1],\n segment[2],\n segment[3],\n segment[4],\n segment[5] === 1 ? 0 : 1,\n x,\n y,\n ] as ASegment;\n break;\n case \"C\":\n if (nextSeg && nextCommand === \"S\") {\n result = [\"S\", segment[1], segment[2], x, y] as SSegment;\n } else {\n result = [\n pathCommand,\n segment[3],\n segment[4],\n segment[1],\n segment[2],\n x,\n y,\n ] as CSegment;\n }\n break;\n case \"S\":\n if (\n prevCommand && \"CS\".includes(prevCommand) &&\n (!nextSeg || nextCommand !== \"S\")\n ) {\n result = [\n \"C\",\n normalizedSegment[3],\n normalizedSegment[4],\n normalizedSegment[1],\n normalizedSegment[2],\n x,\n y,\n ] as CSegment;\n } else {\n result = [\n pathCommand,\n normalizedSegment[1],\n normalizedSegment[2],\n x,\n y,\n ] as SSegment;\n }\n break;\n case \"Q\":\n if (nextSeg && nextCommand === \"T\") {\n result = [\"T\", x, y] as TSegment;\n } else {\n result = [pathCommand, segment[1], segment[2], x, y] as QSegment;\n }\n break;\n case \"T\":\n if (\n prevCommand && \"QT\".includes(prevCommand) &&\n (!nextSeg || nextCommand !== \"T\")\n ) {\n result = [\n \"Q\",\n normalizedSegment[1],\n normalizedSegment[2],\n x,\n y,\n ] as QSegment;\n } else {\n result = [pathCommand, x, y] as TSegment;\n }\n break;\n case \"Z\":\n result = [\"M\", x, y] as MSegment;\n break;\n case \"H\":\n result = [pathCommand, x] as HSegment;\n break;\n case \"V\":\n result = [pathCommand, y] as VSegment;\n break;\n default:\n result = [pathCommand as typeof pathCommand | number].concat(\n segment.slice(1, -2),\n x,\n y,\n ) as PathSegment;\n }\n\n return result;\n });\n\n return (\n isClosed\n ? reversedPath.reverse()\n : [reversedPath[0] as PathSegment].concat(reversedPath.slice(1).reverse())\n ) as PathArray;\n};\n\nexport default reversePath;\n","import type { PathArray } from \"../types\";\nimport defaultOptions from \"../options/options\";\nimport iterate from \"./iterate\";\nimport roundSegment from \"./roundSegment\";\n\n/**\n * Rounds the values of a `pathArray` instance to\n * a specified amount of decimals and returns it.\n *\n * @param path the source `pathArray`\n * @param roundOption the amount of decimals to round numbers to\n * @returns the resulted `pathArray` with rounded values\n */\nconst roundPath = (path: PathArray, roundOption?: number | \"off\") => {\n let { round } = defaultOptions;\n // allow for ZERO decimals\n round = roundOption === \"off\"\n ? roundOption\n : typeof roundOption === \"number\" && roundOption >= 0\n ? roundOption\n : typeof round === \"number\" && round >= 0\n ? round\n : /* istanbul ignore next @preserve */ \"off\";\n\n /* istanbul ignore else @preserve */\n if (round === \"off\") return path.slice(0) as PathArray;\n\n return iterate(path, (segment) => {\n return roundSegment(segment, round);\n });\n};\nexport default roundPath;\n","import midPoint from \"../math/midPoint\";\nimport type { CubicSegment, PointTuple } from \"../types\";\n\n/**\n * Split a cubic-bezier segment into two.\n *\n * @param pts the cubic-bezier parameters\n * @param ratio the cubic-bezier parameters\n * @return two new cubic-bezier segments\n */\nconst splitCubic = (\n pts: number[],\n ratio = 0.5,\n): [CubicSegment, CubicSegment] => {\n const t = ratio;\n const p0 = pts.slice(0, 2) as PointTuple;\n const p1 = pts.slice(2, 4) as PointTuple;\n const p2 = pts.slice(4, 6) as PointTuple;\n const p3 = pts.slice(6, 8) as PointTuple;\n const p4 = midPoint(p0, p1, t);\n const p5 = midPoint(p1, p2, t);\n const p6 = midPoint(p2, p3, t);\n const p7 = midPoint(p4, p5, t);\n const p8 = midPoint(p5, p6, t);\n const p9 = midPoint(p7, p8, t);\n\n return [\n [\"C\", p4[0], p4[1], p7[0], p7[1], p9[0], p9[1]],\n [\"C\", p8[0], p8[1], p6[0], p6[1], p3[0], p3[1]],\n ];\n};\nexport default splitCubic;\n","import paramsParser from \"../parser/paramsParser\";\nimport type {\n AbsoluteCommand,\n HSegment,\n MSegment,\n PathArray,\n PointTuple,\n RelativeCommand,\n VSegment,\n} from \"../types\";\n\n/**\n * Split a path into an `Array` of sub-path strings.\n *\n * In the process, values are converted to absolute\n * for visual consistency.\n *\n * @param pathInput the source `pathArray`\n * @return an array with all sub-path strings\n */\nconst splitPath = (pathInput: PathArray): PathArray[] => {\n const composite = [] as PathArray[];\n let path: PathArray;\n let pi = -1;\n let x = 0;\n let y = 0;\n let mx = 0;\n let my = 0;\n const params = { ...paramsParser };\n\n pathInput.forEach((seg) => {\n const [pathCommand] = seg;\n const absCommand = pathCommand.toUpperCase() as AbsoluteCommand;\n const relCommand = pathCommand.toLowerCase() as RelativeCommand;\n const isRelative = pathCommand === relCommand;\n const values = seg.slice(1) as number[];\n\n if (absCommand === \"M\") {\n pi += 1;\n [x, y] = values as PointTuple;\n x += isRelative ? params.x : 0;\n y += isRelative ? params.y : 0;\n mx = x;\n my = y;\n path = [(isRelative ? [absCommand, mx, my] : seg) as MSegment];\n } else {\n if (absCommand === \"Z\") {\n x = mx;\n y = my;\n } else if (absCommand === \"H\") {\n [, x] = seg as HSegment;\n x += isRelative ? params.x : /* istanbul ignore next @preserve */ 0;\n } else if (absCommand === \"V\") {\n [, y] = seg as VSegment;\n y += isRelative ? params.y : /* istanbul ignore next @preserve */ 0;\n } else {\n [x, y] = seg.slice(-2) as PointTuple;\n x += isRelative ? params.x : 0;\n y += isRelative ? params.y : 0;\n }\n path.push(seg);\n }\n\n params.x = x;\n params.y = y;\n composite[pi] = path;\n });\n\n return composite;\n};\nexport default splitPath;\n","import getSVGMatrix from \"./getSVGMatrix\";\nimport projection2d from \"./projection2d\";\nimport defaultOptions from \"../options/options\";\nimport type {\n AbsoluteArray,\n AbsoluteSegment,\n CSegment,\n LSegment,\n PathArray,\n TransformObjectValues,\n} from \"../types\";\nimport type { TransformObject } from \"../interface\";\nimport iterate from \"./iterate\";\nimport parsePathString from \"../parser/parsePathString\";\nimport absolutizeSegment from \"./absolutizeSegment\";\nimport arcToCubic from \"./arcToCubic\";\n\n/**\n * Apply a 2D / 3D transformation to a `pathArray` instance.\n *\n * Since *SVGElement* doesn't support 3D transformation, this function\n * creates a 2D projection of the element.\n *\n * @param path the `pathArray` to apply transformation\n * @param transform the transform functions `Object`\n * @returns the resulted `pathArray`\n */\nconst transformPath = (\n pathInput: PathArray | string,\n transform?: Partial,\n) => {\n // last x and y transformed values\n let x = 0;\n let y = 0;\n // new x and y transformed\n let lx = 0;\n let ly = 0;\n // segment params iteration index and length\n let j = 0;\n let jj = 0;\n let pathCommand = \"M\";\n // transform uses it's own set of params\n const path = parsePathString(pathInput);\n const transformProps = transform && Object.keys(transform);\n\n // when used as a static method, invalidate somehow\n if (!transform || (transformProps && !transformProps.length)) {\n return path.slice(0) as typeof path;\n }\n\n // transform origin is extremely important\n if (!transform.origin) {\n Object.assign(transform, { origin: defaultOptions.origin });\n }\n const origin = transform.origin as [number, number, number];\n const matrixInstance = getSVGMatrix(transform as TransformObjectValues);\n\n if (matrixInstance.isIdentity) return path.slice(0) as typeof path;\n\n return iterate(path, (seg, index, lastX, lastY) => {\n [pathCommand] = seg;\n const absCommand = pathCommand.toUpperCase();\n const isRelative = absCommand !== pathCommand;\n const absoluteSegment = isRelative\n ? absolutizeSegment(seg, index, lastX, lastY)\n : (seg.slice(0) as AbsoluteSegment);\n\n let result = absCommand === \"A\"\n // ? segmentToCubic(absoluteSegment, transformParams)\n ? ([\"C\" as string | number].concat(\n arcToCubic(\n lastX,\n lastY,\n absoluteSegment[1] as number,\n absoluteSegment[2] as number,\n absoluteSegment[3] as number,\n absoluteSegment[4] as number,\n absoluteSegment[5] as number,\n absoluteSegment[6] as number,\n absoluteSegment[7] as number,\n ),\n ) as CSegment)\n : absCommand === \"V\"\n ? ([\"L\", lastX, absoluteSegment[1]] as LSegment)\n : absCommand === \"H\"\n ? ([\"L\", absoluteSegment[1], lastY] as LSegment)\n : absoluteSegment;\n\n // update pathCommand\n pathCommand = result[0];\n const isLongArc = pathCommand === \"C\" && result.length > 7;\n const tempSegment =\n (isLongArc ? result.slice(0, 7) : result.slice(0)) as AbsoluteSegment;\n\n if (isLongArc) {\n path.splice(\n index + 1,\n 0,\n [\"C\" as typeof pathCommand | number].concat(\n result.slice(7),\n ) as CSegment,\n );\n result = tempSegment as CSegment;\n }\n\n if (pathCommand === \"L\") {\n [lx, ly] = projection2d(matrixInstance, [\n (result as LSegment)[1],\n (result as LSegment)[2],\n ], origin);\n\n /* istanbul ignore else @preserve */\n if (x !== lx && y !== ly) {\n result = [\"L\", lx, ly];\n } else if (y === ly) {\n result = [\"H\", lx];\n } else if (x === lx) {\n result = [\"V\", ly];\n }\n } else {\n for (j = 1, jj = result.length; j < jj; j += 2) {\n [lx, ly] = projection2d(\n matrixInstance,\n [+result[j], +result[j + 1]],\n origin,\n );\n result[j] = lx;\n result[j + 1] = ly;\n }\n }\n // now update x and y\n x = lx;\n y = ly;\n\n return result;\n });\n};\n\nexport default transformPath;\n"],"mappings":"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","names":["util_exports","__export","absolutizeSegment_default","arcToCubic_default","arcTools_exports","bezier_exports","cubicTools_exports","distanceEpsilon_default","distanceSquareRoot_default","finalizeSegment_default","getClosestPoint_default","getDrawDirection_default","getPathArea_default","getPathBBox_default","getPointAtLength_default","getPropertiesAtLength_default","getPropertiesAtPoint_default","getSVGMatrix_default","getSegmentAtLength_default","getSegmentOfPoint_default","getTotalLength_default","invalidPathValue_default","isAbsoluteArray_default","isArcCommand_default","isCurveArray_default","isDigit_default","isDigitStart_default","isMoveCommand_default","isNormalizedArray_default","isPathArray_default","isPathCommand_default","isPointInStroke_default","isRelativeArray_default","isSpace_default","isValidPath_default","iterate_default","lineToCubic_default","lineTools_exports","midPoint_default","normalizePath_default","normalizeSegment_default","optimizePath_default","paramsCount_default","paramsParser_default","parsePathString_default","PathParser","pathToAbsolute_default","pathToCurve_default","pathToRelative_default","pathToString_default","polygonTools_exports","projection2d_default","quadToCubic_default","quadTools_exports","relativizeSegment_default","reverseCurve_default","reversePath_default","rotateVector_default","roundPath_default","roundSegment_default","roundTo_default","scanFlag_default","scanParam_default","scanSegment_default","segmentToCubic_default","shapeParams_default","shapeToPath_default","shapeToPathArray_default","shortenSegment_default","skipSpaces_default","splitCubic_default","splitPath_default","transformPath_default","__toCommonJS","import_dommatrix","arcTools_exports","__export","angleBetween","arcLength","arcPoint","getArcBBox","getArcLength","getArcProps","getPointAtArcLength","lineTools_exports","__export","getLineBBox","getLineLength","getPointAtLineLength","midPoint","a","b","t","ax","ay","bx","by","midPoint_default","distanceSquareRoot","a","b","distanceSquareRoot_default","getLineLength","x1","y1","x2","y2","distanceSquareRoot_default","getPointAtLineLength","distance","point","length","x","y","midPoint_default","getLineBBox","min","max","arcLength","rx","ry","theta","halfTheta","sinHalfTheta","cosHalfTheta","term1","term2","length","arcPoint","cx","cy","alpha","sin","cos","cosA","sinA","x","y","angleBetween","v0","v1","v0x","v0y","v1x","v1y","p","n","getArcProps","x1","y1","RX","RY","angle","LAF","SF","abs","sqrt","PI","xRotRad","dx","dy","transformedPoint","radiiCheck","cSquareNumerator","cSquareRootDenom","cRadicand","cCoef","transformedCenter","center","startVector","startAngle","endVector","sweepAngle","endAngle","getArcLength","getPointAtArcLength","distance","point","getPointAtLineLength","ellipseComponentX","ellipseComponentY","getArcBBox","deltaAngle","min","max","tan","atan2","tangent","angle1","angle2","angle3","angle4","xArray","yArray","xMin","xMax","yMin","yMax","angleAfterStart","pP2","angleBeforeEnd","pP3","p1","p2","p4","p3","bezier_exports","__export","CBEZIER_MINMAX_EPSILON","Cvalues","Tvalues","bezierLength","calculateBezier","computeBezier","deriveBezier","getBezierLength","minmaxC","minmaxQ","points","dpoints","p","d","c","list","j","order","mt","mt2","t2","a","b","derivativeFn","l","len","sum","i","t","curve","idx","step","v1","cp","v2","min","max","E","cp1","cp2","K","T","S","L","R","Q","cubicTools_exports","__export","getCubicBBox","getCubicLength","getPointAtCubicLength","getPointAtCubicSegmentLength","getPointAtCubicSegmentLength","x1","y1","c1x","c1y","c2x","c2y","x2","y2","t","t1","getCubicLength","getBezierLength","getPointAtCubicLength","distance","distanceIsNumber","point","currentLength","getCubicBBox","cxMinMax","minmaxC","cyMinMax","quadTools_exports","__export","getPointAtQuadLength","getPointAtQuadSegmentLength","getQuadBBox","getQuadLength","getPointAtQuadSegmentLength","x1","y1","cx","cy","x2","y2","t","t1","getQuadLength","getBezierLength","getPointAtQuadLength","distance","distanceIsNumber","point","currentLength","getQuadBBox","cxMinMax","minmaxQ","cyMinMax","polygonTools_exports","__export","polygonArea","polygonLength","polygonArea","polygon","n","i","a","b","area","polygonLength","length","point","distanceSquareRoot_default","paramsCount","paramsCount_default","finalizeSegment","path","pathCommand","relativeCommand","data","paramsCount_default","finalizeSegment_default","error","error_default","scanFlag","path","index","pathValue","code","error_default","scanFlag_default","isDigit","code","isDigit_default","invalidPathValue","invalidPathValue_default","scanParam","path","max","pathValue","start","index","zeroFirst","hasCeiling","hasDecimal","hasDot","ch","error_default","invalidPathValue_default","isDigit_default","scanParam_default","isSpace","ch","isSpace_default","skipSpaces","path","pathValue","max","isSpace_default","skipSpaces_default","isPathCommand","code","isPathCommand_default","isDigitStart","code","isDigit_default","isDigitStart_default","isArcCommand","code","isArcCommand_default","isMoveCommand","code","isMoveCommand_default","scanSegment","path","max","pathValue","index","segments","cmdCode","reqParams","paramsCount_default","isPathCommand_default","error_default","invalidPathValue_default","lastSegment","isMoveCommand_default","skipSpaces_default","finalizeSegment_default","i","isArcCommand_default","scanFlag_default","scanParam_default","isDigitStart_default","scanSegment_default","PathParser","pathString","parsePathString","pathInput","path","PathParser","skipSpaces_default","scanSegment_default","parsePathString_default","absolutizeSegment","segment","index","lastX","lastY","pathCommand","absCommand","isAbsolute","absValues","seglen","j","absolutizeSegment_default","iterate","path","iterator","pathLen","segment","pathCommand","absCommand","isRelative","x","y","mx","my","segLen","i","iteratorResult","iterate_default","pathToAbsolute","pathInput","path","parsePathString_default","iterate_default","absolutizeSegment_default","pathToAbsolute_default","relativizeSegment","segment","index","lastX","lastY","pathCommand","relCommand","isRelative","relValues","seglen","j","relativizeSegment_default","pathToRelative","pathInput","path","parsePathString_default","iterate_default","relativizeSegment_default","pathToRelative_default","rotateVector","x","y","rad","sin","cos","X","Y","rotateVector_default","arcToCubic","X1","Y1","RX","RY","angle","LAF","SF","X2","Y2","recursive","x1","y1","rx","ry","x2","y2","d120","rad","res","xy","f1","f2","cx","cy","rotateVector_default","x","y","h","rx2","ry2","k","df","f2old","x2old","y2old","c1","s1","c2","s2","t","hx","hy","m1","m2","m3","m4","newres","i","ii","arcToCubic_default","quadToCubic","x1","y1","qx","qy","x2","y2","r13","r23","quadToCubic_default","lineToCubic","x1","y1","x2","y2","c1","midPoint_default","c2","lineToCubic_default","segmentToCubic","segment","params","pathCommand","values","x","y","px1","py1","px","py","arcToCubic_default","quadToCubic_default","lineToCubic_default","segmentToCubic_default","normalizeSegment","segment","params","pathCommand","absCommand","isRelative","px1","py1","px2","py2","x","y","values","absValues","n","j","x1","y1","qx","qy","nqx","nqy","normalizeSegment_default","paramsParser","paramsParser_default","pathToCurve","pathInput","params","paramsParser_default","path","parsePathString_default","iterate_default","seg","index","lastX","lastY","normalSegment","normalizeSegment_default","result","segmentToCubic_default","seglen","pathToCurve_default","defaultOptions","options_default","roundTo","n","round","pow","roundTo_default","pathToString","path","roundOption","pathLen","round","options_default","segment","result","i","pathCommand","values","j","valLen","roundTo_default","pathToString_default","distanceEpsilon_default","normalizePath","pathInput","path","parsePathString_default","params","paramsParser_default","iterate_default","seg","_","lastX","lastY","result","normalizeSegment_default","seglen","normalizePath_default","getPointAtLength","pathInput","distance","path","normalizePath_default","isM","data","pathCommand","x","y","mx","my","distanceIsNumber","point","length","POINT","totalLength","distanceEpsilon_default","iterate_default","seg","_","lastX","lastY","getPointAtLineLength","getLineLength","getPointAtArcLength","getArcLength","getPointAtCubicLength","getCubicLength","getPointAtQuadLength","getQuadLength","getPointAtLength_default","getTotalLength","pathInput","path","parsePathString_default","paramX1","paramY1","paramX2","paramY2","paramQX","paramQY","pathCommand","mx","my","totalLength","iterate_default","seg","index","lastX","lastY","absCommand","absoluteSegment","absolutizeSegment_default","normalSegment","getLineLength","getArcLength","cp1x","cp1y","getCubicLength","getQuadLength","getTotalLength_default","getPropertiesAtLength","pathInput","distance","pathArray","parsePathString_default","pathTemp","pathLength","getTotalLength_default","index","lengthAtSegment","length","segment","segments","getPropertiesAtLength_default","getPropertiesAtPoint","pathInput","point","path","parsePathString_default","normalPath","normalizePath_default","pathLength","getTotalLength_default","distanceTo","p","dx","dy","precision","scan","closest","scanDistance","bestLength","bestDistance","scanLength","getPointAtLength_default","before","after","beforeLength","afterLength","beforeDistance","afterDistance","segment","getPropertiesAtLength_default","distance","getPropertiesAtPoint_default","getClosestPoint","pathInput","point","getPropertiesAtPoint_default","getClosestPoint_default","getCubicSegArea","x1","y1","c1x","c1y","c2x","c2y","x2","y2","getPathArea","path","x","y","len","pathToCurve_default","seg","a","b","getPathArea_default","getDrawDirection","path","getPathArea_default","pathToCurve_default","getDrawDirection_default","getPathBBox","pathInput","path","parsePathString_default","pathCommand","mx","my","max","min","xMin","yMin","xMax","yMax","minX","minY","maxX","maxY","paramX1","paramY1","paramX2","paramY2","paramQX","paramQY","iterate_default","seg","index","lastX","lastY","absCommand","absoluteSegment","absolutizeSegment_default","normalSegment","getLineBBox","getArcBBox","cp1x","cp1y","getCubicBBox","getQuadBBox","width","height","getPathBBox_default","getSegmentAtLength","pathInput","distance","getPropertiesAtLength_default","getSegmentAtLength_default","getSegmentOfPoint","path","point","getPropertiesAtPoint_default","getSegmentOfPoint_default","isPathArray","path","seg","lk","paramsCount_default","isPathArray_default","isAbsoluteArray","path","isPathArray_default","x","isAbsoluteArray_default","isNormalizedArray","path","isAbsoluteArray_default","pc","isNormalizedArray_default","isCurveArray","path","isNormalizedArray_default","pc","isCurveArray_default","isPointInStroke","pathInput","point","distance","getPropertiesAtPoint_default","distanceEpsilon_default","isPointInStroke_default","isRelativeArray","path","isPathArray_default","pc","isRelativeArray_default","isValidPath","pathString","path","PathParser","skipSpaces_default","scanSegment_default","isValidPath_default","shapeParams","shapeParams_default","isElement","node","isElement_default","getLinePath","attr","x1","y1","x2","y2","getPolyPath","pathArray","points","a","index","getCirclePath","cx","cy","r","getEllipsePath","rx","ry","getRectanglePath","x","y","w","h","shapeToPathArray","element","supportedShapes","shapeParams_default","targetIsElement","isElement_default","tagName","s","error_default","type","shapeAttrs","config","p","parsePathString_default","isPathArray_default","shapeToPathArray_default","shapeToPath","element","replace","ownerDocument","doc","supportedShapes","shapeParams_default","targetIsElement","isElement_default","tagName","error_default","s","path","type","shapeAttrs","config","round","options_default","pathArray","shapeToPathArray_default","description","pathToString_default","name","value","k","m","isValidPath_default","shapeToPath_default","import_dommatrix","getSVGMatrix","transform","matrix","CSSMatrix","origin","originX","originY","translate","rotate","skew","scale","x","getSVGMatrix_default","shortenSegment","segment","normalSegment","params","prevCommand","pathCommand","defaultRound","options_default","round","normalValues","x1","y1","x2","y2","x","y","nx","ny","result","roundTo_default","nx1","ny1","qx","qy","shortenSegment_default","roundSegment","segment","roundOption","values","n","roundTo_default","roundSegment_default","optimizePath","pathInput","roundOption","path","pathToAbsolute_default","round","optimParams","paramsParser_default","allPathCommands","pathCommand","prevCommand","iterate_default","seg","i","lastX","lastY","normalizedSegment","normalizeSegment_default","result","shortSegment","shortenSegment_default","absSegment","roundSegment_default","absString","relativeSegment","relativizeSegment_default","relSegment","relString","seglen","optimizePath_default","import_dommatrix","translatePoint","cssm","v","m","CSSMatrix","projection2d","point2D","origin","originX","originY","originZ","x","y","z","relativePositionX","relativePositionY","relativePositionZ","projection2d_default","reverseCurve","path","rotatedCurve","x","i","curveOnly","_","reverseCurve_default","reversePath","pathInput","absolutePath","pathToAbsolute_default","normalizedPath","normalizePath_default","pLen","isClosed","reversedPath","iterate_default","segment","normalizedSegment","prevSeg","prevCommand","nextSeg","nextCommand","pathCommand","x","y","result","reversePath_default","roundPath","path","roundOption","round","options_default","iterate_default","segment","roundSegment_default","roundPath_default","splitCubic","pts","ratio","t","p0","p1","p2","p3","p4","midPoint_default","p5","p6","p7","p8","p9","splitCubic_default","splitPath","pathInput","composite","path","pi","x","y","mx","my","params","paramsParser_default","seg","pathCommand","absCommand","relCommand","isRelative","values","splitPath_default","transformPath","pathInput","transform","x","y","lx","ly","j","jj","pathCommand","path","parsePathString_default","transformProps","options_default","origin","matrixInstance","getSVGMatrix_default","iterate_default","seg","index","lastX","lastY","absCommand","absoluteSegment","absolutizeSegment_default","result","arcToCubic_default","isLongArc","tempSegment","projection2d_default","transformPath_default"]} \ No newline at end of file diff --git a/dist/util/util.js b/dist/util/util.js index 69a2871..35e9382 100644 --- a/dist/util/util.js +++ b/dist/util/util.js @@ -1,2 +1,2 @@ -(function(g,ee){typeof exports=="object"&&typeof module<"u"?ee(exports):typeof define=="function"&&define.amd?define(["exports"],ee):(g=typeof globalThis<"u"?globalThis:g||self,ee(g.SVGPathCommanderUtil={}))})(this,function(g){"use strict";var ee=Object.defineProperty,$t=(t,e,r)=>e in t?ee(t,e,{enumerable:!0,configurable:!0,writable:!0,value:r}):t[e]=r,V=(t,e,r)=>$t(t,typeof e!="symbol"?e+"":e,r);const jt={a:1,b:0,c:0,d:1,e:0,f:0,m11:1,m12:0,m13:0,m14:0,m21:0,m22:1,m23:0,m24:0,m31:0,m32:0,m33:1,m34:0,m41:0,m42:0,m43:0,m44:1,is2D:!0,isIdentity:!0},He=t=>(t instanceof Float64Array||t instanceof Float32Array||Array.isArray(t)&&t.every(e=>typeof e=="number"))&&[6,16].some(e=>t.length===e),Fe=t=>t instanceof DOMMatrix||t instanceof w||typeof t=="object"&&Object.keys(jt).every(e=>t&&e in t),te=t=>{const e=new w,r=Array.from(t);if(!He(r))throw TypeError(`CSSMatrix: "${r.join(",")}" must be an array with 6/16 numbers.`);if(r.length===16){const[o,n,i,s,a,c,l,u,h,f,y,m,d,M,p,A]=r;e.m11=o,e.a=o,e.m21=a,e.c=a,e.m31=h,e.m41=d,e.e=d,e.m12=n,e.b=n,e.m22=c,e.d=c,e.m32=f,e.m42=M,e.f=M,e.m13=i,e.m23=l,e.m33=y,e.m43=p,e.m14=s,e.m24=u,e.m34=m,e.m44=A}else if(r.length===6){const[o,n,i,s,a,c]=r;e.m11=o,e.a=o,e.m12=n,e.b=n,e.m21=i,e.c=i,e.m22=s,e.d=s,e.m41=a,e.e=a,e.m42=c,e.f=c}return e},Ue=t=>{if(Fe(t))return te([t.m11,t.m12,t.m13,t.m14,t.m21,t.m22,t.m23,t.m24,t.m31,t.m32,t.m33,t.m34,t.m41,t.m42,t.m43,t.m44]);throw TypeError(`CSSMatrix: "${JSON.stringify(t)}" is not a DOMMatrix / CSSMatrix / JSON compatible object.`)},Ge=t=>{if(typeof t!="string")throw TypeError(`CSSMatrix: "${JSON.stringify(t)}" is not a string.`);const e=String(t).replace(/\s/g,"");let r=new w;const o=`CSSMatrix: invalid transform string "${t}"`;return e.split(")").filter(n=>n).forEach(n=>{const[i,s]=n.split("(");if(!s)throw TypeError(o);const a=s.split(",").map(m=>m.includes("rad")?parseFloat(m)*(180/Math.PI):parseFloat(m)),[c,l,u,h]=a,f=[c,l,u],y=[c,l,u,h];if(i==="perspective"&&c&&[l,u].every(m=>m===void 0))r.m34=-1/c;else if(i.includes("matrix")&&[6,16].includes(a.length)&&a.every(m=>!Number.isNaN(+m))){const m=a.map(d=>Math.abs(d)<1e-6?0:d);r=r.multiply(te(m))}else if(i==="translate3d"&&f.every(m=>!Number.isNaN(+m)))r=r.translate(c,l,u);else if(i==="translate"&&c&&u===void 0)r=r.translate(c,l||0,0);else if(i==="rotate3d"&&y.every(m=>!Number.isNaN(+m))&&h)r=r.rotateAxisAngle(c,l,u,h);else if(i==="rotate"&&c&&[l,u].every(m=>m===void 0))r=r.rotate(0,0,c);else if(i==="scale3d"&&f.every(m=>!Number.isNaN(+m))&&f.some(m=>m!==1))r=r.scale(c,l,u);else if(i==="scale"&&!Number.isNaN(c)&&(c!==1||l!==1)&&u===void 0){const m=Number.isNaN(+l)?c:l;r=r.scale(c,m,1)}else if(i==="skew"&&(c||!Number.isNaN(c)&&l)&&u===void 0)r=r.skew(c,l||0);else if(["translate","rotate","scale","skew"].some(m=>i.includes(m))&&/[XYZ]/.test(i)&&c&&[l,u].every(m=>m===void 0))if(i==="skewX"||i==="skewY")r=r[i](c);else{const m=i.replace(/[XYZ]/,""),d=i.replace(m,""),M=["X","Y","Z"].indexOf(d),p=m==="scale"?1:0,A=[M===0?c:p,M===1?c:p,M===2?c:p];r=r[m](...A)}else throw TypeError(o)}),r},Se=(t,e)=>e?[t.a,t.b,t.c,t.d,t.e,t.f]:[t.m11,t.m12,t.m13,t.m14,t.m21,t.m22,t.m23,t.m24,t.m31,t.m32,t.m33,t.m34,t.m41,t.m42,t.m43,t.m44],Je=(t,e,r)=>{const o=new w;return o.m41=t,o.e=t,o.m42=e,o.f=e,o.m43=r,o},Ke=(t,e,r)=>{const o=new w,n=Math.PI/180,i=t*n,s=e*n,a=r*n,c=Math.cos(i),l=-Math.sin(i),u=Math.cos(s),h=-Math.sin(s),f=Math.cos(a),y=-Math.sin(a),m=u*f,d=-u*y;o.m11=m,o.a=m,o.m12=d,o.b=d,o.m13=h;const M=l*h*f+c*y;o.m21=M,o.c=M;const p=c*f-l*h*y;return o.m22=p,o.d=p,o.m23=-l*u,o.m31=l*y-c*h*f,o.m32=l*f+c*h*y,o.m33=c*u,o},We=(t,e,r,o)=>{const n=new w,i=Math.sqrt(t*t+e*e+r*r);if(i===0)return n;const s=t/i,a=e/i,c=r/i,l=o*(Math.PI/360),u=Math.sin(l),h=Math.cos(l),f=u*u,y=s*s,m=a*a,d=c*c,M=1-2*(m+d)*f;n.m11=M,n.a=M;const p=2*(s*a*f+c*u*h);n.m12=p,n.b=p,n.m13=2*(s*c*f-a*u*h);const A=2*(a*s*f-c*u*h);n.m21=A,n.c=A;const b=1-2*(d+y)*f;return n.m22=b,n.d=b,n.m23=2*(a*c*f+s*u*h),n.m31=2*(c*s*f+a*u*h),n.m32=2*(c*a*f-s*u*h),n.m33=1-2*(y+m)*f,n},Xe=(t,e,r)=>{const o=new w;return o.m11=t,o.a=t,o.m22=e,o.d=e,o.m33=r,o},me=(t,e)=>{const r=new w;if(t){const o=t*Math.PI/180,n=Math.tan(o);r.m21=n,r.c=n}if(e){const o=e*Math.PI/180,n=Math.tan(o);r.m12=n,r.b=n}return r},Ye=t=>me(t,0),et=t=>me(0,t),B=(t,e)=>{const r=e.m11*t.m11+e.m12*t.m21+e.m13*t.m31+e.m14*t.m41,o=e.m11*t.m12+e.m12*t.m22+e.m13*t.m32+e.m14*t.m42,n=e.m11*t.m13+e.m12*t.m23+e.m13*t.m33+e.m14*t.m43,i=e.m11*t.m14+e.m12*t.m24+e.m13*t.m34+e.m14*t.m44,s=e.m21*t.m11+e.m22*t.m21+e.m23*t.m31+e.m24*t.m41,a=e.m21*t.m12+e.m22*t.m22+e.m23*t.m32+e.m24*t.m42,c=e.m21*t.m13+e.m22*t.m23+e.m23*t.m33+e.m24*t.m43,l=e.m21*t.m14+e.m22*t.m24+e.m23*t.m34+e.m24*t.m44,u=e.m31*t.m11+e.m32*t.m21+e.m33*t.m31+e.m34*t.m41,h=e.m31*t.m12+e.m32*t.m22+e.m33*t.m32+e.m34*t.m42,f=e.m31*t.m13+e.m32*t.m23+e.m33*t.m33+e.m34*t.m43,y=e.m31*t.m14+e.m32*t.m24+e.m33*t.m34+e.m34*t.m44,m=e.m41*t.m11+e.m42*t.m21+e.m43*t.m31+e.m44*t.m41,d=e.m41*t.m12+e.m42*t.m22+e.m43*t.m32+e.m44*t.m42,M=e.m41*t.m13+e.m42*t.m23+e.m43*t.m33+e.m44*t.m43,p=e.m41*t.m14+e.m42*t.m24+e.m43*t.m34+e.m44*t.m44;return te([r,o,n,i,s,a,c,l,u,h,f,y,m,d,M,p])};class w{constructor(e){return this.a=1,this.b=0,this.c=0,this.d=1,this.e=0,this.f=0,this.m11=1,this.m12=0,this.m13=0,this.m14=0,this.m21=0,this.m22=1,this.m23=0,this.m24=0,this.m31=0,this.m32=0,this.m33=1,this.m34=0,this.m41=0,this.m42=0,this.m43=0,this.m44=1,e?this.setMatrixValue(e):this}get isIdentity(){return this.m11===1&&this.m12===0&&this.m13===0&&this.m14===0&&this.m21===0&&this.m22===1&&this.m23===0&&this.m24===0&&this.m31===0&&this.m32===0&&this.m33===1&&this.m34===0&&this.m41===0&&this.m42===0&&this.m43===0&&this.m44===1}get is2D(){return this.m31===0&&this.m32===0&&this.m33===1&&this.m34===0&&this.m43===0&&this.m44===1}setMatrixValue(e){return typeof e=="string"&&e.length&&e!=="none"?Ge(e):Array.isArray(e)||e instanceof Float64Array||e instanceof Float32Array?te(e):typeof e=="object"?Ue(e):this}toFloat32Array(e){return Float32Array.from(Se(this,e))}toFloat64Array(e){return Float64Array.from(Se(this,e))}toString(){const{is2D:e}=this,r=this.toFloat64Array(e).join(", ");return`${e?"matrix":"matrix3d"}(${r})`}toJSON(){const{is2D:e,isIdentity:r}=this;return{...this,is2D:e,isIdentity:r}}multiply(e){return B(this,e)}translate(e,r,o){const n=e;let i=r,s=o;return typeof i>"u"&&(i=0),typeof s>"u"&&(s=0),B(this,Je(n,i,s))}scale(e,r,o){const n=e;let i=r,s=o;return typeof i>"u"&&(i=e),typeof s>"u"&&(s=1),B(this,Xe(n,i,s))}rotate(e,r,o){let n=e,i=r||0,s=o||0;return typeof e=="number"&&typeof r>"u"&&typeof o>"u"&&(s=n,n=0,i=0),B(this,Ke(n,i,s))}rotateAxisAngle(e,r,o,n){if([e,r,o,n].some(i=>Number.isNaN(+i)))throw new TypeError("CSSMatrix: expecting 4 values");return B(this,We(e,r,o,n))}skewX(e){return B(this,Ye(e))}skewY(e){return B(this,et(e))}skew(e,r){return B(this,me(e,r))}transformPoint(e){const r=this.m11*e.x+this.m21*e.y+this.m31*e.z+this.m41*e.w,o=this.m12*e.x+this.m22*e.y+this.m32*e.z+this.m42*e.w,n=this.m13*e.x+this.m23*e.y+this.m33*e.z+this.m43*e.w,i=this.m14*e.x+this.m24*e.y+this.m34*e.z+this.m44*e.w;return e instanceof DOMPoint?new DOMPoint(r,o,n,i):{x:r,y:o,z:n,w:i}}}V(w,"Translate",Je),V(w,"Rotate",Ke),V(w,"RotateAxisAngle",We),V(w,"Scale",Xe),V(w,"SkewX",Ye),V(w,"SkewY",et),V(w,"Skew",me),V(w,"Multiply",B),V(w,"fromArray",te),V(w,"fromMatrix",Ue),V(w,"fromString",Ge),V(w,"toArray",Se),V(w,"isCompatibleArray",He),V(w,"isCompatibleObject",Fe);const Z=(t,e,r)=>{const[o,n]=t,[i,s]=e;return[o+(i-o)*r,n+(s-n)*r]},ue=(t,e)=>Math.sqrt((t[0]-e[0])*(t[0]-e[0])+(t[1]-e[1])*(t[1]-e[1])),ne=(t,e,r,o)=>ue([t,e],[r,o]),we=(t,e,r,o,n)=>{let i={x:t,y:e};if(typeof n=="number"){const s=ue([t,e],[r,o]);if(n<=0)i={x:t,y:e};else if(n>=s)i={x:r,y:o};else{const[a,c]=Z([t,e],[r,o],n/s);i={x:a,y:c}}}return i},Te=(t,e,r,o)=>{const{min:n,max:i}=Math;return[n(t,r),n(e,o),i(t,r),i(e,o)]},kt=Object.freeze(Object.defineProperty({__proto__:null,getLineBBox:Te,getLineLength:ne,getPointAtLineLength:we},Symbol.toStringTag,{value:"Module"})),Le=(t,e,r)=>{const o=r/2,n=Math.sin(o),i=Math.cos(o),s=t**2*n**2,a=e**2*i**2,c=Math.sqrt(s+a)*r;return Math.abs(c)},G=(t,e,r,o,n,i)=>{const{sin:s,cos:a}=Math,c=a(n),l=s(n),u=r*a(i),h=o*s(i);return[t+c*u-l*h,e+l*u+c*h]},Ne=(t,e)=>{const{x:r,y:o}=t,{x:n,y:i}=e,s=r*n+o*i,a=Math.sqrt((r**2+o**2)*(n**2+i**2));return(r*i-o*n<0?-1:1)*Math.acos(s/a)},he=(t,e,r,o,n,i,s,a,c)=>{const{abs:l,sin:u,cos:h,sqrt:f,PI:y}=Math;let m=l(r),d=l(o);const p=(n%360+360)%360*(y/180);if(t===a&&e===c)return{rx:m,ry:d,startAngle:0,endAngle:0,center:{x:a,y:c}};if(m===0||d===0)return{rx:m,ry:d,startAngle:0,endAngle:0,center:{x:(a+t)/2,y:(c+e)/2}};const A=(t-a)/2,b=(e-c)/2,x={x:h(p)*A+u(p)*b,y:-u(p)*A+h(p)*b},C=x.x**2/m**2+x.y**2/d**2;C>1&&(m*=f(C),d*=f(C));const S=m**2*d**2-m**2*x.y**2-d**2*x.x**2,q=m**2*x.y**2+d**2*x.x**2;let $=S/q;$=$<0?0:$;const v=(i!==s?1:-1)*f($),T={x:v*(m*x.y/d),y:v*(-(d*x.x)/m)},Q={x:h(p)*T.x-u(p)*T.y+(t+a)/2,y:u(p)*T.x+h(p)*T.y+(e+c)/2},J={x:(x.x-T.x)/m,y:(x.y-T.y)/d},j=Ne({x:1,y:0},J),P={x:(-x.x-T.x)/m,y:(-x.y-T.y)/d};let k=Ne(J,P);!s&&k>0?k-=2*y:s&&k<0&&(k+=2*y),k%=2*y;const D=j+k;return{center:Q,startAngle:j,endAngle:D,rx:m,ry:d}},ve=(t,e,r,o,n,i,s,a,c)=>{const{rx:l,ry:u,startAngle:h,endAngle:f}=he(t,e,r,o,n,i,s,a,c);return Le(l,u,f-h)},tt=(t,e,r,o,n,i,s,a,c,l)=>{let u={x:t,y:e};const{center:h,rx:f,ry:y,startAngle:m,endAngle:d}=he(t,e,r,o,n,i,s,a,c);if(typeof l=="number"){const M=Le(f,y,d-m);if(l<=0)u={x:t,y:e};else if(l>=M)u={x:a,y:c};else{if(t===a&&e===c)return{x:a,y:c};if(f===0||y===0)return we(t,e,a,c,l);const{PI:p,cos:A,sin:b}=Math,x=d-m,S=(n%360+360)%360*(p/180),q=m+x*(l/M),$=f*A(q),v=y*b(q);u={x:A(S)*$-b(S)*v+h.x,y:b(S)*$+A(S)*v+h.y}}}return u},nt=(t,e,r,o,n,i,s,a,c)=>{const{center:l,rx:u,ry:h,startAngle:f,endAngle:y}=he(t,e,r,o,n,i,s,a,c),m=y-f,{min:d,max:M,tan:p,atan2:A,PI:b}=Math,{x,y:C}=l,S=n*b/180,q=p(S),$=A(-h*q,u),v=$,T=$+b,Q=A(h,u*q),J=Q+b,j=[a],P=[c];let k=d(t,a),D=M(t,a),R=d(e,c),H=M(e,c);const Y=y-m*1e-5,K=G(x,C,u,h,S,Y),L=y-m*.99999,I=G(x,C,u,h,S,L);if(K[0]>D||I[0]>D){const z=G(x,C,u,h,S,v);j.push(z[0]),P.push(z[1])}if(K[0]H||I[1]>H){const z=G(x,C,u,h,S,Q);j.push(z[0]),P.push(z[1])}return k=d.apply([],j),R=d.apply([],P),D=M.apply([],j),H=M.apply([],P),[k,R,D,H]},It=Object.freeze(Object.defineProperty({__proto__:null,angleBetween:Ne,arcLength:Le,arcPoint:G,getArcBBox:nt,getArcLength:ve,getArcProps:he,getPointAtArcLength:tt},Symbol.toStringTag,{value:"Module"})),ze=[-.06405689286260563,.06405689286260563,-.1911188674736163,.1911188674736163,-.3150426796961634,.3150426796961634,-.4337935076260451,.4337935076260451,-.5454214713888396,.5454214713888396,-.6480936519369755,.6480936519369755,-.7401241915785544,.7401241915785544,-.820001985973903,.820001985973903,-.8864155270044011,.8864155270044011,-.9382745520027328,.9382745520027328,-.9747285559713095,.9747285559713095,-.9951872199970213,.9951872199970213],rt=[.12793819534675216,.12793819534675216,.1258374563468283,.1258374563468283,.12167047292780339,.12167047292780339,.1155056680537256,.1155056680537256,.10744427011596563,.10744427011596563,.09761865210411388,.09761865210411388,.08619016153195327,.08619016153195327,.0733464814110803,.0733464814110803,.05929858491543678,.05929858491543678,.04427743881741981,.04427743881741981,.028531388628933663,.028531388628933663,.0123412297999872,.0123412297999872],ot=t=>{const e=[];for(let r=t,o=r.length,n=o-1;o>1;o-=1,n-=1){const i=[];for(let s=0;s{if(e===0)return t[0].t=0,t[0];const r=t.length-1;if(e===1)return t[r].t=1,t[r];const o=1-e;let n=t;if(r===0)return t[0].t=e,t[0];if(r===1)return{x:o*n[0].x+e*n[1].x,y:o*n[0].y+e*n[1].y,t:e};const i=o*o,s=e*e;let a=0,c=0,l=0,u=0;return r===2?(n=[n[0],n[1],n[2],{x:0,y:0}],a=i,c=o*e*2,l=s):r===3&&(a=i*o,c=i*e*3,l=o*s*3,u=e*s),{x:a*n[0].x+c*n[1].x+l*n[2].x+u*n[3].x,y:a*n[0].y+c*n[1].y+l*n[2].y+u*n[3].y,t:e}},st=(t,e)=>{const r=t(e),o=r.x*r.x+r.y*r.y;return Math.sqrt(o)},ct=t=>{const r=ze.length;let o=0;for(let n=0,i;n{const e=[];for(let o=0,n=t.length,i=2;oit(r[0],o))},at=1e-8,fe=([t,e,r])=>{const o=Math.min(t,r),n=Math.max(t,r);if(e>=t?r>=e:r<=e)return[o,n];const i=(t*r-e*e)/(t-2*e+r);return i{const n=t-3*e+3*r-o;if(Math.abs(n)0&&u<1){const f=t*(1-u)*(1-u)*(1-u)+e*3*(1-u)*(1-u)*u+r*3*(1-u)*u*u+o*u*u*u;fc&&(c=f)}return[a,c]},Vt=Object.freeze(Object.defineProperty({__proto__:null,CBEZIER_MINMAX_EPSILON:at,Cvalues:rt,Tvalues:ze,bezierLength:ct,calculateBezier:st,computeBezier:it,deriveBezier:ot,getBezierLength:re,minmaxC:qe,minmaxQ:fe},Symbol.toStringTag,{value:"Module"})),lt=([t,e,r,o,n,i,s,a],c)=>{const l=1-c;return{x:l**3*t+3*l**2*c*r+3*l*c**2*n+c**3*s,y:l**3*e+3*l**2*c*o+3*l*c**2*i+c**3*a}},ye=(t,e,r,o,n,i,s,a)=>re([t,e,r,o,n,i,s,a]),mt=(t,e,r,o,n,i,s,a,c)=>{const l=typeof c=="number";let u={x:t,y:e};if(l){const h=re([t,e,r,o,n,i,s,a]);c<=0||(c>=h?u={x:s,y:a}:u=lt([t,e,r,o,n,i,s,a],c/h))}return u},$e=(t,e,r,o,n,i,s,a)=>{const c=qe([t,r,n,s]),l=qe([e,o,i,a]);return[c[0],l[0],c[1],l[1]]},Rt=Object.freeze(Object.defineProperty({__proto__:null,getCubicBBox:$e,getCubicLength:ye,getPointAtCubicLength:mt,getPointAtCubicSegmentLength:lt},Symbol.toStringTag,{value:"Module"})),ut=([t,e,r,o,n,i],s)=>{const a=1-s;return{x:a**2*t+2*a*s*r+s**2*n,y:a**2*e+2*a*s*o+s**2*i}},de=(t,e,r,o,n,i)=>re([t,e,r,o,n,i]),ht=(t,e,r,o,n,i,s)=>{const a=typeof s=="number";let c={x:t,y:e};if(a){const l=re([t,e,r,o,n,i]);s<=0||(s>=l?c={x:n,y:i}:c=ut([t,e,r,o,n,i],s/l))}return c},je=(t,e,r,o,n,i)=>{const s=fe([t,r,n]),a=fe([e,o,i]);return[s[0],a[0],s[1],a[1]]},Et=Object.freeze(Object.defineProperty({__proto__:null,getPointAtQuadLength:ht,getPointAtQuadSegmentLength:ut,getQuadBBox:je,getQuadLength:de},Symbol.toStringTag,{value:"Module"})),Ot=Object.freeze(Object.defineProperty({__proto__:null,polygonArea:t=>{const e=t.length;let r=-1,o,n=t[e-1],i=0;for(;++rt.reduce((e,r,o)=>o?e+ue(t[o-1],r):0,0)},Symbol.toStringTag,{value:"Module"})),W={a:7,c:6,h:1,l:2,m:2,r:4,q:4,s:4,t:2,v:1,z:0},ke=t=>{let e=t.pathValue[t.segmentStart],r=e.toLowerCase();const{data:o}=t;for(;o.length>=W[r]&&(r==="m"&&o.length>2?(t.segments.push([e].concat(o.splice(0,2))),r="l",e=e==="m"?"l":"L"):t.segments.push([e].concat(o.splice(0,W[r]))),!!W[r]););},O="SVGPathCommander Error",ft=t=>{const{index:e,pathValue:r}=t,o=r.charCodeAt(e);if(o===48){t.param=0,t.index+=1;return}if(o===49){t.param=1,t.index+=1;return}t.err=`${O}: invalid Arc flag "${r[e]}", expecting 0 or 1 at index ${e}`},F=t=>t>=48&&t<=57,U="Invalid path value",yt=t=>{const{max:e,pathValue:r,index:o}=t;let n=o,i=!1,s=!1,a=!1,c=!1,l;if(n>=e){t.err=`${O}: ${U} at index ${n}, "pathValue" is missing param`;return}if(l=r.charCodeAt(n),(l===43||l===45)&&(n+=1,l=r.charCodeAt(n)),!F(l)&&l!==46){t.err=`${O}: ${U} at index ${n}, "${r[n]}" is not a number`;return}if(l!==46){if(i=l===48,n+=1,l=r.charCodeAt(n),i&&n[5760,6158,8192,8193,8194,8195,8196,8197,8198,8199,8200,8201,8202,8239,8287,12288,65279,10,13,8232,8233,32,9,11,12,160].includes(t),X=t=>{const{pathValue:e,max:r}=t;for(;t.index{switch(t|32){case 109:case 122:case 108:case 104:case 118:case 99:case 115:case 113:case 116:case 97:return!0;default:return!1}},bt=t=>F(t)||t===43||t===45||t===46,xt=t=>(t|32)===97,Mt=t=>{switch(t|32){case 109:case 77:return!0;default:return!1}},Ie=t=>{var c;const{max:e,pathValue:r,index:o,segments:n}=t,i=r.charCodeAt(o),s=W[r[o].toLowerCase()];if(t.segmentStart=o,!gt(i)){t.err=`${O}: ${U} "${r[o]}" is not a path command at index ${o}`;return}const a=n[n.length-1];if(!Mt(i)&&((c=a==null?void 0:a[0])==null?void 0:c.toLocaleLowerCase())==="z"){t.err=`${O}: ${U} "${r[o]}" is not a MoveTo path command at index ${o}`;return}if(t.index+=1,X(t),t.data=[],!s){ke(t);return}for(;;){for(let l=s;l>0;l-=1){if(xt(i)&&(l===3||l===4)?ft(t):yt(t),t.err.length)return;t.data.push(t.param),X(t),t.index=t.max||!bt(r.charCodeAt(t.index)))break}ke(t)};class Ve{constructor(e){this.segments=[],this.pathValue=e,this.max=e.length,this.index=0,this.param=0,this.segmentStart=0,this.data=[],this.err=""}}const _=t=>{if(typeof t!="string")return t.slice(0);const e=new Ve(t);for(X(e);e.index{const[n]=t,i=n.toUpperCase();if(e===0||i===n)return t;if(i==="A")return[i,t[1],t[2],t[3],t[4],t[5],t[6]+r,t[7]+o];if(i==="V")return[i,t[1]+o];if(i==="H")return[i,t[1]+r];if(i==="L")return[i,t[1]+r,t[2]+o];{const a=[],c=t.length;for(let l=1;l{let r=t.length,o,n="M",i="M",s=!1,a=0,c=0,l=0,u=0,h=0;for(let f=0;f{const e=_(t);return E(e,oe)},Ee=(t,e,r,o)=>{const[n]=t,i=n.toLowerCase();if(e===0||n===i)return t;if(i==="a")return[i,t[1],t[2],t[3],t[4],t[5],t[6]-r,t[7]-o];if(i==="v")return[i,t[1]-o];if(i==="h")return[i,t[1]-r];if(i==="l")return[i,t[1]-r,t[2]-o];{const a=[],c=t.length;for(let l=1;l{const e=_(t);return E(e,Ee)},ie=(t,e,r)=>{const{sin:o,cos:n}=Math,i=t*n(r)-e*o(r),s=t*o(r)+e*n(r);return{x:i,y:s}},ge=(t,e,r,o,n,i,s,a,c,l)=>{let u=t,h=e,f=r,y=o,m=a,d=c;const M=Math.PI*120/180,p=Math.PI/180*(+n||0);let A=[],b,x,C,S,q;if(l)[x,C,S,q]=l;else{b=ie(u,h,-p),u=b.x,h=b.y,b=ie(m,d,-p),m=b.x,d=b.y;const L=(u-m)/2,I=(h-d)/2;let z=L*L/(f*f)+I*I/(y*y);z>1&&(z=Math.sqrt(z),f*=z,y*=z);const Ze=f*f,Be=y*y,qt=(i===s?-1:1)*Math.sqrt(Math.abs((Ze*Be-Ze*I*I-Be*L*L)/(Ze*I*I+Be*L*L)));S=qt*f*I/y+(u+m)/2,q=qt*-y*L/f+(h+d)/2,x=Math.asin(((h-q)/y*10**9>>0)/10**9),C=Math.asin(((d-q)/y*10**9>>0)/10**9),x=uC&&(x-=Math.PI*2),!s&&C>x&&(C-=Math.PI*2)}let $=C-x;if(Math.abs($)>M){const L=C,I=m,z=d;C=x+M*(s&&C>x?1:-1),m=S+f*Math.cos(C),d=q+y*Math.sin(C),A=ge(m,d,f,y,n,0,s,I,z,[C,L,S,q])}$=C-x;const v=Math.cos(x),T=Math.sin(x),Q=Math.cos(C),J=Math.sin(C),j=Math.tan($/4),P=4/3*f*j,k=4/3*y*j,D=[u,h],R=[u+P*T,h-k*v],H=[m+P*J,d-k*Q],Y=[m,d];if(R[0]=2*D[0]-R[0],R[1]=2*D[1]-R[1],l)return[R[0],R[1],H[0],H[1],Y[0],Y[1]].concat(A);A=[R[0],R[1],H[0],H[1],Y[0],Y[1]].concat(A);const K=[];for(let L=0,I=A.length;L{const s=.3333333333333333,a=2/3;return[s*t+a*r,s*e+a*o,s*n+a*r,s*i+a*o,n,i]},Oe=(t,e,r,o)=>{const n=Z([t,e],[r,o],.3333333333333333),i=Z([t,e],[r,o],2/3);return[n[0],n[1],i[0],i[1],r,o]},At=(t,e)=>{const[r]=t,o=t.slice(1).map(Number),[n,i]=o,{x1:s,y1:a,x:c,y:l}=e;return"TQ".includes(r)||(e.qx=null,e.qy=null),r==="M"?(e.x=n,e.y=i,t):r==="A"?["C"].concat(ge(s,a,o[0],o[1],o[2],o[3],o[4],o[5],o[6])):r==="Q"?(e.qx=n,e.qy=i,["C"].concat(pt(s,a,o[0],o[1],o[2],o[3]))):r==="L"?["C"].concat(Oe(s,a,n,i)):r==="Z"?["C"].concat(Oe(s,a,c,l)):t},be=(t,e)=>{const[r]=t,o=r.toUpperCase(),n=r!==o,{x1:i,y1:s,x2:a,y2:c,x:l,y:u}=e,h=t.slice(1);let f=h.map((y,m)=>y+(n?m%2?u:l:0));if("TQ".includes(o)||(e.qx=null,e.qy=null),o==="A")return f=h.slice(0,-2).concat(h[5]+(n?l:0),h[6]+(n?u:0)),["A"].concat(f);if(o==="H")return["L",t[1]+(n?l:0),s];if(o==="V")return["L",i,t[1]+(n?u:0)];if(o==="L")return["L",t[1]+(n?l:0),t[2]+(n?u:0)];if(o==="M")return["M",t[1]+(n?l:0),t[2]+(n?u:0)];if(o==="C")return["C"].concat(f);if(o==="S"){const y=i*2-a,m=s*2-c;return e.x1=y,e.y1=m,["C",y,m].concat(f)}else if(o==="T"){const y=i*2-(e.qx?e.qx:0),m=s*2-(e.qy?e.qy:0);return e.qx=y,e.qy=m,["Q",y,m].concat(f)}else if(o==="Q"){const[y,m]=f;return e.qx=y,e.qy=m,["Q"].concat(f)}else if(o==="Z")return["Z"];return t},se={x1:0,y1:0,x2:0,y2:0,x:0,y:0,qx:null,qy:null},_e=t=>{const e={...se},r=_(t);return E(r,(o,n,i,s)=>{e.x=i,e.y=s;const a=be(o,e);let c=At(a,e);c[0]==="C"&&c.length>7&&(r.splice(n+1,0,["C"].concat(c.slice(7))),c=c.slice(0,7));const u=c.length;return e.x1=+c[u-2],e.y1=+c[u-1],e.x2=+c[u-4]||e.x1,e.y2=+c[u-3]||e.y1,c})},ce={origin:[0,0,0],round:4},N=(t,e)=>{const r=e>=1?10**e:1;return e>0?Math.round(t*r)/r:Math.round(t)},Ct=(t,e)=>{const r=t.length;let{round:o}=ce,n=t[0],i="";o=e==="off"||typeof e=="number"&&e>=0?e:typeof o=="number"&&o>=0?o:"off";for(let s=0;s{const e=_(t),r={...se};return E(e,(o,n,i,s)=>{r.x=i,r.y=s;const a=be(o,r),c=a.length;return r.x1=+a[c-2],r.y1=+a[c-1],r.x2=+a[c-4]||r.x1,r.y2=+a[c-3]||r.y1,a})},pe=(t,e)=>{const r=Me(t);let o=!1,n=[],i="M",s=0,a=0,[c,l]=r[0].slice(1);const u=typeof e=="number";let h={x:c,y:l},f=0,y=h,m=0;return!u||e{if([i]=d,o=i==="M",n=o?n:[p,A].concat(d.slice(1)),o?([,c,l]=d,h={x:c,y:l},f=0):i==="L"?(h=we(n[0],n[1],n[2],n[3],e-m),f=ne(n[0],n[1],n[2],n[3])):i==="A"?(h=tt(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7],n[8],e-m),f=ve(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7],n[8])):i==="C"?(h=mt(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7],e-m),f=ye(n[0],n[1],n[2],n[3],n[4],n[5],n[6],n[7])):i==="Q"?(h=ht(n[0],n[1],n[2],n[3],n[4],n[5],e-m),f=de(n[0],n[1],n[2],n[3],n[4],n[5])):i==="Z"&&(n=[p,A,c,l],h={x:c,y:l},f=ne(n[0],n[1],n[2],n[3])),[s,a]=n.slice(-2),mm-xe?{x:s,y:a}:y)},ae=t=>{const e=_(t);let r=0,o=0,n=0,i=0,s=0,a=0,c="M",l=0,u=0,h=0;return E(e,(f,y,m,d)=>{[c]=f;const M=c.toUpperCase(),A=M!==c?oe(f,y,m,d):f.slice(0),b=M==="V"?["L",m,A[1]]:M==="H"?["L",A[1],d]:A;if([c]=b,"TQ".includes(M)||(s=0,a=0),c==="M")[,l,u]=b;else if(c==="L")h+=ne(m,d,b[1],b[2]);else if(c==="A")h+=ve(m,d,b[1],b[2],b[3],b[4],b[5],b[6],b[7]);else if(c==="S"){const x=r*2-n,C=o*2-i;h+=ye(m,d,x,C,b[1],b[2],b[3],b[4])}else c==="C"?h+=ye(m,d,b[1],b[2],b[3],b[4],b[5],b[6]):c==="T"?(s=r*2-s,a=o*2-a,h+=de(m,d,s,a,b[1],b[2])):c==="Q"?(s=b[1],a=b[2],h+=de(m,d,b[1],b[2],b[3],b[4])):c==="Z"&&(h+=ne(m,d,l,u));[r,o]=c==="Z"?[l,u]:b.slice(-2),[n,i]=c==="C"?[b[3],b[4]]:c==="S"?[b[1],b[2]]:[r,o]}),h},Qe=(t,e)=>{const r=_(t);let o=r.slice(0),n=ae(o),i=o.length-1,s=0,a=0,c=r[0];if(i<=0||!e||!Number.isFinite(e))return{segment:c,index:0,length:a,lengthAtSegment:s};if(e>=n)return o=r.slice(0,-1),s=ae(o),a=n-s,c=r[i],{segment:c,index:i,length:a,lengthAtSegment:s};const l=[];for(;i>0;)c=o[i],o=o.slice(0,-1),s=ae(o),a=n-s,n=s,l.push({segment:c,index:i,length:a,lengthAtSegment:s}),i-=1;return l.find(({lengthAtSegment:u})=>u<=e)},Ae=(t,e)=>{const r=_(t),o=Me(r),n=ae(o),i=x=>{const C=x.x-e.x,S=x.y-e.y;return C*C+S*S};let s=8,a,c={x:0,y:0},l=0,u=0,h=1/0;for(let x=0;x<=n;x+=s)a=pe(o,x),l=i(a),l1e-6&&(m=u-s,f=pe(o,m),M=i(f),d=u+s,y=pe(o,d),p=i(y),m>=0&&MAe(t,e).closest,Dt=(t,e,r,o,n,i,s,a)=>3*((a-e)*(r+n)-(s-t)*(o+i)+o*(t-n)-r*(e-i)+a*(n+t/3)-s*(i+e/3))/20,Pt=t=>{let e=0,r=0,o=0;return _e(t).map(n=>{switch(n[0]){case"M":return[,e,r]=n,0;default:return o=Dt(e,r,n[1],n[2],n[3],n[4],n[5],n[6]),[e,r]=n.slice(-2),o}}).reduce((n,i)=>n+i,0)},Zt=t=>Pt(_e(t))>=0,Bt=t=>{if(!t)return{x:0,y:0,width:0,height:0,x2:0,y2:0,cx:0,cy:0,cz:0};const e=_(t);let r="M",o=0,n=0;const{max:i,min:s}=Math;let a=1/0,c=1/0,l=-1/0,u=-1/0,h=0,f=0,y=0,m=0,d=0,M=0,p=0,A=0,b=0,x=0;E(e,(q,$,v,T)=>{[r]=q;const Q=r.toUpperCase(),j=Q!==r?oe(q,$,v,T):q.slice(0),P=Q==="V"?["L",v,j[1]]:Q==="H"?["L",j[1],T]:j;if([r]=P,"TQ".includes(Q)||(b=0,x=0),r==="M")[,o,n]=P,h=o,f=n,y=o,m=n;else if(r==="L")[h,f,y,m]=Te(v,T,P[1],P[2]);else if(r==="A")[h,f,y,m]=nt(v,T,P[1],P[2],P[3],P[4],P[5],P[6],P[7]);else if(r==="S"){const k=d*2-p,D=M*2-A;[h,f,y,m]=$e(v,T,k,D,P[1],P[2],P[3],P[4])}else r==="C"?[h,f,y,m]=$e(v,T,P[1],P[2],P[3],P[4],P[5],P[6]):r==="T"?(b=d*2-b,x=M*2-x,[h,f,y,m]=je(v,T,b,x,P[1],P[2])):r==="Q"?(b=P[1],x=P[2],[h,f,y,m]=je(v,T,P[1],P[2],P[3],P[4])):r==="Z"&&([h,f,y,m]=Te(v,T,o,n));a=s(h,a),c=s(f,c),l=i(y,l),u=i(m,u),[d,M]=r==="Z"?[o,n]:P.slice(-2),[p,A]=r==="C"?[P[3],P[4]]:r==="S"?[P[1],P[2]]:[d,M]});const C=l-a,S=u-c;return{width:C,height:S,x:a,y:c,x2:l,y2:u,cx:a+C/2,cy:c+S/2,cz:Math.max(C,S)+Math.min(C,S)/2}},Ht=(t,e)=>Qe(t,e).segment,Ft=(t,e)=>Ae(t,e).segment,Ce=t=>Array.isArray(t)&&t.every(e=>{const r=e[0].toLowerCase();return W[r]===e.length-1&&"achlmqstvz".includes(r)&&e.slice(1).every(Number.isFinite)})&&t.length>0,St=t=>Ce(t)&&t.every(([e])=>e===e.toUpperCase()),wt=t=>St(t)&&t.every(([e])=>"ACLMQZ".includes(e)),Ut=t=>wt(t)&&t.every(([e])=>"MC".includes(e)),Gt=(t,e)=>{const{distance:r}=Ae(t,e);return Math.abs(r)Ce(t)&&t.slice(1).every(([e])=>e===e.toLowerCase()),Tt=t=>{if(typeof t!="string"||!t.length)return!1;const e=new Ve(t);for(X(e);e.indext!=null&&typeof t=="object"&&t.nodeType===1,Kt=t=>{let{x1:e,y1:r,x2:o,y2:n}=t;return[e,r,o,n]=[e,r,o,n].map(i=>+i),[["M",e,r],["L",o,n]]},Wt=t=>{const e=[],r=(t.points||"").trim().split(/[\s|,]/).map(n=>+n);let o=0;for(;o{let{cx:e,cy:r,r:o}=t;return[e,r,o]=[e,r,o].map(n=>+n),[["M",e-o,r],["a",o,o,0,1,0,2*o,0],["a",o,o,0,1,0,-2*o,0]]},Yt=t=>{let{cx:e,cy:r}=t,o=t.rx||0,n=t.ry||o;return[e,r,o,n]=[e,r,o,n].map(i=>+i),[["M",e-o,r],["a",o,n,0,1,0,2*o,0],["a",o,n,0,1,0,-2*o,0]]},en=t=>{const e=+t.x||0,r=+t.y||0,o=+t.width,n=+t.height;let i=+(t.rx||0),s=+(t.ry||i);return i||s?(i*2>o&&(i-=(i*2-o)/2),s*2>n&&(s-=(s*2-n)/2),[["M",e+i,r],["h",o-i*2],["s",i,0,i,s],["v",n-s*2],["s",0,s,-i,s],["h",-o+i*2],["s",-i,0,-i,-s],["v",-n+s*2],["s",0,-s,i,-s]]):[["M",e,r],["h",o],["v",n],["H",e],["Z"]]},Nt=t=>{const e=Object.keys(le),r=Lt(t),o=r?t.tagName:null;if(o&&[...e,"path"].every(c=>o!==c))throw TypeError(`${O}: "${o}" is not SVGElement`);const n=r?o:t.type,i=le[n],s={type:n};r?i.forEach(c=>{s[c]=t.getAttribute(c)}):Object.assign(s,t);let a=[];return n==="circle"?a=Xt(s):n==="ellipse"?a=Yt(s):["polyline","polygon"].includes(n)?a=Wt(s):n==="rect"?a=en(s):n==="line"?a=Kt(s):["glyph","path"].includes(n)&&(a=_(r?t.getAttribute("d")||"":t.d||"")),Ce(a)&&a.length?a:!1},tn=(t,e,r)=>{const o=r||document,n=Object.keys(le),i=Lt(t),s=i?t.tagName:null;if(s==="path")throw TypeError(`${O}: "${s}" is already SVGPathElement`);if(s&&n.every(m=>s!==m))throw TypeError(`${O}: "${s}" is not SVGElement`);const a=o.createElementNS("http://www.w3.org/2000/svg","path"),c=i?s:t.type,l=le[c],u={type:c},h=ce.round,f=Nt(t),y=f&&f.length?Ct(f,h):"";return i?(l.forEach(m=>{u[m]=t.getAttribute(m)}),Object.values(t.attributes).forEach(({name:m,value:d})=>{l.includes(m)||a.setAttribute(m,d)})):(Object.assign(u,t),Object.keys(u).forEach(m=>{!l.includes(m)&&m!=="type"&&a.setAttribute(m.replace(/[A-Z]/g,d=>`-${d.toLowerCase()}`),u[m])})),Tt(y)?(a.setAttribute("d",y),e&&i&&(t.before(a,t),t.remove()),a):!1},vt=t=>{let e=new w;const{origin:r}=t,[o,n]=r,{translate:i}=t,{rotate:s}=t,{skew:a}=t,{scale:c}=t;return Array.isArray(i)&&i.length>=2&&i.every(l=>!Number.isNaN(+l))&&i.some(l=>l!==0)?e=e.translate(...i):typeof i=="number"&&!Number.isNaN(i)&&(e=e.translate(i)),(s||a||c)&&(e=e.translate(o,n),Array.isArray(s)&&s.length>=2&&s.every(l=>!Number.isNaN(+l))&&s.some(l=>l!==0)?e=e.rotate(...s):typeof s=="number"&&!Number.isNaN(s)&&(e=e.rotate(s)),Array.isArray(a)&&a.length===2&&a.every(l=>!Number.isNaN(+l))&&a.some(l=>l!==0)?(e=a[0]?e.skewX(a[0]):e,e=a[1]?e.skewY(a[1]):e):typeof a=="number"&&!Number.isNaN(a)&&(e=e.skewX(a)),Array.isArray(c)&&c.length>=2&&c.every(l=>!Number.isNaN(+l))&&c.some(l=>l!==1)?e=e.scale(...c):typeof c=="number"&&!Number.isNaN(c)&&(e=e.scale(c)),e=e.translate(-o,-n)),e},zt=(t,e,r,o)=>{const[n]=t,{round:i}=ce,s=i,a=e.slice(1),{x1:c,y1:l,x2:u,y2:h,x:f,y}=r,[m,d]=a.slice(-2),M=t;if("TQ".includes(n)||(r.qx=null,r.qy=null),n==="L"){if(N(f,s)===N(m,s))return["V",d];if(N(y,s)===N(d,s))return["H",m]}else if(n==="C"){const[p,A]=a;if(r.x1=p,r.y1=A,"CS".includes(o)&&(N(p,s)===N(c*2-u,s)&&N(A,s)===N(l*2-h,s)||N(c,s)===N(u*2-f,s)&&N(l,s)===N(h*2-y,s)))return["S",a[2],a[3],a[4],a[5]]}else if(n==="Q"){const[p,A]=a;if(r.qx=p,r.qy=A,"QT".includes(o)&&N(p,s)===N(c*2-u,s)&&N(A,s)===N(l*2-h,s))return["T",a[2],a[3]]}return M},Pe=(t,e)=>{const r=t.slice(1).map(o=>N(o,e));return[t[0]].concat(r)},nn=(t,e)=>{const r=Re(t),o=typeof e=="number"&&e>=0?e:2,n={...se},i=[];let s="M",a="Z";return E(r,(c,l,u,h)=>{n.x=u,n.y=h;const f=be(c,n);let y=c;if([s]=c,i[l]=s,l){a=i[l-1];const d=zt(c,f,n,a),M=Pe(d,o),p=M.join(""),A=Ee(d,l,u,h),b=Pe(A,o),x=b.join("");y=p.length{let r=w.Translate(e[0],e[1],e[2]);return[,,,r.m44]=e,r=t.multiply(r),[r.m41,r.m42,r.m43,r.m44]},De=(t,e,r)=>{const[o,n,i]=r,[s,a,c]=rn(t,[e[0],e[1],0,1]),l=s-o,u=a-n,h=c-i;return[l*(Math.abs(i)/Math.abs(h)||1)+o,u*(Math.abs(i)/Math.abs(h)||1)+n]},on=t=>{const e=t.slice(1).map((r,o,n)=>o?n[o-1].slice(-2).concat(r.slice(1)):t[0].slice(1).concat(r.slice(1))).map(r=>r.map((o,n)=>r[r.length-n-2*(1-n%2)])).reverse();return[["M"].concat(e[0].slice(0,2))].concat(e.map(r=>["C"].concat(r.slice(2))))},sn=t=>{const e=Re(t),r=Me(e),o=e.length,n=e[o-1][0]==="Z",i=E(e,(s,a)=>{const c=r[a],l=a&&e[a-1],u=l&&l[0],h=e[a+1],f=h&&h[0],[y]=s,[m,d]=r[a?a-1:o-1].slice(-2);let M=s;switch(y){case"M":M=n?["Z"]:[y,m,d];break;case"A":M=[y,s[1],s[2],s[3],s[4],s[5]===1?0:1,m,d];break;case"C":h&&f==="S"?M=["S",s[1],s[2],m,d]:M=[y,s[3],s[4],s[1],s[2],m,d];break;case"S":u&&"CS".includes(u)&&(!h||f!=="S")?M=["C",c[3],c[4],c[1],c[2],m,d]:M=[y,c[1],c[2],m,d];break;case"Q":h&&f==="T"?M=["T",m,d]:M=[y,s[1],s[2],m,d];break;case"T":u&&"QT".includes(u)&&(!h||f!=="T")?M=["Q",c[1],c[2],m,d]:M=[y,m,d];break;case"Z":M=["M",m,d];break;case"H":M=[y,m];break;case"V":M=[y,d];break;default:M=[y].concat(s.slice(1,-2),m,d)}return M});return n?i.reverse():[i[0]].concat(i.slice(1).reverse())},cn=(t,e)=>{let{round:r}=ce;return r=e==="off"||typeof e=="number"&&e>=0?e:typeof r=="number"&&r>=0?r:"off",r==="off"?t.slice(0):E(t,o=>Pe(o,r))},an=(t,e=.5)=>{const r=e,o=t.slice(0,2),n=t.slice(2,4),i=t.slice(4,6),s=t.slice(6,8),a=Z(o,n,r),c=Z(n,i,r),l=Z(i,s,r),u=Z(a,c,r),h=Z(c,l,r),f=Z(u,h,r);return[["C",a[0],a[1],u[0],u[1],f[0],f[1]],["C",h[0],h[1],l[0],l[1],s[0],s[1]]]},ln=t=>{const e=[];let r,o=-1,n=0,i=0,s=0,a=0;const c={...se};return t.forEach(l=>{const[u]=l,h=u.toUpperCase(),f=u.toLowerCase(),y=u===f,m=l.slice(1);h==="M"?(o+=1,[n,i]=m,n+=y?c.x:0,i+=y?c.y:0,s=n,a=i,r=[y?[h,s,a]:l]):(h==="Z"?(n=s,i=a):h==="H"?([,n]=l,n+=y?c.x:0):h==="V"?([,i]=l,i+=y?c.y:0):([n,i]=l.slice(-2),n+=y?c.x:0,i+=y?c.y:0),r.push(l)),c.x=n,c.y=i,e[o]=r}),e},mn=(t,e)=>{let r=0,o=0,n=0,i=0,s=0,a=0,c="M";const l=_(t),u=e&&Object.keys(e);if(!e||u&&!u.length)return l.slice(0);e.origin||Object.assign(e,{origin:ce.origin});const h=e.origin,f=vt(e);return f.isIdentity?l.slice(0):E(l,(y,m,d,M)=>{[c]=y;const p=c.toUpperCase(),b=p!==c?oe(y,m,d,M):y.slice(0);let x=p==="A"?["C"].concat(ge(d,M,b[1],b[2],b[3],b[4],b[5],b[6],b[7])):p==="V"?["L",d,b[1]]:p==="H"?["L",b[1],M]:b;c=x[0];const C=c==="C"&&x.length>7,S=C?x.slice(0,7):x.slice(0);if(C&&(l.splice(m+1,0,["C"].concat(x.slice(7))),x=S),c==="L")[n,i]=De(f,[x[1],x[2]],h),r!==n&&o!==i?x=["L",n,i]:o===i?x=["H",n]:r===n&&(x=["V",i]);else for(s=1,a=x.length;s{var ot=Object.defineProperty;var rr=Object.getOwnPropertyDescriptor;var nr=Object.getOwnPropertyNames;var or=Object.prototype.hasOwnProperty;var se=(t,e)=>{for(var n in e)ot(t,n,{get:e[n],enumerable:!0})},ar=(t,e,n,o)=>{if(e&&typeof e=="object"||typeof e=="function")for(let r of nr(e))!or.call(t,r)&&r!==n&&ot(t,r,{get:()=>e[r],enumerable:!(o=rr(e,r))||o.enumerable});return t};var mr=t=>ar(ot({},"__esModule",{value:!0}),t);var Rn={};se(Rn,{CSSMatrix:()=>M,absolutizeSegment:()=>_,arcToCubic:()=>Se,arcTools:()=>ct,bezierTools:()=>ft,cubicTools:()=>bt,distanceEpsilon:()=>fe,distanceSquareRoot:()=>ie,finalizeSegment:()=>Ne,getClosestPoint:()=>Ot,getDrawDirection:()=>jt,getPathArea:()=>Ue,getPathBBox:()=>Bt,getPointAtLength:()=>Ce,getPropertiesAtLength:()=>Me,getPropertiesAtPoint:()=>re,getSVGMatrix:()=>et,getSegmentAtLength:()=>Zt,getSegmentOfPoint:()=>Ht,getTotalLength:()=>te,invalidPathValue:()=>H,isAbsoluteArray:()=>Je,isArcCommand:()=>Ze,isCurveArray:()=>Ft,isDigit:()=>Z,isDigitStart:()=>Be,isMoveCommand:()=>He,isNormalizedArray:()=>Ke,isPathArray:()=>ne,isPathCommand:()=>je,isPointInStroke:()=>Gt,isRelativeArray:()=>_t,isSpace:()=>Oe,isValidPath:()=>We,iterate:()=>T,lineToCubic:()=>ke,lineTools:()=>mt,midPoint:()=>$,normalizePath:()=>ee,normalizeSegment:()=>Y,optimizePath:()=>Jt,paramsCount:()=>F,paramsParser:()=>U,parsePathString:()=>w,pathParser:()=>X,pathToAbsolute:()=>xe,pathToCurve:()=>Ae,pathToRelative:()=>Et,pathToString:()=>_e,polygonTools:()=>dt,projection2d:()=>Re,quadToCubic:()=>Fe,quadTools:()=>yt,relativizeSegment:()=>Pe,reverseCurve:()=>Kt,reversePath:()=>Wt,rotateVector:()=>pe,roundPath:()=>Xt,roundSegment:()=>he,roundTo:()=>L,scanFlag:()=>Ee,scanParam:()=>$e,scanSegment:()=>de,segmentToCubic:()=>Ge,shapeParams:()=>oe,shapeToPath:()=>Ut,shapeToPathArray:()=>Ye,shortenSegment:()=>tt,skipSpaces:()=>G,splitCubic:()=>Yt,splitPath:()=>er,transformPath:()=>tr});var sr=Object.defineProperty,ir=(t,e,n)=>e in t?sr(t,e,{enumerable:!0,configurable:!0,writable:!0,value:n}):t[e]=n,E=(t,e,n)=>ir(t,typeof e!="symbol"?e+"":e,n),ur={a:1,b:0,c:0,d:1,e:0,f:0,m11:1,m12:0,m13:0,m14:0,m21:0,m22:1,m23:0,m24:0,m31:0,m32:0,m33:1,m34:0,m41:0,m42:0,m43:0,m44:1,is2D:!0,isIdentity:!0},Pt=t=>(t instanceof Float64Array||t instanceof Float32Array||Array.isArray(t)&&t.every(e=>typeof e=="number"))&&[6,16].some(e=>t.length===e),St=t=>t instanceof DOMMatrix||t instanceof M||typeof t=="object"&&Object.keys(ur).every(e=>t&&e in t),Te=t=>{let e=new M,n=Array.from(t);if(!Pt(n))throw TypeError(`CSSMatrix: "${n.join(",")}" must be an array with 6/16 numbers.`);if(n.length===16){let[o,r,a,m,i,s,u,c,p,f,h,l,b,d,x,P]=n;e.m11=o,e.a=o,e.m21=i,e.c=i,e.m31=p,e.m41=b,e.e=b,e.m12=r,e.b=r,e.m22=s,e.d=s,e.m32=f,e.m42=d,e.f=d,e.m13=a,e.m23=u,e.m33=h,e.m43=x,e.m14=m,e.m24=c,e.m34=l,e.m44=P}else if(n.length===6){let[o,r,a,m,i,s]=n;e.m11=o,e.a=o,e.m12=r,e.b=r,e.m21=a,e.c=a,e.m22=m,e.d=m,e.m41=i,e.e=i,e.m42=s,e.f=s}return e},At=t=>{if(St(t))return Te([t.m11,t.m12,t.m13,t.m14,t.m21,t.m22,t.m23,t.m24,t.m31,t.m32,t.m33,t.m34,t.m41,t.m42,t.m43,t.m44]);throw TypeError(`CSSMatrix: "${JSON.stringify(t)}" is not a DOMMatrix / CSSMatrix / JSON compatible object.`)},Ct=t=>{if(typeof t!="string")throw TypeError(`CSSMatrix: "${JSON.stringify(t)}" is not a string.`);let e=String(t).replace(/\s/g,""),n=new M,o=`CSSMatrix: invalid transform string "${t}"`;return e.split(")").filter(r=>r).forEach(r=>{let[a,m]=r.split("(");if(!m)throw TypeError(o);let i=m.split(",").map(l=>l.includes("rad")?parseFloat(l)*(180/Math.PI):parseFloat(l)),[s,u,c,p]=i,f=[s,u,c],h=[s,u,c,p];if(a==="perspective"&&s&&[u,c].every(l=>l===void 0))n.m34=-1/s;else if(a.includes("matrix")&&[6,16].includes(i.length)&&i.every(l=>!Number.isNaN(+l))){let l=i.map(b=>Math.abs(b)<1e-6?0:b);n=n.multiply(Te(l))}else if(a==="translate3d"&&f.every(l=>!Number.isNaN(+l)))n=n.translate(s,u,c);else if(a==="translate"&&s&&c===void 0)n=n.translate(s,u||0,0);else if(a==="rotate3d"&&h.every(l=>!Number.isNaN(+l))&&p)n=n.rotateAxisAngle(s,u,c,p);else if(a==="rotate"&&s&&[u,c].every(l=>l===void 0))n=n.rotate(0,0,s);else if(a==="scale3d"&&f.every(l=>!Number.isNaN(+l))&&f.some(l=>l!==1))n=n.scale(s,u,c);else if(a==="scale"&&!Number.isNaN(s)&&(s!==1||u!==1)&&c===void 0){let l=Number.isNaN(+u)?s:u;n=n.scale(s,l,1)}else if(a==="skew"&&(s||!Number.isNaN(s)&&u)&&c===void 0)n=n.skew(s,u||0);else if(["translate","rotate","scale","skew"].some(l=>a.includes(l))&&/[XYZ]/.test(a)&&s&&[u,c].every(l=>l===void 0))if(a==="skewX"||a==="skewY")n=n[a](s);else{let l=a.replace(/[XYZ]/,""),b=a.replace(l,""),d=["X","Y","Z"].indexOf(b),x=l==="scale"?1:0,P=[d===0?s:x,d===1?s:x,d===2?s:x];n=n[l](...P)}else throw TypeError(o)}),n},at=(t,e)=>e?[t.a,t.b,t.c,t.d,t.e,t.f]:[t.m11,t.m12,t.m13,t.m14,t.m21,t.m22,t.m23,t.m24,t.m31,t.m32,t.m33,t.m34,t.m41,t.m42,t.m43,t.m44],Mt=(t,e,n)=>{let o=new M;return o.m41=t,o.e=t,o.m42=e,o.f=e,o.m43=n,o},Tt=(t,e,n)=>{let o=new M,r=Math.PI/180,a=t*r,m=e*r,i=n*r,s=Math.cos(a),u=-Math.sin(a),c=Math.cos(m),p=-Math.sin(m),f=Math.cos(i),h=-Math.sin(i),l=c*f,b=-c*h;o.m11=l,o.a=l,o.m12=b,o.b=b,o.m13=p;let d=u*p*f+s*h;o.m21=d,o.c=d;let x=s*f-u*p*h;return o.m22=x,o.d=x,o.m23=-u*c,o.m31=u*h-s*p*f,o.m32=u*f+s*p*h,o.m33=s*c,o},Lt=(t,e,n,o)=>{let r=new M,a=Math.sqrt(t*t+e*e+n*n);if(a===0)return r;let m=t/a,i=e/a,s=n/a,u=o*(Math.PI/360),c=Math.sin(u),p=Math.cos(u),f=c*c,h=m*m,l=i*i,b=s*s,d=1-2*(l+b)*f;r.m11=d,r.a=d;let x=2*(m*i*f+s*c*p);r.m12=x,r.b=x,r.m13=2*(m*s*f-i*c*p);let P=2*(i*m*f-s*c*p);r.m21=P,r.c=P;let g=1-2*(b+h)*f;return r.m22=g,r.d=g,r.m23=2*(i*s*f+m*c*p),r.m31=2*(s*m*f+i*c*p),r.m32=2*(s*i*f-m*c*p),r.m33=1-2*(h+l)*f,r},vt=(t,e,n)=>{let o=new M;return o.m11=t,o.a=t,o.m22=e,o.d=e,o.m33=n,o},Ve=(t,e)=>{let n=new M;if(t){let o=t*Math.PI/180,r=Math.tan(o);n.m21=r,n.c=r}if(e){let o=e*Math.PI/180,r=Math.tan(o);n.m12=r,n.b=r}return n},wt=t=>Ve(t,0),Nt=t=>Ve(0,t),W=(t,e)=>{let n=e.m11*t.m11+e.m12*t.m21+e.m13*t.m31+e.m14*t.m41,o=e.m11*t.m12+e.m12*t.m22+e.m13*t.m32+e.m14*t.m42,r=e.m11*t.m13+e.m12*t.m23+e.m13*t.m33+e.m14*t.m43,a=e.m11*t.m14+e.m12*t.m24+e.m13*t.m34+e.m14*t.m44,m=e.m21*t.m11+e.m22*t.m21+e.m23*t.m31+e.m24*t.m41,i=e.m21*t.m12+e.m22*t.m22+e.m23*t.m32+e.m24*t.m42,s=e.m21*t.m13+e.m22*t.m23+e.m23*t.m33+e.m24*t.m43,u=e.m21*t.m14+e.m22*t.m24+e.m23*t.m34+e.m24*t.m44,c=e.m31*t.m11+e.m32*t.m21+e.m33*t.m31+e.m34*t.m41,p=e.m31*t.m12+e.m32*t.m22+e.m33*t.m32+e.m34*t.m42,f=e.m31*t.m13+e.m32*t.m23+e.m33*t.m33+e.m34*t.m43,h=e.m31*t.m14+e.m32*t.m24+e.m33*t.m34+e.m34*t.m44,l=e.m41*t.m11+e.m42*t.m21+e.m43*t.m31+e.m44*t.m41,b=e.m41*t.m12+e.m42*t.m22+e.m43*t.m32+e.m44*t.m42,d=e.m41*t.m13+e.m42*t.m23+e.m43*t.m33+e.m44*t.m43,x=e.m41*t.m14+e.m42*t.m24+e.m43*t.m34+e.m44*t.m44;return Te([n,o,r,a,m,i,s,u,c,p,f,h,l,b,d,x])},M=class{constructor(e){return this.a=1,this.b=0,this.c=0,this.d=1,this.e=0,this.f=0,this.m11=1,this.m12=0,this.m13=0,this.m14=0,this.m21=0,this.m22=1,this.m23=0,this.m24=0,this.m31=0,this.m32=0,this.m33=1,this.m34=0,this.m41=0,this.m42=0,this.m43=0,this.m44=1,e?this.setMatrixValue(e):this}get isIdentity(){return this.m11===1&&this.m12===0&&this.m13===0&&this.m14===0&&this.m21===0&&this.m22===1&&this.m23===0&&this.m24===0&&this.m31===0&&this.m32===0&&this.m33===1&&this.m34===0&&this.m41===0&&this.m42===0&&this.m43===0&&this.m44===1}get is2D(){return this.m31===0&&this.m32===0&&this.m33===1&&this.m34===0&&this.m43===0&&this.m44===1}setMatrixValue(e){return typeof e=="string"&&e.length&&e!=="none"?Ct(e):Array.isArray(e)||e instanceof Float64Array||e instanceof Float32Array?Te(e):typeof e=="object"?At(e):this}toFloat32Array(e){return Float32Array.from(at(this,e))}toFloat64Array(e){return Float64Array.from(at(this,e))}toString(){let{is2D:e}=this,n=this.toFloat64Array(e).join(", ");return`${e?"matrix":"matrix3d"}(${n})`}toJSON(){let{is2D:e,isIdentity:n}=this;return{...this,is2D:e,isIdentity:n}}multiply(e){return W(this,e)}translate(e,n,o){let r=e,a=n,m=o;return typeof a>"u"&&(a=0),typeof m>"u"&&(m=0),W(this,Mt(r,a,m))}scale(e,n,o){let r=e,a=n,m=o;return typeof a>"u"&&(a=e),typeof m>"u"&&(m=1),W(this,vt(r,a,m))}rotate(e,n,o){let r=e,a=n||0,m=o||0;return typeof e=="number"&&typeof n>"u"&&typeof o>"u"&&(m=r,r=0,a=0),W(this,Tt(r,a,m))}rotateAxisAngle(e,n,o,r){if([e,n,o,r].some(a=>Number.isNaN(+a)))throw new TypeError("CSSMatrix: expecting 4 values");return W(this,Lt(e,n,o,r))}skewX(e){return W(this,wt(e))}skewY(e){return W(this,Nt(e))}skew(e,n){return W(this,Ve(e,n))}transformPoint(e){let n=this.m11*e.x+this.m21*e.y+this.m31*e.z+this.m41*e.w,o=this.m12*e.x+this.m22*e.y+this.m32*e.z+this.m42*e.w,r=this.m13*e.x+this.m23*e.y+this.m33*e.z+this.m43*e.w,a=this.m14*e.x+this.m24*e.y+this.m34*e.z+this.m44*e.w;return e instanceof DOMPoint?new DOMPoint(n,o,r,a):{x:n,y:o,z:r,w:a}}};E(M,"Translate",Mt),E(M,"Rotate",Tt),E(M,"RotateAxisAngle",Lt),E(M,"Scale",vt),E(M,"SkewX",wt),E(M,"SkewY",Nt),E(M,"Skew",Ve),E(M,"Multiply",W),E(M,"fromArray",Te),E(M,"fromMatrix",At),E(M,"fromString",Ct),E(M,"toArray",at),E(M,"isCompatibleArray",Pt),E(M,"isCompatibleObject",St);var ct={};se(ct,{angleBetween:()=>st,arcLength:()=>it,arcPoint:()=>le,getArcBBox:()=>lt,getArcLength:()=>ve,getArcProps:()=>De,getPointAtArcLength:()=>ut});var mt={};se(mt,{getLineBBox:()=>ze,getLineLength:()=>ue,getPointAtLineLength:()=>Le});var lr=(t,e,n)=>{let[o,r]=t,[a,m]=e;return[o+(a-o)*n,r+(m-r)*n]},$=lr;var cr=(t,e)=>Math.sqrt((t[0]-e[0])*(t[0]-e[0])+(t[1]-e[1])*(t[1]-e[1])),ie=cr;var ue=(t,e,n,o)=>ie([t,e],[n,o]),Le=(t,e,n,o,r)=>{let a={x:t,y:e};if(typeof r=="number"){let m=ie([t,e],[n,o]);if(r<=0)a={x:t,y:e};else if(r>=m)a={x:n,y:o};else{let[i,s]=$([t,e],[n,o],r/m);a={x:i,y:s}}}return a},ze=(t,e,n,o)=>{let{min:r,max:a}=Math;return[r(t,n),r(e,o),a(t,n),a(e,o)]};var it=(t,e,n)=>{let o=n/2,r=Math.sin(o),a=Math.cos(o),m=t**2*r**2,i=e**2*a**2,s=Math.sqrt(m+i)*n;return Math.abs(s)},le=(t,e,n,o,r,a)=>{let{sin:m,cos:i}=Math,s=i(r),u=m(r),c=n*i(a),p=o*m(a);return[t+s*c-u*p,e+u*c+s*p]},st=(t,e)=>{let{x:n,y:o}=t,{x:r,y:a}=e,m=n*r+o*a,i=Math.sqrt((n**2+o**2)*(r**2+a**2));return(n*a-o*r<0?-1:1)*Math.acos(m/i)},De=(t,e,n,o,r,a,m,i,s)=>{let{abs:u,sin:c,cos:p,sqrt:f,PI:h}=Math,l=u(n),b=u(o),x=(r%360+360)%360*(h/180);if(t===i&&e===s)return{rx:l,ry:b,startAngle:0,endAngle:0,center:{x:i,y:s}};if(l===0||b===0)return{rx:l,ry:b,startAngle:0,endAngle:0,center:{x:(i+t)/2,y:(s+e)/2}};let P=(t-i)/2,g=(e-s)/2,y={x:p(x)*P+c(x)*g,y:-c(x)*P+p(x)*g},S=y.x**2/l**2+y.y**2/b**2;S>1&&(l*=f(S),b*=f(S));let C=l**2*b**2-l**2*y.y**2-b**2*y.x**2,V=l**2*y.y**2+b**2*y.x**2,z=C/V;z=z<0?0:z;let k=(a!==m?1:-1)*f(z),v={x:k*(l*y.y/b),y:k*(-(b*y.x)/l)},j={x:p(x)*v.x-c(x)*v.y+(t+i)/2,y:c(x)*v.x+p(x)*v.y+(e+s)/2},ae={x:(y.x-v.x)/l,y:(y.y-v.y)/b},D=st({x:1,y:0},ae),A={x:(-y.x-v.x)/l,y:(-y.y-v.y)/b},Q=st(ae,A);!m&&Q>0?Q-=2*h:m&&Q<0&&(Q+=2*h),Q%=2*h;let B=D+Q;return{center:j,startAngle:D,endAngle:B,rx:l,ry:b}},ve=(t,e,n,o,r,a,m,i,s)=>{let{rx:u,ry:c,startAngle:p,endAngle:f}=De(t,e,n,o,r,a,m,i,s);return it(u,c,f-p)},ut=(t,e,n,o,r,a,m,i,s,u)=>{let c={x:t,y:e},{center:p,rx:f,ry:h,startAngle:l,endAngle:b}=De(t,e,n,o,r,a,m,i,s);if(typeof u=="number"){let d=it(f,h,b-l);if(u<=0)c={x:t,y:e};else if(u>=d)c={x:i,y:s};else{if(t===i&&e===s)return{x:i,y:s};if(f===0||h===0)return Le(t,e,i,s,u);let{PI:x,cos:P,sin:g}=Math,y=b-l,C=(r%360+360)%360*(x/180),V=l+y*(u/d),z=f*P(V),k=h*g(V);c={x:P(C)*z-g(C)*k+p.x,y:g(C)*z+P(C)*k+p.y}}}return c},lt=(t,e,n,o,r,a,m,i,s)=>{let{center:u,rx:c,ry:p,startAngle:f,endAngle:h}=De(t,e,n,o,r,a,m,i,s),l=h-f,{min:b,max:d,tan:x,atan2:P,PI:g}=Math,{x:y,y:S}=u,C=r*g/180,V=x(C),z=P(-p*V,c),k=z,v=z+g,j=P(p,c*V),ae=j+g,D=[i],A=[s],Q=b(t,i),B=d(t,i),O=b(e,s),K=d(e,s),be=h-l*1e-5,me=le(y,S,c,p,C,be),N=h-l*.99999,q=le(y,S,c,p,C,N);if(me[0]>B||q[0]>B){let R=le(y,S,c,p,C,k);D.push(R[0]),A.push(R[1])}if(me[0]K||q[1]>K){let R=le(y,S,c,p,C,j);D.push(R[0]),A.push(R[1])}return Q=b.apply([],D),O=b.apply([],A),B=d.apply([],D),K=d.apply([],A),[Q,O,B,K]};var ft={};se(ft,{CBEZIER_MINMAX_EPSILON:()=>Qt,Cvalues:()=>kt,Tvalues:()=>pt,bezierLength:()=>Dt,calculateBezier:()=>zt,computeBezier:()=>Vt,deriveBezier:()=>Rt,getBezierLength:()=>ce,minmaxC:()=>Qe,minmaxQ:()=>we});var pt=[-.06405689286260563,.06405689286260563,-.1911188674736163,.1911188674736163,-.3150426796961634,.3150426796961634,-.4337935076260451,.4337935076260451,-.5454214713888396,.5454214713888396,-.6480936519369755,.6480936519369755,-.7401241915785544,.7401241915785544,-.820001985973903,.820001985973903,-.8864155270044011,.8864155270044011,-.9382745520027328,.9382745520027328,-.9747285559713095,.9747285559713095,-.9951872199970213,.9951872199970213],kt=[.12793819534675216,.12793819534675216,.1258374563468283,.1258374563468283,.12167047292780339,.12167047292780339,.1155056680537256,.1155056680537256,.10744427011596563,.10744427011596563,.09761865210411388,.09761865210411388,.08619016153195327,.08619016153195327,.0733464814110803,.0733464814110803,.05929858491543678,.05929858491543678,.04427743881741981,.04427743881741981,.028531388628933663,.028531388628933663,.0123412297999872,.0123412297999872],Rt=t=>{let e=[];for(let n=t,o=n.length,r=o-1;o>1;o-=1,r-=1){let a=[];for(let m=0;m{if(e===0)return t[0].t=0,t[0];let n=t.length-1;if(e===1)return t[n].t=1,t[n];let o=1-e,r=t;if(n===0)return t[0].t=e,t[0];if(n===1)return{x:o*r[0].x+e*r[1].x,y:o*r[0].y+e*r[1].y,t:e};let a=o*o,m=e*e,i=0,s=0,u=0,c=0;return n===2?(r=[r[0],r[1],r[2],{x:0,y:0}],i=a,s=o*e*2,u=m):n===3&&(i=a*o,s=a*e*3,u=o*m*3,c=e*m),{x:i*r[0].x+s*r[1].x+u*r[2].x+c*r[3].x,y:i*r[0].y+s*r[1].y+u*r[2].y+c*r[3].y,t:e}},zt=(t,e)=>{let n=t(e),o=n.x*n.x+n.y*n.y;return Math.sqrt(o)},Dt=t=>{let n=pt.length,o=0;for(let r=0,a;r{let e=[];for(let o=0,r=t.length,a=2;oVt(n[0],o))},Qt=1e-8,we=([t,e,n])=>{let o=Math.min(t,n),r=Math.max(t,n);if(e>=t?n>=e:n<=e)return[o,r];let a=(t*n-e*e)/(t-2*e+n);return a{let r=t-3*e+3*n-o;if(Math.abs(r)0&&c<1){let f=t*(1-c)*(1-c)*(1-c)+e*3*(1-c)*(1-c)*c+n*3*(1-c)*c*c+o*c*c*c;fs&&(s=f)}}return[i,s]};var bt={};se(bt,{getCubicBBox:()=>qe,getCubicLength:()=>ge,getPointAtCubicLength:()=>ht,getPointAtCubicSegmentLength:()=>qt});var qt=([t,e,n,o,r,a,m,i],s)=>{let u=1-s;return{x:u**3*t+3*u**2*s*n+3*u*s**2*r+s**3*m,y:u**3*e+3*u**2*s*o+3*u*s**2*a+s**3*i}},ge=(t,e,n,o,r,a,m,i)=>ce([t,e,n,o,r,a,m,i]),ht=(t,e,n,o,r,a,m,i,s)=>{let u=typeof s=="number",c={x:t,y:e};if(u){let p=ce([t,e,n,o,r,a,m,i]);s<=0||(s>=p?c={x:m,y:i}:c=qt([t,e,n,o,r,a,m,i],s/p))}return c},qe=(t,e,n,o,r,a,m,i)=>{let s=Qe([t,n,r,m]),u=Qe([e,o,a,i]);return[s[0],u[0],s[1],u[1]]};var yt={};se(yt,{getPointAtQuadLength:()=>gt,getPointAtQuadSegmentLength:()=>It,getQuadBBox:()=>Ie,getQuadLength:()=>ye});var It=([t,e,n,o,r,a],m)=>{let i=1-m;return{x:i**2*t+2*i*m*n+m**2*r,y:i**2*e+2*i*m*o+m**2*a}},ye=(t,e,n,o,r,a)=>ce([t,e,n,o,r,a]),gt=(t,e,n,o,r,a,m)=>{let i=typeof m=="number",s={x:t,y:e};if(i){let u=ce([t,e,n,o,r,a]);m<=0||(m>=u?s={x:r,y:a}:s=It([t,e,n,o,r,a],m/u))}return s},Ie=(t,e,n,o,r,a)=>{let m=we([t,n,r]),i=we([e,o,a]);return[m[0],i[0],m[1],i[1]]};var dt={};se(dt,{polygonArea:()=>pr,polygonLength:()=>fr});var pr=t=>{let e=t.length,n=-1,o,r=t[e-1],a=0;for(;++nt.reduce((e,n,o)=>o?e+ie(t[o-1],n):0,0);var hr={a:7,c:6,h:1,l:2,m:2,r:4,q:4,s:4,t:2,v:1,z:0},F=hr;var br=t=>{let e=t.pathValue[t.segmentStart],n=e.toLowerCase(),{data:o}=t;for(;o.length>=F[n]&&(n==="m"&&o.length>2?(t.segments.push([e].concat(o.splice(0,2))),n="l",e=e==="m"?"l":"L"):t.segments.push([e].concat(o.splice(0,F[n]))),!!F[n]););},Ne=br;var gr="SVGPathCommander Error",I=gr;var yr=t=>{let{index:e,pathValue:n}=t,o=n.charCodeAt(e);if(o===48){t.param=0,t.index+=1;return}if(o===49){t.param=1,t.index+=1;return}t.err=`${I}: invalid Arc flag "${n[e]}", expecting 0 or 1 at index ${e}`},Ee=yr;var dr=t=>t>=48&&t<=57,Z=dr;var xr="Invalid path value",H=xr;var Pr=t=>{let{max:e,pathValue:n,index:o}=t,r=o,a=!1,m=!1,i=!1,s=!1,u;if(r>=e){t.err=`${I}: ${H} at index ${r}, "pathValue" is missing param`;return}if(u=n.charCodeAt(r),(u===43||u===45)&&(r+=1,u=n.charCodeAt(r)),!Z(u)&&u!==46){t.err=`${I}: ${H} at index ${r}, "${n[r]}" is not a number`;return}if(u!==46){if(a=u===48,r+=1,u=n.charCodeAt(r),a&&r[5760,6158,8192,8193,8194,8195,8196,8197,8198,8199,8200,8201,8202,8239,8287,12288,65279,10,13,8232,8233,32,9,11,12,160].includes(t),Oe=Sr;var Ar=t=>{let{pathValue:e,max:n}=t;for(;t.index{switch(t|32){case 109:case 122:case 108:case 104:case 118:case 99:case 115:case 113:case 116:case 97:return!0;default:return!1}},je=Cr;var Mr=t=>Z(t)||t===43||t===45||t===46,Be=Mr;var Tr=t=>(t|32)===97,Ze=Tr;var Lr=t=>{switch(t|32){case 109:case 77:return!0;default:return!1}},He=Lr;var vr=t=>{let{max:e,pathValue:n,index:o,segments:r}=t,a=n.charCodeAt(o),m=F[n[o].toLowerCase()];if(t.segmentStart=o,!je(a)){t.err=`${I}: ${H} "${n[o]}" is not a path command at index ${o}`;return}let i=r[r.length-1];if(!He(a)&&i?.[0]?.toLocaleLowerCase()==="z"){t.err=`${I}: ${H} "${n[o]}" is not a MoveTo path command at index ${o}`;return}if(t.index+=1,G(t),t.data=[],!m){Ne(t);return}for(;;){for(let s=m;s>0;s-=1){if(Ze(a)&&(s===3||s===4)?Ee(t):$e(t),t.err.length)return;t.data.push(t.param),G(t),t.index=t.max||!Be(n.charCodeAt(t.index)))break}Ne(t)},de=vr;var X=class{constructor(e){this.segments=[],this.pathValue=e,this.max=e.length,this.index=0,this.param=0,this.segmentStart=0,this.data=[],this.err=""}};var wr=t=>{if(typeof t!="string")return t.slice(0);let e=new X(t);for(G(e);e.index{let[r]=t,a=r.toUpperCase(),m=a===r;if(e===0||m)return t;if(a==="A")return[a,t[1],t[2],t[3],t[4],t[5],t[6]+n,t[7]+o];if(a==="V")return[a,t[1]+o];if(a==="H")return[a,t[1]+n];if(a==="L")return[a,t[1]+n,t[2]+o];{let i=[],s=t.length;for(let u=1;u{let n=t.length,o,r="M",a="M",m=!1,i=0,s=0,u=0,c=0,p=0;for(let f=0;f{let e=w(t);return T(e,_)},xe=Rr;var Vr=(t,e,n,o)=>{let[r]=t,a=r.toLowerCase(),m=r===a;if(e===0||m)return t;if(a==="a")return[a,t[1],t[2],t[3],t[4],t[5],t[6]-n,t[7]-o];if(a==="v")return[a,t[1]-o];if(a==="h")return[a,t[1]-n];if(a==="l")return[a,t[1]-n,t[2]-o];{let i=[],s=t.length;for(let u=1;u{let e=w(t);return T(e,Pe)},Et=zr;var Dr=(t,e,n)=>{let{sin:o,cos:r}=Math,a=t*r(n)-e*o(n),m=t*o(n)+e*r(n);return{x:a,y:m}},pe=Dr;var $t=(t,e,n,o,r,a,m,i,s,u)=>{let c=t,p=e,f=n,h=o,l=i,b=s,d=Math.PI*120/180,x=Math.PI/180*(+r||0),P=[],g,y,S,C,V;if(u)[y,S,C,V]=u;else{g=pe(c,p,-x),c=g.x,p=g.y,g=pe(l,b,-x),l=g.x,b=g.y;let N=(c-l)/2,q=(p-b)/2,R=N*N/(f*f)+q*q/(h*h);R>1&&(R=Math.sqrt(R),f*=R,h*=R);let rt=f*f,nt=h*h,xt=(a===m?-1:1)*Math.sqrt(Math.abs((rt*nt-rt*q*q-nt*N*N)/(rt*q*q+nt*N*N)));C=xt*f*q/h+(c+l)/2,V=xt*-h*N/f+(p+b)/2,y=Math.asin(((p-V)/h*10**9>>0)/10**9),S=Math.asin(((b-V)/h*10**9>>0)/10**9),y=cS&&(y-=Math.PI*2),!m&&S>y&&(S-=Math.PI*2)}let z=S-y;if(Math.abs(z)>d){let N=S,q=l,R=b;S=y+d*(m&&S>y?1:-1),l=C+f*Math.cos(S),b=V+h*Math.sin(S),P=$t(l,b,f,h,r,0,m,q,R,[S,N,C,V])}z=S-y;let k=Math.cos(y),v=Math.sin(y),j=Math.cos(S),ae=Math.sin(S),D=Math.tan(z/4),A=4/3*f*D,Q=4/3*h*D,B=[c,p],O=[c+A*v,p-Q*k],K=[l+A*ae,b-Q*j],be=[l,b];if(O[0]=2*B[0]-O[0],O[1]=2*B[1]-O[1],u)return[O[0],O[1],K[0],K[1],be[0],be[1]].concat(P);P=[O[0],O[1],K[0],K[1],be[0],be[1]].concat(P);let me=[];for(let N=0,q=P.length;N{let m=.3333333333333333,i=2/3;return[m*t+i*n,m*e+i*o,m*r+i*n,m*a+i*o,r,a]},Fe=Qr;var qr=(t,e,n,o)=>{let r=$([t,e],[n,o],.3333333333333333),a=$([t,e],[n,o],2/3);return[r[0],r[1],a[0],a[1],n,o]},ke=qr;var Ir=(t,e)=>{let[n]=t,o=t.slice(1).map(Number),[r,a]=o,{x1:m,y1:i,x:s,y:u}=e;return"TQ".includes(n)||(e.qx=null,e.qy=null),n==="M"?(e.x=r,e.y=a,t):n==="A"?["C"].concat(Se(m,i,o[0],o[1],o[2],o[3],o[4],o[5],o[6])):n==="Q"?(e.qx=r,e.qy=a,["C"].concat(Fe(m,i,o[0],o[1],o[2],o[3]))):n==="L"?["C"].concat(ke(m,i,r,a)):n==="Z"?["C"].concat(ke(m,i,s,u)):t},Ge=Ir;var Er=(t,e)=>{let[n]=t,o=n.toUpperCase(),r=n!==o,{x1:a,y1:m,x2:i,y2:s,x:u,y:c}=e,p=t.slice(1),f=p.map((h,l)=>h+(r?l%2?c:u:0));"TQ".includes(o)||(e.qx=null,e.qy=null);if(o==="A")return f=p.slice(0,-2).concat(p[5]+(r?u:0),p[6]+(r?c:0)),["A"].concat(f);if(o==="H")return["L",t[1]+(r?u:0),m];if(o==="V")return["L",a,t[1]+(r?c:0)];if(o==="L")return["L",t[1]+(r?u:0),t[2]+(r?c:0)];if(o==="M")return["M",t[1]+(r?u:0),t[2]+(r?c:0)];if(o==="C")return["C"].concat(f);if(o==="S"){let h=a*2-i,l=m*2-s;return e.x1=h,e.y1=l,["C",h,l].concat(f)}else if(o==="T"){let h=a*2-(e.qx?e.qx:0),l=m*2-(e.qy?e.qy:0);return e.qx=h,e.qy=l,["Q",h,l].concat(f)}else if(o==="Q"){let[h,l]=f;return e.qx=h,e.qy=l,["Q"].concat(f)}else if(o==="Z")return["Z"];return t},Y=Er;var $r={x1:0,y1:0,x2:0,y2:0,x:0,y:0,qx:null,qy:null},U=$r;var Or=t=>{let e={...U},n=w(t);return T(n,(o,r,a,m)=>{e.x=a,e.y=m;let i=Y(o,e),s=Ge(i,e);s[0]==="C"&&s.length>7&&(n.splice(r+1,0,["C"].concat(s.slice(7))),s=s.slice(0,7));let c=s.length;return e.x1=+s[c-2],e.y1=+s[c-1],e.x2=+s[c-4]||e.x1,e.y2=+s[c-3]||e.y1,s})},Ae=Or;var jr={origin:[0,0,0],round:4},J=jr;var Br=(t,e)=>{let n=e>=1?10**e:1;return e>0?Math.round(t*n)/n:Math.round(t)},L=Br;var Zr=(t,e)=>{let n=t.length,{round:o}=J,r=t[0],a="";o=e==="off"||typeof e=="number"&&e>=0?e:typeof o=="number"&&o>=0?o:"off";for(let m=0;m{let e=w(t),n={...U};return T(e,(o,r,a,m)=>{n.x=a,n.y=m;let i=Y(o,n),s=i.length;return n.x1=+i[s-2],n.y1=+i[s-1],n.x2=+i[s-4]||n.x1,n.y2=+i[s-3]||n.y1,i})},ee=Hr;var Fr=(t,e)=>{let n=ee(t),o=!1,r=[],a="M",m=0,i=0,[s,u]=n[0].slice(1),c=typeof e=="number",p={x:s,y:u},f=0,h=p,l=0;return!c||e{[a]=b,o=a==="M",r=o?r:[x,P].concat(b.slice(1));if(o?([,s,u]=b,p={x:s,y:u},f=0):a==="L"?(p=Le(r[0],r[1],r[2],r[3],e-l),f=ue(r[0],r[1],r[2],r[3])):a==="A"?(p=ut(r[0],r[1],r[2],r[3],r[4],r[5],r[6],r[7],r[8],e-l),f=ve(r[0],r[1],r[2],r[3],r[4],r[5],r[6],r[7],r[8])):a==="C"?(p=ht(r[0],r[1],r[2],r[3],r[4],r[5],r[6],r[7],e-l),f=ge(r[0],r[1],r[2],r[3],r[4],r[5],r[6],r[7])):a==="Q"?(p=gt(r[0],r[1],r[2],r[3],r[4],r[5],e-l),f=ye(r[0],r[1],r[2],r[3],r[4],r[5])):a==="Z"&&(r=[x,P,s,u],p={x:s,y:u},f=ue(r[0],r[1],r[2],r[3])),[m,i]=r.slice(-2),ll-fe?{x:m,y:i}:h)},Ce=Fr;var Gr=t=>{let e=w(t),n=0,o=0,r=0,a=0,m=0,i=0,s="M",u=0,c=0,p=0;return T(e,(f,h,l,b)=>{[s]=f;let d=s.toUpperCase(),P=d!==s?_(f,h,l,b):f.slice(0),g=d==="V"?["L",l,P[1]]:d==="H"?["L",P[1],b]:P;[s]=g,"TQ".includes(d)||(m=0,i=0);if(s==="M")[,u,c]=g;else if(s==="L")p+=ue(l,b,g[1],g[2]);else if(s==="A")p+=ve(l,b,g[1],g[2],g[3],g[4],g[5],g[6],g[7]);else if(s==="S"){let y=n*2-r,S=o*2-a;p+=ge(l,b,y,S,g[1],g[2],g[3],g[4])}else s==="C"?p+=ge(l,b,g[1],g[2],g[3],g[4],g[5],g[6]):s==="T"?(m=n*2-m,i=o*2-i,p+=ye(l,b,m,i,g[1],g[2])):s==="Q"?(m=g[1],i=g[2],p+=ye(l,b,g[1],g[2],g[3],g[4])):s==="Z"&&(p+=ue(l,b,u,c));[n,o]=s==="Z"?[u,c]:g.slice(-2),[r,a]=s==="C"?[g[3],g[4]]:s==="S"?[g[1],g[2]]:[n,o]}),p},te=Gr;var _r=(t,e)=>{let n=w(t),o=n.slice(0),r=te(o),a=o.length-1,m=0,i=0,s=n[0];if(a<=0||!e||!Number.isFinite(e))return{segment:s,index:0,length:i,lengthAtSegment:m};if(e>=r)return o=n.slice(0,-1),m=te(o),i=r-m,s=n[a],{segment:s,index:a,length:i,lengthAtSegment:m};let u=[];for(;a>0;)s=o[a],o=o.slice(0,-1),m=te(o),i=r-m,r=m,u.push({segment:s,index:a,length:i,lengthAtSegment:m}),a-=1;return u.find(({lengthAtSegment:c})=>c<=e)},Me=_r;var Ur=(t,e)=>{let n=w(t),o=ee(n),r=te(o),a=y=>{let S=y.x-e.x,C=y.y-e.y;return S*S+C*C},m=8,i,s={x:0,y:0},u=0,c=0,p=1/0;for(let y=0;y<=r;y+=m)i=Ce(o,y),u=a(i),u1e-6&&(l=c-m,f=Ce(o,l),d=a(f),b=c+m,h=Ce(o,b),x=a(h),l>=0&&dre(t,e).closest,Ot=Jr;var Kr=(t,e,n,o,r,a,m,i)=>3*((i-e)*(n+r)-(m-t)*(o+a)+o*(t-r)-n*(e-a)+i*(r+t/3)-m*(a+e/3))/20,Wr=t=>{let e=0,n=0,o=0;return Ae(t).map(r=>{switch(r[0]){case"M":return[,e,n]=r,0;default:return o=Kr(e,n,r[1],r[2],r[3],r[4],r[5],r[6]),[e,n]=r.slice(-2),o}}).reduce((r,a)=>r+a,0)},Ue=Wr;var Xr=t=>Ue(Ae(t))>=0,jt=Xr;var Yr=t=>{if(!t)return{x:0,y:0,width:0,height:0,x2:0,y2:0,cx:0,cy:0,cz:0};let e=w(t),n="M",o=0,r=0,{max:a,min:m}=Math,i=1/0,s=1/0,u=-1/0,c=-1/0,p=0,f=0,h=0,l=0,b=0,d=0,x=0,P=0,g=0,y=0;T(e,(V,z,k,v)=>{[n]=V;let j=n.toUpperCase(),D=j!==n?_(V,z,k,v):V.slice(0),A=j==="V"?["L",k,D[1]]:j==="H"?["L",D[1],v]:D;[n]=A,"TQ".includes(j)||(g=0,y=0);if(n==="M")[,o,r]=A,p=o,f=r,h=o,l=r;else if(n==="L")[p,f,h,l]=ze(k,v,A[1],A[2]);else if(n==="A")[p,f,h,l]=lt(k,v,A[1],A[2],A[3],A[4],A[5],A[6],A[7]);else if(n==="S"){let Q=b*2-x,B=d*2-P;[p,f,h,l]=qe(k,v,Q,B,A[1],A[2],A[3],A[4])}else n==="C"?[p,f,h,l]=qe(k,v,A[1],A[2],A[3],A[4],A[5],A[6]):n==="T"?(g=b*2-g,y=d*2-y,[p,f,h,l]=Ie(k,v,g,y,A[1],A[2])):n==="Q"?(g=A[1],y=A[2],[p,f,h,l]=Ie(k,v,A[1],A[2],A[3],A[4])):n==="Z"&&([p,f,h,l]=ze(k,v,o,r));i=m(p,i),s=m(f,s),u=a(h,u),c=a(l,c),[b,d]=n==="Z"?[o,r]:A.slice(-2),[x,P]=n==="C"?[A[3],A[4]]:n==="S"?[A[1],A[2]]:[b,d]});let S=u-i,C=c-s;return{width:S,height:C,x:i,y:s,x2:u,y2:c,cx:i+S/2,cy:s+C/2,cz:Math.max(S,C)+Math.min(S,C)/2}},Bt=Yr;var en=(t,e)=>Me(t,e).segment,Zt=en;var tn=(t,e)=>re(t,e).segment,Ht=tn;var rn=t=>Array.isArray(t)&&t.every(e=>{let n=e[0].toLowerCase();return F[n]===e.length-1&&"achlmqstvz".includes(n)&&e.slice(1).every(Number.isFinite)})&&t.length>0,ne=rn;var nn=t=>ne(t)&&t.every(([e])=>e===e.toUpperCase()),Je=nn;var on=t=>Je(t)&&t.every(([e])=>"ACLMQZ".includes(e)),Ke=on;var an=t=>Ke(t)&&t.every(([e])=>"MC".includes(e)),Ft=an;var mn=(t,e)=>{let{distance:n}=re(t,e);return Math.abs(n)ne(t)&&t.slice(1).every(([e])=>e===e.toLowerCase()),_t=sn;var un=t=>{if(typeof t!="string"||!t.length)return!1;let e=new X(t);for(G(e);e.indext!=null&&typeof t=="object"&&t.nodeType===1,Xe=cn;var pn=t=>{let{x1:e,y1:n,x2:o,y2:r}=t;return[e,n,o,r]=[e,n,o,r].map(a=>+a),[["M",e,n],["L",o,r]]},fn=t=>{let e=[],n=(t.points||"").trim().split(/[\s|,]/).map(r=>+r),o=0;for(;o{let{cx:e,cy:n,r:o}=t;return[e,n,o]=[e,n,o].map(r=>+r),[["M",e-o,n],["a",o,o,0,1,0,2*o,0],["a",o,o,0,1,0,-2*o,0]]},bn=t=>{let{cx:e,cy:n}=t,o=t.rx||0,r=t.ry||o;return[e,n,o,r]=[e,n,o,r].map(a=>+a),[["M",e-o,n],["a",o,r,0,1,0,2*o,0],["a",o,r,0,1,0,-2*o,0]]},gn=t=>{let e=+t.x||0,n=+t.y||0,o=+t.width,r=+t.height,a=+(t.rx||0),m=+(t.ry||a);if(a||m){a*2>o&&(a-=(a*2-o)/2);return m*2>r&&(m-=(m*2-r)/2),[["M",e+a,n],["h",o-a*2],["s",a,0,a,m],["v",r-m*2],["s",0,m,-a,m],["h",-o+a*2],["s",-a,0,-a,-m],["v",-r+m*2],["s",0,-m,a,-m]]}return[["M",e,n],["h",o],["v",r],["H",e],["Z"]]},yn=t=>{let e=Object.keys(oe),n=Xe(t),o=n?t.tagName:null;if(o&&[...e,"path"].every(s=>o!==s))throw TypeError(`${I}: "${o}" is not SVGElement`);let r=n?o:t.type,a=oe[r],m={type:r};n?a.forEach(s=>{m[s]=t.getAttribute(s)}):Object.assign(m,t);let i=[];return r==="circle"?i=hn(m):r==="ellipse"?i=bn(m):["polyline","polygon"].includes(r)?i=fn(m):r==="rect"?i=gn(m):r==="line"?i=pn(m):["glyph","path"].includes(r)&&(i=w(n?t.getAttribute("d")||"":t.d||"")),ne(i)&&i.length?i:!1},Ye=yn;var dn=(t,e,n)=>{let o=n||document,r=Object.keys(oe),a=Xe(t),m=a?t.tagName:null;if(m==="path")throw TypeError(`${I}: "${m}" is already SVGPathElement`);if(m&&r.every(l=>m!==l))throw TypeError(`${I}: "${m}" is not SVGElement`);let i=o.createElementNS("http://www.w3.org/2000/svg","path"),s=a?m:t.type,u=oe[s],c={type:s},p=J.round,f=Ye(t),h=f&&f.length?_e(f,p):"";return a?(u.forEach(l=>{c[l]=t.getAttribute(l)}),Object.values(t.attributes).forEach(({name:l,value:b})=>{u.includes(l)||i.setAttribute(l,b)})):(Object.assign(c,t),Object.keys(c).forEach(l=>{!u.includes(l)&&l!=="type"&&i.setAttribute(l.replace(/[A-Z]/g,b=>`-${b.toLowerCase()}`),c[l])})),We(h)?(i.setAttribute("d",h),e&&a&&(t.before(i,t),t.remove()),i):!1},Ut=dn;var xn=t=>{let e=new M,{origin:n}=t,[o,r]=n,{translate:a}=t,{rotate:m}=t,{skew:i}=t,{scale:s}=t;return Array.isArray(a)&&a.length>=2&&a.every(u=>!Number.isNaN(+u))&&a.some(u=>u!==0)?e=e.translate(...a):typeof a=="number"&&!Number.isNaN(a)&&(e=e.translate(a)),(m||i||s)&&(e=e.translate(o,r),Array.isArray(m)&&m.length>=2&&m.every(u=>!Number.isNaN(+u))&&m.some(u=>u!==0)?e=e.rotate(...m):typeof m=="number"&&!Number.isNaN(m)&&(e=e.rotate(m)),Array.isArray(i)&&i.length===2&&i.every(u=>!Number.isNaN(+u))&&i.some(u=>u!==0)?(e=i[0]?e.skewX(i[0]):e,e=i[1]?e.skewY(i[1]):e):typeof i=="number"&&!Number.isNaN(i)&&(e=e.skewX(i)),Array.isArray(s)&&s.length>=2&&s.every(u=>!Number.isNaN(+u))&&s.some(u=>u!==1)?e=e.scale(...s):typeof s=="number"&&!Number.isNaN(s)&&(e=e.scale(s)),e=e.translate(-o,-r)),e},et=xn;var Pn=(t,e,n,o)=>{let[r]=t,{round:a}=J,m=typeof a=="number"?a:4,i=e.slice(1),{x1:s,y1:u,x2:c,y2:p,x:f,y:h}=n,[l,b]=i.slice(-2),d=t;if("TQ".includes(r)||(n.qx=null,n.qy=null),r==="L"){if(L(f,m)===L(l,m))return["V",b];if(L(h,m)===L(b,m))return["H",l]}else if(r==="C"){let[x,P]=i;if(n.x1=x,n.y1=P,"CS".includes(o)&&(L(x,m)===L(s*2-c,m)&&L(P,m)===L(u*2-p,m)||L(s,m)===L(c*2-f,m)&&L(u,m)===L(p*2-h,m)))return["S",i[2],i[3],i[4],i[5]]}else if(r==="Q"){let[x,P]=i;if(n.qx=x,n.qy=P,"QT".includes(o)&&L(x,m)===L(s*2-c,m)&&L(P,m)===L(u*2-p,m))return["T",i[2],i[3]]}return d},tt=Pn;var Sn=(t,e)=>{let n=t.slice(1).map(o=>L(o,e));return[t[0]].concat(n)},he=Sn;var An=(t,e)=>{let n=xe(t),o=typeof e=="number"&&e>=0?e:2,r={...U},a=[],m="M",i="Z";return T(n,(s,u,c,p)=>{r.x=c,r.y=p;let f=Y(s,r),h=s;if([m]=s,a[u]=m,u){i=a[u-1];let b=tt(s,f,r,i),d=he(b,o),x=d.join(""),P=Pe(b,u,c,p),g=he(P,o),y=g.join("");h=x.length{let n=M.Translate(e[0],e[1],e[2]);return[,,,n.m44]=e,n=t.multiply(n),[n.m41,n.m42,n.m43,n.m44]},Mn=(t,e,n)=>{let[o,r,a]=n,[m,i,s]=Cn(t,[e[0],e[1],0,1]),u=m-o,c=i-r,p=s-a;return[u*(Math.abs(a)/Math.abs(p)||1)+o,c*(Math.abs(a)/Math.abs(p)||1)+r]},Re=Mn;var Tn=t=>{let e=t.slice(1).map((n,o,r)=>o?r[o-1].slice(-2).concat(n.slice(1)):t[0].slice(1).concat(n.slice(1))).map(n=>n.map((o,r)=>n[n.length-r-2*(1-r%2)])).reverse();return[["M"].concat(e[0].slice(0,2))].concat(e.map(n=>["C"].concat(n.slice(2))))},Kt=Tn;var Ln=t=>{let e=xe(t),n=ee(e),o=e.length,r=e[o-1][0]==="Z",a=T(e,(m,i)=>{let s=n[i],u=i&&e[i-1],c=u&&u[0],p=e[i+1],f=p&&p[0],[h]=m,[l,b]=n[i?i-1:o-1].slice(-2),d=m;switch(h){case"M":d=r?["Z"]:[h,l,b];break;case"A":d=[h,m[1],m[2],m[3],m[4],m[5]===1?0:1,l,b];break;case"C":p&&f==="S"?d=["S",m[1],m[2],l,b]:d=[h,m[3],m[4],m[1],m[2],l,b];break;case"S":c&&"CS".includes(c)&&(!p||f!=="S")?d=["C",s[3],s[4],s[1],s[2],l,b]:d=[h,s[1],s[2],l,b];break;case"Q":p&&f==="T"?d=["T",l,b]:d=[h,m[1],m[2],l,b];break;case"T":c&&"QT".includes(c)&&(!p||f!=="T")?d=["Q",s[1],s[2],l,b]:d=[h,l,b];break;case"Z":d=["M",l,b];break;case"H":d=[h,l];break;case"V":d=[h,b];break;default:d=[h].concat(m.slice(1,-2),l,b)}return d});return r?a.reverse():[a[0]].concat(a.slice(1).reverse())},Wt=Ln;var vn=(t,e)=>{let{round:n}=J;n=e==="off"||typeof e=="number"&&e>=0?e:typeof n=="number"&&n>=0?n:"off";return n==="off"?t.slice(0):T(t,o=>he(o,n))},Xt=vn;var wn=(t,e=.5)=>{let n=e,o=t.slice(0,2),r=t.slice(2,4),a=t.slice(4,6),m=t.slice(6,8),i=$(o,r,n),s=$(r,a,n),u=$(a,m,n),c=$(i,s,n),p=$(s,u,n),f=$(c,p,n);return[["C",i[0],i[1],c[0],c[1],f[0],f[1]],["C",p[0],p[1],u[0],u[1],m[0],m[1]]]},Yt=wn;var Nn=t=>{let e=[],n,o=-1,r=0,a=0,m=0,i=0,s={...U};return t.forEach(u=>{let[c]=u,p=c.toUpperCase(),f=c.toLowerCase(),h=c===f,l=u.slice(1);p==="M"?(o+=1,[r,a]=l,r+=h?s.x:0,a+=h?s.y:0,m=r,i=a,n=[h?[p,m,i]:u]):(p==="Z"?(r=m,a=i):p==="H"?([,r]=u,r+=h?s.x:0):p==="V"?([,a]=u,a+=h?s.y:0):([r,a]=u.slice(-2),r+=h?s.x:0,a+=h?s.y:0),n.push(u)),s.x=r,s.y=a,e[o]=n}),e},er=Nn;var kn=(t,e)=>{let n=0,o=0,r=0,a=0,m=0,i=0,s="M",u=w(t),c=e&&Object.keys(e);if(!e||c&&!c.length)return u.slice(0);e.origin||Object.assign(e,{origin:J.origin});let p=e.origin,f=et(e);return f.isIdentity?u.slice(0):T(u,(h,l,b,d)=>{[s]=h;let x=s.toUpperCase(),g=x!==s?_(h,l,b,d):h.slice(0),y=x==="A"?["C"].concat(Se(b,d,g[1],g[2],g[3],g[4],g[5],g[6],g[7])):x==="V"?["L",b,g[1]]:x==="H"?["L",g[1],d]:g;s=y[0];let S=s==="C"&&y.length>7,C=S?y.slice(0,7):y.slice(0);if(S&&(u.splice(l+1,0,["C"].concat(y.slice(7))),y=C),s==="L"){[r,a]=Re(f,[y[1],y[2]],p);n!==r&&o!==a?y=["L",r,a]:o===a?y=["H",r]:n===r&&(y=["V",a])}else for(m=1,i=y.length;m t in s ? Z(s, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : s[t] = e;\nvar p = (s, t, e) => z(s, typeof t != \"symbol\" ? t + \"\" : t, e);\nconst $ = {\n a: 1,\n b: 0,\n c: 0,\n d: 1,\n e: 0,\n f: 0,\n m11: 1,\n m12: 0,\n m13: 0,\n m14: 0,\n m21: 0,\n m22: 1,\n m23: 0,\n m24: 0,\n m31: 0,\n m32: 0,\n m33: 1,\n m34: 0,\n m41: 0,\n m42: 0,\n m43: 0,\n m44: 1,\n is2D: !0,\n isIdentity: !0\n}, E = (s) => (s instanceof Float64Array || s instanceof Float32Array || Array.isArray(s) && s.every((t) => typeof t == \"number\")) && [6, 16].some((t) => s.length === t), P = (s) => s instanceof DOMMatrix || s instanceof y || typeof s == \"object\" && Object.keys($).every((t) => s && t in s), g = (s) => {\n const t = new y(), e = Array.from(s);\n if (!E(e))\n throw TypeError(\n `CSSMatrix: \"${e.join(\",\")}\" must be an array with 6/16 numbers.`\n );\n // istanbul ignore else @preserve\n if (e.length === 16) {\n const [\n n,\n i,\n r,\n a,\n l,\n m,\n h,\n c,\n u,\n f,\n w,\n o,\n d,\n A,\n M,\n b\n ] = e;\n t.m11 = n, t.a = n, t.m21 = l, t.c = l, t.m31 = u, t.m41 = d, t.e = d, t.m12 = i, t.b = i, t.m22 = m, t.d = m, t.m32 = f, t.m42 = A, t.f = A, t.m13 = r, t.m23 = h, t.m33 = w, t.m43 = M, t.m14 = a, t.m24 = c, t.m34 = o, t.m44 = b;\n } else if (e.length === 6) {\n const [n, i, r, a, l, m] = e;\n t.m11 = n, t.a = n, t.m12 = i, t.b = i, t.m21 = r, t.c = r, t.m22 = a, t.d = a, t.m41 = l, t.e = l, t.m42 = m, t.f = m;\n }\n return t;\n}, X = (s) => {\n if (P(s))\n return g([\n s.m11,\n s.m12,\n s.m13,\n s.m14,\n s.m21,\n s.m22,\n s.m23,\n s.m24,\n s.m31,\n s.m32,\n s.m33,\n s.m34,\n s.m41,\n s.m42,\n s.m43,\n s.m44\n ]);\n throw TypeError(\n `CSSMatrix: \"${JSON.stringify(s)}\" is not a DOMMatrix / CSSMatrix / JSON compatible object.`\n );\n}, O = (s) => {\n if (typeof s != \"string\")\n throw TypeError(`CSSMatrix: \"${JSON.stringify(s)}\" is not a string.`);\n const t = String(s).replace(/\\s/g, \"\");\n let e = new y();\n const n = `CSSMatrix: invalid transform string \"${s}\"`;\n return t.split(\")\").filter((i) => i).forEach((i) => {\n const [r, a] = i.split(\"(\");\n if (!a) throw TypeError(n);\n const l = a.split(\",\").map(\n (o) => o.includes(\"rad\") ? parseFloat(o) * (180 / Math.PI) : parseFloat(o)\n ), [m, h, c, u] = l, f = [m, h, c], w = [m, h, c, u];\n if (r === \"perspective\" && m && [h, c].every((o) => o === void 0))\n e.m34 = -1 / m;\n else if (r.includes(\"matrix\") && [6, 16].includes(l.length) && l.every((o) => !Number.isNaN(+o))) {\n const o = l.map((d) => Math.abs(d) < 1e-6 ? 0 : d);\n e = e.multiply(g(o));\n } else if (r === \"translate3d\" && f.every((o) => !Number.isNaN(+o)))\n e = e.translate(m, h, c);\n else if (r === \"translate\" && m && c === void 0)\n e = e.translate(m, h || 0, 0);\n else if (r === \"rotate3d\" && w.every((o) => !Number.isNaN(+o)) && u)\n e = e.rotateAxisAngle(m, h, c, u);\n else if (r === \"rotate\" && m && [h, c].every((o) => o === void 0))\n e = e.rotate(0, 0, m);\n else if (r === \"scale3d\" && f.every((o) => !Number.isNaN(+o)) && f.some((o) => o !== 1))\n e = e.scale(m, h, c);\n else if (\n // prop === \"scale\" && !Number.isNaN(x) && x !== 1 && z === undefined\n // prop === \"scale\" && !Number.isNaN(x) && [x, y].some((n) => n !== 1) &&\n r === \"scale\" && !Number.isNaN(m) && (m !== 1 || h !== 1) && c === void 0\n ) {\n const d = Number.isNaN(+h) ? m : h;\n e = e.scale(m, d, 1);\n } else if (r === \"skew\" && (m || !Number.isNaN(m) && h) && c === void 0)\n e = e.skew(m, h || 0);\n else if ([\"translate\", \"rotate\", \"scale\", \"skew\"].some(\n (o) => r.includes(o)\n ) && /[XYZ]/.test(r) && m && [h, c].every((o) => o === void 0))\n if (r === \"skewX\" || r === \"skewY\")\n e = e[r](m);\n else {\n const o = r.replace(/[XYZ]/, \"\"), d = r.replace(o, \"\"), A = [\"X\", \"Y\", \"Z\"].indexOf(d), M = o === \"scale\" ? 1 : 0, b = [\n A === 0 ? m : M,\n A === 1 ? m : M,\n A === 2 ? m : M\n ];\n e = e[o](...b);\n }\n else\n throw TypeError(n);\n }), e;\n}, x = (s, t) => t ? [s.a, s.b, s.c, s.d, s.e, s.f] : [\n s.m11,\n s.m12,\n s.m13,\n s.m14,\n s.m21,\n s.m22,\n s.m23,\n s.m24,\n s.m31,\n s.m32,\n s.m33,\n s.m34,\n s.m41,\n s.m42,\n s.m43,\n s.m44\n], Y = (s, t, e) => {\n const n = new y();\n return n.m41 = s, n.e = s, n.m42 = t, n.f = t, n.m43 = e, n;\n}, F = (s, t, e) => {\n const n = new y(), i = Math.PI / 180, r = s * i, a = t * i, l = e * i, m = Math.cos(r), h = -Math.sin(r), c = Math.cos(a), u = -Math.sin(a), f = Math.cos(l), w = -Math.sin(l), o = c * f, d = -c * w;\n n.m11 = o, n.a = o, n.m12 = d, n.b = d, n.m13 = u;\n const A = h * u * f + m * w;\n n.m21 = A, n.c = A;\n const M = m * f - h * u * w;\n return n.m22 = M, n.d = M, n.m23 = -h * c, n.m31 = h * w - m * u * f, n.m32 = h * f + m * u * w, n.m33 = m * c, n;\n}, T = (s, t, e, n) => {\n const i = new y(), r = Math.sqrt(s * s + t * t + e * e);\n if (r === 0)\n return i;\n const a = s / r, l = t / r, m = e / r, h = n * (Math.PI / 360), c = Math.sin(h), u = Math.cos(h), f = c * c, w = a * a, o = l * l, d = m * m, A = 1 - 2 * (o + d) * f;\n i.m11 = A, i.a = A;\n const M = 2 * (a * l * f + m * c * u);\n i.m12 = M, i.b = M, i.m13 = 2 * (a * m * f - l * c * u);\n const b = 2 * (l * a * f - m * c * u);\n i.m21 = b, i.c = b;\n const k = 1 - 2 * (d + w) * f;\n return i.m22 = k, i.d = k, i.m23 = 2 * (l * m * f + a * c * u), i.m31 = 2 * (m * a * f + l * c * u), i.m32 = 2 * (m * l * f - a * c * u), i.m33 = 1 - 2 * (w + o) * f, i;\n}, I = (s, t, e) => {\n const n = new y();\n return n.m11 = s, n.a = s, n.m22 = t, n.d = t, n.m33 = e, n;\n}, v = (s, t) => {\n const e = new y();\n if (s) {\n const n = s * Math.PI / 180, i = Math.tan(n);\n e.m21 = i, e.c = i;\n }\n if (t) {\n const n = t * Math.PI / 180, i = Math.tan(n);\n e.m12 = i, e.b = i;\n }\n return e;\n}, R = (s) => v(s, 0), D = (s) => v(0, s), N = (s, t) => {\n const e = t.m11 * s.m11 + t.m12 * s.m21 + t.m13 * s.m31 + t.m14 * s.m41, n = t.m11 * s.m12 + t.m12 * s.m22 + t.m13 * s.m32 + t.m14 * s.m42, i = t.m11 * s.m13 + t.m12 * s.m23 + t.m13 * s.m33 + t.m14 * s.m43, r = t.m11 * s.m14 + t.m12 * s.m24 + t.m13 * s.m34 + t.m14 * s.m44, a = t.m21 * s.m11 + t.m22 * s.m21 + t.m23 * s.m31 + t.m24 * s.m41, l = t.m21 * s.m12 + t.m22 * s.m22 + t.m23 * s.m32 + t.m24 * s.m42, m = t.m21 * s.m13 + t.m22 * s.m23 + t.m23 * s.m33 + t.m24 * s.m43, h = t.m21 * s.m14 + t.m22 * s.m24 + t.m23 * s.m34 + t.m24 * s.m44, c = t.m31 * s.m11 + t.m32 * s.m21 + t.m33 * s.m31 + t.m34 * s.m41, u = t.m31 * s.m12 + t.m32 * s.m22 + t.m33 * s.m32 + t.m34 * s.m42, f = t.m31 * s.m13 + t.m32 * s.m23 + t.m33 * s.m33 + t.m34 * s.m43, w = t.m31 * s.m14 + t.m32 * s.m24 + t.m33 * s.m34 + t.m34 * s.m44, o = t.m41 * s.m11 + t.m42 * s.m21 + t.m43 * s.m31 + t.m44 * s.m41, d = t.m41 * s.m12 + t.m42 * s.m22 + t.m43 * s.m32 + t.m44 * s.m42, A = t.m41 * s.m13 + t.m42 * s.m23 + t.m43 * s.m33 + t.m44 * s.m43, M = t.m41 * s.m14 + t.m42 * s.m24 + t.m43 * s.m34 + t.m44 * s.m44;\n return g([\n e,\n n,\n i,\n r,\n a,\n l,\n m,\n h,\n c,\n u,\n f,\n w,\n o,\n d,\n A,\n M\n ]);\n};\nclass y {\n /**\n * @constructor\n * @param init accepts all parameter configurations:\n * * valid CSS transform string,\n * * CSSMatrix/DOMMatrix instance,\n * * a 6/16 elements *Array*.\n */\n constructor(t) {\n return this.a = 1, this.b = 0, this.c = 0, this.d = 1, this.e = 0, this.f = 0, this.m11 = 1, this.m12 = 0, this.m13 = 0, this.m14 = 0, this.m21 = 0, this.m22 = 1, this.m23 = 0, this.m24 = 0, this.m31 = 0, this.m32 = 0, this.m33 = 1, this.m34 = 0, this.m41 = 0, this.m42 = 0, this.m43 = 0, this.m44 = 1, t ? this.setMatrixValue(t) : this;\n }\n /**\n * A `Boolean` whose value is `true` if the matrix is the identity matrix. The identity\n * matrix is one in which every value is 0 except those on the main diagonal from top-left\n * to bottom-right corner (in other words, where the offsets in each direction are equal).\n *\n * @return the current property value\n */\n get isIdentity() {\n return this.m11 === 1 && this.m12 === 0 && this.m13 === 0 && this.m14 === 0 && this.m21 === 0 && this.m22 === 1 && this.m23 === 0 && this.m24 === 0 && this.m31 === 0 && this.m32 === 0 && this.m33 === 1 && this.m34 === 0 && this.m41 === 0 && this.m42 === 0 && this.m43 === 0 && this.m44 === 1;\n }\n /**\n * A `Boolean` flag whose value is `true` if the matrix was initialized as a 2D matrix\n * and `false` if the matrix is 3D.\n *\n * @return the current property value\n */\n get is2D() {\n return this.m31 === 0 && this.m32 === 0 && this.m33 === 1 && this.m34 === 0 && this.m43 === 0 && this.m44 === 1;\n }\n /**\n * The `setMatrixValue` method replaces the existing matrix with one computed\n * in the browser. EG: `matrix(1,0.25,-0.25,1,0,0)`\n *\n * The method accepts any *Array* values, the result of\n * `DOMMatrix` instance method `toFloat64Array()` / `toFloat32Array()` calls\n * or `CSSMatrix` instance method `toArray()`.\n *\n * This method expects valid *matrix()* / *matrix3d()* string values, as well\n * as other transform functions like *translateX(10px)*.\n *\n * @param source\n * @return the matrix instance\n */\n setMatrixValue(t) {\n return typeof t == \"string\" && t.length && t !== \"none\" ? O(t) : Array.isArray(t) || t instanceof Float64Array || t instanceof Float32Array ? g(t) : typeof t == \"object\" ? X(t) : this;\n }\n /**\n * Returns a *Float32Array* containing elements which comprise the matrix.\n * The method can return either the 16 elements or the 6 elements\n * depending on the value of the `is2D` parameter.\n *\n * @param is2D *Array* representation of the matrix\n * @return an *Array* representation of the matrix\n */\n toFloat32Array(t) {\n return Float32Array.from(x(this, t));\n }\n /**\n * Returns a *Float64Array* containing elements which comprise the matrix.\n * The method can return either the 16 elements or the 6 elements\n * depending on the value of the `is2D` parameter.\n *\n * @param is2D *Array* representation of the matrix\n * @return an *Array* representation of the matrix\n */\n toFloat64Array(t) {\n return Float64Array.from(x(this, t));\n }\n /**\n * Creates and returns a string representation of the matrix in `CSS` matrix syntax,\n * using the appropriate `CSS` matrix notation.\n *\n * matrix3d *matrix3d(m11, m12, m13, m14, m21, ...)*\n * matrix *matrix(a, b, c, d, e, f)*\n *\n * @return a string representation of the matrix\n */\n toString() {\n const { is2D: t } = this, e = this.toFloat64Array(t).join(\", \");\n return `${t ? \"matrix\" : \"matrix3d\"}(${e})`;\n }\n /**\n * Returns a JSON representation of the `CSSMatrix` instance, a standard *Object*\n * that includes `{a,b,c,d,e,f}` and `{m11,m12,m13,..m44}` properties as well\n * as the `is2D` & `isIdentity` properties.\n *\n * The result can also be used as a second parameter for the `fromMatrix` static method\n * to load values into another matrix instance.\n *\n * @return an *Object* with all matrix values.\n */\n toJSON() {\n const { is2D: t, isIdentity: e } = this;\n return { ...this, is2D: t, isIdentity: e };\n }\n /**\n * The Multiply method returns a new CSSMatrix which is the result of this\n * matrix multiplied by the passed matrix, with the passed matrix to the right.\n * This matrix is not modified.\n *\n * @param m2 CSSMatrix\n * @return The resulted matrix.\n */\n multiply(t) {\n return N(this, t);\n }\n /**\n * The translate method returns a new matrix which is this matrix post\n * multiplied by a translation matrix containing the passed values. If the z\n * component is undefined, a 0 value is used in its place. This matrix is not\n * modified.\n *\n * @param x X component of the translation value.\n * @param y Y component of the translation value.\n * @param z Z component of the translation value.\n * @return The resulted matrix\n */\n translate(t, e, n) {\n const i = t;\n let r = e, a = n;\n return typeof r > \"u\" && (r = 0), typeof a > \"u\" && (a = 0), N(this, Y(i, r, a));\n }\n /**\n * The scale method returns a new matrix which is this matrix post multiplied by\n * a scale matrix containing the passed values. If the z component is undefined,\n * a 1 value is used in its place. If the y component is undefined, the x\n * component value is used in its place. This matrix is not modified.\n *\n * @param x The X component of the scale value.\n * @param y The Y component of the scale value.\n * @param z The Z component of the scale value.\n * @return The resulted matrix\n */\n scale(t, e, n) {\n const i = t;\n let r = e, a = n;\n return typeof r > \"u\" && (r = t), typeof a > \"u\" && (a = 1), N(this, I(i, r, a));\n }\n /**\n * The rotate method returns a new matrix which is this matrix post multiplied\n * by each of 3 rotation matrices about the major axes, first X, then Y, then Z.\n * If the y and z components are undefined, the x value is used to rotate the\n * object about the z axis, as though the vector (0,0,x) were passed. All\n * rotation values are in degrees. This matrix is not modified.\n *\n * @param rx The X component of the rotation, or Z if Y and Z are null.\n * @param ry The (optional) Y component of the rotation value.\n * @param rz The (optional) Z component of the rotation value.\n * @return The resulted matrix\n */\n rotate(t, e, n) {\n let i = t, r = e || 0, a = n || 0;\n return typeof t == \"number\" && typeof e > \"u\" && typeof n > \"u\" && (a = i, i = 0, r = 0), N(this, F(i, r, a));\n }\n /**\n * The rotateAxisAngle method returns a new matrix which is this matrix post\n * multiplied by a rotation matrix with the given axis and `angle`. The right-hand\n * rule is used to determine the direction of rotation. All rotation values are\n * in degrees. This matrix is not modified.\n *\n * @param x The X component of the axis vector.\n * @param y The Y component of the axis vector.\n * @param z The Z component of the axis vector.\n * @param angle The angle of rotation about the axis vector, in degrees.\n * @return The resulted matrix\n */\n rotateAxisAngle(t, e, n, i) {\n if ([t, e, n, i].some((r) => Number.isNaN(+r)))\n throw new TypeError(\"CSSMatrix: expecting 4 values\");\n return N(this, T(t, e, n, i));\n }\n /**\n * Specifies a skew transformation along the `x-axis` by the given angle.\n * This matrix is not modified.\n *\n * @param angle The angle amount in degrees to skew.\n * @return The resulted matrix\n */\n skewX(t) {\n return N(this, R(t));\n }\n /**\n * Specifies a skew transformation along the `y-axis` by the given angle.\n * This matrix is not modified.\n *\n * @param angle The angle amount in degrees to skew.\n * @return The resulted matrix\n */\n skewY(t) {\n return N(this, D(t));\n }\n /**\n * Specifies a skew transformation along both the `x-axis` and `y-axis`.\n * This matrix is not modified.\n *\n * @param angleX The X-angle amount in degrees to skew.\n * @param angleY The angle amount in degrees to skew.\n * @return The resulted matrix\n */\n skew(t, e) {\n return N(this, v(t, e));\n }\n /**\n * Transforms a specified vector using the matrix, returning a new\n * {x,y,z,w} Tuple *Object* comprising the transformed vector.\n * Neither the matrix nor the original vector are altered.\n *\n * The method is equivalent with `transformPoint()` method\n * of the `DOMMatrix` constructor.\n *\n * @param t Tuple with `{x,y,z,w}` components\n * @return the resulting Tuple\n */\n transformPoint(t) {\n const e = this.m11 * t.x + this.m21 * t.y + this.m31 * t.z + this.m41 * t.w, n = this.m12 * t.x + this.m22 * t.y + this.m32 * t.z + this.m42 * t.w, i = this.m13 * t.x + this.m23 * t.y + this.m33 * t.z + this.m43 * t.w, r = this.m14 * t.x + this.m24 * t.y + this.m34 * t.z + this.m44 * t.w;\n return t instanceof DOMPoint ? new DOMPoint(e, n, i, r) : {\n x: e,\n y: n,\n z: i,\n w: r\n };\n }\n}\np(y, \"Translate\", Y), p(y, \"Rotate\", F), p(y, \"RotateAxisAngle\", T), p(y, \"Scale\", I), p(y, \"SkewX\", R), p(y, \"SkewY\", D), p(y, \"Skew\", v), p(y, \"Multiply\", N), p(y, \"fromArray\", g), p(y, \"fromMatrix\", X), p(y, \"fromString\", O), p(y, \"toArray\", x), p(y, \"isCompatibleArray\", E), p(y, \"isCompatibleObject\", P);\nexport {\n y as default\n};\n//# sourceMappingURL=dommatrix.mjs.map\n","import { PointTuple } from \"../types\";\n\n/**\n * Returns the coordinates of a specified distance\n * ratio between two points.\n *\n * @param a the first point coordinates\n * @param b the second point coordinates\n * @param t the ratio\n * @returns the midpoint coordinates\n */\nconst midPoint = (a: PointTuple, b: PointTuple, t: number): PointTuple => {\n const [ax, ay] = a;\n const [bx, by] = b;\n return [ax + (bx - ax) * t, ay + (by - ay) * t];\n};\n\nexport default midPoint;\n","import { type PointTuple } from \"../types\";\n\n/**\n * Returns the square root of the distance\n * between two given points.\n *\n * @param a the first point coordinates\n * @param b the second point coordinates\n * @returns the distance value\n */\nconst distanceSquareRoot = (a: PointTuple, b: PointTuple) => {\n return Math.sqrt(\n (a[0] - b[0]) * (a[0] - b[0]) + (a[1] - b[1]) * (a[1] - b[1]),\n );\n};\n\nexport default distanceSquareRoot;\n","import midPoint from \"./midPoint\";\nimport distanceSquareRoot from \"./distanceSquareRoot\";\n\n/**\n * Returns length for line segments (MoveTo, LineTo).\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the line segment length\n */\nconst getLineLength = (x1: number, y1: number, x2: number, y2: number) => {\n return distanceSquareRoot([x1, y1], [x2, y2]);\n};\n\n/**\n * Returns a point along the line segments (MoveTo, LineTo).\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance the distance to point in [0-1] range\n * @returns the point at length\n */\nconst getPointAtLineLength = (\n x1: number,\n y1: number,\n x2: number,\n y2: number,\n distance?: number,\n) => {\n let point = { x: x1, y: y1 };\n\n /* istanbul ignore else @preserve */\n if (typeof distance === \"number\") {\n const length = distanceSquareRoot([x1, y1], [x2, y2]);\n if (distance <= 0) {\n point = { x: x1, y: y1 };\n } else if (distance >= length) {\n point = { x: x2, y: y2 };\n } else {\n const [x, y] = midPoint([x1, y1], [x2, y2], distance / length);\n point = { x, y };\n }\n }\n return point;\n};\n\n/**\n * Returns bounding box for line segments (MoveTo, LineTo).\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance the distance to point in [0-1] range\n * @returns the extrema for line segments\n */\nconst getLineBBox = (x1: number, y1: number, x2: number, y2: number) => {\n const { min, max } = Math;\n\n return [min(x1, x2), min(y1, y2), max(x1, x2), max(y1, y2)] as [\n number,\n number,\n number,\n number,\n ];\n};\n\nexport { getLineBBox, getLineLength, getPointAtLineLength };\n","import { getPointAtLineLength } from \"./lineTools\";\nimport type { Point, PointTuple } from \"../types\";\n\n/**\n * Returns the Arc segment length.\n * @param rx radius along X axis\n * @param ry radius along Y axis\n * @param theta the angle in radians\n * @returns the arc length\n */\nconst arcLength = (rx: number, ry: number, theta: number) => {\n const halfTheta = theta / 2;\n const sinHalfTheta = Math.sin(halfTheta);\n const cosHalfTheta = Math.cos(halfTheta);\n const term1 = rx ** 2 * sinHalfTheta ** 2;\n const term2 = ry ** 2 * cosHalfTheta ** 2;\n const length = Math.sqrt(term1 + term2) * theta;\n return Math.abs(length);\n};\n\n/**\n * Find point on ellipse at given angle around ellipse (theta);\n * @param cx the center X\n * @param cy the center Y\n * @param rx the radius X\n * @param ry the radius Y\n * @param alpha the arc rotation angle in radians\n * @param theta the arc sweep angle in radians\n * @returns a point around ellipse at given angle\n */\nconst arcPoint = (\n cx: number,\n cy: number,\n rx: number,\n ry: number,\n alpha: number,\n theta: number,\n) => {\n const { sin, cos } = Math;\n // theta is angle in radians around arc\n // alpha is angle of rotation of ellipse in radians\n const cosA = cos(alpha);\n const sinA = sin(alpha);\n const x = rx * cos(theta);\n const y = ry * sin(theta);\n\n return [cx + cosA * x - sinA * y, cy + sinA * x + cosA * y] as PointTuple;\n};\n\n/**\n * Returns the angle between two points.\n * @param v0 starting point\n * @param v1 ending point\n * @returns the angle in radian\n */\nconst angleBetween = (v0: Point, v1: Point) => {\n const { x: v0x, y: v0y } = v0;\n const { x: v1x, y: v1y } = v1;\n const p = v0x * v1x + v0y * v1y;\n const n = Math.sqrt((v0x ** 2 + v0y ** 2) * (v1x ** 2 + v1y ** 2));\n const sign = v0x * v1y - v0y * v1x < 0 ? -1 : 1;\n return sign * Math.acos(p / n);\n};\n\n/**\n * Returns the following properties for an Arc segment: center, start angle,\n * end angle, and radiuses on X and Y axis.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param RX the radius on X axis\n * @param RY the radius on Y axis\n * @param angle the ellipse rotation in degrees\n * @param LAF the large arc flag\n * @param SF the sweep flag\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns properties specific to Arc segments\n */\nconst getArcProps = (\n x1: number,\n y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n x: number,\n y: number,\n) => {\n const { abs, sin, cos, sqrt, PI } = Math;\n let rx = abs(RX);\n let ry = abs(RY);\n const xRot = ((angle % 360) + 360) % 360;\n const xRotRad = xRot * (PI / 180);\n\n // istanbul ignore next @preserve\n if (x1 === x && y1 === y) {\n return {\n rx,\n ry,\n startAngle: 0,\n endAngle: 0,\n center: { x, y },\n };\n }\n\n if (rx === 0 || ry === 0) {\n return {\n rx,\n ry,\n startAngle: 0,\n endAngle: 0,\n center: { x: (x + x1) / 2, y: (y + y1) / 2 },\n };\n }\n\n const dx = (x1 - x) / 2;\n const dy = (y1 - y) / 2;\n\n const transformedPoint = {\n x: cos(xRotRad) * dx + sin(xRotRad) * dy,\n y: -sin(xRotRad) * dx + cos(xRotRad) * dy,\n };\n\n const radiiCheck = transformedPoint.x ** 2 / rx ** 2 +\n transformedPoint.y ** 2 / ry ** 2;\n\n if (radiiCheck > 1) {\n rx *= sqrt(radiiCheck);\n ry *= sqrt(radiiCheck);\n }\n\n const cSquareNumerator = rx ** 2 * ry ** 2 -\n rx ** 2 * transformedPoint.y ** 2 - ry ** 2 * transformedPoint.x ** 2;\n const cSquareRootDenom = rx ** 2 * transformedPoint.y ** 2 +\n ry ** 2 * transformedPoint.x ** 2;\n\n let cRadicand = cSquareNumerator / cSquareRootDenom;\n /* istanbul ignore next @preserve */\n cRadicand = cRadicand < 0 ? 0 : cRadicand;\n const cCoef = (LAF !== SF ? 1 : -1) * sqrt(cRadicand);\n const transformedCenter = {\n x: cCoef * ((rx * transformedPoint.y) / ry),\n y: cCoef * (-(ry * transformedPoint.x) / rx),\n };\n\n const center = {\n x: cos(xRotRad) * transformedCenter.x - sin(xRotRad) * transformedCenter.y +\n (x1 + x) / 2,\n y: sin(xRotRad) * transformedCenter.x + cos(xRotRad) * transformedCenter.y +\n (y1 + y) / 2,\n };\n\n const startVector = {\n x: (transformedPoint.x - transformedCenter.x) / rx,\n y: (transformedPoint.y - transformedCenter.y) / ry,\n };\n\n const startAngle = angleBetween({ x: 1, y: 0 }, startVector);\n\n const endVector = {\n x: (-transformedPoint.x - transformedCenter.x) / rx,\n y: (-transformedPoint.y - transformedCenter.y) / ry,\n };\n\n let sweepAngle = angleBetween(startVector, endVector);\n if (!SF && sweepAngle > 0) {\n sweepAngle -= 2 * PI;\n } else if (SF && sweepAngle < 0) {\n sweepAngle += 2 * PI;\n }\n sweepAngle %= 2 * PI;\n\n const endAngle = startAngle + sweepAngle;\n\n // point.ellipticalArcStartAngle = startAngle;\n // point.ellipticalArcEndAngle = startAngle + sweepAngle;\n // point.ellipticalArcAngle = alpha;\n\n // point.ellipticalArcCenter = center;\n // point.resultantRx = rx;\n // point.resultantRy = ry;\n\n return {\n center,\n startAngle,\n endAngle,\n rx,\n ry,\n };\n};\n\n/**\n * Returns the length of an Arc segment.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the length of the Arc segment\n */\nconst getArcLength = (\n x1: number,\n y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n x: number,\n y: number,\n) => {\n const { rx, ry, startAngle, endAngle } = getArcProps(\n x1,\n y1,\n RX,\n RY,\n angle,\n LAF,\n SF,\n x,\n y,\n );\n return arcLength(rx, ry, endAngle - startAngle);\n};\n\n/**\n * Returns a point along an Arc segment at a given distance.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param RX the radius on X axis\n * @param RY the radius on Y axis\n * @param angle the ellipse rotation in degrees\n * @param LAF the large arc flag\n * @param SF the sweep flag\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance a [0-1] ratio\n * @returns a point along the Arc segment\n */\nconst getPointAtArcLength = (\n x1: number,\n y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n x: number,\n y: number,\n distance?: number,\n) => {\n let point = { x: x1, y: y1 };\n const { center, rx, ry, startAngle, endAngle } = getArcProps(\n x1,\n y1,\n RX,\n RY,\n angle,\n LAF,\n SF,\n x,\n y,\n );\n\n /* istanbul ignore else @preserve */\n if (typeof distance === \"number\") {\n const length = arcLength(rx, ry, endAngle - startAngle);\n if (distance <= 0) {\n point = { x: x1, y: y1 };\n } else if (distance >= length) {\n point = { x, y };\n } else {\n /* istanbul ignore next @preserve */\n if (x1 === x && y1 === y) {\n return { x, y };\n }\n /* istanbul ignore next @preserve */\n if (rx === 0 || ry === 0) {\n return getPointAtLineLength(x1, y1, x, y, distance);\n }\n const { PI, cos, sin } = Math;\n const sweepAngle = endAngle - startAngle;\n const xRot = ((angle % 360) + 360) % 360;\n const xRotRad = xRot * (PI / 180);\n const alpha = startAngle + sweepAngle * (distance / length);\n const ellipseComponentX = rx * cos(alpha);\n const ellipseComponentY = ry * sin(alpha);\n\n point = {\n x: cos(xRotRad) * ellipseComponentX - sin(xRotRad) * ellipseComponentY +\n center.x,\n y: sin(xRotRad) * ellipseComponentX + cos(xRotRad) * ellipseComponentY +\n center.y,\n };\n }\n }\n\n return point;\n};\n\n/**\n * Returns the extrema for an Arc segment in the following format:\n * [MIN_X, MIN_Y, MAX_X, MAX_Y]\n *\n * @see https://github.com/herrstrietzel/svg-pathdata-getbbox\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param RX the radius on X axis\n * @param RY the radius on Y axis\n * @param angle the ellipse rotation in degrees\n * @param LAF the large arc flag\n * @param SF the sweep flag\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the extrema of the Arc segment\n */\nconst getArcBBox = (\n x1: number,\n y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n x: number,\n y: number,\n) => {\n const { center, rx, ry, startAngle, endAngle } = getArcProps(\n x1,\n y1,\n RX,\n RY,\n angle,\n LAF,\n SF,\n x,\n y,\n );\n const deltaAngle = endAngle - startAngle;\n const { min, max, tan, atan2, PI } = Math;\n\n // circle/elipse center coordinates\n const { x: cx, y: cy } = center;\n\n // rotation to radians\n const alpha = (angle * PI) / 180;\n const tangent = tan(alpha);\n\n /**\n * find min/max from zeroes of directional derivative along x and y\n * along x axis\n */\n const theta = atan2(-ry * tangent, rx);\n const angle1 = theta;\n const angle2 = theta + PI;\n const angle3 = atan2(ry, rx * tangent);\n const angle4 = angle3 + PI;\n const xArray = [x];\n const yArray = [y];\n\n // inner bounding box\n let xMin = min(x1, x);\n let xMax = max(x1, x);\n let yMin = min(y1, y);\n let yMax = max(y1, y);\n\n // on path point close after start\n const angleAfterStart = endAngle - deltaAngle * 0.00001;\n const pP2 = arcPoint(cx, cy, rx, ry, alpha, angleAfterStart);\n\n // on path point close before end\n const angleBeforeEnd = endAngle - deltaAngle * 0.99999;\n const pP3 = arcPoint(cx, cy, rx, ry, alpha, angleBeforeEnd);\n\n /**\n * expected extremes\n * if leaving inner bounding box\n * (between segment start and end point)\n * otherwise exclude elliptic extreme points\n */\n\n // right\n if (pP2[0] > xMax || pP3[0] > xMax) {\n // get point for this theta\n const p1 = arcPoint(cx, cy, rx, ry, alpha, angle1);\n xArray.push(p1[0]);\n yArray.push(p1[1]);\n }\n\n // left\n if (pP2[0] < xMin || pP3[0] < xMin) {\n // get anti-symmetric point\n const p2 = arcPoint(cx, cy, rx, ry, alpha, angle2);\n xArray.push(p2[0]);\n yArray.push(p2[1]);\n }\n\n // top\n if (pP2[1] < yMin || pP3[1] < yMin) {\n // get anti-symmetric point\n const p4 = arcPoint(cx, cy, rx, ry, alpha, angle4);\n xArray.push(p4[0]);\n yArray.push(p4[1]);\n }\n\n // bottom\n if (pP2[1] > yMax || pP3[1] > yMax) {\n // get point for this theta\n const p3 = arcPoint(cx, cy, rx, ry, alpha, angle3);\n xArray.push(p3[0]);\n yArray.push(p3[1]);\n }\n\n xMin = min.apply([], xArray);\n yMin = min.apply([], yArray);\n xMax = max.apply([], xArray);\n yMax = max.apply([], yArray);\n\n return [xMin, yMin, xMax, yMax] as [number, number, number, number];\n};\n\nexport {\n angleBetween,\n arcLength,\n arcPoint,\n getArcBBox,\n getArcLength,\n getArcProps,\n getPointAtArcLength,\n};\n","import type {\n CubicCoordinates,\n CubicPoints,\n DeriveCallback,\n DerivedCubicPoints,\n DerivedPoint,\n DerivedQuadPoints,\n PointTuple,\n QuadCoordinates,\n QuadPoints,\n} from \"../types\";\n\n/**\n * Tools from bezier.js by Mike 'Pomax' Kamermans\n * @see https://github.com/Pomax/bezierjs\n */\n\nconst Tvalues = [\n -0.0640568928626056260850430826247450385909,\n 0.0640568928626056260850430826247450385909,\n -0.1911188674736163091586398207570696318404,\n 0.1911188674736163091586398207570696318404,\n -0.3150426796961633743867932913198102407864,\n 0.3150426796961633743867932913198102407864,\n -0.4337935076260451384870842319133497124524,\n 0.4337935076260451384870842319133497124524,\n -0.5454214713888395356583756172183723700107,\n 0.5454214713888395356583756172183723700107,\n -0.6480936519369755692524957869107476266696,\n 0.6480936519369755692524957869107476266696,\n -0.7401241915785543642438281030999784255232,\n 0.7401241915785543642438281030999784255232,\n -0.8200019859739029219539498726697452080761,\n 0.8200019859739029219539498726697452080761,\n -0.8864155270044010342131543419821967550873,\n 0.8864155270044010342131543419821967550873,\n -0.9382745520027327585236490017087214496548,\n 0.9382745520027327585236490017087214496548,\n -0.9747285559713094981983919930081690617411,\n 0.9747285559713094981983919930081690617411,\n -0.9951872199970213601799974097007368118745,\n 0.9951872199970213601799974097007368118745,\n];\n\nconst Cvalues = [\n 0.1279381953467521569740561652246953718517,\n 0.1279381953467521569740561652246953718517,\n 0.1258374563468282961213753825111836887264,\n 0.1258374563468282961213753825111836887264,\n 0.121670472927803391204463153476262425607,\n 0.121670472927803391204463153476262425607,\n 0.1155056680537256013533444839067835598622,\n 0.1155056680537256013533444839067835598622,\n 0.1074442701159656347825773424466062227946,\n 0.1074442701159656347825773424466062227946,\n 0.0976186521041138882698806644642471544279,\n 0.0976186521041138882698806644642471544279,\n 0.086190161531953275917185202983742667185,\n 0.086190161531953275917185202983742667185,\n 0.0733464814110803057340336152531165181193,\n 0.0733464814110803057340336152531165181193,\n 0.0592985849154367807463677585001085845412,\n 0.0592985849154367807463677585001085845412,\n 0.0442774388174198061686027482113382288593,\n 0.0442774388174198061686027482113382288593,\n 0.0285313886289336631813078159518782864491,\n 0.0285313886289336631813078159518782864491,\n 0.0123412297999871995468056670700372915759,\n 0.0123412297999871995468056670700372915759,\n];\n\n/**\n * @param points\n * @returns\n */\nconst deriveBezier = (points: QuadPoints | CubicPoints) => {\n const dpoints = [] as (DerivedCubicPoints | DerivedQuadPoints)[];\n for (let p = points, d = p.length, c = d - 1; d > 1; d -= 1, c -= 1) {\n const list = [] as unknown as DerivedCubicPoints | DerivedQuadPoints;\n for (let j = 0; j < c; j += 1) {\n list.push({\n x: c * (p[j + 1].x - p[j].x),\n y: c * (p[j + 1].y - p[j].y),\n t: 0,\n });\n }\n dpoints.push(list);\n p = list;\n }\n return dpoints;\n};\n\n/**\n * @param points\n * @param t\n */\nconst computeBezier = (\n points: DerivedQuadPoints | DerivedCubicPoints,\n t: number,\n) => {\n // shortcuts\n /* istanbul ignore next @preserve */\n if (t === 0) {\n points[0].t = 0;\n return points[0];\n }\n\n const order = points.length - 1;\n\n /* istanbul ignore next @preserve */\n if (t === 1) {\n points[order].t = 1;\n return points[order];\n }\n\n const mt = 1 - t;\n let p = points as typeof points | [\n DerivedPoint,\n DerivedPoint,\n DerivedPoint,\n DerivedPoint,\n ];\n\n // constant?\n /* istanbul ignore next @preserve */\n if (order === 0) {\n points[0].t = t;\n return points[0];\n }\n\n // linear?\n /* istanbul ignore else @preserve */\n if (order === 1) {\n return {\n x: mt * p[0].x + t * p[1].x,\n y: mt * p[0].y + t * p[1].y,\n t,\n };\n }\n\n // quadratic/cubic curve?\n const mt2 = mt * mt;\n const t2 = t * t;\n let a = 0;\n let b = 0;\n let c = 0;\n let d = 0;\n /* istanbul ignore else @preserve */\n if (order === 2) {\n p = [p[0], p[1], p[2], { x: 0, y: 0 } as DerivedPoint];\n a = mt2;\n b = mt * t * 2;\n c = t2;\n } else if (order === 3) {\n a = mt2 * mt;\n b = mt2 * t * 3;\n c = mt * t2 * 3;\n d = t * t2;\n }\n return {\n x: a * p[0].x + b * p[1].x + c * p[2].x + d * p[3].x,\n y: a * p[0].y + b * p[1].y + c * p[2].y + d * p[3].y,\n t,\n };\n};\n\nconst calculateBezier = (derivativeFn: DeriveCallback, t: number) => {\n const d = derivativeFn(t);\n const l = d.x * d.x + d.y * d.y;\n\n return Math.sqrt(l);\n};\n\nconst bezierLength = (derivativeFn: DeriveCallback) => {\n const z = 0.5;\n const len = Tvalues.length;\n\n let sum = 0;\n\n for (let i = 0, t; i < len; i++) {\n t = z * Tvalues[i] + z;\n sum += Cvalues[i] * calculateBezier(derivativeFn, t);\n }\n return z * sum;\n};\n\n/**\n * Returns the length of CubicBezier / Quad segment.\n * @param curve cubic / quad bezier segment\n */\nconst getBezierLength = (curve: CubicCoordinates | QuadCoordinates) => {\n const points = [] as unknown as CubicPoints | QuadPoints;\n for (let idx = 0, len = curve.length, step = 2; idx < len; idx += step) {\n points.push({\n x: curve[idx],\n y: curve[idx + 1],\n });\n }\n const dpoints = deriveBezier(points);\n return bezierLength((t: number) => {\n return computeBezier(dpoints[0], t);\n });\n};\n\n// Precision for consider cubic polynom as quadratic one\nconst CBEZIER_MINMAX_EPSILON = 0.00000001;\n\n/**\n * Returns the most extreme points in a Quad Bezier segment.\n * @param A an array which consist of X/Y values\n */\n// https://github.com/kpym/SVGPathy/blob/acd1a50c626b36d81969f6e98e8602e128ba4302/lib/box.js#L89\nconst minmaxQ = ([v1, cp, v2]: [number, number, number]) => {\n const min = Math.min(v1, v2);\n const max = Math.max(v1, v2);\n\n /* istanbul ignore next @preserve */\n if (cp >= v1 ? v2 >= cp : v2 <= cp) {\n // if no extremum in ]0,1[\n return [min, max] as PointTuple;\n }\n\n // check if the extremum E is min or max\n const E = (v1 * v2 - cp * cp) / (v1 - 2 * cp + v2);\n return (E < min ? [E, max] : [min, E]) as PointTuple;\n};\n\n/**\n * Returns the most extreme points in a Cubic Bezier segment.\n * @param A an array which consist of X/Y values\n * @see https://github.com/kpym/SVGPathy/blob/acd1a50c626b36d81969f6e98e8602e128ba4302/lib/box.js#L127\n */\nconst minmaxC = ([v1, cp1, cp2, v2]: [number, number, number, number]) => {\n const K = v1 - 3 * cp1 + 3 * cp2 - v2;\n\n // if the polynomial is (almost) quadratic and not cubic\n /* istanbul ignore next @preserve */\n if (Math.abs(K) < CBEZIER_MINMAX_EPSILON) {\n if (v1 === v2 && v1 === cp1) {\n // no curve, point targeting same location\n return [v1, v2] as PointTuple;\n }\n\n return minmaxQ([v1, -0.5 * v1 + 1.5 * cp1, v1 - 3 * cp1 + 3 * cp2]);\n }\n\n // the reduced discriminant of the derivative\n const T = -v1 * cp2 + v1 * v2 - cp1 * cp2 - cp1 * v2 + cp1 * cp1 + cp2 * cp2;\n\n // if the polynomial is monotone in [0,1]\n if (T <= 0) {\n return [Math.min(v1, v2), Math.max(v1, v2)] as PointTuple;\n }\n const S = Math.sqrt(T);\n\n // potential extrema\n let min = Math.min(v1, v2);\n let max = Math.max(v1, v2);\n\n const L = v1 - 2 * cp1 + cp2;\n // check local extrema\n for (let R = (L + S) / K, i = 1; i <= 2; R = (L - S) / K, i++) {\n // istanbul ignore next @preserve\n if (R > 0 && R < 1) {\n // if the extrema is for R in [0,1]\n const Q = v1 * (1 - R) * (1 - R) * (1 - R) +\n cp1 * 3 * (1 - R) * (1 - R) * R + cp2 * 3 * (1 - R) * R * R +\n v2 * R * R * R;\n if (Q < min) {\n min = Q;\n }\n if (Q > max) {\n max = Q;\n }\n }\n }\n\n return [min, max] as PointTuple;\n};\n\nexport {\n bezierLength,\n calculateBezier,\n CBEZIER_MINMAX_EPSILON,\n computeBezier,\n Cvalues,\n deriveBezier,\n getBezierLength,\n minmaxC,\n minmaxQ,\n Tvalues,\n};\n","import { getBezierLength, minmaxC } from \"./bezier\";\nimport { type CubicCoordinates } from \"../types\";\n\n/**\n * Returns a point at a given length of a CubicBezier segment.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param t a [0-1] ratio\n * @returns the point at cubic-bezier segment length\n */\nconst getPointAtCubicSegmentLength = (\n [x1, y1, c1x, c1y, c2x, c2y, x2, y2]: CubicCoordinates,\n t: number,\n) => {\n const t1 = 1 - t;\n return {\n x: t1 ** 3 * x1 + 3 * t1 ** 2 * t * c1x + 3 * t1 * t ** 2 * c2x +\n t ** 3 * x2,\n y: t1 ** 3 * y1 + 3 * t1 ** 2 * t * c1y + 3 * t1 * t ** 2 * c2y +\n t ** 3 * y2,\n };\n};\n\n/**\n * Returns the length of a CubicBezier segment.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the CubicBezier segment length\n */\nconst getCubicLength = (\n x1: number,\n y1: number,\n c1x: number,\n c1y: number,\n c2x: number,\n c2y: number,\n x2: number,\n y2: number,\n) => {\n return getBezierLength([x1, y1, c1x, c1y, c2x, c2y, x2, y2]);\n};\n\n/**\n * Returns the point along a CubicBezier segment at a given distance.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance the distance to look at\n * @returns the point at CubicBezier length\n */\nconst getPointAtCubicLength = (\n x1: number,\n y1: number,\n c1x: number,\n c1y: number,\n c2x: number,\n c2y: number,\n x2: number,\n y2: number,\n distance?: number,\n) => {\n const distanceIsNumber = typeof distance === \"number\";\n let point = { x: x1, y: y1 };\n /* istanbul ignore else @preserve */\n if (distanceIsNumber) {\n const currentLength = getBezierLength([x1, y1, c1x, c1y, c2x, c2y, x2, y2]);\n if (distance <= 0) {\n // first point already defined\n } else if (distance >= currentLength) {\n point = { x: x2, y: y2 };\n } else {\n point = getPointAtCubicSegmentLength(\n [x1, y1, c1x, c1y, c2x, c2y, x2, y2],\n distance / currentLength,\n );\n }\n }\n return point;\n};\n\n/**\n * Returns the boundig box of a CubicBezier segment in the following format:\n * [MIN_X, MIN_Y, MAX_X, MAX_Y]\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the extrema of the CubicBezier segment\n */\nconst getCubicBBox = (\n x1: number,\n y1: number,\n c1x: number,\n c1y: number,\n c2x: number,\n c2y: number,\n x2: number,\n y2: number,\n) => {\n const cxMinMax = minmaxC([x1, c1x, c2x, x2]);\n const cyMinMax = minmaxC([y1, c1y, c2y, y2]);\n\n return [cxMinMax[0], cyMinMax[0], cxMinMax[1], cyMinMax[1]] as [\n number,\n number,\n number,\n number,\n ];\n};\n\nexport {\n getCubicBBox,\n getCubicLength,\n getPointAtCubicLength,\n getPointAtCubicSegmentLength,\n};\n","import { getBezierLength, minmaxQ } from \"./bezier\";\nimport { type QuadCoordinates } from \"../types\";\n\n/**\n * Returns the {x,y} coordinates of a point at a\n * given length of a quadratic-bezier segment.\n *\n * @see https://github.com/substack/point-at-length\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param cx the control point X\n * @param cy the control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param t a [0-1] ratio\n * @returns the requested {x,y} coordinates\n */\nconst getPointAtQuadSegmentLength = (\n [x1, y1, cx, cy, x2, y2]: QuadCoordinates,\n t: number,\n) => {\n const t1 = 1 - t;\n return {\n x: t1 ** 2 * x1 + 2 * t1 * t * cx + t ** 2 * x2,\n y: t1 ** 2 * y1 + 2 * t1 * t * cy + t ** 2 * y2,\n };\n};\n\n/**\n * Returns the length of a QuadraticBezier segment.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param cx the control point X\n * @param cy the control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the QuadraticBezier segment length\n */\nconst getQuadLength = (\n x1: number,\n y1: number,\n cx: number,\n cy: number,\n x2: number,\n y2: number,\n) => {\n return getBezierLength([x1, y1, cx, cy, x2, y2]);\n};\n\n/**\n * Returns the point along a QuadraticBezier segment at a given distance.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param cx the control point X\n * @param cy the control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance the distance to look at\n * @returns the point at QuadraticBezier length\n */\nconst getPointAtQuadLength = (\n x1: number,\n y1: number,\n cx: number,\n cy: number,\n x2: number,\n y2: number,\n distance?: number,\n) => {\n const distanceIsNumber = typeof distance === \"number\";\n let point = { x: x1, y: y1 };\n\n /* istanbul ignore else @preserve */\n if (distanceIsNumber) {\n const currentLength = getBezierLength([x1, y1, cx, cy, x2, y2]);\n if (distance <= 0) {\n // first point already defined\n } else if (distance >= currentLength) {\n point = { x: x2, y: y2 };\n } else {\n point = getPointAtQuadSegmentLength(\n [x1, y1, cx, cy, x2, y2],\n distance / currentLength,\n );\n }\n }\n return point;\n};\n\n/**\n * Returns the boundig box of a QuadraticBezier segment in the following format:\n * [MIN_X, MIN_Y, MAX_X, MAX_Y]\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param cx the control point X\n * @param cy the control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the extrema of the QuadraticBezier segment\n */\nconst getQuadBBox = (\n x1: number,\n y1: number,\n cx: number,\n cy: number,\n x2: number,\n y2: number,\n) => {\n const cxMinMax = minmaxQ([x1, cx, x2]);\n const cyMinMax = minmaxQ([y1, cy, y2]);\n return [cxMinMax[0], cyMinMax[0], cxMinMax[1], cyMinMax[1]] as [\n number,\n number,\n number,\n number,\n ];\n};\n\nexport {\n getPointAtQuadLength,\n getPointAtQuadSegmentLength,\n getQuadBBox,\n getQuadLength,\n};\n","import distanceSquareRoot from \"./distanceSquareRoot\";\nimport { type PointTuple } from \"../types\";\n\n/**\n * d3-polygon-area\n * https://github.com/d3/d3-polygon\n *\n * Returns the area of a polygon.\n *\n * @param polygon an array of coordinates\n * @returns the polygon area\n */\nconst polygonArea = (polygon: PointTuple[]) => {\n const n = polygon.length;\n let i = -1;\n let a: PointTuple;\n let b = polygon[n - 1];\n let area = 0;\n\n /* eslint-disable-next-line */\n while (++i < n) {\n a = b;\n b = polygon[i];\n area += a[1] * b[0] - a[0] * b[1];\n }\n\n return area / 2;\n};\n\n/**\n * d3-polygon-length\n * https://github.com/d3/d3-polygon\n *\n * Returns the perimeter of a polygon.\n *\n * @param polygon an array of coordinates\n * @returns the polygon length\n */\nconst polygonLength = (polygon: PointTuple[]) => {\n return polygon.reduce((length, point, i) => {\n if (i) {\n return length + distanceSquareRoot(polygon[i - 1], point);\n }\n return 0;\n }, 0);\n};\n\nexport { polygonArea, polygonLength };\n","/** Segment params length */\nconst paramsCount = {\n a: 7,\n c: 6,\n h: 1,\n l: 2,\n m: 2,\n r: 4,\n q: 4,\n s: 4,\n t: 2,\n v: 1,\n z: 0,\n};\n\nexport default paramsCount;\n","import paramsCount from \"./paramsCount\";\nimport PathParser from \"./pathParser\";\nimport type { PathCommand, PathSegment, RelativeCommand } from \"../types\";\n\n/**\n * Breaks the parsing of a pathString once a segment is finalized.\n *\n * @param path the `PathParser` instance\n */\nconst finalizeSegment = (path: PathParser) => {\n let pathCommand = path.pathValue[path.segmentStart] as PathCommand;\n let relativeCommand = pathCommand.toLowerCase() as RelativeCommand;\n const { data } = path;\n\n while (data.length >= paramsCount[relativeCommand]) {\n // overloaded `moveTo`\n // https://github.com/rveciana/svg-path-properties/blob/master/src/parse.ts\n if (relativeCommand === \"m\" && data.length > 2) {\n path.segments.push(\n [pathCommand as PathCommand | number].concat(\n data.splice(0, 2) as number[],\n ) as PathSegment,\n );\n relativeCommand = \"l\";\n pathCommand = pathCommand === \"m\" ? \"l\" : \"L\";\n } else {\n path.segments.push(\n [pathCommand as PathCommand | number].concat(\n data.splice(0, paramsCount[relativeCommand]) as number[],\n ) as PathSegment,\n );\n }\n\n if (!paramsCount[relativeCommand]) {\n break;\n }\n }\n};\nexport default finalizeSegment;\n","const error = \"SVGPathCommander Error\";\nexport default error;\n","import error from \"./error\";\nimport type PathParser from \"./pathParser\";\n\n/**\n * Validates an A (arc-to) specific path command value.\n * Usually a `large-arc-flag` or `sweep-flag`.\n *\n * @param path the `PathParser` instance\n */\nconst scanFlag = (path: PathParser) => {\n const { index, pathValue } = path;\n const code = pathValue.charCodeAt(index);\n\n if (code === 0x30 /* 0 */) {\n path.param = 0;\n path.index += 1;\n return;\n }\n\n if (code === 0x31 /* 1 */) {\n path.param = 1;\n path.index += 1;\n return;\n }\n\n path.err = `${error}: invalid Arc flag \"${\n pathValue[index]\n }\", expecting 0 or 1 at index ${index}`;\n};\n\nexport default scanFlag;\n","import { DigitNumber } from \"../types\";\n\n/**\n * Checks if a character is a digit.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isDigit = (code: number): code is DigitNumber => {\n return code >= 48 && code <= 57; // 0..9\n};\nexport default isDigit;\n","const invalidPathValue = \"Invalid path value\";\nexport default invalidPathValue;\n","import isDigit from \"./isDigit\";\nimport invalidPathValue from \"./invalidPathValue\";\nimport error from \"./error\";\nimport type PathParser from \"./pathParser\";\n\n/**\n * Validates every character of the path string,\n * every path command, negative numbers or floating point numbers.\n *\n * @param path the `PathParser` instance\n */\nconst scanParam = (path: PathParser) => {\n const { max, pathValue, index: start } = path;\n let index = start;\n let zeroFirst = false;\n let hasCeiling = false;\n let hasDecimal = false;\n let hasDot = false;\n let ch;\n\n if (index >= max) {\n path.err =\n `${error}: ${invalidPathValue} at index ${index}, \"pathValue\" is missing param`;\n return;\n }\n ch = pathValue.charCodeAt(index);\n\n if (ch === 0x2b /* + */ || ch === 0x2d /* - */) {\n index += 1;\n // ch = (index < max) ? pathValue.charCodeAt(index) : 0;\n ch = pathValue.charCodeAt(index);\n }\n\n // This logic is shamelessly borrowed from Esprima\n // https://github.com/ariya/esprimas\n if (!isDigit(ch) && ch !== 0x2e /* . */) {\n // path.err = 'SvgPath: param should start with 0..9 or `.` (at pos ' + index + ')';\n path.err = `${error}: ${invalidPathValue} at index ${index}, \"${\n pathValue[index]\n }\" is not a number`;\n return;\n }\n\n if (ch !== 0x2e /* . */) {\n zeroFirst = ch === 0x30 /* 0 */;\n index += 1;\n\n ch = pathValue.charCodeAt(index);\n\n if (zeroFirst && index < max) {\n // decimal number starts with '0' such as '09' is illegal.\n if (ch && isDigit(ch)) {\n // path.err = 'SvgPath: numbers started with `0` such as `09`\n // are illegal (at pos ' + start + ')';\n path.err = `${error}: ${invalidPathValue} at index ${start}, \"${\n pathValue[start]\n }\" illegal number`;\n return;\n }\n }\n\n while (index < max && isDigit(pathValue.charCodeAt(index))) {\n index += 1;\n hasCeiling = true;\n }\n\n ch = pathValue.charCodeAt(index);\n }\n\n if (ch === 0x2e /* . */) {\n hasDot = true;\n index += 1;\n while (isDigit(pathValue.charCodeAt(index))) {\n index += 1;\n hasDecimal = true;\n }\n\n ch = pathValue.charCodeAt(index);\n }\n\n if (ch === 0x65 /* e */ || ch === 0x45 /* E */) {\n if (hasDot && !hasCeiling && !hasDecimal) {\n path.err = `${error}: ${invalidPathValue} at index ${index}, \"${\n pathValue[index]\n }\" invalid float exponent`;\n return;\n }\n\n index += 1;\n\n ch = pathValue.charCodeAt(index);\n\n if (ch === 0x2b /* + */ || ch === 0x2d /* - */) {\n index += 1;\n }\n if (index < max && isDigit(pathValue.charCodeAt(index))) {\n while (index < max && isDigit(pathValue.charCodeAt(index))) {\n index += 1;\n }\n } else {\n path.err = `${error}: ${invalidPathValue} at index ${index}, \"${\n pathValue[index]\n }\" invalid integer exponent`;\n return;\n }\n }\n\n path.index = index;\n path.param = +path.pathValue.slice(start, index);\n};\nexport default scanParam;\n","import type { SpaceNumber } from \"../types\";\n\n/**\n * Checks if the character is a space.\n *\n * @param ch the character to check\n * @returns check result\n */\n\nconst isSpace = (ch: number): ch is SpaceNumber => {\n const allSpaces = [\n // Special spaces\n 0x1680,\n 0x180e,\n 0x2000,\n 0x2001,\n 0x2002,\n 0x2003,\n 0x2004,\n 0x2005,\n 0x2006,\n 0x2007,\n 0x2008,\n 0x2009,\n 0x200a,\n 0x202f,\n 0x205f,\n 0x3000,\n 0xfeff,\n // Line terminators\n 0x0a,\n 0x0d,\n 0x2028,\n 0x2029,\n // White spaces\n 0x20,\n 0x09,\n 0x0b,\n 0x0c,\n 0xa0,\n ];\n\n return allSpaces.includes(ch);\n};\nexport default isSpace;\n","import isSpace from \"./isSpace\";\nimport type PathParser from \"./pathParser\";\n\n/**\n * Points the parser to the next character in the\n * path string every time it encounters any kind of\n * space character.\n *\n * @param path the `PathParser` instance\n */\nconst skipSpaces = (path: PathParser) => {\n const { pathValue, max } = path;\n while (path.index < max && isSpace(pathValue.charCodeAt(path.index))) {\n path.index += 1;\n }\n};\nexport default skipSpaces;\n","import type { PathCommandNumber } from \"../types\";\n\n/**\n * Checks if the character is a path command.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isPathCommand = (code: number): code is PathCommandNumber => {\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy\n switch (code | 0x20) {\n case 0x6d /* m */:\n case 0x7a /* z */:\n case 0x6c /* l */:\n case 0x68 /* h */:\n case 0x76 /* v */:\n case 0x63 /* c */:\n case 0x73 /* s */:\n case 0x71 /* q */:\n case 0x74 /* t */:\n case 0x61 /* a */:\n // case 0x72/* r */:\n return true;\n default:\n return false;\n }\n};\nexport default isPathCommand;\n","import isDigit from \"./isDigit\";\nimport type { DigitNumber } from \"../types\";\n\n/**\n * Checks if the character is or belongs to a number.\n * [0-9]|+|-|.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isDigitStart = (\n code: number,\n): code is DigitNumber | 0x2b | 0x2d | 0x2e => {\n return isDigit(code) /* 0..9 */ || code === 0x2b /* + */ ||\n code === 0x2d /* - */ || code === 0x2e; /* . */\n};\nexport default isDigitStart;\n","/**\n * Checks if the character is an A (arc-to) path command.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isArcCommand = (code: number): code is 0x61 => {\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy\n return (code | 0x20) === 0x61;\n};\nexport default isArcCommand;\n","/**\n * Checks if the character is a MoveTo command.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isMoveCommand = (code: number): code is 0x6d | 0x4d => {\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy\n switch (code | 0x20) {\n case 0x6d /* m */:\n case 0x4d /* M */:\n return true;\n default:\n return false;\n }\n};\nexport default isMoveCommand;\n","import finalizeSegment from \"./finalizeSegment\";\nimport paramCounts from \"./paramsCount\";\nimport scanFlag from \"./scanFlag\";\nimport scanParam from \"./scanParam\";\nimport skipSpaces from \"./skipSpaces\";\nimport isPathCommand from \"./isPathCommand\";\nimport isDigitStart from \"./isDigitStart\";\nimport isArcCommand from \"./isArcCommand\";\nimport isMoveCommand from \"./isMoveCommand\";\nimport invalidPathValue from \"./invalidPathValue\";\nimport error from \"./error\";\n\nimport type PathParser from \"./pathParser\";\nimport type { PathSegment, RelativeCommand } from \"../types\";\n\n/**\n * Scans every character in the path string to determine\n * where a segment starts and where it ends.\n *\n * @param path the `PathParser` instance\n */\nconst scanSegment = (path: PathParser) => {\n const { max, pathValue, index, segments } = path;\n const cmdCode = pathValue.charCodeAt(index);\n const reqParams =\n paramCounts[pathValue[index].toLowerCase() as RelativeCommand];\n\n path.segmentStart = index;\n\n // segments always start with a path command\n if (!isPathCommand(cmdCode)) {\n path.err = `${error}: ${invalidPathValue} \"${\n pathValue[index]\n }\" is not a path command at index ${index}`;\n return;\n }\n\n // after a Z segment, we only expect a MoveTo path command\n const lastSegment = segments[segments.length - 1] as PathSegment | undefined;\n if (\n !isMoveCommand(cmdCode) && lastSegment?.[0]?.toLocaleLowerCase() === \"z\"\n ) {\n path.err = `${error}: ${invalidPathValue} \"${\n pathValue[index]\n }\" is not a MoveTo path command at index ${index}`;\n return;\n }\n\n path.index += 1;\n skipSpaces(path);\n\n path.data = [];\n\n if (!reqParams) {\n // Z\n finalizeSegment(path);\n return;\n }\n\n for (;;) {\n for (let i = reqParams; i > 0; i -= 1) {\n if (isArcCommand(cmdCode) && (i === 3 || i === 4)) scanFlag(path);\n else scanParam(path);\n\n if (path.err.length) {\n return;\n }\n path.data.push(path.param);\n\n skipSpaces(path);\n\n // after ',' param is mandatory\n if (\n path.index < max && pathValue.charCodeAt(path.index) === 0x2c /* , */\n ) {\n path.index += 1;\n skipSpaces(path);\n }\n }\n\n if (path.index >= path.max) {\n break;\n }\n\n // Stop on next segment\n if (!isDigitStart(pathValue.charCodeAt(path.index))) {\n break;\n }\n }\n\n finalizeSegment(path);\n};\nexport default scanSegment;\n","import type { PathArray, PathSegment } from \"../types\";\n\n/**\n * The `PathParser` is used by the `parsePathString` static method\n * to generate a `pathArray`.\n *\n * @param pathString\n */\nexport default class PathParser {\n declare segments: PathArray | PathSegment[];\n declare pathValue: string;\n declare max: number;\n declare index: number;\n declare param: number;\n declare segmentStart: number;\n declare data: (string | number)[];\n declare err: string;\n\n constructor(pathString: string) {\n this.segments = [];\n this.pathValue = pathString;\n this.max = pathString.length;\n this.index = 0;\n this.param = 0.0;\n this.segmentStart = 0;\n this.data = [];\n this.err = \"\";\n }\n}\n","import scanSegment from \"./scanSegment\";\nimport skipSpaces from \"./skipSpaces\";\nimport PathParser from \"./pathParser\";\nimport type { PathArray } from \"../types\";\n\n/**\n * Parses a path string value and returns an array\n * of segments we like to call `pathArray`.\n *\n * @param pathInput the string to be parsed\n * @returns the resulted `pathArray` or error string\n */\nconst parsePathString = (pathInput: string | T) => {\n if (typeof pathInput !== \"string\") {\n return pathInput.slice(0) as typeof pathInput;\n }\n\n const path = new PathParser(pathInput);\n\n skipSpaces(path);\n\n while (path.index < path.max && !path.err.length) {\n scanSegment(path);\n }\n\n // handle valid paths first\n // handle errors second\n if (!path.err.length) {\n if (path.segments.length) {\n /**\n * force absolute first M\n * getPathBBox calculation requires first segment to be absolute\n * @see https://github.com/thednp/svg-path-commander/pull/49\n */\n path.segments[0][0] = \"M\";\n }\n } else {\n throw TypeError(path.err);\n }\n\n return path.segments as PathArray;\n};\n\nexport default parsePathString;\n","import type {\n AbsoluteCommand,\n AbsoluteSegment,\n ASegment,\n CSegment,\n HSegment,\n LSegment,\n MSegment,\n PathSegment,\n QSegment,\n SSegment,\n TSegment,\n VSegment,\n} from \"../types\";\n\n/**\n * Returns an absolute segment of a `PathArray` object.\n *\n * @param segment the segment object\n * @param index the segment index\n * @param lastX the last known X value\n * @param lastY the last known Y value\n * @returns the absolute segment\n */\nconst absolutizeSegment = (\n segment: PathSegment,\n index: number,\n lastX: number,\n lastY: number,\n) => {\n const [pathCommand] = segment;\n const absCommand = pathCommand.toUpperCase() as AbsoluteCommand;\n const isAbsolute = absCommand === pathCommand;\n\n /* istanbul ignore else @preserve */\n if (index === 0 || isAbsolute) return segment as MSegment | AbsoluteSegment;\n // const values = segment.slice(1) as number[];\n if (absCommand === \"A\") {\n return [\n absCommand,\n segment[1],\n segment[2],\n segment[3],\n segment[4],\n segment[5],\n (segment as ASegment)[6] + lastX,\n (segment as ASegment)[7] + lastY,\n ] as ASegment;\n } else if (absCommand === \"V\") {\n return [absCommand, (segment as VSegment)[1] + lastY] as VSegment;\n } else if (absCommand === \"H\") {\n return [absCommand, (segment as HSegment)[1] + lastX] as HSegment;\n } else if (absCommand === \"L\") {\n return [\n absCommand,\n (segment as LSegment)[1] + lastX,\n (segment as LSegment)[2] + lastY,\n ] as LSegment;\n } else {\n // use brakets for `eslint: no-case-declaration`\n // https://stackoverflow.com/a/50753272/803358\n const absValues = [] as number[];\n const seglen = segment.length;\n for (let j = 1; j < seglen; j += 1) {\n absValues.push((segment[j] as number) + (j % 2 ? lastX : lastY));\n }\n // for c, s, q, t\n return [absCommand as typeof absCommand | number].concat(absValues) as\n | MSegment\n | QSegment\n | TSegment\n | SSegment\n | CSegment;\n }\n};\nexport default absolutizeSegment;\n","// import paramsParser from '../parser/paramsParser';\nimport type {\n AbsoluteCommand,\n IteratorCallback,\n PathArray,\n PathCommand,\n PathSegment,\n} from \"../types\";\n\nconst iterate = (\n path: PathArray,\n iterator: IteratorCallback,\n) => {\n let pathLen = path.length;\n let segment: PathSegment;\n let pathCommand = \"M\" as PathCommand;\n let absCommand = \"M\" as AbsoluteCommand;\n let isRelative = false;\n let x = 0;\n let y = 0;\n let mx = 0;\n let my = 0;\n let segLen = 0;\n\n for (let i = 0; i < pathLen; i += 1) {\n segment = path[i];\n [pathCommand] = segment;\n segLen = segment.length;\n absCommand = pathCommand.toUpperCase() as AbsoluteCommand;\n isRelative = absCommand !== pathCommand;\n\n const iteratorResult = iterator(segment, i, x, y);\n // some methods like getPointAtLength would like to break\n // when task is complete\n if (iteratorResult === false) {\n break;\n }\n\n // segment = path[i];\n if (absCommand === \"Z\") {\n x = mx;\n y = my;\n } else if (absCommand === \"H\") {\n x = (segment[1] as number) + (isRelative ? x : 0);\n } else if (absCommand === \"V\") {\n y = (segment[1] as number) + (isRelative ? y : 0);\n } else {\n x = (segment[segLen - 2] as number) + (isRelative ? x : 0);\n y = (segment[segLen - 1] as number) + (isRelative ? y : 0);\n\n if (absCommand === \"M\") {\n mx = x;\n my = y;\n }\n }\n\n if (iteratorResult) {\n path[i] = iteratorResult;\n if (iteratorResult[0] === \"C\") {\n pathLen = path.length;\n }\n }\n }\n return path as T;\n};\n\nexport default iterate;\n","import parsePathString from \"../parser/parsePathString\";\nimport absolutizeSegment from \"../process/absolutizeSegment\";\nimport type { AbsoluteArray, PathArray } from \"../types\";\nimport iterate from \"../process/iterate\";\n\n/**\n * Parses a path string value or object and returns an array\n * of segments, all converted to absolute values.\n *\n * @param pathInput the path string | object\n * @returns the resulted `pathArray` with absolute values\n */\nconst pathToAbsolute = (pathInput: string | PathArray) => {\n const path = parsePathString(pathInput);\n\n return iterate(path, absolutizeSegment);\n};\nexport default pathToAbsolute;\n","import type {\n aSegment,\n cSegment,\n hSegment,\n lSegment,\n MSegment,\n PathSegment,\n qSegment,\n RelativeCommand,\n RelativeSegment,\n sSegment,\n tSegment,\n vSegment,\n} from \"../types\";\n\n/**\n * Returns a relative segment of a `PathArray` object.\n *\n * @param segment the segment object\n * @param index the segment index\n * @param lastX the last known X value\n * @param lastY the last known Y value\n * @returns the relative segment\n */\nconst relativizeSegment = (\n segment: PathSegment,\n index: number,\n lastX: number,\n lastY: number,\n) => {\n const [pathCommand] = segment;\n const relCommand = pathCommand.toLowerCase() as RelativeCommand;\n const isRelative = pathCommand === relCommand;\n\n /* istanbul ignore else @preserve */\n if (index === 0 || isRelative) return segment as MSegment | RelativeSegment;\n\n if (relCommand === \"a\") {\n return [\n relCommand,\n segment[1],\n segment[2],\n segment[3],\n segment[4],\n segment[5],\n (segment as aSegment)[6] - lastX,\n (segment as aSegment)[7] - lastY,\n ] as aSegment;\n } else if (relCommand === \"v\") {\n return [relCommand, (segment as vSegment)[1] - lastY] as vSegment;\n } else if (relCommand === \"h\") {\n return [relCommand, (segment as hSegment)[1] - lastX] as hSegment;\n } else if (relCommand === \"l\") {\n return [\n relCommand,\n (segment as lSegment)[1] - lastX,\n (segment as lSegment)[2] - lastY,\n ] as lSegment;\n } else {\n // use brakets for `eslint: no-case-declaration`\n // https://stackoverflow.com/a/50753272/803358\n const relValues = [] as number[];\n const seglen = segment.length;\n for (let j = 1; j < seglen; j += 1) {\n relValues.push((segment[j] as number) - (j % 2 ? lastX : lastY));\n }\n // for c, s, q, t\n return [relCommand as RelativeCommand | number].concat(relValues) as\n | qSegment\n | tSegment\n | sSegment\n | cSegment;\n }\n};\n\nexport default relativizeSegment;\n","import type { PathArray, RelativeArray } from \"../types\";\nimport parsePathString from \"../parser/parsePathString\";\nimport iterate from \"../process/iterate\";\nimport relativizeSegment from \"../process/relativizeSegment\";\n\n/**\n * Parses a path string value or object and returns an array\n * of segments, all converted to relative values.\n *\n * @param pathInput the path string | object\n * @returns the resulted `pathArray` with relative values\n */\nconst pathToRelative = (pathInput: string | PathArray): RelativeArray => {\n const path = parsePathString(pathInput);\n\n return iterate(path, relativizeSegment);\n};\nexport default pathToRelative;\n","/**\n * Returns an {x,y} vector rotated by a given\n * angle in radian.\n *\n * @param x the initial vector x\n * @param y the initial vector y\n * @param rad the radian vector angle\n * @returns the rotated vector\n */\nconst rotateVector = (\n x: number,\n y: number,\n rad: number,\n): { x: number; y: number } => {\n const { sin, cos } = Math;\n const X = x * cos(rad) - y * sin(rad);\n const Y = x * sin(rad) + y * cos(rad);\n return { x: X, y: Y };\n};\n\nexport default rotateVector;\n","import rotateVector from \"../math/rotateVector\";\n\n/**\n * Converts A (arc-to) segments to C (cubic-bezier-to).\n *\n * For more information of where this math came from visit:\n * http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes\n *\n * @param X1 the starting x position\n * @param Y1 the starting y position\n * @param RX x-radius of the arc\n * @param RY y-radius of the arc\n * @param angle x-axis-rotation of the arc\n * @param LAF large-arc-flag of the arc\n * @param SF sweep-flag of the arc\n * @param X2 the ending x position\n * @param Y2 the ending y position\n * @param recursive the parameters needed to split arc into 2 segments\n * @return the resulting cubic-bezier segment(s)\n */\nconst arcToCubic = (\n X1: number,\n Y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n X2: number,\n Y2: number,\n recursive?: [number, number, number, number],\n): number[] => {\n let x1 = X1;\n let y1 = Y1;\n let rx = RX;\n let ry = RY;\n let x2 = X2;\n let y2 = Y2;\n // for more information of where this Math came from visit:\n // http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes\n const d120 = (Math.PI * 120) / 180;\n\n const rad = (Math.PI / 180) * (+angle || 0);\n let res = [] as number[];\n let xy;\n let f1;\n let f2;\n let cx;\n let cy;\n\n if (!recursive) {\n xy = rotateVector(x1, y1, -rad);\n x1 = xy.x;\n y1 = xy.y;\n xy = rotateVector(x2, y2, -rad);\n x2 = xy.x;\n y2 = xy.y;\n\n const x = (x1 - x2) / 2;\n const y = (y1 - y2) / 2;\n let h = (x * x) / (rx * rx) + (y * y) / (ry * ry);\n if (h > 1) {\n h = Math.sqrt(h);\n rx *= h;\n ry *= h;\n }\n const rx2 = rx * rx;\n const ry2 = ry * ry;\n\n const k = (LAF === SF ? -1 : 1) *\n Math.sqrt(\n Math.abs(\n (rx2 * ry2 - rx2 * y * y - ry2 * x * x) / (rx2 * y * y + ry2 * x * x),\n ),\n );\n\n cx = (k * rx * y) / ry + (x1 + x2) / 2;\n cy = (k * -ry * x) / rx + (y1 + y2) / 2;\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy no-bitwise\n f1 = Math.asin(((((y1 - cy) / ry) * 10 ** 9) >> 0) / 10 ** 9);\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy no-bitwise\n f2 = Math.asin(((((y2 - cy) / ry) * 10 ** 9) >> 0) / 10 ** 9);\n\n f1 = x1 < cx ? Math.PI - f1 : f1;\n f2 = x2 < cx ? Math.PI - f2 : f2;\n if (f1 < 0) f1 = Math.PI * 2 + f1;\n if (f2 < 0) f2 = Math.PI * 2 + f2;\n if (SF && f1 > f2) {\n f1 -= Math.PI * 2;\n }\n if (!SF && f2 > f1) {\n f2 -= Math.PI * 2;\n }\n } else {\n [f1, f2, cx, cy] = recursive;\n }\n let df = f2 - f1;\n if (Math.abs(df) > d120) {\n const f2old = f2;\n const x2old = x2;\n const y2old = y2;\n f2 = f1 + d120 * (SF && f2 > f1 ? 1 : -1);\n x2 = cx + rx * Math.cos(f2);\n y2 = cy + ry * Math.sin(f2);\n res = arcToCubic(x2, y2, rx, ry, angle, 0, SF, x2old, y2old, [\n f2,\n f2old,\n cx,\n cy,\n ]);\n }\n df = f2 - f1;\n const c1 = Math.cos(f1);\n const s1 = Math.sin(f1);\n const c2 = Math.cos(f2);\n const s2 = Math.sin(f2);\n const t = Math.tan(df / 4);\n const hx = (4 / 3) * rx * t;\n const hy = (4 / 3) * ry * t;\n const m1 = [x1, y1];\n const m2 = [x1 + hx * s1, y1 - hy * c1];\n const m3 = [x2 + hx * s2, y2 - hy * c2];\n const m4 = [x2, y2];\n m2[0] = 2 * m1[0] - m2[0];\n m2[1] = 2 * m1[1] - m2[1];\n if (recursive) {\n return [m2[0], m2[1], m3[0], m3[1], m4[0], m4[1]].concat(res);\n }\n res = [m2[0], m2[1], m3[0], m3[1], m4[0], m4[1]].concat(res);\n const newres = [];\n for (let i = 0, ii = res.length; i < ii; i += 1) {\n newres[i] = i % 2\n ? rotateVector(res[i - 1], res[i], rad).y\n : rotateVector(res[i], res[i + 1], rad).x;\n }\n return newres;\n};\nexport default arcToCubic;\n","/**\n * Converts a Q (quadratic-bezier) segment to C (cubic-bezier).\n *\n * @param x1 curve start x\n * @param y1 curve start y\n * @param qx control point x\n * @param qy control point y\n * @param x2 curve end x\n * @param y2 curve end y\n * @returns the cubic-bezier segment\n */\nconst quadToCubic = (\n x1: number,\n y1: number,\n qx: number,\n qy: number,\n x2: number,\n y2: number,\n): [number, number, number, number, number, number] => {\n const r13 = 1 / 3;\n const r23 = 2 / 3;\n return [\n r13 * x1 + r23 * qx, // cpx1\n r13 * y1 + r23 * qy, // cpy1\n r13 * x2 + r23 * qx, // cpx2\n r13 * y2 + r23 * qy, // cpy2\n x2,\n y2, // x,y\n ];\n};\nexport default quadToCubic;\n","import midPoint from \"../math/midPoint\";\n\n/**\n * Converts an L (line-to) segment to C (cubic-bezier).\n *\n * @param x1 line start x\n * @param y1 line start y\n * @param x2 line end x\n * @param y2 line end y\n * @returns the cubic-bezier segment\n */\nconst lineToCubic = (x1: number, y1: number, x2: number, y2: number) => {\n const c1 = midPoint([x1, y1], [x2, y2], 1.0 / 3.0);\n const c2 = midPoint([x1, y1], [x2, y2], 2.0 / 3.0);\n return [c1[0], c1[1], c2[0], c2[1], x2, y2];\n};\nexport default lineToCubic;\n","import arcToCubic from \"./arcToCubic\";\nimport quadToCubic from \"./quadToCubic\";\nimport lineToCubic from \"./lineToCubic\";\nimport type { CSegment, MSegment, PathSegment } from \"../types\";\nimport type { ParserParams } from \"../interface\";\n\n/**\n * Converts any segment to C (cubic-bezier).\n *\n * @param segment the source segment\n * @param params the source segment parameters\n * @returns the cubic-bezier segment\n */\nconst segmentToCubic = (segment: PathSegment, params: ParserParams) => {\n const [pathCommand] = segment;\n const values = segment.slice(1).map(Number);\n const [x, y] = values;\n // let args;\n const { x1: px1, y1: py1, x: px, y: py } = params;\n\n if (!\"TQ\".includes(pathCommand)) {\n params.qx = null;\n params.qy = null;\n }\n\n if (pathCommand === \"M\") {\n params.x = x;\n params.y = y;\n return segment;\n } else if (pathCommand === \"A\") {\n return [\"C\" as string | number].concat(\n arcToCubic(\n px1,\n py1,\n values[0],\n values[1],\n values[2],\n values[3],\n values[4],\n values[5],\n values[6],\n ),\n ) as CSegment;\n } else if (pathCommand === \"Q\") {\n params.qx = x;\n params.qy = y;\n return [\"C\" as string | number].concat(\n quadToCubic(px1, py1, values[0], values[1], values[2], values[3]),\n ) as CSegment;\n } else if (pathCommand === \"L\") {\n return [\"C\" as string | number].concat(\n lineToCubic(px1, py1, x, y),\n ) as CSegment;\n } else if (pathCommand === \"Z\") {\n return [\"C\" as string | number].concat(\n lineToCubic(px1, py1, px, py),\n ) as CSegment;\n }\n\n return segment as MSegment | CSegment;\n};\nexport default segmentToCubic;\n","import type { ParserParams } from \"../interface\";\nimport type {\n ASegment,\n CSegment,\n HSegment,\n LSegment,\n MSegment,\n NormalSegment,\n PathCommand,\n PathSegment,\n PointTuple,\n QSegment,\n VSegment,\n} from \"../types\";\n\n/**\n * Normalizes a single segment of a `pathArray` object.\n *\n * @param segment the segment object\n * @param params the normalization parameters\n * @returns the normalized segment\n */\nconst normalizeSegment = (segment: PathSegment, params: ParserParams) => {\n const [pathCommand] = segment;\n const absCommand = pathCommand.toUpperCase();\n const isRelative = pathCommand !== absCommand;\n const { x1: px1, y1: py1, x2: px2, y2: py2, x, y } = params;\n const values = segment.slice(1) as number[];\n let absValues = values.map((n, j) => n + (isRelative ? (j % 2 ? y : x) : 0));\n\n if (!\"TQ\".includes(absCommand)) {\n // optional but good to be cautious\n params.qx = null;\n params.qy = null;\n }\n\n // istanbul ignore else @preserve\n if (absCommand === \"A\") {\n absValues = values.slice(0, -2).concat(\n values[5] + (isRelative ? x : 0),\n values[6] + (isRelative ? y : 0),\n );\n\n return [\"A\" as PathCommand | number].concat(absValues) as ASegment;\n } else if (absCommand === \"H\") {\n return [\n \"L\",\n (segment as HSegment)[1] + (isRelative ? x : 0),\n py1,\n ] as LSegment;\n } else if (absCommand === \"V\") {\n return [\n \"L\",\n px1,\n (segment as VSegment)[1] + (isRelative ? y : 0),\n ] as LSegment;\n } else if (absCommand === \"L\") {\n return [\n \"L\",\n (segment as LSegment)[1] + (isRelative ? x : 0),\n (segment as LSegment)[2] + (isRelative ? y : 0),\n ] as LSegment;\n } else if (absCommand === \"M\") {\n return [\n \"M\",\n (segment as MSegment)[1] + (isRelative ? x : 0),\n (segment as MSegment)[2] + (isRelative ? y : 0),\n ] as MSegment;\n } else if (absCommand === \"C\") {\n return [\"C\" as PathCommand | number].concat(absValues) as CSegment;\n } else if (absCommand === \"S\") {\n const x1 = px1 * 2 - px2;\n const y1 = py1 * 2 - py2;\n params.x1 = x1;\n params.y1 = y1;\n return [\"C\", x1, y1].concat(absValues) as CSegment;\n } else if (absCommand === \"T\") {\n const qx = px1 * 2 - (params.qx ? params.qx : /* istanbul ignore next */ 0);\n const qy = py1 * 2 - (params.qy ? params.qy : /* istanbul ignore next */ 0);\n params.qx = qx;\n params.qy = qy;\n return [\"Q\", qx, qy].concat(absValues) as QSegment;\n } else if (absCommand === \"Q\") {\n const [nqx, nqy] = absValues as PointTuple;\n params.qx = nqx;\n params.qy = nqy;\n return [\"Q\" as PathCommand | number].concat(absValues) as QSegment;\n } else if (absCommand === \"Z\") {\n return [\"Z\"] as NormalSegment;\n }\n\n // istanbul ignore next @preserve\n return segment as NormalSegment;\n};\nexport default normalizeSegment;\n","import type { ParserParams } from \"../interface\";\n\nconst paramsParser: ParserParams = {\n x1: 0,\n y1: 0,\n x2: 0,\n y2: 0,\n x: 0,\n y: 0,\n qx: null,\n qy: null,\n};\n\nexport default paramsParser;\n","import segmentToCubic from \"../process/segmentToCubic\";\nimport { AbsoluteCommand, CSegment, CurveArray, PathArray } from \"../types\";\nimport iterate from \"../process/iterate\";\nimport parsePathString from \"../parser/parsePathString\";\nimport normalizeSegment from \"../process/normalizeSegment\";\nimport paramsParser from \"../parser/paramsParser\";\n\n/**\n * Parses a path string value or 'pathArray' and returns a new one\n * in which all segments are converted to cubic-bezier.\n *\n * In addition, un-necessary `Z` segment is removed if previous segment\n * extends to the `M` segment.\n *\n * @param pathInput the string to be parsed or 'pathArray'\n * @returns the resulted `pathArray` converted to cubic-bezier\n */\nconst pathToCurve = (pathInput: string | PathArray): CurveArray => {\n const params = { ...paramsParser };\n const path = parsePathString(pathInput);\n\n return iterate(path, (seg, index, lastX, lastY) => {\n params.x = lastX;\n params.y = lastY;\n const normalSegment = normalizeSegment(seg, params);\n let result = segmentToCubic(normalSegment, params);\n const isLongArc = result[0] === \"C\" && result.length > 7;\n\n if (isLongArc) {\n path.splice(\n index + 1,\n 0,\n [\"C\" as AbsoluteCommand | number].concat(result.slice(7)) as CSegment,\n );\n result = result.slice(0, 7) as CSegment;\n }\n\n const seglen = result.length;\n params.x1 = +result[seglen - 2];\n params.y1 = +result[seglen - 1];\n params.x2 = +result[seglen - 4] || params.x1;\n params.y2 = +result[seglen - 3] || params.y1;\n\n return result;\n });\n};\nexport default pathToCurve;\n","import { Options } from \"../interface\";\n\n/** SVGPathCommander default options */\nconst defaultOptions: Options = {\n origin: [0, 0, 0],\n round: 4,\n};\n\nexport default defaultOptions;\n","const roundTo = (n: number, round: number) => {\n const pow = round >= 1 ? 10 ** round : 1;\n\n return round > 0 ? Math.round(n * pow) / pow : Math.round(n);\n};\n\nexport default roundTo;\n","import type { PathArray, PathSegment } from \"../types\";\nimport defaultOptions from \"../options/options\";\nimport roundTo from \"../math/roundTo\";\n\n/**\n * Returns a valid `d` attribute string value created\n * by rounding values and concatenating the `pathArray` segments.\n *\n * @param path the `pathArray` object\n * @param roundOption amount of decimals to round values to\n * @returns the concatenated path string\n */\nconst pathToString = (\n path: PathArray,\n roundOption?: number | \"off\",\n): string => {\n const pathLen = path.length;\n let { round } = defaultOptions;\n let segment = path[0] as PathSegment;\n let result = \"\";\n\n // allow for ZERO decimals\n round = roundOption === \"off\"\n ? roundOption\n : typeof roundOption === \"number\" && roundOption >= 0\n ? roundOption\n : typeof round === \"number\" && round >= 0\n ? round\n : /* istanbul ignore next @preserve */ \"off\";\n\n for (let i = 0; i < pathLen; i += 1) {\n segment = path[i];\n const [pathCommand] = segment;\n const values = segment.slice(1) as number[];\n result += pathCommand;\n if (round === \"off\") {\n result += values.join(\" \");\n } else {\n let j = 0;\n const valLen = values.length;\n while (j < valLen) {\n result += roundTo(values[j], round);\n if (j !== valLen - 1) result += \" \";\n j += 1;\n }\n }\n }\n\n return result;\n};\n\nexport default pathToString;\n","const DISTANCE_EPSILON = 0.00001;\n\nexport default DISTANCE_EPSILON;\n","import normalizeSegment from \"./normalizeSegment\";\nimport type { NormalArray, PathArray } from \"../types\";\nimport iterate from \"./iterate\";\nimport parsePathString from \"../parser/parsePathString\";\nimport paramsParser from \"../parser/paramsParser\";\n\n/**\n * Normalizes a `pathArray` object for further processing:\n * * convert segments to absolute values\n * * convert shorthand path commands to their non-shorthand notation\n *\n * @param pathInput the string to be parsed or 'pathArray'\n * @returns the normalized `pathArray`\n */\nconst normalizePath = (pathInput: string | PathArray) => {\n const path = parsePathString(pathInput);\n const params = { ...paramsParser };\n\n return iterate(path, (seg, _, lastX, lastY) => {\n params.x = lastX;\n params.y = lastY;\n const result = normalizeSegment(seg, params);\n\n const seglen = result.length;\n params.x1 = +result[seglen - 2];\n params.y1 = +result[seglen - 1];\n params.x2 = +result[seglen - 4] || params.x1;\n params.y2 = +result[seglen - 3] || params.y1;\n\n return result;\n });\n};\nexport default normalizePath;\n","import DISTANCE_EPSILON from \"./distanceEpsilon\";\nimport type { MSegment, PathArray, PointTuple } from \"../types\";\nimport iterate from \"../process/iterate\";\nimport { getLineLength, getPointAtLineLength } from \"../math/lineTools\";\nimport { getArcLength, getPointAtArcLength } from \"../math/arcTools\";\nimport { getCubicLength, getPointAtCubicLength } from \"../math/cubicTools\";\nimport { getPointAtQuadLength, getQuadLength } from \"../math/quadTools\";\nimport normalizePath from \"../process/normalizePath\";\n\n/**\n * Returns [x,y] coordinates of a point at a given length of a shape.\n *\n * @param pathInput the `pathArray` to look into\n * @param distance the length of the shape to look at\n * @returns the requested {x, y} point coordinates\n */\nconst getPointAtLength = (pathInput: string | PathArray, distance?: number) => {\n const path = normalizePath(pathInput);\n let isM = false;\n let data = [] as number[];\n let pathCommand = \"M\";\n let x = 0;\n let y = 0;\n let [mx, my] = path[0].slice(1) as PointTuple;\n const distanceIsNumber = typeof distance === \"number\";\n let point = { x: mx, y: my };\n let length = 0;\n let POINT = point;\n let totalLength = 0;\n\n if (!distanceIsNumber || distance < DISTANCE_EPSILON) return point;\n\n // for (let i = 0; i < pathLen; i += 1) {\n iterate(path, (seg, _, lastX, lastY) => {\n [pathCommand] = seg;\n isM = pathCommand === \"M\";\n data = !isM ? [lastX, lastY].concat(seg.slice(1) as number[]) : data;\n\n // this segment is always ZERO\n /* istanbul ignore else @preserve */\n if (isM) {\n // remember mx, my for Z\n [, mx, my] = seg as MSegment;\n point = { x: mx, y: my };\n length = 0;\n } else if (pathCommand === \"L\") {\n point = getPointAtLineLength(\n data[0],\n data[1],\n data[2],\n data[3],\n distance - totalLength,\n );\n length = getLineLength(data[0], data[1], data[2], data[3]);\n } else if (pathCommand === \"A\") {\n point = getPointAtArcLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n data[6],\n data[7],\n data[8],\n distance - totalLength,\n );\n length = getArcLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n data[6],\n data[7],\n data[8],\n );\n } else if (pathCommand === \"C\") {\n point = getPointAtCubicLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n data[6],\n data[7],\n distance - totalLength,\n );\n length = getCubicLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n data[6],\n data[7],\n );\n } else if (pathCommand === \"Q\") {\n point = getPointAtQuadLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n distance - totalLength,\n );\n length = getQuadLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n );\n } else if (pathCommand === \"Z\") {\n data = [lastX, lastY, mx, my];\n point = { x: mx, y: my };\n\n length = getLineLength(data[0], data[1], data[2], data[3]);\n }\n\n [x, y] = data.slice(-2);\n\n if (totalLength < distance) {\n POINT = point;\n } else {\n // totalLength >= distance\n // stop right here\n // stop iterator now!\n return false;\n }\n\n totalLength += length;\n return;\n });\n\n // native `getPointAtLength` behavior when the given distance\n // is higher than total length\n if (distance > totalLength - DISTANCE_EPSILON) {\n return { x, y };\n }\n\n return POINT;\n};\n\nexport default getPointAtLength;\n","import type { LSegment, MSegment, PathArray, PointTuple } from \"../types\";\nimport { getLineLength } from \"../math/lineTools\";\nimport { getArcLength } from \"../math/arcTools\";\nimport { getCubicLength } from \"../math/cubicTools\";\nimport { getQuadLength } from \"../math/quadTools\";\nimport iterate from \"../process/iterate\";\nimport parsePathString from \"../parser/parsePathString\";\nimport absolutizeSegment from \"../process/absolutizeSegment\";\n\n/**\n * Returns the shape total length, or the equivalent to `shape.getTotalLength()`.\n *\n * @param pathInput the target `pathArray`\n * @returns the shape total length\n */\nconst getTotalLength = (pathInput: string | PathArray) => {\n const path = parsePathString(pathInput);\n let paramX1 = 0;\n let paramY1 = 0;\n let paramX2 = 0;\n let paramY2 = 0;\n let paramQX = 0;\n let paramQY = 0;\n let pathCommand = \"M\";\n let mx = 0;\n let my = 0;\n let totalLength = 0;\n\n iterate(path, (seg, index, lastX, lastY) => {\n [pathCommand] = seg;\n const absCommand = pathCommand.toUpperCase();\n const isRelative = absCommand !== pathCommand;\n const absoluteSegment = isRelative\n ? absolutizeSegment(seg, index, lastX, lastY)\n : (seg.slice(0) as typeof seg);\n\n const normalSegment = absCommand === \"V\"\n ? ([\"L\", lastX, absoluteSegment[1]] as LSegment)\n : absCommand === \"H\"\n ? ([\"L\", absoluteSegment[1], lastY] as LSegment)\n : absoluteSegment;\n [pathCommand] = normalSegment;\n\n if (!\"TQ\".includes(absCommand)) {\n // optional but good to be cautious\n paramQX = 0;\n paramQY = 0;\n }\n\n // this segment is always ZERO\n /* istanbul ignore else @preserve */\n if (pathCommand === \"M\") {\n // remember mx, my for Z\n [, mx, my] = normalSegment as MSegment;\n } else if (pathCommand === \"L\") {\n totalLength += getLineLength(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n );\n } else if (pathCommand === \"A\") {\n totalLength += getArcLength(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n normalSegment[5] as number,\n normalSegment[6] as number,\n normalSegment[7] as number,\n );\n } else if (pathCommand === \"S\") {\n const cp1x = paramX1 * 2 - paramX2;\n const cp1y = paramY1 * 2 - paramY2;\n\n totalLength += getCubicLength(\n lastX,\n lastY,\n cp1x,\n cp1y,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n );\n } else if (pathCommand === \"C\") {\n totalLength += getCubicLength(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n normalSegment[5] as number,\n normalSegment[6] as number,\n );\n } else if (pathCommand === \"T\") {\n paramQX = paramX1 * 2 - paramQX;\n paramQY = paramY1 * 2 - paramQY;\n totalLength += getQuadLength(\n lastX,\n lastY,\n paramQX,\n paramQY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n );\n } else if (pathCommand === \"Q\") {\n paramQX = normalSegment[1] as number;\n paramQY = normalSegment[2] as number;\n totalLength += getQuadLength(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n );\n } else if (pathCommand === \"Z\") {\n totalLength += getLineLength(lastX, lastY, mx, my);\n }\n\n // update params\n [paramX1, paramY1] = pathCommand === \"Z\"\n ? [mx, my]\n : (normalSegment.slice(-2) as PointTuple);\n [paramX2, paramY2] = pathCommand === \"C\"\n ? ([normalSegment[3], normalSegment[4]] as PointTuple)\n : pathCommand === \"S\"\n ? ([normalSegment[1], normalSegment[2]] as PointTuple)\n : [paramX1, paramY1];\n });\n\n return totalLength;\n};\n\nexport default getTotalLength;\n","import type { PathArray, PathSegment } from \"../types\";\nimport type { SegmentProperties } from \"../interface\";\nimport parsePathString from \"../parser/parsePathString\";\nimport getTotalLength from \"./getTotalLength\";\n\n/**\n * Returns the segment, its index and length as well as\n * the length to that segment at a given length in a path.\n *\n * @param pathInput target `pathArray`\n * @param distance the given length\n * @returns the requested properties\n */\nconst getPropertiesAtLength = (\n pathInput: string | PathArray,\n distance?: number,\n): SegmentProperties => {\n const pathArray = parsePathString(pathInput);\n\n let pathTemp = pathArray.slice(0) as PathArray;\n let pathLength = getTotalLength(pathTemp);\n let index = pathTemp.length - 1;\n let lengthAtSegment = 0;\n let length = 0;\n let segment = pathArray[0] as PathSegment;\n\n // If the path is empty, return 0.\n if (index <= 0 || !distance || !Number.isFinite(distance)) {\n return {\n segment,\n index: 0,\n length,\n lengthAtSegment,\n };\n }\n\n if (distance >= pathLength) {\n pathTemp = pathArray.slice(0, -1) as PathArray;\n lengthAtSegment = getTotalLength(pathTemp);\n length = pathLength - lengthAtSegment;\n segment = pathArray[index];\n return {\n segment,\n index,\n length,\n lengthAtSegment,\n };\n }\n\n const segments = [] as SegmentProperties[];\n while (index > 0) {\n segment = pathTemp[index];\n pathTemp = pathTemp.slice(0, -1) as PathArray;\n lengthAtSegment = getTotalLength(pathTemp);\n length = pathLength - lengthAtSegment;\n pathLength = lengthAtSegment;\n\n segments.push({\n segment,\n index,\n length,\n lengthAtSegment,\n });\n index -= 1;\n }\n\n return segments.find(({ lengthAtSegment: l }) =>\n l <= distance\n ) as SegmentProperties;\n};\n\nexport default getPropertiesAtLength;\n","import type { PathArray, Point } from \"../types\";\nimport type { PointProperties } from \"../interface\";\nimport getPointAtLength from \"./getPointAtLength\";\nimport getPropertiesAtLength from \"./getPropertiesAtLength\";\nimport getTotalLength from \"./getTotalLength\";\nimport parsePathString from \"../parser/parsePathString\";\nimport normalizePath from \"../process/normalizePath\";\n\n/**\n * Returns the point and segment in path closest to a given point as well as\n * the distance to the path stroke.\n *\n * @see https://bl.ocks.org/mbostock/8027637\n *\n * @param pathInput target `pathArray`\n * @param point the given point\n * @returns the requested properties\n */\nconst getPropertiesAtPoint = (\n pathInput: string | PathArray,\n point: Point,\n): PointProperties => {\n const path = parsePathString(pathInput);\n const normalPath = normalizePath(path);\n const pathLength = getTotalLength(normalPath);\n const distanceTo = (p: Point) => {\n const dx = p.x - point.x;\n const dy = p.y - point.y;\n return dx * dx + dy * dy;\n };\n let precision = 8;\n let scan: Point;\n let closest = { x: 0, y: 0 }; // make TS happy\n let scanDistance = 0;\n let bestLength = 0;\n let bestDistance = Infinity;\n\n // linear scan for coarse approximation\n for (let scanLength = 0; scanLength <= pathLength; scanLength += precision) {\n scan = getPointAtLength(normalPath, scanLength);\n scanDistance = distanceTo(scan);\n\n if (scanDistance < bestDistance) {\n closest = scan;\n bestLength = scanLength;\n bestDistance = scanDistance;\n }\n }\n\n // binary search for precise estimate\n precision /= 2;\n let before: { x: number; y: number };\n let after: { x: number; y: number };\n let beforeLength = 0;\n let afterLength = 0;\n let beforeDistance = 0;\n let afterDistance = 0;\n\n while (precision > 0.000001) {\n beforeLength = bestLength - precision;\n before = getPointAtLength(normalPath, beforeLength);\n beforeDistance = distanceTo(before);\n afterLength = bestLength + precision;\n after = getPointAtLength(normalPath, afterLength);\n afterDistance = distanceTo(after);\n\n if (beforeLength >= 0 && beforeDistance < bestDistance) {\n closest = before;\n bestLength = beforeLength;\n bestDistance = beforeDistance;\n } else if (afterLength <= pathLength && afterDistance < bestDistance) {\n closest = after;\n bestLength = afterLength;\n bestDistance = afterDistance;\n } else {\n precision /= 2;\n }\n if (precision < 0.00001) break;\n }\n\n const segment = getPropertiesAtLength(path, bestLength);\n const distance = Math.sqrt(bestDistance);\n\n return { closest, distance, segment };\n};\n\nexport default getPropertiesAtPoint;\n","import type { PathArray } from \"../types\";\nimport getPropertiesAtPoint from \"./getPropertiesAtPoint\";\n\n/**\n * Returns the point in path closest to a given point.\n *\n * @param pathInput target `pathArray`\n * @param point the given point\n * @returns the best match\n */\nconst getClosestPoint = (\n pathInput: string | PathArray,\n point: { x: number; y: number },\n) => {\n return getPropertiesAtPoint(pathInput, point).closest;\n};\n\nexport default getClosestPoint;\n","import pathToCurve from \"../convert/pathToCurve\";\nimport type { PathArray, PointTuple } from \"../types\";\n\n/**\n * Returns the area of a single cubic-bezier segment.\n *\n * http://objectmix.com/graphics/133553-area-closed-bezier-curve.html\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the area of the cubic-bezier segment\n */\nconst getCubicSegArea = (\n x1: number,\n y1: number,\n c1x: number,\n c1y: number,\n c2x: number,\n c2y: number,\n x2: number,\n y2: number,\n) => {\n return (\n (3 *\n ((y2 - y1) * (c1x + c2x) -\n (x2 - x1) * (c1y + c2y) +\n c1y * (x1 - c2x) -\n c1x * (y1 - c2y) +\n y2 * (c2x + x1 / 3) -\n x2 * (c2y + y1 / 3))) /\n 20\n );\n};\n\n/**\n * Returns the area of a shape.\n *\n * @author Jürg Lehni & Jonathan Puckey\n *\n * @see https://github.com/paperjs/paper.js/blob/develop/src/path/Path.js\n *\n * @param path the shape `pathArray`\n * @returns the length of the cubic-bezier segment\n */\nconst getPathArea = (path: PathArray) => {\n let x = 0;\n let y = 0;\n let len = 0;\n\n return pathToCurve(path)\n .map((seg) => {\n switch (seg[0]) {\n case \"M\":\n [, x, y] = seg;\n return 0;\n default:\n len = getCubicSegArea(\n x,\n y,\n seg[1],\n seg[2],\n seg[3],\n seg[4],\n seg[5],\n seg[6],\n );\n [x, y] = seg.slice(-2) as PointTuple;\n return len;\n }\n })\n .reduce((a, b) => a + b, 0);\n};\nexport default getPathArea;\n","import getPathArea from \"./getPathArea\";\nimport pathToCurve from \"../convert/pathToCurve\";\nimport type { PathArray } from \"../types\";\n\n/**\n * Check if a path is drawn clockwise and returns true if so,\n * false otherwise.\n *\n * @param path the path string or `pathArray`\n * @returns true when clockwise or false if not\n */\nconst getDrawDirection = (path: string | PathArray) => {\n return getPathArea(pathToCurve(path)) >= 0;\n};\n\nexport default getDrawDirection;\n","import iterate from \"../process/iterate\";\nimport { PathBBox } from \"../interface\";\nimport { LSegment, MSegment, PathArray, PointTuple } from \"../types\";\nimport { getLineBBox } from \"../math/lineTools\";\nimport { getArcBBox } from \"../math/arcTools\";\nimport { getCubicBBox } from \"../math/cubicTools\";\nimport { getQuadBBox } from \"../math/quadTools\";\nimport parsePathString from \"../parser/parsePathString\";\nimport absolutizeSegment from \"../process/absolutizeSegment\";\n\nconst getPathBBox = (pathInput: PathArray | string) => {\n if (!pathInput) {\n return {\n x: 0,\n y: 0,\n width: 0,\n height: 0,\n x2: 0,\n y2: 0,\n cx: 0,\n cy: 0,\n cz: 0,\n };\n }\n\n const path = parsePathString(pathInput);\n let pathCommand = \"M\";\n let mx = 0;\n let my = 0;\n const { max, min } = Math;\n let xMin = Infinity;\n let yMin = Infinity;\n let xMax = -Infinity;\n let yMax = -Infinity;\n let minX = 0;\n let minY = 0;\n let maxX = 0;\n let maxY = 0;\n let paramX1 = 0;\n let paramY1 = 0;\n let paramX2 = 0;\n let paramY2 = 0;\n let paramQX = 0;\n let paramQY = 0;\n\n iterate(path, (seg, index, lastX, lastY) => {\n [pathCommand] = seg;\n const absCommand = pathCommand.toUpperCase();\n const isRelative = absCommand !== pathCommand;\n const absoluteSegment = isRelative\n ? absolutizeSegment(seg, index, lastX, lastY)\n : (seg.slice(0) as typeof seg);\n\n const normalSegment = absCommand === \"V\"\n ? ([\"L\", lastX, absoluteSegment[1]] as LSegment)\n : absCommand === \"H\"\n ? ([\"L\", absoluteSegment[1], lastY] as LSegment)\n : absoluteSegment;\n\n [pathCommand] = normalSegment;\n\n if (!\"TQ\".includes(absCommand)) {\n // optional but good to be cautious\n paramQX = 0;\n paramQY = 0;\n }\n\n // this segment is always ZERO\n /* istanbul ignore else @preserve */\n if (pathCommand === \"M\") {\n [, mx, my] = normalSegment as MSegment;\n minX = mx;\n minY = my;\n maxX = mx;\n maxY = my;\n } else if (pathCommand === \"L\") {\n [minX, minY, maxX, maxY] = getLineBBox(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n );\n } else if (pathCommand === \"A\") {\n [minX, minY, maxX, maxY] = getArcBBox(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n normalSegment[5] as number,\n normalSegment[6] as number,\n normalSegment[7] as number,\n );\n } else if (pathCommand === \"S\") {\n const cp1x = paramX1 * 2 - paramX2;\n const cp1y = paramY1 * 2 - paramY2;\n\n [minX, minY, maxX, maxY] = getCubicBBox(\n lastX,\n lastY,\n cp1x,\n cp1y,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n );\n } else if (pathCommand === \"C\") {\n [minX, minY, maxX, maxY] = getCubicBBox(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n normalSegment[5] as number,\n normalSegment[6] as number,\n );\n } else if (pathCommand === \"T\") {\n paramQX = paramX1 * 2 - paramQX;\n paramQY = paramY1 * 2 - paramQY;\n [minX, minY, maxX, maxY] = getQuadBBox(\n lastX,\n lastY,\n paramQX,\n paramQY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n );\n } else if (pathCommand === \"Q\") {\n paramQX = normalSegment[1] as number;\n paramQY = normalSegment[2] as number;\n [minX, minY, maxX, maxY] = getQuadBBox(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n );\n } else if (pathCommand === \"Z\") {\n [minX, minY, maxX, maxY] = getLineBBox(lastX, lastY, mx, my);\n }\n xMin = min(minX, xMin);\n yMin = min(minY, yMin);\n xMax = max(maxX, xMax);\n yMax = max(maxY, yMax);\n\n // update params\n [paramX1, paramY1] = pathCommand === \"Z\"\n ? [mx, my]\n : (normalSegment.slice(-2) as PointTuple);\n [paramX2, paramY2] = pathCommand === \"C\"\n ? ([normalSegment[3], normalSegment[4]] as PointTuple)\n : pathCommand === \"S\"\n ? ([normalSegment[1], normalSegment[2]] as PointTuple)\n : [paramX1, paramY1];\n });\n\n const width = xMax - xMin;\n const height = yMax - yMin;\n\n return {\n width,\n height,\n x: xMin,\n y: yMin,\n x2: xMax,\n y2: yMax,\n cx: xMin + width / 2,\n cy: yMin + height / 2,\n // an estimated guess\n cz: Math.max(width, height) + Math.min(width, height) / 2,\n } satisfies PathBBox;\n};\n\nexport default getPathBBox;\n","import type { PathArray, PathSegment } from \"../types\";\nimport getPropertiesAtLength from \"./getPropertiesAtLength\";\n\n/**\n * Returns the segment at a given length.\n *\n * @param pathInput the target `pathArray`\n * @param distance the distance in path to look at\n * @returns the requested segment\n */\nconst getSegmentAtLength = (\n pathInput: string | PathArray,\n distance?: number,\n): PathSegment | undefined => {\n return getPropertiesAtLength(pathInput, distance).segment;\n};\n\nexport default getSegmentAtLength;\n","import type { SegmentProperties } from \"../interface\";\nimport type { PathArray } from \"../types\";\nimport getPropertiesAtPoint from \"./getPropertiesAtPoint\";\n\n/**\n * Returns the path segment which contains a given point.\n *\n * @param path the `pathArray` to look into\n * @param point the point of the shape to look for\n * @returns the requested segment\n */\nconst getSegmentOfPoint = (\n path: string | PathArray,\n point: { x: number; y: number },\n): SegmentProperties | undefined => {\n return getPropertiesAtPoint(path, point).segment;\n};\nexport default getSegmentOfPoint;\n","import type { PathArray, PathSegment, RelativeCommand } from \"../types\";\nimport paramsCount from \"../parser/paramsCount\";\n\n/**\n * Iterates an array to check if it's an actual `pathArray`.\n *\n * @param path the `pathArray` to be checked\n * @returns iteration result\n */\nconst isPathArray = (path: unknown): path is PathArray => {\n return (\n Array.isArray(path) &&\n path.every((seg: PathSegment) => {\n const lk = seg[0].toLowerCase() as RelativeCommand;\n return (\n paramsCount[lk] === seg.length - 1 &&\n \"achlmqstvz\".includes(lk) &&\n (seg.slice(1) as unknown[]).every(Number.isFinite)\n );\n }) &&\n path.length > 0\n );\n};\nexport default isPathArray;\n","import type { AbsoluteArray } from \"../types\";\nimport isPathArray from \"./isPathArray\";\n\n/**\n * Iterates an array to check if it's a `pathArray`\n * with all absolute values.\n *\n * @param path the `pathArray` to be checked\n * @returns iteration result\n */\nconst isAbsoluteArray = (path: unknown): path is AbsoluteArray => {\n return (\n isPathArray(path) &&\n // `isPathArray` also checks if it's `Array`\n path.every(([x]) => x === x.toUpperCase())\n );\n};\nexport default isAbsoluteArray;\n","import type { NormalArray } from \"../types\";\nimport isAbsoluteArray from \"./isAbsoluteArray\";\n\n/**\n * Iterates an array to check if it's a `pathArray`\n * with all segments are in non-shorthand notation\n * with absolute values.\n *\n * @param {string | SVGPath.pathArray} path the `pathArray` to be checked\n * @returns {boolean} iteration result\n */\nconst isNormalizedArray = (path: unknown): path is NormalArray => {\n // `isAbsoluteArray` also checks if it's `Array`\n return isAbsoluteArray(path) && path.every(([pc]) => \"ACLMQZ\".includes(pc));\n};\nexport default isNormalizedArray;\n","import { CurveArray } from \"../types\";\nimport isNormalizedArray from \"./isNormalizedArray\";\n\n/**\n * Iterates an array to check if it's a `pathArray`\n * with all C (cubic bezier) segments.\n *\n * @param path the `Array` to be checked\n * @returns iteration result\n */\nconst isCurveArray = (path: unknown): path is CurveArray => {\n // `isPathArray` also checks if it's `Array`\n return isNormalizedArray(path) && path.every(([pc]) => \"MC\".includes(pc));\n};\nexport default isCurveArray;\n","import type { PathArray } from \"../types\";\nimport getPropertiesAtPoint from \"./getPropertiesAtPoint\";\nimport DISTANCE_EPSILON from \"./distanceEpsilon\";\n\n/**\n * Checks if a given point is in the stroke of a path.\n *\n * @param pathInput target path\n * @param point the given `{x,y}` point\n * @returns the query result\n */\nconst isPointInStroke = (\n pathInput: string | PathArray,\n point: { x: number; y: number },\n) => {\n const { distance } = getPropertiesAtPoint(pathInput, point);\n return Math.abs(distance) < DISTANCE_EPSILON; // 0.01 might be more permissive\n};\nexport default isPointInStroke;\n","import type { RelativeArray } from \"../types\";\nimport isPathArray from \"./isPathArray\";\n\n/**\n * Iterates an array to check if it's a `pathArray`\n * with relative values.\n *\n * @param path the `pathArray` to be checked\n * @returns iteration result\n */\nconst isRelativeArray = (path: unknown): path is RelativeArray => {\n return (\n isPathArray(path) &&\n // `isPathArray` checks if it's `Array`\n path.slice(1).every(([pc]) => pc === pc.toLowerCase())\n );\n};\nexport default isRelativeArray;\n","import scanSegment from \"../parser/scanSegment\";\nimport skipSpaces from \"../parser/skipSpaces\";\nimport PathParser from \"../parser/pathParser\";\n\n/**\n * Parses a path string value to determine its validity\n * then returns true if it's valid or false otherwise.\n *\n * @param pathString the path string to be parsed\n * @returns the path string validity\n */\nconst isValidPath = (pathString: string) => {\n if (typeof pathString !== \"string\" || !pathString.length) {\n return false;\n }\n\n const path = new PathParser(pathString);\n\n skipSpaces(path);\n\n while (path.index < path.max && !path.err.length) {\n scanSegment(path);\n }\n\n return !path.err.length && \"mM\".includes(path.segments[0][0]);\n};\nexport default isValidPath;\n","import type { ShapeParams } from \"../interface\";\n\n/**\n * Supported shapes and their specific parameters.\n */\nconst shapeParams: ShapeParams = {\n line: [\"x1\", \"y1\", \"x2\", \"y2\"],\n circle: [\"cx\", \"cy\", \"r\"],\n ellipse: [\"cx\", \"cy\", \"rx\", \"ry\"],\n rect: [\"width\", \"height\", \"x\", \"y\", \"rx\", \"ry\"],\n polygon: [\"points\"],\n polyline: [\"points\"],\n glyph: [\"d\"],\n};\n\nexport default shapeParams;\n","const isElement = (node?: unknown): node is Element =>\n node !== undefined && node !== null &&\n typeof node === \"object\" &&\n (node as Node).nodeType === 1; // ELEMENT_NODE\n\nexport default isElement;\n","import type {\n CircleAttr,\n EllipseAttr,\n GlyphAttr,\n LineAttr,\n PolyAttr,\n RectAttr,\n ShapeParams,\n} from \"../interface\";\nimport type { PathArray, PathSegment, ShapeOps, ShapeTypes } from \"../types\";\nimport error from \"../parser/error\";\nimport parsePathString from \"../parser/parsePathString\";\nimport shapeParams from \"./shapeParams\";\nimport isPathArray from \"./isPathArray\";\nimport isElement from \"./isElement\";\n\n/**\n * Returns a new `pathArray` from line attributes.\n *\n * @param attr shape configuration\n * @returns a new line `pathArray`\n */\nexport const getLinePath = (attr: LineAttr): PathArray => {\n let { x1, y1, x2, y2 } = attr;\n [x1, y1, x2, y2] = [x1, y1, x2, y2].map((a) => +a);\n return [\n [\"M\", x1, y1],\n [\"L\", x2, y2],\n ];\n};\n\n/**\n * Returns a new `pathArray` like from polyline/polygon attributes.\n *\n * @param attr shape configuration\n * @return a new polygon/polyline `pathArray`\n */\nexport const getPolyPath = (attr: PolyAttr): PathArray => {\n const pathArray = [] as PathSegment[];\n const points = (attr.points || \"\")\n .trim()\n .split(/[\\s|,]/)\n .map((a) => +a);\n\n let index = 0;\n while (index < points.length) {\n pathArray.push([index ? \"L\" : \"M\", points[index], points[index + 1]]);\n index += 2;\n }\n\n return (attr.type === \"polygon\"\n ? [...pathArray, [\"z\"]]\n : pathArray) as PathArray;\n};\n\n/**\n * Returns a new `pathArray` from circle attributes.\n *\n * @param attr shape configuration\n * @return a circle `pathArray`\n */\nexport const getCirclePath = (attr: CircleAttr): PathArray => {\n let { cx, cy, r } = attr;\n [cx, cy, r] = [cx, cy, r].map((a) => +a);\n\n return [\n [\"M\", cx - r, cy],\n [\"a\", r, r, 0, 1, 0, 2 * r, 0],\n [\"a\", r, r, 0, 1, 0, -2 * r, 0],\n ];\n};\n\n/**\n * Returns a new `pathArray` from ellipse attributes.\n *\n * @param attr shape configuration\n * @return an ellipse `pathArray`\n */\nexport const getEllipsePath = (attr: EllipseAttr): PathArray => {\n let { cx, cy } = attr;\n let rx = attr.rx || 0;\n let ry = attr.ry || rx;\n [cx, cy, rx, ry] = [cx, cy, rx, ry].map((a) => +a);\n\n return [\n [\"M\", cx - rx, cy],\n [\"a\", rx, ry, 0, 1, 0, 2 * rx, 0],\n [\"a\", rx, ry, 0, 1, 0, -2 * rx, 0],\n ];\n};\n\n/**\n * Returns a new `pathArray` like from rect attributes.\n *\n * @param attr object with properties above\n * @return a new `pathArray` from `` attributes\n */\nexport const getRectanglePath = (attr: RectAttr): PathArray => {\n const x = +attr.x || 0;\n const y = +attr.y || 0;\n const w = +attr.width;\n const h = +attr.height;\n let rx = +(attr.rx || 0);\n let ry = +(attr.ry || rx);\n\n // Validity checks from http://www.w3.org/TR/SVG/shapes.html#RectElement:\n if (rx || ry) {\n // rx = !rx ? ry : rx;\n // ry = !ry ? rx : ry;\n\n /* istanbul ignore else @preserve */\n if (rx * 2 > w) rx -= (rx * 2 - w) / 2;\n /* istanbul ignore else @preserve */\n if (ry * 2 > h) ry -= (ry * 2 - h) / 2;\n\n return [\n [\"M\", x + rx, y],\n [\"h\", w - rx * 2],\n [\"s\", rx, 0, rx, ry],\n [\"v\", h - ry * 2],\n [\"s\", 0, ry, -rx, ry],\n [\"h\", -w + rx * 2],\n [\"s\", -rx, 0, -rx, -ry],\n [\"v\", -h + ry * 2],\n [\"s\", 0, -ry, rx, -ry],\n ];\n }\n\n return [[\"M\", x, y], [\"h\", w], [\"v\", h], [\"H\", x], [\"Z\"]];\n};\n\n/**\n * Returns a new `pathArray` created from attributes of a ``, ``,\n * ``, ``, ``, ``, or ``.\n *\n * It can also work with an options object, see the type below\n * @see ShapeOps\n *\n * @param element target shape\n * @return the newly created `` element\n */\nconst shapeToPathArray = (\n element: ShapeTypes | ShapeOps,\n) => {\n const supportedShapes = Object.keys(shapeParams) as (keyof ShapeParams)[];\n const targetIsElement = isElement(element);\n const tagName = targetIsElement ? element.tagName : null;\n\n if (tagName && [...supportedShapes, \"path\"].every((s) => tagName !== s)) {\n throw TypeError(`${error}: \"${tagName}\" is not SVGElement`);\n }\n\n const type =\n (targetIsElement ? tagName : (element as ShapeOps).type) as ShapeOps[\n \"type\"\n ];\n const shapeAttrs = shapeParams[type] as string[];\n const config = { type } as Record;\n\n if (targetIsElement) {\n shapeAttrs.forEach((p) => {\n config[p] = element.getAttribute(p) as string;\n });\n } else {\n Object.assign(config, element);\n }\n\n // set d\n let pathArray = [] as unknown as PathArray;\n\n /* istanbul ignore else */\n if (type === \"circle\") {\n pathArray = getCirclePath(config as unknown as CircleAttr);\n } else if (type === \"ellipse\") {\n pathArray = getEllipsePath(config as unknown as EllipseAttr);\n } else if ([\"polyline\", \"polygon\"].includes(type)) {\n pathArray = getPolyPath(config as unknown as PolyAttr);\n } else if (type === \"rect\") {\n pathArray = getRectanglePath(config as unknown as RectAttr);\n } else if (type === \"line\") {\n pathArray = getLinePath(config as unknown as LineAttr);\n } else if ([\"glyph\", \"path\"].includes(type)) {\n pathArray = parsePathString(\n targetIsElement\n ? element.getAttribute(\"d\") || /* istanbul ignore next @preserve */ \"\"\n : (element as GlyphAttr).d || \"\",\n );\n }\n\n // replace target element\n if (isPathArray(pathArray) && pathArray.length) {\n return pathArray;\n }\n return false;\n};\nexport default shapeToPathArray;\n","import type { ShapeParams } from \"../interface\";\nimport type { ShapeOps, ShapeTypes } from \"../types\";\nimport pathToString from \"../convert/pathToString\";\nimport defaultOptions from \"../options/options\";\nimport error from \"../parser/error\";\nimport isValidPath from \"./isValidPath\";\nimport isElement from \"./isElement\";\nimport shapeToPathArray from \"./shapeToPathArray\";\nimport shapeParams from \"./shapeParams\";\n\n/**\n * Returns a new `` element created from attributes of a ``, ``,\n * ``, ``, ``, `` or ``. If `replace` parameter\n * is `true`, it will replace the target. The default `ownerDocument` is your current\n * `document` browser page, if you want to use in server-side using `jsdom`, you can\n * pass the `jsdom` `document` to `ownDocument`.\n *\n * It can also work with an options object, see the type below\n * @see ShapeOps\n *\n * The newly created `` element keeps all non-specific\n * attributes like `class`, `fill`, etc.\n *\n * @param element target shape\n * @param replace option to replace target\n * @param ownerDocument document for create element\n * @return the newly created `` element\n */\nconst shapeToPath = (\n element: ShapeTypes | ShapeOps,\n replace?: boolean,\n ownerDocument?: Document,\n): SVGPathElement | false => {\n const doc = ownerDocument || document;\n const supportedShapes = Object.keys(shapeParams) as (keyof ShapeParams)[];\n const targetIsElement = isElement(element);\n const tagName = targetIsElement ? element.tagName : null;\n\n if (tagName === \"path\") {\n throw TypeError(`${error}: \"${tagName}\" is already SVGPathElement`);\n }\n if (tagName && supportedShapes.every((s) => tagName !== s)) {\n throw TypeError(`${error}: \"${tagName}\" is not SVGElement`);\n }\n\n const path = doc.createElementNS(\"http://www.w3.org/2000/svg\", \"path\");\n const type =\n (targetIsElement ? tagName : (element as ShapeOps).type) as ShapeOps[\n \"type\"\n ];\n const shapeAttrs = shapeParams[type] as string[];\n const config = { type } as Record;\n\n // set d\n const round = defaultOptions.round as number;\n const pathArray = shapeToPathArray(element);\n const description = pathArray && pathArray.length\n ? pathToString(pathArray, round)\n : \"\";\n\n if (targetIsElement) {\n shapeAttrs.forEach((p) => {\n config[p] = element.getAttribute(p) as string;\n });\n // set no-specific shape attributes: fill, stroke, etc\n Object.values(element.attributes).forEach(({ name, value }) => {\n if (!shapeAttrs.includes(name)) path.setAttribute(name, value);\n });\n } else {\n Object.assign(config, element);\n // set no-specific shape attributes: fill, stroke, etc\n Object.keys(config).forEach((k) => {\n if (!shapeAttrs.includes(k) && k !== \"type\") {\n path.setAttribute(\n k.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`),\n config[k],\n );\n }\n });\n }\n\n // replace target element\n if (isValidPath(description)) {\n path.setAttribute(\"d\", description);\n if (replace && targetIsElement) {\n element.before(path, element);\n element.remove();\n }\n return path;\n }\n return false;\n};\n\nexport default shapeToPath;\n","import CSSMatrix from \"@thednp/dommatrix\";\n// import type { TransformObject } from '../interface';\nimport type { TransformObjectValues } from \"../types\";\n\n/**\n * Returns a transformation matrix to apply to `` elements.\n *\n * @see TransformObjectValues\n *\n * @param transform the `transformObject`\n * @returns a new transformation matrix\n */\nconst getSVGMatrix = (transform: TransformObjectValues): CSSMatrix => {\n let matrix = new CSSMatrix();\n const { origin } = transform;\n const [originX, originY] = origin as [number, number, number];\n const { translate } = transform;\n const { rotate } = transform;\n const { skew } = transform;\n const { scale } = transform;\n\n // set translate\n if (\n Array.isArray(translate) &&\n translate.length >= 2 &&\n translate.every((x) => !Number.isNaN(+x)) &&\n translate.some((x) => x !== 0)\n ) {\n matrix = matrix.translate(...(translate as [number, number, number?]));\n } else if (typeof translate === \"number\" && !Number.isNaN(translate)) {\n matrix = matrix.translate(translate);\n }\n\n if (rotate || skew || scale) {\n // set SVG transform-origin, always defined\n matrix = matrix.translate(originX, originY);\n\n // set rotation\n if (\n Array.isArray(rotate) &&\n rotate.length >= 2 &&\n rotate.every((x) => !Number.isNaN(+x)) &&\n rotate.some((x) => x !== 0)\n ) {\n matrix = matrix.rotate(...(rotate as [number, number, number?]));\n } else if (typeof rotate === \"number\" && !Number.isNaN(rotate)) {\n matrix = matrix.rotate(rotate);\n }\n\n // set skew(s)\n if (\n Array.isArray(skew) && skew.length === 2 && skew.every((x) =>\n !Number.isNaN(+x)\n ) && skew.some((x) => x !== 0)\n ) {\n matrix = skew[0] ? matrix.skewX(skew[0]) : matrix;\n matrix = skew[1] ? matrix.skewY(skew[1]) : matrix;\n } else if (typeof skew === \"number\" && !Number.isNaN(skew)) {\n matrix = matrix.skewX(skew);\n }\n\n // set scale\n if (\n Array.isArray(scale) && scale.length >= 2 && scale.every((x) =>\n !Number.isNaN(+x)\n ) && scale.some((x) => x !== 1)\n ) {\n matrix = matrix.scale(...(scale as [number, number, number?]));\n } else if (typeof scale === \"number\" && !Number.isNaN(scale)) {\n matrix = matrix.scale(scale);\n }\n // set SVG transform-origin\n matrix = matrix.translate(-originX, -originY);\n }\n\n return matrix;\n};\nexport default getSVGMatrix;\n","import defaultOptions from \"../options/options\";\nimport type { ParserParams } from \"../interface\";\nimport roundTo from \"../math/roundTo\";\nimport type {\n AbsoluteSegment,\n NormalSegment,\n PathCommand,\n ShortSegment,\n SSegment,\n TSegment,\n} from \"../types\";\n\n/**\n * Shorten a single segment of a `pathArray` object.\n *\n * @param segment the `absoluteSegment` object\n * @param normalSegment the `normalSegment` object\n * @param params the coordinates of the previous segment\n * @param prevCommand the path command of the previous segment\n * @returns the shortened segment\n */\nconst shortenSegment = (\n segment: AbsoluteSegment,\n normalSegment: NormalSegment,\n params: ParserParams,\n prevCommand: PathCommand,\n): ShortSegment => {\n const [pathCommand] = segment;\n const { round: defaultRound } = defaultOptions;\n const round = typeof defaultRound === \"number\"\n ? defaultRound\n : /* istanbul ignore next */ 4;\n const normalValues = normalSegment.slice(1) as number[];\n const { x1, y1, x2, y2, x, y } = params;\n const [nx, ny] = normalValues.slice(-2);\n const result = segment;\n\n if (!\"TQ\".includes(pathCommand)) {\n // optional but good to be cautious\n params.qx = null;\n params.qy = null;\n }\n\n if (pathCommand === \"L\") {\n if (roundTo(x, round) === roundTo(nx, round)) {\n return [\"V\", ny];\n } else if (roundTo(y, round) === roundTo(ny, round)) {\n return [\"H\", nx];\n }\n } else if (pathCommand === \"C\") {\n const [nx1, ny1] = normalValues;\n params.x1 = nx1;\n params.y1 = ny1;\n\n if (\n \"CS\".includes(prevCommand) &&\n ((roundTo(nx1, round) === roundTo(x1 * 2 - x2, round) &&\n roundTo(ny1, round) === roundTo(y1 * 2 - y2, round)) ||\n (roundTo(x1, round) === roundTo(x2 * 2 - x, round) &&\n roundTo(y1, round) === roundTo(y2 * 2 - y, round)))\n ) {\n return [\n \"S\",\n normalValues[2],\n normalValues[3],\n normalValues[4],\n normalValues[5],\n ] as SSegment;\n }\n } else if (pathCommand === \"Q\") {\n const [qx, qy] = normalValues;\n params.qx = qx;\n params.qy = qy;\n\n if (\n \"QT\".includes(prevCommand) &&\n roundTo(qx, round) === roundTo(x1 * 2 - x2, round) &&\n roundTo(qy, round) === roundTo(y1 * 2 - y2, round)\n ) {\n return [\"T\", normalValues[2], normalValues[3]] as TSegment;\n }\n }\n\n // ['V', 'H', 'S', 'T', 'Z'].includes(pathCommand)\n return result as ShortSegment;\n};\n\nexport default shortenSegment;\n","import type { PathCommand, PathSegment } from \"../types\";\nimport roundTo from \"../math/roundTo\";\n\nconst roundSegment = (\n segment: T,\n roundOption: number,\n) => {\n const values = (segment.slice(1) as number[]).map((n) =>\n roundTo(n, roundOption)\n );\n return [segment[0] as PathCommand | number].concat(values) as T;\n};\n\nexport default roundSegment;\n","import type { AbsoluteSegment, PathArray, PathCommand } from \"../types\";\nimport pathToAbsolute from \"../convert/pathToAbsolute\";\nimport shortenSegment from \"./shortenSegment\";\nimport paramsParser from \"../parser/paramsParser\";\nimport iterate from \"./iterate\";\nimport normalizeSegment from \"./normalizeSegment\";\nimport relativizeSegment from \"./relativizeSegment\";\nimport roundSegment from \"./roundSegment\";\n\n/**\n * Optimizes a `pathArray` object:\n * * convert segments to shorthand if possible\n * * select shortest segments from absolute and relative `pathArray`s\n *\n * @param pathInput a string or `pathArray`\n * @param roundOption the amount of decimals to round values to\n * @returns the optimized `pathArray`\n */\nconst optimizePath = (pathInput: PathArray, roundOption?: number) => {\n const path = pathToAbsolute(pathInput);\n // allow for ZERO decimals or use an aggressive value of 2\n const round = typeof roundOption === \"number\" && roundOption >= 0\n ? roundOption\n : /* istanbul ignore next @preserve */ 2;\n // this utility overrides the iterator params\n const optimParams = { ...paramsParser };\n\n const allPathCommands = [] as PathCommand[];\n let pathCommand = \"M\" as PathCommand;\n let prevCommand = \"Z\" as PathCommand;\n\n return iterate(path, (seg, i, lastX, lastY) => {\n optimParams.x = lastX;\n optimParams.y = lastY;\n const normalizedSegment = normalizeSegment(seg, optimParams);\n let result = seg;\n [pathCommand] = seg;\n\n // Save current path command\n allPathCommands[i] = pathCommand;\n if (i) {\n // Get previous path command for `shortenSegment`\n prevCommand = allPathCommands[i - 1];\n const shortSegment = shortenSegment(\n seg as AbsoluteSegment,\n normalizedSegment,\n optimParams,\n prevCommand,\n );\n const absSegment = roundSegment(shortSegment, round);\n const absString = absSegment.join(\"\");\n const relativeSegment = relativizeSegment(shortSegment, i, lastX, lastY);\n const relSegment = roundSegment(relativeSegment, round);\n const relString = relSegment.join(\"\");\n result = absString.length < relString.length ? absSegment : relSegment;\n }\n\n const seglen = normalizedSegment.length;\n optimParams.x1 = +normalizedSegment[seglen - 2];\n optimParams.y1 = +normalizedSegment[seglen - 1];\n optimParams.x2 = +normalizedSegment[seglen - 4] || optimParams.x1;\n optimParams.y2 = +normalizedSegment[seglen - 3] || optimParams.y1;\n\n return result;\n });\n};\n\nexport default optimizePath;\n","import CSSMatrix from \"@thednp/dommatrix\";\nimport { type PointTuple } from \"../types\";\n\n/**\n * Transforms a specified point using a matrix, returning a new\n * Tuple *Object* comprising of the transformed point.\n * Neither the matrix nor the original point are altered.\n *\n * @copyright thednp © 2021\n *\n * @param cssm CSSMatrix instance\n * @param v Tuple\n * @return the resulting Tuple\n */\nconst translatePoint = (\n cssm: CSSMatrix,\n v: [number, number, number, number],\n): [number, number, number, number] => {\n let m = CSSMatrix.Translate(v[0], v[1], v[2]);\n\n [, , , m.m44] = v;\n m = cssm.multiply(m);\n\n return [m.m41, m.m42, m.m43, m.m44];\n};\n\n/**\n * Returns the [x,y] projected coordinates for a given an [x,y] point\n * and an [x,y,z] perspective origin point.\n *\n * Equation found here =>\n * http://en.wikipedia.org/wiki/3D_projection#Diagram\n * Details =>\n * https://stackoverflow.com/questions/23792505/predicted-rendering-of-css-3d-transformed-pixel\n *\n * @param m the transformation matrix\n * @param point2D the initial [x,y] coordinates\n * @param origin the [x,y,z] transform origin\n * @returns the projected [x,y] coordinates\n */\nconst projection2d = (\n m: CSSMatrix,\n point2D: PointTuple,\n origin: [number, number, number],\n): PointTuple => {\n const [originX, originY, originZ] = origin;\n const [x, y, z] = translatePoint(m, [point2D[0], point2D[1], 0, 1]);\n\n const relativePositionX = x - originX;\n const relativePositionY = y - originY;\n const relativePositionZ = z - originZ;\n\n return [\n // protect against division by ZERO\n relativePositionX * (Math.abs(originZ) / Math.abs(relativePositionZ) || 1) +\n originX,\n relativePositionY * (Math.abs(originZ) / Math.abs(relativePositionZ) || 1) +\n originY,\n ];\n};\nexport default projection2d;\n","import type { CSegment, CurveArray, MSegment, PathCommand } from \"../types\";\n\n/**\n * Reverses all segments of a `pathArray`\n * which consists of only C (cubic-bezier) path commands.\n *\n * @param path the source `pathArray`\n * @returns the reversed `pathArray`\n */\nconst reverseCurve = (path: CurveArray) => {\n const rotatedCurve = path\n .slice(1)\n .map((x, i, curveOnly) =>\n !i\n ? path[0].slice(1).concat(x.slice(1) as number[])\n : curveOnly[i - 1].slice(-2).concat(x.slice(1))\n )\n .map((x) => x.map((_, i) => x[x.length - i - 2 * (1 - (i % 2))]))\n .reverse() as (MSegment | CSegment)[];\n\n return [[\"M\" as PathCommand | number].concat(rotatedCurve[0].slice(0, 2))]\n .concat(\n rotatedCurve.map((x) => [\"C\" as PathCommand | number].concat(x.slice(2))),\n ) as CurveArray;\n};\n\nexport default reverseCurve;\n","import type {\n ASegment,\n CSegment,\n HSegment,\n MSegment,\n PathArray,\n PathSegment,\n PointTuple,\n QSegment,\n SSegment,\n TSegment,\n VSegment,\n} from \"../types\";\nimport pathToAbsolute from \"../convert/pathToAbsolute\";\nimport normalizePath from \"./normalizePath\";\nimport iterate from \"./iterate\";\n\n/**\n * Reverses all segments of a `pathArray` and returns a new `pathArray` instance\n * with absolute values.\n *\n * @param pathInput the source `pathArray`\n * @returns the reversed `pathArray`\n */\nconst reversePath = (pathInput: PathArray) => {\n const absolutePath = pathToAbsolute(pathInput);\n const normalizedPath = normalizePath(absolutePath);\n const pLen = absolutePath.length;\n const isClosed = absolutePath[pLen - 1][0] === \"Z\";\n\n const reversedPath = iterate(absolutePath, (segment, i) => {\n const normalizedSegment = normalizedPath[i];\n const prevSeg = i && absolutePath[i - 1];\n const prevCommand = prevSeg && prevSeg[0];\n const nextSeg = absolutePath[i + 1];\n const nextCommand = nextSeg && nextSeg[0];\n const [pathCommand] = segment;\n const [x, y] = normalizedPath[i ? i - 1 : pLen - 1].slice(-2) as PointTuple;\n let result = segment;\n\n switch (pathCommand) {\n case \"M\":\n result = (isClosed ? [\"Z\"] : [pathCommand, x, y]) as PathSegment;\n break;\n case \"A\":\n result = [\n pathCommand,\n segment[1],\n segment[2],\n segment[3],\n segment[4],\n segment[5] === 1 ? 0 : 1,\n x,\n y,\n ] as ASegment;\n break;\n case \"C\":\n if (nextSeg && nextCommand === \"S\") {\n result = [\"S\", segment[1], segment[2], x, y] as SSegment;\n } else {\n result = [\n pathCommand,\n segment[3],\n segment[4],\n segment[1],\n segment[2],\n x,\n y,\n ] as CSegment;\n }\n break;\n case \"S\":\n if (\n prevCommand && \"CS\".includes(prevCommand) &&\n (!nextSeg || nextCommand !== \"S\")\n ) {\n result = [\n \"C\",\n normalizedSegment[3],\n normalizedSegment[4],\n normalizedSegment[1],\n normalizedSegment[2],\n x,\n y,\n ] as CSegment;\n } else {\n result = [\n pathCommand,\n normalizedSegment[1],\n normalizedSegment[2],\n x,\n y,\n ] as SSegment;\n }\n break;\n case \"Q\":\n if (nextSeg && nextCommand === \"T\") {\n result = [\"T\", x, y] as TSegment;\n } else {\n result = [pathCommand, segment[1], segment[2], x, y] as QSegment;\n }\n break;\n case \"T\":\n if (\n prevCommand && \"QT\".includes(prevCommand) &&\n (!nextSeg || nextCommand !== \"T\")\n ) {\n result = [\n \"Q\",\n normalizedSegment[1],\n normalizedSegment[2],\n x,\n y,\n ] as QSegment;\n } else {\n result = [pathCommand, x, y] as TSegment;\n }\n break;\n case \"Z\":\n result = [\"M\", x, y] as MSegment;\n break;\n case \"H\":\n result = [pathCommand, x] as HSegment;\n break;\n case \"V\":\n result = [pathCommand, y] as VSegment;\n break;\n default:\n result = [pathCommand as typeof pathCommand | number].concat(\n segment.slice(1, -2),\n x,\n y,\n ) as PathSegment;\n }\n\n return result;\n });\n\n return (\n isClosed\n ? reversedPath.reverse()\n : [reversedPath[0] as PathSegment].concat(reversedPath.slice(1).reverse())\n ) as PathArray;\n};\n\nexport default reversePath;\n","import type { PathArray } from \"../types\";\nimport defaultOptions from \"../options/options\";\nimport iterate from \"./iterate\";\nimport roundSegment from \"./roundSegment\";\n\n/**\n * Rounds the values of a `pathArray` instance to\n * a specified amount of decimals and returns it.\n *\n * @param path the source `pathArray`\n * @param roundOption the amount of decimals to round numbers to\n * @returns the resulted `pathArray` with rounded values\n */\nconst roundPath = (path: PathArray, roundOption?: number | \"off\") => {\n let { round } = defaultOptions;\n // allow for ZERO decimals\n round = roundOption === \"off\"\n ? roundOption\n : typeof roundOption === \"number\" && roundOption >= 0\n ? roundOption\n : typeof round === \"number\" && round >= 0\n ? round\n : /* istanbul ignore next @preserve */ \"off\";\n\n /* istanbul ignore else @preserve */\n if (round === \"off\") return path.slice(0) as PathArray;\n\n return iterate(path, (segment) => {\n return roundSegment(segment, round);\n });\n};\nexport default roundPath;\n","import midPoint from \"../math/midPoint\";\nimport type { CubicSegment, PointTuple } from \"../types\";\n\n/**\n * Split a cubic-bezier segment into two.\n *\n * @param pts the cubic-bezier parameters\n * @param ratio the cubic-bezier parameters\n * @return two new cubic-bezier segments\n */\nconst splitCubic = (\n pts: number[],\n ratio = 0.5,\n): [CubicSegment, CubicSegment] => {\n const t = ratio;\n const p0 = pts.slice(0, 2) as PointTuple;\n const p1 = pts.slice(2, 4) as PointTuple;\n const p2 = pts.slice(4, 6) as PointTuple;\n const p3 = pts.slice(6, 8) as PointTuple;\n const p4 = midPoint(p0, p1, t);\n const p5 = midPoint(p1, p2, t);\n const p6 = midPoint(p2, p3, t);\n const p7 = midPoint(p4, p5, t);\n const p8 = midPoint(p5, p6, t);\n const p9 = midPoint(p7, p8, t);\n\n return [\n [\"C\", p4[0], p4[1], p7[0], p7[1], p9[0], p9[1]],\n [\"C\", p8[0], p8[1], p6[0], p6[1], p3[0], p3[1]],\n ];\n};\nexport default splitCubic;\n","import paramsParser from \"../parser/paramsParser\";\nimport type {\n AbsoluteCommand,\n HSegment,\n MSegment,\n PathArray,\n PointTuple,\n RelativeCommand,\n VSegment,\n} from \"../types\";\n\n/**\n * Split a path into an `Array` of sub-path strings.\n *\n * In the process, values are converted to absolute\n * for visual consistency.\n *\n * @param pathInput the source `pathArray`\n * @return an array with all sub-path strings\n */\nconst splitPath = (pathInput: PathArray): PathArray[] => {\n const composite = [] as PathArray[];\n let path: PathArray;\n let pi = -1;\n let x = 0;\n let y = 0;\n let mx = 0;\n let my = 0;\n const params = { ...paramsParser };\n\n pathInput.forEach((seg) => {\n const [pathCommand] = seg;\n const absCommand = pathCommand.toUpperCase() as AbsoluteCommand;\n const relCommand = pathCommand.toLowerCase() as RelativeCommand;\n const isRelative = pathCommand === relCommand;\n const values = seg.slice(1) as number[];\n\n if (absCommand === \"M\") {\n pi += 1;\n [x, y] = values as PointTuple;\n x += isRelative ? params.x : 0;\n y += isRelative ? params.y : 0;\n mx = x;\n my = y;\n path = [(isRelative ? [absCommand, mx, my] : seg) as MSegment];\n } else {\n if (absCommand === \"Z\") {\n x = mx;\n y = my;\n } else if (absCommand === \"H\") {\n [, x] = seg as HSegment;\n x += isRelative ? params.x : /* istanbul ignore next @preserve */ 0;\n } else if (absCommand === \"V\") {\n [, y] = seg as VSegment;\n y += isRelative ? params.y : /* istanbul ignore next @preserve */ 0;\n } else {\n [x, y] = seg.slice(-2) as PointTuple;\n x += isRelative ? params.x : 0;\n y += isRelative ? params.y : 0;\n }\n path.push(seg);\n }\n\n params.x = x;\n params.y = y;\n composite[pi] = path;\n });\n\n return composite;\n};\nexport default splitPath;\n","import getSVGMatrix from \"./getSVGMatrix\";\nimport projection2d from \"./projection2d\";\nimport defaultOptions from \"../options/options\";\nimport type {\n AbsoluteArray,\n AbsoluteSegment,\n CSegment,\n LSegment,\n PathArray,\n TransformObjectValues,\n} from \"../types\";\nimport type { TransformObject } from \"../interface\";\nimport iterate from \"./iterate\";\nimport parsePathString from \"../parser/parsePathString\";\nimport absolutizeSegment from \"./absolutizeSegment\";\nimport arcToCubic from \"./arcToCubic\";\n\n/**\n * Apply a 2D / 3D transformation to a `pathArray` instance.\n *\n * Since *SVGElement* doesn't support 3D transformation, this function\n * creates a 2D projection of the element.\n *\n * @param path the `pathArray` to apply transformation\n * @param transform the transform functions `Object`\n * @returns the resulted `pathArray`\n */\nconst transformPath = (\n pathInput: PathArray | string,\n transform?: Partial,\n) => {\n // last x and y transformed values\n let x = 0;\n let y = 0;\n // new x and y transformed\n let lx = 0;\n let ly = 0;\n // segment params iteration index and length\n let j = 0;\n let jj = 0;\n let pathCommand = \"M\";\n // transform uses it's own set of params\n const path = parsePathString(pathInput);\n const transformProps = transform && Object.keys(transform);\n\n // when used as a static method, invalidate somehow\n if (!transform || (transformProps && !transformProps.length)) {\n return path.slice(0) as typeof path;\n }\n\n // transform origin is extremely important\n if (!transform.origin) {\n Object.assign(transform, { origin: defaultOptions.origin });\n }\n const origin = transform.origin as [number, number, number];\n const matrixInstance = getSVGMatrix(transform as TransformObjectValues);\n\n if (matrixInstance.isIdentity) return path.slice(0) as typeof path;\n\n return iterate(path, (seg, index, lastX, lastY) => {\n [pathCommand] = seg;\n const absCommand = pathCommand.toUpperCase();\n const isRelative = absCommand !== pathCommand;\n const absoluteSegment = isRelative\n ? absolutizeSegment(seg, index, lastX, lastY)\n : (seg.slice(0) as AbsoluteSegment);\n\n let result = absCommand === \"A\"\n // ? segmentToCubic(absoluteSegment, transformParams)\n ? ([\"C\" as string | number].concat(\n arcToCubic(\n lastX,\n lastY,\n absoluteSegment[1] as number,\n absoluteSegment[2] as number,\n absoluteSegment[3] as number,\n absoluteSegment[4] as number,\n absoluteSegment[5] as number,\n absoluteSegment[6] as number,\n absoluteSegment[7] as number,\n ),\n ) as CSegment)\n : absCommand === \"V\"\n ? ([\"L\", lastX, absoluteSegment[1]] as LSegment)\n : absCommand === \"H\"\n ? ([\"L\", absoluteSegment[1], lastY] as LSegment)\n : absoluteSegment;\n\n // update pathCommand\n pathCommand = result[0];\n const isLongArc = pathCommand === \"C\" && result.length > 7;\n const tempSegment =\n (isLongArc ? result.slice(0, 7) : result.slice(0)) as AbsoluteSegment;\n\n if (isLongArc) {\n path.splice(\n index + 1,\n 0,\n [\"C\" as typeof pathCommand | number].concat(\n result.slice(7),\n ) as CSegment,\n );\n result = tempSegment as CSegment;\n }\n\n if (pathCommand === \"L\") {\n [lx, ly] = projection2d(matrixInstance, [\n (result as LSegment)[1],\n (result as LSegment)[2],\n ], origin);\n\n /* istanbul ignore else @preserve */\n if (x !== lx && y !== ly) {\n result = [\"L\", lx, ly];\n } else if (y === ly) {\n result = [\"H\", lx];\n } else if (x === lx) {\n result = [\"V\", ly];\n }\n } else {\n for (j = 1, jj = result.length; j < jj; j += 2) {\n [lx, ly] = projection2d(\n matrixInstance,\n [+result[j], +result[j + 1]],\n origin,\n );\n result[j] = lx;\n result[j + 1] = ly;\n }\n }\n // now update x and y\n x = lx;\n y = ly;\n\n return result;\n });\n};\n\nexport default transformPath;\n"],"names":["Z","z","s","t","e","p","$","E","P","y","g","n","i","r","a","l","m","h","c","u","w","o","A","M","b","X","O","d","x","Y","F","T","k","I","v","R","D","N","midPoint","ax","ay","bx","by","distanceSquareRoot","getLineLength","x1","y1","x2","y2","getPointAtLineLength","distance","point","length","getLineBBox","min","max","arcLength","rx","ry","theta","halfTheta","sinHalfTheta","cosHalfTheta","term1","term2","arcPoint","cx","cy","alpha","sin","cos","cosA","sinA","angleBetween","v0","v1","v0x","v0y","v1x","v1y","getArcProps","RX","RY","angle","LAF","SF","abs","sqrt","PI","xRotRad","dx","dy","transformedPoint","radiiCheck","cSquareNumerator","cSquareRootDenom","cRadicand","cCoef","transformedCenter","center","startVector","startAngle","endVector","sweepAngle","endAngle","getArcLength","getPointAtArcLength","ellipseComponentX","ellipseComponentY","getArcBBox","deltaAngle","tan","atan2","tangent","angle1","angle2","angle3","angle4","xArray","yArray","xMin","xMax","yMin","yMax","angleAfterStart","pP2","angleBeforeEnd","pP3","p1","p2","p4","p3","Tvalues","Cvalues","deriveBezier","points","dpoints","list","j","computeBezier","order","mt","mt2","t2","calculateBezier","derivativeFn","bezierLength","len","sum","getBezierLength","curve","idx","step","CBEZIER_MINMAX_EPSILON","minmaxQ","cp","v2","minmaxC","cp1","cp2","K","S","L","Q","getPointAtCubicSegmentLength","c1x","c1y","c2x","c2y","t1","getCubicLength","getPointAtCubicLength","distanceIsNumber","currentLength","getCubicBBox","cxMinMax","cyMinMax","getPointAtQuadSegmentLength","getQuadLength","getPointAtQuadLength","getQuadBBox","polygon","area","paramsCount","finalizeSegment","path","pathCommand","relativeCommand","data","error","scanFlag","index","pathValue","code","isDigit","invalidPathValue","scanParam","start","zeroFirst","hasCeiling","hasDecimal","hasDot","ch","isSpace","skipSpaces","isPathCommand","isDigitStart","isArcCommand","isMoveCommand","scanSegment","segments","cmdCode","reqParams","paramCounts","lastSegment","_a","PathParser","pathString","parsePathString","pathInput","absolutizeSegment","segment","lastX","lastY","absCommand","absValues","seglen","iterate","iterator","pathLen","isRelative","mx","my","segLen","iteratorResult","pathToAbsolute","relativizeSegment","relCommand","relValues","pathToRelative","rotateVector","rad","arcToCubic","X1","Y1","X2","Y2","recursive","d120","res","xy","f1","f2","rx2","ry2","df","f2old","x2old","y2old","c1","s1","c2","s2","hx","hy","m1","m2","m3","m4","newres","ii","quadToCubic","qx","qy","r13","r23","lineToCubic","segmentToCubic","params","values","px1","py1","px","py","normalizeSegment","px2","py2","nqx","nqy","paramsParser","pathToCurve","seg","normalSegment","result","defaultOptions","roundTo","round","pow","pathToString","roundOption","valLen","DISTANCE_EPSILON","normalizePath","_","getPointAtLength","isM","POINT","totalLength","getTotalLength","paramX1","paramY1","paramX2","paramY2","paramQX","paramQY","absoluteSegment","cp1x","cp1y","getPropertiesAtLength","pathArray","pathTemp","pathLength","lengthAtSegment","getPropertiesAtPoint","normalPath","distanceTo","precision","scan","closest","scanDistance","bestLength","bestDistance","scanLength","before","after","beforeLength","afterLength","beforeDistance","afterDistance","getClosestPoint","getCubicSegArea","getPathArea","getDrawDirection","getPathBBox","minX","minY","maxX","maxY","width","height","getSegmentAtLength","getSegmentOfPoint","isPathArray","lk","isAbsoluteArray","isNormalizedArray","pc","isCurveArray","isPointInStroke","isRelativeArray","isValidPath","shapeParams","isElement","node","getLinePath","attr","getPolyPath","getCirclePath","getEllipsePath","getRectanglePath","shapeToPathArray","element","supportedShapes","targetIsElement","tagName","type","shapeAttrs","config","shapeToPath","replace","ownerDocument","doc","description","name","value","getSVGMatrix","transform","matrix","CSSMatrix","origin","originX","originY","translate","rotate","skew","scale","shortenSegment","prevCommand","defaultRound","normalValues","nx","ny","nx1","ny1","roundSegment","optimizePath","optimParams","allPathCommands","normalizedSegment","shortSegment","absSegment","absString","relativeSegment","relSegment","relString","translatePoint","cssm","projection2d","point2D","originZ","relativePositionX","relativePositionY","relativePositionZ","reverseCurve","rotatedCurve","curveOnly","reversePath","absolutePath","normalizedPath","pLen","isClosed","reversedPath","prevSeg","nextSeg","nextCommand","roundPath","splitCubic","pts","ratio","p0","p5","p6","p7","p8","p9","splitPath","composite","pi","transformPath","lx","ly","jj","transformProps","matrixInstance","isLongArc","tempSegment"],"mappings":"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","x_google_ignoreList":[0]} \ No newline at end of file +{"version":3,"sources":["../../src/util.ts","../../node_modules/.pnpm/@thednp+dommatrix@2.0.11/node_modules/@thednp/dommatrix/src/index.ts","../../src/math/arcTools.ts","../../src/math/lineTools.ts","../../src/math/midPoint.ts","../../src/math/distanceSquareRoot.ts","../../src/math/bezier.ts","../../src/math/cubicTools.ts","../../src/math/quadTools.ts","../../src/math/polygonTools.ts","../../src/parser/paramsCount.ts","../../src/parser/finalizeSegment.ts","../../src/parser/error.ts","../../src/parser/scanFlag.ts","../../src/parser/isDigit.ts","../../src/parser/invalidPathValue.ts","../../src/parser/scanParam.ts","../../src/parser/isSpace.ts","../../src/parser/skipSpaces.ts","../../src/parser/isPathCommand.ts","../../src/parser/isDigitStart.ts","../../src/parser/isArcCommand.ts","../../src/parser/isMoveCommand.ts","../../src/parser/scanSegment.ts","../../src/parser/pathParser.ts","../../src/parser/parsePathString.ts","../../src/process/absolutizeSegment.ts","../../src/process/iterate.ts","../../src/convert/pathToAbsolute.ts","../../src/process/relativizeSegment.ts","../../src/convert/pathToRelative.ts","../../src/math/rotateVector.ts","../../src/process/arcToCubic.ts","../../src/process/quadToCubic.ts","../../src/process/lineToCubic.ts","../../src/process/segmentToCubic.ts","../../src/process/normalizeSegment.ts","../../src/parser/paramsParser.ts","../../src/convert/pathToCurve.ts","../../src/options/options.ts","../../src/math/roundTo.ts","../../src/convert/pathToString.ts","../../src/util/distanceEpsilon.ts","../../src/process/normalizePath.ts","../../src/util/getPointAtLength.ts","../../src/util/getTotalLength.ts","../../src/util/getPropertiesAtLength.ts","../../src/util/getPropertiesAtPoint.ts","../../src/util/getClosestPoint.ts","../../src/util/getPathArea.ts","../../src/util/getDrawDirection.ts","../../src/util/getPathBBox.ts","../../src/util/getSegmentAtLength.ts","../../src/util/getSegmentOfPoint.ts","../../src/util/isPathArray.ts","../../src/util/isAbsoluteArray.ts","../../src/util/isNormalizedArray.ts","../../src/util/isCurveArray.ts","../../src/util/isPointInStroke.ts","../../src/util/isRelativeArray.ts","../../src/util/isValidPath.ts","../../src/util/shapeParams.ts","../../src/util/isElement.ts","../../src/util/shapeToPathArray.ts","../../src/util/shapeToPath.ts","../../src/process/getSVGMatrix.ts","../../src/process/shortenSegment.ts","../../src/process/roundSegment.ts","../../src/process/optimizePath.ts","../../src/process/projection2d.ts","../../src/process/reverseCurve.ts","../../src/process/reversePath.ts","../../src/process/roundPath.ts","../../src/process/splitCubic.ts","../../src/process/splitPath.ts","../../src/process/transformPath.ts"],"sourcesContent":["export { default as CSSMatrix } from \"@thednp/dommatrix\";\n// export type { PathArray, PointTuple, TransformObjectValues } from \"./types\";\n// export type { Options, TransformEntries, TransformObject } from \"./interface\";\n// export * from \"./types\";\n// export * from \"./interface\";\n\nimport * as arcTools from \"./math/arcTools\";\nimport * as bezierTools from \"./math/bezier\";\nimport * as cubicTools from \"./math/cubicTools\";\nimport * as lineTools from \"./math/lineTools\";\nimport * as quadTools from \"./math/quadTools\";\nimport * as polygonTools from \"./math/polygonTools\";\nexport { arcTools, bezierTools, cubicTools, lineTools, quadTools, polygonTools };\n\n// export * from \"./math/arcTools\";\n// export * from \"./math/bezier\";\n// export * from \"./math/cubicTools\";\n// export * from \"./math/lineTools\";\n// export * from \"./math/quadTools\";\n// export * from \"./math/polygonTools\";\n\nexport { default as pathToAbsolute } from \"./convert/pathToAbsolute\";\nexport { default as pathToRelative } from \"./convert/pathToRelative\";\nexport { default as pathToCurve } from \"./convert/pathToCurve\";\nexport { default as pathToString } from \"./convert/pathToString\";\n\nexport { default as distanceSquareRoot } from \"./math/distanceSquareRoot\";\nexport { default as midPoint } from \"./math/midPoint\";\nexport { default as rotateVector } from \"./math/rotateVector\";\nexport { default as roundTo } from \"./math/roundTo\";\n\nexport { default as parsePathString } from \"./parser/parsePathString\";\nexport { default as finalizeSegment } from \"./parser/finalizeSegment\";\nexport { default as invalidPathValue } from \"./parser/invalidPathValue\";\nexport { default as isArcCommand } from \"./parser/isArcCommand\";\nexport { default as isDigit } from \"./parser/isDigit\";\nexport { default as isDigitStart } from \"./parser/isDigitStart\";\nexport { default as isMoveCommand } from \"./parser/isMoveCommand\";\nexport { default as isPathCommand } from \"./parser/isPathCommand\";\nexport { default as isSpace } from \"./parser/isSpace\";\nexport { default as paramsCount } from \"./parser/paramsCount\";\nexport { default as paramsParser } from \"./parser/paramsParser\";\nexport { default as pathParser } from \"./parser/pathParser\";\nexport { default as scanFlag } from \"./parser/scanFlag\";\nexport { default as scanParam } from \"./parser/scanParam\";\nexport { default as scanSegment } from \"./parser/scanSegment\";\nexport { default as skipSpaces } from \"./parser/skipSpaces\";\n\nexport { default as distanceEpsilon } from \"./util/distanceEpsilon\";\nexport { default as getClosestPoint } from \"./util/getClosestPoint\";\nexport { default as getDrawDirection } from \"./util/getDrawDirection\";\nexport { default as getPathArea } from \"./util/getPathArea\";\nexport { default as getPathBBox } from \"./util/getPathBBox\";\nexport { default as getPointAtLength } from \"./util/getPointAtLength\";\nexport { default as getPropertiesAtLength } from \"./util/getPropertiesAtLength\";\nexport { default as getPropertiesAtPoint } from \"./util/getPropertiesAtPoint\";\nexport { default as getSegmentAtLength } from \"./util/getSegmentAtLength\";\nexport { default as getSegmentOfPoint } from \"./util/getSegmentOfPoint\";\nexport { default as getTotalLength } from \"./util/getTotalLength\";\n\nexport { default as isAbsoluteArray } from \"./util/isAbsoluteArray\";\nexport { default as isCurveArray } from \"./util/isCurveArray\";\nexport { default as isNormalizedArray } from \"./util/isNormalizedArray\";\nexport { default as isPathArray } from \"./util/isPathArray\";\nexport { default as isPointInStroke } from \"./util/isPointInStroke\";\nexport { default as isRelativeArray } from \"./util/isRelativeArray\";\nexport { default as isValidPath } from \"./util/isValidPath\";\nexport { default as shapeParams } from \"./util/shapeParams\";\nexport { default as shapeToPath } from \"./util/shapeToPath\";\nexport { default as shapeToPathArray } from \"./util/shapeToPathArray\";\n\nexport { default as absolutizeSegment } from \"./process/absolutizeSegment\";\nexport { default as arcToCubic } from \"./process/arcToCubic\";\nexport { default as getSVGMatrix } from \"./process/getSVGMatrix\";\nexport { default as iterate } from \"./process/iterate\";\nexport { default as lineToCubic } from \"./process/lineToCubic\";\nexport { default as normalizePath } from \"./process/normalizePath\";\nexport { default as normalizeSegment } from \"./process/normalizeSegment\";\nexport { default as optimizePath } from \"./process/optimizePath\";\nexport { default as projection2d } from \"./process/projection2d\";\nexport { default as quadToCubic } from \"./process/quadToCubic\";\nexport { default as relativizeSegment } from \"./process/relativizeSegment\";\nexport { default as reverseCurve } from \"./process/reverseCurve\";\nexport { default as reversePath } from \"./process/reversePath\";\nexport { default as roundPath } from \"./process/roundPath\";\nexport { default as roundSegment } from \"./process/roundSegment\";\nexport { default as segmentToCubic } from \"./process/segmentToCubic\";\nexport { default as shortenSegment } from \"./process/shortenSegment\";\nexport { default as splitCubic } from \"./process/splitCubic\";\nexport { default as splitPath } from \"./process/splitPath\";\nexport { default as transformPath } from \"./process/transformPath\";\n","import type {\n CSSMatrixInput,\n JSONMatrix,\n Matrix,\n Matrix3d,\n PointTuple,\n} from \"./types\";\n\n/** A model for JSONMatrix */\nconst JSON_MATRIX: JSONMatrix = {\n a: 1,\n b: 0,\n c: 0,\n d: 1,\n e: 0,\n f: 0,\n m11: 1,\n m12: 0,\n m13: 0,\n m14: 0,\n m21: 0,\n m22: 1,\n m23: 0,\n m24: 0,\n m31: 0,\n m32: 0,\n m33: 1,\n m34: 0,\n m41: 0,\n m42: 0,\n m43: 0,\n m44: 1,\n is2D: true,\n isIdentity: true,\n};\n\n// CSSMatrix Static methods\n// * `fromArray` is a more simple implementation, should also accept Float[32/64]Array;\n// * `fromMatrix` load values from another CSSMatrix/DOMMatrix instance or JSON object;\n// * `fromString` parses and loads values from any valid CSS transform string (TransformList).\n// * `isCompatibleArray` Checks if an array is compatible with CSSMatrix.\n// * `isCompatibleObject` Checks if an object is compatible with CSSMatrix.\n\n/** Checks if an array is compatible with CSSMatrix */\nconst isCompatibleArray = (\n array?: unknown,\n): array is Matrix | Matrix3d | Float32Array | Float64Array => {\n return (\n (array instanceof Float64Array ||\n array instanceof Float32Array ||\n (Array.isArray(array) && array.every((x) => typeof x === \"number\"))) &&\n [6, 16].some((x) => array.length === x)\n );\n};\n\n/** Checks if an object is compatible with CSSMatrix */\nconst isCompatibleObject = (\n object?: unknown,\n): object is CSSMatrix | DOMMatrix | JSONMatrix => {\n return (\n object instanceof DOMMatrix ||\n object instanceof CSSMatrix ||\n (typeof object === \"object\" &&\n Object.keys(JSON_MATRIX).every((k) => object && k in object))\n );\n};\n\n/**\n * Creates a new mutable `CSSMatrix` instance given an array of 16/6 floating point values.\n * This static method invalidates arrays that contain non-number elements.\n *\n * If the array has six values, the result is a 2D matrix; if the array has 16 values,\n * the result is a 3D matrix. Otherwise, a TypeError exception is thrown.\n *\n * @param array an `Array` to feed values from.\n * @return the resulted matrix.\n */\nconst fromArray = (\n array: number[] | Float32Array | Float64Array,\n): CSSMatrix => {\n const m = new CSSMatrix();\n const a = Array.from(array);\n\n if (!isCompatibleArray(a)) {\n throw TypeError(\n `CSSMatrix: \"${a.join(\",\")}\" must be an array with 6/16 numbers.`,\n );\n }\n // istanbul ignore else @preserve\n if (a.length === 16) {\n const [\n m11,\n m12,\n m13,\n m14,\n m21,\n m22,\n m23,\n m24,\n m31,\n m32,\n m33,\n m34,\n m41,\n m42,\n m43,\n m44,\n ] = a;\n\n m.m11 = m11;\n m.a = m11;\n\n m.m21 = m21;\n m.c = m21;\n\n m.m31 = m31;\n\n m.m41 = m41;\n m.e = m41;\n\n m.m12 = m12;\n m.b = m12;\n\n m.m22 = m22;\n m.d = m22;\n\n m.m32 = m32;\n\n m.m42 = m42;\n m.f = m42;\n\n m.m13 = m13;\n m.m23 = m23;\n m.m33 = m33;\n m.m43 = m43;\n m.m14 = m14;\n m.m24 = m24;\n m.m34 = m34;\n m.m44 = m44;\n } else if (a.length === 6) {\n const [M11, M12, M21, M22, M41, M42] = a;\n\n m.m11 = M11;\n m.a = M11;\n\n m.m12 = M12;\n m.b = M12;\n\n m.m21 = M21;\n m.c = M21;\n\n m.m22 = M22;\n m.d = M22;\n\n m.m41 = M41;\n m.e = M41;\n\n m.m42 = M42;\n m.f = M42;\n }\n return m;\n};\n\n/**\n * Creates a new mutable `CSSMatrix` instance given an existing matrix or a\n * `DOMMatrix` instance which provides the values for its properties.\n *\n * @param m the source matrix to feed values from.\n * @return the resulted matrix.\n */\nconst fromMatrix = (m: CSSMatrix | DOMMatrix | JSONMatrix): CSSMatrix => {\n if (isCompatibleObject(m)) {\n return fromArray([\n m.m11,\n m.m12,\n m.m13,\n m.m14,\n m.m21,\n m.m22,\n m.m23,\n m.m24,\n m.m31,\n m.m32,\n m.m33,\n m.m34,\n m.m41,\n m.m42,\n m.m43,\n m.m44,\n ]);\n }\n throw TypeError(\n `CSSMatrix: \"${\n JSON.stringify(m)\n }\" is not a DOMMatrix / CSSMatrix / JSON compatible object.`,\n );\n};\n\n/**\n * Creates a new mutable `CSSMatrix` given any valid CSS transform string,\n * or what we call `TransformList`:\n *\n * * `matrix(a, b, c, d, e, f)` - valid matrix() transform function\n * * `matrix3d(m11, m12, m13, ...m44)` - valid matrix3d() transform function\n * * `translate(tx, ty) rotateX(alpha)` - any valid transform function(s)\n *\n * @copyright thednp © 2021\n *\n * @param source valid CSS transform string syntax.\n * @return the resulted matrix.\n */\nconst fromString = (source: string): CSSMatrix => {\n if (typeof source !== \"string\") {\n throw TypeError(`CSSMatrix: \"${JSON.stringify(source)}\" is not a string.`);\n }\n const str = String(source).replace(/\\s/g, \"\");\n let m = new CSSMatrix();\n const invalidStringError = `CSSMatrix: invalid transform string \"${source}\"`;\n\n // const px = ['perspective'];\n // const length = ['translate', 'translate3d', 'translateX', 'translateY', 'translateZ'];\n // const deg = ['rotate', 'rotate3d', 'rotateX', 'rotateY', 'rotateZ', 'skew', 'skewX', 'skewY'];\n // const abs = ['scale', 'scale3d', 'matrix', 'matrix3d'];\n // const transformFunctions = px.concat(length, deg, abs);\n\n str\n .split(\")\")\n .filter((f) => f)\n .forEach((tf) => {\n const [prop, value] = tf.split(\"(\");\n\n // invalidate empty string\n if (!value) throw TypeError(invalidStringError);\n\n const components = value\n .split(\",\")\n .map((\n n,\n ) => (n.includes(\"rad\")\n ? parseFloat(n) * (180 / Math.PI)\n : parseFloat(n))\n );\n\n const [x, y, z, a] = components;\n const xyz = [x, y, z];\n const xyza = [x, y, z, a];\n\n // single number value expected\n if (\n prop === \"perspective\" && x && [y, z].every((n) => n === undefined)\n ) {\n m.m34 = -1 / x;\n // 6/16 number values expected\n } else if (\n prop.includes(\"matrix\") &&\n [6, 16].includes(components.length) &&\n components.every((n) => !Number.isNaN(+n))\n ) {\n const values = components.map((n) => (Math.abs(n) < 1e-6 ? 0 : n));\n m = m.multiply(fromArray(values as Matrix | Matrix3d));\n // 3 values expected\n } else if (\n prop === \"translate3d\" && xyz.every((n) => !Number.isNaN(+n))\n ) {\n m = m.translate(x, y, z);\n // single/double number value(s) expected\n } else if (prop === \"translate\" && x && z === undefined) {\n m = m.translate(x, y || 0, 0);\n // all 4 values expected\n } else if (\n prop === \"rotate3d\" && xyza.every((n) => !Number.isNaN(+n)) && a\n ) {\n m = m.rotateAxisAngle(x, y, z, a);\n // single value expected\n } else if (\n prop === \"rotate\" && x && [y, z].every((n) => n === undefined)\n ) {\n m = m.rotate(0, 0, x);\n // 3 values expected\n } else if (\n prop === \"scale3d\" && xyz.every((n) => !Number.isNaN(+n)) &&\n xyz.some((n) => n !== 1)\n ) {\n m = m.scale(x, y, z);\n // single value expected\n } else if (\n // prop === \"scale\" && !Number.isNaN(x) && x !== 1 && z === undefined\n // prop === \"scale\" && !Number.isNaN(x) && [x, y].some((n) => n !== 1) &&\n prop === \"scale\" && !Number.isNaN(x) && (x !== 1 || y !== 1) &&\n z === undefined\n ) {\n const nosy = Number.isNaN(+y);\n const sy = nosy ? x : y;\n m = m.scale(x, sy, 1);\n // single/double value expected\n } else if (\n prop === \"skew\" && (x || (!Number.isNaN(x) && y)) && z === undefined\n ) {\n m = m.skew(x, y || 0);\n } else if (\n [\"translate\", \"rotate\", \"scale\", \"skew\"].some((p) =>\n prop.includes(p)\n ) &&\n /[XYZ]/.test(prop) &&\n x &&\n [y, z].every((n) => n === undefined) // a single value expected\n ) {\n if (\"skewX\" === prop || \"skewY\" === prop) {\n m = m[prop](x);\n } else {\n const fn = prop.replace(/[XYZ]/, \"\") as\n | \"scale\"\n | \"translate\"\n | \"rotate\";\n const axis = prop.replace(fn, \"\");\n const idx = [\"X\", \"Y\", \"Z\"].indexOf(axis);\n const def = fn === \"scale\" ? 1 : 0;\n const axeValues: [number, number, number] = [\n idx === 0 ? x : def,\n idx === 1 ? x : def,\n idx === 2 ? x : def,\n ];\n m = m[fn](...axeValues);\n }\n } else {\n throw TypeError(invalidStringError);\n }\n });\n\n return m;\n};\n\n/**\n * Returns an *Array* containing elements which comprise the matrix.\n * The method can return either the 16 elements or the 6 elements\n * depending on the value of the `is2D` parameter.\n *\n * @param m the source matrix to feed values from.\n * @param is2D *Array* representation of the matrix\n * @return an *Array* representation of the matrix\n */\nconst toArray = (\n m: CSSMatrix | DOMMatrix | JSONMatrix,\n is2D?: boolean,\n): Matrix | Matrix3d => {\n if (is2D) {\n return [m.a, m.b, m.c, m.d, m.e, m.f];\n }\n return [\n m.m11,\n m.m12,\n m.m13,\n m.m14,\n m.m21,\n m.m22,\n m.m23,\n m.m24,\n m.m31,\n m.m32,\n m.m33,\n m.m34,\n m.m41,\n m.m42,\n m.m43,\n m.m44,\n ];\n};\n\n// Transform Functions\n// https://www.w3.org/TR/css-transforms-1/#transform-functions\n\n/**\n * Creates a new `CSSMatrix` for the translation matrix and returns it.\n * This method is equivalent to the CSS `translate3d()` function.\n *\n * https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/translate3d\n *\n * @param x the `x-axis` position.\n * @param y the `y-axis` position.\n * @param z the `z-axis` position.\n * @return the resulted matrix.\n */\nconst Translate = (x: number, y: number, z: number): CSSMatrix => {\n const m = new CSSMatrix();\n m.m41 = x;\n m.e = x;\n m.m42 = y;\n m.f = y;\n m.m43 = z;\n return m;\n};\n\n/**\n * Creates a new `CSSMatrix` for the rotation matrix and returns it.\n *\n * http://en.wikipedia.org/wiki/Rotation_matrix\n *\n * @param rx the `x-axis` rotation.\n * @param ry the `y-axis` rotation.\n * @param rz the `z-axis` rotation.\n * @return the resulted matrix.\n */\nconst Rotate = (rx: number, ry: number, rz: number): CSSMatrix => {\n const m = new CSSMatrix();\n const degToRad = Math.PI / 180;\n const radX = rx * degToRad;\n const radY = ry * degToRad;\n const radZ = rz * degToRad;\n\n // minus sin() because of right-handed system\n const cosx = Math.cos(radX);\n const sinx = -Math.sin(radX);\n const cosy = Math.cos(radY);\n const siny = -Math.sin(radY);\n const cosz = Math.cos(radZ);\n const sinz = -Math.sin(radZ);\n\n const m11 = cosy * cosz;\n const m12 = -cosy * sinz;\n\n m.m11 = m11;\n m.a = m11;\n\n m.m12 = m12;\n m.b = m12;\n\n m.m13 = siny;\n\n const m21 = sinx * siny * cosz + cosx * sinz;\n m.m21 = m21;\n m.c = m21;\n\n const m22 = cosx * cosz - sinx * siny * sinz;\n m.m22 = m22;\n m.d = m22;\n\n m.m23 = -sinx * cosy;\n\n m.m31 = sinx * sinz - cosx * siny * cosz;\n m.m32 = sinx * cosz + cosx * siny * sinz;\n m.m33 = cosx * cosy;\n\n return m;\n};\n\n/**\n * Creates a new `CSSMatrix` for the rotation matrix and returns it.\n * This method is equivalent to the CSS `rotate3d()` function.\n *\n * https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/rotate3d\n *\n * @param x the `x-axis` vector length.\n * @param y the `y-axis` vector length.\n * @param z the `z-axis` vector length.\n * @param alpha the value in degrees of the rotation.\n * @return the resulted matrix.\n */\nconst RotateAxisAngle = (\n x: number,\n y: number,\n z: number,\n alpha: number,\n): CSSMatrix => {\n const m = new CSSMatrix();\n const length = Math.sqrt(x * x + y * y + z * z);\n\n if (length === 0) {\n // bad vector length, return identity\n return m;\n }\n\n const X = x / length;\n const Y = y / length;\n const Z = z / length;\n\n const angle = alpha * (Math.PI / 360);\n const sinA = Math.sin(angle);\n const cosA = Math.cos(angle);\n const sinA2 = sinA * sinA;\n const x2 = X * X;\n const y2 = Y * Y;\n const z2 = Z * Z;\n\n const m11 = 1 - 2 * (y2 + z2) * sinA2;\n m.m11 = m11;\n m.a = m11;\n\n const m12 = 2 * (X * Y * sinA2 + Z * sinA * cosA);\n m.m12 = m12;\n m.b = m12;\n\n m.m13 = 2 * (X * Z * sinA2 - Y * sinA * cosA);\n\n const m21 = 2 * (Y * X * sinA2 - Z * sinA * cosA);\n m.m21 = m21;\n m.c = m21;\n\n const m22 = 1 - 2 * (z2 + x2) * sinA2;\n m.m22 = m22;\n m.d = m22;\n\n m.m23 = 2 * (Y * Z * sinA2 + X * sinA * cosA);\n m.m31 = 2 * (Z * X * sinA2 + Y * sinA * cosA);\n m.m32 = 2 * (Z * Y * sinA2 - X * sinA * cosA);\n m.m33 = 1 - 2 * (x2 + y2) * sinA2;\n\n return m;\n};\n\n/**\n * Creates a new `CSSMatrix` for the scale matrix and returns it.\n * This method is equivalent to the CSS `scale3d()` function, except it doesn't\n * accept {x, y, z} transform origin parameters.\n *\n * https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/scale3d\n *\n * @param x the `x-axis` scale.\n * @param y the `y-axis` scale.\n * @param z the `z-axis` scale.\n * @return the resulted matrix.\n */\nconst Scale = (x: number, y: number, z: number): CSSMatrix => {\n const m = new CSSMatrix();\n m.m11 = x;\n m.a = x;\n\n m.m22 = y;\n m.d = y;\n\n m.m33 = z;\n return m;\n};\n\n/**\n * Creates a new `CSSMatrix` for the shear of both the `x-axis` and`y-axis`\n * matrix and returns it. This method is equivalent to the CSS `skew()` function.\n *\n * https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/skew\n *\n * @param angleX the X-angle in degrees.\n * @param angleY the Y-angle in degrees.\n * @return the resulted matrix.\n */\nconst Skew = (angleX: number, angleY: number): CSSMatrix => {\n const m = new CSSMatrix();\n if (angleX) {\n const radX = (angleX * Math.PI) / 180;\n const tX = Math.tan(radX);\n m.m21 = tX;\n m.c = tX;\n }\n if (angleY) {\n const radY = (angleY * Math.PI) / 180;\n const tY = Math.tan(radY);\n m.m12 = tY;\n m.b = tY;\n }\n return m;\n};\n\n/**\n * Creates a new `CSSMatrix` for the shear of the `x-axis` rotation matrix and\n * returns it. This method is equivalent to the CSS `skewX()` function.\n *\n * https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/skewX\n *\n * @param angle the angle in degrees.\n * @return the resulted matrix.\n */\nconst SkewX = (angle: number): CSSMatrix => {\n return Skew(angle, 0);\n};\n\n/**\n * Creates a new `CSSMatrix` for the shear of the `y-axis` rotation matrix and\n * returns it. This method is equivalent to the CSS `skewY()` function.\n *\n * https://developer.mozilla.org/en-US/docs/Web/CSS/transform-function/skewY\n *\n * @param angle the angle in degrees.\n * @return the resulted matrix.\n */\nconst SkewY = (angle: number): CSSMatrix => {\n return Skew(0, angle);\n};\n\n/**\n * Creates a new `CSSMatrix` resulted from the multiplication of two matrixes\n * and returns it. Both matrixes are not changed.\n *\n * @param m1 the first matrix.\n * @param m2 the second matrix.\n * @return the resulted matrix.\n */\nconst Multiply = (\n m1: CSSMatrix | DOMMatrix | JSONMatrix,\n m2: CSSMatrix | DOMMatrix | JSONMatrix,\n): CSSMatrix => {\n const m11 = m2.m11 * m1.m11 + m2.m12 * m1.m21 + m2.m13 * m1.m31 +\n m2.m14 * m1.m41;\n const m12 = m2.m11 * m1.m12 + m2.m12 * m1.m22 + m2.m13 * m1.m32 +\n m2.m14 * m1.m42;\n const m13 = m2.m11 * m1.m13 + m2.m12 * m1.m23 + m2.m13 * m1.m33 +\n m2.m14 * m1.m43;\n const m14 = m2.m11 * m1.m14 + m2.m12 * m1.m24 + m2.m13 * m1.m34 +\n m2.m14 * m1.m44;\n\n const m21 = m2.m21 * m1.m11 + m2.m22 * m1.m21 + m2.m23 * m1.m31 +\n m2.m24 * m1.m41;\n const m22 = m2.m21 * m1.m12 + m2.m22 * m1.m22 + m2.m23 * m1.m32 +\n m2.m24 * m1.m42;\n const m23 = m2.m21 * m1.m13 + m2.m22 * m1.m23 + m2.m23 * m1.m33 +\n m2.m24 * m1.m43;\n const m24 = m2.m21 * m1.m14 + m2.m22 * m1.m24 + m2.m23 * m1.m34 +\n m2.m24 * m1.m44;\n\n const m31 = m2.m31 * m1.m11 + m2.m32 * m1.m21 + m2.m33 * m1.m31 +\n m2.m34 * m1.m41;\n const m32 = m2.m31 * m1.m12 + m2.m32 * m1.m22 + m2.m33 * m1.m32 +\n m2.m34 * m1.m42;\n const m33 = m2.m31 * m1.m13 + m2.m32 * m1.m23 + m2.m33 * m1.m33 +\n m2.m34 * m1.m43;\n const m34 = m2.m31 * m1.m14 + m2.m32 * m1.m24 + m2.m33 * m1.m34 +\n m2.m34 * m1.m44;\n\n const m41 = m2.m41 * m1.m11 + m2.m42 * m1.m21 + m2.m43 * m1.m31 +\n m2.m44 * m1.m41;\n const m42 = m2.m41 * m1.m12 + m2.m42 * m1.m22 + m2.m43 * m1.m32 +\n m2.m44 * m1.m42;\n const m43 = m2.m41 * m1.m13 + m2.m42 * m1.m23 + m2.m43 * m1.m33 +\n m2.m44 * m1.m43;\n const m44 = m2.m41 * m1.m14 + m2.m42 * m1.m24 + m2.m43 * m1.m34 +\n m2.m44 * m1.m44;\n\n return fromArray([\n m11,\n m12,\n m13,\n m14,\n m21,\n m22,\n m23,\n m24,\n m31,\n m32,\n m33,\n m34,\n m41,\n m42,\n m43,\n m44,\n ]);\n};\n\n/**\n * Creates and returns a new `DOMMatrix` compatible instance\n * with equivalent instance.\n *\n * @class CSSMatrix\n *\n * @author thednp \n * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMMatrix\n */\nexport default class CSSMatrix {\n declare m11: number;\n declare m12: number;\n declare m13: number;\n declare m14: number;\n declare m21: number;\n declare m22: number;\n declare m23: number;\n declare m24: number;\n declare m31: number;\n declare m32: number;\n declare m33: number;\n declare m34: number;\n declare m41: number;\n declare m42: number;\n declare m43: number;\n declare m44: number;\n declare a: number;\n declare b: number;\n declare c: number;\n declare d: number;\n declare e: number;\n declare f: number;\n static Translate = Translate;\n static Rotate = Rotate;\n static RotateAxisAngle = RotateAxisAngle;\n static Scale = Scale;\n static SkewX = SkewX;\n static SkewY = SkewY;\n static Skew = Skew;\n static Multiply = Multiply;\n static fromArray = fromArray;\n static fromMatrix = fromMatrix;\n static fromString = fromString;\n static toArray = toArray;\n static isCompatibleArray = isCompatibleArray;\n static isCompatibleObject = isCompatibleObject;\n\n /**\n * @constructor\n * @param init accepts all parameter configurations:\n * * valid CSS transform string,\n * * CSSMatrix/DOMMatrix instance,\n * * a 6/16 elements *Array*.\n */\n constructor(init?: CSSMatrixInput) {\n // array 6\n this.a = 1;\n this.b = 0;\n this.c = 0;\n this.d = 1;\n this.e = 0;\n this.f = 0;\n // array 16\n this.m11 = 1;\n this.m12 = 0;\n this.m13 = 0;\n this.m14 = 0;\n this.m21 = 0;\n this.m22 = 1;\n this.m23 = 0;\n this.m24 = 0;\n this.m31 = 0;\n this.m32 = 0;\n this.m33 = 1;\n this.m34 = 0;\n this.m41 = 0;\n this.m42 = 0;\n this.m43 = 0;\n this.m44 = 1;\n\n if (init) {\n return this.setMatrixValue(init);\n }\n return this;\n }\n\n /**\n * A `Boolean` whose value is `true` if the matrix is the identity matrix. The identity\n * matrix is one in which every value is 0 except those on the main diagonal from top-left\n * to bottom-right corner (in other words, where the offsets in each direction are equal).\n *\n * @return the current property value\n */\n get isIdentity(): boolean {\n return (\n this.m11 === 1 &&\n this.m12 === 0 &&\n this.m13 === 0 &&\n this.m14 === 0 &&\n this.m21 === 0 &&\n this.m22 === 1 &&\n this.m23 === 0 &&\n this.m24 === 0 &&\n this.m31 === 0 &&\n this.m32 === 0 &&\n this.m33 === 1 &&\n this.m34 === 0 &&\n this.m41 === 0 &&\n this.m42 === 0 &&\n this.m43 === 0 &&\n this.m44 === 1\n );\n }\n\n /**\n * A `Boolean` flag whose value is `true` if the matrix was initialized as a 2D matrix\n * and `false` if the matrix is 3D.\n *\n * @return the current property value\n */\n get is2D(): boolean {\n return this.m31 === 0 && this.m32 === 0 && this.m33 === 1 &&\n this.m34 === 0 && this.m43 === 0 && this.m44 === 1;\n }\n\n /**\n * The `setMatrixValue` method replaces the existing matrix with one computed\n * in the browser. EG: `matrix(1,0.25,-0.25,1,0,0)`\n *\n * The method accepts any *Array* values, the result of\n * `DOMMatrix` instance method `toFloat64Array()` / `toFloat32Array()` calls\n * or `CSSMatrix` instance method `toArray()`.\n *\n * This method expects valid *matrix()* / *matrix3d()* string values, as well\n * as other transform functions like *translateX(10px)*.\n *\n * @param source\n * @return the matrix instance\n */\n setMatrixValue(source?: CSSMatrixInput): CSSMatrix {\n // CSS transform string source - TransformList first\n if (typeof source === \"string\" && source.length && source !== \"none\") {\n return fromString(source);\n }\n\n // [Array | Float[32/64]Array] come next\n if (\n Array.isArray(source) || source instanceof Float64Array ||\n source instanceof Float32Array\n ) {\n return fromArray(source);\n }\n\n // new CSSMatrix(CSSMatrix | DOMMatrix | JSONMatrix) last\n if (typeof source === \"object\") {\n return fromMatrix(source);\n }\n\n return this;\n }\n\n /**\n * Returns a *Float32Array* containing elements which comprise the matrix.\n * The method can return either the 16 elements or the 6 elements\n * depending on the value of the `is2D` parameter.\n *\n * @param is2D *Array* representation of the matrix\n * @return an *Array* representation of the matrix\n */\n toFloat32Array(is2D?: boolean): Float32Array {\n return Float32Array.from(toArray(this, is2D));\n }\n\n /**\n * Returns a *Float64Array* containing elements which comprise the matrix.\n * The method can return either the 16 elements or the 6 elements\n * depending on the value of the `is2D` parameter.\n *\n * @param is2D *Array* representation of the matrix\n * @return an *Array* representation of the matrix\n */\n toFloat64Array(is2D?: boolean): Float64Array {\n return Float64Array.from(toArray(this, is2D));\n }\n\n /**\n * Creates and returns a string representation of the matrix in `CSS` matrix syntax,\n * using the appropriate `CSS` matrix notation.\n *\n * matrix3d *matrix3d(m11, m12, m13, m14, m21, ...)*\n * matrix *matrix(a, b, c, d, e, f)*\n *\n * @return a string representation of the matrix\n */\n toString(): string {\n const { is2D } = this;\n const values = this.toFloat64Array(is2D).join(\", \");\n const type = is2D ? \"matrix\" : \"matrix3d\";\n return `${type}(${values})`;\n }\n\n /**\n * Returns a JSON representation of the `CSSMatrix` instance, a standard *Object*\n * that includes `{a,b,c,d,e,f}` and `{m11,m12,m13,..m44}` properties as well\n * as the `is2D` & `isIdentity` properties.\n *\n * The result can also be used as a second parameter for the `fromMatrix` static method\n * to load values into another matrix instance.\n *\n * @return an *Object* with all matrix values.\n */\n toJSON(): JSONMatrix {\n const { is2D, isIdentity } = this;\n return { ...this, is2D, isIdentity };\n }\n\n /**\n * The Multiply method returns a new CSSMatrix which is the result of this\n * matrix multiplied by the passed matrix, with the passed matrix to the right.\n * This matrix is not modified.\n *\n * @param m2 CSSMatrix\n * @return The resulted matrix.\n */\n multiply(m2: CSSMatrix | DOMMatrix | JSONMatrix): CSSMatrix {\n return Multiply(this, m2);\n }\n\n /**\n * The translate method returns a new matrix which is this matrix post\n * multiplied by a translation matrix containing the passed values. If the z\n * component is undefined, a 0 value is used in its place. This matrix is not\n * modified.\n *\n * @param x X component of the translation value.\n * @param y Y component of the translation value.\n * @param z Z component of the translation value.\n * @return The resulted matrix\n */\n translate(x: number, y?: number, z?: number): CSSMatrix {\n const X = x;\n let Y = y;\n let Z = z;\n if (typeof Y === \"undefined\") Y = 0;\n if (typeof Z === \"undefined\") Z = 0;\n return Multiply(this, Translate(X, Y, Z));\n }\n\n /**\n * The scale method returns a new matrix which is this matrix post multiplied by\n * a scale matrix containing the passed values. If the z component is undefined,\n * a 1 value is used in its place. If the y component is undefined, the x\n * component value is used in its place. This matrix is not modified.\n *\n * @param x The X component of the scale value.\n * @param y The Y component of the scale value.\n * @param z The Z component of the scale value.\n * @return The resulted matrix\n */\n scale(x: number, y?: number, z?: number): CSSMatrix {\n const X = x;\n let Y = y;\n let Z = z;\n if (typeof Y === \"undefined\") Y = x;\n if (typeof Z === \"undefined\") Z = 1; // Z must be 1 if undefined\n\n return Multiply(this, Scale(X, Y, Z));\n }\n\n /**\n * The rotate method returns a new matrix which is this matrix post multiplied\n * by each of 3 rotation matrices about the major axes, first X, then Y, then Z.\n * If the y and z components are undefined, the x value is used to rotate the\n * object about the z axis, as though the vector (0,0,x) were passed. All\n * rotation values are in degrees. This matrix is not modified.\n *\n * @param rx The X component of the rotation, or Z if Y and Z are null.\n * @param ry The (optional) Y component of the rotation value.\n * @param rz The (optional) Z component of the rotation value.\n * @return The resulted matrix\n */\n rotate(rx: number, ry?: number, rz?: number): CSSMatrix {\n let RX = rx;\n let RY = ry || 0;\n let RZ = rz || 0;\n\n if (\n typeof rx === \"number\" && typeof ry === \"undefined\" &&\n typeof rz === \"undefined\"\n ) {\n RZ = RX;\n RX = 0;\n RY = 0;\n }\n\n return Multiply(this, Rotate(RX, RY, RZ));\n }\n\n /**\n * The rotateAxisAngle method returns a new matrix which is this matrix post\n * multiplied by a rotation matrix with the given axis and `angle`. The right-hand\n * rule is used to determine the direction of rotation. All rotation values are\n * in degrees. This matrix is not modified.\n *\n * @param x The X component of the axis vector.\n * @param y The Y component of the axis vector.\n * @param z The Z component of the axis vector.\n * @param angle The angle of rotation about the axis vector, in degrees.\n * @return The resulted matrix\n */\n rotateAxisAngle(x: number, y: number, z: number, angle: number): CSSMatrix {\n if ([x, y, z, angle].some((n) => Number.isNaN(+n))) {\n throw new TypeError(\"CSSMatrix: expecting 4 values\");\n }\n return Multiply(this, RotateAxisAngle(x, y, z, angle));\n }\n\n /**\n * Specifies a skew transformation along the `x-axis` by the given angle.\n * This matrix is not modified.\n *\n * @param angle The angle amount in degrees to skew.\n * @return The resulted matrix\n */\n skewX(angle: number): CSSMatrix {\n return Multiply(this, SkewX(angle));\n }\n\n /**\n * Specifies a skew transformation along the `y-axis` by the given angle.\n * This matrix is not modified.\n *\n * @param angle The angle amount in degrees to skew.\n * @return The resulted matrix\n */\n skewY(angle: number): CSSMatrix {\n return Multiply(this, SkewY(angle));\n }\n\n /**\n * Specifies a skew transformation along both the `x-axis` and `y-axis`.\n * This matrix is not modified.\n *\n * @param angleX The X-angle amount in degrees to skew.\n * @param angleY The angle amount in degrees to skew.\n * @return The resulted matrix\n */\n skew(angleX: number, angleY: number): CSSMatrix {\n return Multiply(this, Skew(angleX, angleY));\n }\n\n /**\n * Transforms a specified vector using the matrix, returning a new\n * {x,y,z,w} Tuple *Object* comprising the transformed vector.\n * Neither the matrix nor the original vector are altered.\n *\n * The method is equivalent with `transformPoint()` method\n * of the `DOMMatrix` constructor.\n *\n * @param t Tuple with `{x,y,z,w}` components\n * @return the resulting Tuple\n */\n transformPoint(t: PointTuple | DOMPoint): PointTuple | DOMPoint {\n const x = this.m11 * t.x + this.m21 * t.y + this.m31 * t.z + this.m41 * t.w;\n const y = this.m12 * t.x + this.m22 * t.y + this.m32 * t.z + this.m42 * t.w;\n const z = this.m13 * t.x + this.m23 * t.y + this.m33 * t.z + this.m43 * t.w;\n const w = this.m14 * t.x + this.m24 * t.y + this.m34 * t.z + this.m44 * t.w;\n\n return t instanceof DOMPoint ? new DOMPoint(x, y, z, w) : {\n x,\n y,\n z,\n w,\n };\n }\n}\n","import { getPointAtLineLength } from \"./lineTools\";\nimport type { Point, PointTuple } from \"../types\";\n\n/**\n * Returns the Arc segment length.\n * @param rx radius along X axis\n * @param ry radius along Y axis\n * @param theta the angle in radians\n * @returns the arc length\n */\nconst arcLength = (rx: number, ry: number, theta: number) => {\n const halfTheta = theta / 2;\n const sinHalfTheta = Math.sin(halfTheta);\n const cosHalfTheta = Math.cos(halfTheta);\n const term1 = rx ** 2 * sinHalfTheta ** 2;\n const term2 = ry ** 2 * cosHalfTheta ** 2;\n const length = Math.sqrt(term1 + term2) * theta;\n return Math.abs(length);\n};\n\n/**\n * Find point on ellipse at given angle around ellipse (theta);\n * @param cx the center X\n * @param cy the center Y\n * @param rx the radius X\n * @param ry the radius Y\n * @param alpha the arc rotation angle in radians\n * @param theta the arc sweep angle in radians\n * @returns a point around ellipse at given angle\n */\nconst arcPoint = (\n cx: number,\n cy: number,\n rx: number,\n ry: number,\n alpha: number,\n theta: number,\n) => {\n const { sin, cos } = Math;\n // theta is angle in radians around arc\n // alpha is angle of rotation of ellipse in radians\n const cosA = cos(alpha);\n const sinA = sin(alpha);\n const x = rx * cos(theta);\n const y = ry * sin(theta);\n\n return [cx + cosA * x - sinA * y, cy + sinA * x + cosA * y] as PointTuple;\n};\n\n/**\n * Returns the angle between two points.\n * @param v0 starting point\n * @param v1 ending point\n * @returns the angle in radian\n */\nconst angleBetween = (v0: Point, v1: Point) => {\n const { x: v0x, y: v0y } = v0;\n const { x: v1x, y: v1y } = v1;\n const p = v0x * v1x + v0y * v1y;\n const n = Math.sqrt((v0x ** 2 + v0y ** 2) * (v1x ** 2 + v1y ** 2));\n const sign = v0x * v1y - v0y * v1x < 0 ? -1 : 1;\n return sign * Math.acos(p / n);\n};\n\n/**\n * Returns the following properties for an Arc segment: center, start angle,\n * end angle, and radiuses on X and Y axis.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param RX the radius on X axis\n * @param RY the radius on Y axis\n * @param angle the ellipse rotation in degrees\n * @param LAF the large arc flag\n * @param SF the sweep flag\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns properties specific to Arc segments\n */\nconst getArcProps = (\n x1: number,\n y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n x: number,\n y: number,\n) => {\n const { abs, sin, cos, sqrt, PI } = Math;\n let rx = abs(RX);\n let ry = abs(RY);\n const xRot = ((angle % 360) + 360) % 360;\n const xRotRad = xRot * (PI / 180);\n\n // istanbul ignore next @preserve\n if (x1 === x && y1 === y) {\n return {\n rx,\n ry,\n startAngle: 0,\n endAngle: 0,\n center: { x, y },\n };\n }\n\n if (rx === 0 || ry === 0) {\n return {\n rx,\n ry,\n startAngle: 0,\n endAngle: 0,\n center: { x: (x + x1) / 2, y: (y + y1) / 2 },\n };\n }\n\n const dx = (x1 - x) / 2;\n const dy = (y1 - y) / 2;\n\n const transformedPoint = {\n x: cos(xRotRad) * dx + sin(xRotRad) * dy,\n y: -sin(xRotRad) * dx + cos(xRotRad) * dy,\n };\n\n const radiiCheck = transformedPoint.x ** 2 / rx ** 2 +\n transformedPoint.y ** 2 / ry ** 2;\n\n if (radiiCheck > 1) {\n rx *= sqrt(radiiCheck);\n ry *= sqrt(radiiCheck);\n }\n\n const cSquareNumerator = rx ** 2 * ry ** 2 -\n rx ** 2 * transformedPoint.y ** 2 - ry ** 2 * transformedPoint.x ** 2;\n const cSquareRootDenom = rx ** 2 * transformedPoint.y ** 2 +\n ry ** 2 * transformedPoint.x ** 2;\n\n let cRadicand = cSquareNumerator / cSquareRootDenom;\n /* istanbul ignore next @preserve */\n cRadicand = cRadicand < 0 ? 0 : cRadicand;\n const cCoef = (LAF !== SF ? 1 : -1) * sqrt(cRadicand);\n const transformedCenter = {\n x: cCoef * ((rx * transformedPoint.y) / ry),\n y: cCoef * (-(ry * transformedPoint.x) / rx),\n };\n\n const center = {\n x: cos(xRotRad) * transformedCenter.x - sin(xRotRad) * transformedCenter.y +\n (x1 + x) / 2,\n y: sin(xRotRad) * transformedCenter.x + cos(xRotRad) * transformedCenter.y +\n (y1 + y) / 2,\n };\n\n const startVector = {\n x: (transformedPoint.x - transformedCenter.x) / rx,\n y: (transformedPoint.y - transformedCenter.y) / ry,\n };\n\n const startAngle = angleBetween({ x: 1, y: 0 }, startVector);\n\n const endVector = {\n x: (-transformedPoint.x - transformedCenter.x) / rx,\n y: (-transformedPoint.y - transformedCenter.y) / ry,\n };\n\n let sweepAngle = angleBetween(startVector, endVector);\n if (!SF && sweepAngle > 0) {\n sweepAngle -= 2 * PI;\n } else if (SF && sweepAngle < 0) {\n sweepAngle += 2 * PI;\n }\n sweepAngle %= 2 * PI;\n\n const endAngle = startAngle + sweepAngle;\n\n // point.ellipticalArcStartAngle = startAngle;\n // point.ellipticalArcEndAngle = startAngle + sweepAngle;\n // point.ellipticalArcAngle = alpha;\n\n // point.ellipticalArcCenter = center;\n // point.resultantRx = rx;\n // point.resultantRy = ry;\n\n return {\n center,\n startAngle,\n endAngle,\n rx,\n ry,\n };\n};\n\n/**\n * Returns the length of an Arc segment.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the length of the Arc segment\n */\nconst getArcLength = (\n x1: number,\n y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n x: number,\n y: number,\n) => {\n const { rx, ry, startAngle, endAngle } = getArcProps(\n x1,\n y1,\n RX,\n RY,\n angle,\n LAF,\n SF,\n x,\n y,\n );\n return arcLength(rx, ry, endAngle - startAngle);\n};\n\n/**\n * Returns a point along an Arc segment at a given distance.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param RX the radius on X axis\n * @param RY the radius on Y axis\n * @param angle the ellipse rotation in degrees\n * @param LAF the large arc flag\n * @param SF the sweep flag\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance a [0-1] ratio\n * @returns a point along the Arc segment\n */\nconst getPointAtArcLength = (\n x1: number,\n y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n x: number,\n y: number,\n distance?: number,\n) => {\n let point = { x: x1, y: y1 };\n const { center, rx, ry, startAngle, endAngle } = getArcProps(\n x1,\n y1,\n RX,\n RY,\n angle,\n LAF,\n SF,\n x,\n y,\n );\n\n /* istanbul ignore else @preserve */\n if (typeof distance === \"number\") {\n const length = arcLength(rx, ry, endAngle - startAngle);\n if (distance <= 0) {\n point = { x: x1, y: y1 };\n } else if (distance >= length) {\n point = { x, y };\n } else {\n /* istanbul ignore next @preserve */\n if (x1 === x && y1 === y) {\n return { x, y };\n }\n /* istanbul ignore next @preserve */\n if (rx === 0 || ry === 0) {\n return getPointAtLineLength(x1, y1, x, y, distance);\n }\n const { PI, cos, sin } = Math;\n const sweepAngle = endAngle - startAngle;\n const xRot = ((angle % 360) + 360) % 360;\n const xRotRad = xRot * (PI / 180);\n const alpha = startAngle + sweepAngle * (distance / length);\n const ellipseComponentX = rx * cos(alpha);\n const ellipseComponentY = ry * sin(alpha);\n\n point = {\n x: cos(xRotRad) * ellipseComponentX - sin(xRotRad) * ellipseComponentY +\n center.x,\n y: sin(xRotRad) * ellipseComponentX + cos(xRotRad) * ellipseComponentY +\n center.y,\n };\n }\n }\n\n return point;\n};\n\n/**\n * Returns the extrema for an Arc segment in the following format:\n * [MIN_X, MIN_Y, MAX_X, MAX_Y]\n *\n * @see https://github.com/herrstrietzel/svg-pathdata-getbbox\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param RX the radius on X axis\n * @param RY the radius on Y axis\n * @param angle the ellipse rotation in degrees\n * @param LAF the large arc flag\n * @param SF the sweep flag\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the extrema of the Arc segment\n */\nconst getArcBBox = (\n x1: number,\n y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n x: number,\n y: number,\n) => {\n const { center, rx, ry, startAngle, endAngle } = getArcProps(\n x1,\n y1,\n RX,\n RY,\n angle,\n LAF,\n SF,\n x,\n y,\n );\n const deltaAngle = endAngle - startAngle;\n const { min, max, tan, atan2, PI } = Math;\n\n // circle/elipse center coordinates\n const { x: cx, y: cy } = center;\n\n // rotation to radians\n const alpha = (angle * PI) / 180;\n const tangent = tan(alpha);\n\n /**\n * find min/max from zeroes of directional derivative along x and y\n * along x axis\n */\n const theta = atan2(-ry * tangent, rx);\n const angle1 = theta;\n const angle2 = theta + PI;\n const angle3 = atan2(ry, rx * tangent);\n const angle4 = angle3 + PI;\n const xArray = [x];\n const yArray = [y];\n\n // inner bounding box\n let xMin = min(x1, x);\n let xMax = max(x1, x);\n let yMin = min(y1, y);\n let yMax = max(y1, y);\n\n // on path point close after start\n const angleAfterStart = endAngle - deltaAngle * 0.00001;\n const pP2 = arcPoint(cx, cy, rx, ry, alpha, angleAfterStart);\n\n // on path point close before end\n const angleBeforeEnd = endAngle - deltaAngle * 0.99999;\n const pP3 = arcPoint(cx, cy, rx, ry, alpha, angleBeforeEnd);\n\n /**\n * expected extremes\n * if leaving inner bounding box\n * (between segment start and end point)\n * otherwise exclude elliptic extreme points\n */\n\n // right\n if (pP2[0] > xMax || pP3[0] > xMax) {\n // get point for this theta\n const p1 = arcPoint(cx, cy, rx, ry, alpha, angle1);\n xArray.push(p1[0]);\n yArray.push(p1[1]);\n }\n\n // left\n if (pP2[0] < xMin || pP3[0] < xMin) {\n // get anti-symmetric point\n const p2 = arcPoint(cx, cy, rx, ry, alpha, angle2);\n xArray.push(p2[0]);\n yArray.push(p2[1]);\n }\n\n // top\n if (pP2[1] < yMin || pP3[1] < yMin) {\n // get anti-symmetric point\n const p4 = arcPoint(cx, cy, rx, ry, alpha, angle4);\n xArray.push(p4[0]);\n yArray.push(p4[1]);\n }\n\n // bottom\n if (pP2[1] > yMax || pP3[1] > yMax) {\n // get point for this theta\n const p3 = arcPoint(cx, cy, rx, ry, alpha, angle3);\n xArray.push(p3[0]);\n yArray.push(p3[1]);\n }\n\n xMin = min.apply([], xArray);\n yMin = min.apply([], yArray);\n xMax = max.apply([], xArray);\n yMax = max.apply([], yArray);\n\n return [xMin, yMin, xMax, yMax] as [number, number, number, number];\n};\n\nexport {\n angleBetween,\n arcLength,\n arcPoint,\n getArcBBox,\n getArcLength,\n getArcProps,\n getPointAtArcLength,\n};\n","import midPoint from \"./midPoint\";\nimport distanceSquareRoot from \"./distanceSquareRoot\";\n\n/**\n * Returns length for line segments (MoveTo, LineTo).\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the line segment length\n */\nconst getLineLength = (x1: number, y1: number, x2: number, y2: number) => {\n return distanceSquareRoot([x1, y1], [x2, y2]);\n};\n\n/**\n * Returns a point along the line segments (MoveTo, LineTo).\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance the distance to point in [0-1] range\n * @returns the point at length\n */\nconst getPointAtLineLength = (\n x1: number,\n y1: number,\n x2: number,\n y2: number,\n distance?: number,\n) => {\n let point = { x: x1, y: y1 };\n\n /* istanbul ignore else @preserve */\n if (typeof distance === \"number\") {\n const length = distanceSquareRoot([x1, y1], [x2, y2]);\n if (distance <= 0) {\n point = { x: x1, y: y1 };\n } else if (distance >= length) {\n point = { x: x2, y: y2 };\n } else {\n const [x, y] = midPoint([x1, y1], [x2, y2], distance / length);\n point = { x, y };\n }\n }\n return point;\n};\n\n/**\n * Returns bounding box for line segments (MoveTo, LineTo).\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance the distance to point in [0-1] range\n * @returns the extrema for line segments\n */\nconst getLineBBox = (x1: number, y1: number, x2: number, y2: number) => {\n const { min, max } = Math;\n\n return [min(x1, x2), min(y1, y2), max(x1, x2), max(y1, y2)] as [\n number,\n number,\n number,\n number,\n ];\n};\n\nexport { getLineBBox, getLineLength, getPointAtLineLength };\n","import { PointTuple } from \"../types\";\n\n/**\n * Returns the coordinates of a specified distance\n * ratio between two points.\n *\n * @param a the first point coordinates\n * @param b the second point coordinates\n * @param t the ratio\n * @returns the midpoint coordinates\n */\nconst midPoint = (a: PointTuple, b: PointTuple, t: number): PointTuple => {\n const [ax, ay] = a;\n const [bx, by] = b;\n return [ax + (bx - ax) * t, ay + (by - ay) * t];\n};\n\nexport default midPoint;\n","import { type PointTuple } from \"../types\";\n\n/**\n * Returns the square root of the distance\n * between two given points.\n *\n * @param a the first point coordinates\n * @param b the second point coordinates\n * @returns the distance value\n */\nconst distanceSquareRoot = (a: PointTuple, b: PointTuple) => {\n return Math.sqrt(\n (a[0] - b[0]) * (a[0] - b[0]) + (a[1] - b[1]) * (a[1] - b[1]),\n );\n};\n\nexport default distanceSquareRoot;\n","import type {\n CubicCoordinates,\n CubicPoints,\n DeriveCallback,\n DerivedCubicPoints,\n DerivedPoint,\n DerivedQuadPoints,\n PointTuple,\n QuadCoordinates,\n QuadPoints,\n} from \"../types\";\n\n/**\n * Tools from bezier.js by Mike 'Pomax' Kamermans\n * @see https://github.com/Pomax/bezierjs\n */\n\nconst Tvalues = [\n -0.0640568928626056260850430826247450385909,\n 0.0640568928626056260850430826247450385909,\n -0.1911188674736163091586398207570696318404,\n 0.1911188674736163091586398207570696318404,\n -0.3150426796961633743867932913198102407864,\n 0.3150426796961633743867932913198102407864,\n -0.4337935076260451384870842319133497124524,\n 0.4337935076260451384870842319133497124524,\n -0.5454214713888395356583756172183723700107,\n 0.5454214713888395356583756172183723700107,\n -0.6480936519369755692524957869107476266696,\n 0.6480936519369755692524957869107476266696,\n -0.7401241915785543642438281030999784255232,\n 0.7401241915785543642438281030999784255232,\n -0.8200019859739029219539498726697452080761,\n 0.8200019859739029219539498726697452080761,\n -0.8864155270044010342131543419821967550873,\n 0.8864155270044010342131543419821967550873,\n -0.9382745520027327585236490017087214496548,\n 0.9382745520027327585236490017087214496548,\n -0.9747285559713094981983919930081690617411,\n 0.9747285559713094981983919930081690617411,\n -0.9951872199970213601799974097007368118745,\n 0.9951872199970213601799974097007368118745,\n];\n\nconst Cvalues = [\n 0.1279381953467521569740561652246953718517,\n 0.1279381953467521569740561652246953718517,\n 0.1258374563468282961213753825111836887264,\n 0.1258374563468282961213753825111836887264,\n 0.121670472927803391204463153476262425607,\n 0.121670472927803391204463153476262425607,\n 0.1155056680537256013533444839067835598622,\n 0.1155056680537256013533444839067835598622,\n 0.1074442701159656347825773424466062227946,\n 0.1074442701159656347825773424466062227946,\n 0.0976186521041138882698806644642471544279,\n 0.0976186521041138882698806644642471544279,\n 0.086190161531953275917185202983742667185,\n 0.086190161531953275917185202983742667185,\n 0.0733464814110803057340336152531165181193,\n 0.0733464814110803057340336152531165181193,\n 0.0592985849154367807463677585001085845412,\n 0.0592985849154367807463677585001085845412,\n 0.0442774388174198061686027482113382288593,\n 0.0442774388174198061686027482113382288593,\n 0.0285313886289336631813078159518782864491,\n 0.0285313886289336631813078159518782864491,\n 0.0123412297999871995468056670700372915759,\n 0.0123412297999871995468056670700372915759,\n];\n\n/**\n * @param points\n * @returns\n */\nconst deriveBezier = (points: QuadPoints | CubicPoints) => {\n const dpoints = [] as (DerivedCubicPoints | DerivedQuadPoints)[];\n for (let p = points, d = p.length, c = d - 1; d > 1; d -= 1, c -= 1) {\n const list = [] as unknown as DerivedCubicPoints | DerivedQuadPoints;\n for (let j = 0; j < c; j += 1) {\n list.push({\n x: c * (p[j + 1].x - p[j].x),\n y: c * (p[j + 1].y - p[j].y),\n t: 0,\n });\n }\n dpoints.push(list);\n p = list;\n }\n return dpoints;\n};\n\n/**\n * @param points\n * @param t\n */\nconst computeBezier = (\n points: DerivedQuadPoints | DerivedCubicPoints,\n t: number,\n) => {\n // shortcuts\n /* istanbul ignore next @preserve */\n if (t === 0) {\n points[0].t = 0;\n return points[0];\n }\n\n const order = points.length - 1;\n\n /* istanbul ignore next @preserve */\n if (t === 1) {\n points[order].t = 1;\n return points[order];\n }\n\n const mt = 1 - t;\n let p = points as typeof points | [\n DerivedPoint,\n DerivedPoint,\n DerivedPoint,\n DerivedPoint,\n ];\n\n // constant?\n /* istanbul ignore next @preserve */\n if (order === 0) {\n points[0].t = t;\n return points[0];\n }\n\n // linear?\n /* istanbul ignore else @preserve */\n if (order === 1) {\n return {\n x: mt * p[0].x + t * p[1].x,\n y: mt * p[0].y + t * p[1].y,\n t,\n };\n }\n\n // quadratic/cubic curve?\n const mt2 = mt * mt;\n const t2 = t * t;\n let a = 0;\n let b = 0;\n let c = 0;\n let d = 0;\n /* istanbul ignore else @preserve */\n if (order === 2) {\n p = [p[0], p[1], p[2], { x: 0, y: 0 } as DerivedPoint];\n a = mt2;\n b = mt * t * 2;\n c = t2;\n } else if (order === 3) {\n a = mt2 * mt;\n b = mt2 * t * 3;\n c = mt * t2 * 3;\n d = t * t2;\n }\n return {\n x: a * p[0].x + b * p[1].x + c * p[2].x + d * p[3].x,\n y: a * p[0].y + b * p[1].y + c * p[2].y + d * p[3].y,\n t,\n };\n};\n\nconst calculateBezier = (derivativeFn: DeriveCallback, t: number) => {\n const d = derivativeFn(t);\n const l = d.x * d.x + d.y * d.y;\n\n return Math.sqrt(l);\n};\n\nconst bezierLength = (derivativeFn: DeriveCallback) => {\n const z = 0.5;\n const len = Tvalues.length;\n\n let sum = 0;\n\n for (let i = 0, t; i < len; i++) {\n t = z * Tvalues[i] + z;\n sum += Cvalues[i] * calculateBezier(derivativeFn, t);\n }\n return z * sum;\n};\n\n/**\n * Returns the length of CubicBezier / Quad segment.\n * @param curve cubic / quad bezier segment\n */\nconst getBezierLength = (curve: CubicCoordinates | QuadCoordinates) => {\n const points = [] as unknown as CubicPoints | QuadPoints;\n for (let idx = 0, len = curve.length, step = 2; idx < len; idx += step) {\n points.push({\n x: curve[idx],\n y: curve[idx + 1],\n });\n }\n const dpoints = deriveBezier(points);\n return bezierLength((t: number) => {\n return computeBezier(dpoints[0], t);\n });\n};\n\n// Precision for consider cubic polynom as quadratic one\nconst CBEZIER_MINMAX_EPSILON = 0.00000001;\n\n/**\n * Returns the most extreme points in a Quad Bezier segment.\n * @param A an array which consist of X/Y values\n */\n// https://github.com/kpym/SVGPathy/blob/acd1a50c626b36d81969f6e98e8602e128ba4302/lib/box.js#L89\nconst minmaxQ = ([v1, cp, v2]: [number, number, number]) => {\n const min = Math.min(v1, v2);\n const max = Math.max(v1, v2);\n\n /* istanbul ignore next @preserve */\n if (cp >= v1 ? v2 >= cp : v2 <= cp) {\n // if no extremum in ]0,1[\n return [min, max] as PointTuple;\n }\n\n // check if the extremum E is min or max\n const E = (v1 * v2 - cp * cp) / (v1 - 2 * cp + v2);\n return (E < min ? [E, max] : [min, E]) as PointTuple;\n};\n\n/**\n * Returns the most extreme points in a Cubic Bezier segment.\n * @param A an array which consist of X/Y values\n * @see https://github.com/kpym/SVGPathy/blob/acd1a50c626b36d81969f6e98e8602e128ba4302/lib/box.js#L127\n */\nconst minmaxC = ([v1, cp1, cp2, v2]: [number, number, number, number]) => {\n const K = v1 - 3 * cp1 + 3 * cp2 - v2;\n\n // if the polynomial is (almost) quadratic and not cubic\n /* istanbul ignore next @preserve */\n if (Math.abs(K) < CBEZIER_MINMAX_EPSILON) {\n if (v1 === v2 && v1 === cp1) {\n // no curve, point targeting same location\n return [v1, v2] as PointTuple;\n }\n\n return minmaxQ([v1, -0.5 * v1 + 1.5 * cp1, v1 - 3 * cp1 + 3 * cp2]);\n }\n\n // the reduced discriminant of the derivative\n const T = -v1 * cp2 + v1 * v2 - cp1 * cp2 - cp1 * v2 + cp1 * cp1 + cp2 * cp2;\n\n // if the polynomial is monotone in [0,1]\n if (T <= 0) {\n return [Math.min(v1, v2), Math.max(v1, v2)] as PointTuple;\n }\n const S = Math.sqrt(T);\n\n // potential extrema\n let min = Math.min(v1, v2);\n let max = Math.max(v1, v2);\n\n const L = v1 - 2 * cp1 + cp2;\n // check local extrema\n for (let R = (L + S) / K, i = 1; i <= 2; R = (L - S) / K, i++) {\n // istanbul ignore next @preserve\n if (R > 0 && R < 1) {\n // if the extrema is for R in [0,1]\n const Q = v1 * (1 - R) * (1 - R) * (1 - R) +\n cp1 * 3 * (1 - R) * (1 - R) * R + cp2 * 3 * (1 - R) * R * R +\n v2 * R * R * R;\n if (Q < min) {\n min = Q;\n }\n if (Q > max) {\n max = Q;\n }\n }\n }\n\n return [min, max] as PointTuple;\n};\n\nexport {\n bezierLength,\n calculateBezier,\n CBEZIER_MINMAX_EPSILON,\n computeBezier,\n Cvalues,\n deriveBezier,\n getBezierLength,\n minmaxC,\n minmaxQ,\n Tvalues,\n};\n","import { getBezierLength, minmaxC } from \"./bezier\";\nimport { type CubicCoordinates } from \"../types\";\n\n/**\n * Returns a point at a given length of a CubicBezier segment.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param t a [0-1] ratio\n * @returns the point at cubic-bezier segment length\n */\nconst getPointAtCubicSegmentLength = (\n [x1, y1, c1x, c1y, c2x, c2y, x2, y2]: CubicCoordinates,\n t: number,\n) => {\n const t1 = 1 - t;\n return {\n x: t1 ** 3 * x1 + 3 * t1 ** 2 * t * c1x + 3 * t1 * t ** 2 * c2x +\n t ** 3 * x2,\n y: t1 ** 3 * y1 + 3 * t1 ** 2 * t * c1y + 3 * t1 * t ** 2 * c2y +\n t ** 3 * y2,\n };\n};\n\n/**\n * Returns the length of a CubicBezier segment.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the CubicBezier segment length\n */\nconst getCubicLength = (\n x1: number,\n y1: number,\n c1x: number,\n c1y: number,\n c2x: number,\n c2y: number,\n x2: number,\n y2: number,\n) => {\n return getBezierLength([x1, y1, c1x, c1y, c2x, c2y, x2, y2]);\n};\n\n/**\n * Returns the point along a CubicBezier segment at a given distance.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance the distance to look at\n * @returns the point at CubicBezier length\n */\nconst getPointAtCubicLength = (\n x1: number,\n y1: number,\n c1x: number,\n c1y: number,\n c2x: number,\n c2y: number,\n x2: number,\n y2: number,\n distance?: number,\n) => {\n const distanceIsNumber = typeof distance === \"number\";\n let point = { x: x1, y: y1 };\n /* istanbul ignore else @preserve */\n if (distanceIsNumber) {\n const currentLength = getBezierLength([x1, y1, c1x, c1y, c2x, c2y, x2, y2]);\n if (distance <= 0) {\n // first point already defined\n } else if (distance >= currentLength) {\n point = { x: x2, y: y2 };\n } else {\n point = getPointAtCubicSegmentLength(\n [x1, y1, c1x, c1y, c2x, c2y, x2, y2],\n distance / currentLength,\n );\n }\n }\n return point;\n};\n\n/**\n * Returns the boundig box of a CubicBezier segment in the following format:\n * [MIN_X, MIN_Y, MAX_X, MAX_Y]\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the extrema of the CubicBezier segment\n */\nconst getCubicBBox = (\n x1: number,\n y1: number,\n c1x: number,\n c1y: number,\n c2x: number,\n c2y: number,\n x2: number,\n y2: number,\n) => {\n const cxMinMax = minmaxC([x1, c1x, c2x, x2]);\n const cyMinMax = minmaxC([y1, c1y, c2y, y2]);\n\n return [cxMinMax[0], cyMinMax[0], cxMinMax[1], cyMinMax[1]] as [\n number,\n number,\n number,\n number,\n ];\n};\n\nexport {\n getCubicBBox,\n getCubicLength,\n getPointAtCubicLength,\n getPointAtCubicSegmentLength,\n};\n","import { getBezierLength, minmaxQ } from \"./bezier\";\nimport { type QuadCoordinates } from \"../types\";\n\n/**\n * Returns the {x,y} coordinates of a point at a\n * given length of a quadratic-bezier segment.\n *\n * @see https://github.com/substack/point-at-length\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param cx the control point X\n * @param cy the control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param t a [0-1] ratio\n * @returns the requested {x,y} coordinates\n */\nconst getPointAtQuadSegmentLength = (\n [x1, y1, cx, cy, x2, y2]: QuadCoordinates,\n t: number,\n) => {\n const t1 = 1 - t;\n return {\n x: t1 ** 2 * x1 + 2 * t1 * t * cx + t ** 2 * x2,\n y: t1 ** 2 * y1 + 2 * t1 * t * cy + t ** 2 * y2,\n };\n};\n\n/**\n * Returns the length of a QuadraticBezier segment.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param cx the control point X\n * @param cy the control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the QuadraticBezier segment length\n */\nconst getQuadLength = (\n x1: number,\n y1: number,\n cx: number,\n cy: number,\n x2: number,\n y2: number,\n) => {\n return getBezierLength([x1, y1, cx, cy, x2, y2]);\n};\n\n/**\n * Returns the point along a QuadraticBezier segment at a given distance.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param cx the control point X\n * @param cy the control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance the distance to look at\n * @returns the point at QuadraticBezier length\n */\nconst getPointAtQuadLength = (\n x1: number,\n y1: number,\n cx: number,\n cy: number,\n x2: number,\n y2: number,\n distance?: number,\n) => {\n const distanceIsNumber = typeof distance === \"number\";\n let point = { x: x1, y: y1 };\n\n /* istanbul ignore else @preserve */\n if (distanceIsNumber) {\n const currentLength = getBezierLength([x1, y1, cx, cy, x2, y2]);\n if (distance <= 0) {\n // first point already defined\n } else if (distance >= currentLength) {\n point = { x: x2, y: y2 };\n } else {\n point = getPointAtQuadSegmentLength(\n [x1, y1, cx, cy, x2, y2],\n distance / currentLength,\n );\n }\n }\n return point;\n};\n\n/**\n * Returns the boundig box of a QuadraticBezier segment in the following format:\n * [MIN_X, MIN_Y, MAX_X, MAX_Y]\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param cx the control point X\n * @param cy the control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the extrema of the QuadraticBezier segment\n */\nconst getQuadBBox = (\n x1: number,\n y1: number,\n cx: number,\n cy: number,\n x2: number,\n y2: number,\n) => {\n const cxMinMax = minmaxQ([x1, cx, x2]);\n const cyMinMax = minmaxQ([y1, cy, y2]);\n return [cxMinMax[0], cyMinMax[0], cxMinMax[1], cyMinMax[1]] as [\n number,\n number,\n number,\n number,\n ];\n};\n\nexport {\n getPointAtQuadLength,\n getPointAtQuadSegmentLength,\n getQuadBBox,\n getQuadLength,\n};\n","import distanceSquareRoot from \"./distanceSquareRoot\";\nimport { type PointTuple } from \"../types\";\n\n/**\n * d3-polygon-area\n * https://github.com/d3/d3-polygon\n *\n * Returns the area of a polygon.\n *\n * @param polygon an array of coordinates\n * @returns the polygon area\n */\nconst polygonArea = (polygon: PointTuple[]) => {\n const n = polygon.length;\n let i = -1;\n let a: PointTuple;\n let b = polygon[n - 1];\n let area = 0;\n\n /* eslint-disable-next-line */\n while (++i < n) {\n a = b;\n b = polygon[i];\n area += a[1] * b[0] - a[0] * b[1];\n }\n\n return area / 2;\n};\n\n/**\n * d3-polygon-length\n * https://github.com/d3/d3-polygon\n *\n * Returns the perimeter of a polygon.\n *\n * @param polygon an array of coordinates\n * @returns the polygon length\n */\nconst polygonLength = (polygon: PointTuple[]) => {\n return polygon.reduce((length, point, i) => {\n if (i) {\n return length + distanceSquareRoot(polygon[i - 1], point);\n }\n return 0;\n }, 0);\n};\n\nexport { polygonArea, polygonLength };\n","/** Segment params length */\nconst paramsCount = {\n a: 7,\n c: 6,\n h: 1,\n l: 2,\n m: 2,\n r: 4,\n q: 4,\n s: 4,\n t: 2,\n v: 1,\n z: 0,\n};\n\nexport default paramsCount;\n","import paramsCount from \"./paramsCount\";\nimport PathParser from \"./pathParser\";\nimport type { PathCommand, PathSegment, RelativeCommand } from \"../types\";\n\n/**\n * Breaks the parsing of a pathString once a segment is finalized.\n *\n * @param path the `PathParser` instance\n */\nconst finalizeSegment = (path: PathParser) => {\n let pathCommand = path.pathValue[path.segmentStart] as PathCommand;\n let relativeCommand = pathCommand.toLowerCase() as RelativeCommand;\n const { data } = path;\n\n while (data.length >= paramsCount[relativeCommand]) {\n // overloaded `moveTo`\n // https://github.com/rveciana/svg-path-properties/blob/master/src/parse.ts\n if (relativeCommand === \"m\" && data.length > 2) {\n path.segments.push(\n [pathCommand as PathCommand | number].concat(\n data.splice(0, 2) as number[],\n ) as PathSegment,\n );\n relativeCommand = \"l\";\n pathCommand = pathCommand === \"m\" ? \"l\" : \"L\";\n } else {\n path.segments.push(\n [pathCommand as PathCommand | number].concat(\n data.splice(0, paramsCount[relativeCommand]) as number[],\n ) as PathSegment,\n );\n }\n\n if (!paramsCount[relativeCommand]) {\n break;\n }\n }\n};\nexport default finalizeSegment;\n","const error = \"SVGPathCommander Error\";\nexport default error;\n","import error from \"./error\";\nimport type PathParser from \"./pathParser\";\n\n/**\n * Validates an A (arc-to) specific path command value.\n * Usually a `large-arc-flag` or `sweep-flag`.\n *\n * @param path the `PathParser` instance\n */\nconst scanFlag = (path: PathParser) => {\n const { index, pathValue } = path;\n const code = pathValue.charCodeAt(index);\n\n if (code === 0x30 /* 0 */) {\n path.param = 0;\n path.index += 1;\n return;\n }\n\n if (code === 0x31 /* 1 */) {\n path.param = 1;\n path.index += 1;\n return;\n }\n\n path.err = `${error}: invalid Arc flag \"${\n pathValue[index]\n }\", expecting 0 or 1 at index ${index}`;\n};\n\nexport default scanFlag;\n","import { DigitNumber } from \"../types\";\n\n/**\n * Checks if a character is a digit.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isDigit = (code: number): code is DigitNumber => {\n return code >= 48 && code <= 57; // 0..9\n};\nexport default isDigit;\n","const invalidPathValue = \"Invalid path value\";\nexport default invalidPathValue;\n","import isDigit from \"./isDigit\";\nimport invalidPathValue from \"./invalidPathValue\";\nimport error from \"./error\";\nimport type PathParser from \"./pathParser\";\n\n/**\n * Validates every character of the path string,\n * every path command, negative numbers or floating point numbers.\n *\n * @param path the `PathParser` instance\n */\nconst scanParam = (path: PathParser) => {\n const { max, pathValue, index: start } = path;\n let index = start;\n let zeroFirst = false;\n let hasCeiling = false;\n let hasDecimal = false;\n let hasDot = false;\n let ch;\n\n if (index >= max) {\n path.err =\n `${error}: ${invalidPathValue} at index ${index}, \"pathValue\" is missing param`;\n return;\n }\n ch = pathValue.charCodeAt(index);\n\n if (ch === 0x2b /* + */ || ch === 0x2d /* - */) {\n index += 1;\n // ch = (index < max) ? pathValue.charCodeAt(index) : 0;\n ch = pathValue.charCodeAt(index);\n }\n\n // This logic is shamelessly borrowed from Esprima\n // https://github.com/ariya/esprimas\n if (!isDigit(ch) && ch !== 0x2e /* . */) {\n // path.err = 'SvgPath: param should start with 0..9 or `.` (at pos ' + index + ')';\n path.err = `${error}: ${invalidPathValue} at index ${index}, \"${\n pathValue[index]\n }\" is not a number`;\n return;\n }\n\n if (ch !== 0x2e /* . */) {\n zeroFirst = ch === 0x30 /* 0 */;\n index += 1;\n\n ch = pathValue.charCodeAt(index);\n\n if (zeroFirst && index < max) {\n // decimal number starts with '0' such as '09' is illegal.\n if (ch && isDigit(ch)) {\n // path.err = 'SvgPath: numbers started with `0` such as `09`\n // are illegal (at pos ' + start + ')';\n path.err = `${error}: ${invalidPathValue} at index ${start}, \"${\n pathValue[start]\n }\" illegal number`;\n return;\n }\n }\n\n while (index < max && isDigit(pathValue.charCodeAt(index))) {\n index += 1;\n hasCeiling = true;\n }\n\n ch = pathValue.charCodeAt(index);\n }\n\n if (ch === 0x2e /* . */) {\n hasDot = true;\n index += 1;\n while (isDigit(pathValue.charCodeAt(index))) {\n index += 1;\n hasDecimal = true;\n }\n\n ch = pathValue.charCodeAt(index);\n }\n\n if (ch === 0x65 /* e */ || ch === 0x45 /* E */) {\n if (hasDot && !hasCeiling && !hasDecimal) {\n path.err = `${error}: ${invalidPathValue} at index ${index}, \"${\n pathValue[index]\n }\" invalid float exponent`;\n return;\n }\n\n index += 1;\n\n ch = pathValue.charCodeAt(index);\n\n if (ch === 0x2b /* + */ || ch === 0x2d /* - */) {\n index += 1;\n }\n if (index < max && isDigit(pathValue.charCodeAt(index))) {\n while (index < max && isDigit(pathValue.charCodeAt(index))) {\n index += 1;\n }\n } else {\n path.err = `${error}: ${invalidPathValue} at index ${index}, \"${\n pathValue[index]\n }\" invalid integer exponent`;\n return;\n }\n }\n\n path.index = index;\n path.param = +path.pathValue.slice(start, index);\n};\nexport default scanParam;\n","import type { SpaceNumber } from \"../types\";\n\n/**\n * Checks if the character is a space.\n *\n * @param ch the character to check\n * @returns check result\n */\n\nconst isSpace = (ch: number): ch is SpaceNumber => {\n const allSpaces = [\n // Special spaces\n 0x1680,\n 0x180e,\n 0x2000,\n 0x2001,\n 0x2002,\n 0x2003,\n 0x2004,\n 0x2005,\n 0x2006,\n 0x2007,\n 0x2008,\n 0x2009,\n 0x200a,\n 0x202f,\n 0x205f,\n 0x3000,\n 0xfeff,\n // Line terminators\n 0x0a,\n 0x0d,\n 0x2028,\n 0x2029,\n // White spaces\n 0x20,\n 0x09,\n 0x0b,\n 0x0c,\n 0xa0,\n ];\n\n return allSpaces.includes(ch);\n};\nexport default isSpace;\n","import isSpace from \"./isSpace\";\nimport type PathParser from \"./pathParser\";\n\n/**\n * Points the parser to the next character in the\n * path string every time it encounters any kind of\n * space character.\n *\n * @param path the `PathParser` instance\n */\nconst skipSpaces = (path: PathParser) => {\n const { pathValue, max } = path;\n while (path.index < max && isSpace(pathValue.charCodeAt(path.index))) {\n path.index += 1;\n }\n};\nexport default skipSpaces;\n","import type { PathCommandNumber } from \"../types\";\n\n/**\n * Checks if the character is a path command.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isPathCommand = (code: number): code is PathCommandNumber => {\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy\n switch (code | 0x20) {\n case 0x6d /* m */:\n case 0x7a /* z */:\n case 0x6c /* l */:\n case 0x68 /* h */:\n case 0x76 /* v */:\n case 0x63 /* c */:\n case 0x73 /* s */:\n case 0x71 /* q */:\n case 0x74 /* t */:\n case 0x61 /* a */:\n // case 0x72/* r */:\n return true;\n default:\n return false;\n }\n};\nexport default isPathCommand;\n","import isDigit from \"./isDigit\";\nimport type { DigitNumber } from \"../types\";\n\n/**\n * Checks if the character is or belongs to a number.\n * [0-9]|+|-|.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isDigitStart = (\n code: number,\n): code is DigitNumber | 0x2b | 0x2d | 0x2e => {\n return isDigit(code) /* 0..9 */ || code === 0x2b /* + */ ||\n code === 0x2d /* - */ || code === 0x2e; /* . */\n};\nexport default isDigitStart;\n","/**\n * Checks if the character is an A (arc-to) path command.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isArcCommand = (code: number): code is 0x61 => {\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy\n return (code | 0x20) === 0x61;\n};\nexport default isArcCommand;\n","/**\n * Checks if the character is a MoveTo command.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isMoveCommand = (code: number): code is 0x6d | 0x4d => {\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy\n switch (code | 0x20) {\n case 0x6d /* m */:\n case 0x4d /* M */:\n return true;\n default:\n return false;\n }\n};\nexport default isMoveCommand;\n","import finalizeSegment from \"./finalizeSegment\";\nimport paramCounts from \"./paramsCount\";\nimport scanFlag from \"./scanFlag\";\nimport scanParam from \"./scanParam\";\nimport skipSpaces from \"./skipSpaces\";\nimport isPathCommand from \"./isPathCommand\";\nimport isDigitStart from \"./isDigitStart\";\nimport isArcCommand from \"./isArcCommand\";\nimport isMoveCommand from \"./isMoveCommand\";\nimport invalidPathValue from \"./invalidPathValue\";\nimport error from \"./error\";\n\nimport type PathParser from \"./pathParser\";\nimport type { PathSegment, RelativeCommand } from \"../types\";\n\n/**\n * Scans every character in the path string to determine\n * where a segment starts and where it ends.\n *\n * @param path the `PathParser` instance\n */\nconst scanSegment = (path: PathParser) => {\n const { max, pathValue, index, segments } = path;\n const cmdCode = pathValue.charCodeAt(index);\n const reqParams =\n paramCounts[pathValue[index].toLowerCase() as RelativeCommand];\n\n path.segmentStart = index;\n\n // segments always start with a path command\n if (!isPathCommand(cmdCode)) {\n path.err = `${error}: ${invalidPathValue} \"${\n pathValue[index]\n }\" is not a path command at index ${index}`;\n return;\n }\n\n // after a Z segment, we only expect a MoveTo path command\n const lastSegment = segments[segments.length - 1] as PathSegment | undefined;\n if (\n !isMoveCommand(cmdCode) && lastSegment?.[0]?.toLocaleLowerCase() === \"z\"\n ) {\n path.err = `${error}: ${invalidPathValue} \"${\n pathValue[index]\n }\" is not a MoveTo path command at index ${index}`;\n return;\n }\n\n path.index += 1;\n skipSpaces(path);\n\n path.data = [];\n\n if (!reqParams) {\n // Z\n finalizeSegment(path);\n return;\n }\n\n for (;;) {\n for (let i = reqParams; i > 0; i -= 1) {\n if (isArcCommand(cmdCode) && (i === 3 || i === 4)) scanFlag(path);\n else scanParam(path);\n\n if (path.err.length) {\n return;\n }\n path.data.push(path.param);\n\n skipSpaces(path);\n\n // after ',' param is mandatory\n if (\n path.index < max && pathValue.charCodeAt(path.index) === 0x2c /* , */\n ) {\n path.index += 1;\n skipSpaces(path);\n }\n }\n\n if (path.index >= path.max) {\n break;\n }\n\n // Stop on next segment\n if (!isDigitStart(pathValue.charCodeAt(path.index))) {\n break;\n }\n }\n\n finalizeSegment(path);\n};\nexport default scanSegment;\n","import type { PathArray, PathSegment } from \"../types\";\n\n/**\n * The `PathParser` is used by the `parsePathString` static method\n * to generate a `pathArray`.\n *\n * @param pathString\n */\nexport default class PathParser {\n declare segments: PathArray | PathSegment[];\n declare pathValue: string;\n declare max: number;\n declare index: number;\n declare param: number;\n declare segmentStart: number;\n declare data: (string | number)[];\n declare err: string;\n\n constructor(pathString: string) {\n this.segments = [];\n this.pathValue = pathString;\n this.max = pathString.length;\n this.index = 0;\n this.param = 0.0;\n this.segmentStart = 0;\n this.data = [];\n this.err = \"\";\n }\n}\n","import scanSegment from \"./scanSegment\";\nimport skipSpaces from \"./skipSpaces\";\nimport PathParser from \"./pathParser\";\nimport type { PathArray } from \"../types\";\n\n/**\n * Parses a path string value and returns an array\n * of segments we like to call `pathArray`.\n *\n * @param pathInput the string to be parsed\n * @returns the resulted `pathArray` or error string\n */\nconst parsePathString = (pathInput: string | T) => {\n if (typeof pathInput !== \"string\") {\n return pathInput.slice(0) as typeof pathInput;\n }\n\n const path = new PathParser(pathInput);\n\n skipSpaces(path);\n\n while (path.index < path.max && !path.err.length) {\n scanSegment(path);\n }\n\n // handle valid paths first\n // handle errors second\n if (!path.err.length) {\n if (path.segments.length) {\n /**\n * force absolute first M\n * getPathBBox calculation requires first segment to be absolute\n * @see https://github.com/thednp/svg-path-commander/pull/49\n */\n path.segments[0][0] = \"M\";\n }\n } else {\n throw TypeError(path.err);\n }\n\n return path.segments as PathArray;\n};\n\nexport default parsePathString;\n","import type {\n AbsoluteCommand,\n AbsoluteSegment,\n ASegment,\n CSegment,\n HSegment,\n LSegment,\n MSegment,\n PathSegment,\n QSegment,\n SSegment,\n TSegment,\n VSegment,\n} from \"../types\";\n\n/**\n * Returns an absolute segment of a `PathArray` object.\n *\n * @param segment the segment object\n * @param index the segment index\n * @param lastX the last known X value\n * @param lastY the last known Y value\n * @returns the absolute segment\n */\nconst absolutizeSegment = (\n segment: PathSegment,\n index: number,\n lastX: number,\n lastY: number,\n) => {\n const [pathCommand] = segment;\n const absCommand = pathCommand.toUpperCase() as AbsoluteCommand;\n const isAbsolute = absCommand === pathCommand;\n\n /* istanbul ignore else @preserve */\n if (index === 0 || isAbsolute) return segment as MSegment | AbsoluteSegment;\n // const values = segment.slice(1) as number[];\n if (absCommand === \"A\") {\n return [\n absCommand,\n segment[1],\n segment[2],\n segment[3],\n segment[4],\n segment[5],\n (segment as ASegment)[6] + lastX,\n (segment as ASegment)[7] + lastY,\n ] as ASegment;\n } else if (absCommand === \"V\") {\n return [absCommand, (segment as VSegment)[1] + lastY] as VSegment;\n } else if (absCommand === \"H\") {\n return [absCommand, (segment as HSegment)[1] + lastX] as HSegment;\n } else if (absCommand === \"L\") {\n return [\n absCommand,\n (segment as LSegment)[1] + lastX,\n (segment as LSegment)[2] + lastY,\n ] as LSegment;\n } else {\n // use brakets for `eslint: no-case-declaration`\n // https://stackoverflow.com/a/50753272/803358\n const absValues = [] as number[];\n const seglen = segment.length;\n for (let j = 1; j < seglen; j += 1) {\n absValues.push((segment[j] as number) + (j % 2 ? lastX : lastY));\n }\n // for c, s, q, t\n return [absCommand as typeof absCommand | number].concat(absValues) as\n | MSegment\n | QSegment\n | TSegment\n | SSegment\n | CSegment;\n }\n};\nexport default absolutizeSegment;\n","// import paramsParser from '../parser/paramsParser';\nimport type {\n AbsoluteCommand,\n IteratorCallback,\n PathArray,\n PathCommand,\n PathSegment,\n} from \"../types\";\n\nconst iterate = (\n path: PathArray,\n iterator: IteratorCallback,\n) => {\n let pathLen = path.length;\n let segment: PathSegment;\n let pathCommand = \"M\" as PathCommand;\n let absCommand = \"M\" as AbsoluteCommand;\n let isRelative = false;\n let x = 0;\n let y = 0;\n let mx = 0;\n let my = 0;\n let segLen = 0;\n\n for (let i = 0; i < pathLen; i += 1) {\n segment = path[i];\n [pathCommand] = segment;\n segLen = segment.length;\n absCommand = pathCommand.toUpperCase() as AbsoluteCommand;\n isRelative = absCommand !== pathCommand;\n\n const iteratorResult = iterator(segment, i, x, y);\n // some methods like getPointAtLength would like to break\n // when task is complete\n if (iteratorResult === false) {\n break;\n }\n\n // segment = path[i];\n if (absCommand === \"Z\") {\n x = mx;\n y = my;\n } else if (absCommand === \"H\") {\n x = (segment[1] as number) + (isRelative ? x : 0);\n } else if (absCommand === \"V\") {\n y = (segment[1] as number) + (isRelative ? y : 0);\n } else {\n x = (segment[segLen - 2] as number) + (isRelative ? x : 0);\n y = (segment[segLen - 1] as number) + (isRelative ? y : 0);\n\n if (absCommand === \"M\") {\n mx = x;\n my = y;\n }\n }\n\n if (iteratorResult) {\n path[i] = iteratorResult;\n if (iteratorResult[0] === \"C\") {\n pathLen = path.length;\n }\n }\n }\n return path as T;\n};\n\nexport default iterate;\n","import parsePathString from \"../parser/parsePathString\";\nimport absolutizeSegment from \"../process/absolutizeSegment\";\nimport type { AbsoluteArray, PathArray } from \"../types\";\nimport iterate from \"../process/iterate\";\n\n/**\n * Parses a path string value or object and returns an array\n * of segments, all converted to absolute values.\n *\n * @param pathInput the path string | object\n * @returns the resulted `pathArray` with absolute values\n */\nconst pathToAbsolute = (pathInput: string | PathArray) => {\n const path = parsePathString(pathInput);\n\n return iterate(path, absolutizeSegment);\n};\nexport default pathToAbsolute;\n","import type {\n aSegment,\n cSegment,\n hSegment,\n lSegment,\n MSegment,\n PathSegment,\n qSegment,\n RelativeCommand,\n RelativeSegment,\n sSegment,\n tSegment,\n vSegment,\n} from \"../types\";\n\n/**\n * Returns a relative segment of a `PathArray` object.\n *\n * @param segment the segment object\n * @param index the segment index\n * @param lastX the last known X value\n * @param lastY the last known Y value\n * @returns the relative segment\n */\nconst relativizeSegment = (\n segment: PathSegment,\n index: number,\n lastX: number,\n lastY: number,\n) => {\n const [pathCommand] = segment;\n const relCommand = pathCommand.toLowerCase() as RelativeCommand;\n const isRelative = pathCommand === relCommand;\n\n /* istanbul ignore else @preserve */\n if (index === 0 || isRelative) return segment as MSegment | RelativeSegment;\n\n if (relCommand === \"a\") {\n return [\n relCommand,\n segment[1],\n segment[2],\n segment[3],\n segment[4],\n segment[5],\n (segment as aSegment)[6] - lastX,\n (segment as aSegment)[7] - lastY,\n ] as aSegment;\n } else if (relCommand === \"v\") {\n return [relCommand, (segment as vSegment)[1] - lastY] as vSegment;\n } else if (relCommand === \"h\") {\n return [relCommand, (segment as hSegment)[1] - lastX] as hSegment;\n } else if (relCommand === \"l\") {\n return [\n relCommand,\n (segment as lSegment)[1] - lastX,\n (segment as lSegment)[2] - lastY,\n ] as lSegment;\n } else {\n // use brakets for `eslint: no-case-declaration`\n // https://stackoverflow.com/a/50753272/803358\n const relValues = [] as number[];\n const seglen = segment.length;\n for (let j = 1; j < seglen; j += 1) {\n relValues.push((segment[j] as number) - (j % 2 ? lastX : lastY));\n }\n // for c, s, q, t\n return [relCommand as RelativeCommand | number].concat(relValues) as\n | qSegment\n | tSegment\n | sSegment\n | cSegment;\n }\n};\n\nexport default relativizeSegment;\n","import type { PathArray, RelativeArray } from \"../types\";\nimport parsePathString from \"../parser/parsePathString\";\nimport iterate from \"../process/iterate\";\nimport relativizeSegment from \"../process/relativizeSegment\";\n\n/**\n * Parses a path string value or object and returns an array\n * of segments, all converted to relative values.\n *\n * @param pathInput the path string | object\n * @returns the resulted `pathArray` with relative values\n */\nconst pathToRelative = (pathInput: string | PathArray): RelativeArray => {\n const path = parsePathString(pathInput);\n\n return iterate(path, relativizeSegment);\n};\nexport default pathToRelative;\n","/**\n * Returns an {x,y} vector rotated by a given\n * angle in radian.\n *\n * @param x the initial vector x\n * @param y the initial vector y\n * @param rad the radian vector angle\n * @returns the rotated vector\n */\nconst rotateVector = (\n x: number,\n y: number,\n rad: number,\n): { x: number; y: number } => {\n const { sin, cos } = Math;\n const X = x * cos(rad) - y * sin(rad);\n const Y = x * sin(rad) + y * cos(rad);\n return { x: X, y: Y };\n};\n\nexport default rotateVector;\n","import rotateVector from \"../math/rotateVector\";\n\n/**\n * Converts A (arc-to) segments to C (cubic-bezier-to).\n *\n * For more information of where this math came from visit:\n * http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes\n *\n * @param X1 the starting x position\n * @param Y1 the starting y position\n * @param RX x-radius of the arc\n * @param RY y-radius of the arc\n * @param angle x-axis-rotation of the arc\n * @param LAF large-arc-flag of the arc\n * @param SF sweep-flag of the arc\n * @param X2 the ending x position\n * @param Y2 the ending y position\n * @param recursive the parameters needed to split arc into 2 segments\n * @return the resulting cubic-bezier segment(s)\n */\nconst arcToCubic = (\n X1: number,\n Y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n X2: number,\n Y2: number,\n recursive?: [number, number, number, number],\n): number[] => {\n let x1 = X1;\n let y1 = Y1;\n let rx = RX;\n let ry = RY;\n let x2 = X2;\n let y2 = Y2;\n // for more information of where this Math came from visit:\n // http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes\n const d120 = (Math.PI * 120) / 180;\n\n const rad = (Math.PI / 180) * (+angle || 0);\n let res = [] as number[];\n let xy;\n let f1;\n let f2;\n let cx;\n let cy;\n\n if (!recursive) {\n xy = rotateVector(x1, y1, -rad);\n x1 = xy.x;\n y1 = xy.y;\n xy = rotateVector(x2, y2, -rad);\n x2 = xy.x;\n y2 = xy.y;\n\n const x = (x1 - x2) / 2;\n const y = (y1 - y2) / 2;\n let h = (x * x) / (rx * rx) + (y * y) / (ry * ry);\n if (h > 1) {\n h = Math.sqrt(h);\n rx *= h;\n ry *= h;\n }\n const rx2 = rx * rx;\n const ry2 = ry * ry;\n\n const k = (LAF === SF ? -1 : 1) *\n Math.sqrt(\n Math.abs(\n (rx2 * ry2 - rx2 * y * y - ry2 * x * x) / (rx2 * y * y + ry2 * x * x),\n ),\n );\n\n cx = (k * rx * y) / ry + (x1 + x2) / 2;\n cy = (k * -ry * x) / rx + (y1 + y2) / 2;\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy no-bitwise\n f1 = Math.asin(((((y1 - cy) / ry) * 10 ** 9) >> 0) / 10 ** 9);\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy no-bitwise\n f2 = Math.asin(((((y2 - cy) / ry) * 10 ** 9) >> 0) / 10 ** 9);\n\n f1 = x1 < cx ? Math.PI - f1 : f1;\n f2 = x2 < cx ? Math.PI - f2 : f2;\n if (f1 < 0) f1 = Math.PI * 2 + f1;\n if (f2 < 0) f2 = Math.PI * 2 + f2;\n if (SF && f1 > f2) {\n f1 -= Math.PI * 2;\n }\n if (!SF && f2 > f1) {\n f2 -= Math.PI * 2;\n }\n } else {\n [f1, f2, cx, cy] = recursive;\n }\n let df = f2 - f1;\n if (Math.abs(df) > d120) {\n const f2old = f2;\n const x2old = x2;\n const y2old = y2;\n f2 = f1 + d120 * (SF && f2 > f1 ? 1 : -1);\n x2 = cx + rx * Math.cos(f2);\n y2 = cy + ry * Math.sin(f2);\n res = arcToCubic(x2, y2, rx, ry, angle, 0, SF, x2old, y2old, [\n f2,\n f2old,\n cx,\n cy,\n ]);\n }\n df = f2 - f1;\n const c1 = Math.cos(f1);\n const s1 = Math.sin(f1);\n const c2 = Math.cos(f2);\n const s2 = Math.sin(f2);\n const t = Math.tan(df / 4);\n const hx = (4 / 3) * rx * t;\n const hy = (4 / 3) * ry * t;\n const m1 = [x1, y1];\n const m2 = [x1 + hx * s1, y1 - hy * c1];\n const m3 = [x2 + hx * s2, y2 - hy * c2];\n const m4 = [x2, y2];\n m2[0] = 2 * m1[0] - m2[0];\n m2[1] = 2 * m1[1] - m2[1];\n if (recursive) {\n return [m2[0], m2[1], m3[0], m3[1], m4[0], m4[1]].concat(res);\n }\n res = [m2[0], m2[1], m3[0], m3[1], m4[0], m4[1]].concat(res);\n const newres = [];\n for (let i = 0, ii = res.length; i < ii; i += 1) {\n newres[i] = i % 2\n ? rotateVector(res[i - 1], res[i], rad).y\n : rotateVector(res[i], res[i + 1], rad).x;\n }\n return newres;\n};\nexport default arcToCubic;\n","/**\n * Converts a Q (quadratic-bezier) segment to C (cubic-bezier).\n *\n * @param x1 curve start x\n * @param y1 curve start y\n * @param qx control point x\n * @param qy control point y\n * @param x2 curve end x\n * @param y2 curve end y\n * @returns the cubic-bezier segment\n */\nconst quadToCubic = (\n x1: number,\n y1: number,\n qx: number,\n qy: number,\n x2: number,\n y2: number,\n): [number, number, number, number, number, number] => {\n const r13 = 1 / 3;\n const r23 = 2 / 3;\n return [\n r13 * x1 + r23 * qx, // cpx1\n r13 * y1 + r23 * qy, // cpy1\n r13 * x2 + r23 * qx, // cpx2\n r13 * y2 + r23 * qy, // cpy2\n x2,\n y2, // x,y\n ];\n};\nexport default quadToCubic;\n","import midPoint from \"../math/midPoint\";\n\n/**\n * Converts an L (line-to) segment to C (cubic-bezier).\n *\n * @param x1 line start x\n * @param y1 line start y\n * @param x2 line end x\n * @param y2 line end y\n * @returns the cubic-bezier segment\n */\nconst lineToCubic = (x1: number, y1: number, x2: number, y2: number) => {\n const c1 = midPoint([x1, y1], [x2, y2], 1.0 / 3.0);\n const c2 = midPoint([x1, y1], [x2, y2], 2.0 / 3.0);\n return [c1[0], c1[1], c2[0], c2[1], x2, y2];\n};\nexport default lineToCubic;\n","import arcToCubic from \"./arcToCubic\";\nimport quadToCubic from \"./quadToCubic\";\nimport lineToCubic from \"./lineToCubic\";\nimport type { CSegment, MSegment, PathSegment } from \"../types\";\nimport type { ParserParams } from \"../interface\";\n\n/**\n * Converts any segment to C (cubic-bezier).\n *\n * @param segment the source segment\n * @param params the source segment parameters\n * @returns the cubic-bezier segment\n */\nconst segmentToCubic = (segment: PathSegment, params: ParserParams) => {\n const [pathCommand] = segment;\n const values = segment.slice(1).map(Number);\n const [x, y] = values;\n // let args;\n const { x1: px1, y1: py1, x: px, y: py } = params;\n\n if (!\"TQ\".includes(pathCommand)) {\n params.qx = null;\n params.qy = null;\n }\n\n if (pathCommand === \"M\") {\n params.x = x;\n params.y = y;\n return segment;\n } else if (pathCommand === \"A\") {\n return [\"C\" as string | number].concat(\n arcToCubic(\n px1,\n py1,\n values[0],\n values[1],\n values[2],\n values[3],\n values[4],\n values[5],\n values[6],\n ),\n ) as CSegment;\n } else if (pathCommand === \"Q\") {\n params.qx = x;\n params.qy = y;\n return [\"C\" as string | number].concat(\n quadToCubic(px1, py1, values[0], values[1], values[2], values[3]),\n ) as CSegment;\n } else if (pathCommand === \"L\") {\n return [\"C\" as string | number].concat(\n lineToCubic(px1, py1, x, y),\n ) as CSegment;\n } else if (pathCommand === \"Z\") {\n return [\"C\" as string | number].concat(\n lineToCubic(px1, py1, px, py),\n ) as CSegment;\n }\n\n return segment as MSegment | CSegment;\n};\nexport default segmentToCubic;\n","import type { ParserParams } from \"../interface\";\nimport type {\n ASegment,\n CSegment,\n HSegment,\n LSegment,\n MSegment,\n NormalSegment,\n PathCommand,\n PathSegment,\n PointTuple,\n QSegment,\n VSegment,\n} from \"../types\";\n\n/**\n * Normalizes a single segment of a `pathArray` object.\n *\n * @param segment the segment object\n * @param params the normalization parameters\n * @returns the normalized segment\n */\nconst normalizeSegment = (segment: PathSegment, params: ParserParams) => {\n const [pathCommand] = segment;\n const absCommand = pathCommand.toUpperCase();\n const isRelative = pathCommand !== absCommand;\n const { x1: px1, y1: py1, x2: px2, y2: py2, x, y } = params;\n const values = segment.slice(1) as number[];\n let absValues = values.map((n, j) => n + (isRelative ? (j % 2 ? y : x) : 0));\n\n if (!\"TQ\".includes(absCommand)) {\n // optional but good to be cautious\n params.qx = null;\n params.qy = null;\n }\n\n // istanbul ignore else @preserve\n if (absCommand === \"A\") {\n absValues = values.slice(0, -2).concat(\n values[5] + (isRelative ? x : 0),\n values[6] + (isRelative ? y : 0),\n );\n\n return [\"A\" as PathCommand | number].concat(absValues) as ASegment;\n } else if (absCommand === \"H\") {\n return [\n \"L\",\n (segment as HSegment)[1] + (isRelative ? x : 0),\n py1,\n ] as LSegment;\n } else if (absCommand === \"V\") {\n return [\n \"L\",\n px1,\n (segment as VSegment)[1] + (isRelative ? y : 0),\n ] as LSegment;\n } else if (absCommand === \"L\") {\n return [\n \"L\",\n (segment as LSegment)[1] + (isRelative ? x : 0),\n (segment as LSegment)[2] + (isRelative ? y : 0),\n ] as LSegment;\n } else if (absCommand === \"M\") {\n return [\n \"M\",\n (segment as MSegment)[1] + (isRelative ? x : 0),\n (segment as MSegment)[2] + (isRelative ? y : 0),\n ] as MSegment;\n } else if (absCommand === \"C\") {\n return [\"C\" as PathCommand | number].concat(absValues) as CSegment;\n } else if (absCommand === \"S\") {\n const x1 = px1 * 2 - px2;\n const y1 = py1 * 2 - py2;\n params.x1 = x1;\n params.y1 = y1;\n return [\"C\", x1, y1].concat(absValues) as CSegment;\n } else if (absCommand === \"T\") {\n const qx = px1 * 2 - (params.qx ? params.qx : /* istanbul ignore next */ 0);\n const qy = py1 * 2 - (params.qy ? params.qy : /* istanbul ignore next */ 0);\n params.qx = qx;\n params.qy = qy;\n return [\"Q\", qx, qy].concat(absValues) as QSegment;\n } else if (absCommand === \"Q\") {\n const [nqx, nqy] = absValues as PointTuple;\n params.qx = nqx;\n params.qy = nqy;\n return [\"Q\" as PathCommand | number].concat(absValues) as QSegment;\n } else if (absCommand === \"Z\") {\n return [\"Z\"] as NormalSegment;\n }\n\n // istanbul ignore next @preserve\n return segment as NormalSegment;\n};\nexport default normalizeSegment;\n","import type { ParserParams } from \"../interface\";\n\nconst paramsParser: ParserParams = {\n x1: 0,\n y1: 0,\n x2: 0,\n y2: 0,\n x: 0,\n y: 0,\n qx: null,\n qy: null,\n};\n\nexport default paramsParser;\n","import segmentToCubic from \"../process/segmentToCubic\";\nimport { AbsoluteCommand, CSegment, CurveArray, PathArray } from \"../types\";\nimport iterate from \"../process/iterate\";\nimport parsePathString from \"../parser/parsePathString\";\nimport normalizeSegment from \"../process/normalizeSegment\";\nimport paramsParser from \"../parser/paramsParser\";\n\n/**\n * Parses a path string value or 'pathArray' and returns a new one\n * in which all segments are converted to cubic-bezier.\n *\n * In addition, un-necessary `Z` segment is removed if previous segment\n * extends to the `M` segment.\n *\n * @param pathInput the string to be parsed or 'pathArray'\n * @returns the resulted `pathArray` converted to cubic-bezier\n */\nconst pathToCurve = (pathInput: string | PathArray): CurveArray => {\n const params = { ...paramsParser };\n const path = parsePathString(pathInput);\n\n return iterate(path, (seg, index, lastX, lastY) => {\n params.x = lastX;\n params.y = lastY;\n const normalSegment = normalizeSegment(seg, params);\n let result = segmentToCubic(normalSegment, params);\n const isLongArc = result[0] === \"C\" && result.length > 7;\n\n if (isLongArc) {\n path.splice(\n index + 1,\n 0,\n [\"C\" as AbsoluteCommand | number].concat(result.slice(7)) as CSegment,\n );\n result = result.slice(0, 7) as CSegment;\n }\n\n const seglen = result.length;\n params.x1 = +result[seglen - 2];\n params.y1 = +result[seglen - 1];\n params.x2 = +result[seglen - 4] || params.x1;\n params.y2 = +result[seglen - 3] || params.y1;\n\n return result;\n });\n};\nexport default pathToCurve;\n","import { Options } from \"../interface\";\n\n/** SVGPathCommander default options */\nconst defaultOptions: Options = {\n origin: [0, 0, 0],\n round: 4,\n};\n\nexport default defaultOptions;\n","const roundTo = (n: number, round: number) => {\n const pow = round >= 1 ? 10 ** round : 1;\n\n return round > 0 ? Math.round(n * pow) / pow : Math.round(n);\n};\n\nexport default roundTo;\n","import type { PathArray, PathSegment } from \"../types\";\nimport defaultOptions from \"../options/options\";\nimport roundTo from \"../math/roundTo\";\n\n/**\n * Returns a valid `d` attribute string value created\n * by rounding values and concatenating the `pathArray` segments.\n *\n * @param path the `pathArray` object\n * @param roundOption amount of decimals to round values to\n * @returns the concatenated path string\n */\nconst pathToString = (\n path: PathArray,\n roundOption?: number | \"off\",\n): string => {\n const pathLen = path.length;\n let { round } = defaultOptions;\n let segment = path[0] as PathSegment;\n let result = \"\";\n\n // allow for ZERO decimals\n round = roundOption === \"off\"\n ? roundOption\n : typeof roundOption === \"number\" && roundOption >= 0\n ? roundOption\n : typeof round === \"number\" && round >= 0\n ? round\n : /* istanbul ignore next @preserve */ \"off\";\n\n for (let i = 0; i < pathLen; i += 1) {\n segment = path[i];\n const [pathCommand] = segment;\n const values = segment.slice(1) as number[];\n result += pathCommand;\n if (round === \"off\") {\n result += values.join(\" \");\n } else {\n let j = 0;\n const valLen = values.length;\n while (j < valLen) {\n result += roundTo(values[j], round);\n if (j !== valLen - 1) result += \" \";\n j += 1;\n }\n }\n }\n\n return result;\n};\n\nexport default pathToString;\n","const DISTANCE_EPSILON = 0.00001;\n\nexport default DISTANCE_EPSILON;\n","import normalizeSegment from \"./normalizeSegment\";\nimport type { NormalArray, PathArray } from \"../types\";\nimport iterate from \"./iterate\";\nimport parsePathString from \"../parser/parsePathString\";\nimport paramsParser from \"../parser/paramsParser\";\n\n/**\n * Normalizes a `pathArray` object for further processing:\n * * convert segments to absolute values\n * * convert shorthand path commands to their non-shorthand notation\n *\n * @param pathInput the string to be parsed or 'pathArray'\n * @returns the normalized `pathArray`\n */\nconst normalizePath = (pathInput: string | PathArray) => {\n const path = parsePathString(pathInput);\n const params = { ...paramsParser };\n\n return iterate(path, (seg, _, lastX, lastY) => {\n params.x = lastX;\n params.y = lastY;\n const result = normalizeSegment(seg, params);\n\n const seglen = result.length;\n params.x1 = +result[seglen - 2];\n params.y1 = +result[seglen - 1];\n params.x2 = +result[seglen - 4] || params.x1;\n params.y2 = +result[seglen - 3] || params.y1;\n\n return result;\n });\n};\nexport default normalizePath;\n","import DISTANCE_EPSILON from \"./distanceEpsilon\";\nimport type { MSegment, PathArray, PointTuple } from \"../types\";\nimport iterate from \"../process/iterate\";\nimport { getLineLength, getPointAtLineLength } from \"../math/lineTools\";\nimport { getArcLength, getPointAtArcLength } from \"../math/arcTools\";\nimport { getCubicLength, getPointAtCubicLength } from \"../math/cubicTools\";\nimport { getPointAtQuadLength, getQuadLength } from \"../math/quadTools\";\nimport normalizePath from \"../process/normalizePath\";\n\n/**\n * Returns [x,y] coordinates of a point at a given length of a shape.\n *\n * @param pathInput the `pathArray` to look into\n * @param distance the length of the shape to look at\n * @returns the requested {x, y} point coordinates\n */\nconst getPointAtLength = (pathInput: string | PathArray, distance?: number) => {\n const path = normalizePath(pathInput);\n let isM = false;\n let data = [] as number[];\n let pathCommand = \"M\";\n let x = 0;\n let y = 0;\n let [mx, my] = path[0].slice(1) as PointTuple;\n const distanceIsNumber = typeof distance === \"number\";\n let point = { x: mx, y: my };\n let length = 0;\n let POINT = point;\n let totalLength = 0;\n\n if (!distanceIsNumber || distance < DISTANCE_EPSILON) return point;\n\n // for (let i = 0; i < pathLen; i += 1) {\n iterate(path, (seg, _, lastX, lastY) => {\n [pathCommand] = seg;\n isM = pathCommand === \"M\";\n data = !isM ? [lastX, lastY].concat(seg.slice(1) as number[]) : data;\n\n // this segment is always ZERO\n /* istanbul ignore else @preserve */\n if (isM) {\n // remember mx, my for Z\n [, mx, my] = seg as MSegment;\n point = { x: mx, y: my };\n length = 0;\n } else if (pathCommand === \"L\") {\n point = getPointAtLineLength(\n data[0],\n data[1],\n data[2],\n data[3],\n distance - totalLength,\n );\n length = getLineLength(data[0], data[1], data[2], data[3]);\n } else if (pathCommand === \"A\") {\n point = getPointAtArcLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n data[6],\n data[7],\n data[8],\n distance - totalLength,\n );\n length = getArcLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n data[6],\n data[7],\n data[8],\n );\n } else if (pathCommand === \"C\") {\n point = getPointAtCubicLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n data[6],\n data[7],\n distance - totalLength,\n );\n length = getCubicLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n data[6],\n data[7],\n );\n } else if (pathCommand === \"Q\") {\n point = getPointAtQuadLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n distance - totalLength,\n );\n length = getQuadLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n );\n } else if (pathCommand === \"Z\") {\n data = [lastX, lastY, mx, my];\n point = { x: mx, y: my };\n\n length = getLineLength(data[0], data[1], data[2], data[3]);\n }\n\n [x, y] = data.slice(-2);\n\n if (totalLength < distance) {\n POINT = point;\n } else {\n // totalLength >= distance\n // stop right here\n // stop iterator now!\n return false;\n }\n\n totalLength += length;\n return;\n });\n\n // native `getPointAtLength` behavior when the given distance\n // is higher than total length\n if (distance > totalLength - DISTANCE_EPSILON) {\n return { x, y };\n }\n\n return POINT;\n};\n\nexport default getPointAtLength;\n","import type { LSegment, MSegment, PathArray, PointTuple } from \"../types\";\nimport { getLineLength } from \"../math/lineTools\";\nimport { getArcLength } from \"../math/arcTools\";\nimport { getCubicLength } from \"../math/cubicTools\";\nimport { getQuadLength } from \"../math/quadTools\";\nimport iterate from \"../process/iterate\";\nimport parsePathString from \"../parser/parsePathString\";\nimport absolutizeSegment from \"../process/absolutizeSegment\";\n\n/**\n * Returns the shape total length, or the equivalent to `shape.getTotalLength()`.\n *\n * @param pathInput the target `pathArray`\n * @returns the shape total length\n */\nconst getTotalLength = (pathInput: string | PathArray) => {\n const path = parsePathString(pathInput);\n let paramX1 = 0;\n let paramY1 = 0;\n let paramX2 = 0;\n let paramY2 = 0;\n let paramQX = 0;\n let paramQY = 0;\n let pathCommand = \"M\";\n let mx = 0;\n let my = 0;\n let totalLength = 0;\n\n iterate(path, (seg, index, lastX, lastY) => {\n [pathCommand] = seg;\n const absCommand = pathCommand.toUpperCase();\n const isRelative = absCommand !== pathCommand;\n const absoluteSegment = isRelative\n ? absolutizeSegment(seg, index, lastX, lastY)\n : (seg.slice(0) as typeof seg);\n\n const normalSegment = absCommand === \"V\"\n ? ([\"L\", lastX, absoluteSegment[1]] as LSegment)\n : absCommand === \"H\"\n ? ([\"L\", absoluteSegment[1], lastY] as LSegment)\n : absoluteSegment;\n [pathCommand] = normalSegment;\n\n if (!\"TQ\".includes(absCommand)) {\n // optional but good to be cautious\n paramQX = 0;\n paramQY = 0;\n }\n\n // this segment is always ZERO\n /* istanbul ignore else @preserve */\n if (pathCommand === \"M\") {\n // remember mx, my for Z\n [, mx, my] = normalSegment as MSegment;\n } else if (pathCommand === \"L\") {\n totalLength += getLineLength(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n );\n } else if (pathCommand === \"A\") {\n totalLength += getArcLength(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n normalSegment[5] as number,\n normalSegment[6] as number,\n normalSegment[7] as number,\n );\n } else if (pathCommand === \"S\") {\n const cp1x = paramX1 * 2 - paramX2;\n const cp1y = paramY1 * 2 - paramY2;\n\n totalLength += getCubicLength(\n lastX,\n lastY,\n cp1x,\n cp1y,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n );\n } else if (pathCommand === \"C\") {\n totalLength += getCubicLength(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n normalSegment[5] as number,\n normalSegment[6] as number,\n );\n } else if (pathCommand === \"T\") {\n paramQX = paramX1 * 2 - paramQX;\n paramQY = paramY1 * 2 - paramQY;\n totalLength += getQuadLength(\n lastX,\n lastY,\n paramQX,\n paramQY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n );\n } else if (pathCommand === \"Q\") {\n paramQX = normalSegment[1] as number;\n paramQY = normalSegment[2] as number;\n totalLength += getQuadLength(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n );\n } else if (pathCommand === \"Z\") {\n totalLength += getLineLength(lastX, lastY, mx, my);\n }\n\n // update params\n [paramX1, paramY1] = pathCommand === \"Z\"\n ? [mx, my]\n : (normalSegment.slice(-2) as PointTuple);\n [paramX2, paramY2] = pathCommand === \"C\"\n ? ([normalSegment[3], normalSegment[4]] as PointTuple)\n : pathCommand === \"S\"\n ? ([normalSegment[1], normalSegment[2]] as PointTuple)\n : [paramX1, paramY1];\n });\n\n return totalLength;\n};\n\nexport default getTotalLength;\n","import type { PathArray, PathSegment } from \"../types\";\nimport type { SegmentProperties } from \"../interface\";\nimport parsePathString from \"../parser/parsePathString\";\nimport getTotalLength from \"./getTotalLength\";\n\n/**\n * Returns the segment, its index and length as well as\n * the length to that segment at a given length in a path.\n *\n * @param pathInput target `pathArray`\n * @param distance the given length\n * @returns the requested properties\n */\nconst getPropertiesAtLength = (\n pathInput: string | PathArray,\n distance?: number,\n): SegmentProperties => {\n const pathArray = parsePathString(pathInput);\n\n let pathTemp = pathArray.slice(0) as PathArray;\n let pathLength = getTotalLength(pathTemp);\n let index = pathTemp.length - 1;\n let lengthAtSegment = 0;\n let length = 0;\n let segment = pathArray[0] as PathSegment;\n\n // If the path is empty, return 0.\n if (index <= 0 || !distance || !Number.isFinite(distance)) {\n return {\n segment,\n index: 0,\n length,\n lengthAtSegment,\n };\n }\n\n if (distance >= pathLength) {\n pathTemp = pathArray.slice(0, -1) as PathArray;\n lengthAtSegment = getTotalLength(pathTemp);\n length = pathLength - lengthAtSegment;\n segment = pathArray[index];\n return {\n segment,\n index,\n length,\n lengthAtSegment,\n };\n }\n\n const segments = [] as SegmentProperties[];\n while (index > 0) {\n segment = pathTemp[index];\n pathTemp = pathTemp.slice(0, -1) as PathArray;\n lengthAtSegment = getTotalLength(pathTemp);\n length = pathLength - lengthAtSegment;\n pathLength = lengthAtSegment;\n\n segments.push({\n segment,\n index,\n length,\n lengthAtSegment,\n });\n index -= 1;\n }\n\n return segments.find(({ lengthAtSegment: l }) =>\n l <= distance\n ) as SegmentProperties;\n};\n\nexport default getPropertiesAtLength;\n","import type { PathArray, Point } from \"../types\";\nimport type { PointProperties } from \"../interface\";\nimport getPointAtLength from \"./getPointAtLength\";\nimport getPropertiesAtLength from \"./getPropertiesAtLength\";\nimport getTotalLength from \"./getTotalLength\";\nimport parsePathString from \"../parser/parsePathString\";\nimport normalizePath from \"../process/normalizePath\";\n\n/**\n * Returns the point and segment in path closest to a given point as well as\n * the distance to the path stroke.\n *\n * @see https://bl.ocks.org/mbostock/8027637\n *\n * @param pathInput target `pathArray`\n * @param point the given point\n * @returns the requested properties\n */\nconst getPropertiesAtPoint = (\n pathInput: string | PathArray,\n point: Point,\n): PointProperties => {\n const path = parsePathString(pathInput);\n const normalPath = normalizePath(path);\n const pathLength = getTotalLength(normalPath);\n const distanceTo = (p: Point) => {\n const dx = p.x - point.x;\n const dy = p.y - point.y;\n return dx * dx + dy * dy;\n };\n let precision = 8;\n let scan: Point;\n let closest = { x: 0, y: 0 }; // make TS happy\n let scanDistance = 0;\n let bestLength = 0;\n let bestDistance = Infinity;\n\n // linear scan for coarse approximation\n for (let scanLength = 0; scanLength <= pathLength; scanLength += precision) {\n scan = getPointAtLength(normalPath, scanLength);\n scanDistance = distanceTo(scan);\n\n if (scanDistance < bestDistance) {\n closest = scan;\n bestLength = scanLength;\n bestDistance = scanDistance;\n }\n }\n\n // binary search for precise estimate\n precision /= 2;\n let before: { x: number; y: number };\n let after: { x: number; y: number };\n let beforeLength = 0;\n let afterLength = 0;\n let beforeDistance = 0;\n let afterDistance = 0;\n\n while (precision > 0.000001) {\n beforeLength = bestLength - precision;\n before = getPointAtLength(normalPath, beforeLength);\n beforeDistance = distanceTo(before);\n afterLength = bestLength + precision;\n after = getPointAtLength(normalPath, afterLength);\n afterDistance = distanceTo(after);\n\n if (beforeLength >= 0 && beforeDistance < bestDistance) {\n closest = before;\n bestLength = beforeLength;\n bestDistance = beforeDistance;\n } else if (afterLength <= pathLength && afterDistance < bestDistance) {\n closest = after;\n bestLength = afterLength;\n bestDistance = afterDistance;\n } else {\n precision /= 2;\n }\n if (precision < 0.00001) break;\n }\n\n const segment = getPropertiesAtLength(path, bestLength);\n const distance = Math.sqrt(bestDistance);\n\n return { closest, distance, segment };\n};\n\nexport default getPropertiesAtPoint;\n","import type { PathArray } from \"../types\";\nimport getPropertiesAtPoint from \"./getPropertiesAtPoint\";\n\n/**\n * Returns the point in path closest to a given point.\n *\n * @param pathInput target `pathArray`\n * @param point the given point\n * @returns the best match\n */\nconst getClosestPoint = (\n pathInput: string | PathArray,\n point: { x: number; y: number },\n) => {\n return getPropertiesAtPoint(pathInput, point).closest;\n};\n\nexport default getClosestPoint;\n","import pathToCurve from \"../convert/pathToCurve\";\nimport type { PathArray, PointTuple } from \"../types\";\n\n/**\n * Returns the area of a single cubic-bezier segment.\n *\n * http://objectmix.com/graphics/133553-area-closed-bezier-curve.html\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the area of the cubic-bezier segment\n */\nconst getCubicSegArea = (\n x1: number,\n y1: number,\n c1x: number,\n c1y: number,\n c2x: number,\n c2y: number,\n x2: number,\n y2: number,\n) => {\n return (\n (3 *\n ((y2 - y1) * (c1x + c2x) -\n (x2 - x1) * (c1y + c2y) +\n c1y * (x1 - c2x) -\n c1x * (y1 - c2y) +\n y2 * (c2x + x1 / 3) -\n x2 * (c2y + y1 / 3))) /\n 20\n );\n};\n\n/**\n * Returns the area of a shape.\n *\n * @author Jürg Lehni & Jonathan Puckey\n *\n * @see https://github.com/paperjs/paper.js/blob/develop/src/path/Path.js\n *\n * @param path the shape `pathArray`\n * @returns the length of the cubic-bezier segment\n */\nconst getPathArea = (path: PathArray) => {\n let x = 0;\n let y = 0;\n let len = 0;\n\n return pathToCurve(path)\n .map((seg) => {\n switch (seg[0]) {\n case \"M\":\n [, x, y] = seg;\n return 0;\n default:\n len = getCubicSegArea(\n x,\n y,\n seg[1],\n seg[2],\n seg[3],\n seg[4],\n seg[5],\n seg[6],\n );\n [x, y] = seg.slice(-2) as PointTuple;\n return len;\n }\n })\n .reduce((a, b) => a + b, 0);\n};\nexport default getPathArea;\n","import getPathArea from \"./getPathArea\";\nimport pathToCurve from \"../convert/pathToCurve\";\nimport type { PathArray } from \"../types\";\n\n/**\n * Check if a path is drawn clockwise and returns true if so,\n * false otherwise.\n *\n * @param path the path string or `pathArray`\n * @returns true when clockwise or false if not\n */\nconst getDrawDirection = (path: string | PathArray) => {\n return getPathArea(pathToCurve(path)) >= 0;\n};\n\nexport default getDrawDirection;\n","import iterate from \"../process/iterate\";\nimport { PathBBox } from \"../interface\";\nimport { LSegment, MSegment, PathArray, PointTuple } from \"../types\";\nimport { getLineBBox } from \"../math/lineTools\";\nimport { getArcBBox } from \"../math/arcTools\";\nimport { getCubicBBox } from \"../math/cubicTools\";\nimport { getQuadBBox } from \"../math/quadTools\";\nimport parsePathString from \"../parser/parsePathString\";\nimport absolutizeSegment from \"../process/absolutizeSegment\";\n\nconst getPathBBox = (pathInput: PathArray | string) => {\n if (!pathInput) {\n return {\n x: 0,\n y: 0,\n width: 0,\n height: 0,\n x2: 0,\n y2: 0,\n cx: 0,\n cy: 0,\n cz: 0,\n };\n }\n\n const path = parsePathString(pathInput);\n let pathCommand = \"M\";\n let mx = 0;\n let my = 0;\n const { max, min } = Math;\n let xMin = Infinity;\n let yMin = Infinity;\n let xMax = -Infinity;\n let yMax = -Infinity;\n let minX = 0;\n let minY = 0;\n let maxX = 0;\n let maxY = 0;\n let paramX1 = 0;\n let paramY1 = 0;\n let paramX2 = 0;\n let paramY2 = 0;\n let paramQX = 0;\n let paramQY = 0;\n\n iterate(path, (seg, index, lastX, lastY) => {\n [pathCommand] = seg;\n const absCommand = pathCommand.toUpperCase();\n const isRelative = absCommand !== pathCommand;\n const absoluteSegment = isRelative\n ? absolutizeSegment(seg, index, lastX, lastY)\n : (seg.slice(0) as typeof seg);\n\n const normalSegment = absCommand === \"V\"\n ? ([\"L\", lastX, absoluteSegment[1]] as LSegment)\n : absCommand === \"H\"\n ? ([\"L\", absoluteSegment[1], lastY] as LSegment)\n : absoluteSegment;\n\n [pathCommand] = normalSegment;\n\n if (!\"TQ\".includes(absCommand)) {\n // optional but good to be cautious\n paramQX = 0;\n paramQY = 0;\n }\n\n // this segment is always ZERO\n /* istanbul ignore else @preserve */\n if (pathCommand === \"M\") {\n [, mx, my] = normalSegment as MSegment;\n minX = mx;\n minY = my;\n maxX = mx;\n maxY = my;\n } else if (pathCommand === \"L\") {\n [minX, minY, maxX, maxY] = getLineBBox(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n );\n } else if (pathCommand === \"A\") {\n [minX, minY, maxX, maxY] = getArcBBox(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n normalSegment[5] as number,\n normalSegment[6] as number,\n normalSegment[7] as number,\n );\n } else if (pathCommand === \"S\") {\n const cp1x = paramX1 * 2 - paramX2;\n const cp1y = paramY1 * 2 - paramY2;\n\n [minX, minY, maxX, maxY] = getCubicBBox(\n lastX,\n lastY,\n cp1x,\n cp1y,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n );\n } else if (pathCommand === \"C\") {\n [minX, minY, maxX, maxY] = getCubicBBox(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n normalSegment[5] as number,\n normalSegment[6] as number,\n );\n } else if (pathCommand === \"T\") {\n paramQX = paramX1 * 2 - paramQX;\n paramQY = paramY1 * 2 - paramQY;\n [minX, minY, maxX, maxY] = getQuadBBox(\n lastX,\n lastY,\n paramQX,\n paramQY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n );\n } else if (pathCommand === \"Q\") {\n paramQX = normalSegment[1] as number;\n paramQY = normalSegment[2] as number;\n [minX, minY, maxX, maxY] = getQuadBBox(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n );\n } else if (pathCommand === \"Z\") {\n [minX, minY, maxX, maxY] = getLineBBox(lastX, lastY, mx, my);\n }\n xMin = min(minX, xMin);\n yMin = min(minY, yMin);\n xMax = max(maxX, xMax);\n yMax = max(maxY, yMax);\n\n // update params\n [paramX1, paramY1] = pathCommand === \"Z\"\n ? [mx, my]\n : (normalSegment.slice(-2) as PointTuple);\n [paramX2, paramY2] = pathCommand === \"C\"\n ? ([normalSegment[3], normalSegment[4]] as PointTuple)\n : pathCommand === \"S\"\n ? ([normalSegment[1], normalSegment[2]] as PointTuple)\n : [paramX1, paramY1];\n });\n\n const width = xMax - xMin;\n const height = yMax - yMin;\n\n return {\n width,\n height,\n x: xMin,\n y: yMin,\n x2: xMax,\n y2: yMax,\n cx: xMin + width / 2,\n cy: yMin + height / 2,\n // an estimated guess\n cz: Math.max(width, height) + Math.min(width, height) / 2,\n } satisfies PathBBox;\n};\n\nexport default getPathBBox;\n","import type { PathArray, PathSegment } from \"../types\";\nimport getPropertiesAtLength from \"./getPropertiesAtLength\";\n\n/**\n * Returns the segment at a given length.\n *\n * @param pathInput the target `pathArray`\n * @param distance the distance in path to look at\n * @returns the requested segment\n */\nconst getSegmentAtLength = (\n pathInput: string | PathArray,\n distance?: number,\n): PathSegment | undefined => {\n return getPropertiesAtLength(pathInput, distance).segment;\n};\n\nexport default getSegmentAtLength;\n","import type { SegmentProperties } from \"../interface\";\nimport type { PathArray } from \"../types\";\nimport getPropertiesAtPoint from \"./getPropertiesAtPoint\";\n\n/**\n * Returns the path segment which contains a given point.\n *\n * @param path the `pathArray` to look into\n * @param point the point of the shape to look for\n * @returns the requested segment\n */\nconst getSegmentOfPoint = (\n path: string | PathArray,\n point: { x: number; y: number },\n): SegmentProperties | undefined => {\n return getPropertiesAtPoint(path, point).segment;\n};\nexport default getSegmentOfPoint;\n","import type { PathArray, PathSegment, RelativeCommand } from \"../types\";\nimport paramsCount from \"../parser/paramsCount\";\n\n/**\n * Iterates an array to check if it's an actual `pathArray`.\n *\n * @param path the `pathArray` to be checked\n * @returns iteration result\n */\nconst isPathArray = (path: unknown): path is PathArray => {\n return (\n Array.isArray(path) &&\n path.every((seg: PathSegment) => {\n const lk = seg[0].toLowerCase() as RelativeCommand;\n return (\n paramsCount[lk] === seg.length - 1 &&\n \"achlmqstvz\".includes(lk) &&\n (seg.slice(1) as unknown[]).every(Number.isFinite)\n );\n }) &&\n path.length > 0\n );\n};\nexport default isPathArray;\n","import type { AbsoluteArray } from \"../types\";\nimport isPathArray from \"./isPathArray\";\n\n/**\n * Iterates an array to check if it's a `pathArray`\n * with all absolute values.\n *\n * @param path the `pathArray` to be checked\n * @returns iteration result\n */\nconst isAbsoluteArray = (path: unknown): path is AbsoluteArray => {\n return (\n isPathArray(path) &&\n // `isPathArray` also checks if it's `Array`\n path.every(([x]) => x === x.toUpperCase())\n );\n};\nexport default isAbsoluteArray;\n","import type { NormalArray } from \"../types\";\nimport isAbsoluteArray from \"./isAbsoluteArray\";\n\n/**\n * Iterates an array to check if it's a `pathArray`\n * with all segments are in non-shorthand notation\n * with absolute values.\n *\n * @param {string | SVGPath.pathArray} path the `pathArray` to be checked\n * @returns {boolean} iteration result\n */\nconst isNormalizedArray = (path: unknown): path is NormalArray => {\n // `isAbsoluteArray` also checks if it's `Array`\n return isAbsoluteArray(path) && path.every(([pc]) => \"ACLMQZ\".includes(pc));\n};\nexport default isNormalizedArray;\n","import { CurveArray } from \"../types\";\nimport isNormalizedArray from \"./isNormalizedArray\";\n\n/**\n * Iterates an array to check if it's a `pathArray`\n * with all C (cubic bezier) segments.\n *\n * @param path the `Array` to be checked\n * @returns iteration result\n */\nconst isCurveArray = (path: unknown): path is CurveArray => {\n // `isPathArray` also checks if it's `Array`\n return isNormalizedArray(path) && path.every(([pc]) => \"MC\".includes(pc));\n};\nexport default isCurveArray;\n","import type { PathArray } from \"../types\";\nimport getPropertiesAtPoint from \"./getPropertiesAtPoint\";\nimport DISTANCE_EPSILON from \"./distanceEpsilon\";\n\n/**\n * Checks if a given point is in the stroke of a path.\n *\n * @param pathInput target path\n * @param point the given `{x,y}` point\n * @returns the query result\n */\nconst isPointInStroke = (\n pathInput: string | PathArray,\n point: { x: number; y: number },\n) => {\n const { distance } = getPropertiesAtPoint(pathInput, point);\n return Math.abs(distance) < DISTANCE_EPSILON; // 0.01 might be more permissive\n};\nexport default isPointInStroke;\n","import type { RelativeArray } from \"../types\";\nimport isPathArray from \"./isPathArray\";\n\n/**\n * Iterates an array to check if it's a `pathArray`\n * with relative values.\n *\n * @param path the `pathArray` to be checked\n * @returns iteration result\n */\nconst isRelativeArray = (path: unknown): path is RelativeArray => {\n return (\n isPathArray(path) &&\n // `isPathArray` checks if it's `Array`\n path.slice(1).every(([pc]) => pc === pc.toLowerCase())\n );\n};\nexport default isRelativeArray;\n","import scanSegment from \"../parser/scanSegment\";\nimport skipSpaces from \"../parser/skipSpaces\";\nimport PathParser from \"../parser/pathParser\";\n\n/**\n * Parses a path string value to determine its validity\n * then returns true if it's valid or false otherwise.\n *\n * @param pathString the path string to be parsed\n * @returns the path string validity\n */\nconst isValidPath = (pathString: string) => {\n if (typeof pathString !== \"string\" || !pathString.length) {\n return false;\n }\n\n const path = new PathParser(pathString);\n\n skipSpaces(path);\n\n while (path.index < path.max && !path.err.length) {\n scanSegment(path);\n }\n\n return !path.err.length && \"mM\".includes(path.segments[0][0]);\n};\nexport default isValidPath;\n","import type { ShapeParams } from \"../interface\";\n\n/**\n * Supported shapes and their specific parameters.\n */\nconst shapeParams: ShapeParams = {\n line: [\"x1\", \"y1\", \"x2\", \"y2\"],\n circle: [\"cx\", \"cy\", \"r\"],\n ellipse: [\"cx\", \"cy\", \"rx\", \"ry\"],\n rect: [\"width\", \"height\", \"x\", \"y\", \"rx\", \"ry\"],\n polygon: [\"points\"],\n polyline: [\"points\"],\n glyph: [\"d\"],\n};\n\nexport default shapeParams;\n","const isElement = (node?: unknown): node is Element =>\n node !== undefined && node !== null &&\n typeof node === \"object\" &&\n (node as Node).nodeType === 1; // ELEMENT_NODE\n\nexport default isElement;\n","import type {\n CircleAttr,\n EllipseAttr,\n GlyphAttr,\n LineAttr,\n PolyAttr,\n RectAttr,\n ShapeParams,\n} from \"../interface\";\nimport type { PathArray, PathSegment, ShapeOps, ShapeTypes } from \"../types\";\nimport error from \"../parser/error\";\nimport parsePathString from \"../parser/parsePathString\";\nimport shapeParams from \"./shapeParams\";\nimport isPathArray from \"./isPathArray\";\nimport isElement from \"./isElement\";\n\n/**\n * Returns a new `pathArray` from line attributes.\n *\n * @param attr shape configuration\n * @returns a new line `pathArray`\n */\nexport const getLinePath = (attr: LineAttr): PathArray => {\n let { x1, y1, x2, y2 } = attr;\n [x1, y1, x2, y2] = [x1, y1, x2, y2].map((a) => +a);\n return [\n [\"M\", x1, y1],\n [\"L\", x2, y2],\n ];\n};\n\n/**\n * Returns a new `pathArray` like from polyline/polygon attributes.\n *\n * @param attr shape configuration\n * @return a new polygon/polyline `pathArray`\n */\nexport const getPolyPath = (attr: PolyAttr): PathArray => {\n const pathArray = [] as PathSegment[];\n const points = (attr.points || \"\")\n .trim()\n .split(/[\\s|,]/)\n .map((a) => +a);\n\n let index = 0;\n while (index < points.length) {\n pathArray.push([index ? \"L\" : \"M\", points[index], points[index + 1]]);\n index += 2;\n }\n\n return (attr.type === \"polygon\"\n ? [...pathArray, [\"z\"]]\n : pathArray) as PathArray;\n};\n\n/**\n * Returns a new `pathArray` from circle attributes.\n *\n * @param attr shape configuration\n * @return a circle `pathArray`\n */\nexport const getCirclePath = (attr: CircleAttr): PathArray => {\n let { cx, cy, r } = attr;\n [cx, cy, r] = [cx, cy, r].map((a) => +a);\n\n return [\n [\"M\", cx - r, cy],\n [\"a\", r, r, 0, 1, 0, 2 * r, 0],\n [\"a\", r, r, 0, 1, 0, -2 * r, 0],\n ];\n};\n\n/**\n * Returns a new `pathArray` from ellipse attributes.\n *\n * @param attr shape configuration\n * @return an ellipse `pathArray`\n */\nexport const getEllipsePath = (attr: EllipseAttr): PathArray => {\n let { cx, cy } = attr;\n let rx = attr.rx || 0;\n let ry = attr.ry || rx;\n [cx, cy, rx, ry] = [cx, cy, rx, ry].map((a) => +a);\n\n return [\n [\"M\", cx - rx, cy],\n [\"a\", rx, ry, 0, 1, 0, 2 * rx, 0],\n [\"a\", rx, ry, 0, 1, 0, -2 * rx, 0],\n ];\n};\n\n/**\n * Returns a new `pathArray` like from rect attributes.\n *\n * @param attr object with properties above\n * @return a new `pathArray` from `` attributes\n */\nexport const getRectanglePath = (attr: RectAttr): PathArray => {\n const x = +attr.x || 0;\n const y = +attr.y || 0;\n const w = +attr.width;\n const h = +attr.height;\n let rx = +(attr.rx || 0);\n let ry = +(attr.ry || rx);\n\n // Validity checks from http://www.w3.org/TR/SVG/shapes.html#RectElement:\n if (rx || ry) {\n // rx = !rx ? ry : rx;\n // ry = !ry ? rx : ry;\n\n /* istanbul ignore else @preserve */\n if (rx * 2 > w) rx -= (rx * 2 - w) / 2;\n /* istanbul ignore else @preserve */\n if (ry * 2 > h) ry -= (ry * 2 - h) / 2;\n\n return [\n [\"M\", x + rx, y],\n [\"h\", w - rx * 2],\n [\"s\", rx, 0, rx, ry],\n [\"v\", h - ry * 2],\n [\"s\", 0, ry, -rx, ry],\n [\"h\", -w + rx * 2],\n [\"s\", -rx, 0, -rx, -ry],\n [\"v\", -h + ry * 2],\n [\"s\", 0, -ry, rx, -ry],\n ];\n }\n\n return [[\"M\", x, y], [\"h\", w], [\"v\", h], [\"H\", x], [\"Z\"]];\n};\n\n/**\n * Returns a new `pathArray` created from attributes of a ``, ``,\n * ``, ``, ``, ``, or ``.\n *\n * It can also work with an options object, see the type below\n * @see ShapeOps\n *\n * @param element target shape\n * @return the newly created `` element\n */\nconst shapeToPathArray = (\n element: ShapeTypes | ShapeOps,\n) => {\n const supportedShapes = Object.keys(shapeParams) as (keyof ShapeParams)[];\n const targetIsElement = isElement(element);\n const tagName = targetIsElement ? element.tagName : null;\n\n if (tagName && [...supportedShapes, \"path\"].every((s) => tagName !== s)) {\n throw TypeError(`${error}: \"${tagName}\" is not SVGElement`);\n }\n\n const type =\n (targetIsElement ? tagName : (element as ShapeOps).type) as ShapeOps[\n \"type\"\n ];\n const shapeAttrs = shapeParams[type] as string[];\n const config = { type } as Record;\n\n if (targetIsElement) {\n shapeAttrs.forEach((p) => {\n config[p] = element.getAttribute(p) as string;\n });\n } else {\n Object.assign(config, element);\n }\n\n // set d\n let pathArray = [] as unknown as PathArray;\n\n /* istanbul ignore else */\n if (type === \"circle\") {\n pathArray = getCirclePath(config as unknown as CircleAttr);\n } else if (type === \"ellipse\") {\n pathArray = getEllipsePath(config as unknown as EllipseAttr);\n } else if ([\"polyline\", \"polygon\"].includes(type)) {\n pathArray = getPolyPath(config as unknown as PolyAttr);\n } else if (type === \"rect\") {\n pathArray = getRectanglePath(config as unknown as RectAttr);\n } else if (type === \"line\") {\n pathArray = getLinePath(config as unknown as LineAttr);\n } else if ([\"glyph\", \"path\"].includes(type)) {\n pathArray = parsePathString(\n targetIsElement\n ? element.getAttribute(\"d\") || /* istanbul ignore next @preserve */ \"\"\n : (element as GlyphAttr).d || \"\",\n );\n }\n\n // replace target element\n if (isPathArray(pathArray) && pathArray.length) {\n return pathArray;\n }\n return false;\n};\nexport default shapeToPathArray;\n","import type { ShapeParams } from \"../interface\";\nimport type { ShapeOps, ShapeTypes } from \"../types\";\nimport pathToString from \"../convert/pathToString\";\nimport defaultOptions from \"../options/options\";\nimport error from \"../parser/error\";\nimport isValidPath from \"./isValidPath\";\nimport isElement from \"./isElement\";\nimport shapeToPathArray from \"./shapeToPathArray\";\nimport shapeParams from \"./shapeParams\";\n\n/**\n * Returns a new `` element created from attributes of a ``, ``,\n * ``, ``, ``, `` or ``. If `replace` parameter\n * is `true`, it will replace the target. The default `ownerDocument` is your current\n * `document` browser page, if you want to use in server-side using `jsdom`, you can\n * pass the `jsdom` `document` to `ownDocument`.\n *\n * It can also work with an options object, see the type below\n * @see ShapeOps\n *\n * The newly created `` element keeps all non-specific\n * attributes like `class`, `fill`, etc.\n *\n * @param element target shape\n * @param replace option to replace target\n * @param ownerDocument document for create element\n * @return the newly created `` element\n */\nconst shapeToPath = (\n element: ShapeTypes | ShapeOps,\n replace?: boolean,\n ownerDocument?: Document,\n): SVGPathElement | false => {\n const doc = ownerDocument || document;\n const supportedShapes = Object.keys(shapeParams) as (keyof ShapeParams)[];\n const targetIsElement = isElement(element);\n const tagName = targetIsElement ? element.tagName : null;\n\n if (tagName === \"path\") {\n throw TypeError(`${error}: \"${tagName}\" is already SVGPathElement`);\n }\n if (tagName && supportedShapes.every((s) => tagName !== s)) {\n throw TypeError(`${error}: \"${tagName}\" is not SVGElement`);\n }\n\n const path = doc.createElementNS(\"http://www.w3.org/2000/svg\", \"path\");\n const type =\n (targetIsElement ? tagName : (element as ShapeOps).type) as ShapeOps[\n \"type\"\n ];\n const shapeAttrs = shapeParams[type] as string[];\n const config = { type } as Record;\n\n // set d\n const round = defaultOptions.round as number;\n const pathArray = shapeToPathArray(element);\n const description = pathArray && pathArray.length\n ? pathToString(pathArray, round)\n : \"\";\n\n if (targetIsElement) {\n shapeAttrs.forEach((p) => {\n config[p] = element.getAttribute(p) as string;\n });\n // set no-specific shape attributes: fill, stroke, etc\n Object.values(element.attributes).forEach(({ name, value }) => {\n if (!shapeAttrs.includes(name)) path.setAttribute(name, value);\n });\n } else {\n Object.assign(config, element);\n // set no-specific shape attributes: fill, stroke, etc\n Object.keys(config).forEach((k) => {\n if (!shapeAttrs.includes(k) && k !== \"type\") {\n path.setAttribute(\n k.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`),\n config[k],\n );\n }\n });\n }\n\n // replace target element\n if (isValidPath(description)) {\n path.setAttribute(\"d\", description);\n if (replace && targetIsElement) {\n element.before(path, element);\n element.remove();\n }\n return path;\n }\n return false;\n};\n\nexport default shapeToPath;\n","import CSSMatrix from \"@thednp/dommatrix\";\n// import type { TransformObject } from '../interface';\nimport type { TransformObjectValues } from \"../types\";\n\n/**\n * Returns a transformation matrix to apply to `` elements.\n *\n * @see TransformObjectValues\n *\n * @param transform the `transformObject`\n * @returns a new transformation matrix\n */\nconst getSVGMatrix = (transform: TransformObjectValues): CSSMatrix => {\n let matrix = new CSSMatrix();\n const { origin } = transform;\n const [originX, originY] = origin as [number, number, number];\n const { translate } = transform;\n const { rotate } = transform;\n const { skew } = transform;\n const { scale } = transform;\n\n // set translate\n if (\n Array.isArray(translate) &&\n translate.length >= 2 &&\n translate.every((x) => !Number.isNaN(+x)) &&\n translate.some((x) => x !== 0)\n ) {\n matrix = matrix.translate(...(translate as [number, number, number?]));\n } else if (typeof translate === \"number\" && !Number.isNaN(translate)) {\n matrix = matrix.translate(translate);\n }\n\n if (rotate || skew || scale) {\n // set SVG transform-origin, always defined\n matrix = matrix.translate(originX, originY);\n\n // set rotation\n if (\n Array.isArray(rotate) &&\n rotate.length >= 2 &&\n rotate.every((x) => !Number.isNaN(+x)) &&\n rotate.some((x) => x !== 0)\n ) {\n matrix = matrix.rotate(...(rotate as [number, number, number?]));\n } else if (typeof rotate === \"number\" && !Number.isNaN(rotate)) {\n matrix = matrix.rotate(rotate);\n }\n\n // set skew(s)\n if (\n Array.isArray(skew) && skew.length === 2 && skew.every((x) =>\n !Number.isNaN(+x)\n ) && skew.some((x) => x !== 0)\n ) {\n matrix = skew[0] ? matrix.skewX(skew[0]) : matrix;\n matrix = skew[1] ? matrix.skewY(skew[1]) : matrix;\n } else if (typeof skew === \"number\" && !Number.isNaN(skew)) {\n matrix = matrix.skewX(skew);\n }\n\n // set scale\n if (\n Array.isArray(scale) && scale.length >= 2 && scale.every((x) =>\n !Number.isNaN(+x)\n ) && scale.some((x) => x !== 1)\n ) {\n matrix = matrix.scale(...(scale as [number, number, number?]));\n } else if (typeof scale === \"number\" && !Number.isNaN(scale)) {\n matrix = matrix.scale(scale);\n }\n // set SVG transform-origin\n matrix = matrix.translate(-originX, -originY);\n }\n\n return matrix;\n};\nexport default getSVGMatrix;\n","import defaultOptions from \"../options/options\";\nimport type { ParserParams } from \"../interface\";\nimport roundTo from \"../math/roundTo\";\nimport type {\n AbsoluteSegment,\n NormalSegment,\n PathCommand,\n ShortSegment,\n SSegment,\n TSegment,\n} from \"../types\";\n\n/**\n * Shorten a single segment of a `pathArray` object.\n *\n * @param segment the `absoluteSegment` object\n * @param normalSegment the `normalSegment` object\n * @param params the coordinates of the previous segment\n * @param prevCommand the path command of the previous segment\n * @returns the shortened segment\n */\nconst shortenSegment = (\n segment: AbsoluteSegment,\n normalSegment: NormalSegment,\n params: ParserParams,\n prevCommand: PathCommand,\n): ShortSegment => {\n const [pathCommand] = segment;\n const { round: defaultRound } = defaultOptions;\n const round = typeof defaultRound === \"number\"\n ? defaultRound\n : /* istanbul ignore next */ 4;\n const normalValues = normalSegment.slice(1) as number[];\n const { x1, y1, x2, y2, x, y } = params;\n const [nx, ny] = normalValues.slice(-2);\n const result = segment;\n\n if (!\"TQ\".includes(pathCommand)) {\n // optional but good to be cautious\n params.qx = null;\n params.qy = null;\n }\n\n if (pathCommand === \"L\") {\n if (roundTo(x, round) === roundTo(nx, round)) {\n return [\"V\", ny];\n } else if (roundTo(y, round) === roundTo(ny, round)) {\n return [\"H\", nx];\n }\n } else if (pathCommand === \"C\") {\n const [nx1, ny1] = normalValues;\n params.x1 = nx1;\n params.y1 = ny1;\n\n if (\n \"CS\".includes(prevCommand) &&\n ((roundTo(nx1, round) === roundTo(x1 * 2 - x2, round) &&\n roundTo(ny1, round) === roundTo(y1 * 2 - y2, round)) ||\n (roundTo(x1, round) === roundTo(x2 * 2 - x, round) &&\n roundTo(y1, round) === roundTo(y2 * 2 - y, round)))\n ) {\n return [\n \"S\",\n normalValues[2],\n normalValues[3],\n normalValues[4],\n normalValues[5],\n ] as SSegment;\n }\n } else if (pathCommand === \"Q\") {\n const [qx, qy] = normalValues;\n params.qx = qx;\n params.qy = qy;\n\n if (\n \"QT\".includes(prevCommand) &&\n roundTo(qx, round) === roundTo(x1 * 2 - x2, round) &&\n roundTo(qy, round) === roundTo(y1 * 2 - y2, round)\n ) {\n return [\"T\", normalValues[2], normalValues[3]] as TSegment;\n }\n }\n\n // ['V', 'H', 'S', 'T', 'Z'].includes(pathCommand)\n return result as ShortSegment;\n};\n\nexport default shortenSegment;\n","import type { PathCommand, PathSegment } from \"../types\";\nimport roundTo from \"../math/roundTo\";\n\nconst roundSegment = (\n segment: T,\n roundOption: number,\n) => {\n const values = (segment.slice(1) as number[]).map((n) =>\n roundTo(n, roundOption)\n );\n return [segment[0] as PathCommand | number].concat(values) as T;\n};\n\nexport default roundSegment;\n","import type { AbsoluteSegment, PathArray, PathCommand } from \"../types\";\nimport pathToAbsolute from \"../convert/pathToAbsolute\";\nimport shortenSegment from \"./shortenSegment\";\nimport paramsParser from \"../parser/paramsParser\";\nimport iterate from \"./iterate\";\nimport normalizeSegment from \"./normalizeSegment\";\nimport relativizeSegment from \"./relativizeSegment\";\nimport roundSegment from \"./roundSegment\";\n\n/**\n * Optimizes a `pathArray` object:\n * * convert segments to shorthand if possible\n * * select shortest segments from absolute and relative `pathArray`s\n *\n * @param pathInput a string or `pathArray`\n * @param roundOption the amount of decimals to round values to\n * @returns the optimized `pathArray`\n */\nconst optimizePath = (pathInput: PathArray, roundOption?: number) => {\n const path = pathToAbsolute(pathInput);\n // allow for ZERO decimals or use an aggressive value of 2\n const round = typeof roundOption === \"number\" && roundOption >= 0\n ? roundOption\n : /* istanbul ignore next @preserve */ 2;\n // this utility overrides the iterator params\n const optimParams = { ...paramsParser };\n\n const allPathCommands = [] as PathCommand[];\n let pathCommand = \"M\" as PathCommand;\n let prevCommand = \"Z\" as PathCommand;\n\n return iterate(path, (seg, i, lastX, lastY) => {\n optimParams.x = lastX;\n optimParams.y = lastY;\n const normalizedSegment = normalizeSegment(seg, optimParams);\n let result = seg;\n [pathCommand] = seg;\n\n // Save current path command\n allPathCommands[i] = pathCommand;\n if (i) {\n // Get previous path command for `shortenSegment`\n prevCommand = allPathCommands[i - 1];\n const shortSegment = shortenSegment(\n seg as AbsoluteSegment,\n normalizedSegment,\n optimParams,\n prevCommand,\n );\n const absSegment = roundSegment(shortSegment, round);\n const absString = absSegment.join(\"\");\n const relativeSegment = relativizeSegment(shortSegment, i, lastX, lastY);\n const relSegment = roundSegment(relativeSegment, round);\n const relString = relSegment.join(\"\");\n result = absString.length < relString.length ? absSegment : relSegment;\n }\n\n const seglen = normalizedSegment.length;\n optimParams.x1 = +normalizedSegment[seglen - 2];\n optimParams.y1 = +normalizedSegment[seglen - 1];\n optimParams.x2 = +normalizedSegment[seglen - 4] || optimParams.x1;\n optimParams.y2 = +normalizedSegment[seglen - 3] || optimParams.y1;\n\n return result;\n });\n};\n\nexport default optimizePath;\n","import CSSMatrix from \"@thednp/dommatrix\";\nimport { type PointTuple } from \"../types\";\n\n/**\n * Transforms a specified point using a matrix, returning a new\n * Tuple *Object* comprising of the transformed point.\n * Neither the matrix nor the original point are altered.\n *\n * @copyright thednp © 2021\n *\n * @param cssm CSSMatrix instance\n * @param v Tuple\n * @return the resulting Tuple\n */\nconst translatePoint = (\n cssm: CSSMatrix,\n v: [number, number, number, number],\n): [number, number, number, number] => {\n let m = CSSMatrix.Translate(v[0], v[1], v[2]);\n\n [, , , m.m44] = v;\n m = cssm.multiply(m);\n\n return [m.m41, m.m42, m.m43, m.m44];\n};\n\n/**\n * Returns the [x,y] projected coordinates for a given an [x,y] point\n * and an [x,y,z] perspective origin point.\n *\n * Equation found here =>\n * http://en.wikipedia.org/wiki/3D_projection#Diagram\n * Details =>\n * https://stackoverflow.com/questions/23792505/predicted-rendering-of-css-3d-transformed-pixel\n *\n * @param m the transformation matrix\n * @param point2D the initial [x,y] coordinates\n * @param origin the [x,y,z] transform origin\n * @returns the projected [x,y] coordinates\n */\nconst projection2d = (\n m: CSSMatrix,\n point2D: PointTuple,\n origin: [number, number, number],\n): PointTuple => {\n const [originX, originY, originZ] = origin;\n const [x, y, z] = translatePoint(m, [point2D[0], point2D[1], 0, 1]);\n\n const relativePositionX = x - originX;\n const relativePositionY = y - originY;\n const relativePositionZ = z - originZ;\n\n return [\n // protect against division by ZERO\n relativePositionX * (Math.abs(originZ) / Math.abs(relativePositionZ) || 1) +\n originX,\n relativePositionY * (Math.abs(originZ) / Math.abs(relativePositionZ) || 1) +\n originY,\n ];\n};\nexport default projection2d;\n","import type { CSegment, CurveArray, MSegment, PathCommand } from \"../types\";\n\n/**\n * Reverses all segments of a `pathArray`\n * which consists of only C (cubic-bezier) path commands.\n *\n * @param path the source `pathArray`\n * @returns the reversed `pathArray`\n */\nconst reverseCurve = (path: CurveArray) => {\n const rotatedCurve = path\n .slice(1)\n .map((x, i, curveOnly) =>\n !i\n ? path[0].slice(1).concat(x.slice(1) as number[])\n : curveOnly[i - 1].slice(-2).concat(x.slice(1))\n )\n .map((x) => x.map((_, i) => x[x.length - i - 2 * (1 - (i % 2))]))\n .reverse() as (MSegment | CSegment)[];\n\n return [[\"M\" as PathCommand | number].concat(rotatedCurve[0].slice(0, 2))]\n .concat(\n rotatedCurve.map((x) => [\"C\" as PathCommand | number].concat(x.slice(2))),\n ) as CurveArray;\n};\n\nexport default reverseCurve;\n","import type {\n ASegment,\n CSegment,\n HSegment,\n MSegment,\n PathArray,\n PathSegment,\n PointTuple,\n QSegment,\n SSegment,\n TSegment,\n VSegment,\n} from \"../types\";\nimport pathToAbsolute from \"../convert/pathToAbsolute\";\nimport normalizePath from \"./normalizePath\";\nimport iterate from \"./iterate\";\n\n/**\n * Reverses all segments of a `pathArray` and returns a new `pathArray` instance\n * with absolute values.\n *\n * @param pathInput the source `pathArray`\n * @returns the reversed `pathArray`\n */\nconst reversePath = (pathInput: PathArray) => {\n const absolutePath = pathToAbsolute(pathInput);\n const normalizedPath = normalizePath(absolutePath);\n const pLen = absolutePath.length;\n const isClosed = absolutePath[pLen - 1][0] === \"Z\";\n\n const reversedPath = iterate(absolutePath, (segment, i) => {\n const normalizedSegment = normalizedPath[i];\n const prevSeg = i && absolutePath[i - 1];\n const prevCommand = prevSeg && prevSeg[0];\n const nextSeg = absolutePath[i + 1];\n const nextCommand = nextSeg && nextSeg[0];\n const [pathCommand] = segment;\n const [x, y] = normalizedPath[i ? i - 1 : pLen - 1].slice(-2) as PointTuple;\n let result = segment;\n\n switch (pathCommand) {\n case \"M\":\n result = (isClosed ? [\"Z\"] : [pathCommand, x, y]) as PathSegment;\n break;\n case \"A\":\n result = [\n pathCommand,\n segment[1],\n segment[2],\n segment[3],\n segment[4],\n segment[5] === 1 ? 0 : 1,\n x,\n y,\n ] as ASegment;\n break;\n case \"C\":\n if (nextSeg && nextCommand === \"S\") {\n result = [\"S\", segment[1], segment[2], x, y] as SSegment;\n } else {\n result = [\n pathCommand,\n segment[3],\n segment[4],\n segment[1],\n segment[2],\n x,\n y,\n ] as CSegment;\n }\n break;\n case \"S\":\n if (\n prevCommand && \"CS\".includes(prevCommand) &&\n (!nextSeg || nextCommand !== \"S\")\n ) {\n result = [\n \"C\",\n normalizedSegment[3],\n normalizedSegment[4],\n normalizedSegment[1],\n normalizedSegment[2],\n x,\n y,\n ] as CSegment;\n } else {\n result = [\n pathCommand,\n normalizedSegment[1],\n normalizedSegment[2],\n x,\n y,\n ] as SSegment;\n }\n break;\n case \"Q\":\n if (nextSeg && nextCommand === \"T\") {\n result = [\"T\", x, y] as TSegment;\n } else {\n result = [pathCommand, segment[1], segment[2], x, y] as QSegment;\n }\n break;\n case \"T\":\n if (\n prevCommand && \"QT\".includes(prevCommand) &&\n (!nextSeg || nextCommand !== \"T\")\n ) {\n result = [\n \"Q\",\n normalizedSegment[1],\n normalizedSegment[2],\n x,\n y,\n ] as QSegment;\n } else {\n result = [pathCommand, x, y] as TSegment;\n }\n break;\n case \"Z\":\n result = [\"M\", x, y] as MSegment;\n break;\n case \"H\":\n result = [pathCommand, x] as HSegment;\n break;\n case \"V\":\n result = [pathCommand, y] as VSegment;\n break;\n default:\n result = [pathCommand as typeof pathCommand | number].concat(\n segment.slice(1, -2),\n x,\n y,\n ) as PathSegment;\n }\n\n return result;\n });\n\n return (\n isClosed\n ? reversedPath.reverse()\n : [reversedPath[0] as PathSegment].concat(reversedPath.slice(1).reverse())\n ) as PathArray;\n};\n\nexport default reversePath;\n","import type { PathArray } from \"../types\";\nimport defaultOptions from \"../options/options\";\nimport iterate from \"./iterate\";\nimport roundSegment from \"./roundSegment\";\n\n/**\n * Rounds the values of a `pathArray` instance to\n * a specified amount of decimals and returns it.\n *\n * @param path the source `pathArray`\n * @param roundOption the amount of decimals to round numbers to\n * @returns the resulted `pathArray` with rounded values\n */\nconst roundPath = (path: PathArray, roundOption?: number | \"off\") => {\n let { round } = defaultOptions;\n // allow for ZERO decimals\n round = roundOption === \"off\"\n ? roundOption\n : typeof roundOption === \"number\" && roundOption >= 0\n ? roundOption\n : typeof round === \"number\" && round >= 0\n ? round\n : /* istanbul ignore next @preserve */ \"off\";\n\n /* istanbul ignore else @preserve */\n if (round === \"off\") return path.slice(0) as PathArray;\n\n return iterate(path, (segment) => {\n return roundSegment(segment, round);\n });\n};\nexport default roundPath;\n","import midPoint from \"../math/midPoint\";\nimport type { CubicSegment, PointTuple } from \"../types\";\n\n/**\n * Split a cubic-bezier segment into two.\n *\n * @param pts the cubic-bezier parameters\n * @param ratio the cubic-bezier parameters\n * @return two new cubic-bezier segments\n */\nconst splitCubic = (\n pts: number[],\n ratio = 0.5,\n): [CubicSegment, CubicSegment] => {\n const t = ratio;\n const p0 = pts.slice(0, 2) as PointTuple;\n const p1 = pts.slice(2, 4) as PointTuple;\n const p2 = pts.slice(4, 6) as PointTuple;\n const p3 = pts.slice(6, 8) as PointTuple;\n const p4 = midPoint(p0, p1, t);\n const p5 = midPoint(p1, p2, t);\n const p6 = midPoint(p2, p3, t);\n const p7 = midPoint(p4, p5, t);\n const p8 = midPoint(p5, p6, t);\n const p9 = midPoint(p7, p8, t);\n\n return [\n [\"C\", p4[0], p4[1], p7[0], p7[1], p9[0], p9[1]],\n [\"C\", p8[0], p8[1], p6[0], p6[1], p3[0], p3[1]],\n ];\n};\nexport default splitCubic;\n","import paramsParser from \"../parser/paramsParser\";\nimport type {\n AbsoluteCommand,\n HSegment,\n MSegment,\n PathArray,\n PointTuple,\n RelativeCommand,\n VSegment,\n} from \"../types\";\n\n/**\n * Split a path into an `Array` of sub-path strings.\n *\n * In the process, values are converted to absolute\n * for visual consistency.\n *\n * @param pathInput the source `pathArray`\n * @return an array with all sub-path strings\n */\nconst splitPath = (pathInput: PathArray): PathArray[] => {\n const composite = [] as PathArray[];\n let path: PathArray;\n let pi = -1;\n let x = 0;\n let y = 0;\n let mx = 0;\n let my = 0;\n const params = { ...paramsParser };\n\n pathInput.forEach((seg) => {\n const [pathCommand] = seg;\n const absCommand = pathCommand.toUpperCase() as AbsoluteCommand;\n const relCommand = pathCommand.toLowerCase() as RelativeCommand;\n const isRelative = pathCommand === relCommand;\n const values = seg.slice(1) as number[];\n\n if (absCommand === \"M\") {\n pi += 1;\n [x, y] = values as PointTuple;\n x += isRelative ? params.x : 0;\n y += isRelative ? params.y : 0;\n mx = x;\n my = y;\n path = [(isRelative ? [absCommand, mx, my] : seg) as MSegment];\n } else {\n if (absCommand === \"Z\") {\n x = mx;\n y = my;\n } else if (absCommand === \"H\") {\n [, x] = seg as HSegment;\n x += isRelative ? params.x : /* istanbul ignore next @preserve */ 0;\n } else if (absCommand === \"V\") {\n [, y] = seg as VSegment;\n y += isRelative ? params.y : /* istanbul ignore next @preserve */ 0;\n } else {\n [x, y] = seg.slice(-2) as PointTuple;\n x += isRelative ? params.x : 0;\n y += isRelative ? params.y : 0;\n }\n path.push(seg);\n }\n\n params.x = x;\n params.y = y;\n composite[pi] = path;\n });\n\n return composite;\n};\nexport default splitPath;\n","import getSVGMatrix from \"./getSVGMatrix\";\nimport projection2d from \"./projection2d\";\nimport defaultOptions from \"../options/options\";\nimport type {\n AbsoluteArray,\n AbsoluteSegment,\n CSegment,\n LSegment,\n PathArray,\n TransformObjectValues,\n} from \"../types\";\nimport type { TransformObject } from \"../interface\";\nimport iterate from \"./iterate\";\nimport parsePathString from \"../parser/parsePathString\";\nimport absolutizeSegment from \"./absolutizeSegment\";\nimport arcToCubic from \"./arcToCubic\";\n\n/**\n * Apply a 2D / 3D transformation to a `pathArray` instance.\n *\n * Since *SVGElement* doesn't support 3D transformation, this function\n * creates a 2D projection of the element.\n *\n * @param path the `pathArray` to apply transformation\n * @param transform the transform functions `Object`\n * @returns the resulted `pathArray`\n */\nconst transformPath = (\n pathInput: PathArray | string,\n transform?: Partial,\n) => {\n // last x and y transformed values\n let x = 0;\n let y = 0;\n // new x and y transformed\n let lx = 0;\n let ly = 0;\n // segment params iteration index and length\n let j = 0;\n let jj = 0;\n let pathCommand = \"M\";\n // transform uses it's own set of params\n const path = parsePathString(pathInput);\n const transformProps = transform && Object.keys(transform);\n\n // when used as a static method, invalidate somehow\n if (!transform || (transformProps && !transformProps.length)) {\n return path.slice(0) as typeof path;\n }\n\n // transform origin is extremely important\n if (!transform.origin) {\n Object.assign(transform, { origin: defaultOptions.origin });\n }\n const origin = transform.origin as [number, number, number];\n const matrixInstance = getSVGMatrix(transform as TransformObjectValues);\n\n if (matrixInstance.isIdentity) return path.slice(0) as typeof path;\n\n return iterate(path, (seg, index, lastX, lastY) => {\n [pathCommand] = seg;\n const absCommand = pathCommand.toUpperCase();\n const isRelative = absCommand !== pathCommand;\n const absoluteSegment = isRelative\n ? absolutizeSegment(seg, index, lastX, lastY)\n : (seg.slice(0) as AbsoluteSegment);\n\n let result = absCommand === \"A\"\n // ? segmentToCubic(absoluteSegment, transformParams)\n ? ([\"C\" as string | number].concat(\n arcToCubic(\n lastX,\n lastY,\n absoluteSegment[1] as number,\n absoluteSegment[2] as number,\n absoluteSegment[3] as number,\n absoluteSegment[4] as number,\n absoluteSegment[5] as number,\n absoluteSegment[6] as number,\n absoluteSegment[7] as number,\n ),\n ) as CSegment)\n : absCommand === \"V\"\n ? ([\"L\", lastX, absoluteSegment[1]] as LSegment)\n : absCommand === \"H\"\n ? ([\"L\", absoluteSegment[1], lastY] as LSegment)\n : absoluteSegment;\n\n // update pathCommand\n pathCommand = result[0];\n const isLongArc = pathCommand === \"C\" && result.length > 7;\n const tempSegment =\n (isLongArc ? result.slice(0, 7) : result.slice(0)) as AbsoluteSegment;\n\n if (isLongArc) {\n path.splice(\n index + 1,\n 0,\n [\"C\" as typeof pathCommand | number].concat(\n result.slice(7),\n ) as CSegment,\n );\n result = tempSegment as CSegment;\n }\n\n if (pathCommand === \"L\") {\n [lx, ly] = projection2d(matrixInstance, [\n (result as LSegment)[1],\n (result as LSegment)[2],\n ], origin);\n\n /* istanbul ignore else @preserve */\n if (x !== lx && y !== ly) {\n result = [\"L\", lx, ly];\n } else if (y === ly) {\n result = [\"H\", lx];\n } else if (x === lx) {\n result = [\"V\", ly];\n }\n } else {\n for (j = 1, jj = result.length; j < jj; j += 2) {\n [lx, ly] = projection2d(\n matrixInstance,\n [+result[j], +result[j + 1]],\n origin,\n );\n result[j] = lx;\n result[j + 1] = ly;\n }\n }\n // now update x and y\n x = lx;\n y = ly;\n\n return result;\n });\n};\n\nexport default transformPath;\n"],"mappings":"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","names":["util_exports","__export","y","absolutizeSegment_default","arcToCubic_default","arcTools_exports","bezier_exports","cubicTools_exports","distanceEpsilon_default","distanceSquareRoot_default","finalizeSegment_default","getClosestPoint_default","getDrawDirection_default","getPathArea_default","getPathBBox_default","getPointAtLength_default","getPropertiesAtLength_default","getPropertiesAtPoint_default","getSVGMatrix_default","getSegmentAtLength_default","getSegmentOfPoint_default","getTotalLength_default","invalidPathValue_default","isAbsoluteArray_default","isArcCommand_default","isCurveArray_default","isDigit_default","isDigitStart_default","isMoveCommand_default","isNormalizedArray_default","isPathArray_default","isPathCommand_default","isPointInStroke_default","isRelativeArray_default","isSpace_default","isValidPath_default","iterate_default","lineToCubic_default","lineTools_exports","midPoint_default","normalizePath_default","normalizeSegment_default","optimizePath_default","paramsCount_default","paramsParser_default","parsePathString_default","PathParser","pathToAbsolute_default","pathToCurve_default","pathToRelative_default","pathToString_default","polygonTools_exports","projection2d_default","quadToCubic_default","quadTools_exports","relativizeSegment_default","reverseCurve_default","reversePath_default","rotateVector_default","roundPath_default","roundSegment_default","roundTo_default","scanFlag_default","scanParam_default","scanSegment_default","segmentToCubic_default","shapeParams_default","shapeToPath_default","shapeToPathArray_default","shortenSegment_default","skipSpaces_default","splitCubic_default","splitPath_default","transformPath_default","JSON_MATRIX","isCompatibleArray","array","x","isCompatibleObject","object","CSSMatrix","k","fromArray","m","a","m11","m12","m13","m14","m21","m22","m23","m24","m31","m32","m33","m34","m41","m42","m43","m44","M11","M12","M21","M22","M41","M42","fromMatrix","fromString","source","str","invalidStringError","f","tf","prop","value","components","n","y","z","xyz","xyza","values","sy","p","fn","axis","idx","def","axeValues","toArray","is2D","Translate","Rotate","rx","ry","rz","degToRad","radX","radY","radZ","cosx","sinx","cosy","siny","cosz","sinz","RotateAxisAngle","alpha","length","X","Y","Z","angle","sinA","cosA","sinA2","x2","y2","z2","Scale","Skew","angleX","angleY","tX","tY","SkewX","SkewY","Multiply","m1","m2","init","isIdentity","RX","RY","RZ","t","w","__publicField","arcTools_exports","__export","angleBetween","arcLength","arcPoint","getArcBBox","getArcLength","getArcProps","getPointAtArcLength","lineTools_exports","__export","getLineBBox","getLineLength","getPointAtLineLength","midPoint","a","b","t","ax","ay","bx","by","midPoint_default","distanceSquareRoot","a","b","distanceSquareRoot_default","getLineLength","x1","y1","x2","y2","distanceSquareRoot_default","getPointAtLineLength","distance","point","length","x","y","midPoint_default","getLineBBox","min","max","arcLength","rx","ry","theta","halfTheta","sinHalfTheta","cosHalfTheta","term1","term2","length","arcPoint","cx","cy","alpha","sin","cos","cosA","sinA","x","y","angleBetween","v0","v1","v0x","v0y","v1x","v1y","p","n","getArcProps","x1","y1","RX","RY","angle","LAF","SF","abs","sqrt","PI","xRotRad","dx","dy","transformedPoint","radiiCheck","cSquareNumerator","cSquareRootDenom","cRadicand","cCoef","transformedCenter","center","startVector","startAngle","endVector","sweepAngle","endAngle","getArcLength","getPointAtArcLength","distance","point","getPointAtLineLength","ellipseComponentX","ellipseComponentY","getArcBBox","deltaAngle","min","max","tan","atan2","tangent","angle1","angle2","angle3","angle4","xArray","yArray","xMin","xMax","yMin","yMax","angleAfterStart","pP2","angleBeforeEnd","pP3","p1","p2","p4","p3","bezier_exports","__export","CBEZIER_MINMAX_EPSILON","Cvalues","Tvalues","bezierLength","calculateBezier","computeBezier","deriveBezier","getBezierLength","minmaxC","minmaxQ","points","dpoints","p","d","c","list","j","t","order","mt","mt2","t2","a","b","derivativeFn","l","len","sum","i","curve","idx","step","v1","cp","v2","min","max","E","cp1","cp2","K","T","S","L","R","Q","cubicTools_exports","__export","getCubicBBox","getCubicLength","getPointAtCubicLength","getPointAtCubicSegmentLength","getPointAtCubicSegmentLength","x1","y1","c1x","c1y","c2x","c2y","x2","y2","t","t1","getCubicLength","getBezierLength","getPointAtCubicLength","distance","distanceIsNumber","point","currentLength","getCubicBBox","cxMinMax","minmaxC","cyMinMax","quadTools_exports","__export","getPointAtQuadLength","getPointAtQuadSegmentLength","getQuadBBox","getQuadLength","getPointAtQuadSegmentLength","x1","y1","cx","cy","x2","y2","t","t1","getQuadLength","getBezierLength","getPointAtQuadLength","distance","distanceIsNumber","point","currentLength","getQuadBBox","cxMinMax","minmaxQ","cyMinMax","polygonTools_exports","__export","polygonArea","polygonLength","polygonArea","polygon","n","i","a","b","area","polygonLength","length","point","distanceSquareRoot_default","paramsCount","paramsCount_default","finalizeSegment","path","pathCommand","relativeCommand","data","paramsCount_default","finalizeSegment_default","error","error_default","scanFlag","path","index","pathValue","code","error_default","scanFlag_default","isDigit","code","isDigit_default","invalidPathValue","invalidPathValue_default","scanParam","path","max","pathValue","start","index","zeroFirst","hasCeiling","hasDecimal","hasDot","ch","error_default","invalidPathValue_default","isDigit_default","scanParam_default","isSpace","ch","isSpace_default","skipSpaces","path","pathValue","max","isSpace_default","skipSpaces_default","isPathCommand","code","isPathCommand_default","isDigitStart","code","isDigit_default","isDigitStart_default","isArcCommand","code","isArcCommand_default","isMoveCommand","code","isMoveCommand_default","scanSegment","path","max","pathValue","index","segments","cmdCode","reqParams","paramsCount_default","isPathCommand_default","error_default","invalidPathValue_default","lastSegment","isMoveCommand_default","skipSpaces_default","finalizeSegment_default","i","isArcCommand_default","scanFlag_default","scanParam_default","isDigitStart_default","scanSegment_default","PathParser","pathString","parsePathString","pathInput","path","PathParser","skipSpaces_default","scanSegment_default","parsePathString_default","absolutizeSegment","segment","index","lastX","lastY","pathCommand","absCommand","isAbsolute","absValues","seglen","j","absolutizeSegment_default","iterate","path","iterator","pathLen","segment","pathCommand","absCommand","isRelative","x","y","mx","my","segLen","i","iteratorResult","iterate_default","pathToAbsolute","pathInput","path","parsePathString_default","iterate_default","absolutizeSegment_default","pathToAbsolute_default","relativizeSegment","segment","index","lastX","lastY","pathCommand","relCommand","isRelative","relValues","seglen","j","relativizeSegment_default","pathToRelative","pathInput","path","parsePathString_default","iterate_default","relativizeSegment_default","pathToRelative_default","rotateVector","x","y","rad","sin","cos","X","Y","rotateVector_default","arcToCubic","X1","Y1","RX","RY","angle","LAF","SF","X2","Y2","recursive","x1","y1","rx","ry","x2","y2","d120","rad","res","xy","f1","f2","cx","cy","rotateVector_default","x","y","h","rx2","ry2","k","df","f2old","x2old","y2old","c1","s1","c2","s2","t","hx","hy","m1","m2","m3","m4","newres","i","ii","arcToCubic_default","quadToCubic","x1","y1","qx","qy","x2","y2","r13","r23","quadToCubic_default","lineToCubic","x1","y1","x2","y2","c1","midPoint_default","c2","lineToCubic_default","segmentToCubic","segment","params","pathCommand","values","x","y","px1","py1","px","py","arcToCubic_default","quadToCubic_default","lineToCubic_default","segmentToCubic_default","normalizeSegment","segment","params","pathCommand","absCommand","isRelative","px1","py1","px2","py2","x","y","values","absValues","n","j","x1","y1","qx","qy","nqx","nqy","normalizeSegment_default","paramsParser","paramsParser_default","pathToCurve","pathInput","params","paramsParser_default","path","parsePathString_default","iterate_default","seg","index","lastX","lastY","normalSegment","normalizeSegment_default","result","segmentToCubic_default","seglen","pathToCurve_default","defaultOptions","options_default","roundTo","n","round","pow","roundTo_default","pathToString","path","roundOption","pathLen","round","options_default","segment","result","i","pathCommand","values","j","valLen","roundTo_default","pathToString_default","distanceEpsilon_default","normalizePath","pathInput","path","parsePathString_default","params","paramsParser_default","iterate_default","seg","_","lastX","lastY","result","normalizeSegment_default","seglen","normalizePath_default","getPointAtLength","pathInput","distance","path","normalizePath_default","isM","data","pathCommand","x","y","mx","my","distanceIsNumber","point","length","POINT","totalLength","distanceEpsilon_default","iterate_default","seg","_","lastX","lastY","getPointAtLineLength","getLineLength","getPointAtArcLength","getArcLength","getPointAtCubicLength","getCubicLength","getPointAtQuadLength","getQuadLength","getPointAtLength_default","getTotalLength","pathInput","path","parsePathString_default","paramX1","paramY1","paramX2","paramY2","paramQX","paramQY","pathCommand","mx","my","totalLength","iterate_default","seg","index","lastX","lastY","absCommand","absoluteSegment","absolutizeSegment_default","normalSegment","getLineLength","getArcLength","cp1x","cp1y","getCubicLength","getQuadLength","getTotalLength_default","getPropertiesAtLength","pathInput","distance","pathArray","parsePathString_default","pathTemp","pathLength","getTotalLength_default","index","lengthAtSegment","length","segment","segments","l","getPropertiesAtLength_default","getPropertiesAtPoint","pathInput","point","path","parsePathString_default","normalPath","normalizePath_default","pathLength","getTotalLength_default","distanceTo","p","dx","dy","precision","scan","closest","scanDistance","bestLength","bestDistance","scanLength","getPointAtLength_default","before","after","beforeLength","afterLength","beforeDistance","afterDistance","segment","getPropertiesAtLength_default","distance","getPropertiesAtPoint_default","getClosestPoint","pathInput","point","getPropertiesAtPoint_default","getClosestPoint_default","getCubicSegArea","x1","y1","c1x","c1y","c2x","c2y","x2","y2","getPathArea","path","x","y","len","pathToCurve_default","seg","a","b","getPathArea_default","getDrawDirection","path","getPathArea_default","pathToCurve_default","getDrawDirection_default","getPathBBox","pathInput","path","parsePathString_default","pathCommand","mx","my","max","min","xMin","yMin","xMax","yMax","minX","minY","maxX","maxY","paramX1","paramY1","paramX2","paramY2","paramQX","paramQY","iterate_default","seg","index","lastX","lastY","absCommand","absoluteSegment","absolutizeSegment_default","normalSegment","getLineBBox","getArcBBox","cp1x","cp1y","getCubicBBox","getQuadBBox","width","height","getPathBBox_default","getSegmentAtLength","pathInput","distance","getPropertiesAtLength_default","getSegmentAtLength_default","getSegmentOfPoint","path","point","getPropertiesAtPoint_default","getSegmentOfPoint_default","isPathArray","path","seg","lk","paramsCount_default","isPathArray_default","isAbsoluteArray","path","isPathArray_default","x","isAbsoluteArray_default","isNormalizedArray","path","isAbsoluteArray_default","pc","isNormalizedArray_default","isCurveArray","path","isNormalizedArray_default","pc","isCurveArray_default","isPointInStroke","pathInput","point","distance","getPropertiesAtPoint_default","distanceEpsilon_default","isPointInStroke_default","isRelativeArray","path","isPathArray_default","pc","isRelativeArray_default","isValidPath","pathString","path","PathParser","skipSpaces_default","scanSegment_default","isValidPath_default","shapeParams","shapeParams_default","isElement","node","isElement_default","getLinePath","attr","x1","y1","x2","y2","getPolyPath","pathArray","points","a","index","getCirclePath","cx","cy","r","getEllipsePath","rx","ry","getRectanglePath","x","y","w","h","shapeToPathArray","element","supportedShapes","shapeParams_default","targetIsElement","isElement_default","tagName","error_default","type","shapeAttrs","config","p","parsePathString_default","isPathArray_default","shapeToPathArray_default","shapeToPath","element","replace","ownerDocument","doc","supportedShapes","shapeParams_default","targetIsElement","isElement_default","tagName","error_default","s","path","type","shapeAttrs","config","round","options_default","pathArray","shapeToPathArray_default","description","pathToString_default","p","name","value","k","m","isValidPath_default","shapeToPath_default","getSVGMatrix","transform","matrix","y","origin","originX","originY","translate","rotate","skew","scale","x","getSVGMatrix_default","shortenSegment","segment","normalSegment","params","prevCommand","pathCommand","defaultRound","options_default","round","normalValues","x1","y1","x2","y2","x","y","nx","ny","result","roundTo_default","nx1","ny1","qx","qy","shortenSegment_default","roundSegment","segment","roundOption","values","n","roundTo_default","roundSegment_default","optimizePath","pathInput","roundOption","path","pathToAbsolute_default","round","optimParams","paramsParser_default","allPathCommands","pathCommand","prevCommand","iterate_default","seg","i","lastX","lastY","normalizedSegment","normalizeSegment_default","result","shortSegment","shortenSegment_default","absSegment","roundSegment_default","absString","relativeSegment","relativizeSegment_default","relSegment","relString","seglen","optimizePath_default","translatePoint","cssm","v","m","y","projection2d","point2D","origin","originX","originY","originZ","x","z","relativePositionX","relativePositionY","relativePositionZ","projection2d_default","reverseCurve","path","rotatedCurve","x","i","curveOnly","_","reverseCurve_default","reversePath","pathInput","absolutePath","pathToAbsolute_default","normalizedPath","normalizePath_default","pLen","isClosed","reversedPath","iterate_default","segment","normalizedSegment","prevSeg","prevCommand","nextSeg","nextCommand","pathCommand","x","y","result","reversePath_default","roundPath","path","roundOption","round","options_default","iterate_default","segment","roundSegment_default","roundPath_default","splitCubic","pts","ratio","t","p0","p1","p2","p3","p4","midPoint_default","p5","p6","p7","p8","p9","splitCubic_default","splitPath","pathInput","composite","path","pi","x","y","mx","my","params","paramsParser_default","seg","pathCommand","absCommand","relCommand","isRelative","values","splitPath_default","transformPath","pathInput","transform","x","y","lx","ly","j","jj","pathCommand","path","parsePathString_default","transformProps","options_default","origin","matrixInstance","getSVGMatrix_default","iterate_default","seg","index","lastX","lastY","absCommand","absoluteSegment","absolutizeSegment_default","result","arcToCubic_default","isLongArc","tempSegment","projection2d_default","transformPath_default"]} \ No newline at end of file diff --git a/dist/util/util.mjs b/dist/util/util.mjs index 7ee165d..37f73ee 100644 --- a/dist/util/util.mjs +++ b/dist/util/util.mjs @@ -1,1928 +1,2 @@ -var ft = Object.defineProperty, yt = (t, e, r) => e in t ? ft(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r, k = (t, e, r) => yt(t, typeof e != "symbol" ? e + "" : e, r); -const xt = { - a: 1, - b: 0, - c: 0, - d: 1, - e: 0, - f: 0, - m11: 1, - m12: 0, - m13: 0, - m14: 0, - m21: 0, - m22: 1, - m23: 0, - m24: 0, - m31: 0, - m32: 0, - m33: 1, - m34: 0, - m41: 0, - m42: 0, - m43: 0, - m44: 1, - is2D: !0, - isIdentity: !0 -}, Re = (t) => (t instanceof Float64Array || t instanceof Float32Array || Array.isArray(t) && t.every((e) => typeof e == "number")) && [6, 16].some((e) => t.length === e), _e = (t) => t instanceof DOMMatrix || t instanceof P || typeof t == "object" && Object.keys(xt).every((e) => t && e in t), ee = (t) => { - const e = new P(), r = Array.from(t); - if (!Re(r)) - throw TypeError( - `CSSMatrix: "${r.join(",")}" must be an array with 6/16 numbers.` - ); - if (r.length === 16) { - const [ - o, - n, - s, - i, - l, - c, - a, - u, - h, - f, - y, - m, - x, - p, - b, - M - ] = r; - e.m11 = o, e.a = o, e.m21 = l, e.c = l, e.m31 = h, e.m41 = x, e.e = x, e.m12 = n, e.b = n, e.m22 = c, e.d = c, e.m32 = f, e.m42 = p, e.f = p, e.m13 = s, e.m23 = a, e.m33 = y, e.m43 = b, e.m14 = i, e.m24 = u, e.m34 = m, e.m44 = M; - } else if (r.length === 6) { - const [o, n, s, i, l, c] = r; - e.m11 = o, e.a = o, e.m12 = n, e.b = n, e.m21 = s, e.c = s, e.m22 = i, e.d = i, e.m41 = l, e.e = l, e.m42 = c, e.f = c; - } - return e; -}, Oe = (t) => { - if (_e(t)) - return ee([ - t.m11, - t.m12, - t.m13, - t.m14, - t.m21, - t.m22, - t.m23, - t.m24, - t.m31, - t.m32, - t.m33, - t.m34, - t.m41, - t.m42, - t.m43, - t.m44 - ]); - throw TypeError( - `CSSMatrix: "${JSON.stringify(t)}" is not a DOMMatrix / CSSMatrix / JSON compatible object.` - ); -}, Qe = (t) => { - if (typeof t != "string") - throw TypeError(`CSSMatrix: "${JSON.stringify(t)}" is not a string.`); - const e = String(t).replace(/\s/g, ""); - let r = new P(); - const o = `CSSMatrix: invalid transform string "${t}"`; - return e.split(")").filter((n) => n).forEach((n) => { - const [s, i] = n.split("("); - if (!i) throw TypeError(o); - const l = i.split(",").map( - (m) => m.includes("rad") ? parseFloat(m) * (180 / Math.PI) : parseFloat(m) - ), [c, a, u, h] = l, f = [c, a, u], y = [c, a, u, h]; - if (s === "perspective" && c && [a, u].every((m) => m === void 0)) - r.m34 = -1 / c; - else if (s.includes("matrix") && [6, 16].includes(l.length) && l.every((m) => !Number.isNaN(+m))) { - const m = l.map((x) => Math.abs(x) < 1e-6 ? 0 : x); - r = r.multiply(ee(m)); - } else if (s === "translate3d" && f.every((m) => !Number.isNaN(+m))) - r = r.translate(c, a, u); - else if (s === "translate" && c && u === void 0) - r = r.translate(c, a || 0, 0); - else if (s === "rotate3d" && y.every((m) => !Number.isNaN(+m)) && h) - r = r.rotateAxisAngle(c, a, u, h); - else if (s === "rotate" && c && [a, u].every((m) => m === void 0)) - r = r.rotate(0, 0, c); - else if (s === "scale3d" && f.every((m) => !Number.isNaN(+m)) && f.some((m) => m !== 1)) - r = r.scale(c, a, u); - else if ( - // prop === "scale" && !Number.isNaN(x) && x !== 1 && z === undefined - // prop === "scale" && !Number.isNaN(x) && [x, y].some((n) => n !== 1) && - s === "scale" && !Number.isNaN(c) && (c !== 1 || a !== 1) && u === void 0 - ) { - const m = Number.isNaN(+a) ? c : a; - r = r.scale(c, m, 1); - } else if (s === "skew" && (c || !Number.isNaN(c) && a) && u === void 0) - r = r.skew(c, a || 0); - else if (["translate", "rotate", "scale", "skew"].some( - (m) => s.includes(m) - ) && /[XYZ]/.test(s) && c && [a, u].every((m) => m === void 0)) - if (s === "skewX" || s === "skewY") - r = r[s](c); - else { - const m = s.replace(/[XYZ]/, ""), x = s.replace(m, ""), p = ["X", "Y", "Z"].indexOf(x), b = m === "scale" ? 1 : 0, M = [ - p === 0 ? c : b, - p === 1 ? c : b, - p === 2 ? c : b - ]; - r = r[m](...M); - } - else - throw TypeError(o); - }), r; -}, de = (t, e) => e ? [t.a, t.b, t.c, t.d, t.e, t.f] : [ - t.m11, - t.m12, - t.m13, - t.m14, - t.m21, - t.m22, - t.m23, - t.m24, - t.m31, - t.m32, - t.m33, - t.m34, - t.m41, - t.m42, - t.m43, - t.m44 -], Ze = (t, e, r) => { - const o = new P(); - return o.m41 = t, o.e = t, o.m42 = e, o.f = e, o.m43 = r, o; -}, De = (t, e, r) => { - const o = new P(), n = Math.PI / 180, s = t * n, i = e * n, l = r * n, c = Math.cos(s), a = -Math.sin(s), u = Math.cos(i), h = -Math.sin(i), f = Math.cos(l), y = -Math.sin(l), m = u * f, x = -u * y; - o.m11 = m, o.a = m, o.m12 = x, o.b = x, o.m13 = h; - const p = a * h * f + c * y; - o.m21 = p, o.c = p; - const b = c * f - a * h * y; - return o.m22 = b, o.d = b, o.m23 = -a * u, o.m31 = a * y - c * h * f, o.m32 = a * f + c * h * y, o.m33 = c * u, o; -}, Be = (t, e, r, o) => { - const n = new P(), s = Math.sqrt(t * t + e * e + r * r); - if (s === 0) - return n; - const i = t / s, l = e / s, c = r / s, a = o * (Math.PI / 360), u = Math.sin(a), h = Math.cos(a), f = u * u, y = i * i, m = l * l, x = c * c, p = 1 - 2 * (m + x) * f; - n.m11 = p, n.a = p; - const b = 2 * (i * l * f + c * u * h); - n.m12 = b, n.b = b, n.m13 = 2 * (i * c * f - l * u * h); - const M = 2 * (l * i * f - c * u * h); - n.m21 = M, n.c = M; - const d = 1 - 2 * (x + y) * f; - return n.m22 = d, n.d = d, n.m23 = 2 * (l * c * f + i * u * h), n.m31 = 2 * (c * i * f + l * u * h), n.m32 = 2 * (c * l * f - i * u * h), n.m33 = 1 - 2 * (y + m) * f, n; -}, He = (t, e, r) => { - const o = new P(); - return o.m11 = t, o.a = t, o.m22 = e, o.d = e, o.m33 = r, o; -}, ae = (t, e) => { - const r = new P(); - if (t) { - const o = t * Math.PI / 180, n = Math.tan(o); - r.m21 = n, r.c = n; - } - if (e) { - const o = e * Math.PI / 180, n = Math.tan(o); - r.m12 = n, r.b = n; - } - return r; -}, Fe = (t) => ae(t, 0), Ue = (t) => ae(0, t), D = (t, e) => { - const r = e.m11 * t.m11 + e.m12 * t.m21 + e.m13 * t.m31 + e.m14 * t.m41, o = e.m11 * t.m12 + e.m12 * t.m22 + e.m13 * t.m32 + e.m14 * t.m42, n = e.m11 * t.m13 + e.m12 * t.m23 + e.m13 * t.m33 + e.m14 * t.m43, s = e.m11 * t.m14 + e.m12 * t.m24 + e.m13 * t.m34 + e.m14 * t.m44, i = e.m21 * t.m11 + e.m22 * t.m21 + e.m23 * t.m31 + e.m24 * t.m41, l = e.m21 * t.m12 + e.m22 * t.m22 + e.m23 * t.m32 + e.m24 * t.m42, c = e.m21 * t.m13 + e.m22 * t.m23 + e.m23 * t.m33 + e.m24 * t.m43, a = e.m21 * t.m14 + e.m22 * t.m24 + e.m23 * t.m34 + e.m24 * t.m44, u = e.m31 * t.m11 + e.m32 * t.m21 + e.m33 * t.m31 + e.m34 * t.m41, h = e.m31 * t.m12 + e.m32 * t.m22 + e.m33 * t.m32 + e.m34 * t.m42, f = e.m31 * t.m13 + e.m32 * t.m23 + e.m33 * t.m33 + e.m34 * t.m43, y = e.m31 * t.m14 + e.m32 * t.m24 + e.m33 * t.m34 + e.m34 * t.m44, m = e.m41 * t.m11 + e.m42 * t.m21 + e.m43 * t.m31 + e.m44 * t.m41, x = e.m41 * t.m12 + e.m42 * t.m22 + e.m43 * t.m32 + e.m44 * t.m42, p = e.m41 * t.m13 + e.m42 * t.m23 + e.m43 * t.m33 + e.m44 * t.m43, b = e.m41 * t.m14 + e.m42 * t.m24 + e.m43 * t.m34 + e.m44 * t.m44; - return ee([ - r, - o, - n, - s, - i, - l, - c, - a, - u, - h, - f, - y, - m, - x, - p, - b - ]); -}; -class P { - /** - * @constructor - * @param init accepts all parameter configurations: - * * valid CSS transform string, - * * CSSMatrix/DOMMatrix instance, - * * a 6/16 elements *Array*. - */ - constructor(e) { - return this.a = 1, this.b = 0, this.c = 0, this.d = 1, this.e = 0, this.f = 0, this.m11 = 1, this.m12 = 0, this.m13 = 0, this.m14 = 0, this.m21 = 0, this.m22 = 1, this.m23 = 0, this.m24 = 0, this.m31 = 0, this.m32 = 0, this.m33 = 1, this.m34 = 0, this.m41 = 0, this.m42 = 0, this.m43 = 0, this.m44 = 1, e ? this.setMatrixValue(e) : this; - } - /** - * A `Boolean` whose value is `true` if the matrix is the identity matrix. The identity - * matrix is one in which every value is 0 except those on the main diagonal from top-left - * to bottom-right corner (in other words, where the offsets in each direction are equal). - * - * @return the current property value - */ - get isIdentity() { - return this.m11 === 1 && this.m12 === 0 && this.m13 === 0 && this.m14 === 0 && this.m21 === 0 && this.m22 === 1 && this.m23 === 0 && this.m24 === 0 && this.m31 === 0 && this.m32 === 0 && this.m33 === 1 && this.m34 === 0 && this.m41 === 0 && this.m42 === 0 && this.m43 === 0 && this.m44 === 1; - } - /** - * A `Boolean` flag whose value is `true` if the matrix was initialized as a 2D matrix - * and `false` if the matrix is 3D. - * - * @return the current property value - */ - get is2D() { - return this.m31 === 0 && this.m32 === 0 && this.m33 === 1 && this.m34 === 0 && this.m43 === 0 && this.m44 === 1; - } - /** - * The `setMatrixValue` method replaces the existing matrix with one computed - * in the browser. EG: `matrix(1,0.25,-0.25,1,0,0)` - * - * The method accepts any *Array* values, the result of - * `DOMMatrix` instance method `toFloat64Array()` / `toFloat32Array()` calls - * or `CSSMatrix` instance method `toArray()`. - * - * This method expects valid *matrix()* / *matrix3d()* string values, as well - * as other transform functions like *translateX(10px)*. - * - * @param source - * @return the matrix instance - */ - setMatrixValue(e) { - return typeof e == "string" && e.length && e !== "none" ? Qe(e) : Array.isArray(e) || e instanceof Float64Array || e instanceof Float32Array ? ee(e) : typeof e == "object" ? Oe(e) : this; - } - /** - * Returns a *Float32Array* containing elements which comprise the matrix. - * The method can return either the 16 elements or the 6 elements - * depending on the value of the `is2D` parameter. - * - * @param is2D *Array* representation of the matrix - * @return an *Array* representation of the matrix - */ - toFloat32Array(e) { - return Float32Array.from(de(this, e)); - } - /** - * Returns a *Float64Array* containing elements which comprise the matrix. - * The method can return either the 16 elements or the 6 elements - * depending on the value of the `is2D` parameter. - * - * @param is2D *Array* representation of the matrix - * @return an *Array* representation of the matrix - */ - toFloat64Array(e) { - return Float64Array.from(de(this, e)); - } - /** - * Creates and returns a string representation of the matrix in `CSS` matrix syntax, - * using the appropriate `CSS` matrix notation. - * - * matrix3d *matrix3d(m11, m12, m13, m14, m21, ...)* - * matrix *matrix(a, b, c, d, e, f)* - * - * @return a string representation of the matrix - */ - toString() { - const { is2D: e } = this, r = this.toFloat64Array(e).join(", "); - return `${e ? "matrix" : "matrix3d"}(${r})`; - } - /** - * Returns a JSON representation of the `CSSMatrix` instance, a standard *Object* - * that includes `{a,b,c,d,e,f}` and `{m11,m12,m13,..m44}` properties as well - * as the `is2D` & `isIdentity` properties. - * - * The result can also be used as a second parameter for the `fromMatrix` static method - * to load values into another matrix instance. - * - * @return an *Object* with all matrix values. - */ - toJSON() { - const { is2D: e, isIdentity: r } = this; - return { ...this, is2D: e, isIdentity: r }; - } - /** - * The Multiply method returns a new CSSMatrix which is the result of this - * matrix multiplied by the passed matrix, with the passed matrix to the right. - * This matrix is not modified. - * - * @param m2 CSSMatrix - * @return The resulted matrix. - */ - multiply(e) { - return D(this, e); - } - /** - * The translate method returns a new matrix which is this matrix post - * multiplied by a translation matrix containing the passed values. If the z - * component is undefined, a 0 value is used in its place. This matrix is not - * modified. - * - * @param x X component of the translation value. - * @param y Y component of the translation value. - * @param z Z component of the translation value. - * @return The resulted matrix - */ - translate(e, r, o) { - const n = e; - let s = r, i = o; - return typeof s > "u" && (s = 0), typeof i > "u" && (i = 0), D(this, Ze(n, s, i)); - } - /** - * The scale method returns a new matrix which is this matrix post multiplied by - * a scale matrix containing the passed values. If the z component is undefined, - * a 1 value is used in its place. If the y component is undefined, the x - * component value is used in its place. This matrix is not modified. - * - * @param x The X component of the scale value. - * @param y The Y component of the scale value. - * @param z The Z component of the scale value. - * @return The resulted matrix - */ - scale(e, r, o) { - const n = e; - let s = r, i = o; - return typeof s > "u" && (s = e), typeof i > "u" && (i = 1), D(this, He(n, s, i)); - } - /** - * The rotate method returns a new matrix which is this matrix post multiplied - * by each of 3 rotation matrices about the major axes, first X, then Y, then Z. - * If the y and z components are undefined, the x value is used to rotate the - * object about the z axis, as though the vector (0,0,x) were passed. All - * rotation values are in degrees. This matrix is not modified. - * - * @param rx The X component of the rotation, or Z if Y and Z are null. - * @param ry The (optional) Y component of the rotation value. - * @param rz The (optional) Z component of the rotation value. - * @return The resulted matrix - */ - rotate(e, r, o) { - let n = e, s = r || 0, i = o || 0; - return typeof e == "number" && typeof r > "u" && typeof o > "u" && (i = n, n = 0, s = 0), D(this, De(n, s, i)); - } - /** - * The rotateAxisAngle method returns a new matrix which is this matrix post - * multiplied by a rotation matrix with the given axis and `angle`. The right-hand - * rule is used to determine the direction of rotation. All rotation values are - * in degrees. This matrix is not modified. - * - * @param x The X component of the axis vector. - * @param y The Y component of the axis vector. - * @param z The Z component of the axis vector. - * @param angle The angle of rotation about the axis vector, in degrees. - * @return The resulted matrix - */ - rotateAxisAngle(e, r, o, n) { - if ([e, r, o, n].some((s) => Number.isNaN(+s))) - throw new TypeError("CSSMatrix: expecting 4 values"); - return D(this, Be(e, r, o, n)); - } - /** - * Specifies a skew transformation along the `x-axis` by the given angle. - * This matrix is not modified. - * - * @param angle The angle amount in degrees to skew. - * @return The resulted matrix - */ - skewX(e) { - return D(this, Fe(e)); - } - /** - * Specifies a skew transformation along the `y-axis` by the given angle. - * This matrix is not modified. - * - * @param angle The angle amount in degrees to skew. - * @return The resulted matrix - */ - skewY(e) { - return D(this, Ue(e)); - } - /** - * Specifies a skew transformation along both the `x-axis` and `y-axis`. - * This matrix is not modified. - * - * @param angleX The X-angle amount in degrees to skew. - * @param angleY The angle amount in degrees to skew. - * @return The resulted matrix - */ - skew(e, r) { - return D(this, ae(e, r)); - } - /** - * Transforms a specified vector using the matrix, returning a new - * {x,y,z,w} Tuple *Object* comprising the transformed vector. - * Neither the matrix nor the original vector are altered. - * - * The method is equivalent with `transformPoint()` method - * of the `DOMMatrix` constructor. - * - * @param t Tuple with `{x,y,z,w}` components - * @return the resulting Tuple - */ - transformPoint(e) { - const r = this.m11 * e.x + this.m21 * e.y + this.m31 * e.z + this.m41 * e.w, o = this.m12 * e.x + this.m22 * e.y + this.m32 * e.z + this.m42 * e.w, n = this.m13 * e.x + this.m23 * e.y + this.m33 * e.z + this.m43 * e.w, s = this.m14 * e.x + this.m24 * e.y + this.m34 * e.z + this.m44 * e.w; - return e instanceof DOMPoint ? new DOMPoint(r, o, n, s) : { - x: r, - y: o, - z: n, - w: s - }; - } -} -k(P, "Translate", Ze), k(P, "Rotate", De), k(P, "RotateAxisAngle", Be), k(P, "Scale", He), k(P, "SkewX", Fe), k(P, "SkewY", Ue), k(P, "Skew", ae), k(P, "Multiply", D), k(P, "fromArray", ee), k(P, "fromMatrix", Oe), k(P, "fromString", Qe), k(P, "toArray", de), k(P, "isCompatibleArray", Re), k(P, "isCompatibleObject", _e); -const B = (t, e, r) => { - const [o, n] = t, [s, i] = e; - return [o + (s - o) * r, n + (i - n) * r]; -}, we = (t, e) => Math.sqrt( - (t[0] - e[0]) * (t[0] - e[0]) + (t[1] - e[1]) * (t[1] - e[1]) -), Y = (t, e, r, o) => we([t, e], [r, o]), Le = (t, e, r, o, n) => { - let s = { x: t, y: e }; - if (typeof n == "number") { - const i = we([t, e], [r, o]); - if (n <= 0) - s = { x: t, y: e }; - else if (n >= i) - s = { x: r, y: o }; - else { - const [l, c] = B([t, e], [r, o], n / i); - s = { x: l, y: c }; - } - } - return s; -}, ge = (t, e, r, o) => { - const { min: n, max: s } = Math; - return [n(t, r), n(e, o), s(t, r), s(e, o)]; -}, Zt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ - __proto__: null, - getLineBBox: ge, - getLineLength: Y, - getPointAtLineLength: Le -}, Symbol.toStringTag, { value: "Module" })), Ne = (t, e, r) => { - const o = r / 2, n = Math.sin(o), s = Math.cos(o), i = t ** 2 * n ** 2, l = e ** 2 * s ** 2, c = Math.sqrt(i + l) * r; - return Math.abs(c); -}, U = (t, e, r, o, n, s) => { - const { sin: i, cos: l } = Math, c = l(n), a = i(n), u = r * l(s), h = o * i(s); - return [t + c * u - a * h, e + a * u + c * h]; -}, pe = (t, e) => { - const { x: r, y: o } = t, { x: n, y: s } = e, i = r * n + o * s, l = Math.sqrt((r ** 2 + o ** 2) * (n ** 2 + s ** 2)); - return (r * s - o * n < 0 ? -1 : 1) * Math.acos(i / l); -}, me = (t, e, r, o, n, s, i, l, c) => { - const { abs: a, sin: u, cos: h, sqrt: f, PI: y } = Math; - let m = a(r), x = a(o); - const b = (n % 360 + 360) % 360 * (y / 180); - if (t === l && e === c) - return { - rx: m, - ry: x, - startAngle: 0, - endAngle: 0, - center: { x: l, y: c } - }; - if (m === 0 || x === 0) - return { - rx: m, - ry: x, - startAngle: 0, - endAngle: 0, - center: { x: (l + t) / 2, y: (c + e) / 2 } - }; - const M = (t - l) / 2, d = (e - c) / 2, g = { - x: h(b) * M + u(b) * d, - y: -u(b) * M + h(b) * d - }, A = g.x ** 2 / m ** 2 + g.y ** 2 / x ** 2; - A > 1 && (m *= f(A), x *= f(A)); - const S = m ** 2 * x ** 2 - m ** 2 * g.y ** 2 - x ** 2 * g.x ** 2, v = m ** 2 * g.y ** 2 + x ** 2 * g.x ** 2; - let q = S / v; - q = q < 0 ? 0 : q; - const N = (s !== i ? 1 : -1) * f(q), w = { - x: N * (m * g.y / x), - y: N * (-(x * g.x) / m) - }, V = { - x: h(b) * w.x - u(b) * w.y + (t + l) / 2, - y: u(b) * w.x + h(b) * w.y + (e + c) / 2 - }, H = { - x: (g.x - w.x) / m, - y: (g.y - w.y) / x - }, z = pe({ x: 1, y: 0 }, H), C = { - x: (-g.x - w.x) / m, - y: (-g.y - w.y) / x - }; - let j = pe(H, C); - !i && j > 0 ? j -= 2 * y : i && j < 0 && (j += 2 * y), j %= 2 * y; - const R = z + j; - return { - center: V, - startAngle: z, - endAngle: R, - rx: m, - ry: x - }; -}, Te = (t, e, r, o, n, s, i, l, c) => { - const { rx: a, ry: u, startAngle: h, endAngle: f } = me( - t, - e, - r, - o, - n, - s, - i, - l, - c - ); - return Ne(a, u, f - h); -}, Ge = (t, e, r, o, n, s, i, l, c, a) => { - let u = { x: t, y: e }; - const { center: h, rx: f, ry: y, startAngle: m, endAngle: x } = me( - t, - e, - r, - o, - n, - s, - i, - l, - c - ); - if (typeof a == "number") { - const p = Ne(f, y, x - m); - if (a <= 0) - u = { x: t, y: e }; - else if (a >= p) - u = { x: l, y: c }; - else { - if (t === l && e === c) - return { x: l, y: c }; - if (f === 0 || y === 0) - return Le(t, e, l, c, a); - const { PI: b, cos: M, sin: d } = Math, g = x - m, S = (n % 360 + 360) % 360 * (b / 180), v = m + g * (a / p), q = f * M(v), N = y * d(v); - u = { - x: M(S) * q - d(S) * N + h.x, - y: d(S) * q + M(S) * N + h.y - }; - } - } - return u; -}, Je = (t, e, r, o, n, s, i, l, c) => { - const { center: a, rx: u, ry: h, startAngle: f, endAngle: y } = me( - t, - e, - r, - o, - n, - s, - i, - l, - c - ), m = y - f, { min: x, max: p, tan: b, atan2: M, PI: d } = Math, { x: g, y: A } = a, S = n * d / 180, v = b(S), q = M(-h * v, u), N = q, w = q + d, V = M(h, u * v), H = V + d, z = [l], C = [c]; - let j = x(t, l), R = p(t, l), E = x(e, c), Z = p(e, c); - const K = y - m * 1e-5, F = U(g, A, u, h, S, K), L = y - m * 0.99999, I = U(g, A, u, h, S, L); - if (F[0] > R || I[0] > R) { - const T = U(g, A, u, h, S, N); - z.push(T[0]), C.push(T[1]); - } - if (F[0] < j || I[0] < j) { - const T = U(g, A, u, h, S, w); - z.push(T[0]), C.push(T[1]); - } - if (F[1] < E || I[1] < E) { - const T = U(g, A, u, h, S, H); - z.push(T[0]), C.push(T[1]); - } - if (F[1] > Z || I[1] > Z) { - const T = U(g, A, u, h, S, V); - z.push(T[0]), C.push(T[1]); - } - return j = x.apply([], z), E = x.apply([], C), R = p.apply([], z), Z = p.apply([], C), [j, E, R, Z]; -}, Dt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ - __proto__: null, - angleBetween: pe, - arcLength: Ne, - arcPoint: U, - getArcBBox: Je, - getArcLength: Te, - getArcProps: me, - getPointAtArcLength: Ge -}, Symbol.toStringTag, { value: "Module" })), be = [ - -0.06405689286260563, - 0.06405689286260563, - -0.1911188674736163, - 0.1911188674736163, - -0.3150426796961634, - 0.3150426796961634, - -0.4337935076260451, - 0.4337935076260451, - -0.5454214713888396, - 0.5454214713888396, - -0.6480936519369755, - 0.6480936519369755, - -0.7401241915785544, - 0.7401241915785544, - -0.820001985973903, - 0.820001985973903, - -0.8864155270044011, - 0.8864155270044011, - -0.9382745520027328, - 0.9382745520027328, - -0.9747285559713095, - 0.9747285559713095, - -0.9951872199970213, - 0.9951872199970213 -], Ke = [ - 0.12793819534675216, - 0.12793819534675216, - 0.1258374563468283, - 0.1258374563468283, - 0.12167047292780339, - 0.12167047292780339, - 0.1155056680537256, - 0.1155056680537256, - 0.10744427011596563, - 0.10744427011596563, - 0.09761865210411388, - 0.09761865210411388, - 0.08619016153195327, - 0.08619016153195327, - 0.0733464814110803, - 0.0733464814110803, - 0.05929858491543678, - 0.05929858491543678, - 0.04427743881741981, - 0.04427743881741981, - 0.028531388628933663, - 0.028531388628933663, - 0.0123412297999872, - 0.0123412297999872 -], We = (t) => { - const e = []; - for (let r = t, o = r.length, n = o - 1; o > 1; o -= 1, n -= 1) { - const s = []; - for (let i = 0; i < n; i += 1) - s.push({ - x: n * (r[i + 1].x - r[i].x), - y: n * (r[i + 1].y - r[i].y), - t: 0 - }); - e.push(s), r = s; - } - return e; -}, Xe = (t, e) => { - if (e === 0) - return t[0].t = 0, t[0]; - const r = t.length - 1; - if (e === 1) - return t[r].t = 1, t[r]; - const o = 1 - e; - let n = t; - if (r === 0) - return t[0].t = e, t[0]; - if (r === 1) - return { - x: o * n[0].x + e * n[1].x, - y: o * n[0].y + e * n[1].y, - t: e - }; - const s = o * o, i = e * e; - let l = 0, c = 0, a = 0, u = 0; - return r === 2 ? (n = [n[0], n[1], n[2], { x: 0, y: 0 }], l = s, c = o * e * 2, a = i) : r === 3 && (l = s * o, c = s * e * 3, a = o * i * 3, u = e * i), { - x: l * n[0].x + c * n[1].x + a * n[2].x + u * n[3].x, - y: l * n[0].y + c * n[1].y + a * n[2].y + u * n[3].y, - t: e - }; -}, Ye = (t, e) => { - const r = t(e), o = r.x * r.x + r.y * r.y; - return Math.sqrt(o); -}, et = (t) => { - const r = be.length; - let o = 0; - for (let n = 0, s; n < r; n++) - s = 0.5 * be[n] + 0.5, o += Ke[n] * Ye(t, s); - return 0.5 * o; -}, te = (t) => { - const e = []; - for (let o = 0, n = t.length, s = 2; o < n; o += s) - e.push({ - x: t[o], - y: t[o + 1] - }); - const r = We(e); - return et((o) => Xe(r[0], o)); -}, tt = 1e-8, se = ([t, e, r]) => { - const o = Math.min(t, r), n = Math.max(t, r); - if (e >= t ? r >= e : r <= e) - return [o, n]; - const s = (t * r - e * e) / (t - 2 * e + r); - return s < o ? [s, n] : [o, s]; -}, Me = ([t, e, r, o]) => { - const n = t - 3 * e + 3 * r - o; - if (Math.abs(n) < tt) - return t === o && t === e ? [t, o] : se([t, -0.5 * t + 1.5 * e, t - 3 * e + 3 * r]); - const s = -t * r + t * o - e * r - e * o + e * e + r * r; - if (s <= 0) - return [Math.min(t, o), Math.max(t, o)]; - const i = Math.sqrt(s); - let l = Math.min(t, o), c = Math.max(t, o); - const a = t - 2 * e + r; - for (let u = (a + i) / n, h = 1; h <= 2; u = (a - i) / n, h++) - if (u > 0 && u < 1) { - const f = t * (1 - u) * (1 - u) * (1 - u) + e * 3 * (1 - u) * (1 - u) * u + r * 3 * (1 - u) * u * u + o * u * u * u; - f < l && (l = f), f > c && (c = f); - } - return [l, c]; -}, Bt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ - __proto__: null, - CBEZIER_MINMAX_EPSILON: tt, - Cvalues: Ke, - Tvalues: be, - bezierLength: et, - calculateBezier: Ye, - computeBezier: Xe, - deriveBezier: We, - getBezierLength: te, - minmaxC: Me, - minmaxQ: se -}, Symbol.toStringTag, { value: "Module" })), nt = ([t, e, r, o, n, s, i, l], c) => { - const a = 1 - c; - return { - x: a ** 3 * t + 3 * a ** 2 * c * r + 3 * a * c ** 2 * n + c ** 3 * i, - y: a ** 3 * e + 3 * a ** 2 * c * o + 3 * a * c ** 2 * s + c ** 3 * l - }; -}, ie = (t, e, r, o, n, s, i, l) => te([t, e, r, o, n, s, i, l]), rt = (t, e, r, o, n, s, i, l, c) => { - const a = typeof c == "number"; - let u = { x: t, y: e }; - if (a) { - const h = te([t, e, r, o, n, s, i, l]); - c <= 0 || (c >= h ? u = { x: i, y: l } : u = nt( - [t, e, r, o, n, s, i, l], - c / h - )); - } - return u; -}, Ae = (t, e, r, o, n, s, i, l) => { - const c = Me([t, r, n, i]), a = Me([e, o, s, l]); - return [c[0], a[0], c[1], a[1]]; -}, Ht = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ - __proto__: null, - getCubicBBox: Ae, - getCubicLength: ie, - getPointAtCubicLength: rt, - getPointAtCubicSegmentLength: nt -}, Symbol.toStringTag, { value: "Module" })), ot = ([t, e, r, o, n, s], i) => { - const l = 1 - i; - return { - x: l ** 2 * t + 2 * l * i * r + i ** 2 * n, - y: l ** 2 * e + 2 * l * i * o + i ** 2 * s - }; -}, ce = (t, e, r, o, n, s) => te([t, e, r, o, n, s]), st = (t, e, r, o, n, s, i) => { - const l = typeof i == "number"; - let c = { x: t, y: e }; - if (l) { - const a = te([t, e, r, o, n, s]); - i <= 0 || (i >= a ? c = { x: n, y: s } : c = ot( - [t, e, r, o, n, s], - i / a - )); - } - return c; -}, Ce = (t, e, r, o, n, s) => { - const i = se([t, r, n]), l = se([e, o, s]); - return [i[0], l[0], i[1], l[1]]; -}, Ft = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ - __proto__: null, - getPointAtQuadLength: st, - getPointAtQuadSegmentLength: ot, - getQuadBBox: Ce, - getQuadLength: ce -}, Symbol.toStringTag, { value: "Module" })), dt = (t) => { - const e = t.length; - let r = -1, o, n = t[e - 1], s = 0; - for (; ++r < e; ) - o = n, n = t[r], s += o[1] * n[0] - o[0] * n[1]; - return s / 2; -}, gt = (t) => t.reduce((e, r, o) => o ? e + we(t[o - 1], r) : 0, 0), Ut = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ - __proto__: null, - polygonArea: dt, - polygonLength: gt -}, Symbol.toStringTag, { value: "Module" })), W = { - a: 7, - c: 6, - h: 1, - l: 2, - m: 2, - r: 4, - q: 4, - s: 4, - t: 2, - v: 1, - z: 0 -}, ke = (t) => { - let e = t.pathValue[t.segmentStart], r = e.toLowerCase(); - const { data: o } = t; - for (; o.length >= W[r] && (r === "m" && o.length > 2 ? (t.segments.push( - [e].concat( - o.splice(0, 2) - ) - ), r = "l", e = e === "m" ? "l" : "L") : t.segments.push( - [e].concat( - o.splice(0, W[r]) - ) - ), !!W[r]); ) - ; -}, _ = "SVGPathCommander Error", pt = (t) => { - const { index: e, pathValue: r } = t, o = r.charCodeAt(e); - if (o === 48) { - t.param = 0, t.index += 1; - return; - } - if (o === 49) { - t.param = 1, t.index += 1; - return; - } - t.err = `${_}: invalid Arc flag "${r[e]}", expecting 0 or 1 at index ${e}`; -}, G = (t) => t >= 48 && t <= 57, J = "Invalid path value", bt = (t) => { - const { max: e, pathValue: r, index: o } = t; - let n = o, s = !1, i = !1, l = !1, c = !1, a; - if (n >= e) { - t.err = `${_}: ${J} at index ${n}, "pathValue" is missing param`; - return; - } - if (a = r.charCodeAt(n), (a === 43 || a === 45) && (n += 1, a = r.charCodeAt(n)), !G(a) && a !== 46) { - t.err = `${_}: ${J} at index ${n}, "${r[n]}" is not a number`; - return; - } - if (a !== 46) { - if (s = a === 48, n += 1, a = r.charCodeAt(n), s && n < e && a && G(a)) { - t.err = `${_}: ${J} at index ${o}, "${r[o]}" illegal number`; - return; - } - for (; n < e && G(r.charCodeAt(n)); ) - n += 1, i = !0; - a = r.charCodeAt(n); - } - if (a === 46) { - for (c = !0, n += 1; G(r.charCodeAt(n)); ) - n += 1, l = !0; - a = r.charCodeAt(n); - } - if (a === 101 || a === 69) { - if (c && !i && !l) { - t.err = `${_}: ${J} at index ${n}, "${r[n]}" invalid float exponent`; - return; - } - if (n += 1, a = r.charCodeAt(n), (a === 43 || a === 45) && (n += 1), n < e && G(r.charCodeAt(n))) - for (; n < e && G(r.charCodeAt(n)); ) - n += 1; - else { - t.err = `${_}: ${J} at index ${n}, "${r[n]}" invalid integer exponent`; - return; - } - } - t.index = n, t.param = +t.pathValue.slice(o, n); -}, Mt = (t) => [ - // Special spaces - 5760, - 6158, - 8192, - 8193, - 8194, - 8195, - 8196, - 8197, - 8198, - 8199, - 8200, - 8201, - 8202, - 8239, - 8287, - 12288, - 65279, - // Line terminators - 10, - 13, - 8232, - 8233, - // White spaces - 32, - 9, - 11, - 12, - 160 -].includes(t), X = (t) => { - const { pathValue: e, max: r } = t; - for (; t.index < r && Mt(e.charCodeAt(t.index)); ) - t.index += 1; -}, At = (t) => { - switch (t | 32) { - case 109: - case 122: - case 108: - case 104: - case 118: - case 99: - case 115: - case 113: - case 116: - case 97: - return !0; - default: - return !1; - } -}, Ct = (t) => G(t) || t === 43 || t === 45 || t === 46, St = (t) => (t | 32) === 97, Pt = (t) => { - switch (t | 32) { - case 109: - case 77: - return !0; - default: - return !1; - } -}, it = (t) => { - var c; - const { max: e, pathValue: r, index: o, segments: n } = t, s = r.charCodeAt(o), i = W[r[o].toLowerCase()]; - if (t.segmentStart = o, !At(s)) { - t.err = `${_}: ${J} "${r[o]}" is not a path command at index ${o}`; - return; - } - const l = n[n.length - 1]; - if (!Pt(s) && ((c = l == null ? void 0 : l[0]) == null ? void 0 : c.toLocaleLowerCase()) === "z") { - t.err = `${_}: ${J} "${r[o]}" is not a MoveTo path command at index ${o}`; - return; - } - if (t.index += 1, X(t), t.data = [], !i) { - ke(t); - return; - } - for (; ; ) { - for (let a = i; a > 0; a -= 1) { - if (St(s) && (a === 3 || a === 4) ? pt(t) : bt(t), t.err.length) - return; - t.data.push(t.param), X(t), t.index < e && r.charCodeAt(t.index) === 44 && (t.index += 1, X(t)); - } - if (t.index >= t.max || !Ct(r.charCodeAt(t.index))) - break; - } - ke(t); -}; -class ct { - constructor(e) { - this.segments = [], this.pathValue = e, this.max = e.length, this.index = 0, this.param = 0, this.segmentStart = 0, this.data = [], this.err = ""; - } -} -const Q = (t) => { - if (typeof t != "string") - return t.slice(0); - const e = new ct(t); - for (X(e); e.index < e.max && !e.err.length; ) - it(e); - if (!e.err.length) - e.segments.length && (e.segments[0][0] = "M"); - else - throw TypeError(e.err); - return e.segments; -}, ue = (t, e, r, o) => { - const [n] = t, s = n.toUpperCase(); - if (e === 0 || s === n) return t; - if (s === "A") - return [ - s, - t[1], - t[2], - t[3], - t[4], - t[5], - t[6] + r, - t[7] + o - ]; - if (s === "V") - return [s, t[1] + o]; - if (s === "H") - return [s, t[1] + r]; - if (s === "L") - return [ - s, - t[1] + r, - t[2] + o - ]; - { - const l = [], c = t.length; - for (let a = 1; a < c; a += 1) - l.push(t[a] + (a % 2 ? r : o)); - return [s].concat(l); - } -}, O = (t, e) => { - let r = t.length, o, n = "M", s = "M", i = !1, l = 0, c = 0, a = 0, u = 0, h = 0; - for (let f = 0; f < r; f += 1) { - o = t[f], [n] = o, h = o.length, s = n.toUpperCase(), i = s !== n; - const y = e(o, f, l, c); - if (y === !1) - break; - s === "Z" ? (l = a, c = u) : s === "H" ? l = o[1] + (i ? l : 0) : s === "V" ? c = o[1] + (i ? c : 0) : (l = o[h - 2] + (i ? l : 0), c = o[h - 1] + (i ? c : 0), s === "M" && (a = l, u = c)), y && (t[f] = y, y[0] === "C" && (r = t.length)); - } - return t; -}, lt = (t) => { - const e = Q(t); - return O(e, ue); -}, at = (t, e, r, o) => { - const [n] = t, s = n.toLowerCase(); - if (e === 0 || n === s) return t; - if (s === "a") - return [ - s, - t[1], - t[2], - t[3], - t[4], - t[5], - t[6] - r, - t[7] - o - ]; - if (s === "v") - return [s, t[1] - o]; - if (s === "h") - return [s, t[1] - r]; - if (s === "l") - return [ - s, - t[1] - r, - t[2] - o - ]; - { - const l = [], c = t.length; - for (let a = 1; a < c; a += 1) - l.push(t[a] - (a % 2 ? r : o)); - return [s].concat(l); - } -}, Gt = (t) => { - const e = Q(t); - return O(e, at); -}, re = (t, e, r) => { - const { sin: o, cos: n } = Math, s = t * n(r) - e * o(r), i = t * o(r) + e * n(r); - return { x: s, y: i }; -}, ve = (t, e, r, o, n, s, i, l, c, a) => { - let u = t, h = e, f = r, y = o, m = l, x = c; - const p = Math.PI * 120 / 180, b = Math.PI / 180 * (+n || 0); - let M = [], d, g, A, S, v; - if (a) - [g, A, S, v] = a; - else { - d = re(u, h, -b), u = d.x, h = d.y, d = re(m, x, -b), m = d.x, x = d.y; - const L = (u - m) / 2, I = (h - x) / 2; - let T = L * L / (f * f) + I * I / (y * y); - T > 1 && (T = Math.sqrt(T), f *= T, y *= T); - const fe = f * f, ye = y * y, Ie = (s === i ? -1 : 1) * Math.sqrt( - Math.abs( - (fe * ye - fe * I * I - ye * L * L) / (fe * I * I + ye * L * L) - ) - ); - S = Ie * f * I / y + (u + m) / 2, v = Ie * -y * L / f + (h + x) / 2, g = Math.asin(((h - v) / y * 10 ** 9 >> 0) / 10 ** 9), A = Math.asin(((x - v) / y * 10 ** 9 >> 0) / 10 ** 9), g = u < S ? Math.PI - g : g, A = m < S ? Math.PI - A : A, g < 0 && (g = Math.PI * 2 + g), A < 0 && (A = Math.PI * 2 + A), i && g > A && (g -= Math.PI * 2), !i && A > g && (A -= Math.PI * 2); - } - let q = A - g; - if (Math.abs(q) > p) { - const L = A, I = m, T = x; - A = g + p * (i && A > g ? 1 : -1), m = S + f * Math.cos(A), x = v + y * Math.sin(A), M = ve(m, x, f, y, n, 0, i, I, T, [ - A, - L, - S, - v - ]); - } - q = A - g; - const N = Math.cos(g), w = Math.sin(g), V = Math.cos(A), H = Math.sin(A), z = Math.tan(q / 4), C = 4 / 3 * f * z, j = 4 / 3 * y * z, R = [u, h], E = [u + C * w, h - j * N], Z = [m + C * H, x - j * V], K = [m, x]; - if (E[0] = 2 * R[0] - E[0], E[1] = 2 * R[1] - E[1], a) - return [E[0], E[1], Z[0], Z[1], K[0], K[1]].concat(M); - M = [E[0], E[1], Z[0], Z[1], K[0], K[1]].concat(M); - const F = []; - for (let L = 0, I = M.length; L < I; L += 1) - F[L] = L % 2 ? re(M[L - 1], M[L], b).y : re(M[L], M[L + 1], b).x; - return F; -}, wt = (t, e, r, o, n, s) => { - const i = 0.3333333333333333, l = 2 / 3; - return [ - i * t + l * r, - // cpx1 - i * e + l * o, - // cpy1 - i * n + l * r, - // cpx2 - i * s + l * o, - // cpy2 - n, - s - // x,y - ]; -}, Ee = (t, e, r, o) => { - const n = B([t, e], [r, o], 0.3333333333333333), s = B([t, e], [r, o], 2 / 3); - return [n[0], n[1], s[0], s[1], r, o]; -}, Lt = (t, e) => { - const [r] = t, o = t.slice(1).map(Number), [n, s] = o, { x1: i, y1: l, x: c, y: a } = e; - return "TQ".includes(r) || (e.qx = null, e.qy = null), r === "M" ? (e.x = n, e.y = s, t) : r === "A" ? ["C"].concat( - ve( - i, - l, - o[0], - o[1], - o[2], - o[3], - o[4], - o[5], - o[6] - ) - ) : r === "Q" ? (e.qx = n, e.qy = s, ["C"].concat( - wt(i, l, o[0], o[1], o[2], o[3]) - )) : r === "L" ? ["C"].concat( - Ee(i, l, n, s) - ) : r === "Z" ? ["C"].concat( - Ee(i, l, c, a) - ) : t; -}, $e = (t, e) => { - const [r] = t, o = r.toUpperCase(), n = r !== o, { x1: s, y1: i, x2: l, y2: c, x: a, y: u } = e, h = t.slice(1); - let f = h.map((y, m) => y + (n ? m % 2 ? u : a : 0)); - if ("TQ".includes(o) || (e.qx = null, e.qy = null), o === "A") - return f = h.slice(0, -2).concat( - h[5] + (n ? a : 0), - h[6] + (n ? u : 0) - ), ["A"].concat(f); - if (o === "H") - return [ - "L", - t[1] + (n ? a : 0), - i - ]; - if (o === "V") - return [ - "L", - s, - t[1] + (n ? u : 0) - ]; - if (o === "L") - return [ - "L", - t[1] + (n ? a : 0), - t[2] + (n ? u : 0) - ]; - if (o === "M") - return [ - "M", - t[1] + (n ? a : 0), - t[2] + (n ? u : 0) - ]; - if (o === "C") - return ["C"].concat(f); - if (o === "S") { - const y = s * 2 - l, m = i * 2 - c; - return e.x1 = y, e.y1 = m, ["C", y, m].concat(f); - } else if (o === "T") { - const y = s * 2 - (e.qx ? e.qx : ( - /* istanbul ignore next */ - 0 - )), m = i * 2 - (e.qy ? e.qy : ( - /* istanbul ignore next */ - 0 - )); - return e.qx = y, e.qy = m, ["Q", y, m].concat(f); - } else if (o === "Q") { - const [y, m] = f; - return e.qx = y, e.qy = m, ["Q"].concat(f); - } else if (o === "Z") - return ["Z"]; - return t; -}, he = { - x1: 0, - y1: 0, - x2: 0, - y2: 0, - x: 0, - y: 0, - qx: null, - qy: null -}, mt = (t) => { - const e = { ...he }, r = Q(t); - return O(r, (o, n, s, i) => { - e.x = s, e.y = i; - const l = $e(o, e); - let c = Lt(l, e); - c[0] === "C" && c.length > 7 && (r.splice( - n + 1, - 0, - ["C"].concat(c.slice(7)) - ), c = c.slice(0, 7)); - const u = c.length; - return e.x1 = +c[u - 2], e.y1 = +c[u - 1], e.x2 = +c[u - 4] || e.x1, e.y2 = +c[u - 3] || e.y1, c; - }); -}, ne = { - origin: [0, 0, 0], - round: 4 -}, $ = (t, e) => { - const r = e >= 1 ? 10 ** e : 1; - return e > 0 ? Math.round(t * r) / r : Math.round(t); -}, Nt = (t, e) => { - const r = t.length; - let { round: o } = ne, n = t[0], s = ""; - o = e === "off" || typeof e == "number" && e >= 0 ? e : typeof o == "number" && o >= 0 ? o : ( - /* istanbul ignore next @preserve */ - "off" - ); - for (let i = 0; i < r; i += 1) { - n = t[i]; - const [l] = n, c = n.slice(1); - if (s += l, o === "off") - s += c.join(" "); - else { - let a = 0; - const u = c.length; - for (; a < u; ) - s += $(c[a], o), a !== u - 1 && (s += " "), a += 1; - } - } - return s; -}, Se = 1e-5, qe = (t) => { - const e = Q(t), r = { ...he }; - return O(e, (o, n, s, i) => { - r.x = s, r.y = i; - const l = $e(o, r), c = l.length; - return r.x1 = +l[c - 2], r.y1 = +l[c - 1], r.x2 = +l[c - 4] || r.x1, r.y2 = +l[c - 3] || r.y1, l; - }); -}, xe = (t, e) => { - const r = qe(t); - let o = !1, n = [], s = "M", i = 0, l = 0, [c, a] = r[0].slice(1); - const u = typeof e == "number"; - let h = { x: c, y: a }, f = 0, y = h, m = 0; - return !u || e < Se ? h : (O(r, (x, p, b, M) => { - if ([s] = x, o = s === "M", n = o ? n : [b, M].concat(x.slice(1)), o ? ([, c, a] = x, h = { x: c, y: a }, f = 0) : s === "L" ? (h = Le( - n[0], - n[1], - n[2], - n[3], - e - m - ), f = Y(n[0], n[1], n[2], n[3])) : s === "A" ? (h = Ge( - n[0], - n[1], - n[2], - n[3], - n[4], - n[5], - n[6], - n[7], - n[8], - e - m - ), f = Te( - n[0], - n[1], - n[2], - n[3], - n[4], - n[5], - n[6], - n[7], - n[8] - )) : s === "C" ? (h = rt( - n[0], - n[1], - n[2], - n[3], - n[4], - n[5], - n[6], - n[7], - e - m - ), f = ie( - n[0], - n[1], - n[2], - n[3], - n[4], - n[5], - n[6], - n[7] - )) : s === "Q" ? (h = st( - n[0], - n[1], - n[2], - n[3], - n[4], - n[5], - e - m - ), f = ce( - n[0], - n[1], - n[2], - n[3], - n[4], - n[5] - )) : s === "Z" && (n = [b, M, c, a], h = { x: c, y: a }, f = Y(n[0], n[1], n[2], n[3])), [i, l] = n.slice(-2), m < e) - y = h; - else - return !1; - m += f; - }), e > m - Se ? { x: i, y: l } : y); -}, oe = (t) => { - const e = Q(t); - let r = 0, o = 0, n = 0, s = 0, i = 0, l = 0, c = "M", a = 0, u = 0, h = 0; - return O(e, (f, y, m, x) => { - [c] = f; - const p = c.toUpperCase(), M = p !== c ? ue(f, y, m, x) : f.slice(0), d = p === "V" ? ["L", m, M[1]] : p === "H" ? ["L", M[1], x] : M; - if ([c] = d, "TQ".includes(p) || (i = 0, l = 0), c === "M") - [, a, u] = d; - else if (c === "L") - h += Y( - m, - x, - d[1], - d[2] - ); - else if (c === "A") - h += Te( - m, - x, - d[1], - d[2], - d[3], - d[4], - d[5], - d[6], - d[7] - ); - else if (c === "S") { - const g = r * 2 - n, A = o * 2 - s; - h += ie( - m, - x, - g, - A, - d[1], - d[2], - d[3], - d[4] - ); - } else c === "C" ? h += ie( - m, - x, - d[1], - d[2], - d[3], - d[4], - d[5], - d[6] - ) : c === "T" ? (i = r * 2 - i, l = o * 2 - l, h += ce( - m, - x, - i, - l, - d[1], - d[2] - )) : c === "Q" ? (i = d[1], l = d[2], h += ce( - m, - x, - d[1], - d[2], - d[3], - d[4] - )) : c === "Z" && (h += Y(m, x, a, u)); - [r, o] = c === "Z" ? [a, u] : d.slice(-2), [n, s] = c === "C" ? [d[3], d[4]] : c === "S" ? [d[1], d[2]] : [r, o]; - }), h; -}, ut = (t, e) => { - const r = Q(t); - let o = r.slice(0), n = oe(o), s = o.length - 1, i = 0, l = 0, c = r[0]; - if (s <= 0 || !e || !Number.isFinite(e)) - return { - segment: c, - index: 0, - length: l, - lengthAtSegment: i - }; - if (e >= n) - return o = r.slice(0, -1), i = oe(o), l = n - i, c = r[s], { - segment: c, - index: s, - length: l, - lengthAtSegment: i - }; - const a = []; - for (; s > 0; ) - c = o[s], o = o.slice(0, -1), i = oe(o), l = n - i, n = i, a.push({ - segment: c, - index: s, - length: l, - lengthAtSegment: i - }), s -= 1; - return a.find( - ({ lengthAtSegment: u }) => u <= e - ); -}, ze = (t, e) => { - const r = Q(t), o = qe(r), n = oe(o), s = (g) => { - const A = g.x - e.x, S = g.y - e.y; - return A * A + S * S; - }; - let i = 8, l, c = { x: 0, y: 0 }, a = 0, u = 0, h = 1 / 0; - for (let g = 0; g <= n; g += i) - l = xe(o, g), a = s(l), a < h && (c = l, u = g, h = a); - i /= 2; - let f, y, m = 0, x = 0, p = 0, b = 0; - for (; i > 1e-6 && (m = u - i, f = xe(o, m), p = s(f), x = u + i, y = xe(o, x), b = s(y), m >= 0 && p < h ? (c = f, u = m, h = p) : x <= n && b < h ? (c = y, u = x, h = b) : i /= 2, !(i < 1e-5)); ) - ; - const M = ut(r, u), d = Math.sqrt(h); - return { closest: c, distance: d, segment: M }; -}, Jt = (t, e) => ze(t, e).closest, Tt = (t, e, r, o, n, s, i, l) => 3 * ((l - e) * (r + n) - (i - t) * (o + s) + o * (t - n) - r * (e - s) + l * (n + t / 3) - i * (s + e / 3)) / 20, vt = (t) => { - let e = 0, r = 0, o = 0; - return mt(t).map((n) => { - switch (n[0]) { - case "M": - return [, e, r] = n, 0; - default: - return o = Tt( - e, - r, - n[1], - n[2], - n[3], - n[4], - n[5], - n[6] - ), [e, r] = n.slice(-2), o; - } - }).reduce((n, s) => n + s, 0); -}, Kt = (t) => vt(mt(t)) >= 0, Wt = (t) => { - if (!t) - return { - x: 0, - y: 0, - width: 0, - height: 0, - x2: 0, - y2: 0, - cx: 0, - cy: 0, - cz: 0 - }; - const e = Q(t); - let r = "M", o = 0, n = 0; - const { max: s, min: i } = Math; - let l = 1 / 0, c = 1 / 0, a = -1 / 0, u = -1 / 0, h = 0, f = 0, y = 0, m = 0, x = 0, p = 0, b = 0, M = 0, d = 0, g = 0; - O(e, (v, q, N, w) => { - [r] = v; - const V = r.toUpperCase(), z = V !== r ? ue(v, q, N, w) : v.slice(0), C = V === "V" ? ["L", N, z[1]] : V === "H" ? ["L", z[1], w] : z; - if ([r] = C, "TQ".includes(V) || (d = 0, g = 0), r === "M") - [, o, n] = C, h = o, f = n, y = o, m = n; - else if (r === "L") - [h, f, y, m] = ge( - N, - w, - C[1], - C[2] - ); - else if (r === "A") - [h, f, y, m] = Je( - N, - w, - C[1], - C[2], - C[3], - C[4], - C[5], - C[6], - C[7] - ); - else if (r === "S") { - const j = x * 2 - b, R = p * 2 - M; - [h, f, y, m] = Ae( - N, - w, - j, - R, - C[1], - C[2], - C[3], - C[4] - ); - } else r === "C" ? [h, f, y, m] = Ae( - N, - w, - C[1], - C[2], - C[3], - C[4], - C[5], - C[6] - ) : r === "T" ? (d = x * 2 - d, g = p * 2 - g, [h, f, y, m] = Ce( - N, - w, - d, - g, - C[1], - C[2] - )) : r === "Q" ? (d = C[1], g = C[2], [h, f, y, m] = Ce( - N, - w, - C[1], - C[2], - C[3], - C[4] - )) : r === "Z" && ([h, f, y, m] = ge(N, w, o, n)); - l = i(h, l), c = i(f, c), a = s(y, a), u = s(m, u), [x, p] = r === "Z" ? [o, n] : C.slice(-2), [b, M] = r === "C" ? [C[3], C[4]] : r === "S" ? [C[1], C[2]] : [x, p]; - }); - const A = a - l, S = u - c; - return { - width: A, - height: S, - x: l, - y: c, - x2: a, - y2: u, - cx: l + A / 2, - cy: c + S / 2, - // an estimated guess - cz: Math.max(A, S) + Math.min(A, S) / 2 - }; -}, Xt = (t, e) => ut(t, e).segment, Yt = (t, e) => ze(t, e).segment, je = (t) => Array.isArray(t) && t.every((e) => { - const r = e[0].toLowerCase(); - return W[r] === e.length - 1 && "achlmqstvz".includes(r) && e.slice(1).every(Number.isFinite); -}) && t.length > 0, $t = (t) => je(t) && // `isPathArray` also checks if it's `Array` -t.every(([e]) => e === e.toUpperCase()), qt = (t) => $t(t) && t.every(([e]) => "ACLMQZ".includes(e)), en = (t) => qt(t) && t.every(([e]) => "MC".includes(e)), tn = (t, e) => { - const { distance: r } = ze(t, e); - return Math.abs(r) < Se; -}, nn = (t) => je(t) && // `isPathArray` checks if it's `Array` -t.slice(1).every(([e]) => e === e.toLowerCase()), zt = (t) => { - if (typeof t != "string" || !t.length) - return !1; - const e = new ct(t); - for (X(e); e.index < e.max && !e.err.length; ) - it(e); - return !e.err.length && "mM".includes(e.segments[0][0]); -}, le = { - line: ["x1", "y1", "x2", "y2"], - circle: ["cx", "cy", "r"], - ellipse: ["cx", "cy", "rx", "ry"], - rect: ["width", "height", "x", "y", "rx", "ry"], - polygon: ["points"], - polyline: ["points"], - glyph: ["d"] -}, ht = (t) => t != null && typeof t == "object" && t.nodeType === 1, jt = (t) => { - let { x1: e, y1: r, x2: o, y2: n } = t; - return [e, r, o, n] = [e, r, o, n].map((s) => +s), [ - ["M", e, r], - ["L", o, n] - ]; -}, It = (t) => { - const e = [], r = (t.points || "").trim().split(/[\s|,]/).map((n) => +n); - let o = 0; - for (; o < r.length; ) - e.push([o ? "L" : "M", r[o], r[o + 1]]), o += 2; - return t.type === "polygon" ? [...e, ["z"]] : e; -}, kt = (t) => { - let { cx: e, cy: r, r: o } = t; - return [e, r, o] = [e, r, o].map((n) => +n), [ - ["M", e - o, r], - ["a", o, o, 0, 1, 0, 2 * o, 0], - ["a", o, o, 0, 1, 0, -2 * o, 0] - ]; -}, Et = (t) => { - let { cx: e, cy: r } = t, o = t.rx || 0, n = t.ry || o; - return [e, r, o, n] = [e, r, o, n].map((s) => +s), [ - ["M", e - o, r], - ["a", o, n, 0, 1, 0, 2 * o, 0], - ["a", o, n, 0, 1, 0, -2 * o, 0] - ]; -}, Vt = (t) => { - const e = +t.x || 0, r = +t.y || 0, o = +t.width, n = +t.height; - let s = +(t.rx || 0), i = +(t.ry || s); - return s || i ? (s * 2 > o && (s -= (s * 2 - o) / 2), i * 2 > n && (i -= (i * 2 - n) / 2), [ - ["M", e + s, r], - ["h", o - s * 2], - ["s", s, 0, s, i], - ["v", n - i * 2], - ["s", 0, i, -s, i], - ["h", -o + s * 2], - ["s", -s, 0, -s, -i], - ["v", -n + i * 2], - ["s", 0, -i, s, -i] - ]) : [["M", e, r], ["h", o], ["v", n], ["H", e], ["Z"]]; -}, Rt = (t) => { - const e = Object.keys(le), r = ht(t), o = r ? t.tagName : null; - if (o && [...e, "path"].every((c) => o !== c)) - throw TypeError(`${_}: "${o}" is not SVGElement`); - const n = r ? o : t.type, s = le[n], i = { type: n }; - r ? s.forEach((c) => { - i[c] = t.getAttribute(c); - }) : Object.assign(i, t); - let l = []; - return n === "circle" ? l = kt(i) : n === "ellipse" ? l = Et(i) : ["polyline", "polygon"].includes(n) ? l = It(i) : n === "rect" ? l = Vt(i) : n === "line" ? l = jt(i) : ["glyph", "path"].includes(n) && (l = Q( - r ? t.getAttribute("d") || /* istanbul ignore next @preserve */ - "" : t.d || "" - )), je(l) && l.length ? l : !1; -}, rn = (t, e, r) => { - const o = r || document, n = Object.keys(le), s = ht(t), i = s ? t.tagName : null; - if (i === "path") - throw TypeError(`${_}: "${i}" is already SVGPathElement`); - if (i && n.every((m) => i !== m)) - throw TypeError(`${_}: "${i}" is not SVGElement`); - const l = o.createElementNS("http://www.w3.org/2000/svg", "path"), c = s ? i : t.type, a = le[c], u = { type: c }, h = ne.round, f = Rt(t), y = f && f.length ? Nt(f, h) : ""; - return s ? (a.forEach((m) => { - u[m] = t.getAttribute(m); - }), Object.values(t.attributes).forEach(({ name: m, value: x }) => { - a.includes(m) || l.setAttribute(m, x); - })) : (Object.assign(u, t), Object.keys(u).forEach((m) => { - !a.includes(m) && m !== "type" && l.setAttribute( - m.replace(/[A-Z]/g, (x) => `-${x.toLowerCase()}`), - u[m] - ); - })), zt(y) ? (l.setAttribute("d", y), e && s && (t.before(l, t), t.remove()), l) : !1; -}, _t = (t) => { - let e = new P(); - const { origin: r } = t, [o, n] = r, { translate: s } = t, { rotate: i } = t, { skew: l } = t, { scale: c } = t; - return Array.isArray(s) && s.length >= 2 && s.every((a) => !Number.isNaN(+a)) && s.some((a) => a !== 0) ? e = e.translate(...s) : typeof s == "number" && !Number.isNaN(s) && (e = e.translate(s)), (i || l || c) && (e = e.translate(o, n), Array.isArray(i) && i.length >= 2 && i.every((a) => !Number.isNaN(+a)) && i.some((a) => a !== 0) ? e = e.rotate(...i) : typeof i == "number" && !Number.isNaN(i) && (e = e.rotate(i)), Array.isArray(l) && l.length === 2 && l.every( - (a) => !Number.isNaN(+a) - ) && l.some((a) => a !== 0) ? (e = l[0] ? e.skewX(l[0]) : e, e = l[1] ? e.skewY(l[1]) : e) : typeof l == "number" && !Number.isNaN(l) && (e = e.skewX(l)), Array.isArray(c) && c.length >= 2 && c.every( - (a) => !Number.isNaN(+a) - ) && c.some((a) => a !== 1) ? e = e.scale(...c) : typeof c == "number" && !Number.isNaN(c) && (e = e.scale(c)), e = e.translate(-o, -n)), e; -}, Ot = (t, e, r, o) => { - const [n] = t, { round: s } = ne, i = s, l = e.slice(1), { x1: c, y1: a, x2: u, y2: h, x: f, y } = r, [m, x] = l.slice(-2), p = t; - if ("TQ".includes(n) || (r.qx = null, r.qy = null), n === "L") { - if ($(f, i) === $(m, i)) - return ["V", x]; - if ($(y, i) === $(x, i)) - return ["H", m]; - } else if (n === "C") { - const [b, M] = l; - if (r.x1 = b, r.y1 = M, "CS".includes(o) && ($(b, i) === $(c * 2 - u, i) && $(M, i) === $(a * 2 - h, i) || $(c, i) === $(u * 2 - f, i) && $(a, i) === $(h * 2 - y, i))) - return [ - "S", - l[2], - l[3], - l[4], - l[5] - ]; - } else if (n === "Q") { - const [b, M] = l; - if (r.qx = b, r.qy = M, "QT".includes(o) && $(b, i) === $(c * 2 - u, i) && $(M, i) === $(a * 2 - h, i)) - return ["T", l[2], l[3]]; - } - return p; -}, Pe = (t, e) => { - const r = t.slice(1).map( - (o) => $(o, e) - ); - return [t[0]].concat(r); -}, on = (t, e) => { - const r = lt(t), o = typeof e == "number" && e >= 0 ? e : ( - /* istanbul ignore next @preserve */ - 2 - ), n = { ...he }, s = []; - let i = "M", l = "Z"; - return O(r, (c, a, u, h) => { - n.x = u, n.y = h; - const f = $e(c, n); - let y = c; - if ([i] = c, s[a] = i, a) { - l = s[a - 1]; - const x = Ot( - c, - f, - n, - l - ), p = Pe(x, o), b = p.join(""), M = at(x, a, u, h), d = Pe(M, o), g = d.join(""); - y = b.length < g.length ? p : d; - } - const m = f.length; - return n.x1 = +f[m - 2], n.y1 = +f[m - 1], n.x2 = +f[m - 4] || n.x1, n.y2 = +f[m - 3] || n.y1, y; - }); -}, Qt = (t, e) => { - let r = P.Translate(e[0], e[1], e[2]); - return [, , , r.m44] = e, r = t.multiply(r), [r.m41, r.m42, r.m43, r.m44]; -}, Ve = (t, e, r) => { - const [o, n, s] = r, [i, l, c] = Qt(t, [e[0], e[1], 0, 1]), a = i - o, u = l - n, h = c - s; - return [ - // protect against division by ZERO - a * (Math.abs(s) / Math.abs(h) || 1) + o, - u * (Math.abs(s) / Math.abs(h) || 1) + n - ]; -}, sn = (t) => { - const e = t.slice(1).map( - (r, o, n) => o ? n[o - 1].slice(-2).concat(r.slice(1)) : t[0].slice(1).concat(r.slice(1)) - ).map((r) => r.map((o, n) => r[r.length - n - 2 * (1 - n % 2)])).reverse(); - return [["M"].concat(e[0].slice(0, 2))].concat( - e.map((r) => ["C"].concat(r.slice(2))) - ); -}, cn = (t) => { - const e = lt(t), r = qe(e), o = e.length, n = e[o - 1][0] === "Z", s = O(e, (i, l) => { - const c = r[l], a = l && e[l - 1], u = a && a[0], h = e[l + 1], f = h && h[0], [y] = i, [m, x] = r[l ? l - 1 : o - 1].slice(-2); - let p = i; - switch (y) { - case "M": - p = n ? ["Z"] : [y, m, x]; - break; - case "A": - p = [ - y, - i[1], - i[2], - i[3], - i[4], - i[5] === 1 ? 0 : 1, - m, - x - ]; - break; - case "C": - h && f === "S" ? p = ["S", i[1], i[2], m, x] : p = [ - y, - i[3], - i[4], - i[1], - i[2], - m, - x - ]; - break; - case "S": - u && "CS".includes(u) && (!h || f !== "S") ? p = [ - "C", - c[3], - c[4], - c[1], - c[2], - m, - x - ] : p = [ - y, - c[1], - c[2], - m, - x - ]; - break; - case "Q": - h && f === "T" ? p = ["T", m, x] : p = [y, i[1], i[2], m, x]; - break; - case "T": - u && "QT".includes(u) && (!h || f !== "T") ? p = [ - "Q", - c[1], - c[2], - m, - x - ] : p = [y, m, x]; - break; - case "Z": - p = ["M", m, x]; - break; - case "H": - p = [y, m]; - break; - case "V": - p = [y, x]; - break; - default: - p = [y].concat( - i.slice(1, -2), - m, - x - ); - } - return p; - }); - return n ? s.reverse() : [s[0]].concat(s.slice(1).reverse()); -}, ln = (t, e) => { - let { round: r } = ne; - return r = e === "off" || typeof e == "number" && e >= 0 ? e : typeof r == "number" && r >= 0 ? r : ( - /* istanbul ignore next @preserve */ - "off" - ), r === "off" ? t.slice(0) : O(t, (o) => Pe(o, r)); -}, an = (t, e = 0.5) => { - const r = e, o = t.slice(0, 2), n = t.slice(2, 4), s = t.slice(4, 6), i = t.slice(6, 8), l = B(o, n, r), c = B(n, s, r), a = B(s, i, r), u = B(l, c, r), h = B(c, a, r), f = B(u, h, r); - return [ - ["C", l[0], l[1], u[0], u[1], f[0], f[1]], - ["C", h[0], h[1], a[0], a[1], i[0], i[1]] - ]; -}, mn = (t) => { - const e = []; - let r, o = -1, n = 0, s = 0, i = 0, l = 0; - const c = { ...he }; - return t.forEach((a) => { - const [u] = a, h = u.toUpperCase(), f = u.toLowerCase(), y = u === f, m = a.slice(1); - h === "M" ? (o += 1, [n, s] = m, n += y ? c.x : 0, s += y ? c.y : 0, i = n, l = s, r = [y ? [h, i, l] : a]) : (h === "Z" ? (n = i, s = l) : h === "H" ? ([, n] = a, n += y ? c.x : ( - /* istanbul ignore next @preserve */ - 0 - )) : h === "V" ? ([, s] = a, s += y ? c.y : ( - /* istanbul ignore next @preserve */ - 0 - )) : ([n, s] = a.slice(-2), n += y ? c.x : 0, s += y ? c.y : 0), r.push(a)), c.x = n, c.y = s, e[o] = r; - }), e; -}, un = (t, e) => { - let r = 0, o = 0, n = 0, s = 0, i = 0, l = 0, c = "M"; - const a = Q(t), u = e && Object.keys(e); - if (!e || u && !u.length) - return a.slice(0); - e.origin || Object.assign(e, { origin: ne.origin }); - const h = e.origin, f = _t(e); - return f.isIdentity ? a.slice(0) : O(a, (y, m, x, p) => { - [c] = y; - const b = c.toUpperCase(), d = b !== c ? ue(y, m, x, p) : y.slice(0); - let g = b === "A" ? ["C"].concat( - ve( - x, - p, - d[1], - d[2], - d[3], - d[4], - d[5], - d[6], - d[7] - ) - ) : b === "V" ? ["L", x, d[1]] : b === "H" ? ["L", d[1], p] : d; - c = g[0]; - const A = c === "C" && g.length > 7, S = A ? g.slice(0, 7) : g.slice(0); - if (A && (a.splice( - m + 1, - 0, - ["C"].concat( - g.slice(7) - ) - ), g = S), c === "L") - [n, s] = Ve(f, [ - g[1], - g[2] - ], h), r !== n && o !== s ? g = ["L", n, s] : o === s ? g = ["H", n] : r === n && (g = ["V", s]); - else - for (i = 1, l = g.length; i < l; i += 2) - [n, s] = Ve( - f, - [+g[i], +g[i + 1]], - h - ), g[i] = n, g[i + 1] = s; - return r = n, o = s, g; - }); -}; -export { - P as CSSMatrix, - ue as absolutizeSegment, - ve as arcToCubic, - Dt as arcTools, - Bt as bezierTools, - Ht as cubicTools, - Se as distanceEpsilon, - we as distanceSquareRoot, - ke as finalizeSegment, - Jt as getClosestPoint, - Kt as getDrawDirection, - vt as getPathArea, - Wt as getPathBBox, - xe as getPointAtLength, - ut as getPropertiesAtLength, - ze as getPropertiesAtPoint, - _t as getSVGMatrix, - Xt as getSegmentAtLength, - Yt as getSegmentOfPoint, - oe as getTotalLength, - J as invalidPathValue, - $t as isAbsoluteArray, - St as isArcCommand, - en as isCurveArray, - G as isDigit, - Ct as isDigitStart, - Pt as isMoveCommand, - qt as isNormalizedArray, - je as isPathArray, - At as isPathCommand, - tn as isPointInStroke, - nn as isRelativeArray, - Mt as isSpace, - zt as isValidPath, - O as iterate, - Ee as lineToCubic, - Zt as lineTools, - B as midPoint, - qe as normalizePath, - $e as normalizeSegment, - on as optimizePath, - W as paramsCount, - he as paramsParser, - Q as parsePathString, - ct as pathParser, - lt as pathToAbsolute, - mt as pathToCurve, - Gt as pathToRelative, - Nt as pathToString, - Ut as polygonTools, - Ve as projection2d, - wt as quadToCubic, - Ft as quadTools, - at as relativizeSegment, - sn as reverseCurve, - cn as reversePath, - re as rotateVector, - ln as roundPath, - Pe as roundSegment, - $ as roundTo, - pt as scanFlag, - bt as scanParam, - it as scanSegment, - Lt as segmentToCubic, - le as shapeParams, - rn as shapeToPath, - Rt as shapeToPathArray, - Ot as shortenSegment, - X as skipSpaces, - an as splitCubic, - mn as splitPath, - un as transformPath -}; -//# sourceMappingURL=util.mjs.map +var At=Object.defineProperty;var ie=(e,t)=>{for(var n in t)At(e,n,{get:t[n],enumerable:!0})};import{default as Ws}from"@thednp/dommatrix";var it={};ie(it,{angleBetween:()=>De,arcLength:()=>Ee,arcPoint:()=>Y,getArcBBox:()=>$e,getArcLength:()=>ge,getArcProps:()=>Le,getPointAtArcLength:()=>Ie});var mt={};ie(mt,{getLineBBox:()=>Me,getLineLength:()=>X,getPointAtLineLength:()=>he});var Ct=(e,t,n)=>{let[o,r]=e,[a,s]=t;return[o+(a-o)*n,r+(s-r)*n]},I=Ct;var Tt=(e,t)=>Math.sqrt((e[0]-t[0])*(e[0]-t[0])+(e[1]-t[1])*(e[1]-t[1])),ue=Tt;var X=(e,t,n,o)=>ue([e,t],[n,o]),he=(e,t,n,o,r)=>{let a={x:e,y:t};if(typeof r=="number"){let s=ue([e,t],[n,o]);if(r<=0)a={x:e,y:t};else if(r>=s)a={x:n,y:o};else{let[i,m]=I([e,t],[n,o],r/s);a={x:i,y:m}}}return a},Me=(e,t,n,o)=>{let{min:r,max:a}=Math;return[r(e,n),r(t,o),a(e,n),a(t,o)]};var Ee=(e,t,n)=>{let o=n/2,r=Math.sin(o),a=Math.cos(o),s=e**2*r**2,i=t**2*a**2,m=Math.sqrt(s+i)*n;return Math.abs(m)},Y=(e,t,n,o,r,a)=>{let{sin:s,cos:i}=Math,m=i(r),u=s(r),l=n*i(a),c=o*s(a);return[e+m*l-u*c,t+u*l+m*c]},De=(e,t)=>{let{x:n,y:o}=e,{x:r,y:a}=t,s=n*r+o*a,i=Math.sqrt((n**2+o**2)*(r**2+a**2));return(n*a-o*r<0?-1:1)*Math.acos(s/i)},Le=(e,t,n,o,r,a,s,i,m)=>{let{abs:u,sin:l,cos:c,sqrt:f,PI:b}=Math,p=u(n),h=u(o),S=(r%360+360)%360*(b/180);if(e===i&&t===m)return{rx:p,ry:h,startAngle:0,endAngle:0,center:{x:i,y:m}};if(p===0||h===0)return{rx:p,ry:h,startAngle:0,endAngle:0,center:{x:(i+e)/2,y:(m+t)/2}};let A=(e-i)/2,d=(t-m)/2,g={x:c(S)*A+l(S)*d,y:-l(S)*A+c(S)*d},x=g.x**2/p**2+g.y**2/h**2;x>1&&(p*=f(x),h*=f(x));let C=p**2*h**2-p**2*g.y**2-h**2*g.x**2,V=p**2*g.y**2+h**2*g.x**2,Q=C/V;Q=Q<0?0:Q;let w=(a!==s?1:-1)*f(Q),M={x:w*(p*g.y/h),y:w*(-(h*g.x)/p)},$={x:c(S)*M.x-l(S)*M.y+(e+i)/2,y:l(S)*M.x+c(S)*M.y+(t+m)/2},J={x:(g.x-M.x)/p,y:(g.y-M.y)/h},k=De({x:1,y:0},J),P={x:(-g.x-M.x)/p,y:(-g.y-M.y)/h},z=De(J,P);!s&&z>0?z-=2*b:s&&z<0&&(z+=2*b),z%=2*b;let B=k+z;return{center:$,startAngle:k,endAngle:B,rx:p,ry:h}},ge=(e,t,n,o,r,a,s,i,m)=>{let{rx:u,ry:l,startAngle:c,endAngle:f}=Le(e,t,n,o,r,a,s,i,m);return Ee(u,l,f-c)},Ie=(e,t,n,o,r,a,s,i,m,u)=>{let l={x:e,y:t},{center:c,rx:f,ry:b,startAngle:p,endAngle:h}=Le(e,t,n,o,r,a,s,i,m);if(typeof u=="number"){let y=Ee(f,b,h-p);if(u<=0)l={x:e,y:t};else if(u>=y)l={x:i,y:m};else{if(e===i&&t===m)return{x:i,y:m};if(f===0||b===0)return he(e,t,i,m,u);let{PI:S,cos:A,sin:d}=Math,g=h-p,C=(r%360+360)%360*(S/180),V=p+g*(u/y),Q=f*A(V),w=b*d(V);l={x:A(C)*Q-d(C)*w+c.x,y:d(C)*Q+A(C)*w+c.y}}}return l},$e=(e,t,n,o,r,a,s,i,m)=>{let{center:u,rx:l,ry:c,startAngle:f,endAngle:b}=Le(e,t,n,o,r,a,s,i,m),p=b-f,{min:h,max:y,tan:S,atan2:A,PI:d}=Math,{x:g,y:x}=u,C=r*d/180,V=S(C),Q=A(-c*V,l),w=Q,M=Q+d,$=A(c,l*V),J=$+d,k=[i],P=[m],z=h(e,i),B=y(e,i),E=h(t,m),Z=y(t,m),me=b-p*1e-5,W=Y(g,x,l,c,C,me),N=b-p*.99999,q=Y(g,x,l,c,C,N);if(W[0]>B||q[0]>B){let R=Y(g,x,l,c,C,w);k.push(R[0]),P.push(R[1])}if(W[0]Z||q[1]>Z){let R=Y(g,x,l,c,C,$);k.push(R[0]),P.push(R[1])}return z=h.apply([],k),E=h.apply([],P),B=y.apply([],k),Z=y.apply([],P),[z,E,B,Z]};var ht={};ie(ht,{CBEZIER_MINMAX_EPSILON:()=>bt,Cvalues:()=>ut,Tvalues:()=>Be,bezierLength:()=>ft,calculateBezier:()=>ct,computeBezier:()=>pt,deriveBezier:()=>lt,getBezierLength:()=>ee,minmaxC:()=>ve,minmaxQ:()=>de});var Be=[-.06405689286260563,.06405689286260563,-.1911188674736163,.1911188674736163,-.3150426796961634,.3150426796961634,-.4337935076260451,.4337935076260451,-.5454214713888396,.5454214713888396,-.6480936519369755,.6480936519369755,-.7401241915785544,.7401241915785544,-.820001985973903,.820001985973903,-.8864155270044011,.8864155270044011,-.9382745520027328,.9382745520027328,-.9747285559713095,.9747285559713095,-.9951872199970213,.9951872199970213],ut=[.12793819534675216,.12793819534675216,.1258374563468283,.1258374563468283,.12167047292780339,.12167047292780339,.1155056680537256,.1155056680537256,.10744427011596563,.10744427011596563,.09761865210411388,.09761865210411388,.08619016153195327,.08619016153195327,.0733464814110803,.0733464814110803,.05929858491543678,.05929858491543678,.04427743881741981,.04427743881741981,.028531388628933663,.028531388628933663,.0123412297999872,.0123412297999872],lt=e=>{let t=[];for(let n=e,o=n.length,r=o-1;o>1;o-=1,r-=1){let a=[];for(let s=0;s{if(t===0)return e[0].t=0,e[0];let n=e.length-1;if(t===1)return e[n].t=1,e[n];let o=1-t,r=e;if(n===0)return e[0].t=t,e[0];if(n===1)return{x:o*r[0].x+t*r[1].x,y:o*r[0].y+t*r[1].y,t};let a=o*o,s=t*t,i=0,m=0,u=0,l=0;return n===2?(r=[r[0],r[1],r[2],{x:0,y:0}],i=a,m=o*t*2,u=s):n===3&&(i=a*o,m=a*t*3,u=o*s*3,l=t*s),{x:i*r[0].x+m*r[1].x+u*r[2].x+l*r[3].x,y:i*r[0].y+m*r[1].y+u*r[2].y+l*r[3].y,t}},ct=(e,t)=>{let n=e(t),o=n.x*n.x+n.y*n.y;return Math.sqrt(o)},ft=e=>{let n=Be.length,o=0;for(let r=0,a;r{let t=[];for(let o=0,r=e.length,a=2;opt(n[0],o))},bt=1e-8,de=([e,t,n])=>{let o=Math.min(e,n),r=Math.max(e,n);if(t>=e?n>=t:n<=t)return[o,r];let a=(e*n-t*t)/(e-2*t+n);return a{let r=e-3*t+3*n-o;if(Math.abs(r)0&&l<1){let f=e*(1-l)*(1-l)*(1-l)+t*3*(1-l)*(1-l)*l+n*3*(1-l)*l*l+o*l*l*l;fm&&(m=f)}}return[i,m]};var dt={};ie(dt,{getCubicBBox:()=>Ne,getCubicLength:()=>le,getPointAtCubicLength:()=>je,getPointAtCubicSegmentLength:()=>gt});var gt=([e,t,n,o,r,a,s,i],m)=>{let u=1-m;return{x:u**3*e+3*u**2*m*n+3*u*m**2*r+m**3*s,y:u**3*t+3*u**2*m*o+3*u*m**2*a+m**3*i}},le=(e,t,n,o,r,a,s,i)=>ee([e,t,n,o,r,a,s,i]),je=(e,t,n,o,r,a,s,i,m)=>{let u=typeof m=="number",l={x:e,y:t};if(u){let c=ee([e,t,n,o,r,a,s,i]);m<=0||(m>=c?l={x:s,y:i}:l=gt([e,t,n,o,r,a,s,i],m/c))}return l},Ne=(e,t,n,o,r,a,s,i)=>{let m=ve([e,n,r,s]),u=ve([t,o,a,i]);return[m[0],u[0],m[1],u[1]]};var xt={};ie(xt,{getPointAtQuadLength:()=>Oe,getPointAtQuadSegmentLength:()=>yt,getQuadBBox:()=>we,getQuadLength:()=>pe});var yt=([e,t,n,o,r,a],s)=>{let i=1-s;return{x:i**2*e+2*i*s*n+s**2*r,y:i**2*t+2*i*s*o+s**2*a}},pe=(e,t,n,o,r,a)=>ee([e,t,n,o,r,a]),Oe=(e,t,n,o,r,a,s)=>{let i=typeof s=="number",m={x:e,y:t};if(i){let u=ee([e,t,n,o,r,a]);s<=0||(s>=u?m={x:r,y:a}:m=yt([e,t,n,o,r,a],s/u))}return m},we=(e,t,n,o,r,a)=>{let s=de([e,n,r]),i=de([t,o,a]);return[s[0],i[0],s[1],i[1]]};var Pt={};ie(Pt,{polygonArea:()=>Mt,polygonLength:()=>Lt});var Mt=e=>{let t=e.length,n=-1,o,r=e[t-1],a=0;for(;++ne.reduce((t,n,o)=>o?t+ue(e[o-1],n):0,0);var vt={a:7,c:6,h:1,l:2,m:2,r:4,q:4,s:4,t:2,v:1,z:0},G=vt;var Nt=e=>{let t=e.pathValue[e.segmentStart],n=t.toLowerCase(),{data:o}=e;for(;o.length>=G[n]&&(n==="m"&&o.length>2?(e.segments.push([t].concat(o.splice(0,2))),n="l",t=t==="m"?"l":"L"):e.segments.push([t].concat(o.splice(0,G[n]))),!!G[n]););},Re=Nt;var wt="SVGPathCommander Error",D=wt;var Rt=e=>{let{index:t,pathValue:n}=e,o=n.charCodeAt(t);if(o===48){e.param=0,e.index+=1;return}if(o===49){e.param=1,e.index+=1;return}e.err=`${D}: invalid Arc flag "${n[t]}", expecting 0 or 1 at index ${t}`},He=Rt;var Vt=e=>e>=48&&e<=57,j=Vt;var Qt="Invalid path value",O=Qt;var kt=e=>{let{max:t,pathValue:n,index:o}=e,r=o,a=!1,s=!1,i=!1,m=!1,u;if(r>=t){e.err=`${D}: ${O} at index ${r}, "pathValue" is missing param`;return}if(u=n.charCodeAt(r),(u===43||u===45)&&(r+=1,u=n.charCodeAt(r)),!j(u)&&u!==46){e.err=`${D}: ${O} at index ${r}, "${n[r]}" is not a number`;return}if(u!==46){if(a=u===48,r+=1,u=n.charCodeAt(r),a&&r[5760,6158,8192,8193,8194,8195,8196,8197,8198,8199,8200,8201,8202,8239,8287,12288,65279,10,13,8232,8233,32,9,11,12,160].includes(e),Ge=zt;var qt=e=>{let{pathValue:t,max:n}=e;for(;e.index{switch(e|32){case 109:case 122:case 108:case 104:case 118:case 99:case 115:case 113:case 116:case 97:return!0;default:return!1}},_e=Dt;var Et=e=>j(e)||e===43||e===45||e===46,Ue=Et;var It=e=>(e|32)===97,Ke=It;var $t=e=>{switch(e|32){case 109:case 77:return!0;default:return!1}},Fe=$t;var Bt=e=>{let{max:t,pathValue:n,index:o,segments:r}=e,a=n.charCodeAt(o),s=G[n[o].toLowerCase()];if(e.segmentStart=o,!_e(a)){e.err=`${D}: ${O} "${n[o]}" is not a path command at index ${o}`;return}let i=r[r.length-1];if(!Fe(a)&&i?.[0]?.toLocaleLowerCase()==="z"){e.err=`${D}: ${O} "${n[o]}" is not a MoveTo path command at index ${o}`;return}if(e.index+=1,_(e),e.data=[],!s){Re(e);return}for(;;){for(let m=s;m>0;m-=1){if(Ke(a)&&(m===3||m===4)?He(e):Ze(e),e.err.length)return;e.data.push(e.param),_(e),e.index=e.max||!Ue(n.charCodeAt(e.index)))break}Re(e)},ye=Bt;var F=class{constructor(t){this.segments=[],this.pathValue=t,this.max=t.length,this.index=0,this.param=0,this.segmentStart=0,this.data=[],this.err=""}};var jt=e=>{if(typeof e!="string")return e.slice(0);let t=new F(e);for(_(t);t.index{let[r]=e,a=r.toUpperCase(),s=a===r;if(t===0||s)return e;if(a==="A")return[a,e[1],e[2],e[3],e[4],e[5],e[6]+n,e[7]+o];if(a==="V")return[a,e[1]+o];if(a==="H")return[a,e[1]+n];if(a==="L")return[a,e[1]+n,e[2]+o];{let i=[],m=e.length;for(let u=1;u{let n=e.length,o,r="M",a="M",s=!1,i=0,m=0,u=0,l=0,c=0;for(let f=0;f{let t=v(e);return T(t,U)},xe=Zt;var Gt=(e,t,n,o)=>{let[r]=e,a=r.toLowerCase(),s=r===a;if(t===0||s)return e;if(a==="a")return[a,e[1],e[2],e[3],e[4],e[5],e[6]-n,e[7]-o];if(a==="v")return[a,e[1]-o];if(a==="h")return[a,e[1]-n];if(a==="l")return[a,e[1]-n,e[2]-o];{let i=[],m=e.length;for(let u=1;u{let t=v(e);return T(t,Pe)},Ut=_t;var Kt=(e,t,n)=>{let{sin:o,cos:r}=Math,a=e*r(n)-t*o(n),s=e*o(n)+t*r(n);return{x:a,y:s}},ce=Kt;var St=(e,t,n,o,r,a,s,i,m,u)=>{let l=e,c=t,f=n,b=o,p=i,h=m,y=Math.PI*120/180,S=Math.PI/180*(+r||0),A=[],d,g,x,C,V;if(u)[g,x,C,V]=u;else{d=ce(l,c,-S),l=d.x,c=d.y,d=ce(p,h,-S),p=d.x,h=d.y;let N=(l-p)/2,q=(c-h)/2,R=N*N/(f*f)+q*q/(b*b);R>1&&(R=Math.sqrt(R),f*=R,b*=R);let ze=f*f,qe=b*b,st=(a===s?-1:1)*Math.sqrt(Math.abs((ze*qe-ze*q*q-qe*N*N)/(ze*q*q+qe*N*N)));C=st*f*q/b+(l+p)/2,V=st*-b*N/f+(c+h)/2,g=Math.asin(((c-V)/b*10**9>>0)/10**9),x=Math.asin(((h-V)/b*10**9>>0)/10**9),g=lx&&(g-=Math.PI*2),!s&&x>g&&(x-=Math.PI*2)}let Q=x-g;if(Math.abs(Q)>y){let N=x,q=p,R=h;x=g+y*(s&&x>g?1:-1),p=C+f*Math.cos(x),h=V+b*Math.sin(x),A=St(p,h,f,b,r,0,s,q,R,[x,N,C,V])}Q=x-g;let w=Math.cos(g),M=Math.sin(g),$=Math.cos(x),J=Math.sin(x),k=Math.tan(Q/4),P=4/3*f*k,z=4/3*b*k,B=[l,c],E=[l+P*M,c-z*w],Z=[p+P*J,h-z*$],me=[p,h];if(E[0]=2*B[0]-E[0],E[1]=2*B[1]-E[1],u)return[E[0],E[1],Z[0],Z[1],me[0],me[1]].concat(A);A=[E[0],E[1],Z[0],Z[1],me[0],me[1]].concat(A);let W=[];for(let N=0,q=A.length;N{let s=.3333333333333333,i=2/3;return[s*e+i*n,s*t+i*o,s*r+i*n,s*a+i*o,r,a]},Je=Ft;var Jt=(e,t,n,o)=>{let r=I([e,t],[n,o],.3333333333333333),a=I([e,t],[n,o],2/3);return[r[0],r[1],a[0],a[1],n,o]},Ve=Jt;var Wt=(e,t)=>{let[n]=e,o=e.slice(1).map(Number),[r,a]=o,{x1:s,y1:i,x:m,y:u}=t;return"TQ".includes(n)||(t.qx=null,t.qy=null),n==="M"?(t.x=r,t.y=a,e):n==="A"?["C"].concat(Se(s,i,o[0],o[1],o[2],o[3],o[4],o[5],o[6])):n==="Q"?(t.qx=r,t.qy=a,["C"].concat(Je(s,i,o[0],o[1],o[2],o[3]))):n==="L"?["C"].concat(Ve(s,i,r,a)):n==="Z"?["C"].concat(Ve(s,i,m,u)):e},We=Wt;var Xt=(e,t)=>{let[n]=e,o=n.toUpperCase(),r=n!==o,{x1:a,y1:s,x2:i,y2:m,x:u,y:l}=t,c=e.slice(1),f=c.map((b,p)=>b+(r?p%2?l:u:0));"TQ".includes(o)||(t.qx=null,t.qy=null);if(o==="A")return f=c.slice(0,-2).concat(c[5]+(r?u:0),c[6]+(r?l:0)),["A"].concat(f);if(o==="H")return["L",e[1]+(r?u:0),s];if(o==="V")return["L",a,e[1]+(r?l:0)];if(o==="L")return["L",e[1]+(r?u:0),e[2]+(r?l:0)];if(o==="M")return["M",e[1]+(r?u:0),e[2]+(r?l:0)];if(o==="C")return["C"].concat(f);if(o==="S"){let b=a*2-i,p=s*2-m;return t.x1=b,t.y1=p,["C",b,p].concat(f)}else if(o==="T"){let b=a*2-(t.qx?t.qx:0),p=s*2-(t.qy?t.qy:0);return t.qx=b,t.qy=p,["Q",b,p].concat(f)}else if(o==="Q"){let[b,p]=f;return t.qx=b,t.qy=p,["Q"].concat(f)}else if(o==="Z")return["Z"];return e},te=Xt;var Yt={x1:0,y1:0,x2:0,y2:0,x:0,y:0,qx:null,qy:null},K=Yt;var er=e=>{let t={...K},n=v(e);return T(n,(o,r,a,s)=>{t.x=a,t.y=s;let i=te(o,t),m=We(i,t);m[0]==="C"&&m.length>7&&(n.splice(r+1,0,["C"].concat(m.slice(7))),m=m.slice(0,7));let l=m.length;return t.x1=+m[l-2],t.y1=+m[l-1],t.x2=+m[l-4]||t.x1,t.y2=+m[l-3]||t.y1,m})},Ae=er;var tr={origin:[0,0,0],round:4},H=tr;var rr=(e,t)=>{let n=t>=1?10**t:1;return t>0?Math.round(e*n)/n:Math.round(e)},L=rr;var nr=(e,t)=>{let n=e.length,{round:o}=H,r=e[0],a="";o=t==="off"||typeof t=="number"&&t>=0?t:typeof o=="number"&&o>=0?o:"off";for(let s=0;s{let t=v(e),n={...K};return T(t,(o,r,a,s)=>{n.x=a,n.y=s;let i=te(o,n),m=i.length;return n.x1=+i[m-2],n.y1=+i[m-1],n.x2=+i[m-4]||n.x1,n.y2=+i[m-3]||n.y1,i})},re=or;var ar=(e,t)=>{let n=re(e),o=!1,r=[],a="M",s=0,i=0,[m,u]=n[0].slice(1),l=typeof t=="number",c={x:m,y:u},f=0,b=c,p=0;return!l||t{[a]=h,o=a==="M",r=o?r:[S,A].concat(h.slice(1));if(o?([,m,u]=h,c={x:m,y:u},f=0):a==="L"?(c=he(r[0],r[1],r[2],r[3],t-p),f=X(r[0],r[1],r[2],r[3])):a==="A"?(c=Ie(r[0],r[1],r[2],r[3],r[4],r[5],r[6],r[7],r[8],t-p),f=ge(r[0],r[1],r[2],r[3],r[4],r[5],r[6],r[7],r[8])):a==="C"?(c=je(r[0],r[1],r[2],r[3],r[4],r[5],r[6],r[7],t-p),f=le(r[0],r[1],r[2],r[3],r[4],r[5],r[6],r[7])):a==="Q"?(c=Oe(r[0],r[1],r[2],r[3],r[4],r[5],t-p),f=pe(r[0],r[1],r[2],r[3],r[4],r[5])):a==="Z"&&(r=[S,A,m,u],c={x:m,y:u},f=X(r[0],r[1],r[2],r[3])),[s,i]=r.slice(-2),pp-fe?{x:s,y:i}:b)},Ce=ar;var sr=e=>{let t=v(e),n=0,o=0,r=0,a=0,s=0,i=0,m="M",u=0,l=0,c=0;return T(t,(f,b,p,h)=>{[m]=f;let y=m.toUpperCase(),A=y!==m?U(f,b,p,h):f.slice(0),d=y==="V"?["L",p,A[1]]:y==="H"?["L",A[1],h]:A;[m]=d,"TQ".includes(y)||(s=0,i=0);if(m==="M")[,u,l]=d;else if(m==="L")c+=X(p,h,d[1],d[2]);else if(m==="A")c+=ge(p,h,d[1],d[2],d[3],d[4],d[5],d[6],d[7]);else if(m==="S"){let g=n*2-r,x=o*2-a;c+=le(p,h,g,x,d[1],d[2],d[3],d[4])}else m==="C"?c+=le(p,h,d[1],d[2],d[3],d[4],d[5],d[6]):m==="T"?(s=n*2-s,i=o*2-i,c+=pe(p,h,s,i,d[1],d[2])):m==="Q"?(s=d[1],i=d[2],c+=pe(p,h,d[1],d[2],d[3],d[4])):m==="Z"&&(c+=X(p,h,u,l));[n,o]=m==="Z"?[u,l]:d.slice(-2),[r,a]=m==="C"?[d[3],d[4]]:m==="S"?[d[1],d[2]]:[n,o]}),c},ne=sr;var mr=(e,t)=>{let n=v(e),o=n.slice(0),r=ne(o),a=o.length-1,s=0,i=0,m=n[0];if(a<=0||!t||!Number.isFinite(t))return{segment:m,index:0,length:i,lengthAtSegment:s};if(t>=r)return o=n.slice(0,-1),s=ne(o),i=r-s,m=n[a],{segment:m,index:a,length:i,lengthAtSegment:s};let u=[];for(;a>0;)m=o[a],o=o.slice(0,-1),s=ne(o),i=r-s,r=s,u.push({segment:m,index:a,length:i,lengthAtSegment:s}),a-=1;return u.find(({lengthAtSegment:l})=>l<=t)},Te=mr;var ir=(e,t)=>{let n=v(e),o=re(n),r=ne(o),a=g=>{let x=g.x-t.x,C=g.y-t.y;return x*x+C*C},s=8,i,m={x:0,y:0},u=0,l=0,c=1/0;for(let g=0;g<=r;g+=s)i=Ce(o,g),u=a(i),u1e-6&&(p=l-s,f=Ce(o,p),y=a(f),h=l+s,b=Ce(o,h),S=a(b),p>=0&&yoe(e,t).closest,lr=ur;var pr=(e,t,n,o,r,a,s,i)=>3*((i-t)*(n+r)-(s-e)*(o+a)+o*(e-r)-n*(t-a)+i*(r+e/3)-s*(a+t/3))/20,cr=e=>{let t=0,n=0,o=0;return Ae(e).map(r=>{switch(r[0]){case"M":return[,t,n]=r,0;default:return o=pr(t,n,r[1],r[2],r[3],r[4],r[5],r[6]),[t,n]=r.slice(-2),o}}).reduce((r,a)=>r+a,0)},Ye=cr;var fr=e=>Ye(Ae(e))>=0,br=fr;var hr=e=>{if(!e)return{x:0,y:0,width:0,height:0,x2:0,y2:0,cx:0,cy:0,cz:0};let t=v(e),n="M",o=0,r=0,{max:a,min:s}=Math,i=1/0,m=1/0,u=-1/0,l=-1/0,c=0,f=0,b=0,p=0,h=0,y=0,S=0,A=0,d=0,g=0;T(t,(V,Q,w,M)=>{[n]=V;let $=n.toUpperCase(),k=$!==n?U(V,Q,w,M):V.slice(0),P=$==="V"?["L",w,k[1]]:$==="H"?["L",k[1],M]:k;[n]=P,"TQ".includes($)||(d=0,g=0);if(n==="M")[,o,r]=P,c=o,f=r,b=o,p=r;else if(n==="L")[c,f,b,p]=Me(w,M,P[1],P[2]);else if(n==="A")[c,f,b,p]=$e(w,M,P[1],P[2],P[3],P[4],P[5],P[6],P[7]);else if(n==="S"){let z=h*2-S,B=y*2-A;[c,f,b,p]=Ne(w,M,z,B,P[1],P[2],P[3],P[4])}else n==="C"?[c,f,b,p]=Ne(w,M,P[1],P[2],P[3],P[4],P[5],P[6]):n==="T"?(d=h*2-d,g=y*2-g,[c,f,b,p]=we(w,M,d,g,P[1],P[2])):n==="Q"?(d=P[1],g=P[2],[c,f,b,p]=we(w,M,P[1],P[2],P[3],P[4])):n==="Z"&&([c,f,b,p]=Me(w,M,o,r));i=s(c,i),m=s(f,m),u=a(b,u),l=a(p,l),[h,y]=n==="Z"?[o,r]:P.slice(-2),[S,A]=n==="C"?[P[3],P[4]]:n==="S"?[P[1],P[2]]:[h,y]});let x=u-i,C=l-m;return{width:x,height:C,x:i,y:m,x2:u,y2:l,cx:i+x/2,cy:m+C/2,cz:Math.max(x,C)+Math.min(x,C)/2}},gr=hr;var dr=(e,t)=>Te(e,t).segment,yr=dr;var xr=(e,t)=>oe(e,t).segment,Pr=xr;var Sr=e=>Array.isArray(e)&&e.every(t=>{let n=t[0].toLowerCase();return G[n]===t.length-1&&"achlmqstvz".includes(n)&&t.slice(1).every(Number.isFinite)})&&e.length>0,ae=Sr;var Ar=e=>ae(e)&&e.every(([t])=>t===t.toUpperCase()),et=Ar;var Cr=e=>et(e)&&e.every(([t])=>"ACLMQZ".includes(t)),tt=Cr;var Tr=e=>tt(e)&&e.every(([t])=>"MC".includes(t)),Mr=Tr;var Lr=(e,t)=>{let{distance:n}=oe(e,t);return Math.abs(n)ae(e)&&e.slice(1).every(([t])=>t===t.toLowerCase()),wr=Nr;var Rr=e=>{if(typeof e!="string"||!e.length)return!1;let t=new F(e);for(_(t);t.indexe!=null&&typeof e=="object"&&e.nodeType===1,Qe=Qr;var kr=e=>{let{x1:t,y1:n,x2:o,y2:r}=e;return[t,n,o,r]=[t,n,o,r].map(a=>+a),[["M",t,n],["L",o,r]]},zr=e=>{let t=[],n=(e.points||"").trim().split(/[\s|,]/).map(r=>+r),o=0;for(;o{let{cx:t,cy:n,r:o}=e;return[t,n,o]=[t,n,o].map(r=>+r),[["M",t-o,n],["a",o,o,0,1,0,2*o,0],["a",o,o,0,1,0,-2*o,0]]},Dr=e=>{let{cx:t,cy:n}=e,o=e.rx||0,r=e.ry||o;return[t,n,o,r]=[t,n,o,r].map(a=>+a),[["M",t-o,n],["a",o,r,0,1,0,2*o,0],["a",o,r,0,1,0,-2*o,0]]},Er=e=>{let t=+e.x||0,n=+e.y||0,o=+e.width,r=+e.height,a=+(e.rx||0),s=+(e.ry||a);if(a||s){a*2>o&&(a-=(a*2-o)/2);return s*2>r&&(s-=(s*2-r)/2),[["M",t+a,n],["h",o-a*2],["s",a,0,a,s],["v",r-s*2],["s",0,s,-a,s],["h",-o+a*2],["s",-a,0,-a,-s],["v",-r+s*2],["s",0,-s,a,-s]]}return[["M",t,n],["h",o],["v",r],["H",t],["Z"]]},Ir=e=>{let t=Object.keys(se),n=Qe(e),o=n?e.tagName:null;if(o&&[...t,"path"].every(m=>o!==m))throw TypeError(`${D}: "${o}" is not SVGElement`);let r=n?o:e.type,a=se[r],s={type:r};n?a.forEach(m=>{s[m]=e.getAttribute(m)}):Object.assign(s,e);let i=[];return r==="circle"?i=qr(s):r==="ellipse"?i=Dr(s):["polyline","polygon"].includes(r)?i=zr(s):r==="rect"?i=Er(s):r==="line"?i=kr(s):["glyph","path"].includes(r)&&(i=v(n?e.getAttribute("d")||"":e.d||"")),ae(i)&&i.length?i:!1},nt=Ir;var $r=(e,t,n)=>{let o=n||document,r=Object.keys(se),a=Qe(e),s=a?e.tagName:null;if(s==="path")throw TypeError(`${D}: "${s}" is already SVGPathElement`);if(s&&r.every(p=>s!==p))throw TypeError(`${D}: "${s}" is not SVGElement`);let i=o.createElementNS("http://www.w3.org/2000/svg","path"),m=a?s:e.type,u=se[m],l={type:m},c=H.round,f=nt(e),b=f&&f.length?Xe(f,c):"";return a?(u.forEach(p=>{l[p]=e.getAttribute(p)}),Object.values(e.attributes).forEach(({name:p,value:h})=>{u.includes(p)||i.setAttribute(p,h)})):(Object.assign(l,e),Object.keys(l).forEach(p=>{!u.includes(p)&&p!=="type"&&i.setAttribute(p.replace(/[A-Z]/g,h=>`-${h.toLowerCase()}`),l[p])})),rt(b)?(i.setAttribute("d",b),t&&a&&(e.before(i,e),e.remove()),i):!1},Br=$r;import jr from"@thednp/dommatrix";var Or=e=>{let t=new jr,{origin:n}=e,[o,r]=n,{translate:a}=e,{rotate:s}=e,{skew:i}=e,{scale:m}=e;return Array.isArray(a)&&a.length>=2&&a.every(u=>!Number.isNaN(+u))&&a.some(u=>u!==0)?t=t.translate(...a):typeof a=="number"&&!Number.isNaN(a)&&(t=t.translate(a)),(s||i||m)&&(t=t.translate(o,r),Array.isArray(s)&&s.length>=2&&s.every(u=>!Number.isNaN(+u))&&s.some(u=>u!==0)?t=t.rotate(...s):typeof s=="number"&&!Number.isNaN(s)&&(t=t.rotate(s)),Array.isArray(i)&&i.length===2&&i.every(u=>!Number.isNaN(+u))&&i.some(u=>u!==0)?(t=i[0]?t.skewX(i[0]):t,t=i[1]?t.skewY(i[1]):t):typeof i=="number"&&!Number.isNaN(i)&&(t=t.skewX(i)),Array.isArray(m)&&m.length>=2&&m.every(u=>!Number.isNaN(+u))&&m.some(u=>u!==1)?t=t.scale(...m):typeof m=="number"&&!Number.isNaN(m)&&(t=t.scale(m)),t=t.translate(-o,-r)),t},ot=Or;var Hr=(e,t,n,o)=>{let[r]=e,{round:a}=H,s=typeof a=="number"?a:4,i=t.slice(1),{x1:m,y1:u,x2:l,y2:c,x:f,y:b}=n,[p,h]=i.slice(-2),y=e;if("TQ".includes(r)||(n.qx=null,n.qy=null),r==="L"){if(L(f,s)===L(p,s))return["V",h];if(L(b,s)===L(h,s))return["H",p]}else if(r==="C"){let[S,A]=i;if(n.x1=S,n.y1=A,"CS".includes(o)&&(L(S,s)===L(m*2-l,s)&&L(A,s)===L(u*2-c,s)||L(m,s)===L(l*2-f,s)&&L(u,s)===L(c*2-b,s)))return["S",i[2],i[3],i[4],i[5]]}else if(r==="Q"){let[S,A]=i;if(n.qx=S,n.qy=A,"QT".includes(o)&&L(S,s)===L(m*2-l,s)&&L(A,s)===L(u*2-c,s))return["T",i[2],i[3]]}return y},at=Hr;var Zr=(e,t)=>{let n=e.slice(1).map(o=>L(o,t));return[e[0]].concat(n)},be=Zr;var Gr=(e,t)=>{let n=xe(e),o=typeof t=="number"&&t>=0?t:2,r={...K},a=[],s="M",i="Z";return T(n,(m,u,l,c)=>{r.x=l,r.y=c;let f=te(m,r),b=m;if([s]=m,a[u]=s,u){i=a[u-1];let h=at(m,f,r,i),y=be(h,o),S=y.join(""),A=Pe(h,u,l,c),d=be(A,o),g=d.join("");b=S.length{let n=Ur.Translate(t[0],t[1],t[2]);return[,,,n.m44]=t,n=e.multiply(n),[n.m41,n.m42,n.m43,n.m44]},Fr=(e,t,n)=>{let[o,r,a]=n,[s,i,m]=Kr(e,[t[0],t[1],0,1]),u=s-o,l=i-r,c=m-a;return[u*(Math.abs(a)/Math.abs(c)||1)+o,l*(Math.abs(a)/Math.abs(c)||1)+r]},ke=Fr;var Jr=e=>{let t=e.slice(1).map((n,o,r)=>o?r[o-1].slice(-2).concat(n.slice(1)):e[0].slice(1).concat(n.slice(1))).map(n=>n.map((o,r)=>n[n.length-r-2*(1-r%2)])).reverse();return[["M"].concat(t[0].slice(0,2))].concat(t.map(n=>["C"].concat(n.slice(2))))},Wr=Jr;var Xr=e=>{let t=xe(e),n=re(t),o=t.length,r=t[o-1][0]==="Z",a=T(t,(s,i)=>{let m=n[i],u=i&&t[i-1],l=u&&u[0],c=t[i+1],f=c&&c[0],[b]=s,[p,h]=n[i?i-1:o-1].slice(-2),y=s;switch(b){case"M":y=r?["Z"]:[b,p,h];break;case"A":y=[b,s[1],s[2],s[3],s[4],s[5]===1?0:1,p,h];break;case"C":c&&f==="S"?y=["S",s[1],s[2],p,h]:y=[b,s[3],s[4],s[1],s[2],p,h];break;case"S":l&&"CS".includes(l)&&(!c||f!=="S")?y=["C",m[3],m[4],m[1],m[2],p,h]:y=[b,m[1],m[2],p,h];break;case"Q":c&&f==="T"?y=["T",p,h]:y=[b,s[1],s[2],p,h];break;case"T":l&&"QT".includes(l)&&(!c||f!=="T")?y=["Q",m[1],m[2],p,h]:y=[b,p,h];break;case"Z":y=["M",p,h];break;case"H":y=[b,p];break;case"V":y=[b,h];break;default:y=[b].concat(s.slice(1,-2),p,h)}return y});return r?a.reverse():[a[0]].concat(a.slice(1).reverse())},Yr=Xr;var en=(e,t)=>{let{round:n}=H;n=t==="off"||typeof t=="number"&&t>=0?t:typeof n=="number"&&n>=0?n:"off";return n==="off"?e.slice(0):T(e,o=>be(o,n))},tn=en;var rn=(e,t=.5)=>{let n=t,o=e.slice(0,2),r=e.slice(2,4),a=e.slice(4,6),s=e.slice(6,8),i=I(o,r,n),m=I(r,a,n),u=I(a,s,n),l=I(i,m,n),c=I(m,u,n),f=I(l,c,n);return[["C",i[0],i[1],l[0],l[1],f[0],f[1]],["C",c[0],c[1],u[0],u[1],s[0],s[1]]]},nn=rn;var on=e=>{let t=[],n,o=-1,r=0,a=0,s=0,i=0,m={...K};return e.forEach(u=>{let[l]=u,c=l.toUpperCase(),f=l.toLowerCase(),b=l===f,p=u.slice(1);c==="M"?(o+=1,[r,a]=p,r+=b?m.x:0,a+=b?m.y:0,s=r,i=a,n=[b?[c,s,i]:u]):(c==="Z"?(r=s,a=i):c==="H"?([,r]=u,r+=b?m.x:0):c==="V"?([,a]=u,a+=b?m.y:0):([r,a]=u.slice(-2),r+=b?m.x:0,a+=b?m.y:0),n.push(u)),m.x=r,m.y=a,t[o]=n}),t},an=on;var sn=(e,t)=>{let n=0,o=0,r=0,a=0,s=0,i=0,m="M",u=v(e),l=t&&Object.keys(t);if(!t||l&&!l.length)return u.slice(0);t.origin||Object.assign(t,{origin:H.origin});let c=t.origin,f=ot(t);return f.isIdentity?u.slice(0):T(u,(b,p,h,y)=>{[m]=b;let S=m.toUpperCase(),d=S!==m?U(b,p,h,y):b.slice(0),g=S==="A"?["C"].concat(Se(h,y,d[1],d[2],d[3],d[4],d[5],d[6],d[7])):S==="V"?["L",h,d[1]]:S==="H"?["L",d[1],y]:d;m=g[0];let x=m==="C"&&g.length>7,C=x?g.slice(0,7):g.slice(0);if(x&&(u.splice(p+1,0,["C"].concat(g.slice(7))),g=C),m==="L"){[r,a]=ke(f,[g[1],g[2]],c);n!==r&&o!==a?g=["L",r,a]:o===a?g=["H",r]:n===r&&(g=["V",a])}else for(s=1,i=g.length;s t in s ? Z(s, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : s[t] = e;\nvar p = (s, t, e) => z(s, typeof t != \"symbol\" ? t + \"\" : t, e);\nconst $ = {\n a: 1,\n b: 0,\n c: 0,\n d: 1,\n e: 0,\n f: 0,\n m11: 1,\n m12: 0,\n m13: 0,\n m14: 0,\n m21: 0,\n m22: 1,\n m23: 0,\n m24: 0,\n m31: 0,\n m32: 0,\n m33: 1,\n m34: 0,\n m41: 0,\n m42: 0,\n m43: 0,\n m44: 1,\n is2D: !0,\n isIdentity: !0\n}, E = (s) => (s instanceof Float64Array || s instanceof Float32Array || Array.isArray(s) && s.every((t) => typeof t == \"number\")) && [6, 16].some((t) => s.length === t), P = (s) => s instanceof DOMMatrix || s instanceof y || typeof s == \"object\" && Object.keys($).every((t) => s && t in s), g = (s) => {\n const t = new y(), e = Array.from(s);\n if (!E(e))\n throw TypeError(\n `CSSMatrix: \"${e.join(\",\")}\" must be an array with 6/16 numbers.`\n );\n // istanbul ignore else @preserve\n if (e.length === 16) {\n const [\n n,\n i,\n r,\n a,\n l,\n m,\n h,\n c,\n u,\n f,\n w,\n o,\n d,\n A,\n M,\n b\n ] = e;\n t.m11 = n, t.a = n, t.m21 = l, t.c = l, t.m31 = u, t.m41 = d, t.e = d, t.m12 = i, t.b = i, t.m22 = m, t.d = m, t.m32 = f, t.m42 = A, t.f = A, t.m13 = r, t.m23 = h, t.m33 = w, t.m43 = M, t.m14 = a, t.m24 = c, t.m34 = o, t.m44 = b;\n } else if (e.length === 6) {\n const [n, i, r, a, l, m] = e;\n t.m11 = n, t.a = n, t.m12 = i, t.b = i, t.m21 = r, t.c = r, t.m22 = a, t.d = a, t.m41 = l, t.e = l, t.m42 = m, t.f = m;\n }\n return t;\n}, X = (s) => {\n if (P(s))\n return g([\n s.m11,\n s.m12,\n s.m13,\n s.m14,\n s.m21,\n s.m22,\n s.m23,\n s.m24,\n s.m31,\n s.m32,\n s.m33,\n s.m34,\n s.m41,\n s.m42,\n s.m43,\n s.m44\n ]);\n throw TypeError(\n `CSSMatrix: \"${JSON.stringify(s)}\" is not a DOMMatrix / CSSMatrix / JSON compatible object.`\n );\n}, O = (s) => {\n if (typeof s != \"string\")\n throw TypeError(`CSSMatrix: \"${JSON.stringify(s)}\" is not a string.`);\n const t = String(s).replace(/\\s/g, \"\");\n let e = new y();\n const n = `CSSMatrix: invalid transform string \"${s}\"`;\n return t.split(\")\").filter((i) => i).forEach((i) => {\n const [r, a] = i.split(\"(\");\n if (!a) throw TypeError(n);\n const l = a.split(\",\").map(\n (o) => o.includes(\"rad\") ? parseFloat(o) * (180 / Math.PI) : parseFloat(o)\n ), [m, h, c, u] = l, f = [m, h, c], w = [m, h, c, u];\n if (r === \"perspective\" && m && [h, c].every((o) => o === void 0))\n e.m34 = -1 / m;\n else if (r.includes(\"matrix\") && [6, 16].includes(l.length) && l.every((o) => !Number.isNaN(+o))) {\n const o = l.map((d) => Math.abs(d) < 1e-6 ? 0 : d);\n e = e.multiply(g(o));\n } else if (r === \"translate3d\" && f.every((o) => !Number.isNaN(+o)))\n e = e.translate(m, h, c);\n else if (r === \"translate\" && m && c === void 0)\n e = e.translate(m, h || 0, 0);\n else if (r === \"rotate3d\" && w.every((o) => !Number.isNaN(+o)) && u)\n e = e.rotateAxisAngle(m, h, c, u);\n else if (r === \"rotate\" && m && [h, c].every((o) => o === void 0))\n e = e.rotate(0, 0, m);\n else if (r === \"scale3d\" && f.every((o) => !Number.isNaN(+o)) && f.some((o) => o !== 1))\n e = e.scale(m, h, c);\n else if (\n // prop === \"scale\" && !Number.isNaN(x) && x !== 1 && z === undefined\n // prop === \"scale\" && !Number.isNaN(x) && [x, y].some((n) => n !== 1) &&\n r === \"scale\" && !Number.isNaN(m) && (m !== 1 || h !== 1) && c === void 0\n ) {\n const d = Number.isNaN(+h) ? m : h;\n e = e.scale(m, d, 1);\n } else if (r === \"skew\" && (m || !Number.isNaN(m) && h) && c === void 0)\n e = e.skew(m, h || 0);\n else if ([\"translate\", \"rotate\", \"scale\", \"skew\"].some(\n (o) => r.includes(o)\n ) && /[XYZ]/.test(r) && m && [h, c].every((o) => o === void 0))\n if (r === \"skewX\" || r === \"skewY\")\n e = e[r](m);\n else {\n const o = r.replace(/[XYZ]/, \"\"), d = r.replace(o, \"\"), A = [\"X\", \"Y\", \"Z\"].indexOf(d), M = o === \"scale\" ? 1 : 0, b = [\n A === 0 ? m : M,\n A === 1 ? m : M,\n A === 2 ? m : M\n ];\n e = e[o](...b);\n }\n else\n throw TypeError(n);\n }), e;\n}, x = (s, t) => t ? [s.a, s.b, s.c, s.d, s.e, s.f] : [\n s.m11,\n s.m12,\n s.m13,\n s.m14,\n s.m21,\n s.m22,\n s.m23,\n s.m24,\n s.m31,\n s.m32,\n s.m33,\n s.m34,\n s.m41,\n s.m42,\n s.m43,\n s.m44\n], Y = (s, t, e) => {\n const n = new y();\n return n.m41 = s, n.e = s, n.m42 = t, n.f = t, n.m43 = e, n;\n}, F = (s, t, e) => {\n const n = new y(), i = Math.PI / 180, r = s * i, a = t * i, l = e * i, m = Math.cos(r), h = -Math.sin(r), c = Math.cos(a), u = -Math.sin(a), f = Math.cos(l), w = -Math.sin(l), o = c * f, d = -c * w;\n n.m11 = o, n.a = o, n.m12 = d, n.b = d, n.m13 = u;\n const A = h * u * f + m * w;\n n.m21 = A, n.c = A;\n const M = m * f - h * u * w;\n return n.m22 = M, n.d = M, n.m23 = -h * c, n.m31 = h * w - m * u * f, n.m32 = h * f + m * u * w, n.m33 = m * c, n;\n}, T = (s, t, e, n) => {\n const i = new y(), r = Math.sqrt(s * s + t * t + e * e);\n if (r === 0)\n return i;\n const a = s / r, l = t / r, m = e / r, h = n * (Math.PI / 360), c = Math.sin(h), u = Math.cos(h), f = c * c, w = a * a, o = l * l, d = m * m, A = 1 - 2 * (o + d) * f;\n i.m11 = A, i.a = A;\n const M = 2 * (a * l * f + m * c * u);\n i.m12 = M, i.b = M, i.m13 = 2 * (a * m * f - l * c * u);\n const b = 2 * (l * a * f - m * c * u);\n i.m21 = b, i.c = b;\n const k = 1 - 2 * (d + w) * f;\n return i.m22 = k, i.d = k, i.m23 = 2 * (l * m * f + a * c * u), i.m31 = 2 * (m * a * f + l * c * u), i.m32 = 2 * (m * l * f - a * c * u), i.m33 = 1 - 2 * (w + o) * f, i;\n}, I = (s, t, e) => {\n const n = new y();\n return n.m11 = s, n.a = s, n.m22 = t, n.d = t, n.m33 = e, n;\n}, v = (s, t) => {\n const e = new y();\n if (s) {\n const n = s * Math.PI / 180, i = Math.tan(n);\n e.m21 = i, e.c = i;\n }\n if (t) {\n const n = t * Math.PI / 180, i = Math.tan(n);\n e.m12 = i, e.b = i;\n }\n return e;\n}, R = (s) => v(s, 0), D = (s) => v(0, s), N = (s, t) => {\n const e = t.m11 * s.m11 + t.m12 * s.m21 + t.m13 * s.m31 + t.m14 * s.m41, n = t.m11 * s.m12 + t.m12 * s.m22 + t.m13 * s.m32 + t.m14 * s.m42, i = t.m11 * s.m13 + t.m12 * s.m23 + t.m13 * s.m33 + t.m14 * s.m43, r = t.m11 * s.m14 + t.m12 * s.m24 + t.m13 * s.m34 + t.m14 * s.m44, a = t.m21 * s.m11 + t.m22 * s.m21 + t.m23 * s.m31 + t.m24 * s.m41, l = t.m21 * s.m12 + t.m22 * s.m22 + t.m23 * s.m32 + t.m24 * s.m42, m = t.m21 * s.m13 + t.m22 * s.m23 + t.m23 * s.m33 + t.m24 * s.m43, h = t.m21 * s.m14 + t.m22 * s.m24 + t.m23 * s.m34 + t.m24 * s.m44, c = t.m31 * s.m11 + t.m32 * s.m21 + t.m33 * s.m31 + t.m34 * s.m41, u = t.m31 * s.m12 + t.m32 * s.m22 + t.m33 * s.m32 + t.m34 * s.m42, f = t.m31 * s.m13 + t.m32 * s.m23 + t.m33 * s.m33 + t.m34 * s.m43, w = t.m31 * s.m14 + t.m32 * s.m24 + t.m33 * s.m34 + t.m34 * s.m44, o = t.m41 * s.m11 + t.m42 * s.m21 + t.m43 * s.m31 + t.m44 * s.m41, d = t.m41 * s.m12 + t.m42 * s.m22 + t.m43 * s.m32 + t.m44 * s.m42, A = t.m41 * s.m13 + t.m42 * s.m23 + t.m43 * s.m33 + t.m44 * s.m43, M = t.m41 * s.m14 + t.m42 * s.m24 + t.m43 * s.m34 + t.m44 * s.m44;\n return g([\n e,\n n,\n i,\n r,\n a,\n l,\n m,\n h,\n c,\n u,\n f,\n w,\n o,\n d,\n A,\n M\n ]);\n};\nclass y {\n /**\n * @constructor\n * @param init accepts all parameter configurations:\n * * valid CSS transform string,\n * * CSSMatrix/DOMMatrix instance,\n * * a 6/16 elements *Array*.\n */\n constructor(t) {\n return this.a = 1, this.b = 0, this.c = 0, this.d = 1, this.e = 0, this.f = 0, this.m11 = 1, this.m12 = 0, this.m13 = 0, this.m14 = 0, this.m21 = 0, this.m22 = 1, this.m23 = 0, this.m24 = 0, this.m31 = 0, this.m32 = 0, this.m33 = 1, this.m34 = 0, this.m41 = 0, this.m42 = 0, this.m43 = 0, this.m44 = 1, t ? this.setMatrixValue(t) : this;\n }\n /**\n * A `Boolean` whose value is `true` if the matrix is the identity matrix. The identity\n * matrix is one in which every value is 0 except those on the main diagonal from top-left\n * to bottom-right corner (in other words, where the offsets in each direction are equal).\n *\n * @return the current property value\n */\n get isIdentity() {\n return this.m11 === 1 && this.m12 === 0 && this.m13 === 0 && this.m14 === 0 && this.m21 === 0 && this.m22 === 1 && this.m23 === 0 && this.m24 === 0 && this.m31 === 0 && this.m32 === 0 && this.m33 === 1 && this.m34 === 0 && this.m41 === 0 && this.m42 === 0 && this.m43 === 0 && this.m44 === 1;\n }\n /**\n * A `Boolean` flag whose value is `true` if the matrix was initialized as a 2D matrix\n * and `false` if the matrix is 3D.\n *\n * @return the current property value\n */\n get is2D() {\n return this.m31 === 0 && this.m32 === 0 && this.m33 === 1 && this.m34 === 0 && this.m43 === 0 && this.m44 === 1;\n }\n /**\n * The `setMatrixValue` method replaces the existing matrix with one computed\n * in the browser. EG: `matrix(1,0.25,-0.25,1,0,0)`\n *\n * The method accepts any *Array* values, the result of\n * `DOMMatrix` instance method `toFloat64Array()` / `toFloat32Array()` calls\n * or `CSSMatrix` instance method `toArray()`.\n *\n * This method expects valid *matrix()* / *matrix3d()* string values, as well\n * as other transform functions like *translateX(10px)*.\n *\n * @param source\n * @return the matrix instance\n */\n setMatrixValue(t) {\n return typeof t == \"string\" && t.length && t !== \"none\" ? O(t) : Array.isArray(t) || t instanceof Float64Array || t instanceof Float32Array ? g(t) : typeof t == \"object\" ? X(t) : this;\n }\n /**\n * Returns a *Float32Array* containing elements which comprise the matrix.\n * The method can return either the 16 elements or the 6 elements\n * depending on the value of the `is2D` parameter.\n *\n * @param is2D *Array* representation of the matrix\n * @return an *Array* representation of the matrix\n */\n toFloat32Array(t) {\n return Float32Array.from(x(this, t));\n }\n /**\n * Returns a *Float64Array* containing elements which comprise the matrix.\n * The method can return either the 16 elements or the 6 elements\n * depending on the value of the `is2D` parameter.\n *\n * @param is2D *Array* representation of the matrix\n * @return an *Array* representation of the matrix\n */\n toFloat64Array(t) {\n return Float64Array.from(x(this, t));\n }\n /**\n * Creates and returns a string representation of the matrix in `CSS` matrix syntax,\n * using the appropriate `CSS` matrix notation.\n *\n * matrix3d *matrix3d(m11, m12, m13, m14, m21, ...)*\n * matrix *matrix(a, b, c, d, e, f)*\n *\n * @return a string representation of the matrix\n */\n toString() {\n const { is2D: t } = this, e = this.toFloat64Array(t).join(\", \");\n return `${t ? \"matrix\" : \"matrix3d\"}(${e})`;\n }\n /**\n * Returns a JSON representation of the `CSSMatrix` instance, a standard *Object*\n * that includes `{a,b,c,d,e,f}` and `{m11,m12,m13,..m44}` properties as well\n * as the `is2D` & `isIdentity` properties.\n *\n * The result can also be used as a second parameter for the `fromMatrix` static method\n * to load values into another matrix instance.\n *\n * @return an *Object* with all matrix values.\n */\n toJSON() {\n const { is2D: t, isIdentity: e } = this;\n return { ...this, is2D: t, isIdentity: e };\n }\n /**\n * The Multiply method returns a new CSSMatrix which is the result of this\n * matrix multiplied by the passed matrix, with the passed matrix to the right.\n * This matrix is not modified.\n *\n * @param m2 CSSMatrix\n * @return The resulted matrix.\n */\n multiply(t) {\n return N(this, t);\n }\n /**\n * The translate method returns a new matrix which is this matrix post\n * multiplied by a translation matrix containing the passed values. If the z\n * component is undefined, a 0 value is used in its place. This matrix is not\n * modified.\n *\n * @param x X component of the translation value.\n * @param y Y component of the translation value.\n * @param z Z component of the translation value.\n * @return The resulted matrix\n */\n translate(t, e, n) {\n const i = t;\n let r = e, a = n;\n return typeof r > \"u\" && (r = 0), typeof a > \"u\" && (a = 0), N(this, Y(i, r, a));\n }\n /**\n * The scale method returns a new matrix which is this matrix post multiplied by\n * a scale matrix containing the passed values. If the z component is undefined,\n * a 1 value is used in its place. If the y component is undefined, the x\n * component value is used in its place. This matrix is not modified.\n *\n * @param x The X component of the scale value.\n * @param y The Y component of the scale value.\n * @param z The Z component of the scale value.\n * @return The resulted matrix\n */\n scale(t, e, n) {\n const i = t;\n let r = e, a = n;\n return typeof r > \"u\" && (r = t), typeof a > \"u\" && (a = 1), N(this, I(i, r, a));\n }\n /**\n * The rotate method returns a new matrix which is this matrix post multiplied\n * by each of 3 rotation matrices about the major axes, first X, then Y, then Z.\n * If the y and z components are undefined, the x value is used to rotate the\n * object about the z axis, as though the vector (0,0,x) were passed. All\n * rotation values are in degrees. This matrix is not modified.\n *\n * @param rx The X component of the rotation, or Z if Y and Z are null.\n * @param ry The (optional) Y component of the rotation value.\n * @param rz The (optional) Z component of the rotation value.\n * @return The resulted matrix\n */\n rotate(t, e, n) {\n let i = t, r = e || 0, a = n || 0;\n return typeof t == \"number\" && typeof e > \"u\" && typeof n > \"u\" && (a = i, i = 0, r = 0), N(this, F(i, r, a));\n }\n /**\n * The rotateAxisAngle method returns a new matrix which is this matrix post\n * multiplied by a rotation matrix with the given axis and `angle`. The right-hand\n * rule is used to determine the direction of rotation. All rotation values are\n * in degrees. This matrix is not modified.\n *\n * @param x The X component of the axis vector.\n * @param y The Y component of the axis vector.\n * @param z The Z component of the axis vector.\n * @param angle The angle of rotation about the axis vector, in degrees.\n * @return The resulted matrix\n */\n rotateAxisAngle(t, e, n, i) {\n if ([t, e, n, i].some((r) => Number.isNaN(+r)))\n throw new TypeError(\"CSSMatrix: expecting 4 values\");\n return N(this, T(t, e, n, i));\n }\n /**\n * Specifies a skew transformation along the `x-axis` by the given angle.\n * This matrix is not modified.\n *\n * @param angle The angle amount in degrees to skew.\n * @return The resulted matrix\n */\n skewX(t) {\n return N(this, R(t));\n }\n /**\n * Specifies a skew transformation along the `y-axis` by the given angle.\n * This matrix is not modified.\n *\n * @param angle The angle amount in degrees to skew.\n * @return The resulted matrix\n */\n skewY(t) {\n return N(this, D(t));\n }\n /**\n * Specifies a skew transformation along both the `x-axis` and `y-axis`.\n * This matrix is not modified.\n *\n * @param angleX The X-angle amount in degrees to skew.\n * @param angleY The angle amount in degrees to skew.\n * @return The resulted matrix\n */\n skew(t, e) {\n return N(this, v(t, e));\n }\n /**\n * Transforms a specified vector using the matrix, returning a new\n * {x,y,z,w} Tuple *Object* comprising the transformed vector.\n * Neither the matrix nor the original vector are altered.\n *\n * The method is equivalent with `transformPoint()` method\n * of the `DOMMatrix` constructor.\n *\n * @param t Tuple with `{x,y,z,w}` components\n * @return the resulting Tuple\n */\n transformPoint(t) {\n const e = this.m11 * t.x + this.m21 * t.y + this.m31 * t.z + this.m41 * t.w, n = this.m12 * t.x + this.m22 * t.y + this.m32 * t.z + this.m42 * t.w, i = this.m13 * t.x + this.m23 * t.y + this.m33 * t.z + this.m43 * t.w, r = this.m14 * t.x + this.m24 * t.y + this.m34 * t.z + this.m44 * t.w;\n return t instanceof DOMPoint ? new DOMPoint(e, n, i, r) : {\n x: e,\n y: n,\n z: i,\n w: r\n };\n }\n}\np(y, \"Translate\", Y), p(y, \"Rotate\", F), p(y, \"RotateAxisAngle\", T), p(y, \"Scale\", I), p(y, \"SkewX\", R), p(y, \"SkewY\", D), p(y, \"Skew\", v), p(y, \"Multiply\", N), p(y, \"fromArray\", g), p(y, \"fromMatrix\", X), p(y, \"fromString\", O), p(y, \"toArray\", x), p(y, \"isCompatibleArray\", E), p(y, \"isCompatibleObject\", P);\nexport {\n y as default\n};\n//# sourceMappingURL=dommatrix.mjs.map\n","import { PointTuple } from \"../types\";\n\n/**\n * Returns the coordinates of a specified distance\n * ratio between two points.\n *\n * @param a the first point coordinates\n * @param b the second point coordinates\n * @param t the ratio\n * @returns the midpoint coordinates\n */\nconst midPoint = (a: PointTuple, b: PointTuple, t: number): PointTuple => {\n const [ax, ay] = a;\n const [bx, by] = b;\n return [ax + (bx - ax) * t, ay + (by - ay) * t];\n};\n\nexport default midPoint;\n","import { type PointTuple } from \"../types\";\n\n/**\n * Returns the square root of the distance\n * between two given points.\n *\n * @param a the first point coordinates\n * @param b the second point coordinates\n * @returns the distance value\n */\nconst distanceSquareRoot = (a: PointTuple, b: PointTuple) => {\n return Math.sqrt(\n (a[0] - b[0]) * (a[0] - b[0]) + (a[1] - b[1]) * (a[1] - b[1]),\n );\n};\n\nexport default distanceSquareRoot;\n","import midPoint from \"./midPoint\";\nimport distanceSquareRoot from \"./distanceSquareRoot\";\n\n/**\n * Returns length for line segments (MoveTo, LineTo).\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the line segment length\n */\nconst getLineLength = (x1: number, y1: number, x2: number, y2: number) => {\n return distanceSquareRoot([x1, y1], [x2, y2]);\n};\n\n/**\n * Returns a point along the line segments (MoveTo, LineTo).\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance the distance to point in [0-1] range\n * @returns the point at length\n */\nconst getPointAtLineLength = (\n x1: number,\n y1: number,\n x2: number,\n y2: number,\n distance?: number,\n) => {\n let point = { x: x1, y: y1 };\n\n /* istanbul ignore else @preserve */\n if (typeof distance === \"number\") {\n const length = distanceSquareRoot([x1, y1], [x2, y2]);\n if (distance <= 0) {\n point = { x: x1, y: y1 };\n } else if (distance >= length) {\n point = { x: x2, y: y2 };\n } else {\n const [x, y] = midPoint([x1, y1], [x2, y2], distance / length);\n point = { x, y };\n }\n }\n return point;\n};\n\n/**\n * Returns bounding box for line segments (MoveTo, LineTo).\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance the distance to point in [0-1] range\n * @returns the extrema for line segments\n */\nconst getLineBBox = (x1: number, y1: number, x2: number, y2: number) => {\n const { min, max } = Math;\n\n return [min(x1, x2), min(y1, y2), max(x1, x2), max(y1, y2)] as [\n number,\n number,\n number,\n number,\n ];\n};\n\nexport { getLineBBox, getLineLength, getPointAtLineLength };\n","import { getPointAtLineLength } from \"./lineTools\";\nimport type { Point, PointTuple } from \"../types\";\n\n/**\n * Returns the Arc segment length.\n * @param rx radius along X axis\n * @param ry radius along Y axis\n * @param theta the angle in radians\n * @returns the arc length\n */\nconst arcLength = (rx: number, ry: number, theta: number) => {\n const halfTheta = theta / 2;\n const sinHalfTheta = Math.sin(halfTheta);\n const cosHalfTheta = Math.cos(halfTheta);\n const term1 = rx ** 2 * sinHalfTheta ** 2;\n const term2 = ry ** 2 * cosHalfTheta ** 2;\n const length = Math.sqrt(term1 + term2) * theta;\n return Math.abs(length);\n};\n\n/**\n * Find point on ellipse at given angle around ellipse (theta);\n * @param cx the center X\n * @param cy the center Y\n * @param rx the radius X\n * @param ry the radius Y\n * @param alpha the arc rotation angle in radians\n * @param theta the arc sweep angle in radians\n * @returns a point around ellipse at given angle\n */\nconst arcPoint = (\n cx: number,\n cy: number,\n rx: number,\n ry: number,\n alpha: number,\n theta: number,\n) => {\n const { sin, cos } = Math;\n // theta is angle in radians around arc\n // alpha is angle of rotation of ellipse in radians\n const cosA = cos(alpha);\n const sinA = sin(alpha);\n const x = rx * cos(theta);\n const y = ry * sin(theta);\n\n return [cx + cosA * x - sinA * y, cy + sinA * x + cosA * y] as PointTuple;\n};\n\n/**\n * Returns the angle between two points.\n * @param v0 starting point\n * @param v1 ending point\n * @returns the angle in radian\n */\nconst angleBetween = (v0: Point, v1: Point) => {\n const { x: v0x, y: v0y } = v0;\n const { x: v1x, y: v1y } = v1;\n const p = v0x * v1x + v0y * v1y;\n const n = Math.sqrt((v0x ** 2 + v0y ** 2) * (v1x ** 2 + v1y ** 2));\n const sign = v0x * v1y - v0y * v1x < 0 ? -1 : 1;\n return sign * Math.acos(p / n);\n};\n\n/**\n * Returns the following properties for an Arc segment: center, start angle,\n * end angle, and radiuses on X and Y axis.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param RX the radius on X axis\n * @param RY the radius on Y axis\n * @param angle the ellipse rotation in degrees\n * @param LAF the large arc flag\n * @param SF the sweep flag\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns properties specific to Arc segments\n */\nconst getArcProps = (\n x1: number,\n y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n x: number,\n y: number,\n) => {\n const { abs, sin, cos, sqrt, PI } = Math;\n let rx = abs(RX);\n let ry = abs(RY);\n const xRot = ((angle % 360) + 360) % 360;\n const xRotRad = xRot * (PI / 180);\n\n // istanbul ignore next @preserve\n if (x1 === x && y1 === y) {\n return {\n rx,\n ry,\n startAngle: 0,\n endAngle: 0,\n center: { x, y },\n };\n }\n\n if (rx === 0 || ry === 0) {\n return {\n rx,\n ry,\n startAngle: 0,\n endAngle: 0,\n center: { x: (x + x1) / 2, y: (y + y1) / 2 },\n };\n }\n\n const dx = (x1 - x) / 2;\n const dy = (y1 - y) / 2;\n\n const transformedPoint = {\n x: cos(xRotRad) * dx + sin(xRotRad) * dy,\n y: -sin(xRotRad) * dx + cos(xRotRad) * dy,\n };\n\n const radiiCheck = transformedPoint.x ** 2 / rx ** 2 +\n transformedPoint.y ** 2 / ry ** 2;\n\n if (radiiCheck > 1) {\n rx *= sqrt(radiiCheck);\n ry *= sqrt(radiiCheck);\n }\n\n const cSquareNumerator = rx ** 2 * ry ** 2 -\n rx ** 2 * transformedPoint.y ** 2 - ry ** 2 * transformedPoint.x ** 2;\n const cSquareRootDenom = rx ** 2 * transformedPoint.y ** 2 +\n ry ** 2 * transformedPoint.x ** 2;\n\n let cRadicand = cSquareNumerator / cSquareRootDenom;\n /* istanbul ignore next @preserve */\n cRadicand = cRadicand < 0 ? 0 : cRadicand;\n const cCoef = (LAF !== SF ? 1 : -1) * sqrt(cRadicand);\n const transformedCenter = {\n x: cCoef * ((rx * transformedPoint.y) / ry),\n y: cCoef * (-(ry * transformedPoint.x) / rx),\n };\n\n const center = {\n x: cos(xRotRad) * transformedCenter.x - sin(xRotRad) * transformedCenter.y +\n (x1 + x) / 2,\n y: sin(xRotRad) * transformedCenter.x + cos(xRotRad) * transformedCenter.y +\n (y1 + y) / 2,\n };\n\n const startVector = {\n x: (transformedPoint.x - transformedCenter.x) / rx,\n y: (transformedPoint.y - transformedCenter.y) / ry,\n };\n\n const startAngle = angleBetween({ x: 1, y: 0 }, startVector);\n\n const endVector = {\n x: (-transformedPoint.x - transformedCenter.x) / rx,\n y: (-transformedPoint.y - transformedCenter.y) / ry,\n };\n\n let sweepAngle = angleBetween(startVector, endVector);\n if (!SF && sweepAngle > 0) {\n sweepAngle -= 2 * PI;\n } else if (SF && sweepAngle < 0) {\n sweepAngle += 2 * PI;\n }\n sweepAngle %= 2 * PI;\n\n const endAngle = startAngle + sweepAngle;\n\n // point.ellipticalArcStartAngle = startAngle;\n // point.ellipticalArcEndAngle = startAngle + sweepAngle;\n // point.ellipticalArcAngle = alpha;\n\n // point.ellipticalArcCenter = center;\n // point.resultantRx = rx;\n // point.resultantRy = ry;\n\n return {\n center,\n startAngle,\n endAngle,\n rx,\n ry,\n };\n};\n\n/**\n * Returns the length of an Arc segment.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the length of the Arc segment\n */\nconst getArcLength = (\n x1: number,\n y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n x: number,\n y: number,\n) => {\n const { rx, ry, startAngle, endAngle } = getArcProps(\n x1,\n y1,\n RX,\n RY,\n angle,\n LAF,\n SF,\n x,\n y,\n );\n return arcLength(rx, ry, endAngle - startAngle);\n};\n\n/**\n * Returns a point along an Arc segment at a given distance.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param RX the radius on X axis\n * @param RY the radius on Y axis\n * @param angle the ellipse rotation in degrees\n * @param LAF the large arc flag\n * @param SF the sweep flag\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance a [0-1] ratio\n * @returns a point along the Arc segment\n */\nconst getPointAtArcLength = (\n x1: number,\n y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n x: number,\n y: number,\n distance?: number,\n) => {\n let point = { x: x1, y: y1 };\n const { center, rx, ry, startAngle, endAngle } = getArcProps(\n x1,\n y1,\n RX,\n RY,\n angle,\n LAF,\n SF,\n x,\n y,\n );\n\n /* istanbul ignore else @preserve */\n if (typeof distance === \"number\") {\n const length = arcLength(rx, ry, endAngle - startAngle);\n if (distance <= 0) {\n point = { x: x1, y: y1 };\n } else if (distance >= length) {\n point = { x, y };\n } else {\n /* istanbul ignore next @preserve */\n if (x1 === x && y1 === y) {\n return { x, y };\n }\n /* istanbul ignore next @preserve */\n if (rx === 0 || ry === 0) {\n return getPointAtLineLength(x1, y1, x, y, distance);\n }\n const { PI, cos, sin } = Math;\n const sweepAngle = endAngle - startAngle;\n const xRot = ((angle % 360) + 360) % 360;\n const xRotRad = xRot * (PI / 180);\n const alpha = startAngle + sweepAngle * (distance / length);\n const ellipseComponentX = rx * cos(alpha);\n const ellipseComponentY = ry * sin(alpha);\n\n point = {\n x: cos(xRotRad) * ellipseComponentX - sin(xRotRad) * ellipseComponentY +\n center.x,\n y: sin(xRotRad) * ellipseComponentX + cos(xRotRad) * ellipseComponentY +\n center.y,\n };\n }\n }\n\n return point;\n};\n\n/**\n * Returns the extrema for an Arc segment in the following format:\n * [MIN_X, MIN_Y, MAX_X, MAX_Y]\n *\n * @see https://github.com/herrstrietzel/svg-pathdata-getbbox\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param RX the radius on X axis\n * @param RY the radius on Y axis\n * @param angle the ellipse rotation in degrees\n * @param LAF the large arc flag\n * @param SF the sweep flag\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the extrema of the Arc segment\n */\nconst getArcBBox = (\n x1: number,\n y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n x: number,\n y: number,\n) => {\n const { center, rx, ry, startAngle, endAngle } = getArcProps(\n x1,\n y1,\n RX,\n RY,\n angle,\n LAF,\n SF,\n x,\n y,\n );\n const deltaAngle = endAngle - startAngle;\n const { min, max, tan, atan2, PI } = Math;\n\n // circle/elipse center coordinates\n const { x: cx, y: cy } = center;\n\n // rotation to radians\n const alpha = (angle * PI) / 180;\n const tangent = tan(alpha);\n\n /**\n * find min/max from zeroes of directional derivative along x and y\n * along x axis\n */\n const theta = atan2(-ry * tangent, rx);\n const angle1 = theta;\n const angle2 = theta + PI;\n const angle3 = atan2(ry, rx * tangent);\n const angle4 = angle3 + PI;\n const xArray = [x];\n const yArray = [y];\n\n // inner bounding box\n let xMin = min(x1, x);\n let xMax = max(x1, x);\n let yMin = min(y1, y);\n let yMax = max(y1, y);\n\n // on path point close after start\n const angleAfterStart = endAngle - deltaAngle * 0.00001;\n const pP2 = arcPoint(cx, cy, rx, ry, alpha, angleAfterStart);\n\n // on path point close before end\n const angleBeforeEnd = endAngle - deltaAngle * 0.99999;\n const pP3 = arcPoint(cx, cy, rx, ry, alpha, angleBeforeEnd);\n\n /**\n * expected extremes\n * if leaving inner bounding box\n * (between segment start and end point)\n * otherwise exclude elliptic extreme points\n */\n\n // right\n if (pP2[0] > xMax || pP3[0] > xMax) {\n // get point for this theta\n const p1 = arcPoint(cx, cy, rx, ry, alpha, angle1);\n xArray.push(p1[0]);\n yArray.push(p1[1]);\n }\n\n // left\n if (pP2[0] < xMin || pP3[0] < xMin) {\n // get anti-symmetric point\n const p2 = arcPoint(cx, cy, rx, ry, alpha, angle2);\n xArray.push(p2[0]);\n yArray.push(p2[1]);\n }\n\n // top\n if (pP2[1] < yMin || pP3[1] < yMin) {\n // get anti-symmetric point\n const p4 = arcPoint(cx, cy, rx, ry, alpha, angle4);\n xArray.push(p4[0]);\n yArray.push(p4[1]);\n }\n\n // bottom\n if (pP2[1] > yMax || pP3[1] > yMax) {\n // get point for this theta\n const p3 = arcPoint(cx, cy, rx, ry, alpha, angle3);\n xArray.push(p3[0]);\n yArray.push(p3[1]);\n }\n\n xMin = min.apply([], xArray);\n yMin = min.apply([], yArray);\n xMax = max.apply([], xArray);\n yMax = max.apply([], yArray);\n\n return [xMin, yMin, xMax, yMax] as [number, number, number, number];\n};\n\nexport {\n angleBetween,\n arcLength,\n arcPoint,\n getArcBBox,\n getArcLength,\n getArcProps,\n getPointAtArcLength,\n};\n","import type {\n CubicCoordinates,\n CubicPoints,\n DeriveCallback,\n DerivedCubicPoints,\n DerivedPoint,\n DerivedQuadPoints,\n PointTuple,\n QuadCoordinates,\n QuadPoints,\n} from \"../types\";\n\n/**\n * Tools from bezier.js by Mike 'Pomax' Kamermans\n * @see https://github.com/Pomax/bezierjs\n */\n\nconst Tvalues = [\n -0.0640568928626056260850430826247450385909,\n 0.0640568928626056260850430826247450385909,\n -0.1911188674736163091586398207570696318404,\n 0.1911188674736163091586398207570696318404,\n -0.3150426796961633743867932913198102407864,\n 0.3150426796961633743867932913198102407864,\n -0.4337935076260451384870842319133497124524,\n 0.4337935076260451384870842319133497124524,\n -0.5454214713888395356583756172183723700107,\n 0.5454214713888395356583756172183723700107,\n -0.6480936519369755692524957869107476266696,\n 0.6480936519369755692524957869107476266696,\n -0.7401241915785543642438281030999784255232,\n 0.7401241915785543642438281030999784255232,\n -0.8200019859739029219539498726697452080761,\n 0.8200019859739029219539498726697452080761,\n -0.8864155270044010342131543419821967550873,\n 0.8864155270044010342131543419821967550873,\n -0.9382745520027327585236490017087214496548,\n 0.9382745520027327585236490017087214496548,\n -0.9747285559713094981983919930081690617411,\n 0.9747285559713094981983919930081690617411,\n -0.9951872199970213601799974097007368118745,\n 0.9951872199970213601799974097007368118745,\n];\n\nconst Cvalues = [\n 0.1279381953467521569740561652246953718517,\n 0.1279381953467521569740561652246953718517,\n 0.1258374563468282961213753825111836887264,\n 0.1258374563468282961213753825111836887264,\n 0.121670472927803391204463153476262425607,\n 0.121670472927803391204463153476262425607,\n 0.1155056680537256013533444839067835598622,\n 0.1155056680537256013533444839067835598622,\n 0.1074442701159656347825773424466062227946,\n 0.1074442701159656347825773424466062227946,\n 0.0976186521041138882698806644642471544279,\n 0.0976186521041138882698806644642471544279,\n 0.086190161531953275917185202983742667185,\n 0.086190161531953275917185202983742667185,\n 0.0733464814110803057340336152531165181193,\n 0.0733464814110803057340336152531165181193,\n 0.0592985849154367807463677585001085845412,\n 0.0592985849154367807463677585001085845412,\n 0.0442774388174198061686027482113382288593,\n 0.0442774388174198061686027482113382288593,\n 0.0285313886289336631813078159518782864491,\n 0.0285313886289336631813078159518782864491,\n 0.0123412297999871995468056670700372915759,\n 0.0123412297999871995468056670700372915759,\n];\n\n/**\n * @param points\n * @returns\n */\nconst deriveBezier = (points: QuadPoints | CubicPoints) => {\n const dpoints = [] as (DerivedCubicPoints | DerivedQuadPoints)[];\n for (let p = points, d = p.length, c = d - 1; d > 1; d -= 1, c -= 1) {\n const list = [] as unknown as DerivedCubicPoints | DerivedQuadPoints;\n for (let j = 0; j < c; j += 1) {\n list.push({\n x: c * (p[j + 1].x - p[j].x),\n y: c * (p[j + 1].y - p[j].y),\n t: 0,\n });\n }\n dpoints.push(list);\n p = list;\n }\n return dpoints;\n};\n\n/**\n * @param points\n * @param t\n */\nconst computeBezier = (\n points: DerivedQuadPoints | DerivedCubicPoints,\n t: number,\n) => {\n // shortcuts\n /* istanbul ignore next @preserve */\n if (t === 0) {\n points[0].t = 0;\n return points[0];\n }\n\n const order = points.length - 1;\n\n /* istanbul ignore next @preserve */\n if (t === 1) {\n points[order].t = 1;\n return points[order];\n }\n\n const mt = 1 - t;\n let p = points as typeof points | [\n DerivedPoint,\n DerivedPoint,\n DerivedPoint,\n DerivedPoint,\n ];\n\n // constant?\n /* istanbul ignore next @preserve */\n if (order === 0) {\n points[0].t = t;\n return points[0];\n }\n\n // linear?\n /* istanbul ignore else @preserve */\n if (order === 1) {\n return {\n x: mt * p[0].x + t * p[1].x,\n y: mt * p[0].y + t * p[1].y,\n t,\n };\n }\n\n // quadratic/cubic curve?\n const mt2 = mt * mt;\n const t2 = t * t;\n let a = 0;\n let b = 0;\n let c = 0;\n let d = 0;\n /* istanbul ignore else @preserve */\n if (order === 2) {\n p = [p[0], p[1], p[2], { x: 0, y: 0 } as DerivedPoint];\n a = mt2;\n b = mt * t * 2;\n c = t2;\n } else if (order === 3) {\n a = mt2 * mt;\n b = mt2 * t * 3;\n c = mt * t2 * 3;\n d = t * t2;\n }\n return {\n x: a * p[0].x + b * p[1].x + c * p[2].x + d * p[3].x,\n y: a * p[0].y + b * p[1].y + c * p[2].y + d * p[3].y,\n t,\n };\n};\n\nconst calculateBezier = (derivativeFn: DeriveCallback, t: number) => {\n const d = derivativeFn(t);\n const l = d.x * d.x + d.y * d.y;\n\n return Math.sqrt(l);\n};\n\nconst bezierLength = (derivativeFn: DeriveCallback) => {\n const z = 0.5;\n const len = Tvalues.length;\n\n let sum = 0;\n\n for (let i = 0, t; i < len; i++) {\n t = z * Tvalues[i] + z;\n sum += Cvalues[i] * calculateBezier(derivativeFn, t);\n }\n return z * sum;\n};\n\n/**\n * Returns the length of CubicBezier / Quad segment.\n * @param curve cubic / quad bezier segment\n */\nconst getBezierLength = (curve: CubicCoordinates | QuadCoordinates) => {\n const points = [] as unknown as CubicPoints | QuadPoints;\n for (let idx = 0, len = curve.length, step = 2; idx < len; idx += step) {\n points.push({\n x: curve[idx],\n y: curve[idx + 1],\n });\n }\n const dpoints = deriveBezier(points);\n return bezierLength((t: number) => {\n return computeBezier(dpoints[0], t);\n });\n};\n\n// Precision for consider cubic polynom as quadratic one\nconst CBEZIER_MINMAX_EPSILON = 0.00000001;\n\n/**\n * Returns the most extreme points in a Quad Bezier segment.\n * @param A an array which consist of X/Y values\n */\n// https://github.com/kpym/SVGPathy/blob/acd1a50c626b36d81969f6e98e8602e128ba4302/lib/box.js#L89\nconst minmaxQ = ([v1, cp, v2]: [number, number, number]) => {\n const min = Math.min(v1, v2);\n const max = Math.max(v1, v2);\n\n /* istanbul ignore next @preserve */\n if (cp >= v1 ? v2 >= cp : v2 <= cp) {\n // if no extremum in ]0,1[\n return [min, max] as PointTuple;\n }\n\n // check if the extremum E is min or max\n const E = (v1 * v2 - cp * cp) / (v1 - 2 * cp + v2);\n return (E < min ? [E, max] : [min, E]) as PointTuple;\n};\n\n/**\n * Returns the most extreme points in a Cubic Bezier segment.\n * @param A an array which consist of X/Y values\n * @see https://github.com/kpym/SVGPathy/blob/acd1a50c626b36d81969f6e98e8602e128ba4302/lib/box.js#L127\n */\nconst minmaxC = ([v1, cp1, cp2, v2]: [number, number, number, number]) => {\n const K = v1 - 3 * cp1 + 3 * cp2 - v2;\n\n // if the polynomial is (almost) quadratic and not cubic\n /* istanbul ignore next @preserve */\n if (Math.abs(K) < CBEZIER_MINMAX_EPSILON) {\n if (v1 === v2 && v1 === cp1) {\n // no curve, point targeting same location\n return [v1, v2] as PointTuple;\n }\n\n return minmaxQ([v1, -0.5 * v1 + 1.5 * cp1, v1 - 3 * cp1 + 3 * cp2]);\n }\n\n // the reduced discriminant of the derivative\n const T = -v1 * cp2 + v1 * v2 - cp1 * cp2 - cp1 * v2 + cp1 * cp1 + cp2 * cp2;\n\n // if the polynomial is monotone in [0,1]\n if (T <= 0) {\n return [Math.min(v1, v2), Math.max(v1, v2)] as PointTuple;\n }\n const S = Math.sqrt(T);\n\n // potential extrema\n let min = Math.min(v1, v2);\n let max = Math.max(v1, v2);\n\n const L = v1 - 2 * cp1 + cp2;\n // check local extrema\n for (let R = (L + S) / K, i = 1; i <= 2; R = (L - S) / K, i++) {\n // istanbul ignore next @preserve\n if (R > 0 && R < 1) {\n // if the extrema is for R in [0,1]\n const Q = v1 * (1 - R) * (1 - R) * (1 - R) +\n cp1 * 3 * (1 - R) * (1 - R) * R + cp2 * 3 * (1 - R) * R * R +\n v2 * R * R * R;\n if (Q < min) {\n min = Q;\n }\n if (Q > max) {\n max = Q;\n }\n }\n }\n\n return [min, max] as PointTuple;\n};\n\nexport {\n bezierLength,\n calculateBezier,\n CBEZIER_MINMAX_EPSILON,\n computeBezier,\n Cvalues,\n deriveBezier,\n getBezierLength,\n minmaxC,\n minmaxQ,\n Tvalues,\n};\n","import { getBezierLength, minmaxC } from \"./bezier\";\nimport { type CubicCoordinates } from \"../types\";\n\n/**\n * Returns a point at a given length of a CubicBezier segment.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param t a [0-1] ratio\n * @returns the point at cubic-bezier segment length\n */\nconst getPointAtCubicSegmentLength = (\n [x1, y1, c1x, c1y, c2x, c2y, x2, y2]: CubicCoordinates,\n t: number,\n) => {\n const t1 = 1 - t;\n return {\n x: t1 ** 3 * x1 + 3 * t1 ** 2 * t * c1x + 3 * t1 * t ** 2 * c2x +\n t ** 3 * x2,\n y: t1 ** 3 * y1 + 3 * t1 ** 2 * t * c1y + 3 * t1 * t ** 2 * c2y +\n t ** 3 * y2,\n };\n};\n\n/**\n * Returns the length of a CubicBezier segment.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the CubicBezier segment length\n */\nconst getCubicLength = (\n x1: number,\n y1: number,\n c1x: number,\n c1y: number,\n c2x: number,\n c2y: number,\n x2: number,\n y2: number,\n) => {\n return getBezierLength([x1, y1, c1x, c1y, c2x, c2y, x2, y2]);\n};\n\n/**\n * Returns the point along a CubicBezier segment at a given distance.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance the distance to look at\n * @returns the point at CubicBezier length\n */\nconst getPointAtCubicLength = (\n x1: number,\n y1: number,\n c1x: number,\n c1y: number,\n c2x: number,\n c2y: number,\n x2: number,\n y2: number,\n distance?: number,\n) => {\n const distanceIsNumber = typeof distance === \"number\";\n let point = { x: x1, y: y1 };\n /* istanbul ignore else @preserve */\n if (distanceIsNumber) {\n const currentLength = getBezierLength([x1, y1, c1x, c1y, c2x, c2y, x2, y2]);\n if (distance <= 0) {\n // first point already defined\n } else if (distance >= currentLength) {\n point = { x: x2, y: y2 };\n } else {\n point = getPointAtCubicSegmentLength(\n [x1, y1, c1x, c1y, c2x, c2y, x2, y2],\n distance / currentLength,\n );\n }\n }\n return point;\n};\n\n/**\n * Returns the boundig box of a CubicBezier segment in the following format:\n * [MIN_X, MIN_Y, MAX_X, MAX_Y]\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the extrema of the CubicBezier segment\n */\nconst getCubicBBox = (\n x1: number,\n y1: number,\n c1x: number,\n c1y: number,\n c2x: number,\n c2y: number,\n x2: number,\n y2: number,\n) => {\n const cxMinMax = minmaxC([x1, c1x, c2x, x2]);\n const cyMinMax = minmaxC([y1, c1y, c2y, y2]);\n\n return [cxMinMax[0], cyMinMax[0], cxMinMax[1], cyMinMax[1]] as [\n number,\n number,\n number,\n number,\n ];\n};\n\nexport {\n getCubicBBox,\n getCubicLength,\n getPointAtCubicLength,\n getPointAtCubicSegmentLength,\n};\n","import { getBezierLength, minmaxQ } from \"./bezier\";\nimport { type QuadCoordinates } from \"../types\";\n\n/**\n * Returns the {x,y} coordinates of a point at a\n * given length of a quadratic-bezier segment.\n *\n * @see https://github.com/substack/point-at-length\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param cx the control point X\n * @param cy the control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param t a [0-1] ratio\n * @returns the requested {x,y} coordinates\n */\nconst getPointAtQuadSegmentLength = (\n [x1, y1, cx, cy, x2, y2]: QuadCoordinates,\n t: number,\n) => {\n const t1 = 1 - t;\n return {\n x: t1 ** 2 * x1 + 2 * t1 * t * cx + t ** 2 * x2,\n y: t1 ** 2 * y1 + 2 * t1 * t * cy + t ** 2 * y2,\n };\n};\n\n/**\n * Returns the length of a QuadraticBezier segment.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param cx the control point X\n * @param cy the control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the QuadraticBezier segment length\n */\nconst getQuadLength = (\n x1: number,\n y1: number,\n cx: number,\n cy: number,\n x2: number,\n y2: number,\n) => {\n return getBezierLength([x1, y1, cx, cy, x2, y2]);\n};\n\n/**\n * Returns the point along a QuadraticBezier segment at a given distance.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param cx the control point X\n * @param cy the control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance the distance to look at\n * @returns the point at QuadraticBezier length\n */\nconst getPointAtQuadLength = (\n x1: number,\n y1: number,\n cx: number,\n cy: number,\n x2: number,\n y2: number,\n distance?: number,\n) => {\n const distanceIsNumber = typeof distance === \"number\";\n let point = { x: x1, y: y1 };\n\n /* istanbul ignore else @preserve */\n if (distanceIsNumber) {\n const currentLength = getBezierLength([x1, y1, cx, cy, x2, y2]);\n if (distance <= 0) {\n // first point already defined\n } else if (distance >= currentLength) {\n point = { x: x2, y: y2 };\n } else {\n point = getPointAtQuadSegmentLength(\n [x1, y1, cx, cy, x2, y2],\n distance / currentLength,\n );\n }\n }\n return point;\n};\n\n/**\n * Returns the boundig box of a QuadraticBezier segment in the following format:\n * [MIN_X, MIN_Y, MAX_X, MAX_Y]\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param cx the control point X\n * @param cy the control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the extrema of the QuadraticBezier segment\n */\nconst getQuadBBox = (\n x1: number,\n y1: number,\n cx: number,\n cy: number,\n x2: number,\n y2: number,\n) => {\n const cxMinMax = minmaxQ([x1, cx, x2]);\n const cyMinMax = minmaxQ([y1, cy, y2]);\n return [cxMinMax[0], cyMinMax[0], cxMinMax[1], cyMinMax[1]] as [\n number,\n number,\n number,\n number,\n ];\n};\n\nexport {\n getPointAtQuadLength,\n getPointAtQuadSegmentLength,\n getQuadBBox,\n getQuadLength,\n};\n","import distanceSquareRoot from \"./distanceSquareRoot\";\nimport { type PointTuple } from \"../types\";\n\n/**\n * d3-polygon-area\n * https://github.com/d3/d3-polygon\n *\n * Returns the area of a polygon.\n *\n * @param polygon an array of coordinates\n * @returns the polygon area\n */\nconst polygonArea = (polygon: PointTuple[]) => {\n const n = polygon.length;\n let i = -1;\n let a: PointTuple;\n let b = polygon[n - 1];\n let area = 0;\n\n /* eslint-disable-next-line */\n while (++i < n) {\n a = b;\n b = polygon[i];\n area += a[1] * b[0] - a[0] * b[1];\n }\n\n return area / 2;\n};\n\n/**\n * d3-polygon-length\n * https://github.com/d3/d3-polygon\n *\n * Returns the perimeter of a polygon.\n *\n * @param polygon an array of coordinates\n * @returns the polygon length\n */\nconst polygonLength = (polygon: PointTuple[]) => {\n return polygon.reduce((length, point, i) => {\n if (i) {\n return length + distanceSquareRoot(polygon[i - 1], point);\n }\n return 0;\n }, 0);\n};\n\nexport { polygonArea, polygonLength };\n","/** Segment params length */\nconst paramsCount = {\n a: 7,\n c: 6,\n h: 1,\n l: 2,\n m: 2,\n r: 4,\n q: 4,\n s: 4,\n t: 2,\n v: 1,\n z: 0,\n};\n\nexport default paramsCount;\n","import paramsCount from \"./paramsCount\";\nimport PathParser from \"./pathParser\";\nimport type { PathCommand, PathSegment, RelativeCommand } from \"../types\";\n\n/**\n * Breaks the parsing of a pathString once a segment is finalized.\n *\n * @param path the `PathParser` instance\n */\nconst finalizeSegment = (path: PathParser) => {\n let pathCommand = path.pathValue[path.segmentStart] as PathCommand;\n let relativeCommand = pathCommand.toLowerCase() as RelativeCommand;\n const { data } = path;\n\n while (data.length >= paramsCount[relativeCommand]) {\n // overloaded `moveTo`\n // https://github.com/rveciana/svg-path-properties/blob/master/src/parse.ts\n if (relativeCommand === \"m\" && data.length > 2) {\n path.segments.push(\n [pathCommand as PathCommand | number].concat(\n data.splice(0, 2) as number[],\n ) as PathSegment,\n );\n relativeCommand = \"l\";\n pathCommand = pathCommand === \"m\" ? \"l\" : \"L\";\n } else {\n path.segments.push(\n [pathCommand as PathCommand | number].concat(\n data.splice(0, paramsCount[relativeCommand]) as number[],\n ) as PathSegment,\n );\n }\n\n if (!paramsCount[relativeCommand]) {\n break;\n }\n }\n};\nexport default finalizeSegment;\n","const error = \"SVGPathCommander Error\";\nexport default error;\n","import error from \"./error\";\nimport type PathParser from \"./pathParser\";\n\n/**\n * Validates an A (arc-to) specific path command value.\n * Usually a `large-arc-flag` or `sweep-flag`.\n *\n * @param path the `PathParser` instance\n */\nconst scanFlag = (path: PathParser) => {\n const { index, pathValue } = path;\n const code = pathValue.charCodeAt(index);\n\n if (code === 0x30 /* 0 */) {\n path.param = 0;\n path.index += 1;\n return;\n }\n\n if (code === 0x31 /* 1 */) {\n path.param = 1;\n path.index += 1;\n return;\n }\n\n path.err = `${error}: invalid Arc flag \"${\n pathValue[index]\n }\", expecting 0 or 1 at index ${index}`;\n};\n\nexport default scanFlag;\n","import { DigitNumber } from \"../types\";\n\n/**\n * Checks if a character is a digit.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isDigit = (code: number): code is DigitNumber => {\n return code >= 48 && code <= 57; // 0..9\n};\nexport default isDigit;\n","const invalidPathValue = \"Invalid path value\";\nexport default invalidPathValue;\n","import isDigit from \"./isDigit\";\nimport invalidPathValue from \"./invalidPathValue\";\nimport error from \"./error\";\nimport type PathParser from \"./pathParser\";\n\n/**\n * Validates every character of the path string,\n * every path command, negative numbers or floating point numbers.\n *\n * @param path the `PathParser` instance\n */\nconst scanParam = (path: PathParser) => {\n const { max, pathValue, index: start } = path;\n let index = start;\n let zeroFirst = false;\n let hasCeiling = false;\n let hasDecimal = false;\n let hasDot = false;\n let ch;\n\n if (index >= max) {\n path.err =\n `${error}: ${invalidPathValue} at index ${index}, \"pathValue\" is missing param`;\n return;\n }\n ch = pathValue.charCodeAt(index);\n\n if (ch === 0x2b /* + */ || ch === 0x2d /* - */) {\n index += 1;\n // ch = (index < max) ? pathValue.charCodeAt(index) : 0;\n ch = pathValue.charCodeAt(index);\n }\n\n // This logic is shamelessly borrowed from Esprima\n // https://github.com/ariya/esprimas\n if (!isDigit(ch) && ch !== 0x2e /* . */) {\n // path.err = 'SvgPath: param should start with 0..9 or `.` (at pos ' + index + ')';\n path.err = `${error}: ${invalidPathValue} at index ${index}, \"${\n pathValue[index]\n }\" is not a number`;\n return;\n }\n\n if (ch !== 0x2e /* . */) {\n zeroFirst = ch === 0x30 /* 0 */;\n index += 1;\n\n ch = pathValue.charCodeAt(index);\n\n if (zeroFirst && index < max) {\n // decimal number starts with '0' such as '09' is illegal.\n if (ch && isDigit(ch)) {\n // path.err = 'SvgPath: numbers started with `0` such as `09`\n // are illegal (at pos ' + start + ')';\n path.err = `${error}: ${invalidPathValue} at index ${start}, \"${\n pathValue[start]\n }\" illegal number`;\n return;\n }\n }\n\n while (index < max && isDigit(pathValue.charCodeAt(index))) {\n index += 1;\n hasCeiling = true;\n }\n\n ch = pathValue.charCodeAt(index);\n }\n\n if (ch === 0x2e /* . */) {\n hasDot = true;\n index += 1;\n while (isDigit(pathValue.charCodeAt(index))) {\n index += 1;\n hasDecimal = true;\n }\n\n ch = pathValue.charCodeAt(index);\n }\n\n if (ch === 0x65 /* e */ || ch === 0x45 /* E */) {\n if (hasDot && !hasCeiling && !hasDecimal) {\n path.err = `${error}: ${invalidPathValue} at index ${index}, \"${\n pathValue[index]\n }\" invalid float exponent`;\n return;\n }\n\n index += 1;\n\n ch = pathValue.charCodeAt(index);\n\n if (ch === 0x2b /* + */ || ch === 0x2d /* - */) {\n index += 1;\n }\n if (index < max && isDigit(pathValue.charCodeAt(index))) {\n while (index < max && isDigit(pathValue.charCodeAt(index))) {\n index += 1;\n }\n } else {\n path.err = `${error}: ${invalidPathValue} at index ${index}, \"${\n pathValue[index]\n }\" invalid integer exponent`;\n return;\n }\n }\n\n path.index = index;\n path.param = +path.pathValue.slice(start, index);\n};\nexport default scanParam;\n","import type { SpaceNumber } from \"../types\";\n\n/**\n * Checks if the character is a space.\n *\n * @param ch the character to check\n * @returns check result\n */\n\nconst isSpace = (ch: number): ch is SpaceNumber => {\n const allSpaces = [\n // Special spaces\n 0x1680,\n 0x180e,\n 0x2000,\n 0x2001,\n 0x2002,\n 0x2003,\n 0x2004,\n 0x2005,\n 0x2006,\n 0x2007,\n 0x2008,\n 0x2009,\n 0x200a,\n 0x202f,\n 0x205f,\n 0x3000,\n 0xfeff,\n // Line terminators\n 0x0a,\n 0x0d,\n 0x2028,\n 0x2029,\n // White spaces\n 0x20,\n 0x09,\n 0x0b,\n 0x0c,\n 0xa0,\n ];\n\n return allSpaces.includes(ch);\n};\nexport default isSpace;\n","import isSpace from \"./isSpace\";\nimport type PathParser from \"./pathParser\";\n\n/**\n * Points the parser to the next character in the\n * path string every time it encounters any kind of\n * space character.\n *\n * @param path the `PathParser` instance\n */\nconst skipSpaces = (path: PathParser) => {\n const { pathValue, max } = path;\n while (path.index < max && isSpace(pathValue.charCodeAt(path.index))) {\n path.index += 1;\n }\n};\nexport default skipSpaces;\n","import type { PathCommandNumber } from \"../types\";\n\n/**\n * Checks if the character is a path command.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isPathCommand = (code: number): code is PathCommandNumber => {\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy\n switch (code | 0x20) {\n case 0x6d /* m */:\n case 0x7a /* z */:\n case 0x6c /* l */:\n case 0x68 /* h */:\n case 0x76 /* v */:\n case 0x63 /* c */:\n case 0x73 /* s */:\n case 0x71 /* q */:\n case 0x74 /* t */:\n case 0x61 /* a */:\n // case 0x72/* r */:\n return true;\n default:\n return false;\n }\n};\nexport default isPathCommand;\n","import isDigit from \"./isDigit\";\nimport type { DigitNumber } from \"../types\";\n\n/**\n * Checks if the character is or belongs to a number.\n * [0-9]|+|-|.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isDigitStart = (\n code: number,\n): code is DigitNumber | 0x2b | 0x2d | 0x2e => {\n return isDigit(code) /* 0..9 */ || code === 0x2b /* + */ ||\n code === 0x2d /* - */ || code === 0x2e; /* . */\n};\nexport default isDigitStart;\n","/**\n * Checks if the character is an A (arc-to) path command.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isArcCommand = (code: number): code is 0x61 => {\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy\n return (code | 0x20) === 0x61;\n};\nexport default isArcCommand;\n","/**\n * Checks if the character is a MoveTo command.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isMoveCommand = (code: number): code is 0x6d | 0x4d => {\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy\n switch (code | 0x20) {\n case 0x6d /* m */:\n case 0x4d /* M */:\n return true;\n default:\n return false;\n }\n};\nexport default isMoveCommand;\n","import finalizeSegment from \"./finalizeSegment\";\nimport paramCounts from \"./paramsCount\";\nimport scanFlag from \"./scanFlag\";\nimport scanParam from \"./scanParam\";\nimport skipSpaces from \"./skipSpaces\";\nimport isPathCommand from \"./isPathCommand\";\nimport isDigitStart from \"./isDigitStart\";\nimport isArcCommand from \"./isArcCommand\";\nimport isMoveCommand from \"./isMoveCommand\";\nimport invalidPathValue from \"./invalidPathValue\";\nimport error from \"./error\";\n\nimport type PathParser from \"./pathParser\";\nimport type { PathSegment, RelativeCommand } from \"../types\";\n\n/**\n * Scans every character in the path string to determine\n * where a segment starts and where it ends.\n *\n * @param path the `PathParser` instance\n */\nconst scanSegment = (path: PathParser) => {\n const { max, pathValue, index, segments } = path;\n const cmdCode = pathValue.charCodeAt(index);\n const reqParams =\n paramCounts[pathValue[index].toLowerCase() as RelativeCommand];\n\n path.segmentStart = index;\n\n // segments always start with a path command\n if (!isPathCommand(cmdCode)) {\n path.err = `${error}: ${invalidPathValue} \"${\n pathValue[index]\n }\" is not a path command at index ${index}`;\n return;\n }\n\n // after a Z segment, we only expect a MoveTo path command\n const lastSegment = segments[segments.length - 1] as PathSegment | undefined;\n if (\n !isMoveCommand(cmdCode) && lastSegment?.[0]?.toLocaleLowerCase() === \"z\"\n ) {\n path.err = `${error}: ${invalidPathValue} \"${\n pathValue[index]\n }\" is not a MoveTo path command at index ${index}`;\n return;\n }\n\n path.index += 1;\n skipSpaces(path);\n\n path.data = [];\n\n if (!reqParams) {\n // Z\n finalizeSegment(path);\n return;\n }\n\n for (;;) {\n for (let i = reqParams; i > 0; i -= 1) {\n if (isArcCommand(cmdCode) && (i === 3 || i === 4)) scanFlag(path);\n else scanParam(path);\n\n if (path.err.length) {\n return;\n }\n path.data.push(path.param);\n\n skipSpaces(path);\n\n // after ',' param is mandatory\n if (\n path.index < max && pathValue.charCodeAt(path.index) === 0x2c /* , */\n ) {\n path.index += 1;\n skipSpaces(path);\n }\n }\n\n if (path.index >= path.max) {\n break;\n }\n\n // Stop on next segment\n if (!isDigitStart(pathValue.charCodeAt(path.index))) {\n break;\n }\n }\n\n finalizeSegment(path);\n};\nexport default scanSegment;\n","import type { PathArray, PathSegment } from \"../types\";\n\n/**\n * The `PathParser` is used by the `parsePathString` static method\n * to generate a `pathArray`.\n *\n * @param pathString\n */\nexport default class PathParser {\n declare segments: PathArray | PathSegment[];\n declare pathValue: string;\n declare max: number;\n declare index: number;\n declare param: number;\n declare segmentStart: number;\n declare data: (string | number)[];\n declare err: string;\n\n constructor(pathString: string) {\n this.segments = [];\n this.pathValue = pathString;\n this.max = pathString.length;\n this.index = 0;\n this.param = 0.0;\n this.segmentStart = 0;\n this.data = [];\n this.err = \"\";\n }\n}\n","import scanSegment from \"./scanSegment\";\nimport skipSpaces from \"./skipSpaces\";\nimport PathParser from \"./pathParser\";\nimport type { PathArray } from \"../types\";\n\n/**\n * Parses a path string value and returns an array\n * of segments we like to call `pathArray`.\n *\n * @param pathInput the string to be parsed\n * @returns the resulted `pathArray` or error string\n */\nconst parsePathString = (pathInput: string | T) => {\n if (typeof pathInput !== \"string\") {\n return pathInput.slice(0) as typeof pathInput;\n }\n\n const path = new PathParser(pathInput);\n\n skipSpaces(path);\n\n while (path.index < path.max && !path.err.length) {\n scanSegment(path);\n }\n\n // handle valid paths first\n // handle errors second\n if (!path.err.length) {\n if (path.segments.length) {\n /**\n * force absolute first M\n * getPathBBox calculation requires first segment to be absolute\n * @see https://github.com/thednp/svg-path-commander/pull/49\n */\n path.segments[0][0] = \"M\";\n }\n } else {\n throw TypeError(path.err);\n }\n\n return path.segments as PathArray;\n};\n\nexport default parsePathString;\n","import type {\n AbsoluteCommand,\n AbsoluteSegment,\n ASegment,\n CSegment,\n HSegment,\n LSegment,\n MSegment,\n PathSegment,\n QSegment,\n SSegment,\n TSegment,\n VSegment,\n} from \"../types\";\n\n/**\n * Returns an absolute segment of a `PathArray` object.\n *\n * @param segment the segment object\n * @param index the segment index\n * @param lastX the last known X value\n * @param lastY the last known Y value\n * @returns the absolute segment\n */\nconst absolutizeSegment = (\n segment: PathSegment,\n index: number,\n lastX: number,\n lastY: number,\n) => {\n const [pathCommand] = segment;\n const absCommand = pathCommand.toUpperCase() as AbsoluteCommand;\n const isAbsolute = absCommand === pathCommand;\n\n /* istanbul ignore else @preserve */\n if (index === 0 || isAbsolute) return segment as MSegment | AbsoluteSegment;\n // const values = segment.slice(1) as number[];\n if (absCommand === \"A\") {\n return [\n absCommand,\n segment[1],\n segment[2],\n segment[3],\n segment[4],\n segment[5],\n (segment as ASegment)[6] + lastX,\n (segment as ASegment)[7] + lastY,\n ] as ASegment;\n } else if (absCommand === \"V\") {\n return [absCommand, (segment as VSegment)[1] + lastY] as VSegment;\n } else if (absCommand === \"H\") {\n return [absCommand, (segment as HSegment)[1] + lastX] as HSegment;\n } else if (absCommand === \"L\") {\n return [\n absCommand,\n (segment as LSegment)[1] + lastX,\n (segment as LSegment)[2] + lastY,\n ] as LSegment;\n } else {\n // use brakets for `eslint: no-case-declaration`\n // https://stackoverflow.com/a/50753272/803358\n const absValues = [] as number[];\n const seglen = segment.length;\n for (let j = 1; j < seglen; j += 1) {\n absValues.push((segment[j] as number) + (j % 2 ? lastX : lastY));\n }\n // for c, s, q, t\n return [absCommand as typeof absCommand | number].concat(absValues) as\n | MSegment\n | QSegment\n | TSegment\n | SSegment\n | CSegment;\n }\n};\nexport default absolutizeSegment;\n","// import paramsParser from '../parser/paramsParser';\nimport type {\n AbsoluteCommand,\n IteratorCallback,\n PathArray,\n PathCommand,\n PathSegment,\n} from \"../types\";\n\nconst iterate = (\n path: PathArray,\n iterator: IteratorCallback,\n) => {\n let pathLen = path.length;\n let segment: PathSegment;\n let pathCommand = \"M\" as PathCommand;\n let absCommand = \"M\" as AbsoluteCommand;\n let isRelative = false;\n let x = 0;\n let y = 0;\n let mx = 0;\n let my = 0;\n let segLen = 0;\n\n for (let i = 0; i < pathLen; i += 1) {\n segment = path[i];\n [pathCommand] = segment;\n segLen = segment.length;\n absCommand = pathCommand.toUpperCase() as AbsoluteCommand;\n isRelative = absCommand !== pathCommand;\n\n const iteratorResult = iterator(segment, i, x, y);\n // some methods like getPointAtLength would like to break\n // when task is complete\n if (iteratorResult === false) {\n break;\n }\n\n // segment = path[i];\n if (absCommand === \"Z\") {\n x = mx;\n y = my;\n } else if (absCommand === \"H\") {\n x = (segment[1] as number) + (isRelative ? x : 0);\n } else if (absCommand === \"V\") {\n y = (segment[1] as number) + (isRelative ? y : 0);\n } else {\n x = (segment[segLen - 2] as number) + (isRelative ? x : 0);\n y = (segment[segLen - 1] as number) + (isRelative ? y : 0);\n\n if (absCommand === \"M\") {\n mx = x;\n my = y;\n }\n }\n\n if (iteratorResult) {\n path[i] = iteratorResult;\n if (iteratorResult[0] === \"C\") {\n pathLen = path.length;\n }\n }\n }\n return path as T;\n};\n\nexport default iterate;\n","import parsePathString from \"../parser/parsePathString\";\nimport absolutizeSegment from \"../process/absolutizeSegment\";\nimport type { AbsoluteArray, PathArray } from \"../types\";\nimport iterate from \"../process/iterate\";\n\n/**\n * Parses a path string value or object and returns an array\n * of segments, all converted to absolute values.\n *\n * @param pathInput the path string | object\n * @returns the resulted `pathArray` with absolute values\n */\nconst pathToAbsolute = (pathInput: string | PathArray) => {\n const path = parsePathString(pathInput);\n\n return iterate(path, absolutizeSegment);\n};\nexport default pathToAbsolute;\n","import type {\n aSegment,\n cSegment,\n hSegment,\n lSegment,\n MSegment,\n PathSegment,\n qSegment,\n RelativeCommand,\n RelativeSegment,\n sSegment,\n tSegment,\n vSegment,\n} from \"../types\";\n\n/**\n * Returns a relative segment of a `PathArray` object.\n *\n * @param segment the segment object\n * @param index the segment index\n * @param lastX the last known X value\n * @param lastY the last known Y value\n * @returns the relative segment\n */\nconst relativizeSegment = (\n segment: PathSegment,\n index: number,\n lastX: number,\n lastY: number,\n) => {\n const [pathCommand] = segment;\n const relCommand = pathCommand.toLowerCase() as RelativeCommand;\n const isRelative = pathCommand === relCommand;\n\n /* istanbul ignore else @preserve */\n if (index === 0 || isRelative) return segment as MSegment | RelativeSegment;\n\n if (relCommand === \"a\") {\n return [\n relCommand,\n segment[1],\n segment[2],\n segment[3],\n segment[4],\n segment[5],\n (segment as aSegment)[6] - lastX,\n (segment as aSegment)[7] - lastY,\n ] as aSegment;\n } else if (relCommand === \"v\") {\n return [relCommand, (segment as vSegment)[1] - lastY] as vSegment;\n } else if (relCommand === \"h\") {\n return [relCommand, (segment as hSegment)[1] - lastX] as hSegment;\n } else if (relCommand === \"l\") {\n return [\n relCommand,\n (segment as lSegment)[1] - lastX,\n (segment as lSegment)[2] - lastY,\n ] as lSegment;\n } else {\n // use brakets for `eslint: no-case-declaration`\n // https://stackoverflow.com/a/50753272/803358\n const relValues = [] as number[];\n const seglen = segment.length;\n for (let j = 1; j < seglen; j += 1) {\n relValues.push((segment[j] as number) - (j % 2 ? lastX : lastY));\n }\n // for c, s, q, t\n return [relCommand as RelativeCommand | number].concat(relValues) as\n | qSegment\n | tSegment\n | sSegment\n | cSegment;\n }\n};\n\nexport default relativizeSegment;\n","import type { PathArray, RelativeArray } from \"../types\";\nimport parsePathString from \"../parser/parsePathString\";\nimport iterate from \"../process/iterate\";\nimport relativizeSegment from \"../process/relativizeSegment\";\n\n/**\n * Parses a path string value or object and returns an array\n * of segments, all converted to relative values.\n *\n * @param pathInput the path string | object\n * @returns the resulted `pathArray` with relative values\n */\nconst pathToRelative = (pathInput: string | PathArray): RelativeArray => {\n const path = parsePathString(pathInput);\n\n return iterate(path, relativizeSegment);\n};\nexport default pathToRelative;\n","/**\n * Returns an {x,y} vector rotated by a given\n * angle in radian.\n *\n * @param x the initial vector x\n * @param y the initial vector y\n * @param rad the radian vector angle\n * @returns the rotated vector\n */\nconst rotateVector = (\n x: number,\n y: number,\n rad: number,\n): { x: number; y: number } => {\n const { sin, cos } = Math;\n const X = x * cos(rad) - y * sin(rad);\n const Y = x * sin(rad) + y * cos(rad);\n return { x: X, y: Y };\n};\n\nexport default rotateVector;\n","import rotateVector from \"../math/rotateVector\";\n\n/**\n * Converts A (arc-to) segments to C (cubic-bezier-to).\n *\n * For more information of where this math came from visit:\n * http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes\n *\n * @param X1 the starting x position\n * @param Y1 the starting y position\n * @param RX x-radius of the arc\n * @param RY y-radius of the arc\n * @param angle x-axis-rotation of the arc\n * @param LAF large-arc-flag of the arc\n * @param SF sweep-flag of the arc\n * @param X2 the ending x position\n * @param Y2 the ending y position\n * @param recursive the parameters needed to split arc into 2 segments\n * @return the resulting cubic-bezier segment(s)\n */\nconst arcToCubic = (\n X1: number,\n Y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n X2: number,\n Y2: number,\n recursive?: [number, number, number, number],\n): number[] => {\n let x1 = X1;\n let y1 = Y1;\n let rx = RX;\n let ry = RY;\n let x2 = X2;\n let y2 = Y2;\n // for more information of where this Math came from visit:\n // http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes\n const d120 = (Math.PI * 120) / 180;\n\n const rad = (Math.PI / 180) * (+angle || 0);\n let res = [] as number[];\n let xy;\n let f1;\n let f2;\n let cx;\n let cy;\n\n if (!recursive) {\n xy = rotateVector(x1, y1, -rad);\n x1 = xy.x;\n y1 = xy.y;\n xy = rotateVector(x2, y2, -rad);\n x2 = xy.x;\n y2 = xy.y;\n\n const x = (x1 - x2) / 2;\n const y = (y1 - y2) / 2;\n let h = (x * x) / (rx * rx) + (y * y) / (ry * ry);\n if (h > 1) {\n h = Math.sqrt(h);\n rx *= h;\n ry *= h;\n }\n const rx2 = rx * rx;\n const ry2 = ry * ry;\n\n const k = (LAF === SF ? -1 : 1) *\n Math.sqrt(\n Math.abs(\n (rx2 * ry2 - rx2 * y * y - ry2 * x * x) / (rx2 * y * y + ry2 * x * x),\n ),\n );\n\n cx = (k * rx * y) / ry + (x1 + x2) / 2;\n cy = (k * -ry * x) / rx + (y1 + y2) / 2;\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy no-bitwise\n f1 = Math.asin(((((y1 - cy) / ry) * 10 ** 9) >> 0) / 10 ** 9);\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy no-bitwise\n f2 = Math.asin(((((y2 - cy) / ry) * 10 ** 9) >> 0) / 10 ** 9);\n\n f1 = x1 < cx ? Math.PI - f1 : f1;\n f2 = x2 < cx ? Math.PI - f2 : f2;\n if (f1 < 0) f1 = Math.PI * 2 + f1;\n if (f2 < 0) f2 = Math.PI * 2 + f2;\n if (SF && f1 > f2) {\n f1 -= Math.PI * 2;\n }\n if (!SF && f2 > f1) {\n f2 -= Math.PI * 2;\n }\n } else {\n [f1, f2, cx, cy] = recursive;\n }\n let df = f2 - f1;\n if (Math.abs(df) > d120) {\n const f2old = f2;\n const x2old = x2;\n const y2old = y2;\n f2 = f1 + d120 * (SF && f2 > f1 ? 1 : -1);\n x2 = cx + rx * Math.cos(f2);\n y2 = cy + ry * Math.sin(f2);\n res = arcToCubic(x2, y2, rx, ry, angle, 0, SF, x2old, y2old, [\n f2,\n f2old,\n cx,\n cy,\n ]);\n }\n df = f2 - f1;\n const c1 = Math.cos(f1);\n const s1 = Math.sin(f1);\n const c2 = Math.cos(f2);\n const s2 = Math.sin(f2);\n const t = Math.tan(df / 4);\n const hx = (4 / 3) * rx * t;\n const hy = (4 / 3) * ry * t;\n const m1 = [x1, y1];\n const m2 = [x1 + hx * s1, y1 - hy * c1];\n const m3 = [x2 + hx * s2, y2 - hy * c2];\n const m4 = [x2, y2];\n m2[0] = 2 * m1[0] - m2[0];\n m2[1] = 2 * m1[1] - m2[1];\n if (recursive) {\n return [m2[0], m2[1], m3[0], m3[1], m4[0], m4[1]].concat(res);\n }\n res = [m2[0], m2[1], m3[0], m3[1], m4[0], m4[1]].concat(res);\n const newres = [];\n for (let i = 0, ii = res.length; i < ii; i += 1) {\n newres[i] = i % 2\n ? rotateVector(res[i - 1], res[i], rad).y\n : rotateVector(res[i], res[i + 1], rad).x;\n }\n return newres;\n};\nexport default arcToCubic;\n","/**\n * Converts a Q (quadratic-bezier) segment to C (cubic-bezier).\n *\n * @param x1 curve start x\n * @param y1 curve start y\n * @param qx control point x\n * @param qy control point y\n * @param x2 curve end x\n * @param y2 curve end y\n * @returns the cubic-bezier segment\n */\nconst quadToCubic = (\n x1: number,\n y1: number,\n qx: number,\n qy: number,\n x2: number,\n y2: number,\n): [number, number, number, number, number, number] => {\n const r13 = 1 / 3;\n const r23 = 2 / 3;\n return [\n r13 * x1 + r23 * qx, // cpx1\n r13 * y1 + r23 * qy, // cpy1\n r13 * x2 + r23 * qx, // cpx2\n r13 * y2 + r23 * qy, // cpy2\n x2,\n y2, // x,y\n ];\n};\nexport default quadToCubic;\n","import midPoint from \"../math/midPoint\";\n\n/**\n * Converts an L (line-to) segment to C (cubic-bezier).\n *\n * @param x1 line start x\n * @param y1 line start y\n * @param x2 line end x\n * @param y2 line end y\n * @returns the cubic-bezier segment\n */\nconst lineToCubic = (x1: number, y1: number, x2: number, y2: number) => {\n const c1 = midPoint([x1, y1], [x2, y2], 1.0 / 3.0);\n const c2 = midPoint([x1, y1], [x2, y2], 2.0 / 3.0);\n return [c1[0], c1[1], c2[0], c2[1], x2, y2];\n};\nexport default lineToCubic;\n","import arcToCubic from \"./arcToCubic\";\nimport quadToCubic from \"./quadToCubic\";\nimport lineToCubic from \"./lineToCubic\";\nimport type { CSegment, MSegment, PathSegment } from \"../types\";\nimport type { ParserParams } from \"../interface\";\n\n/**\n * Converts any segment to C (cubic-bezier).\n *\n * @param segment the source segment\n * @param params the source segment parameters\n * @returns the cubic-bezier segment\n */\nconst segmentToCubic = (segment: PathSegment, params: ParserParams) => {\n const [pathCommand] = segment;\n const values = segment.slice(1).map(Number);\n const [x, y] = values;\n // let args;\n const { x1: px1, y1: py1, x: px, y: py } = params;\n\n if (!\"TQ\".includes(pathCommand)) {\n params.qx = null;\n params.qy = null;\n }\n\n if (pathCommand === \"M\") {\n params.x = x;\n params.y = y;\n return segment;\n } else if (pathCommand === \"A\") {\n return [\"C\" as string | number].concat(\n arcToCubic(\n px1,\n py1,\n values[0],\n values[1],\n values[2],\n values[3],\n values[4],\n values[5],\n values[6],\n ),\n ) as CSegment;\n } else if (pathCommand === \"Q\") {\n params.qx = x;\n params.qy = y;\n return [\"C\" as string | number].concat(\n quadToCubic(px1, py1, values[0], values[1], values[2], values[3]),\n ) as CSegment;\n } else if (pathCommand === \"L\") {\n return [\"C\" as string | number].concat(\n lineToCubic(px1, py1, x, y),\n ) as CSegment;\n } else if (pathCommand === \"Z\") {\n return [\"C\" as string | number].concat(\n lineToCubic(px1, py1, px, py),\n ) as CSegment;\n }\n\n return segment as MSegment | CSegment;\n};\nexport default segmentToCubic;\n","import type { ParserParams } from \"../interface\";\nimport type {\n ASegment,\n CSegment,\n HSegment,\n LSegment,\n MSegment,\n NormalSegment,\n PathCommand,\n PathSegment,\n PointTuple,\n QSegment,\n VSegment,\n} from \"../types\";\n\n/**\n * Normalizes a single segment of a `pathArray` object.\n *\n * @param segment the segment object\n * @param params the normalization parameters\n * @returns the normalized segment\n */\nconst normalizeSegment = (segment: PathSegment, params: ParserParams) => {\n const [pathCommand] = segment;\n const absCommand = pathCommand.toUpperCase();\n const isRelative = pathCommand !== absCommand;\n const { x1: px1, y1: py1, x2: px2, y2: py2, x, y } = params;\n const values = segment.slice(1) as number[];\n let absValues = values.map((n, j) => n + (isRelative ? (j % 2 ? y : x) : 0));\n\n if (!\"TQ\".includes(absCommand)) {\n // optional but good to be cautious\n params.qx = null;\n params.qy = null;\n }\n\n // istanbul ignore else @preserve\n if (absCommand === \"A\") {\n absValues = values.slice(0, -2).concat(\n values[5] + (isRelative ? x : 0),\n values[6] + (isRelative ? y : 0),\n );\n\n return [\"A\" as PathCommand | number].concat(absValues) as ASegment;\n } else if (absCommand === \"H\") {\n return [\n \"L\",\n (segment as HSegment)[1] + (isRelative ? x : 0),\n py1,\n ] as LSegment;\n } else if (absCommand === \"V\") {\n return [\n \"L\",\n px1,\n (segment as VSegment)[1] + (isRelative ? y : 0),\n ] as LSegment;\n } else if (absCommand === \"L\") {\n return [\n \"L\",\n (segment as LSegment)[1] + (isRelative ? x : 0),\n (segment as LSegment)[2] + (isRelative ? y : 0),\n ] as LSegment;\n } else if (absCommand === \"M\") {\n return [\n \"M\",\n (segment as MSegment)[1] + (isRelative ? x : 0),\n (segment as MSegment)[2] + (isRelative ? y : 0),\n ] as MSegment;\n } else if (absCommand === \"C\") {\n return [\"C\" as PathCommand | number].concat(absValues) as CSegment;\n } else if (absCommand === \"S\") {\n const x1 = px1 * 2 - px2;\n const y1 = py1 * 2 - py2;\n params.x1 = x1;\n params.y1 = y1;\n return [\"C\", x1, y1].concat(absValues) as CSegment;\n } else if (absCommand === \"T\") {\n const qx = px1 * 2 - (params.qx ? params.qx : /* istanbul ignore next */ 0);\n const qy = py1 * 2 - (params.qy ? params.qy : /* istanbul ignore next */ 0);\n params.qx = qx;\n params.qy = qy;\n return [\"Q\", qx, qy].concat(absValues) as QSegment;\n } else if (absCommand === \"Q\") {\n const [nqx, nqy] = absValues as PointTuple;\n params.qx = nqx;\n params.qy = nqy;\n return [\"Q\" as PathCommand | number].concat(absValues) as QSegment;\n } else if (absCommand === \"Z\") {\n return [\"Z\"] as NormalSegment;\n }\n\n // istanbul ignore next @preserve\n return segment as NormalSegment;\n};\nexport default normalizeSegment;\n","import type { ParserParams } from \"../interface\";\n\nconst paramsParser: ParserParams = {\n x1: 0,\n y1: 0,\n x2: 0,\n y2: 0,\n x: 0,\n y: 0,\n qx: null,\n qy: null,\n};\n\nexport default paramsParser;\n","import segmentToCubic from \"../process/segmentToCubic\";\nimport { AbsoluteCommand, CSegment, CurveArray, PathArray } from \"../types\";\nimport iterate from \"../process/iterate\";\nimport parsePathString from \"../parser/parsePathString\";\nimport normalizeSegment from \"../process/normalizeSegment\";\nimport paramsParser from \"../parser/paramsParser\";\n\n/**\n * Parses a path string value or 'pathArray' and returns a new one\n * in which all segments are converted to cubic-bezier.\n *\n * In addition, un-necessary `Z` segment is removed if previous segment\n * extends to the `M` segment.\n *\n * @param pathInput the string to be parsed or 'pathArray'\n * @returns the resulted `pathArray` converted to cubic-bezier\n */\nconst pathToCurve = (pathInput: string | PathArray): CurveArray => {\n const params = { ...paramsParser };\n const path = parsePathString(pathInput);\n\n return iterate(path, (seg, index, lastX, lastY) => {\n params.x = lastX;\n params.y = lastY;\n const normalSegment = normalizeSegment(seg, params);\n let result = segmentToCubic(normalSegment, params);\n const isLongArc = result[0] === \"C\" && result.length > 7;\n\n if (isLongArc) {\n path.splice(\n index + 1,\n 0,\n [\"C\" as AbsoluteCommand | number].concat(result.slice(7)) as CSegment,\n );\n result = result.slice(0, 7) as CSegment;\n }\n\n const seglen = result.length;\n params.x1 = +result[seglen - 2];\n params.y1 = +result[seglen - 1];\n params.x2 = +result[seglen - 4] || params.x1;\n params.y2 = +result[seglen - 3] || params.y1;\n\n return result;\n });\n};\nexport default pathToCurve;\n","import { Options } from \"../interface\";\n\n/** SVGPathCommander default options */\nconst defaultOptions: Options = {\n origin: [0, 0, 0],\n round: 4,\n};\n\nexport default defaultOptions;\n","const roundTo = (n: number, round: number) => {\n const pow = round >= 1 ? 10 ** round : 1;\n\n return round > 0 ? Math.round(n * pow) / pow : Math.round(n);\n};\n\nexport default roundTo;\n","import type { PathArray, PathSegment } from \"../types\";\nimport defaultOptions from \"../options/options\";\nimport roundTo from \"../math/roundTo\";\n\n/**\n * Returns a valid `d` attribute string value created\n * by rounding values and concatenating the `pathArray` segments.\n *\n * @param path the `pathArray` object\n * @param roundOption amount of decimals to round values to\n * @returns the concatenated path string\n */\nconst pathToString = (\n path: PathArray,\n roundOption?: number | \"off\",\n): string => {\n const pathLen = path.length;\n let { round } = defaultOptions;\n let segment = path[0] as PathSegment;\n let result = \"\";\n\n // allow for ZERO decimals\n round = roundOption === \"off\"\n ? roundOption\n : typeof roundOption === \"number\" && roundOption >= 0\n ? roundOption\n : typeof round === \"number\" && round >= 0\n ? round\n : /* istanbul ignore next @preserve */ \"off\";\n\n for (let i = 0; i < pathLen; i += 1) {\n segment = path[i];\n const [pathCommand] = segment;\n const values = segment.slice(1) as number[];\n result += pathCommand;\n if (round === \"off\") {\n result += values.join(\" \");\n } else {\n let j = 0;\n const valLen = values.length;\n while (j < valLen) {\n result += roundTo(values[j], round);\n if (j !== valLen - 1) result += \" \";\n j += 1;\n }\n }\n }\n\n return result;\n};\n\nexport default pathToString;\n","const DISTANCE_EPSILON = 0.00001;\n\nexport default DISTANCE_EPSILON;\n","import normalizeSegment from \"./normalizeSegment\";\nimport type { NormalArray, PathArray } from \"../types\";\nimport iterate from \"./iterate\";\nimport parsePathString from \"../parser/parsePathString\";\nimport paramsParser from \"../parser/paramsParser\";\n\n/**\n * Normalizes a `pathArray` object for further processing:\n * * convert segments to absolute values\n * * convert shorthand path commands to their non-shorthand notation\n *\n * @param pathInput the string to be parsed or 'pathArray'\n * @returns the normalized `pathArray`\n */\nconst normalizePath = (pathInput: string | PathArray) => {\n const path = parsePathString(pathInput);\n const params = { ...paramsParser };\n\n return iterate(path, (seg, _, lastX, lastY) => {\n params.x = lastX;\n params.y = lastY;\n const result = normalizeSegment(seg, params);\n\n const seglen = result.length;\n params.x1 = +result[seglen - 2];\n params.y1 = +result[seglen - 1];\n params.x2 = +result[seglen - 4] || params.x1;\n params.y2 = +result[seglen - 3] || params.y1;\n\n return result;\n });\n};\nexport default normalizePath;\n","import DISTANCE_EPSILON from \"./distanceEpsilon\";\nimport type { MSegment, PathArray, PointTuple } from \"../types\";\nimport iterate from \"../process/iterate\";\nimport { getLineLength, getPointAtLineLength } from \"../math/lineTools\";\nimport { getArcLength, getPointAtArcLength } from \"../math/arcTools\";\nimport { getCubicLength, getPointAtCubicLength } from \"../math/cubicTools\";\nimport { getPointAtQuadLength, getQuadLength } from \"../math/quadTools\";\nimport normalizePath from \"../process/normalizePath\";\n\n/**\n * Returns [x,y] coordinates of a point at a given length of a shape.\n *\n * @param pathInput the `pathArray` to look into\n * @param distance the length of the shape to look at\n * @returns the requested {x, y} point coordinates\n */\nconst getPointAtLength = (pathInput: string | PathArray, distance?: number) => {\n const path = normalizePath(pathInput);\n let isM = false;\n let data = [] as number[];\n let pathCommand = \"M\";\n let x = 0;\n let y = 0;\n let [mx, my] = path[0].slice(1) as PointTuple;\n const distanceIsNumber = typeof distance === \"number\";\n let point = { x: mx, y: my };\n let length = 0;\n let POINT = point;\n let totalLength = 0;\n\n if (!distanceIsNumber || distance < DISTANCE_EPSILON) return point;\n\n // for (let i = 0; i < pathLen; i += 1) {\n iterate(path, (seg, _, lastX, lastY) => {\n [pathCommand] = seg;\n isM = pathCommand === \"M\";\n data = !isM ? [lastX, lastY].concat(seg.slice(1) as number[]) : data;\n\n // this segment is always ZERO\n /* istanbul ignore else @preserve */\n if (isM) {\n // remember mx, my for Z\n [, mx, my] = seg as MSegment;\n point = { x: mx, y: my };\n length = 0;\n } else if (pathCommand === \"L\") {\n point = getPointAtLineLength(\n data[0],\n data[1],\n data[2],\n data[3],\n distance - totalLength,\n );\n length = getLineLength(data[0], data[1], data[2], data[3]);\n } else if (pathCommand === \"A\") {\n point = getPointAtArcLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n data[6],\n data[7],\n data[8],\n distance - totalLength,\n );\n length = getArcLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n data[6],\n data[7],\n data[8],\n );\n } else if (pathCommand === \"C\") {\n point = getPointAtCubicLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n data[6],\n data[7],\n distance - totalLength,\n );\n length = getCubicLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n data[6],\n data[7],\n );\n } else if (pathCommand === \"Q\") {\n point = getPointAtQuadLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n distance - totalLength,\n );\n length = getQuadLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n );\n } else if (pathCommand === \"Z\") {\n data = [lastX, lastY, mx, my];\n point = { x: mx, y: my };\n\n length = getLineLength(data[0], data[1], data[2], data[3]);\n }\n\n [x, y] = data.slice(-2);\n\n if (totalLength < distance) {\n POINT = point;\n } else {\n // totalLength >= distance\n // stop right here\n // stop iterator now!\n return false;\n }\n\n totalLength += length;\n return;\n });\n\n // native `getPointAtLength` behavior when the given distance\n // is higher than total length\n if (distance > totalLength - DISTANCE_EPSILON) {\n return { x, y };\n }\n\n return POINT;\n};\n\nexport default getPointAtLength;\n","import type { LSegment, MSegment, PathArray, PointTuple } from \"../types\";\nimport { getLineLength } from \"../math/lineTools\";\nimport { getArcLength } from \"../math/arcTools\";\nimport { getCubicLength } from \"../math/cubicTools\";\nimport { getQuadLength } from \"../math/quadTools\";\nimport iterate from \"../process/iterate\";\nimport parsePathString from \"../parser/parsePathString\";\nimport absolutizeSegment from \"../process/absolutizeSegment\";\n\n/**\n * Returns the shape total length, or the equivalent to `shape.getTotalLength()`.\n *\n * @param pathInput the target `pathArray`\n * @returns the shape total length\n */\nconst getTotalLength = (pathInput: string | PathArray) => {\n const path = parsePathString(pathInput);\n let paramX1 = 0;\n let paramY1 = 0;\n let paramX2 = 0;\n let paramY2 = 0;\n let paramQX = 0;\n let paramQY = 0;\n let pathCommand = \"M\";\n let mx = 0;\n let my = 0;\n let totalLength = 0;\n\n iterate(path, (seg, index, lastX, lastY) => {\n [pathCommand] = seg;\n const absCommand = pathCommand.toUpperCase();\n const isRelative = absCommand !== pathCommand;\n const absoluteSegment = isRelative\n ? absolutizeSegment(seg, index, lastX, lastY)\n : (seg.slice(0) as typeof seg);\n\n const normalSegment = absCommand === \"V\"\n ? ([\"L\", lastX, absoluteSegment[1]] as LSegment)\n : absCommand === \"H\"\n ? ([\"L\", absoluteSegment[1], lastY] as LSegment)\n : absoluteSegment;\n [pathCommand] = normalSegment;\n\n if (!\"TQ\".includes(absCommand)) {\n // optional but good to be cautious\n paramQX = 0;\n paramQY = 0;\n }\n\n // this segment is always ZERO\n /* istanbul ignore else @preserve */\n if (pathCommand === \"M\") {\n // remember mx, my for Z\n [, mx, my] = normalSegment as MSegment;\n } else if (pathCommand === \"L\") {\n totalLength += getLineLength(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n );\n } else if (pathCommand === \"A\") {\n totalLength += getArcLength(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n normalSegment[5] as number,\n normalSegment[6] as number,\n normalSegment[7] as number,\n );\n } else if (pathCommand === \"S\") {\n const cp1x = paramX1 * 2 - paramX2;\n const cp1y = paramY1 * 2 - paramY2;\n\n totalLength += getCubicLength(\n lastX,\n lastY,\n cp1x,\n cp1y,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n );\n } else if (pathCommand === \"C\") {\n totalLength += getCubicLength(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n normalSegment[5] as number,\n normalSegment[6] as number,\n );\n } else if (pathCommand === \"T\") {\n paramQX = paramX1 * 2 - paramQX;\n paramQY = paramY1 * 2 - paramQY;\n totalLength += getQuadLength(\n lastX,\n lastY,\n paramQX,\n paramQY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n );\n } else if (pathCommand === \"Q\") {\n paramQX = normalSegment[1] as number;\n paramQY = normalSegment[2] as number;\n totalLength += getQuadLength(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n );\n } else if (pathCommand === \"Z\") {\n totalLength += getLineLength(lastX, lastY, mx, my);\n }\n\n // update params\n [paramX1, paramY1] = pathCommand === \"Z\"\n ? [mx, my]\n : (normalSegment.slice(-2) as PointTuple);\n [paramX2, paramY2] = pathCommand === \"C\"\n ? ([normalSegment[3], normalSegment[4]] as PointTuple)\n : pathCommand === \"S\"\n ? ([normalSegment[1], normalSegment[2]] as PointTuple)\n : [paramX1, paramY1];\n });\n\n return totalLength;\n};\n\nexport default getTotalLength;\n","import type { PathArray, PathSegment } from \"../types\";\nimport type { SegmentProperties } from \"../interface\";\nimport parsePathString from \"../parser/parsePathString\";\nimport getTotalLength from \"./getTotalLength\";\n\n/**\n * Returns the segment, its index and length as well as\n * the length to that segment at a given length in a path.\n *\n * @param pathInput target `pathArray`\n * @param distance the given length\n * @returns the requested properties\n */\nconst getPropertiesAtLength = (\n pathInput: string | PathArray,\n distance?: number,\n): SegmentProperties => {\n const pathArray = parsePathString(pathInput);\n\n let pathTemp = pathArray.slice(0) as PathArray;\n let pathLength = getTotalLength(pathTemp);\n let index = pathTemp.length - 1;\n let lengthAtSegment = 0;\n let length = 0;\n let segment = pathArray[0] as PathSegment;\n\n // If the path is empty, return 0.\n if (index <= 0 || !distance || !Number.isFinite(distance)) {\n return {\n segment,\n index: 0,\n length,\n lengthAtSegment,\n };\n }\n\n if (distance >= pathLength) {\n pathTemp = pathArray.slice(0, -1) as PathArray;\n lengthAtSegment = getTotalLength(pathTemp);\n length = pathLength - lengthAtSegment;\n segment = pathArray[index];\n return {\n segment,\n index,\n length,\n lengthAtSegment,\n };\n }\n\n const segments = [] as SegmentProperties[];\n while (index > 0) {\n segment = pathTemp[index];\n pathTemp = pathTemp.slice(0, -1) as PathArray;\n lengthAtSegment = getTotalLength(pathTemp);\n length = pathLength - lengthAtSegment;\n pathLength = lengthAtSegment;\n\n segments.push({\n segment,\n index,\n length,\n lengthAtSegment,\n });\n index -= 1;\n }\n\n return segments.find(({ lengthAtSegment: l }) =>\n l <= distance\n ) as SegmentProperties;\n};\n\nexport default getPropertiesAtLength;\n","import type { PathArray, Point } from \"../types\";\nimport type { PointProperties } from \"../interface\";\nimport getPointAtLength from \"./getPointAtLength\";\nimport getPropertiesAtLength from \"./getPropertiesAtLength\";\nimport getTotalLength from \"./getTotalLength\";\nimport parsePathString from \"../parser/parsePathString\";\nimport normalizePath from \"../process/normalizePath\";\n\n/**\n * Returns the point and segment in path closest to a given point as well as\n * the distance to the path stroke.\n *\n * @see https://bl.ocks.org/mbostock/8027637\n *\n * @param pathInput target `pathArray`\n * @param point the given point\n * @returns the requested properties\n */\nconst getPropertiesAtPoint = (\n pathInput: string | PathArray,\n point: Point,\n): PointProperties => {\n const path = parsePathString(pathInput);\n const normalPath = normalizePath(path);\n const pathLength = getTotalLength(normalPath);\n const distanceTo = (p: Point) => {\n const dx = p.x - point.x;\n const dy = p.y - point.y;\n return dx * dx + dy * dy;\n };\n let precision = 8;\n let scan: Point;\n let closest = { x: 0, y: 0 }; // make TS happy\n let scanDistance = 0;\n let bestLength = 0;\n let bestDistance = Infinity;\n\n // linear scan for coarse approximation\n for (let scanLength = 0; scanLength <= pathLength; scanLength += precision) {\n scan = getPointAtLength(normalPath, scanLength);\n scanDistance = distanceTo(scan);\n\n if (scanDistance < bestDistance) {\n closest = scan;\n bestLength = scanLength;\n bestDistance = scanDistance;\n }\n }\n\n // binary search for precise estimate\n precision /= 2;\n let before: { x: number; y: number };\n let after: { x: number; y: number };\n let beforeLength = 0;\n let afterLength = 0;\n let beforeDistance = 0;\n let afterDistance = 0;\n\n while (precision > 0.000001) {\n beforeLength = bestLength - precision;\n before = getPointAtLength(normalPath, beforeLength);\n beforeDistance = distanceTo(before);\n afterLength = bestLength + precision;\n after = getPointAtLength(normalPath, afterLength);\n afterDistance = distanceTo(after);\n\n if (beforeLength >= 0 && beforeDistance < bestDistance) {\n closest = before;\n bestLength = beforeLength;\n bestDistance = beforeDistance;\n } else if (afterLength <= pathLength && afterDistance < bestDistance) {\n closest = after;\n bestLength = afterLength;\n bestDistance = afterDistance;\n } else {\n precision /= 2;\n }\n if (precision < 0.00001) break;\n }\n\n const segment = getPropertiesAtLength(path, bestLength);\n const distance = Math.sqrt(bestDistance);\n\n return { closest, distance, segment };\n};\n\nexport default getPropertiesAtPoint;\n","import type { PathArray } from \"../types\";\nimport getPropertiesAtPoint from \"./getPropertiesAtPoint\";\n\n/**\n * Returns the point in path closest to a given point.\n *\n * @param pathInput target `pathArray`\n * @param point the given point\n * @returns the best match\n */\nconst getClosestPoint = (\n pathInput: string | PathArray,\n point: { x: number; y: number },\n) => {\n return getPropertiesAtPoint(pathInput, point).closest;\n};\n\nexport default getClosestPoint;\n","import pathToCurve from \"../convert/pathToCurve\";\nimport type { PathArray, PointTuple } from \"../types\";\n\n/**\n * Returns the area of a single cubic-bezier segment.\n *\n * http://objectmix.com/graphics/133553-area-closed-bezier-curve.html\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the area of the cubic-bezier segment\n */\nconst getCubicSegArea = (\n x1: number,\n y1: number,\n c1x: number,\n c1y: number,\n c2x: number,\n c2y: number,\n x2: number,\n y2: number,\n) => {\n return (\n (3 *\n ((y2 - y1) * (c1x + c2x) -\n (x2 - x1) * (c1y + c2y) +\n c1y * (x1 - c2x) -\n c1x * (y1 - c2y) +\n y2 * (c2x + x1 / 3) -\n x2 * (c2y + y1 / 3))) /\n 20\n );\n};\n\n/**\n * Returns the area of a shape.\n *\n * @author Jürg Lehni & Jonathan Puckey\n *\n * @see https://github.com/paperjs/paper.js/blob/develop/src/path/Path.js\n *\n * @param path the shape `pathArray`\n * @returns the length of the cubic-bezier segment\n */\nconst getPathArea = (path: PathArray) => {\n let x = 0;\n let y = 0;\n let len = 0;\n\n return pathToCurve(path)\n .map((seg) => {\n switch (seg[0]) {\n case \"M\":\n [, x, y] = seg;\n return 0;\n default:\n len = getCubicSegArea(\n x,\n y,\n seg[1],\n seg[2],\n seg[3],\n seg[4],\n seg[5],\n seg[6],\n );\n [x, y] = seg.slice(-2) as PointTuple;\n return len;\n }\n })\n .reduce((a, b) => a + b, 0);\n};\nexport default getPathArea;\n","import getPathArea from \"./getPathArea\";\nimport pathToCurve from \"../convert/pathToCurve\";\nimport type { PathArray } from \"../types\";\n\n/**\n * Check if a path is drawn clockwise and returns true if so,\n * false otherwise.\n *\n * @param path the path string or `pathArray`\n * @returns true when clockwise or false if not\n */\nconst getDrawDirection = (path: string | PathArray) => {\n return getPathArea(pathToCurve(path)) >= 0;\n};\n\nexport default getDrawDirection;\n","import iterate from \"../process/iterate\";\nimport { PathBBox } from \"../interface\";\nimport { LSegment, MSegment, PathArray, PointTuple } from \"../types\";\nimport { getLineBBox } from \"../math/lineTools\";\nimport { getArcBBox } from \"../math/arcTools\";\nimport { getCubicBBox } from \"../math/cubicTools\";\nimport { getQuadBBox } from \"../math/quadTools\";\nimport parsePathString from \"../parser/parsePathString\";\nimport absolutizeSegment from \"../process/absolutizeSegment\";\n\nconst getPathBBox = (pathInput: PathArray | string) => {\n if (!pathInput) {\n return {\n x: 0,\n y: 0,\n width: 0,\n height: 0,\n x2: 0,\n y2: 0,\n cx: 0,\n cy: 0,\n cz: 0,\n };\n }\n\n const path = parsePathString(pathInput);\n let pathCommand = \"M\";\n let mx = 0;\n let my = 0;\n const { max, min } = Math;\n let xMin = Infinity;\n let yMin = Infinity;\n let xMax = -Infinity;\n let yMax = -Infinity;\n let minX = 0;\n let minY = 0;\n let maxX = 0;\n let maxY = 0;\n let paramX1 = 0;\n let paramY1 = 0;\n let paramX2 = 0;\n let paramY2 = 0;\n let paramQX = 0;\n let paramQY = 0;\n\n iterate(path, (seg, index, lastX, lastY) => {\n [pathCommand] = seg;\n const absCommand = pathCommand.toUpperCase();\n const isRelative = absCommand !== pathCommand;\n const absoluteSegment = isRelative\n ? absolutizeSegment(seg, index, lastX, lastY)\n : (seg.slice(0) as typeof seg);\n\n const normalSegment = absCommand === \"V\"\n ? ([\"L\", lastX, absoluteSegment[1]] as LSegment)\n : absCommand === \"H\"\n ? ([\"L\", absoluteSegment[1], lastY] as LSegment)\n : absoluteSegment;\n\n [pathCommand] = normalSegment;\n\n if (!\"TQ\".includes(absCommand)) {\n // optional but good to be cautious\n paramQX = 0;\n paramQY = 0;\n }\n\n // this segment is always ZERO\n /* istanbul ignore else @preserve */\n if (pathCommand === \"M\") {\n [, mx, my] = normalSegment as MSegment;\n minX = mx;\n minY = my;\n maxX = mx;\n maxY = my;\n } else if (pathCommand === \"L\") {\n [minX, minY, maxX, maxY] = getLineBBox(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n );\n } else if (pathCommand === \"A\") {\n [minX, minY, maxX, maxY] = getArcBBox(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n normalSegment[5] as number,\n normalSegment[6] as number,\n normalSegment[7] as number,\n );\n } else if (pathCommand === \"S\") {\n const cp1x = paramX1 * 2 - paramX2;\n const cp1y = paramY1 * 2 - paramY2;\n\n [minX, minY, maxX, maxY] = getCubicBBox(\n lastX,\n lastY,\n cp1x,\n cp1y,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n );\n } else if (pathCommand === \"C\") {\n [minX, minY, maxX, maxY] = getCubicBBox(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n normalSegment[5] as number,\n normalSegment[6] as number,\n );\n } else if (pathCommand === \"T\") {\n paramQX = paramX1 * 2 - paramQX;\n paramQY = paramY1 * 2 - paramQY;\n [minX, minY, maxX, maxY] = getQuadBBox(\n lastX,\n lastY,\n paramQX,\n paramQY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n );\n } else if (pathCommand === \"Q\") {\n paramQX = normalSegment[1] as number;\n paramQY = normalSegment[2] as number;\n [minX, minY, maxX, maxY] = getQuadBBox(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n );\n } else if (pathCommand === \"Z\") {\n [minX, minY, maxX, maxY] = getLineBBox(lastX, lastY, mx, my);\n }\n xMin = min(minX, xMin);\n yMin = min(minY, yMin);\n xMax = max(maxX, xMax);\n yMax = max(maxY, yMax);\n\n // update params\n [paramX1, paramY1] = pathCommand === \"Z\"\n ? [mx, my]\n : (normalSegment.slice(-2) as PointTuple);\n [paramX2, paramY2] = pathCommand === \"C\"\n ? ([normalSegment[3], normalSegment[4]] as PointTuple)\n : pathCommand === \"S\"\n ? ([normalSegment[1], normalSegment[2]] as PointTuple)\n : [paramX1, paramY1];\n });\n\n const width = xMax - xMin;\n const height = yMax - yMin;\n\n return {\n width,\n height,\n x: xMin,\n y: yMin,\n x2: xMax,\n y2: yMax,\n cx: xMin + width / 2,\n cy: yMin + height / 2,\n // an estimated guess\n cz: Math.max(width, height) + Math.min(width, height) / 2,\n } satisfies PathBBox;\n};\n\nexport default getPathBBox;\n","import type { PathArray, PathSegment } from \"../types\";\nimport getPropertiesAtLength from \"./getPropertiesAtLength\";\n\n/**\n * Returns the segment at a given length.\n *\n * @param pathInput the target `pathArray`\n * @param distance the distance in path to look at\n * @returns the requested segment\n */\nconst getSegmentAtLength = (\n pathInput: string | PathArray,\n distance?: number,\n): PathSegment | undefined => {\n return getPropertiesAtLength(pathInput, distance).segment;\n};\n\nexport default getSegmentAtLength;\n","import type { SegmentProperties } from \"../interface\";\nimport type { PathArray } from \"../types\";\nimport getPropertiesAtPoint from \"./getPropertiesAtPoint\";\n\n/**\n * Returns the path segment which contains a given point.\n *\n * @param path the `pathArray` to look into\n * @param point the point of the shape to look for\n * @returns the requested segment\n */\nconst getSegmentOfPoint = (\n path: string | PathArray,\n point: { x: number; y: number },\n): SegmentProperties | undefined => {\n return getPropertiesAtPoint(path, point).segment;\n};\nexport default getSegmentOfPoint;\n","import type { PathArray, PathSegment, RelativeCommand } from \"../types\";\nimport paramsCount from \"../parser/paramsCount\";\n\n/**\n * Iterates an array to check if it's an actual `pathArray`.\n *\n * @param path the `pathArray` to be checked\n * @returns iteration result\n */\nconst isPathArray = (path: unknown): path is PathArray => {\n return (\n Array.isArray(path) &&\n path.every((seg: PathSegment) => {\n const lk = seg[0].toLowerCase() as RelativeCommand;\n return (\n paramsCount[lk] === seg.length - 1 &&\n \"achlmqstvz\".includes(lk) &&\n (seg.slice(1) as unknown[]).every(Number.isFinite)\n );\n }) &&\n path.length > 0\n );\n};\nexport default isPathArray;\n","import type { AbsoluteArray } from \"../types\";\nimport isPathArray from \"./isPathArray\";\n\n/**\n * Iterates an array to check if it's a `pathArray`\n * with all absolute values.\n *\n * @param path the `pathArray` to be checked\n * @returns iteration result\n */\nconst isAbsoluteArray = (path: unknown): path is AbsoluteArray => {\n return (\n isPathArray(path) &&\n // `isPathArray` also checks if it's `Array`\n path.every(([x]) => x === x.toUpperCase())\n );\n};\nexport default isAbsoluteArray;\n","import type { NormalArray } from \"../types\";\nimport isAbsoluteArray from \"./isAbsoluteArray\";\n\n/**\n * Iterates an array to check if it's a `pathArray`\n * with all segments are in non-shorthand notation\n * with absolute values.\n *\n * @param {string | SVGPath.pathArray} path the `pathArray` to be checked\n * @returns {boolean} iteration result\n */\nconst isNormalizedArray = (path: unknown): path is NormalArray => {\n // `isAbsoluteArray` also checks if it's `Array`\n return isAbsoluteArray(path) && path.every(([pc]) => \"ACLMQZ\".includes(pc));\n};\nexport default isNormalizedArray;\n","import { CurveArray } from \"../types\";\nimport isNormalizedArray from \"./isNormalizedArray\";\n\n/**\n * Iterates an array to check if it's a `pathArray`\n * with all C (cubic bezier) segments.\n *\n * @param path the `Array` to be checked\n * @returns iteration result\n */\nconst isCurveArray = (path: unknown): path is CurveArray => {\n // `isPathArray` also checks if it's `Array`\n return isNormalizedArray(path) && path.every(([pc]) => \"MC\".includes(pc));\n};\nexport default isCurveArray;\n","import type { PathArray } from \"../types\";\nimport getPropertiesAtPoint from \"./getPropertiesAtPoint\";\nimport DISTANCE_EPSILON from \"./distanceEpsilon\";\n\n/**\n * Checks if a given point is in the stroke of a path.\n *\n * @param pathInput target path\n * @param point the given `{x,y}` point\n * @returns the query result\n */\nconst isPointInStroke = (\n pathInput: string | PathArray,\n point: { x: number; y: number },\n) => {\n const { distance } = getPropertiesAtPoint(pathInput, point);\n return Math.abs(distance) < DISTANCE_EPSILON; // 0.01 might be more permissive\n};\nexport default isPointInStroke;\n","import type { RelativeArray } from \"../types\";\nimport isPathArray from \"./isPathArray\";\n\n/**\n * Iterates an array to check if it's a `pathArray`\n * with relative values.\n *\n * @param path the `pathArray` to be checked\n * @returns iteration result\n */\nconst isRelativeArray = (path: unknown): path is RelativeArray => {\n return (\n isPathArray(path) &&\n // `isPathArray` checks if it's `Array`\n path.slice(1).every(([pc]) => pc === pc.toLowerCase())\n );\n};\nexport default isRelativeArray;\n","import scanSegment from \"../parser/scanSegment\";\nimport skipSpaces from \"../parser/skipSpaces\";\nimport PathParser from \"../parser/pathParser\";\n\n/**\n * Parses a path string value to determine its validity\n * then returns true if it's valid or false otherwise.\n *\n * @param pathString the path string to be parsed\n * @returns the path string validity\n */\nconst isValidPath = (pathString: string) => {\n if (typeof pathString !== \"string\" || !pathString.length) {\n return false;\n }\n\n const path = new PathParser(pathString);\n\n skipSpaces(path);\n\n while (path.index < path.max && !path.err.length) {\n scanSegment(path);\n }\n\n return !path.err.length && \"mM\".includes(path.segments[0][0]);\n};\nexport default isValidPath;\n","import type { ShapeParams } from \"../interface\";\n\n/**\n * Supported shapes and their specific parameters.\n */\nconst shapeParams: ShapeParams = {\n line: [\"x1\", \"y1\", \"x2\", \"y2\"],\n circle: [\"cx\", \"cy\", \"r\"],\n ellipse: [\"cx\", \"cy\", \"rx\", \"ry\"],\n rect: [\"width\", \"height\", \"x\", \"y\", \"rx\", \"ry\"],\n polygon: [\"points\"],\n polyline: [\"points\"],\n glyph: [\"d\"],\n};\n\nexport default shapeParams;\n","const isElement = (node?: unknown): node is Element =>\n node !== undefined && node !== null &&\n typeof node === \"object\" &&\n (node as Node).nodeType === 1; // ELEMENT_NODE\n\nexport default isElement;\n","import type {\n CircleAttr,\n EllipseAttr,\n GlyphAttr,\n LineAttr,\n PolyAttr,\n RectAttr,\n ShapeParams,\n} from \"../interface\";\nimport type { PathArray, PathSegment, ShapeOps, ShapeTypes } from \"../types\";\nimport error from \"../parser/error\";\nimport parsePathString from \"../parser/parsePathString\";\nimport shapeParams from \"./shapeParams\";\nimport isPathArray from \"./isPathArray\";\nimport isElement from \"./isElement\";\n\n/**\n * Returns a new `pathArray` from line attributes.\n *\n * @param attr shape configuration\n * @returns a new line `pathArray`\n */\nexport const getLinePath = (attr: LineAttr): PathArray => {\n let { x1, y1, x2, y2 } = attr;\n [x1, y1, x2, y2] = [x1, y1, x2, y2].map((a) => +a);\n return [\n [\"M\", x1, y1],\n [\"L\", x2, y2],\n ];\n};\n\n/**\n * Returns a new `pathArray` like from polyline/polygon attributes.\n *\n * @param attr shape configuration\n * @return a new polygon/polyline `pathArray`\n */\nexport const getPolyPath = (attr: PolyAttr): PathArray => {\n const pathArray = [] as PathSegment[];\n const points = (attr.points || \"\")\n .trim()\n .split(/[\\s|,]/)\n .map((a) => +a);\n\n let index = 0;\n while (index < points.length) {\n pathArray.push([index ? \"L\" : \"M\", points[index], points[index + 1]]);\n index += 2;\n }\n\n return (attr.type === \"polygon\"\n ? [...pathArray, [\"z\"]]\n : pathArray) as PathArray;\n};\n\n/**\n * Returns a new `pathArray` from circle attributes.\n *\n * @param attr shape configuration\n * @return a circle `pathArray`\n */\nexport const getCirclePath = (attr: CircleAttr): PathArray => {\n let { cx, cy, r } = attr;\n [cx, cy, r] = [cx, cy, r].map((a) => +a);\n\n return [\n [\"M\", cx - r, cy],\n [\"a\", r, r, 0, 1, 0, 2 * r, 0],\n [\"a\", r, r, 0, 1, 0, -2 * r, 0],\n ];\n};\n\n/**\n * Returns a new `pathArray` from ellipse attributes.\n *\n * @param attr shape configuration\n * @return an ellipse `pathArray`\n */\nexport const getEllipsePath = (attr: EllipseAttr): PathArray => {\n let { cx, cy } = attr;\n let rx = attr.rx || 0;\n let ry = attr.ry || rx;\n [cx, cy, rx, ry] = [cx, cy, rx, ry].map((a) => +a);\n\n return [\n [\"M\", cx - rx, cy],\n [\"a\", rx, ry, 0, 1, 0, 2 * rx, 0],\n [\"a\", rx, ry, 0, 1, 0, -2 * rx, 0],\n ];\n};\n\n/**\n * Returns a new `pathArray` like from rect attributes.\n *\n * @param attr object with properties above\n * @return a new `pathArray` from `` attributes\n */\nexport const getRectanglePath = (attr: RectAttr): PathArray => {\n const x = +attr.x || 0;\n const y = +attr.y || 0;\n const w = +attr.width;\n const h = +attr.height;\n let rx = +(attr.rx || 0);\n let ry = +(attr.ry || rx);\n\n // Validity checks from http://www.w3.org/TR/SVG/shapes.html#RectElement:\n if (rx || ry) {\n // rx = !rx ? ry : rx;\n // ry = !ry ? rx : ry;\n\n /* istanbul ignore else @preserve */\n if (rx * 2 > w) rx -= (rx * 2 - w) / 2;\n /* istanbul ignore else @preserve */\n if (ry * 2 > h) ry -= (ry * 2 - h) / 2;\n\n return [\n [\"M\", x + rx, y],\n [\"h\", w - rx * 2],\n [\"s\", rx, 0, rx, ry],\n [\"v\", h - ry * 2],\n [\"s\", 0, ry, -rx, ry],\n [\"h\", -w + rx * 2],\n [\"s\", -rx, 0, -rx, -ry],\n [\"v\", -h + ry * 2],\n [\"s\", 0, -ry, rx, -ry],\n ];\n }\n\n return [[\"M\", x, y], [\"h\", w], [\"v\", h], [\"H\", x], [\"Z\"]];\n};\n\n/**\n * Returns a new `pathArray` created from attributes of a ``, ``,\n * ``, ``, ``, ``, or ``.\n *\n * It can also work with an options object, see the type below\n * @see ShapeOps\n *\n * @param element target shape\n * @return the newly created `` element\n */\nconst shapeToPathArray = (\n element: ShapeTypes | ShapeOps,\n) => {\n const supportedShapes = Object.keys(shapeParams) as (keyof ShapeParams)[];\n const targetIsElement = isElement(element);\n const tagName = targetIsElement ? element.tagName : null;\n\n if (tagName && [...supportedShapes, \"path\"].every((s) => tagName !== s)) {\n throw TypeError(`${error}: \"${tagName}\" is not SVGElement`);\n }\n\n const type =\n (targetIsElement ? tagName : (element as ShapeOps).type) as ShapeOps[\n \"type\"\n ];\n const shapeAttrs = shapeParams[type] as string[];\n const config = { type } as Record;\n\n if (targetIsElement) {\n shapeAttrs.forEach((p) => {\n config[p] = element.getAttribute(p) as string;\n });\n } else {\n Object.assign(config, element);\n }\n\n // set d\n let pathArray = [] as unknown as PathArray;\n\n /* istanbul ignore else */\n if (type === \"circle\") {\n pathArray = getCirclePath(config as unknown as CircleAttr);\n } else if (type === \"ellipse\") {\n pathArray = getEllipsePath(config as unknown as EllipseAttr);\n } else if ([\"polyline\", \"polygon\"].includes(type)) {\n pathArray = getPolyPath(config as unknown as PolyAttr);\n } else if (type === \"rect\") {\n pathArray = getRectanglePath(config as unknown as RectAttr);\n } else if (type === \"line\") {\n pathArray = getLinePath(config as unknown as LineAttr);\n } else if ([\"glyph\", \"path\"].includes(type)) {\n pathArray = parsePathString(\n targetIsElement\n ? element.getAttribute(\"d\") || /* istanbul ignore next @preserve */ \"\"\n : (element as GlyphAttr).d || \"\",\n );\n }\n\n // replace target element\n if (isPathArray(pathArray) && pathArray.length) {\n return pathArray;\n }\n return false;\n};\nexport default shapeToPathArray;\n","import type { ShapeParams } from \"../interface\";\nimport type { ShapeOps, ShapeTypes } from \"../types\";\nimport pathToString from \"../convert/pathToString\";\nimport defaultOptions from \"../options/options\";\nimport error from \"../parser/error\";\nimport isValidPath from \"./isValidPath\";\nimport isElement from \"./isElement\";\nimport shapeToPathArray from \"./shapeToPathArray\";\nimport shapeParams from \"./shapeParams\";\n\n/**\n * Returns a new `` element created from attributes of a ``, ``,\n * ``, ``, ``, `` or ``. If `replace` parameter\n * is `true`, it will replace the target. The default `ownerDocument` is your current\n * `document` browser page, if you want to use in server-side using `jsdom`, you can\n * pass the `jsdom` `document` to `ownDocument`.\n *\n * It can also work with an options object, see the type below\n * @see ShapeOps\n *\n * The newly created `` element keeps all non-specific\n * attributes like `class`, `fill`, etc.\n *\n * @param element target shape\n * @param replace option to replace target\n * @param ownerDocument document for create element\n * @return the newly created `` element\n */\nconst shapeToPath = (\n element: ShapeTypes | ShapeOps,\n replace?: boolean,\n ownerDocument?: Document,\n): SVGPathElement | false => {\n const doc = ownerDocument || document;\n const supportedShapes = Object.keys(shapeParams) as (keyof ShapeParams)[];\n const targetIsElement = isElement(element);\n const tagName = targetIsElement ? element.tagName : null;\n\n if (tagName === \"path\") {\n throw TypeError(`${error}: \"${tagName}\" is already SVGPathElement`);\n }\n if (tagName && supportedShapes.every((s) => tagName !== s)) {\n throw TypeError(`${error}: \"${tagName}\" is not SVGElement`);\n }\n\n const path = doc.createElementNS(\"http://www.w3.org/2000/svg\", \"path\");\n const type =\n (targetIsElement ? tagName : (element as ShapeOps).type) as ShapeOps[\n \"type\"\n ];\n const shapeAttrs = shapeParams[type] as string[];\n const config = { type } as Record;\n\n // set d\n const round = defaultOptions.round as number;\n const pathArray = shapeToPathArray(element);\n const description = pathArray && pathArray.length\n ? pathToString(pathArray, round)\n : \"\";\n\n if (targetIsElement) {\n shapeAttrs.forEach((p) => {\n config[p] = element.getAttribute(p) as string;\n });\n // set no-specific shape attributes: fill, stroke, etc\n Object.values(element.attributes).forEach(({ name, value }) => {\n if (!shapeAttrs.includes(name)) path.setAttribute(name, value);\n });\n } else {\n Object.assign(config, element);\n // set no-specific shape attributes: fill, stroke, etc\n Object.keys(config).forEach((k) => {\n if (!shapeAttrs.includes(k) && k !== \"type\") {\n path.setAttribute(\n k.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`),\n config[k],\n );\n }\n });\n }\n\n // replace target element\n if (isValidPath(description)) {\n path.setAttribute(\"d\", description);\n if (replace && targetIsElement) {\n element.before(path, element);\n element.remove();\n }\n return path;\n }\n return false;\n};\n\nexport default shapeToPath;\n","import CSSMatrix from \"@thednp/dommatrix\";\n// import type { TransformObject } from '../interface';\nimport type { TransformObjectValues } from \"../types\";\n\n/**\n * Returns a transformation matrix to apply to `` elements.\n *\n * @see TransformObjectValues\n *\n * @param transform the `transformObject`\n * @returns a new transformation matrix\n */\nconst getSVGMatrix = (transform: TransformObjectValues): CSSMatrix => {\n let matrix = new CSSMatrix();\n const { origin } = transform;\n const [originX, originY] = origin as [number, number, number];\n const { translate } = transform;\n const { rotate } = transform;\n const { skew } = transform;\n const { scale } = transform;\n\n // set translate\n if (\n Array.isArray(translate) &&\n translate.length >= 2 &&\n translate.every((x) => !Number.isNaN(+x)) &&\n translate.some((x) => x !== 0)\n ) {\n matrix = matrix.translate(...(translate as [number, number, number?]));\n } else if (typeof translate === \"number\" && !Number.isNaN(translate)) {\n matrix = matrix.translate(translate);\n }\n\n if (rotate || skew || scale) {\n // set SVG transform-origin, always defined\n matrix = matrix.translate(originX, originY);\n\n // set rotation\n if (\n Array.isArray(rotate) &&\n rotate.length >= 2 &&\n rotate.every((x) => !Number.isNaN(+x)) &&\n rotate.some((x) => x !== 0)\n ) {\n matrix = matrix.rotate(...(rotate as [number, number, number?]));\n } else if (typeof rotate === \"number\" && !Number.isNaN(rotate)) {\n matrix = matrix.rotate(rotate);\n }\n\n // set skew(s)\n if (\n Array.isArray(skew) && skew.length === 2 && skew.every((x) =>\n !Number.isNaN(+x)\n ) && skew.some((x) => x !== 0)\n ) {\n matrix = skew[0] ? matrix.skewX(skew[0]) : matrix;\n matrix = skew[1] ? matrix.skewY(skew[1]) : matrix;\n } else if (typeof skew === \"number\" && !Number.isNaN(skew)) {\n matrix = matrix.skewX(skew);\n }\n\n // set scale\n if (\n Array.isArray(scale) && scale.length >= 2 && scale.every((x) =>\n !Number.isNaN(+x)\n ) && scale.some((x) => x !== 1)\n ) {\n matrix = matrix.scale(...(scale as [number, number, number?]));\n } else if (typeof scale === \"number\" && !Number.isNaN(scale)) {\n matrix = matrix.scale(scale);\n }\n // set SVG transform-origin\n matrix = matrix.translate(-originX, -originY);\n }\n\n return matrix;\n};\nexport default getSVGMatrix;\n","import defaultOptions from \"../options/options\";\nimport type { ParserParams } from \"../interface\";\nimport roundTo from \"../math/roundTo\";\nimport type {\n AbsoluteSegment,\n NormalSegment,\n PathCommand,\n ShortSegment,\n SSegment,\n TSegment,\n} from \"../types\";\n\n/**\n * Shorten a single segment of a `pathArray` object.\n *\n * @param segment the `absoluteSegment` object\n * @param normalSegment the `normalSegment` object\n * @param params the coordinates of the previous segment\n * @param prevCommand the path command of the previous segment\n * @returns the shortened segment\n */\nconst shortenSegment = (\n segment: AbsoluteSegment,\n normalSegment: NormalSegment,\n params: ParserParams,\n prevCommand: PathCommand,\n): ShortSegment => {\n const [pathCommand] = segment;\n const { round: defaultRound } = defaultOptions;\n const round = typeof defaultRound === \"number\"\n ? defaultRound\n : /* istanbul ignore next */ 4;\n const normalValues = normalSegment.slice(1) as number[];\n const { x1, y1, x2, y2, x, y } = params;\n const [nx, ny] = normalValues.slice(-2);\n const result = segment;\n\n if (!\"TQ\".includes(pathCommand)) {\n // optional but good to be cautious\n params.qx = null;\n params.qy = null;\n }\n\n if (pathCommand === \"L\") {\n if (roundTo(x, round) === roundTo(nx, round)) {\n return [\"V\", ny];\n } else if (roundTo(y, round) === roundTo(ny, round)) {\n return [\"H\", nx];\n }\n } else if (pathCommand === \"C\") {\n const [nx1, ny1] = normalValues;\n params.x1 = nx1;\n params.y1 = ny1;\n\n if (\n \"CS\".includes(prevCommand) &&\n ((roundTo(nx1, round) === roundTo(x1 * 2 - x2, round) &&\n roundTo(ny1, round) === roundTo(y1 * 2 - y2, round)) ||\n (roundTo(x1, round) === roundTo(x2 * 2 - x, round) &&\n roundTo(y1, round) === roundTo(y2 * 2 - y, round)))\n ) {\n return [\n \"S\",\n normalValues[2],\n normalValues[3],\n normalValues[4],\n normalValues[5],\n ] as SSegment;\n }\n } else if (pathCommand === \"Q\") {\n const [qx, qy] = normalValues;\n params.qx = qx;\n params.qy = qy;\n\n if (\n \"QT\".includes(prevCommand) &&\n roundTo(qx, round) === roundTo(x1 * 2 - x2, round) &&\n roundTo(qy, round) === roundTo(y1 * 2 - y2, round)\n ) {\n return [\"T\", normalValues[2], normalValues[3]] as TSegment;\n }\n }\n\n // ['V', 'H', 'S', 'T', 'Z'].includes(pathCommand)\n return result as ShortSegment;\n};\n\nexport default shortenSegment;\n","import type { PathCommand, PathSegment } from \"../types\";\nimport roundTo from \"../math/roundTo\";\n\nconst roundSegment = (\n segment: T,\n roundOption: number,\n) => {\n const values = (segment.slice(1) as number[]).map((n) =>\n roundTo(n, roundOption)\n );\n return [segment[0] as PathCommand | number].concat(values) as T;\n};\n\nexport default roundSegment;\n","import type { AbsoluteSegment, PathArray, PathCommand } from \"../types\";\nimport pathToAbsolute from \"../convert/pathToAbsolute\";\nimport shortenSegment from \"./shortenSegment\";\nimport paramsParser from \"../parser/paramsParser\";\nimport iterate from \"./iterate\";\nimport normalizeSegment from \"./normalizeSegment\";\nimport relativizeSegment from \"./relativizeSegment\";\nimport roundSegment from \"./roundSegment\";\n\n/**\n * Optimizes a `pathArray` object:\n * * convert segments to shorthand if possible\n * * select shortest segments from absolute and relative `pathArray`s\n *\n * @param pathInput a string or `pathArray`\n * @param roundOption the amount of decimals to round values to\n * @returns the optimized `pathArray`\n */\nconst optimizePath = (pathInput: PathArray, roundOption?: number) => {\n const path = pathToAbsolute(pathInput);\n // allow for ZERO decimals or use an aggressive value of 2\n const round = typeof roundOption === \"number\" && roundOption >= 0\n ? roundOption\n : /* istanbul ignore next @preserve */ 2;\n // this utility overrides the iterator params\n const optimParams = { ...paramsParser };\n\n const allPathCommands = [] as PathCommand[];\n let pathCommand = \"M\" as PathCommand;\n let prevCommand = \"Z\" as PathCommand;\n\n return iterate(path, (seg, i, lastX, lastY) => {\n optimParams.x = lastX;\n optimParams.y = lastY;\n const normalizedSegment = normalizeSegment(seg, optimParams);\n let result = seg;\n [pathCommand] = seg;\n\n // Save current path command\n allPathCommands[i] = pathCommand;\n if (i) {\n // Get previous path command for `shortenSegment`\n prevCommand = allPathCommands[i - 1];\n const shortSegment = shortenSegment(\n seg as AbsoluteSegment,\n normalizedSegment,\n optimParams,\n prevCommand,\n );\n const absSegment = roundSegment(shortSegment, round);\n const absString = absSegment.join(\"\");\n const relativeSegment = relativizeSegment(shortSegment, i, lastX, lastY);\n const relSegment = roundSegment(relativeSegment, round);\n const relString = relSegment.join(\"\");\n result = absString.length < relString.length ? absSegment : relSegment;\n }\n\n const seglen = normalizedSegment.length;\n optimParams.x1 = +normalizedSegment[seglen - 2];\n optimParams.y1 = +normalizedSegment[seglen - 1];\n optimParams.x2 = +normalizedSegment[seglen - 4] || optimParams.x1;\n optimParams.y2 = +normalizedSegment[seglen - 3] || optimParams.y1;\n\n return result;\n });\n};\n\nexport default optimizePath;\n","import CSSMatrix from \"@thednp/dommatrix\";\nimport { type PointTuple } from \"../types\";\n\n/**\n * Transforms a specified point using a matrix, returning a new\n * Tuple *Object* comprising of the transformed point.\n * Neither the matrix nor the original point are altered.\n *\n * @copyright thednp © 2021\n *\n * @param cssm CSSMatrix instance\n * @param v Tuple\n * @return the resulting Tuple\n */\nconst translatePoint = (\n cssm: CSSMatrix,\n v: [number, number, number, number],\n): [number, number, number, number] => {\n let m = CSSMatrix.Translate(v[0], v[1], v[2]);\n\n [, , , m.m44] = v;\n m = cssm.multiply(m);\n\n return [m.m41, m.m42, m.m43, m.m44];\n};\n\n/**\n * Returns the [x,y] projected coordinates for a given an [x,y] point\n * and an [x,y,z] perspective origin point.\n *\n * Equation found here =>\n * http://en.wikipedia.org/wiki/3D_projection#Diagram\n * Details =>\n * https://stackoverflow.com/questions/23792505/predicted-rendering-of-css-3d-transformed-pixel\n *\n * @param m the transformation matrix\n * @param point2D the initial [x,y] coordinates\n * @param origin the [x,y,z] transform origin\n * @returns the projected [x,y] coordinates\n */\nconst projection2d = (\n m: CSSMatrix,\n point2D: PointTuple,\n origin: [number, number, number],\n): PointTuple => {\n const [originX, originY, originZ] = origin;\n const [x, y, z] = translatePoint(m, [point2D[0], point2D[1], 0, 1]);\n\n const relativePositionX = x - originX;\n const relativePositionY = y - originY;\n const relativePositionZ = z - originZ;\n\n return [\n // protect against division by ZERO\n relativePositionX * (Math.abs(originZ) / Math.abs(relativePositionZ) || 1) +\n originX,\n relativePositionY * (Math.abs(originZ) / Math.abs(relativePositionZ) || 1) +\n originY,\n ];\n};\nexport default projection2d;\n","import type { CSegment, CurveArray, MSegment, PathCommand } from \"../types\";\n\n/**\n * Reverses all segments of a `pathArray`\n * which consists of only C (cubic-bezier) path commands.\n *\n * @param path the source `pathArray`\n * @returns the reversed `pathArray`\n */\nconst reverseCurve = (path: CurveArray) => {\n const rotatedCurve = path\n .slice(1)\n .map((x, i, curveOnly) =>\n !i\n ? path[0].slice(1).concat(x.slice(1) as number[])\n : curveOnly[i - 1].slice(-2).concat(x.slice(1))\n )\n .map((x) => x.map((_, i) => x[x.length - i - 2 * (1 - (i % 2))]))\n .reverse() as (MSegment | CSegment)[];\n\n return [[\"M\" as PathCommand | number].concat(rotatedCurve[0].slice(0, 2))]\n .concat(\n rotatedCurve.map((x) => [\"C\" as PathCommand | number].concat(x.slice(2))),\n ) as CurveArray;\n};\n\nexport default reverseCurve;\n","import type {\n ASegment,\n CSegment,\n HSegment,\n MSegment,\n PathArray,\n PathSegment,\n PointTuple,\n QSegment,\n SSegment,\n TSegment,\n VSegment,\n} from \"../types\";\nimport pathToAbsolute from \"../convert/pathToAbsolute\";\nimport normalizePath from \"./normalizePath\";\nimport iterate from \"./iterate\";\n\n/**\n * Reverses all segments of a `pathArray` and returns a new `pathArray` instance\n * with absolute values.\n *\n * @param pathInput the source `pathArray`\n * @returns the reversed `pathArray`\n */\nconst reversePath = (pathInput: PathArray) => {\n const absolutePath = pathToAbsolute(pathInput);\n const normalizedPath = normalizePath(absolutePath);\n const pLen = absolutePath.length;\n const isClosed = absolutePath[pLen - 1][0] === \"Z\";\n\n const reversedPath = iterate(absolutePath, (segment, i) => {\n const normalizedSegment = normalizedPath[i];\n const prevSeg = i && absolutePath[i - 1];\n const prevCommand = prevSeg && prevSeg[0];\n const nextSeg = absolutePath[i + 1];\n const nextCommand = nextSeg && nextSeg[0];\n const [pathCommand] = segment;\n const [x, y] = normalizedPath[i ? i - 1 : pLen - 1].slice(-2) as PointTuple;\n let result = segment;\n\n switch (pathCommand) {\n case \"M\":\n result = (isClosed ? [\"Z\"] : [pathCommand, x, y]) as PathSegment;\n break;\n case \"A\":\n result = [\n pathCommand,\n segment[1],\n segment[2],\n segment[3],\n segment[4],\n segment[5] === 1 ? 0 : 1,\n x,\n y,\n ] as ASegment;\n break;\n case \"C\":\n if (nextSeg && nextCommand === \"S\") {\n result = [\"S\", segment[1], segment[2], x, y] as SSegment;\n } else {\n result = [\n pathCommand,\n segment[3],\n segment[4],\n segment[1],\n segment[2],\n x,\n y,\n ] as CSegment;\n }\n break;\n case \"S\":\n if (\n prevCommand && \"CS\".includes(prevCommand) &&\n (!nextSeg || nextCommand !== \"S\")\n ) {\n result = [\n \"C\",\n normalizedSegment[3],\n normalizedSegment[4],\n normalizedSegment[1],\n normalizedSegment[2],\n x,\n y,\n ] as CSegment;\n } else {\n result = [\n pathCommand,\n normalizedSegment[1],\n normalizedSegment[2],\n x,\n y,\n ] as SSegment;\n }\n break;\n case \"Q\":\n if (nextSeg && nextCommand === \"T\") {\n result = [\"T\", x, y] as TSegment;\n } else {\n result = [pathCommand, segment[1], segment[2], x, y] as QSegment;\n }\n break;\n case \"T\":\n if (\n prevCommand && \"QT\".includes(prevCommand) &&\n (!nextSeg || nextCommand !== \"T\")\n ) {\n result = [\n \"Q\",\n normalizedSegment[1],\n normalizedSegment[2],\n x,\n y,\n ] as QSegment;\n } else {\n result = [pathCommand, x, y] as TSegment;\n }\n break;\n case \"Z\":\n result = [\"M\", x, y] as MSegment;\n break;\n case \"H\":\n result = [pathCommand, x] as HSegment;\n break;\n case \"V\":\n result = [pathCommand, y] as VSegment;\n break;\n default:\n result = [pathCommand as typeof pathCommand | number].concat(\n segment.slice(1, -2),\n x,\n y,\n ) as PathSegment;\n }\n\n return result;\n });\n\n return (\n isClosed\n ? reversedPath.reverse()\n : [reversedPath[0] as PathSegment].concat(reversedPath.slice(1).reverse())\n ) as PathArray;\n};\n\nexport default reversePath;\n","import type { PathArray } from \"../types\";\nimport defaultOptions from \"../options/options\";\nimport iterate from \"./iterate\";\nimport roundSegment from \"./roundSegment\";\n\n/**\n * Rounds the values of a `pathArray` instance to\n * a specified amount of decimals and returns it.\n *\n * @param path the source `pathArray`\n * @param roundOption the amount of decimals to round numbers to\n * @returns the resulted `pathArray` with rounded values\n */\nconst roundPath = (path: PathArray, roundOption?: number | \"off\") => {\n let { round } = defaultOptions;\n // allow for ZERO decimals\n round = roundOption === \"off\"\n ? roundOption\n : typeof roundOption === \"number\" && roundOption >= 0\n ? roundOption\n : typeof round === \"number\" && round >= 0\n ? round\n : /* istanbul ignore next @preserve */ \"off\";\n\n /* istanbul ignore else @preserve */\n if (round === \"off\") return path.slice(0) as PathArray;\n\n return iterate(path, (segment) => {\n return roundSegment(segment, round);\n });\n};\nexport default roundPath;\n","import midPoint from \"../math/midPoint\";\nimport type { CubicSegment, PointTuple } from \"../types\";\n\n/**\n * Split a cubic-bezier segment into two.\n *\n * @param pts the cubic-bezier parameters\n * @param ratio the cubic-bezier parameters\n * @return two new cubic-bezier segments\n */\nconst splitCubic = (\n pts: number[],\n ratio = 0.5,\n): [CubicSegment, CubicSegment] => {\n const t = ratio;\n const p0 = pts.slice(0, 2) as PointTuple;\n const p1 = pts.slice(2, 4) as PointTuple;\n const p2 = pts.slice(4, 6) as PointTuple;\n const p3 = pts.slice(6, 8) as PointTuple;\n const p4 = midPoint(p0, p1, t);\n const p5 = midPoint(p1, p2, t);\n const p6 = midPoint(p2, p3, t);\n const p7 = midPoint(p4, p5, t);\n const p8 = midPoint(p5, p6, t);\n const p9 = midPoint(p7, p8, t);\n\n return [\n [\"C\", p4[0], p4[1], p7[0], p7[1], p9[0], p9[1]],\n [\"C\", p8[0], p8[1], p6[0], p6[1], p3[0], p3[1]],\n ];\n};\nexport default splitCubic;\n","import paramsParser from \"../parser/paramsParser\";\nimport type {\n AbsoluteCommand,\n HSegment,\n MSegment,\n PathArray,\n PointTuple,\n RelativeCommand,\n VSegment,\n} from \"../types\";\n\n/**\n * Split a path into an `Array` of sub-path strings.\n *\n * In the process, values are converted to absolute\n * for visual consistency.\n *\n * @param pathInput the source `pathArray`\n * @return an array with all sub-path strings\n */\nconst splitPath = (pathInput: PathArray): PathArray[] => {\n const composite = [] as PathArray[];\n let path: PathArray;\n let pi = -1;\n let x = 0;\n let y = 0;\n let mx = 0;\n let my = 0;\n const params = { ...paramsParser };\n\n pathInput.forEach((seg) => {\n const [pathCommand] = seg;\n const absCommand = pathCommand.toUpperCase() as AbsoluteCommand;\n const relCommand = pathCommand.toLowerCase() as RelativeCommand;\n const isRelative = pathCommand === relCommand;\n const values = seg.slice(1) as number[];\n\n if (absCommand === \"M\") {\n pi += 1;\n [x, y] = values as PointTuple;\n x += isRelative ? params.x : 0;\n y += isRelative ? params.y : 0;\n mx = x;\n my = y;\n path = [(isRelative ? [absCommand, mx, my] : seg) as MSegment];\n } else {\n if (absCommand === \"Z\") {\n x = mx;\n y = my;\n } else if (absCommand === \"H\") {\n [, x] = seg as HSegment;\n x += isRelative ? params.x : /* istanbul ignore next @preserve */ 0;\n } else if (absCommand === \"V\") {\n [, y] = seg as VSegment;\n y += isRelative ? params.y : /* istanbul ignore next @preserve */ 0;\n } else {\n [x, y] = seg.slice(-2) as PointTuple;\n x += isRelative ? params.x : 0;\n y += isRelative ? params.y : 0;\n }\n path.push(seg);\n }\n\n params.x = x;\n params.y = y;\n composite[pi] = path;\n });\n\n return composite;\n};\nexport default splitPath;\n","import getSVGMatrix from \"./getSVGMatrix\";\nimport projection2d from \"./projection2d\";\nimport defaultOptions from \"../options/options\";\nimport type {\n AbsoluteArray,\n AbsoluteSegment,\n CSegment,\n LSegment,\n PathArray,\n TransformObjectValues,\n} from \"../types\";\nimport type { TransformObject } from \"../interface\";\nimport iterate from \"./iterate\";\nimport parsePathString from \"../parser/parsePathString\";\nimport absolutizeSegment from \"./absolutizeSegment\";\nimport arcToCubic from \"./arcToCubic\";\n\n/**\n * Apply a 2D / 3D transformation to a `pathArray` instance.\n *\n * Since *SVGElement* doesn't support 3D transformation, this function\n * creates a 2D projection of the element.\n *\n * @param path the `pathArray` to apply transformation\n * @param transform the transform functions `Object`\n * @returns the resulted `pathArray`\n */\nconst transformPath = (\n pathInput: PathArray | string,\n transform?: Partial,\n) => {\n // last x and y transformed values\n let x = 0;\n let y = 0;\n // new x and y transformed\n let lx = 0;\n let ly = 0;\n // segment params iteration index and length\n let j = 0;\n let jj = 0;\n let pathCommand = \"M\";\n // transform uses it's own set of params\n const path = parsePathString(pathInput);\n const transformProps = transform && Object.keys(transform);\n\n // when used as a static method, invalidate somehow\n if (!transform || (transformProps && !transformProps.length)) {\n return path.slice(0) as typeof path;\n }\n\n // transform origin is extremely important\n if (!transform.origin) {\n Object.assign(transform, { origin: defaultOptions.origin });\n }\n const origin = transform.origin as [number, number, number];\n const matrixInstance = getSVGMatrix(transform as TransformObjectValues);\n\n if (matrixInstance.isIdentity) return path.slice(0) as typeof path;\n\n return iterate(path, (seg, index, lastX, lastY) => {\n [pathCommand] = seg;\n const absCommand = pathCommand.toUpperCase();\n const isRelative = absCommand !== pathCommand;\n const absoluteSegment = isRelative\n ? absolutizeSegment(seg, index, lastX, lastY)\n : (seg.slice(0) as AbsoluteSegment);\n\n let result = absCommand === \"A\"\n // ? segmentToCubic(absoluteSegment, transformParams)\n ? ([\"C\" as string | number].concat(\n arcToCubic(\n lastX,\n lastY,\n absoluteSegment[1] as number,\n absoluteSegment[2] as number,\n absoluteSegment[3] as number,\n absoluteSegment[4] as number,\n absoluteSegment[5] as number,\n absoluteSegment[6] as number,\n absoluteSegment[7] as number,\n ),\n ) as CSegment)\n : absCommand === \"V\"\n ? ([\"L\", lastX, absoluteSegment[1]] as LSegment)\n : absCommand === \"H\"\n ? ([\"L\", absoluteSegment[1], lastY] as LSegment)\n : absoluteSegment;\n\n // update pathCommand\n pathCommand = result[0];\n const isLongArc = pathCommand === \"C\" && result.length > 7;\n const tempSegment =\n (isLongArc ? result.slice(0, 7) : result.slice(0)) as AbsoluteSegment;\n\n if (isLongArc) {\n path.splice(\n index + 1,\n 0,\n [\"C\" as typeof pathCommand | number].concat(\n result.slice(7),\n ) as CSegment,\n );\n result = tempSegment as CSegment;\n }\n\n if (pathCommand === \"L\") {\n [lx, ly] = projection2d(matrixInstance, [\n (result as LSegment)[1],\n (result as LSegment)[2],\n ], origin);\n\n /* istanbul ignore else @preserve */\n if (x !== lx && y !== ly) {\n result = [\"L\", lx, ly];\n } else if (y === ly) {\n result = [\"H\", lx];\n } else if (x === lx) {\n result = [\"V\", ly];\n }\n } else {\n for (j = 1, jj = result.length; j < jj; j += 2) {\n [lx, ly] = projection2d(\n matrixInstance,\n [+result[j], +result[j + 1]],\n origin,\n );\n result[j] = lx;\n result[j + 1] = ly;\n }\n }\n // now update x and y\n x = lx;\n y = ly;\n\n return result;\n });\n};\n\nexport default transformPath;\n"],"names":["Z","z","s","t","e","p","$","E","P","y","g","n","i","r","a","m","h","c","u","w","o","d","A","M","b","X","O","x","Y","F","T","k","I","v","R","D","N","midPoint","ax","ay","bx","by","distanceSquareRoot","getLineLength","x1","y1","x2","y2","getPointAtLineLength","distance","point","length","getLineBBox","min","max","arcLength","rx","ry","theta","halfTheta","sinHalfTheta","cosHalfTheta","term1","term2","arcPoint","cx","cy","alpha","sin","cos","cosA","sinA","angleBetween","v0","v1","v0x","v0y","v1x","v1y","getArcProps","RX","RY","angle","LAF","SF","abs","sqrt","PI","xRotRad","dx","dy","transformedPoint","radiiCheck","cSquareNumerator","cSquareRootDenom","cRadicand","cCoef","transformedCenter","center","startVector","startAngle","endVector","sweepAngle","endAngle","getArcLength","getPointAtArcLength","ellipseComponentX","ellipseComponentY","getArcBBox","deltaAngle","tan","atan2","tangent","angle1","angle2","angle3","angle4","xArray","yArray","xMin","xMax","yMin","yMax","angleAfterStart","pP2","angleBeforeEnd","pP3","p1","p2","p4","p3","Tvalues","Cvalues","deriveBezier","points","dpoints","list","j","computeBezier","order","mt","mt2","t2","calculateBezier","derivativeFn","l","bezierLength","len","sum","getBezierLength","curve","idx","step","CBEZIER_MINMAX_EPSILON","minmaxQ","cp","v2","minmaxC","cp1","cp2","K","S","L","Q","getPointAtCubicSegmentLength","c1x","c1y","c2x","c2y","t1","getCubicLength","getPointAtCubicLength","distanceIsNumber","currentLength","getCubicBBox","cxMinMax","cyMinMax","getPointAtQuadSegmentLength","getQuadLength","getPointAtQuadLength","getQuadBBox","polygonArea","polygon","area","polygonLength","paramsCount","finalizeSegment","path","pathCommand","relativeCommand","data","error","scanFlag","index","pathValue","code","isDigit","invalidPathValue","scanParam","start","zeroFirst","hasCeiling","hasDecimal","hasDot","ch","isSpace","skipSpaces","isPathCommand","isDigitStart","isArcCommand","isMoveCommand","scanSegment","_a","segments","cmdCode","reqParams","paramCounts","lastSegment","PathParser","pathString","parsePathString","pathInput","absolutizeSegment","segment","lastX","lastY","absCommand","absValues","seglen","iterate","iterator","pathLen","isRelative","mx","my","segLen","iteratorResult","pathToAbsolute","relativizeSegment","relCommand","relValues","pathToRelative","rotateVector","rad","arcToCubic","X1","Y1","X2","Y2","recursive","d120","res","xy","f1","f2","rx2","ry2","df","f2old","x2old","y2old","c1","s1","c2","s2","hx","hy","m1","m2","m3","m4","newres","ii","quadToCubic","qx","qy","r13","r23","lineToCubic","segmentToCubic","params","values","px1","py1","px","py","normalizeSegment","px2","py2","nqx","nqy","paramsParser","pathToCurve","seg","normalSegment","result","defaultOptions","roundTo","round","pow","pathToString","roundOption","valLen","DISTANCE_EPSILON","normalizePath","_","getPointAtLength","isM","POINT","totalLength","getTotalLength","paramX1","paramY1","paramX2","paramY2","paramQX","paramQY","absoluteSegment","cp1x","cp1y","getPropertiesAtLength","pathArray","pathTemp","pathLength","lengthAtSegment","getPropertiesAtPoint","normalPath","distanceTo","precision","scan","closest","scanDistance","bestLength","bestDistance","scanLength","before","after","beforeLength","afterLength","beforeDistance","afterDistance","getClosestPoint","getCubicSegArea","getPathArea","getDrawDirection","getPathBBox","minX","minY","maxX","maxY","width","height","getSegmentAtLength","getSegmentOfPoint","isPathArray","lk","isAbsoluteArray","isNormalizedArray","pc","isCurveArray","isPointInStroke","isRelativeArray","isValidPath","shapeParams","isElement","node","getLinePath","attr","getPolyPath","getCirclePath","getEllipsePath","getRectanglePath","shapeToPathArray","element","supportedShapes","targetIsElement","tagName","type","shapeAttrs","config","shapeToPath","replace","ownerDocument","doc","description","name","value","getSVGMatrix","transform","matrix","CSSMatrix","origin","originX","originY","translate","rotate","skew","scale","shortenSegment","prevCommand","defaultRound","normalValues","nx","ny","nx1","ny1","roundSegment","optimizePath","optimParams","allPathCommands","normalizedSegment","shortSegment","absSegment","absString","relativeSegment","relSegment","relString","translatePoint","cssm","projection2d","point2D","originZ","relativePositionX","relativePositionY","relativePositionZ","reverseCurve","rotatedCurve","curveOnly","reversePath","absolutePath","normalizedPath","pLen","isClosed","reversedPath","prevSeg","nextSeg","nextCommand","roundPath","splitCubic","pts","ratio","p0","p5","p6","p7","p8","p9","splitPath","composite","pi","transformPath","lx","ly","jj","transformProps","matrixInstance","isLongArc","tempSegment"],"mappings":"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","x_google_ignoreList":[0]} \ No newline at end of file +{"version":3,"sources":["../../src/util.ts","../../src/math/arcTools.ts","../../src/math/lineTools.ts","../../src/math/midPoint.ts","../../src/math/distanceSquareRoot.ts","../../src/math/bezier.ts","../../src/math/cubicTools.ts","../../src/math/quadTools.ts","../../src/math/polygonTools.ts","../../src/parser/paramsCount.ts","../../src/parser/finalizeSegment.ts","../../src/parser/error.ts","../../src/parser/scanFlag.ts","../../src/parser/isDigit.ts","../../src/parser/invalidPathValue.ts","../../src/parser/scanParam.ts","../../src/parser/isSpace.ts","../../src/parser/skipSpaces.ts","../../src/parser/isPathCommand.ts","../../src/parser/isDigitStart.ts","../../src/parser/isArcCommand.ts","../../src/parser/isMoveCommand.ts","../../src/parser/scanSegment.ts","../../src/parser/pathParser.ts","../../src/parser/parsePathString.ts","../../src/process/absolutizeSegment.ts","../../src/process/iterate.ts","../../src/convert/pathToAbsolute.ts","../../src/process/relativizeSegment.ts","../../src/convert/pathToRelative.ts","../../src/math/rotateVector.ts","../../src/process/arcToCubic.ts","../../src/process/quadToCubic.ts","../../src/process/lineToCubic.ts","../../src/process/segmentToCubic.ts","../../src/process/normalizeSegment.ts","../../src/parser/paramsParser.ts","../../src/convert/pathToCurve.ts","../../src/options/options.ts","../../src/math/roundTo.ts","../../src/convert/pathToString.ts","../../src/util/distanceEpsilon.ts","../../src/process/normalizePath.ts","../../src/util/getPointAtLength.ts","../../src/util/getTotalLength.ts","../../src/util/getPropertiesAtLength.ts","../../src/util/getPropertiesAtPoint.ts","../../src/util/getClosestPoint.ts","../../src/util/getPathArea.ts","../../src/util/getDrawDirection.ts","../../src/util/getPathBBox.ts","../../src/util/getSegmentAtLength.ts","../../src/util/getSegmentOfPoint.ts","../../src/util/isPathArray.ts","../../src/util/isAbsoluteArray.ts","../../src/util/isNormalizedArray.ts","../../src/util/isCurveArray.ts","../../src/util/isPointInStroke.ts","../../src/util/isRelativeArray.ts","../../src/util/isValidPath.ts","../../src/util/shapeParams.ts","../../src/util/isElement.ts","../../src/util/shapeToPathArray.ts","../../src/util/shapeToPath.ts","../../src/process/getSVGMatrix.ts","../../src/process/shortenSegment.ts","../../src/process/roundSegment.ts","../../src/process/optimizePath.ts","../../src/process/projection2d.ts","../../src/process/reverseCurve.ts","../../src/process/reversePath.ts","../../src/process/roundPath.ts","../../src/process/splitCubic.ts","../../src/process/splitPath.ts","../../src/process/transformPath.ts"],"sourcesContent":["export { default as CSSMatrix } from \"@thednp/dommatrix\";\n// export type { PathArray, PointTuple, TransformObjectValues } from \"./types\";\n// export type { Options, TransformEntries, TransformObject } from \"./interface\";\n// export * from \"./types\";\n// export * from \"./interface\";\n\nimport * as arcTools from \"./math/arcTools\";\nimport * as bezierTools from \"./math/bezier\";\nimport * as cubicTools from \"./math/cubicTools\";\nimport * as lineTools from \"./math/lineTools\";\nimport * as quadTools from \"./math/quadTools\";\nimport * as polygonTools from \"./math/polygonTools\";\nexport { arcTools, bezierTools, cubicTools, lineTools, quadTools, polygonTools };\n\n// export * from \"./math/arcTools\";\n// export * from \"./math/bezier\";\n// export * from \"./math/cubicTools\";\n// export * from \"./math/lineTools\";\n// export * from \"./math/quadTools\";\n// export * from \"./math/polygonTools\";\n\nexport { default as pathToAbsolute } from \"./convert/pathToAbsolute\";\nexport { default as pathToRelative } from \"./convert/pathToRelative\";\nexport { default as pathToCurve } from \"./convert/pathToCurve\";\nexport { default as pathToString } from \"./convert/pathToString\";\n\nexport { default as distanceSquareRoot } from \"./math/distanceSquareRoot\";\nexport { default as midPoint } from \"./math/midPoint\";\nexport { default as rotateVector } from \"./math/rotateVector\";\nexport { default as roundTo } from \"./math/roundTo\";\n\nexport { default as parsePathString } from \"./parser/parsePathString\";\nexport { default as finalizeSegment } from \"./parser/finalizeSegment\";\nexport { default as invalidPathValue } from \"./parser/invalidPathValue\";\nexport { default as isArcCommand } from \"./parser/isArcCommand\";\nexport { default as isDigit } from \"./parser/isDigit\";\nexport { default as isDigitStart } from \"./parser/isDigitStart\";\nexport { default as isMoveCommand } from \"./parser/isMoveCommand\";\nexport { default as isPathCommand } from \"./parser/isPathCommand\";\nexport { default as isSpace } from \"./parser/isSpace\";\nexport { default as paramsCount } from \"./parser/paramsCount\";\nexport { default as paramsParser } from \"./parser/paramsParser\";\nexport { default as pathParser } from \"./parser/pathParser\";\nexport { default as scanFlag } from \"./parser/scanFlag\";\nexport { default as scanParam } from \"./parser/scanParam\";\nexport { default as scanSegment } from \"./parser/scanSegment\";\nexport { default as skipSpaces } from \"./parser/skipSpaces\";\n\nexport { default as distanceEpsilon } from \"./util/distanceEpsilon\";\nexport { default as getClosestPoint } from \"./util/getClosestPoint\";\nexport { default as getDrawDirection } from \"./util/getDrawDirection\";\nexport { default as getPathArea } from \"./util/getPathArea\";\nexport { default as getPathBBox } from \"./util/getPathBBox\";\nexport { default as getPointAtLength } from \"./util/getPointAtLength\";\nexport { default as getPropertiesAtLength } from \"./util/getPropertiesAtLength\";\nexport { default as getPropertiesAtPoint } from \"./util/getPropertiesAtPoint\";\nexport { default as getSegmentAtLength } from \"./util/getSegmentAtLength\";\nexport { default as getSegmentOfPoint } from \"./util/getSegmentOfPoint\";\nexport { default as getTotalLength } from \"./util/getTotalLength\";\n\nexport { default as isAbsoluteArray } from \"./util/isAbsoluteArray\";\nexport { default as isCurveArray } from \"./util/isCurveArray\";\nexport { default as isNormalizedArray } from \"./util/isNormalizedArray\";\nexport { default as isPathArray } from \"./util/isPathArray\";\nexport { default as isPointInStroke } from \"./util/isPointInStroke\";\nexport { default as isRelativeArray } from \"./util/isRelativeArray\";\nexport { default as isValidPath } from \"./util/isValidPath\";\nexport { default as shapeParams } from \"./util/shapeParams\";\nexport { default as shapeToPath } from \"./util/shapeToPath\";\nexport { default as shapeToPathArray } from \"./util/shapeToPathArray\";\n\nexport { default as absolutizeSegment } from \"./process/absolutizeSegment\";\nexport { default as arcToCubic } from \"./process/arcToCubic\";\nexport { default as getSVGMatrix } from \"./process/getSVGMatrix\";\nexport { default as iterate } from \"./process/iterate\";\nexport { default as lineToCubic } from \"./process/lineToCubic\";\nexport { default as normalizePath } from \"./process/normalizePath\";\nexport { default as normalizeSegment } from \"./process/normalizeSegment\";\nexport { default as optimizePath } from \"./process/optimizePath\";\nexport { default as projection2d } from \"./process/projection2d\";\nexport { default as quadToCubic } from \"./process/quadToCubic\";\nexport { default as relativizeSegment } from \"./process/relativizeSegment\";\nexport { default as reverseCurve } from \"./process/reverseCurve\";\nexport { default as reversePath } from \"./process/reversePath\";\nexport { default as roundPath } from \"./process/roundPath\";\nexport { default as roundSegment } from \"./process/roundSegment\";\nexport { default as segmentToCubic } from \"./process/segmentToCubic\";\nexport { default as shortenSegment } from \"./process/shortenSegment\";\nexport { default as splitCubic } from \"./process/splitCubic\";\nexport { default as splitPath } from \"./process/splitPath\";\nexport { default as transformPath } from \"./process/transformPath\";\n","import { getPointAtLineLength } from \"./lineTools\";\nimport type { Point, PointTuple } from \"../types\";\n\n/**\n * Returns the Arc segment length.\n * @param rx radius along X axis\n * @param ry radius along Y axis\n * @param theta the angle in radians\n * @returns the arc length\n */\nconst arcLength = (rx: number, ry: number, theta: number) => {\n const halfTheta = theta / 2;\n const sinHalfTheta = Math.sin(halfTheta);\n const cosHalfTheta = Math.cos(halfTheta);\n const term1 = rx ** 2 * sinHalfTheta ** 2;\n const term2 = ry ** 2 * cosHalfTheta ** 2;\n const length = Math.sqrt(term1 + term2) * theta;\n return Math.abs(length);\n};\n\n/**\n * Find point on ellipse at given angle around ellipse (theta);\n * @param cx the center X\n * @param cy the center Y\n * @param rx the radius X\n * @param ry the radius Y\n * @param alpha the arc rotation angle in radians\n * @param theta the arc sweep angle in radians\n * @returns a point around ellipse at given angle\n */\nconst arcPoint = (\n cx: number,\n cy: number,\n rx: number,\n ry: number,\n alpha: number,\n theta: number,\n) => {\n const { sin, cos } = Math;\n // theta is angle in radians around arc\n // alpha is angle of rotation of ellipse in radians\n const cosA = cos(alpha);\n const sinA = sin(alpha);\n const x = rx * cos(theta);\n const y = ry * sin(theta);\n\n return [cx + cosA * x - sinA * y, cy + sinA * x + cosA * y] as PointTuple;\n};\n\n/**\n * Returns the angle between two points.\n * @param v0 starting point\n * @param v1 ending point\n * @returns the angle in radian\n */\nconst angleBetween = (v0: Point, v1: Point) => {\n const { x: v0x, y: v0y } = v0;\n const { x: v1x, y: v1y } = v1;\n const p = v0x * v1x + v0y * v1y;\n const n = Math.sqrt((v0x ** 2 + v0y ** 2) * (v1x ** 2 + v1y ** 2));\n const sign = v0x * v1y - v0y * v1x < 0 ? -1 : 1;\n return sign * Math.acos(p / n);\n};\n\n/**\n * Returns the following properties for an Arc segment: center, start angle,\n * end angle, and radiuses on X and Y axis.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param RX the radius on X axis\n * @param RY the radius on Y axis\n * @param angle the ellipse rotation in degrees\n * @param LAF the large arc flag\n * @param SF the sweep flag\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns properties specific to Arc segments\n */\nconst getArcProps = (\n x1: number,\n y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n x: number,\n y: number,\n) => {\n const { abs, sin, cos, sqrt, PI } = Math;\n let rx = abs(RX);\n let ry = abs(RY);\n const xRot = ((angle % 360) + 360) % 360;\n const xRotRad = xRot * (PI / 180);\n\n // istanbul ignore next @preserve\n if (x1 === x && y1 === y) {\n return {\n rx,\n ry,\n startAngle: 0,\n endAngle: 0,\n center: { x, y },\n };\n }\n\n if (rx === 0 || ry === 0) {\n return {\n rx,\n ry,\n startAngle: 0,\n endAngle: 0,\n center: { x: (x + x1) / 2, y: (y + y1) / 2 },\n };\n }\n\n const dx = (x1 - x) / 2;\n const dy = (y1 - y) / 2;\n\n const transformedPoint = {\n x: cos(xRotRad) * dx + sin(xRotRad) * dy,\n y: -sin(xRotRad) * dx + cos(xRotRad) * dy,\n };\n\n const radiiCheck = transformedPoint.x ** 2 / rx ** 2 +\n transformedPoint.y ** 2 / ry ** 2;\n\n if (radiiCheck > 1) {\n rx *= sqrt(radiiCheck);\n ry *= sqrt(radiiCheck);\n }\n\n const cSquareNumerator = rx ** 2 * ry ** 2 -\n rx ** 2 * transformedPoint.y ** 2 - ry ** 2 * transformedPoint.x ** 2;\n const cSquareRootDenom = rx ** 2 * transformedPoint.y ** 2 +\n ry ** 2 * transformedPoint.x ** 2;\n\n let cRadicand = cSquareNumerator / cSquareRootDenom;\n /* istanbul ignore next @preserve */\n cRadicand = cRadicand < 0 ? 0 : cRadicand;\n const cCoef = (LAF !== SF ? 1 : -1) * sqrt(cRadicand);\n const transformedCenter = {\n x: cCoef * ((rx * transformedPoint.y) / ry),\n y: cCoef * (-(ry * transformedPoint.x) / rx),\n };\n\n const center = {\n x: cos(xRotRad) * transformedCenter.x - sin(xRotRad) * transformedCenter.y +\n (x1 + x) / 2,\n y: sin(xRotRad) * transformedCenter.x + cos(xRotRad) * transformedCenter.y +\n (y1 + y) / 2,\n };\n\n const startVector = {\n x: (transformedPoint.x - transformedCenter.x) / rx,\n y: (transformedPoint.y - transformedCenter.y) / ry,\n };\n\n const startAngle = angleBetween({ x: 1, y: 0 }, startVector);\n\n const endVector = {\n x: (-transformedPoint.x - transformedCenter.x) / rx,\n y: (-transformedPoint.y - transformedCenter.y) / ry,\n };\n\n let sweepAngle = angleBetween(startVector, endVector);\n if (!SF && sweepAngle > 0) {\n sweepAngle -= 2 * PI;\n } else if (SF && sweepAngle < 0) {\n sweepAngle += 2 * PI;\n }\n sweepAngle %= 2 * PI;\n\n const endAngle = startAngle + sweepAngle;\n\n // point.ellipticalArcStartAngle = startAngle;\n // point.ellipticalArcEndAngle = startAngle + sweepAngle;\n // point.ellipticalArcAngle = alpha;\n\n // point.ellipticalArcCenter = center;\n // point.resultantRx = rx;\n // point.resultantRy = ry;\n\n return {\n center,\n startAngle,\n endAngle,\n rx,\n ry,\n };\n};\n\n/**\n * Returns the length of an Arc segment.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the length of the Arc segment\n */\nconst getArcLength = (\n x1: number,\n y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n x: number,\n y: number,\n) => {\n const { rx, ry, startAngle, endAngle } = getArcProps(\n x1,\n y1,\n RX,\n RY,\n angle,\n LAF,\n SF,\n x,\n y,\n );\n return arcLength(rx, ry, endAngle - startAngle);\n};\n\n/**\n * Returns a point along an Arc segment at a given distance.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param RX the radius on X axis\n * @param RY the radius on Y axis\n * @param angle the ellipse rotation in degrees\n * @param LAF the large arc flag\n * @param SF the sweep flag\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance a [0-1] ratio\n * @returns a point along the Arc segment\n */\nconst getPointAtArcLength = (\n x1: number,\n y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n x: number,\n y: number,\n distance?: number,\n) => {\n let point = { x: x1, y: y1 };\n const { center, rx, ry, startAngle, endAngle } = getArcProps(\n x1,\n y1,\n RX,\n RY,\n angle,\n LAF,\n SF,\n x,\n y,\n );\n\n /* istanbul ignore else @preserve */\n if (typeof distance === \"number\") {\n const length = arcLength(rx, ry, endAngle - startAngle);\n if (distance <= 0) {\n point = { x: x1, y: y1 };\n } else if (distance >= length) {\n point = { x, y };\n } else {\n /* istanbul ignore next @preserve */\n if (x1 === x && y1 === y) {\n return { x, y };\n }\n /* istanbul ignore next @preserve */\n if (rx === 0 || ry === 0) {\n return getPointAtLineLength(x1, y1, x, y, distance);\n }\n const { PI, cos, sin } = Math;\n const sweepAngle = endAngle - startAngle;\n const xRot = ((angle % 360) + 360) % 360;\n const xRotRad = xRot * (PI / 180);\n const alpha = startAngle + sweepAngle * (distance / length);\n const ellipseComponentX = rx * cos(alpha);\n const ellipseComponentY = ry * sin(alpha);\n\n point = {\n x: cos(xRotRad) * ellipseComponentX - sin(xRotRad) * ellipseComponentY +\n center.x,\n y: sin(xRotRad) * ellipseComponentX + cos(xRotRad) * ellipseComponentY +\n center.y,\n };\n }\n }\n\n return point;\n};\n\n/**\n * Returns the extrema for an Arc segment in the following format:\n * [MIN_X, MIN_Y, MAX_X, MAX_Y]\n *\n * @see https://github.com/herrstrietzel/svg-pathdata-getbbox\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param RX the radius on X axis\n * @param RY the radius on Y axis\n * @param angle the ellipse rotation in degrees\n * @param LAF the large arc flag\n * @param SF the sweep flag\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the extrema of the Arc segment\n */\nconst getArcBBox = (\n x1: number,\n y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n x: number,\n y: number,\n) => {\n const { center, rx, ry, startAngle, endAngle } = getArcProps(\n x1,\n y1,\n RX,\n RY,\n angle,\n LAF,\n SF,\n x,\n y,\n );\n const deltaAngle = endAngle - startAngle;\n const { min, max, tan, atan2, PI } = Math;\n\n // circle/elipse center coordinates\n const { x: cx, y: cy } = center;\n\n // rotation to radians\n const alpha = (angle * PI) / 180;\n const tangent = tan(alpha);\n\n /**\n * find min/max from zeroes of directional derivative along x and y\n * along x axis\n */\n const theta = atan2(-ry * tangent, rx);\n const angle1 = theta;\n const angle2 = theta + PI;\n const angle3 = atan2(ry, rx * tangent);\n const angle4 = angle3 + PI;\n const xArray = [x];\n const yArray = [y];\n\n // inner bounding box\n let xMin = min(x1, x);\n let xMax = max(x1, x);\n let yMin = min(y1, y);\n let yMax = max(y1, y);\n\n // on path point close after start\n const angleAfterStart = endAngle - deltaAngle * 0.00001;\n const pP2 = arcPoint(cx, cy, rx, ry, alpha, angleAfterStart);\n\n // on path point close before end\n const angleBeforeEnd = endAngle - deltaAngle * 0.99999;\n const pP3 = arcPoint(cx, cy, rx, ry, alpha, angleBeforeEnd);\n\n /**\n * expected extremes\n * if leaving inner bounding box\n * (between segment start and end point)\n * otherwise exclude elliptic extreme points\n */\n\n // right\n if (pP2[0] > xMax || pP3[0] > xMax) {\n // get point for this theta\n const p1 = arcPoint(cx, cy, rx, ry, alpha, angle1);\n xArray.push(p1[0]);\n yArray.push(p1[1]);\n }\n\n // left\n if (pP2[0] < xMin || pP3[0] < xMin) {\n // get anti-symmetric point\n const p2 = arcPoint(cx, cy, rx, ry, alpha, angle2);\n xArray.push(p2[0]);\n yArray.push(p2[1]);\n }\n\n // top\n if (pP2[1] < yMin || pP3[1] < yMin) {\n // get anti-symmetric point\n const p4 = arcPoint(cx, cy, rx, ry, alpha, angle4);\n xArray.push(p4[0]);\n yArray.push(p4[1]);\n }\n\n // bottom\n if (pP2[1] > yMax || pP3[1] > yMax) {\n // get point for this theta\n const p3 = arcPoint(cx, cy, rx, ry, alpha, angle3);\n xArray.push(p3[0]);\n yArray.push(p3[1]);\n }\n\n xMin = min.apply([], xArray);\n yMin = min.apply([], yArray);\n xMax = max.apply([], xArray);\n yMax = max.apply([], yArray);\n\n return [xMin, yMin, xMax, yMax] as [number, number, number, number];\n};\n\nexport {\n angleBetween,\n arcLength,\n arcPoint,\n getArcBBox,\n getArcLength,\n getArcProps,\n getPointAtArcLength,\n};\n","import midPoint from \"./midPoint\";\nimport distanceSquareRoot from \"./distanceSquareRoot\";\n\n/**\n * Returns length for line segments (MoveTo, LineTo).\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the line segment length\n */\nconst getLineLength = (x1: number, y1: number, x2: number, y2: number) => {\n return distanceSquareRoot([x1, y1], [x2, y2]);\n};\n\n/**\n * Returns a point along the line segments (MoveTo, LineTo).\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance the distance to point in [0-1] range\n * @returns the point at length\n */\nconst getPointAtLineLength = (\n x1: number,\n y1: number,\n x2: number,\n y2: number,\n distance?: number,\n) => {\n let point = { x: x1, y: y1 };\n\n /* istanbul ignore else @preserve */\n if (typeof distance === \"number\") {\n const length = distanceSquareRoot([x1, y1], [x2, y2]);\n if (distance <= 0) {\n point = { x: x1, y: y1 };\n } else if (distance >= length) {\n point = { x: x2, y: y2 };\n } else {\n const [x, y] = midPoint([x1, y1], [x2, y2], distance / length);\n point = { x, y };\n }\n }\n return point;\n};\n\n/**\n * Returns bounding box for line segments (MoveTo, LineTo).\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance the distance to point in [0-1] range\n * @returns the extrema for line segments\n */\nconst getLineBBox = (x1: number, y1: number, x2: number, y2: number) => {\n const { min, max } = Math;\n\n return [min(x1, x2), min(y1, y2), max(x1, x2), max(y1, y2)] as [\n number,\n number,\n number,\n number,\n ];\n};\n\nexport { getLineBBox, getLineLength, getPointAtLineLength };\n","import { PointTuple } from \"../types\";\n\n/**\n * Returns the coordinates of a specified distance\n * ratio between two points.\n *\n * @param a the first point coordinates\n * @param b the second point coordinates\n * @param t the ratio\n * @returns the midpoint coordinates\n */\nconst midPoint = (a: PointTuple, b: PointTuple, t: number): PointTuple => {\n const [ax, ay] = a;\n const [bx, by] = b;\n return [ax + (bx - ax) * t, ay + (by - ay) * t];\n};\n\nexport default midPoint;\n","import { type PointTuple } from \"../types\";\n\n/**\n * Returns the square root of the distance\n * between two given points.\n *\n * @param a the first point coordinates\n * @param b the second point coordinates\n * @returns the distance value\n */\nconst distanceSquareRoot = (a: PointTuple, b: PointTuple) => {\n return Math.sqrt(\n (a[0] - b[0]) * (a[0] - b[0]) + (a[1] - b[1]) * (a[1] - b[1]),\n );\n};\n\nexport default distanceSquareRoot;\n","import type {\n CubicCoordinates,\n CubicPoints,\n DeriveCallback,\n DerivedCubicPoints,\n DerivedPoint,\n DerivedQuadPoints,\n PointTuple,\n QuadCoordinates,\n QuadPoints,\n} from \"../types\";\n\n/**\n * Tools from bezier.js by Mike 'Pomax' Kamermans\n * @see https://github.com/Pomax/bezierjs\n */\n\nconst Tvalues = [\n -0.0640568928626056260850430826247450385909,\n 0.0640568928626056260850430826247450385909,\n -0.1911188674736163091586398207570696318404,\n 0.1911188674736163091586398207570696318404,\n -0.3150426796961633743867932913198102407864,\n 0.3150426796961633743867932913198102407864,\n -0.4337935076260451384870842319133497124524,\n 0.4337935076260451384870842319133497124524,\n -0.5454214713888395356583756172183723700107,\n 0.5454214713888395356583756172183723700107,\n -0.6480936519369755692524957869107476266696,\n 0.6480936519369755692524957869107476266696,\n -0.7401241915785543642438281030999784255232,\n 0.7401241915785543642438281030999784255232,\n -0.8200019859739029219539498726697452080761,\n 0.8200019859739029219539498726697452080761,\n -0.8864155270044010342131543419821967550873,\n 0.8864155270044010342131543419821967550873,\n -0.9382745520027327585236490017087214496548,\n 0.9382745520027327585236490017087214496548,\n -0.9747285559713094981983919930081690617411,\n 0.9747285559713094981983919930081690617411,\n -0.9951872199970213601799974097007368118745,\n 0.9951872199970213601799974097007368118745,\n];\n\nconst Cvalues = [\n 0.1279381953467521569740561652246953718517,\n 0.1279381953467521569740561652246953718517,\n 0.1258374563468282961213753825111836887264,\n 0.1258374563468282961213753825111836887264,\n 0.121670472927803391204463153476262425607,\n 0.121670472927803391204463153476262425607,\n 0.1155056680537256013533444839067835598622,\n 0.1155056680537256013533444839067835598622,\n 0.1074442701159656347825773424466062227946,\n 0.1074442701159656347825773424466062227946,\n 0.0976186521041138882698806644642471544279,\n 0.0976186521041138882698806644642471544279,\n 0.086190161531953275917185202983742667185,\n 0.086190161531953275917185202983742667185,\n 0.0733464814110803057340336152531165181193,\n 0.0733464814110803057340336152531165181193,\n 0.0592985849154367807463677585001085845412,\n 0.0592985849154367807463677585001085845412,\n 0.0442774388174198061686027482113382288593,\n 0.0442774388174198061686027482113382288593,\n 0.0285313886289336631813078159518782864491,\n 0.0285313886289336631813078159518782864491,\n 0.0123412297999871995468056670700372915759,\n 0.0123412297999871995468056670700372915759,\n];\n\n/**\n * @param points\n * @returns\n */\nconst deriveBezier = (points: QuadPoints | CubicPoints) => {\n const dpoints = [] as (DerivedCubicPoints | DerivedQuadPoints)[];\n for (let p = points, d = p.length, c = d - 1; d > 1; d -= 1, c -= 1) {\n const list = [] as unknown as DerivedCubicPoints | DerivedQuadPoints;\n for (let j = 0; j < c; j += 1) {\n list.push({\n x: c * (p[j + 1].x - p[j].x),\n y: c * (p[j + 1].y - p[j].y),\n t: 0,\n });\n }\n dpoints.push(list);\n p = list;\n }\n return dpoints;\n};\n\n/**\n * @param points\n * @param t\n */\nconst computeBezier = (\n points: DerivedQuadPoints | DerivedCubicPoints,\n t: number,\n) => {\n // shortcuts\n /* istanbul ignore next @preserve */\n if (t === 0) {\n points[0].t = 0;\n return points[0];\n }\n\n const order = points.length - 1;\n\n /* istanbul ignore next @preserve */\n if (t === 1) {\n points[order].t = 1;\n return points[order];\n }\n\n const mt = 1 - t;\n let p = points as typeof points | [\n DerivedPoint,\n DerivedPoint,\n DerivedPoint,\n DerivedPoint,\n ];\n\n // constant?\n /* istanbul ignore next @preserve */\n if (order === 0) {\n points[0].t = t;\n return points[0];\n }\n\n // linear?\n /* istanbul ignore else @preserve */\n if (order === 1) {\n return {\n x: mt * p[0].x + t * p[1].x,\n y: mt * p[0].y + t * p[1].y,\n t,\n };\n }\n\n // quadratic/cubic curve?\n const mt2 = mt * mt;\n const t2 = t * t;\n let a = 0;\n let b = 0;\n let c = 0;\n let d = 0;\n /* istanbul ignore else @preserve */\n if (order === 2) {\n p = [p[0], p[1], p[2], { x: 0, y: 0 } as DerivedPoint];\n a = mt2;\n b = mt * t * 2;\n c = t2;\n } else if (order === 3) {\n a = mt2 * mt;\n b = mt2 * t * 3;\n c = mt * t2 * 3;\n d = t * t2;\n }\n return {\n x: a * p[0].x + b * p[1].x + c * p[2].x + d * p[3].x,\n y: a * p[0].y + b * p[1].y + c * p[2].y + d * p[3].y,\n t,\n };\n};\n\nconst calculateBezier = (derivativeFn: DeriveCallback, t: number) => {\n const d = derivativeFn(t);\n const l = d.x * d.x + d.y * d.y;\n\n return Math.sqrt(l);\n};\n\nconst bezierLength = (derivativeFn: DeriveCallback) => {\n const z = 0.5;\n const len = Tvalues.length;\n\n let sum = 0;\n\n for (let i = 0, t; i < len; i++) {\n t = z * Tvalues[i] + z;\n sum += Cvalues[i] * calculateBezier(derivativeFn, t);\n }\n return z * sum;\n};\n\n/**\n * Returns the length of CubicBezier / Quad segment.\n * @param curve cubic / quad bezier segment\n */\nconst getBezierLength = (curve: CubicCoordinates | QuadCoordinates) => {\n const points = [] as unknown as CubicPoints | QuadPoints;\n for (let idx = 0, len = curve.length, step = 2; idx < len; idx += step) {\n points.push({\n x: curve[idx],\n y: curve[idx + 1],\n });\n }\n const dpoints = deriveBezier(points);\n return bezierLength((t: number) => {\n return computeBezier(dpoints[0], t);\n });\n};\n\n// Precision for consider cubic polynom as quadratic one\nconst CBEZIER_MINMAX_EPSILON = 0.00000001;\n\n/**\n * Returns the most extreme points in a Quad Bezier segment.\n * @param A an array which consist of X/Y values\n */\n// https://github.com/kpym/SVGPathy/blob/acd1a50c626b36d81969f6e98e8602e128ba4302/lib/box.js#L89\nconst minmaxQ = ([v1, cp, v2]: [number, number, number]) => {\n const min = Math.min(v1, v2);\n const max = Math.max(v1, v2);\n\n /* istanbul ignore next @preserve */\n if (cp >= v1 ? v2 >= cp : v2 <= cp) {\n // if no extremum in ]0,1[\n return [min, max] as PointTuple;\n }\n\n // check if the extremum E is min or max\n const E = (v1 * v2 - cp * cp) / (v1 - 2 * cp + v2);\n return (E < min ? [E, max] : [min, E]) as PointTuple;\n};\n\n/**\n * Returns the most extreme points in a Cubic Bezier segment.\n * @param A an array which consist of X/Y values\n * @see https://github.com/kpym/SVGPathy/blob/acd1a50c626b36d81969f6e98e8602e128ba4302/lib/box.js#L127\n */\nconst minmaxC = ([v1, cp1, cp2, v2]: [number, number, number, number]) => {\n const K = v1 - 3 * cp1 + 3 * cp2 - v2;\n\n // if the polynomial is (almost) quadratic and not cubic\n /* istanbul ignore next @preserve */\n if (Math.abs(K) < CBEZIER_MINMAX_EPSILON) {\n if (v1 === v2 && v1 === cp1) {\n // no curve, point targeting same location\n return [v1, v2] as PointTuple;\n }\n\n return minmaxQ([v1, -0.5 * v1 + 1.5 * cp1, v1 - 3 * cp1 + 3 * cp2]);\n }\n\n // the reduced discriminant of the derivative\n const T = -v1 * cp2 + v1 * v2 - cp1 * cp2 - cp1 * v2 + cp1 * cp1 + cp2 * cp2;\n\n // if the polynomial is monotone in [0,1]\n if (T <= 0) {\n return [Math.min(v1, v2), Math.max(v1, v2)] as PointTuple;\n }\n const S = Math.sqrt(T);\n\n // potential extrema\n let min = Math.min(v1, v2);\n let max = Math.max(v1, v2);\n\n const L = v1 - 2 * cp1 + cp2;\n // check local extrema\n for (let R = (L + S) / K, i = 1; i <= 2; R = (L - S) / K, i++) {\n // istanbul ignore next @preserve\n if (R > 0 && R < 1) {\n // if the extrema is for R in [0,1]\n const Q = v1 * (1 - R) * (1 - R) * (1 - R) +\n cp1 * 3 * (1 - R) * (1 - R) * R + cp2 * 3 * (1 - R) * R * R +\n v2 * R * R * R;\n if (Q < min) {\n min = Q;\n }\n if (Q > max) {\n max = Q;\n }\n }\n }\n\n return [min, max] as PointTuple;\n};\n\nexport {\n bezierLength,\n calculateBezier,\n CBEZIER_MINMAX_EPSILON,\n computeBezier,\n Cvalues,\n deriveBezier,\n getBezierLength,\n minmaxC,\n minmaxQ,\n Tvalues,\n};\n","import { getBezierLength, minmaxC } from \"./bezier\";\nimport { type CubicCoordinates } from \"../types\";\n\n/**\n * Returns a point at a given length of a CubicBezier segment.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param t a [0-1] ratio\n * @returns the point at cubic-bezier segment length\n */\nconst getPointAtCubicSegmentLength = (\n [x1, y1, c1x, c1y, c2x, c2y, x2, y2]: CubicCoordinates,\n t: number,\n) => {\n const t1 = 1 - t;\n return {\n x: t1 ** 3 * x1 + 3 * t1 ** 2 * t * c1x + 3 * t1 * t ** 2 * c2x +\n t ** 3 * x2,\n y: t1 ** 3 * y1 + 3 * t1 ** 2 * t * c1y + 3 * t1 * t ** 2 * c2y +\n t ** 3 * y2,\n };\n};\n\n/**\n * Returns the length of a CubicBezier segment.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the CubicBezier segment length\n */\nconst getCubicLength = (\n x1: number,\n y1: number,\n c1x: number,\n c1y: number,\n c2x: number,\n c2y: number,\n x2: number,\n y2: number,\n) => {\n return getBezierLength([x1, y1, c1x, c1y, c2x, c2y, x2, y2]);\n};\n\n/**\n * Returns the point along a CubicBezier segment at a given distance.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance the distance to look at\n * @returns the point at CubicBezier length\n */\nconst getPointAtCubicLength = (\n x1: number,\n y1: number,\n c1x: number,\n c1y: number,\n c2x: number,\n c2y: number,\n x2: number,\n y2: number,\n distance?: number,\n) => {\n const distanceIsNumber = typeof distance === \"number\";\n let point = { x: x1, y: y1 };\n /* istanbul ignore else @preserve */\n if (distanceIsNumber) {\n const currentLength = getBezierLength([x1, y1, c1x, c1y, c2x, c2y, x2, y2]);\n if (distance <= 0) {\n // first point already defined\n } else if (distance >= currentLength) {\n point = { x: x2, y: y2 };\n } else {\n point = getPointAtCubicSegmentLength(\n [x1, y1, c1x, c1y, c2x, c2y, x2, y2],\n distance / currentLength,\n );\n }\n }\n return point;\n};\n\n/**\n * Returns the boundig box of a CubicBezier segment in the following format:\n * [MIN_X, MIN_Y, MAX_X, MAX_Y]\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the extrema of the CubicBezier segment\n */\nconst getCubicBBox = (\n x1: number,\n y1: number,\n c1x: number,\n c1y: number,\n c2x: number,\n c2y: number,\n x2: number,\n y2: number,\n) => {\n const cxMinMax = minmaxC([x1, c1x, c2x, x2]);\n const cyMinMax = minmaxC([y1, c1y, c2y, y2]);\n\n return [cxMinMax[0], cyMinMax[0], cxMinMax[1], cyMinMax[1]] as [\n number,\n number,\n number,\n number,\n ];\n};\n\nexport {\n getCubicBBox,\n getCubicLength,\n getPointAtCubicLength,\n getPointAtCubicSegmentLength,\n};\n","import { getBezierLength, minmaxQ } from \"./bezier\";\nimport { type QuadCoordinates } from \"../types\";\n\n/**\n * Returns the {x,y} coordinates of a point at a\n * given length of a quadratic-bezier segment.\n *\n * @see https://github.com/substack/point-at-length\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param cx the control point X\n * @param cy the control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param t a [0-1] ratio\n * @returns the requested {x,y} coordinates\n */\nconst getPointAtQuadSegmentLength = (\n [x1, y1, cx, cy, x2, y2]: QuadCoordinates,\n t: number,\n) => {\n const t1 = 1 - t;\n return {\n x: t1 ** 2 * x1 + 2 * t1 * t * cx + t ** 2 * x2,\n y: t1 ** 2 * y1 + 2 * t1 * t * cy + t ** 2 * y2,\n };\n};\n\n/**\n * Returns the length of a QuadraticBezier segment.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param cx the control point X\n * @param cy the control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the QuadraticBezier segment length\n */\nconst getQuadLength = (\n x1: number,\n y1: number,\n cx: number,\n cy: number,\n x2: number,\n y2: number,\n) => {\n return getBezierLength([x1, y1, cx, cy, x2, y2]);\n};\n\n/**\n * Returns the point along a QuadraticBezier segment at a given distance.\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param cx the control point X\n * @param cy the control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @param distance the distance to look at\n * @returns the point at QuadraticBezier length\n */\nconst getPointAtQuadLength = (\n x1: number,\n y1: number,\n cx: number,\n cy: number,\n x2: number,\n y2: number,\n distance?: number,\n) => {\n const distanceIsNumber = typeof distance === \"number\";\n let point = { x: x1, y: y1 };\n\n /* istanbul ignore else @preserve */\n if (distanceIsNumber) {\n const currentLength = getBezierLength([x1, y1, cx, cy, x2, y2]);\n if (distance <= 0) {\n // first point already defined\n } else if (distance >= currentLength) {\n point = { x: x2, y: y2 };\n } else {\n point = getPointAtQuadSegmentLength(\n [x1, y1, cx, cy, x2, y2],\n distance / currentLength,\n );\n }\n }\n return point;\n};\n\n/**\n * Returns the boundig box of a QuadraticBezier segment in the following format:\n * [MIN_X, MIN_Y, MAX_X, MAX_Y]\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param cx the control point X\n * @param cy the control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the extrema of the QuadraticBezier segment\n */\nconst getQuadBBox = (\n x1: number,\n y1: number,\n cx: number,\n cy: number,\n x2: number,\n y2: number,\n) => {\n const cxMinMax = minmaxQ([x1, cx, x2]);\n const cyMinMax = minmaxQ([y1, cy, y2]);\n return [cxMinMax[0], cyMinMax[0], cxMinMax[1], cyMinMax[1]] as [\n number,\n number,\n number,\n number,\n ];\n};\n\nexport {\n getPointAtQuadLength,\n getPointAtQuadSegmentLength,\n getQuadBBox,\n getQuadLength,\n};\n","import distanceSquareRoot from \"./distanceSquareRoot\";\nimport { type PointTuple } from \"../types\";\n\n/**\n * d3-polygon-area\n * https://github.com/d3/d3-polygon\n *\n * Returns the area of a polygon.\n *\n * @param polygon an array of coordinates\n * @returns the polygon area\n */\nconst polygonArea = (polygon: PointTuple[]) => {\n const n = polygon.length;\n let i = -1;\n let a: PointTuple;\n let b = polygon[n - 1];\n let area = 0;\n\n /* eslint-disable-next-line */\n while (++i < n) {\n a = b;\n b = polygon[i];\n area += a[1] * b[0] - a[0] * b[1];\n }\n\n return area / 2;\n};\n\n/**\n * d3-polygon-length\n * https://github.com/d3/d3-polygon\n *\n * Returns the perimeter of a polygon.\n *\n * @param polygon an array of coordinates\n * @returns the polygon length\n */\nconst polygonLength = (polygon: PointTuple[]) => {\n return polygon.reduce((length, point, i) => {\n if (i) {\n return length + distanceSquareRoot(polygon[i - 1], point);\n }\n return 0;\n }, 0);\n};\n\nexport { polygonArea, polygonLength };\n","/** Segment params length */\nconst paramsCount = {\n a: 7,\n c: 6,\n h: 1,\n l: 2,\n m: 2,\n r: 4,\n q: 4,\n s: 4,\n t: 2,\n v: 1,\n z: 0,\n};\n\nexport default paramsCount;\n","import paramsCount from \"./paramsCount\";\nimport PathParser from \"./pathParser\";\nimport type { PathCommand, PathSegment, RelativeCommand } from \"../types\";\n\n/**\n * Breaks the parsing of a pathString once a segment is finalized.\n *\n * @param path the `PathParser` instance\n */\nconst finalizeSegment = (path: PathParser) => {\n let pathCommand = path.pathValue[path.segmentStart] as PathCommand;\n let relativeCommand = pathCommand.toLowerCase() as RelativeCommand;\n const { data } = path;\n\n while (data.length >= paramsCount[relativeCommand]) {\n // overloaded `moveTo`\n // https://github.com/rveciana/svg-path-properties/blob/master/src/parse.ts\n if (relativeCommand === \"m\" && data.length > 2) {\n path.segments.push(\n [pathCommand as PathCommand | number].concat(\n data.splice(0, 2) as number[],\n ) as PathSegment,\n );\n relativeCommand = \"l\";\n pathCommand = pathCommand === \"m\" ? \"l\" : \"L\";\n } else {\n path.segments.push(\n [pathCommand as PathCommand | number].concat(\n data.splice(0, paramsCount[relativeCommand]) as number[],\n ) as PathSegment,\n );\n }\n\n if (!paramsCount[relativeCommand]) {\n break;\n }\n }\n};\nexport default finalizeSegment;\n","const error = \"SVGPathCommander Error\";\nexport default error;\n","import error from \"./error\";\nimport type PathParser from \"./pathParser\";\n\n/**\n * Validates an A (arc-to) specific path command value.\n * Usually a `large-arc-flag` or `sweep-flag`.\n *\n * @param path the `PathParser` instance\n */\nconst scanFlag = (path: PathParser) => {\n const { index, pathValue } = path;\n const code = pathValue.charCodeAt(index);\n\n if (code === 0x30 /* 0 */) {\n path.param = 0;\n path.index += 1;\n return;\n }\n\n if (code === 0x31 /* 1 */) {\n path.param = 1;\n path.index += 1;\n return;\n }\n\n path.err = `${error}: invalid Arc flag \"${\n pathValue[index]\n }\", expecting 0 or 1 at index ${index}`;\n};\n\nexport default scanFlag;\n","import { DigitNumber } from \"../types\";\n\n/**\n * Checks if a character is a digit.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isDigit = (code: number): code is DigitNumber => {\n return code >= 48 && code <= 57; // 0..9\n};\nexport default isDigit;\n","const invalidPathValue = \"Invalid path value\";\nexport default invalidPathValue;\n","import isDigit from \"./isDigit\";\nimport invalidPathValue from \"./invalidPathValue\";\nimport error from \"./error\";\nimport type PathParser from \"./pathParser\";\n\n/**\n * Validates every character of the path string,\n * every path command, negative numbers or floating point numbers.\n *\n * @param path the `PathParser` instance\n */\nconst scanParam = (path: PathParser) => {\n const { max, pathValue, index: start } = path;\n let index = start;\n let zeroFirst = false;\n let hasCeiling = false;\n let hasDecimal = false;\n let hasDot = false;\n let ch;\n\n if (index >= max) {\n path.err =\n `${error}: ${invalidPathValue} at index ${index}, \"pathValue\" is missing param`;\n return;\n }\n ch = pathValue.charCodeAt(index);\n\n if (ch === 0x2b /* + */ || ch === 0x2d /* - */) {\n index += 1;\n // ch = (index < max) ? pathValue.charCodeAt(index) : 0;\n ch = pathValue.charCodeAt(index);\n }\n\n // This logic is shamelessly borrowed from Esprima\n // https://github.com/ariya/esprimas\n if (!isDigit(ch) && ch !== 0x2e /* . */) {\n // path.err = 'SvgPath: param should start with 0..9 or `.` (at pos ' + index + ')';\n path.err = `${error}: ${invalidPathValue} at index ${index}, \"${\n pathValue[index]\n }\" is not a number`;\n return;\n }\n\n if (ch !== 0x2e /* . */) {\n zeroFirst = ch === 0x30 /* 0 */;\n index += 1;\n\n ch = pathValue.charCodeAt(index);\n\n if (zeroFirst && index < max) {\n // decimal number starts with '0' such as '09' is illegal.\n if (ch && isDigit(ch)) {\n // path.err = 'SvgPath: numbers started with `0` such as `09`\n // are illegal (at pos ' + start + ')';\n path.err = `${error}: ${invalidPathValue} at index ${start}, \"${\n pathValue[start]\n }\" illegal number`;\n return;\n }\n }\n\n while (index < max && isDigit(pathValue.charCodeAt(index))) {\n index += 1;\n hasCeiling = true;\n }\n\n ch = pathValue.charCodeAt(index);\n }\n\n if (ch === 0x2e /* . */) {\n hasDot = true;\n index += 1;\n while (isDigit(pathValue.charCodeAt(index))) {\n index += 1;\n hasDecimal = true;\n }\n\n ch = pathValue.charCodeAt(index);\n }\n\n if (ch === 0x65 /* e */ || ch === 0x45 /* E */) {\n if (hasDot && !hasCeiling && !hasDecimal) {\n path.err = `${error}: ${invalidPathValue} at index ${index}, \"${\n pathValue[index]\n }\" invalid float exponent`;\n return;\n }\n\n index += 1;\n\n ch = pathValue.charCodeAt(index);\n\n if (ch === 0x2b /* + */ || ch === 0x2d /* - */) {\n index += 1;\n }\n if (index < max && isDigit(pathValue.charCodeAt(index))) {\n while (index < max && isDigit(pathValue.charCodeAt(index))) {\n index += 1;\n }\n } else {\n path.err = `${error}: ${invalidPathValue} at index ${index}, \"${\n pathValue[index]\n }\" invalid integer exponent`;\n return;\n }\n }\n\n path.index = index;\n path.param = +path.pathValue.slice(start, index);\n};\nexport default scanParam;\n","import type { SpaceNumber } from \"../types\";\n\n/**\n * Checks if the character is a space.\n *\n * @param ch the character to check\n * @returns check result\n */\n\nconst isSpace = (ch: number): ch is SpaceNumber => {\n const allSpaces = [\n // Special spaces\n 0x1680,\n 0x180e,\n 0x2000,\n 0x2001,\n 0x2002,\n 0x2003,\n 0x2004,\n 0x2005,\n 0x2006,\n 0x2007,\n 0x2008,\n 0x2009,\n 0x200a,\n 0x202f,\n 0x205f,\n 0x3000,\n 0xfeff,\n // Line terminators\n 0x0a,\n 0x0d,\n 0x2028,\n 0x2029,\n // White spaces\n 0x20,\n 0x09,\n 0x0b,\n 0x0c,\n 0xa0,\n ];\n\n return allSpaces.includes(ch);\n};\nexport default isSpace;\n","import isSpace from \"./isSpace\";\nimport type PathParser from \"./pathParser\";\n\n/**\n * Points the parser to the next character in the\n * path string every time it encounters any kind of\n * space character.\n *\n * @param path the `PathParser` instance\n */\nconst skipSpaces = (path: PathParser) => {\n const { pathValue, max } = path;\n while (path.index < max && isSpace(pathValue.charCodeAt(path.index))) {\n path.index += 1;\n }\n};\nexport default skipSpaces;\n","import type { PathCommandNumber } from \"../types\";\n\n/**\n * Checks if the character is a path command.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isPathCommand = (code: number): code is PathCommandNumber => {\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy\n switch (code | 0x20) {\n case 0x6d /* m */:\n case 0x7a /* z */:\n case 0x6c /* l */:\n case 0x68 /* h */:\n case 0x76 /* v */:\n case 0x63 /* c */:\n case 0x73 /* s */:\n case 0x71 /* q */:\n case 0x74 /* t */:\n case 0x61 /* a */:\n // case 0x72/* r */:\n return true;\n default:\n return false;\n }\n};\nexport default isPathCommand;\n","import isDigit from \"./isDigit\";\nimport type { DigitNumber } from \"../types\";\n\n/**\n * Checks if the character is or belongs to a number.\n * [0-9]|+|-|.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isDigitStart = (\n code: number,\n): code is DigitNumber | 0x2b | 0x2d | 0x2e => {\n return isDigit(code) /* 0..9 */ || code === 0x2b /* + */ ||\n code === 0x2d /* - */ || code === 0x2e; /* . */\n};\nexport default isDigitStart;\n","/**\n * Checks if the character is an A (arc-to) path command.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isArcCommand = (code: number): code is 0x61 => {\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy\n return (code | 0x20) === 0x61;\n};\nexport default isArcCommand;\n","/**\n * Checks if the character is a MoveTo command.\n *\n * @param code the character to check\n * @returns check result\n */\nconst isMoveCommand = (code: number): code is 0x6d | 0x4d => {\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy\n switch (code | 0x20) {\n case 0x6d /* m */:\n case 0x4d /* M */:\n return true;\n default:\n return false;\n }\n};\nexport default isMoveCommand;\n","import finalizeSegment from \"./finalizeSegment\";\nimport paramCounts from \"./paramsCount\";\nimport scanFlag from \"./scanFlag\";\nimport scanParam from \"./scanParam\";\nimport skipSpaces from \"./skipSpaces\";\nimport isPathCommand from \"./isPathCommand\";\nimport isDigitStart from \"./isDigitStart\";\nimport isArcCommand from \"./isArcCommand\";\nimport isMoveCommand from \"./isMoveCommand\";\nimport invalidPathValue from \"./invalidPathValue\";\nimport error from \"./error\";\n\nimport type PathParser from \"./pathParser\";\nimport type { PathSegment, RelativeCommand } from \"../types\";\n\n/**\n * Scans every character in the path string to determine\n * where a segment starts and where it ends.\n *\n * @param path the `PathParser` instance\n */\nconst scanSegment = (path: PathParser) => {\n const { max, pathValue, index, segments } = path;\n const cmdCode = pathValue.charCodeAt(index);\n const reqParams =\n paramCounts[pathValue[index].toLowerCase() as RelativeCommand];\n\n path.segmentStart = index;\n\n // segments always start with a path command\n if (!isPathCommand(cmdCode)) {\n path.err = `${error}: ${invalidPathValue} \"${\n pathValue[index]\n }\" is not a path command at index ${index}`;\n return;\n }\n\n // after a Z segment, we only expect a MoveTo path command\n const lastSegment = segments[segments.length - 1] as PathSegment | undefined;\n if (\n !isMoveCommand(cmdCode) && lastSegment?.[0]?.toLocaleLowerCase() === \"z\"\n ) {\n path.err = `${error}: ${invalidPathValue} \"${\n pathValue[index]\n }\" is not a MoveTo path command at index ${index}`;\n return;\n }\n\n path.index += 1;\n skipSpaces(path);\n\n path.data = [];\n\n if (!reqParams) {\n // Z\n finalizeSegment(path);\n return;\n }\n\n for (;;) {\n for (let i = reqParams; i > 0; i -= 1) {\n if (isArcCommand(cmdCode) && (i === 3 || i === 4)) scanFlag(path);\n else scanParam(path);\n\n if (path.err.length) {\n return;\n }\n path.data.push(path.param);\n\n skipSpaces(path);\n\n // after ',' param is mandatory\n if (\n path.index < max && pathValue.charCodeAt(path.index) === 0x2c /* , */\n ) {\n path.index += 1;\n skipSpaces(path);\n }\n }\n\n if (path.index >= path.max) {\n break;\n }\n\n // Stop on next segment\n if (!isDigitStart(pathValue.charCodeAt(path.index))) {\n break;\n }\n }\n\n finalizeSegment(path);\n};\nexport default scanSegment;\n","import type { PathArray, PathSegment } from \"../types\";\n\n/**\n * The `PathParser` is used by the `parsePathString` static method\n * to generate a `pathArray`.\n *\n * @param pathString\n */\nexport default class PathParser {\n declare segments: PathArray | PathSegment[];\n declare pathValue: string;\n declare max: number;\n declare index: number;\n declare param: number;\n declare segmentStart: number;\n declare data: (string | number)[];\n declare err: string;\n\n constructor(pathString: string) {\n this.segments = [];\n this.pathValue = pathString;\n this.max = pathString.length;\n this.index = 0;\n this.param = 0.0;\n this.segmentStart = 0;\n this.data = [];\n this.err = \"\";\n }\n}\n","import scanSegment from \"./scanSegment\";\nimport skipSpaces from \"./skipSpaces\";\nimport PathParser from \"./pathParser\";\nimport type { PathArray } from \"../types\";\n\n/**\n * Parses a path string value and returns an array\n * of segments we like to call `pathArray`.\n *\n * @param pathInput the string to be parsed\n * @returns the resulted `pathArray` or error string\n */\nconst parsePathString = (pathInput: string | T) => {\n if (typeof pathInput !== \"string\") {\n return pathInput.slice(0) as typeof pathInput;\n }\n\n const path = new PathParser(pathInput);\n\n skipSpaces(path);\n\n while (path.index < path.max && !path.err.length) {\n scanSegment(path);\n }\n\n // handle valid paths first\n // handle errors second\n if (!path.err.length) {\n if (path.segments.length) {\n /**\n * force absolute first M\n * getPathBBox calculation requires first segment to be absolute\n * @see https://github.com/thednp/svg-path-commander/pull/49\n */\n path.segments[0][0] = \"M\";\n }\n } else {\n throw TypeError(path.err);\n }\n\n return path.segments as PathArray;\n};\n\nexport default parsePathString;\n","import type {\n AbsoluteCommand,\n AbsoluteSegment,\n ASegment,\n CSegment,\n HSegment,\n LSegment,\n MSegment,\n PathSegment,\n QSegment,\n SSegment,\n TSegment,\n VSegment,\n} from \"../types\";\n\n/**\n * Returns an absolute segment of a `PathArray` object.\n *\n * @param segment the segment object\n * @param index the segment index\n * @param lastX the last known X value\n * @param lastY the last known Y value\n * @returns the absolute segment\n */\nconst absolutizeSegment = (\n segment: PathSegment,\n index: number,\n lastX: number,\n lastY: number,\n) => {\n const [pathCommand] = segment;\n const absCommand = pathCommand.toUpperCase() as AbsoluteCommand;\n const isAbsolute = absCommand === pathCommand;\n\n /* istanbul ignore else @preserve */\n if (index === 0 || isAbsolute) return segment as MSegment | AbsoluteSegment;\n // const values = segment.slice(1) as number[];\n if (absCommand === \"A\") {\n return [\n absCommand,\n segment[1],\n segment[2],\n segment[3],\n segment[4],\n segment[5],\n (segment as ASegment)[6] + lastX,\n (segment as ASegment)[7] + lastY,\n ] as ASegment;\n } else if (absCommand === \"V\") {\n return [absCommand, (segment as VSegment)[1] + lastY] as VSegment;\n } else if (absCommand === \"H\") {\n return [absCommand, (segment as HSegment)[1] + lastX] as HSegment;\n } else if (absCommand === \"L\") {\n return [\n absCommand,\n (segment as LSegment)[1] + lastX,\n (segment as LSegment)[2] + lastY,\n ] as LSegment;\n } else {\n // use brakets for `eslint: no-case-declaration`\n // https://stackoverflow.com/a/50753272/803358\n const absValues = [] as number[];\n const seglen = segment.length;\n for (let j = 1; j < seglen; j += 1) {\n absValues.push((segment[j] as number) + (j % 2 ? lastX : lastY));\n }\n // for c, s, q, t\n return [absCommand as typeof absCommand | number].concat(absValues) as\n | MSegment\n | QSegment\n | TSegment\n | SSegment\n | CSegment;\n }\n};\nexport default absolutizeSegment;\n","// import paramsParser from '../parser/paramsParser';\nimport type {\n AbsoluteCommand,\n IteratorCallback,\n PathArray,\n PathCommand,\n PathSegment,\n} from \"../types\";\n\nconst iterate = (\n path: PathArray,\n iterator: IteratorCallback,\n) => {\n let pathLen = path.length;\n let segment: PathSegment;\n let pathCommand = \"M\" as PathCommand;\n let absCommand = \"M\" as AbsoluteCommand;\n let isRelative = false;\n let x = 0;\n let y = 0;\n let mx = 0;\n let my = 0;\n let segLen = 0;\n\n for (let i = 0; i < pathLen; i += 1) {\n segment = path[i];\n [pathCommand] = segment;\n segLen = segment.length;\n absCommand = pathCommand.toUpperCase() as AbsoluteCommand;\n isRelative = absCommand !== pathCommand;\n\n const iteratorResult = iterator(segment, i, x, y);\n // some methods like getPointAtLength would like to break\n // when task is complete\n if (iteratorResult === false) {\n break;\n }\n\n // segment = path[i];\n if (absCommand === \"Z\") {\n x = mx;\n y = my;\n } else if (absCommand === \"H\") {\n x = (segment[1] as number) + (isRelative ? x : 0);\n } else if (absCommand === \"V\") {\n y = (segment[1] as number) + (isRelative ? y : 0);\n } else {\n x = (segment[segLen - 2] as number) + (isRelative ? x : 0);\n y = (segment[segLen - 1] as number) + (isRelative ? y : 0);\n\n if (absCommand === \"M\") {\n mx = x;\n my = y;\n }\n }\n\n if (iteratorResult) {\n path[i] = iteratorResult;\n if (iteratorResult[0] === \"C\") {\n pathLen = path.length;\n }\n }\n }\n return path as T;\n};\n\nexport default iterate;\n","import parsePathString from \"../parser/parsePathString\";\nimport absolutizeSegment from \"../process/absolutizeSegment\";\nimport type { AbsoluteArray, PathArray } from \"../types\";\nimport iterate from \"../process/iterate\";\n\n/**\n * Parses a path string value or object and returns an array\n * of segments, all converted to absolute values.\n *\n * @param pathInput the path string | object\n * @returns the resulted `pathArray` with absolute values\n */\nconst pathToAbsolute = (pathInput: string | PathArray) => {\n const path = parsePathString(pathInput);\n\n return iterate(path, absolutizeSegment);\n};\nexport default pathToAbsolute;\n","import type {\n aSegment,\n cSegment,\n hSegment,\n lSegment,\n MSegment,\n PathSegment,\n qSegment,\n RelativeCommand,\n RelativeSegment,\n sSegment,\n tSegment,\n vSegment,\n} from \"../types\";\n\n/**\n * Returns a relative segment of a `PathArray` object.\n *\n * @param segment the segment object\n * @param index the segment index\n * @param lastX the last known X value\n * @param lastY the last known Y value\n * @returns the relative segment\n */\nconst relativizeSegment = (\n segment: PathSegment,\n index: number,\n lastX: number,\n lastY: number,\n) => {\n const [pathCommand] = segment;\n const relCommand = pathCommand.toLowerCase() as RelativeCommand;\n const isRelative = pathCommand === relCommand;\n\n /* istanbul ignore else @preserve */\n if (index === 0 || isRelative) return segment as MSegment | RelativeSegment;\n\n if (relCommand === \"a\") {\n return [\n relCommand,\n segment[1],\n segment[2],\n segment[3],\n segment[4],\n segment[5],\n (segment as aSegment)[6] - lastX,\n (segment as aSegment)[7] - lastY,\n ] as aSegment;\n } else if (relCommand === \"v\") {\n return [relCommand, (segment as vSegment)[1] - lastY] as vSegment;\n } else if (relCommand === \"h\") {\n return [relCommand, (segment as hSegment)[1] - lastX] as hSegment;\n } else if (relCommand === \"l\") {\n return [\n relCommand,\n (segment as lSegment)[1] - lastX,\n (segment as lSegment)[2] - lastY,\n ] as lSegment;\n } else {\n // use brakets for `eslint: no-case-declaration`\n // https://stackoverflow.com/a/50753272/803358\n const relValues = [] as number[];\n const seglen = segment.length;\n for (let j = 1; j < seglen; j += 1) {\n relValues.push((segment[j] as number) - (j % 2 ? lastX : lastY));\n }\n // for c, s, q, t\n return [relCommand as RelativeCommand | number].concat(relValues) as\n | qSegment\n | tSegment\n | sSegment\n | cSegment;\n }\n};\n\nexport default relativizeSegment;\n","import type { PathArray, RelativeArray } from \"../types\";\nimport parsePathString from \"../parser/parsePathString\";\nimport iterate from \"../process/iterate\";\nimport relativizeSegment from \"../process/relativizeSegment\";\n\n/**\n * Parses a path string value or object and returns an array\n * of segments, all converted to relative values.\n *\n * @param pathInput the path string | object\n * @returns the resulted `pathArray` with relative values\n */\nconst pathToRelative = (pathInput: string | PathArray): RelativeArray => {\n const path = parsePathString(pathInput);\n\n return iterate(path, relativizeSegment);\n};\nexport default pathToRelative;\n","/**\n * Returns an {x,y} vector rotated by a given\n * angle in radian.\n *\n * @param x the initial vector x\n * @param y the initial vector y\n * @param rad the radian vector angle\n * @returns the rotated vector\n */\nconst rotateVector = (\n x: number,\n y: number,\n rad: number,\n): { x: number; y: number } => {\n const { sin, cos } = Math;\n const X = x * cos(rad) - y * sin(rad);\n const Y = x * sin(rad) + y * cos(rad);\n return { x: X, y: Y };\n};\n\nexport default rotateVector;\n","import rotateVector from \"../math/rotateVector\";\n\n/**\n * Converts A (arc-to) segments to C (cubic-bezier-to).\n *\n * For more information of where this math came from visit:\n * http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes\n *\n * @param X1 the starting x position\n * @param Y1 the starting y position\n * @param RX x-radius of the arc\n * @param RY y-radius of the arc\n * @param angle x-axis-rotation of the arc\n * @param LAF large-arc-flag of the arc\n * @param SF sweep-flag of the arc\n * @param X2 the ending x position\n * @param Y2 the ending y position\n * @param recursive the parameters needed to split arc into 2 segments\n * @return the resulting cubic-bezier segment(s)\n */\nconst arcToCubic = (\n X1: number,\n Y1: number,\n RX: number,\n RY: number,\n angle: number,\n LAF: number,\n SF: number,\n X2: number,\n Y2: number,\n recursive?: [number, number, number, number],\n): number[] => {\n let x1 = X1;\n let y1 = Y1;\n let rx = RX;\n let ry = RY;\n let x2 = X2;\n let y2 = Y2;\n // for more information of where this Math came from visit:\n // http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes\n const d120 = (Math.PI * 120) / 180;\n\n const rad = (Math.PI / 180) * (+angle || 0);\n let res = [] as number[];\n let xy;\n let f1;\n let f2;\n let cx;\n let cy;\n\n if (!recursive) {\n xy = rotateVector(x1, y1, -rad);\n x1 = xy.x;\n y1 = xy.y;\n xy = rotateVector(x2, y2, -rad);\n x2 = xy.x;\n y2 = xy.y;\n\n const x = (x1 - x2) / 2;\n const y = (y1 - y2) / 2;\n let h = (x * x) / (rx * rx) + (y * y) / (ry * ry);\n if (h > 1) {\n h = Math.sqrt(h);\n rx *= h;\n ry *= h;\n }\n const rx2 = rx * rx;\n const ry2 = ry * ry;\n\n const k = (LAF === SF ? -1 : 1) *\n Math.sqrt(\n Math.abs(\n (rx2 * ry2 - rx2 * y * y - ry2 * x * x) / (rx2 * y * y + ry2 * x * x),\n ),\n );\n\n cx = (k * rx * y) / ry + (x1 + x2) / 2;\n cy = (k * -ry * x) / rx + (y1 + y2) / 2;\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy no-bitwise\n f1 = Math.asin(((((y1 - cy) / ry) * 10 ** 9) >> 0) / 10 ** 9);\n // eslint-disable-next-line no-bitwise -- Impossible to satisfy no-bitwise\n f2 = Math.asin(((((y2 - cy) / ry) * 10 ** 9) >> 0) / 10 ** 9);\n\n f1 = x1 < cx ? Math.PI - f1 : f1;\n f2 = x2 < cx ? Math.PI - f2 : f2;\n if (f1 < 0) f1 = Math.PI * 2 + f1;\n if (f2 < 0) f2 = Math.PI * 2 + f2;\n if (SF && f1 > f2) {\n f1 -= Math.PI * 2;\n }\n if (!SF && f2 > f1) {\n f2 -= Math.PI * 2;\n }\n } else {\n [f1, f2, cx, cy] = recursive;\n }\n let df = f2 - f1;\n if (Math.abs(df) > d120) {\n const f2old = f2;\n const x2old = x2;\n const y2old = y2;\n f2 = f1 + d120 * (SF && f2 > f1 ? 1 : -1);\n x2 = cx + rx * Math.cos(f2);\n y2 = cy + ry * Math.sin(f2);\n res = arcToCubic(x2, y2, rx, ry, angle, 0, SF, x2old, y2old, [\n f2,\n f2old,\n cx,\n cy,\n ]);\n }\n df = f2 - f1;\n const c1 = Math.cos(f1);\n const s1 = Math.sin(f1);\n const c2 = Math.cos(f2);\n const s2 = Math.sin(f2);\n const t = Math.tan(df / 4);\n const hx = (4 / 3) * rx * t;\n const hy = (4 / 3) * ry * t;\n const m1 = [x1, y1];\n const m2 = [x1 + hx * s1, y1 - hy * c1];\n const m3 = [x2 + hx * s2, y2 - hy * c2];\n const m4 = [x2, y2];\n m2[0] = 2 * m1[0] - m2[0];\n m2[1] = 2 * m1[1] - m2[1];\n if (recursive) {\n return [m2[0], m2[1], m3[0], m3[1], m4[0], m4[1]].concat(res);\n }\n res = [m2[0], m2[1], m3[0], m3[1], m4[0], m4[1]].concat(res);\n const newres = [];\n for (let i = 0, ii = res.length; i < ii; i += 1) {\n newres[i] = i % 2\n ? rotateVector(res[i - 1], res[i], rad).y\n : rotateVector(res[i], res[i + 1], rad).x;\n }\n return newres;\n};\nexport default arcToCubic;\n","/**\n * Converts a Q (quadratic-bezier) segment to C (cubic-bezier).\n *\n * @param x1 curve start x\n * @param y1 curve start y\n * @param qx control point x\n * @param qy control point y\n * @param x2 curve end x\n * @param y2 curve end y\n * @returns the cubic-bezier segment\n */\nconst quadToCubic = (\n x1: number,\n y1: number,\n qx: number,\n qy: number,\n x2: number,\n y2: number,\n): [number, number, number, number, number, number] => {\n const r13 = 1 / 3;\n const r23 = 2 / 3;\n return [\n r13 * x1 + r23 * qx, // cpx1\n r13 * y1 + r23 * qy, // cpy1\n r13 * x2 + r23 * qx, // cpx2\n r13 * y2 + r23 * qy, // cpy2\n x2,\n y2, // x,y\n ];\n};\nexport default quadToCubic;\n","import midPoint from \"../math/midPoint\";\n\n/**\n * Converts an L (line-to) segment to C (cubic-bezier).\n *\n * @param x1 line start x\n * @param y1 line start y\n * @param x2 line end x\n * @param y2 line end y\n * @returns the cubic-bezier segment\n */\nconst lineToCubic = (x1: number, y1: number, x2: number, y2: number) => {\n const c1 = midPoint([x1, y1], [x2, y2], 1.0 / 3.0);\n const c2 = midPoint([x1, y1], [x2, y2], 2.0 / 3.0);\n return [c1[0], c1[1], c2[0], c2[1], x2, y2];\n};\nexport default lineToCubic;\n","import arcToCubic from \"./arcToCubic\";\nimport quadToCubic from \"./quadToCubic\";\nimport lineToCubic from \"./lineToCubic\";\nimport type { CSegment, MSegment, PathSegment } from \"../types\";\nimport type { ParserParams } from \"../interface\";\n\n/**\n * Converts any segment to C (cubic-bezier).\n *\n * @param segment the source segment\n * @param params the source segment parameters\n * @returns the cubic-bezier segment\n */\nconst segmentToCubic = (segment: PathSegment, params: ParserParams) => {\n const [pathCommand] = segment;\n const values = segment.slice(1).map(Number);\n const [x, y] = values;\n // let args;\n const { x1: px1, y1: py1, x: px, y: py } = params;\n\n if (!\"TQ\".includes(pathCommand)) {\n params.qx = null;\n params.qy = null;\n }\n\n if (pathCommand === \"M\") {\n params.x = x;\n params.y = y;\n return segment;\n } else if (pathCommand === \"A\") {\n return [\"C\" as string | number].concat(\n arcToCubic(\n px1,\n py1,\n values[0],\n values[1],\n values[2],\n values[3],\n values[4],\n values[5],\n values[6],\n ),\n ) as CSegment;\n } else if (pathCommand === \"Q\") {\n params.qx = x;\n params.qy = y;\n return [\"C\" as string | number].concat(\n quadToCubic(px1, py1, values[0], values[1], values[2], values[3]),\n ) as CSegment;\n } else if (pathCommand === \"L\") {\n return [\"C\" as string | number].concat(\n lineToCubic(px1, py1, x, y),\n ) as CSegment;\n } else if (pathCommand === \"Z\") {\n return [\"C\" as string | number].concat(\n lineToCubic(px1, py1, px, py),\n ) as CSegment;\n }\n\n return segment as MSegment | CSegment;\n};\nexport default segmentToCubic;\n","import type { ParserParams } from \"../interface\";\nimport type {\n ASegment,\n CSegment,\n HSegment,\n LSegment,\n MSegment,\n NormalSegment,\n PathCommand,\n PathSegment,\n PointTuple,\n QSegment,\n VSegment,\n} from \"../types\";\n\n/**\n * Normalizes a single segment of a `pathArray` object.\n *\n * @param segment the segment object\n * @param params the normalization parameters\n * @returns the normalized segment\n */\nconst normalizeSegment = (segment: PathSegment, params: ParserParams) => {\n const [pathCommand] = segment;\n const absCommand = pathCommand.toUpperCase();\n const isRelative = pathCommand !== absCommand;\n const { x1: px1, y1: py1, x2: px2, y2: py2, x, y } = params;\n const values = segment.slice(1) as number[];\n let absValues = values.map((n, j) => n + (isRelative ? (j % 2 ? y : x) : 0));\n\n if (!\"TQ\".includes(absCommand)) {\n // optional but good to be cautious\n params.qx = null;\n params.qy = null;\n }\n\n // istanbul ignore else @preserve\n if (absCommand === \"A\") {\n absValues = values.slice(0, -2).concat(\n values[5] + (isRelative ? x : 0),\n values[6] + (isRelative ? y : 0),\n );\n\n return [\"A\" as PathCommand | number].concat(absValues) as ASegment;\n } else if (absCommand === \"H\") {\n return [\n \"L\",\n (segment as HSegment)[1] + (isRelative ? x : 0),\n py1,\n ] as LSegment;\n } else if (absCommand === \"V\") {\n return [\n \"L\",\n px1,\n (segment as VSegment)[1] + (isRelative ? y : 0),\n ] as LSegment;\n } else if (absCommand === \"L\") {\n return [\n \"L\",\n (segment as LSegment)[1] + (isRelative ? x : 0),\n (segment as LSegment)[2] + (isRelative ? y : 0),\n ] as LSegment;\n } else if (absCommand === \"M\") {\n return [\n \"M\",\n (segment as MSegment)[1] + (isRelative ? x : 0),\n (segment as MSegment)[2] + (isRelative ? y : 0),\n ] as MSegment;\n } else if (absCommand === \"C\") {\n return [\"C\" as PathCommand | number].concat(absValues) as CSegment;\n } else if (absCommand === \"S\") {\n const x1 = px1 * 2 - px2;\n const y1 = py1 * 2 - py2;\n params.x1 = x1;\n params.y1 = y1;\n return [\"C\", x1, y1].concat(absValues) as CSegment;\n } else if (absCommand === \"T\") {\n const qx = px1 * 2 - (params.qx ? params.qx : /* istanbul ignore next */ 0);\n const qy = py1 * 2 - (params.qy ? params.qy : /* istanbul ignore next */ 0);\n params.qx = qx;\n params.qy = qy;\n return [\"Q\", qx, qy].concat(absValues) as QSegment;\n } else if (absCommand === \"Q\") {\n const [nqx, nqy] = absValues as PointTuple;\n params.qx = nqx;\n params.qy = nqy;\n return [\"Q\" as PathCommand | number].concat(absValues) as QSegment;\n } else if (absCommand === \"Z\") {\n return [\"Z\"] as NormalSegment;\n }\n\n // istanbul ignore next @preserve\n return segment as NormalSegment;\n};\nexport default normalizeSegment;\n","import type { ParserParams } from \"../interface\";\n\nconst paramsParser: ParserParams = {\n x1: 0,\n y1: 0,\n x2: 0,\n y2: 0,\n x: 0,\n y: 0,\n qx: null,\n qy: null,\n};\n\nexport default paramsParser;\n","import segmentToCubic from \"../process/segmentToCubic\";\nimport { AbsoluteCommand, CSegment, CurveArray, PathArray } from \"../types\";\nimport iterate from \"../process/iterate\";\nimport parsePathString from \"../parser/parsePathString\";\nimport normalizeSegment from \"../process/normalizeSegment\";\nimport paramsParser from \"../parser/paramsParser\";\n\n/**\n * Parses a path string value or 'pathArray' and returns a new one\n * in which all segments are converted to cubic-bezier.\n *\n * In addition, un-necessary `Z` segment is removed if previous segment\n * extends to the `M` segment.\n *\n * @param pathInput the string to be parsed or 'pathArray'\n * @returns the resulted `pathArray` converted to cubic-bezier\n */\nconst pathToCurve = (pathInput: string | PathArray): CurveArray => {\n const params = { ...paramsParser };\n const path = parsePathString(pathInput);\n\n return iterate(path, (seg, index, lastX, lastY) => {\n params.x = lastX;\n params.y = lastY;\n const normalSegment = normalizeSegment(seg, params);\n let result = segmentToCubic(normalSegment, params);\n const isLongArc = result[0] === \"C\" && result.length > 7;\n\n if (isLongArc) {\n path.splice(\n index + 1,\n 0,\n [\"C\" as AbsoluteCommand | number].concat(result.slice(7)) as CSegment,\n );\n result = result.slice(0, 7) as CSegment;\n }\n\n const seglen = result.length;\n params.x1 = +result[seglen - 2];\n params.y1 = +result[seglen - 1];\n params.x2 = +result[seglen - 4] || params.x1;\n params.y2 = +result[seglen - 3] || params.y1;\n\n return result;\n });\n};\nexport default pathToCurve;\n","import { Options } from \"../interface\";\n\n/** SVGPathCommander default options */\nconst defaultOptions: Options = {\n origin: [0, 0, 0],\n round: 4,\n};\n\nexport default defaultOptions;\n","const roundTo = (n: number, round: number) => {\n const pow = round >= 1 ? 10 ** round : 1;\n\n return round > 0 ? Math.round(n * pow) / pow : Math.round(n);\n};\n\nexport default roundTo;\n","import type { PathArray, PathSegment } from \"../types\";\nimport defaultOptions from \"../options/options\";\nimport roundTo from \"../math/roundTo\";\n\n/**\n * Returns a valid `d` attribute string value created\n * by rounding values and concatenating the `pathArray` segments.\n *\n * @param path the `pathArray` object\n * @param roundOption amount of decimals to round values to\n * @returns the concatenated path string\n */\nconst pathToString = (\n path: PathArray,\n roundOption?: number | \"off\",\n): string => {\n const pathLen = path.length;\n let { round } = defaultOptions;\n let segment = path[0] as PathSegment;\n let result = \"\";\n\n // allow for ZERO decimals\n round = roundOption === \"off\"\n ? roundOption\n : typeof roundOption === \"number\" && roundOption >= 0\n ? roundOption\n : typeof round === \"number\" && round >= 0\n ? round\n : /* istanbul ignore next @preserve */ \"off\";\n\n for (let i = 0; i < pathLen; i += 1) {\n segment = path[i];\n const [pathCommand] = segment;\n const values = segment.slice(1) as number[];\n result += pathCommand;\n if (round === \"off\") {\n result += values.join(\" \");\n } else {\n let j = 0;\n const valLen = values.length;\n while (j < valLen) {\n result += roundTo(values[j], round);\n if (j !== valLen - 1) result += \" \";\n j += 1;\n }\n }\n }\n\n return result;\n};\n\nexport default pathToString;\n","const DISTANCE_EPSILON = 0.00001;\n\nexport default DISTANCE_EPSILON;\n","import normalizeSegment from \"./normalizeSegment\";\nimport type { NormalArray, PathArray } from \"../types\";\nimport iterate from \"./iterate\";\nimport parsePathString from \"../parser/parsePathString\";\nimport paramsParser from \"../parser/paramsParser\";\n\n/**\n * Normalizes a `pathArray` object for further processing:\n * * convert segments to absolute values\n * * convert shorthand path commands to their non-shorthand notation\n *\n * @param pathInput the string to be parsed or 'pathArray'\n * @returns the normalized `pathArray`\n */\nconst normalizePath = (pathInput: string | PathArray) => {\n const path = parsePathString(pathInput);\n const params = { ...paramsParser };\n\n return iterate(path, (seg, _, lastX, lastY) => {\n params.x = lastX;\n params.y = lastY;\n const result = normalizeSegment(seg, params);\n\n const seglen = result.length;\n params.x1 = +result[seglen - 2];\n params.y1 = +result[seglen - 1];\n params.x2 = +result[seglen - 4] || params.x1;\n params.y2 = +result[seglen - 3] || params.y1;\n\n return result;\n });\n};\nexport default normalizePath;\n","import DISTANCE_EPSILON from \"./distanceEpsilon\";\nimport type { MSegment, PathArray, PointTuple } from \"../types\";\nimport iterate from \"../process/iterate\";\nimport { getLineLength, getPointAtLineLength } from \"../math/lineTools\";\nimport { getArcLength, getPointAtArcLength } from \"../math/arcTools\";\nimport { getCubicLength, getPointAtCubicLength } from \"../math/cubicTools\";\nimport { getPointAtQuadLength, getQuadLength } from \"../math/quadTools\";\nimport normalizePath from \"../process/normalizePath\";\n\n/**\n * Returns [x,y] coordinates of a point at a given length of a shape.\n *\n * @param pathInput the `pathArray` to look into\n * @param distance the length of the shape to look at\n * @returns the requested {x, y} point coordinates\n */\nconst getPointAtLength = (pathInput: string | PathArray, distance?: number) => {\n const path = normalizePath(pathInput);\n let isM = false;\n let data = [] as number[];\n let pathCommand = \"M\";\n let x = 0;\n let y = 0;\n let [mx, my] = path[0].slice(1) as PointTuple;\n const distanceIsNumber = typeof distance === \"number\";\n let point = { x: mx, y: my };\n let length = 0;\n let POINT = point;\n let totalLength = 0;\n\n if (!distanceIsNumber || distance < DISTANCE_EPSILON) return point;\n\n // for (let i = 0; i < pathLen; i += 1) {\n iterate(path, (seg, _, lastX, lastY) => {\n [pathCommand] = seg;\n isM = pathCommand === \"M\";\n data = !isM ? [lastX, lastY].concat(seg.slice(1) as number[]) : data;\n\n // this segment is always ZERO\n /* istanbul ignore else @preserve */\n if (isM) {\n // remember mx, my for Z\n [, mx, my] = seg as MSegment;\n point = { x: mx, y: my };\n length = 0;\n } else if (pathCommand === \"L\") {\n point = getPointAtLineLength(\n data[0],\n data[1],\n data[2],\n data[3],\n distance - totalLength,\n );\n length = getLineLength(data[0], data[1], data[2], data[3]);\n } else if (pathCommand === \"A\") {\n point = getPointAtArcLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n data[6],\n data[7],\n data[8],\n distance - totalLength,\n );\n length = getArcLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n data[6],\n data[7],\n data[8],\n );\n } else if (pathCommand === \"C\") {\n point = getPointAtCubicLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n data[6],\n data[7],\n distance - totalLength,\n );\n length = getCubicLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n data[6],\n data[7],\n );\n } else if (pathCommand === \"Q\") {\n point = getPointAtQuadLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n distance - totalLength,\n );\n length = getQuadLength(\n data[0],\n data[1],\n data[2],\n data[3],\n data[4],\n data[5],\n );\n } else if (pathCommand === \"Z\") {\n data = [lastX, lastY, mx, my];\n point = { x: mx, y: my };\n\n length = getLineLength(data[0], data[1], data[2], data[3]);\n }\n\n [x, y] = data.slice(-2);\n\n if (totalLength < distance) {\n POINT = point;\n } else {\n // totalLength >= distance\n // stop right here\n // stop iterator now!\n return false;\n }\n\n totalLength += length;\n return;\n });\n\n // native `getPointAtLength` behavior when the given distance\n // is higher than total length\n if (distance > totalLength - DISTANCE_EPSILON) {\n return { x, y };\n }\n\n return POINT;\n};\n\nexport default getPointAtLength;\n","import type { LSegment, MSegment, PathArray, PointTuple } from \"../types\";\nimport { getLineLength } from \"../math/lineTools\";\nimport { getArcLength } from \"../math/arcTools\";\nimport { getCubicLength } from \"../math/cubicTools\";\nimport { getQuadLength } from \"../math/quadTools\";\nimport iterate from \"../process/iterate\";\nimport parsePathString from \"../parser/parsePathString\";\nimport absolutizeSegment from \"../process/absolutizeSegment\";\n\n/**\n * Returns the shape total length, or the equivalent to `shape.getTotalLength()`.\n *\n * @param pathInput the target `pathArray`\n * @returns the shape total length\n */\nconst getTotalLength = (pathInput: string | PathArray) => {\n const path = parsePathString(pathInput);\n let paramX1 = 0;\n let paramY1 = 0;\n let paramX2 = 0;\n let paramY2 = 0;\n let paramQX = 0;\n let paramQY = 0;\n let pathCommand = \"M\";\n let mx = 0;\n let my = 0;\n let totalLength = 0;\n\n iterate(path, (seg, index, lastX, lastY) => {\n [pathCommand] = seg;\n const absCommand = pathCommand.toUpperCase();\n const isRelative = absCommand !== pathCommand;\n const absoluteSegment = isRelative\n ? absolutizeSegment(seg, index, lastX, lastY)\n : (seg.slice(0) as typeof seg);\n\n const normalSegment = absCommand === \"V\"\n ? ([\"L\", lastX, absoluteSegment[1]] as LSegment)\n : absCommand === \"H\"\n ? ([\"L\", absoluteSegment[1], lastY] as LSegment)\n : absoluteSegment;\n [pathCommand] = normalSegment;\n\n if (!\"TQ\".includes(absCommand)) {\n // optional but good to be cautious\n paramQX = 0;\n paramQY = 0;\n }\n\n // this segment is always ZERO\n /* istanbul ignore else @preserve */\n if (pathCommand === \"M\") {\n // remember mx, my for Z\n [, mx, my] = normalSegment as MSegment;\n } else if (pathCommand === \"L\") {\n totalLength += getLineLength(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n );\n } else if (pathCommand === \"A\") {\n totalLength += getArcLength(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n normalSegment[5] as number,\n normalSegment[6] as number,\n normalSegment[7] as number,\n );\n } else if (pathCommand === \"S\") {\n const cp1x = paramX1 * 2 - paramX2;\n const cp1y = paramY1 * 2 - paramY2;\n\n totalLength += getCubicLength(\n lastX,\n lastY,\n cp1x,\n cp1y,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n );\n } else if (pathCommand === \"C\") {\n totalLength += getCubicLength(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n normalSegment[5] as number,\n normalSegment[6] as number,\n );\n } else if (pathCommand === \"T\") {\n paramQX = paramX1 * 2 - paramQX;\n paramQY = paramY1 * 2 - paramQY;\n totalLength += getQuadLength(\n lastX,\n lastY,\n paramQX,\n paramQY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n );\n } else if (pathCommand === \"Q\") {\n paramQX = normalSegment[1] as number;\n paramQY = normalSegment[2] as number;\n totalLength += getQuadLength(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n );\n } else if (pathCommand === \"Z\") {\n totalLength += getLineLength(lastX, lastY, mx, my);\n }\n\n // update params\n [paramX1, paramY1] = pathCommand === \"Z\"\n ? [mx, my]\n : (normalSegment.slice(-2) as PointTuple);\n [paramX2, paramY2] = pathCommand === \"C\"\n ? ([normalSegment[3], normalSegment[4]] as PointTuple)\n : pathCommand === \"S\"\n ? ([normalSegment[1], normalSegment[2]] as PointTuple)\n : [paramX1, paramY1];\n });\n\n return totalLength;\n};\n\nexport default getTotalLength;\n","import type { PathArray, PathSegment } from \"../types\";\nimport type { SegmentProperties } from \"../interface\";\nimport parsePathString from \"../parser/parsePathString\";\nimport getTotalLength from \"./getTotalLength\";\n\n/**\n * Returns the segment, its index and length as well as\n * the length to that segment at a given length in a path.\n *\n * @param pathInput target `pathArray`\n * @param distance the given length\n * @returns the requested properties\n */\nconst getPropertiesAtLength = (\n pathInput: string | PathArray,\n distance?: number,\n): SegmentProperties => {\n const pathArray = parsePathString(pathInput);\n\n let pathTemp = pathArray.slice(0) as PathArray;\n let pathLength = getTotalLength(pathTemp);\n let index = pathTemp.length - 1;\n let lengthAtSegment = 0;\n let length = 0;\n let segment = pathArray[0] as PathSegment;\n\n // If the path is empty, return 0.\n if (index <= 0 || !distance || !Number.isFinite(distance)) {\n return {\n segment,\n index: 0,\n length,\n lengthAtSegment,\n };\n }\n\n if (distance >= pathLength) {\n pathTemp = pathArray.slice(0, -1) as PathArray;\n lengthAtSegment = getTotalLength(pathTemp);\n length = pathLength - lengthAtSegment;\n segment = pathArray[index];\n return {\n segment,\n index,\n length,\n lengthAtSegment,\n };\n }\n\n const segments = [] as SegmentProperties[];\n while (index > 0) {\n segment = pathTemp[index];\n pathTemp = pathTemp.slice(0, -1) as PathArray;\n lengthAtSegment = getTotalLength(pathTemp);\n length = pathLength - lengthAtSegment;\n pathLength = lengthAtSegment;\n\n segments.push({\n segment,\n index,\n length,\n lengthAtSegment,\n });\n index -= 1;\n }\n\n return segments.find(({ lengthAtSegment: l }) =>\n l <= distance\n ) as SegmentProperties;\n};\n\nexport default getPropertiesAtLength;\n","import type { PathArray, Point } from \"../types\";\nimport type { PointProperties } from \"../interface\";\nimport getPointAtLength from \"./getPointAtLength\";\nimport getPropertiesAtLength from \"./getPropertiesAtLength\";\nimport getTotalLength from \"./getTotalLength\";\nimport parsePathString from \"../parser/parsePathString\";\nimport normalizePath from \"../process/normalizePath\";\n\n/**\n * Returns the point and segment in path closest to a given point as well as\n * the distance to the path stroke.\n *\n * @see https://bl.ocks.org/mbostock/8027637\n *\n * @param pathInput target `pathArray`\n * @param point the given point\n * @returns the requested properties\n */\nconst getPropertiesAtPoint = (\n pathInput: string | PathArray,\n point: Point,\n): PointProperties => {\n const path = parsePathString(pathInput);\n const normalPath = normalizePath(path);\n const pathLength = getTotalLength(normalPath);\n const distanceTo = (p: Point) => {\n const dx = p.x - point.x;\n const dy = p.y - point.y;\n return dx * dx + dy * dy;\n };\n let precision = 8;\n let scan: Point;\n let closest = { x: 0, y: 0 }; // make TS happy\n let scanDistance = 0;\n let bestLength = 0;\n let bestDistance = Infinity;\n\n // linear scan for coarse approximation\n for (let scanLength = 0; scanLength <= pathLength; scanLength += precision) {\n scan = getPointAtLength(normalPath, scanLength);\n scanDistance = distanceTo(scan);\n\n if (scanDistance < bestDistance) {\n closest = scan;\n bestLength = scanLength;\n bestDistance = scanDistance;\n }\n }\n\n // binary search for precise estimate\n precision /= 2;\n let before: { x: number; y: number };\n let after: { x: number; y: number };\n let beforeLength = 0;\n let afterLength = 0;\n let beforeDistance = 0;\n let afterDistance = 0;\n\n while (precision > 0.000001) {\n beforeLength = bestLength - precision;\n before = getPointAtLength(normalPath, beforeLength);\n beforeDistance = distanceTo(before);\n afterLength = bestLength + precision;\n after = getPointAtLength(normalPath, afterLength);\n afterDistance = distanceTo(after);\n\n if (beforeLength >= 0 && beforeDistance < bestDistance) {\n closest = before;\n bestLength = beforeLength;\n bestDistance = beforeDistance;\n } else if (afterLength <= pathLength && afterDistance < bestDistance) {\n closest = after;\n bestLength = afterLength;\n bestDistance = afterDistance;\n } else {\n precision /= 2;\n }\n if (precision < 0.00001) break;\n }\n\n const segment = getPropertiesAtLength(path, bestLength);\n const distance = Math.sqrt(bestDistance);\n\n return { closest, distance, segment };\n};\n\nexport default getPropertiesAtPoint;\n","import type { PathArray } from \"../types\";\nimport getPropertiesAtPoint from \"./getPropertiesAtPoint\";\n\n/**\n * Returns the point in path closest to a given point.\n *\n * @param pathInput target `pathArray`\n * @param point the given point\n * @returns the best match\n */\nconst getClosestPoint = (\n pathInput: string | PathArray,\n point: { x: number; y: number },\n) => {\n return getPropertiesAtPoint(pathInput, point).closest;\n};\n\nexport default getClosestPoint;\n","import pathToCurve from \"../convert/pathToCurve\";\nimport type { PathArray, PointTuple } from \"../types\";\n\n/**\n * Returns the area of a single cubic-bezier segment.\n *\n * http://objectmix.com/graphics/133553-area-closed-bezier-curve.html\n *\n * @param x1 the starting point X\n * @param y1 the starting point Y\n * @param c1x the first control point X\n * @param c1y the first control point Y\n * @param c2x the second control point X\n * @param c2y the second control point Y\n * @param x2 the ending point X\n * @param y2 the ending point Y\n * @returns the area of the cubic-bezier segment\n */\nconst getCubicSegArea = (\n x1: number,\n y1: number,\n c1x: number,\n c1y: number,\n c2x: number,\n c2y: number,\n x2: number,\n y2: number,\n) => {\n return (\n (3 *\n ((y2 - y1) * (c1x + c2x) -\n (x2 - x1) * (c1y + c2y) +\n c1y * (x1 - c2x) -\n c1x * (y1 - c2y) +\n y2 * (c2x + x1 / 3) -\n x2 * (c2y + y1 / 3))) /\n 20\n );\n};\n\n/**\n * Returns the area of a shape.\n *\n * @author Jürg Lehni & Jonathan Puckey\n *\n * @see https://github.com/paperjs/paper.js/blob/develop/src/path/Path.js\n *\n * @param path the shape `pathArray`\n * @returns the length of the cubic-bezier segment\n */\nconst getPathArea = (path: PathArray) => {\n let x = 0;\n let y = 0;\n let len = 0;\n\n return pathToCurve(path)\n .map((seg) => {\n switch (seg[0]) {\n case \"M\":\n [, x, y] = seg;\n return 0;\n default:\n len = getCubicSegArea(\n x,\n y,\n seg[1],\n seg[2],\n seg[3],\n seg[4],\n seg[5],\n seg[6],\n );\n [x, y] = seg.slice(-2) as PointTuple;\n return len;\n }\n })\n .reduce((a, b) => a + b, 0);\n};\nexport default getPathArea;\n","import getPathArea from \"./getPathArea\";\nimport pathToCurve from \"../convert/pathToCurve\";\nimport type { PathArray } from \"../types\";\n\n/**\n * Check if a path is drawn clockwise and returns true if so,\n * false otherwise.\n *\n * @param path the path string or `pathArray`\n * @returns true when clockwise or false if not\n */\nconst getDrawDirection = (path: string | PathArray) => {\n return getPathArea(pathToCurve(path)) >= 0;\n};\n\nexport default getDrawDirection;\n","import iterate from \"../process/iterate\";\nimport { PathBBox } from \"../interface\";\nimport { LSegment, MSegment, PathArray, PointTuple } from \"../types\";\nimport { getLineBBox } from \"../math/lineTools\";\nimport { getArcBBox } from \"../math/arcTools\";\nimport { getCubicBBox } from \"../math/cubicTools\";\nimport { getQuadBBox } from \"../math/quadTools\";\nimport parsePathString from \"../parser/parsePathString\";\nimport absolutizeSegment from \"../process/absolutizeSegment\";\n\nconst getPathBBox = (pathInput: PathArray | string) => {\n if (!pathInput) {\n return {\n x: 0,\n y: 0,\n width: 0,\n height: 0,\n x2: 0,\n y2: 0,\n cx: 0,\n cy: 0,\n cz: 0,\n };\n }\n\n const path = parsePathString(pathInput);\n let pathCommand = \"M\";\n let mx = 0;\n let my = 0;\n const { max, min } = Math;\n let xMin = Infinity;\n let yMin = Infinity;\n let xMax = -Infinity;\n let yMax = -Infinity;\n let minX = 0;\n let minY = 0;\n let maxX = 0;\n let maxY = 0;\n let paramX1 = 0;\n let paramY1 = 0;\n let paramX2 = 0;\n let paramY2 = 0;\n let paramQX = 0;\n let paramQY = 0;\n\n iterate(path, (seg, index, lastX, lastY) => {\n [pathCommand] = seg;\n const absCommand = pathCommand.toUpperCase();\n const isRelative = absCommand !== pathCommand;\n const absoluteSegment = isRelative\n ? absolutizeSegment(seg, index, lastX, lastY)\n : (seg.slice(0) as typeof seg);\n\n const normalSegment = absCommand === \"V\"\n ? ([\"L\", lastX, absoluteSegment[1]] as LSegment)\n : absCommand === \"H\"\n ? ([\"L\", absoluteSegment[1], lastY] as LSegment)\n : absoluteSegment;\n\n [pathCommand] = normalSegment;\n\n if (!\"TQ\".includes(absCommand)) {\n // optional but good to be cautious\n paramQX = 0;\n paramQY = 0;\n }\n\n // this segment is always ZERO\n /* istanbul ignore else @preserve */\n if (pathCommand === \"M\") {\n [, mx, my] = normalSegment as MSegment;\n minX = mx;\n minY = my;\n maxX = mx;\n maxY = my;\n } else if (pathCommand === \"L\") {\n [minX, minY, maxX, maxY] = getLineBBox(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n );\n } else if (pathCommand === \"A\") {\n [minX, minY, maxX, maxY] = getArcBBox(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n normalSegment[5] as number,\n normalSegment[6] as number,\n normalSegment[7] as number,\n );\n } else if (pathCommand === \"S\") {\n const cp1x = paramX1 * 2 - paramX2;\n const cp1y = paramY1 * 2 - paramY2;\n\n [minX, minY, maxX, maxY] = getCubicBBox(\n lastX,\n lastY,\n cp1x,\n cp1y,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n );\n } else if (pathCommand === \"C\") {\n [minX, minY, maxX, maxY] = getCubicBBox(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n normalSegment[5] as number,\n normalSegment[6] as number,\n );\n } else if (pathCommand === \"T\") {\n paramQX = paramX1 * 2 - paramQX;\n paramQY = paramY1 * 2 - paramQY;\n [minX, minY, maxX, maxY] = getQuadBBox(\n lastX,\n lastY,\n paramQX,\n paramQY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n );\n } else if (pathCommand === \"Q\") {\n paramQX = normalSegment[1] as number;\n paramQY = normalSegment[2] as number;\n [minX, minY, maxX, maxY] = getQuadBBox(\n lastX,\n lastY,\n normalSegment[1] as number,\n normalSegment[2] as number,\n normalSegment[3] as number,\n normalSegment[4] as number,\n );\n } else if (pathCommand === \"Z\") {\n [minX, minY, maxX, maxY] = getLineBBox(lastX, lastY, mx, my);\n }\n xMin = min(minX, xMin);\n yMin = min(minY, yMin);\n xMax = max(maxX, xMax);\n yMax = max(maxY, yMax);\n\n // update params\n [paramX1, paramY1] = pathCommand === \"Z\"\n ? [mx, my]\n : (normalSegment.slice(-2) as PointTuple);\n [paramX2, paramY2] = pathCommand === \"C\"\n ? ([normalSegment[3], normalSegment[4]] as PointTuple)\n : pathCommand === \"S\"\n ? ([normalSegment[1], normalSegment[2]] as PointTuple)\n : [paramX1, paramY1];\n });\n\n const width = xMax - xMin;\n const height = yMax - yMin;\n\n return {\n width,\n height,\n x: xMin,\n y: yMin,\n x2: xMax,\n y2: yMax,\n cx: xMin + width / 2,\n cy: yMin + height / 2,\n // an estimated guess\n cz: Math.max(width, height) + Math.min(width, height) / 2,\n } satisfies PathBBox;\n};\n\nexport default getPathBBox;\n","import type { PathArray, PathSegment } from \"../types\";\nimport getPropertiesAtLength from \"./getPropertiesAtLength\";\n\n/**\n * Returns the segment at a given length.\n *\n * @param pathInput the target `pathArray`\n * @param distance the distance in path to look at\n * @returns the requested segment\n */\nconst getSegmentAtLength = (\n pathInput: string | PathArray,\n distance?: number,\n): PathSegment | undefined => {\n return getPropertiesAtLength(pathInput, distance).segment;\n};\n\nexport default getSegmentAtLength;\n","import type { SegmentProperties } from \"../interface\";\nimport type { PathArray } from \"../types\";\nimport getPropertiesAtPoint from \"./getPropertiesAtPoint\";\n\n/**\n * Returns the path segment which contains a given point.\n *\n * @param path the `pathArray` to look into\n * @param point the point of the shape to look for\n * @returns the requested segment\n */\nconst getSegmentOfPoint = (\n path: string | PathArray,\n point: { x: number; y: number },\n): SegmentProperties | undefined => {\n return getPropertiesAtPoint(path, point).segment;\n};\nexport default getSegmentOfPoint;\n","import type { PathArray, PathSegment, RelativeCommand } from \"../types\";\nimport paramsCount from \"../parser/paramsCount\";\n\n/**\n * Iterates an array to check if it's an actual `pathArray`.\n *\n * @param path the `pathArray` to be checked\n * @returns iteration result\n */\nconst isPathArray = (path: unknown): path is PathArray => {\n return (\n Array.isArray(path) &&\n path.every((seg: PathSegment) => {\n const lk = seg[0].toLowerCase() as RelativeCommand;\n return (\n paramsCount[lk] === seg.length - 1 &&\n \"achlmqstvz\".includes(lk) &&\n (seg.slice(1) as unknown[]).every(Number.isFinite)\n );\n }) &&\n path.length > 0\n );\n};\nexport default isPathArray;\n","import type { AbsoluteArray } from \"../types\";\nimport isPathArray from \"./isPathArray\";\n\n/**\n * Iterates an array to check if it's a `pathArray`\n * with all absolute values.\n *\n * @param path the `pathArray` to be checked\n * @returns iteration result\n */\nconst isAbsoluteArray = (path: unknown): path is AbsoluteArray => {\n return (\n isPathArray(path) &&\n // `isPathArray` also checks if it's `Array`\n path.every(([x]) => x === x.toUpperCase())\n );\n};\nexport default isAbsoluteArray;\n","import type { NormalArray } from \"../types\";\nimport isAbsoluteArray from \"./isAbsoluteArray\";\n\n/**\n * Iterates an array to check if it's a `pathArray`\n * with all segments are in non-shorthand notation\n * with absolute values.\n *\n * @param {string | SVGPath.pathArray} path the `pathArray` to be checked\n * @returns {boolean} iteration result\n */\nconst isNormalizedArray = (path: unknown): path is NormalArray => {\n // `isAbsoluteArray` also checks if it's `Array`\n return isAbsoluteArray(path) && path.every(([pc]) => \"ACLMQZ\".includes(pc));\n};\nexport default isNormalizedArray;\n","import { CurveArray } from \"../types\";\nimport isNormalizedArray from \"./isNormalizedArray\";\n\n/**\n * Iterates an array to check if it's a `pathArray`\n * with all C (cubic bezier) segments.\n *\n * @param path the `Array` to be checked\n * @returns iteration result\n */\nconst isCurveArray = (path: unknown): path is CurveArray => {\n // `isPathArray` also checks if it's `Array`\n return isNormalizedArray(path) && path.every(([pc]) => \"MC\".includes(pc));\n};\nexport default isCurveArray;\n","import type { PathArray } from \"../types\";\nimport getPropertiesAtPoint from \"./getPropertiesAtPoint\";\nimport DISTANCE_EPSILON from \"./distanceEpsilon\";\n\n/**\n * Checks if a given point is in the stroke of a path.\n *\n * @param pathInput target path\n * @param point the given `{x,y}` point\n * @returns the query result\n */\nconst isPointInStroke = (\n pathInput: string | PathArray,\n point: { x: number; y: number },\n) => {\n const { distance } = getPropertiesAtPoint(pathInput, point);\n return Math.abs(distance) < DISTANCE_EPSILON; // 0.01 might be more permissive\n};\nexport default isPointInStroke;\n","import type { RelativeArray } from \"../types\";\nimport isPathArray from \"./isPathArray\";\n\n/**\n * Iterates an array to check if it's a `pathArray`\n * with relative values.\n *\n * @param path the `pathArray` to be checked\n * @returns iteration result\n */\nconst isRelativeArray = (path: unknown): path is RelativeArray => {\n return (\n isPathArray(path) &&\n // `isPathArray` checks if it's `Array`\n path.slice(1).every(([pc]) => pc === pc.toLowerCase())\n );\n};\nexport default isRelativeArray;\n","import scanSegment from \"../parser/scanSegment\";\nimport skipSpaces from \"../parser/skipSpaces\";\nimport PathParser from \"../parser/pathParser\";\n\n/**\n * Parses a path string value to determine its validity\n * then returns true if it's valid or false otherwise.\n *\n * @param pathString the path string to be parsed\n * @returns the path string validity\n */\nconst isValidPath = (pathString: string) => {\n if (typeof pathString !== \"string\" || !pathString.length) {\n return false;\n }\n\n const path = new PathParser(pathString);\n\n skipSpaces(path);\n\n while (path.index < path.max && !path.err.length) {\n scanSegment(path);\n }\n\n return !path.err.length && \"mM\".includes(path.segments[0][0]);\n};\nexport default isValidPath;\n","import type { ShapeParams } from \"../interface\";\n\n/**\n * Supported shapes and their specific parameters.\n */\nconst shapeParams: ShapeParams = {\n line: [\"x1\", \"y1\", \"x2\", \"y2\"],\n circle: [\"cx\", \"cy\", \"r\"],\n ellipse: [\"cx\", \"cy\", \"rx\", \"ry\"],\n rect: [\"width\", \"height\", \"x\", \"y\", \"rx\", \"ry\"],\n polygon: [\"points\"],\n polyline: [\"points\"],\n glyph: [\"d\"],\n};\n\nexport default shapeParams;\n","const isElement = (node?: unknown): node is Element =>\n node !== undefined && node !== null &&\n typeof node === \"object\" &&\n (node as Node).nodeType === 1; // ELEMENT_NODE\n\nexport default isElement;\n","import type {\n CircleAttr,\n EllipseAttr,\n GlyphAttr,\n LineAttr,\n PolyAttr,\n RectAttr,\n ShapeParams,\n} from \"../interface\";\nimport type { PathArray, PathSegment, ShapeOps, ShapeTypes } from \"../types\";\nimport error from \"../parser/error\";\nimport parsePathString from \"../parser/parsePathString\";\nimport shapeParams from \"./shapeParams\";\nimport isPathArray from \"./isPathArray\";\nimport isElement from \"./isElement\";\n\n/**\n * Returns a new `pathArray` from line attributes.\n *\n * @param attr shape configuration\n * @returns a new line `pathArray`\n */\nexport const getLinePath = (attr: LineAttr): PathArray => {\n let { x1, y1, x2, y2 } = attr;\n [x1, y1, x2, y2] = [x1, y1, x2, y2].map((a) => +a);\n return [\n [\"M\", x1, y1],\n [\"L\", x2, y2],\n ];\n};\n\n/**\n * Returns a new `pathArray` like from polyline/polygon attributes.\n *\n * @param attr shape configuration\n * @return a new polygon/polyline `pathArray`\n */\nexport const getPolyPath = (attr: PolyAttr): PathArray => {\n const pathArray = [] as PathSegment[];\n const points = (attr.points || \"\")\n .trim()\n .split(/[\\s|,]/)\n .map((a) => +a);\n\n let index = 0;\n while (index < points.length) {\n pathArray.push([index ? \"L\" : \"M\", points[index], points[index + 1]]);\n index += 2;\n }\n\n return (attr.type === \"polygon\"\n ? [...pathArray, [\"z\"]]\n : pathArray) as PathArray;\n};\n\n/**\n * Returns a new `pathArray` from circle attributes.\n *\n * @param attr shape configuration\n * @return a circle `pathArray`\n */\nexport const getCirclePath = (attr: CircleAttr): PathArray => {\n let { cx, cy, r } = attr;\n [cx, cy, r] = [cx, cy, r].map((a) => +a);\n\n return [\n [\"M\", cx - r, cy],\n [\"a\", r, r, 0, 1, 0, 2 * r, 0],\n [\"a\", r, r, 0, 1, 0, -2 * r, 0],\n ];\n};\n\n/**\n * Returns a new `pathArray` from ellipse attributes.\n *\n * @param attr shape configuration\n * @return an ellipse `pathArray`\n */\nexport const getEllipsePath = (attr: EllipseAttr): PathArray => {\n let { cx, cy } = attr;\n let rx = attr.rx || 0;\n let ry = attr.ry || rx;\n [cx, cy, rx, ry] = [cx, cy, rx, ry].map((a) => +a);\n\n return [\n [\"M\", cx - rx, cy],\n [\"a\", rx, ry, 0, 1, 0, 2 * rx, 0],\n [\"a\", rx, ry, 0, 1, 0, -2 * rx, 0],\n ];\n};\n\n/**\n * Returns a new `pathArray` like from rect attributes.\n *\n * @param attr object with properties above\n * @return a new `pathArray` from `` attributes\n */\nexport const getRectanglePath = (attr: RectAttr): PathArray => {\n const x = +attr.x || 0;\n const y = +attr.y || 0;\n const w = +attr.width;\n const h = +attr.height;\n let rx = +(attr.rx || 0);\n let ry = +(attr.ry || rx);\n\n // Validity checks from http://www.w3.org/TR/SVG/shapes.html#RectElement:\n if (rx || ry) {\n // rx = !rx ? ry : rx;\n // ry = !ry ? rx : ry;\n\n /* istanbul ignore else @preserve */\n if (rx * 2 > w) rx -= (rx * 2 - w) / 2;\n /* istanbul ignore else @preserve */\n if (ry * 2 > h) ry -= (ry * 2 - h) / 2;\n\n return [\n [\"M\", x + rx, y],\n [\"h\", w - rx * 2],\n [\"s\", rx, 0, rx, ry],\n [\"v\", h - ry * 2],\n [\"s\", 0, ry, -rx, ry],\n [\"h\", -w + rx * 2],\n [\"s\", -rx, 0, -rx, -ry],\n [\"v\", -h + ry * 2],\n [\"s\", 0, -ry, rx, -ry],\n ];\n }\n\n return [[\"M\", x, y], [\"h\", w], [\"v\", h], [\"H\", x], [\"Z\"]];\n};\n\n/**\n * Returns a new `pathArray` created from attributes of a ``, ``,\n * ``, ``, ``, ``, or ``.\n *\n * It can also work with an options object, see the type below\n * @see ShapeOps\n *\n * @param element target shape\n * @return the newly created `` element\n */\nconst shapeToPathArray = (\n element: ShapeTypes | ShapeOps,\n) => {\n const supportedShapes = Object.keys(shapeParams) as (keyof ShapeParams)[];\n const targetIsElement = isElement(element);\n const tagName = targetIsElement ? element.tagName : null;\n\n if (tagName && [...supportedShapes, \"path\"].every((s) => tagName !== s)) {\n throw TypeError(`${error}: \"${tagName}\" is not SVGElement`);\n }\n\n const type =\n (targetIsElement ? tagName : (element as ShapeOps).type) as ShapeOps[\n \"type\"\n ];\n const shapeAttrs = shapeParams[type] as string[];\n const config = { type } as Record;\n\n if (targetIsElement) {\n shapeAttrs.forEach((p) => {\n config[p] = element.getAttribute(p) as string;\n });\n } else {\n Object.assign(config, element);\n }\n\n // set d\n let pathArray = [] as unknown as PathArray;\n\n /* istanbul ignore else */\n if (type === \"circle\") {\n pathArray = getCirclePath(config as unknown as CircleAttr);\n } else if (type === \"ellipse\") {\n pathArray = getEllipsePath(config as unknown as EllipseAttr);\n } else if ([\"polyline\", \"polygon\"].includes(type)) {\n pathArray = getPolyPath(config as unknown as PolyAttr);\n } else if (type === \"rect\") {\n pathArray = getRectanglePath(config as unknown as RectAttr);\n } else if (type === \"line\") {\n pathArray = getLinePath(config as unknown as LineAttr);\n } else if ([\"glyph\", \"path\"].includes(type)) {\n pathArray = parsePathString(\n targetIsElement\n ? element.getAttribute(\"d\") || /* istanbul ignore next @preserve */ \"\"\n : (element as GlyphAttr).d || \"\",\n );\n }\n\n // replace target element\n if (isPathArray(pathArray) && pathArray.length) {\n return pathArray;\n }\n return false;\n};\nexport default shapeToPathArray;\n","import type { ShapeParams } from \"../interface\";\nimport type { ShapeOps, ShapeTypes } from \"../types\";\nimport pathToString from \"../convert/pathToString\";\nimport defaultOptions from \"../options/options\";\nimport error from \"../parser/error\";\nimport isValidPath from \"./isValidPath\";\nimport isElement from \"./isElement\";\nimport shapeToPathArray from \"./shapeToPathArray\";\nimport shapeParams from \"./shapeParams\";\n\n/**\n * Returns a new `` element created from attributes of a ``, ``,\n * ``, ``, ``, `` or ``. If `replace` parameter\n * is `true`, it will replace the target. The default `ownerDocument` is your current\n * `document` browser page, if you want to use in server-side using `jsdom`, you can\n * pass the `jsdom` `document` to `ownDocument`.\n *\n * It can also work with an options object, see the type below\n * @see ShapeOps\n *\n * The newly created `` element keeps all non-specific\n * attributes like `class`, `fill`, etc.\n *\n * @param element target shape\n * @param replace option to replace target\n * @param ownerDocument document for create element\n * @return the newly created `` element\n */\nconst shapeToPath = (\n element: ShapeTypes | ShapeOps,\n replace?: boolean,\n ownerDocument?: Document,\n): SVGPathElement | false => {\n const doc = ownerDocument || document;\n const supportedShapes = Object.keys(shapeParams) as (keyof ShapeParams)[];\n const targetIsElement = isElement(element);\n const tagName = targetIsElement ? element.tagName : null;\n\n if (tagName === \"path\") {\n throw TypeError(`${error}: \"${tagName}\" is already SVGPathElement`);\n }\n if (tagName && supportedShapes.every((s) => tagName !== s)) {\n throw TypeError(`${error}: \"${tagName}\" is not SVGElement`);\n }\n\n const path = doc.createElementNS(\"http://www.w3.org/2000/svg\", \"path\");\n const type =\n (targetIsElement ? tagName : (element as ShapeOps).type) as ShapeOps[\n \"type\"\n ];\n const shapeAttrs = shapeParams[type] as string[];\n const config = { type } as Record;\n\n // set d\n const round = defaultOptions.round as number;\n const pathArray = shapeToPathArray(element);\n const description = pathArray && pathArray.length\n ? pathToString(pathArray, round)\n : \"\";\n\n if (targetIsElement) {\n shapeAttrs.forEach((p) => {\n config[p] = element.getAttribute(p) as string;\n });\n // set no-specific shape attributes: fill, stroke, etc\n Object.values(element.attributes).forEach(({ name, value }) => {\n if (!shapeAttrs.includes(name)) path.setAttribute(name, value);\n });\n } else {\n Object.assign(config, element);\n // set no-specific shape attributes: fill, stroke, etc\n Object.keys(config).forEach((k) => {\n if (!shapeAttrs.includes(k) && k !== \"type\") {\n path.setAttribute(\n k.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`),\n config[k],\n );\n }\n });\n }\n\n // replace target element\n if (isValidPath(description)) {\n path.setAttribute(\"d\", description);\n if (replace && targetIsElement) {\n element.before(path, element);\n element.remove();\n }\n return path;\n }\n return false;\n};\n\nexport default shapeToPath;\n","import CSSMatrix from \"@thednp/dommatrix\";\n// import type { TransformObject } from '../interface';\nimport type { TransformObjectValues } from \"../types\";\n\n/**\n * Returns a transformation matrix to apply to `` elements.\n *\n * @see TransformObjectValues\n *\n * @param transform the `transformObject`\n * @returns a new transformation matrix\n */\nconst getSVGMatrix = (transform: TransformObjectValues): CSSMatrix => {\n let matrix = new CSSMatrix();\n const { origin } = transform;\n const [originX, originY] = origin as [number, number, number];\n const { translate } = transform;\n const { rotate } = transform;\n const { skew } = transform;\n const { scale } = transform;\n\n // set translate\n if (\n Array.isArray(translate) &&\n translate.length >= 2 &&\n translate.every((x) => !Number.isNaN(+x)) &&\n translate.some((x) => x !== 0)\n ) {\n matrix = matrix.translate(...(translate as [number, number, number?]));\n } else if (typeof translate === \"number\" && !Number.isNaN(translate)) {\n matrix = matrix.translate(translate);\n }\n\n if (rotate || skew || scale) {\n // set SVG transform-origin, always defined\n matrix = matrix.translate(originX, originY);\n\n // set rotation\n if (\n Array.isArray(rotate) &&\n rotate.length >= 2 &&\n rotate.every((x) => !Number.isNaN(+x)) &&\n rotate.some((x) => x !== 0)\n ) {\n matrix = matrix.rotate(...(rotate as [number, number, number?]));\n } else if (typeof rotate === \"number\" && !Number.isNaN(rotate)) {\n matrix = matrix.rotate(rotate);\n }\n\n // set skew(s)\n if (\n Array.isArray(skew) && skew.length === 2 && skew.every((x) =>\n !Number.isNaN(+x)\n ) && skew.some((x) => x !== 0)\n ) {\n matrix = skew[0] ? matrix.skewX(skew[0]) : matrix;\n matrix = skew[1] ? matrix.skewY(skew[1]) : matrix;\n } else if (typeof skew === \"number\" && !Number.isNaN(skew)) {\n matrix = matrix.skewX(skew);\n }\n\n // set scale\n if (\n Array.isArray(scale) && scale.length >= 2 && scale.every((x) =>\n !Number.isNaN(+x)\n ) && scale.some((x) => x !== 1)\n ) {\n matrix = matrix.scale(...(scale as [number, number, number?]));\n } else if (typeof scale === \"number\" && !Number.isNaN(scale)) {\n matrix = matrix.scale(scale);\n }\n // set SVG transform-origin\n matrix = matrix.translate(-originX, -originY);\n }\n\n return matrix;\n};\nexport default getSVGMatrix;\n","import defaultOptions from \"../options/options\";\nimport type { ParserParams } from \"../interface\";\nimport roundTo from \"../math/roundTo\";\nimport type {\n AbsoluteSegment,\n NormalSegment,\n PathCommand,\n ShortSegment,\n SSegment,\n TSegment,\n} from \"../types\";\n\n/**\n * Shorten a single segment of a `pathArray` object.\n *\n * @param segment the `absoluteSegment` object\n * @param normalSegment the `normalSegment` object\n * @param params the coordinates of the previous segment\n * @param prevCommand the path command of the previous segment\n * @returns the shortened segment\n */\nconst shortenSegment = (\n segment: AbsoluteSegment,\n normalSegment: NormalSegment,\n params: ParserParams,\n prevCommand: PathCommand,\n): ShortSegment => {\n const [pathCommand] = segment;\n const { round: defaultRound } = defaultOptions;\n const round = typeof defaultRound === \"number\"\n ? defaultRound\n : /* istanbul ignore next */ 4;\n const normalValues = normalSegment.slice(1) as number[];\n const { x1, y1, x2, y2, x, y } = params;\n const [nx, ny] = normalValues.slice(-2);\n const result = segment;\n\n if (!\"TQ\".includes(pathCommand)) {\n // optional but good to be cautious\n params.qx = null;\n params.qy = null;\n }\n\n if (pathCommand === \"L\") {\n if (roundTo(x, round) === roundTo(nx, round)) {\n return [\"V\", ny];\n } else if (roundTo(y, round) === roundTo(ny, round)) {\n return [\"H\", nx];\n }\n } else if (pathCommand === \"C\") {\n const [nx1, ny1] = normalValues;\n params.x1 = nx1;\n params.y1 = ny1;\n\n if (\n \"CS\".includes(prevCommand) &&\n ((roundTo(nx1, round) === roundTo(x1 * 2 - x2, round) &&\n roundTo(ny1, round) === roundTo(y1 * 2 - y2, round)) ||\n (roundTo(x1, round) === roundTo(x2 * 2 - x, round) &&\n roundTo(y1, round) === roundTo(y2 * 2 - y, round)))\n ) {\n return [\n \"S\",\n normalValues[2],\n normalValues[3],\n normalValues[4],\n normalValues[5],\n ] as SSegment;\n }\n } else if (pathCommand === \"Q\") {\n const [qx, qy] = normalValues;\n params.qx = qx;\n params.qy = qy;\n\n if (\n \"QT\".includes(prevCommand) &&\n roundTo(qx, round) === roundTo(x1 * 2 - x2, round) &&\n roundTo(qy, round) === roundTo(y1 * 2 - y2, round)\n ) {\n return [\"T\", normalValues[2], normalValues[3]] as TSegment;\n }\n }\n\n // ['V', 'H', 'S', 'T', 'Z'].includes(pathCommand)\n return result as ShortSegment;\n};\n\nexport default shortenSegment;\n","import type { PathCommand, PathSegment } from \"../types\";\nimport roundTo from \"../math/roundTo\";\n\nconst roundSegment = (\n segment: T,\n roundOption: number,\n) => {\n const values = (segment.slice(1) as number[]).map((n) =>\n roundTo(n, roundOption)\n );\n return [segment[0] as PathCommand | number].concat(values) as T;\n};\n\nexport default roundSegment;\n","import type { AbsoluteSegment, PathArray, PathCommand } from \"../types\";\nimport pathToAbsolute from \"../convert/pathToAbsolute\";\nimport shortenSegment from \"./shortenSegment\";\nimport paramsParser from \"../parser/paramsParser\";\nimport iterate from \"./iterate\";\nimport normalizeSegment from \"./normalizeSegment\";\nimport relativizeSegment from \"./relativizeSegment\";\nimport roundSegment from \"./roundSegment\";\n\n/**\n * Optimizes a `pathArray` object:\n * * convert segments to shorthand if possible\n * * select shortest segments from absolute and relative `pathArray`s\n *\n * @param pathInput a string or `pathArray`\n * @param roundOption the amount of decimals to round values to\n * @returns the optimized `pathArray`\n */\nconst optimizePath = (pathInput: PathArray, roundOption?: number) => {\n const path = pathToAbsolute(pathInput);\n // allow for ZERO decimals or use an aggressive value of 2\n const round = typeof roundOption === \"number\" && roundOption >= 0\n ? roundOption\n : /* istanbul ignore next @preserve */ 2;\n // this utility overrides the iterator params\n const optimParams = { ...paramsParser };\n\n const allPathCommands = [] as PathCommand[];\n let pathCommand = \"M\" as PathCommand;\n let prevCommand = \"Z\" as PathCommand;\n\n return iterate(path, (seg, i, lastX, lastY) => {\n optimParams.x = lastX;\n optimParams.y = lastY;\n const normalizedSegment = normalizeSegment(seg, optimParams);\n let result = seg;\n [pathCommand] = seg;\n\n // Save current path command\n allPathCommands[i] = pathCommand;\n if (i) {\n // Get previous path command for `shortenSegment`\n prevCommand = allPathCommands[i - 1];\n const shortSegment = shortenSegment(\n seg as AbsoluteSegment,\n normalizedSegment,\n optimParams,\n prevCommand,\n );\n const absSegment = roundSegment(shortSegment, round);\n const absString = absSegment.join(\"\");\n const relativeSegment = relativizeSegment(shortSegment, i, lastX, lastY);\n const relSegment = roundSegment(relativeSegment, round);\n const relString = relSegment.join(\"\");\n result = absString.length < relString.length ? absSegment : relSegment;\n }\n\n const seglen = normalizedSegment.length;\n optimParams.x1 = +normalizedSegment[seglen - 2];\n optimParams.y1 = +normalizedSegment[seglen - 1];\n optimParams.x2 = +normalizedSegment[seglen - 4] || optimParams.x1;\n optimParams.y2 = +normalizedSegment[seglen - 3] || optimParams.y1;\n\n return result;\n });\n};\n\nexport default optimizePath;\n","import CSSMatrix from \"@thednp/dommatrix\";\nimport { type PointTuple } from \"../types\";\n\n/**\n * Transforms a specified point using a matrix, returning a new\n * Tuple *Object* comprising of the transformed point.\n * Neither the matrix nor the original point are altered.\n *\n * @copyright thednp © 2021\n *\n * @param cssm CSSMatrix instance\n * @param v Tuple\n * @return the resulting Tuple\n */\nconst translatePoint = (\n cssm: CSSMatrix,\n v: [number, number, number, number],\n): [number, number, number, number] => {\n let m = CSSMatrix.Translate(v[0], v[1], v[2]);\n\n [, , , m.m44] = v;\n m = cssm.multiply(m);\n\n return [m.m41, m.m42, m.m43, m.m44];\n};\n\n/**\n * Returns the [x,y] projected coordinates for a given an [x,y] point\n * and an [x,y,z] perspective origin point.\n *\n * Equation found here =>\n * http://en.wikipedia.org/wiki/3D_projection#Diagram\n * Details =>\n * https://stackoverflow.com/questions/23792505/predicted-rendering-of-css-3d-transformed-pixel\n *\n * @param m the transformation matrix\n * @param point2D the initial [x,y] coordinates\n * @param origin the [x,y,z] transform origin\n * @returns the projected [x,y] coordinates\n */\nconst projection2d = (\n m: CSSMatrix,\n point2D: PointTuple,\n origin: [number, number, number],\n): PointTuple => {\n const [originX, originY, originZ] = origin;\n const [x, y, z] = translatePoint(m, [point2D[0], point2D[1], 0, 1]);\n\n const relativePositionX = x - originX;\n const relativePositionY = y - originY;\n const relativePositionZ = z - originZ;\n\n return [\n // protect against division by ZERO\n relativePositionX * (Math.abs(originZ) / Math.abs(relativePositionZ) || 1) +\n originX,\n relativePositionY * (Math.abs(originZ) / Math.abs(relativePositionZ) || 1) +\n originY,\n ];\n};\nexport default projection2d;\n","import type { CSegment, CurveArray, MSegment, PathCommand } from \"../types\";\n\n/**\n * Reverses all segments of a `pathArray`\n * which consists of only C (cubic-bezier) path commands.\n *\n * @param path the source `pathArray`\n * @returns the reversed `pathArray`\n */\nconst reverseCurve = (path: CurveArray) => {\n const rotatedCurve = path\n .slice(1)\n .map((x, i, curveOnly) =>\n !i\n ? path[0].slice(1).concat(x.slice(1) as number[])\n : curveOnly[i - 1].slice(-2).concat(x.slice(1))\n )\n .map((x) => x.map((_, i) => x[x.length - i - 2 * (1 - (i % 2))]))\n .reverse() as (MSegment | CSegment)[];\n\n return [[\"M\" as PathCommand | number].concat(rotatedCurve[0].slice(0, 2))]\n .concat(\n rotatedCurve.map((x) => [\"C\" as PathCommand | number].concat(x.slice(2))),\n ) as CurveArray;\n};\n\nexport default reverseCurve;\n","import type {\n ASegment,\n CSegment,\n HSegment,\n MSegment,\n PathArray,\n PathSegment,\n PointTuple,\n QSegment,\n SSegment,\n TSegment,\n VSegment,\n} from \"../types\";\nimport pathToAbsolute from \"../convert/pathToAbsolute\";\nimport normalizePath from \"./normalizePath\";\nimport iterate from \"./iterate\";\n\n/**\n * Reverses all segments of a `pathArray` and returns a new `pathArray` instance\n * with absolute values.\n *\n * @param pathInput the source `pathArray`\n * @returns the reversed `pathArray`\n */\nconst reversePath = (pathInput: PathArray) => {\n const absolutePath = pathToAbsolute(pathInput);\n const normalizedPath = normalizePath(absolutePath);\n const pLen = absolutePath.length;\n const isClosed = absolutePath[pLen - 1][0] === \"Z\";\n\n const reversedPath = iterate(absolutePath, (segment, i) => {\n const normalizedSegment = normalizedPath[i];\n const prevSeg = i && absolutePath[i - 1];\n const prevCommand = prevSeg && prevSeg[0];\n const nextSeg = absolutePath[i + 1];\n const nextCommand = nextSeg && nextSeg[0];\n const [pathCommand] = segment;\n const [x, y] = normalizedPath[i ? i - 1 : pLen - 1].slice(-2) as PointTuple;\n let result = segment;\n\n switch (pathCommand) {\n case \"M\":\n result = (isClosed ? [\"Z\"] : [pathCommand, x, y]) as PathSegment;\n break;\n case \"A\":\n result = [\n pathCommand,\n segment[1],\n segment[2],\n segment[3],\n segment[4],\n segment[5] === 1 ? 0 : 1,\n x,\n y,\n ] as ASegment;\n break;\n case \"C\":\n if (nextSeg && nextCommand === \"S\") {\n result = [\"S\", segment[1], segment[2], x, y] as SSegment;\n } else {\n result = [\n pathCommand,\n segment[3],\n segment[4],\n segment[1],\n segment[2],\n x,\n y,\n ] as CSegment;\n }\n break;\n case \"S\":\n if (\n prevCommand && \"CS\".includes(prevCommand) &&\n (!nextSeg || nextCommand !== \"S\")\n ) {\n result = [\n \"C\",\n normalizedSegment[3],\n normalizedSegment[4],\n normalizedSegment[1],\n normalizedSegment[2],\n x,\n y,\n ] as CSegment;\n } else {\n result = [\n pathCommand,\n normalizedSegment[1],\n normalizedSegment[2],\n x,\n y,\n ] as SSegment;\n }\n break;\n case \"Q\":\n if (nextSeg && nextCommand === \"T\") {\n result = [\"T\", x, y] as TSegment;\n } else {\n result = [pathCommand, segment[1], segment[2], x, y] as QSegment;\n }\n break;\n case \"T\":\n if (\n prevCommand && \"QT\".includes(prevCommand) &&\n (!nextSeg || nextCommand !== \"T\")\n ) {\n result = [\n \"Q\",\n normalizedSegment[1],\n normalizedSegment[2],\n x,\n y,\n ] as QSegment;\n } else {\n result = [pathCommand, x, y] as TSegment;\n }\n break;\n case \"Z\":\n result = [\"M\", x, y] as MSegment;\n break;\n case \"H\":\n result = [pathCommand, x] as HSegment;\n break;\n case \"V\":\n result = [pathCommand, y] as VSegment;\n break;\n default:\n result = [pathCommand as typeof pathCommand | number].concat(\n segment.slice(1, -2),\n x,\n y,\n ) as PathSegment;\n }\n\n return result;\n });\n\n return (\n isClosed\n ? reversedPath.reverse()\n : [reversedPath[0] as PathSegment].concat(reversedPath.slice(1).reverse())\n ) as PathArray;\n};\n\nexport default reversePath;\n","import type { PathArray } from \"../types\";\nimport defaultOptions from \"../options/options\";\nimport iterate from \"./iterate\";\nimport roundSegment from \"./roundSegment\";\n\n/**\n * Rounds the values of a `pathArray` instance to\n * a specified amount of decimals and returns it.\n *\n * @param path the source `pathArray`\n * @param roundOption the amount of decimals to round numbers to\n * @returns the resulted `pathArray` with rounded values\n */\nconst roundPath = (path: PathArray, roundOption?: number | \"off\") => {\n let { round } = defaultOptions;\n // allow for ZERO decimals\n round = roundOption === \"off\"\n ? roundOption\n : typeof roundOption === \"number\" && roundOption >= 0\n ? roundOption\n : typeof round === \"number\" && round >= 0\n ? round\n : /* istanbul ignore next @preserve */ \"off\";\n\n /* istanbul ignore else @preserve */\n if (round === \"off\") return path.slice(0) as PathArray;\n\n return iterate(path, (segment) => {\n return roundSegment(segment, round);\n });\n};\nexport default roundPath;\n","import midPoint from \"../math/midPoint\";\nimport type { CubicSegment, PointTuple } from \"../types\";\n\n/**\n * Split a cubic-bezier segment into two.\n *\n * @param pts the cubic-bezier parameters\n * @param ratio the cubic-bezier parameters\n * @return two new cubic-bezier segments\n */\nconst splitCubic = (\n pts: number[],\n ratio = 0.5,\n): [CubicSegment, CubicSegment] => {\n const t = ratio;\n const p0 = pts.slice(0, 2) as PointTuple;\n const p1 = pts.slice(2, 4) as PointTuple;\n const p2 = pts.slice(4, 6) as PointTuple;\n const p3 = pts.slice(6, 8) as PointTuple;\n const p4 = midPoint(p0, p1, t);\n const p5 = midPoint(p1, p2, t);\n const p6 = midPoint(p2, p3, t);\n const p7 = midPoint(p4, p5, t);\n const p8 = midPoint(p5, p6, t);\n const p9 = midPoint(p7, p8, t);\n\n return [\n [\"C\", p4[0], p4[1], p7[0], p7[1], p9[0], p9[1]],\n [\"C\", p8[0], p8[1], p6[0], p6[1], p3[0], p3[1]],\n ];\n};\nexport default splitCubic;\n","import paramsParser from \"../parser/paramsParser\";\nimport type {\n AbsoluteCommand,\n HSegment,\n MSegment,\n PathArray,\n PointTuple,\n RelativeCommand,\n VSegment,\n} from \"../types\";\n\n/**\n * Split a path into an `Array` of sub-path strings.\n *\n * In the process, values are converted to absolute\n * for visual consistency.\n *\n * @param pathInput the source `pathArray`\n * @return an array with all sub-path strings\n */\nconst splitPath = (pathInput: PathArray): PathArray[] => {\n const composite = [] as PathArray[];\n let path: PathArray;\n let pi = -1;\n let x = 0;\n let y = 0;\n let mx = 0;\n let my = 0;\n const params = { ...paramsParser };\n\n pathInput.forEach((seg) => {\n const [pathCommand] = seg;\n const absCommand = pathCommand.toUpperCase() as AbsoluteCommand;\n const relCommand = pathCommand.toLowerCase() as RelativeCommand;\n const isRelative = pathCommand === relCommand;\n const values = seg.slice(1) as number[];\n\n if (absCommand === \"M\") {\n pi += 1;\n [x, y] = values as PointTuple;\n x += isRelative ? params.x : 0;\n y += isRelative ? params.y : 0;\n mx = x;\n my = y;\n path = [(isRelative ? [absCommand, mx, my] : seg) as MSegment];\n } else {\n if (absCommand === \"Z\") {\n x = mx;\n y = my;\n } else if (absCommand === \"H\") {\n [, x] = seg as HSegment;\n x += isRelative ? params.x : /* istanbul ignore next @preserve */ 0;\n } else if (absCommand === \"V\") {\n [, y] = seg as VSegment;\n y += isRelative ? params.y : /* istanbul ignore next @preserve */ 0;\n } else {\n [x, y] = seg.slice(-2) as PointTuple;\n x += isRelative ? params.x : 0;\n y += isRelative ? params.y : 0;\n }\n path.push(seg);\n }\n\n params.x = x;\n params.y = y;\n composite[pi] = path;\n });\n\n return composite;\n};\nexport default splitPath;\n","import getSVGMatrix from \"./getSVGMatrix\";\nimport projection2d from \"./projection2d\";\nimport defaultOptions from \"../options/options\";\nimport type {\n AbsoluteArray,\n AbsoluteSegment,\n CSegment,\n LSegment,\n PathArray,\n TransformObjectValues,\n} from \"../types\";\nimport type { TransformObject } from \"../interface\";\nimport iterate from \"./iterate\";\nimport parsePathString from \"../parser/parsePathString\";\nimport absolutizeSegment from \"./absolutizeSegment\";\nimport arcToCubic from \"./arcToCubic\";\n\n/**\n * Apply a 2D / 3D transformation to a `pathArray` instance.\n *\n * Since *SVGElement* doesn't support 3D transformation, this function\n * creates a 2D projection of the element.\n *\n * @param path the `pathArray` to apply transformation\n * @param transform the transform functions `Object`\n * @returns the resulted `pathArray`\n */\nconst transformPath = (\n pathInput: PathArray | string,\n transform?: Partial,\n) => {\n // last x and y transformed values\n let x = 0;\n let y = 0;\n // new x and y transformed\n let lx = 0;\n let ly = 0;\n // segment params iteration index and length\n let j = 0;\n let jj = 0;\n let pathCommand = \"M\";\n // transform uses it's own set of params\n const path = parsePathString(pathInput);\n const transformProps = transform && Object.keys(transform);\n\n // when used as a static method, invalidate somehow\n if (!transform || (transformProps && !transformProps.length)) {\n return path.slice(0) as typeof path;\n }\n\n // transform origin is extremely important\n if (!transform.origin) {\n Object.assign(transform, { origin: defaultOptions.origin });\n }\n const origin = transform.origin as [number, number, number];\n const matrixInstance = getSVGMatrix(transform as TransformObjectValues);\n\n if (matrixInstance.isIdentity) return path.slice(0) as typeof path;\n\n return iterate(path, (seg, index, lastX, lastY) => {\n [pathCommand] = seg;\n const absCommand = pathCommand.toUpperCase();\n const isRelative = absCommand !== pathCommand;\n const absoluteSegment = isRelative\n ? absolutizeSegment(seg, index, lastX, lastY)\n : (seg.slice(0) as AbsoluteSegment);\n\n let result = absCommand === \"A\"\n // ? segmentToCubic(absoluteSegment, transformParams)\n ? ([\"C\" as string | number].concat(\n arcToCubic(\n lastX,\n lastY,\n absoluteSegment[1] as number,\n absoluteSegment[2] as number,\n absoluteSegment[3] as number,\n absoluteSegment[4] as number,\n absoluteSegment[5] as number,\n absoluteSegment[6] as number,\n absoluteSegment[7] as number,\n ),\n ) as CSegment)\n : absCommand === \"V\"\n ? ([\"L\", lastX, absoluteSegment[1]] as LSegment)\n : absCommand === \"H\"\n ? ([\"L\", absoluteSegment[1], lastY] as LSegment)\n : absoluteSegment;\n\n // update pathCommand\n pathCommand = result[0];\n const isLongArc = pathCommand === \"C\" && result.length > 7;\n const tempSegment =\n (isLongArc ? result.slice(0, 7) : result.slice(0)) as AbsoluteSegment;\n\n if (isLongArc) {\n path.splice(\n index + 1,\n 0,\n [\"C\" as typeof pathCommand | number].concat(\n result.slice(7),\n ) as CSegment,\n );\n result = tempSegment as CSegment;\n }\n\n if (pathCommand === \"L\") {\n [lx, ly] = projection2d(matrixInstance, [\n (result as LSegment)[1],\n (result as LSegment)[2],\n ], origin);\n\n /* istanbul ignore else @preserve */\n if (x !== lx && y !== ly) {\n result = [\"L\", lx, ly];\n } else if (y === ly) {\n result = [\"H\", lx];\n } else if (x === lx) {\n result = [\"V\", ly];\n }\n } else {\n for (j = 1, jj = result.length; j < jj; j += 2) {\n [lx, ly] = projection2d(\n matrixInstance,\n [+result[j], +result[j + 1]],\n origin,\n );\n result[j] = lx;\n result[j + 1] = ly;\n }\n }\n // now update x and y\n x = lx;\n y = ly;\n\n return result;\n });\n};\n\nexport default transformPath;\n"],"mappings":"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","names":["default","arcTools_exports","__export","angleBetween","arcLength","arcPoint","getArcBBox","getArcLength","getArcProps","getPointAtArcLength","lineTools_exports","__export","getLineBBox","getLineLength","getPointAtLineLength","midPoint","a","b","t","ax","ay","bx","by","midPoint_default","distanceSquareRoot","a","b","distanceSquareRoot_default","getLineLength","x1","y1","x2","y2","distanceSquareRoot_default","getPointAtLineLength","distance","point","length","x","y","midPoint_default","getLineBBox","min","max","arcLength","rx","ry","theta","halfTheta","sinHalfTheta","cosHalfTheta","term1","term2","length","arcPoint","cx","cy","alpha","sin","cos","cosA","sinA","x","y","angleBetween","v0","v1","v0x","v0y","v1x","v1y","p","n","getArcProps","x1","y1","RX","RY","angle","LAF","SF","abs","sqrt","PI","xRotRad","dx","dy","transformedPoint","radiiCheck","cSquareNumerator","cSquareRootDenom","cRadicand","cCoef","transformedCenter","center","startVector","startAngle","endVector","sweepAngle","endAngle","getArcLength","getPointAtArcLength","distance","point","getPointAtLineLength","ellipseComponentX","ellipseComponentY","getArcBBox","deltaAngle","min","max","tan","atan2","tangent","angle1","angle2","angle3","angle4","xArray","yArray","xMin","xMax","yMin","yMax","angleAfterStart","pP2","angleBeforeEnd","pP3","p1","p2","p4","p3","bezier_exports","__export","CBEZIER_MINMAX_EPSILON","Cvalues","Tvalues","bezierLength","calculateBezier","computeBezier","deriveBezier","getBezierLength","minmaxC","minmaxQ","points","dpoints","p","d","c","list","j","order","mt","mt2","t2","a","b","derivativeFn","l","len","sum","i","t","curve","idx","step","v1","cp","v2","min","max","E","cp1","cp2","K","T","S","L","R","Q","cubicTools_exports","__export","getCubicBBox","getCubicLength","getPointAtCubicLength","getPointAtCubicSegmentLength","getPointAtCubicSegmentLength","x1","y1","c1x","c1y","c2x","c2y","x2","y2","t","t1","getCubicLength","getBezierLength","getPointAtCubicLength","distance","distanceIsNumber","point","currentLength","getCubicBBox","cxMinMax","minmaxC","cyMinMax","quadTools_exports","__export","getPointAtQuadLength","getPointAtQuadSegmentLength","getQuadBBox","getQuadLength","getPointAtQuadSegmentLength","x1","y1","cx","cy","x2","y2","t","t1","getQuadLength","getBezierLength","getPointAtQuadLength","distance","distanceIsNumber","point","currentLength","getQuadBBox","cxMinMax","minmaxQ","cyMinMax","polygonTools_exports","__export","polygonArea","polygonLength","polygonArea","polygon","n","i","a","b","area","polygonLength","length","point","distanceSquareRoot_default","paramsCount","paramsCount_default","finalizeSegment","path","pathCommand","relativeCommand","data","paramsCount_default","finalizeSegment_default","error","error_default","scanFlag","path","index","pathValue","code","error_default","scanFlag_default","isDigit","code","isDigit_default","invalidPathValue","invalidPathValue_default","scanParam","path","max","pathValue","start","index","zeroFirst","hasCeiling","hasDecimal","hasDot","ch","error_default","invalidPathValue_default","isDigit_default","scanParam_default","isSpace","ch","isSpace_default","skipSpaces","path","pathValue","max","isSpace_default","skipSpaces_default","isPathCommand","code","isPathCommand_default","isDigitStart","code","isDigit_default","isDigitStart_default","isArcCommand","code","isArcCommand_default","isMoveCommand","code","isMoveCommand_default","scanSegment","path","max","pathValue","index","segments","cmdCode","reqParams","paramsCount_default","isPathCommand_default","error_default","invalidPathValue_default","lastSegment","isMoveCommand_default","skipSpaces_default","finalizeSegment_default","i","isArcCommand_default","scanFlag_default","scanParam_default","isDigitStart_default","scanSegment_default","PathParser","pathString","parsePathString","pathInput","path","PathParser","skipSpaces_default","scanSegment_default","parsePathString_default","absolutizeSegment","segment","index","lastX","lastY","pathCommand","absCommand","isAbsolute","absValues","seglen","j","absolutizeSegment_default","iterate","path","iterator","pathLen","segment","pathCommand","absCommand","isRelative","x","y","mx","my","segLen","i","iteratorResult","iterate_default","pathToAbsolute","pathInput","path","parsePathString_default","iterate_default","absolutizeSegment_default","pathToAbsolute_default","relativizeSegment","segment","index","lastX","lastY","pathCommand","relCommand","isRelative","relValues","seglen","j","relativizeSegment_default","pathToRelative","pathInput","path","parsePathString_default","iterate_default","relativizeSegment_default","pathToRelative_default","rotateVector","x","y","rad","sin","cos","X","Y","rotateVector_default","arcToCubic","X1","Y1","RX","RY","angle","LAF","SF","X2","Y2","recursive","x1","y1","rx","ry","x2","y2","d120","rad","res","xy","f1","f2","cx","cy","rotateVector_default","x","y","h","rx2","ry2","k","df","f2old","x2old","y2old","c1","s1","c2","s2","t","hx","hy","m1","m2","m3","m4","newres","i","ii","arcToCubic_default","quadToCubic","x1","y1","qx","qy","x2","y2","r13","r23","quadToCubic_default","lineToCubic","x1","y1","x2","y2","c1","midPoint_default","c2","lineToCubic_default","segmentToCubic","segment","params","pathCommand","values","x","y","px1","py1","px","py","arcToCubic_default","quadToCubic_default","lineToCubic_default","segmentToCubic_default","normalizeSegment","segment","params","pathCommand","absCommand","isRelative","px1","py1","px2","py2","x","y","values","absValues","n","j","x1","y1","qx","qy","nqx","nqy","normalizeSegment_default","paramsParser","paramsParser_default","pathToCurve","pathInput","params","paramsParser_default","path","parsePathString_default","iterate_default","seg","index","lastX","lastY","normalSegment","normalizeSegment_default","result","segmentToCubic_default","seglen","pathToCurve_default","defaultOptions","options_default","roundTo","n","round","pow","roundTo_default","pathToString","path","roundOption","pathLen","round","options_default","segment","result","i","pathCommand","values","j","valLen","roundTo_default","pathToString_default","distanceEpsilon_default","normalizePath","pathInput","path","parsePathString_default","params","paramsParser_default","iterate_default","seg","_","lastX","lastY","result","normalizeSegment_default","seglen","normalizePath_default","getPointAtLength","pathInput","distance","path","normalizePath_default","isM","data","pathCommand","x","y","mx","my","distanceIsNumber","point","length","POINT","totalLength","distanceEpsilon_default","iterate_default","seg","_","lastX","lastY","getPointAtLineLength","getLineLength","getPointAtArcLength","getArcLength","getPointAtCubicLength","getCubicLength","getPointAtQuadLength","getQuadLength","getPointAtLength_default","getTotalLength","pathInput","path","parsePathString_default","paramX1","paramY1","paramX2","paramY2","paramQX","paramQY","pathCommand","mx","my","totalLength","iterate_default","seg","index","lastX","lastY","absCommand","absoluteSegment","absolutizeSegment_default","normalSegment","getLineLength","getArcLength","cp1x","cp1y","getCubicLength","getQuadLength","getTotalLength_default","getPropertiesAtLength","pathInput","distance","pathArray","parsePathString_default","pathTemp","pathLength","getTotalLength_default","index","lengthAtSegment","length","segment","segments","getPropertiesAtLength_default","getPropertiesAtPoint","pathInput","point","path","parsePathString_default","normalPath","normalizePath_default","pathLength","getTotalLength_default","distanceTo","p","dx","dy","precision","scan","closest","scanDistance","bestLength","bestDistance","scanLength","getPointAtLength_default","before","after","beforeLength","afterLength","beforeDistance","afterDistance","segment","getPropertiesAtLength_default","distance","getPropertiesAtPoint_default","getClosestPoint","pathInput","point","getPropertiesAtPoint_default","getClosestPoint_default","getCubicSegArea","x1","y1","c1x","c1y","c2x","c2y","x2","y2","getPathArea","path","x","y","len","pathToCurve_default","seg","a","b","getPathArea_default","getDrawDirection","path","getPathArea_default","pathToCurve_default","getDrawDirection_default","getPathBBox","pathInput","path","parsePathString_default","pathCommand","mx","my","max","min","xMin","yMin","xMax","yMax","minX","minY","maxX","maxY","paramX1","paramY1","paramX2","paramY2","paramQX","paramQY","iterate_default","seg","index","lastX","lastY","absCommand","absoluteSegment","absolutizeSegment_default","normalSegment","getLineBBox","getArcBBox","cp1x","cp1y","getCubicBBox","getQuadBBox","width","height","getPathBBox_default","getSegmentAtLength","pathInput","distance","getPropertiesAtLength_default","getSegmentAtLength_default","getSegmentOfPoint","path","point","getPropertiesAtPoint_default","getSegmentOfPoint_default","isPathArray","path","seg","lk","paramsCount_default","isPathArray_default","isAbsoluteArray","path","isPathArray_default","x","isAbsoluteArray_default","isNormalizedArray","path","isAbsoluteArray_default","pc","isNormalizedArray_default","isCurveArray","path","isNormalizedArray_default","pc","isCurveArray_default","isPointInStroke","pathInput","point","distance","getPropertiesAtPoint_default","distanceEpsilon_default","isPointInStroke_default","isRelativeArray","path","isPathArray_default","pc","isRelativeArray_default","isValidPath","pathString","path","PathParser","skipSpaces_default","scanSegment_default","isValidPath_default","shapeParams","shapeParams_default","isElement","node","isElement_default","getLinePath","attr","x1","y1","x2","y2","getPolyPath","pathArray","points","a","index","getCirclePath","cx","cy","r","getEllipsePath","rx","ry","getRectanglePath","x","y","w","h","shapeToPathArray","element","supportedShapes","shapeParams_default","targetIsElement","isElement_default","tagName","s","error_default","type","shapeAttrs","config","p","parsePathString_default","isPathArray_default","shapeToPathArray_default","shapeToPath","element","replace","ownerDocument","doc","supportedShapes","shapeParams_default","targetIsElement","isElement_default","tagName","error_default","s","path","type","shapeAttrs","config","round","options_default","pathArray","shapeToPathArray_default","description","pathToString_default","name","value","k","m","isValidPath_default","shapeToPath_default","CSSMatrix","getSVGMatrix","transform","matrix","origin","originX","originY","translate","rotate","skew","scale","x","getSVGMatrix_default","shortenSegment","segment","normalSegment","params","prevCommand","pathCommand","defaultRound","options_default","round","normalValues","x1","y1","x2","y2","x","y","nx","ny","result","roundTo_default","nx1","ny1","qx","qy","shortenSegment_default","roundSegment","segment","roundOption","values","n","roundTo_default","roundSegment_default","optimizePath","pathInput","roundOption","path","pathToAbsolute_default","round","optimParams","paramsParser_default","allPathCommands","pathCommand","prevCommand","iterate_default","seg","i","lastX","lastY","normalizedSegment","normalizeSegment_default","result","shortSegment","shortenSegment_default","absSegment","roundSegment_default","absString","relativeSegment","relativizeSegment_default","relSegment","relString","seglen","optimizePath_default","CSSMatrix","translatePoint","cssm","v","m","projection2d","point2D","origin","originX","originY","originZ","x","y","z","relativePositionX","relativePositionY","relativePositionZ","projection2d_default","reverseCurve","path","rotatedCurve","x","i","curveOnly","_","reverseCurve_default","reversePath","pathInput","absolutePath","pathToAbsolute_default","normalizedPath","normalizePath_default","pLen","isClosed","reversedPath","iterate_default","segment","normalizedSegment","prevSeg","prevCommand","nextSeg","nextCommand","pathCommand","x","y","result","reversePath_default","roundPath","path","roundOption","round","options_default","iterate_default","segment","roundSegment_default","roundPath_default","splitCubic","pts","ratio","t","p0","p1","p2","p3","p4","midPoint_default","p5","p6","p7","p8","p9","splitCubic_default","splitPath","pathInput","composite","path","pi","x","y","mx","my","params","paramsParser_default","seg","pathCommand","absCommand","relCommand","isRelative","values","splitPath_default","transformPath","pathInput","transform","x","y","lx","ly","j","jj","pathCommand","path","parsePathString_default","transformProps","options_default","origin","matrixInstance","getSVGMatrix_default","iterate_default","seg","index","lastX","lastY","absCommand","absoluteSegment","absolutizeSegment_default","result","arcToCubic_default","isLongArc","tempSegment","projection2d_default","transformPath_default"]} \ No newline at end of file diff --git a/package.json b/package.json index 659b10d..d51f797 100755 --- a/package.json +++ b/package.json @@ -34,11 +34,8 @@ "fix:ts": "deno lint --fix src", "lint:ts": "deno lint src", "check:ts": "tsc --noEmit", - "build": "pnpm build-vite && pnpm build-util", - "build-vite": "vite build --config vite.config.mts && pnpm copy-docs", - "build-util": "vite build --config vite.config-util.mts && pnpm built-util-types", - "built-util-types": "npx tsup src/util.ts --dts-only -d dist/util", - "copy-docs": "cp dist/svg-path-commander.js docs/svg-path-commander.js && cp dist/svg-path-commander.js.map docs/svg-path-commander.js.map", + "build": "tsup", + "type-check": "tsc --noEmit", "prepublishOnly": "pnpm update && pnpm format && pnpm lint:ts && pnpm build && pnpm badges" }, "repository": { @@ -71,9 +68,8 @@ "@vitest/ui": "^3.0.5", "playwright": "^1.50.1", "typescript": "5.7.3", - "vite": "^6.0.11", - "vite-plugin-dts": "^4.5.0", - "vitest": "^3.0.5" + "vitest": "^3.0.5", + "tsup": "^8.0.2" }, "dependencies": { "@thednp/dommatrix": "^2.0.11" diff --git a/tsup.config.ts b/tsup.config.ts new file mode 100644 index 0000000..9cfd7ea --- /dev/null +++ b/tsup.config.ts @@ -0,0 +1,51 @@ +import { defineConfig } from 'tsup' + +export default defineConfig([ + // Main bundle configuration + { + entryPoints: { + 'svg-path-commander': 'src/index.ts' + }, + format: ['esm', 'cjs', 'iife'], + dts: true, + clean: true, + sourcemap: true, + minify: true, + splitting: false, + outDir: 'dist', + target: 'es2020', + globalName: 'SVGPathCommander', + outExtension: ({ format }) => ({ + js: { + esm: '.mjs', + iife: '.js', + cjs: '.cjs' + }[format] + }), + esbuildOptions(options) { + options.legalComments = 'none' + } + }, + // Util bundle configuration + { + entry: ['src/util.ts'], + format: ['esm', 'cjs', 'iife'], + clean: true, + sourcemap: true, + minify: true, + splitting: false, + outDir: 'dist/util', + target: 'es2020', + globalName: 'SVGPathCommanderUtil', + outExtension: ({ format }) => ({ + js: { + esm: '.mjs', + iife: '.js', + cjs: '.cjs' + }[format] + }), + esbuildOptions(options) { + options.legalComments = 'none' + } + } +]) \ No newline at end of file diff --git a/vite.config-util.mts b/vite.config-util.mts deleted file mode 100755 index 85f1f7f..0000000 --- a/vite.config-util.mts +++ /dev/null @@ -1,45 +0,0 @@ -"use strict"; -import { resolve } from 'node:path'; -import { defineConfig } from 'vite'; -import dts from "vite-plugin-dts"; - -const NAME = 'SVGPathCommanderUtil'; - -const fileName = { - es: `util.mjs`, - cjs: `util.cjs`, - // iife: `util.js`, - umd: `util.js`, - -}; - -export default defineConfig({ - base: './', - resolve: { - alias: { - "~": resolve(__dirname, "src"), - }, - }, - // plugins: [ - // dts({ - // outDir: 'dist/util', - // copyDtsFiles: false, - // rollupTypes: true, - // }), - // ], - build: { - emptyOutDir: true, - outDir: 'dist/util', - lib: { - entry: resolve(__dirname, 'src/util.ts'), - name: NAME, - formats: ['es', 'umd', 'cjs'], - fileName: (format: string) => fileName[format], - }, - sourcemap: true, - reportCompressedSize: true, - }, - esbuild: { - legalComments: 'none' - } -}); diff --git a/vite.config.mts b/vite.config.mts deleted file mode 100755 index 22cc43a..0000000 --- a/vite.config.mts +++ /dev/null @@ -1,52 +0,0 @@ -"use strict"; -import { resolve } from 'node:path'; -import { defineConfig } from 'vite'; -import { name } from './package.json'; -import dts from "vite-plugin-dts"; - -const getPackageName = () => { - return name.includes('@') ? name.split('/')[1] : name; -}; - -const NAME = 'SVGPathCommander'; - -const fileName = { - es: `${getPackageName()}.mjs`, - cjs: `${getPackageName()}.cjs`, - iife: `${getPackageName()}.js`, -}; - -export default defineConfig({ - base: './', - resolve: { - alias: { - "~": resolve(__dirname, "src"), - }, - }, - plugins: [ - dts({ - outDir: 'dist', - copyDtsFiles: true, - rollupTypes: true, - - }), - ], - build: { - emptyOutDir: true, - outDir: 'dist', - lib: { - entry: resolve(__dirname, 'src/index.ts'), - name: NAME, - formats: ['es', 'cjs', 'iife'], - fileName: (format: string) => fileName[format], - - }, - sourcemap: true, - reportCompressedSize: true, - - }, - esbuild: { - legalComments: 'none', - } -}); - From 9e926e60af12ec07f233bb44c29a0425bb9b4c47 Mon Sep 17 00:00:00 2001 From: Vlad Date: Tue, 4 Feb 2025 12:05:33 +0200 Subject: [PATCH 3/4] x --- package.json | 3 +- pnpm-lock.yaml | 498 +------------------------------------------------ 2 files changed, 3 insertions(+), 498 deletions(-) diff --git a/package.json b/package.json index d51f797..fd8e636 100755 --- a/package.json +++ b/package.json @@ -69,7 +69,8 @@ "playwright": "^1.50.1", "typescript": "5.7.3", "vitest": "^3.0.5", - "tsup": "^8.0.2" + "tsup": "^8.0.2", + "vite": "^6.0.11" }, "dependencies": { "@thednp/dommatrix": "^2.0.11" diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 3fb1ad2..9ea3e64 100755 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -26,7 +26,7 @@ devDependencies: specifier: ^1.50.1 version: 1.50.1 tsup: - specifier: ^8.3.6 + specifier: ^8.0.2 version: 8.3.6(typescript@5.7.3) typescript: specifier: 5.7.3 @@ -34,9 +34,6 @@ devDependencies: vite: specifier: ^6.0.11 version: 6.0.11(@types/node@22.13.0) - vite-plugin-dts: - specifier: ^4.5.0 - version: 4.5.0(@types/node@22.13.0)(typescript@5.7.3)(vite@6.0.11) vitest: specifier: ^3.0.5 version: 3.0.5(@types/node@22.13.0)(@vitest/browser@3.0.5)(@vitest/ui@3.0.5) @@ -546,50 +543,6 @@ packages: '@jridgewell/sourcemap-codec': 1.5.0 dev: true - /@microsoft/api-extractor-model@7.30.3(@types/node@22.13.0): - resolution: {integrity: sha512-yEAvq0F78MmStXdqz9TTT4PZ05Xu5R8nqgwI5xmUmQjWBQ9E6R2n8HB/iZMRciG4rf9iwI2mtuQwIzDXBvHn1w==} - dependencies: - '@microsoft/tsdoc': 0.15.1 - '@microsoft/tsdoc-config': 0.17.1 - '@rushstack/node-core-library': 5.11.0(@types/node@22.13.0) - transitivePeerDependencies: - - '@types/node' - dev: true - - /@microsoft/api-extractor@7.49.2(@types/node@22.13.0): - resolution: {integrity: sha512-DI/WnvhbkHcucxxc4ys00ejCiViFls5EKPrEfe4NV3GGpVkoM5ZXF61HZNSGA8IG0oEV4KfTqIa59Rc3wdMopw==} - hasBin: true - dependencies: - '@microsoft/api-extractor-model': 7.30.3(@types/node@22.13.0) - '@microsoft/tsdoc': 0.15.1 - '@microsoft/tsdoc-config': 0.17.1 - '@rushstack/node-core-library': 5.11.0(@types/node@22.13.0) - '@rushstack/rig-package': 0.5.3 - '@rushstack/terminal': 0.14.6(@types/node@22.13.0) - '@rushstack/ts-command-line': 4.23.4(@types/node@22.13.0) - lodash: 4.17.21 - minimatch: 3.0.8 - resolve: 1.22.10 - semver: 7.5.4 - source-map: 0.6.1 - typescript: 5.7.2 - transitivePeerDependencies: - - '@types/node' - dev: true - - /@microsoft/tsdoc-config@0.17.1: - resolution: {integrity: sha512-UtjIFe0C6oYgTnad4q1QP4qXwLhe6tIpNTRStJ2RZEPIkqQPREAwE5spzVxsdn9UaEMUqhh0AqSx3X4nWAKXWw==} - dependencies: - '@microsoft/tsdoc': 0.15.1 - ajv: 8.12.0 - jju: 1.4.0 - resolve: 1.22.10 - dev: true - - /@microsoft/tsdoc@0.15.1: - resolution: {integrity: sha512-4aErSrCR/On/e5G2hDP0wjooqDdauzEbIq8hIkIe5pXV0rtWJZvdCEKL0ykZxex+IxIwBp0eGeV48hQN07dXtw==} - dev: true - /@mswjs/interceptors@0.37.6: resolution: {integrity: sha512-wK+5pLK5XFmgtH3aQ2YVvA3HohS3xqV/OxuVOdNx9Wpnz7VE/fnC+e1A7ln6LFYeck7gOJ/dsZV6OLplOtAJ2w==} engines: {node: '>=18'} @@ -628,20 +581,6 @@ packages: resolution: {integrity: sha512-8LduaNlMZGwdZ6qWrKlfa+2M4gahzFkprZiAt2TF8uS0qQgBizKXpXURqvTJ4WtmupWxaLqjRb2UCTe72mu+Aw==} dev: true - /@rollup/pluginutils@5.1.4: - resolution: {integrity: sha512-USm05zrsFxYLPdWWq+K3STlWiT/3ELn3RcV5hJMghpeAIhxfsUIg6mt12CBJBInWMV4VneoV7SfGv8xIwo2qNQ==} - engines: {node: '>=14.0.0'} - peerDependencies: - rollup: ^1.20.0||^2.0.0||^3.0.0||^4.0.0 - peerDependenciesMeta: - rollup: - optional: true - dependencies: - '@types/estree': 1.0.6 - estree-walker: 2.0.2 - picomatch: 4.0.2 - dev: true - /@rollup/rollup-android-arm-eabi@4.34.2: resolution: {integrity: sha512-6Fyg9yQbwJR+ykVdT9sid1oc2ewejS6h4wzQltmJfSW53N60G/ah9pngXGANdy9/aaE/TcUFpWosdm7JXS1WTQ==} cpu: [arm] @@ -794,56 +733,6 @@ packages: dev: true optional: true - /@rushstack/node-core-library@5.11.0(@types/node@22.13.0): - resolution: {integrity: sha512-I8+VzG9A0F3nH2rLpPd7hF8F7l5Xb7D+ldrWVZYegXM6CsKkvWc670RlgK3WX8/AseZfXA/vVrh0bpXe2Y2UDQ==} - peerDependencies: - '@types/node': '*' - peerDependenciesMeta: - '@types/node': - optional: true - dependencies: - '@types/node': 22.13.0 - ajv: 8.13.0 - ajv-draft-04: 1.0.0(ajv@8.13.0) - ajv-formats: 3.0.1(ajv@8.13.0) - fs-extra: 11.3.0 - import-lazy: 4.0.0 - jju: 1.4.0 - resolve: 1.22.10 - semver: 7.5.4 - dev: true - - /@rushstack/rig-package@0.5.3: - resolution: {integrity: sha512-olzSSjYrvCNxUFZowevC3uz8gvKr3WTpHQ7BkpjtRpA3wK+T0ybep/SRUMfr195gBzJm5gaXw0ZMgjIyHqJUow==} - dependencies: - resolve: 1.22.10 - strip-json-comments: 3.1.1 - dev: true - - /@rushstack/terminal@0.14.6(@types/node@22.13.0): - resolution: {integrity: sha512-4nMUy4h0u5PGXVG71kEA9uYI3l8GjVqewoHOFONiM6fuqS51ORdaJZ5ZXB2VZEGUyfg1TOTSy88MF2cdAy+lqA==} - peerDependencies: - '@types/node': '*' - peerDependenciesMeta: - '@types/node': - optional: true - dependencies: - '@rushstack/node-core-library': 5.11.0(@types/node@22.13.0) - '@types/node': 22.13.0 - supports-color: 8.1.1 - dev: true - - /@rushstack/ts-command-line@4.23.4(@types/node@22.13.0): - resolution: {integrity: sha512-pqmzDJCm0TS8VyeqnzcJ7ncwXgiLDQ6LVmXXfqv2nPL6VIz+UpyTpNVfZRJpyyJ+UDxqob1vIj2liaUfBjv8/A==} - dependencies: - '@rushstack/terminal': 0.14.6(@types/node@22.13.0) - '@types/argparse': 1.0.38 - argparse: 1.0.10 - string-argv: 0.3.2 - transitivePeerDependencies: - - '@types/node' - dev: true - /@testing-library/dom@10.4.0: resolution: {integrity: sha512-pemlzrSESWbdAloYml3bAJMEfNh1Z7EduzqPKprCH5S341frlpYnUEW0H72dLxa6IsYr+mPno20GiSm+h9dEdQ==} engines: {node: '>=18'} @@ -872,10 +761,6 @@ packages: engines: {node: '>=20', pnpm: '>=8.6.0'} dev: false - /@types/argparse@1.0.38: - resolution: {integrity: sha512-ebDJ9b0e702Yr7pWgB0jzm+CX4Srzz8RcXtLJDJB+BSccqMa36uyH/zUsSYao5+BD1ytv3k3rPYCq4mAE1hsXA==} - dev: true - /@types/aria-query@5.0.4: resolution: {integrity: sha512-rfT93uj5s0PRL7EzccGMs3brplhcrghnDoV26NqKhCAS1hVo+WdNsPvE/yb6ilfr5hi2MEk6d5EWJTKdxg8jVw==} dev: true @@ -1033,121 +918,6 @@ packages: tinyrainbow: 2.0.0 dev: true - /@volar/language-core@2.4.11: - resolution: {integrity: sha512-lN2C1+ByfW9/JRPpqScuZt/4OrUUse57GLI6TbLgTIqBVemdl1wNcZ1qYGEo2+Gw8coYLgCy7SuKqn6IrQcQgg==} - dependencies: - '@volar/source-map': 2.4.11 - dev: true - - /@volar/source-map@2.4.11: - resolution: {integrity: sha512-ZQpmafIGvaZMn/8iuvCFGrW3smeqkq/IIh9F1SdSx9aUl0J4Iurzd6/FhmjNO5g2ejF3rT45dKskgXWiofqlZQ==} - dev: true - - /@volar/typescript@2.4.11: - resolution: {integrity: sha512-2DT+Tdh88Spp5PyPbqhyoYavYCPDsqbHLFwcUI9K1NlY1YgUJvujGdrqUp0zWxnW7KWNTr3xSpMuv2WnaTKDAw==} - dependencies: - '@volar/language-core': 2.4.11 - path-browserify: 1.0.1 - vscode-uri: 3.0.8 - dev: true - - /@vue/compiler-core@3.5.13: - resolution: {integrity: sha512-oOdAkwqUfW1WqpwSYJce06wvt6HljgY3fGeM9NcVA1HaYOij3mZG9Rkysn0OHuyUAGMbEbARIpsG+LPVlBJ5/Q==} - dependencies: - '@babel/parser': 7.26.7 - '@vue/shared': 3.5.13 - entities: 4.5.0 - estree-walker: 2.0.2 - source-map-js: 1.2.1 - dev: true - - /@vue/compiler-dom@3.5.13: - resolution: {integrity: sha512-ZOJ46sMOKUjO3e94wPdCzQ6P1Lx/vhp2RSvfaab88Ajexs0AHeV0uasYhi99WPaogmBlRHNRuly8xV75cNTMDA==} - dependencies: - '@vue/compiler-core': 3.5.13 - '@vue/shared': 3.5.13 - dev: true - - /@vue/compiler-vue2@2.7.16: - resolution: {integrity: sha512-qYC3Psj9S/mfu9uVi5WvNZIzq+xnXMhOwbTFKKDD7b1lhpnn71jXSFdTQ+WsIEk0ONCd7VV2IMm7ONl6tbQ86A==} - dependencies: - de-indent: 1.0.2 - he: 1.2.0 - dev: true - - /@vue/language-core@2.2.0(typescript@5.7.3): - resolution: {integrity: sha512-O1ZZFaaBGkKbsRfnVH1ifOK1/1BUkyK+3SQsfnh6PmMmD4qJcTU8godCeA96jjDRTL6zgnK7YzCHfaUlH2r0Mw==} - peerDependencies: - typescript: '*' - peerDependenciesMeta: - typescript: - optional: true - dependencies: - '@volar/language-core': 2.4.11 - '@vue/compiler-dom': 3.5.13 - '@vue/compiler-vue2': 2.7.16 - '@vue/shared': 3.5.13 - alien-signals: 0.4.14 - minimatch: 9.0.5 - muggle-string: 0.4.1 - path-browserify: 1.0.1 - typescript: 5.7.3 - dev: true - - /@vue/shared@3.5.13: - resolution: {integrity: sha512-/hnE/qP5ZoGpol0a5mDi45bOd7t3tjYJBjsgCsivow7D48cJeV5l05RD82lPqi7gRiphZM37rnhW1l6ZoCNNnQ==} - dev: true - - /acorn@8.14.0: - resolution: {integrity: sha512-cl669nCJTZBsL97OF4kUQm5g5hC2uihk0NxY3WENAC0TYdILVkAyHymAntgxGkl7K+t0cXIrH5siy5S4XkFycA==} - engines: {node: '>=0.4.0'} - hasBin: true - dev: true - - /ajv-draft-04@1.0.0(ajv@8.13.0): - resolution: {integrity: sha512-mv00Te6nmYbRp5DCwclxtt7yV/joXJPGS7nM+97GdxvuttCOfgI3K4U25zboyeX0O+myI8ERluxQe5wljMmVIw==} - peerDependencies: - ajv: ^8.5.0 - peerDependenciesMeta: - ajv: - optional: true - dependencies: - ajv: 8.13.0 - dev: true - - /ajv-formats@3.0.1(ajv@8.13.0): - resolution: {integrity: sha512-8iUql50EUR+uUcdRQ3HDqa6EVyo3docL8g5WJ3FNcWmu62IbkGUue/pEyLBW8VGKKucTPgqeks4fIU1DA4yowQ==} - peerDependencies: - ajv: ^8.0.0 - peerDependenciesMeta: - ajv: - optional: true - dependencies: - ajv: 8.13.0 - dev: true - - /ajv@8.12.0: - resolution: {integrity: sha512-sRu1kpcO9yLtYxBKvqfTeh9KzZEwO3STyX1HT+4CaDzC6HpTGYhIhPIzj9XuKU7KYDwnaeh5hcOwjy1QuJzBPA==} - dependencies: - fast-deep-equal: 3.1.3 - json-schema-traverse: 1.0.0 - require-from-string: 2.0.2 - uri-js: 4.4.1 - dev: true - - /ajv@8.13.0: - resolution: {integrity: sha512-PRA911Blj99jR5RMeTunVbNXMF6Lp4vZXnk5GQjcnUWUTsrXtekg/pnmFFI2u/I36Y/2bITGS30GZCXei6uNkA==} - dependencies: - fast-deep-equal: 3.1.3 - json-schema-traverse: 1.0.0 - require-from-string: 2.0.2 - uri-js: 4.4.1 - dev: true - - /alien-signals@0.4.14: - resolution: {integrity: sha512-itUAVzhczTmP2U5yX67xVpsbbOiquusbWVyA9N+sy6+r6YVbFkahXvNCeEPWEOMhwDYwbVbGHFkVL03N9I5g+Q==} - dev: true - /ansi-escapes@4.3.2: resolution: {integrity: sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==} engines: {node: '>=8'} @@ -1186,12 +956,6 @@ packages: resolution: {integrity: sha512-7UvmKalWRt1wgjL1RrGxoSJW/0QZFIegpeGvZG9kjp8vrRu55XTHbwnqq2GpXm9uLbcuhxm3IqX9OB4MZR1b2A==} dev: true - /argparse@1.0.10: - resolution: {integrity: sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==} - dependencies: - sprintf-js: 1.0.3 - dev: true - /aria-query@5.3.0: resolution: {integrity: sha512-b0P0sZPKtyu8HkeRAfCq0IfURZK+SuwMjY1UXGBU27wpAiTwQAIlq56IbIO+ytk/JjS1fMR14ee5WBBfKi5J6A==} dependencies: @@ -1207,13 +971,6 @@ packages: resolution: {integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==} dev: true - /brace-expansion@1.1.11: - resolution: {integrity: sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==} - dependencies: - balanced-match: 1.0.2 - concat-map: 0.0.1 - dev: true - /brace-expansion@2.0.1: resolution: {integrity: sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==} dependencies: @@ -1311,18 +1068,6 @@ packages: engines: {node: '>= 6'} dev: true - /compare-versions@6.1.1: - resolution: {integrity: sha512-4hm4VPpIecmlg59CHXnRDnqGplJFrbLG4aFEl5vl6cK1u76ws3LLvX7ikFnTDl5vo39sjWD6AaDPYodJp/NNHg==} - dev: true - - /concat-map@0.0.1: - resolution: {integrity: sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==} - dev: true - - /confbox@0.1.8: - resolution: {integrity: sha512-RMtmw0iFkeR4YV+fUOSucriAQNb9g8zFR52MWCtl+cCZOFRNL6zeB395vPzFhEjjn4fMxXudmELnl/KF/WrK6w==} - dev: true - /consola@3.4.0: resolution: {integrity: sha512-EiPU8G6dQG0GFHNR8ljnZFki/8a+cQwEQ+7wpxdChl02Q8HXlwEZWD5lqAF8vC2sEC3Tehr8hy7vErz88LHyUA==} engines: {node: ^14.18.0 || >=16.10.0} @@ -1346,10 +1091,6 @@ packages: which: 2.0.2 dev: true - /de-indent@1.0.2: - resolution: {integrity: sha512-e/1zu3xH5MQryN2zdVaF0OrdNLUbvWxzMbi+iNA6Bky7l1RoP8a2fIbRocyHclXt/arDrrR6lL3TqFD9pMQTsg==} - dev: true - /debug@4.4.0: resolution: {integrity: sha512-6WTZ/IxCY/T6BALoZHaE4ctp9xm+Z5kY/pzYaCHRFeyVhojxlrm+46y68HA6hr0TcwEssoxNiDEUJQjfPZ/RYA==} engines: {node: '>=6.0'} @@ -1392,11 +1133,6 @@ packages: resolution: {integrity: sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==} dev: true - /entities@4.5.0: - resolution: {integrity: sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==} - engines: {node: '>=0.12'} - dev: true - /es-module-lexer@1.6.0: resolution: {integrity: sha512-qqnD1yMU6tk/jnaMosogGySTZP8YtUgAffA9nMN+E/rjxcfRQ6IEk7IiozUjgxKoFHBGjTLnrHB/YC45r/59EQ==} dev: true @@ -1439,10 +1175,6 @@ packages: engines: {node: '>=6'} dev: true - /estree-walker@2.0.2: - resolution: {integrity: sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==} - dev: true - /estree-walker@3.0.3: resolution: {integrity: sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==} dependencies: @@ -1454,10 +1186,6 @@ packages: engines: {node: '>=12.0.0'} dev: true - /fast-deep-equal@3.1.3: - resolution: {integrity: sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==} - dev: true - /fdir@6.4.3(picomatch@4.0.2): resolution: {integrity: sha512-PMXmW2y1hDDfTSRc9gaXIuCCRpuoz3Kaz8cUelp3smouvfT632ozg2vrT6lJsHKKOF59YLbOGfAWGUcKEfRMQw==} peerDependencies: @@ -1485,15 +1213,6 @@ packages: signal-exit: 4.1.0 dev: true - /fs-extra@11.3.0: - resolution: {integrity: sha512-Z4XaCL6dUDHfP/jT25jJKMmtxvuwbkrD1vNSMFlo9lNLY2c5FHYSQgHPRZUjAB26TpDEoW9HCOgplrdbaPV/ew==} - engines: {node: '>=14.14'} - dependencies: - graceful-fs: 4.2.11 - jsonfile: 6.1.0 - universalify: 2.0.1 - dev: true - /fsevents@2.3.2: resolution: {integrity: sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==} engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0} @@ -1510,10 +1229,6 @@ packages: dev: true optional: true - /function-bind@1.1.2: - resolution: {integrity: sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==} - dev: true - /gensync@1.0.0-beta.2: resolution: {integrity: sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==} engines: {node: '>=6.9.0'} @@ -1541,10 +1256,6 @@ packages: engines: {node: '>=4'} dev: true - /graceful-fs@4.2.11: - resolution: {integrity: sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==} - dev: true - /graphql@16.10.0: resolution: {integrity: sha512-AjqGKbDGUFRKIRCP9tCKiIGHyriz2oHEbPIbEtcSLSs4YjReZOIPQQWek4+6hjw62H9QShXHyaGivGiYVLeYFQ==} engines: {node: ^12.22.0 || ^14.16.0 || ^16.0.0 || >=17.0.0} @@ -1555,18 +1266,6 @@ packages: engines: {node: '>=8'} dev: true - /hasown@2.0.2: - resolution: {integrity: sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==} - engines: {node: '>= 0.4'} - dependencies: - function-bind: 1.1.2 - dev: true - - /he@1.2.0: - resolution: {integrity: sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==} - hasBin: true - dev: true - /headers-polyfill@4.0.3: resolution: {integrity: sha512-IScLbePpkvO846sIwOtOTDjutRMWdXdJmXdMvk6gCBHxFO8d+QKOQedyZSxFTTFYRSmlgSTDtXqqq4pcenBXLQ==} dev: true @@ -1575,18 +1274,6 @@ packages: resolution: {integrity: sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==} dev: true - /import-lazy@4.0.0: - resolution: {integrity: sha512-rKtvo6a868b5Hu3heneU+L4yEQ4jYKLtjpnPeUdK7h0yzXGmyBTypknlkCvHFBqfX9YlorEiMM6Dnq/5atfHkw==} - engines: {node: '>=8'} - dev: true - - /is-core-module@2.16.1: - resolution: {integrity: sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==} - engines: {node: '>= 0.4'} - dependencies: - hasown: 2.0.2 - dev: true - /is-fullwidth-code-point@3.0.0: resolution: {integrity: sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==} engines: {node: '>=8'} @@ -1654,10 +1341,6 @@ packages: '@pkgjs/parseargs': 0.11.0 dev: true - /jju@1.4.0: - resolution: {integrity: sha512-8wb9Yw966OSxApiCt0K3yNJL8pnNeIv+OEq2YMidz4FKP6nonSRoOXc80iXY4JaN2FC11B9qsNmDsm+ZOfMROA==} - dev: true - /joycon@3.1.1: resolution: {integrity: sha512-34wB/Y7MW7bzjKRjUKTa46I2Z7eV62Rkhva+KkopW7Qvv/OSWBqvkSY7vusOPrNuZcUG3tApvdVgNB8POj3SPw==} engines: {node: '>=10'} @@ -1673,28 +1356,12 @@ packages: hasBin: true dev: true - /json-schema-traverse@1.0.0: - resolution: {integrity: sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==} - dev: true - /json5@2.2.3: resolution: {integrity: sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==} engines: {node: '>=6'} hasBin: true dev: true - /jsonfile@6.1.0: - resolution: {integrity: sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==} - dependencies: - universalify: 2.0.1 - optionalDependencies: - graceful-fs: 4.2.11 - dev: true - - /kolorist@1.8.0: - resolution: {integrity: sha512-Y+60/zizpJ3HRH8DCss+q95yr6145JXZo46OTpFvDZWLfRCE4qChOyk1b26nMaNpfHHgxagk9dXT5OP0Tfe+dQ==} - dev: true - /lilconfig@3.1.3: resolution: {integrity: sha512-/vlFKAoH5Cgt3Ie+JLhRbwOsCQePABiU3tJ1egGvyQ+33R/vcwM2Zl2QR/LzjsBeItPt3oSVXapn+m4nQDvpzw==} engines: {node: '>=14'} @@ -1709,22 +1376,10 @@ packages: engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0} dev: true - /local-pkg@0.5.1: - resolution: {integrity: sha512-9rrA30MRRP3gBD3HTGnC6cDFpaE1kVDWxWgqWJUN0RvDNAo+Nz/9GxB+nHOH0ifbVFy0hSA1V6vFDvnx54lTEQ==} - engines: {node: '>=14'} - dependencies: - mlly: 1.7.4 - pkg-types: 1.3.1 - dev: true - /lodash.sortby@4.7.0: resolution: {integrity: sha512-HDWXG8isMntAyRF5vZ7xKuEvOhT4AhlRt/3czTSjvGUxjYCBVRQY48ViDHyfYz9VIoBkW4TMGQNapx+l3RUwdA==} dev: true - /lodash@4.17.21: - resolution: {integrity: sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==} - dev: true - /loupe@3.1.3: resolution: {integrity: sha512-kkIp7XSkP78ZxJEsSxW3712C6teJVoeHHwgo9zJ380de7IYyJ2ISlxojcH2pC5OFLewESmnRi/+XCDIEEVyoug==} dev: true @@ -1739,13 +1394,6 @@ packages: yallist: 3.1.1 dev: true - /lru-cache@6.0.0: - resolution: {integrity: sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==} - engines: {node: '>=10'} - dependencies: - yallist: 4.0.0 - dev: true - /lz-string@1.5.0: resolution: {integrity: sha512-h5bgJWpxJNswbU7qCrV0tIKQCaS3blPDrqKWx+QxzuzL1zGUzij9XCWLrSLsJPu5t+eWA/ycetzYAO5IOMcWAQ==} hasBin: true @@ -1772,12 +1420,6 @@ packages: semver: 7.7.1 dev: true - /minimatch@3.0.8: - resolution: {integrity: sha512-6FsRAQsxQ61mw+qP1ZzbL9Bc78x2p5OqNgNpnoAFLTrX8n5Kxph0CsnhmKKNXTWjXqU5L0pGPR7hYk+XWZr60Q==} - dependencies: - brace-expansion: 1.1.11 - dev: true - /minimatch@9.0.5: resolution: {integrity: sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==} engines: {node: '>=16 || 14 >=14.17'} @@ -1790,15 +1432,6 @@ packages: engines: {node: '>=16 || 14 >=14.17'} dev: true - /mlly@1.7.4: - resolution: {integrity: sha512-qmdSIPC4bDJXgZTCR7XosJiNKySV7O215tsPtDN9iEO/7q/76b/ijtgRu/+epFXSJhijtTCCGp3DWS549P3xKw==} - dependencies: - acorn: 8.14.0 - pathe: 2.0.2 - pkg-types: 1.3.1 - ufo: 1.5.4 - dev: true - /mrmime@2.0.0: resolution: {integrity: sha512-eu38+hdgojoyq63s+yTpN4XMBdt5l8HhMhc4VKLO9KM5caLIBvUm4thi7fFaxyTmCKeNnXZ5pAlBwCUnhA09uw==} engines: {node: '>=10'} @@ -1842,10 +1475,6 @@ packages: - '@types/node' dev: true - /muggle-string@0.4.1: - resolution: {integrity: sha512-VNTrAak/KhO2i8dqqnqnAHOa3cYBwXEZe9h+D5h/1ZqFSTEFHdM65lR7RoIqq3tBBYavsOXV84NoHXZ0AkPyqQ==} - dev: true - /mute-stream@2.0.0: resolution: {integrity: sha512-WWdIxpyjEn+FhQJQQv9aQAYlHoNVdzIzUySNV1gHUPDSdZJ3yZn7pAAbQcV7B56Mvu881q9FZV+0Vx2xC44VWA==} engines: {node: ^18.17.0 || >=20.5.0} @@ -1882,19 +1511,11 @@ packages: resolution: {integrity: sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==} dev: true - /path-browserify@1.0.1: - resolution: {integrity: sha512-b7uo2UCUOYZcnF/3ID0lulOJi/bafxa1xPe7ZPsammBSpjSWQkjNxlt635YGS2MiR9GjvuXCtz2emr3jbsz98g==} - dev: true - /path-key@3.1.1: resolution: {integrity: sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==} engines: {node: '>=8'} dev: true - /path-parse@1.0.7: - resolution: {integrity: sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==} - dev: true - /path-scurry@1.11.1: resolution: {integrity: sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==} engines: {node: '>=16 || 14 >=14.18'} @@ -1930,14 +1551,6 @@ packages: engines: {node: '>= 6'} dev: true - /pkg-types@1.3.1: - resolution: {integrity: sha512-/Jm5M4RvtBFVkKWRu2BLUTNP8/M2a+UwuAX+ae4770q1qVGtfjG+WTCupoZixokjmHiry8uI+dlY8KXYV5HVVQ==} - dependencies: - confbox: 0.1.8 - mlly: 1.7.4 - pathe: 2.0.2 - dev: true - /playwright-core@1.50.1: resolution: {integrity: sha512-ra9fsNWayuYumt+NiM069M6OkcRb1FZSK8bgi66AtpFoWkg2+y0bJSNmkFrWhMbEBbVKC/EruAHH3g0zmtwGmQ==} engines: {node: '>=18'} @@ -2026,11 +1639,6 @@ packages: engines: {node: '>=0.10.0'} dev: true - /require-from-string@2.0.2: - resolution: {integrity: sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==} - engines: {node: '>=0.10.0'} - dev: true - /requires-port@1.0.0: resolution: {integrity: sha512-KigOCHcocU3XODJxsu8i/j8T9tzT4adHiecwORRQ0ZZFcp7ahwXuRU1m+yuO90C5ZUyGeGfocHDI14M3L3yDAQ==} dev: true @@ -2040,16 +1648,6 @@ packages: engines: {node: '>=8'} dev: true - /resolve@1.22.10: - resolution: {integrity: sha512-NPRy+/ncIMeDlTAsuqwKIiferiawhefFJtkNSW0qZJEqMEb+qBt/77B/jGeeek+F0uOeN05CDa6HXbbIgtVX4w==} - engines: {node: '>= 0.4'} - hasBin: true - dependencies: - is-core-module: 2.16.1 - path-parse: 1.0.7 - supports-preserve-symlinks-flag: 1.0.0 - dev: true - /rollup@4.34.2: resolution: {integrity: sha512-sBDUoxZEaqLu9QeNalL8v3jw6WjPku4wfZGyTU7l7m1oC+rpRihXc/n/H+4148ZkGz5Xli8CHMns//fFGKvpIQ==} engines: {node: '>=18.0.0', npm: '>=8.0.0'} @@ -2084,14 +1682,6 @@ packages: hasBin: true dev: true - /semver@7.5.4: - resolution: {integrity: sha512-1bCSESV6Pv+i21Hvpxp3Dx+pSD8lIPt8uVjRrxAUt/nbswYc+tK6Y2btiULjd4+fnq15PX+nqQDC7Oft7WkwcA==} - engines: {node: '>=10'} - hasBin: true - dependencies: - lru-cache: 6.0.0 - dev: true - /semver@7.7.1: resolution: {integrity: sha512-hlq8tAfn0m/61p4BVRcPzIGr6LKiMwo4VM6dGi6pt4qcRkmNzTcWq6eCEjEh+qXjkMDvPlOFFSGwQjoEa6gyMA==} engines: {node: '>=10'} @@ -2133,11 +1723,6 @@ packages: engines: {node: '>=0.10.0'} dev: true - /source-map@0.6.1: - resolution: {integrity: sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==} - engines: {node: '>=0.10.0'} - dev: true - /source-map@0.8.0-beta.0: resolution: {integrity: sha512-2ymg6oRBpebeZi9UUNsgQ89bhx01TcTkmNTGnNO88imTmbSgy4nfujrgVEFKWpMTEGA11EDkTt7mqObTPdigIA==} engines: {node: '>= 8'} @@ -2145,10 +1730,6 @@ packages: whatwg-url: 7.1.0 dev: true - /sprintf-js@1.0.3: - resolution: {integrity: sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==} - dev: true - /stackback@0.0.2: resolution: {integrity: sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==} dev: true @@ -2166,11 +1747,6 @@ packages: resolution: {integrity: sha512-vMgjE/GGEPEFnhFub6pa4FmJBRBVOLpIII2hvCZ8Kzb7K0hlHo7mQv6xYrBvCL2LtAIBwFUK8wvuJgTVSQ5MFQ==} dev: true - /string-argv@0.3.2: - resolution: {integrity: sha512-aqD2Q0144Z+/RqG52NeHEkZauTAUWJO8c6yTftGJKO3Tja5tUgIfmIl6kExvhtxSDP7fXB6DvzkfMpCd/F3G+Q==} - engines: {node: '>=0.6.19'} - dev: true - /string-width@4.2.3: resolution: {integrity: sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==} engines: {node: '>=8'} @@ -2203,11 +1779,6 @@ packages: ansi-regex: 6.1.0 dev: true - /strip-json-comments@3.1.1: - resolution: {integrity: sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==} - engines: {node: '>=8'} - dev: true - /sucrase@3.35.0: resolution: {integrity: sha512-8EbVDiu9iN/nESwxeSxDKe0dunta1GOlHufmSSXxMD2z2/tMZpDMpvXQGsc+ajGo8y2uYUmixaSRUc/QPoQ0GA==} engines: {node: '>=16 || 14 >=14.17'} @@ -2229,18 +1800,6 @@ packages: has-flag: 4.0.0 dev: true - /supports-color@8.1.1: - resolution: {integrity: sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==} - engines: {node: '>=10'} - dependencies: - has-flag: 4.0.0 - dev: true - - /supports-preserve-symlinks-flag@1.0.0: - resolution: {integrity: sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==} - engines: {node: '>= 0.4'} - dev: true - /test-exclude@7.0.1: resolution: {integrity: sha512-pFYqmTw68LXVjeWJMST4+borgQP2AyMNbg1BpZh9LbyhUeNkeaPF9gzfPGUAnSMV3qPYdWUwDIjjCLiSDOl7vg==} engines: {node: '>=18'} @@ -2377,22 +1936,12 @@ packages: engines: {node: '>=16'} dev: true - /typescript@5.7.2: - resolution: {integrity: sha512-i5t66RHxDvVN40HfDd1PsEThGNnlMCMT3jMUuoh9/0TaqWevNontacunWyN02LA9/fIbEWlcHZcgTKb9QoaLfg==} - engines: {node: '>=14.17'} - hasBin: true - dev: true - /typescript@5.7.3: resolution: {integrity: sha512-84MVSjMEHP+FQRPy3pX9sTVV/INIex71s9TL2Gm5FG/WG1SqXeKyZ0k7/blY/4FdOzI12CBy1vGc4og/eus0fw==} engines: {node: '>=14.17'} hasBin: true dev: true - /ufo@1.5.4: - resolution: {integrity: sha512-UsUk3byDzKd04EyoZ7U4DOlxQaD14JUKQl6/P7wiX4FNvUfm3XL246n9W5AmqwW5RSFJ27NAuM0iLscAOYUiGQ==} - dev: true - /undici-types@6.20.0: resolution: {integrity: sha512-Ny6QZ2Nju20vw1SRHe3d9jVu6gJ+4e3+MMpqu7pqE5HT6WsTSlce++GQmK5UXS8mzV8DSYHrQH+Xrf2jVcuKNg==} dev: true @@ -2402,11 +1951,6 @@ packages: engines: {node: '>= 4.0.0'} dev: true - /universalify@2.0.1: - resolution: {integrity: sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==} - engines: {node: '>= 10.0.0'} - dev: true - /update-browserslist-db@1.1.2(browserslist@4.24.4): resolution: {integrity: sha512-PPypAm5qvlD7XMZC3BujecnaOxwhrtoFR+Dqkk5Aa/6DssiH0ibKoketaj9w8LP7Bont1rYeoV5plxD7RTEPRg==} hasBin: true @@ -2418,12 +1962,6 @@ packages: picocolors: 1.1.1 dev: true - /uri-js@4.4.1: - resolution: {integrity: sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==} - dependencies: - punycode: 2.3.1 - dev: true - /url-parse@1.5.10: resolution: {integrity: sha512-WypcfiRhfeUP9vvF0j6rw0J3hrWrw6iZv3+22h6iRMJ/8z1Tj6XfLP4DsUix5MhMPnXpiHDoKyoZ/bdCkwBCiQ==} dependencies: @@ -2456,32 +1994,6 @@ packages: - yaml dev: true - /vite-plugin-dts@4.5.0(@types/node@22.13.0)(typescript@5.7.3)(vite@6.0.11): - resolution: {integrity: sha512-M1lrPTdi7gilLYRZoLmGYnl4fbPryVYsehPN9JgaxjJKTs8/f7tuAlvCCvOLB5gRDQTTKnptBcB0ACsaw2wNLw==} - peerDependencies: - typescript: '*' - vite: '*' - peerDependenciesMeta: - vite: - optional: true - dependencies: - '@microsoft/api-extractor': 7.49.2(@types/node@22.13.0) - '@rollup/pluginutils': 5.1.4 - '@volar/typescript': 2.4.11 - '@vue/language-core': 2.2.0(typescript@5.7.3) - compare-versions: 6.1.1 - debug: 4.4.0 - kolorist: 1.8.0 - local-pkg: 0.5.1 - magic-string: 0.30.17 - typescript: 5.7.3 - vite: 6.0.11(@types/node@22.13.0) - transitivePeerDependencies: - - '@types/node' - - rollup - - supports-color - dev: true - /vite@6.0.11(@types/node@22.13.0): resolution: {integrity: sha512-4VL9mQPKoHy4+FE0NnRE/kbY51TOfaknxAjt3fJbGJxhIpBZiqVzlZDEesWWsuREXHwNdAoOFZ9MkPEVXczHwg==} engines: {node: ^18.0.0 || ^20.0.0 || >=22.0.0} @@ -2596,10 +2108,6 @@ packages: - yaml dev: true - /vscode-uri@3.0.8: - resolution: {integrity: sha512-AyFQ0EVmsOZOlAnxoFOGOq1SQDWAB7C6aqMGS23svWAllfOaxbuFvcT8D1i8z3Gyn8fraVeZNNmN6e9bxxXkKw==} - dev: true - /webidl-conversions@4.0.2: resolution: {integrity: sha512-YQ+BmxuTgd6UXZW3+ICGfyqRyHXVlD5GtQr5+qjiNW7bF0cqrzX500HVXPBOvgXb5YnzDd+h0zqyv61KUD7+Sg==} dev: true @@ -2678,10 +2186,6 @@ packages: resolution: {integrity: sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==} dev: true - /yallist@4.0.0: - resolution: {integrity: sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==} - dev: true - /yargs-parser@21.1.1: resolution: {integrity: sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==} engines: {node: '>=12'} From 74496fc4bbd1b428530a570908d136d2427c2857 Mon Sep 17 00:00:00 2001 From: Vlad Date: Tue, 4 Feb 2025 12:06:13 +0200 Subject: [PATCH 4/4] x --- package.json | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/package.json b/package.json index fd8e636..7736ee0 100755 --- a/package.json +++ b/package.json @@ -34,7 +34,8 @@ "fix:ts": "deno lint --fix src", "lint:ts": "deno lint src", "check:ts": "tsc --noEmit", - "build": "tsup", + "build": "tsup && pnpm copy-docs", + "copy-docs": "cp dist/svg-path-commander.js docs/svg-path-commander.js && cp dist/svg-path-commander.js.map docs/svg-path-commander.js.map", "type-check": "tsc --noEmit", "prepublishOnly": "pnpm update && pnpm format && pnpm lint:ts && pnpm build && pnpm badges" },