@nasser-sw/fabric 7.0.0-beta1

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

@@ -0,0 +1,49 @@
+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
+     */
+    blur: BlurOwnProps['blur'];
+    horizontal: boolean;
+    aspectRatio: number;
+    static type: string;
+    static defaults: BlurOwnProps;
+    static uniformLocations: string[];
+    getFragmentSource(): string;
+    applyTo(options: TWebGLPipelineState | T2DPipelineState): void;
+    applyTo2d({ imageData: { data, width, height } }: 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;
+    isNeutralState(): boolean;
+    getBlurValue(): number;
+    /**
+     * 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":"AAAA,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;;;;;OAKG;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,EAAE,SAAS,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,gBAAgB;IA2FlE;;;;;OAKG;IACH,eAAe,CACb,EAAE,EAAE,qBAAqB,EACzB,gBAAgB,EAAE,wBAAwB;IAM5C,cAAc;IAId,YAAY,IAAI,MAAM;IAiBtB;;;OAGG;IACH,gBAAgB;CAIjB"}

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

@@ -0,0 +1,45 @@
+import { BaseFilter } from './BaseFilter';
+import type { T2DPipelineState, TWebGLUniformLocationMap } from './typedefs';
+type BrightnessOwnProps = {
+    brightness: number;
+};
+export declare const brightnessDefaultValues: BrightnessOwnProps;
+/**
+ * Brightness filter class
+ * @example
+ * const filter = new Brightness({
+ *   brightness: 0.05
+ * });
+ * object.filters.push(filter);
+ * object.applyFilters();
+ */
+export declare class Brightness extends BaseFilter<'Brightness', BrightnessOwnProps> {
+    /**
+     * Brightness value, from -1 to 1.
+     * translated to -255 to 255 for 2d
+     * 0.0039215686 is the part of 1 that get translated to 1 in 2d
+     * @param {Number} brightness
+     */
+    brightness: BrightnessOwnProps['brightness'];
+    static type: string;
+    static defaults: BrightnessOwnProps;
+    static uniformLocations: string[];
+    getFragmentSource(): string;
+    /**
+     * Apply the Brightness 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;
+    isNeutralState(): boolean;
+    /**
+     * 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=Brightness.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Brightness.d.ts","sourceRoot":"","sources":["../../../src/filters/Brightness.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,KAAK,EAAE,gBAAgB,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAI7E,KAAK,kBAAkB,GAAG;IACxB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,kBAErC,CAAC;AAEF;;;;;;;;GAQG;AACH,qBAAa,UAAW,SAAQ,UAAU,CAAC,YAAY,EAAE,kBAAkB,CAAC;IAC1E;;;;;OAKG;IACK,UAAU,EAAE,kBAAkB,CAAC,YAAY,CAAC,CAAC;IAErD,MAAM,CAAC,IAAI,SAAgB;IAE3B,MAAM,CAAC,QAAQ,qBAA2B;IAE1C,MAAM,CAAC,gBAAgB,WAAmB;IAE1C,iBAAiB;IAIjB;;;;;OAKG;IACH,SAAS,CAAC,EAAE,SAAS,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,gBAAgB;IASnD,cAAc;IAId;;;;;OAKG;IACH,eAAe,CACb,EAAE,EAAE,qBAAqB,EACzB,gBAAgB,EAAE,wBAAwB;CAI7C"}

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

@@ -0,0 +1,27 @@
+/**
+ * Canvas 2D filter backend.
+ */
+import type { BaseFilter } from './BaseFilter';
+import type { T2DPipelineState, TPipelineResources } from './typedefs';
+export declare class Canvas2dFilterBackend {
+    /**
+     * Experimental. This object is a sort of repository of help layers used to avoid
+     * of recreating them during frequent filtering. If you are previewing a filter with
+     * a slider you probably do not want to create help layers every filter step.
+     * in this object there will be appended some canvases, created once, resized sometimes
+     * cleared never. Clearing is left to the developer.
+     **/
+    resources: TPipelineResources;
+    /**
+     * Apply a set of filters against a source image and draw the filtered output
+     * to the provided destination canvas.
+     *
+     * @param {EnhancedFilter} filters The filter to apply.
+     * @param {HTMLImageElement|HTMLCanvasElement} sourceElement The source to be filtered.
+     * @param {Number} sourceWidth The width of the source input.
+     * @param {Number} sourceHeight The height of the source input.
+     * @param {HTMLCanvasElement} targetCanvas The destination for filtered output to be drawn.
+     */
+    applyFilters(filters: BaseFilter<string, Record<string, any>>[], sourceElement: CanvasImageSource, sourceWidth: number, sourceHeight: number, targetCanvas: HTMLCanvasElement): T2DPipelineState | void;
+}
+//# sourceMappingURL=Canvas2dFilterBackend.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Canvas2dFilterBackend.d.ts","sourceRoot":"","sources":["../../../src/filters/Canvas2dFilterBackend.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,KAAK,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAEvE,qBAAa,qBAAqB;IAChC;;;;;;QAMI;IACJ,SAAS,EAAE,kBAAkB,CAAM;IAEnC;;;;;;;;;OASG;IACH,YAAY,CACV,OAAO,EAAE,UAAU,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,EAAE,EAClD,aAAa,EAAE,iBAAiB,EAChC,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,iBAAiB,GAC9B,gBAAgB,GAAG,IAAI;CAmC3B"}

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

@@ -0,0 +1,62 @@
+import { BaseFilter } from './BaseFilter';
+import type { T2DPipelineState, TMatColorMatrix, TWebGLUniformLocationMap } from './typedefs';
+export type ColorMatrixOwnProps = {
+    matrix: TMatColorMatrix;
+    colorsOnly: boolean;
+};
+export declare const colorMatrixDefaultValues: ColorMatrixOwnProps;
+/**
+   * Color Matrix filter class
+   * @see {@link http://fabricjs.com/image-filters|ImageFilters demo}
+   * @see {@link http://phoboslab.org/log/2013/11/fast-image-filters-with-webgl demo}
+   * @example <caption>Kodachrome filter</caption>
+   * const filter = new ColorMatrix({
+   *  matrix: [
+       1.1285582396593525, -0.3967382283601348, -0.03992559172921793, 0, 63.72958762196502,
+       -0.16404339962244616, 1.0835251566291304, -0.05498805115633132, 0, 24.732407896706203,
+       -0.16786010706155763, -0.5603416277695248, 1.6014850761964943, 0, 35.62982807460946,
+       0, 0, 0, 1, 0
+      ]
+   * });
+   * object.filters.push(filter);
+   * object.applyFilters();
+   */
+export declare class ColorMatrix<Name extends string = 'ColorMatrix', OwnProps extends object = ColorMatrixOwnProps, SerializedProps extends object = ColorMatrixOwnProps> extends BaseFilter<Name, OwnProps, SerializedProps> {
+    /**
+     * Colormatrix for pixels.
+     * array of 20 floats. Numbers in positions 4, 9, 14, 19 loose meaning
+     * outside the -1, 1 range.
+     * 0.0039215686 is the part of 1 that get translated to 1 in 2d
+     * @param {Array} matrix array of 20 numbers.
+     */
+    matrix: ColorMatrixOwnProps['matrix'];
+    /**
+     * Lock the colormatrix on the color part, skipping alpha, mainly for non webgl scenario
+     * to save some calculation
+     * @type Boolean
+     * @default true
+     */
+    colorsOnly: ColorMatrixOwnProps['colorsOnly'];
+    static type: string;
+    static defaults: ColorMatrixOwnProps;
+    static uniformLocations: string[];
+    getFragmentSource(): string;
+    /**
+     * Apply the ColorMatrix operation to a Uint8Array representing the pixels of an image.
+     *
+     * @param {Object} options
+     * @param {ImageData} options.imageData The Uint8Array to be filtered.
+     */
+    applyTo2d(options: 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;
+    toObject(): {
+        type: Name;
+    } & SerializedProps;
+}
+//# sourceMappingURL=ColorMatrix.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ColorMatrix.d.ts","sourceRoot":"","sources":["../../../src/filters/ColorMatrix.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,KAAK,EACV,gBAAgB,EAChB,eAAe,EACf,wBAAwB,EACzB,MAAM,YAAY,CAAC;AAIpB,MAAM,MAAM,mBAAmB,GAAG;IAChC,MAAM,EAAE,eAAe,CAAC;IACxB,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,mBAGtC,CAAC;AAEF;;;;;;;;;;;;;;;KAeK;AACL,qBAAa,WAAW,CACtB,IAAI,SAAS,MAAM,GAAG,aAAa,EACnC,QAAQ,SAAS,MAAM,GAAG,mBAAmB,EAC7C,eAAe,SAAS,MAAM,GAAG,mBAAmB,CACpD,SAAQ,UAAU,CAAC,IAAI,EAAE,QAAQ,EAAE,eAAe,CAAC;IACnD;;;;;;OAMG;IACK,MAAM,EAAE,mBAAmB,CAAC,QAAQ,CAAC,CAAC;IAE9C;;;;;OAKG;IACK,UAAU,EAAE,mBAAmB,CAAC,YAAY,CAAC,CAAC;IAEtD,MAAM,CAAC,IAAI,SAAiB;IAE5B,MAAM,CAAC,QAAQ,sBAA4B;IAE3C,MAAM,CAAC,gBAAgB,WAAkC;IAEzD,iBAAiB,IAAI,MAAM;IAI3B;;;;;OAKG;IACH,SAAS,CAAC,OAAO,EAAE,gBAAgB;IAyBnC;;;;;OAKG;IACH,eAAe,CACb,EAAE,EAAE,qBAAqB,EACzB,gBAAgB,EAAE,wBAAwB;IA0B5C,QAAQ,IAAI;QAAE,IAAI,EAAE,IAAI,CAAA;KAAE,GAAG,eAAe;CAM7C"}

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

@@ -0,0 +1,15 @@
+import { ColorMatrix } from './ColorMatrix';
+import type { TMatColorMatrix } from './typedefs';
+type FixedFiltersOwnProps = {
+    colorsOnly: boolean;
+};
+export declare function createColorMatrixFilter(key: string, matrix: TMatColorMatrix): typeof ColorMatrix<typeof key, FixedFiltersOwnProps>;
+export declare const Brownie: typeof ColorMatrix<string, FixedFiltersOwnProps>;
+export declare const Vintage: typeof ColorMatrix<string, FixedFiltersOwnProps>;
+export declare const Kodachrome: typeof ColorMatrix<string, FixedFiltersOwnProps>;
+export declare const Technicolor: typeof ColorMatrix<string, FixedFiltersOwnProps>;
+export declare const Polaroid: typeof ColorMatrix<string, FixedFiltersOwnProps>;
+export declare const Sepia: typeof ColorMatrix<string, FixedFiltersOwnProps>;
+export declare const BlackWhite: typeof ColorMatrix<string, FixedFiltersOwnProps>;
+export {};
+//# sourceMappingURL=ColorMatrixFilters.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ColorMatrixFilters.d.ts","sourceRoot":"","sources":["../../../src/filters/ColorMatrixFilters.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD,KAAK,oBAAoB,GAAG;IAC1B,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAEF,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe,GAkBvD,OAAO,WAAW,CAAC,OAAO,GAAG,EAAE,oBAAoB,CAAC,CACxE;AAED,eAAO,MAAM,OAAO,EAHC,OAAO,WAAW,SAAa,oBAAoB,CASvE,CAAC;AAEF,eAAO,MAAM,OAAO,EAXC,OAAO,WAAW,SAAa,oBAAoB,CAiBvE,CAAC;AAEF,eAAO,MAAM,UAAU,EAnBF,OAAO,WAAW,SAAa,oBAAoB,CAyBvE,CAAC;AAEF,eAAO,MAAM,WAAW,EA3BH,OAAO,WAAW,SAAa,oBAAoB,CAiCvE,CAAC;AAEF,eAAO,MAAM,QAAQ,EAnCA,OAAO,WAAW,SAAa,oBAAoB,CAyCvE,CAAC;AAEF,eAAO,MAAM,KAAK,EA3CG,OAAO,WAAW,SAAa,oBAAoB,CAiDvE,CAAC;AAEF,eAAO,MAAM,UAAU,EAnDF,OAAO,WAAW,SAAa,oBAAoB,CAyDvE,CAAC"}

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

@@ -0,0 +1,51 @@
+import { BaseFilter } from './BaseFilter';
+import type { T2DPipelineState, TWebGLPipelineState } from './typedefs';
+type ComposedOwnProps = {
+    subFilters: BaseFilter<string, object, object>[];
+};
+type ComposedSerializedProps = {
+    subFilters: Record<string, unknown>[];
+};
+/**
+ * A container class that knows how to apply a sequence of filters to an input image.
+ */
+export declare class Composed extends BaseFilter<'Composed', ComposedOwnProps, ComposedSerializedProps> {
+    /**
+     * A non sparse array of filters to apply
+     */
+    subFilters: ComposedOwnProps['subFilters'];
+    static type: string;
+    constructor(options?: {
+        subFilters?: BaseFilter<string>[];
+    } & Record<string, any>);
+    /**
+     * Apply this container's filters to the input image provided.
+     *
+     * @param {Object} options
+     * @param {Number} options.passes The number of filters remaining to be applied.
+     */
+    applyTo(options: TWebGLPipelineState | T2DPipelineState): void;
+    /**
+     * Serialize this filter into JSON.
+     * @returns {Object} A JSON representation of this filter.
+     */
+    toObject(): {
+        type: "Composed";
+        subFilters: ({
+            type: string;
+        } & object)[];
+    };
+    isNeutralState(): boolean;
+    /**
+     * Deserialize a JSON definition of a ComposedFilter into a concrete instance.
+     * @param {oject} object Object to create an instance from
+     * @param {object} [options]
+     * @param {AbortSignal} [options.signal] handle aborting `BlendImage` filter loading, see https://developer.mozilla.org/en-US/docs/Web/API/AbortController/signal
+     * @returns {Promise<Composed>}
+     */
+    static fromObject(object: Record<string, any>, options?: {
+        signal: AbortSignal;
+    }): Promise<Composed>;
+}
+export {};
+//# sourceMappingURL=Composed.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Composed.d.ts","sourceRoot":"","sources":["../../../src/filters/Composed.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,KAAK,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAIxE,KAAK,gBAAgB,GAAG;IACtB,UAAU,EAAE,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC;CAClD,CAAC;AAEF,KAAK,uBAAuB,GAAG;IAC7B,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;CACvC,CAAC;AAEF;;GAEG;AACH,qBAAa,QAAS,SAAQ,UAAU,CACtC,UAAU,EACV,gBAAgB,EAChB,uBAAuB,CACxB;IACC;;OAEG;IACK,UAAU,EAAE,gBAAgB,CAAC,YAAY,CAAC,CAAC;IAEnD,MAAM,CAAC,IAAI,SAAc;gBAGvB,OAAO,GAAE;QAAE,UAAU,CAAC,EAAE,UAAU,CAAC,MAAM,CAAC,EAAE,CAAA;KAAE,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAM;IAM3E;;;;;OAKG;IACH,OAAO,CAAC,OAAO,EAAE,mBAAmB,GAAG,gBAAgB;IASvD;;;OAGG;IACH,QAAQ;;;;;;IAOR,cAAc;IAId;;;;;;OAMG;IACH,MAAM,CAAC,UAAU,CACf,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC3B,OAAO,CAAC,EAAE;QAAE,MAAM,EAAE,WAAW,CAAA;KAAE,GAChC,OAAO,CAAC,QAAQ,CAAC;CASrB"}

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

@@ -0,0 +1,44 @@
+import { BaseFilter } from './BaseFilter';
+import type { T2DPipelineState, TWebGLUniformLocationMap } from './typedefs';
+type ContrastOwnProps = {
+    contrast: number;
+};
+export declare const contrastDefaultValues: ContrastOwnProps;
+/**
+ * Contrast filter class
+ * @example
+ * const filter = new Contrast({
+ *   contrast: 0.25
+ * });
+ * object.filters.push(filter);
+ * object.applyFilters();
+ */
+export declare class Contrast extends BaseFilter<'Contrast', ContrastOwnProps> {
+    /**
+     * contrast value, range from -1 to 1.
+     * @param {Number} contrast
+     * @default 0
+     */
+    contrast: ContrastOwnProps['contrast'];
+    static type: string;
+    static defaults: ContrastOwnProps;
+    static uniformLocations: string[];
+    getFragmentSource(): string;
+    isNeutralState(): boolean;
+    /**
+     * Apply the Contrast operation to a Uint8Array representing the pixels of an image.
+     *
+     * @param {Object} options
+     * @param {ImageData} options.imageData The Uint8Array 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=Contrast.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Contrast.d.ts","sourceRoot":"","sources":["../../../src/filters/Contrast.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,KAAK,EAAE,gBAAgB,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAI7E,KAAK,gBAAgB,GAAG;IACtB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,gBAEnC,CAAC;AAEF;;;;;;;;GAQG;AACH,qBAAa,QAAS,SAAQ,UAAU,CAAC,UAAU,EAAE,gBAAgB,CAAC;IACpE;;;;OAIG;IACK,QAAQ,EAAE,gBAAgB,CAAC,UAAU,CAAC,CAAC;IAE/C,MAAM,CAAC,IAAI,SAAc;IAEzB,MAAM,CAAC,QAAQ,mBAAyB;IAExC,MAAM,CAAC,gBAAgB,WAAiB;IAExC,iBAAiB;IAIjB,cAAc;IAId;;;;;OAKG;IACH,SAAS,CAAC,EAAE,SAAS,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,gBAAgB;IAWnD;;;;;OAKG;IACH,eAAe,CACb,EAAE,EAAE,qBAAqB,EACzB,gBAAgB,EAAE,wBAAwB;CAI7C"}

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

@@ -0,0 +1,81 @@
+import { BaseFilter } from './BaseFilter';
+import type { T2DPipelineState, TWebGLUniformLocationMap } from './typedefs';
+import { fragmentSource } from './shaders/convolute';
+export type ConvoluteOwnProps = {
+    opaque: boolean;
+    matrix: number[];
+};
+export declare const convoluteDefaultValues: ConvoluteOwnProps;
+/**
+ * Adapted from <a href="http://www.html5rocks.com/en/tutorials/canvas/imagefilters/">html5rocks article</a>
+ * @example <caption>Sharpen filter</caption>
+ * const filter = new Convolute({
+ *   matrix: [ 0, -1,  0,
+ *            -1,  5, -1,
+ *             0, -1,  0 ]
+ * });
+ * object.filters.push(filter);
+ * object.applyFilters();
+ * canvas.renderAll();
+ * @example <caption>Blur filter</caption>
+ * const filter = new Convolute({
+ *   matrix: [ 1/9, 1/9, 1/9,
+ *             1/9, 1/9, 1/9,
+ *             1/9, 1/9, 1/9 ]
+ * });
+ * object.filters.push(filter);
+ * object.applyFilters();
+ * canvas.renderAll();
+ * @example <caption>Emboss filter</caption>
+ * const filter = new Convolute({
+ *   matrix: [ 1,   1,  1,
+ *             1, 0.7, -1,
+ *            -1,  -1, -1 ]
+ * });
+ * object.filters.push(filter);
+ * object.applyFilters();
+ * canvas.renderAll();
+ * @example <caption>Emboss filter with opaqueness</caption>
+ * const filter = new Convolute({
+ *   opaque: true,
+ *   matrix: [ 1,   1,  1,
+ *             1, 0.7, -1,
+ *            -1,  -1, -1 ]
+ * });
+ * object.filters.push(filter);
+ * object.applyFilters();
+ * canvas.renderAll();
+ */
+export declare class Convolute extends BaseFilter<'Convolute', ConvoluteOwnProps> {
+    opaque: ConvoluteOwnProps['opaque'];
+    matrix: ConvoluteOwnProps['matrix'];
+    static type: string;
+    static defaults: ConvoluteOwnProps;
+    static uniformLocations: string[];
+    getCacheKey(): keyof typeof fragmentSource;
+    getFragmentSource(): string;
+    /**
+     * Apply the Brightness operation to a Uint8ClampedArray representing the pixels of an image.
+     *
+     * @param {Object} options
+     * @param {ImageData} options.imageData The Uint8ClampedArray to be filtered.
+     */
+    applyTo2d(options: 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
+     * @return {Object} Object representation of an instance
+     */
+    toObject(): {
+        opaque: boolean;
+        matrix: number[];
+        type: "Convolute";
+    };
+}
+//# sourceMappingURL=Convolute.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Convolute.d.ts","sourceRoot":"","sources":["../../../src/filters/Convolute.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,KAAK,EAAE,gBAAgB,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAE7E,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAErD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,iBAGpC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,qBAAa,SAAU,SAAQ,UAAU,CAAC,WAAW,EAAE,iBAAiB,CAAC;IAI/D,MAAM,EAAE,iBAAiB,CAAC,QAAQ,CAAC,CAAC;IAKpC,MAAM,EAAE,iBAAiB,CAAC,QAAQ,CAAC,CAAC;IAE5C,MAAM,CAAC,IAAI,SAAe;IAE1B,MAAM,CAAC,QAAQ,oBAA0B;IAEzC,MAAM,CAAC,gBAAgB,WAAgD;IAEvE,WAAW,IAGH,MAAM,OAAO,cAAc;IAGnC,iBAAiB;IAIjB;;;;;OAKG;IACH,SAAS,CAAC,OAAO,EAAE,gBAAgB;IA2DnC;;;;;OAKG;IACH,eAAe,CACb,EAAE,EAAE,qBAAqB,EACzB,gBAAgB,EAAE,wBAAwB;IAK5C;;;OAGG;IACH,QAAQ;;;;;CAOT"}

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

@@ -0,0 +1,15 @@
+import { Canvas2dFilterBackend } from './Canvas2dFilterBackend';
+import { WebGLFilterBackend } from './WebGLFilterBackend';
+export type FilterBackend = WebGLFilterBackend | Canvas2dFilterBackend;
+/**
+ * Verifies if it is possible to initialize webgl or fallback on a canvas2d filtering backend
+ */
+export declare function initFilterBackend(): FilterBackend;
+/**
+ * Get the current fabricJS filter backend  or initialize one if not available yet
+ * @param [strict] pass `true` to create the backend if it wasn't created yet (default behavior),
+ * pass `false` to get the backend ref without mutating it
+ */
+export declare function getFilterBackend(strict?: boolean): FilterBackend;
+export declare function setFilterBackend(backend: FilterBackend): void;
+//# sourceMappingURL=FilterBackend.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FilterBackend.d.ts","sourceRoot":"","sources":["../../../src/filters/FilterBackend.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE1D,MAAM,MAAM,aAAa,GAAG,kBAAkB,GAAG,qBAAqB,CAAC;AAIvE;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,aAAa,CAQjD;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,UAAO,GAAG,aAAa,CAK7D;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,aAAa,QAEtD"}

package/dist-extensions/src/filters/GLProbes/GLProbe.d.ts

@@ -0,0 +1,7 @@
+export type GLPrecision = 'lowp' | 'mediump' | 'highp';
+export declare abstract class GLProbe {
+    GLPrecision: GLPrecision | undefined;
+    abstract queryWebGL(canvas: HTMLCanvasElement): void;
+    abstract isSupported(textureSize: number): boolean;
+}
+//# sourceMappingURL=GLProbe.d.ts.map

package/dist-extensions/src/filters/GLProbes/GLProbe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GLProbe.d.ts","sourceRoot":"","sources":["../../../../src/filters/GLProbes/GLProbe.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC;AAEvD,8BAAsB,OAAO;IACnB,WAAW,EAAE,WAAW,GAAG,SAAS,CAAC;IAC7C,QAAQ,CAAC,UAAU,CAAC,MAAM,EAAE,iBAAiB,GAAG,IAAI;IACpD,QAAQ,CAAC,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO;CACnD"}

package/dist-extensions/src/filters/GLProbes/WebGLProbe.d.ts

@@ -0,0 +1,20 @@
+import { GLProbe } from './GLProbe';
+/**
+ * Lazy initialize WebGL constants
+ */
+export declare class WebGLProbe extends GLProbe {
+    maxTextureSize?: number;
+    /**
+     * Tests if webgl supports certain precision
+     * @param {WebGL} Canvas WebGL context to test on
+     * @param {GLPrecision} Precision to test can be any of following
+     * @returns {Boolean} Whether the user's browser WebGL supports given precision.
+     */
+    private testPrecision;
+    /**
+     * query browser for WebGL
+     */
+    queryWebGL(canvas: HTMLCanvasElement): void;
+    isSupported(textureSize: number): boolean;
+}
+//# sourceMappingURL=WebGLProbe.d.ts.map

package/dist-extensions/src/filters/GLProbes/WebGLProbe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebGLProbe.d.ts","sourceRoot":"","sources":["../../../../src/filters/GLProbes/WebGLProbe.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAGpC;;GAEG;AACH,qBAAa,UAAW,SAAQ,OAAO;IAC7B,cAAc,CAAC,EAAE,MAAM,CAAC;IAEhC;;;;;OAKG;IACH,OAAO,CAAC,aAAa;IAcrB;;OAEG;IACH,UAAU,CAAC,MAAM,EAAE,iBAAiB;IAYpC,WAAW,CAAC,WAAW,EAAE,MAAM;CAGhC"}

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

@@ -0,0 +1,57 @@
+import { BaseFilter } from './BaseFilter';
+import type { T2DPipelineState, TWebGLUniformLocationMap } from './typedefs';
+declare const GAMMA: "Gamma";
+export type GammaInput = [number, number, number];
+export type GammaOwnProps = {
+    gamma: GammaInput;
+};
+export declare const gammaDefaultValues: GammaOwnProps;
+/**
+ * Gamma filter class
+ * @example
+ * const filter = new Gamma({
+ *   gamma: [1, 0.5, 2.1]
+ * });
+ * object.filters.push(filter);
+ * object.applyFilters();
+ */
+export declare class Gamma extends BaseFilter<typeof GAMMA, GammaOwnProps> {
+    /**
+     * Gamma array value, from 0.01 to 2.2.
+     * @param {Array} gamma
+     */
+    gamma: GammaOwnProps['gamma'];
+    rgbValues?: {
+        r: Uint8Array;
+        g: Uint8Array;
+        b: Uint8Array;
+    };
+    static type: "Gamma";
+    static defaults: GammaOwnProps;
+    static uniformLocations: string[];
+    getFragmentSource(): string;
+    constructor(options?: {
+        gamma?: GammaInput;
+    });
+    /**
+     * Apply the Gamma operation to a Uint8Array representing the pixels of an image.
+     *
+     * @param {Object} options
+     * @param {ImageData} options.imageData The Uint8Array 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;
+    isNeutralState(): boolean;
+    toObject(): {
+        type: typeof GAMMA;
+        gamma: GammaInput;
+    };
+}
+export {};
+//# sourceMappingURL=Gamma.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Gamma.d.ts","sourceRoot":"","sources":["../../../src/filters/Gamma.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAG1C,OAAO,KAAK,EAAE,gBAAgB,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAE7E,QAAA,MAAM,KAAK,EAAG,OAAgB,CAAC;AAE/B,MAAM,MAAM,UAAU,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAElD,MAAM,MAAM,aAAa,GAAG;IAC1B,KAAK,EAAE,UAAU,CAAC;CACnB,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,aAEhC,CAAC;AAEF;;;;;;;;GAQG;AACH,qBAAa,KAAM,SAAQ,UAAU,CAAC,OAAO,KAAK,EAAE,aAAa,CAAC;IAChE;;;OAGG;IACK,KAAK,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;IAC9B,SAAS,CAAC,EAAE;QAClB,CAAC,EAAE,UAAU,CAAC;QACd,CAAC,EAAE,UAAU,CAAC;QACd,CAAC,EAAE,UAAU,CAAC;KACf,CAAC;IAEF,MAAM,CAAC,IAAI,UAAS;IAEpB,MAAM,CAAC,QAAQ,gBAAsB;IAErC,MAAM,CAAC,gBAAgB,WAAc;IAErC,iBAAiB;gBAIL,OAAO,GAAE;QAAE,KAAK,CAAC,EAAE,UAAU,CAAA;KAAO;IAShD;;;;;OAKG;IACH,SAAS,CAAC,EAAE,SAAS,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,gBAAgB;IA6BnD;;;;;OAKG;IACH,eAAe,CACb,EAAE,EAAE,qBAAqB,EACzB,gBAAgB,EAAE,wBAAwB;IAK5C,cAAc;IAKd,QAAQ,IAAI;QAAE,IAAI,EAAE,OAAO,KAAK,CAAC;QAAC,KAAK,EAAE,UAAU,CAAA;KAAE;CAMtD"}

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

@@ -0,0 +1,44 @@
+import { BaseFilter } from './BaseFilter';
+import type { T2DPipelineState, TWebGLUniformLocationMap } from './typedefs';
+export type TGrayscaleMode = 'average' | 'lightness' | 'luminosity';
+type GrayscaleOwnProps = {
+    mode: TGrayscaleMode;
+};
+export declare const grayscaleDefaultValues: GrayscaleOwnProps;
+/**
+ * Grayscale image filter class
+ * @example
+ * const filter = new Grayscale();
+ * object.filters.push(filter);
+ * object.applyFilters();
+ */
+export declare class Grayscale extends BaseFilter<'Grayscale', GrayscaleOwnProps> {
+    mode: TGrayscaleMode;
+    static type: string;
+    static defaults: GrayscaleOwnProps;
+    static uniformLocations: string[];
+    /**
+     * Apply the Grayscale operation to a Uint8Array representing the pixels of an image.
+     *
+     * @param {Object} options
+     * @param {ImageData} options.imageData The Uint8Array to be filtered.
+     */
+    applyTo2d({ imageData: { data } }: T2DPipelineState): void;
+    getCacheKey(): string;
+    getFragmentSource(): string;
+    /**
+     * 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;
+    /**
+     * Grayscale filter isNeutralState implementation
+     * The filter is never neutral
+     * on the image
+     **/
+    isNeutralState(): boolean;
+}
+export {};
+//# sourceMappingURL=Grayscale.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Grayscale.d.ts","sourceRoot":"","sources":["../../../src/filters/Grayscale.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,KAAK,EAAE,gBAAgB,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAI7E,MAAM,MAAM,cAAc,GAAG,SAAS,GAAG,WAAW,GAAG,YAAY,CAAC;AAEpE,KAAK,iBAAiB,GAAG;IACvB,IAAI,EAAE,cAAc,CAAC;CACtB,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,iBAEpC,CAAC;AAEF;;;;;;GAMG;AACH,qBAAa,SAAU,SAAQ,UAAU,CAAC,WAAW,EAAE,iBAAiB,CAAC;IAC/D,IAAI,EAAE,cAAc,CAAC;IAE7B,MAAM,CAAC,IAAI,SAAe;IAE1B,MAAM,CAAC,QAAQ,oBAA0B;IAEzC,MAAM,CAAC,gBAAgB,WAAa;IAEpC;;;;;OAKG;IACH,SAAS,CAAC,EAAE,SAAS,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,gBAAgB;IAqBnD,WAAW;IAIX,iBAAiB;IAIjB;;;;;OAKG;IACH,eAAe,CACb,EAAE,EAAE,qBAAqB,EACzB,gBAAgB,EAAE,wBAAwB;IAM5C;;;;QAII;IACJ,cAAc;CAGf"}

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

@@ -0,0 +1,34 @@
+import { ColorMatrix, type ColorMatrixOwnProps } from './ColorMatrix';
+import type { TWebGLPipelineState, T2DPipelineState } from './typedefs';
+export type HueRotationOwnProps = ColorMatrixOwnProps & {
+    rotation: number;
+};
+export type HueRotationSerializedProps = {
+    rotation: number;
+};
+export declare const hueRotationDefaultValues: HueRotationOwnProps;
+/**
+ * HueRotation filter class
+ * @example
+ * const filter = new HueRotation({
+ *   rotation: -0.5
+ * });
+ * object.filters.push(filter);
+ * object.applyFilters();
+ */
+export declare class HueRotation extends ColorMatrix<'HueRotation', HueRotationOwnProps, HueRotationSerializedProps> {
+    /**
+     * HueRotation value, from -1 to 1.
+     */
+    rotation: HueRotationOwnProps['rotation'];
+    static type: string;
+    static defaults: HueRotationOwnProps;
+    calculateMatrix(): void;
+    isNeutralState(): boolean;
+    applyTo(options: TWebGLPipelineState | T2DPipelineState): void;
+    toObject(): {
+        type: "HueRotation";
+        rotation: number;
+    };
+}
+//# sourceMappingURL=HueRotation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"HueRotation.d.ts","sourceRoot":"","sources":["../../../src/filters/HueRotation.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,WAAW,EACX,KAAK,mBAAmB,EAEzB,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAGxE,MAAM,MAAM,mBAAmB,GAAG,mBAAmB,GAAG;IACtD,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAAG;IACvC,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,mBAGtC,CAAC;AAEF;;;;;;;;GAQG;AACH,qBAAa,WAAY,SAAQ,WAAW,CAC1C,aAAa,EACb,mBAAmB,EACnB,0BAA0B,CAC3B;IACC;;OAEG;IACK,QAAQ,EAAE,mBAAmB,CAAC,UAAU,CAAC,CAAC;IAElD,MAAM,CAAC,IAAI,SAAiB;IAE5B,MAAM,CAAC,QAAQ,sBAA4B;IAE3C,eAAe;IA+Bf,cAAc;IAId,OAAO,CAAC,OAAO,EAAE,mBAAmB,GAAG,gBAAgB;IAKvD,QAAQ;;;;CAMT"}