fabric 5.3.0 → 6.0.0-beta1

package/dist/src/util/dom_event.d.ts

@@ -0,0 +1,5 @@
+import { Point } from '../Point';
+export declare const getPointer: (event: any) => Point;
+export declare const isTouchEvent: (event: any) => boolean;
+export declare const stopEvent: (e: Event) => void;
+//# sourceMappingURL=dom_event.d.ts.map

package/dist/src/util/dom_misc.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Wraps element with another element
+ * @param {HTMLElement} element Element to wrap
+ * @param {HTMLElement|String} wrapper Element to wrap with
+ * @param {Object} [attributes] Attributes to set on a wrapper
+ * @return {HTMLElement} wrapper
+ */
+export declare function wrapElement(element: any, wrapper: any): any;
+/**
+ * Returns element scroll offsets
+ * @param {HTMLElement} element Element to operate on
+ * @return {Object} Object with left/top values
+ */
+export declare function getScrollLeftTop(element: any): {
+    left: number;
+    top: number;
+};
+/**
+ * Returns offset for a given element
+ * @param {HTMLElement} element Element to get offset for
+ * @return {Object} Object with "left" and "top" properties
+ */
+export declare function getElementOffset(element: any): {
+    left: number;
+    top: number;
+};
+/**
+ * Makes element unselectable
+ * @param {HTMLElement} element Element to make unselectable
+ * @return {HTMLElement} Element that was passed in
+ */
+export declare function makeElementUnselectable(element: any): any;
+/**
+ * Makes element selectable
+ * @param {HTMLElement} element Element to make selectable
+ * @return {HTMLElement} Element that was passed in
+ */
+export declare function makeElementSelectable(element: any): any;
+export declare function cleanUpJsdomNode(element: any): void;
+//# sourceMappingURL=dom_misc.d.ts.map

package/dist/src/util/dom_request.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Cross-browser abstraction for sending XMLHttpRequest
+ * @deprecated this has to go away, we can use a modern browser method to do the same.
+ * @param {String} url URL to send XMLHttpRequest to
+ * @param {Object} [options] Options object
+ * @param {String} [options.method="GET"]
+ * @param {Record<string, string>} [options.parameters] parameters to append to url in GET or in body
+ * @param {String} [options.body] body to send with POST or PUT request
+ * @param {AbortSignal} [options.signal] handle aborting, see https://developer.mozilla.org/en-US/docs/Web/API/AbortController/signal
+ * @param {Function} options.onComplete Callback to invoke when request is completed
+ * @return {XMLHttpRequest} request
+ */
+export declare function request(url: any, options?: {}): any;
+//# sourceMappingURL=dom_request.d.ts.map

package/dist/src/util/dom_style.d.ts

@@ -0,0 +1,7 @@
+/**
+ * wrapper for setting element's style
+ * @param {HTMLElement} element
+ * @param {Object | string} styles
+ */
+export declare function setStyle(element: any, styles: any): void;
+//# sourceMappingURL=dom_style.d.ts.map

package/dist/src/util/fireEvent.d.ts

@@ -0,0 +1,3 @@
+import { BasicTransformEvent, TModificationEvents } from '../EventTypeDefs';
+export declare const fireEvent: (eventName: TModificationEvents, options: BasicTransformEvent) => void;
+//# sourceMappingURL=fireEvent.d.ts.map

package/dist/src/util/internals/cloneDeep.d.ts

@@ -0,0 +1,2 @@
+export declare const cloneDeep: <T extends object>(object: T) => T;
+//# sourceMappingURL=cloneDeep.d.ts.map

package/dist/src/util/internals/getRandomInt.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns random number between 2 specified ones.
+ * @param {Number} min lower limit
+ * @param {Number} max upper limit
+ * @return {Number} random value (between min and max)
+ */
+export declare const getRandomInt: (min: number, max: number) => number;
+//# sourceMappingURL=getRandomInt.d.ts.map

package/dist/src/util/internals/ifNaN.d.ts

@@ -0,0 +1,8 @@
+/**
+ *
+ * @param value value to check if NaN
+ * @param [valueIfNaN]
+ * @returns `fallback` is `value is NaN
+ */
+export declare const ifNaN: (value: number, valueIfNaN?: number) => number;
+//# sourceMappingURL=ifNaN.d.ts.map

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

@@ -0,0 +1,4 @@
+export { getRandomInt } from './getRandomInt';
+export { ifNaN } from './ifNaN';
+export { removeFromArray } from './removeFromArray';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/util/internals/removeFromArray.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Removes value from an array.
+ * Presence of value (and its position in an array) is determined via `Array.prototype.indexOf`
+ * @param {Array} array
+ * @param {*} value
+ * @return {Array} original array
+ */
+export declare const removeFromArray: <T>(array: T[], value: T) => T[];
+//# sourceMappingURL=removeFromArray.d.ts.map

package/dist/src/util/internals/uid.d.ts

@@ -0,0 +1,2 @@
+export declare const uid: () => number;
+//# sourceMappingURL=uid.d.ts.map

package/dist/src/util/lang_class.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Helper for creation of "classes".
+ * @param {Function} [parent] optional "Class" to inherit from
+ * @param {Object} [properties] Properties shared by all instances of this class
+ *                  (be careful modifying objects defined here as this would affect all instances)
+ */
+export declare function createClass(...args: any[]): {
+    (...klassArgs: any[]): void;
+    superclass: any;
+    prototype: any;
+};
+//# sourceMappingURL=lang_class.d.ts.map

package/dist/src/util/lang_string.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Capitalizes a string
+ * @param {String} string String to capitalize
+ * @param {Boolean} [firstLetterOnly] If true only first letter is capitalized
+ * and other letters stay untouched, if false first letter is capitalized
+ * and other letters are converted to lowercase.
+ * @return {String} Capitalized version of a string
+ */
+export declare const capitalize: (string: string, firstLetterOnly?: boolean) => string;
+/**
+ * Escapes XML in a string
+ * @param {String} string String to escape
+ * @return {String} Escaped version of a string
+ */
+export declare const escapeXml: (string: string) => string;
+/**
+ * Divide a string in the user perceived single units
+ * @param {String} textstring String to escape
+ * @return {Array} array containing the graphemes
+ */
+export declare const graphemeSplit: (textstring: string) => string[];
+//# sourceMappingURL=lang_string.d.ts.map

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

@@ -0,0 +1,9 @@
+import { IPoint } from '../../Point';
+import { TBBox } from '../../typedefs';
+/**
+ * Calculates bounding box (left, top, width, height) from given `points`
+ * @param {IPoint[]} points
+ * @return {Object} Object with left, top, width, height properties
+ */
+export declare const makeBoundingBoxFromPoints: (points: IPoint[]) => TBBox;
+//# sourceMappingURL=boundingBoxFromPoints.d.ts.map

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

@@ -0,0 +1,2 @@
+export declare const capValue: (min: number, value: number, max: number) => number;
+//# sourceMappingURL=capValue.d.ts.map

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

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

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

@@ -0,0 +1,28 @@
+import { ImageFormat } from '../../typedefs';
+/**
+ * Creates canvas element
+ * @return {CanvasElement} initialized canvas element
+ */
+export declare const createCanvasElement: () => HTMLCanvasElement;
+/**
+ * Creates image element (works on client and node)
+ * @return {HTMLImageElement} HTML image element
+ */
+export declare const createImage: () => HTMLImageElement;
+/**
+ * Creates a canvas element that is a copy of another and is also painted
+ * @param {CanvasElement} canvas to copy size and content of
+ * @return {CanvasElement} initialized canvas element
+ */
+export declare const copyCanvasElement: (canvas: HTMLCanvasElement) => HTMLCanvasElement;
+/**
+ * since 2.6.0 moved from canvas instance to utility.
+ * possibly useless
+ * @param {CanvasElement} canvasEl to copy size and content of
+ * @param {String} format 'jpeg' or 'png', in some browsers 'webp' is ok too
+ * @param {Number} quality <= 1 and > 0
+ * @return {String} data url
+ */
+export declare const toDataURL: (canvasEl: HTMLCanvasElement, format: ImageFormat, quality: number) => string;
+export declare const isHTMLCanvas: (canvas: HTMLCanvasElement | string) => canvas is HTMLCanvasElement;
+//# sourceMappingURL=dom.d.ts.map

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

@@ -0,0 +1,29 @@
+export interface IWithDimensions {
+    /**
+     * natural unscaled width of the object
+     */
+    width: number;
+    /**
+     * natural unscaled height of the object
+     */
+    height: number;
+}
+/**
+ * Finds the scale for the object source to fit inside the object destination,
+ * keeping aspect ratio intact.
+ * respect the total allowed area for the cache.
+ * @param {IWithDimensions} source
+ * @param {IWithDimensions} destination
+ * @return {Number} scale factor to apply to source to fit into destination
+ */
+export declare const findScaleToFit: (source: IWithDimensions, destination: IWithDimensions) => number;
+/**
+ * Finds the scale for the object source to cover entirely the object destination,
+ * keeping aspect ratio intact.
+ * respect the total allowed area for the cache.
+ * @param {IWithDimensions} source
+ * @param {IWithDimensions} destination
+ * @return {Number} scale factor to apply to source to cover destination
+ */
+export declare const findScaleToCover: (source: IWithDimensions, destination: IWithDimensions) => number;
+//# sourceMappingURL=findScaleTo.d.ts.map

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

@@ -0,0 +1,9 @@
+import type { FabricObject } from '../../shapes/Object/FabricObject';
+/**
+ * Groups SVG elements (usually those retrieved from SVG document)
+ * @static
+ * @param {FabricObject[]} elements FabricObject(s) parsed from svg, to group
+ * @return {FabricObject | Group}
+ */
+export declare const groupSVGElements: (elements: FabricObject[]) => FabricObject<import("../../EventTypeDefs").ObjectEvents>;
+//# sourceMappingURL=groupSVGElements.d.ts.map

package/dist/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
+ * @param {Number} y y coordinate in canvasElementCoordinate, not fabric space
+ * @param {Number} tolerance Tolerance pixels around the point, not alpha tolerance
+ * @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/matrix.d.ts

@@ -0,0 +1,92 @@
+import { IPoint, Point } from '../../Point';
+import { TDegree, TMat2D } from '../../typedefs';
+type TRotateMatrixArgs = {
+    angle?: TDegree;
+};
+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
+ * @param  {Point | IPoint} 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: IPoint, 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;
+/**
+ * Decomposes standard 2x3 matrix into transform components
+ * @param  {TMat2D} a transformMatrix
+ * @return {Object} Components of transform
+ */
+export declare const qrDecompose: (a: TMat2D) => TQrDecomposeOut;
+/**
+ * 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
+ * @param  {Object} options
+ * @param  {Number} [options.angle] angle in degrees
+ * @return {TMat2D} transform matrix
+ */
+export declare const calcRotateMatrix: ({ angle }: TRotateMatrixArgs) => 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
+ * @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: ({ translateX, translateY, angle, ...otherOptions }: TComposeMatrixArgs) => TMat2D;
+export {};
+//# sourceMappingURL=matrix.d.ts.map

package/dist/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/src/util/misc/objectEnlive.d.ts

@@ -0,0 +1,56 @@
+import type { FabricObject } from '../../shapes/Object/FabricObject';
+import type { TCrossOrigin, TFiller } from '../../typedefs';
+export type LoadImageOptions = {
+    /**
+     * see https://developer.mozilla.org/en-US/docs/Web/API/AbortController/signal
+     */
+    signal?: AbortSignal;
+    /**
+     * 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 = {
+    /**
+     * handle aborting, see https://developer.mozilla.org/en-US/docs/Web/API/AbortController/signal
+     */
+    signal?: AbortSignal;
+    /**
+     * Method for further parsing of object elements,
+     * called after each fabric object created.
+     */
+    reviver?: (serializedObj: Record<string, any>, instance: FabricObject) => void;
+    /**
+     * Namespace to get klass "Class" object from
+     */
+    namespace?: any;
+};
+/**
+ * Creates corresponding fabric instances from their object representations
+ * @param {Object[]} objects Objects to enliven
+ * @param {EnlivenObjectOptions} [options]
+ * @param {object} [options.namespace] Namespace to get klass "Class" object from
+ * @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: (objects: any[], { signal, reviver }?: EnlivenObjectOptions) => Promise<FabricObject<import("../../EventTypeDefs").ObjectEvents>[]>;
+/**
+ * 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, TFiller | FabricObject<import("../../EventTypeDefs").ObjectEvents> | null>>(serializedObject: any, { signal }?: {
+    signal?: AbortSignal | undefined;
+}) => Promise<R>;
+//# sourceMappingURL=objectEnlive.d.ts.map

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

@@ -0,0 +1,68 @@
+import { Point } from '../../Point';
+import type { FabricObject } from '../../shapes/Object/Object';
+import { TMat2D } from '../../typedefs';
+import type { TScaleMatrixArgs } from './matrix';
+/**
+ * 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
+ * described in options.
+ * Use to calculate the boxes around objects for controls.
+ * @param {Number} width
+ * @param {Number} height
+ * @param {Object} options
+ * @param {Number} options.scaleX
+ * @param {Number} options.scaleY
+ * @param {Number} options.skewX
+ * @param {Number} options.skewY
+ * @returns {Point} size
+ */
+export declare const sizeAfterTransform: (width: number, height: number, options: TScaleMatrixArgs) => Point;
+//# sourceMappingURL=objectTransforms.d.ts.map

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

@@ -0,0 +1,8 @@
+/**
+ * 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>;
+//# sourceMappingURL=pick.d.ts.map

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

@@ -0,0 +1,84 @@
+import type { Point } from '../../Point';
+import type { FabricObject } from '../../shapes/Object/FabricObject';
+import type { TMat2D } from '../../typedefs';
+import type { StaticCanvas } from '../../canvas/StaticCanvas';
+export declare const enum ObjectRelation {
+    sibling = "sibling",
+    child = "child"
+}
+/**
+ * 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
+ *
+ * @see {transformPointRelativeToCanvas} for transforming relative to canvas
+ * @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;
+/**
+ * Transform point relative to canvas.
+ * From the viewport/viewer's perspective the point remains unchanged.
+ *
+ * `child` relation means `point` exists in the coordinate plane created by `canvas`.
+ * In other words point is measured according to canvas' top left corner
+ * meaning that if `point` is equal to (0,0) it is positioned at canvas' top left corner.
+ *
+ * `sibling` relation means `point` exists in the same coordinate plane as canvas.
+ * In other words they both relate to the same (0,0) and agree on every point, which is how an event relates to canvas.
+ *
+ * @param {Point} point
+ * @param {StaticCanvas} canvas
+ * @param {'sibling'|'child'} relationBefore current relation of point to canvas
+ * @param {'sibling'|'child'} relationAfter desired relation of point to canvas
+ * @returns {Point} transformed point
+ */
+export declare const transformPointRelativeToCanvas: (point: Point, canvas: StaticCanvas, relationBefore: ObjectRelation, relationAfter: ObjectRelation) => 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