@luma.gl/effects 7.4.0-alpha.2 → 9.1.0-beta.1

package/dist/index.cjs

@@ -0,0 +1,1724 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// dist/index.js
+var dist_exports = {};
+__export(dist_exports, {
+  _warp: () => warp,
+  brightnessContrast: () => brightnessContrast,
+  bulgePinch: () => bulgePinch,
+  colorHalftone: () => colorHalftone,
+  denoise: () => denoise,
+  dotScreen: () => dotScreen,
+  edgeWork: () => edgeWork,
+  fxaa: () => fxaa,
+  hexagonalPixelate: () => hexagonalPixelate,
+  hueSaturation: () => hueSaturation,
+  ink: () => ink,
+  magnify: () => magnify,
+  noise: () => noise,
+  sepia: () => sepia,
+  swirl: () => swirl,
+  tiltShift: () => tiltShift,
+  triangleBlur: () => triangleBlur,
+  vibrance: () => vibrance,
+  vignette: () => vignette,
+  zoomBlur: () => zoomBlur
+});
+module.exports = __toCommonJS(dist_exports);
+
+// dist/passes/postprocessing/image-adjust-filters/brightnesscontrast.js
+var source = (
+  /* wgsl */
+  `struct brightnessContrastUniforms {
+  float brightness;
+  float contrast;
+};
+
+// Binding 0:1 is reserved for shader passes
+@binding(1) @group(0) var<uniform> brightnessContrast : brightnessContrastUniforms;
+
+fn brightnessContrast_filterColor_ext(color: vec4<f32>, texSize: vec2<f32>, texCoords: vec2<f32>) -> vec4<f32> {
+  color.rgb += brightnessContrast.brightness;
+  if (brightnessContrast.contrast > 0.0) {
+    color.rgb = (color.rgb - 0.5) / (1.0 - brightnessContrast.contrast) + 0.5;
+  } else {
+    color.rgb = (color.rgb - 0.5) * (1.0 + brightnessContrast.contrast) + 0.5;
+  }
+  return color;
+}
+`
+);
+var fs = (
+  /* glsl */
+  `uniform brightnessContrastUniforms {
+  float brightness;
+  float contrast;
+} brightnessContrast;
+
+vec4 brightnessContrast_filterColor(vec4 color) {
+  color.rgb += brightnessContrast.brightness;
+  if (brightnessContrast.contrast > 0.0) {
+    color.rgb = (color.rgb - 0.5) / (1.0 - brightnessContrast.contrast) + 0.5;
+  } else {
+    color.rgb = (color.rgb - 0.5) * (1.0 + brightnessContrast.contrast) + 0.5;
+  }
+  return color;
+}
+
+vec4 brightnessContrast_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {
+  return brightnessContrast_filterColor(color);
+}
+`
+);
+var brightnessContrast = {
+  props: {},
+  name: "brightnessContrast",
+  uniformTypes: {
+    brightness: "f32",
+    contrast: "f32"
+  },
+  defaultUniforms: {
+    brightness: 0,
+    contrast: 0
+  },
+  propTypes: {
+    brightness: { format: "f32", value: 0, min: -1, max: 1 },
+    contrast: { format: "f32", value: 0, min: -1, max: 1 }
+  },
+  passes: [{ filter: true }],
+  source,
+  fs
+};
+
+// dist/passes/postprocessing/image-adjust-filters/denoise.js
+var source2 = (
+  /* wgsl */
+  `
+@group(?), @binding(?) var<uniform> denoiseUniforms {		strength: f32 } noise;
+
+fn denoise_sampleColor(source: sampler2D, texSize: vec2<f32>, texCoord: vec2<f32>) -> vec4<f32> {
+	let adjustedExponent: f32 = 3. + 200. * pow(1. - noise.strength, 4.);
+	let center: vec4<f32> = sample_texture(BUFFER_source, texCoord);
+	var color: vec4<f32> = vec4<f32>(0.);
+	var total: f32 = 0.;
+
+	for (var x: f32 = -4.; x <= 4.; x = x + (1.)) {
+
+		for (var y: f32 = -4.; y <= 4.; y = y + (1.)) {
+			let offsetColor: vec4<f32> = sample_texture(BUFFER_source, texCoord + vec2<f32>(x, y) / texSize);
+			var weight: f32 = 1. - abs(dot(offsetColor.rgb - center.rgb, vec3<f32>(0.25)));
+			weight = pow(weight, adjustedExponent);
+			color = color + (offsetColor * weight);
+			total = total + (weight);
+		}
+
+	}
+
+	return color / total;
+} 
+`
+);
+var fs2 = (
+  /* glsl */
+  `uniform denoiseUniforms {
+  float strength;
+} noise;
+
+vec4 denoise_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
+  float adjustedExponent = 3. + 200. * pow(1. - noise.strength, 4.);
+
+  vec4 center = texture(source, texCoord);
+  vec4 color = vec4(0.0);
+  float total = 0.0;
+  for (float x = -4.0; x <= 4.0; x += 1.0) {
+    for (float y = -4.0; y <= 4.0; y += 1.0) {
+      vec4 offsetColor = texture(source, texCoord + vec2(x, y) / texSize);
+      float weight = 1.0 - abs(dot(offsetColor.rgb - center.rgb, vec3(0.25)));
+      weight = pow(weight, adjustedExponent);
+      color += offsetColor * weight;
+      total += weight;
+    }
+  }
+
+  return color / total;
+}
+`
+);
+var denoise = {
+  props: {},
+  uniforms: {},
+  name: "denoise",
+  uniformTypes: {
+    strength: "f32"
+  },
+  propTypes: {
+    strength: { format: "f32", value: 0.5, min: 0, max: 1 }
+    // strength: {..., adjust: (strength: number): number => 0.53 + 200 * Math.pow(1 - strength, 4) // TODO - JS preprocessing
+  },
+  source: source2,
+  fs: fs2,
+  passes: [{ sampler: true }, { sampler: true }]
+};
+
+// dist/passes/postprocessing/image-adjust-filters/huesaturation.js
+var source3 = (
+  /* wgsl */
+  `@group(?), @binding(?)
+var<uniform> hueSaturationUniforms {		hue: f32,
+
+		saturation: f32,
+
+}hueSaturation;
+
+fn hueSaturation_filterColor(color: vec4<f32>) -> vec4<f32> {
+	let angle: f32 = hueSaturation.hue * 3.1415927;
+	let s: f32 = sin(angle);
+	let c: f32 = cos(angle);
+	let weights: vec3<f32> = (vec3<f32>(2. * c, -sqrt(3.) * s - c, sqrt(3.) * s - c) + 1.) / 3.;
+	let len: f32 = length(color.rgb);
+	var colorrgb = color.rgb;
+	colorrgb = vec3<f32>(dot(color.rgb, weights.xyz), dot(color.rgb, weights.zxy), dot(color.rgb, weights.yzx));
+	color.r = colorrgb.x;
+	color.g = colorrgb.y;
+	color.b = colorrgb.z;
+	let average: f32 = (color.r + color.g + color.b) / 3.;
+	if (hueSaturation.saturation > 0.) {
+		var colorrgb = color.rgb;
+	colorrgb = color.rgb + ((average - color.rgb) * (1. - 1. / (1.001 - hueSaturation.saturation)));
+	color.r = colorrgb.x;
+	color.g = colorrgb.y;
+	color.b = colorrgb.z;
+	} else { 
+		var colorrgb = color.rgb;
+	colorrgb = color.rgb + ((average - color.rgb) * -hueSaturation.saturation);
+	color.r = colorrgb.x;
+	color.g = colorrgb.y;
+	color.b = colorrgb.z;
+	}
+	return color;
+} 
+
+fn hueSaturation_filterColor_ext(color: vec4<f32>, texSize: vec2<f32>, texCoord: vec2<f32>) -> vec4<f32> {
+	return hueSaturation_filterColor(color);
+} 
+`
+);
+var fs3 = (
+  /* glsl */
+  `uniform hueSaturationUniforms {
+  float hue;
+  float saturation;
+} hueSaturation;
+
+vec4 hueSaturation_filterColor(vec4 color) {
+  // hue adjustment, wolfram alpha: RotationTransform[angle, {1, 1, 1}][{x, y, z}]
+  float angle = hueSaturation.hue * 3.14159265;
+  float s = sin(angle), c = cos(angle);
+  vec3 weights = (vec3(2.0 * c, -sqrt(3.0) * s - c, sqrt(3.0) * s - c) + 1.0) / 3.0;
+  float len = length(color.rgb);
+  color.rgb = vec3(
+    dot(color.rgb, weights.xyz),
+    dot(color.rgb, weights.zxy),
+    dot(color.rgb, weights.yzx)
+  );
+
+  // saturation adjustment
+  float average = (color.r + color.g + color.b) / 3.0;
+  if (hueSaturation.saturation > 0.0) {
+    color.rgb += (average - color.rgb) * (1.0 - 1.0 / (1.001 - hueSaturation.saturation));
+  } else {
+    color.rgb += (average - color.rgb) * (-hueSaturation.saturation);
+  }
+
+  return color;
+}
+
+vec4 hueSaturation_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {
+  return hueSaturation_filterColor(color);
+}
+`
+);
+var hueSaturation = {
+  props: {},
+  name: "hueSaturation",
+  source: source3,
+  fs: fs3,
+  uniformTypes: {
+    hue: "f32",
+    saturation: "f32"
+  },
+  propTypes: {
+    hue: { value: 0, min: -1, max: 1 },
+    saturation: { value: 0, min: -1, max: 1 }
+  },
+  passes: [{ filter: true }]
+};
+
+// dist/passes/postprocessing/image-adjust-filters/noise.js
+var source4 = (
+  /* wgsl */
+  `struct noiseUniforms {
+  amount: f32
+};
+
+@group(0), @binding(0) var<uniform> noise: NoiseUniforms;
+
+fn rand(co: vec2<f32>) -> f32 {
+	return fract(sin(dot(co.xy, vec2<f32>(12.9898, 78.233))) * 43758.547);
+} 
+
+fn noise_filterColor_ext(color: vec4<f32>, texSize: vec2<f32>, texCoord: vec2<f32>) -> vec4<f32> {
+	let diff: f32 = (rand(texCoord) - 0.5) * noise.amount;
+	color.r = color.r + (diff);
+	color.g = color.g + (diff);
+	color.b = color.b + (diff);
+	return color;
+} 
+`
+);
+var fs4 = (
+  /* glsl */
+  `uniform noiseUniforms {
+  float amount;
+} noise;
+
+float rand(vec2 co) {
+  return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
+}
+
+vec4 noise_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {
+  float diff = (rand(texCoord) - 0.5) * noise.amount;
+  color.r += diff;
+  color.g += diff;
+  color.b += diff;
+  return color;
+}
+`
+);
+var noise = {
+  props: {},
+  uniforms: {},
+  name: "noise",
+  uniformTypes: {
+    amount: "f32"
+  },
+  propTypes: {
+    amount: { value: 0.5, min: 0, max: 1 }
+  },
+  fs: fs4,
+  source: source4,
+  passes: [{ filter: true }]
+};
+
+// dist/passes/postprocessing/image-adjust-filters/sepia.js
+var fs5 = (
+  /* glsl */
+  `uniform sepiaUniforms {
+  float amount;
+} sepia;
+
+vec4 sepia_filterColor(vec4 color) {
+  float r = color.r;
+  float g = color.g;
+  float b = color.b;
+
+  color.r =
+    min(1.0, (r * (1.0 - (0.607 * sepia.amount))) + (g * (0.769 * sepia.amount)) + (b * (0.189 * sepia.amount)));
+  color.g = min(1.0, (r * 0.349 * sepia.amount) + (g * (1.0 - (0.314 * sepia.amount))) + (b * 0.168 * sepia.amount));
+  color.b = min(1.0, (r * 0.272 * sepia.amount) + (g * 0.534 * sepia.amount) + (b * (1.0 - (0.869 * sepia.amount))));
+
+  return color;
+}
+
+vec4 sepia_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {
+  return sepia_filterColor(color);
+}
+`
+);
+var sepia = {
+  props: {},
+  uniforms: {},
+  name: "sepia",
+  uniformTypes: {
+    amount: "f32"
+  },
+  propTypes: {
+    amount: { value: 0.5, min: 0, max: 1 }
+  },
+  fs: fs5,
+  passes: [{ filter: true }]
+};
+
+// dist/passes/postprocessing/image-adjust-filters/vibrance.js
+var fs6 = (
+  /* glsl */
+  `uniform vibranceUniforms {
+  float amount;
+} vibrance;
+
+vec4 vibrance_filterColor(vec4 color) {
+  float average = (color.r + color.g + color.b) / 3.0;
+  float mx = max(color.r, max(color.g, color.b));
+  float amt = (mx - average) * (-vibrance.amount * 3.0);
+  color.rgb = mix(color.rgb, vec3(mx), amt);
+  return color;
+}
+
+vec4 vibrance_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {
+  return vibrance_filterColor(color);
+}
+`
+);
+var vibrance = {
+  props: {},
+  uniforms: {},
+  name: "vibrance",
+  uniformTypes: {
+    amount: "f32"
+  },
+  propTypes: {
+    amount: { value: 0, min: -1, max: 1 }
+  },
+  fs: fs6,
+  passes: [{ filter: true }]
+};
+
+// dist/passes/postprocessing/image-adjust-filters/vignette.js
+var fs7 = (
+  /* glsl */
+  `uniform vignetteUniforms {
+  float radius;
+  float amount;
+} vignette;
+
+vec4 vignette_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {
+  float dist = distance(texCoord, vec2(0.5, 0.5));
+  float ratio = smoothstep(0.8, vignette.radius * 0.799, dist * (vignette.amount + vignette.radius));
+  return color.rgba * ratio + (1.0 - ratio)*vec4(0.0, 0.0, 0.0, 1.0);
+}
+`
+);
+var vignette = {
+  props: {},
+  uniforms: {},
+  name: "vignette",
+  uniformTypes: {
+    radius: "f32",
+    amount: "f32"
+  },
+  defaultUniforms: {
+    radius: 0.5,
+    amount: 0.5
+  },
+  propTypes: {
+    radius: { value: 0.5, min: 0, max: 1 },
+    amount: { value: 0.5, min: 0, max: 1 }
+  },
+  passes: [{ filter: true }],
+  fs: fs7
+};
+
+// dist/passes/postprocessing/image-blur-filters/tiltshift.js
+var import_shadertools = require("@luma.gl/shadertools");
+var fs8 = (
+  /* glsl */
+  `uniform tiltShiftUniforms {
+  float blurRadius;
+  float gradientRadius;
+  vec2 start;
+  vec2 end;
+  bool invert;
+} tiltShift;
+
+vec2 tiltShift_getDelta(vec2 texSize) {
+  vec2 vector = normalize((tiltShift.end - tiltShift.start) * texSize);
+  return tiltShift.invert ? vec2(-vector.y, vector.x) : vector;
+}
+
+vec4 tiltShift_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
+  vec4 color = vec4(0.0);
+  float total = 0.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((tiltShift.start.y - tiltShift.end.y) * texSize.y, (tiltShift.end.x - tiltShift.start.x) * texSize.x));
+  float radius = smoothstep(0.0, 1.0,
+    abs(dot(texCoord * texSize - tiltShift.start * texSize, normal)) / tiltShift.gradientRadius) * tiltShift.blurRadius;
+
+  for (float t = -30.0; t <= 30.0; t++) {
+    float percent = (t + offset - 0.5) / 30.0;
+    float weight = 1.0 - abs(percent);
+    vec4 offsetColor = texture(source, texCoord + tiltShift_getDelta(texSize) / texSize * percent * radius);
+
+    /* switch to pre-multiplied alpha to correctly blur transparent images */
+    offsetColor.rgb *= offsetColor.a;
+
+    color += offsetColor * weight;
+    total += weight;
+  }
+
+  color = color / total;
+
+  /* switch back from pre-multiplied alpha */
+  color.rgb /= color.a + 0.00001;
+
+  return color;
+}
+`
+);
+var tiltShift = {
+  props: {},
+  uniforms: {},
+  name: "tiltShift",
+  dependencies: [import_shadertools.random],
+  uniformTypes: {
+    blurRadius: "f32",
+    gradientRadius: "f32",
+    start: "vec2<f32>",
+    end: "vec2<f32>",
+    invert: "i32"
+  },
+  propTypes: {
+    blurRadius: { value: 15, min: 0, max: 50 },
+    gradientRadius: { value: 200, min: 0, max: 400 },
+    start: { value: [0, 0] },
+    end: { value: [1, 1] },
+    invert: { value: 0, private: true }
+  },
+  passes: [
+    { sampler: true, uniforms: { invert: 0 } },
+    { sampler: true, uniforms: { invert: 1 } }
+  ],
+  fs: fs8
+};
+
+// dist/passes/postprocessing/image-blur-filters/triangleblur.js
+var import_shadertools2 = require("@luma.gl/shadertools");
+var fs9 = (
+  /* glsl */
+  `uniform triangleBlurUniforms {
+  float radius;
+  vec2 delta;
+} triangleBlur;
+
+vec4 triangleBlur_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
+  vec2 adjustedDelta = triangleBlur.delta * triangleBlur.radius / texSize;
+
+  vec4 color = vec4(0.0);
+  float total = 0.0;
+
+  /* randomize the lookup values to hide the fixed number of samples */
+  float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);
+
+  for (float t = -30.0; t <= 30.0; t++) {
+    float percent = (t + offset - 0.5) / 30.0;
+    float weight = 1.0 - abs(percent);
+    vec4 offsetColor = texture(source, texCoord + adjustedDelta * percent);
+
+    /* switch to pre-multiplied alpha to correctly blur transparent images */
+    offsetColor.rgb *= offsetColor.a;
+
+    color += offsetColor * weight;
+    total += weight;
+  }
+
+  color = color / total;
+
+  /* switch back from pre-multiplied alpha */
+  color.rgb /= color.a + 0.00001;
+
+  return color;
+}
+`
+);
+var triangleBlur = {
+  props: {},
+  uniforms: {},
+  name: "triangleBlur",
+  uniformTypes: {
+    radius: "f32",
+    delta: "vec2<f32>"
+  },
+  propTypes: {
+    radius: { value: 20, min: 0, softMax: 100 },
+    delta: { value: [1, 0], private: true }
+  },
+  fs: fs9,
+  dependencies: [import_shadertools2.random],
+  passes: [
+    { sampler: true, uniforms: { delta: [1, 0] } },
+    { sampler: true, uniforms: { delta: [0, 1] } }
+  ]
+};
+
+// dist/passes/postprocessing/image-blur-filters/zoomblur.js
+var import_shadertools3 = require("@luma.gl/shadertools");
+var fs10 = `
+uniform zoomBlurUniforms {
+  vec2 center;
+  float strength;
+} zoomBlur;
+
+vec4 zoomBlur_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
+  vec4 color = vec4(0.0);
+  float total = 0.0;
+  vec2 toCenter = zoomBlur.center * texSize - texCoord * texSize;
+
+  /* randomize the lookup values to hide the fixed number of samples */
+  float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);
+
+  for (float t = 0.0; t <= 40.0; t++) {
+    float percent = (t + offset) / 40.0;
+    float weight = 4.0 * (percent - percent * percent);
+    vec4 offsetColor = texture(source, texCoord + toCenter * percent * zoomBlur.strength / texSize);
+
+    /* switch to pre-multiplied alpha to correctly blur transparent images */
+    offsetColor.rgb *= offsetColor.a;
+
+    color += offsetColor * weight;
+    total += weight;
+  }
+
+  color = color / total;
+
+  /* switch back from pre-multiplied alpha */
+  color.rgb /= color.a + 0.00001;
+
+  return color;
+}
+`;
+var zoomBlur = {
+  props: {},
+  uniforms: {},
+  name: "zoomBlur",
+  uniformTypes: {
+    center: "vec2<f32>",
+    strength: "f32"
+  },
+  propTypes: {
+    center: { value: [0.5, 0.5] },
+    strength: { value: 0.3, min: 0, softMax: 1 }
+  },
+  fs: fs10,
+  dependencies: [import_shadertools3.random],
+  passes: [{ sampler: true }]
+};
+
+// dist/passes/postprocessing/image-fun-filters/colorhalftone.js
+var fs11 = (
+  /* glsl */
+  `uniform colorHalftoneUniforms {
+  vec2 center;
+  float angle;
+  float size;
+} colorHalftone;
+
+float pattern(float angle, float scale, vec2 texSize, vec2 texCoord) {
+  float s = sin(angle), c = cos(angle);
+  vec2 tex = texCoord * texSize - colorHalftone.center * texSize;
+  vec2 point = vec2(
+	c * tex.x - s * tex.y,
+	s * tex.x + c * tex.y
+  ) * scale;
+  return (sin(point.x) * sin(point.y)) * 4.0;
+}
+
+vec4 colorHalftone_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {
+  float scale = 3.1514 / colorHalftone.size;
+  vec3 cmy = 1.0 - color.rgb;
+  float k = min(cmy.x, min(cmy.y, cmy.z));
+
+  cmy = (cmy - k) / (1.0 - k);
+  cmy = clamp(
+	  cmy * 10.0 - 3.0 + vec3(
+      pattern(colorHalftone.angle + 0.26179, scale, texSize, texCoord),
+	    pattern(colorHalftone.angle + 1.30899, scale, texSize, texCoord),
+      pattern(colorHalftone.angle, scale, texSize, texCoord)
+    ),
+	  0.0,
+	  1.0
+  );
+  k = clamp(k * 10.0 - 5.0 + pattern(colorHalftone.angle + 0.78539, scale, texSize, texCoord), 0.0, 1.0);
+  return vec4(1.0 - cmy - k, color.a);
+}
+`
+);
+var colorHalftone = {
+  props: {},
+  uniforms: {},
+  name: "colorHalftone",
+  uniformTypes: {
+    center: "vec2<f32>",
+    angle: "f32",
+    size: "f32"
+  },
+  propTypes: {
+    center: { value: [0.5, 0.5] },
+    angle: { value: 1.1, softMin: 0, softMax: Math.PI / 2 },
+    size: { value: 4, min: 1, softMin: 3, softMax: 20 }
+  },
+  fs: fs11,
+  passes: [{ filter: true }]
+};
+
+// dist/passes/postprocessing/image-fun-filters/dotscreen.js
+var fs12 = (
+  /* glsl */
+  `uniform dotScreenUniforms {
+  vec2 center;
+  float angle;
+  float size;
+} dotScreen;
+
+float pattern(vec2 texSize, vec2 texCoord) {
+  float scale = 3.1415 / dotScreen.size;
+
+  float s = sin(dotScreen.angle), c = cos(dotScreen.angle);
+  vec2 tex = texCoord * texSize - dotScreen.center * texSize;
+  vec2 point = vec2(
+    c * tex.x - s * tex.y,
+    s * tex.x + c * tex.y
+  ) * scale;
+  return (sin(point.x) * sin(point.y)) * 4.0;
+}
+
+vec4 dotScreen_filterColor_ext(vec4 color, vec2 texSize, vec2 texCoord) {
+  float average = (color.r + color.g + color.b) / 3.0;
+  return vec4(vec3(average * 10.0 - 5.0 + pattern(texSize, texCoord)), color.a);
+}
+`
+);
+var dotScreen = {
+  props: {},
+  uniforms: {},
+  name: "dotScreen",
+  uniformTypes: {
+    center: "vec2<f32>",
+    angle: "f32",
+    size: "f32"
+  },
+  propTypes: {
+    center: { value: [0.5, 0.5] },
+    angle: { value: 1.1, softMin: 0, softMax: Math.PI / 2 },
+    size: { value: 3, min: 1, softMin: 3, softMax: 20 }
+  },
+  fs: fs12,
+  passes: [{ filter: true }]
+};
+
+// dist/passes/postprocessing/image-fun-filters/edgework.js
+var import_shadertools4 = require("@luma.gl/shadertools");
+var fs13 = (
+  /* glsl */
+  `uniform edgeWorkUniforms {
+  float radius;
+  int mode;
+} edgeWork;
+
+vec4 edgeWork_sampleColorRGB(sampler2D source, vec2 texSize, vec2 texCoord, vec2 delta) {
+  vec2 relativeDelta = edgeWork.radius * delta / texSize;
+
+  vec2 color = vec2(0.0);
+  vec2 total = vec2(0.0);
+
+  /* randomize the lookup values to hide the fixed number of samples */
+  float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);
+
+  for (float t = -30.0; t <= 30.0; t++) {
+    float percent = (t + offset - 0.5) / 30.0;
+    float weight = 1.0 - abs(percent);
+    vec3 sampleColor = texture(source, texCoord + relativeDelta * percent).rgb;
+    float average = (sampleColor.r + sampleColor.g + sampleColor.b) / 3.0;
+    color.x += average * weight;
+    total.x += weight;
+    if (abs(t) < 15.0) {
+      weight = weight * 2.0 - 1.0;
+      color.y += average * weight;
+      total.y += weight;
+    }
+  }
+  return vec4(color / total, 0.0, 1.0);
+}
+
+vec4 edgeWork_sampleColorXY(sampler2D source, vec2 texSize, vec2 texCoord, vec2 delta) {
+  vec2 relativeDelta = edgeWork.radius * delta / texSize;
+
+  vec2 color = vec2(0.0);
+  vec2 total = vec2(0.0);
+
+  /* randomize the lookup values to hide the fixed number of samples */
+  float offset = random(vec3(12.9898, 78.233, 151.7182), 0.0);
+
+  for (float t = -30.0; t <= 30.0; t++) {
+    float percent = (t + offset - 0.5) / 30.0;
+    float weight = 1.0 - abs(percent);
+    vec2 sampleColor = texture(source, texCoord + relativeDelta * percent).xy;
+    color.x += sampleColor.x * weight;
+    total.x += weight;
+    if (abs(t) < 15.0) {
+      weight = weight * 2.0 - 1.0;
+      color.y += sampleColor.y * weight;
+      total.y += weight;
+    }
+  }
+  float c = clamp(10000.0 * (color.y / total.y - color.x / total.x) + 0.5, 0.0, 1.0);
+  return vec4(c, c, c, 1.0);
+}
+
+vec4 edgeWork_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
+  switch (edgeWork.mode) {
+    case 0: 
+    return edgeWork_sampleColorRGB(source, texSize, texCoord, vec2(1., 0.));
+    case 1: 
+    default:
+      return edgeWork_sampleColorXY(source, texSize, texCoord, vec2(0., 1.));
+  }
+}
+`
+);
+var edgeWork = {
+  props: {},
+  uniforms: {},
+  name: "edgeWork",
+  dependencies: [import_shadertools4.random],
+  fs: fs13,
+  uniformTypes: {
+    radius: "f32",
+    mode: "i32"
+  },
+  propTypes: {
+    radius: { value: 2, min: 1, softMax: 50 },
+    mode: { value: 0, private: true }
+  },
+  passes: [
+    {
+      sampler: true,
+      uniforms: { mode: 0 }
+    },
+    {
+      sampler: true,
+      uniforms: { mode: 1 }
+    }
+  ]
+};
+
+// dist/passes/postprocessing/image-fun-filters/hexagonalpixelate.js
+var fs14 = (
+  /* glsl */
+  `uniform hexagonalPixelateUniforms {
+  vec2 center;
+  float scale;
+} hexagonalPixelate;
+
+vec4 hexagonalPixelate_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
+  vec2 tex = (texCoord * texSize - hexagonalPixelate.center * texSize) / hexagonalPixelate.scale;
+  tex.y /= 0.866025404;
+  tex.x -= tex.y * 0.5;
+
+  vec2 a;
+  if (tex.x + tex.y - floor(tex.x) - floor(tex.y) < 1.0) {
+    a = vec2(floor(tex.x), floor(tex.y));
+  }
+  else a = vec2(ceil(tex.x), ceil(tex.y));
+  vec2 b = vec2(ceil(tex.x), floor(tex.y));
+  vec2 c = vec2(floor(tex.x), ceil(tex.y));
+
+  vec3 TEX = vec3(tex.x, tex.y, 1.0 - tex.x - tex.y);
+  vec3 A = vec3(a.x, a.y, 1.0 - a.x - a.y);
+  vec3 B = vec3(b.x, b.y, 1.0 - b.x - b.y);
+  vec3 C = vec3(c.x, c.y, 1.0 - c.x - c.y);
+
+  float alen = length(TEX - A);
+  float blen = length(TEX - B);
+  float clen = length(TEX - C);
+
+  vec2 choice;
+  if (alen < blen) {
+    if (alen < clen) choice = a;
+    else choice = c;
+  } else {
+    if (blen < clen) choice = b;
+    else choice = c;
+  }
+
+  choice.x += choice.y * 0.5;
+  choice.y *= 0.866025404;
+  choice *= hexagonalPixelate.scale / texSize;
+
+  return texture(source, choice + hexagonalPixelate.center);
+}
+`
+);
+var hexagonalPixelate = {
+  props: {},
+  uniforms: {},
+  name: "hexagonalPixelate",
+  uniformTypes: {
+    center: "vec2<f32>",
+    scale: "f32"
+  },
+  propTypes: {
+    center: { value: [0.5, 0.5], hint: "screenspace" },
+    scale: { value: 10, min: 1, softMin: 5, softMax: 50 }
+  },
+  fs: fs14,
+  passes: [{ sampler: true }]
+};
+
+// dist/passes/postprocessing/image-fun-filters/ink.js
+var fs15 = (
+  /* glsl */
+  `uniform inkUniforms {
+  float strength;
+} ink;
+
+vec4 ink_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
+  vec2 dx = vec2(1.0 / texSize.x, 0.0);
+  vec2 dy = vec2(0.0, 1.0 / texSize.y);
+  vec4 color = texture(source, texCoord);
+  float bigTotal = 0.0;
+  float smallTotal = 0.0;
+  vec3 bigAverage = vec3(0.0);
+  vec3 smallAverage = vec3(0.0);
+  for (float x = -2.0; x <= 2.0; x += 1.0) {
+    for (float y = -2.0; y <= 2.0; y += 1.0) {
+      vec3 offsetColor = texture(source, texCoord + dx * x + dy * y).rgb;
+      bigAverage += offsetColor;
+      bigTotal += 1.0;
+      if (abs(x) + abs(y) < 2.0) {
+        smallAverage += offsetColor;
+        smallTotal += 1.0;
+      }
+    }
+  }
+  vec3 edge = max(vec3(0.0), bigAverage / bigTotal - smallAverage / smallTotal);
+  float power = ink.strength * ink.strength * ink.strength * ink.strength * ink.strength;
+  return vec4(color.rgb - dot(edge, edge) * power * 100000.0, color.a);
+}
+`
+);
+var ink = {
+  props: {},
+  uniforms: {},
+  name: "ink",
+  fs: fs15,
+  uniformTypes: {
+    strength: "f32"
+  },
+  propTypes: {
+    strength: { value: 0.25, min: 0, softMax: 1 }
+  },
+  passes: [{ sampler: true }]
+};
+
+// dist/passes/postprocessing/image-fun-filters/magnify.js
+var fs16 = (
+  /* glsl */
+  `uniform magnifyUniforms {
+  vec2 screenXY;
+  float radiusPixels;
+  float zoom;
+  float borderWidthPixels;
+  vec4 borderColor;
+} magnify;
+
+vec4 magnify_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
+  vec2 pos = vec2(magnify.screenXY.x, 1.0 - magnify.screenXY.y);
+  float dist = distance(texCoord * texSize, pos * texSize);
+  if (dist < magnify.radiusPixels) {
+    return texture(source, (texCoord - pos) / magnify.zoom + pos);
+  }
+
+  if (dist <= magnify.radiusPixels + magnify.borderWidthPixels) {
+    return magnify.borderColor;
+  }
+  return texture(source, texCoord);
+}
+`
+);
+var magnify = {
+  name: "magnify",
+  uniformTypes: {
+    screenXY: "vec2<f32>",
+    radiusPixels: "f32",
+    zoom: "f32",
+    borderWidthPixels: "f32",
+    borderColor: "vec4<f32>"
+  },
+  propTypes: {
+    // range 0 to 1
+    screenXY: { value: [0, 0] },
+    radiusPixels: 200,
+    zoom: 2,
+    borderWidthPixels: 0,
+    borderColor: { value: [255, 255, 255, 255] }
+  },
+  fs: fs16,
+  passes: [{ sampler: true }]
+};
+
+// dist/passes/postprocessing/image-warp-filters/warp.js
+var fs17 = (
+  /* glsl */
+  `vec4 warp_sampleColor(sampler2D source, vec2 texSize, vec2 coord) {
+  vec4 color = texture(source, coord / texSize);
+  vec2 clampedCoord = clamp(coord, vec2(0.0), texSize);
+  if (coord != clampedCoord) {
+    /* fade to transparent if we are outside the image */
+    color.a *= max(0.0, 1.0 - length(coord - clampedCoord));
+  }
+
+  return color;
+}
+`
+);
+var warp = {
+  name: "warp",
+  passes: [],
+  fs: fs17
+};
+
+// dist/passes/postprocessing/image-warp-filters/bulgepinch.js
+var fs18 = (
+  /* glsl */
+  `uniform bulgePinchUniforms {
+  float radius;
+  float strength;
+  vec2 center;
+} bulgePinch;
+
+vec2 bulgePinch_warp(vec2 coord, vec2 texCenter) {
+  coord -= texCenter;
+  float distance = length(coord);
+  if (distance < bulgePinch.radius) {
+    float percent = distance / bulgePinch.radius;
+    if (bulgePinch.strength > 0.0) {
+      coord *= mix(1.0, smoothstep(0.0, bulgePinch.radius / distance, percent), bulgePinch.strength * 0.75);
+    } else {
+      coord *= mix(1.0, pow(percent, 1.0 + bulgePinch.strength * 0.75) * bulgePinch.radius / distance, 1.0 - percent);
+    }
+  }
+  coord += texCenter;
+  return coord;
+}
+
+vec4 bulgePinch_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
+  vec2 coord = texCoord * texSize;
+  coord = bulgePinch_warp(coord, bulgePinch.center * texSize);
+
+  return warp_sampleColor(source, texSize, coord);
+}
+`
+);
+var bulgePinch = {
+  props: {},
+  uniforms: {},
+  name: "bulgePinch",
+  dependencies: [warp],
+  fs: fs18,
+  uniformTypes: {
+    center: "vec2<f32>",
+    radius: "f32",
+    strength: "f32"
+  },
+  propTypes: {
+    center: { value: [0.5, 0.5] },
+    radius: { value: 200, min: 1, softMax: 600 },
+    strength: { value: 0.5, min: -1, max: 1 }
+  },
+  passes: [{ sampler: true }]
+};
+
+// dist/passes/postprocessing/image-warp-filters/swirl.js
+var fs19 = (
+  /* glsl */
+  `uniform swirlUniforms {
+  float radius;
+  float angle;
+  vec2 center;
+} swirl;
+
+vec2 swirl_warp(vec2 coord, vec2 texCenter) {
+  coord -= texCenter;
+  float distance = length(coord);
+  if (distance < swirl.radius) {
+    float percent = (swirl.radius - distance) / swirl.radius;
+    float theta = percent * percent * swirl.angle;
+    float s = sin(theta);
+    float c = cos(theta);
+    coord = vec2(
+      coord.x * c - coord.y * s,
+      coord.x * s + coord.y * c
+    );
+  }
+  coord += texCenter;
+  return coord;
+}
+
+vec4 swirl_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
+  vec2 coord = texCoord * texSize;
+  coord = swirl_warp(coord, swirl.center * texSize);
+
+  return warp_sampleColor(source, texSize, coord);
+}
+`
+);
+var swirl = {
+  props: {},
+  uniforms: {},
+  name: "swirl",
+  dependencies: [warp],
+  fs: fs19,
+  uniformTypes: {
+    center: "vec2<f32>",
+    radius: "f32",
+    angle: "f32"
+  },
+  propTypes: {
+    center: { value: [0.5, 0.5] },
+    radius: { value: 200, min: 1, softMax: 600 },
+    angle: { value: 3, softMin: -25, softMax: 25 }
+  },
+  passes: [{ sampler: true }]
+};
+
+// dist/passes/postprocessing/fxaa/fxaa.js
+var fs20 = (
+  /* glsl */
+  `
+#define FXAA_QUALITY_PRESET 29
+
+#if (FXAA_QUALITY_PRESET == 10)
+    #define FXAA_QUALITY_PS 3
+    #define FXAA_QUALITY_P0 1.5
+    #define FXAA_QUALITY_P1 3.0
+    #define FXAA_QUALITY_P2 12.0
+#endif
+#if (FXAA_QUALITY_PRESET == 11)
+    #define FXAA_QUALITY_PS 4
+    #define FXAA_QUALITY_P0 1.0
+    #define FXAA_QUALITY_P1 1.5
+    #define FXAA_QUALITY_P2 3.0
+    #define FXAA_QUALITY_P3 12.0
+#endif
+#if (FXAA_QUALITY_PRESET == 12)
+    #define FXAA_QUALITY_PS 5
+    #define FXAA_QUALITY_P0 1.0
+    #define FXAA_QUALITY_P1 1.5
+    #define FXAA_QUALITY_P2 2.0
+    #define FXAA_QUALITY_P3 4.0
+    #define FXAA_QUALITY_P4 12.0
+#endif
+#if (FXAA_QUALITY_PRESET == 13)
+    #define FXAA_QUALITY_PS 6
+    #define FXAA_QUALITY_P0 1.0
+    #define FXAA_QUALITY_P1 1.5
+    #define FXAA_QUALITY_P2 2.0
+    #define FXAA_QUALITY_P3 2.0
+    #define FXAA_QUALITY_P4 4.0
+    #define FXAA_QUALITY_P5 12.0
+#endif
+#if (FXAA_QUALITY_PRESET == 14)
+    #define FXAA_QUALITY_PS 7
+    #define FXAA_QUALITY_P0 1.0
+    #define FXAA_QUALITY_P1 1.5
+    #define FXAA_QUALITY_P2 2.0
+    #define FXAA_QUALITY_P3 2.0
+    #define FXAA_QUALITY_P4 2.0
+    #define FXAA_QUALITY_P5 4.0
+    #define FXAA_QUALITY_P6 12.0
+#endif
+#if (FXAA_QUALITY_PRESET == 15)
+    #define FXAA_QUALITY_PS 8
+    #define FXAA_QUALITY_P0 1.0
+    #define FXAA_QUALITY_P1 1.5
+    #define FXAA_QUALITY_P2 2.0
+    #define FXAA_QUALITY_P3 2.0
+    #define FXAA_QUALITY_P4 2.0
+    #define FXAA_QUALITY_P5 2.0
+    #define FXAA_QUALITY_P6 4.0
+    #define FXAA_QUALITY_P7 12.0
+#endif
+#if (FXAA_QUALITY_PRESET == 20)
+    #define FXAA_QUALITY_PS 3
+    #define FXAA_QUALITY_P0 1.5
+    #define FXAA_QUALITY_P1 2.0
+    #define FXAA_QUALITY_P2 8.0
+#endif
+#if (FXAA_QUALITY_PRESET == 21)
+    #define FXAA_QUALITY_PS 4
+    #define FXAA_QUALITY_P0 1.0
+    #define FXAA_QUALITY_P1 1.5
+    #define FXAA_QUALITY_P2 2.0
+    #define FXAA_QUALITY_P3 8.0
+#endif
+#if (FXAA_QUALITY_PRESET == 22)
+    #define FXAA_QUALITY_PS 5
+    #define FXAA_QUALITY_P0 1.0
+    #define FXAA_QUALITY_P1 1.5
+    #define FXAA_QUALITY_P2 2.0
+    #define FXAA_QUALITY_P3 2.0
+    #define FXAA_QUALITY_P4 8.0
+#endif
+#if (FXAA_QUALITY_PRESET == 23)
+    #define FXAA_QUALITY_PS 6
+    #define FXAA_QUALITY_P0 1.0
+    #define FXAA_QUALITY_P1 1.5
+    #define FXAA_QUALITY_P2 2.0
+    #define FXAA_QUALITY_P3 2.0
+    #define FXAA_QUALITY_P4 2.0
+    #define FXAA_QUALITY_P5 8.0
+#endif
+#if (FXAA_QUALITY_PRESET == 24)
+    #define FXAA_QUALITY_PS 7
+    #define FXAA_QUALITY_P0 1.0
+    #define FXAA_QUALITY_P1 1.5
+    #define FXAA_QUALITY_P2 2.0
+    #define FXAA_QUALITY_P3 2.0
+    #define FXAA_QUALITY_P4 2.0
+    #define FXAA_QUALITY_P5 3.0
+    #define FXAA_QUALITY_P6 8.0
+#endif
+#if (FXAA_QUALITY_PRESET == 25)
+    #define FXAA_QUALITY_PS 8
+    #define FXAA_QUALITY_P0 1.0
+    #define FXAA_QUALITY_P1 1.5
+    #define FXAA_QUALITY_P2 2.0
+    #define FXAA_QUALITY_P3 2.0
+    #define FXAA_QUALITY_P4 2.0
+    #define FXAA_QUALITY_P5 2.0
+    #define FXAA_QUALITY_P6 4.0
+    #define FXAA_QUALITY_P7 8.0
+#endif
+#if (FXAA_QUALITY_PRESET == 26)
+    #define FXAA_QUALITY_PS 9
+    #define FXAA_QUALITY_P0 1.0
+    #define FXAA_QUALITY_P1 1.5
+    #define FXAA_QUALITY_P2 2.0
+    #define FXAA_QUALITY_P3 2.0
+    #define FXAA_QUALITY_P4 2.0
+    #define FXAA_QUALITY_P5 2.0
+    #define FXAA_QUALITY_P6 2.0
+    #define FXAA_QUALITY_P7 4.0
+    #define FXAA_QUALITY_P8 8.0
+#endif
+#if (FXAA_QUALITY_PRESET == 27)
+    #define FXAA_QUALITY_PS 10
+    #define FXAA_QUALITY_P0 1.0
+    #define FXAA_QUALITY_P1 1.5
+    #define FXAA_QUALITY_P2 2.0
+    #define FXAA_QUALITY_P3 2.0
+    #define FXAA_QUALITY_P4 2.0
+    #define FXAA_QUALITY_P5 2.0
+    #define FXAA_QUALITY_P6 2.0
+    #define FXAA_QUALITY_P7 2.0
+    #define FXAA_QUALITY_P8 4.0
+    #define FXAA_QUALITY_P9 8.0
+#endif
+#if (FXAA_QUALITY_PRESET == 28)
+    #define FXAA_QUALITY_PS 11
+    #define FXAA_QUALITY_P0 1.0
+    #define FXAA_QUALITY_P1 1.5
+    #define FXAA_QUALITY_P2 2.0
+    #define FXAA_QUALITY_P3 2.0
+    #define FXAA_QUALITY_P4 2.0
+    #define FXAA_QUALITY_P5 2.0
+    #define FXAA_QUALITY_P6 2.0
+    #define FXAA_QUALITY_P7 2.0
+    #define FXAA_QUALITY_P8 2.0
+    #define FXAA_QUALITY_P9 4.0
+    #define FXAA_QUALITY_P10 8.0
+#endif
+#if (FXAA_QUALITY_PRESET == 29)
+    #define FXAA_QUALITY_PS 12
+    #define FXAA_QUALITY_P0 1.0
+    #define FXAA_QUALITY_P1 1.5
+    #define FXAA_QUALITY_P2 2.0
+    #define FXAA_QUALITY_P3 2.0
+    #define FXAA_QUALITY_P4 2.0
+    #define FXAA_QUALITY_P5 2.0
+    #define FXAA_QUALITY_P6 2.0
+    #define FXAA_QUALITY_P7 2.0
+    #define FXAA_QUALITY_P8 2.0
+    #define FXAA_QUALITY_P9 2.0
+    #define FXAA_QUALITY_P10 4.0
+    #define FXAA_QUALITY_P11 8.0
+#endif
+#if (FXAA_QUALITY_PRESET == 39)
+    #define FXAA_QUALITY_PS 12
+    #define FXAA_QUALITY_P0 1.0
+    #define FXAA_QUALITY_P1 1.0
+    #define FXAA_QUALITY_P2 1.0
+    #define FXAA_QUALITY_P3 1.0
+    #define FXAA_QUALITY_P4 1.0
+    #define FXAA_QUALITY_P5 1.5
+    #define FXAA_QUALITY_P6 2.0
+    #define FXAA_QUALITY_P7 2.0
+    #define FXAA_QUALITY_P8 2.0
+    #define FXAA_QUALITY_P9 2.0
+    #define FXAA_QUALITY_P10 4.0
+    #define FXAA_QUALITY_P11 8.0
+#endif
+
+#define FxaaBool bool
+#define FxaaFloat float
+#define FxaaFloat2 vec2
+#define FxaaFloat3 vec3
+#define FxaaFloat4 vec4
+#define FxaaHalf float
+#define FxaaHalf2 vec2
+#define FxaaHalf3 vec3
+#define FxaaHalf4 vec4
+#define FxaaInt2 vec2
+#define FxaaTex sampler2D
+
+#define FxaaSat(x) clamp(x, 0.0, 1.0)
+#define FxaaTexTop(t, p) texture(t, p)
+#define FxaaTexOff(t, p, o, r) texture(t, p + (o * r))
+
+FxaaFloat FxaaLuma_(FxaaFloat4 rgba) { return dot(rgba.rgb, vec3(0.2126, 0.7152, 0.0722)); }
+
+FxaaFloat4 FxaaPixelShader_(
+    //
+    // Use noperspective interpolation here (turn off perspective interpolation).
+    // {xy} = center of pixel
+    FxaaFloat2 pos,
+    //
+    // Input color texture.
+    // {rgb_} = color in linear or perceptual color space
+    // if (FXAA_GREEN_AS_LUMA == 0)
+    //     {___a} = luma in perceptual color space (not linear)
+    FxaaTex tex,
+    //
+    // Only used on FXAA Quality.
+    // This must be from a constant/uniform.
+    // {x_} = 1.0/screenWidthInPixels
+    // {_y} = 1.0/screenHeightInPixels
+    FxaaFloat2 fxaaQualityRcpFrame,
+    //
+    // Only used on FXAA Quality.
+    // This used to be the FXAA_QUALITY_SUBPIX define.
+    // It is here now to allow easier tuning.
+    // Choose the amount of sub-pixel aliasing removal.
+    // This can effect sharpness.
+    //   1.00 - upper limit (softer)
+    //   0.75 - default amount of filtering
+    //   0.50 - lower limit (sharper, less sub-pixel aliasing removal)
+    //   0.25 - almost off
+    //   0.00 - completely off
+    FxaaFloat fxaaQualitySubpix,
+    //
+    // Only used on FXAA Quality.
+    // This used to be the FXAA_QUALITY_EDGE_THRESHOLD define.
+    // It is here now to allow easier tuning.
+    // The minimum amount of local contrast required to apply algorithm.
+    //   0.333 - too little (faster)
+    //   0.250 - low quality
+    //   0.166 - default
+    //   0.125 - high quality
+    //   0.063 - overkill (slower)
+    FxaaFloat fxaaQualityEdgeThreshold,
+    //
+    // Only used on FXAA Quality.
+    // This used to be the FXAA_QUALITY_EDGE_THRESHOLD_MIN define.
+    // It is here now to allow easier tuning.
+    // Trims the algorithm from processing darks.
+    //   0.0833 - upper limit (default, the start of visible unfiltered edges)
+    //   0.0625 - high quality (faster)
+    //   0.0312 - visible limit (slower)
+    // Special notes when using FXAA_GREEN_AS_LUMA,
+    //   Likely want to set this to zero.
+    //   As colors that are mostly not-green
+    //   will appear very dark in the green channel!
+    //   Tune by looking at mostly non-green content,
+    //   then start at zero and increase until aliasing is a problem.
+    FxaaFloat fxaaQualityEdgeThresholdMin
+) {
+/*--------------------------------------------------------------------------*/
+    FxaaFloat2 posM;
+    posM.x = pos.x;
+    posM.y = pos.y;
+    FxaaFloat4 rgbyM = FxaaTexTop(tex, posM);
+    #define lumaM rgbyM.y
+    FxaaFloat lumaS = FxaaLuma_(FxaaTexOff(tex, posM, FxaaInt2( 0, 1), fxaaQualityRcpFrame.xy));
+    FxaaFloat lumaE = FxaaLuma_(FxaaTexOff(tex, posM, FxaaInt2( 1, 0), fxaaQualityRcpFrame.xy));
+    FxaaFloat lumaN = FxaaLuma_(FxaaTexOff(tex, posM, FxaaInt2( 0,-1), fxaaQualityRcpFrame.xy));
+    FxaaFloat lumaW = FxaaLuma_(FxaaTexOff(tex, posM, FxaaInt2(-1, 0), fxaaQualityRcpFrame.xy));
+/*--------------------------------------------------------------------------*/
+    FxaaFloat maxSM = max(lumaS, lumaM);
+    FxaaFloat minSM = min(lumaS, lumaM);
+    FxaaFloat maxESM = max(lumaE, maxSM);
+    FxaaFloat minESM = min(lumaE, minSM);
+    FxaaFloat maxWN = max(lumaN, lumaW);
+    FxaaFloat minWN = min(lumaN, lumaW);
+    FxaaFloat rangeMax = max(maxWN, maxESM);
+    FxaaFloat rangeMin = min(minWN, minESM);
+    FxaaFloat rangeMaxScaled = rangeMax * fxaaQualityEdgeThreshold;
+    FxaaFloat range = rangeMax - rangeMin;
+    FxaaFloat rangeMaxClamped = max(fxaaQualityEdgeThresholdMin, rangeMaxScaled);
+    FxaaBool earlyExit = range < rangeMaxClamped;
+/*--------------------------------------------------------------------------*/
+    if(earlyExit)
+        return rgbyM;
+/*--------------------------------------------------------------------------*/
+    FxaaFloat lumaNW = FxaaLuma_(FxaaTexOff(tex, posM, FxaaInt2(-1,-1), fxaaQualityRcpFrame.xy));
+    FxaaFloat lumaSE = FxaaLuma_(FxaaTexOff(tex, posM, FxaaInt2( 1, 1), fxaaQualityRcpFrame.xy));
+    FxaaFloat lumaNE = FxaaLuma_(FxaaTexOff(tex, posM, FxaaInt2( 1,-1), fxaaQualityRcpFrame.xy));
+    FxaaFloat lumaSW = FxaaLuma_(FxaaTexOff(tex, posM, FxaaInt2(-1, 1), fxaaQualityRcpFrame.xy));
+/*--------------------------------------------------------------------------*/
+    FxaaFloat lumaNS = lumaN + lumaS;
+    FxaaFloat lumaWE = lumaW + lumaE;
+    FxaaFloat subpixRcpRange = 1.0/range;
+    FxaaFloat subpixNSWE = lumaNS + lumaWE;
+    FxaaFloat edgeHorz1 = (-2.0 * lumaM) + lumaNS;
+    FxaaFloat edgeVert1 = (-2.0 * lumaM) + lumaWE;
+/*--------------------------------------------------------------------------*/
+    FxaaFloat lumaNESE = lumaNE + lumaSE;
+    FxaaFloat lumaNWNE = lumaNW + lumaNE;
+    FxaaFloat edgeHorz2 = (-2.0 * lumaE) + lumaNESE;
+    FxaaFloat edgeVert2 = (-2.0 * lumaN) + lumaNWNE;
+/*--------------------------------------------------------------------------*/
+    FxaaFloat lumaNWSW = lumaNW + lumaSW;
+    FxaaFloat lumaSWSE = lumaSW + lumaSE;
+    FxaaFloat edgeHorz4 = (abs(edgeHorz1) * 2.0) + abs(edgeHorz2);
+    FxaaFloat edgeVert4 = (abs(edgeVert1) * 2.0) + abs(edgeVert2);
+    FxaaFloat edgeHorz3 = (-2.0 * lumaW) + lumaNWSW;
+    FxaaFloat edgeVert3 = (-2.0 * lumaS) + lumaSWSE;
+    FxaaFloat edgeHorz = abs(edgeHorz3) + edgeHorz4;
+    FxaaFloat edgeVert = abs(edgeVert3) + edgeVert4;
+/*--------------------------------------------------------------------------*/
+    FxaaFloat subpixNWSWNESE = lumaNWSW + lumaNESE;
+    FxaaFloat lengthSign = fxaaQualityRcpFrame.x;
+    FxaaBool horzSpan = edgeHorz >= edgeVert;
+    FxaaFloat subpixA = subpixNSWE * 2.0 + subpixNWSWNESE;
+/*--------------------------------------------------------------------------*/
+    if(!horzSpan) lumaN = lumaW;
+    if(!horzSpan) lumaS = lumaE;
+    if(horzSpan) lengthSign = fxaaQualityRcpFrame.y;
+    FxaaFloat subpixB = (subpixA * (1.0/12.0)) - lumaM;
+/*--------------------------------------------------------------------------*/
+    FxaaFloat gradientN = lumaN - lumaM;
+    FxaaFloat gradientS = lumaS - lumaM;
+    FxaaFloat lumaNN = lumaN + lumaM;
+    FxaaFloat lumaSS = lumaS + lumaM;
+    FxaaBool pairN = abs(gradientN) >= abs(gradientS);
+    FxaaFloat gradient = max(abs(gradientN), abs(gradientS));
+    if(pairN) lengthSign = -lengthSign;
+    FxaaFloat subpixC = FxaaSat(abs(subpixB) * subpixRcpRange);
+/*--------------------------------------------------------------------------*/
+    FxaaFloat2 posB;
+    posB.x = posM.x;
+    posB.y = posM.y;
+    FxaaFloat2 offNP;
+    offNP.x = (!horzSpan) ? 0.0 : fxaaQualityRcpFrame.x;
+    offNP.y = ( horzSpan) ? 0.0 : fxaaQualityRcpFrame.y;
+    if(!horzSpan) posB.x += lengthSign * 0.5;
+    if( horzSpan) posB.y += lengthSign * 0.5;
+/*--------------------------------------------------------------------------*/
+    FxaaFloat2 posN;
+    posN.x = posB.x - offNP.x * FXAA_QUALITY_P0;
+    posN.y = posB.y - offNP.y * FXAA_QUALITY_P0;
+    FxaaFloat2 posP;
+    posP.x = posB.x + offNP.x * FXAA_QUALITY_P0;
+    posP.y = posB.y + offNP.y * FXAA_QUALITY_P0;
+    FxaaFloat subpixD = ((-2.0)*subpixC) + 3.0;
+    FxaaFloat lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN));
+    FxaaFloat subpixE = subpixC * subpixC;
+    FxaaFloat lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP));
+/*--------------------------------------------------------------------------*/
+    if(!pairN) lumaNN = lumaSS;
+    FxaaFloat gradientScaled = gradient * 1.0/4.0;
+    FxaaFloat lumaMM = lumaM - lumaNN * 0.5;
+    FxaaFloat subpixF = subpixD * subpixE;
+    FxaaBool lumaMLTZero = lumaMM < 0.0;
+/*--------------------------------------------------------------------------*/
+    lumaEndN -= lumaNN * 0.5;
+    lumaEndP -= lumaNN * 0.5;
+    FxaaBool doneN = abs(lumaEndN) >= gradientScaled;
+    FxaaBool doneP = abs(lumaEndP) >= gradientScaled;
+    if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P1;
+    if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P1;
+    FxaaBool doneNP = (!doneN) || (!doneP);
+    if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P1;
+    if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P1;
+/*--------------------------------------------------------------------------*/
+    if(doneNP) {
+        if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));
+        if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));
+        if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
+        if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
+        doneN = abs(lumaEndN) >= gradientScaled;
+        doneP = abs(lumaEndP) >= gradientScaled;
+        if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P2;
+        if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P2;
+        doneNP = (!doneN) || (!doneP);
+        if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P2;
+        if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P2;
+/*--------------------------------------------------------------------------*/
+        #if (FXAA_QUALITY_PS > 3)
+        if(doneNP) {
+            if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));
+            if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));
+            if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
+            if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
+            doneN = abs(lumaEndN) >= gradientScaled;
+            doneP = abs(lumaEndP) >= gradientScaled;
+            if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P3;
+            if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P3;
+            doneNP = (!doneN) || (!doneP);
+            if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P3;
+            if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P3;
+/*--------------------------------------------------------------------------*/
+            #if (FXAA_QUALITY_PS > 4)
+            if(doneNP) {
+                if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));
+                if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));
+                if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
+                if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
+                doneN = abs(lumaEndN) >= gradientScaled;
+                doneP = abs(lumaEndP) >= gradientScaled;
+                if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P4;
+                if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P4;
+                doneNP = (!doneN) || (!doneP);
+                if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P4;
+                if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P4;
+/*--------------------------------------------------------------------------*/
+                #if (FXAA_QUALITY_PS > 5)
+                if(doneNP) {
+                    if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));
+                    if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));
+                    if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
+                    if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
+                    doneN = abs(lumaEndN) >= gradientScaled;
+                    doneP = abs(lumaEndP) >= gradientScaled;
+                    if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P5;
+                    if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P5;
+                    doneNP = (!doneN) || (!doneP);
+                    if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P5;
+                    if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P5;
+/*--------------------------------------------------------------------------*/
+                    #if (FXAA_QUALITY_PS > 6)
+                    if(doneNP) {
+                        if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));
+                        if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));
+                        if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
+                        if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
+                        doneN = abs(lumaEndN) >= gradientScaled;
+                        doneP = abs(lumaEndP) >= gradientScaled;
+                        if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P6;
+                        if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P6;
+                        doneNP = (!doneN) || (!doneP);
+                        if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P6;
+                        if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P6;
+/*--------------------------------------------------------------------------*/
+                        #if (FXAA_QUALITY_PS > 7)
+                        if(doneNP) {
+                            if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));
+                            if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));
+                            if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
+                            if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
+                            doneN = abs(lumaEndN) >= gradientScaled;
+                            doneP = abs(lumaEndP) >= gradientScaled;
+                            if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P7;
+                            if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P7;
+                            doneNP = (!doneN) || (!doneP);
+                            if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P7;
+                            if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P7;
+/*--------------------------------------------------------------------------*/
+    #if (FXAA_QUALITY_PS > 8)
+    if(doneNP) {
+        if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));
+        if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));
+        if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
+        if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
+        doneN = abs(lumaEndN) >= gradientScaled;
+        doneP = abs(lumaEndP) >= gradientScaled;
+        if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P8;
+        if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P8;
+        doneNP = (!doneN) || (!doneP);
+        if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P8;
+        if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P8;
+/*--------------------------------------------------------------------------*/
+        #if (FXAA_QUALITY_PS > 9)
+        if(doneNP) {
+            if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));
+            if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));
+            if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
+            if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
+            doneN = abs(lumaEndN) >= gradientScaled;
+            doneP = abs(lumaEndP) >= gradientScaled;
+            if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P9;
+            if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P9;
+            doneNP = (!doneN) || (!doneP);
+            if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P9;
+            if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P9;
+/*--------------------------------------------------------------------------*/
+            #if (FXAA_QUALITY_PS > 10)
+            if(doneNP) {
+                if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));
+                if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));
+                if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
+                if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
+                doneN = abs(lumaEndN) >= gradientScaled;
+                doneP = abs(lumaEndP) >= gradientScaled;
+                if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P10;
+                if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P10;
+                doneNP = (!doneN) || (!doneP);
+                if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P10;
+                if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P10;
+/*--------------------------------------------------------------------------*/
+                #if (FXAA_QUALITY_PS > 11)
+                if(doneNP) {
+                    if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));
+                    if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));
+                    if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
+                    if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
+                    doneN = abs(lumaEndN) >= gradientScaled;
+                    doneP = abs(lumaEndP) >= gradientScaled;
+                    if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P11;
+                    if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P11;
+                    doneNP = (!doneN) || (!doneP);
+                    if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P11;
+                    if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P11;
+/*--------------------------------------------------------------------------*/
+                    #if (FXAA_QUALITY_PS > 12)
+                    if(doneNP) {
+                        if(!doneN) lumaEndN = FxaaLuma_(FxaaTexTop(tex, posN.xy));
+                        if(!doneP) lumaEndP = FxaaLuma_(FxaaTexTop(tex, posP.xy));
+                        if(!doneN) lumaEndN = lumaEndN - lumaNN * 0.5;
+                        if(!doneP) lumaEndP = lumaEndP - lumaNN * 0.5;
+                        doneN = abs(lumaEndN) >= gradientScaled;
+                        doneP = abs(lumaEndP) >= gradientScaled;
+                        if(!doneN) posN.x -= offNP.x * FXAA_QUALITY_P12;
+                        if(!doneN) posN.y -= offNP.y * FXAA_QUALITY_P12;
+                        doneNP = (!doneN) || (!doneP);
+                        if(!doneP) posP.x += offNP.x * FXAA_QUALITY_P12;
+                        if(!doneP) posP.y += offNP.y * FXAA_QUALITY_P12;
+/*--------------------------------------------------------------------------*/
+                    }
+                    #endif
+/*--------------------------------------------------------------------------*/
+                }
+                #endif
+/*--------------------------------------------------------------------------*/
+            }
+            #endif
+/*--------------------------------------------------------------------------*/
+        }
+        #endif
+/*--------------------------------------------------------------------------*/
+    }
+    #endif
+/*--------------------------------------------------------------------------*/
+                        }
+                        #endif
+/*--------------------------------------------------------------------------*/
+                    }
+                    #endif
+/*--------------------------------------------------------------------------*/
+                }
+                #endif
+/*--------------------------------------------------------------------------*/
+            }
+            #endif
+/*--------------------------------------------------------------------------*/
+        }
+        #endif
+/*--------------------------------------------------------------------------*/
+    }
+/*--------------------------------------------------------------------------*/
+    FxaaFloat dstN = posM.x - posN.x;
+    FxaaFloat dstP = posP.x - posM.x;
+    if(!horzSpan) dstN = posM.y - posN.y;
+    if(!horzSpan) dstP = posP.y - posM.y;
+/*--------------------------------------------------------------------------*/
+    FxaaBool goodSpanN = (lumaEndN < 0.0) != lumaMLTZero;
+    FxaaFloat spanLength = (dstP + dstN);
+    FxaaBool goodSpanP = (lumaEndP < 0.0) != lumaMLTZero;
+    FxaaFloat spanLengthRcp = 1.0/spanLength;
+/*--------------------------------------------------------------------------*/
+    FxaaBool directionN = dstN < dstP;
+    FxaaFloat dst = min(dstN, dstP);
+    FxaaBool goodSpan = directionN ? goodSpanN : goodSpanP;
+    FxaaFloat subpixG = subpixF * subpixF;
+    FxaaFloat pixelOffset = (dst * (-spanLengthRcp)) + 0.5;
+    FxaaFloat subpixH = subpixG * fxaaQualitySubpix;
+/*--------------------------------------------------------------------------*/
+    FxaaFloat pixelOffsetGood = goodSpan ? pixelOffset : 0.0;
+    FxaaFloat pixelOffsetSubpix = max(pixelOffsetGood, subpixH);
+    if(!horzSpan) posM.x += pixelOffsetSubpix * lengthSign;
+    if( horzSpan) posM.y += pixelOffsetSubpix * lengthSign;
+    return FxaaTexTop(tex, posM);
+}
+
+vec4 fxaa_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
+    const float fxaa_QualitySubpix = 0.5;
+    const float fxaa_QualityEdgeThreshold = 0.125;
+    const float fxaa_QualityEdgeThresholdMin = 0.0833;
+
+    return FxaaPixelShader_(
+        texCoord,
+        source,
+        vec2(1.0) / texSize,
+        fxaa_QualitySubpix,
+        fxaa_QualityEdgeThreshold,
+        fxaa_QualityEdgeThresholdMin
+    );
+}
+`
+);
+var fxaa = {
+  name: "fxaa",
+  propTypes: {},
+  fs: fs20,
+  passes: [{ sampler: true }],
+  getUniforms: (props) => props
+};
+/**
+ * ORIGINAL LICENCE
+ * @license
+ * Copyright (c) 2014-2015, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ''AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+//# sourceMappingURL=index.cjs.map