fabric 6.2.0 → 6.3.0

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

@@ -0,0 +1,44 @@
+import { BaseFilter } from './BaseFilter';
+import type { T2DPipelineState, TWebGLUniformLocationMap } from './typedefs';
+export type NoiseOwnProps = {
+    noise: number;
+};
+export declare const noiseDefaultValues: NoiseOwnProps;
+/**
+ * Noise filter class
+ * @example
+ * const filter = new Noise({
+ *   noise: 700
+ * });
+ * object.filters.push(filter);
+ * object.applyFilters();
+ * canvas.renderAll();
+ */
+export declare class Noise extends BaseFilter<'Noise', NoiseOwnProps> {
+    /**
+     * Noise value, from
+     * @param {Number} noise
+     * @default
+     */
+    noise: NoiseOwnProps['noise'];
+    static type: string;
+    static defaults: NoiseOwnProps;
+    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;
+    /**
+     * 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;
+}
+//# sourceMappingURL=Noise.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Noise.d.ts","sourceRoot":"","sources":["../../../src/filters/Noise.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,aAAa,GAAG;IAC1B,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,aAEhC,CAAC;AAEF;;;;;;;;;GASG;AACH,qBAAa,KAAM,SAAQ,UAAU,CAAC,OAAO,EAAE,aAAa,CAAC;IAC3D;;;;OAIG;IACK,KAAK,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;IAEtC,MAAM,CAAC,IAAI,SAAW;IAEtB,MAAM,CAAC,QAAQ,gBAAsB;IAErC,MAAM,CAAC,gBAAgB,WAAuB;IAE9C,iBAAiB;IAIjB;;;;;OAKG;IACH,SAAS,CAAC,EAAE,SAAS,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,gBAAgB;IAUnD;;;;;OAKG;IACH,eAAe,CACb,EAAE,EAAE,qBAAqB,EACzB,gBAAgB,EAAE,wBAAwB;IAM5C,cAAc;CAGf"}

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

@@ -0,0 +1,41 @@
+import { BaseFilter } from './BaseFilter';
+import type { T2DPipelineState, TWebGLUniformLocationMap } from './typedefs';
+export type PixelateOwnProps = {
+    blocksize: number;
+};
+export declare const pixelateDefaultValues: PixelateOwnProps;
+/**
+ * Pixelate filter class
+ * @example
+ * const filter = new Pixelate({
+ *   blocksize: 8
+ * });
+ * object.filters.push(filter);
+ * object.applyFilters();
+ */
+export declare class Pixelate extends BaseFilter<'Pixelate', PixelateOwnProps> {
+    blocksize: PixelateOwnProps['blocksize'];
+    static type: string;
+    static defaults: PixelateOwnProps;
+    static uniformLocations: string[];
+    /**
+     * Apply the Pixelate 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 } }: T2DPipelineState): void;
+    /**
+     * Indicate when the filter is not gonna apply changes to the image
+     **/
+    isNeutralState(): boolean;
+    protected 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;
+}
+//# sourceMappingURL=Pixelate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Pixelate.d.ts","sourceRoot":"","sources":["../../../src/filters/Pixelate.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,gBAAgB,GAAG;IAC7B,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,gBAEnC,CAAC;AAEF;;;;;;;;GAQG;AACH,qBAAa,QAAS,SAAQ,UAAU,CAAC,UAAU,EAAE,gBAAgB,CAAC;IAC5D,SAAS,EAAE,gBAAgB,CAAC,WAAW,CAAC,CAAC;IAEjD,MAAM,CAAC,IAAI,SAAc;IAEzB,MAAM,CAAC,QAAQ,mBAAyB;IAExC,MAAM,CAAC,gBAAgB,WAAkB;IAEzC;;;;;OAKG;IACH,SAAS,CAAC,EAAE,SAAS,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,gBAAgB;IAsBlE;;QAEI;IACJ,cAAc;IAId,SAAS,CAAC,iBAAiB,IAAI,MAAM;IAIrC;;;;;OAKG;IACH,eAAe,CACb,EAAE,EAAE,qBAAqB,EACzB,gBAAgB,EAAE,wBAAwB;CAI7C"}

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

@@ -0,0 +1,53 @@
+import { BaseFilter } from './BaseFilter';
+import type { T2DPipelineState, TWebGLUniformLocationMap } from './typedefs';
+export type RemoveColorOwnProps = {
+    color: string;
+    distance: number;
+    useAlpha: boolean;
+};
+export declare const removeColorDefaultValues: RemoveColorOwnProps;
+/**
+ * Remove white filter class
+ * @example
+ * const filter = new RemoveColor({
+ *   threshold: 0.2,
+ * });
+ * object.filters.push(filter);
+ * object.applyFilters();
+ * canvas.renderAll();
+ */
+export declare class RemoveColor extends BaseFilter<'RemoveColor', RemoveColorOwnProps> {
+    /**
+     * Color to remove, in any format understood by {@link Color}.
+     * @param {String} type
+     * @default
+     */
+    color: RemoveColorOwnProps['color'];
+    /**
+     * distance to actual color, as value up or down from each r,g,b
+     * between 0 and 1
+     **/
+    distance: RemoveColorOwnProps['distance'];
+    /**
+     * For color to remove inside distance, use alpha channel for a smoother deletion
+     * NOT IMPLEMENTED YET
+     **/
+    useAlpha: RemoveColorOwnProps['useAlpha'];
+    static type: string;
+    static defaults: RemoveColorOwnProps;
+    static uniformLocations: string[];
+    getFragmentSource(): string;
+    /**
+     * Applies filter to canvas element
+     * @param {Object} canvasEl Canvas element to apply filter to
+     */
+    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;
+}
+//# sourceMappingURL=RemoveColor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"RemoveColor.d.ts","sourceRoot":"","sources":["../../../src/filters/RemoveColor.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,OAAO,KAAK,EAAE,gBAAgB,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAE7E,MAAM,MAAM,mBAAmB,GAAG;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,mBAItC,CAAC;AAEF;;;;;;;;;GASG;AACH,qBAAa,WAAY,SAAQ,UAAU,CACzC,aAAa,EACb,mBAAmB,CACpB;IACC;;;;OAIG;IACK,KAAK,EAAE,mBAAmB,CAAC,OAAO,CAAC,CAAC;IAE5C;;;QAGI;IACI,QAAQ,EAAE,mBAAmB,CAAC,UAAU,CAAC,CAAC;IAElD;;;QAGI;IACI,QAAQ,EAAE,mBAAmB,CAAC,UAAU,CAAC,CAAC;IAElD,MAAM,CAAC,IAAI,SAAiB;IAE5B,MAAM,CAAC,QAAQ,sBAA4B;IAE3C,MAAM,CAAC,gBAAgB,WAAqB;IAE5C,iBAAiB;IAIjB;;;OAGG;IACH,SAAS,CAAC,EAAE,SAAS,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,gBAAgB;IA4BnD;;;;;OAKG;IACH,eAAe,CACb,EAAE,EAAE,qBAAqB,EACzB,gBAAgB,EAAE,wBAAwB;CAmB7C"}

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

@@ -0,0 +1,137 @@
+import { BaseFilter } from './BaseFilter';
+import type { T2DPipelineState, TWebGLPipelineState, TWebGLUniformLocationMap } from './typedefs';
+export type TResizeType = 'bilinear' | 'hermite' | 'sliceHack' | 'lanczos';
+export type ResizeOwnProps = {
+    resizeType: TResizeType;
+    scaleX: number;
+    scaleY: number;
+    lanczosLobes: number;
+};
+export declare const resizeDefaultValues: ResizeOwnProps;
+type ResizeDuring2DResize = Resize & {
+    rcpScaleX: number;
+    rcpScaleY: number;
+};
+type ResizeDuringWEBGLResize = Resize & {
+    rcpScaleX: number;
+    rcpScaleY: number;
+    horizontal: boolean;
+    width: number;
+    height: number;
+    taps: number[];
+    tempScale: number;
+    dH: number;
+    dW: number;
+};
+/**
+ * Resize image filter class
+ * @example
+ * const filter = new Resize();
+ * object.filters.push(filter);
+ * object.applyFilters(canvas.renderAll.bind(canvas));
+ */
+export declare class Resize extends BaseFilter<'Resize', ResizeOwnProps> {
+    /**
+     * Resize type
+     * for webgl resizeType is just lanczos, for canvas2d can be:
+     * bilinear, hermite, sliceHack, lanczos.
+     * @default
+     */
+    resizeType: ResizeOwnProps['resizeType'];
+    /**
+     * Scale factor for resizing, x axis
+     * @param {Number} scaleX
+     * @default
+     */
+    scaleX: ResizeOwnProps['scaleX'];
+    /**
+     * Scale factor for resizing, y axis
+     * @param {Number} scaleY
+     * @default
+     */
+    scaleY: ResizeOwnProps['scaleY'];
+    /**
+     * LanczosLobes parameter for lanczos filter, valid for resizeType lanczos
+     * @param {Number} lanczosLobes
+     * @default
+     */
+    lanczosLobes: ResizeOwnProps['lanczosLobes'];
+    static type: string;
+    static defaults: ResizeOwnProps;
+    static uniformLocations: 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(this: ResizeDuringWEBGLResize, gl: WebGLRenderingContext, uniformLocations: TWebGLUniformLocationMap): void;
+    getFilterWindow(this: ResizeDuringWEBGLResize): number;
+    getCacheKey(this: ResizeDuringWEBGLResize): string;
+    getFragmentSource(this: ResizeDuringWEBGLResize): string;
+    getTaps(this: ResizeDuringWEBGLResize): any[];
+    /**
+     * Generate vertex and shader sources from the necessary steps numbers
+     * @param {Number} filterWindow
+     */
+    generateShader(filterWindow: number): string;
+    applyToForWebgl(this: ResizeDuringWEBGLResize, options: TWebGLPipelineState): void;
+    /**
+     * Apply the resize filter to the image
+     * 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;
+    isNeutralState(): boolean;
+    lanczosCreate(lobes: number): (x: number) => number;
+    applyTo2d(this: ResizeDuring2DResize, options: T2DPipelineState): void;
+    /**
+     * Filter sliceByTwo
+     * @param {Object} canvasEl Canvas element to apply filter to
+     * @param {Number} oW Original Width
+     * @param {Number} oH Original Height
+     * @param {Number} dW Destination Width
+     * @param {Number} dH Destination Height
+     * @returns {ImageData}
+     */
+    sliceByTwo(options: T2DPipelineState, oW: number, oH: number, dW: number, dH: number): ImageData;
+    /**
+     * Filter lanczosResize
+     * @param {Object} canvasEl Canvas element to apply filter to
+     * @param {Number} oW Original Width
+     * @param {Number} oH Original Height
+     * @param {Number} dW Destination Width
+     * @param {Number} dH Destination Height
+     * @returns {ImageData}
+     */
+    lanczosResize(this: ResizeDuring2DResize, options: T2DPipelineState, oW: number, oH: number, dW: number, dH: number): ImageData;
+    /**
+     * bilinearFiltering
+     * @param {Object} canvasEl Canvas element to apply filter to
+     * @param {Number} oW Original Width
+     * @param {Number} oH Original Height
+     * @param {Number} dW Destination Width
+     * @param {Number} dH Destination Height
+     * @returns {ImageData}
+     */
+    bilinearFiltering(this: ResizeDuring2DResize, options: T2DPipelineState, oW: number, oH: number, dW: number, dH: number): ImageData;
+    /**
+     * hermiteFastResize
+     * @param {Object} canvasEl Canvas element to apply filter to
+     * @param {Number} oW Original Width
+     * @param {Number} oH Original Height
+     * @param {Number} dW Destination Width
+     * @param {Number} dH Destination Height
+     * @returns {ImageData}
+     */
+    hermiteFastResize(this: ResizeDuring2DResize, options: T2DPipelineState, oW: number, oH: number, dW: number, dH: number): ImageData;
+}
+export {};
+//# sourceMappingURL=Resize.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Resize.d.ts","sourceRoot":"","sources":["../../../src/filters/Resize.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,46 @@
+import { BaseFilter } from './BaseFilter';
+import type { T2DPipelineState, TWebGLUniformLocationMap } from './typedefs';
+export type SaturationOwnProps = {
+    saturation: number;
+};
+export declare const saturationDefaultValues: SaturationOwnProps;
+/**
+ * Saturate filter class
+ * @example
+ * const filter = new Saturation({
+ *   saturation: 1
+ * });
+ * object.filters.push(filter);
+ * object.applyFilters();
+ */
+export declare class Saturation extends BaseFilter<'Saturation', SaturationOwnProps> {
+    /**
+     * Saturation value, from -1 to 1.
+     * Increases/decreases the color saturation.
+     * A value of 0 has no effect.
+     *
+     * @param {Number} saturation
+     * @default
+     */
+    saturation: SaturationOwnProps['saturation'];
+    static type: string;
+    static defaults: SaturationOwnProps;
+    static uniformLocations: string[];
+    getFragmentSource(): string;
+    /**
+     * Apply the Saturation 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;
+    isNeutralState(): boolean;
+}
+//# sourceMappingURL=Saturation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Saturation.d.ts","sourceRoot":"","sources":["../../../src/filters/Saturation.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,kBAAkB,GAAG;IAC/B,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;;;;;;;OAOG;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;IAUnD;;;;;OAKG;IACH,eAAe,CACb,EAAE,EAAE,qBAAqB,EACzB,gBAAgB,EAAE,wBAAwB;IAK5C,cAAc;CAGf"}

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

@@ -0,0 +1,46 @@
+import { BaseFilter } from './BaseFilter';
+import type { T2DPipelineState, TWebGLUniformLocationMap } from './typedefs';
+export type VibranceOwnProps = {
+    vibrance: number;
+};
+export declare const vibranceDefaultValues: VibranceOwnProps;
+/**
+ * Vibrance filter class
+ * @example
+ * const filter = new Vibrance({
+ *   vibrance: 1
+ * });
+ * object.filters.push(filter);
+ * object.applyFilters();
+ */
+export declare class Vibrance extends BaseFilter<'Vibrance', VibranceOwnProps> {
+    /**
+     * Vibrance value, from -1 to 1.
+     * Increases/decreases the saturation of more muted colors with less effect on saturated colors.
+     * A value of 0 has no effect.
+     *
+     * @param {Number} vibrance
+     * @default
+     */
+    vibrance: VibranceOwnProps['vibrance'];
+    static type: string;
+    static defaults: VibranceOwnProps;
+    static uniformLocations: string[];
+    getFragmentSource(): string;
+    /**
+     * Apply the Vibrance 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 {TWebGLUniformLocationMap} uniformLocations A map of string uniform names to WebGLUniformLocation objects
+     */
+    sendUniformData(gl: WebGLRenderingContext, uniformLocations: TWebGLUniformLocationMap): void;
+    isNeutralState(): boolean;
+}
+//# sourceMappingURL=Vibrance.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Vibrance.d.ts","sourceRoot":"","sources":["../../../src/filters/Vibrance.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,gBAAgB,GAAG;IAC7B,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;;;;;;;OAOG;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;;;;;OAKG;IACH,SAAS,CAAC,EAAE,SAAS,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,gBAAgB;IAYnD;;;;;OAKG;IACH,eAAe,CACb,EAAE,EAAE,qBAAqB,EACzB,gBAAgB,EAAE,wBAAwB;IAK5C,cAAc;CAGf"}

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

@@ -0,0 +1,131 @@
+import type { TWebGLPipelineState, TProgramCache, TTextureCache, TPipelineResources } from './typedefs';
+import type { BaseFilter } from './BaseFilter';
+export declare class WebGLFilterBackend {
+    tileSize: number;
+    /**
+     * Define ...
+     **/
+    aPosition: Float32Array;
+    /**
+     * If GLPut data is the fastest operation, or if forced, this buffer will be used
+     * to transfer the data back in the 2d logic
+     **/
+    imageBuffer?: ArrayBuffer;
+    canvas: HTMLCanvasElement;
+    /**
+     * The Webgl context that will execute the operations for filtering
+     **/
+    gl: WebGLRenderingContext;
+    /**
+     * Keyed map for shader cache
+     **/
+    programCache: TProgramCache;
+    /**
+     * Keyed map for texture cache
+     **/
+    textureCache: TTextureCache;
+    /**
+     * Contains GPU info for debug
+     **/
+    gpuInfo: any;
+    /**
+     * 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;
+    constructor({ tileSize }?: {
+        tileSize?: number | undefined;
+    });
+    /**
+     * Setup a WebGL context suitable for filtering, and bind any needed event handlers.
+     */
+    setupGLContext(width: number, height: number): void;
+    /**
+     * Create a canvas element and associated WebGL context and attaches them as
+     * class properties to the GLFilterBackend class.
+     */
+    createWebGLCanvas(width: number, height: number): void;
+    /**
+     * Attempts to apply the requested filters to the source provided, drawing the filtered output
+     * to the provided target canvas.
+     *
+     * @param {Array} filters The filters to apply.
+     * @param {TexImageSource} source The source to be filtered.
+     * @param {Number} width The width of the source input.
+     * @param {Number} height The height of the source input.
+     * @param {HTMLCanvasElement} targetCanvas The destination for filtered output to be drawn.
+     * @param {String|undefined} cacheKey A key used to cache resources related to the source. If
+     * omitted, caching will be skipped.
+     */
+    applyFilters(filters: BaseFilter<string, Record<string, any>>[], source: TexImageSource, width: number, height: number, targetCanvas: HTMLCanvasElement, cacheKey?: string): TWebGLPipelineState | undefined;
+    /**
+     * Detach event listeners, remove references, and clean up caches.
+     */
+    dispose(): void;
+    /**
+     * Wipe out WebGL-related caches.
+     */
+    clearWebGLCaches(): void;
+    /**
+     * Create a WebGL texture object.
+     *
+     * Accepts specific dimensions to initialize the texture to or a source image.
+     *
+     * @param {WebGLRenderingContext} gl The GL context to use for creating the texture.
+     * @param {number} width The width to initialize the texture at.
+     * @param {number} height The height to initialize the texture.
+     * @param {TexImageSource} textureImageSource A source for the texture data.
+     * @param {number} filter gl.NEAREST default or gl.LINEAR filters for the texture.
+     * This filter is very useful for LUTs filters. If you need interpolation use gl.LINEAR
+     * @returns {WebGLTexture}
+     */
+    createTexture(gl: WebGLRenderingContext, width: number, height: number, textureImageSource?: TexImageSource, filter?: WebGLRenderingContextBase['NEAREST'] | WebGLRenderingContextBase['LINEAR']): WebGLTexture | null;
+    /**
+     * Can be optionally used to get a texture from the cache array
+     *
+     * If an existing texture is not found, a new texture is created and cached.
+     *
+     * @param {String} uniqueId A cache key to use to find an existing texture.
+     * @param {HTMLImageElement|HTMLCanvasElement} textureImageSource A source to use to create the
+     * texture cache entry if one does not already exist.
+     */
+    getCachedTexture(uniqueId: string, textureImageSource: TexImageSource, filter?: WebGLRenderingContextBase['NEAREST'] | WebGLRenderingContextBase['LINEAR']): WebGLTexture | null;
+    /**
+     * Clear out cached resources related to a source image that has been
+     * filtered previously.
+     *
+     * @param {String} cacheKey The cache key provided when the source image was filtered.
+     */
+    evictCachesForKey(cacheKey: string): void;
+    /**
+     * Copy an input WebGL canvas on to an output 2D canvas.
+     *
+     * The WebGL canvas is assumed to be upside down, with the top-left pixel of the
+     * desired output image appearing in the bottom-left corner of the WebGL canvas.
+     *
+     * @param {WebGLRenderingContext} sourceContext The WebGL context to copy from.
+     * @param {Object} pipelineState The 2D target canvas to copy on to.
+     */
+    copyGLTo2D(gl: WebGLRenderingContext, pipelineState: TWebGLPipelineState): void;
+    /**
+     * Copy an input WebGL canvas on to an output 2D canvas using 2d canvas' putImageData
+     * API. Measurably faster than using ctx.drawImage in Firefox (version 54 on OSX Sierra).
+     *
+     * @param {WebGLRenderingContext} sourceContext The WebGL context to copy from.
+     * @param {HTMLCanvasElement} targetCanvas The 2D target canvas to copy on to.
+     * @param {Object} pipelineState The 2D target canvas to copy on to.
+     */
+    copyGLTo2DPutImageData(this: Required<WebGLFilterBackend>, gl: WebGLRenderingContext, pipelineState: TWebGLPipelineState): void;
+    /**
+     * Attempt to extract GPU information strings from a WebGL context.
+     *
+     * Useful information when debugging or blacklisting specific GPUs.
+     *
+     * @returns {Object} A GPU info object with renderer and vendor strings.
+     */
+    captureGPUInfo(): any;
+}
+//# sourceMappingURL=WebGLFilterBackend.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"WebGLFilterBackend.d.ts","sourceRoot":"","sources":["../../../src/filters/WebGLFilterBackend.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,mBAAmB,EACnB,aAAa,EACb,aAAa,EACb,kBAAkB,EACnB,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE/C,qBAAa,kBAAkB;IACrB,QAAQ,EAAE,MAAM,CAAC;IAEzB;;QAEI;IACJ,SAAS,EAAE,YAAY,CAA8C;IAErE;;;QAGI;IACI,WAAW,CAAC,EAAE,WAAW,CAAC;IAE1B,MAAM,EAAE,iBAAiB,CAAC;IAElC;;QAEI;IACI,EAAE,EAAE,qBAAqB,CAAC;IAElC;;QAEI;IACI,YAAY,EAAE,aAAa,CAAC;IAEpC;;QAEI;IACI,YAAY,EAAE,aAAa,CAAC;IAEpC;;QAEI;IACI,OAAO,EAAE,GAAG,CAAC;IAErB;;;;;;QAMI;IACJ,SAAS,EAAE,kBAAkB,CAAM;gBAEvB,EAAE,QAA6B,EAAE;;KAAK;IAMlD;;OAEG;IACH,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAKnD;;;OAGG;IACH,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAsBtD;;;;;;;;;;;OAWG;IACH,YAAY,CACV,OAAO,EAAE,UAAU,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,EAAE,EAClD,MAAM,EAAE,cAAc,EACtB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,iBAAiB,EAC/B,QAAQ,CAAC,EAAE,MAAM,GAChB,mBAAmB,GAAG,SAAS;IAgElC;;OAEG;IACH,OAAO;IAYP;;OAEG;IACH,gBAAgB;IAKhB;;;;;;;;;;;;OAYG;IACH,aAAa,CACX,EAAE,EAAE,qBAAqB,EACzB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,kBAAkB,CAAC,EAAE,cAAc,EACnC,MAAM,CAAC,EACH,yBAAyB,CAAC,SAAS,CAAC,GACpC,yBAAyB,CAAC,QAAQ,CAAC;IA4CzC;;;;;;;;OAQG;IACH,gBAAgB,CACd,QAAQ,EAAE,MAAM,EAChB,kBAAkB,EAAE,cAAc,EAClC,MAAM,CAAC,EACH,yBAAyB,CAAC,SAAS,CAAC,GACpC,yBAAyB,CAAC,QAAQ,CAAC,GACtC,YAAY,GAAG,IAAI;IAmBtB;;;;;OAKG;IACH,iBAAiB,CAAC,QAAQ,EAAE,MAAM;IAOlC;;;;;;;;OAQG;IACH,UAAU,CAAC,EAAE,EAAE,qBAAqB,EAAE,aAAa,EAAE,mBAAmB;IAwBxE;;;;;;;OAOG;IACH,sBAAsB,CACpB,IAAI,EAAE,QAAQ,CAAC,kBAAkB,CAAC,EAClC,EAAE,EAAE,qBAAqB,EACzB,aAAa,EAAE,mBAAmB;IAkBpC;;;;;;OAMG;IACH,cAAc;CAuBf"}

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

@@ -0,0 +1,23 @@
+export { BaseFilter } from './BaseFilter';
+export type { TBlendMode } from './BlendColor';
+export { BlendColor } from './BlendColor';
+export { BlendImage } from './BlendImage';
+export { Blur } from './Blur';
+export { Brightness } from './Brightness';
+export { ColorMatrix } from './ColorMatrix';
+export { BlackWhite, Brownie, Kodachrome, Polaroid, Sepia, Technicolor, Vintage, } from './ColorMatrixFilters';
+export { Composed } from './Composed';
+export { Contrast } from './Contrast';
+export { Convolute } from './Convolute';
+export { Gamma } from './Gamma';
+export { Grayscale } from './Grayscale';
+export { HueRotation } from './HueRotation';
+export { Invert } from './Invert';
+export { Noise } from './Noise';
+export { Pixelate } from './Pixelate';
+export { RemoveColor } from './RemoveColor';
+export type { TResizeType } from './Resize';
+export { Resize } from './Resize';
+export { Saturation } from './Saturation';
+export { Vibrance } from './Vibrance';
+//# sourceMappingURL=filters.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"filters.d.ts","sourceRoot":"","sources":["../../../src/filters/filters.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,YAAY,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EACL,UAAU,EACV,OAAO,EACP,UAAU,EACV,QAAQ,EACR,KAAK,EACL,WAAW,EACX,OAAO,GACR,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,YAAY,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC"}

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

@@ -0,0 +1,7 @@
+export * as filters from './filters';
+export { getFilterBackend, initFilterBackend, setFilterBackend, } from './FilterBackend';
+export { Canvas2dFilterBackend } from './Canvas2dFilterBackend';
+export { WebGLFilterBackend } from './WebGLFilterBackend';
+export { isWebGLPipelineState, isPutImageFaster } from './utils';
+export * from './typedefs';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/filters/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,WAAW,CAAC;AAErC,OAAO,EACL,gBAAgB,EAChB,iBAAiB,EACjB,gBAAgB,GACjB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEjE,cAAc,YAAY,CAAC"}

package/dist-extensions/src/filters/shaders/baseFilter.d.ts

@@ -0,0 +1,4 @@
+export declare const highPsourceCode = "precision highp float";
+export declare const identityFragmentShader = "\n    precision highp float;\n    varying vec2 vTexCoord;\n    uniform sampler2D uTexture;\n    void main() {\n      gl_FragColor = texture2D(uTexture, vTexCoord);\n    }";
+export declare const vertexSource = "\n    attribute vec2 aPosition;\n    varying vec2 vTexCoord;\n    void main() {\n      vTexCoord = aPosition;\n      gl_Position = vec4(aPosition * 2.0 - 1.0, 0.0, 1.0);\n    }";
+//# sourceMappingURL=baseFilter.d.ts.map

package/dist-extensions/src/filters/shaders/baseFilter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"baseFilter.d.ts","sourceRoot":"","sources":["../../../../src/filters/shaders/baseFilter.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,eAAe,0BAA0B,CAAC;AAEvD,eAAO,MAAM,sBAAsB,+KAM7B,CAAC;AAEP,eAAO,MAAM,YAAY,qLAMnB,CAAC"}

package/dist-extensions/src/filters/shaders/blendColor.d.ts

@@ -0,0 +1,13 @@
+export declare const blendColorFragmentSource: {
+    readonly multiply: "gl_FragColor.rgb *= uColor.rgb;\n";
+    readonly screen: "gl_FragColor.rgb = 1.0 - (1.0 - gl_FragColor.rgb) * (1.0 - uColor.rgb);\n";
+    readonly add: "gl_FragColor.rgb += uColor.rgb;\n";
+    readonly difference: "gl_FragColor.rgb = abs(gl_FragColor.rgb - uColor.rgb);\n";
+    readonly subtract: "gl_FragColor.rgb -= uColor.rgb;\n";
+    readonly lighten: "gl_FragColor.rgb = max(gl_FragColor.rgb, uColor.rgb);\n";
+    readonly darken: "gl_FragColor.rgb = min(gl_FragColor.rgb, uColor.rgb);\n";
+    readonly exclusion: "gl_FragColor.rgb += uColor.rgb - 2.0 * (uColor.rgb * gl_FragColor.rgb);\n";
+    readonly overlay: "\n    if (uColor.r < 0.5) {\n      gl_FragColor.r *= 2.0 * uColor.r;\n    } else {\n      gl_FragColor.r = 1.0 - 2.0 * (1.0 - gl_FragColor.r) * (1.0 - uColor.r);\n    }\n    if (uColor.g < 0.5) {\n      gl_FragColor.g *= 2.0 * uColor.g;\n    } else {\n      gl_FragColor.g = 1.0 - 2.0 * (1.0 - gl_FragColor.g) * (1.0 - uColor.g);\n    }\n    if (uColor.b < 0.5) {\n      gl_FragColor.b *= 2.0 * uColor.b;\n    } else {\n      gl_FragColor.b = 1.0 - 2.0 * (1.0 - gl_FragColor.b) * (1.0 - uColor.b);\n    }\n    ";
+    readonly tint: "\n    gl_FragColor.rgb *= (1.0 - uColor.a);\n    gl_FragColor.rgb += uColor.rgb;\n    ";
+};
+//# sourceMappingURL=blendColor.d.ts.map

package/dist-extensions/src/filters/shaders/blendColor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blendColor.d.ts","sourceRoot":"","sources":["../../../../src/filters/shaders/blendColor.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,wBAAwB;;;;;;;;;;;CAgC3B,CAAC"}

package/dist-extensions/src/filters/shaders/blendImage.d.ts

@@ -0,0 +1,4 @@
+import type { TBlendImageMode } from '../BlendImage';
+export declare const fragmentSource: Record<TBlendImageMode, string>;
+export declare const vertexSource: "\n    attribute vec2 aPosition;\n    varying vec2 vTexCoord;\n    varying vec2 vTexCoord2;\n    uniform mat3 uTransformMatrix;\n    void main() {\n      vTexCoord = aPosition;\n      vTexCoord2 = (uTransformMatrix * vec3(aPosition, 1.0)).xy;\n      gl_Position = vec4(aPosition * 2.0 - 1.0, 0.0, 1.0);\n    }\n    ";
+//# sourceMappingURL=blendImage.d.ts.map

package/dist-extensions/src/filters/shaders/blendImage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blendImage.d.ts","sourceRoot":"","sources":["../../../../src/filters/shaders/blendImage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAErD,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,eAAe,EAAE,MAAM,CA6BjD,CAAC;AAEX,eAAO,MAAM,YAAY,8TAUX,CAAC"}

package/dist-extensions/src/filters/shaders/blur.d.ts

@@ -0,0 +1,2 @@
+export declare const fragmentSource: "\n    precision highp float;\n    uniform sampler2D uTexture;\n    uniform vec2 uDelta;\n    varying vec2 vTexCoord;\n    const float nSamples = 15.0;\n    vec3 v3offset = vec3(12.9898, 78.233, 151.7182);\n    float random(vec3 scale) {\n      /* use the fragment position for a different seed per-pixel */\n      return fract(sin(dot(gl_FragCoord.xyz, scale)) * 43758.5453);\n    }\n    void main() {\n      vec4 color = vec4(0.0);\n      float total = 0.0;\n      float offset = random(v3offset);\n      for (float t = -nSamples; t <= nSamples; t++) {\n        float percent = (t + offset - 0.5) / nSamples;\n        float weight = 1.0 - abs(percent);\n        color += texture2D(uTexture, vTexCoord + uDelta * percent) * weight;\n        total += weight;\n      }\n      gl_FragColor = color / total;\n    }\n  ";
+//# sourceMappingURL=blur.d.ts.map

package/dist-extensions/src/filters/shaders/blur.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blur.d.ts","sourceRoot":"","sources":["../../../../src/filters/shaders/blur.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,kzBAuBf,CAAC"}

package/dist-extensions/src/filters/shaders/brightness.d.ts

@@ -0,0 +1,2 @@
+export declare const fragmentSource = "\n  precision highp float;\n  uniform sampler2D uTexture;\n  uniform float uBrightness;\n  varying vec2 vTexCoord;\n  void main() {\n    vec4 color = texture2D(uTexture, vTexCoord);\n    color.rgb += uBrightness;\n    gl_FragColor = color;\n  }\n";
+//# sourceMappingURL=brightness.d.ts.map

package/dist-extensions/src/filters/shaders/brightness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"brightness.d.ts","sourceRoot":"","sources":["../../../../src/filters/shaders/brightness.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,2PAU1B,CAAC"}

package/dist-extensions/src/filters/shaders/colorMatrix.d.ts

@@ -0,0 +1,2 @@
+export declare const fragmentSource = "\n  precision highp float;\n  uniform sampler2D uTexture;\n  varying vec2 vTexCoord;\n  uniform mat4 uColorMatrix;\n  uniform vec4 uConstants;\n  void main() {\n    vec4 color = texture2D(uTexture, vTexCoord);\n    color *= uColorMatrix;\n    color += uConstants;\n    gl_FragColor = color;\n  }";
+//# sourceMappingURL=colorMatrix.d.ts.map

package/dist-extensions/src/filters/shaders/colorMatrix.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"colorMatrix.d.ts","sourceRoot":"","sources":["../../../../src/filters/shaders/colorMatrix.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,4SAWvB,CAAC"}