@react-three/postprocessing 2.15.1 → 2.15.2

package/dist/effects/TiltShift2.cjs

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+const postprocessing = require("postprocessing");
+const util = require("../util.cjs");
+const TiltShiftShader = {
+  fragmentShader: `
+
+    // original shader by Evan Wallace
+
+    #define MAX_ITERATIONS 100
+
+    uniform float blur;
+    uniform float taper;
+    uniform vec2 start;
+    uniform vec2 end;
+    uniform vec2 direction;
+    uniform int samples;
+
+    float random(vec3 scale, float seed) {
+        /* use the fragment position for a different seed per-pixel */
+        return fract(sin(dot(gl_FragCoord.xyz + seed, scale)) * 43758.5453 + seed);
+    }
+
+    void mainImage(const in vec4 inputColor, const in vec2 uv, out vec4 outputColor) {
+        vec4 color = vec4(0.0);
+        float total = 0.0;
+        vec2 startPixel = vec2(start.x * resolution.x, start.y * resolution.y);
+        vec2 endPixel = vec2(end.x * resolution.x, end.y * resolution.y);
+        float f_samples = float(samples);
+        float half_samples = f_samples / 2.0;
+
+        // use screen diagonal to normalize blur radii
+        float maxScreenDistance = distance(vec2(0.0), resolution); // diagonal distance
+        float gradientRadius = taper * (maxScreenDistance);
+        float blurRadius = blur * (maxScreenDistance / 16.0);
+
+        /* randomize the lookup values to hide the fixed number of samples */
+        float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);
+        vec2 normal = normalize(vec2(startPixel.y - endPixel.y, endPixel.x - startPixel.x));
+        float radius = smoothstep(0.0, 1.0, abs(dot(uv * resolution - startPixel, normal)) / gradientRadius) * blurRadius;
+
+        #pragma unroll_loop_start
+        for (int i = 0; i <= MAX_ITERATIONS; i++) {
+            if (i >= samples) { break; } // return early if over sample count
+            float f_i = float(i);
+            float s_i = -half_samples + f_i;
+            float percent = (s_i + offset - 0.5) / half_samples;
+            float weight = 1.0 - abs(percent);
+            vec4 sample_i = texture2D(inputBuffer, uv + normalize(direction) / resolution * percent * radius);
+            /* switch to pre-multiplied alpha to correctly blur transparent images */
+            sample_i.rgb *= sample_i.a;
+            color += sample_i * weight;
+            total += weight;
+        }
+        #pragma unroll_loop_end
+
+        outputColor = color / total;
+
+        /* switch back from pre-multiplied alpha */
+        outputColor.rgb /= outputColor.a + 0.00001;
+    }
+    `
+};
+class TiltShiftEffect extends postprocessing.Effect {
+  constructor({
+    blendFunction = postprocessing.BlendFunction.NORMAL,
+    blur = 0.15,
+    // [0, 1], can go beyond 1 for extra
+    taper = 0.5,
+    // [0, 1], can go beyond 1 for extra
+    start = [0.5, 0],
+    // [0,1] percentage x,y of screenspace
+    end = [0.5, 1],
+    // [0,1] percentage x,y of screenspace
+    samples = 10,
+    // number of blur samples
+    direction = [1, 1]
+    // direction of blur
+  } = {}) {
+    super("TiltShiftEffect", TiltShiftShader.fragmentShader, {
+      blendFunction,
+      attributes: postprocessing.EffectAttribute.CONVOLUTION,
+      uniforms: /* @__PURE__ */ new Map([
+        ["blur", new THREE.Uniform(blur)],
+        ["taper", new THREE.Uniform(taper)],
+        ["start", new THREE.Uniform(start)],
+        ["end", new THREE.Uniform(end)],
+        ["samples", new THREE.Uniform(samples)],
+        ["direction", new THREE.Uniform(direction)]
+      ])
+    });
+  }
+}
+const TiltShift2 = util.wrapEffect(TiltShiftEffect, { blendFunction: postprocessing.BlendFunction.NORMAL });
+exports.TiltShift2 = TiltShift2;
+exports.TiltShiftEffect = TiltShiftEffect;
+//# sourceMappingURL=TiltShift2.cjs.map

package/dist/effects/TiltShift2.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"TiltShift2.cjs","sources":["../../src/effects/TiltShift2.tsx"],"sourcesContent":["import { Uniform } from 'three'\nimport { BlendFunction, Effect, EffectAttribute } from 'postprocessing'\nimport { wrapEffect } from '../util'\n\nconst TiltShiftShader = {\n  fragmentShader: `\n\n    // original shader by Evan Wallace\n\n    #define MAX_ITERATIONS 100\n\n    uniform float blur;\n    uniform float taper;\n    uniform vec2 start;\n    uniform vec2 end;\n    uniform vec2 direction;\n    uniform int samples;\n\n    float random(vec3 scale, float seed) {\n        /* use the fragment position for a different seed per-pixel */\n        return fract(sin(dot(gl_FragCoord.xyz + seed, scale)) * 43758.5453 + seed);\n    }\n\n    void mainImage(const in vec4 inputColor, const in vec2 uv, out vec4 outputColor) {\n        vec4 color = vec4(0.0);\n        float total = 0.0;\n        vec2 startPixel = vec2(start.x * resolution.x, start.y * resolution.y);\n        vec2 endPixel = vec2(end.x * resolution.x, end.y * resolution.y);\n        float f_samples = float(samples);\n        float half_samples = f_samples / 2.0;\n\n        // use screen diagonal to normalize blur radii\n        float maxScreenDistance = distance(vec2(0.0), resolution); // diagonal distance\n        float gradientRadius = taper * (maxScreenDistance);\n        float blurRadius = blur * (maxScreenDistance / 16.0);\n\n        /* randomize the lookup values to hide the fixed number of samples */\n        float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);\n        vec2 normal = normalize(vec2(startPixel.y - endPixel.y, endPixel.x - startPixel.x));\n        float radius = smoothstep(0.0, 1.0, abs(dot(uv * resolution - startPixel, normal)) / gradientRadius) * blurRadius;\n\n        #pragma unroll_loop_start\n        for (int i = 0; i <= MAX_ITERATIONS; i++) {\n            if (i >= samples) { break; } // return early if over sample count\n            float f_i = float(i);\n            float s_i = -half_samples + f_i;\n            float percent = (s_i + offset - 0.5) / half_samples;\n            float weight = 1.0 - abs(percent);\n            vec4 sample_i = texture2D(inputBuffer, uv + normalize(direction) / resolution * percent * radius);\n            /* switch to pre-multiplied alpha to correctly blur transparent images */\n            sample_i.rgb *= sample_i.a;\n            color += sample_i * weight;\n            total += weight;\n        }\n        #pragma unroll_loop_end\n\n        outputColor = color / total;\n\n        /* switch back from pre-multiplied alpha */\n        outputColor.rgb /= outputColor.a + 0.00001;\n    }\n    `,\n}\n\nexport class TiltShiftEffect extends Effect {\n  constructor({\n    blendFunction = BlendFunction.NORMAL,\n    blur = 0.15, // [0, 1], can go beyond 1 for extra\n    taper = 0.5, // [0, 1], can go beyond 1 for extra\n    start = [0.5, 0.0], // [0,1] percentage x,y of screenspace\n    end = [0.5, 1.0], // [0,1] percentage x,y of screenspace\n    samples = 10.0, // number of blur samples\n    direction = [1, 1], // direction of blur\n  } = {}) {\n    super('TiltShiftEffect', TiltShiftShader.fragmentShader, {\n      blendFunction,\n      attributes: EffectAttribute.CONVOLUTION,\n      uniforms: new Map<string, Uniform<number | number[]>>([\n        ['blur', new Uniform(blur)],\n        ['taper', new Uniform(taper)],\n        ['start', new Uniform(start)],\n        ['end', new Uniform(end)],\n        ['samples', new Uniform(samples)],\n        ['direction', new Uniform(direction)],\n      ]),\n    })\n  }\n}\n\nexport const TiltShift2 = wrapEffect(TiltShiftEffect, { blendFunction: BlendFunction.NORMAL })\n"],"names":["Effect","BlendFunction","EffectAttribute","Uniform","wrapEffect"],"mappings":";;;;;AAIA,MAAM,kBAAkB;AAAA,EACtB,gBAAgB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAyDlB;AAEO,MAAM,wBAAwBA,eAAAA,OAAO;AAAA,EAC1C,YAAY;AAAA,IACV,gBAAgBC,eAAc,cAAA;AAAA,IAC9B,OAAO;AAAA;AAAA,IACP,QAAQ;AAAA;AAAA,IACR,QAAQ,CAAC,KAAK,CAAG;AAAA;AAAA,IACjB,MAAM,CAAC,KAAK,CAAG;AAAA;AAAA,IACf,UAAU;AAAA;AAAA,IACV,YAAY,CAAC,GAAG,CAAC;AAAA;AAAA,EACnB,IAAI,IAAI;AACA,UAAA,mBAAmB,gBAAgB,gBAAgB;AAAA,MACvD;AAAA,MACA,YAAYC,eAAgB,gBAAA;AAAA,MAC5B,8BAAc,IAAwC;AAAA,QACpD,CAAC,QAAQ,IAAIC,cAAQ,IAAI,CAAC;AAAA,QAC1B,CAAC,SAAS,IAAIA,cAAQ,KAAK,CAAC;AAAA,QAC5B,CAAC,SAAS,IAAIA,cAAQ,KAAK,CAAC;AAAA,QAC5B,CAAC,OAAO,IAAIA,cAAQ,GAAG,CAAC;AAAA,QACxB,CAAC,WAAW,IAAIA,cAAQ,OAAO,CAAC;AAAA,QAChC,CAAC,aAAa,IAAIA,cAAQ,SAAS,CAAC;AAAA,MAAA,CACrC;AAAA,IAAA,CACF;AAAA,EACH;AACF;AAEO,MAAM,aAAaC,KAAW,WAAA,iBAAiB,EAAE,eAAeH,eAAAA,cAAc,OAAQ,CAAA;;;"}

package/dist/effects/TiltShift2.js

@@ -0,0 +1,98 @@
+import { Uniform } from "three";
+import { Effect, EffectAttribute, BlendFunction } from "postprocessing";
+import { wrapEffect } from "../util.js";
+const TiltShiftShader = {
+  fragmentShader: `
+
+    // original shader by Evan Wallace
+
+    #define MAX_ITERATIONS 100
+
+    uniform float blur;
+    uniform float taper;
+    uniform vec2 start;
+    uniform vec2 end;
+    uniform vec2 direction;
+    uniform int samples;
+
+    float random(vec3 scale, float seed) {
+        /* use the fragment position for a different seed per-pixel */
+        return fract(sin(dot(gl_FragCoord.xyz + seed, scale)) * 43758.5453 + seed);
+    }
+
+    void mainImage(const in vec4 inputColor, const in vec2 uv, out vec4 outputColor) {
+        vec4 color = vec4(0.0);
+        float total = 0.0;
+        vec2 startPixel = vec2(start.x * resolution.x, start.y * resolution.y);
+        vec2 endPixel = vec2(end.x * resolution.x, end.y * resolution.y);
+        float f_samples = float(samples);
+        float half_samples = f_samples / 2.0;
+
+        // use screen diagonal to normalize blur radii
+        float maxScreenDistance = distance(vec2(0.0), resolution); // diagonal distance
+        float gradientRadius = taper * (maxScreenDistance);
+        float blurRadius = blur * (maxScreenDistance / 16.0);
+
+        /* randomize the lookup values to hide the fixed number of samples */
+        float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);
+        vec2 normal = normalize(vec2(startPixel.y - endPixel.y, endPixel.x - startPixel.x));
+        float radius = smoothstep(0.0, 1.0, abs(dot(uv * resolution - startPixel, normal)) / gradientRadius) * blurRadius;
+
+        #pragma unroll_loop_start
+        for (int i = 0; i <= MAX_ITERATIONS; i++) {
+            if (i >= samples) { break; } // return early if over sample count
+            float f_i = float(i);
+            float s_i = -half_samples + f_i;
+            float percent = (s_i + offset - 0.5) / half_samples;
+            float weight = 1.0 - abs(percent);
+            vec4 sample_i = texture2D(inputBuffer, uv + normalize(direction) / resolution * percent * radius);
+            /* switch to pre-multiplied alpha to correctly blur transparent images */
+            sample_i.rgb *= sample_i.a;
+            color += sample_i * weight;
+            total += weight;
+        }
+        #pragma unroll_loop_end
+
+        outputColor = color / total;
+
+        /* switch back from pre-multiplied alpha */
+        outputColor.rgb /= outputColor.a + 0.00001;
+    }
+    `
+};
+class TiltShiftEffect extends Effect {
+  constructor({
+    blendFunction = BlendFunction.NORMAL,
+    blur = 0.15,
+    // [0, 1], can go beyond 1 for extra
+    taper = 0.5,
+    // [0, 1], can go beyond 1 for extra
+    start = [0.5, 0],
+    // [0,1] percentage x,y of screenspace
+    end = [0.5, 1],
+    // [0,1] percentage x,y of screenspace
+    samples = 10,
+    // number of blur samples
+    direction = [1, 1]
+    // direction of blur
+  } = {}) {
+    super("TiltShiftEffect", TiltShiftShader.fragmentShader, {
+      blendFunction,
+      attributes: EffectAttribute.CONVOLUTION,
+      uniforms: /* @__PURE__ */ new Map([
+        ["blur", new Uniform(blur)],
+        ["taper", new Uniform(taper)],
+        ["start", new Uniform(start)],
+        ["end", new Uniform(end)],
+        ["samples", new Uniform(samples)],
+        ["direction", new Uniform(direction)]
+      ])
+    });
+  }
+}
+const TiltShift2 = wrapEffect(TiltShiftEffect, { blendFunction: BlendFunction.NORMAL });
+export {
+  TiltShift2,
+  TiltShiftEffect
+};
+//# sourceMappingURL=TiltShift2.js.map

package/dist/effects/TiltShift2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TiltShift2.js","sources":["../../src/effects/TiltShift2.tsx"],"sourcesContent":["import { Uniform } from 'three'\nimport { BlendFunction, Effect, EffectAttribute } from 'postprocessing'\nimport { wrapEffect } from '../util'\n\nconst TiltShiftShader = {\n  fragmentShader: `\n\n    // original shader by Evan Wallace\n\n    #define MAX_ITERATIONS 100\n\n    uniform float blur;\n    uniform float taper;\n    uniform vec2 start;\n    uniform vec2 end;\n    uniform vec2 direction;\n    uniform int samples;\n\n    float random(vec3 scale, float seed) {\n        /* use the fragment position for a different seed per-pixel */\n        return fract(sin(dot(gl_FragCoord.xyz + seed, scale)) * 43758.5453 + seed);\n    }\n\n    void mainImage(const in vec4 inputColor, const in vec2 uv, out vec4 outputColor) {\n        vec4 color = vec4(0.0);\n        float total = 0.0;\n        vec2 startPixel = vec2(start.x * resolution.x, start.y * resolution.y);\n        vec2 endPixel = vec2(end.x * resolution.x, end.y * resolution.y);\n        float f_samples = float(samples);\n        float half_samples = f_samples / 2.0;\n\n        // use screen diagonal to normalize blur radii\n        float maxScreenDistance = distance(vec2(0.0), resolution); // diagonal distance\n        float gradientRadius = taper * (maxScreenDistance);\n        float blurRadius = blur * (maxScreenDistance / 16.0);\n\n        /* randomize the lookup values to hide the fixed number of samples */\n        float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);\n        vec2 normal = normalize(vec2(startPixel.y - endPixel.y, endPixel.x - startPixel.x));\n        float radius = smoothstep(0.0, 1.0, abs(dot(uv * resolution - startPixel, normal)) / gradientRadius) * blurRadius;\n\n        #pragma unroll_loop_start\n        for (int i = 0; i <= MAX_ITERATIONS; i++) {\n            if (i >= samples) { break; } // return early if over sample count\n            float f_i = float(i);\n            float s_i = -half_samples + f_i;\n            float percent = (s_i + offset - 0.5) / half_samples;\n            float weight = 1.0 - abs(percent);\n            vec4 sample_i = texture2D(inputBuffer, uv + normalize(direction) / resolution * percent * radius);\n            /* switch to pre-multiplied alpha to correctly blur transparent images */\n            sample_i.rgb *= sample_i.a;\n            color += sample_i * weight;\n            total += weight;\n        }\n        #pragma unroll_loop_end\n\n        outputColor = color / total;\n\n        /* switch back from pre-multiplied alpha */\n        outputColor.rgb /= outputColor.a + 0.00001;\n    }\n    `,\n}\n\nexport class TiltShiftEffect extends Effect {\n  constructor({\n    blendFunction = BlendFunction.NORMAL,\n    blur = 0.15, // [0, 1], can go beyond 1 for extra\n    taper = 0.5, // [0, 1], can go beyond 1 for extra\n    start = [0.5, 0.0], // [0,1] percentage x,y of screenspace\n    end = [0.5, 1.0], // [0,1] percentage x,y of screenspace\n    samples = 10.0, // number of blur samples\n    direction = [1, 1], // direction of blur\n  } = {}) {\n    super('TiltShiftEffect', TiltShiftShader.fragmentShader, {\n      blendFunction,\n      attributes: EffectAttribute.CONVOLUTION,\n      uniforms: new Map<string, Uniform<number | number[]>>([\n        ['blur', new Uniform(blur)],\n        ['taper', new Uniform(taper)],\n        ['start', new Uniform(start)],\n        ['end', new Uniform(end)],\n        ['samples', new Uniform(samples)],\n        ['direction', new Uniform(direction)],\n      ]),\n    })\n  }\n}\n\nexport const TiltShift2 = wrapEffect(TiltShiftEffect, { blendFunction: BlendFunction.NORMAL })\n"],"names":[],"mappings":";;;AAIA,MAAM,kBAAkB;AAAA,EACtB,gBAAgB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAyDlB;AAEO,MAAM,wBAAwB,OAAO;AAAA,EAC1C,YAAY;AAAA,IACV,gBAAgB,cAAc;AAAA,IAC9B,OAAO;AAAA;AAAA,IACP,QAAQ;AAAA;AAAA,IACR,QAAQ,CAAC,KAAK,CAAG;AAAA;AAAA,IACjB,MAAM,CAAC,KAAK,CAAG;AAAA;AAAA,IACf,UAAU;AAAA;AAAA,IACV,YAAY,CAAC,GAAG,CAAC;AAAA;AAAA,EACnB,IAAI,IAAI;AACA,UAAA,mBAAmB,gBAAgB,gBAAgB;AAAA,MACvD;AAAA,MACA,YAAY,gBAAgB;AAAA,MAC5B,8BAAc,IAAwC;AAAA,QACpD,CAAC,QAAQ,IAAI,QAAQ,IAAI,CAAC;AAAA,QAC1B,CAAC,SAAS,IAAI,QAAQ,KAAK,CAAC;AAAA,QAC5B,CAAC,SAAS,IAAI,QAAQ,KAAK,CAAC;AAAA,QAC5B,CAAC,OAAO,IAAI,QAAQ,GAAG,CAAC;AAAA,QACxB,CAAC,WAAW,IAAI,QAAQ,OAAO,CAAC;AAAA,QAChC,CAAC,aAAa,IAAI,QAAQ,SAAS,CAAC;AAAA,MAAA,CACrC;AAAA,IAAA,CACF;AAAA,EACH;AACF;AAEO,MAAM,aAAa,WAAW,iBAAiB,EAAE,eAAe,cAAc,OAAQ,CAAA;"}

package/dist/effects/ToneMapping.cjs

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const postprocessing = require("postprocessing");
+const util = require("../util.cjs");
+const ToneMapping = util.wrapEffect(postprocessing.ToneMappingEffect);
+exports.ToneMapping = ToneMapping;
+//# sourceMappingURL=ToneMapping.cjs.map

package/dist/effects/ToneMapping.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToneMapping.cjs","sources":["../../src/effects/ToneMapping.tsx"],"sourcesContent":["import { ToneMappingEffect } from 'postprocessing'\nimport { wrapEffect } from '../util'\n\nexport const ToneMapping = wrapEffect(ToneMappingEffect)\n"],"names":["wrapEffect","ToneMappingEffect"],"mappings":";;;;AAGa,MAAA,cAAcA,gBAAWC,eAAiB,iBAAA;;"}

package/dist/effects/ToneMapping.js

@@ -0,0 +1,7 @@
+import { ToneMappingEffect } from "postprocessing";
+import { wrapEffect } from "../util.js";
+const ToneMapping = wrapEffect(ToneMappingEffect);
+export {
+  ToneMapping
+};
+//# sourceMappingURL=ToneMapping.js.map

package/dist/effects/ToneMapping.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToneMapping.js","sources":["../../src/effects/ToneMapping.tsx"],"sourcesContent":["import { ToneMappingEffect } from 'postprocessing'\nimport { wrapEffect } from '../util'\n\nexport const ToneMapping = wrapEffect(ToneMappingEffect)\n"],"names":[],"mappings":";;AAGa,MAAA,cAAc,WAAW,iBAAiB;"}

package/dist/effects/Vignette.cjs

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const postprocessing = require("postprocessing");
+const util = require("../util.cjs");
+const Vignette = util.wrapEffect(postprocessing.VignetteEffect);
+exports.Vignette = Vignette;
+//# sourceMappingURL=Vignette.cjs.map

package/dist/effects/Vignette.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Vignette.cjs","sources":["../../src/effects/Vignette.tsx"],"sourcesContent":["import { VignetteEffect } from 'postprocessing'\nimport { wrapEffect } from '../util'\n\nexport const Vignette = wrapEffect(VignetteEffect)\n"],"names":["wrapEffect","VignetteEffect"],"mappings":";;;;AAGa,MAAA,WAAWA,gBAAWC,eAAc,cAAA;;"}

package/dist/effects/Vignette.js

@@ -0,0 +1,7 @@
+import { VignetteEffect } from "postprocessing";
+import { wrapEffect } from "../util.js";
+const Vignette = wrapEffect(VignetteEffect);
+export {
+  Vignette
+};
+//# sourceMappingURL=Vignette.js.map

package/dist/effects/Vignette.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Vignette.js","sources":["../../src/effects/Vignette.tsx"],"sourcesContent":["import { VignetteEffect } from 'postprocessing'\nimport { wrapEffect } from '../util'\n\nexport const Vignette = wrapEffect(VignetteEffect)\n"],"names":[],"mappings":";;AAGa,MAAA,WAAW,WAAW,cAAc;"}