fabric 5.3.0 → 6.0.0-beta1

package/dist/src/Collection.d.ts

@@ -0,0 +1,126 @@
+import type { Constructor } from './typedefs';
+import type { BaseFabricObject } from './EventTypeDefs';
+export declare function createCollectionMixin<TBase extends Constructor>(Base: TBase): {
+    new (...args: any[]): {
+        /**
+         * @type {BaseFabricObject[]}
+         * @TODO needs to end up in the constructor too
+         */
+        _objects: BaseFabricObject[];
+        _onObjectAdded(object: BaseFabricObject): void;
+        _onObjectRemoved(object: BaseFabricObject): void;
+        _onStackOrderChanged(object: BaseFabricObject): void;
+        /**
+         * Adds objects to collection
+         * Objects should be instances of (or inherit from) BaseFabricObject
+         * @param {...BaseFabricObject[]} objects to add
+         * @returns {number} new array length
+         */
+        add(...objects: BaseFabricObject[]): number;
+        /**
+         * Inserts an object into collection at specified index
+         * @param {number} index Index to insert object at
+         * @param {...BaseFabricObject[]} objects Object(s) to insert
+         * @returns {number} new array length
+         */
+        insertAt(index: number, ...objects: BaseFabricObject[]): number;
+        /**
+         * Removes objects from a collection, then renders canvas (if `renderOnAddRemove` is not `false`)
+         * @private
+         * @param {...BaseFabricObject[]} objects objects to remove
+         * @returns {BaseFabricObject[]} removed objects
+         */
+        remove(...objects: BaseFabricObject[]): BaseFabricObject[];
+        /**
+         * Executes given function for each object in this group
+         * A simple shortcut for getObjects().forEach, before es6 was more complicated,
+         * now is just a shortcut.
+         * @param {Function} callback
+         *                   Callback invoked with current object as first argument,
+         *                   index - as second and an array of all objects - as third.
+         */
+        forEachObject(callback: (object: BaseFabricObject, index: number, array: BaseFabricObject[]) => any): void;
+        /**
+         * Returns an array of children objects of this instance
+         * @param {...String} [types] When specified, only objects of these types are returned
+         * @return {Array}
+         */
+        getObjects(...types: string[]): BaseFabricObject[];
+        /**
+         * Returns object at specified index
+         * @param {Number} index
+         * @return {Object} object at index
+         */
+        item(index: number): BaseFabricObject;
+        /**
+         * Returns true if collection contains no objects
+         * @return {Boolean} true if collection is empty
+         */
+        isEmpty(): boolean;
+        /**
+         * Returns a size of a collection (i.e: length of an array containing its objects)
+         * @return {Number} Collection size
+         */
+        size(): number;
+        /**
+         * Returns true if collection contains an object.\
+         * **Prefer using {@link `BaseFabricObject#isDescendantOf`} for performance reasons**
+         * instead of `a.contains(b)` use `b.isDescendantOf(a)`
+         * @param {Object} object Object to check against
+         * @param {Boolean} [deep=false] `true` to check all descendants, `false` to check only `_objects`
+         * @return {Boolean} `true` if collection contains an object
+         */
+        contains(object: BaseFabricObject, deep?: boolean): boolean;
+        /**
+         * Returns number representation of a collection complexity
+         * @return {Number} complexity
+         */
+        complexity(): number;
+        /**
+         * Moves an object or the objects of a multiple selection
+         * to the bottom of the stack of drawn objects
+         * @param {fabric.Object} object Object to send to back
+         * @returns {boolean} true if change occurred
+         */
+        sendObjectToBack(object: BaseFabricObject): boolean;
+        /**
+         * Moves an object or the objects of a multiple selection
+         * to the top of the stack of drawn objects
+         * @param {fabric.Object} object Object to send
+         * @returns {boolean} true if change occurred
+         */
+        bringObjectToFront(object: BaseFabricObject): boolean;
+        /**
+         * Moves an object or a selection down in stack of drawn objects
+         * An optional parameter, `intersecting` allows to move the object in behind
+         * the first intersecting object. Where intersection is calculated with
+         * bounding box. If no intersection is found, there will not be change in the
+         * stack.
+         * @param {fabric.Object} object Object to send
+         * @param {boolean} [intersecting] If `true`, send object behind next lower intersecting object
+         * @returns {boolean} true if change occurred
+         */
+        sendObjectBackwards(object: BaseFabricObject, intersecting?: boolean): boolean;
+        /**
+         * Moves an object or a selection up in stack of drawn objects
+         * An optional parameter, intersecting allows to move the object in front
+         * of the first intersecting object. Where intersection is calculated with
+         * bounding box. If no intersection is found, there will not be change in the
+         * stack.
+         * @param {fabric.Object} object Object to send
+         * @param {boolean} [intersecting] If `true`, send object in front of next upper intersecting object
+         * @returns {boolean} true if change occurred
+         */
+        bringObjectForward(object: BaseFabricObject, intersecting?: boolean): boolean;
+        /**
+         * Moves an object to specified level in stack of drawn objects
+         * @param {fabric.Object} object Object to send
+         * @param {number} index Position to move to
+         * @returns {boolean} true if change occurred
+         */
+        moveObjectTo(object: BaseFabricObject, index: number): boolean;
+        findNewLowerIndex(object: BaseFabricObject, idx: number, intersecting?: boolean): number;
+        findNewUpperIndex(object: BaseFabricObject, idx: number, intersecting?: boolean): number;
+    };
+} & TBase;
+//# sourceMappingURL=Collection.d.ts.map

package/dist/src/CommonMethods.d.ts

@@ -0,0 +1,32 @@
+import { Observable } from './Observable';
+export declare class CommonMethods<EventSpec> extends Observable<EventSpec> {
+    /**
+     * Sets object's properties from options, for initialization only
+     * @protected
+     * @param {Object} [options] Options object
+     */
+    protected _setOptions(options?: any): void;
+    /**
+     * @private
+     */
+    _setObject(obj: Record<string, any>): void;
+    /**
+     * Sets property to a given value. When changing position/dimension -related properties (left, top, scale, angle, etc.) `set` does not update position of object's borders/controls. If you need to update those, call `setCoords()`.
+     * @param {String|Object} key Property name or object (if object, iterate over the object properties)
+     * @param {Object|Function} value Property value (if function, the value is passed into it and its return value is used as a new one)
+     */
+    set(key: string | Record<string, any>, value?: any): this;
+    _set(key: string, value: any): void;
+    /**
+     * Toggles specified property from `true` to `false` or from `false` to `true`
+     * @param {String} property Property to toggle
+     */
+    toggle(property: string): this;
+    /**
+     * Basic getter
+     * @param {String} property Property name
+     * @return {*} value of a property
+     */
+    get(property: string): any;
+}
+//# sourceMappingURL=CommonMethods.d.ts.map

package/dist/src/EventTypeDefs.d.ts

@@ -0,0 +1,226 @@
+import type { Control } from './controls/Control';
+import type { Point } from './Point';
+import type { FabricObject } from './shapes/Object/FabricObject';
+import type { FabricObject as StaticFabricObject } from './shapes/Object/Object';
+import type { FabricObjectSVGExportMixin } from './shapes/Object/FabricObjectSVGExportMixin';
+import type { Group } from './shapes/Group';
+import type { TOriginX, TOriginY, TRadian } from './typedefs';
+import type { saveObjectTransform } from './util/misc/objectTransforms';
+import type { Canvas } from './canvas/Canvas';
+import type { IText } from './shapes/IText/IText';
+import type { StaticCanvas } from './canvas/StaticCanvas';
+export interface BaseFabricObject extends StaticFabricObject, FabricObjectSVGExportMixin {
+}
+export type ModifierKey = keyof Pick<MouseEvent | PointerEvent | TouchEvent, 'altKey' | 'shiftKey' | 'ctrlKey' | 'metaKey'>;
+export type TOptionalModifierKey = ModifierKey | null | undefined;
+export type TPointerEvent = MouseEvent | TouchEvent | PointerEvent;
+export type TransformAction<T extends Transform = Transform, R = void> = (eventData: TPointerEvent, transform: T, x: number, y: number) => R;
+/**
+ * Control handlers that define a transformation
+ * Those handlers run when the user starts a transform and during a transform
+ */
+export type TransformActionHandler<T extends Transform = Transform> = TransformAction<T, boolean>;
+/**
+ * Control handlers that run on control click/down/up
+ * Those handlers run with or without a transform defined
+ */
+export type ControlActionHandler = TransformAction<Transform, any>;
+export type ControlCallback<R = void> = (eventData: TPointerEvent, control: Control, fabricObject: FabricObject) => R;
+export type ControlCursorCallback = ControlCallback<string>;
+/**
+ * relative to target's containing coordinate plane
+ * both agree on every point
+ */
+export type Transform = {
+    target: FabricObject;
+    action: string;
+    actionHandler?: TransformActionHandler;
+    corner: string | 0;
+    scaleX: number;
+    scaleY: number;
+    skewX: number;
+    skewY: number;
+    offsetX: number;
+    offsetY: number;
+    originX: TOriginX;
+    originY: TOriginY;
+    ex: number;
+    ey: number;
+    lastX: number;
+    lastY: number;
+    theta: TRadian;
+    width: number;
+    height: number;
+    shiftKey: boolean;
+    altKey: boolean;
+    original: ReturnType<typeof saveObjectTransform> & {
+        originX: TOriginX;
+        originY: TOriginY;
+    };
+    actionPerformed: boolean;
+};
+export type TEvent<E extends Event = TPointerEvent> = {
+    e: E;
+};
+type TEventWithTarget<E extends Event = TPointerEvent> = TEvent<E> & {
+    target: FabricObject;
+};
+export type BasicTransformEvent<E extends Event = TPointerEvent> = TEvent<E> & {
+    transform: Transform;
+    pointer: Point;
+};
+export type TModificationEvents = 'moving' | 'scaling' | 'rotating' | 'skewing' | 'resizing';
+export type ModifiedEvent<E extends Event = TPointerEvent> = TEvent<E> & {
+    transform: Transform;
+    target: FabricObject;
+    action: string;
+};
+type ModificationEventsSpec<Prefix extends string = '', Modification = BasicTransformEvent, Modified = ModifiedEvent | never> = Record<`${Prefix}${TModificationEvents}`, Modification> & Record<`${Prefix}modified`, Modified>;
+type ObjectModificationEvents = ModificationEventsSpec;
+type CanvasModificationEvents = ModificationEventsSpec<'object:', BasicTransformEvent & {
+    target: FabricObject;
+}, ModifiedEvent | {
+    target: FabricObject;
+}> & {
+    'before:transform': TEvent & {
+        transform: Transform;
+    };
+};
+export type TPointerEventInfo<E extends TPointerEvent = TPointerEvent> = TEvent<E> & {
+    target?: FabricObject;
+    subTargets?: FabricObject[];
+    button?: number;
+    isClick: boolean;
+    pointer: Point;
+    transform?: Transform | null;
+    absolutePointer: Point;
+    currentSubTargets?: FabricObject[];
+    currentTarget?: FabricObject | null;
+};
+type SimpleEventHandler<T extends Event = TPointerEvent> = TEvent<T> & {
+    target?: FabricObject;
+    subTargets: FabricObject[];
+};
+type InEvent = {
+    previousTarget?: FabricObject;
+};
+type OutEvent = {
+    nextTarget?: FabricObject;
+};
+export type DragEventData = TEvent<DragEvent> & {
+    target?: FabricObject;
+    subTargets?: FabricObject[];
+    dragSource?: FabricObject;
+    canDrop?: boolean;
+    didDrop?: boolean;
+    dropTarget?: FabricObject;
+};
+export type DropEventData = DragEventData & {
+    pointer: Point;
+};
+type DnDEvents = {
+    dragstart: TEventWithTarget<DragEvent>;
+    drag: DragEventData;
+    dragover: DragEventData;
+    dragenter: DragEventData & InEvent;
+    dragleave: DragEventData & OutEvent;
+    dragend: DragEventData;
+    'drop:before': DropEventData;
+    drop: DropEventData;
+    'drop:after': DropEventData;
+};
+type CanvasDnDEvents = DnDEvents & {
+    'drag:enter': DragEventData & InEvent;
+    'drag:leave': DragEventData & OutEvent;
+};
+type CanvasSelectionEvents = {
+    'selection:created': Partial<TEvent> & {
+        selected: FabricObject[];
+    };
+    'selection:updated': Partial<TEvent> & {
+        selected: FabricObject[];
+        deselected: FabricObject[];
+    };
+    'before:selection:cleared': Partial<TEvent> & {
+        deselected: FabricObject[];
+    };
+    'selection:cleared': Partial<TEvent> & {
+        deselected: FabricObject[];
+    };
+};
+export type CollectionEvents = {
+    'object:added': {
+        target: StaticFabricObject;
+    };
+    'object:removed': {
+        target: StaticFabricObject;
+    };
+};
+type BeforeSuffix<T extends string> = `${T}:before`;
+type WithBeforeSuffix<T extends string> = T | BeforeSuffix<T>;
+type TPointerEvents<Prefix extends string> = Record<`${Prefix}${WithBeforeSuffix<'down'> | WithBeforeSuffix<'move'> | WithBeforeSuffix<'up'> | 'dblclick'}`, TPointerEventInfo> & Record<`${Prefix}wheel`, TPointerEventInfo<WheelEvent>> & Record<`${Prefix}over`, TPointerEventInfo & InEvent> & Record<`${Prefix}out`, TPointerEventInfo & OutEvent>;
+export type TPointerEventNames = WithBeforeSuffix<'down'> | WithBeforeSuffix<'move'> | WithBeforeSuffix<'up'> | 'dblclick' | 'wheel';
+export type ObjectPointerEvents = TPointerEvents<'mouse'>;
+export type CanvasPointerEvents = TPointerEvents<'mouse:'>;
+export type MiscEvents = {
+    'contextmenu:before': SimpleEventHandler<Event>;
+    contextmenu: SimpleEventHandler<Event>;
+};
+export type ObjectEvents = ObjectPointerEvents & DnDEvents & MiscEvents & ObjectModificationEvents & {
+    selected: Partial<TEvent> & {
+        target: FabricObject;
+    };
+    deselected: Partial<TEvent> & {
+        target: FabricObject;
+    };
+    added: {
+        target: Group | Canvas | StaticCanvas;
+    };
+    removed: {
+        target: Group | Canvas | StaticCanvas;
+    };
+    'erasing:end': {
+        path: FabricObject;
+    };
+};
+export type StaticCanvasEvents = CollectionEvents & {
+    'canvas:cleared': never;
+    'before:render': {
+        ctx: CanvasRenderingContext2D;
+    };
+    'after:render': {
+        ctx: CanvasRenderingContext2D;
+    };
+};
+export type CanvasEvents = StaticCanvasEvents & CanvasPointerEvents & CanvasDnDEvents & MiscEvents & CanvasModificationEvents & CanvasSelectionEvents & {
+    'before:path:created': {
+        path: FabricObject;
+    };
+    'path:created': {
+        path: FabricObject;
+    };
+    'erasing:start': never;
+    'erasing:end': never | {
+        path: FabricObject;
+        targets: FabricObject[];
+        subTargets: FabricObject[];
+        drawables: {
+            backgroundImage?: FabricObject;
+            overlayImage?: FabricObject;
+        };
+    };
+    'text:selection:changed': {
+        target: IText;
+    };
+    'text:changed': {
+        target: IText;
+    };
+    'text:editing:entered': {
+        target: IText;
+    };
+    'text:editing:exited': {
+        target: IText;
+    };
+};
+export {};
+//# sourceMappingURL=EventTypeDefs.d.ts.map

package/dist/src/Intersection.d.ts

@@ -0,0 +1,100 @@
+import { Point } from './Point';
+export type IntersectionType = 'Intersection' | 'Coincident' | 'Parallel';
+export declare class Intersection {
+    points: Point[];
+    status?: IntersectionType;
+    constructor(status?: IntersectionType);
+    /**
+     * Used to verify if a point is alredy in the collection
+     * @param {Point} point
+     * @returns {boolean}
+     */
+    private includes;
+    /**
+     * Appends points of intersection
+     * @param {...Point[]} points
+     * @return {Intersection} thisArg
+     * @chainable
+     */
+    private append;
+    /**
+     * Checks if a line intersects another
+     * @static
+     * @param {Point} a1
+     * @param {Point} a2
+     * @param {Point} b1
+     * @param {Point} b2
+     * @param {boolean} [aInfinite=true] check segment intersection by passing `false`
+     * @param {boolean} [bInfinite=true] check segment intersection by passing `false`
+     * @return {Intersection}
+     */
+    static intersectLineLine(a1: Point, a2: Point, b1: Point, b2: Point, aInfinite?: boolean, bInfinite?: boolean): Intersection;
+    /**
+     * Checks if a segment intersects a line
+     * @see {@link intersectLineLine} for line intersection
+     * @static
+     * @param {Point} s1 boundary point of segment
+     * @param {Point} s2 other boundary point of segment
+     * @param {Point} l1 point on line
+     * @param {Point} l2 other point on line
+     * @return {Intersection}
+     */
+    static intersectSegmentLine(s1: Point, s2: Point, l1: Point, l2: Point): Intersection;
+    /**
+     * Checks if a segment intersects another
+     * @see {@link intersectLineLine} for line intersection
+     * @static
+     * @param {Point} a1 boundary point of segment
+     * @param {Point} a2 other boundary point of segment
+     * @param {Point} b1 boundary point of segment
+     * @param {Point} b2 other boundary point of segment
+     * @return {Intersection}
+     */
+    static intersectSegmentSegment(a1: Point, a2: Point, b1: Point, b2: Point): Intersection;
+    /**
+     * Checks if line intersects polygon
+     *
+     * @todo account for stroke
+     *
+     * @static
+     * @see {@link intersectSegmentPolygon} for segment intersection
+     * @param {Point} a1 point on line
+     * @param {Point} a2 other point on line
+     * @param {Point[]} points polygon points
+     * @param {boolean} [infinite=true] check segment intersection by passing `false`
+     * @return {Intersection}
+     */
+    static intersectLinePolygon(a1: Point, a2: Point, points: Point[], infinite?: boolean): Intersection;
+    /**
+     * Checks if segment intersects polygon
+     * @static
+     * @see {@link intersectLinePolygon} for line intersection
+     * @param {Point} a1 boundary point of segment
+     * @param {Point} a2 other boundary point of segment
+     * @param {Point[]} points polygon points
+     * @return {Intersection}
+     */
+    static intersectSegmentPolygon(a1: Point, a2: Point, points: Point[]): Intersection;
+    /**
+     * Checks if polygon intersects another polygon
+     *
+     * @todo account for stroke
+     *
+     * @static
+     * @param {Point[]} points1
+     * @param {Point[]} points2
+     * @return {Intersection}
+     */
+    static intersectPolygonPolygon(points1: Point[], points2: Point[]): Intersection;
+    /**
+     * Checks if polygon intersects rectangle
+     * @static
+     * @see {@link intersectPolygonPolygon} for polygon intersection
+     * @param {Point[]} points polygon points
+     * @param {Point} r1 top left point of rect
+     * @param {Point} r2 bottom right point of rect
+     * @return {Intersection}
+     */
+    static intersectPolygonRectangle(points: Point[], r1: Point, r2: Point): Intersection;
+}
+//# sourceMappingURL=Intersection.d.ts.map

package/dist/src/Observable.d.ts

@@ -0,0 +1,54 @@
+export type TEventCallback<T = any> = (options: T) => any;
+type EventRegistryObject<K extends string | number | symbol = string, E = any> = Record<K, TEventCallback<E>>;
+/**
+ * @tutorial {@link http://fabricjs.com/fabric-intro-part-2#events}
+ * @see {@link http://fabricjs.com/events|Events demo}
+ */
+export declare class Observable<EventSpec> {
+    private __eventListeners;
+    /**
+     * Observes specified event
+     * @alias on
+     * @param {string} eventName Event name (eg. 'after:render')
+     * @param {EventRegistryObject} handlers key/value pairs (eg. {'after:render': handler, 'selection:cleared': handler})
+     * @param {Function} handler Function that receives a notification when an event of the specified type occurs
+     * @return {Function} disposer
+     */
+    on<K extends keyof EventSpec, E extends EventSpec[K]>(eventName: K, handler: TEventCallback<E>): VoidFunction;
+    on<K extends string, E>(eventName: K, handler: TEventCallback<E>): VoidFunction;
+    on<K extends keyof EventSpec, E extends EventSpec[K]>(handlers: EventRegistryObject<K, E>): VoidFunction;
+    /**
+     * Observes specified event **once**
+     * @alias once
+     * @param {string} eventName Event name (eg. 'after:render')
+     * @param {EventRegistryObject} handlers key/value pairs (eg. {'after:render': handler, 'selection:cleared': handler})
+     * @param {Function} handler Function that receives a notification when an event of the specified type occurs
+     * @return {Function} disposer
+     */
+    once<K extends keyof EventSpec, E extends EventSpec[K]>(eventName: K, handler: TEventCallback<E>): VoidFunction;
+    once<K extends string, E>(eventName: K, handler: TEventCallback<E>): VoidFunction;
+    once<K extends keyof EventSpec, E extends EventSpec[K]>(handlers: EventRegistryObject<K, E>): VoidFunction;
+    /**
+     * @private
+     * @param {string} eventName
+     * @param {Function} [handler]
+     */
+    private _removeEventListener;
+    /**
+     * Stops event observing for a particular event handler. Calling this method
+     * without arguments removes all handlers for all events
+     * @param {string} eventName Event name (eg. 'after:render')
+     * @param {EventRegistryObject} handlers key/value pairs (eg. {'after:render': handler, 'selection:cleared': handler})
+     * @param {Function} handler Function to be deleted from EventListeners
+     */
+    off<K extends keyof EventSpec>(eventName: K, handler: TEventCallback): void;
+    off(handlers: EventRegistryObject): void;
+    /**
+     * Fires event with an optional options object
+     * @param {String} eventName Event name to fire
+     * @param {Object} [options] Options object
+     */
+    fire<K extends keyof EventSpec>(eventName: K, options?: EventSpec[K]): void;
+}
+export {};
+//# sourceMappingURL=Observable.d.ts.map

package/dist/src/Pattern.d.ts

@@ -0,0 +1,104 @@
+import { TCrossOrigin, TMat2D, TSize } from './typedefs';
+export type TPatternRepeat = 'repeat' | 'repeat-x' | 'repeat-y' | 'no-repeat';
+type TExportedKeys = 'crossOrigin' | 'offsetX' | 'offsetY' | 'patternTransform' | 'repeat' | 'source';
+export type TPatternOptions = Partial<Pick<Pattern, TExportedKeys>>;
+export type TPatternSerialized = TPatternOptions & {
+    source: string;
+};
+export type TPatternHydrationOptions = {
+    /**
+     * handle aborting
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/AbortController/signal
+     */
+    signal?: AbortSignal;
+};
+type TImageSource = {
+    source: HTMLImageElement;
+};
+type TCanvasSource = {
+    source: HTMLCanvasElement;
+};
+/**
+ * @see {@link http://fabricjs.com/patterns demo}
+ * @see {@link http://fabricjs.com/dynamic-patterns demo}
+ */
+export declare class Pattern {
+    type: string;
+    /**
+     * @type TPatternRepeat
+     * @defaults
+     */
+    repeat: TPatternRepeat;
+    /**
+     * Pattern horizontal offset from object's left/top corner
+     * @type Number
+     * @default
+     */
+    offsetX: number;
+    /**
+     * Pattern vertical offset from object's left/top corner
+     * @type Number
+     * @default
+     */
+    offsetY: number;
+    /**
+     * @type TCrossOrigin
+     * @default
+     */
+    crossOrigin: TCrossOrigin;
+    /**
+     * transform matrix to change the pattern, imported from svgs.
+     * @todo verify if using the identity matrix as default makes the rest of the code more easy
+     * @type Array
+     * @default
+     */
+    patternTransform: TMat2D | null;
+    /**
+     * The actual pixel source of the pattern
+     */
+    source: CanvasImageSource;
+    /**
+     * If true, this object will not be exported during the serialization of a canvas
+     * @type boolean
+     */
+    excludeFromExport?: boolean;
+    /**
+     * ID used for SVG export functionalities
+     * @type number
+     */
+    readonly id: number;
+    /**
+     * Constructor
+     * @param {Object} [options] Options object
+     * @param {option.source} [source] the pattern source, eventually empty or a drawable
+     */
+    constructor(options?: TPatternOptions);
+    /**
+     * @returns true if {@link source} is an <img> element
+     */
+    isImageSource(): this is TImageSource;
+    /**
+     * @returns true if {@link source} is a <canvas> element
+     */
+    isCanvasSource(): this is TCanvasSource;
+    sourceToString(): string;
+    /**
+     * Returns an instance of CanvasPattern
+     * @param {CanvasRenderingContext2D} ctx Context to create pattern
+     * @return {CanvasPattern}
+     */
+    toLive(ctx: CanvasRenderingContext2D): CanvasPattern | null;
+    /**
+     * Returns object representation of a pattern
+     * @param {Array} [propertiesToInclude] Any properties that you might want to additionally include in the output
+     * @return {object} Object representation of a pattern instance
+     */
+    toObject(propertiesToInclude?: string[]): Record<string, any>;
+    /**
+     * Returns SVG representation of a pattern
+     */
+    toSVG({ width, height }: TSize): string;
+    static fromObject({ source, ...serialized }: TPatternSerialized, options: TPatternHydrationOptions): Promise<Pattern>;
+}
+export {};
+//# sourceMappingURL=Pattern.d.ts.map