@nasser-sw/fabric 7.0.0-beta1

package/dist-extensions/src/shapes/Object/types/FillStrokeProps.d.ts

@@ -0,0 +1,78 @@
+import type { TFiller } from '../../../typedefs';
+export interface FillStrokeProps {
+    /**
+     * Determines if the fill or the stroke is drawn first (one of "fill" or "stroke")
+     * @type String
+     */
+    paintFirst: 'fill' | 'stroke';
+    /**
+     * Color of object's fill
+     * takes css colors https://www.w3.org/TR/css-color-3/
+     * @type String
+     * @default rgb(0,0,0)
+     */
+    fill: ReturnType<TFiller['toObject']> | string | null;
+    /**
+     * Fill rule used to fill an object
+     * accepted values are nonzero, evenodd
+     * <b>Backwards incompatibility note:</b> This property was used for setting globalCompositeOperation until v1.4.12 (use `globalCompositeOperation` instead)
+     * @type String
+     * @default nonzero
+     */
+    fillRule: CanvasFillRule;
+    /**
+     * When defined, an object is rendered via stroke and this property specifies its color
+     * takes css colors https://www.w3.org/TR/css-color-3/
+     * @type String
+     * @default null
+     */
+    stroke: ReturnType<TFiller['toObject']> | string | null;
+    /**
+     * Width of a stroke used to render this object
+     * @type Number
+     * @default 1
+     */
+    strokeWidth: number;
+    /**
+     * Array specifying dash pattern of an object's stroke (stroke must be defined)
+     * @type Array
+     * @default null;
+     */
+    strokeDashArray: number[] | null;
+    /**
+     * Line offset of an object's stroke
+     * @type Number
+     * @default 0
+     */
+    strokeDashOffset: number;
+    /**
+     * Line endings style of an object's stroke (one of "butt", "round", "square")
+     * @type String
+     * @default butt
+     */
+    strokeLineCap: CanvasLineCap;
+    /**
+     * Corner style of an object's stroke (one of "bevel", "round", "miter")
+     * @type String
+     */
+    strokeLineJoin: CanvasLineJoin;
+    /**
+     * Maximum miter length (used for strokeLineJoin = "miter") of an object's stroke
+     * @type Number
+     * @default 4
+     */
+    strokeMiterLimit: number;
+    /**
+     * When `false`, the stoke width will scale with the object.
+     * When `true`, the stroke will always match the exact pixel size entered for stroke width.
+     * this Property does not work on Text classes or drawing call that uses strokeText,fillText methods
+     * default to false
+     * @since 2.6.0
+     * @type Boolean
+     * @default false
+     * @type Boolean
+     * @default false
+     */
+    strokeUniform: boolean;
+}
+//# sourceMappingURL=FillStrokeProps.d.ts.map

package/dist-extensions/src/shapes/Object/types/FillStrokeProps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FillStrokeProps.d.ts","sourceRoot":"","sources":["../../../../../src/shapes/Object/types/FillStrokeProps.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAEjD,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,UAAU,EAAE,MAAM,GAAG,QAAQ,CAAC;IAE9B;;;;;OAKG;IACH,IAAI,EAAE,UAAU,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,GAAG,MAAM,GAAG,IAAI,CAAC;IAEtD;;;;;;OAMG;IACH,QAAQ,EAAE,cAAc,CAAC;IAEzB;;;;;OAKG;IACH,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,GAAG,MAAM,GAAG,IAAI,CAAC;IAExD;;;;OAIG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;;;OAIG;IACH,eAAe,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IAEjC;;;;OAIG;IACH,gBAAgB,EAAE,MAAM,CAAC;IAEzB;;;;OAIG;IACH,aAAa,EAAE,aAAa,CAAC;IAE7B;;;OAGG;IACH,cAAc,EAAE,cAAc,CAAC;IAE/B;;;;OAIG;IACH,gBAAgB,EAAE,MAAM,CAAC;IAEzB;;;;;;;;;;OAUG;IACH,aAAa,EAAE,OAAO,CAAC;CACxB"}

package/dist-extensions/src/shapes/Object/types/LockInteractionProps.d.ts

@@ -0,0 +1,43 @@
+export interface LockInteractionProps {
+    /**
+     * When `true`, object horizontal movement is locked
+     * @type Boolean
+     */
+    lockMovementX: boolean;
+    /**
+     * When `true`, object vertical movement is locked
+     * @type Boolean
+     */
+    lockMovementY: boolean;
+    /**
+     * When `true`, object rotation is locked
+     * @type Boolean
+     */
+    lockRotation: boolean;
+    /**
+     * When `true`, object horizontal scaling is locked
+     * @type Boolean
+     */
+    lockScalingX: boolean;
+    /**
+     * When `true`, object vertical scaling is locked
+     * @type Boolean
+     */
+    lockScalingY: boolean;
+    /**
+     * When `true`, object horizontal skewing is locked
+     * @type Boolean
+     */
+    lockSkewingX: boolean;
+    /**
+     * When `true`, object vertical skewing is locked
+     * @type Boolean
+     */
+    lockSkewingY: boolean;
+    /**
+     * When `true`, object cannot be flipped by scaling into negative values
+     * @type Boolean
+     */
+    lockScalingFlip: boolean;
+}
+//# sourceMappingURL=LockInteractionProps.d.ts.map

package/dist-extensions/src/shapes/Object/types/LockInteractionProps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LockInteractionProps.d.ts","sourceRoot":"","sources":["../../../../../src/shapes/Object/types/LockInteractionProps.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,oBAAoB;IACnC;;;OAGG;IACH,aAAa,EAAE,OAAO,CAAC;IAEvB;;;OAGG;IACH,aAAa,EAAE,OAAO,CAAC;IAEvB;;;OAGG;IACH,YAAY,EAAE,OAAO,CAAC;IAEtB;;;OAGG;IACH,YAAY,EAAE,OAAO,CAAC;IAEtB;;;OAGG;IACH,YAAY,EAAE,OAAO,CAAC;IAEtB;;;OAGG;IACH,YAAY,EAAE,OAAO,CAAC;IAEtB;;;OAGG;IACH,YAAY,EAAE,OAAO,CAAC;IAEtB;;;OAGG;IACH,eAAe,EAAE,OAAO,CAAC;CAC1B"}

package/dist-extensions/src/shapes/Object/types/ObjectProps.d.ts

@@ -0,0 +1,41 @@
+import type { Shadow } from '../../../Shadow';
+import type { Canvas } from '../../../canvas/Canvas';
+import type { StaticCanvas } from '../../../canvas/StaticCanvas';
+import type { TFiller } from '../../../typedefs';
+import type { FabricObject } from '../Object';
+import type { ObjectTransformActionProps } from './ObjectTransformProps';
+import type { ClipPathProps, SerializedObjectProps } from './SerializedObjectProps';
+export interface ObjectProps extends SerializedObjectProps, ClipPathProps, ObjectTransformActionProps {
+    clipPath?: FabricObject;
+    fill: TFiller | string | null;
+    stroke: TFiller | string | null;
+    shadow: Shadow | null;
+    canvas?: StaticCanvas | Canvas;
+    /**
+     * Minimum allowed scale value of an object
+     * @type Number
+     * @default 0
+     */
+    minScaleLimit: number;
+    /**
+     * When `true`, object is cached on an additional canvas.
+     * When `false`, object is not cached unless necessary ( clipPath )
+     * default to true
+     * @since 1.7.0
+     * @type Boolean
+     * @default true
+     */
+    objectCaching: boolean;
+    /**
+     * When `false`, default object's values are not included in its serialization
+     * @type Boolean
+     */
+    includeDefaultValues: boolean;
+    /**
+     * When `true`, object is not exported in OBJECT/JSON
+     * @since 1.6.3
+     * @type Boolean
+     */
+    excludeFromExport: boolean;
+}
+//# sourceMappingURL=ObjectProps.d.ts.map

package/dist-extensions/src/shapes/Object/types/ObjectProps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ObjectProps.d.ts","sourceRoot":"","sources":["../../../../../src/shapes/Object/types/ObjectProps.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAC9C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AACjE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,wBAAwB,CAAC;AACzE,OAAO,KAAK,EACV,aAAa,EACb,qBAAqB,EACtB,MAAM,yBAAyB,CAAC;AAEjC,MAAM,WAAW,WACf,SAAQ,qBAAqB,EAC3B,aAAa,EACb,0BAA0B;IAC5B,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB,IAAI,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAAC;IAC9B,MAAM,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAAC;IAChC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,MAAM,CAAC,EAAE,YAAY,GAAG,MAAM,CAAC;IAE/B;;;;OAIG;IACH,aAAa,EAAE,MAAM,CAAC;IAEtB;;;;;;;OAOG;IACH,aAAa,EAAE,OAAO,CAAC;IAEvB;;;OAGG;IACH,oBAAoB,EAAE,OAAO,CAAC;IAE9B;;;;OAIG;IACH,iBAAiB,EAAE,OAAO,CAAC;CAC5B"}

package/dist-extensions/src/shapes/Object/types/ObjectTransformProps.d.ts

@@ -0,0 +1,32 @@
+import type { TDegree } from '../../../typedefs';
+export interface ObjectTransformActionProps {
+    /**
+     * The angle that an object will lock to while rotating.
+     * @type [TDegree]
+     */
+    snapAngle?: TDegree;
+    /**
+     * The angle difference from the current snapped angle in which snapping should occur.
+     * When undefined, the snapThreshold will default to the snapAngle.
+     * @type [TDegree]
+     */
+    snapThreshold?: TDegree;
+    /**
+     * When `true` the object will rotate on its center.
+     * When `false` will rotate around the origin point defined by originX and originY.
+     * The value of this property is IGNORED during a transform if the canvas has already
+     * centeredRotation set to `true`
+     * The object method `rotate` will always consider this property and never the canvas's one.
+     * @since 1.3.4
+     * @type Boolean
+     */
+    centeredRotation: boolean;
+    /**
+     * When true, this object will use center point as the origin of transformation
+     * when being scaled via the controls.
+     * @since 1.3.4
+     * @type Boolean
+     */
+    centeredScaling: boolean;
+}
+//# sourceMappingURL=ObjectTransformProps.d.ts.map

package/dist-extensions/src/shapes/Object/types/ObjectTransformProps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ObjectTransformProps.d.ts","sourceRoot":"","sources":["../../../../../src/shapes/Object/types/ObjectTransformProps.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAEjD,MAAM,WAAW,0BAA0B;IACzC;;;OAGG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IAEpB;;;;OAIG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IAExB;;;;;;;;OAQG;IACH,gBAAgB,EAAE,OAAO,CAAC;IAE1B;;;;;OAKG;IACH,eAAe,EAAE,OAAO,CAAC;CAC1B"}

package/dist-extensions/src/shapes/Object/types/SerializedObjectProps.d.ts

@@ -0,0 +1,63 @@
+import type { Shadow } from '../../../Shadow';
+import type { BaseProps } from './BaseProps';
+import type { FillStrokeProps } from './FillStrokeProps';
+export interface SerializedObjectProps extends BaseProps, FillStrokeProps {
+    /**
+     * Opacity of an object
+     * @type Number
+     * @default 1
+     */
+    opacity: number;
+    /**
+     * Composite rule used for canvas globalCompositeOperation
+     * @type String
+     */
+    globalCompositeOperation: GlobalCompositeOperation;
+    /**
+     * Background color of an object.
+     * takes css colors https://www.w3.org/TR/css-color-3/
+     * @type String
+     */
+    backgroundColor: string;
+    /**
+     * Shadow object representing shadow of this shape
+     * @type Shadow
+     * @default null
+     */
+    shadow: ReturnType<Shadow['toObject']> | null;
+    /**
+     * When set to `false`, an object is not rendered on canvas
+     * @type Boolean
+     */
+    visible: boolean;
+    /**
+     * a fabricObject that, without stroke define a clipping area with their shape. filled in black
+     * the clipPath object gets used when the object has rendered, and the context is placed in the center
+     * of the object cacheCanvas.
+     * If you want 0,0 of a clipPath to align with an object center, use clipPath.originX/Y to 'center'
+     * @type FabricObject
+     */
+    clipPath?: Partial<SerializedObjectProps & ClipPathProps>;
+}
+export interface ClipPathProps {
+    /**
+     * Meaningful ONLY when the object is used as clipPath.
+     * if true, the clipPath will make the object clip to the outside of the clipPath
+     * since 2.4.0
+     * @type boolean
+     * @default false
+     */
+    inverted: boolean;
+    /**
+     * Meaningful ONLY when the object is used as clipPath.
+     * if true, the clipPath will have its top and left relative to canvas, and will
+     * not be influenced by the object transform. This will make the clipPath relative
+     * to the canvas, but clipping just a particular object.
+     * WARNING this is beta, this feature may change or be renamed.
+     * since 2.4.0
+     * @type boolean
+     * @default false
+     */
+    absolutePositioned: boolean;
+}
+//# sourceMappingURL=SerializedObjectProps.d.ts.map

package/dist-extensions/src/shapes/Object/types/SerializedObjectProps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SerializedObjectProps.d.ts","sourceRoot":"","sources":["../../../../../src/shapes/Object/types/SerializedObjectProps.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAC9C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEzD,MAAM,WAAW,qBAAsB,SAAQ,SAAS,EAAE,eAAe;IACvE;;;;OAIG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;;OAGG;IACH,wBAAwB,EAAE,wBAAwB,CAAC;IAEnD;;;;OAIG;IACH,eAAe,EAAE,MAAM,CAAC;IAExB;;;;OAIG;IACH,MAAM,EAAE,UAAU,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,GAAG,IAAI,CAAC;IAE9C;;;OAGG;IACH,OAAO,EAAE,OAAO,CAAC;IAEjB;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC,qBAAqB,GAAG,aAAa,CAAC,CAAC;CAC3D;AAED,MAAM,WAAW,aAAa;IAC5B;;;;;;OAMG;IACH,QAAQ,EAAE,OAAO,CAAC;IAElB;;;;;;;;;OASG;IACH,kBAAkB,EAAE,OAAO,CAAC;CAC7B"}

package/dist-extensions/src/shapes/Object/types/index.d.ts

@@ -0,0 +1,6 @@
+import type { FabricObjectProps } from './FabricObjectProps';
+import type { TOptions } from '../../../typedefs';
+export type { SerializedObjectProps } from './SerializedObjectProps';
+export type { FabricObjectProps };
+export type TFabricObjectProps = TOptions<FabricObjectProps>;
+//# sourceMappingURL=index.d.ts.map

package/dist-extensions/src/shapes/Object/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/shapes/Object/types/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAElD,YAAY,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AACrE,YAAY,EAAE,iBAAiB,EAAE,CAAC;AAElC,MAAM,MAAM,kBAAkB,GAAG,QAAQ,CAAC,iBAAiB,CAAC,CAAC"}

package/dist-extensions/src/shapes/Path.d.ts

@@ -0,0 +1,208 @@
+import { Point } from '../Point';
+import { FabricObject } from './Object/FabricObject';
+import type { TComplexPathData, TPathSegmentInfo, TSimplePathData } from '../util/path/typedefs';
+import type { FabricObjectProps, SerializedObjectProps } from './Object/types';
+import type { ObjectEvents } from '../EventTypeDefs';
+import type { TBBox, TClassProperties, TSVGReviver, TOptions } from '../typedefs';
+import type { CSSRules } from '../parser/typedefs';
+interface UniquePathProps {
+    sourcePath?: string;
+    path?: TSimplePathData;
+}
+export interface SerializedPathProps extends SerializedObjectProps, UniquePathProps {
+}
+export interface PathProps extends FabricObjectProps, UniquePathProps {
+}
+export interface IPathBBox extends TBBox {
+    left: number;
+    top: number;
+    pathOffset: Point;
+}
+export declare class Path<Props extends TOptions<PathProps> = Partial<PathProps>, SProps extends SerializedPathProps = SerializedPathProps, EventSpec extends ObjectEvents = ObjectEvents> extends FabricObject<Props, SProps, EventSpec> {
+    /**
+     * Array of path points
+     * @type Array
+     */
+    path: TSimplePathData;
+    pathOffset: Point;
+    sourcePath?: string;
+    segmentsInfo?: TPathSegmentInfo[];
+    static type: string;
+    static cacheProperties: string[];
+    /**
+     * Constructor
+     * @param {TComplexPathData} path Path data (sequence of coordinates and corresponding "command" tokens)
+     * @param {Partial<PathProps>} [options] Options object
+     * @return {Path} thisArg
+     */
+    constructor(path: TComplexPathData | string, { path: _, left, top, ...options }?: Partial<Props>);
+    /**
+     * @private
+     * @param {TComplexPathData | string} path Path data (sequence of coordinates and corresponding "command" tokens)
+     * @param {boolean} [adjustPosition] pass true to reposition the object according to the bounding box
+     * @returns {Point} top left position of the bounding box, useful for complementary positioning
+     */
+    _setPath(path: TComplexPathData | string, adjustPosition?: boolean): void;
+    /**
+     * This function is an helper for svg import. it returns the center of the object in the svg
+     * untransformed coordinates, by look at the polyline/polygon points.
+     * @private
+     * @return {Point} center point from element coordinates
+     */
+    _findCenterFromElement(): Point;
+    /**
+     * @private
+     * @param {CanvasRenderingContext2D} ctx context to render path on
+     */
+    _renderPathCommands(ctx: CanvasRenderingContext2D): void;
+    /**
+     * @private
+     * @param {CanvasRenderingContext2D} ctx context to render path on
+     */
+    _render(ctx: CanvasRenderingContext2D): void;
+    /**
+     * Returns string representation of an instance
+     * @return {string} string representation of an instance
+     */
+    toString(): string;
+    /**
+     * Returns object representation of an instance
+     * @param {Array} [propertiesToInclude] Any properties that you might want to additionally include in the output
+     * @return {Object} object representation of an instance
+     */
+    toObject<T extends Omit<Props & TClassProperties<this>, keyof SProps>, K extends keyof T = never>(propertiesToInclude?: K[]): Pick<T, K> & SProps;
+    /**
+     * Returns dataless object representation of an instance
+     * @param {Array} [propertiesToInclude] Any properties that you might want to additionally include in the output
+     * @return {Object} object representation of an instance
+     */
+    toDatalessObject<T extends Omit<Props & TClassProperties<this>, keyof SProps>, K extends keyof T = never>(propertiesToInclude?: K[]): Pick<T, K> & SProps;
+    /**
+     * Returns svg representation of an instance
+     * @return {Array} an array of strings with the specific svg representation
+     * of the instance
+     */
+    _toSVG(): string[];
+    /**
+     * @private
+     * @return the path command's translate transform attribute
+     */
+    _getOffsetTransform(): string;
+    /**
+     * Returns svg clipPath representation of an instance
+     * @param {Function} [reviver] Method for further parsing of svg representation.
+     * @return {string} svg representation of an instance
+     */
+    toClipPathSVG(reviver?: TSVGReviver): string;
+    /**
+     * Returns svg representation of an instance
+     * @param {Function} [reviver] Method for further parsing of svg representation.
+     * @return {string} svg representation of an instance
+     */
+    toSVG(reviver?: TSVGReviver): string;
+    /**
+     * Returns number representation of an instance complexity
+     * @return {number} complexity of this instance
+     */
+    complexity(): number;
+    setDimensions(): void;
+    setBoundingBox(adjustPosition?: boolean): void;
+    _calcBoundsFromPath(): TBBox;
+    /**
+     * @private
+     */
+    _calcDimensions(): IPathBBox;
+    /**
+     * List of attribute names to account for when parsing SVG element (used by `Path.fromElement`)
+     * @see http://www.w3.org/TR/SVG/paths.html#PathElement
+     */
+    static ATTRIBUTE_NAMES: string[];
+    /**
+     * Creates an instance of Path from an object
+     * @param {Object} object
+     * @returns {Promise<Path>}
+     */
+    static fromObject<T extends TOptions<SerializedPathProps>>(object: T): Promise<Path<Partial<PathProps>, SerializedPathProps, ObjectEvents>>;
+    /**
+     * Creates an instance of Path from an SVG <path> element
+     * @param {HTMLElement} element to parse
+     * @param {Partial<PathProps>} [options] Options object
+     */
+    static fromElement(element: HTMLElement | SVGElement, options?: Partial<PathProps>, cssRules?: CSSRules): Promise<Path<{
+        left: undefined;
+        top: undefined;
+        noScaleCache: boolean;
+        hoverCursor: CSSStyleDeclaration["cursor"] | null;
+        moveCursor: CSSStyleDeclaration["cursor"] | null;
+        selectionBackgroundColor: string;
+        perPixelTargetFind: boolean;
+        selectable: boolean;
+        evented: boolean;
+        activeOn: "down" | "up";
+        clipPath: import("./Object/Object").FabricObject;
+        fill: string | import("../gradient").Gradient<"linear", "linear"> | import("../gradient").Gradient<"radial", "radial"> | import("../Pattern").Pattern | null;
+        stroke: string | import("../gradient").Gradient<"linear", "linear"> | import("../gradient").Gradient<"radial", "radial"> | import("../Pattern").Pattern | null;
+        shadow: import("../Shadow").Shadow | null;
+        canvas: import("../..").StaticCanvas | import("../..").Canvas;
+        minScaleLimit: number;
+        objectCaching: boolean;
+        includeDefaultValues: boolean;
+        excludeFromExport: boolean;
+        opacity: number;
+        globalCompositeOperation: "color" | "screen" | "color-burn" | "color-dodge" | "copy" | "darken" | "destination-atop" | "destination-in" | "destination-out" | "destination-over" | "difference" | "exclusion" | "hard-light" | "hue" | "lighten" | "lighter" | "luminosity" | "multiply" | "overlay" | "saturation" | "soft-light" | "source-atop" | "source-in" | "source-out" | "source-over" | "xor";
+        backgroundColor: string;
+        visible: boolean;
+        width: number;
+        height: number;
+        originX: number | "center" | "left" | "right";
+        originY: number | "center" | "top" | "bottom";
+        angle: import("../typedefs").TDegree;
+        flipX: boolean;
+        flipY: boolean;
+        scaleX: number;
+        scaleY: number;
+        skewX: import("../typedefs").TDegree;
+        skewY: import("../typedefs").TDegree;
+        paintFirst: "fill" | "stroke";
+        fillRule: "evenodd" | "nonzero";
+        strokeWidth: number;
+        strokeDashArray: number[] | null;
+        strokeDashOffset: number;
+        strokeLineCap: "butt" | "round" | "square";
+        strokeLineJoin: "round" | "bevel" | "miter";
+        strokeMiterLimit: number;
+        strokeUniform: boolean;
+        inverted: boolean;
+        absolutePositioned: boolean;
+        snapAngle: import("../typedefs").TDegree;
+        snapThreshold: import("../typedefs").TDegree;
+        centeredRotation: boolean;
+        centeredScaling: boolean;
+        cornerSize: number;
+        touchCornerSize: number;
+        transparentCorners: boolean;
+        cornerColor: string;
+        cornerStrokeColor: string;
+        cornerStyle: "rect" | "circle";
+        cornerDashArray: number[] | null;
+        padding: number;
+        hasControls: boolean;
+        borderColor: string;
+        borderDashArray: number[] | null;
+        hasBorders: boolean;
+        borderOpacityWhenMoving: number;
+        borderScaleFactor: number;
+        lockMovementX: boolean;
+        lockMovementY: boolean;
+        lockRotation: boolean;
+        lockScalingX: boolean;
+        lockScalingY: boolean;
+        lockSkewingX: boolean;
+        lockSkewingY: boolean;
+        lockScalingFlip: boolean;
+        sourcePath: string;
+        path: TSimplePathData;
+    }, SerializedPathProps, ObjectEvents>>;
+}
+export {};
+//# sourceMappingURL=Path.d.ts.map

package/dist-extensions/src/shapes/Path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Path.d.ts","sourceRoot":"","sources":["../../../src/shapes/Path.ts"],"names":[],"mappings":"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"}

package/dist-extensions/src/shapes/Polygon.d.ts

@@ -0,0 +1,7 @@
+import { Polyline } from './Polyline';
+export declare class Polygon extends Polyline {
+    static ownDefaults: Partial<import("../typedefs").TClassProperties<Polyline<Partial<import("./Object/types").FabricObjectProps>, import("./Polyline").SerializedPolylineProps, import("../EventTypeDefs").ObjectEvents>>>;
+    static type: string;
+    protected isOpen(): boolean;
+}
+//# sourceMappingURL=Polygon.d.ts.map

package/dist-extensions/src/shapes/Polygon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Polygon.d.ts","sourceRoot":"","sources":["../../../src/shapes/Polygon.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAyB,MAAM,YAAY,CAAC;AAE7D,qBAAa,OAAQ,SAAQ,QAAQ;IACnC,MAAM,CAAC,WAAW,wMAAyB;IAE3C,MAAM,CAAC,IAAI,SAAa;IAExB,SAAS,CAAC,MAAM;CAGjB"}

package/dist-extensions/src/shapes/Polyline.d.ts

@@ -0,0 +1,149 @@
+import type { XY } from '../Point';
+import { Point } from '../Point';
+import type { Abortable, TClassProperties, TOptions } from '../typedefs';
+import type { TProjectStrokeOnPointsOptions } from '../util/misc/projectStroke/types';
+import { FabricObject } from './Object/FabricObject';
+import type { FabricObjectProps, SerializedObjectProps } from './Object/types';
+import type { ObjectEvents } from '../EventTypeDefs';
+import type { CSSRules } from '../parser/typedefs';
+export declare const polylineDefaultValues: Partial<TClassProperties<Polyline>>;
+export interface SerializedPolylineProps extends SerializedObjectProps {
+    points: XY[];
+}
+export declare class Polyline<Props extends TOptions<FabricObjectProps> = Partial<FabricObjectProps>, SProps extends SerializedPolylineProps = SerializedPolylineProps, EventSpec extends ObjectEvents = ObjectEvents> extends FabricObject<Props, SProps, EventSpec> {
+    /**
+     * Points array
+     * @type Array
+     */
+    points: XY[];
+    /**
+     * WARNING: Feature in progress
+     * Calculate the exact bounding box taking in account strokeWidth on acute angles
+     * this will be turned to true by default on fabric 6.0
+     * maybe will be left in as an optimization since calculations may be slow
+     * @deprecated transient option soon to be removed in favor of a different design
+     * @type Boolean
+     * @default false
+     */
+    exactBoundingBox: boolean;
+    private initialized;
+    static ownDefaults: Partial<TClassProperties<Polyline<Partial<FabricObjectProps>, SerializedPolylineProps, ObjectEvents>>>;
+    static type: string;
+    static getDefaults(): Record<string, any>;
+    /**
+     * A list of properties that if changed trigger a recalculation of dimensions
+     * @todo check if you really need to recalculate for all cases
+     */
+    static layoutProperties: (keyof Polyline)[];
+    pathOffset: Point;
+    strokeOffset: Point;
+    static cacheProperties: string[];
+    strokeDiff: Point;
+    /**
+     * Constructor
+     * @param {Array} points Array of points (where each point is an object with x and y)
+     * @param {Object} [options] Options object
+     * @return {Polyline} thisArg
+     * @example
+     * var poly = new Polyline([
+     *     { x: 10, y: 10 },
+     *     { x: 50, y: 30 },
+     *     { x: 40, y: 70 },
+     *     { x: 60, y: 50 },
+     *     { x: 100, y: 150 },
+     *     { x: 40, y: 100 }
+     *   ], {
+     *   stroke: 'red',
+     *   left: 100,
+     *   top: 100
+     * });
+     */
+    constructor(points?: XY[], options?: Props);
+    protected isOpen(): boolean;
+    private _projectStrokeOnPoints;
+    /**
+     * Calculate the polygon bounding box
+     * @private
+     */
+    _calcDimensions(options?: Partial<TProjectStrokeOnPointsOptions>): {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+        pathOffset: Point;
+        strokeOffset: Point;
+        strokeDiff: Point;
+    };
+    /**
+     * This function is an helper for svg import. it returns the center of the object in the svg
+     * untransformed coordinates, by look at the polyline/polygon points.
+     * @private
+     * @return {Point} center point from element coordinates
+     */
+    _findCenterFromElement(): Point;
+    setDimensions(): void;
+    setBoundingBox(adjustPosition?: boolean): void;
+    /**
+     * @deprecated intermidiate method to be removed, do not use
+     */
+    protected isStrokeAccountedForInDimensions(): boolean;
+    /**
+     * @override stroke is taken in account in size
+     */
+    _getNonTransformedDimensions(): Point;
+    /**
+     * @override stroke and skewing are taken into account when projecting stroke on points,
+     * therefore we don't want the default calculation to account for skewing as well.
+     * Though it is possible to pass `width` and `height` in `options`, doing so is very strange, use with discretion.
+     *
+     * @private
+     */
+    _getTransformedDimensions(options?: any): Point;
+    /**
+     * Recalculates dimensions when changing skew and scale
+     * @private
+     */
+    _set(key: string, value: any): this;
+    /**
+     * Returns object representation of an instance
+     * @param {Array} [propertiesToInclude] Any properties that you might want to additionally include in the output
+     * @return {Object} Object representation of an instance
+     */
+    toObject<T extends Omit<Props & TClassProperties<this>, keyof SProps>, K extends keyof T = never>(propertiesToInclude?: K[]): Pick<T, K> & SProps;
+    /**
+     * Returns svg representation of an instance
+     * @return {Array} an array of strings with the specific svg representation
+     * of the instance
+     */
+    _toSVG(): string[];
+    /**
+     * @private
+     * @param {CanvasRenderingContext2D} ctx Context to render on
+     */
+    _render(ctx: CanvasRenderingContext2D): void;
+    /**
+     * Returns complexity of an instance
+     * @return {Number} complexity of this instance
+     */
+    complexity(): number;
+    /**
+     * List of attribute names to account for when parsing SVG element (used by {@link Polyline.fromElement})
+     * @see: http://www.w3.org/TR/SVG/shapes.html#PolylineElement
+     */
+    static ATTRIBUTE_NAMES: string[];
+    /**
+     * Returns Polyline instance from an SVG element
+     * @param {HTMLElement} element Element to parser
+     * @param {Object} [options] Options object
+     */
+    static fromElement(element: HTMLElement | SVGElement, options?: Abortable, cssRules?: CSSRules): Promise<Polyline<{
+        signal?: AbortSignal;
+    }, SerializedPolylineProps, ObjectEvents>>;
+    /**
+     * Returns Polyline instance from an object representation
+     * @param {Object} object Object to create an instance from
+     * @returns {Promise<Polyline>}
+     */
+    static fromObject<T extends TOptions<SerializedPolylineProps>>(object: T): Promise<Polyline<Partial<FabricObjectProps>, SerializedPolylineProps, ObjectEvents>>;
+}
+//# sourceMappingURL=Polyline.d.ts.map