fabric 5.3.0 → 6.0.0-beta3

package/dist/src/util/misc/projectStroke/StrokeLineCapProjections.d.ts

@@ -0,0 +1,51 @@
+import { XY, Point } from '../../../Point';
+import { StrokeProjectionsBase } from './StrokeProjectionsBase';
+import { TProjection, TProjectStrokeOnPointsOptions } from './types';
+/**
+ * class in charge of finding projections for each type of line cap for start/end of an open path
+ * @see {@link [Open path projections at #8344](https://github.com/fabricjs/fabric.js/pull/8344#1-open-path)}
+ *
+ * Reference:
+ * - MDN:
+ *   - https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/lineCap
+ *   - https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-linecap
+ * - Spec: https://html.spec.whatwg.org/multipage/canvas.html#dom-context-2d-linecap-dev
+ * - Playground to understand how the line joins works: https://hypertolosana.github.io/efficient-webgl-stroking/index.html
+ * - View the calculated projections for each of the control points: https://codesandbox.io/s/project-stroke-points-with-context-to-trace-b8jc4j?file=/src/index.js
+ */
+export declare class StrokeLineCapProjections extends StrokeProjectionsBase {
+    /**
+     * edge point
+     */
+    A: Point;
+    /**
+     * point next to edge point
+     */
+    T: Point;
+    constructor(A: XY, T: XY, options: TProjectStrokeOnPointsOptions);
+    calcOrthogonalProjection(from: Point, to: Point, magnitude?: number): Point;
+    /**
+     * OPEN PATH START/END - Line cap: Butt
+     * Calculation: to find the projections, just find the points orthogonal to the stroke
+     *
+     * @see https://github.com/fabricjs/fabric.js/pull/8344#1-1-butt
+     */
+    projectButt(): Point[];
+    /**
+     * OPEN PATH START/END - Line cap: Round
+     * Calculation: same as stroke line join `round`
+     *
+     * @see https://github.com/fabricjs/fabric.js/pull/8344#1-2-round
+     */
+    projectRound(): Point[];
+    /**
+     * OPEN PATH START/END - Line cap: Square
+     * Calculation: project a rectangle of points on the stroke in the opposite direction of the vector `AT`
+     *
+     * @see https://github.com/fabricjs/fabric.js/pull/8344#1-3-square
+     */
+    projectSquare(): Point[];
+    protected projectPoints(): Point[];
+    project(): TProjection[];
+}
+//# sourceMappingURL=StrokeLineCapProjections.d.ts.map

package/dist/src/util/misc/projectStroke/StrokeLineJoinProjections.d.ts

@@ -0,0 +1,81 @@
+import { XY, Point } from '../../../Point';
+import { getBisector } from '../vectors';
+import { StrokeProjectionsBase } from './StrokeProjectionsBase';
+import { TProjection, TProjectStrokeOnPointsOptions } from './types';
+/**
+ * class in charge of finding projections for each type of line join
+ * @see {@link [Closed path projections at #8344](https://github.com/fabricjs/fabric.js/pull/8344#2-closed-path)}
+ *
+ * - MDN:
+ *   - https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/lineJoin
+ *   - https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-linejoin
+ * - Spec: https://svgwg.org/svg2-draft/painting.html#StrokeLinejoinProperty
+ * - Playground to understand how the line joins works: https://hypertolosana.github.io/efficient-webgl-stroking/index.html
+ * - View the calculated projections for each of the control points: https://codesandbox.io/s/project-stroke-points-with-context-to-trace-b8jc4j?file=/src/index.js
+ *
+ */
+export declare class StrokeLineJoinProjections extends StrokeProjectionsBase {
+    /**
+     * The point being projected (the angle ∠BAC)
+     */
+    A: Point;
+    /**
+     * The point before A
+     */
+    B: Point;
+    /**
+     * The point after A
+     */
+    C: Point;
+    /**
+     * The bisector of A (∠BAC)
+     */
+    bisector: ReturnType<typeof getBisector>;
+    constructor(A: XY, B: XY, C: XY, options: TProjectStrokeOnPointsOptions);
+    get bisectorVector(): Point;
+    get bisectorAngle(): import("../../../typedefs").TRadian;
+    calcOrthogonalProjection(from: Point, to: Point, magnitude?: number): Point;
+    /**
+     * BEVEL
+     * Calculation: the projection points are formed by the vector orthogonal to the vertex.
+     *
+     * @see https://github.com/fabricjs/fabric.js/pull/8344#2-2-bevel
+     */
+    projectBevel(): Point[];
+    /**
+     * MITER
+     * Calculation: the corner is formed by extending the outer edges of the stroke
+     * at the tangents of the path segments until they intersect.
+     *
+     * @see https://github.com/fabricjs/fabric.js/pull/8344#2-1-miter
+     */
+    projectMiter(): Point[];
+    /**
+     * ROUND (without skew)
+     * Calculation: the projections are the two vectors parallel to X and Y axes
+     *
+     * @see https://github.com/fabricjs/fabric.js/pull/8344#2-3-1-round-without-skew
+     */
+    private projectRoundNoSkew;
+    /**
+     * ROUND (with skew)
+     * Calculation: the projections are the points furthest from the vertex in
+     * the direction of the X and Y axes after distortion.
+     *
+     * @todo TODO:
+     *  - Consider only projections that are inside the beginning and end of the circle segment
+     *
+     * @see https://github.com/fabricjs/fabric.js/pull/8344#2-3-2-round-skew
+     */
+    private projectRoundWithSkew;
+    projectRound(): Point[];
+    /**
+     * Project stroke width on points returning projections for each point as follows:
+     * - `miter`: 1 point corresponding to the outer boundary. If the miter limit is exceeded, it will be 2 points (becomes bevel)
+     * - `bevel`: 2 points corresponding to the bevel possible boundaries, orthogonal to the stroke.
+     * - `round`: same as `bevel` when it has no skew, with skew are 4 points.
+     */
+    protected projectPoints(): Point[];
+    project(): TProjection[];
+}
+//# sourceMappingURL=StrokeLineJoinProjections.d.ts.map

package/dist/src/util/misc/projectStroke/StrokeProjectionsBase.d.ts

@@ -0,0 +1,25 @@
+import { XY, Point } from '../../../Point';
+import { TProjectStrokeOnPointsOptions, TProjection } from './types';
+/**
+ * @see https://github.com/fabricjs/fabric.js/pull/8344
+ */
+export declare abstract class StrokeProjectionsBase {
+    options: TProjectStrokeOnPointsOptions;
+    scale: Point;
+    strokeUniformScalar: Point;
+    strokeProjectionMagnitude: number;
+    static getAcuteAngleFactor(vector1: Point, vector2?: Point): 1 | -1;
+    constructor(options: TProjectStrokeOnPointsOptions);
+    /**
+     * When the stroke is uniform, scaling affects the arrangement of points. So we must take it into account.
+     */
+    protected createSideVector(from: XY, to: XY): Point;
+    protected abstract calcOrthogonalProjection(from: Point, to: Point, magnitude?: number): Point;
+    protected projectOrthogonally(from: Point, to: Point, magnitude?: number): Point;
+    protected isSkewed(): boolean;
+    protected applySkew(point: Point): Point;
+    protected scaleUnitVector(unitVector: Point, scalar: number): Point;
+    protected abstract projectPoints(): Point[];
+    abstract project(): TProjection[];
+}
+//# sourceMappingURL=StrokeProjectionsBase.d.ts.map

package/dist/src/util/misc/projectStroke/index.d.ts

@@ -0,0 +1,11 @@
+import { XY } from '../../../Point';
+import { TProjection, TProjectStrokeOnPointsOptions } from './types';
+/**
+ *
+ * Used to calculate object's bounding box
+ *
+ * @see https://github.com/fabricjs/fabric.js/pull/8344
+ *
+ */
+export declare const projectStrokeOnPoints: (points: XY[], options: TProjectStrokeOnPointsOptions, openPath?: boolean) => TProjection[];
+//# sourceMappingURL=index.d.ts.map

package/dist/src/util/misc/projectStroke/types.d.ts

@@ -0,0 +1,23 @@
+import { Point } from '../../../Point';
+import { TDegree } from '../../../typedefs';
+import { getBisector } from '../vectors';
+export type TProjectStrokeOnPointsOptions = {
+    strokeWidth: number;
+    strokeLineCap: CanvasLineCap;
+    strokeLineJoin: CanvasLineJoin;
+    /**
+     * https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/stroke-miterlimit
+     */
+    strokeMiterLimit: number;
+    strokeUniform: boolean;
+    scaleX: number;
+    scaleY: number;
+    skewX: TDegree;
+    skewY: TDegree;
+};
+export type TProjection = {
+    projectedPoint: Point;
+    originPoint: Point;
+    bisector?: ReturnType<typeof getBisector>;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/src/util/misc/radiansDegreesConversion.d.ts

@@ -0,0 +1,14 @@
+import type { TRadian, TDegree } from '../../typedefs';
+/**
+ * Transforms degrees to radians.
+ * @param {TDegree} degrees value in degrees
+ * @return {TRadian} value in radians
+ */
+export declare const degreesToRadians: (degrees: TDegree) => TRadian;
+/**
+ * Transforms radians to degrees.
+ * @param {TRadian} radians value in radians
+ * @return {TDegree} value in degrees
+ */
+export declare const radiansToDegrees: (radians: TRadian) => TDegree;
+//# sourceMappingURL=radiansDegreesConversion.d.ts.map

package/dist/src/util/misc/resolveOrigin.d.ts

@@ -0,0 +1,9 @@
+import { TOriginX, TOriginY } from '../../typedefs';
+/**
+ * Resolves origin value relative to center
+ * @private
+ * @param {TOriginX | TOriginY} originValue originX / originY
+ * @returns number
+ */
+export declare const resolveOrigin: (originValue: TOriginX | TOriginY | number) => number;
+//# sourceMappingURL=resolveOrigin.d.ts.map

package/dist/src/util/misc/rotatePoint.d.ts

@@ -0,0 +1,12 @@
+import type { Point } from '../../Point';
+import type { TRadian } from '../../typedefs';
+/**
+ * Rotates `point` around `origin` with `radians`
+ * @deprecated use the Point.rotate
+ * @param {Point} origin The origin of the rotation
+ * @param {Point} origin The origin of the rotation
+ * @param {TRadian} radians The radians of the angle for the rotation
+ * @return {Point} The new rotated point
+ */
+export declare const rotatePoint: (point: Point, origin: Point, radians: TRadian) => Point;
+//# sourceMappingURL=rotatePoint.d.ts.map

package/dist/src/util/misc/sin.d.ts

@@ -0,0 +1,10 @@
+import type { TRadian } from '../../typedefs';
+/**
+ * Calculate the cos of an angle, avoiding returning floats for known results
+ * This function is here just to avoid getting 0.999999999999999 when dealing
+ * with numbers that are really 1 or 0.
+ * @param {TRadian} angle the angle
+ * @return {Number} the sin value for angle.
+ */
+export declare const sin: (angle: TRadian) => number;
+//# sourceMappingURL=sin.d.ts.map

package/dist/src/util/misc/svgParsing.d.ts

@@ -0,0 +1,53 @@
+import { SVGElementName, TBBox, TMat2D } from '../../typedefs';
+/**
+ * Returns array of attributes for given svg that fabric parses
+ * @param {SVGElementName} type Type of svg element (eg. 'circle')
+ * @return {Array} string names of supported attributes
+ */
+export declare const getSvgAttributes: (type: SVGElementName) => string[];
+/**
+ * Converts from attribute value to pixel value if applicable.
+ * Returns converted pixels or original value not converted.
+ * @param {string} value number to operate on
+ * @param {number} fontSize
+ * @return {number}
+ */
+export declare const parseUnit: (value: string, fontSize: number) => number;
+export declare const enum MeetOrSlice {
+    meet = "meet",
+    slice = "slice"
+}
+export declare const enum MinMidMax {
+    min = "Min",
+    mid = "Mid",
+    max = "Max",
+    none = "none"
+}
+export type TPreserveArParsed = {
+    meetOrSlice: MeetOrSlice;
+    alignX: MinMidMax;
+    alignY: MinMidMax;
+};
+/**
+ * Parse preserveAspectRatio attribute from element
+ * https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/preserveAspectRatio
+ * @param {string} attribute to be parsed
+ * @return {Object} an object containing align and meetOrSlice attribute
+ */
+export declare const parsePreserveAspectRatioAttribute: (attribute: string) => TPreserveArParsed;
+/**
+ * given an array of 6 number returns something like `"matrix(...numbers)"`
+ * @param {TMat2D} transform an array with 6 numbers
+ * @return {String} transform matrix for svg
+ */
+export declare const matrixToSVG: (transform: TMat2D) => string;
+/**
+ * Adobe Illustrator (at least CS5) is unable to render rgba()-based fill values
+ * we work around it by "moving" alpha channel into opacity attribute and setting fill's alpha to 1
+ * @param prop
+ * @param value
+ * @returns
+ */
+export declare const colorPropToSVG: (prop: string, value?: any) => string;
+export declare const createSVGRect: (color: string, { left, top, width, height }: TBBox, precision?: number) => string;
+//# sourceMappingURL=svgParsing.d.ts.map

package/dist/src/util/misc/textStyles.d.ts

@@ -0,0 +1,32 @@
+import type { TextStyle, TextStyleDeclaration } from '../../shapes/Text/StyledText';
+export type TextStyleArray = {
+    start: number;
+    end: number;
+    style: TextStyleDeclaration;
+}[];
+/**
+ * @param {Object} prevStyle first style to compare
+ * @param {Object} thisStyle second style to compare
+ * @param {boolean} forTextSpans whether to check overline, underline, and line-through properties
+ * @return {boolean} true if the style changed
+ */
+export declare const hasStyleChanged: (prevStyle: TextStyleDeclaration, thisStyle: TextStyleDeclaration, forTextSpans?: boolean) => boolean;
+/**
+ * Returns the array form of a text object's inline styles property with styles grouped in ranges
+ * rather than per character. This format is less verbose, and is better suited for storage
+ * so it is used in serialization (not during runtime).
+ * @param {object} styles per character styles for a text object
+ * @param {String} text the text string that the styles are applied to
+ * @return {{start: number, end: number, style: object}[]}
+ */
+export declare const stylesToArray: (styles: TextStyle, text: string) => TextStyleArray;
+/**
+ * Returns the object form of the styles property with styles that are assigned per
+ * character rather than grouped by range. This format is more verbose, and is
+ * only used during runtime (not for serialization/storage)
+ * @param {Array} styles the serialized form of a text object's styles
+ * @param {String} text the text string that the styles are applied to
+ * @return {Object}
+ */
+export declare const stylesFromArray: (styles: TextStyleArray | TextStyle, text: string) => TextStyle;
+//# sourceMappingURL=textStyles.d.ts.map

package/dist/src/util/misc/toFixed.d.ts

@@ -0,0 +1,8 @@
+/**
+ * A wrapper around Number#toFixed, which contrary to native method returns number, not string.
+ * @param {number|string} number number to operate on
+ * @param {number} fractionDigits number of fraction digits to "leave"
+ * @return {number}
+ */
+export declare const toFixed: (number: number | string, fractionDigits: number) => number;
+//# sourceMappingURL=toFixed.d.ts.map

package/dist/src/util/misc/vectors.d.ts

@@ -0,0 +1,57 @@
+import { XY, Point } from '../../Point';
+import { TRadian } from '../../typedefs';
+/**
+ * Rotates `vector` with `radians`
+ * @param {Point} vector The vector to rotate (x and y)
+ * @param {Number} radians The radians of the angle for the rotation
+ * @return {Point} The new rotated point
+ */
+export declare const rotateVector: (vector: Point, radians: TRadian) => Point;
+/**
+ * Creates a vector from points represented as a point
+ *
+ * @param {Point} from
+ * @param {Point} to
+ * @returns {Point} vector
+ */
+export declare const createVector: (from: XY, to: XY) => Point;
+/**
+ * return the magnitude of a vector
+ * @return {number}
+ */
+export declare const magnitude: (point: Point) => number;
+/**
+ * Calculates the angle between 2 vectors
+ * @param {Point} a
+ * @param {Point} b
+ * @returns the angle in radians from `a` to `b`
+ */
+export declare const calcAngleBetweenVectors: (a: Point, b: Point) => TRadian;
+/**
+ * Calculates the angle between the x axis and the vector
+ * @param {Point} v
+ * @returns the angle in radians of `v`
+ */
+export declare const calcVectorRotation: (v: Point) => TRadian;
+/**
+ * @param {Point} v
+ * @returns {Point} vector representing the unit vector pointing to the direction of `v`
+ */
+export declare const getUnitVector: (v: Point) => Point;
+/**
+ * @param {Point} A
+ * @param {Point} B
+ * @param {Point} C
+ * @returns {{ vector: Point, angle: TRadian}} vector representing the bisector of A and A's angle
+ */
+export declare const getBisector: (A: Point, B: Point, C: Point) => {
+    vector: Point;
+    angle: TRadian;
+};
+/**
+ * @param {Point} v
+ * @param {Boolean} [counterClockwise] the direction of the orthogonal vector, defaults to `true`
+ * @returns {Point} the unit orthogonal vector
+ */
+export declare const getOrthonormalVector: (v: Point, counterClockwise?: boolean) => Point;
+//# sourceMappingURL=vectors.d.ts.map

package/dist/src/util/path/index.d.ts

@@ -0,0 +1,96 @@
+import type { TMat2D, TRectBounds } from '../../typedefs';
+import { TComplexPathData, TParsedAbsoluteCubicCurveCommand, TPathSegmentInfo, TPointAngle, TSimplePathData, TParsedArcCommand } from './typedefs';
+import { Point } from '../../Point';
+/**
+ * Calculate bounding box of a cubic Bezier curve
+ * Taken from http://jsbin.com/ivomiq/56/edit (no credits available)
+ * TODO: can we normalize this with the starting points set at 0 and then translated the bbox?
+ * @param {number} begx starting point
+ * @param {number} begy
+ * @param {number} cp1x first control point
+ * @param {number} cp1y
+ * @param {number} cp2x second control point
+ * @param {number} cp2y
+ * @param {number} endx end of bezier
+ * @param {number} endy
+ * @return {TRectBounds} the rectangular bounds
+ */
+export declare function getBoundsOfCurve(begx: number, begy: number, cp1x: number, cp1y: number, cp2x: number, cp2y: number, endx: number, endy: number): TRectBounds;
+/**
+ * Converts arc to a bunch of cubic Bezier curves
+ * @param {number} fx starting point x
+ * @param {number} fy starting point y
+ * @param {TParsedArcCommand} coords Arc command
+ */
+export declare const fromArcToBeziers: (fx: number, fy: number, [_, rx, ry, rot, large, sweep, tx, ty]: TParsedArcCommand) => TParsedAbsoluteCubicCurveCommand[];
+/**
+ * This function takes a parsed SVG path and makes it simpler for fabricJS logic.
+ * Simplification consist of:
+ * - All commands converted to absolute (lowercase to uppercase)
+ * - S converted to C
+ * - T converted to Q
+ * - A converted to C
+ * @param {TComplexPathData} path the array of commands of a parsed SVG path for `Path`
+ * @return {TSimplePathData} the simplified array of commands of a parsed SVG path for `Path`
+ * TODO: figure out how to remove the type assertions in a nice way
+ */
+export declare const makePathSimpler: (path: TComplexPathData) => TSimplePathData;
+/**
+ * Run over a parsed and simplified path and extract some information (length of each command and starting point)
+ * @param {TSimplePathData} path parsed path commands
+ * @return {TPathSegmentInfo[]} path commands information
+ */
+export declare const getPathSegmentsInfo: (path: TSimplePathData) => TPathSegmentInfo[];
+/**
+ * Get the point on the path that is distance along the path
+ * @param path
+ * @param distance
+ * @param infos
+ */
+export declare const getPointOnPath: (path: TSimplePathData, distance: number, infos?: TPathSegmentInfo[]) => TPointAngle | undefined;
+/**
+ *
+ * @param {string} pathString
+ * @return {TComplexPathData} An array of SVG path commands
+ * @example <caption>Usage</caption>
+ * parsePath('M 3 4 Q 3 5 2 1 4 0 Q 9 12 2 1 4 0') === [
+ *   ['M', 3, 4],
+ *   ['Q', 3, 5, 2, 1, 4, 0],
+ *   ['Q', 9, 12, 2, 1, 4, 0],
+ * ];
+ *
+ */
+export declare const parsePath: (pathString: string) => TComplexPathData;
+/**
+ *
+ * Converts points to a smooth SVG path
+ * @param {XY[]} points Array of points
+ * @param {number} [correction] Apply a correction to the path (usually we use `width / 1000`). If value is undefined 0 is used as the correction value.
+ * @return {(string|number)[][]} An array of SVG path commands
+ */
+export declare const getSmoothPathFromPoints: (points: Point[], correction?: number) => TSimplePathData;
+/**
+ * Transform a path by transforming each segment.
+ * it has to be a simplified path or it won't work.
+ * WARNING: this depends from pathOffset for correct operation
+ * @param {TSimplePathData} path fabricJS parsed and simplified path commands
+ * @param {TMat2D} transform matrix that represent the transformation
+ * @param {Point} [pathOffset] `Path.pathOffset`
+ * @returns {TSimplePathData} the transformed path
+ */
+export declare const transformPath: (path: TSimplePathData, transform: TMat2D, pathOffset: Point) => TSimplePathData;
+/**
+ * Returns an array of path commands to create a regular polygon
+ * @param {number} numVertexes
+ * @param {number} radius
+ * @returns {TSimplePathData} An array of SVG path commands
+ */
+export declare const getRegularPolygonPath: (numVertexes: number, radius: number) => TSimplePathData;
+/**
+ * Join path commands to go back to svg format
+ * @param {TSimplePathData} pathData fabricJS parsed path commands
+ * @param {number} fractionDigits number of fraction digits to "leave"
+ * @return {String} joined path 'M 0 0 L 20 30'
+ */
+export declare const joinPath: (pathData: TSimplePathData, fractionDigits?: number) => string;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/util/path/regex.d.ts

@@ -0,0 +1,3 @@
+export declare const numberRegExStr: string;
+export declare const rePathCommand: string;
+//# sourceMappingURL=regex.d.ts.map

package/dist/src/util/path/typechecks.d.ts

@@ -0,0 +1,24 @@
+import type { TComplexParsedCommand, TParsedAbsoluteArcCommand, TParsedAbsoluteClosePathCommand, TParsedAbsoluteCubicCurveCommand, TParsedAbsoluteCubicCurveShortcutCommand, TParsedAbsoluteHorizontalLineCommand, TParsedAbsoluteLineCommand, TParsedAbsoluteMoveToCommand, TParsedAbsoluteQuadraticCurveCommand, TParsedAbsoluteQuadraticCurveShortcutCommand, TParsedAbsoluteVerticalLineCommand, TParsedClosePathCommand, TParsedLineCommand, TParsedRelativeArcCommand, TParsedRelativeClosePathCommand, TParsedRelativeCubicCurveCommand, TParsedRelativeCubicCurveShortcutCommand, TParsedRelativeHorizontalLineCommand, TParsedRelativeLineCommand, TParsedRelativeMoveToCommand, TParsedRelativeQuadraticCurveCommand, TParsedRelativeQuadraticCurveShortcutCommand, TParsedRelativeVerticalLineCommand } from './typedefs';
+export declare function isAbsMoveToCmd(cmd: TComplexParsedCommand): cmd is TParsedAbsoluteMoveToCommand;
+export declare function isRelMoveToCmd(cmd: TComplexParsedCommand): cmd is TParsedRelativeMoveToCommand;
+export declare function isAbsLineCmd(cmd: TComplexParsedCommand): cmd is TParsedAbsoluteLineCommand;
+export declare function isRelLineCmd(cmd: TComplexParsedCommand): cmd is TParsedRelativeLineCommand;
+export declare function isLineCommand(cmd: TComplexParsedCommand): cmd is TParsedLineCommand;
+export declare function isAbsHorizontalLineCmd(cmd: TComplexParsedCommand): cmd is TParsedAbsoluteHorizontalLineCommand;
+export declare function isRelHorizontalLineCmd(cmd: TComplexParsedCommand): cmd is TParsedRelativeHorizontalLineCommand;
+export declare function isAbsVerticalLineCmd(cmd: TComplexParsedCommand): cmd is TParsedAbsoluteVerticalLineCommand;
+export declare function isRelVerticalLineCmd(cmd: TComplexParsedCommand): cmd is TParsedRelativeVerticalLineCommand;
+export declare function isAbsClosePathCmd(cmd: TComplexParsedCommand): cmd is TParsedAbsoluteClosePathCommand;
+export declare function isRelClosePathCmd(cmd: TComplexParsedCommand): cmd is TParsedRelativeClosePathCommand;
+export declare function isClosePathCommand(cmd: TComplexParsedCommand): cmd is TParsedClosePathCommand;
+export declare function isAbsCubicCurveCmd(cmd: TComplexParsedCommand): cmd is TParsedAbsoluteCubicCurveCommand;
+export declare function isRelCubicCurveCmd(cmd: TComplexParsedCommand): cmd is TParsedRelativeCubicCurveCommand;
+export declare function isAbsCubicCurveShortcutCmd(cmd: TComplexParsedCommand): cmd is TParsedAbsoluteCubicCurveShortcutCommand;
+export declare function isRelCubicCurveShortcutCmd(cmd: TComplexParsedCommand): cmd is TParsedRelativeCubicCurveShortcutCommand;
+export declare function isAbsQuadraticCurveCmd(cmd: TComplexParsedCommand): cmd is TParsedAbsoluteQuadraticCurveCommand;
+export declare function isRelQuadraticCurveCmd(cmd: TComplexParsedCommand): cmd is TParsedRelativeQuadraticCurveCommand;
+export declare function isAbsQuadraticCurveShortcutCmd(cmd: TComplexParsedCommand): cmd is TParsedAbsoluteQuadraticCurveShortcutCommand;
+export declare function isRelQuadraticCurveShortcutCmd(cmd: TComplexParsedCommand): cmd is TParsedRelativeQuadraticCurveShortcutCommand;
+export declare function isAbsArcCmd(cmd: TComplexParsedCommand): cmd is TParsedAbsoluteArcCommand;
+export declare function isRelArcCmd(cmd: TComplexParsedCommand): cmd is TParsedRelativeArcCommand;
+//# sourceMappingURL=typechecks.d.ts.map