fabric 7.3.1 → 7.5.0-beta.1

package/dist/src/util/misc/groupSVGElements.min.mjs

@@ -1,2 +0,0 @@
-import{Group as e}from"../../shapes/Group.min.mjs";const t=(t,n)=>t&&t.length===1?t[0]:new e(t,n);export{t as groupSVGElements};
-//# sourceMappingURL=groupSVGElements.min.mjs.map

package/dist/src/util/misc/groupSVGElements.min.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"groupSVGElements.min.mjs","names":[],"sources":["../../../../src/util/misc/groupSVGElements.ts"],"sourcesContent":["import type { GroupProps } from '../../shapes/Group';\nimport { Group } from '../../shapes/Group';\nimport type { FabricObject } from '../../shapes/Object/FabricObject';\n\n/**\n * TODO experiment with different layout manager and svg results ( fixed fit content )\n * Groups SVG elements (usually those retrieved from SVG document)\n * @param {FabricObject[]} elements FabricObject(s) parsed from svg, to group\n * @return {FabricObject | Group}\n */\nexport const groupSVGElements = (\n  elements: FabricObject[],\n  options?: Partial<GroupProps>,\n) => {\n  if (elements && elements.length === 1) {\n    return elements[0];\n  }\n  return new Group(elements, options);\n};\n"],"mappings":"mDAUA,MAAa,GACX,EACA,IAEI,GAAY,EAAS,SAAW,EAC3B,EAAS,GAEX,IAAI,EAAM,EAAU,EAAA,CAAA,OAAA,KAAA"}

package/dist/src/util/misc/groupSVGElements.mjs

@@ -1,16 +0,0 @@
-import { Group } from "../../shapes/Group.mjs";
-//#region src/util/misc/groupSVGElements.ts
-/**
-* TODO experiment with different layout manager and svg results ( fixed fit content )
-* Groups SVG elements (usually those retrieved from SVG document)
-* @param {FabricObject[]} elements FabricObject(s) parsed from svg, to group
-* @return {FabricObject | Group}
-*/
-const groupSVGElements = (elements, options) => {
-	if (elements && elements.length === 1) return elements[0];
-	return new Group(elements, options);
-};
-//#endregion
-export { groupSVGElements };
-
-//# sourceMappingURL=groupSVGElements.mjs.map

package/dist/src/util/misc/groupSVGElements.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"groupSVGElements.mjs","names":[],"sources":["../../../../src/util/misc/groupSVGElements.ts"],"sourcesContent":["import type { GroupProps } from '../../shapes/Group';\nimport { Group } from '../../shapes/Group';\nimport type { FabricObject } from '../../shapes/Object/FabricObject';\n\n/**\n * TODO experiment with different layout manager and svg results ( fixed fit content )\n * Groups SVG elements (usually those retrieved from SVG document)\n * @param {FabricObject[]} elements FabricObject(s) parsed from svg, to group\n * @return {FabricObject | Group}\n */\nexport const groupSVGElements = (\n  elements: FabricObject[],\n  options?: Partial<GroupProps>,\n) => {\n  if (elements && elements.length === 1) {\n    return elements[0];\n  }\n  return new Group(elements, options);\n};\n"],"mappings":";;;;;;;;AAUA,MAAa,oBACX,UACA,YACG;AACH,KAAI,YAAY,SAAS,WAAW,EAClC,QAAO,SAAS;AAElB,QAAO,IAAI,MAAM,UAAU,QAAQ"}

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

@@ -1,11 +0,0 @@
-/**
- * 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/src/util/misc/isTransparent.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"isTransparent.d.ts","sourceRoot":"","sources":["../../../../src/util/misc/isTransparent.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,GACxB,KAAK,wBAAwB,EAC7B,GAAG,MAAM,EACT,GAAG,MAAM,EACT,WAAW,MAAM,KAChB,OAaF,CAAC"}

package/dist/src/util/misc/isTransparent.min.mjs

@@ -1,2 +0,0 @@
-const e=(e,t,n,r)=>{let i=2*(r=Math.round(r))+1,{data:a}=e.getImageData(t-r,n-r,i,i);for(let e=3;e<a.length;e+=4)if(a[e]>0)return!1;return!0};export{e as isTransparent};
-//# sourceMappingURL=isTransparent.min.mjs.map

package/dist/src/util/misc/isTransparent.min.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"isTransparent.min.mjs","names":[],"sources":["../../../../src/util/misc/isTransparent.ts"],"sourcesContent":["/**\n * Returns true if context has transparent pixel\n * at specified location (taking tolerance into account)\n * @param {CanvasRenderingContext2D} ctx context\n * @param {Number} x x coordinate in canvasElementCoordinate, not fabric space. integer\n * @param {Number} y y coordinate in canvasElementCoordinate, not fabric space. integer\n * @param {Number} tolerance Tolerance pixels around the point, not alpha tolerance, integer\n * @return {boolean} true if transparent\n */\nexport const isTransparent = (\n  ctx: CanvasRenderingContext2D,\n  x: number,\n  y: number,\n  tolerance: number,\n): boolean => {\n  tolerance = Math.round(tolerance);\n  const size = tolerance * 2 + 1;\n  const { data } = ctx.getImageData(x - tolerance, y - tolerance, size, size);\n\n  // Split image data - for tolerance > 1, pixelDataSize = 4;\n  for (let i = 3; i < data.length; i += 4) {\n    const alphaChannel = data[i];\n    if (alphaChannel > 0) {\n      return false;\n    }\n  }\n  return true;\n};\n"],"mappings":"AASA,MAAa,GACX,EACA,EACA,EACA,IAAA,CAGA,IAAM,EAAmB,GADzB,EAAY,KAAK,MAAM,EAAA,EACM,EAAA,CACvB,KAAE,GAAS,EAAI,aAAa,EAAI,EAAW,EAAI,EAAW,EAAM,EAAA,CAGtE,IAAK,IAAI,EAAI,EAAG,EAAI,EAAK,OAAQ,GAAK,EAEpC,GADqB,EAAK,GACP,EACjB,MAAA,CAAO,EAGX,MAAA,CAAO,GAAA,OAAA,KAAA"}

package/dist/src/util/misc/isTransparent.mjs

@@ -1,21 +0,0 @@
-//#region src/util/misc/isTransparent.ts
-/**
-* 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
-*/
-const isTransparent = (ctx, x, y, tolerance) => {
-	tolerance = Math.round(tolerance);
-	const size = tolerance * 2 + 1;
-	const { data } = ctx.getImageData(x - tolerance, y - tolerance, size, size);
-	for (let i = 3; i < data.length; i += 4) if (data[i] > 0) return false;
-	return true;
-};
-//#endregion
-export { isTransparent };
-
-//# sourceMappingURL=isTransparent.mjs.map

package/dist/src/util/misc/isTransparent.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"isTransparent.mjs","names":[],"sources":["../../../../src/util/misc/isTransparent.ts"],"sourcesContent":["/**\n * Returns true if context has transparent pixel\n * at specified location (taking tolerance into account)\n * @param {CanvasRenderingContext2D} ctx context\n * @param {Number} x x coordinate in canvasElementCoordinate, not fabric space. integer\n * @param {Number} y y coordinate in canvasElementCoordinate, not fabric space. integer\n * @param {Number} tolerance Tolerance pixels around the point, not alpha tolerance, integer\n * @return {boolean} true if transparent\n */\nexport const isTransparent = (\n  ctx: CanvasRenderingContext2D,\n  x: number,\n  y: number,\n  tolerance: number,\n): boolean => {\n  tolerance = Math.round(tolerance);\n  const size = tolerance * 2 + 1;\n  const { data } = ctx.getImageData(x - tolerance, y - tolerance, size, size);\n\n  // Split image data - for tolerance > 1, pixelDataSize = 4;\n  for (let i = 3; i < data.length; i += 4) {\n    const alphaChannel = data[i];\n    if (alphaChannel > 0) {\n      return false;\n    }\n  }\n  return true;\n};\n"],"mappings":";;;;;;;;;;AASA,MAAa,iBACX,KACA,GACA,GACA,cACY;AACZ,aAAY,KAAK,MAAM,UAAU;CACjC,MAAM,OAAO,YAAY,IAAI;CAC7B,MAAM,EAAE,SAAS,IAAI,aAAa,IAAI,WAAW,IAAI,WAAW,MAAM,KAAK;AAG3E,MAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK,EAEpC,KADqB,KAAK,KACP,EACjB,QAAO;AAGX,QAAO"}

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

@@ -1,170 +0,0 @@
-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 the matrices array 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/src/util/misc/matrix.d.ts.map

@@ -1 +0,0 @@
-{"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,GAAI,KAAK,MAAM,YACW,CAAC;AAExD;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,GACzB,GAAG,EAAE,EACL,GAAG,MAAM,EACT,eAAe,OAAO,KACrB,KAAgD,CAAC;AAEpD;;;;GAIG;AACH,eAAO,MAAM,eAAe,GAAI,GAAG,MAAM,KAAG,MAO3C,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,GACpC,GAAG,MAAM,EACT,GAAG,MAAM,EACT,QAAQ,OAAO,KACd,MAQU,CAAC;AAEd;;;;;;;;GAQG;AACH,eAAO,MAAM,4BAA4B,GACvC,UAAU,CAAC,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,KAAK,CAAC,EAAE,EAC/C,QAAQ,OAAO,WAQM,CAAC;AAExB,eAAO,MAAM,iBAAiB,GAAI,QAAQ,MAAM,KAC1B,OAAO,CAAC;AAE9B;;;;GAIG;AACH,eAAO,MAAM,WAAW,GAAI,GAAG,MAAM,KAAG,eAevC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,qBAAqB,GAAI,GAAG,MAAM,EAAE,UAAK,KAAG,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,GAAI,GAAG,MAAM,EAAE,IAAG,MAAU,KAAG,MAO5D,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,OAAO,OAAO,WACP,CAAC;AAEpC,eAAO,MAAM,WAAW,GAAI,OAAO,OAAO,YACN,CAAC;AAErC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,iBAAiB,GAAI,WAAW,OAAO,KAAG,MAOtD,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,iBAAiB,GAAI,WAAW,OAAO,KAAG,MAOtD,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,oBAAoB,GAAI,iDAOlC,gBAAgB,WAYlB,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,aAAa,GAAI,SAAS,kBAAkB,KAAG,MAW3D,CAAC"}

package/dist/src/util/misc/matrix.min.mjs

@@ -1,2 +0,0 @@
-import{iMatrix as e}from"../../constants.min.mjs";import{cos as t}from"./cos.min.mjs";import{sin as n}from"./sin.min.mjs";import{Point as r}from"../../Point.min.mjs";import{degreesToRadians as i,radiansToDegrees as a}from"./radiansDegreesConversion.min.mjs";const o=t=>t.every((t,n)=>t===e[n]),s=(e,t,n)=>new r(e).transform(t,n),c=e=>{let t=1/(e[0]*e[3]-e[1]*e[2]),n=[t*e[3],-t*e[1],-t*e[2],t*e[0],0,0],{x:i,y:a}=new r(e[4],e[5]).transform(n,!0);return n[4]=-i,n[5]=-a,n},l=(e,t,n)=>[e[0]*t[0]+e[2]*t[1],e[1]*t[0]+e[3]*t[1],e[0]*t[2]+e[2]*t[3],e[1]*t[2]+e[3]*t[3],n?0:e[0]*t[4]+e[2]*t[5]+e[4],n?0:e[1]*t[4]+e[3]*t[5]+e[5]],u=(t,n)=>t.reduceRight((e,t)=>t&&e?l(t,e,n):t||e,void 0)||e.concat(),d=([e,t])=>Math.atan2(t,e),f=e=>{let t=d(e),n=e[0]**2+e[1]**2,r=Math.sqrt(n),i=(e[0]*e[3]-e[2]*e[1])/r,o=Math.atan2(e[0]*e[2]+e[1]*e[3],n);return{angle:a(t),scaleX:r,scaleY:i,skewX:a(o),skewY:0,translateX:e[4]||0,translateY:e[5]||0}},p=(e,t=0)=>[1,0,0,1,e,t];function m({angle:e=0}={},{x:r=0,y:a=0}={}){let o=i(e),s=t(o),c=n(o);return[s,c,-c,s,r?r-(s*r-c*a):0,a?a-(c*r+s*a):0]}const h=(e,t=e)=>[e,0,0,t,0,0],g=e=>Math.tan(i(e)),_=e=>[1,0,g(e),1,0,0],v=e=>[1,g(e),0,1,0,0],y=({scaleX:e=1,scaleY:t=1,flipX:n=!1,flipY:r=!1,skewX:i=0,skewY:a=0})=>{let o=h(n?-e:e,r?-t:t);return i&&(o=l(o,_(i),!0)),a&&(o=l(o,v(a),!0)),o},b=e=>{let{translateX:t=0,translateY:n=0,angle:r=0}=e,i=p(t,n);r&&(i=l(i,m({angle:r})));let a=y(e);return o(a)||(i=l(i,a)),i};export{y as calcDimensionsMatrix,d as calcPlaneRotation,b as composeMatrix,m as createRotateMatrix,h as createScaleMatrix,_ as createSkewXMatrix,v as createSkewYMatrix,p as createTranslateMatrix,c as invertTransform,o as isIdentityMatrix,l as multiplyTransformMatrices,u as multiplyTransformMatrixArray,f as qrDecompose,s as transformPoint};
-//# sourceMappingURL=matrix.min.mjs.map

package/dist/src/util/misc/matrix.min.mjs.map

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

package/dist/src/util/misc/matrix.mjs

@@ -1,238 +0,0 @@
-import { iMatrix } from "../../constants.mjs";
-import { cos } from "./cos.mjs";
-import { sin } from "./sin.mjs";
-import { Point } from "../../Point.mjs";
-import { degreesToRadians, radiansToDegrees } from "./radiansDegreesConversion.mjs";
-//#region src/util/misc/matrix.ts
-const isIdentityMatrix = (mat) => mat.every((value, index) => value === iMatrix[index]);
-/**
-* 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
-*/
-const transformPoint = (p, t, ignoreOffset) => new Point(p).transform(t, ignoreOffset);
-/**
-* Invert transformation t
-* @param {Array} t The transform
-* @return {Array} The inverted transform
-*/
-const invertTransform = (t) => {
-	const a = 1 / (t[0] * t[3] - t[1] * t[2]), r = [
-		a * t[3],
-		-a * t[1],
-		-a * t[2],
-		a * t[0],
-		0,
-		0
-	], { x, y } = new Point(t[4], t[5]).transform(r, true);
-	r[4] = -x;
-	r[5] = -y;
-	return r;
-};
-/**
-* 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
-*/
-const multiplyTransformMatrices = (a, b, is2x2) => [
-	a[0] * b[0] + a[2] * b[1],
-	a[1] * b[0] + a[3] * b[1],
-	a[0] * b[2] + a[2] * b[3],
-	a[1] * b[2] + a[3] * b[3],
-	is2x2 ? 0 : a[0] * b[4] + a[2] * b[5] + a[4],
-	is2x2 ? 0 : a[1] * b[4] + a[3] * b[5] + a[5]
-];
-/**
-* Multiplies the matrices array 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
-*/
-const multiplyTransformMatrixArray = (matrices, is2x2) => matrices.reduceRight((product, curr) => curr && product ? multiplyTransformMatrices(curr, product, is2x2) : curr || product, void 0) || iMatrix.concat();
-const calcPlaneRotation = ([a, b]) => Math.atan2(b, a);
-/**
-* Decomposes standard 2x3 matrix into transform components
-* @param  {TMat2D} a transformMatrix
-* @return {Object} Components of transform
-*/
-const qrDecompose = (a) => {
-	const angle = calcPlaneRotation(a), denom = Math.pow(a[0], 2) + Math.pow(a[1], 2), scaleX = Math.sqrt(denom), scaleY = (a[0] * a[3] - a[2] * a[1]) / scaleX, skewX = Math.atan2(a[0] * a[2] + a[1] * a[3], denom);
-	return {
-		angle: radiansToDegrees(angle),
-		scaleX,
-		scaleY,
-		skewX: radiansToDegrees(skewX),
-		skewY: 0,
-		translateX: a[4] || 0,
-		translateY: a[5] || 0
-	};
-};
-/**
-* 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
-*/
-const createTranslateMatrix = (x, y = 0) => [
-	1,
-	0,
-	0,
-	1,
-	x,
-	y
-];
-/**
-* 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
-*/
-function createRotateMatrix({ angle = 0 } = {}, { x = 0, y = 0 } = {}) {
-	const angleRadiant = degreesToRadians(angle), cosValue = cos(angleRadiant), sinValue = sin(angleRadiant);
-	return [
-		cosValue,
-		sinValue,
-		-sinValue,
-		cosValue,
-		x ? x - (cosValue * x - sinValue * y) : 0,
-		y ? y - (sinValue * x + cosValue * y) : 0
-	];
-}
-/**
-* 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
-*/
-const createScaleMatrix = (x, y = x) => [
-	x,
-	0,
-	0,
-	y,
-	0,
-	0
-];
-const angleToSkew = (angle) => Math.tan(degreesToRadians(angle));
-/**
-* 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
-*/
-const createSkewXMatrix = (skewValue) => [
-	1,
-	0,
-	angleToSkew(skewValue),
-	1,
-	0,
-	0
-];
-/**
-* 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
-*/
-const createSkewYMatrix = (skewValue) => [
-	1,
-	angleToSkew(skewValue),
-	0,
-	1,
-	0,
-	0
-];
-/**
-* 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
-*/
-const calcDimensionsMatrix = ({ scaleX = 1, scaleY = 1, flipX = false, flipY = false, skewX = 0, skewY = 0 }) => {
-	let matrix = createScaleMatrix(flipX ? -scaleX : scaleX, flipY ? -scaleY : scaleY);
-	if (skewX) matrix = multiplyTransformMatrices(matrix, createSkewXMatrix(skewX), true);
-	if (skewY) matrix = multiplyTransformMatrices(matrix, createSkewYMatrix(skewY), true);
-	return matrix;
-};
-/**
-* 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
-*/
-const composeMatrix = (options) => {
-	const { translateX = 0, translateY = 0, angle = 0 } = options;
-	let matrix = createTranslateMatrix(translateX, translateY);
-	if (angle) matrix = multiplyTransformMatrices(matrix, createRotateMatrix({ angle }));
-	const scaleMatrix = calcDimensionsMatrix(options);
-	if (!isIdentityMatrix(scaleMatrix)) matrix = multiplyTransformMatrices(matrix, scaleMatrix);
-	return matrix;
-};
-//#endregion
-export { calcDimensionsMatrix, calcPlaneRotation, composeMatrix, createRotateMatrix, createScaleMatrix, createSkewXMatrix, createSkewYMatrix, createTranslateMatrix, invertTransform, isIdentityMatrix, multiplyTransformMatrices, multiplyTransformMatrixArray, qrDecompose, transformPoint };
-
-//# sourceMappingURL=matrix.mjs.map

package/dist/src/util/misc/matrix.mjs.map

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

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

@@ -1,22 +0,0 @@
-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.
- *
- * @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/src/util/misc/mergeClipPaths.d.ts.map

@@ -1 +0,0 @@
-{"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;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,cAAc,GAAI,IAAI,YAAY,EAAE,IAAI,YAAY,UAiBhE,CAAC"}

package/dist/src/util/misc/mergeClipPaths.min.mjs

@@ -1,2 +0,0 @@
-import{sendObjectToPlane as e}from"./planeChange.min.mjs";import{Group as t}from"../../shapes/Group.min.mjs";const n=(n,r)=>{var i;let a=n,o=r;a.inverted&&!o.inverted&&(a=r,o=n),e(o,(i=o.group)==null?void 0:i.calcTransformMatrix(),a.calcTransformMatrix());let s=a.inverted&&o.inverted;return s&&(a.inverted=o.inverted=!1),new t([a],{clipPath:o,inverted:s})};export{n as mergeClipPaths};
-//# sourceMappingURL=mergeClipPaths.min.mjs.map

package/dist/src/util/misc/mergeClipPaths.min.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"mergeClipPaths.min.mjs","names":[],"sources":["../../../../src/util/misc/mergeClipPaths.ts"],"sourcesContent":["import type { FabricObject } from '../../shapes/Object/FabricObject';\nimport { sendObjectToPlane } from './planeChange';\nimport { Group } from '../../shapes/Group';\n/**\n * Merges 2 clip paths into one visually equal clip path\n *\n * **IMPORTANT**:\\\n * Does **NOT** clone the arguments, clone them proir if necessary.\n *\n * Creates a wrapper (group) that contains one clip path and is clipped by the other so content is kept where both overlap.\n * 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.\n *\n * In order to handle the `inverted` property we follow logic described in the following cases:\\\n * **(1)** both clip paths are inverted - the clip paths pass the inverted prop to the wrapper and loose it themselves.\\\n * **(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.\\\n * **(3)** both clip paths are not inverted - wrapper and clip paths remain unchanged.\n *\n * @param {fabric.Object} c1\n * @param {fabric.Object} c2\n * @returns {fabric.Object} merged clip path\n */\nexport const mergeClipPaths = (c1: FabricObject, c2: FabricObject) => {\n  let a = c1,\n    b = c2;\n  if (a.inverted && !b.inverted) {\n    //  case (2)\n    a = c2;\n    b = c1;\n  }\n  //  `b` becomes `a`'s clip path so we transform `b` to `a` coordinate plane\n  sendObjectToPlane(b, b.group?.calcTransformMatrix(), a.calcTransformMatrix());\n  //  assign the `inverted` prop to the wrapping group\n  const inverted = a.inverted && b.inverted;\n  if (inverted) {\n    //  case (1)\n    a.inverted = b.inverted = false;\n  }\n  return new Group([a], { clipPath: b, inverted });\n};\n"],"mappings":"6GAqBA,MAAa,GAAkB,EAAkB,IAAA,CAAA,IAAA,EAC/C,IAAI,EAAI,EACN,EAAI,EACF,EAAE,UAAA,CAAa,EAAE,WAEnB,EAAI,EACJ,EAAI,GAGN,EAAkB,GAAA,EAAG,EAAE,QAAA,KAAA,IAAA,GAAA,EAAO,qBAAA,CAAuB,EAAE,qBAAA,CAAA,CAEvD,IAAM,EAAW,EAAE,UAAY,EAAE,SAKjC,OAJI,IAEF,EAAE,SAAW,EAAE,SAAA,CAAW,GAErB,IAAI,EAAM,CAAC,EAAA,CAAI,CAAE,SAAU,EAAG,SAAA,EAAA,CAAA,EAAA,OAAA,KAAA"}

package/dist/src/util/misc/mergeClipPaths.mjs

@@ -1,40 +0,0 @@
-import { sendObjectToPlane } from "./planeChange.mjs";
-import { Group } from "../../shapes/Group.mjs";
-//#region src/util/misc/mergeClipPaths.ts
-/**
-* 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.
-*
-* @param {fabric.Object} c1
-* @param {fabric.Object} c2
-* @returns {fabric.Object} merged clip path
-*/
-const mergeClipPaths = (c1, c2) => {
-	var _b$group;
-	let a = c1, b = c2;
-	if (a.inverted && !b.inverted) {
-		a = c2;
-		b = c1;
-	}
-	sendObjectToPlane(b, (_b$group = b.group) === null || _b$group === void 0 ? void 0 : _b$group.calcTransformMatrix(), a.calcTransformMatrix());
-	const inverted = a.inverted && b.inverted;
-	if (inverted) a.inverted = b.inverted = false;
-	return new Group([a], {
-		clipPath: b,
-		inverted
-	});
-};
-//#endregion
-export { mergeClipPaths };
-
-//# sourceMappingURL=mergeClipPaths.mjs.map