svg-path-commander 1.0.5 → 2.0.0-alpha2

package/types/svg-path-commander.d.ts

@@ -1,1089 +0,0 @@
-declare module "svg-path-commander/src/parser/paramsCount" {
-    export default paramsCount;
-    /**
-     * Segment params length
-     * @type {Record<string, number>}
-     */
-    const paramsCount: Record<string, number>;
-}
-declare module "svg-path-commander/src/parser/finalizeSegment" {
-    /**
-     * Breaks the parsing of a pathString once a segment is finalized.
-     *
-     * @param {SVGPath.PathParser} path the `PathParser` instance
-     */
-    export default function finalizeSegment(path: SVGPath.PathParser): void;
-}
-declare module "svg-path-commander/src/parser/error" {
-    export default error;
-    const error: "SVGPathCommander error";
-}
-declare module "svg-path-commander/src/parser/scanFlag" {
-    /**
-     * Validates an A (arc-to) specific path command value.
-     * Usually a `large-arc-flag` or `sweep-flag`.
-     *
-     * @param {SVGPath.PathParser} path the `PathParser` instance
-     */
-    export default function scanFlag(path: SVGPath.PathParser): void;
-}
-declare module "svg-path-commander/src/parser/isDigit" {
-    /**
-     * Checks if a character is a digit.
-     *
-     * @param {number} code the character to check
-     * @returns {boolean} check result
-     */
-    export default function isDigit(code: number): boolean;
-}
-declare module "svg-path-commander/src/parser/invalidPathValue" {
-    export default invalidPathValue;
-    const invalidPathValue: "Invalid path value";
-}
-declare module "svg-path-commander/src/parser/scanParam" {
-    /**
-     * Validates every character of the path string,
-     * every path command, negative numbers or floating point numbers.
-     *
-     * @param {SVGPath.PathParser} path the `PathParser` instance
-     */
-    export default function scanParam(path: SVGPath.PathParser): void;
-}
-declare module "svg-path-commander/src/parser/isSpace" {
-    /**
-     * Checks if the character is a space.
-     *
-     * @param {number} ch the character to check
-     * @returns {boolean} check result
-     */
-    export default function isSpace(ch: number): boolean;
-}
-declare module "svg-path-commander/src/parser/skipSpaces" {
-    /**
-     * Points the parser to the next character in the
-     * path string every time it encounters any kind of
-     * space character.
-     *
-     * @param {SVGPath.PathParser} path the `PathParser` instance
-     */
-    export default function skipSpaces(path: SVGPath.PathParser): void;
-}
-declare module "svg-path-commander/src/parser/isPathCommand" {
-    /**
-     * Checks if the character is a path command.
-     *
-     * @param {any} code the character to check
-     * @returns {boolean} check result
-     */
-    export default function isPathCommand(code: any): boolean;
-}
-declare module "svg-path-commander/src/parser/isDigitStart" {
-    /**
-     * Checks if the character is or belongs to a number.
-     * [0-9]|+|-|.
-     *
-     * @param {number} code the character to check
-     * @returns {boolean} check result
-     */
-    export default function isDigitStart(code: number): boolean;
-}
-declare module "svg-path-commander/src/parser/isArcCommand" {
-    /**
-     * Checks if the character is an A (arc-to) path command.
-     *
-     * @param {number} code the character to check
-     * @returns {boolean} check result
-     */
-    export default function isArcCommand(code: number): boolean;
-}
-declare module "svg-path-commander/src/parser/scanSegment" {
-    /**
-     * Scans every character in the path string to determine
-     * where a segment starts and where it ends.
-     *
-     * @param {SVGPath.PathParser} path the `PathParser` instance
-     */
-    export default function scanSegment(path: SVGPath.PathParser): void;
-}
-declare module "svg-path-commander/src/process/clonePath" {
-    /**
-     * Returns a clone of an existing `pathArray`.
-     *
-     * @param {SVGPath.pathArray | SVGPath.pathSegment} path the source `pathArray`
-     * @returns {any} the cloned `pathArray`
-     */
-    export default function clonePath(path: SVGPath.pathArray | SVGPath.pathSegment): any;
-}
-declare module "svg-path-commander/src/parser/pathParser" {
-    /**
-     * The `PathParser` is used by the `parsePathString` static method
-     * to generate a `pathArray`.
-     *
-     * @param {string} pathString
-     */
-    export default function PathParser(pathString: string): void;
-    export default class PathParser {
-        /**
-         * The `PathParser` is used by the `parsePathString` static method
-         * to generate a `pathArray`.
-         *
-         * @param {string} pathString
-         */
-        constructor(pathString: string);
-        /** @type {SVGPath.pathArray} */
-        segments: SVGPath.pathArray;
-        /** @type {string} */
-        pathValue: string;
-        /** @type {number} */
-        max: number;
-        /** @type {number} */
-        index: number;
-        /** @type {number} */
-        param: number;
-        /** @type {number} */
-        segmentStart: number;
-        /** @type {any} */
-        data: any;
-        /** @type {string} */
-        err: string;
-    }
-}
-declare module "svg-path-commander/src/util/isPathArray" {
-    /**
-     * Iterates an array to check if it's an actual `pathArray`.
-     *
-     * @param {string | SVGPath.pathArray} path the `pathArray` to be checked
-     * @returns {boolean} iteration result
-     */
-    export default function isPathArray(path: string | SVGPath.pathArray): boolean;
-}
-declare module "svg-path-commander/src/parser/parsePathString" {
-    /**
-     * Parses a path string value and returns an array
-     * of segments we like to call `pathArray`.
-     *
-     * @param {SVGPath.pathArray | string} pathInput the string to be parsed
-     * @returns {SVGPath.pathArray | string} the resulted `pathArray`
-     */
-    export default function parsePathString(pathInput: SVGPath.pathArray | string): SVGPath.pathArray | string;
-}
-declare module "svg-path-commander/src/util/isAbsoluteArray" {
-    /**
-     * Iterates an array to check if it's a `pathArray`
-     * with all absolute values.
-     *
-     * @param {string | SVGPath.pathArray} path the `pathArray` to be checked
-     * @returns {boolean} iteration result
-     */
-    export default function isAbsoluteArray(path: string | SVGPath.pathArray): boolean;
-}
-declare module "svg-path-commander/src/convert/pathToAbsolute" {
-    /**
-     * Parses a path string value or object and returns an array
-     * of segments, all converted to absolute values.
-     *
-     * @param {string | SVGPath.pathArray} pathInput the path string | object
-     * @returns {SVGPath.absoluteArray} the resulted `pathArray` with absolute values
-     */
-    export default function pathToAbsolute(pathInput: string | SVGPath.pathArray): SVGPath.absoluteArray;
-}
-declare module "svg-path-commander/src/util/isRelativeArray" {
-    /**
-     * Iterates an array to check if it's a `pathArray`
-     * with relative values.
-     *
-     * @param {string | SVGPath.pathArray} path the `pathArray` to be checked
-     * @returns {boolean} iteration result
-     */
-    export default function isRelativeArray(path: string | SVGPath.pathArray): boolean;
-}
-declare module "svg-path-commander/src/convert/pathToRelative" {
-    /**
-     * Parses a path string value or object and returns an array
-     * of segments, all converted to relative values.
-     *
-     * @param {string | SVGPath.pathArray} pathInput the path string | object
-     * @returns {SVGPath.relativeArray} the resulted `pathArray` with relative values
-     */
-    export default function pathToRelative(pathInput: string | SVGPath.pathArray): SVGPath.relativeArray;
-}
-declare module "svg-path-commander/src/process/fixArc" {
-    /**
-     * Splits an extended A (arc-to) segment into two cubic-bezier segments.
-     *
-     * @param {SVGPath.pathArray} path the `pathArray` this segment belongs to
-     * @param {string[]} allPathCommands all previous path commands
-     * @param {number} i the segment index
-     */
-    export default function fixArc(path: SVGPath.pathArray, allPathCommands: string[], i: number): void;
-}
-declare module "svg-path-commander/src/process/shorthandToQuad" {
-    /**
-     * Returns the missing control point from an
-     * T (shorthand quadratic bezier) segment.
-     *
-     * @param {number} x1 curve start x
-     * @param {number} y1 curve start y
-     * @param {number} qx control point x
-     * @param {number} qy control point y
-     * @param {string} prevCommand the previous path command
-     * @returns {{qx: number, qy: number}}} the missing control point
-     */
-    export default function shorthandToQuad(x1: number, y1: number, qx: number, qy: number, prevCommand: string): {
-        qx: number;
-        qy: number;
-    };
-}
-declare module "svg-path-commander/src/process/shorthandToCubic" {
-    /**
-     * Returns the missing control point from an
-     * S (shorthand cubic bezier) segment.
-     *
-     * @param {number} x1 curve start x
-     * @param {number} y1 curve start y
-     * @param {number} x2 curve end x
-     * @param {number} y2 curve end y
-     * @param {string} prevCommand the previous path command
-     * @returns {{x1: number, y1: number}}} the missing control point
-     */
-    export default function shorthandToCubic(x1: number, y1: number, x2: number, y2: number, prevCommand: string): {
-        x1: number;
-        y1: number;
-    };
-}
-declare module "svg-path-commander/src/process/normalizeSegment" {
-    /**
-     * Normalizes a single segment of a `pathArray` object.
-     *
-     * @param {SVGPath.pathSegment} segment the segment object
-     * @param {any} params the coordinates of the previous segment
-     * @param {string} prevCommand the path command of the previous segment
-     * @returns {SVGPath.normalSegment} the normalized segment
-     */
-    export default function normalizeSegment(segment: SVGPath.pathSegment, params: any, prevCommand: string): SVGPath.normalSegment;
-}
-declare module "svg-path-commander/src/util/isNormalizedArray" {
-    /**
-     * 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
-     */
-    export default function isNormalizedArray(path: string | SVGPath.pathArray): boolean;
-}
-declare module "svg-path-commander/src/parser/paramsParser" {
-    export default paramsParser;
-    /**
-     * @type {SVGPath.parserParams}
-     */
-    const paramsParser: SVGPath.parserParams;
-}
-declare module "svg-path-commander/src/process/normalizePath" {
-    /**
-     * Normalizes a `path` object for further processing:
-     * * convert segments to absolute values
-     * * convert shorthand path commands to their non-shorthand notation
-     *
-     * @param {string | SVGPath.pathArray} pathInput the string to be parsed or 'pathArray'
-     * @returns {SVGPath.normalArray} the normalized `pathArray`
-     */
-    export default function normalizePath(pathInput: string | SVGPath.pathArray): SVGPath.normalArray;
-}
-declare module "svg-path-commander/src/process/fixPath" {
-    /**
-     * Checks a `pathArray` for an unnecessary `Z` segment
-     * and returns a new `pathArray` without it.
-     *
-     * The `pathInput` must be a single path, without
-     * sub-paths. For multi-path `<path>` elements,
-     * use `splitPath` first and apply this utility on each
-     * sub-path separately.
-     *
-     * @param {SVGPath.pathArray | string} pathInput the `pathArray` source
-     * @return {SVGPath.pathArray} a fixed `pathArray`
-     */
-    export default function fixPath(pathInput: SVGPath.pathArray | string): SVGPath.pathArray;
-}
-declare module "svg-path-commander/src/util/isCurveArray" {
-    /**
-     * Iterates an array to check if it's a `pathArray`
-     * with all C (cubic bezier) segments.
-     *
-     * @param {string | SVGPath.pathArray} path the `Array` to be checked
-     * @returns {boolean} iteration result
-     */
-    export default function isCurveArray(path: string | SVGPath.pathArray): boolean;
-}
-declare module "svg-path-commander/src/math/rotateVector" {
-    /**
-     * Returns an {x,y} vector rotated by a given
-     * angle in radian.
-     *
-     * @param {number} x the initial vector x
-     * @param {number} y the initial vector y
-     * @param {number} rad the radian vector angle
-     * @returns {{x: number, y: number}} the rotated vector
-     */
-    export default function rotateVector(x: number, y: number, rad: number): {
-        x: number;
-        y: number;
-    };
-}
-declare module "svg-path-commander/src/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 {number} X1 the starting x position
-     * @param {number} Y1 the starting y position
-     * @param {number} RX x-radius of the arc
-     * @param {number} RY y-radius of the arc
-     * @param {number} angle x-axis-rotation of the arc
-     * @param {number} LAF large-arc-flag of the arc
-     * @param {number} SF sweep-flag of the arc
-     * @param {number} X2 the ending x position
-     * @param {number} Y2 the ending y position
-     * @param {number[]=} recursive the parameters needed to split arc into 2 segments
-     * @return {number[]} the resulting cubic-bezier segment(s)
-     */
-    export default function arcToCubic(X1: number, Y1: number, RX: number, RY: number, angle: number, LAF: number, SF: number, X2: number, Y2: number, recursive?: number[] | undefined): number[];
-}
-declare module "svg-path-commander/src/process/quadToCubic" {
-    /**
-     * Converts a Q (quadratic-bezier) segment to C (cubic-bezier).
-     *
-     * @param {number} x1 curve start x
-     * @param {number} y1 curve start y
-     * @param {number} qx control point x
-     * @param {number} qy control point y
-     * @param {number} x2 curve end x
-     * @param {number} y2 curve end y
-     * @returns {number[]} the cubic-bezier segment
-     */
-    export default function quadToCubic(x1: number, y1: number, qx: number, qy: number, x2: number, y2: number): number[];
-}
-declare module "svg-path-commander/src/math/midPoint" {
-    /**
-     * Returns the coordinates of a specified distance
-     * ratio between two points.
-     *
-     * @param {[number, number]} a the first point coordinates
-     * @param {[number, number]} b the second point coordinates
-     * @param {number} t the ratio
-     * @returns {[number, number]} the midpoint coordinates
-     */
-    export default function midPoint(a: [number, number], b: [number, number], t: number): [number, number];
-}
-declare module "svg-path-commander/src/math/distanceSquareRoot" {
-    /**
-     * Returns the square root of the distance
-     * between two given points.
-     *
-     * @param {[number, number]} a the first point coordinates
-     * @param {[number, number]} b the second point coordinates
-     * @returns {number} the distance value
-     */
-    export default function distanceSquareRoot(a: [number, number], b: [number, number]): number;
-}
-declare module "svg-path-commander/src/util/segmentLineFactory" {
-    /**
-     * Returns a {x,y} point at a given length, the total length and
-     * the minimum and maximum {x,y} coordinates of a line (L,V,H,Z) segment.
-     *
-     * @param {number} x1 the starting point X
-     * @param {number} y1 the starting point Y
-     * @param {number} x2 the ending point X
-     * @param {number} y2 the ending point Y
-     * @param {number=} distance the distance to point
-     * @returns {SVGPath.lengthFactory} the segment length, point, min & max
-     */
-    export default function segmentLineFactory(x1: number, y1: number, x2: number, y2: number, distance?: number | undefined): SVGPath.lengthFactory;
-}
-declare module "svg-path-commander/src/process/lineToCubic" {
-    /**
-     * Converts an L (line-to) segment to C (cubic-bezier).
-     *
-     * @param {number} x1 line start x
-     * @param {number} y1 line start y
-     * @param {number} x2 line end x
-     * @param {number} y2 line end y
-     * @returns {number[]} the cubic-bezier segment
-     */
-    export default function lineToCubic(x1: number, y1: number, x2: number, y2: number): number[];
-}
-declare module "svg-path-commander/src/process/segmentToCubic" {
-    /**
-     * Converts any segment to C (cubic-bezier).
-     *
-     * @param {SVGPath.pathSegment} segment the source segment
-     * @param {SVGPath.parserParams} params the source segment parameters
-     * @returns {SVGPath.cubicSegment | SVGPath.MSegment} the cubic-bezier segment
-     */
-    export default function segmentToCubic(segment: SVGPath.pathSegment, params: SVGPath.parserParams): SVGPath.cubicSegment | SVGPath.MSegment;
-}
-declare module "svg-path-commander/src/convert/pathToCurve" {
-    /**
-     * 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 {string | SVGPath.pathArray} pathInput the string to be parsed or 'pathArray'
-     * @returns {SVGPath.curveArray} the resulted `pathArray` converted to cubic-bezier
-     */
-    export default function pathToCurve(pathInput: string | SVGPath.pathArray): SVGPath.curveArray;
-}
-declare module "svg-path-commander/src/options/options" {
-    export default defaultOptions;
-    /**
-     * SVGPathCommander default options
-     * @type {SVGPath.options}
-     */
-    const defaultOptions: SVGPath.options;
-}
-declare module "svg-path-commander/src/process/roundPath" {
-    /**
-     * Rounds the values of a `pathArray` instance to
-     * a specified amount of decimals and returns it.
-     *
-     * @param {SVGPath.pathArray} path the source `pathArray`
-     * @param {number | 'off'} roundOption the amount of decimals to round numbers to
-     * @returns {SVGPath.pathArray} the resulted `pathArray` with rounded values
-     */
-    export default function roundPath(path: SVGPath.pathArray, roundOption: number | 'off'): SVGPath.pathArray;
-}
-declare module "svg-path-commander/src/convert/pathToString" {
-    /**
-     * Returns a valid `d` attribute string value created
-     * by rounding values and concatenating the `pathArray` segments.
-     *
-     * @param {SVGPath.pathArray} path the `pathArray` object
-     * @param {number | 'off'} round amount of decimals to round values to
-     * @returns {string} the concatenated path string
-     */
-    export default function pathToString(path: SVGPath.pathArray, round: number | 'off'): string;
-}
-declare module "svg-path-commander/src/math/epsilon" {
-    export default epsilon;
-    /**
-     * A global namespace for epsilon.
-     *
-     * @type {number}
-     */
-    const epsilon: number;
-}
-declare module "svg-path-commander/src/math/polygonArea" {
-    /**
-     * d3-polygon-area
-     * https://github.com/d3/d3-polygon
-     *
-     * Returns the area of a polygon.
-     *
-     * @param {number[][]} polygon an array of coordinates
-     * @returns {number} the polygon area
-     */
-    export default function polygonArea(polygon: number[][]): number;
-}
-declare module "svg-path-commander/src/math/polygonLength" {
-    /**
-     * d3-polygon-length
-     * https://github.com/d3/d3-polygon
-     *
-     * Returns the perimeter of a polygon.
-     *
-     * @param {[number,number][]} polygon an array of coordinates
-     * @returns {number} the polygon length
-     */
-    export default function polygonLength(polygon: [number, number][]): number;
-}
-declare module "svg-path-commander/src/process/getSVGMatrix" {
-    /**
-     * Returns a transformation matrix to apply to `<path>` elements.
-     *
-     * @see SVGPath.transformObject
-     *
-     * @param {SVGPath.transformObject} transform the `transformObject`
-     * @returns {CSSMatrix} a new transformation matrix
-     */
-    export default function getSVGMatrix(transform: SVGPath.transformObject): CSSMatrix;
-    import CSSMatrix from "dommatrix";
-}
-declare module "svg-path-commander/src/process/shortenSegment" {
-    /**
-     * Shorten a single segment of a `pathArray` object.
-     *
-     * @param {SVGPath.absoluteSegment} segment the `absoluteSegment` object
-     * @param {SVGPath.normalSegment} normalSegment the `normalSegment` object
-     * @param {any} params the coordinates of the previous segment
-     * @param {string} prevCommand the path command of the previous segment
-     * @returns {SVGPath.shortSegment | SVGPath.pathSegment} the shortened segment
-     */
-    export default function shortenSegment(segment: SVGPath.absoluteSegment, normalSegment: SVGPath.normalSegment, params: any, prevCommand: string): SVGPath.shortSegment | SVGPath.pathSegment;
-}
-declare module "svg-path-commander/src/process/optimizePath" {
-    /**
-     * Optimizes a `pathArray` object:
-     * * convert segments to shorthand if possible
-     * * select shortest segments from absolute and relative `pathArray`s
-     *
-     * TO DO
-     * * implement `auto` for rounding values based on pathBBox
-     * * also revers path check if it's smaller string, maybe?
-     *
-     * @param {SVGPath.pathArray} pathInput a string or `pathArray`
-     * @param {number | 'off'} round the amount of decimals to round values to
-     * @returns {SVGPath.pathArray} the optimized `pathArray`
-     */
-    export default function optimizePath(pathInput: SVGPath.pathArray, round: number | 'off'): SVGPath.pathArray;
-}
-declare module "svg-path-commander/src/process/projection2d" {
-    /**
-     * 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 {SVGPath.CSSMatrix} m the transformation matrix
-     * @param {[number, number]} point2D the initial [x,y] coordinates
-     * @param {number[]} origin the [x,y,z] transform origin
-     * @returns {[number, number]} the projected [x,y] coordinates
-     */
-    export default function projection2d(m: SVGPath.CSSMatrix, point2D: [number, number], origin: number[]): [number, number];
-}
-declare module "svg-path-commander/src/process/reverseCurve" {
-    /**
-     * Reverses all segments of a `pathArray`
-     * which consists of only C (cubic-bezier) path commands.
-     *
-     * @param {SVGPath.curveArray} path the source `pathArray`
-     * @returns {SVGPath.curveArray} the reversed `pathArray`
-     */
-    export default function reverseCurve(path: SVGPath.curveArray): SVGPath.curveArray;
-}
-declare module "svg-path-commander/src/process/reversePath" {
-    /**
-     * Reverses all segments of a `pathArray` and returns a new `pathArray` instance.
-     *
-     * @param {SVGPath.pathArray} pathInput the source `pathArray`
-     * @returns {SVGPath.pathArray} the reversed `pathArray`
-     */
-    export default function reversePath(pathInput: SVGPath.pathArray): SVGPath.pathArray;
-}
-declare module "svg-path-commander/src/process/splitCubic" {
-    /**
-     * Split a cubic-bezier segment into two.
-     *
-     * @param {number[]} pts the cubic-bezier parameters
-     * @return {SVGPath.cubicSegment[]} two new cubic-bezier segments
-     */
-    export default function splitCubic(pts: number[]): SVGPath.cubicSegment[];
-}
-declare module "svg-path-commander/src/process/splitPath" {
-    /**
-     * Split a path into an `Array` of sub-path strings.
-     *
-     * In the process, values are converted to absolute
-     * for visual consistency.
-     *
-     * @param {SVGPath.pathArray} pathInput the source `pathArray`
-     * @return {SVGPath.pathArray[]} an array with all sub-path strings
-     */
-    export default function splitPath(pathInput: SVGPath.pathArray): SVGPath.pathArray[];
-}
-declare module "svg-path-commander/src/process/transformEllipse" {
-    /**
-     * Apply a 2D transformation matrix to an ellipse.
-     *
-     * @param {number[]} m the 2D transformation matrix
-     * @param {number} rx ellipse radius X
-     * @param {number} ry ellipse radius Y
-     * @param {number} ax ellipse rotation angle
-     */
-    export default function transformEllipse(m: number[], rx: number, ry: number, ax: number): {
-        rx: number;
-        ry: number;
-        ax: number;
-    };
-}
-declare module "svg-path-commander/src/process/transformPath" {
-    /**
-     * Apply a 2D / 3D transformation to a `pathArray` instance.
-     *
-     * Since *SVGElement* doesn't support 3D transformation, this function
-     * creates a 2D projection of the <path> element.
-     *
-     * @param {SVGPath.pathArray} path the `pathArray` to apply transformation
-     * @param {SVGPath.transformObject} transform the transform functions `Object`
-     * @returns {SVGPath.pathArray} the resulted `pathArray`
-     */
-    export default function transformPath(path: SVGPath.pathArray, transform: SVGPath.transformObject): SVGPath.pathArray;
-}
-declare module "svg-path-commander/src/util/getPathArea" {
-    /**
-     * 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 {SVGPath.pathArray} path the shape `pathArray`
-     * @returns {number} the length of the cubic-bezier segment
-     */
-    export default function getPathArea(path: SVGPath.pathArray): number;
-}
-declare module "svg-path-commander/src/util/getDrawDirection" {
-    /**
-     * Check if a path is drawn clockwise and returns true if so,
-     * false otherwise.
-     *
-     * @param {SVGPath.pathArray} path the path string or `pathArray`
-     * @returns {boolean} true when clockwise or false if not
-     */
-    export default function getDrawDirection(path: SVGPath.pathArray): boolean;
-}
-declare module "svg-path-commander/src/util/segmentCubicFactory" {
-    /**
-     * Returns the length of a C (cubic-bezier) segment
-     * or an {x,y} point at a given length.
-     *
-     * @param {number} x1 the starting point X
-     * @param {number} y1 the starting point Y
-     * @param {number} c1x the first control point X
-     * @param {number} c1y the first control point Y
-     * @param {number} c2x the second control point X
-     * @param {number} c2y the second control point Y
-     * @param {number} x2 the ending point X
-     * @param {number} y2 the ending point Y
-     * @param {number=} distance the point distance
-     * @returns {SVGPath.lengthFactory} the segment length, point, min & max
-     */
-    export default function segmentCubicFactory(x1: number, y1: number, c1x: number, c1y: number, c2x: number, c2y: number, x2: number, y2: number, distance?: number | undefined): SVGPath.lengthFactory;
-}
-declare module "svg-path-commander/src/util/segmentArcFactory" {
-    /**
-     * Returns a {x,y} point at a given length, the total length and
-     * the shape minimum and maximum {x,y} coordinates of an A (arc-to) segment.
-     *
-     * @param {number} X1 the starting x position
-     * @param {number} Y1 the starting y position
-     * @param {number} RX x-radius of the arc
-     * @param {number} RY y-radius of the arc
-     * @param {number} angle x-axis-rotation of the arc
-     * @param {number} LAF large-arc-flag of the arc
-     * @param {number} SF sweep-flag of the arc
-     * @param {number} X2 the ending x position
-     * @param {number} Y2 the ending y position
-     * @param {number} distance the point distance
-     * @returns {SVGPath.lengthFactory} the segment length, point, min & max
-     */
-    export default function segmentArcFactory(X1: number, Y1: number, RX: number, RY: number, angle: number, LAF: number, SF: number, X2: number, Y2: number, distance: number): SVGPath.lengthFactory;
-}
-declare module "svg-path-commander/src/util/segmentQuadFactory" {
-    /**
-     * Returns a {x,y} point at a given length, the total length and
-     * the minimum and maximum {x,y} coordinates of a Q (quadratic-bezier) segment.
-     *
-     * @param {number} x1 the starting point X
-     * @param {number} y1 the starting point Y
-     * @param {number} qx the control point X
-     * @param {number} qy the control point Y
-     * @param {number} x2 the ending point X
-     * @param {number} y2 the ending point Y
-     * @param {number=} distance the distance to point
-     * @returns {SVGPath.lengthFactory} the segment length, point, min & max
-     */
-    export default function segmentQuadFactory(x1: number, y1: number, qx: number, qy: number, x2: number, y2: number, distance?: number | undefined): SVGPath.lengthFactory;
-}
-declare module "svg-path-commander/src/util/pathLengthFactory" {
-    /**
-     * Returns a {x,y} point at a given length
-     * of a shape, the shape total length and
-     * the shape minimum and maximum {x,y} coordinates.
-     *
-     * @param {string | SVGPath.pathArray} pathInput the `pathArray` to look into
-     * @param {number=} distance the length of the shape to look at
-     * @returns {SVGPath.lengthFactory} the path length, point, min & max
-     */
-    export default function pathLengthFactory(pathInput: string | SVGPath.pathArray, distance?: number | undefined): SVGPath.lengthFactory;
-}
-declare module "svg-path-commander/src/util/getPathBBox" {
-    /**
-     * Returns the bounding box of a shape.
-     *
-     * @param {SVGPath.pathArray=} path the shape `pathArray`
-     * @returns {SVGPath.pathBBox} the length of the cubic-bezier segment
-     */
-    export default function getPathBBox(path?: SVGPath.pathArray | undefined): SVGPath.pathBBox;
-}
-declare module "svg-path-commander/src/util/getTotalLength" {
-    /**
-     * Returns the shape total length, or the equivalent to `shape.getTotalLength()`.
-     *
-     * The `normalizePath` version is lighter, faster, more efficient and more accurate
-     * with paths that are not `curveArray`.
-     *
-     * @param {string | SVGPath.pathArray} pathInput the target `pathArray`
-     * @returns {number} the shape total length
-     */
-    export default function getTotalLength(pathInput: string | SVGPath.pathArray): number;
-}
-declare module "svg-path-commander/src/util/getPointAtLength" {
-    /**
-     * Returns [x,y] coordinates of a point at a given length of a shape.
-     *
-     * @param {string | SVGPath.pathArray} pathInput the `pathArray` to look into
-     * @param {number} distance the length of the shape to look at
-     * @returns {{x: number, y: number}} the requested {x, y} point coordinates
-     */
-    export default function getPointAtLength(pathInput: string | SVGPath.pathArray, distance: number): {
-        x: number;
-        y: number;
-    };
-}
-declare module "svg-path-commander/src/util/getPropertiesAtLength" {
-    /**
-     * Returns the segment, its index and length as well as
-     * the length to that segment at a given length in a path.
-     *
-     * @param {string | SVGPath.pathArray} pathInput target `pathArray`
-     * @param {number=} distance the given length
-     * @returns {SVGPath.segmentProperties=} the requested properties
-     */
-    export default function getPropertiesAtLength(pathInput: string | SVGPath.pathArray, distance?: number | undefined): SVGPath.segmentProperties | undefined;
-}
-declare module "svg-path-commander/src/util/getPropertiesAtPoint" {
-    /**
-     * 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 {string | SVGPath.pathArray} pathInput target `pathArray`
-     * @param {{x: number, y: number}} point the given point
-     * @returns {SVGPath.pointProperties} the requested properties
-     */
-    export default function getPropertiesAtPoint(pathInput: string | SVGPath.pathArray, point: {
-        x: number;
-        y: number;
-    }): SVGPath.pointProperties;
-}
-declare module "svg-path-commander/src/util/getClosestPoint" {
-    /**
-     * Returns the point in path closest to a given point.
-     *
-     * @param {string | SVGPath.pathArray} pathInput target `pathArray`
-     * @param {{x: number, y: number}} point the given point
-     * @returns {{x: number, y: number}} the best match
-     */
-    export default function getClosestPoint(pathInput: string | SVGPath.pathArray, point: {
-        x: number;
-        y: number;
-    }): {
-        x: number;
-        y: number;
-    };
-}
-declare module "svg-path-commander/src/util/getSegmentAtLength" {
-    /**
-     * Returns the segment at a given length.
-     * @param {string | SVGPath.pathArray} pathInput the target `pathArray`
-     * @param {number} distance the distance in path to look at
-     * @returns {SVGPath.pathSegment?} the requested segment
-     */
-    export default function getSegmentAtLength(pathInput: string | SVGPath.pathArray, distance: number): SVGPath.pathSegment | null;
-}
-declare module "svg-path-commander/src/util/getSegmentOfPoint" {
-    /**
-     * Returns the path segment which contains a given point.
-     *
-     * @param {string | SVGPath.pathArray} path the `pathArray` to look into
-     * @param {{x: number, y: number}} point the point of the shape to look for
-     * @returns {SVGPath.pathSegment?} the requested segment
-     */
-    export default function getSegmentOfPoint(path: string | SVGPath.pathArray, point: {
-        x: number;
-        y: number;
-    }): SVGPath.pathSegment | null;
-}
-declare module "svg-path-commander/src/util/isPointInStroke" {
-    /**
-     * Checks if a given point is in the stroke of a path.
-     *
-     * @param {string | SVGPath.pathArray} pathInput target path
-     * @param {{x: number, y: number}} point the given `{x,y}` point
-     * @returns {boolean} the query result
-     */
-    export default function isPointInStroke(pathInput: string | SVGPath.pathArray, point: {
-        x: number;
-        y: number;
-    }): boolean;
-}
-declare module "svg-path-commander/src/util/isValidPath" {
-    /**
-     * Parses a path string value to determine its validity
-     * then returns true if it's valid or false otherwise.
-     *
-     * @param {string} pathString the path string to be parsed
-     * @returns {boolean} the path string validity
-     */
-    export default function isValidPath(pathString: string): boolean;
-}
-declare module "svg-path-commander/src/util/shapeToPath" {
-    /**
-     * Returns a new `pathArray` from line attributes.
-     *
-     * @param {SVGPath.lineAttr} attr shape configuration
-     * @returns {SVGPath.pathArray} a new line `pathArray`
-     */
-    export function getLinePath(attr: SVGPath.lineAttr): SVGPath.pathArray;
-    /**
-     * Returns a new `pathArray` like from polyline/polygon attributes.
-     *
-     * @param {SVGPath.polyAttr} attr shape configuration
-     * @return {SVGPath.pathArray} a new polygon/polyline `pathArray`
-     */
-    export function getPolyPath(attr: SVGPath.polyAttr): SVGPath.pathArray;
-    /**
-     * Returns a new `pathArray` from circle attributes.
-     *
-     * @param {SVGPath.circleAttr} attr shape configuration
-     * @return {SVGPath.pathArray} a circle `pathArray`
-     */
-    export function getCirclePath(attr: SVGPath.circleAttr): SVGPath.pathArray;
-    /**
-     * Returns a new `pathArray` from ellipse attributes.
-     *
-     * @param {SVGPath.ellipseAttr} attr shape configuration
-     * @return {SVGPath.pathArray} an ellipse `pathArray`
-     */
-    export function getEllipsePath(attr: SVGPath.ellipseAttr): SVGPath.pathArray;
-    /**
-     * Returns a new `pathArray` like from rect attributes.
-     *
-     * @param {SVGPath.rectAttr} attr object with properties above
-     * @return {SVGPath.pathArray} a new `pathArray` from `<rect>` attributes
-     */
-    export function getRectanglePath(attr: SVGPath.rectAttr): SVGPath.pathArray;
-    /**
-     * Returns a new `<path>` element created from attributes of a `<line>`, `<polyline>`,
-     * `<polygon>`, `<rect>`, `<ellipse>`, `<circle>` or `<glyph>`. If `replace` parameter
-     * is `true`, it will replace the target.
-     *
-     * It can also work with an options object,
-     * @see SVGPath.shapeOps
-     *
-     * The newly created `<path>` element keeps all non-specific
-     * attributes like `class`, `fill`, etc.
-     *
-     * @param {SVGPath.shapeTypes | SVGPath.shapeOps} element target shape
-     * @param {boolean=} replace option to replace target
-     * @return {SVGPathElement | boolean} the newly created `<path>` element
-     */
-    export default function shapeToPath(element: SVGPath.shapeTypes | SVGPath.shapeOps, replace?: boolean | undefined): SVGPathElement | boolean;
-}
-declare module "svg-path-commander/src/version" {
-    export default Version;
-    /**
-     * A global namespace for library version.
-     * @type {string}
-     */
-    const Version: string;
-}
-declare module "svg-path-commander/src/svg-path-commander" {
-    export default SVGPathCommander;
-    /**
-     * Creates a new SVGPathCommander instance with the following properties:
-     * * segments: `pathArray`
-     * * round: number
-     * * origin: [number, number, number?]
-     *
-     * @class
-     * @author thednp <https://github.com/thednp/svg-path-commander>
-     * @returns {SVGPathCommander} a new SVGPathCommander instance
-     */
-    class SVGPathCommander {
-        /**
-         * @constructor
-         * @param {string} pathValue the path string
-         * @param {any} config instance options
-         */
-        constructor(pathValue: string, config: any);
-        /**
-         * @type {SVGPath.pathArray}
-         */
-        segments: SVGPath.pathArray;
-        /**
-         * @type {number | 'off'}
-         */
-        round: number | 'off';
-        origin: number[];
-        /**
-         * Returns the path bounding box, equivalent to native `path.getBBox()`.
-         * @public
-         * @returns {SVGPath.pathBBox}
-         */
-        public getBBox(): SVGPath.pathBBox;
-        /**
-         * Returns the total path length, equivalent to native `path.getTotalLength()`.
-         * @public
-         * @returns {number}
-         */
-        public getTotalLength(): number;
-        /**
-         * Returns an `{x,y}` point in the path stroke at a given length,
-         * equivalent to the native `path.getPointAtLength()`.
-         *
-         * @public
-         * @param {number} length the length
-         * @returns {{x: number, y:number}} the requested point
-         */
-        public getPointAtLength(length: number): {
-            x: number;
-            y: number;
-        };
-        /**
-         * Convert path to absolute values
-         * @public
-         */
-        public toAbsolute(): SVGPathCommander;
-        /**
-         * Convert path to relative values
-         * @public
-         */
-        public toRelative(): SVGPathCommander;
-        /**
-         * Convert path to cubic-bezier values. In addition, un-necessary `Z`
-         * segment is removed if previous segment extends to the `M` segment.
-         *
-         * @public
-         */
-        public toCurve(): SVGPathCommander;
-        /**
-         * Reverse the order of the segments and their values.
-         * @param {boolean} onlySubpath option to reverse all sub-paths except first
-         * @public
-         */
-        public reverse(onlySubpath: boolean): SVGPathCommander;
-        /**
-         * Normalize path in 2 steps:
-         * * convert `pathArray`(s) to absolute values
-         * * convert shorthand notation to standard notation
-         * @public
-         */
-        public normalize(): SVGPathCommander;
-        /**
-         * 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
-         */
-        public optimize(): SVGPathCommander;
-        /**
-         * Transform path using values from an `Object` defined as `transformObject`.
-         * @see SVGPath.transformObject for a quick refference
-         *
-         * @param {SVGPath.transformObject} source a `transformObject`as described above
-         * @public
-         */
-        public transform(source: SVGPath.transformObject): SVGPathCommander;
-        /**
-         * Rotate path 180deg horizontally
-         * @public
-         */
-        public flipX(): SVGPathCommander;
-        /**
-         * Rotate path 180deg vertically
-         * @public
-         */
-        public flipY(): SVGPathCommander;
-        /**
-         * Export the current path to be used
-         * for the `d` (description) attribute.
-         * @public
-         * @return {String} the path string
-         */
-        public toString(): string;
-    }
-}
-declare module "svg-path-commander/types/more/modules" {
-    export { default as pathToAbsolute } from "svg-path-commander/src/convert/pathToAbsolute";
-    export { default as pathToRelative } from "svg-path-commander/src/convert/pathToRelative";
-    export { default as pathToCurve } from "svg-path-commander/src/convert/pathToCurve";
-    export { default as pathToString } from "svg-path-commander/src/convert/pathToString";
-    export { default as distanceSquareRoot } from "svg-path-commander/src/math/distanceSquareRoot";
-    export { default as epsilon } from "svg-path-commander/src/math/epsilon";
-    export { default as midPoint } from "svg-path-commander/src/math/midPoint";
-    export { default as polygonArea } from "svg-path-commander/src/math/polygonArea";
-    export { default as polygonLength } from "svg-path-commander/src/math/polygonLength";
-    export { default as rotateVector } from "svg-path-commander/src/math/rotateVector";
-    export { default as defaultOptions } from "svg-path-commander/src/options/options";
-    export { default as finalizeSegment } from "svg-path-commander/src/parser/finalizeSegment";
-    export { default as invalidPathValue } from "svg-path-commander/src/parser/invalidPathValue";
-    export { default as isArcCommand } from "svg-path-commander/src/parser/isArcCommand";
-    export { default as isDigit } from "svg-path-commander/src/parser/isDigit";
-    export { default as isDigitStart } from "svg-path-commander/src/parser/isDigitStart";
-    export { default as isPathCommand } from "svg-path-commander/src/parser/isPathCommand";
-    export { default as isSpace } from "svg-path-commander/src/parser/isSpace";
-    export { default as paramsCount } from "svg-path-commander/src/parser/paramsCount";
-    export { default as paramsParser } from "svg-path-commander/src/parser/paramsParser";
-    export { default as parsePathString } from "svg-path-commander/src/parser/parsePathString";
-    export { default as PathParser } from "svg-path-commander/src/parser/pathParser";
-    export { default as scanFlag } from "svg-path-commander/src/parser/scanFlag";
-    export { default as scanParam } from "svg-path-commander/src/parser/scanParam";
-    export { default as scanSegment } from "svg-path-commander/src/parser/scanSegment";
-    export { default as skipSpaces } from "svg-path-commander/src/parser/skipSpaces";
-    export { default as arcToCubic } from "svg-path-commander/src/process/arcToCubic";
-    export { default as clonePath } from "svg-path-commander/src/process/clonePath";
-    export { default as fixArc } from "svg-path-commander/src/process/fixArc";
-    export { default as fixPath } from "svg-path-commander/src/process/fixPath";
-    export { default as getSVGMatrix } from "svg-path-commander/src/process/getSVGMatrix";
-    export { default as lineToCubic } from "svg-path-commander/src/process/lineToCubic";
-    export { default as normalizePath } from "svg-path-commander/src/process/normalizePath";
-    export { default as normalizeSegment } from "svg-path-commander/src/process/normalizeSegment";
-    export { default as optimizePath } from "svg-path-commander/src/process/optimizePath";
-    export { default as projection2d } from "svg-path-commander/src/process/projection2d";
-    export { default as quadToCubic } from "svg-path-commander/src/process/quadToCubic";
-    export { default as reverseCurve } from "svg-path-commander/src/process/reverseCurve";
-    export { default as reversePath } from "svg-path-commander/src/process/reversePath";
-    export { default as roundPath } from "svg-path-commander/src/process/roundPath";
-    export { default as segmentToCubic } from "svg-path-commander/src/process/segmentToCubic";
-    export { default as shortenSegment } from "svg-path-commander/src/process/shortenSegment";
-    export { default as shorthandToCubic } from "svg-path-commander/src/process/shorthandToCubic";
-    export { default as shorthandToQuad } from "svg-path-commander/src/process/shorthandToQuad";
-    export { default as splitCubic } from "svg-path-commander/src/process/splitCubic";
-    export { default as splitPath } from "svg-path-commander/src/process/splitPath";
-    export { default as transformEllipse } from "svg-path-commander/src/process/transformEllipse";
-    export { default as transformPath } from "svg-path-commander/src/process/transformPath";
-    export { default as getDrawDirection } from "svg-path-commander/src/util/getDrawDirection";
-    export { default as getPathArea } from "svg-path-commander/src/util/getPathArea";
-    export { default as getPathBBox } from "svg-path-commander/src/util/getPathBBox";
-    export { default as pathLengthFactory } from "svg-path-commander/src/util/pathLengthFactory";
-    export { default as getTotalLength } from "svg-path-commander/src/util/getTotalLength";
-    export { default as segmentLineFactory } from "svg-path-commander/src/util/segmentLineFactory";
-    export { default as segmentArcFactory } from "svg-path-commander/src/util/segmentArcFactory";
-    export { default as segmentCubicFactory } from "svg-path-commander/src/util/segmentCubicFactory";
-    export { default as segmentQuadFactory } from "svg-path-commander/src/util/segmentQuadFactory";
-    export { default as getPointAtLength } from "svg-path-commander/src/util/getPointAtLength";
-    export { default as getPropertiesAtPoint } from "svg-path-commander/src/util/getPropertiesAtPoint";
-    export { default as getPropertiesAtLength } from "svg-path-commander/src/util/getPropertiesAtLength";
-    export { default as getClosestPoint } from "svg-path-commander/src/util/getClosestPoint";
-    export { default as getSegmentAtLength } from "svg-path-commander/src/util/getSegmentAtLength";
-    export { default as getSegmentOfPoint } from "svg-path-commander/src/util/getSegmentOfPoint";
-    export { default as isPointInStroke } from "svg-path-commander/src/util/isPointInStroke";
-    export { default as isAbsoluteArray } from "svg-path-commander/src/util/isAbsoluteArray";
-    export { default as isCurveArray } from "svg-path-commander/src/util/isCurveArray";
-    export { default as isNormalizedArray } from "svg-path-commander/src/util/isNormalizedArray";
-    export { default as isPathArray } from "svg-path-commander/src/util/isPathArray";
-    export { default as isRelativeArray } from "svg-path-commander/src/util/isRelativeArray";
-    export { default as isValidPath } from "svg-path-commander/src/util/isValidPath";
-    export { default as shapeToPath } from "svg-path-commander/src/util/shapeToPath";
-    export { default as Version } from "svg-path-commander/src/version";
-    export { default as SVGPathCommander } from "svg-path-commander/src/svg-path-commander";
-}