fabric 6.2.0 → 6.3.0

package/dist-extensions/src/controls/scale.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scale.d.ts","sourceRoot":"","sources":["../../../src/controls/scale.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,qBAAqB,EACrB,aAAa,EACb,SAAS,EACT,sBAAsB,EACvB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAClE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAczC,KAAK,cAAc,GAAG,SAAS,GAAG;IAChC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,KAAK,OAAO,GAAG,KAAK,GAAG,SAAS,GAAG,EAAE,GAAG,SAAS,CAAC;AAElD;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,aAAa,EACxB,YAAY,EAAE,YAAY,GACzB,OAAO,CAOT;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,YAAY,EAAE,YAAY,EAC1B,EAAE,EAAE,OAAO,EACX,mBAAmB,EAAE,OAAO,WA0B7B;AAID;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,EAAE,qBAiBrC,CAAC;AA4GF;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,EAAE,sBAAsB,CAAC,cAAc,CAOxE,CAAC;AAsCF,eAAO,MAAM,cAAc,wCAG1B,CAAC;AAEF,eAAO,MAAM,QAAQ,wCAGpB,CAAC;AAEF,eAAO,MAAM,QAAQ,wCAGpB,CAAC"}

package/dist-extensions/src/controls/scaleSkew.d.ts

@@ -0,0 +1,39 @@
+import type { ControlCallback, ControlCursorCallback, TransformActionHandler } from '../EventTypeDefs';
+import type { TAxisKey } from '../typedefs';
+/**
+ * Inspect event, control and fabricObject to return the correct action name
+ * @param {Event} eventData the javascript event that is causing the scale
+ * @param {Control} control the control that is interested in the action
+ * @param {FabricObject} fabricObject the fabric object that is interested in the action
+ * @return {String} an action name
+ */
+export declare const scaleOrSkewActionName: ControlCallback<TAxisKey<'skew' | 'scale'> | ''>;
+/**
+ * Combine skew and scale style handlers to cover fabric standard use case
+ * @param {Event} eventData the javascript event that is causing the scale
+ * @param {Control} control the control that is interested in the action
+ * @param {FabricObject} fabricObject the fabric object that is interested in the action
+ * @return {String} a valid css string for the cursor
+ */
+export declare const scaleSkewCursorStyleHandler: ControlCursorCallback;
+/**
+ * Composed action handler to either scale X or skew Y
+ * Needs to be wrapped with `wrapWithFixedAnchor` to be effective
+ * @param {Event} eventData javascript event that is doing the transform
+ * @param {Object} transform javascript object containing a series of information around the current transform
+ * @param {number} x current mouse x position, canvas normalized
+ * @param {number} y current mouse y position, canvas normalized
+ * @return {Boolean} true if some change happened
+ */
+export declare const scalingXOrSkewingY: TransformActionHandler;
+/**
+ * Composed action handler to either scale Y or skew X
+ * Needs to be wrapped with `wrapWithFixedAnchor` to be effective
+ * @param {Event} eventData javascript event that is doing the transform
+ * @param {Object} transform javascript object containing a series of information around the current transform
+ * @param {number} x current mouse x position, canvas normalized
+ * @param {number} y current mouse y position, canvas normalized
+ * @return {Boolean} true if some change happened
+ */
+export declare const scalingYOrSkewingX: TransformActionHandler;
+//# sourceMappingURL=scaleSkew.d.ts.map

package/dist-extensions/src/controls/scaleSkew.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scaleSkew.d.ts","sourceRoot":"","sources":["../../../src/controls/scaleSkew.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,qBAAqB,EAErB,sBAAsB,EACvB,MAAM,kBAAkB,CAAC;AAG1B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAQ5C;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,EAAE,eAAe,CACjD,QAAQ,CAAC,MAAM,GAAG,OAAO,CAAC,GAAG,EAAE,CAYhC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B,EAAE,qBAQzC,CAAC;AACF;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,EAAE,sBAShC,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,EAAE,sBAShC,CAAC"}

package/dist-extensions/src/controls/skew.d.ts

@@ -0,0 +1,33 @@
+import type { ControlCursorCallback, Transform, TransformActionHandler } from '../EventTypeDefs';
+export type SkewTransform = Transform & {
+    skewingSide: -1 | 1;
+};
+/**
+ * return the correct cursor style for the skew action
+ * @param {Event} eventData the javascript event that is causing the scale
+ * @param {Control} control the control that is interested in the action
+ * @param {FabricObject} fabricObject the fabric object that is interested in the action
+ * @return {String} a valid css string for the cursor
+ */
+export declare const skewCursorStyleHandler: ControlCursorCallback;
+/**
+ * Wrapped Action handler for skewing on the X axis, takes care of the
+ * skew direction and determines the correct transform origin for the anchor point
+ * @param {Event} eventData javascript event that is doing the transform
+ * @param {Object} transform javascript object containing a series of information around the current transform
+ * @param {number} x current mouse x position, canvas normalized
+ * @param {number} y current mouse y position, canvas normalized
+ * @return {Boolean} true if some change happened
+ */
+export declare const skewHandlerX: TransformActionHandler;
+/**
+ * Wrapped Action handler for skewing on the Y axis, takes care of the
+ * skew direction and determines the correct transform origin for the anchor point
+ * @param {Event} eventData javascript event that is doing the transform
+ * @param {Object} transform javascript object containing a series of information around the current transform
+ * @param {number} x current mouse x position, canvas normalized
+ * @param {number} y current mouse y position, canvas normalized
+ * @return {Boolean} true if some change happened
+ */
+export declare const skewHandlerY: TransformActionHandler;
+//# sourceMappingURL=skew.d.ts.map

package/dist-extensions/src/controls/skew.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skew.d.ts","sourceRoot":"","sources":["../../../src/controls/skew.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,qBAAqB,EAErB,SAAS,EACT,sBAAsB,EACvB,MAAM,kBAAkB,CAAC;AAyB1B,MAAM,MAAM,aAAa,GAAG,SAAS,GAAG;IAAE,WAAW,EAAE,CAAC,CAAC,GAAG,CAAC,CAAA;CAAE,CAAC;AAiChE;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,EAAE,qBAapC,CAAC;AAoIF;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY,EAAE,sBAO1B,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY,EAAE,sBAO1B,CAAC"}

package/dist-extensions/src/controls/util.d.ts

@@ -0,0 +1,41 @@
+import type { TPointerEvent, Transform, TransformAction, BasicTransformEvent } from '../EventTypeDefs';
+import { Point } from '../Point';
+import type { FabricObject } from '../shapes/Object/FabricObject';
+import type { TOriginX, TOriginY } from '../typedefs';
+import type { Control } from './Control';
+export declare const NOT_ALLOWED_CURSOR = "not-allowed";
+/**
+ * @param {Boolean} alreadySelected true if target is already selected
+ * @param {String} corner a string representing the corner ml, mr, tl ...
+ * @param {Event} e Event object
+ * @param {FabricObject} [target] inserted back to help overriding. Unused
+ */
+export declare const getActionFromCorner: (alreadySelected: boolean, corner: string | undefined, e: TPointerEvent, target: FabricObject) => string;
+/**
+ * Checks if transform is centered
+ * @param {Object} transform transform data
+ * @return {Boolean} true if transform is centered
+ */
+export declare function isTransformCentered(transform: Transform): boolean;
+export declare function invertOrigin(origin: TOriginX | TOriginY): number;
+export declare const isLocked: (target: FabricObject, lockingKey: "lockMovementX" | "lockMovementY" | "lockRotation" | "lockScalingX" | "lockScalingY" | "lockSkewingX" | "lockSkewingY" | "lockScalingFlip") => boolean;
+export declare const commonEventInfo: TransformAction<Transform, BasicTransformEvent>;
+/**
+ * Combine control position and object angle to find the control direction compared
+ * to the object center.
+ * @param {FabricObject} fabricObject the fabric object for which we are rendering controls
+ * @param {Control} control the control class
+ * @return {Number} 0 - 7 a quadrant number
+ */
+export declare function findCornerQuadrant(fabricObject: FabricObject, control: Control): number;
+/**
+ * Transforms a point to the offset from the given origin
+ * @param {Object} transform
+ * @param {String} originX
+ * @param {String} originY
+ * @param {number} x
+ * @param {number} y
+ * @return {Fabric.Point} the normalized point
+ */
+export declare function getLocalPoint({ target, corner }: Transform, originX: TOriginX, originY: TOriginY, x: number, y: number): Point;
+//# sourceMappingURL=util.d.ts.map

package/dist-extensions/src/controls/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../../src/controls/util.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,SAAS,EACT,eAAe,EACf,mBAAmB,EACpB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AACjC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAClE,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAKtD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAGzC,eAAO,MAAM,kBAAkB,gBAAgB,CAAC;AAEhD;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,oBACb,OAAO,UAChB,MAAM,GAAG,SAAS,KACvB,aAAa,UACR,YAAY,WAOrB,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,SAAS,WAKvD;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,QAAQ,GAAG,QAAQ,UAEvD;AAED,eAAO,MAAM,QAAQ,WACX,YAAY,cAEhB,eAAe,GACf,eAAe,GACf,cAAc,GACd,cAAc,GACd,cAAc,GACd,cAAc,GACd,cAAc,GACd,iBAAiB,YACA,CAAC;AAExB,eAAO,MAAM,eAAe,EAAE,eAAe,CAC3C,SAAS,EACT,mBAAmB,CAOpB,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,YAAY,EAAE,YAAY,EAC1B,OAAO,EAAE,OAAO,GACf,MAAM,CAMR;AA4BD;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAC3B,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,SAAS,EAC7B,OAAO,EAAE,QAAQ,EACjB,OAAO,EAAE,QAAQ,EACjB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,SAqBV"}

package/dist-extensions/src/controls/wrapWithFireEvent.d.ts

@@ -0,0 +1,10 @@
+import type { TModificationEvents, Transform, TransformActionHandler } from '../EventTypeDefs';
+/**
+ * Wrap an action handler with firing an event if the action is performed
+ * @param {TModificationEvents} eventName the event we want to fire
+ * @param {TransformActionHandler<T>} actionHandler the function to wrap
+ * @param {object} extraEventInfo extra information to pas to the event handler
+ * @return {TransformActionHandler<T>} a function with an action handler signature
+ */
+export declare const wrapWithFireEvent: <T extends Transform, P extends object = Record<string, never>>(eventName: TModificationEvents, actionHandler: TransformActionHandler<T>, extraEventInfo?: P) => TransformActionHandler<T>;
+//# sourceMappingURL=wrapWithFireEvent.d.ts.map

package/dist-extensions/src/controls/wrapWithFireEvent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrapWithFireEvent.d.ts","sourceRoot":"","sources":["../../../src/controls/wrapWithFireEvent.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,mBAAmB,EACnB,SAAS,EACT,sBAAsB,EACvB,MAAM,kBAAkB,CAAC;AAI1B;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,GAC5B,CAAC,SAAS,SAAS,EACnB,CAAC,SAAS,MAAM,qCAEL,mBAAmB,iBACf,sBAAsB,CAAC,CAAC,CAAC,mBACvB,CAAC,KAWZ,sBAAsB,CAAC,CAAC,CAC/B,CAAC"}

package/dist-extensions/src/controls/wrapWithFixedAnchor.d.ts

@@ -0,0 +1,9 @@
+import type { Transform, TransformActionHandler } from '../EventTypeDefs';
+/**
+ * Wrap an action handler with saving/restoring object position on the transform.
+ * this is the code that permits to objects to keep their position while transforming.
+ * @param {Function} actionHandler the function to wrap
+ * @return {Function} a function with an action handler signature
+ */
+export declare function wrapWithFixedAnchor<T extends Transform>(actionHandler: TransformActionHandler<T>): TransformActionHandler<T>;
+//# sourceMappingURL=wrapWithFixedAnchor.d.ts.map

package/dist-extensions/src/controls/wrapWithFixedAnchor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrapWithFixedAnchor.d.ts","sourceRoot":"","sources":["../../../src/controls/wrapWithFixedAnchor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAE1E;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,SAAS,EACrD,aAAa,EAAE,sBAAsB,CAAC,CAAC,CAAC,GAelC,sBAAsB,CAAC,CAAC,CAAC,CAChC"}

package/dist-extensions/src/env/browser.d.ts

@@ -0,0 +1,3 @@
+import type { TFabricEnv } from './types';
+export declare const getEnv: () => TFabricEnv;
+//# sourceMappingURL=browser.d.ts.map

package/dist-extensions/src/env/browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.d.ts","sourceRoot":"","sources":["../../../src/env/browser.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAkB,UAAU,EAAE,MAAM,SAAS,CAAC;AAI1D,eAAO,MAAM,MAAM,QAAO,UAczB,CAAC"}

package/dist-extensions/src/env/index.d.ts

@@ -0,0 +1,34 @@
+/**
+ * This file is consumed by fabric.
+ * The `./node` and `./browser` files define the env variable that is used by this module.
+ * The `./browser` module is defined to be the default env and doesn't set the env at all.
+ * This is done in order to support isomorphic usage for browser and node applications
+ * since window and document aren't defined at time of import in SSR, we can't set env so we avoid it by deferring to the default env.
+ */
+import type { TFabricEnv } from './types';
+import type { DOMWindow } from 'jsdom';
+/**
+ * Sets the environment variables used by fabric.\
+ * This is exposed for special cases, such as configuring a test environment, and should be used with care.
+ *
+ * **CAUTION**: Must be called before using the package.
+ *
+ * @example
+ * <caption>Passing `window` and `document` objects to fabric (in case they are mocked or something)</caption>
+ * import { getEnv, setEnv } from 'fabric';
+ * // we want fabric to use the `window` and `document` objects exposed by the environment we are running in.
+ * setEnv({ ...getEnv(), window, document });
+ * // done with setup, using fabric is now safe
+ */
+export declare const setEnv: (value: TFabricEnv) => void;
+/**
+ * In order to support SSR we **MUST** access the browser env only after the window has loaded
+ */
+export declare const getEnv: () => TFabricEnv;
+export declare const getFabricDocument: () => Document;
+export declare const getFabricWindow: () => (Window & typeof globalThis) | DOMWindow;
+/**
+ * @returns the config value if defined, fallbacks to the environment value
+ */
+export declare const getDevicePixelRatio: () => number;
+//# sourceMappingURL=index.d.ts.map

package/dist-extensions/src/env/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/env/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAC1C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAIvC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,MAAM,UAAW,UAAU,SAEvC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,MAAM,kBAAuC,CAAC;AAE3D,eAAO,MAAM,iBAAiB,QAAO,QAA6B,CAAC;AAEnE,eAAO,MAAM,eAAe,QAAO,CAAC,MAAM,GAAG,OAAO,UAAU,CAAC,GAAG,SACjD,CAAC;AAElB;;GAEG;AACH,eAAO,MAAM,mBAAmB,cAC4C,CAAC"}

package/dist-extensions/src/env/types.d.ts

@@ -0,0 +1,16 @@
+import type { GLProbe } from '../filters/GLProbes/GLProbe';
+import type { DOMWindow } from 'jsdom';
+import type { TextStyleDeclaration } from '../shapes/Text/StyledText';
+export type TCopyPasteData = {
+    copiedText?: string;
+    copiedTextStyle?: TextStyleDeclaration[];
+};
+export type TFabricEnv = {
+    readonly document: Document;
+    readonly window: (Window & typeof globalThis) | DOMWindow;
+    readonly isTouchSupported: boolean;
+    WebGLProbe: GLProbe;
+    dispose(element: Element): void;
+    copyPasteData: TCopyPasteData;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist-extensions/src/env/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/env/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAEtE,MAAM,MAAM,cAAc,GAAG;IAC3B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,eAAe,CAAC,EAAE,oBAAoB,EAAE,CAAC;CAC1C,CAAC;AACF,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAE,CAAC,MAAM,GAAG,OAAO,UAAU,CAAC,GAAG,SAAS,CAAC;IAC1D,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC;IACnC,UAAU,EAAE,OAAO,CAAC;IACpB,OAAO,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;IAChC,aAAa,EAAE,cAAc,CAAC;CAC/B,CAAC"}

package/dist-extensions/src/filters/BaseFilter.d.ts

@@ -0,0 +1,153 @@
+import type { T2DPipelineState, TWebGLAttributeLocationMap, TWebGLPipelineState, TWebGLProgramCacheItem, TWebGLUniformLocationMap } from './typedefs';
+import type { Abortable } from '../typedefs';
+export declare class BaseFilter<Name extends string, OwnProps extends Record<string, any> = object> {
+    /**
+     * Filter type
+     * @param {String} type
+     * @default
+     */
+    get type(): Name;
+    /**
+     * The class type. Used to identify which class this is.
+     * This is used for serialization purposes and internally it can be used
+     * to identify classes. As a developer you could use `instance of Class`
+     * but to avoid importing all the code and blocking tree shaking we try
+     * to avoid doing that.
+     */
+    static type: string;
+    /**
+     * Contains the uniform locations for the fragment shader.
+     * uStepW and uStepH are handled by the BaseFilter, each filter class
+     * needs to specify all the one that are needed
+     */
+    static uniformLocations: string[];
+    static defaults: Record<string, unknown>;
+    /**
+     * Constructor
+     * @param {Object} [options] Options object
+     */
+    constructor({ type, ...options }?: {
+        type?: never;
+    } & Partial<OwnProps> & Record<string, any>);
+    protected getFragmentSource(): string;
+    getVertexSource(): string;
+    /**
+     * Compile this filter's shader program.
+     *
+     * @param {WebGLRenderingContext} gl The GL canvas context to use for shader compilation.
+     * @param {String} fragmentSource fragmentShader source for compilation
+     * @param {String} vertexSource vertexShader source for compilation
+     */
+    createProgram(gl: WebGLRenderingContext, fragmentSource?: string, vertexSource?: string): {
+        program: WebGLProgram;
+        attributeLocations: TWebGLAttributeLocationMap;
+        uniformLocations: TWebGLUniformLocationMap;
+    };
+    /**
+     * Return a map of attribute names to WebGLAttributeLocation objects.
+     *
+     * @param {WebGLRenderingContext} gl The canvas context used to compile the shader program.
+     * @param {WebGLShaderProgram} program The shader program from which to take attribute locations.
+     * @returns {Object} A map of attribute names to attribute locations.
+     */
+    getAttributeLocations(gl: WebGLRenderingContext, program: WebGLProgram): TWebGLAttributeLocationMap;
+    /**
+     * Return a map of uniform names to WebGLUniformLocation objects.
+     *
+     * @param {WebGLRenderingContext} gl The canvas context used to compile the shader program.
+     * @param {WebGLShaderProgram} program The shader program from which to take uniform locations.
+     * @returns {Object} A map of uniform names to uniform locations.
+     */
+    getUniformLocations(gl: WebGLRenderingContext, program: WebGLProgram): TWebGLUniformLocationMap;
+    /**
+     * Send attribute data from this filter to its shader program on the GPU.
+     *
+     * @param {WebGLRenderingContext} gl The canvas context used to compile the shader program.
+     * @param {Object} attributeLocations A map of shader attribute names to their locations.
+     */
+    sendAttributeData(gl: WebGLRenderingContext, attributeLocations: Record<string, number>, aPositionData: Float32Array): void;
+    _setupFrameBuffer(options: TWebGLPipelineState): void;
+    _swapTextures(options: TWebGLPipelineState): void;
+    /**
+     * Generic isNeutral implementation for one parameter based filters.
+     * Used only in image applyFilters to discard filters that will not have an effect
+     * on the image
+     * Other filters may need their own version ( ColorMatrix, HueRotation, gamma, ComposedFilter )
+     * @param {Object} options
+     **/
+    isNeutralState(options?: any): boolean;
+    /**
+     * Apply this filter to the input image data provided.
+     *
+     * Determines whether to use WebGL or Canvas2D based on the options.webgl flag.
+     *
+     * @param {Object} options
+     * @param {Number} options.passes The number of filters remaining to be executed
+     * @param {Boolean} options.webgl Whether to use webgl to render the filter.
+     * @param {WebGLTexture} options.sourceTexture The texture setup as the source to be filtered.
+     * @param {WebGLTexture} options.targetTexture The texture where filtered output should be drawn.
+     * @param {WebGLRenderingContext} options.context The GL context used for rendering.
+     * @param {Object} options.programCache A map of compiled shader programs, keyed by filter type.
+     */
+    applyTo(options: TWebGLPipelineState | T2DPipelineState): void;
+    applyTo2d(_options: T2DPipelineState): void;
+    /**
+     * Returns a string that represent the current selected shader code for the filter.
+     * Used to force recompilation when parameters change or to retrieve the shader from cache
+     * @type string
+     **/
+    getCacheKey(): string;
+    /**
+     * Retrieves the cached shader.
+     * @param {Object} options
+     * @param {WebGLRenderingContext} options.context The GL context used for rendering.
+     * @param {Object} options.programCache A map of compiled shader programs, keyed by filter type.
+     * @return {WebGLProgram} the compiled program shader
+     */
+    retrieveShader(options: TWebGLPipelineState): TWebGLProgramCacheItem;
+    /**
+     * Apply this filter using webgl.
+     *
+     * @param {Object} options
+     * @param {Number} options.passes The number of filters remaining to be executed
+     * @param {Boolean} options.webgl Whether to use webgl to render the filter.
+     * @param {WebGLTexture} options.originalTexture The texture of the original input image.
+     * @param {WebGLTexture} options.sourceTexture The texture setup as the source to be filtered.
+     * @param {WebGLTexture} options.targetTexture The texture where filtered output should be drawn.
+     * @param {WebGLRenderingContext} options.context The GL context used for rendering.
+     * @param {Object} options.programCache A map of compiled shader programs, keyed by filter type.
+     */
+    applyToWebGL(options: TWebGLPipelineState): void;
+    bindAdditionalTexture(gl: WebGLRenderingContext, texture: WebGLTexture, textureUnit: number): void;
+    unbindAdditionalTexture(gl: WebGLRenderingContext, textureUnit: number): void;
+    /**
+     * Send uniform data from this filter to its shader program on the GPU.
+     *
+     * Intended to be overridden by subclasses.
+     *
+     * @param {WebGLRenderingContext} _gl The canvas context used to compile the shader program.
+     * @param {Object} _uniformLocations A map of shader uniform names to their locations.
+     */
+    sendUniformData(_gl: WebGLRenderingContext, _uniformLocations: TWebGLUniformLocationMap): void;
+    /**
+     * If needed by a 2d filter, this functions can create an helper canvas to be used
+     * remember that options.targetCanvas is available for use till end of chain.
+     */
+    createHelpLayer(options: T2DPipelineState): void;
+    /**
+     * Returns object representation of an instance
+     * @return {Object} Object representation of an instance
+     */
+    toObject(): {
+        type: Name;
+    } & OwnProps;
+    /**
+     * Returns a JSON representation of an instance
+     * @return {Object} JSON
+     */
+    toJSON(): {
+        type: Name;
+    } & OwnProps;
+    static fromObject({ type, ...filterOptions }: Record<string, any>, _options: Abortable): Promise<BaseFilter<string, object>>;
+}
+//# sourceMappingURL=BaseFilter.d.ts.map

package/dist-extensions/src/filters/BaseFilter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseFilter.d.ts","sourceRoot":"","sources":["../../../src/filters/BaseFilter.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,gBAAgB,EAChB,0BAA0B,EAC1B,mBAAmB,EACnB,sBAAsB,EACtB,wBAAwB,EACzB,MAAM,YAAY,CAAC;AAOpB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAK7C,qBAAa,UAAU,CACrB,IAAI,SAAS,MAAM,EACnB,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM;IAE7C;;;;OAIG;IACH,IAAI,IAAI,IAAI,IAAI,CAEf;IAED;;;;;;OAMG;IACH,MAAM,CAAC,IAAI,SAAgB;IAE3B;;;;OAIG;IACH,MAAM,CAAC,gBAAgB,EAAE,MAAM,EAAE,CAAM;IAEvC,OAAe,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAEjD;;;OAGG;gBACS,EACV,IAAI,EACJ,GAAG,OAAO,EACX,GAAE;QAAE,IAAI,CAAC,EAAE,KAAK,CAAA;KAAE,GAAG,OAAO,CAAC,QAAQ,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAM;IAQlE,SAAS,CAAC,iBAAiB,IAAI,MAAM;IAIrC,eAAe,IAAI,MAAM;IAIzB;;;;;;OAMG;IACH,aAAa,CACX,EAAE,EAAE,qBAAqB,EACzB,cAAc,GAAE,MAAiC,EACjD,YAAY,GAAE,MAA+B;;;;;IA4D/C;;;;;;OAMG;IACH,qBAAqB,CACnB,EAAE,EAAE,qBAAqB,EACzB,OAAO,EAAE,YAAY,GACpB,0BAA0B;IAM7B;;;;;;OAMG;IACH,mBAAmB,CACjB,EAAE,EAAE,qBAAqB,EACzB,OAAO,EAAE,YAAY,GACpB,wBAAwB;IAc3B;;;;;OAKG;IACH,iBAAiB,CACf,EAAE,EAAE,qBAAqB,EACzB,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC1C,aAAa,EAAE,YAAY;IAU7B,iBAAiB,CAAC,OAAO,EAAE,mBAAmB;IA2B9C,aAAa,CAAC,OAAO,EAAE,mBAAmB;IAQ1C;;;;;;QAMI;IAEJ,cAAc,CAAC,OAAO,CAAC,EAAE,GAAG,GAAG,OAAO;IAItC;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,OAAO,EAAE,mBAAmB,GAAG,gBAAgB;IAUvD,SAAS,CAAC,QAAQ,EAAE,gBAAgB,GAAG,IAAI;IAI3C;;;;QAII;IACJ,WAAW,IAAI,MAAM;IAIrB;;;;;;OAMG;IACH,cAAc,CAAC,OAAO,EAAE,mBAAmB,GAAG,sBAAsB;IAQpE;;;;;;;;;;;OAWG;IACH,YAAY,CAAC,OAAO,EAAE,mBAAmB;IAmBzC,qBAAqB,CACnB,EAAE,EAAE,qBAAqB,EACzB,OAAO,EAAE,YAAY,EACrB,WAAW,EAAE,MAAM;IAQrB,uBAAuB,CAAC,EAAE,EAAE,qBAAqB,EAAE,WAAW,EAAE,MAAM;IAMtE;;;;;;;OAOG;IACH,eAAe,CACb,GAAG,EAAE,qBAAqB,EAC1B,iBAAiB,EAAE,wBAAwB,GAC1C,IAAI;IAIP;;;OAGG;IACH,eAAe,CAAC,OAAO,EAAE,gBAAgB;IASzC;;;OAGG;IACH,QAAQ,IAAI;QAAE,IAAI,EAAE,IAAI,CAAA;KAAE,GAAG,QAAQ;IAgBrC;;;OAGG;IACH,MAAM;cApBc,IAAI;;WAyBX,UAAU,CACrB,EAAE,IAAI,EAAE,GAAG,aAAa,EAAE,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC/C,QAAQ,EAAE,SAAS,GAClB,OAAO,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAGvC"}

package/dist-extensions/src/filters/BlendColor.d.ts

@@ -0,0 +1,68 @@
+import { BaseFilter } from './BaseFilter';
+import type { T2DPipelineState, TWebGLUniformLocationMap } from './typedefs';
+export type TBlendMode = 'multiply' | 'add' | 'difference' | 'screen' | 'subtract' | 'darken' | 'lighten' | 'overlay' | 'exclusion' | 'tint';
+type BlendColorOwnProps = {
+    color: string;
+    mode: TBlendMode;
+    alpha: number;
+};
+export declare const blendColorDefaultValues: BlendColorOwnProps;
+/**
+ * Color Blend filter class
+ * @example
+ * const filter = new BlendColor({
+ *  color: '#000',
+ *  mode: 'multiply'
+ * });
+ *
+ * const filter = new BlendImage({
+ *  image: fabricImageObject,
+ *  mode: 'multiply'
+ * });
+ * object.filters.push(filter);
+ * object.applyFilters();
+ * canvas.renderAll();
+ */
+export declare class BlendColor extends BaseFilter<'BlendColor', BlendColorOwnProps> {
+    /**
+     * Color to make the blend operation with. default to a reddish color since black or white
+     * gives always strong result.
+     * @type String
+     * @default
+     **/
+    color: BlendColorOwnProps['color'];
+    /**
+     * Blend mode for the filter: one of multiply, add, difference, screen, subtract,
+     * darken, lighten, overlay, exclusion, tint.
+     * @type String
+     * @default
+     **/
+    mode: BlendColorOwnProps['mode'];
+    /**
+     * alpha value. represent the strength of the blend color operation.
+     * @type Number
+     * @default
+     **/
+    alpha: BlendColorOwnProps['alpha'];
+    static defaults: BlendColorOwnProps;
+    static type: string;
+    static uniformLocations: string[];
+    getCacheKey(): string;
+    protected getFragmentSource(): string;
+    /**
+     * Apply the Blend operation to a Uint8ClampedArray representing the pixels of an image.
+     *
+     * @param {Object} options
+     * @param {ImageData} options.imageData The Uint8ClampedArray to be filtered.
+     */
+    applyTo2d({ imageData: { data } }: T2DPipelineState): void;
+    /**
+     * Send data from this filter to its shader program's uniforms.
+     *
+     * @param {WebGLRenderingContext} gl The GL canvas context used to compile this filter's shader.
+     * @param {Object} uniformLocations A map of string uniform names to WebGLUniformLocation objects
+     */
+    sendUniformData(gl: WebGLRenderingContext, uniformLocations: TWebGLUniformLocationMap): void;
+}
+export {};
+//# sourceMappingURL=BlendColor.d.ts.map

package/dist-extensions/src/filters/BlendColor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlendColor.d.ts","sourceRoot":"","sources":["../../../src/filters/BlendColor.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,KAAK,EAAE,gBAAgB,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAI7E,MAAM,MAAM,UAAU,GAClB,UAAU,GACV,KAAK,GACL,YAAY,GACZ,QAAQ,GACR,UAAU,GACV,QAAQ,GACR,SAAS,GACT,SAAS,GACT,WAAW,GACX,MAAM,CAAC;AAEX,KAAK,kBAAkB,GAAG;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,UAAU,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,kBAIrC,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,UAAW,SAAQ,UAAU,CAAC,YAAY,EAAE,kBAAkB,CAAC;IAC1E;;;;;QAKI;IACI,KAAK,EAAE,kBAAkB,CAAC,OAAO,CAAC,CAAC;IAE3C;;;;;QAKI;IACI,IAAI,EAAE,kBAAkB,CAAC,MAAM,CAAC,CAAC;IACzC;;;;QAII;IACI,KAAK,EAAE,kBAAkB,CAAC,OAAO,CAAC,CAAC;IAE3C,MAAM,CAAC,QAAQ,qBAA2B;IAE1C,MAAM,CAAC,IAAI,SAAgB;IAE3B,MAAM,CAAC,gBAAgB,WAAc;IAErC,WAAW;IAIX,SAAS,CAAC,iBAAiB,IAAI,MAAM;IAgBrC;;;;;OAKG;IACH,SAAS,CAAC,EAAE,SAAS,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,gBAAgB;IA2EnD;;;;;OAKG;IACH,eAAe,CACb,EAAE,EAAE,qBAAqB,EACzB,gBAAgB,EAAE,wBAAwB;CAS7C"}

package/dist-extensions/src/filters/BlendImage.d.ts

@@ -0,0 +1,99 @@
+import { FabricImage } from '../shapes/Image';
+import { BaseFilter } from './BaseFilter';
+import type { T2DPipelineState, TWebGLPipelineState, TWebGLUniformLocationMap } from './typedefs';
+import type { WebGLFilterBackend } from './WebGLFilterBackend';
+export type TBlendImageMode = 'multiply' | 'mask';
+type BlendImageOwnProps = {
+    mode: TBlendImageMode;
+    alpha: number;
+};
+export declare const blendImageDefaultValues: BlendImageOwnProps;
+/**
+ * Image Blend filter class
+ * @example
+ * const filter = new filters.BlendColor({
+ *  color: '#000',
+ *  mode: 'multiply'
+ * });
+ *
+ * const filter = new BlendImage({
+ *  image: fabricImageObject,
+ *  mode: 'multiply'
+ * });
+ * object.filters.push(filter);
+ * object.applyFilters();
+ * canvas.renderAll();
+ */
+export declare class BlendImage extends BaseFilter<'BlendImage', BlendImageOwnProps> {
+    /**
+     * Image to make the blend operation with.
+     **/
+    image: FabricImage;
+    /**
+     * Blend mode for the filter: either 'multiply' or 'mask'. 'multiply' will
+     * multiply the values of each channel (R, G, B, and A) of the filter image by
+     * their corresponding values in the base image. 'mask' will only look at the
+     * alpha channel of the filter image, and apply those values to the base
+     * image's alpha channel.
+     * @type String
+     * @default
+     **/
+    mode: BlendImageOwnProps['mode'];
+    /**
+     * alpha value. represent the strength of the blend image operation.
+     * not implemented.
+     **/
+    alpha: BlendImageOwnProps['alpha'];
+    static type: string;
+    static defaults: BlendImageOwnProps;
+    static uniformLocations: string[];
+    getCacheKey(): string;
+    getFragmentSource(): string;
+    getVertexSource(): string;
+    applyToWebGL(options: TWebGLPipelineState): void;
+    createTexture(backend: WebGLFilterBackend, image: FabricImage): WebGLTexture | null;
+    /**
+     * Calculate a transformMatrix to adapt the image to blend over
+     * @param {Object} options
+     * @param {WebGLRenderingContext} options.context The GL context used for rendering.
+     * @param {Object} options.programCache A map of compiled shader programs, keyed by filter type.
+     */
+    calculateMatrix(): number[];
+    /**
+     * Apply the Blend operation to a Uint8ClampedArray representing the pixels of an image.
+     *
+     * @param {Object} options
+     * @param {ImageData} options.imageData The Uint8ClampedArray to be filtered.
+     */
+    applyTo2d({ imageData: { data, width, height }, filterBackend: { resources }, }: T2DPipelineState): void;
+    /**
+     * Send data from this filter to its shader program's uniforms.
+     *
+     * @param {WebGLRenderingContext} gl The GL canvas context used to compile this filter's shader.
+     * @param {Object} uniformLocations A map of string uniform names to WebGLUniformLocation objects
+     */
+    sendUniformData(gl: WebGLRenderingContext, uniformLocations: TWebGLUniformLocationMap): void;
+    /**
+     * Returns object representation of an instance
+     * TODO: Handle the possibility of missing image better.
+     * As of now a BlendImage filter without image can't be used with fromObject
+     * @return {Object} Object representation of an instance
+     */
+    toObject(): {
+        type: 'BlendImage';
+        image: ReturnType<FabricImage['toObject']>;
+    } & BlendImageOwnProps;
+    /**
+     * Create filter instance from an object representation
+     * @static
+     * @param {object} object Object to create an instance from
+     * @param {object} [options]
+     * @param {AbortSignal} [options.signal] handle aborting image loading, see https://developer.mozilla.org/en-US/docs/Web/API/AbortController/signal
+     * @returns {Promise<BlendImage>}
+     */
+    static fromObject({ type, image, ...filterOptions }: Record<string, any>, options: {
+        signal: AbortSignal;
+    }): Promise<BaseFilter<'BlendImage', BlendImageOwnProps>>;
+}
+export {};
+//# sourceMappingURL=BlendImage.d.ts.map

package/dist-extensions/src/filters/BlendImage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlendImage.d.ts","sourceRoot":"","sources":["../../../src/filters/BlendImage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAE9C,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,KAAK,EACV,gBAAgB,EAChB,mBAAmB,EACnB,wBAAwB,EACzB,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAI/D,MAAM,MAAM,eAAe,GAAG,UAAU,GAAG,MAAM,CAAC;AAElD,KAAK,kBAAkB,GAAG;IACxB,IAAI,EAAE,eAAe,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,kBAGrC,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,UAAW,SAAQ,UAAU,CAAC,YAAY,EAAE,kBAAkB,CAAC;IAC1E;;QAEI;IACI,KAAK,EAAE,WAAW,CAAC;IAE3B;;;;;;;;QAQI;IACI,IAAI,EAAE,kBAAkB,CAAC,MAAM,CAAC,CAAC;IAEzC;;;QAGI;IACI,KAAK,EAAE,kBAAkB,CAAC,OAAO,CAAC,CAAC;IAE3C,MAAM,CAAC,IAAI,SAAgB;IAE3B,MAAM,CAAC,QAAQ,qBAA2B;IAE1C,MAAM,CAAC,gBAAgB,WAAkC;IAEzD,WAAW;IAIX,iBAAiB,IAAI,MAAM;IAI3B,eAAe,IAAI,MAAM;IAIzB,YAAY,CAAC,OAAO,EAAE,mBAAmB;IAQzC,aAAa,CAAC,OAAO,EAAE,kBAAkB,EAAE,KAAK,EAAE,WAAW;IAI7D;;;;;OAKG;IACH,eAAe;IAgBf;;;;;OAKG;IACH,SAAS,CAAC,EACR,SAAS,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,EAClC,aAAa,EAAE,EAAE,SAAS,EAAE,GAC7B,EAAE,gBAAgB;IAgDnB;;;;;OAKG;IACH,eAAe,CACb,EAAE,EAAE,qBAAqB,EACzB,gBAAgB,EAAE,wBAAwB;IAO5C;;;;;OAKG;IACH,QAAQ,IAAI;QACV,IAAI,EAAE,YAAY,CAAC;QACnB,KAAK,EAAE,UAAU,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC,CAAC;KAC5C,GAAG,kBAAkB;IAOtB;;;;;;;OAOG;WACU,UAAU,CACrB,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,aAAa,EAAE,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACtD,OAAO,EAAE;QAAE,MAAM,EAAE,WAAW,CAAA;KAAE,GAC/B,OAAO,CAAC,UAAU,CAAC,YAAY,EAAE,kBAAkB,CAAC,CAAC;CAMzD"}

package/dist-extensions/src/filters/Blur.d.ts

@@ -0,0 +1,50 @@
+import { BaseFilter } from './BaseFilter';
+import type { TWebGLPipelineState, T2DPipelineState, TWebGLUniformLocationMap } from './typedefs';
+type BlurOwnProps = {
+    blur: number;
+};
+export declare const blurDefaultValues: BlurOwnProps;
+/**
+ * Blur filter class
+ * @example
+ * const filter = new Blur({
+ *   blur: 0.5
+ * });
+ * object.filters.push(filter);
+ * object.applyFilters();
+ * canvas.renderAll();
+ */
+export declare class Blur extends BaseFilter<'Blur', BlurOwnProps> {
+    /**
+     * blur value, in percentage of image dimensions.
+     * specific to keep the image blur constant at different resolutions
+     * range between 0 and 1.
+     * @type Number
+     * @default
+     */
+    blur: BlurOwnProps['blur'];
+    horizontal: boolean;
+    aspectRatio: number;
+    static type: string;
+    static defaults: BlurOwnProps;
+    static uniformLocations: string[];
+    getFragmentSource(): string;
+    applyTo(options: TWebGLPipelineState | T2DPipelineState): void;
+    applyTo2d(options: T2DPipelineState): void;
+    simpleBlur({ ctx, imageData, filterBackend: { resources }, }: T2DPipelineState): ImageData;
+    /**
+     * Send data from this filter to its shader program's uniforms.
+     *
+     * @param {WebGLRenderingContext} gl The GL canvas context used to compile this filter's shader.
+     * @param {Object} uniformLocations A map of string uniform names to WebGLUniformLocation objects
+     */
+    sendUniformData(gl: WebGLRenderingContext, uniformLocations: TWebGLUniformLocationMap): void;
+    isNeutralState(): boolean;
+    /**
+     * choose right value of image percentage to blur with
+     * @returns {Array} a numeric array with delta values
+     */
+    chooseRightDelta(): number[];
+}
+export {};
+//# sourceMappingURL=Blur.d.ts.map

package/dist-extensions/src/filters/Blur.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Blur.d.ts","sourceRoot":"","sources":["../../../src/filters/Blur.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,KAAK,EACV,mBAAmB,EACnB,gBAAgB,EAChB,wBAAwB,EACzB,MAAM,YAAY,CAAC;AAKpB,KAAK,YAAY,GAAG;IAClB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,YAE/B,CAAC;AAEF;;;;;;;;;GASG;AACH,qBAAa,IAAK,SAAQ,UAAU,CAAC,MAAM,EAAE,YAAY,CAAC;IACxD;;;;;;OAMG;IACK,IAAI,EAAE,YAAY,CAAC,MAAM,CAAC,CAAC;IAE3B,UAAU,EAAE,OAAO,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IAE5B,MAAM,CAAC,IAAI,SAAU;IAErB,MAAM,CAAC,QAAQ,eAAqB;IAEpC,MAAM,CAAC,gBAAgB,WAAc;IAErC,iBAAiB,IAAI,MAAM;IAI3B,OAAO,CAAC,OAAO,EAAE,mBAAmB,GAAG,gBAAgB;IAkBvD,SAAS,CAAC,OAAO,EAAE,gBAAgB;IAInC,UAAU,CAAC,EACT,GAAG,EACH,SAAS,EACT,aAAa,EAAE,EAAE,SAAS,EAAE,GAC7B,EAAE,gBAAgB;IAiDnB;;;;;OAKG;IACH,eAAe,CACb,EAAE,EAAE,qBAAqB,EACzB,gBAAgB,EAAE,wBAAwB;IAM5C,cAAc;IAId;;;OAGG;IACH,gBAAgB;CAsBjB"}