@nasser-sw/fabric 7.0.0-beta1

package/dist/src/filters/GLProbes/NodeGLProbe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeGLProbe.d.ts","sourceRoot":"","sources":["../../../../src/filters/GLProbes/NodeGLProbe.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC;;;;GAIG;AACH,qBAAa,WAAY,SAAQ,OAAO;IACtC,UAAU;IAGV,WAAW;CAGZ"}

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/GLProbes/WebGLProbe.d.ts.map

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

package/dist/src/filters/GLProbes/WebGLProbe.min.mjs

@@ -0,0 +1,2 @@
+import{log as e}from"../../util/internals/console.min.mjs";import{GLProbe as t}from"./GLProbe.min.mjs";class i extends t{testPrecision(e,t){const i=`precision ${t} float;\nvoid main(){}`,r=e.createShader(e.FRAGMENT_SHADER);return!!r&&(e.shaderSource(r,i),e.compileShader(r),!!e.getShaderParameter(r,e.COMPILE_STATUS))}queryWebGL(t){const i=t.getContext("webgl");i&&(this.maxTextureSize=i.getParameter(i.MAX_TEXTURE_SIZE),this.GLPrecision=["highp","mediump","lowp"].find(e=>this.testPrecision(i,e)),i.getExtension("WEBGL_lose_context").loseContext(),e("log",`WebGL: max texture size ${this.maxTextureSize}`))}isSupported(e){return!!this.maxTextureSize&&this.maxTextureSize>=e}}export{i as WebGLProbe};
+//# sourceMappingURL=WebGLProbe.min.mjs.map

package/dist/src/filters/GLProbes/WebGLProbe.min.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebGLProbe.min.mjs","sources":["../../../../src/filters/GLProbes/WebGLProbe.ts"],"sourcesContent":["import { log } from '../../util/internals/console';\nimport { GLProbe } from './GLProbe';\nimport type { GLPrecision } from './GLProbe';\n\n/**\n * Lazy initialize WebGL constants\n */\nexport class WebGLProbe extends GLProbe {\n  declare maxTextureSize?: number;\n\n  /**\n   * Tests if webgl supports certain precision\n   * @param {WebGL} Canvas WebGL context to test on\n   * @param {GLPrecision} Precision to test can be any of following\n   * @returns {Boolean} Whether the user's browser WebGL supports given precision.\n   */\n  private testPrecision(\n    gl: WebGLRenderingContext,\n    precision: GLPrecision,\n  ): boolean {\n    const fragmentSource = `precision ${precision} float;\\nvoid main(){}`;\n    const fragmentShader = gl.createShader(gl.FRAGMENT_SHADER);\n    if (!fragmentShader) {\n      return false;\n    }\n    gl.shaderSource(fragmentShader, fragmentSource);\n    gl.compileShader(fragmentShader);\n    return !!gl.getShaderParameter(fragmentShader, gl.COMPILE_STATUS);\n  }\n\n  /**\n   * query browser for WebGL\n   */\n  queryWebGL(canvas: HTMLCanvasElement) {\n    const gl = canvas.getContext('webgl');\n    if (gl) {\n      this.maxTextureSize = gl.getParameter(gl.MAX_TEXTURE_SIZE);\n      this.GLPrecision = (['highp', 'mediump', 'lowp'] as const).find(\n        (precision) => this.testPrecision(gl, precision),\n      );\n      gl.getExtension('WEBGL_lose_context')!.loseContext();\n      log('log', `WebGL: max texture size ${this.maxTextureSize}`);\n    }\n  }\n\n  isSupported(textureSize: number) {\n    return !!this.maxTextureSize && this.maxTextureSize >= textureSize;\n  }\n}\n"],"names":["WebGLProbe","GLProbe","testPrecision","gl","precision","fragmentSource","fragmentShader","createShader","FRAGMENT_SHADER","shaderSource","compileShader","getShaderParameter","COMPILE_STATUS","queryWebGL","canvas","getContext","this","maxTextureSize","getParameter","MAX_TEXTURE_SIZE","GLPrecision","find","getExtension","loseContext","log","isSupported","textureSize"],"mappings":"uGAOO,MAAMA,UAAmBC,EAStBC,aAAAA,CACNC,EACAC,GAEA,MAAMC,EAAiB,aAAaD,0BAC9BE,EAAiBH,EAAGI,aAAaJ,EAAGK,iBAC1C,QAAKF,IAGLH,EAAGM,aAAaH,EAAgBD,GAChCF,EAAGO,cAAcJ,KACRH,EAAGQ,mBAAmBL,EAAgBH,EAAGS,gBACpD,CAKAC,UAAAA,CAAWC,GACT,MAAMX,EAAKW,EAAOC,WAAW,SACzBZ,IACFa,KAAKC,eAAiBd,EAAGe,aAAaf,EAAGgB,kBACzCH,KAAKI,YAAe,CAAC,QAAS,UAAW,QAAkBC,KACxDjB,GAAcY,KAAKd,cAAcC,EAAIC,IAExCD,EAAGmB,aAAa,sBAAuBC,cACvCC,EAAI,MAAO,2BAA2BR,KAAKC,kBAE/C,CAEAQ,WAAAA,CAAYC,GACV,QAASV,KAAKC,gBAAkBD,KAAKC,gBAAkBS,CACzD"}

package/dist/src/filters/GLProbes/WebGLProbe.mjs

@@ -0,0 +1,43 @@
+import { log } from '../../util/internals/console.mjs';
+import { GLProbe } from './GLProbe.mjs';
+
+/**
+ * Lazy initialize WebGL constants
+ */
+class WebGLProbe extends GLProbe {
+  /**
+   * 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.
+   */
+  testPrecision(gl, precision) {
+    const fragmentSource = `precision ${precision} float;\nvoid main(){}`;
+    const fragmentShader = gl.createShader(gl.FRAGMENT_SHADER);
+    if (!fragmentShader) {
+      return false;
+    }
+    gl.shaderSource(fragmentShader, fragmentSource);
+    gl.compileShader(fragmentShader);
+    return !!gl.getShaderParameter(fragmentShader, gl.COMPILE_STATUS);
+  }
+
+  /**
+   * query browser for WebGL
+   */
+  queryWebGL(canvas) {
+    const gl = canvas.getContext('webgl');
+    if (gl) {
+      this.maxTextureSize = gl.getParameter(gl.MAX_TEXTURE_SIZE);
+      this.GLPrecision = ['highp', 'mediump', 'lowp'].find(precision => this.testPrecision(gl, precision));
+      gl.getExtension('WEBGL_lose_context').loseContext();
+      log('log', `WebGL: max texture size ${this.maxTextureSize}`);
+    }
+  }
+  isSupported(textureSize) {
+    return !!this.maxTextureSize && this.maxTextureSize >= textureSize;
+  }
+}
+
+export { WebGLProbe };
+//# sourceMappingURL=WebGLProbe.mjs.map

package/dist/src/filters/GLProbes/WebGLProbe.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebGLProbe.mjs","sources":["../../../../src/filters/GLProbes/WebGLProbe.ts"],"sourcesContent":["import { log } from '../../util/internals/console';\nimport { GLProbe } from './GLProbe';\nimport type { GLPrecision } from './GLProbe';\n\n/**\n * Lazy initialize WebGL constants\n */\nexport class WebGLProbe extends GLProbe {\n  declare maxTextureSize?: number;\n\n  /**\n   * Tests if webgl supports certain precision\n   * @param {WebGL} Canvas WebGL context to test on\n   * @param {GLPrecision} Precision to test can be any of following\n   * @returns {Boolean} Whether the user's browser WebGL supports given precision.\n   */\n  private testPrecision(\n    gl: WebGLRenderingContext,\n    precision: GLPrecision,\n  ): boolean {\n    const fragmentSource = `precision ${precision} float;\\nvoid main(){}`;\n    const fragmentShader = gl.createShader(gl.FRAGMENT_SHADER);\n    if (!fragmentShader) {\n      return false;\n    }\n    gl.shaderSource(fragmentShader, fragmentSource);\n    gl.compileShader(fragmentShader);\n    return !!gl.getShaderParameter(fragmentShader, gl.COMPILE_STATUS);\n  }\n\n  /**\n   * query browser for WebGL\n   */\n  queryWebGL(canvas: HTMLCanvasElement) {\n    const gl = canvas.getContext('webgl');\n    if (gl) {\n      this.maxTextureSize = gl.getParameter(gl.MAX_TEXTURE_SIZE);\n      this.GLPrecision = (['highp', 'mediump', 'lowp'] as const).find(\n        (precision) => this.testPrecision(gl, precision),\n      );\n      gl.getExtension('WEBGL_lose_context')!.loseContext();\n      log('log', `WebGL: max texture size ${this.maxTextureSize}`);\n    }\n  }\n\n  isSupported(textureSize: number) {\n    return !!this.maxTextureSize && this.maxTextureSize >= textureSize;\n  }\n}\n"],"names":["WebGLProbe","GLProbe","testPrecision","gl","precision","fragmentSource","fragmentShader","createShader","FRAGMENT_SHADER","shaderSource","compileShader","getShaderParameter","COMPILE_STATUS","queryWebGL","canvas","getContext","maxTextureSize","getParameter","MAX_TEXTURE_SIZE","GLPrecision","find","getExtension","loseContext","log","isSupported","textureSize"],"mappings":";;;AAIA;AACA;AACA;AACO,MAAMA,UAAU,SAASC,OAAO,CAAC;AAGtC;AACF;AACA;AACA;AACA;AACA;AACUC,EAAAA,aAAaA,CACnBC,EAAyB,EACzBC,SAAsB,EACb;AACT,IAAA,MAAMC,cAAc,GAAG,CAAA,UAAA,EAAaD,SAAS,CAAA,sBAAA,CAAwB;IACrE,MAAME,cAAc,GAAGH,EAAE,CAACI,YAAY,CAACJ,EAAE,CAACK,eAAe,CAAC;IAC1D,IAAI,CAACF,cAAc,EAAE;AACnB,MAAA,OAAO,KAAK;AACd,IAAA;AACAH,IAAAA,EAAE,CAACM,YAAY,CAACH,cAAc,EAAED,cAAc,CAAC;AAC/CF,IAAAA,EAAE,CAACO,aAAa,CAACJ,cAAc,CAAC;IAChC,OAAO,CAAC,CAACH,EAAE,CAACQ,kBAAkB,CAACL,cAAc,EAAEH,EAAE,CAACS,cAAc,CAAC;AACnE,EAAA;;AAEA;AACF;AACA;EACEC,UAAUA,CAACC,MAAyB,EAAE;AACpC,IAAA,MAAMX,EAAE,GAAGW,MAAM,CAACC,UAAU,CAAC,OAAO,CAAC;AACrC,IAAA,IAAIZ,EAAE,EAAE;MACN,IAAI,CAACa,cAAc,GAAGb,EAAE,CAACc,YAAY,CAACd,EAAE,CAACe,gBAAgB,CAAC;MAC1D,IAAI,CAACC,WAAW,GAAI,CAAC,OAAO,EAAE,SAAS,EAAE,MAAM,CAAC,CAAWC,IAAI,CAC5DhB,SAAS,IAAK,IAAI,CAACF,aAAa,CAACC,EAAE,EAAEC,SAAS,CACjD,CAAC;MACDD,EAAE,CAACkB,YAAY,CAAC,oBAAoB,CAAC,CAAEC,WAAW,EAAE;MACpDC,GAAG,CAAC,KAAK,EAAE,CAAA,wBAAA,EAA2B,IAAI,CAACP,cAAc,EAAE,CAAC;AAC9D,IAAA;AACF,EAAA;EAEAQ,WAAWA,CAACC,WAAmB,EAAE;IAC/B,OAAO,CAAC,CAAC,IAAI,CAACT,cAAc,IAAI,IAAI,CAACA,cAAc,IAAIS,WAAW;AACpE,EAAA;AACF;;;;"}

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

@@ -0,0 +1,57 @@
+import { BaseFilter } from './BaseFilter';
+import type { T2DPipelineState, TWebGLUniformLocationMap } from './typedefs';
+declare const GAMMA: "Gamma";
+export type GammaInput = [number, number, number];
+export type GammaOwnProps = {
+    gamma: GammaInput;
+};
+export declare const gammaDefaultValues: GammaOwnProps;
+/**
+ * Gamma filter class
+ * @example
+ * const filter = new Gamma({
+ *   gamma: [1, 0.5, 2.1]
+ * });
+ * object.filters.push(filter);
+ * object.applyFilters();
+ */
+export declare class Gamma extends BaseFilter<typeof GAMMA, GammaOwnProps> {
+    /**
+     * Gamma array value, from 0.01 to 2.2.
+     * @param {Array} gamma
+     */
+    gamma: GammaOwnProps['gamma'];
+    rgbValues?: {
+        r: Uint8Array;
+        g: Uint8Array;
+        b: Uint8Array;
+    };
+    static type: "Gamma";
+    static defaults: GammaOwnProps;
+    static uniformLocations: string[];
+    getFragmentSource(): string;
+    constructor(options?: {
+        gamma?: GammaInput;
+    });
+    /**
+     * Apply the Gamma operation to a Uint8Array representing the pixels of an image.
+     *
+     * @param {Object} options
+     * @param {ImageData} options.imageData The Uint8Array to be filtered.
+     */
+    applyTo2d({ imageData: { data } }: T2DPipelineState): void;
+    /**
+     * Send data from this filter to its shader program's uniforms.
+     *
+     * @param {WebGLRenderingContext} gl The GL canvas context used to compile this filter's shader.
+     * @param {Object} uniformLocations A map of string uniform names to WebGLUniformLocation objects
+     */
+    sendUniformData(gl: WebGLRenderingContext, uniformLocations: TWebGLUniformLocationMap): void;
+    isNeutralState(): boolean;
+    toObject(): {
+        type: typeof GAMMA;
+        gamma: GammaInput;
+    };
+}
+export {};
+//# sourceMappingURL=Gamma.d.ts.map

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

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

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

@@ -0,0 +1,2 @@
+import{defineProperty as t}from"../../_virtual/_rollupPluginBabelHelpers.min.mjs";import{BaseFilter as a}from"./BaseFilter.min.mjs";import{classRegistry as r}from"../ClassRegistry.min.mjs";import{fragmentSource as m}from"./shaders/gamma.min.mjs";const e="Gamma",s={gamma:[1,1,1]};class o extends a{getFragmentSource(){return m}constructor(){let t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};super(t),this.gamma=t.gamma||this.constructor.defaults.gamma.concat()}applyTo2d(t){let{imageData:{data:a}}=t;const r=this.gamma,m=1/r[0],e=1/r[1],s=1/r[2];this.rgbValues||(this.rgbValues={r:new Uint8Array(256),g:new Uint8Array(256),b:new Uint8Array(256)});const o=this.rgbValues;for(let t=0;t<256;t++)o.r[t]=255*Math.pow(t/255,m),o.g[t]=255*Math.pow(t/255,e),o.b[t]=255*Math.pow(t/255,s);for(let t=0;t<a.length;t+=4)a[t]=o.r[a[t]],a[t+1]=o.g[a[t+1]],a[t+2]=o.b[a[t+2]]}sendUniformData(t,a){t.uniform3fv(a.uGamma,this.gamma)}isNeutralState(){const{gamma:t}=this;return 1===t[0]&&1===t[1]&&1===t[2]}toObject(){return{type:e,gamma:this.gamma.concat()}}}t(o,"type",e),t(o,"defaults",s),t(o,"uniformLocations",["uGamma"]),r.setClass(o);export{o as Gamma,s as gammaDefaultValues};
+//# sourceMappingURL=Gamma.min.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Gamma.min.mjs","sources":["../../../src/filters/Gamma.ts"],"sourcesContent":["import { BaseFilter } from './BaseFilter';\nimport { classRegistry } from '../ClassRegistry';\nimport { fragmentSource } from './shaders/gamma';\nimport type { T2DPipelineState, TWebGLUniformLocationMap } from './typedefs';\n\nconst GAMMA = 'Gamma' as const;\n\nexport type GammaInput = [number, number, number];\n\nexport type GammaOwnProps = {\n  gamma: GammaInput;\n};\n\nexport const gammaDefaultValues: GammaOwnProps = {\n  gamma: [1, 1, 1],\n};\n\n/**\n * Gamma filter class\n * @example\n * const filter = new Gamma({\n *   gamma: [1, 0.5, 2.1]\n * });\n * object.filters.push(filter);\n * object.applyFilters();\n */\nexport class Gamma extends BaseFilter<typeof GAMMA, GammaOwnProps> {\n  /**\n   * Gamma array value, from 0.01 to 2.2.\n   * @param {Array} gamma\n   */\n  declare gamma: GammaOwnProps['gamma'];\n  declare rgbValues?: {\n    r: Uint8Array;\n    g: Uint8Array;\n    b: Uint8Array;\n  };\n\n  static type = GAMMA;\n\n  static defaults = gammaDefaultValues;\n\n  static uniformLocations = ['uGamma'];\n\n  getFragmentSource() {\n    return fragmentSource;\n  }\n\n  constructor(options: { gamma?: GammaInput } = {}) {\n    super(options);\n    this.gamma =\n      options.gamma ||\n      ((\n        this.constructor as typeof Gamma\n      ).defaults.gamma.concat() as GammaInput);\n  }\n\n  /**\n   * Apply the Gamma operation to a Uint8Array representing the pixels of an image.\n   *\n   * @param {Object} options\n   * @param {ImageData} options.imageData The Uint8Array to be filtered.\n   */\n  applyTo2d({ imageData: { data } }: T2DPipelineState) {\n    const gamma = this.gamma,\n      rInv = 1 / gamma[0],\n      gInv = 1 / gamma[1],\n      bInv = 1 / gamma[2];\n\n    if (!this.rgbValues) {\n      this.rgbValues = {\n        r: new Uint8Array(256),\n        g: new Uint8Array(256),\n        b: new Uint8Array(256),\n      };\n    }\n\n    // This is an optimization - pre-compute a look-up table for each color channel\n    // instead of performing these pow calls for each pixel in the image.\n    const rgb = this.rgbValues;\n    for (let i = 0; i < 256; i++) {\n      rgb.r[i] = Math.pow(i / 255, rInv) * 255;\n      rgb.g[i] = Math.pow(i / 255, gInv) * 255;\n      rgb.b[i] = Math.pow(i / 255, bInv) * 255;\n    }\n    for (let i = 0; i < data.length; i += 4) {\n      data[i] = rgb.r[data[i]];\n      data[i + 1] = rgb.g[data[i + 1]];\n      data[i + 2] = rgb.b[data[i + 2]];\n    }\n  }\n\n  /**\n   * Send data from this filter to its shader program's uniforms.\n   *\n   * @param {WebGLRenderingContext} gl The GL canvas context used to compile this filter's shader.\n   * @param {Object} uniformLocations A map of string uniform names to WebGLUniformLocation objects\n   */\n  sendUniformData(\n    gl: WebGLRenderingContext,\n    uniformLocations: TWebGLUniformLocationMap,\n  ) {\n    gl.uniform3fv(uniformLocations.uGamma, this.gamma);\n  }\n\n  isNeutralState() {\n    const { gamma } = this;\n    return gamma[0] === 1 && gamma[1] === 1 && gamma[2] === 1;\n  }\n\n  toObject(): { type: typeof GAMMA; gamma: GammaInput } {\n    return {\n      type: GAMMA,\n      gamma: this.gamma.concat() as GammaInput,\n    };\n  }\n}\n\nclassRegistry.setClass(Gamma);\n"],"names":["GAMMA","gammaDefaultValues","gamma","Gamma","BaseFilter","getFragmentSource","fragmentSource","constructor","options","arguments","length","undefined","super","this","defaults","concat","applyTo2d","_ref","imageData","data","rInv","gInv","bInv","rgbValues","r","Uint8Array","g","b","rgb","i","Math","pow","sendUniformData","gl","uniformLocations","uniform3fv","uGamma","isNeutralState","toObject","type","_defineProperty","classRegistry","setClass"],"mappings":"sPAKA,MAAMA,EAAQ,QAQDC,EAAoC,CAC/CC,MAAO,CAAC,EAAG,EAAG,IAYT,MAAMC,UAAcC,EAkBzBC,iBAAAA,GACE,OAAOC,CACT,CAEAC,WAAAA,GAAkD,IAAtCC,EAA+BC,UAAAC,OAAA,QAAAC,IAAAF,UAAA,GAAAA,UAAA,GAAG,CAAA,EAC5CG,MAAMJ,GACNK,KAAKX,MACHM,EAAQN,OAENW,KAAKN,YACLO,SAASZ,MAAMa,QACrB,CAQAC,SAAAA,CAASC,GAA4C,IAAzCC,WAAWC,KAAEA,IAA0BF,EACjD,MAAMf,EAAQW,KAAKX,MACjBkB,EAAO,EAAIlB,EAAM,GACjBmB,EAAO,EAAInB,EAAM,GACjBoB,EAAO,EAAIpB,EAAM,GAEdW,KAAKU,YACRV,KAAKU,UAAY,CACfC,EAAG,IAAIC,WAAW,KAClBC,EAAG,IAAID,WAAW,KAClBE,EAAG,IAAIF,WAAW,OAMtB,MAAMG,EAAMf,KAAKU,UACjB,IAAK,IAAIM,EAAI,EAAGA,EAAI,IAAKA,IACvBD,EAAIJ,EAAEK,GAA+B,IAA1BC,KAAKC,IAAIF,EAAI,IAAKT,GAC7BQ,EAAIF,EAAEG,GAA+B,IAA1BC,KAAKC,IAAIF,EAAI,IAAKR,GAC7BO,EAAID,EAAEE,GAA+B,IAA1BC,KAAKC,IAAIF,EAAI,IAAKP,GAE/B,IAAK,IAAIO,EAAI,EAAGA,EAAIV,EAAKT,OAAQmB,GAAK,EACpCV,EAAKU,GAAKD,EAAIJ,EAAEL,EAAKU,IACrBV,EAAKU,EAAI,GAAKD,EAAIF,EAAEP,EAAKU,EAAI,IAC7BV,EAAKU,EAAI,GAAKD,EAAID,EAAER,EAAKU,EAAI,GAEjC,CAQAG,eAAAA,CACEC,EACAC,GAEAD,EAAGE,WAAWD,EAAiBE,OAAQvB,KAAKX,MAC9C,CAEAmC,cAAAA,GACE,MAAMnC,MAAEA,GAAUW,KAClB,OAAoB,IAAbX,EAAM,IAAyB,IAAbA,EAAM,IAAyB,IAAbA,EAAM,EACnD,CAEAoC,QAAAA,GACE,MAAO,CACLC,KAAMvC,EACNE,MAAOW,KAAKX,MAAMa,SAEtB,EAxFAyB,EADWrC,EAAK,OAYFH,GAAKwC,EAZRrC,EAAK,WAcEF,GAAkBuC,EAdzBrC,EAAK,mBAgBU,CAAC,WA4E7BsC,EAAcC,SAASvC"}

package/dist/src/filters/Gamma.mjs

@@ -0,0 +1,101 @@
+import { defineProperty as _defineProperty } from '../../_virtual/_rollupPluginBabelHelpers.mjs';
+import { BaseFilter } from './BaseFilter.mjs';
+import { classRegistry } from '../ClassRegistry.mjs';
+import { fragmentSource } from './shaders/gamma.mjs';
+
+const GAMMA = 'Gamma';
+const gammaDefaultValues = {
+  gamma: [1, 1, 1]
+};
+
+/**
+ * Gamma filter class
+ * @example
+ * const filter = new Gamma({
+ *   gamma: [1, 0.5, 2.1]
+ * });
+ * object.filters.push(filter);
+ * object.applyFilters();
+ */
+class Gamma extends BaseFilter {
+  getFragmentSource() {
+    return fragmentSource;
+  }
+  constructor() {
+    let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    super(options);
+    this.gamma = options.gamma || this.constructor.defaults.gamma.concat();
+  }
+
+  /**
+   * 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(_ref) {
+    let {
+      imageData: {
+        data
+      }
+    } = _ref;
+    const gamma = this.gamma,
+      rInv = 1 / gamma[0],
+      gInv = 1 / gamma[1],
+      bInv = 1 / gamma[2];
+    if (!this.rgbValues) {
+      this.rgbValues = {
+        r: new Uint8Array(256),
+        g: new Uint8Array(256),
+        b: new Uint8Array(256)
+      };
+    }
+
+    // This is an optimization - pre-compute a look-up table for each color channel
+    // instead of performing these pow calls for each pixel in the image.
+    const rgb = this.rgbValues;
+    for (let i = 0; i < 256; i++) {
+      rgb.r[i] = Math.pow(i / 255, rInv) * 255;
+      rgb.g[i] = Math.pow(i / 255, gInv) * 255;
+      rgb.b[i] = Math.pow(i / 255, bInv) * 255;
+    }
+    for (let i = 0; i < data.length; i += 4) {
+      data[i] = rgb.r[data[i]];
+      data[i + 1] = rgb.g[data[i + 1]];
+      data[i + 2] = rgb.b[data[i + 2]];
+    }
+  }
+
+  /**
+   * 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, uniformLocations) {
+    gl.uniform3fv(uniformLocations.uGamma, this.gamma);
+  }
+  isNeutralState() {
+    const {
+      gamma
+    } = this;
+    return gamma[0] === 1 && gamma[1] === 1 && gamma[2] === 1;
+  }
+  toObject() {
+    return {
+      type: GAMMA,
+      gamma: this.gamma.concat()
+    };
+  }
+}
+/**
+ * Gamma array value, from 0.01 to 2.2.
+ * @param {Array} gamma
+ */
+_defineProperty(Gamma, "type", GAMMA);
+_defineProperty(Gamma, "defaults", gammaDefaultValues);
+_defineProperty(Gamma, "uniformLocations", ['uGamma']);
+classRegistry.setClass(Gamma);
+
+export { Gamma, gammaDefaultValues };
+//# sourceMappingURL=Gamma.mjs.map

package/dist/src/filters/Gamma.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Gamma.mjs","sources":["../../../src/filters/Gamma.ts"],"sourcesContent":["import { BaseFilter } from './BaseFilter';\nimport { classRegistry } from '../ClassRegistry';\nimport { fragmentSource } from './shaders/gamma';\nimport type { T2DPipelineState, TWebGLUniformLocationMap } from './typedefs';\n\nconst GAMMA = 'Gamma' as const;\n\nexport type GammaInput = [number, number, number];\n\nexport type GammaOwnProps = {\n  gamma: GammaInput;\n};\n\nexport const gammaDefaultValues: GammaOwnProps = {\n  gamma: [1, 1, 1],\n};\n\n/**\n * Gamma filter class\n * @example\n * const filter = new Gamma({\n *   gamma: [1, 0.5, 2.1]\n * });\n * object.filters.push(filter);\n * object.applyFilters();\n */\nexport class Gamma extends BaseFilter<typeof GAMMA, GammaOwnProps> {\n  /**\n   * Gamma array value, from 0.01 to 2.2.\n   * @param {Array} gamma\n   */\n  declare gamma: GammaOwnProps['gamma'];\n  declare rgbValues?: {\n    r: Uint8Array;\n    g: Uint8Array;\n    b: Uint8Array;\n  };\n\n  static type = GAMMA;\n\n  static defaults = gammaDefaultValues;\n\n  static uniformLocations = ['uGamma'];\n\n  getFragmentSource() {\n    return fragmentSource;\n  }\n\n  constructor(options: { gamma?: GammaInput } = {}) {\n    super(options);\n    this.gamma =\n      options.gamma ||\n      ((\n        this.constructor as typeof Gamma\n      ).defaults.gamma.concat() as GammaInput);\n  }\n\n  /**\n   * Apply the Gamma operation to a Uint8Array representing the pixels of an image.\n   *\n   * @param {Object} options\n   * @param {ImageData} options.imageData The Uint8Array to be filtered.\n   */\n  applyTo2d({ imageData: { data } }: T2DPipelineState) {\n    const gamma = this.gamma,\n      rInv = 1 / gamma[0],\n      gInv = 1 / gamma[1],\n      bInv = 1 / gamma[2];\n\n    if (!this.rgbValues) {\n      this.rgbValues = {\n        r: new Uint8Array(256),\n        g: new Uint8Array(256),\n        b: new Uint8Array(256),\n      };\n    }\n\n    // This is an optimization - pre-compute a look-up table for each color channel\n    // instead of performing these pow calls for each pixel in the image.\n    const rgb = this.rgbValues;\n    for (let i = 0; i < 256; i++) {\n      rgb.r[i] = Math.pow(i / 255, rInv) * 255;\n      rgb.g[i] = Math.pow(i / 255, gInv) * 255;\n      rgb.b[i] = Math.pow(i / 255, bInv) * 255;\n    }\n    for (let i = 0; i < data.length; i += 4) {\n      data[i] = rgb.r[data[i]];\n      data[i + 1] = rgb.g[data[i + 1]];\n      data[i + 2] = rgb.b[data[i + 2]];\n    }\n  }\n\n  /**\n   * Send data from this filter to its shader program's uniforms.\n   *\n   * @param {WebGLRenderingContext} gl The GL canvas context used to compile this filter's shader.\n   * @param {Object} uniformLocations A map of string uniform names to WebGLUniformLocation objects\n   */\n  sendUniformData(\n    gl: WebGLRenderingContext,\n    uniformLocations: TWebGLUniformLocationMap,\n  ) {\n    gl.uniform3fv(uniformLocations.uGamma, this.gamma);\n  }\n\n  isNeutralState() {\n    const { gamma } = this;\n    return gamma[0] === 1 && gamma[1] === 1 && gamma[2] === 1;\n  }\n\n  toObject(): { type: typeof GAMMA; gamma: GammaInput } {\n    return {\n      type: GAMMA,\n      gamma: this.gamma.concat() as GammaInput,\n    };\n  }\n}\n\nclassRegistry.setClass(Gamma);\n"],"names":["GAMMA","gammaDefaultValues","gamma","Gamma","BaseFilter","getFragmentSource","fragmentSource","constructor","options","arguments","length","undefined","defaults","concat","applyTo2d","_ref","imageData","data","rInv","gInv","bInv","rgbValues","r","Uint8Array","g","b","rgb","i","Math","pow","sendUniformData","gl","uniformLocations","uniform3fv","uGamma","isNeutralState","toObject","type","_defineProperty","classRegistry","setClass"],"mappings":"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"}

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

@@ -0,0 +1,44 @@
+import { BaseFilter } from './BaseFilter';
+import type { T2DPipelineState, TWebGLUniformLocationMap } from './typedefs';
+export type TGrayscaleMode = 'average' | 'lightness' | 'luminosity';
+type GrayscaleOwnProps = {
+    mode: TGrayscaleMode;
+};
+export declare const grayscaleDefaultValues: GrayscaleOwnProps;
+/**
+ * Grayscale image filter class
+ * @example
+ * const filter = new Grayscale();
+ * object.filters.push(filter);
+ * object.applyFilters();
+ */
+export declare class Grayscale extends BaseFilter<'Grayscale', GrayscaleOwnProps> {
+    mode: TGrayscaleMode;
+    static type: string;
+    static defaults: GrayscaleOwnProps;
+    static uniformLocations: string[];
+    /**
+     * Apply the Grayscale operation to a Uint8Array representing the pixels of an image.
+     *
+     * @param {Object} options
+     * @param {ImageData} options.imageData The Uint8Array to be filtered.
+     */
+    applyTo2d({ imageData: { data } }: T2DPipelineState): void;
+    getCacheKey(): string;
+    getFragmentSource(): string;
+    /**
+     * Send data from this filter to its shader program's uniforms.
+     *
+     * @param {WebGLRenderingContext} gl The GL canvas context used to compile this filter's shader.
+     * @param {Object} uniformLocations A map of string uniform names to WebGLUniformLocation objects
+     */
+    sendUniformData(gl: WebGLRenderingContext, uniformLocations: TWebGLUniformLocationMap): void;
+    /**
+     * Grayscale filter isNeutralState implementation
+     * The filter is never neutral
+     * on the image
+     **/
+    isNeutralState(): boolean;
+}
+export {};
+//# sourceMappingURL=Grayscale.d.ts.map

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

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

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

@@ -0,0 +1,2 @@
+import{defineProperty as e}from"../../_virtual/_rollupPluginBabelHelpers.min.mjs";import{BaseFilter as t}from"./BaseFilter.min.mjs";import{classRegistry as a}from"../ClassRegistry.min.mjs";import{fragmentSource as s}from"./shaders/grayscale.min.mjs";const r={mode:"average"};class i extends t{applyTo2d(e){let{imageData:{data:t}}=e;for(let e,a=0;a<t.length;a+=4){const s=t[a],r=t[a+1],i=t[a+2];switch(this.mode){case"average":e=(s+r+i)/3;break;case"lightness":e=(Math.min(s,r,i)+Math.max(s,r,i))/2;break;case"luminosity":e=.21*s+.72*r+.07*i}t[a+2]=t[a+1]=t[a]=e}}getCacheKey(){return`${this.type}_${this.mode}`}getFragmentSource(){return s[this.mode]}sendUniformData(e,t){e.uniform1i(t.uMode,1)}isNeutralState(){return!1}}e(i,"type","Grayscale"),e(i,"defaults",r),e(i,"uniformLocations",["uMode"]),a.setClass(i);export{i as Grayscale,r as grayscaleDefaultValues};
+//# sourceMappingURL=Grayscale.min.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Grayscale.min.mjs","sources":["../../../src/filters/Grayscale.ts"],"sourcesContent":["import { BaseFilter } from './BaseFilter';\nimport type { T2DPipelineState, TWebGLUniformLocationMap } from './typedefs';\nimport { classRegistry } from '../ClassRegistry';\nimport { fragmentSource } from './shaders/grayscale';\n\nexport type TGrayscaleMode = 'average' | 'lightness' | 'luminosity';\n\ntype GrayscaleOwnProps = {\n  mode: TGrayscaleMode;\n};\n\nexport const grayscaleDefaultValues: GrayscaleOwnProps = {\n  mode: 'average',\n};\n\n/**\n * Grayscale image filter class\n * @example\n * const filter = new Grayscale();\n * object.filters.push(filter);\n * object.applyFilters();\n */\nexport class Grayscale extends BaseFilter<'Grayscale', GrayscaleOwnProps> {\n  declare mode: TGrayscaleMode;\n\n  static type = 'Grayscale';\n\n  static defaults = grayscaleDefaultValues;\n\n  static uniformLocations = ['uMode'];\n\n  /**\n   * Apply the Grayscale operation to a Uint8Array representing the pixels of an image.\n   *\n   * @param {Object} options\n   * @param {ImageData} options.imageData The Uint8Array to be filtered.\n   */\n  applyTo2d({ imageData: { data } }: T2DPipelineState) {\n    for (let i = 0, value: number; i < data.length; i += 4) {\n      const r = data[i];\n      const g = data[i + 1];\n      const b = data[i + 2];\n      switch (this.mode) {\n        case 'average':\n          value = (r + g + b) / 3;\n          break;\n        case 'lightness':\n          value = (Math.min(r, g, b) + Math.max(r, g, b)) / 2;\n          break;\n        case 'luminosity':\n          value = 0.21 * r + 0.72 * g + 0.07 * b;\n          break;\n      }\n\n      data[i + 2] = data[i + 1] = data[i] = value;\n    }\n  }\n\n  getCacheKey() {\n    return `${this.type}_${this.mode}`;\n  }\n\n  getFragmentSource() {\n    return fragmentSource[this.mode];\n  }\n\n  /**\n   * Send data from this filter to its shader program's uniforms.\n   *\n   * @param {WebGLRenderingContext} gl The GL canvas context used to compile this filter's shader.\n   * @param {Object} uniformLocations A map of string uniform names to WebGLUniformLocation objects\n   */\n  sendUniformData(\n    gl: WebGLRenderingContext,\n    uniformLocations: TWebGLUniformLocationMap,\n  ) {\n    const mode = 1;\n    gl.uniform1i(uniformLocations.uMode, mode);\n  }\n\n  /**\n   * Grayscale filter isNeutralState implementation\n   * The filter is never neutral\n   * on the image\n   **/\n  isNeutralState() {\n    return false;\n  }\n}\n\nclassRegistry.setClass(Grayscale);\n"],"names":["grayscaleDefaultValues","mode","Grayscale","BaseFilter","applyTo2d","_ref","imageData","data","value","i","length","r","g","b","this","Math","min","max","getCacheKey","type","getFragmentSource","fragmentSource","sendUniformData","gl","uniformLocations","uniform1i","uMode","isNeutralState","_defineProperty","classRegistry","setClass"],"mappings":"0PAWO,MAAMA,EAA4C,CACvDC,KAAM,WAUD,MAAMC,UAAkBC,EAe7BC,SAAAA,CAASC,GAA4C,IAAzCC,WAAWC,KAAEA,IAA0BF,EACjD,IAAK,IAAWG,EAAPC,EAAI,EAAkBA,EAAIF,EAAKG,OAAQD,GAAK,EAAG,CACtD,MAAME,EAAIJ,EAAKE,GACTG,EAAIL,EAAKE,EAAI,GACbI,EAAIN,EAAKE,EAAI,GACnB,OAAQK,KAAKb,MACX,IAAK,UACHO,GAASG,EAAIC,EAAIC,GAAK,EACtB,MACF,IAAK,YACHL,GAASO,KAAKC,IAAIL,EAAGC,EAAGC,GAAKE,KAAKE,IAAIN,EAAGC,EAAGC,IAAM,EAClD,MACF,IAAK,aACHL,EAAQ,IAAOG,EAAI,IAAOC,EAAI,IAAOC,EAIzCN,EAAKE,EAAI,GAAKF,EAAKE,EAAI,GAAKF,EAAKE,GAAKD,CACxC,CACF,CAEAU,WAAAA,GACE,MAAO,GAAGJ,KAAKK,QAAQL,KAAKb,MAC9B,CAEAmB,iBAAAA,GACE,OAAOC,EAAeP,KAAKb,KAC7B,CAQAqB,eAAAA,CACEC,EACAC,GAGAD,EAAGE,UAAUD,EAAiBE,MADjB,EAEf,CAOAC,cAAAA,GACE,OAAO,CACT,EACDC,EAlEY1B,EAAS,OAGN,aAAW0B,EAHd1B,EAAS,WAKFF,GAAsB4B,EAL7B1B,EAAS,mBAOM,CAAC,UA6D7B2B,EAAcC,SAAS5B"}

package/dist/src/filters/Grayscale.mjs

@@ -0,0 +1,81 @@
+import { defineProperty as _defineProperty } from '../../_virtual/_rollupPluginBabelHelpers.mjs';
+import { BaseFilter } from './BaseFilter.mjs';
+import { classRegistry } from '../ClassRegistry.mjs';
+import { fragmentSource } from './shaders/grayscale.mjs';
+
+const grayscaleDefaultValues = {
+  mode: 'average'
+};
+
+/**
+ * Grayscale image filter class
+ * @example
+ * const filter = new Grayscale();
+ * object.filters.push(filter);
+ * object.applyFilters();
+ */
+class Grayscale extends BaseFilter {
+  /**
+   * 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(_ref) {
+    let {
+      imageData: {
+        data
+      }
+    } = _ref;
+    for (let i = 0, value; i < data.length; i += 4) {
+      const r = data[i];
+      const g = data[i + 1];
+      const b = data[i + 2];
+      switch (this.mode) {
+        case 'average':
+          value = (r + g + b) / 3;
+          break;
+        case 'lightness':
+          value = (Math.min(r, g, b) + Math.max(r, g, b)) / 2;
+          break;
+        case 'luminosity':
+          value = 0.21 * r + 0.72 * g + 0.07 * b;
+          break;
+      }
+      data[i + 2] = data[i + 1] = data[i] = value;
+    }
+  }
+  getCacheKey() {
+    return `${this.type}_${this.mode}`;
+  }
+  getFragmentSource() {
+    return fragmentSource[this.mode];
+  }
+
+  /**
+   * 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, uniformLocations) {
+    const mode = 1;
+    gl.uniform1i(uniformLocations.uMode, mode);
+  }
+
+  /**
+   * Grayscale filter isNeutralState implementation
+   * The filter is never neutral
+   * on the image
+   **/
+  isNeutralState() {
+    return false;
+  }
+}
+_defineProperty(Grayscale, "type", 'Grayscale');
+_defineProperty(Grayscale, "defaults", grayscaleDefaultValues);
+_defineProperty(Grayscale, "uniformLocations", ['uMode']);
+classRegistry.setClass(Grayscale);
+
+export { Grayscale, grayscaleDefaultValues };
+//# sourceMappingURL=Grayscale.mjs.map

package/dist/src/filters/Grayscale.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Grayscale.mjs","sources":["../../../src/filters/Grayscale.ts"],"sourcesContent":["import { BaseFilter } from './BaseFilter';\nimport type { T2DPipelineState, TWebGLUniformLocationMap } from './typedefs';\nimport { classRegistry } from '../ClassRegistry';\nimport { fragmentSource } from './shaders/grayscale';\n\nexport type TGrayscaleMode = 'average' | 'lightness' | 'luminosity';\n\ntype GrayscaleOwnProps = {\n  mode: TGrayscaleMode;\n};\n\nexport const grayscaleDefaultValues: GrayscaleOwnProps = {\n  mode: 'average',\n};\n\n/**\n * Grayscale image filter class\n * @example\n * const filter = new Grayscale();\n * object.filters.push(filter);\n * object.applyFilters();\n */\nexport class Grayscale extends BaseFilter<'Grayscale', GrayscaleOwnProps> {\n  declare mode: TGrayscaleMode;\n\n  static type = 'Grayscale';\n\n  static defaults = grayscaleDefaultValues;\n\n  static uniformLocations = ['uMode'];\n\n  /**\n   * Apply the Grayscale operation to a Uint8Array representing the pixels of an image.\n   *\n   * @param {Object} options\n   * @param {ImageData} options.imageData The Uint8Array to be filtered.\n   */\n  applyTo2d({ imageData: { data } }: T2DPipelineState) {\n    for (let i = 0, value: number; i < data.length; i += 4) {\n      const r = data[i];\n      const g = data[i + 1];\n      const b = data[i + 2];\n      switch (this.mode) {\n        case 'average':\n          value = (r + g + b) / 3;\n          break;\n        case 'lightness':\n          value = (Math.min(r, g, b) + Math.max(r, g, b)) / 2;\n          break;\n        case 'luminosity':\n          value = 0.21 * r + 0.72 * g + 0.07 * b;\n          break;\n      }\n\n      data[i + 2] = data[i + 1] = data[i] = value;\n    }\n  }\n\n  getCacheKey() {\n    return `${this.type}_${this.mode}`;\n  }\n\n  getFragmentSource() {\n    return fragmentSource[this.mode];\n  }\n\n  /**\n   * Send data from this filter to its shader program's uniforms.\n   *\n   * @param {WebGLRenderingContext} gl The GL canvas context used to compile this filter's shader.\n   * @param {Object} uniformLocations A map of string uniform names to WebGLUniformLocation objects\n   */\n  sendUniformData(\n    gl: WebGLRenderingContext,\n    uniformLocations: TWebGLUniformLocationMap,\n  ) {\n    const mode = 1;\n    gl.uniform1i(uniformLocations.uMode, mode);\n  }\n\n  /**\n   * Grayscale filter isNeutralState implementation\n   * The filter is never neutral\n   * on the image\n   **/\n  isNeutralState() {\n    return false;\n  }\n}\n\nclassRegistry.setClass(Grayscale);\n"],"names":["grayscaleDefaultValues","mode","Grayscale","BaseFilter","applyTo2d","_ref","imageData","data","i","value","length","r","g","b","Math","min","max","getCacheKey","type","getFragmentSource","fragmentSource","sendUniformData","gl","uniformLocations","uniform1i","uMode","isNeutralState","_defineProperty","classRegistry","setClass"],"mappings":";;;;;AAWO,MAAMA,sBAAyC,GAAG;AACvDC,EAAAA,IAAI,EAAE;AACR;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMC,SAAS,SAASC,UAAU,CAAiC;AASxE;AACF;AACA;AACA;AACA;AACA;EACEC,SAASA,CAAAC,IAAA,EAA4C;IAAA,IAA3C;AAAEC,MAAAA,SAAS,EAAE;AAAEC,QAAAA;AAAK;AAAoB,KAAC,GAAAF,IAAA;AACjD,IAAA,KAAK,IAAIG,CAAC,GAAG,CAAC,EAAEC,KAAa,EAAED,CAAC,GAAGD,IAAI,CAACG,MAAM,EAAEF,CAAC,IAAI,CAAC,EAAE;AACtD,MAAA,MAAMG,CAAC,GAAGJ,IAAI,CAACC,CAAC,CAAC;AACjB,MAAA,MAAMI,CAAC,GAAGL,IAAI,CAACC,CAAC,GAAG,CAAC,CAAC;AACrB,MAAA,MAAMK,CAAC,GAAGN,IAAI,CAACC,CAAC,GAAG,CAAC,CAAC;MACrB,QAAQ,IAAI,CAACP,IAAI;AACf,QAAA,KAAK,SAAS;UACZQ,KAAK,GAAG,CAACE,CAAC,GAAGC,CAAC,GAAGC,CAAC,IAAI,CAAC;AACvB,UAAA;AACF,QAAA,KAAK,WAAW;UACdJ,KAAK,GAAG,CAACK,IAAI,CAACC,GAAG,CAACJ,CAAC,EAAEC,CAAC,EAAEC,CAAC,CAAC,GAAGC,IAAI,CAACE,GAAG,CAACL,CAAC,EAAEC,CAAC,EAAEC,CAAC,CAAC,IAAI,CAAC;AACnD,UAAA;AACF,QAAA,KAAK,YAAY;UACfJ,KAAK,GAAG,IAAI,GAAGE,CAAC,GAAG,IAAI,GAAGC,CAAC,GAAG,IAAI,GAAGC,CAAC;AACtC,UAAA;AACJ;AAEAN,MAAAA,IAAI,CAACC,CAAC,GAAG,CAAC,CAAC,GAAGD,IAAI,CAACC,CAAC,GAAG,CAAC,CAAC,GAAGD,IAAI,CAACC,CAAC,CAAC,GAAGC,KAAK;AAC7C,IAAA;AACF,EAAA;AAEAQ,EAAAA,WAAWA,GAAG;IACZ,OAAO,CAAA,EAAG,IAAI,CAACC,IAAI,IAAI,IAAI,CAACjB,IAAI,CAAA,CAAE;AACpC,EAAA;AAEAkB,EAAAA,iBAAiBA,GAAG;AAClB,IAAA,OAAOC,cAAc,CAAC,IAAI,CAACnB,IAAI,CAAC;AAClC,EAAA;;AAEA;AACF;AACA;AACA;AACA;AACA;AACEoB,EAAAA,eAAeA,CACbC,EAAyB,EACzBC,gBAA0C,EAC1C;IACA,MAAMtB,IAAI,GAAG,CAAC;IACdqB,EAAE,CAACE,SAAS,CAACD,gBAAgB,CAACE,KAAK,EAAExB,IAAI,CAAC;AAC5C,EAAA;;AAEA;AACF;AACA;AACA;AACA;AACEyB,EAAAA,cAAcA,GAAG;AACf,IAAA,OAAO,KAAK;AACd,EAAA;AACF;AAACC,eAAA,CAlEYzB,SAAS,EAAA,MAAA,EAGN,WAAW,CAAA;AAAAyB,eAAA,CAHdzB,SAAS,EAAA,UAAA,EAKFF,sBAAsB,CAAA;AAAA2B,eAAA,CAL7BzB,SAAS,EAAA,kBAAA,EAOM,CAAC,OAAO,CAAC,CAAA;AA6DrC0B,aAAa,CAACC,QAAQ,CAAC3B,SAAS,CAAC;;;;"}

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

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

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

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

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

@@ -0,0 +1,2 @@
+import{defineProperty as t}from"../../_virtual/_rollupPluginBabelHelpers.min.mjs";import{cos as i}from"../util/misc/cos.min.mjs";import{sin as r}from"../util/misc/sin.min.mjs";import{colorMatrixDefaultValues as o,ColorMatrix as s}from"./ColorMatrix.min.mjs";import{classRegistry as a}from"../ClassRegistry.min.mjs";const e={...o,rotation:0};class m extends s{calculateMatrix(){const t=this.rotation*Math.PI,o=i(t),s=r(t),a=1/3,e=Math.sqrt(a)*s,m=1-o;this.matrix=[o+m/3,a*m-e,a*m+e,0,0,a*m+e,o+a*m,a*m-e,0,0,a*m-e,a*m+e,o+a*m,0,0,0,0,0,1,0]}isNeutralState(){return 0===this.rotation}applyTo(t){this.calculateMatrix(),super.applyTo(t)}toObject(){return{type:this.type,rotation:this.rotation}}}t(m,"type","HueRotation"),t(m,"defaults",e),a.setClass(m);export{m as HueRotation,e as hueRotationDefaultValues};
+//# sourceMappingURL=HueRotation.min.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"HueRotation.min.mjs","sources":["../../../src/filters/HueRotation.ts"],"sourcesContent":["import { cos } from '../util/misc/cos';\nimport { sin } from '../util/misc/sin';\nimport {\n  ColorMatrix,\n  type ColorMatrixOwnProps,\n  colorMatrixDefaultValues,\n} from './ColorMatrix';\nimport type { TWebGLPipelineState, T2DPipelineState } from './typedefs';\nimport { classRegistry } from '../ClassRegistry';\n\nexport type HueRotationOwnProps = ColorMatrixOwnProps & {\n  rotation: number;\n};\n\nexport type HueRotationSerializedProps = {\n  rotation: number;\n};\n\nexport const hueRotationDefaultValues: HueRotationOwnProps = {\n  ...colorMatrixDefaultValues,\n  rotation: 0,\n};\n\n/**\n * HueRotation filter class\n * @example\n * const filter = new HueRotation({\n *   rotation: -0.5\n * });\n * object.filters.push(filter);\n * object.applyFilters();\n */\nexport class HueRotation extends ColorMatrix<\n  'HueRotation',\n  HueRotationOwnProps,\n  HueRotationSerializedProps\n> {\n  /**\n   * HueRotation value, from -1 to 1.\n   */\n  declare rotation: HueRotationOwnProps['rotation'];\n\n  static type = 'HueRotation';\n\n  static defaults = hueRotationDefaultValues;\n\n  calculateMatrix() {\n    const rad = this.rotation * Math.PI,\n      cosine = cos(rad),\n      sine = sin(rad),\n      aThird = 1 / 3,\n      aThirdSqtSin = Math.sqrt(aThird) * sine,\n      OneMinusCos = 1 - cosine;\n    this.matrix = [\n      cosine + OneMinusCos / 3,\n      aThird * OneMinusCos - aThirdSqtSin,\n      aThird * OneMinusCos + aThirdSqtSin,\n      0,\n      0,\n      aThird * OneMinusCos + aThirdSqtSin,\n      cosine + aThird * OneMinusCos,\n      aThird * OneMinusCos - aThirdSqtSin,\n      0,\n      0,\n      aThird * OneMinusCos - aThirdSqtSin,\n      aThird * OneMinusCos + aThirdSqtSin,\n      cosine + aThird * OneMinusCos,\n      0,\n      0,\n      0,\n      0,\n      0,\n      1,\n      0,\n    ];\n  }\n\n  isNeutralState() {\n    return this.rotation === 0;\n  }\n\n  applyTo(options: TWebGLPipelineState | T2DPipelineState) {\n    this.calculateMatrix();\n    super.applyTo(options);\n  }\n\n  toObject() {\n    return {\n      type: this.type,\n      rotation: this.rotation,\n    };\n  }\n}\n\nclassRegistry.setClass(HueRotation);\n"],"names":["hueRotationDefaultValues","colorMatrixDefaultValues","rotation","HueRotation","ColorMatrix","calculateMatrix","rad","this","Math","PI","cosine","cos","sine","sin","aThird","aThirdSqtSin","sqrt","OneMinusCos","matrix","isNeutralState","applyTo","options","super","toObject","type","_defineProperty","classRegistry","setClass"],"mappings":"2TAkBO,MAAMA,EAAgD,IACxDC,EACHC,SAAU,GAYL,MAAMC,UAAoBC,EAc/BC,eAAAA,GACE,MAAMC,EAAMC,KAAKL,SAAWM,KAAKC,GAC/BC,EAASC,EAAIL,GACbM,EAAOC,EAAIP,GACXQ,EAAS,EAAI,EACbC,EAAeP,KAAKQ,KAAKF,GAAUF,EACnCK,EAAc,EAAIP,EACpBH,KAAKW,OAAS,CACZR,EAASO,EAAc,EACvBH,EAASG,EAAcF,EACvBD,EAASG,EAAcF,EACvB,EACA,EACAD,EAASG,EAAcF,EACvBL,EAASI,EAASG,EAClBH,EAASG,EAAcF,EACvB,EACA,EACAD,EAASG,EAAcF,EACvBD,EAASG,EAAcF,EACvBL,EAASI,EAASG,EAClB,EACA,EACA,EACA,EACA,EACA,EACA,EAEJ,CAEAE,cAAAA,GACE,OAAyB,IAAlBZ,KAAKL,QACd,CAEAkB,OAAAA,CAAQC,GACNd,KAAKF,kBACLiB,MAAMF,QAAQC,EAChB,CAEAE,QAAAA,GACE,MAAO,CACLC,KAAMjB,KAAKiB,KACXtB,SAAUK,KAAKL,SAEnB,EAtDAuB,EALWtB,EAAW,OAUR,eAAasB,EAVhBtB,EAAW,WAYJH,GAkDpB0B,EAAcC,SAASxB"}

package/dist/src/filters/HueRotation.mjs

@@ -0,0 +1,53 @@
+import { defineProperty as _defineProperty } from '../../_virtual/_rollupPluginBabelHelpers.mjs';
+import { cos } from '../util/misc/cos.mjs';
+import { sin } from '../util/misc/sin.mjs';
+import { colorMatrixDefaultValues, ColorMatrix } from './ColorMatrix.mjs';
+import { classRegistry } from '../ClassRegistry.mjs';
+
+const hueRotationDefaultValues = {
+  ...colorMatrixDefaultValues,
+  rotation: 0
+};
+
+/**
+ * HueRotation filter class
+ * @example
+ * const filter = new HueRotation({
+ *   rotation: -0.5
+ * });
+ * object.filters.push(filter);
+ * object.applyFilters();
+ */
+class HueRotation extends ColorMatrix {
+  calculateMatrix() {
+    const rad = this.rotation * Math.PI,
+      cosine = cos(rad),
+      sine = sin(rad),
+      aThird = 1 / 3,
+      aThirdSqtSin = Math.sqrt(aThird) * sine,
+      OneMinusCos = 1 - cosine;
+    this.matrix = [cosine + OneMinusCos / 3, aThird * OneMinusCos - aThirdSqtSin, aThird * OneMinusCos + aThirdSqtSin, 0, 0, aThird * OneMinusCos + aThirdSqtSin, cosine + aThird * OneMinusCos, aThird * OneMinusCos - aThirdSqtSin, 0, 0, aThird * OneMinusCos - aThirdSqtSin, aThird * OneMinusCos + aThirdSqtSin, cosine + aThird * OneMinusCos, 0, 0, 0, 0, 0, 1, 0];
+  }
+  isNeutralState() {
+    return this.rotation === 0;
+  }
+  applyTo(options) {
+    this.calculateMatrix();
+    super.applyTo(options);
+  }
+  toObject() {
+    return {
+      type: this.type,
+      rotation: this.rotation
+    };
+  }
+}
+/**
+ * HueRotation value, from -1 to 1.
+ */
+_defineProperty(HueRotation, "type", 'HueRotation');
+_defineProperty(HueRotation, "defaults", hueRotationDefaultValues);
+classRegistry.setClass(HueRotation);
+
+export { HueRotation, hueRotationDefaultValues };
+//# sourceMappingURL=HueRotation.mjs.map

package/dist/src/filters/HueRotation.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"HueRotation.mjs","sources":["../../../src/filters/HueRotation.ts"],"sourcesContent":["import { cos } from '../util/misc/cos';\nimport { sin } from '../util/misc/sin';\nimport {\n  ColorMatrix,\n  type ColorMatrixOwnProps,\n  colorMatrixDefaultValues,\n} from './ColorMatrix';\nimport type { TWebGLPipelineState, T2DPipelineState } from './typedefs';\nimport { classRegistry } from '../ClassRegistry';\n\nexport type HueRotationOwnProps = ColorMatrixOwnProps & {\n  rotation: number;\n};\n\nexport type HueRotationSerializedProps = {\n  rotation: number;\n};\n\nexport const hueRotationDefaultValues: HueRotationOwnProps = {\n  ...colorMatrixDefaultValues,\n  rotation: 0,\n};\n\n/**\n * HueRotation filter class\n * @example\n * const filter = new HueRotation({\n *   rotation: -0.5\n * });\n * object.filters.push(filter);\n * object.applyFilters();\n */\nexport class HueRotation extends ColorMatrix<\n  'HueRotation',\n  HueRotationOwnProps,\n  HueRotationSerializedProps\n> {\n  /**\n   * HueRotation value, from -1 to 1.\n   */\n  declare rotation: HueRotationOwnProps['rotation'];\n\n  static type = 'HueRotation';\n\n  static defaults = hueRotationDefaultValues;\n\n  calculateMatrix() {\n    const rad = this.rotation * Math.PI,\n      cosine = cos(rad),\n      sine = sin(rad),\n      aThird = 1 / 3,\n      aThirdSqtSin = Math.sqrt(aThird) * sine,\n      OneMinusCos = 1 - cosine;\n    this.matrix = [\n      cosine + OneMinusCos / 3,\n      aThird * OneMinusCos - aThirdSqtSin,\n      aThird * OneMinusCos + aThirdSqtSin,\n      0,\n      0,\n      aThird * OneMinusCos + aThirdSqtSin,\n      cosine + aThird * OneMinusCos,\n      aThird * OneMinusCos - aThirdSqtSin,\n      0,\n      0,\n      aThird * OneMinusCos - aThirdSqtSin,\n      aThird * OneMinusCos + aThirdSqtSin,\n      cosine + aThird * OneMinusCos,\n      0,\n      0,\n      0,\n      0,\n      0,\n      1,\n      0,\n    ];\n  }\n\n  isNeutralState() {\n    return this.rotation === 0;\n  }\n\n  applyTo(options: TWebGLPipelineState | T2DPipelineState) {\n    this.calculateMatrix();\n    super.applyTo(options);\n  }\n\n  toObject() {\n    return {\n      type: this.type,\n      rotation: this.rotation,\n    };\n  }\n}\n\nclassRegistry.setClass(HueRotation);\n"],"names":["hueRotationDefaultValues","colorMatrixDefaultValues","rotation","HueRotation","ColorMatrix","calculateMatrix","rad","Math","PI","cosine","cos","sine","sin","aThird","aThirdSqtSin","sqrt","OneMinusCos","matrix","isNeutralState","applyTo","options","toObject","type","_defineProperty","classRegistry","setClass"],"mappings":";;;;;;AAkBO,MAAMA,wBAA6C,GAAG;AAC3D,EAAA,GAAGC,wBAAwB;AAC3BC,EAAAA,QAAQ,EAAE;AACZ;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMC,WAAW,SAASC,WAAW,CAI1C;AAUAC,EAAAA,eAAeA,GAAG;IAChB,MAAMC,GAAG,GAAG,IAAI,CAACJ,QAAQ,GAAGK,IAAI,CAACC,EAAE;AACjCC,MAAAA,MAAM,GAAGC,GAAG,CAACJ,GAAG,CAAC;AACjBK,MAAAA,IAAI,GAAGC,GAAG,CAACN,GAAG,CAAC;MACfO,MAAM,GAAG,CAAC,GAAG,CAAC;MACdC,YAAY,GAAGP,IAAI,CAACQ,IAAI,CAACF,MAAM,CAAC,GAAGF,IAAI;MACvCK,WAAW,GAAG,CAAC,GAAGP,MAAM;AAC1B,IAAA,IAAI,CAACQ,MAAM,GAAG,CACZR,MAAM,GAAGO,WAAW,GAAG,CAAC,EACxBH,MAAM,GAAGG,WAAW,GAAGF,YAAY,EACnCD,MAAM,GAAGG,WAAW,GAAGF,YAAY,EACnC,CAAC,EACD,CAAC,EACDD,MAAM,GAAGG,WAAW,GAAGF,YAAY,EACnCL,MAAM,GAAGI,MAAM,GAAGG,WAAW,EAC7BH,MAAM,GAAGG,WAAW,GAAGF,YAAY,EACnC,CAAC,EACD,CAAC,EACDD,MAAM,GAAGG,WAAW,GAAGF,YAAY,EACnCD,MAAM,GAAGG,WAAW,GAAGF,YAAY,EACnCL,MAAM,GAAGI,MAAM,GAAGG,WAAW,EAC7B,CAAC,EACD,CAAC,EACD,CAAC,EACD,CAAC,EACD,CAAC,EACD,CAAC,EACD,CAAC,CACF;AACH,EAAA;AAEAE,EAAAA,cAAcA,GAAG;AACf,IAAA,OAAO,IAAI,CAAChB,QAAQ,KAAK,CAAC;AAC5B,EAAA;EAEAiB,OAAOA,CAACC,OAA+C,EAAE;IACvD,IAAI,CAACf,eAAe,EAAE;AACtB,IAAA,KAAK,CAACc,OAAO,CAACC,OAAO,CAAC;AACxB,EAAA;AAEAC,EAAAA,QAAQA,GAAG;IACT,OAAO;MACLC,IAAI,EAAE,IAAI,CAACA,IAAI;MACfpB,QAAQ,EAAE,IAAI,CAACA;KAChB;AACH,EAAA;AACF;AAvDE;AACF;AACA;AAFEqB,eAAA,CALWpB,WAAW,EAAA,MAAA,EAUR,aAAa,CAAA;AAAAoB,eAAA,CAVhBpB,WAAW,EAAA,UAAA,EAYJH,wBAAwB,CAAA;AAkD5CwB,aAAa,CAACC,QAAQ,CAACtB,WAAW,CAAC;;;;"}

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

@@ -0,0 +1,51 @@
+import { BaseFilter } from './BaseFilter';
+import type { T2DPipelineState, TWebGLUniformLocationMap } from './typedefs';
+export type InvertOwnProps = {
+    alpha: boolean;
+    invert: boolean;
+};
+export declare const invertDefaultValues: InvertOwnProps;
+/**
+ * @example
+ * const filter = new Invert();
+ * object.filters.push(filter);
+ * object.applyFilters(canvas.renderAll.bind(canvas));
+ */
+export declare class Invert extends BaseFilter<'Invert', InvertOwnProps> {
+    /**
+     * Invert also alpha.
+     * @param {Boolean} alpha
+     **/
+    alpha: InvertOwnProps['alpha'];
+    /**
+     * Filter invert. if false, does nothing
+     * @param {Boolean} invert
+     */
+    invert: InvertOwnProps['invert'];
+    static type: string;
+    static defaults: InvertOwnProps;
+    static uniformLocations: string[];
+    /**
+     * 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;
+    /**
+     * 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/Invert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Invert.d.ts","sourceRoot":"","sources":["../../../src/filters/Invert.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,KAAK,EAAE,gBAAgB,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAI7E,MAAM,MAAM,cAAc,GAAG;IAC3B,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,cAGjC,CAAC;AAEF;;;;;GAKG;AACH,qBAAa,MAAO,SAAQ,UAAU,CAAC,QAAQ,EAAE,cAAc,CAAC;IAC9D;;;QAGI;IACI,KAAK,EAAE,cAAc,CAAC,OAAO,CAAC,CAAC;IAEvC;;;OAGG;IACK,MAAM,EAAE,cAAc,CAAC,QAAQ,CAAC,CAAC;IAEzC,MAAM,CAAC,IAAI,SAAY;IAEvB,MAAM,CAAC,QAAQ,iBAAuB;IAEtC,MAAM,CAAC,gBAAgB,WAAyB;IAEhD;;;;;OAKG;IACH,SAAS,CAAC,EAAE,SAAS,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,gBAAgB;IAYnD,SAAS,CAAC,iBAAiB,IAAI,MAAM;IAIrC;;;;;QAKI;IACJ,cAAc;IAId;;;;;OAKG;IACH,eAAe,CACb,EAAE,EAAE,qBAAqB,EACzB,gBAAgB,EAAE,wBAAwB;CAK7C"}