fabric 6.2.0 → 6.3.0

package/dist-extensions/src/util/misc/groupSVGElements.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"groupSVGElements.d.ts","sourceRoot":"","sources":["../../../../src/util/misc/groupSVGElements.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAErE;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,aACjB,YAAY,EAAE,YACd,OAAO,CAAC,UAAU,CAAC,sJAM9B,CAAC"}

package/dist-extensions/src/util/misc/isTransparent.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Returns true if context has transparent pixel
+ * at specified location (taking tolerance into account)
+ * @param {CanvasRenderingContext2D} ctx context
+ * @param {Number} x x coordinate in canvasElementCoordinate, not fabric space. integer
+ * @param {Number} y y coordinate in canvasElementCoordinate, not fabric space. integer
+ * @param {Number} tolerance Tolerance pixels around the point, not alpha tolerance, integer
+ * @return {boolean} true if transparent
+ */
+export declare const isTransparent: (ctx: CanvasRenderingContext2D, x: number, y: number, tolerance: number) => boolean;
+//# sourceMappingURL=isTransparent.d.ts.map

package/dist-extensions/src/util/misc/isTransparent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isTransparent.d.ts","sourceRoot":"","sources":["../../../../src/util/misc/isTransparent.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,QACnB,wBAAwB,KAC1B,MAAM,KACN,MAAM,aACE,MAAM,KAChB,OAaF,CAAC"}

package/dist-extensions/src/util/misc/matrix.d.ts

@@ -0,0 +1,170 @@
+import type { XY } from '../../Point';
+import { Point } from '../../Point';
+import type { TDegree, TRadian, TMat2D } from '../../typedefs';
+export type TRotateMatrixArgs = {
+    angle?: TDegree;
+};
+export type TTranslateMatrixArgs = {
+    translateX?: number;
+    translateY?: number;
+};
+export type TScaleMatrixArgs = {
+    scaleX?: number;
+    scaleY?: number;
+    flipX?: boolean;
+    flipY?: boolean;
+    skewX?: TDegree;
+    skewY?: TDegree;
+};
+export type TComposeMatrixArgs = TTranslateMatrixArgs & TRotateMatrixArgs & TScaleMatrixArgs;
+export type TQrDecomposeOut = Required<Omit<TComposeMatrixArgs, 'flipX' | 'flipY'>>;
+export declare const isIdentityMatrix: (mat: TMat2D) => boolean;
+/**
+ * Apply transform t to point p
+ * @deprecated use {@link Point#transform}
+ * @param  {Point | XY} p The point to transform
+ * @param  {Array} t The transform
+ * @param  {Boolean} [ignoreOffset] Indicates that the offset should not be applied
+ * @return {Point} The transformed point
+ */
+export declare const transformPoint: (p: XY, t: TMat2D, ignoreOffset?: boolean) => Point;
+/**
+ * Invert transformation t
+ * @param {Array} t The transform
+ * @return {Array} The inverted transform
+ */
+export declare const invertTransform: (t: TMat2D) => TMat2D;
+/**
+ * Multiply matrix A by matrix B to nest transformations
+ * @param  {TMat2D} a First transformMatrix
+ * @param  {TMat2D} b Second transformMatrix
+ * @param  {Boolean} is2x2 flag to multiply matrices as 2x2 matrices
+ * @return {TMat2D} The product of the two transform matrices
+ */
+export declare const multiplyTransformMatrices: (a: TMat2D, b: TMat2D, is2x2?: boolean) => TMat2D;
+/**
+ * Multiplies {@link matrices} such that a matrix defines the plane for the rest of the matrices **after** it
+ *
+ * `multiplyTransformMatrixArray([A, B, C, D])` is equivalent to `A(B(C(D)))`
+ *
+ * @param matrices an array of matrices
+ * @param [is2x2] flag to multiply matrices as 2x2 matrices
+ * @returns the multiplication product
+ */
+export declare const multiplyTransformMatrixArray: (matrices: (TMat2D | undefined | null | false)[], is2x2?: boolean) => TMat2D;
+export declare const calcPlaneRotation: ([a, b]: TMat2D) => TRadian;
+/**
+ * Decomposes standard 2x3 matrix into transform components
+ * @param  {TMat2D} a transformMatrix
+ * @return {Object} Components of transform
+ */
+export declare const qrDecompose: (a: TMat2D) => TQrDecomposeOut;
+/**
+ * Generate a translation matrix
+ *
+ * A translation matrix in the form of
+ * [ 1 0 x ]
+ * [ 0 1 y ]
+ * [ 0 0 1 ]
+ *
+ * See @link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/transform#translate for more details
+ *
+ * @param {number} x translation on X axis
+ * @param {number} [y] translation on Y axis
+ * @returns {TMat2D} matrix
+ */
+export declare const createTranslateMatrix: (x: number, y?: number) => TMat2D;
+/**
+ * Generate a rotation matrix around around a point (x,y), defaulting to (0,0)
+ *
+ * A matrix in the form of
+ * [cos(a) -sin(a) -x*cos(a)+y*sin(a)+x]
+ * [sin(a)  cos(a) -x*sin(a)-y*cos(a)+y]
+ * [0       0      1                 ]
+ *
+ *
+ * @param {TDegree} angle rotation in degrees
+ * @param {XY} [pivotPoint] pivot point to rotate around
+ * @returns {TMat2D} matrix
+ */
+export declare function createRotateMatrix({ angle }?: TRotateMatrixArgs, { x, y }?: Partial<XY>): TMat2D;
+/**
+ * Generate a scale matrix around the point (0,0)
+ *
+ * A matrix in the form of
+ * [x 0 0]
+ * [0 y 0]
+ * [0 0 1]
+ *
+ * @link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/transform#scale
+ *
+ * @param {number} x scale on X axis
+ * @param {number} [y] scale on Y axis
+ * @returns {TMat2D} matrix
+ */
+export declare const createScaleMatrix: (x: number, y?: number) => TMat2D;
+export declare const angleToSkew: (angle: TDegree) => number;
+export declare const skewToAngle: (value: TRadian) => TDegree;
+/**
+ * Generate a skew matrix for the X axis
+ *
+ * A matrix in the form of
+ * [1 x 0]
+ * [0 1 0]
+ * [0 0 1]
+ *
+ * @link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/transform#skewx
+ *
+ * @param {TDegree} skewValue translation on X axis
+ * @returns {TMat2D} matrix
+ */
+export declare const createSkewXMatrix: (skewValue: TDegree) => TMat2D;
+/**
+ * Generate a skew matrix for the Y axis
+ *
+ * A matrix in the form of
+ * [1 0 0]
+ * [y 1 0]
+ * [0 0 1]
+ *
+ * @link https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/transform#skewy
+ *
+ * @param {TDegree} skewValue translation on Y axis
+ * @returns {TMat2D} matrix
+ */
+export declare const createSkewYMatrix: (skewValue: TDegree) => TMat2D;
+/**
+ * Returns a transform matrix starting from an object of the same kind of
+ * the one returned from qrDecompose, useful also if you want to calculate some
+ * transformations from an object that is not enlived yet.
+ * is called DimensionsTransformMatrix because those properties are the one that influence
+ * the size of the resulting box of the object.
+ * @param  {Object} options
+ * @param  {Number} [options.scaleX]
+ * @param  {Number} [options.scaleY]
+ * @param  {Boolean} [options.flipX]
+ * @param  {Boolean} [options.flipY]
+ * @param  {Number} [options.skewX]
+ * @param  {Number} [options.skewY]
+ * @return {Number[]} transform matrix
+ */
+export declare const calcDimensionsMatrix: ({ scaleX, scaleY, flipX, flipY, skewX, skewY, }: TScaleMatrixArgs) => TMat2D;
+/**
+ * Returns a transform matrix starting from an object of the same kind of
+ * the one returned from qrDecompose, useful also if you want to calculate some
+ * transformations from an object that is not enlived yet
+ * Before changing this function look at: src/benchmarks/calcTransformMatrix.mjs
+ * @param  {Object} options
+ * @param  {Number} [options.angle]
+ * @param  {Number} [options.scaleX]
+ * @param  {Number} [options.scaleY]
+ * @param  {Boolean} [options.flipX]
+ * @param  {Boolean} [options.flipY]
+ * @param  {Number} [options.skewX]
+ * @param  {Number} [options.skewY]
+ * @param  {Number} [options.translateX]
+ * @param  {Number} [options.translateY]
+ * @return {Number[]} transform matrix
+ */
+export declare const composeMatrix: (options: TComposeMatrixArgs) => TMat2D;
+//# sourceMappingURL=matrix.d.ts.map

package/dist-extensions/src/util/misc/matrix.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matrix.d.ts","sourceRoot":"","sources":["../../../../src/util/misc/matrix.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,aAAa,CAAC;AACtC,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAK/D,MAAM,MAAM,iBAAiB,GAAG;IAC9B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG,oBAAoB,GACnD,iBAAiB,GACjB,gBAAgB,CAAC;AAEnB,MAAM,MAAM,eAAe,GAAG,QAAQ,CACpC,IAAI,CAAC,kBAAkB,EAAE,OAAO,GAAG,OAAO,CAAC,CAC5C,CAAC;AAEF,eAAO,MAAM,gBAAgB,QAAS,MAAM,YACW,CAAC;AAExD;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,MACtB,EAAE,KACF,MAAM,iBACM,OAAO,KACrB,KAAgD,CAAC;AAEpD;;;;GAIG;AACH,eAAO,MAAM,eAAe,MAAO,MAAM,KAAG,MAO3C,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,MACjC,MAAM,KACN,MAAM,UACD,OAAO,KACd,MAQU,CAAC;AAEd;;;;;;;;GAQG;AACH,eAAO,MAAM,4BAA4B,aAC7B,CAAC,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,KAAK,CAAC,EAAE,UACvC,OAAO,WAQM,CAAC;AAExB,eAAO,MAAM,iBAAiB,WAAY,MAAM,KAC1B,OAAO,CAAC;AAE9B;;;;GAIG;AACH,eAAO,MAAM,WAAW,MAAO,MAAM,KAAG,eAevC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,qBAAqB,MAAO,MAAM,iBAAU,MAOxD,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAChC,EAAE,KAAS,EAAE,GAAE,iBAAsB,EACrC,EAAE,CAAK,EAAE,CAAK,EAAE,GAAE,OAAO,CAAC,EAAE,CAAM,GACjC,MAAM,CAYR;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,iBAAiB,MAAO,MAAM,MAAK,MAAM,KAAO,MAO5D,CAAC;AAEF,eAAO,MAAM,WAAW,UAAW,OAAO,WACP,CAAC;AAEpC,eAAO,MAAM,WAAW,UAAW,OAAO,YACN,CAAC;AAErC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,iBAAiB,cAAe,OAAO,KAAG,MAOtD,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,iBAAiB,cAAe,OAAO,KAAG,MAOtD,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,oBAAoB,oDAO9B,gBAAgB,WAYlB,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,aAAa,YAAa,kBAAkB,KAAG,MAW3D,CAAC"}

package/dist-extensions/src/util/misc/mergeClipPaths.d.ts

@@ -0,0 +1,23 @@
+import type { FabricObject } from '../../shapes/Object/FabricObject';
+import { Group } from '../../shapes/Group';
+/**
+ * Merges 2 clip paths into one visually equal clip path
+ *
+ * **IMPORTANT**:\
+ * Does **NOT** clone the arguments, clone them proir if necessary.
+ *
+ * Creates a wrapper (group) that contains one clip path and is clipped by the other so content is kept where both overlap.
+ * Use this method if both the clip paths may have nested clip paths of their own, so assigning one to the other's clip path property is not possible.
+ *
+ * In order to handle the `inverted` property we follow logic described in the following cases:\
+ * **(1)** both clip paths are inverted - the clip paths pass the inverted prop to the wrapper and loose it themselves.\
+ * **(2)** one is inverted and the other isn't - the wrapper shouldn't become inverted and the inverted clip path must clip the non inverted one to produce an identical visual effect.\
+ * **(3)** both clip paths are not inverted - wrapper and clip paths remain unchanged.
+ *
+ * @memberOf fabric.util
+ * @param {fabric.Object} c1
+ * @param {fabric.Object} c2
+ * @returns {fabric.Object} merged clip path
+ */
+export declare const mergeClipPaths: (c1: FabricObject, c2: FabricObject) => Group;
+//# sourceMappingURL=mergeClipPaths.d.ts.map

package/dist-extensions/src/util/misc/mergeClipPaths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mergeClipPaths.d.ts","sourceRoot":"","sources":["../../../../src/util/misc/mergeClipPaths.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAErE,OAAO,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAC3C;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,cAAc,OAAQ,YAAY,MAAM,YAAY,UAiBhE,CAAC"}

package/dist-extensions/src/util/misc/objectEnlive.d.ts

@@ -0,0 +1,45 @@
+import type { FabricObject } from '../../shapes/Object/FabricObject';
+import type { Abortable, TCrossOrigin, TFiller } from '../../typedefs';
+import type { BaseFilter } from '../../filters/BaseFilter';
+import type { FabricObject as BaseFabricObject } from '../../shapes/Object/Object';
+import type { Shadow } from '../../Shadow';
+export type LoadImageOptions = Abortable & {
+    /**
+     * cors value for the image loading, default to anonymous
+     */
+    crossOrigin?: TCrossOrigin;
+};
+/**
+ * Loads image element from given url and resolve it, or catch.
+ * @param {String} url URL representing an image
+ * @param {LoadImageOptions} [options] image loading options
+ * @returns {Promise<HTMLImageElement>} the loaded image.
+ */
+export declare const loadImage: (url: string, { signal, crossOrigin }?: LoadImageOptions) => Promise<HTMLImageElement>;
+export type EnlivenObjectOptions = Abortable & {
+    /**
+     * Method for further parsing of object elements,
+     * called after each fabric object created.
+     */
+    reviver?: <T extends BaseFabricObject | FabricObject | BaseFilter<string> | Shadow | TFiller>(serializedObj: Record<string, any>, instance: T) => void;
+};
+/**
+ * @TODO type this correctly.
+ * Creates corresponding fabric instances from their object representations
+ * @param {Object[]} objects Objects to enliven
+ * @param {EnlivenObjectOptions} [options]
+ * @param {(serializedObj: object, instance: FabricObject) => any} [options.reviver] Method for further parsing of object elements,
+ * called after each fabric object created.
+ * @param {AbortSignal} [options.signal] handle aborting, see https://developer.mozilla.org/en-US/docs/Web/API/AbortController/signal
+ * @returns {Promise<FabricObject[]>}
+ */
+export declare const enlivenObjects: <T extends BaseFabricObject | FabricObject | BaseFilter<string> | Shadow | TFiller>(objects: any[], { signal, reviver }?: EnlivenObjectOptions) => Promise<T[]>;
+/**
+ * Creates corresponding fabric instances residing in an object, e.g. `clipPath`
+ * @param {Object} object with properties to enlive ( fill, stroke, clipPath, path )
+ * @param {object} [options]
+ * @param {AbortSignal} [options.signal] handle aborting, see https://developer.mozilla.org/en-US/docs/Web/API/AbortController/signal
+ * @returns {Promise<Record<string, FabricObject | TFiller | null>>} the input object with enlived values
+ */
+export declare const enlivenObjectEnlivables: <R = Record<string, FabricObject<Partial<import("../../..").FabricObjectProps>, import("../../..").SerializedObjectProps, import("../../EventTypeDefs").ObjectEvents> | TFiller | null>>(serializedObject: any, { signal }?: Abortable) => Promise<R>;
+//# sourceMappingURL=objectEnlive.d.ts.map

package/dist-extensions/src/util/misc/objectEnlive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"objectEnlive.d.ts","sourceRoot":"","sources":["../../../../src/util/misc/objectEnlive.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AACrE,OAAO,KAAK,EACV,SAAS,EAET,YAAY,EACZ,OAAO,EACR,MAAM,gBAAgB,CAAC;AAGxB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,KAAK,EAAE,YAAY,IAAI,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAEnF,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAE3C,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG;IACzC;;OAEG;IACH,WAAW,CAAC,EAAE,YAAY,CAAC;CAC5B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,SAAS,QACf,MAAM,4BACqB,gBAAgB,8BA+B9C,CAAC;AAEL,MAAM,MAAM,oBAAoB,GAAG,SAAS,GAAG;IAC7C;;;OAGG;IACH,OAAO,CAAC,EAAE,CACR,CAAC,SACG,gBAAgB,GAChB,YAAY,GACZ,UAAU,CAAC,MAAM,CAAC,GAClB,MAAM,GACN,OAAO,EAEX,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAClC,QAAQ,EAAE,CAAC,KACR,IAAI,CAAC;CACX,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,GACzB,CAAC,SACG,gBAAgB,GAChB,YAAY,GACZ,UAAU,CAAC,MAAM,CAAC,GAClB,MAAM,GACN,OAAO,WAEF,GAAG,EAAE,wBACc,oBAAoB,iBAiC9C,CAAC;AAEL;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,GAClC,CAAC,yMAEiB,GAAG,eACT,SAAS,eA6CnB,CAAC"}

package/dist-extensions/src/util/misc/objectTransforms.d.ts

@@ -0,0 +1,62 @@
+import { Point } from '../../Point';
+import type { FabricObject } from '../../shapes/Object/Object';
+import type { TMat2D } from '../../typedefs';
+/**
+ * given an object and a transform, apply the inverse transform to the object,
+ * this is equivalent to remove from that object that transformation, so that
+ * added in a space with the removed transform, the object will be the same as before.
+ * Removing from an object a transform that scale by 2 is like scaling it by 1/2.
+ * Removing from an object a transform that rotate by 30deg is like rotating by 30deg
+ * in the opposite direction.
+ * This util is used to add objects inside transformed groups or nested groups.
+ * @param {FabricObject} object the object you want to transform
+ * @param {TMat2D} transform the destination transform
+ */
+export declare const removeTransformFromObject: (object: FabricObject, transform: TMat2D) => void;
+/**
+ * given an object and a transform, apply the transform to the object.
+ * this is equivalent to change the space where the object is drawn.
+ * Adding to an object a transform that scale by 2 is like scaling it by 2.
+ * This is used when removing an object from an active selection for example.
+ * @param {FabricObject} object the object you want to transform
+ * @param {Array} transform the destination transform
+ */
+export declare const addTransformToObject: (object: FabricObject, transform: TMat2D) => void;
+/**
+ * discard an object transform state and apply the one from the matrix.
+ * @param {FabricObject} object the object you want to transform
+ * @param {Array} transform the destination transform
+ */
+export declare const applyTransformToObject: (object: FabricObject, transform: TMat2D) => void;
+/**
+ * reset an object transform state to neutral. Top and left are not accounted for
+ * @param  {FabricObject} target object to transform
+ */
+export declare const resetObjectTransform: (target: FabricObject) => void;
+/**
+ * Extract Object transform values
+ * @param  {FabricObject} target object to read from
+ * @return {Object} Components of transform
+ */
+export declare const saveObjectTransform: (target: FabricObject) => {
+    scaleX: number;
+    scaleY: number;
+    skewX: number;
+    skewY: number;
+    angle: import("../../typedefs").TDegree;
+    left: number;
+    flipX: boolean;
+    flipY: boolean;
+    top: number;
+};
+/**
+ * given a width and height, return the size of the bounding box
+ * that can contains the box with width/height with applied transform.
+ * Use to calculate the boxes around objects for controls.
+ * @param {Number} width
+ * @param {Number} height
+ * @param {TMat2D} t
+ * @returns {Point} size
+ */
+export declare const sizeAfterTransform: (width: number, height: number, t: TMat2D) => Point;
+//# sourceMappingURL=objectTransforms.d.ts.map

package/dist-extensions/src/util/misc/objectTransforms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"objectTransforms.d.ts","sourceRoot":"","sources":["../../../../src/util/misc/objectTransforms.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEpC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAQ7C;;;;;;;;;;GAUG;AACH,eAAO,MAAM,yBAAyB,WAC5B,YAAY,aACT,MAAM,SAQlB,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,WAAY,YAAY,aAAa,MAAM,SAIzE,CAAC;AAEJ;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,WACzB,YAAY,aACT,MAAM,SAUlB,CAAC;AACF;;;GAGG;AACH,eAAO,MAAM,oBAAoB,WAAY,YAAY,SAQxD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,WAAY,YAAY;;;;;;;;;;CAUtD,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,UACtB,MAAM,UACL,MAAM,KACX,MAAM,UAYV,CAAC"}

package/dist-extensions/src/util/misc/pick.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Populates an object with properties of another object
+ * @param {Object} source Source object
+ * @param {string[]} properties Properties names to include
+ * @returns object populated with the picked keys
+ */
+export declare const pick: <T extends Record<string, any>>(source: T, keys?: (keyof T)[]) => Partial<T>;
+export declare const pickBy: <T extends Record<string, any>>(source: T, predicate: <K extends keyof T>(value: T[K], key: K, collection: T) => boolean) => Partial<T>;
+//# sourceMappingURL=pick.d.ts.map

package/dist-extensions/src/util/misc/pick.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pick.d.ts","sourceRoot":"","sources":["../../../../src/util/misc/pick.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,UACxC,CAAC,SACH,CAAC,MAAM,CAAC,CAAC,EAAE,eAQlB,CAAC;AAEF,eAAO,MAAM,MAAM,GAAI,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,UAC1C,CAAC,aACE,CAAC,CAAiB,SAAP,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC,KAAK,OAAO,eAQ9E,CAAC"}

package/dist-extensions/src/util/misc/planeChange.d.ts

@@ -0,0 +1,64 @@
+import type { Point } from '../../Point';
+import type { FabricObject } from '../../shapes/Object/Object';
+import type { TMat2D } from '../../typedefs';
+/**
+ * We are actually looking for the transformation from the destination plane to the source plane (change of basis matrix)\
+ * The object will exist on the destination plane and we want it to seem unchanged by it so we invert the destination matrix (`to`) and then apply the source matrix (`from`)
+ * @param [from]
+ * @param [to]
+ * @returns
+ */
+export declare const calcPlaneChangeMatrix: (from?: TMat2D, to?: TMat2D) => TMat2D;
+/**
+ * Sends a point from the source coordinate plane to the destination coordinate plane.\
+ * From the canvas/viewer's perspective the point remains unchanged.
+ *
+ * @example <caption>Send point from canvas plane to group plane</caption>
+ * var obj = new Rect({ left: 20, top: 20, width: 60, height: 60, strokeWidth: 0 });
+ * var group = new Group([obj], { strokeWidth: 0 });
+ * var sentPoint1 = sendPointToPlane(new Point(50, 50), undefined, group.calcTransformMatrix());
+ * var sentPoint2 = sendPointToPlane(new Point(50, 50), iMatrix, group.calcTransformMatrix());
+ * console.log(sentPoint1, sentPoint2) //  both points print (0,0) which is the center of group
+ *
+ * @param {Point} point
+ * @param {TMat2D} [from] plane matrix containing object. Passing `undefined` is equivalent to passing the identity matrix, which means `point` exists in the canvas coordinate plane.
+ * @param {TMat2D} [to] destination plane matrix to contain object. Passing `undefined` means `point` should be sent to the canvas coordinate plane.
+ * @returns {Point} transformed point
+ */
+export declare const sendPointToPlane: (point: Point, from?: TMat2D, to?: TMat2D) => Point;
+/**
+ * See {@link sendPointToPlane}
+ */
+export declare const sendVectorToPlane: (point: Point, from?: TMat2D, to?: TMat2D) => Point;
+/**
+ *
+ * A util that abstracts applying transform to objects.\
+ * Sends `object` to the destination coordinate plane by applying the relevant transformations.\
+ * Changes the space/plane where `object` is drawn.\
+ * From the canvas/viewer's perspective `object` remains unchanged.
+ *
+ * @example <caption>Move clip path from one object to another while preserving it's appearance as viewed by canvas/viewer</caption>
+ * let obj, obj2;
+ * let clipPath = new Circle({ radius: 50 });
+ * obj.clipPath = clipPath;
+ * // render
+ * sendObjectToPlane(clipPath, obj.calcTransformMatrix(), obj2.calcTransformMatrix());
+ * obj.clipPath = undefined;
+ * obj2.clipPath = clipPath;
+ * // render, clipPath now clips obj2 but seems unchanged from the eyes of the viewer
+ *
+ * @example <caption>Clip an object's clip path with an existing object</caption>
+ * let obj, existingObj;
+ * let clipPath = new Circle({ radius: 50 });
+ * obj.clipPath = clipPath;
+ * let transformTo = multiplyTransformMatrices(obj.calcTransformMatrix(), clipPath.calcTransformMatrix());
+ * sendObjectToPlane(existingObj, existingObj.group?.calcTransformMatrix(), transformTo);
+ * clipPath.clipPath = existingObj;
+ *
+ * @param {FabricObject} object
+ * @param {Matrix} [from] plane matrix containing object. Passing `undefined` is equivalent to passing the identity matrix, which means `object` is a direct child of canvas.
+ * @param {Matrix} [to] destination plane matrix to contain object. Passing `undefined` means `object` should be sent to the canvas coordinate plane.
+ * @returns {Matrix} the transform matrix that was applied to `object`
+ */
+export declare const sendObjectToPlane: (object: FabricObject, from?: TMat2D, to?: TMat2D) => TMat2D;
+//# sourceMappingURL=planeChange.d.ts.map

package/dist-extensions/src/util/misc/planeChange.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"planeChange.d.ts","sourceRoot":"","sources":["../../../../src/util/misc/planeChange.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAI7C;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,UAC1B,MAAM,OACR,MAAM,WAC6C,CAAC;AAE1D;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,gBAAgB,UACpB,KAAK,SACN,MAAM,OACR,MAAM,KACT,KAAyD,CAAC;AAE7D;;GAEG;AACH,eAAO,MAAM,iBAAiB,UACrB,KAAK,SACN,MAAM,OACR,MAAM,KACT,KAA+D,CAAC;AAEnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,iBAAiB,WACpB,YAAY,SACb,MAAM,OACR,MAAM,KACV,MAOF,CAAC"}

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

@@ -0,0 +1,52 @@
+import type { XY } from '../../../Point';
+import { Point } from '../../../Point';
+import { StrokeProjectionsBase } from './StrokeProjectionsBase';
+import type { 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-extensions/src/util/misc/projectStroke/StrokeLineCapProjections.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StrokeLineCapProjections.d.ts","sourceRoot":"","sources":["../../../../../src/util/misc/projectStroke/StrokeLineCapProjections.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAC;AACzC,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAGvC,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,KAAK,EAAE,WAAW,EAAE,6BAA6B,EAAE,MAAM,SAAS,CAAC;AAE1E;;;;;;;;;;;GAWG;AACH,qBAAa,wBAAyB,SAAQ,qBAAqB;IACjE;;OAEG;IACK,CAAC,EAAE,KAAK,CAAC;IACjB;;OAEG;IACK,CAAC,EAAE,KAAK,CAAC;gBAEL,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,OAAO,EAAE,6BAA6B;IAMhE,wBAAwB,CACtB,IAAI,EAAE,KAAK,EACX,EAAE,EAAE,KAAK,EACT,SAAS,GAAE,MAAuC;IAMpD;;;;;OAKG;IACH,WAAW;IAOX;;;;;OAKG;IACH,YAAY;IA6BZ;;;;;OAKG;IACH,aAAa;IAgCb,SAAS,CAAC,aAAa;IAWhB,OAAO,IAAI,WAAW,EAAE;CAMhC"}

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

@@ -0,0 +1,90 @@
+import type { XY } from '../../../Point';
+import { Point } from '../../../Point';
+import type { TRadian } from '../../../typedefs';
+import { StrokeProjectionsBase } from './StrokeProjectionsBase';
+import type { 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 AB vector
+     */
+    AB: Point;
+    /**
+     * The AC vector
+     */
+    AC: Point;
+    /**
+     * The angle of A (∠BAC)
+     */
+    alpha: TRadian;
+    /**
+     * The bisector of A (∠BAC)
+     */
+    bisector: Point;
+    static getOrthogonalRotationFactor(vector1: Point, vector2?: Point): 1 | -1;
+    constructor(A: XY, B: XY, C: XY, options: TProjectStrokeOnPointsOptions);
+    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.
+     *
+     * @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-extensions/src/util/misc/projectStroke/StrokeLineJoinProjections.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StrokeLineJoinProjections.d.ts","sourceRoot":"","sources":["../../../../../src/util/misc/projectStroke/StrokeLineJoinProjections.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAC;AACzC,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAEvC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAYjD,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,KAAK,EAAE,WAAW,EAAE,6BAA6B,EAAE,MAAM,SAAS,CAAC;AAI1E;;;;;;;;;;;GAWG;AACH,qBAAa,yBAA0B,SAAQ,qBAAqB;IAClE;;OAEG;IACK,CAAC,EAAE,KAAK,CAAC;IACjB;;OAEG;IACK,CAAC,EAAE,KAAK,CAAC;IACjB;;OAEG;IACK,CAAC,EAAE,KAAK,CAAC;IACjB;;OAEG;IACH,EAAE,EAAE,KAAK,CAAC;IACV;;OAEG;IACH,EAAE,EAAE,KAAK,CAAC;IACV;;OAEG;IACH,KAAK,EAAE,OAAO,CAAC;IACf;;OAEG;IACH,QAAQ,EAAE,KAAK,CAAC;IAEhB,MAAM,CAAC,2BAA2B,CAAC,OAAO,EAAE,KAAK,EAAE,OAAO,CAAC,EAAE,KAAK;gBAOtD,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,OAAO,EAAE,6BAA6B;IAevE,wBAAwB,CACtB,IAAI,EAAE,KAAK,EACX,EAAE,EAAE,KAAK,EACT,SAAS,GAAE,MAAuC;IAWpD;;;;;OAKG;IACH,YAAY;IAcZ;;;;;;OAMG;IACH,YAAY;IAmCZ;;;;;OAKG;IACH,OAAO,CAAC,kBAAkB;IA0B1B;;;;;;OAMG;IACH,OAAO,CAAC,oBAAoB;IAyD5B,YAAY;IAgCZ;;;;;OAKG;IACH,SAAS,CAAC,aAAa;IAWhB,OAAO,IAAI,WAAW,EAAE;CAQhC"}

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

@@ -0,0 +1,27 @@
+import type { XY } from '../../../Point';
+import { Point } from '../../../Point';
+import type { TProjectStrokeOnPointsOptions, TProjection } from './types';
+/**
+ * @see https://github.com/fabricjs/fabric.js/pull/8344
+ * @todo consider removing skewing from points before calculating stroke projection,
+ * see https://github.com/fabricjs/fabric.js/commit/494a10ee2f8c2278ae9a55b20bf50cf6ee25b064#commitcomment-94751537
+ */
+export declare abstract class StrokeProjectionsBase {
+    options: TProjectStrokeOnPointsOptions;
+    scale: Point;
+    strokeUniformScalar: Point;
+    strokeProjectionMagnitude: number;
+    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-extensions/src/util/misc/projectStroke/StrokeProjectionsBase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StrokeProjectionsBase.d.ts","sourceRoot":"","sources":["../../../../../src/util/misc/projectStroke/StrokeProjectionsBase.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAC;AACzC,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAGvC,OAAO,KAAK,EAAE,6BAA6B,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE1E;;;;GAIG;AACH,8BAAsB,qBAAqB;IACjC,OAAO,EAAE,6BAA6B,CAAC;IACvC,KAAK,EAAE,KAAK,CAAC;IACb,mBAAmB,EAAE,KAAK,CAAC;IAC3B,yBAAyB,EAAE,MAAM,CAAC;gBAE9B,OAAO,EAAE,6BAA6B;IASlD;;OAEG;IACH,SAAS,CAAC,gBAAgB,CAAC,IAAI,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE;IAK3C,SAAS,CAAC,QAAQ,CAAC,wBAAwB,CACzC,IAAI,EAAE,KAAK,EACX,EAAE,EAAE,KAAK,EACT,SAAS,CAAC,EAAE,MAAM,GACjB,KAAK;IAER,SAAS,CAAC,mBAAmB,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,MAAM;IAMxE,SAAS,CAAC,QAAQ;IAIlB,SAAS,CAAC,SAAS,CAAC,KAAK,EAAE,KAAK;IAQhC,SAAS,CAAC,eAAe,CAAC,UAAU,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM;IAI3D,SAAS,CAAC,QAAQ,CAAC,aAAa,IAAI,KAAK,EAAE;aAE3B,OAAO,IAAI,WAAW,EAAE;CACzC"}

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

@@ -0,0 +1,12 @@
+import { type XY } from '../../../Point';
+import type { TProjection, TProjectStrokeOnPointsOptions } from './types';
+export * 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-extensions/src/util/misc/projectStroke/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/util/misc/projectStroke/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,KAAK,EAAE,EAAE,MAAM,gBAAgB,CAAC;AAIhD,OAAO,KAAK,EAAE,WAAW,EAAE,6BAA6B,EAAE,MAAM,SAAS,CAAC;AAE1E,cAAc,SAAS,CAAC;AAExB;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,WACxB,EAAE,EAAE,WACH,6BAA6B,yBAErC,WAAW,EA6Db,CAAC"}