fabric 5.3.0 → 6.0.0-beta3

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

@@ -0,0 +1,45 @@
+import type { TClassProperties } from '../typedefs';
+import { BaseFilter } from './BaseFilter';
+import type { T2DPipelineState, TWebGLUniformLocationMap } from './typedefs';
+export declare const contrastDefaultValues: Partial<TClassProperties<Contrast>>;
+/**
+ * Contrast filter class
+ * @example
+ * const filter = new Contrast({
+ *   contrast: 0.25
+ * });
+ * object.filters.push(filter);
+ * object.applyFilters();
+ */
+export declare class Contrast extends BaseFilter {
+    /**
+     * contrast value, range from -1 to 1.
+     * @param {Number} contrast
+     * @default 0
+     */
+    contrast: number;
+    static defaults: Partial<TClassProperties<Contrast>>;
+    getFragmentSource(): string;
+    /**
+     * 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;
+    /**
+     * Return WebGL uniform locations for this filter's shader.
+     *
+     * @param {WebGLRenderingContext} gl The GL canvas context used to compile this filter's shader.
+     * @param {WebGLShaderProgram} program This filter's compiled shader program.
+     */
+    getUniformLocations(gl: WebGLRenderingContext, program: WebGLProgram): TWebGLUniformLocationMap;
+    /**
+     * 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=Contrast.d.ts.map

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

@@ -0,0 +1,82 @@
+import type { TClassProperties } from '../typedefs';
+import { BaseFilter } from './BaseFilter';
+import type { T2DPipelineState, TWebGLUniformLocationMap } from './typedefs';
+export declare const convoluteDefaultValues: Partial<TClassProperties<Convolute>>;
+/**
+ * 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 {
+    opaque: boolean;
+    matrix: number[];
+    static defaults: Partial<TClassProperties<Convolute>>;
+    getCacheKey(): "Convolute_3_1" | "Convolute_3_0" | "Convolute_5_1" | "Convolute_5_0" | "Convolute_7_1" | "Convolute_7_0" | "Convolute_9_1" | "Convolute_9_0";
+    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;
+    /**
+     * Return WebGL uniform locations for this filter's shader.
+     *
+     * @param {WebGLRenderingContext} gl The GL canvas context used to compile this filter's shader.
+     * @param {WebGLShaderProgram} program This filter's compiled shader program.
+     */
+    getUniformLocations(gl: WebGLRenderingContext, program: WebGLProgram): TWebGLUniformLocationMap;
+    /**
+     * 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: string;
+    };
+}
+//# sourceMappingURL=Convolute.d.ts.map

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

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

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

@@ -0,0 +1,11 @@
+export declare enum GLPrecision {
+    low = "lowp",
+    medium = "mediump",
+    high = "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/src/filters/GLProbes/NodeGLProbe.d.ts

@@ -0,0 +1,11 @@
+import { GLProbe } from './GLProbe';
+/**
+ * @todo GL rendering in node is possible:
+ * - https://github.com/stackgl/headless-gl
+ * - https://github.com/akira-cn/node-canvas-webgl
+ */
+export declare class NodeGLProbe extends GLProbe {
+    queryWebGL(): void;
+    isSupported(): boolean;
+}
+//# sourceMappingURL=NodeGLProbe.d.ts.map

package/dist/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/src/filters/Gamma.d.ts

@@ -0,0 +1,54 @@
+import type { TClassProperties } from '../typedefs';
+import { BaseFilter } from './BaseFilter';
+import type { T2DPipelineState, TWebGLUniformLocationMap } from './typedefs';
+export type GammaInput = [number, number, number];
+export declare const gammaDefaultValues: Partial<TClassProperties<Gamma>>;
+/**
+ * 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 {
+    /**
+     * Gamma array value, from 0.01 to 2.2.
+     * @param {Array} gamma
+     * @default
+     */
+    gamma: GammaInput;
+    rgbValues?: {
+        r: Uint8Array;
+        g: Uint8Array;
+        b: Uint8Array;
+    };
+    static defaults: Partial<TClassProperties<Gamma>>;
+    getFragmentSource(): string;
+    constructor({ gamma, ...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;
+    /**
+     * Return WebGL uniform locations for this filter's shader.
+     *
+     * @param {WebGLRenderingContext} gl The GL canvas context used to compile this filter's shader.
+     * @param {WebGLShaderProgram} program This filter's compiled shader program.
+     */
+    getUniformLocations(gl: WebGLRenderingContext, program: WebGLProgram): TWebGLUniformLocationMap;
+    /**
+     * 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=Gamma.d.ts.map

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

@@ -0,0 +1,46 @@
+import type { TClassProperties } from '../typedefs';
+import { BaseFilter } from './BaseFilter';
+import type { T2DPipelineState, TWebGLUniformLocationMap } from './typedefs';
+export type TGrayscaleMode = 'average' | 'lightness' | 'luminosity';
+export declare const grayscaleDefaultValues: Partial<TClassProperties<Grayscale>>;
+/**
+ * Grayscale image filter class
+ * @example
+ * const filter = new Grayscale();
+ * object.filters.push(filter);
+ * object.applyFilters();
+ */
+export declare class Grayscale extends BaseFilter {
+    mode: TGrayscaleMode;
+    static defaults: Partial<TClassProperties<Grayscale>>;
+    /**
+     * 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;
+    /**
+     * Return WebGL uniform locations for this filter's shader.
+     *
+     * @param {WebGLRenderingContext} gl The GL canvas context used to compile this filter's shader.
+     * @param {WebGLShaderProgram} program This filter's compiled shader program.
+     */
+    getUniformLocations(gl: WebGLRenderingContext, program: WebGLProgram): TWebGLUniformLocationMap;
+    /**
+     * 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;
+}
+//# sourceMappingURL=Grayscale.d.ts.map

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

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

package/dist/src/filters/Invert.d.ts

@@ -0,0 +1,55 @@
+import type { TClassProperties } from '../typedefs';
+import { BaseFilter } from './BaseFilter';
+import type { T2DPipelineState, TWebGLUniformLocationMap } from './typedefs';
+export declare const invertDefaultValues: Partial<TClassProperties<Invert>>;
+/**
+ * @example
+ * const filter = new Invert();
+ * object.filters.push(filter);
+ * object.applyFilters(canvas.renderAll.bind(canvas));
+ */
+export declare class Invert extends BaseFilter {
+    /**
+     * Invert also alpha.
+     * @param {Boolean} alpha
+     * @default
+     **/
+    alpha: boolean;
+    /**
+     * Filter invert. if false, does nothing
+     * @param {Boolean} invert
+     * @default
+     */
+    invert: boolean;
+    static defaults: Partial<TClassProperties<Invert>>;
+    /**
+     * Apply the Invert 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;
+    protected getFragmentSource(): string;
+    /**
+     * Invert filter isNeutralState implementation
+     * Used only in image applyFilters to discard filters that will not have an effect
+     * on the image
+     * @param {Object} options
+     **/
+    isNeutralState(): boolean;
+    /**
+     * Return WebGL uniform locations for this filter's shader.
+     *
+     * @param {WebGLRenderingContext} gl The GL canvas context used to compile this filter's shader.
+     * @param {WebGLShaderProgram} program This filter's compiled shader program.
+     */
+    getUniformLocations(gl: WebGLRenderingContext, program: WebGLProgram): TWebGLUniformLocationMap;
+    /**
+     * 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=Invert.d.ts.map

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

@@ -0,0 +1,54 @@
+import type { TClassProperties } from '../typedefs';
+import { BaseFilter } from './BaseFilter';
+import type { T2DPipelineState, TWebGLUniformLocationMap } from './typedefs';
+export declare const noiseDefaultValues: Partial<TClassProperties<Noise>>;
+/**
+ * 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 value, from
+     * @param {Number} noise
+     * @default
+     */
+    noise: number;
+    static defaults: Partial<TClassProperties<Noise>>;
+    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;
+    /**
+     * Return WebGL uniform locations for this filter's shader.
+     *
+     * @param {WebGLRenderingContext} gl The GL canvas context used to compile this filter's shader.
+     * @param {WebGLShaderProgram} program This filter's compiled shader program.
+     */
+    getUniformLocations(gl: WebGLRenderingContext, program: WebGLProgram): TWebGLUniformLocationMap;
+    /**
+     * 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(): {
+        noise: number;
+        type: string;
+    };
+}
+//# sourceMappingURL=Noise.d.ts.map

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

@@ -0,0 +1,44 @@
+import type { TClassProperties } from '../typedefs';
+import { BaseFilter } from './BaseFilter';
+import type { T2DPipelineState, TWebGLUniformLocationMap } from './typedefs';
+export declare const pixelateDefaultValues: Partial<TClassProperties<Pixelate>>;
+/**
+ * Pixelate filter class
+ * @example
+ * const filter = new Pixelate({
+ *   blocksize: 8
+ * });
+ * object.filters.push(filter);
+ * object.applyFilters();
+ */
+export declare class Pixelate extends BaseFilter {
+    blocksize: number;
+    static defaults: Partial<TClassProperties<Pixelate>>;
+    /**
+     * 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;
+    /**
+     * Return WebGL uniform locations for this filter's shader.
+     *
+     * @param {WebGLRenderingContext} gl The GL canvas context used to compile this filter's shader.
+     * @param {WebGLShaderProgram} program This filter's compiled shader program.
+     */
+    getUniformLocations(gl: WebGLRenderingContext, program: WebGLProgram): TWebGLUniformLocationMap;
+    /**
+     * 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/src/filters/RemoveColor.d.ts

@@ -0,0 +1,63 @@
+import type { TClassProperties } from '../typedefs';
+import { BaseFilter } from './BaseFilter';
+import type { T2DPipelineState, TWebGLUniformLocationMap } from './typedefs';
+export declare const removeColorDefaultValues: Partial<TClassProperties<RemoveColor>>;
+/**
+ * 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 {
+    /**
+     * Color to remove, in any format understood by {@link Color}.
+     * @param {String} type
+     * @default
+     */
+    color: string;
+    /**
+     * distance to actual color, as value up or down from each r,g,b
+     * between 0 and 1
+     **/
+    distance: number;
+    /**
+     * For color to remove inside distance, use alpha channel for a smoother deletion
+     * NOT IMPLEMENTED YET
+     **/
+    useAlpha: boolean;
+    static defaults: Partial<TClassProperties<RemoveColor>>;
+    getFragmentShader(): string;
+    /**
+     * Applies filter to canvas element
+     * @param {Object} canvasEl Canvas element to apply filter to
+     */
+    applyTo2d({ imageData: { data } }: T2DPipelineState): void;
+    /**
+     * Return WebGL uniform locations for this filter's shader.
+     *
+     * @param {WebGLRenderingContext} gl The GL canvas context used to compile this filter's shader.
+     * @param {WebGLShaderProgram} program This filter's compiled shader program.
+     */
+    getUniformLocations(gl: WebGLRenderingContext, program: WebGLProgram): TWebGLUniformLocationMap;
+    /**
+     * 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(): {
+        color: string;
+        distance: number;
+        type: string;
+    };
+}
+//# sourceMappingURL=RemoveColor.d.ts.map

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

@@ -0,0 +1,136 @@
+import type { TClassProperties } from '../typedefs';
+import { BaseFilter } from './BaseFilter';
+import type { T2DPipelineState, TWebGLPipelineState } from './typedefs';
+export declare const resizeDefaultValues: Partial<TClassProperties<Resize>>;
+type TResizeType = 'bilinear' | 'hermite' | 'sliceHack' | 'lanczos';
+/**
+ * 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 type
+     * for webgl resizeType is just lanczos, for canvas2d can be:
+     * bilinear, hermite, sliceHack, lanczos.
+     * @default
+     */
+    resizeType: TResizeType;
+    /**
+     * Scale factor for resizing, x axis
+     * @param {Number} scaleX
+     * @default
+     */
+    scaleX: number;
+    /**
+     * Scale factor for resizing, y axis
+     * @param {Number} scaleY
+     * @default
+     */
+    scaleY: number;
+    /**
+     * LanczosLobes parameter for lanczos filter, valid for resizeType lanczos
+     * @param {Number} lanczosLobes
+     * @default
+     */
+    lanczosLobes: number;
+    fragmentSourceTOP: string;
+    static defaults: Partial<TClassProperties<Resize>>;
+    /**
+     * Return WebGL uniform locations for this filter's shader.
+     *
+     * @param {WebGLRenderingContext} gl The GL canvas context used to compile this filter's shader.
+     * @param {WebGLShaderProgram} program This filter's compiled shader program.
+     */
+    getUniformLocations(gl: any, program: any): {
+        uDelta: any;
+        uTaps: any;
+    };
+    /**
+     * 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: any, uniformLocations: any): void;
+    getFilterWindow(): number;
+    getCacheKey(): string;
+    getFragmentSource(): string;
+    getTaps(): any[];
+    /**
+     * Generate vertex and shader sources from the necessary steps numbers
+     * @param {Number} filterWindow
+     */
+    generateShader(filterWindow: number): string;
+    /**
+     * 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(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): any;
+    /**
+     * 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(options: T2DPipelineState, oW: number, oH: number, dW: number, dH: number): any;
+    /**
+     * 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(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(options: T2DPipelineState, oW: number, oH: number, dW: number, dH: number): ImageData;
+    /**
+     * Returns object representation of an instance
+     * @return {Object} Object representation of an instance
+     */
+    toObject(): {
+        type: string;
+        scaleX: number;
+        scaleY: number;
+        resizeType: TResizeType;
+        lanczosLobes: number;
+    };
+}
+export {};
+//# sourceMappingURL=Resize.d.ts.map