@nasser-sw/fabric 7.0.0-beta1

package/dist/src/env/index.min.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.min.mjs","sources":["../../../src/env/index.ts"],"sourcesContent":["/**\n * This file is consumed by fabric.\n * The `./node` and `./browser` files define the env variable that is used by this module.\n * The `./browser` module is defined to be the default env and doesn't set the env at all.\n * This is done in order to support isomorphic usage for browser and node applications\n * since window and document aren't defined at time of import in SSR, we can't set env so we avoid it by deferring to the default env.\n */\n\nimport { config } from '../config';\nimport { getEnv as getBrowserEnv } from './browser';\nimport type { TFabricEnv } from './types';\nimport type { DOMWindow } from 'jsdom';\n\nlet env: TFabricEnv;\n\n/**\n * Sets the environment variables used by fabric.\\\n * This is exposed for special cases, such as configuring a test environment, and should be used with care.\n *\n * **CAUTION**: Must be called before using the package.\n *\n * @example\n * <caption>Passing `window` and `document` objects to fabric (in case they are mocked or something)</caption>\n * import { getEnv, setEnv } from 'fabric';\n * // we want fabric to use the `window` and `document` objects exposed by the environment we are running in.\n * setEnv({ ...getEnv(), window, document });\n * // done with setup, using fabric is now safe\n */\nexport const setEnv = (value: TFabricEnv) => {\n  env = value;\n};\n\n/**\n * In order to support SSR we **MUST** access the browser env only after the window has loaded\n */\nexport const getEnv = () => env || (env = getBrowserEnv());\n\nexport const getFabricDocument = (): Document => getEnv().document;\n\nexport const getFabricWindow = (): (Window & typeof globalThis) | DOMWindow =>\n  getEnv().window;\n\n/**\n * @returns the config value if defined, fallbacks to the environment value\n */\nexport const getDevicePixelRatio = () =>\n  Math.max(config.devicePixelRatio ?? getFabricWindow().devicePixelRatio, 1);\n"],"names":["env","setEnv","value","getEnv","getBrowserEnv","getFabricDocument","document","getFabricWindow","window","getDevicePixelRatio","_config$devicePixelRa","Math","max","config","devicePixelRatio"],"mappings":"sFAaA,IAAIA,EAeG,MAAMC,EAAUC,IACrBF,EAAME,GAMKC,EAASA,IAAMH,IAAQA,EAAMI,KAE7BC,EAAoBA,IAAgBF,IAASG,SAE7CC,EAAkBA,IAC7BJ,IAASK,OAKEC,EAAsBA,KAAA,IAAAC,EAAA,OACjCC,KAAKC,IAA2B,QAAxBF,EAACG,EAAOC,wBAAgB,IAAAJ,EAAAA,EAAIH,IAAkBO,iBAAkB"}

package/dist/src/env/index.mjs

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

package/dist/src/env/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":["../../../src/env/index.ts"],"sourcesContent":["/**\n * This file is consumed by fabric.\n * The `./node` and `./browser` files define the env variable that is used by this module.\n * The `./browser` module is defined to be the default env and doesn't set the env at all.\n * This is done in order to support isomorphic usage for browser and node applications\n * since window and document aren't defined at time of import in SSR, we can't set env so we avoid it by deferring to the default env.\n */\n\nimport { config } from '../config';\nimport { getEnv as getBrowserEnv } from './browser';\nimport type { TFabricEnv } from './types';\nimport type { DOMWindow } from 'jsdom';\n\nlet env: TFabricEnv;\n\n/**\n * Sets the environment variables used by fabric.\\\n * This is exposed for special cases, such as configuring a test environment, and should be used with care.\n *\n * **CAUTION**: Must be called before using the package.\n *\n * @example\n * <caption>Passing `window` and `document` objects to fabric (in case they are mocked or something)</caption>\n * import { getEnv, setEnv } from 'fabric';\n * // we want fabric to use the `window` and `document` objects exposed by the environment we are running in.\n * setEnv({ ...getEnv(), window, document });\n * // done with setup, using fabric is now safe\n */\nexport const setEnv = (value: TFabricEnv) => {\n  env = value;\n};\n\n/**\n * In order to support SSR we **MUST** access the browser env only after the window has loaded\n */\nexport const getEnv = () => env || (env = getBrowserEnv());\n\nexport const getFabricDocument = (): Document => getEnv().document;\n\nexport const getFabricWindow = (): (Window & typeof globalThis) | DOMWindow =>\n  getEnv().window;\n\n/**\n * @returns the config value if defined, fallbacks to the environment value\n */\nexport const getDevicePixelRatio = () =>\n  Math.max(config.devicePixelRatio ?? getFabricWindow().devicePixelRatio, 1);\n"],"names":["env","setEnv","value","getEnv","getBrowserEnv","getFabricDocument","document","getFabricWindow","window","getDevicePixelRatio","_config$devicePixelRa","Math","max","config","devicePixelRatio"],"mappings":";;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;;AAOA,IAAIA,GAAe;;AAEnB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMC,MAAM,GAAIC,KAAiB,IAAK;AAC3CF,EAAAA,GAAG,GAAGE,KAAK;AACb;;AAEA;AACA;AACA;AACO,MAAMC,MAAM,GAAGA,MAAMH,GAAG,KAAKA,GAAG,GAAGI,QAAa,EAAE;AAElD,MAAMC,iBAAiB,GAAGA,MAAgBF,MAAM,EAAE,CAACG;AAEnD,MAAMC,eAAe,GAAGA,MAC7BJ,MAAM,EAAE,CAACK;;AAEX;AACA;AACA;AACO,MAAMC,mBAAmB,GAAGA,MAAA;AAAA,EAAA,IAAAC,qBAAA;EAAA,OACjCC,IAAI,CAACC,GAAG,CAAA,CAAAF,qBAAA,GAACG,MAAM,CAACC,gBAAgB,MAAA,IAAA,IAAAJ,qBAAA,KAAA,MAAA,GAAAA,qBAAA,GAAIH,eAAe,EAAE,CAACO,gBAAgB,EAAE,CAAC,CAAC;AAAA;;;;"}

package/dist/src/env/node.d.ts

@@ -0,0 +1,6 @@
+import type { Canvas as NodeCanvas } from 'canvas';
+import type { TFabricEnv } from './types';
+export declare const getNodeCanvas: (canvasEl: HTMLCanvasElement) => NodeCanvas;
+export declare const dispose: (element: Element) => void;
+export declare const getEnv: () => TFabricEnv;
+//# sourceMappingURL=node.d.ts.map

package/dist/src/env/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../src/env/node.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,QAAQ,CAAC;AAKnD,OAAO,KAAK,EAAkB,UAAU,EAAE,MAAM,SAAS,CAAC;AAiB1D,eAAO,MAAM,aAAa,GAAI,UAAU,iBAAiB,KAEf,UACzC,CAAC;AAEF,eAAO,MAAM,OAAO,GAAI,SAAS,OAAO,SAUvC,CAAC;AAEF,eAAO,MAAM,MAAM,QAAO,UASzB,CAAC"}

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

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

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

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

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

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

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

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

package/dist/src/filters/BaseFilter.min.mjs

@@ -0,0 +1,2 @@
+import{defineProperty as e}from"../../_virtual/_rollupPluginBabelHelpers.min.mjs";import{getEnv as t}from"../env/index.min.mjs";import{isWebGLPipelineState as r}from"./utils.min.mjs";import{identityFragmentShader as o,vertexSource as i,highPsourceCode as a}from"./shaders/baseFilter.min.mjs";import{FabricError as n}from"../util/internals/console.min.mjs";import{createCanvasElementFor as s}from"../util/misc/dom.min.mjs";const u=new RegExp(a,"g");class c{get type(){return this.constructor.type}constructor(){let{type:e,...t}=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};Object.assign(this,this.constructor.defaults,t)}getFragmentSource(){return o}getVertexSource(){return i}createProgram(e){let r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:this.getFragmentSource(),o=arguments.length>2&&void 0!==arguments[2]?arguments[2]:this.getVertexSource();const{WebGLProbe:{GLPrecision:i="highp"}}=t();"highp"!==i&&(r=r.replace(u,a.replace("highp",i)));const s=e.createShader(e.VERTEX_SHADER),c=e.createShader(e.FRAGMENT_SHADER),h=e.createProgram();if(!s||!c||!h)throw new n("Vertex, fragment shader or program creation error");if(e.shaderSource(s,o),e.compileShader(s),!e.getShaderParameter(s,e.COMPILE_STATUS))throw new n(`Vertex shader compile error for ${this.type}: ${e.getShaderInfoLog(s)}`);if(e.shaderSource(c,r),e.compileShader(c),!e.getShaderParameter(c,e.COMPILE_STATUS))throw new n(`Fragment shader compile error for ${this.type}: ${e.getShaderInfoLog(c)}`);if(e.attachShader(h,s),e.attachShader(h,c),e.linkProgram(h),!e.getProgramParameter(h,e.LINK_STATUS))throw new n(`Shader link error for "${this.type}" ${e.getProgramInfoLog(h)}`);const m=this.getUniformLocations(e,h)||{};return m.uStepW=e.getUniformLocation(h,"uStepW"),m.uStepH=e.getUniformLocation(h,"uStepH"),{program:h,attributeLocations:this.getAttributeLocations(e,h),uniformLocations:m}}getAttributeLocations(e,t){return{aPosition:e.getAttribLocation(t,"aPosition")}}getUniformLocations(e,t){const r=this.constructor.uniformLocations,o={};for(let i=0;i<r.length;i++)o[r[i]]=e.getUniformLocation(t,r[i]);return o}sendAttributeData(e,t,r){const o=t.aPosition,i=e.createBuffer();e.bindBuffer(e.ARRAY_BUFFER,i),e.enableVertexAttribArray(o),e.vertexAttribPointer(o,2,e.FLOAT,!1,0,0),e.bufferData(e.ARRAY_BUFFER,r,e.STATIC_DRAW)}_setupFrameBuffer(e){const t=e.context;if(e.passes>1){const r=e.destinationWidth,o=e.destinationHeight;e.sourceWidth===r&&e.sourceHeight===o||(t.deleteTexture(e.targetTexture),e.targetTexture=e.filterBackend.createTexture(t,r,o)),t.framebufferTexture2D(t.FRAMEBUFFER,t.COLOR_ATTACHMENT0,t.TEXTURE_2D,e.targetTexture,0)}else t.bindFramebuffer(t.FRAMEBUFFER,null),t.finish()}_swapTextures(e){e.passes--,e.pass++;const t=e.targetTexture;e.targetTexture=e.sourceTexture,e.sourceTexture=t}isNeutralState(e){return!1}applyTo(e){r(e)?(this._setupFrameBuffer(e),this.applyToWebGL(e),this._swapTextures(e)):this.applyTo2d(e)}applyTo2d(e){}getCacheKey(){return this.type}retrieveShader(e){const t=this.getCacheKey();return e.programCache[t]||(e.programCache[t]=this.createProgram(e.context)),e.programCache[t]}applyToWebGL(e){const t=e.context,r=this.retrieveShader(e);0===e.pass&&e.originalTexture?t.bindTexture(t.TEXTURE_2D,e.originalTexture):t.bindTexture(t.TEXTURE_2D,e.sourceTexture),t.useProgram(r.program),this.sendAttributeData(t,r.attributeLocations,e.aPosition),t.uniform1f(r.uniformLocations.uStepW,1/e.sourceWidth),t.uniform1f(r.uniformLocations.uStepH,1/e.sourceHeight),this.sendUniformData(t,r.uniformLocations),t.viewport(0,0,e.destinationWidth,e.destinationHeight),t.drawArrays(t.TRIANGLE_STRIP,0,4)}bindAdditionalTexture(e,t,r){e.activeTexture(r),e.bindTexture(e.TEXTURE_2D,t),e.activeTexture(e.TEXTURE0)}unbindAdditionalTexture(e,t){e.activeTexture(t),e.bindTexture(e.TEXTURE_2D,null),e.activeTexture(e.TEXTURE0)}sendUniformData(e,t){}createHelpLayer(e){if(!e.helpLayer){const{sourceWidth:t,sourceHeight:r}=e,o=s({width:t,height:r});e.helpLayer=o}}toObject(){const e=Object.keys(this.constructor.defaults||{});return{type:this.type,...e.reduce((e,t)=>(e[t]=this[t],e),{})}}toJSON(){return this.toObject()}static async fromObject(e,t){let{type:r,...o}=e;return new this(o)}}e(c,"type","BaseFilter"),e(c,"uniformLocations",[]);export{c as BaseFilter};
+//# sourceMappingURL=BaseFilter.min.mjs.map

package/dist/src/filters/BaseFilter.min.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseFilter.min.mjs","sources":["../../../src/filters/BaseFilter.ts"],"sourcesContent":["import { getEnv } from '../env';\nimport type {\n  T2DPipelineState,\n  TWebGLAttributeLocationMap,\n  TWebGLPipelineState,\n  TWebGLProgramCacheItem,\n  TWebGLUniformLocationMap,\n} from './typedefs';\nimport { isWebGLPipelineState } from './utils';\nimport {\n  highPsourceCode,\n  identityFragmentShader,\n  vertexSource,\n} from './shaders/baseFilter';\nimport type { Abortable } from '../typedefs';\nimport { FabricError } from '../util/internals/console';\nimport { createCanvasElementFor } from '../util/misc/dom';\n\nconst regex = new RegExp(highPsourceCode, 'g');\n\nexport class BaseFilter<\n  Name extends string,\n  OwnProps extends Record<string, any> = object,\n  SerializedProps extends Record<string, any> = OwnProps,\n> {\n  /**\n   * Filter type\n   */\n  get type(): Name {\n    return (this.constructor as typeof BaseFilter).type as Name;\n  }\n\n  /**\n   * The class type. Used to identify which class this is.\n   * This is used for serialization purposes and internally it can be used\n   * to identify classes. As a developer you could use `instance of Class`\n   * but to avoid importing all the code and blocking tree shaking we try\n   * to avoid doing that.\n   */\n  static type = 'BaseFilter';\n\n  /**\n   * Contains the uniform locations for the fragment shader.\n   * uStepW and uStepH are handled by the BaseFilter, each filter class\n   * needs to specify all the one that are needed\n   */\n  static uniformLocations: string[] = [];\n\n  declare static defaults: Record<string, unknown>;\n\n  /**\n   * Constructor\n   * @param {Object} [options] Options object\n   */\n  constructor({\n    type,\n    ...options\n  }: { type?: never } & Partial<OwnProps> & Record<string, any> = {}) {\n    Object.assign(\n      this,\n      (this.constructor as typeof BaseFilter).defaults,\n      options,\n    );\n  }\n\n  protected getFragmentSource(): string {\n    return identityFragmentShader;\n  }\n\n  getVertexSource(): string {\n    return vertexSource;\n  }\n\n  /**\n   * Compile this filter's shader program.\n   *\n   * @param {WebGLRenderingContext} gl The GL canvas context to use for shader compilation.\n   * @param {String} fragmentSource fragmentShader source for compilation\n   * @param {String} vertexSource vertexShader source for compilation\n   */\n  createProgram(\n    gl: WebGLRenderingContext,\n    fragmentSource: string = this.getFragmentSource(),\n    vertexSource: string = this.getVertexSource(),\n  ) {\n    const {\n      WebGLProbe: { GLPrecision = 'highp' },\n    } = getEnv();\n    if (GLPrecision !== 'highp') {\n      fragmentSource = fragmentSource.replace(\n        regex,\n        highPsourceCode.replace('highp', GLPrecision),\n      );\n    }\n    const vertexShader = gl.createShader(gl.VERTEX_SHADER);\n    const fragmentShader = gl.createShader(gl.FRAGMENT_SHADER);\n    const program = gl.createProgram();\n\n    if (!vertexShader || !fragmentShader || !program) {\n      throw new FabricError(\n        'Vertex, fragment shader or program creation error',\n      );\n    }\n    gl.shaderSource(vertexShader, vertexSource);\n    gl.compileShader(vertexShader);\n    if (!gl.getShaderParameter(vertexShader, gl.COMPILE_STATUS)) {\n      throw new FabricError(\n        `Vertex shader compile error for ${this.type}: ${gl.getShaderInfoLog(\n          vertexShader,\n        )}`,\n      );\n    }\n\n    gl.shaderSource(fragmentShader, fragmentSource);\n    gl.compileShader(fragmentShader);\n    if (!gl.getShaderParameter(fragmentShader, gl.COMPILE_STATUS)) {\n      throw new FabricError(\n        `Fragment shader compile error for ${this.type}: ${gl.getShaderInfoLog(\n          fragmentShader,\n        )}`,\n      );\n    }\n\n    gl.attachShader(program, vertexShader);\n    gl.attachShader(program, fragmentShader);\n    gl.linkProgram(program);\n    if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {\n      throw new FabricError(\n        `Shader link error for \"${this.type}\" ${gl.getProgramInfoLog(program)}`,\n      );\n    }\n\n    const uniformLocations = this.getUniformLocations(gl, program) || {};\n    uniformLocations.uStepW = gl.getUniformLocation(program, 'uStepW');\n    uniformLocations.uStepH = gl.getUniformLocation(program, 'uStepH');\n\n    return {\n      program,\n      attributeLocations: this.getAttributeLocations(gl, program),\n      uniformLocations,\n    };\n  }\n\n  /**\n   * Return a map of attribute names to WebGLAttributeLocation objects.\n   *\n   * @param {WebGLRenderingContext} gl The canvas context used to compile the shader program.\n   * @param {WebGLShaderProgram} program The shader program from which to take attribute locations.\n   * @returns {Object} A map of attribute names to attribute locations.\n   */\n  getAttributeLocations(\n    gl: WebGLRenderingContext,\n    program: WebGLProgram,\n  ): TWebGLAttributeLocationMap {\n    return {\n      aPosition: gl.getAttribLocation(program, 'aPosition'),\n    };\n  }\n\n  /**\n   * Return a map of uniform names to WebGLUniformLocation objects.\n   *\n   * @param {WebGLRenderingContext} gl The canvas context used to compile the shader program.\n   * @param {WebGLShaderProgram} program The shader program from which to take uniform locations.\n   * @returns {Object} A map of uniform names to uniform locations.\n   */\n  getUniformLocations(\n    gl: WebGLRenderingContext,\n    program: WebGLProgram,\n  ): TWebGLUniformLocationMap {\n    const locations = (this.constructor as unknown as typeof BaseFilter<string>)\n      .uniformLocations;\n\n    const uniformLocations: Record<string, WebGLUniformLocation | null> = {};\n    for (let i = 0; i < locations.length; i++) {\n      uniformLocations[locations[i]] = gl.getUniformLocation(\n        program,\n        locations[i],\n      );\n    }\n    return uniformLocations;\n  }\n\n  /**\n   * Send attribute data from this filter to its shader program on the GPU.\n   *\n   * @param {WebGLRenderingContext} gl The canvas context used to compile the shader program.\n   * @param {Object} attributeLocations A map of shader attribute names to their locations.\n   */\n  sendAttributeData(\n    gl: WebGLRenderingContext,\n    attributeLocations: Record<string, number>,\n    aPositionData: Float32Array,\n  ) {\n    const attributeLocation = attributeLocations.aPosition;\n    const buffer = gl.createBuffer();\n    gl.bindBuffer(gl.ARRAY_BUFFER, buffer);\n    gl.enableVertexAttribArray(attributeLocation);\n    gl.vertexAttribPointer(attributeLocation, 2, gl.FLOAT, false, 0, 0);\n    gl.bufferData(gl.ARRAY_BUFFER, aPositionData, gl.STATIC_DRAW);\n  }\n\n  _setupFrameBuffer(options: TWebGLPipelineState) {\n    const gl = options.context;\n    if (options.passes > 1) {\n      const width = options.destinationWidth;\n      const height = options.destinationHeight;\n      if (options.sourceWidth !== width || options.sourceHeight !== height) {\n        gl.deleteTexture(options.targetTexture);\n        options.targetTexture = options.filterBackend.createTexture(\n          gl,\n          width,\n          height,\n        );\n      }\n      gl.framebufferTexture2D(\n        gl.FRAMEBUFFER,\n        gl.COLOR_ATTACHMENT0,\n        gl.TEXTURE_2D,\n        options.targetTexture,\n        0,\n      );\n    } else {\n      // draw last filter on canvas and not to framebuffer.\n      gl.bindFramebuffer(gl.FRAMEBUFFER, null);\n      gl.finish();\n    }\n  }\n\n  _swapTextures(options: TWebGLPipelineState) {\n    options.passes--;\n    options.pass++;\n    const temp = options.targetTexture;\n    options.targetTexture = options.sourceTexture;\n    options.sourceTexture = temp;\n  }\n\n  /**\n   * Generic isNeutral implementation for one parameter based filters.\n   * Used only in image applyFilters to discard filters that will not have an effect\n   * on the image\n   * Other filters may need their own version ( ColorMatrix, HueRotation, gamma, ComposedFilter )\n   * @param {Object} options\n   **/\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  isNeutralState(options?: any): boolean {\n    return false;\n  }\n\n  /**\n   * Apply this filter to the input image data provided.\n   *\n   * Determines whether to use WebGL or Canvas2D based on the options.webgl flag.\n   *\n   * @param {Object} options\n   * @param {Number} options.passes The number of filters remaining to be executed\n   * @param {Boolean} options.webgl Whether to use webgl to render the filter.\n   * @param {WebGLTexture} options.sourceTexture The texture setup as the source to be filtered.\n   * @param {WebGLTexture} options.targetTexture The texture where filtered output should be drawn.\n   * @param {WebGLRenderingContext} options.context The GL context used for rendering.\n   * @param {Object} options.programCache A map of compiled shader programs, keyed by filter type.\n   */\n  applyTo(options: TWebGLPipelineState | T2DPipelineState) {\n    if (isWebGLPipelineState(options)) {\n      this._setupFrameBuffer(options);\n      this.applyToWebGL(options);\n      this._swapTextures(options);\n    } else {\n      this.applyTo2d(options);\n    }\n  }\n\n  applyTo2d(_options: T2DPipelineState): void {\n    // override by subclass\n  }\n\n  /**\n   * Returns a string that represent the current selected shader code for the filter.\n   * Used to force recompilation when parameters change or to retrieve the shader from cache\n   * @type string\n   **/\n  getCacheKey(): string {\n    return this.type;\n  }\n\n  /**\n   * Retrieves the cached shader.\n   * @param {Object} options\n   * @param {WebGLRenderingContext} options.context The GL context used for rendering.\n   * @param {Object} options.programCache A map of compiled shader programs, keyed by filter type.\n   * @return {WebGLProgram} the compiled program shader\n   */\n  retrieveShader(options: TWebGLPipelineState): TWebGLProgramCacheItem {\n    const key = this.getCacheKey();\n    if (!options.programCache[key]) {\n      options.programCache[key] = this.createProgram(options.context);\n    }\n    return options.programCache[key];\n  }\n\n  /**\n   * Apply this filter using webgl.\n   *\n   * @param {Object} options\n   * @param {Number} options.passes The number of filters remaining to be executed\n   * @param {Boolean} options.webgl Whether to use webgl to render the filter.\n   * @param {WebGLTexture} options.originalTexture The texture of the original input image.\n   * @param {WebGLTexture} options.sourceTexture The texture setup as the source to be filtered.\n   * @param {WebGLTexture} options.targetTexture The texture where filtered output should be drawn.\n   * @param {WebGLRenderingContext} options.context The GL context used for rendering.\n   * @param {Object} options.programCache A map of compiled shader programs, keyed by filter type.\n   */\n  applyToWebGL(options: TWebGLPipelineState) {\n    const gl = options.context;\n    const shader = this.retrieveShader(options);\n    if (options.pass === 0 && options.originalTexture) {\n      gl.bindTexture(gl.TEXTURE_2D, options.originalTexture);\n    } else {\n      gl.bindTexture(gl.TEXTURE_2D, options.sourceTexture);\n    }\n    gl.useProgram(shader.program);\n    this.sendAttributeData(gl, shader.attributeLocations, options.aPosition);\n\n    gl.uniform1f(shader.uniformLocations.uStepW, 1 / options.sourceWidth);\n    gl.uniform1f(shader.uniformLocations.uStepH, 1 / options.sourceHeight);\n\n    this.sendUniformData(gl, shader.uniformLocations);\n    gl.viewport(0, 0, options.destinationWidth, options.destinationHeight);\n    gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);\n  }\n\n  bindAdditionalTexture(\n    gl: WebGLRenderingContext,\n    texture: WebGLTexture,\n    textureUnit: number,\n  ) {\n    gl.activeTexture(textureUnit);\n    gl.bindTexture(gl.TEXTURE_2D, texture);\n    // reset active texture to 0 as usual\n    gl.activeTexture(gl.TEXTURE0);\n  }\n\n  unbindAdditionalTexture(gl: WebGLRenderingContext, textureUnit: number) {\n    gl.activeTexture(textureUnit);\n    gl.bindTexture(gl.TEXTURE_2D, null);\n    gl.activeTexture(gl.TEXTURE0);\n  }\n\n  /**\n   * Send uniform data from this filter to its shader program on the GPU.\n   *\n   * Intended to be overridden by subclasses.\n   *\n   * @param {WebGLRenderingContext} _gl The canvas context used to compile the shader program.\n   * @param {Object} _uniformLocations A map of shader uniform names to their locations.\n   */\n  sendUniformData(\n    _gl: WebGLRenderingContext,\n    _uniformLocations: TWebGLUniformLocationMap,\n  ): void {\n    // override by subclass\n  }\n\n  /**\n   * If needed by a 2d filter, this functions can create an helper canvas to be used\n   * remember that options.targetCanvas is available for use till end of chain.\n   */\n  createHelpLayer(options: T2DPipelineState) {\n    if (!options.helpLayer) {\n      const { sourceWidth, sourceHeight } = options;\n      const helpLayer = createCanvasElementFor({\n        width: sourceWidth,\n        height: sourceHeight,\n      });\n      options.helpLayer = helpLayer;\n    }\n  }\n\n  /**\n   * Returns object representation of an instance\n   * It will automatically export the default values of a filter,\n   * stored in the static defaults property.\n   * @return {Object} Object representation of an instance\n   */\n  toObject(): { type: Name } & SerializedProps {\n    const defaultKeys = Object.keys(\n      (this.constructor as typeof BaseFilter).defaults || {},\n    ) as (keyof SerializedProps)[];\n\n    return {\n      type: this.type,\n      ...defaultKeys.reduce<SerializedProps>((acc, key) => {\n        acc[key] = this[\n          key as keyof this\n        ] as unknown as (typeof acc)[typeof key];\n        return acc;\n      }, {} as SerializedProps),\n    };\n  }\n\n  /**\n   * Returns a JSON representation of an instance\n   * @return {Object} JSON\n   */\n  toJSON() {\n    // delegate, not alias\n    return this.toObject();\n  }\n\n  static async fromObject(\n    { type, ...filterOptions }: Record<string, any>,\n    _options?: Abortable,\n  ): Promise<BaseFilter<string>> {\n    return new this(filterOptions);\n  }\n}\n"],"names":["regex","RegExp","highPsourceCode","BaseFilter","type","this","constructor","options","arguments","length","undefined","Object","assign","defaults","getFragmentSource","identityFragmentShader","getVertexSource","vertexSource","createProgram","gl","fragmentSource","WebGLProbe","GLPrecision","getEnv","replace","vertexShader","createShader","VERTEX_SHADER","fragmentShader","FRAGMENT_SHADER","program","FabricError","shaderSource","compileShader","getShaderParameter","COMPILE_STATUS","getShaderInfoLog","attachShader","linkProgram","getProgramParameter","LINK_STATUS","getProgramInfoLog","uniformLocations","getUniformLocations","uStepW","getUniformLocation","uStepH","attributeLocations","getAttributeLocations","aPosition","getAttribLocation","locations","i","sendAttributeData","aPositionData","attributeLocation","buffer","createBuffer","bindBuffer","ARRAY_BUFFER","enableVertexAttribArray","vertexAttribPointer","FLOAT","bufferData","STATIC_DRAW","_setupFrameBuffer","context","passes","width","destinationWidth","height","destinationHeight","sourceWidth","sourceHeight","deleteTexture","targetTexture","filterBackend","createTexture","framebufferTexture2D","FRAMEBUFFER","COLOR_ATTACHMENT0","TEXTURE_2D","bindFramebuffer","finish","_swapTextures","pass","temp","sourceTexture","isNeutralState","applyTo","isWebGLPipelineState","applyToWebGL","applyTo2d","_options","getCacheKey","retrieveShader","key","programCache","shader","originalTexture","bindTexture","useProgram","uniform1f","sendUniformData","viewport","drawArrays","TRIANGLE_STRIP","bindAdditionalTexture","texture","textureUnit","activeTexture","TEXTURE0","unbindAdditionalTexture","_gl","_uniformLocations","createHelpLayer","helpLayer","createCanvasElementFor","toObject","defaultKeys","keys","reduce","acc","toJSON","fromObject","_ref","filterOptions","_defineProperty"],"mappings":"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"}

package/dist/src/filters/BaseFilter.mjs

@@ -0,0 +1,334 @@
+import { defineProperty as _defineProperty } from '../../_virtual/_rollupPluginBabelHelpers.mjs';
+import { getEnv } from '../env/index.mjs';
+import { isWebGLPipelineState } from './utils.mjs';
+import { identityFragmentShader, vertexSource, highPsourceCode } from './shaders/baseFilter.mjs';
+import { FabricError } from '../util/internals/console.mjs';
+import { createCanvasElementFor } from '../util/misc/dom.mjs';
+
+const regex = new RegExp(highPsourceCode, 'g');
+class BaseFilter {
+  /**
+   * Filter type
+   */
+  get type() {
+    return this.constructor.type;
+  }
+
+  /**
+   * The class type. Used to identify which class this is.
+   * This is used for serialization purposes and internally it can be used
+   * to identify classes. As a developer you could use `instance of Class`
+   * but to avoid importing all the code and blocking tree shaking we try
+   * to avoid doing that.
+   */
+
+  /**
+   * Constructor
+   * @param {Object} [options] Options object
+   */
+  constructor() {
+    let {
+      type,
+      ...options
+    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    Object.assign(this, this.constructor.defaults, options);
+  }
+  getFragmentSource() {
+    return identityFragmentShader;
+  }
+  getVertexSource() {
+    return vertexSource;
+  }
+
+  /**
+   * Compile this filter's shader program.
+   *
+   * @param {WebGLRenderingContext} gl The GL canvas context to use for shader compilation.
+   * @param {String} fragmentSource fragmentShader source for compilation
+   * @param {String} vertexSource vertexShader source for compilation
+   */
+  createProgram(gl) {
+    let fragmentSource = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.getFragmentSource();
+    let vertexSource = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this.getVertexSource();
+    const {
+      WebGLProbe: {
+        GLPrecision = 'highp'
+      }
+    } = getEnv();
+    if (GLPrecision !== 'highp') {
+      fragmentSource = fragmentSource.replace(regex, highPsourceCode.replace('highp', GLPrecision));
+    }
+    const vertexShader = gl.createShader(gl.VERTEX_SHADER);
+    const fragmentShader = gl.createShader(gl.FRAGMENT_SHADER);
+    const program = gl.createProgram();
+    if (!vertexShader || !fragmentShader || !program) {
+      throw new FabricError('Vertex, fragment shader or program creation error');
+    }
+    gl.shaderSource(vertexShader, vertexSource);
+    gl.compileShader(vertexShader);
+    if (!gl.getShaderParameter(vertexShader, gl.COMPILE_STATUS)) {
+      throw new FabricError(`Vertex shader compile error for ${this.type}: ${gl.getShaderInfoLog(vertexShader)}`);
+    }
+    gl.shaderSource(fragmentShader, fragmentSource);
+    gl.compileShader(fragmentShader);
+    if (!gl.getShaderParameter(fragmentShader, gl.COMPILE_STATUS)) {
+      throw new FabricError(`Fragment shader compile error for ${this.type}: ${gl.getShaderInfoLog(fragmentShader)}`);
+    }
+    gl.attachShader(program, vertexShader);
+    gl.attachShader(program, fragmentShader);
+    gl.linkProgram(program);
+    if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
+      throw new FabricError(`Shader link error for "${this.type}" ${gl.getProgramInfoLog(program)}`);
+    }
+    const uniformLocations = this.getUniformLocations(gl, program) || {};
+    uniformLocations.uStepW = gl.getUniformLocation(program, 'uStepW');
+    uniformLocations.uStepH = gl.getUniformLocation(program, 'uStepH');
+    return {
+      program,
+      attributeLocations: this.getAttributeLocations(gl, program),
+      uniformLocations
+    };
+  }
+
+  /**
+   * Return a map of attribute names to WebGLAttributeLocation objects.
+   *
+   * @param {WebGLRenderingContext} gl The canvas context used to compile the shader program.
+   * @param {WebGLShaderProgram} program The shader program from which to take attribute locations.
+   * @returns {Object} A map of attribute names to attribute locations.
+   */
+  getAttributeLocations(gl, program) {
+    return {
+      aPosition: gl.getAttribLocation(program, 'aPosition')
+    };
+  }
+
+  /**
+   * Return a map of uniform names to WebGLUniformLocation objects.
+   *
+   * @param {WebGLRenderingContext} gl The canvas context used to compile the shader program.
+   * @param {WebGLShaderProgram} program The shader program from which to take uniform locations.
+   * @returns {Object} A map of uniform names to uniform locations.
+   */
+  getUniformLocations(gl, program) {
+    const locations = this.constructor.uniformLocations;
+    const uniformLocations = {};
+    for (let i = 0; i < locations.length; i++) {
+      uniformLocations[locations[i]] = gl.getUniformLocation(program, locations[i]);
+    }
+    return uniformLocations;
+  }
+
+  /**
+   * Send attribute data from this filter to its shader program on the GPU.
+   *
+   * @param {WebGLRenderingContext} gl The canvas context used to compile the shader program.
+   * @param {Object} attributeLocations A map of shader attribute names to their locations.
+   */
+  sendAttributeData(gl, attributeLocations, aPositionData) {
+    const attributeLocation = attributeLocations.aPosition;
+    const buffer = gl.createBuffer();
+    gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+    gl.enableVertexAttribArray(attributeLocation);
+    gl.vertexAttribPointer(attributeLocation, 2, gl.FLOAT, false, 0, 0);
+    gl.bufferData(gl.ARRAY_BUFFER, aPositionData, gl.STATIC_DRAW);
+  }
+  _setupFrameBuffer(options) {
+    const gl = options.context;
+    if (options.passes > 1) {
+      const width = options.destinationWidth;
+      const height = options.destinationHeight;
+      if (options.sourceWidth !== width || options.sourceHeight !== height) {
+        gl.deleteTexture(options.targetTexture);
+        options.targetTexture = options.filterBackend.createTexture(gl, width, height);
+      }
+      gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, options.targetTexture, 0);
+    } else {
+      // draw last filter on canvas and not to framebuffer.
+      gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+      gl.finish();
+    }
+  }
+  _swapTextures(options) {
+    options.passes--;
+    options.pass++;
+    const temp = options.targetTexture;
+    options.targetTexture = options.sourceTexture;
+    options.sourceTexture = temp;
+  }
+
+  /**
+   * Generic isNeutral implementation for one parameter based filters.
+   * Used only in image applyFilters to discard filters that will not have an effect
+   * on the image
+   * Other filters may need their own version ( ColorMatrix, HueRotation, gamma, ComposedFilter )
+   * @param {Object} options
+   **/
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  isNeutralState(options) {
+    return false;
+  }
+
+  /**
+   * Apply this filter to the input image data provided.
+   *
+   * Determines whether to use WebGL or Canvas2D based on the options.webgl flag.
+   *
+   * @param {Object} options
+   * @param {Number} options.passes The number of filters remaining to be executed
+   * @param {Boolean} options.webgl Whether to use webgl to render the filter.
+   * @param {WebGLTexture} options.sourceTexture The texture setup as the source to be filtered.
+   * @param {WebGLTexture} options.targetTexture The texture where filtered output should be drawn.
+   * @param {WebGLRenderingContext} options.context The GL context used for rendering.
+   * @param {Object} options.programCache A map of compiled shader programs, keyed by filter type.
+   */
+  applyTo(options) {
+    if (isWebGLPipelineState(options)) {
+      this._setupFrameBuffer(options);
+      this.applyToWebGL(options);
+      this._swapTextures(options);
+    } else {
+      this.applyTo2d(options);
+    }
+  }
+  applyTo2d(_options) {
+    // override by subclass
+  }
+
+  /**
+   * Returns a string that represent the current selected shader code for the filter.
+   * Used to force recompilation when parameters change or to retrieve the shader from cache
+   * @type string
+   **/
+  getCacheKey() {
+    return this.type;
+  }
+
+  /**
+   * Retrieves the cached shader.
+   * @param {Object} options
+   * @param {WebGLRenderingContext} options.context The GL context used for rendering.
+   * @param {Object} options.programCache A map of compiled shader programs, keyed by filter type.
+   * @return {WebGLProgram} the compiled program shader
+   */
+  retrieveShader(options) {
+    const key = this.getCacheKey();
+    if (!options.programCache[key]) {
+      options.programCache[key] = this.createProgram(options.context);
+    }
+    return options.programCache[key];
+  }
+
+  /**
+   * Apply this filter using webgl.
+   *
+   * @param {Object} options
+   * @param {Number} options.passes The number of filters remaining to be executed
+   * @param {Boolean} options.webgl Whether to use webgl to render the filter.
+   * @param {WebGLTexture} options.originalTexture The texture of the original input image.
+   * @param {WebGLTexture} options.sourceTexture The texture setup as the source to be filtered.
+   * @param {WebGLTexture} options.targetTexture The texture where filtered output should be drawn.
+   * @param {WebGLRenderingContext} options.context The GL context used for rendering.
+   * @param {Object} options.programCache A map of compiled shader programs, keyed by filter type.
+   */
+  applyToWebGL(options) {
+    const gl = options.context;
+    const shader = this.retrieveShader(options);
+    if (options.pass === 0 && options.originalTexture) {
+      gl.bindTexture(gl.TEXTURE_2D, options.originalTexture);
+    } else {
+      gl.bindTexture(gl.TEXTURE_2D, options.sourceTexture);
+    }
+    gl.useProgram(shader.program);
+    this.sendAttributeData(gl, shader.attributeLocations, options.aPosition);
+    gl.uniform1f(shader.uniformLocations.uStepW, 1 / options.sourceWidth);
+    gl.uniform1f(shader.uniformLocations.uStepH, 1 / options.sourceHeight);
+    this.sendUniformData(gl, shader.uniformLocations);
+    gl.viewport(0, 0, options.destinationWidth, options.destinationHeight);
+    gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+  }
+  bindAdditionalTexture(gl, texture, textureUnit) {
+    gl.activeTexture(textureUnit);
+    gl.bindTexture(gl.TEXTURE_2D, texture);
+    // reset active texture to 0 as usual
+    gl.activeTexture(gl.TEXTURE0);
+  }
+  unbindAdditionalTexture(gl, textureUnit) {
+    gl.activeTexture(textureUnit);
+    gl.bindTexture(gl.TEXTURE_2D, null);
+    gl.activeTexture(gl.TEXTURE0);
+  }
+
+  /**
+   * Send uniform data from this filter to its shader program on the GPU.
+   *
+   * Intended to be overridden by subclasses.
+   *
+   * @param {WebGLRenderingContext} _gl The canvas context used to compile the shader program.
+   * @param {Object} _uniformLocations A map of shader uniform names to their locations.
+   */
+  sendUniformData(_gl, _uniformLocations) {
+    // override by subclass
+  }
+
+  /**
+   * If needed by a 2d filter, this functions can create an helper canvas to be used
+   * remember that options.targetCanvas is available for use till end of chain.
+   */
+  createHelpLayer(options) {
+    if (!options.helpLayer) {
+      const {
+        sourceWidth,
+        sourceHeight
+      } = options;
+      const helpLayer = createCanvasElementFor({
+        width: sourceWidth,
+        height: sourceHeight
+      });
+      options.helpLayer = helpLayer;
+    }
+  }
+
+  /**
+   * Returns object representation of an instance
+   * It will automatically export the default values of a filter,
+   * stored in the static defaults property.
+   * @return {Object} Object representation of an instance
+   */
+  toObject() {
+    const defaultKeys = Object.keys(this.constructor.defaults || {});
+    return {
+      type: this.type,
+      ...defaultKeys.reduce((acc, key) => {
+        acc[key] = this[key];
+        return acc;
+      }, {})
+    };
+  }
+
+  /**
+   * Returns a JSON representation of an instance
+   * @return {Object} JSON
+   */
+  toJSON() {
+    // delegate, not alias
+    return this.toObject();
+  }
+  static async fromObject(_ref, _options) {
+    let {
+      type,
+      ...filterOptions
+    } = _ref;
+    return new this(filterOptions);
+  }
+}
+_defineProperty(BaseFilter, "type", 'BaseFilter');
+/**
+ * Contains the uniform locations for the fragment shader.
+ * uStepW and uStepH are handled by the BaseFilter, each filter class
+ * needs to specify all the one that are needed
+ */
+_defineProperty(BaseFilter, "uniformLocations", []);
+
+export { BaseFilter };
+//# sourceMappingURL=BaseFilter.mjs.map