@kepler.gl/deckgl-layers 3.3.0-alpha.5 → 3.3.0-alpha.7

package/dist/esm/raster/util.js

@@ -0,0 +1,134 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import { UNIFORM_NAME_MAP } from './raster-processing-uniforms';
+
+/**
+ * Test if two lists of modules are equal
+ *
+ * @param modules     Modules list
+ * @param oldModules  Modules list
+ *
+ * @return true if both lists are equal
+ */
+export function modulesEqual(modules, oldModules) {
+  if (modules.length !== oldModules.length) {
+    return false;
+  }
+  for (var i = 0; i < modules.length; i++) {
+    if (modules[i].name !== oldModules[i].name) {
+      return false;
+    }
+  }
+  return true;
+}
+function isUniformValue(value) {
+  return typeof value === 'number' || typeof value === 'boolean' || ArrayBuffer.isView(value) || Array.isArray(value);
+}
+
+/**
+ * Apply module uniforms/bindings to shaderInputs, calling each module's
+ * getUniforms exactly once and writing the result directly — avoiding the
+ * double-getUniforms bug where shaderInputs.setProps() would re-invoke
+ * getUniforms on already-transformed values.
+ *
+ * For modules whose uniforms have been consolidated into the shared
+ * rasterProcessing UBO, the uniform values are remapped (prefixed) and
+ * written to the rasterProcessing slot instead of the individual module slot.
+ */
+export function applyModuleUniforms(shaderInputs, modules, allModuleProps) {
+  var _iterator = _createForOfIteratorHelper(modules),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var mod = _step.value;
+      if (mod.getUniforms) {
+        var result = mod.getUniforms(allModuleProps);
+        if (result) {
+          var uniforms = {};
+          var bindings = {};
+          for (var _i = 0, _Object$entries = Object.entries(result); _i < _Object$entries.length; _i++) {
+            var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+              key = _Object$entries$_i[0],
+              value = _Object$entries$_i[1];
+            if (isUniformValue(value)) {
+              uniforms[key] = value;
+            } else {
+              bindings[key] = value;
+            }
+          }
+          try {
+            var nameMap = UNIFORM_NAME_MAP[mod.name];
+            if (nameMap && mod.uniformTypes) {
+              // Consolidated module: remap uniforms to the shared rasterProcessing UBO
+              if (!shaderInputs.moduleUniforms.rasterProcessing) {
+                shaderInputs.moduleUniforms.rasterProcessing = {};
+              }
+              for (var _i2 = 0, _Object$entries2 = Object.entries(uniforms); _i2 < _Object$entries2.length; _i2++) {
+                var _Object$entries2$_i = _slicedToArray(_Object$entries2[_i2], 2),
+                  _key = _Object$entries2$_i[0],
+                  _value = _Object$entries2$_i[1];
+                var remapped = nameMap[_key];
+                if (remapped) {
+                  shaderInputs.moduleUniforms.rasterProcessing[remapped] = _value;
+                }
+              }
+              // Bindings (textures) stay on the original module name
+              if (Object.keys(bindings).length > 0) {
+                if (!shaderInputs.moduleBindings[mod.name]) {
+                  shaderInputs.moduleBindings[mod.name] = {};
+                }
+                Object.assign(shaderInputs.moduleBindings[mod.name], bindings);
+              }
+            } else {
+              // Non-consolidated module: write directly as before
+              if (!shaderInputs.moduleUniforms[mod.name]) {
+                shaderInputs.moduleUniforms[mod.name] = {};
+              }
+              if (!shaderInputs.moduleBindings[mod.name]) {
+                shaderInputs.moduleBindings[mod.name] = {};
+              }
+              Object.assign(shaderInputs.moduleUniforms[mod.name], uniforms);
+              Object.assign(shaderInputs.moduleBindings[mod.name], bindings);
+            }
+          } catch (_unused) {
+            var _nameMap = UNIFORM_NAME_MAP[mod.name];
+            if (_nameMap && mod.uniformTypes) {
+              var _shaderInputs$setProp;
+              var remappedUniforms = {};
+              for (var _i3 = 0, _Object$entries3 = Object.entries(uniforms); _i3 < _Object$entries3.length; _i3++) {
+                var _Object$entries3$_i = _slicedToArray(_Object$entries3[_i3], 2),
+                  _key2 = _Object$entries3$_i[0],
+                  val = _Object$entries3$_i[1];
+                var _remapped = _nameMap[_key2];
+                if (_remapped) {
+                  remappedUniforms[_remapped] = val;
+                }
+              }
+              (_shaderInputs$setProp = shaderInputs.setProps) === null || _shaderInputs$setProp === void 0 || _shaderInputs$setProp.call(shaderInputs, {
+                rasterProcessing: remappedUniforms
+              });
+              if (Object.keys(bindings).length > 0) {
+                var _shaderInputs$setProp2;
+                (_shaderInputs$setProp2 = shaderInputs.setProps) === null || _shaderInputs$setProp2 === void 0 || _shaderInputs$setProp2.call(shaderInputs, _defineProperty({}, mod.name, bindings));
+              }
+            } else {
+              var _shaderInputs$setProp4;
+              (_shaderInputs$setProp4 = shaderInputs.setProps) === null || _shaderInputs$setProp4 === void 0 || _shaderInputs$setProp4.call(shaderInputs, _defineProperty({}, mod.name, result));
+            }
+          }
+        }
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["UNIFORM_NAME_MAP","modulesEqual","modules","oldModules","length","i","name","isUniformValue","value","ArrayBuffer","isView","Array","isArray","applyModuleUniforms","shaderInputs","allModuleProps","_iterator","_createForOfIteratorHelper","_step","s","n","done","mod","getUniforms","result","uniforms","bindings","_i","_Object$entries","Object","entries","_Object$entries$_i","_slicedToArray","key","nameMap","uniformTypes","moduleUniforms","rasterProcessing","_i2","_Object$entries2","_Object$entries2$_i","remapped","keys","moduleBindings","assign","_unused","_shaderInputs$setProp","remappedUniforms","_i3","_Object$entries3","_Object$entries3$_i","val","setProps","call","_shaderInputs$setProp2","_defineProperty","_shaderInputs$setProp4","err","e","f"],"sources":["../../../src/raster/util.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport {ShaderModule} from './webgl/types';\nimport {UNIFORM_NAME_MAP} from './raster-processing-uniforms';\n\n/**\n * Test if two lists of modules are equal\n *\n * @param modules     Modules list\n * @param oldModules  Modules list\n *\n * @return true if both lists are equal\n */\nexport function modulesEqual(modules: ShaderModule[], oldModules: ShaderModule[]): boolean {\n  if (modules.length !== oldModules.length) {\n    return false;\n  }\n\n  for (let i = 0; i < modules.length; i++) {\n    if (modules[i].name !== oldModules[i].name) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nfunction isUniformValue(value: unknown): boolean {\n  return (\n    typeof value === 'number' ||\n    typeof value === 'boolean' ||\n    ArrayBuffer.isView(value) ||\n    Array.isArray(value)\n  );\n}\n\n/**\n * Apply module uniforms/bindings to shaderInputs, calling each module's\n * getUniforms exactly once and writing the result directly — avoiding the\n * double-getUniforms bug where shaderInputs.setProps() would re-invoke\n * getUniforms on already-transformed values.\n *\n * For modules whose uniforms have been consolidated into the shared\n * rasterProcessing UBO, the uniform values are remapped (prefixed) and\n * written to the rasterProcessing slot instead of the individual module slot.\n */\nexport function applyModuleUniforms(\n  shaderInputs: {\n    moduleUniforms: Record<string, Record<string, unknown>>;\n    moduleBindings: Record<string, Record<string, unknown>>;\n    setProps?: (props: any) => void;\n  },\n  modules: ShaderModule[],\n  allModuleProps: Record<string, unknown>\n): void {\n  for (const mod of modules) {\n    if (mod.getUniforms) {\n      const result = mod.getUniforms(allModuleProps as object);\n      if (result) {\n        const uniforms: Record<string, unknown> = {};\n        const bindings: Record<string, unknown> = {};\n        for (const [key, value] of Object.entries(result)) {\n          if (isUniformValue(value)) {\n            uniforms[key] = value;\n          } else {\n            bindings[key] = value;\n          }\n        }\n        try {\n          const nameMap = UNIFORM_NAME_MAP[mod.name];\n          if (nameMap && mod.uniformTypes) {\n            // Consolidated module: remap uniforms to the shared rasterProcessing UBO\n            if (!shaderInputs.moduleUniforms.rasterProcessing) {\n              shaderInputs.moduleUniforms.rasterProcessing = {};\n            }\n            for (const [key, value] of Object.entries(uniforms)) {\n              const remapped = nameMap[key];\n              if (remapped) {\n                shaderInputs.moduleUniforms.rasterProcessing[remapped] = value;\n              }\n            }\n            // Bindings (textures) stay on the original module name\n            if (Object.keys(bindings).length > 0) {\n              if (!shaderInputs.moduleBindings[mod.name]) {\n                shaderInputs.moduleBindings[mod.name] = {};\n              }\n              Object.assign(shaderInputs.moduleBindings[mod.name], bindings);\n            }\n          } else {\n            // Non-consolidated module: write directly as before\n            if (!shaderInputs.moduleUniforms[mod.name]) {\n              shaderInputs.moduleUniforms[mod.name] = {};\n            }\n            if (!shaderInputs.moduleBindings[mod.name]) {\n              shaderInputs.moduleBindings[mod.name] = {};\n            }\n            Object.assign(shaderInputs.moduleUniforms[mod.name], uniforms);\n            Object.assign(shaderInputs.moduleBindings[mod.name], bindings);\n          }\n        } catch {\n          const nameMap = UNIFORM_NAME_MAP[mod.name];\n          if (nameMap && mod.uniformTypes) {\n            const remappedUniforms: Record<string, unknown> = {};\n            for (const [key, val] of Object.entries(uniforms)) {\n              const remapped = nameMap[key];\n              if (remapped) {\n                remappedUniforms[remapped] = val;\n              }\n            }\n            shaderInputs.setProps?.({rasterProcessing: remappedUniforms});\n            if (Object.keys(bindings).length > 0) {\n              shaderInputs.setProps?.({[mod.name]: bindings});\n            }\n          } else {\n            shaderInputs.setProps?.({[mod.name]: result});\n          }\n        }\n      }\n    }\n  }\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/raster/webgl/color/colormap.js

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+var fs = "uniform sampler2D uColormapTexture;\n\nuniform colormapUniforms {\n  int hasCategoricalColors;\n  int categoricalMinValue;\n  int categoricalMaxValue;\n  int maxPixelValue;\n} colormap;\n\n// Apply colormap texture given value\n// Since the texture only varies in the x direction, setting v to 0.5 as a\n// constant is fine\n// Assumes the input range of value is -1 to 1\nvec4 colormapApply(sampler2D cmap, vec4 image) {\n  vec2 uv;\n  if (colormap.hasCategoricalColors == 1) {\n    float step = float(colormap.maxPixelValue) / float(colormap.categoricalMaxValue - colormap.categoricalMinValue);\n    uv = vec2(image.r * step, 0.5);\n  } else {\n    uv = vec2(0.5 * image.r + 0.5, 0.5);\n  }\n  vec4 color = texture(cmap, uv);\n  if(color.a <= 0.0) discard;\n  return color;\n}\n";
+function getUniforms() {
+  var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var imageColormap = opts.imageColormap,
+    minCategoricalBandValue = opts.minCategoricalBandValue,
+    maxCategoricalBandValue = opts.maxCategoricalBandValue,
+    dataTypeMaxValue = opts.dataTypeMaxValue,
+    maxPixelValue = opts.maxPixelValue;
+  if (!imageColormap) {
+    return null;
+  }
+  var isSupportedDataType = Number.isFinite(dataTypeMaxValue);
+  var isCategorical = isSupportedDataType && Number.isFinite(maxPixelValue) && Number.isFinite(minCategoricalBandValue) && Number.isFinite(maxCategoricalBandValue);
+  return {
+    uColormapTexture: imageColormap,
+    hasCategoricalColors: isCategorical ? 1 : 0,
+    categoricalMinValue: Number.isFinite(minCategoricalBandValue) ? minCategoricalBandValue : 0,
+    categoricalMaxValue: Number.isFinite(maxCategoricalBandValue) ? maxCategoricalBandValue : 0,
+    maxPixelValue: Number.isFinite(maxPixelValue) ? maxPixelValue : 0
+  };
+}
+export var colormap = {
+  name: 'colormap',
+  fs: fs,
+  uniformTypes: {
+    hasCategoricalColors: 'i32',
+    categoricalMinValue: 'i32',
+    categoricalMaxValue: 'i32',
+    maxPixelValue: 'i32'
+  },
+  getUniforms: getUniforms,
+  inject: {
+    'fs:DECKGL_MUTATE_COLOR': "\n    image = colormapApply(uColormapTexture, image);\n    "
+  }
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/raster/webgl/color/filter.js

@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+var fs = "uniform bandFilterUniforms {\n  float min1;\n  float max1;\n  float min2;\n  float max2;\n  float min3;\n  float max3;\n  float min4;\n  float max4;\n} bandFilter;\n";
+
+// You can't pass JS' -Infinity or Infinity to a shader as a uniform
+var inf = Math.pow(2, 62);
+
+// eslint-disable-next-line complexity
+function getUniforms() {
+  var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var filterMin1 = opts.filterMin1,
+    filterMin2 = opts.filterMin2,
+    filterMin3 = opts.filterMin3,
+    filterMin4 = opts.filterMin4,
+    filterMax1 = opts.filterMax1,
+    filterMax2 = opts.filterMax2,
+    filterMax3 = opts.filterMax3,
+    filterMax4 = opts.filterMax4;
+  if (Number.isFinite(filterMin1) || Number.isFinite(filterMin2) || Number.isFinite(filterMin3) || Number.isFinite(filterMin4) || Number.isFinite(filterMax1) || Number.isFinite(filterMax2) || Number.isFinite(filterMax3) || Number.isFinite(filterMax4)) {
+    return {
+      min1: Number.isFinite(filterMin1) ? filterMin1 : -inf,
+      min2: Number.isFinite(filterMin2) ? filterMin2 : -inf,
+      min3: Number.isFinite(filterMin3) ? filterMin3 : -inf,
+      min4: Number.isFinite(filterMin4) ? filterMin4 : -inf,
+      max1: Number.isFinite(filterMax1) ? filterMax1 : inf,
+      max2: Number.isFinite(filterMax2) ? filterMax2 : inf,
+      max3: Number.isFinite(filterMax3) ? filterMax3 : inf,
+      max4: Number.isFinite(filterMax4) ? filterMax4 : inf
+    };
+  }
+  return null;
+}
+export var filter = {
+  name: 'bandFilter',
+  fs: fs,
+  uniformTypes: {
+    min1: 'f32',
+    max1: 'f32',
+    min2: 'f32',
+    max2: 'f32',
+    min3: 'f32',
+    max3: 'f32',
+    min4: 'f32',
+    max4: 'f32'
+  },
+  getUniforms: getUniforms,
+  inject: {
+    'fs:DECKGL_MUTATE_COLOR': "\n    if (image.r < bandFilter.min1) discard;\n    if (image.g < bandFilter.min2) discard;\n    if (image.b < bandFilter.min3) discard;\n    if (image.a < bandFilter.min4) discard;\n    if (image.r > bandFilter.max1) discard;\n    if (image.g > bandFilter.max2) discard;\n    if (image.b > bandFilter.max3) discard;\n    if (image.a > bandFilter.max4) discard;\n    "
+  }
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/raster/webgl/color/gamma-contrast.js

@@ -0,0 +1,62 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+// Gamma correction is a nonlinear operation that
+// adjusts the image's channel values pixel-by-pixel according
+// to a power-law:
+//
+// .. math:: pixel_{out} = pixel_{in} ^ {gamma}
+//
+// Setting gamma (:math:gamma) to be less than 1.0 darkens the image and
+// setting gamma to be greater than 1.0 lightens it.
+
+// Parameters
+// ----------
+// gamma (:math:gamma): float
+//     Reasonable values range from 0.8 to 2.4.
+
+// NOTE: Input array must have float values between 0 and 1!
+// NOTE: gamma must be >= 0
+var fs = "#define epsilon 0.00000001\n\nuniform gamma_contrastUniforms {\n  float gamma1;\n  float gamma2;\n  float gamma3;\n  float gamma4;\n} gamma_contrast;\n\nfloat gammaContrastCalc(float arr, float g) {\n  // Gamma must be > 0\n  g = clamp(g, epsilon, g);\n\n  return pow(arr, 1.0 / g);\n}\n\nvec4 gammaContrastCalc(vec4 arr, float g1, float g2, float g3, float g4) {\n  arr.r = gammaContrastCalc(arr.r, g1);\n  arr.g = gammaContrastCalc(arr.g, g2);\n  arr.b = gammaContrastCalc(arr.b, g3);\n  arr.a = gammaContrastCalc(arr.a, g4);\n\n  return arr;\n}\n";
+function getUniforms() {
+  var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var gammaContrastValue = opts.gammaContrastValue,
+    gammaContrastValue1 = opts.gammaContrastValue1,
+    gammaContrastValue2 = opts.gammaContrastValue2,
+    gammaContrastValue3 = opts.gammaContrastValue3,
+    gammaContrastValue4 = opts.gammaContrastValue4;
+
+  // Gamma must be > 0, so not using Number.isFinite is fine
+
+  if (gammaContrastValue) {
+    return {
+      gamma1: gammaContrastValue,
+      gamma2: gammaContrastValue,
+      gamma3: gammaContrastValue,
+      gamma4: gammaContrastValue
+    };
+  } else if (gammaContrastValue1 || gammaContrastValue2 || gammaContrastValue3 || gammaContrastValue4) {
+    return {
+      gamma1: gammaContrastValue1 || 1,
+      gamma2: gammaContrastValue2 || 1,
+      gamma3: gammaContrastValue3 || 1,
+      gamma4: gammaContrastValue4 || 1
+    };
+  }
+  return null;
+}
+export var gammaContrast = {
+  name: 'gamma_contrast',
+  fs: fs,
+  uniformTypes: {
+    gamma1: 'f32',
+    gamma2: 'f32',
+    gamma3: 'f32',
+    gamma4: 'f32'
+  },
+  getUniforms: getUniforms,
+  inject: {
+    'fs:DECKGL_MUTATE_COLOR': "\n    image = gammaContrastCalc(image, gamma_contrast.gamma1, gamma_contrast.gamma2, gamma_contrast.gamma3, gamma_contrast.gamma4);\n    "
+  }
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/raster/webgl/color/linear-rescale.js

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+var fs = "uniform linear_rescaleUniforms {\n  float scaler;\n  float offset;\n} linear_rescale;\n\n// Perform a linear rescaling of image\nvec4 linear_rescale_fn(vec4 arr, float scaler, float offset) {\n  return arr * scaler + offset;\n}\n";
+function getUniforms() {
+  var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var linearRescaleScaler = opts.linearRescaleScaler,
+    linearRescaleOffset = opts.linearRescaleOffset;
+  if (!Number.isFinite(linearRescaleScaler) && !Number.isFinite(linearRescaleOffset)) {
+    return null;
+  }
+  return {
+    scaler: Number.isFinite(linearRescaleScaler) ? linearRescaleScaler : 1,
+    offset: Number.isFinite(linearRescaleOffset) ? linearRescaleOffset : 0
+  };
+}
+export var linearRescale = {
+  name: 'linear_rescale',
+  fs: fs,
+  uniformTypes: {
+    scaler: 'f32',
+    offset: 'f32'
+  },
+  getUniforms: getUniforms,
+  inject: {
+    'fs:DECKGL_MUTATE_COLOR': "\n    image = linear_rescale_fn(image, linear_rescale.scaler, linear_rescale.offset);\n    "
+  }
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJmcyIsImdldFVuaWZvcm1zIiwib3B0cyIsImFyZ3VtZW50cyIsImxlbmd0aCIsInVuZGVmaW5lZCIsImxpbmVhclJlc2NhbGVTY2FsZXIiLCJsaW5lYXJSZXNjYWxlT2Zmc2V0IiwiTnVtYmVyIiwiaXNGaW5pdGUiLCJzY2FsZXIiLCJvZmZzZXQiLCJsaW5lYXJSZXNjYWxlIiwibmFtZSIsInVuaWZvcm1UeXBlcyIsImluamVjdCJdLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9yYXN0ZXIvd2ViZ2wvY29sb3IvbGluZWFyLXJlc2NhbGUudHMiXSwic291cmNlc0NvbnRlbnQiOlsiLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IE1JVFxuLy8gQ29weXJpZ2h0IGNvbnRyaWJ1dG9ycyB0byB0aGUga2VwbGVyLmdsIHByb2plY3RcblxuaW1wb3J0IHtHZXRVbmlmb3Jtc091dHB1dCwgU2hhZGVyTW9kdWxlfSBmcm9tICcuLi90eXBlcyc7XG5cbmNvbnN0IGZzID0gYFxcXG51bmlmb3JtIGxpbmVhcl9yZXNjYWxlVW5pZm9ybXMge1xuICBmbG9hdCBzY2FsZXI7XG4gIGZsb2F0IG9mZnNldDtcbn0gbGluZWFyX3Jlc2NhbGU7XG5cbi8vIFBlcmZvcm0gYSBsaW5lYXIgcmVzY2FsaW5nIG9mIGltYWdlXG52ZWM0IGxpbmVhcl9yZXNjYWxlX2ZuKHZlYzQgYXJyLCBmbG9hdCBzY2FsZXIsIGZsb2F0IG9mZnNldCkge1xuICByZXR1cm4gYXJyICogc2NhbGVyICsgb2Zmc2V0O1xufVxuYDtcblxuZnVuY3Rpb24gZ2V0VW5pZm9ybXMoXG4gIG9wdHM6IHtsaW5lYXJSZXNjYWxlU2NhbGVyPzogbnVtYmVyOyBsaW5lYXJSZXNjYWxlT2Zmc2V0PzogbnVtYmVyfSA9IHt9XG4pOiBHZXRVbmlmb3Jtc091dHB1dCB7XG4gIGNvbnN0IHtsaW5lYXJSZXNjYWxlU2NhbGVyLCBsaW5lYXJSZXNjYWxlT2Zmc2V0fSA9IG9wdHM7XG5cbiAgaWYgKCFOdW1iZXIuaXNGaW5pdGUobGluZWFyUmVzY2FsZVNjYWxlcikgJiYgIU51bWJlci5pc0Zpbml0ZShsaW5lYXJSZXNjYWxlT2Zmc2V0KSkge1xuICAgIHJldHVybiBudWxsO1xuICB9XG5cbiAgcmV0dXJuIHtcbiAgICBzY2FsZXI6IE51bWJlci5pc0Zpbml0ZShsaW5lYXJSZXNjYWxlU2NhbGVyKSA/IGxpbmVhclJlc2NhbGVTY2FsZXIgOiAxLFxuICAgIG9mZnNldDogTnVtYmVyLmlzRmluaXRlKGxpbmVhclJlc2NhbGVPZmZzZXQpID8gbGluZWFyUmVzY2FsZU9mZnNldCA6IDBcbiAgfTtcbn1cblxuZXhwb3J0IGNvbnN0IGxpbmVhclJlc2NhbGU6IFNoYWRlck1vZHVsZSA9IHtcbiAgbmFtZTogJ2xpbmVhcl9yZXNjYWxlJyxcbiAgZnMsXG4gIHVuaWZvcm1UeXBlczoge1xuICAgIHNjYWxlcjogJ2YzMicsXG4gICAgb2Zmc2V0OiAnZjMyJ1xuICB9LFxuICBnZXRVbmlmb3JtcyxcbiAgaW5qZWN0OiB7XG4gICAgJ2ZzOkRFQ0tHTF9NVVRBVEVfQ09MT1InOiBgXG4gICAgaW1hZ2UgPSBsaW5lYXJfcmVzY2FsZV9mbihpbWFnZSwgbGluZWFyX3Jlc2NhbGUuc2NhbGVyLCBsaW5lYXJfcmVzY2FsZS5vZmZzZXQpO1xuICAgIGBcbiAgfVxufTtcbiJdLCJtYXBwaW5ncyI6IkFBQUE7QUFDQTs7QUFJQSxJQUFNQSxFQUFFLDBPQVVQO0FBRUQsU0FBU0MsV0FBV0EsQ0FBQSxFQUVDO0VBQUEsSUFEbkJDLElBQWtFLEdBQUFDLFNBQUEsQ0FBQUMsTUFBQSxRQUFBRCxTQUFBLFFBQUFFLFNBQUEsR0FBQUYsU0FBQSxNQUFHLENBQUMsQ0FBQztFQUV2RSxJQUFPRyxtQkFBbUIsR0FBeUJKLElBQUksQ0FBaERJLG1CQUFtQjtJQUFFQyxtQkFBbUIsR0FBSUwsSUFBSSxDQUEzQkssbUJBQW1CO0VBRS9DLElBQUksQ0FBQ0MsTUFBTSxDQUFDQyxRQUFRLENBQUNILG1CQUFtQixDQUFDLElBQUksQ0FBQ0UsTUFBTSxDQUFDQyxRQUFRLENBQUNGLG1CQUFtQixDQUFDLEVBQUU7SUFDbEYsT0FBTyxJQUFJO0VBQ2I7RUFFQSxPQUFPO0lBQ0xHLE1BQU0sRUFBRUYsTUFBTSxDQUFDQyxRQUFRLENBQUNILG1CQUFtQixDQUFDLEdBQUdBLG1CQUFtQixHQUFHLENBQUM7SUFDdEVLLE1BQU0sRUFBRUgsTUFBTSxDQUFDQyxRQUFRLENBQUNGLG1CQUFtQixDQUFDLEdBQUdBLG1CQUFtQixHQUFHO0VBQ3ZFLENBQUM7QUFDSDtBQUVBLE9BQU8sSUFBTUssYUFBMkIsR0FBRztFQUN6Q0MsSUFBSSxFQUFFLGdCQUFnQjtFQUN0QmIsRUFBRSxFQUFGQSxFQUFFO0VBQ0ZjLFlBQVksRUFBRTtJQUNaSixNQUFNLEVBQUUsS0FBSztJQUNiQyxNQUFNLEVBQUU7RUFDVixDQUFDO0VBQ0RWLFdBQVcsRUFBWEEsV0FBVztFQUNYYyxNQUFNLEVBQUU7SUFDTix3QkFBd0I7RUFHMUI7QUFDRixDQUFDIiwiaWdub3JlTGlzdCI6W119

package/dist/esm/raster/webgl/color/saturation.js

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+/**
+ * Adjusts the saturation of a color.
+ * From cesium:
+ * https://github.com/CesiumGS/cesium/blob/master/Source/Shaders/Builtin/Functions/saturation.glsl
+ *
+ * @param {vec3} rgb The color.
+ * @param {float} adjustment The amount to adjust the saturation of the color. Usually between 0 and 2.
+ *
+ * @returns {vec3} The color with the saturation adjusted.
+ */
+var fs = "uniform saturationUniforms {\n  float value;\n} saturation;\n\nvec3 saturate(vec3 rgb, float adjustment) {\n    // Algorithm from Chapter 16 of OpenGL Shading Language\n    const vec3 W = vec3(0.2125, 0.7154, 0.0721);\n    vec3 intensity = vec3(dot(rgb, W));\n    return mix(intensity, rgb, adjustment);\n}\n";
+function getUniforms() {
+  var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var saturationValue = opts.saturationValue;
+  if (!saturationValue) {
+    return null;
+  }
+  return {
+    value: Number.isFinite(saturationValue) ? saturationValue : 1
+  };
+}
+export var saturation = {
+  name: 'saturation',
+  fs: fs,
+  uniformTypes: {
+    value: 'f32'
+  },
+  getUniforms: getUniforms,
+  inject: {
+    'fs:DECKGL_MUTATE_COLOR': "\n    image = vec4(saturate(image.rgb, saturation.value), image.a);\n    "
+  }
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJmcyIsImdldFVuaWZvcm1zIiwib3B0cyIsImFyZ3VtZW50cyIsImxlbmd0aCIsInVuZGVmaW5lZCIsInNhdHVyYXRpb25WYWx1ZSIsInZhbHVlIiwiTnVtYmVyIiwiaXNGaW5pdGUiLCJzYXR1cmF0aW9uIiwibmFtZSIsInVuaWZvcm1UeXBlcyIsImluamVjdCJdLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9yYXN0ZXIvd2ViZ2wvY29sb3Ivc2F0dXJhdGlvbi50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogTUlUXG4vLyBDb3B5cmlnaHQgY29udHJpYnV0b3JzIHRvIHRoZSBrZXBsZXIuZ2wgcHJvamVjdFxuXG5pbXBvcnQge0dldFVuaWZvcm1zT3V0cHV0LCBTaGFkZXJNb2R1bGV9IGZyb20gJy4uL3R5cGVzJztcblxuLyoqXG4gKiBBZGp1c3RzIHRoZSBzYXR1cmF0aW9uIG9mIGEgY29sb3IuXG4gKiBGcm9tIGNlc2l1bTpcbiAqIGh0dHBzOi8vZ2l0aHViLmNvbS9DZXNpdW1HUy9jZXNpdW0vYmxvYi9tYXN0ZXIvU291cmNlL1NoYWRlcnMvQnVpbHRpbi9GdW5jdGlvbnMvc2F0dXJhdGlvbi5nbHNsXG4gKlxuICogQHBhcmFtIHt2ZWMzfSByZ2IgVGhlIGNvbG9yLlxuICogQHBhcmFtIHtmbG9hdH0gYWRqdXN0bWVudCBUaGUgYW1vdW50IHRvIGFkanVzdCB0aGUgc2F0dXJhdGlvbiBvZiB0aGUgY29sb3IuIFVzdWFsbHkgYmV0d2VlbiAwIGFuZCAyLlxuICpcbiAqIEByZXR1cm5zIHt2ZWMzfSBUaGUgY29sb3Igd2l0aCB0aGUgc2F0dXJhdGlvbiBhZGp1c3RlZC5cbiAqL1xuY29uc3QgZnMgPSBgXFxcbnVuaWZvcm0gc2F0dXJhdGlvblVuaWZvcm1zIHtcbiAgZmxvYXQgdmFsdWU7XG59IHNhdHVyYXRpb247XG5cbnZlYzMgc2F0dXJhdGUodmVjMyByZ2IsIGZsb2F0IGFkanVzdG1lbnQpIHtcbiAgICAvLyBBbGdvcml0aG0gZnJvbSBDaGFwdGVyIDE2IG9mIE9wZW5HTCBTaGFkaW5nIExhbmd1YWdlXG4gICAgY29uc3QgdmVjMyBXID0gdmVjMygwLjIxMjUsIDAuNzE1NCwgMC4wNzIxKTtcbiAgICB2ZWMzIGludGVuc2l0eSA9IHZlYzMoZG90KHJnYiwgVykpO1xuICAgIHJldHVybiBtaXgoaW50ZW5zaXR5LCByZ2IsIGFkanVzdG1lbnQpO1xufVxuYDtcblxuZnVuY3Rpb24gZ2V0VW5pZm9ybXMob3B0czoge3NhdHVyYXRpb25WYWx1ZT86IG51bWJlcn0gPSB7fSk6IEdldFVuaWZvcm1zT3V0cHV0IHtcbiAgY29uc3Qge3NhdHVyYXRpb25WYWx1ZX0gPSBvcHRzO1xuXG4gIGlmICghc2F0dXJhdGlvblZhbHVlKSB7XG4gICAgcmV0dXJuIG51bGw7XG4gIH1cblxuICByZXR1cm4ge1xuICAgIHZhbHVlOiBOdW1iZXIuaXNGaW5pdGUoc2F0dXJhdGlvblZhbHVlKSA/IHNhdHVyYXRpb25WYWx1ZSA6IDFcbiAgfTtcbn1cblxuZXhwb3J0IGNvbnN0IHNhdHVyYXRpb246IFNoYWRlck1vZHVsZSA9IHtcbiAgbmFtZTogJ3NhdHVyYXRpb24nLFxuICBmcyxcbiAgdW5pZm9ybVR5cGVzOiB7XG4gICAgdmFsdWU6ICdmMzInXG4gIH0sXG4gIGdldFVuaWZvcm1zLFxuICBpbmplY3Q6IHtcbiAgICAnZnM6REVDS0dMX01VVEFURV9DT0xPUic6IGBcbiAgICBpbWFnZSA9IHZlYzQoc2F0dXJhdGUoaW1hZ2UucmdiLCBzYXR1cmF0aW9uLnZhbHVlKSwgaW1hZ2UuYSk7XG4gICAgYFxuICB9XG59O1xuIl0sIm1hcHBpbmdzIjoiQUFBQTtBQUNBOztBQUlBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0EsSUFBTUEsRUFBRSx5VEFXUDtBQUVELFNBQVNDLFdBQVdBLENBQUEsRUFBMkQ7RUFBQSxJQUExREMsSUFBZ0MsR0FBQUMsU0FBQSxDQUFBQyxNQUFBLFFBQUFELFNBQUEsUUFBQUUsU0FBQSxHQUFBRixTQUFBLE1BQUcsQ0FBQyxDQUFDO0VBQ3hELElBQU9HLGVBQWUsR0FBSUosSUFBSSxDQUF2QkksZUFBZTtFQUV0QixJQUFJLENBQUNBLGVBQWUsRUFBRTtJQUNwQixPQUFPLElBQUk7RUFDYjtFQUVBLE9BQU87SUFDTEMsS0FBSyxFQUFFQyxNQUFNLENBQUNDLFFBQVEsQ0FBQ0gsZUFBZSxDQUFDLEdBQUdBLGVBQWUsR0FBRztFQUM5RCxDQUFDO0FBQ0g7QUFFQSxPQUFPLElBQU1JLFVBQXdCLEdBQUc7RUFDdENDLElBQUksRUFBRSxZQUFZO0VBQ2xCWCxFQUFFLEVBQUZBLEVBQUU7RUFDRlksWUFBWSxFQUFFO0lBQ1pMLEtBQUssRUFBRTtFQUNULENBQUM7RUFDRE4sV0FBVyxFQUFYQSxXQUFXO0VBQ1hZLE1BQU0sRUFBRTtJQUNOLHdCQUF3QjtFQUcxQjtBQUNGLENBQUMiLCJpZ25vcmVMaXN0IjpbXX0=

package/dist/esm/raster/webgl/color/sigmoidal-contrast.js

@@ -0,0 +1,62 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+// From mapbox/rio-color under the MIT License
+//
+// Sigmoidal contrast is a type of contrast control that
+// adjusts the contrast without saturating highlights or shadows.
+// It allows control over two factors:
+// the contrast range from light to dark, and where the middle value
+// of the mid-tones falls. The result is a non-linear and smooth
+// contrast change.
+// Parameters
+// ----------
+// arr : ndarray, float, 0 .. 1
+//     Array of color values to adjust
+// contrast : integer
+//     Enhances the intensity differences between the lighter and darker
+//     elements of the image. For example, 0 is none, 3 is typical and
+//     20 is a lot.
+// bias : float, between 0 and 1
+//     Threshold level for the contrast function to center on
+//     (typically centered at 0.5)
+// Notes
+// ----------
+// Sigmoidal contrast is based on the sigmoidal transfer function:
+// .. math:: g(u) = ( 1/(1 + e^{- \alpha * u + \beta)})
+// This sigmoid function is scaled so that the output is bound by
+// the interval [0, 1].
+// .. math:: ( 1/(1 + e^(\beta * (\alpha - u))) - 1/(1 + e^(\beta * \alpha)))/
+//     ( 1/(1 + e^(\beta*(\alpha - 1))) - 1/(1 + e^(\beta * \alpha)) )
+// Where :math: `\alpha` is the threshold level, and :math: `\beta` the
+// contrast factor to be applied.
+// References
+// ----------
+// .. [CT] Hany Farid "Fundamentals of Image Processing"
+//         http://www.cs.dartmouth.edu/farid/downloads/tutorials/fip.pdf
+var fs = "#define epsilon 0.00000001\n\nuniform sigmoidalContrastUniforms {\n  float contrast;\n  float bias;\n} sigmoidalContrast;\n\n// NOTE: Input array must have float values between 0 and 1!\n// NOTE: bias must be a scalar float between 0 and 1!\nvec4 calculateSigmoidalContrast(vec4 arr, float contrast, float bias) {\n  // We use the names alpha and beta to match documentation.\n  float alpha = bias;\n  float beta = contrast;\n\n  // alpha must be >= 0\n  alpha = clamp(alpha, epsilon, alpha);\n\n  if (beta > 0.) {\n    vec4 numerator = 1. / (1. + exp(beta * (alpha - arr))) - 1. / (\n      1. + exp(beta * alpha)\n    );\n    float denominator = 1. / (1. + exp(beta * (alpha - 1.))) - 1. / (\n      1. + exp(beta * alpha)\n    );\n    arr = numerator / denominator;\n  } else if (beta < 0.) {\n    arr = (\n      (beta * alpha) - log(\n        (\n          1.0 / (\n            (arr / (1.0 + exp((beta * alpha) - beta))) -\n            (arr / (1.0 + exp(beta * alpha))) +\n            (1.0 / (1.0 + exp(beta * alpha)))\n          )\n        ) - 1.0)\n    ) / beta;\n  }\n\n  return arr;\n}\n";
+function getUniforms() {
+  var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var sigmoidalContrast = opts.sigmoidalContrast,
+    sigmoidalBias = opts.sigmoidalBias;
+  if (!(Number.isFinite(sigmoidalContrast) || Number.isFinite(sigmoidalBias))) {
+    return null;
+  }
+  return {
+    contrast: Number.isFinite(sigmoidalContrast) ? sigmoidalContrast : 0,
+    bias: Number.isFinite(sigmoidalBias) ? sigmoidalBias : 0.5
+  };
+}
+export var sigmoidalContrast = {
+  name: 'sigmoidalContrast',
+  fs: fs,
+  uniformTypes: {
+    contrast: 'f32',
+    bias: 'f32'
+  },
+  getUniforms: getUniforms,
+  inject: {
+    'fs:DECKGL_MUTATE_COLOR': "\n    image = calculateSigmoidalContrast(image, sigmoidalContrast.contrast, sigmoidalContrast.bias);\n    "
+  }
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/raster/webgl/index.js

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+// Create texture
+export { combineBandsFloat, combineBandsUint, combineBandsInt } from './texture/combine-bands';
+export { rgbaImage } from './texture/rgba-image';
+export { maskFloat, maskUint, maskInt } from './texture/mask';
+export { reorderBands } from './texture/reorder-bands';
+
+// Color operations
+export { colormap } from './color/colormap';
+export { linearRescale } from './color/linear-rescale';
+export { sigmoidalContrast } from './color/sigmoidal-contrast';
+export { gammaContrast } from './color/gamma-contrast';
+export { saturation } from './color/saturation';
+export { filter } from './color/filter';
+
+// Pansharpening
+export { pansharpenBrovey } from './pansharpen/pansharpen-brovey';
+
+// Spectral indices
+export { enhancedVegetationIndex } from './spectral-indices/evi';
+export { modifiedSoilAdjustedVegetationIndex } from './spectral-indices/msavi';
+export { normalizedDifference } from './spectral-indices/normalized-difference';
+export { soilAdjustedVegetationIndex } from './spectral-indices/savi';
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/raster/webgl/pansharpen/pansharpen-brovey.js

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+// Brovey Method: Each resampled, multispectral pixel is
+// multiplied by the ratio of the corresponding
+// panchromatic pixel intensity to the sum of all the
+// multispectral intensities.
+// Original code from https://github.com/mapbox/rio-pansharpen
+//
+var fs1 = "uniform sampler2D bitmapTexturePan;\n\nuniform pansharpen_broveyUniforms {\n  float panWeight;\n} pansharpen_brovey;\n\nfloat pansharpen_brovey_ratio(vec4 rgb, float pan, float weight) {\n  return pan / ((rgb.r + rgb.g + rgb.b * weight) / (2. + weight));\n}\n\nvec4 pansharpen_brovey_calc(vec4 rgb, float pan, float weight) {\n  float ratio = pansharpen_brovey_ratio(rgb, pan, weight);\n  return ratio * rgb;\n}\n";
+var fs2 = "precision mediump usampler2D;\n\n#ifdef SAMPLER_TYPE\n  uniform SAMPLER_TYPE bitmapTexturePan;\n#else\n  uniform sampler2D bitmapTexturePan;\n#endif\n\nuniform pansharpen_broveyUniforms {\n  float panWeight;\n} pansharpen_brovey;\n\nfloat pansharpen_brovey_ratio(vec4 rgb, float pan, float weight) {\n  return pan / ((rgb.r + rgb.g + rgb.b * weight) / (2. + weight));\n}\n\nvec4 pansharpen_brovey_calc(vec4 rgb, float pan, float weight) {\n  float ratio = pansharpen_brovey_ratio(rgb, pan, weight);\n  return ratio * rgb;\n}\n";
+function getUniforms() {
+  var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var imagePan = opts.imagePan,
+    _opts$panWeight = opts.panWeight,
+    panWeight = _opts$panWeight === void 0 ? 0.2 : _opts$panWeight;
+  if (!imagePan) {
+    return null;
+  }
+  return {
+    bitmapTexturePan: imagePan,
+    panWeight: panWeight
+  };
+}
+export var pansharpenBrovey = {
+  name: 'pansharpen_brovey',
+  fs1: fs1,
+  fs2: fs2,
+  uniformTypes: {
+    panWeight: 'f32'
+  },
+  defines: {
+    SAMPLER_TYPE: 'sampler2D'
+  },
+  getUniforms: getUniforms,
+  inject: {
+    'fs:DECKGL_MUTATE_COLOR': "\n    float pan_band = float(texture(bitmapTexturePan, coord).r);\n    image = pansharpen_brovey_calc(image, pan_band, pansharpen_brovey.panWeight);\n    "
+  }
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/raster/webgl/spectral-indices/evi.js

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+// Calculate enhanced vegetation index
+// Expected to be ordered:
+// red: Landsat 8 band 5
+// green: Landsat 8 band 4
+// blue: Landsat 8 band 2
+//
+// EVI = 2.5 * ((Band 5 – Band 4) / (Band 5 + 6 * Band 4 – 7.5 * Band 2 + 1))
+// https://www.usgs.gov/land-resources/nli/landsat/landsat-enhanced-vegetation-index
+var fs = "float enhanced_vegetation_index_calc(vec4 image) {\n  float band5 = image.r;\n  float band4 = image.g;\n  float band2 = image.b;\n\n  float numerator = band5 - band4;\n  float denominator = band5 + (6. * band4) - (7.5 * band2) + 1.;\n  return 2.5 * (numerator / denominator);\n}\n";
+export var enhancedVegetationIndex = {
+  name: 'enhanced_vegetation_index',
+  fs: fs,
+  inject: {
+    'fs:DECKGL_MUTATE_COLOR': "\n    image = vec4(enhanced_vegetation_index_calc(image), 0., 0., 0.);\n    "
+  }
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJmcyIsImVuaGFuY2VkVmVnZXRhdGlvbkluZGV4IiwibmFtZSIsImluamVjdCJdLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9yYXN0ZXIvd2ViZ2wvc3BlY3RyYWwtaW5kaWNlcy9ldmkudHMiXSwic291cmNlc0NvbnRlbnQiOlsiLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IE1JVFxuLy8gQ29weXJpZ2h0IGNvbnRyaWJ1dG9ycyB0byB0aGUga2VwbGVyLmdsIHByb2plY3RcblxuaW1wb3J0IHtTaGFkZXJNb2R1bGV9IGZyb20gJy4uL3R5cGVzJztcblxuLy8gQ2FsY3VsYXRlIGVuaGFuY2VkIHZlZ2V0YXRpb24gaW5kZXhcbi8vIEV4cGVjdGVkIHRvIGJlIG9yZGVyZWQ6XG4vLyByZWQ6IExhbmRzYXQgOCBiYW5kIDVcbi8vIGdyZWVuOiBMYW5kc2F0IDggYmFuZCA0XG4vLyBibHVlOiBMYW5kc2F0IDggYmFuZCAyXG4vL1xuLy8gRVZJID0gMi41ICogKChCYW5kIDUg4oCTIEJhbmQgNCkgLyAoQmFuZCA1ICsgNiAqIEJhbmQgNCDigJMgNy41ICogQmFuZCAyICsgMSkpXG4vLyBodHRwczovL3d3dy51c2dzLmdvdi9sYW5kLXJlc291cmNlcy9ubGkvbGFuZHNhdC9sYW5kc2F0LWVuaGFuY2VkLXZlZ2V0YXRpb24taW5kZXhcbmNvbnN0IGZzID0gYFxcXG5mbG9hdCBlbmhhbmNlZF92ZWdldGF0aW9uX2luZGV4X2NhbGModmVjNCBpbWFnZSkge1xuICBmbG9hdCBiYW5kNSA9IGltYWdlLnI7XG4gIGZsb2F0IGJhbmQ0ID0gaW1hZ2UuZztcbiAgZmxvYXQgYmFuZDIgPSBpbWFnZS5iO1xuXG4gIGZsb2F0IG51bWVyYXRvciA9IGJhbmQ1IC0gYmFuZDQ7XG4gIGZsb2F0IGRlbm9taW5hdG9yID0gYmFuZDUgKyAoNi4gKiBiYW5kNCkgLSAoNy41ICogYmFuZDIpICsgMS47XG4gIHJldHVybiAyLjUgKiAobnVtZXJhdG9yIC8gZGVub21pbmF0b3IpO1xufVxuYDtcblxuZXhwb3J0IGNvbnN0IGVuaGFuY2VkVmVnZXRhdGlvbkluZGV4OiBTaGFkZXJNb2R1bGUgPSB7XG4gIG5hbWU6ICdlbmhhbmNlZF92ZWdldGF0aW9uX2luZGV4JyxcbiAgZnMsXG4gIGluamVjdDoge1xuICAgICdmczpERUNLR0xfTVVUQVRFX0NPTE9SJzogYFxuICAgIGltYWdlID0gdmVjNChlbmhhbmNlZF92ZWdldGF0aW9uX2luZGV4X2NhbGMoaW1hZ2UpLCAwLiwgMC4sIDAuKTtcbiAgICBgXG4gIH1cbn07XG4iXSwibWFwcGluZ3MiOiJBQUFBO0FBQ0E7O0FBSUE7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBLElBQU1BLEVBQUUsNlJBVVA7QUFFRCxPQUFPLElBQU1DLHVCQUFxQyxHQUFHO0VBQ25EQyxJQUFJLEVBQUUsMkJBQTJCO0VBQ2pDRixFQUFFLEVBQUZBLEVBQUU7RUFDRkcsTUFBTSxFQUFFO0lBQ04sd0JBQXdCO0VBRzFCO0FBQ0YsQ0FBQyIsImlnbm9yZUxpc3QiOltdfQ==