@deck.gl/extensions 8.10.0-alpha.6 → 8.10.0-alpha.7

package/dist/dist.dev.js

@@ -733,17 +733,24 @@ void main() {
     fp64ifyMatrix4
   };
 
-  // ../../node_modules/@math.gl/core/dist/esm/lib/common.js
+  // ../../node_modules/@math.gl/core/dist/lib/common.js
   var RADIANS_TO_DEGREES = 1 / Math.PI * 180;
   var DEGREES_TO_RADIANS = 1 / 180 * Math.PI;
-  var config = {
+  var DEFAULT_CONFIG = {
     EPSILON: 1e-12,
     debug: false,
     precision: 4,
     printTypes: false,
     printDegrees: false,
-    printRowMajor: true
+    printRowMajor: true,
+    _cartographicRadians: false
   };
+  globalThis.mathgl = globalThis.mathgl || {
+    config: {
+      ...DEFAULT_CONFIG
+    }
+  };
+  var config = globalThis.mathgl.config;
   function isArray(value) {
     return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView);
   }
@@ -782,21 +789,72 @@ void main() {
     }
   }
 
-  // ../../node_modules/gl-matrix/esm/common.js
+  // ../../node_modules/@math.gl/core/dist/gl-matrix/common.js
+  var EPSILON = 1e-6;
   var ARRAY_TYPE = typeof Float32Array !== "undefined" ? Float32Array : Array;
+  var RANDOM = Math.random;
+  function round(a) {
+    if (a >= 0)
+      return Math.round(a);
+    return a % 0.5 === 0 ? Math.floor(a) : Math.round(a);
+  }
   var degree = Math.PI / 180;
-  if (!Math.hypot)
-    Math.hypot = function() {
-      var y = 0, i = arguments.length;
-      while (i--) {
-        y += arguments[i] * arguments[i];
-      }
-      return Math.sqrt(y);
-    };
 
-  // ../../node_modules/gl-matrix/esm/vec3.js
+  // ../../node_modules/@math.gl/core/dist/gl-matrix/vec3.js
+  var vec3_exports = {};
+  __export(vec3_exports, {
+    add: () => add,
+    angle: () => angle,
+    bezier: () => bezier,
+    ceil: () => ceil,
+    clone: () => clone,
+    copy: () => copy,
+    create: () => create,
+    cross: () => cross,
+    dist: () => dist,
+    distance: () => distance,
+    div: () => div,
+    divide: () => divide,
+    dot: () => dot,
+    equals: () => equals2,
+    exactEquals: () => exactEquals,
+    floor: () => floor,
+    forEach: () => forEach,
+    fromValues: () => fromValues,
+    hermite: () => hermite,
+    inverse: () => inverse,
+    len: () => len,
+    length: () => length,
+    lerp: () => lerp,
+    max: () => max,
+    min: () => min,
+    mul: () => mul,
+    multiply: () => multiply,
+    negate: () => negate,
+    normalize: () => normalize,
+    random: () => random,
+    rotateX: () => rotateX,
+    rotateY: () => rotateY,
+    rotateZ: () => rotateZ,
+    round: () => round2,
+    scale: () => scale,
+    scaleAndAdd: () => scaleAndAdd,
+    set: () => set,
+    slerp: () => slerp,
+    sqrDist: () => sqrDist,
+    sqrLen: () => sqrLen,
+    squaredDistance: () => squaredDistance,
+    squaredLength: () => squaredLength,
+    str: () => str,
+    sub: () => sub,
+    subtract: () => subtract,
+    transformMat3: () => transformMat3,
+    transformMat4: () => transformMat4,
+    transformQuat: () => transformQuat,
+    zero: () => zero
+  });
   function create() {
-    var out = new ARRAY_TYPE(3);
+    const out = new ARRAY_TYPE(3);
     if (ARRAY_TYPE != Float32Array) {
       out[0] = 0;
       out[1] = 0;
@@ -804,17 +862,347 @@ void main() {
     }
     return out;
   }
+  function clone(a) {
+    const out = new ARRAY_TYPE(3);
+    out[0] = a[0];
+    out[1] = a[1];
+    out[2] = a[2];
+    return out;
+  }
+  function length(a) {
+    const x = a[0];
+    const y = a[1];
+    const z = a[2];
+    return Math.sqrt(x * x + y * y + z * z);
+  }
+  function fromValues(x, y, z) {
+    const out = new ARRAY_TYPE(3);
+    out[0] = x;
+    out[1] = y;
+    out[2] = z;
+    return out;
+  }
+  function copy(out, a) {
+    out[0] = a[0];
+    out[1] = a[1];
+    out[2] = a[2];
+    return out;
+  }
+  function set(out, x, y, z) {
+    out[0] = x;
+    out[1] = y;
+    out[2] = z;
+    return out;
+  }
+  function add(out, a, b) {
+    out[0] = a[0] + b[0];
+    out[1] = a[1] + b[1];
+    out[2] = a[2] + b[2];
+    return out;
+  }
+  function subtract(out, a, b) {
+    out[0] = a[0] - b[0];
+    out[1] = a[1] - b[1];
+    out[2] = a[2] - b[2];
+    return out;
+  }
+  function multiply(out, a, b) {
+    out[0] = a[0] * b[0];
+    out[1] = a[1] * b[1];
+    out[2] = a[2] * b[2];
+    return out;
+  }
+  function divide(out, a, b) {
+    out[0] = a[0] / b[0];
+    out[1] = a[1] / b[1];
+    out[2] = a[2] / b[2];
+    return out;
+  }
+  function ceil(out, a) {
+    out[0] = Math.ceil(a[0]);
+    out[1] = Math.ceil(a[1]);
+    out[2] = Math.ceil(a[2]);
+    return out;
+  }
+  function floor(out, a) {
+    out[0] = Math.floor(a[0]);
+    out[1] = Math.floor(a[1]);
+    out[2] = Math.floor(a[2]);
+    return out;
+  }
+  function min(out, a, b) {
+    out[0] = Math.min(a[0], b[0]);
+    out[1] = Math.min(a[1], b[1]);
+    out[2] = Math.min(a[2], b[2]);
+    return out;
+  }
+  function max(out, a, b) {
+    out[0] = Math.max(a[0], b[0]);
+    out[1] = Math.max(a[1], b[1]);
+    out[2] = Math.max(a[2], b[2]);
+    return out;
+  }
+  function round2(out, a) {
+    out[0] = round(a[0]);
+    out[1] = round(a[1]);
+    out[2] = round(a[2]);
+    return out;
+  }
+  function scale(out, a, b) {
+    out[0] = a[0] * b;
+    out[1] = a[1] * b;
+    out[2] = a[2] * b;
+    return out;
+  }
+  function scaleAndAdd(out, a, b, scale2) {
+    out[0] = a[0] + b[0] * scale2;
+    out[1] = a[1] + b[1] * scale2;
+    out[2] = a[2] + b[2] * scale2;
+    return out;
+  }
   function distance(a, b) {
-    var x = b[0] - a[0];
-    var y = b[1] - a[1];
-    var z = b[2] - a[2];
-    return Math.hypot(x, y, z);
+    const x = b[0] - a[0];
+    const y = b[1] - a[1];
+    const z = b[2] - a[2];
+    return Math.sqrt(x * x + y * y + z * z);
+  }
+  function squaredDistance(a, b) {
+    const x = b[0] - a[0];
+    const y = b[1] - a[1];
+    const z = b[2] - a[2];
+    return x * x + y * y + z * z;
+  }
+  function squaredLength(a) {
+    const x = a[0];
+    const y = a[1];
+    const z = a[2];
+    return x * x + y * y + z * z;
+  }
+  function negate(out, a) {
+    out[0] = -a[0];
+    out[1] = -a[1];
+    out[2] = -a[2];
+    return out;
+  }
+  function inverse(out, a) {
+    out[0] = 1 / a[0];
+    out[1] = 1 / a[1];
+    out[2] = 1 / a[2];
+    return out;
+  }
+  function normalize(out, a) {
+    const x = a[0];
+    const y = a[1];
+    const z = a[2];
+    let len2 = x * x + y * y + z * z;
+    if (len2 > 0) {
+      len2 = 1 / Math.sqrt(len2);
+    }
+    out[0] = a[0] * len2;
+    out[1] = a[1] * len2;
+    out[2] = a[2] * len2;
+    return out;
+  }
+  function dot(a, b) {
+    return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+  }
+  function cross(out, a, b) {
+    const ax = a[0];
+    const ay = a[1];
+    const az = a[2];
+    const bx = b[0];
+    const by = b[1];
+    const bz = b[2];
+    out[0] = ay * bz - az * by;
+    out[1] = az * bx - ax * bz;
+    out[2] = ax * by - ay * bx;
+    return out;
+  }
+  function lerp(out, a, b, t) {
+    const ax = a[0];
+    const ay = a[1];
+    const az = a[2];
+    out[0] = ax + t * (b[0] - ax);
+    out[1] = ay + t * (b[1] - ay);
+    out[2] = az + t * (b[2] - az);
+    return out;
+  }
+  function slerp(out, a, b, t) {
+    const angle2 = Math.acos(Math.min(Math.max(dot(a, b), -1), 1));
+    const sinTotal = Math.sin(angle2);
+    const ratioA = Math.sin((1 - t) * angle2) / sinTotal;
+    const ratioB = Math.sin(t * angle2) / sinTotal;
+    out[0] = ratioA * a[0] + ratioB * b[0];
+    out[1] = ratioA * a[1] + ratioB * b[1];
+    out[2] = ratioA * a[2] + ratioB * b[2];
+    return out;
+  }
+  function hermite(out, a, b, c, d, t) {
+    const factorTimes2 = t * t;
+    const factor1 = factorTimes2 * (2 * t - 3) + 1;
+    const factor2 = factorTimes2 * (t - 2) + t;
+    const factor3 = factorTimes2 * (t - 1);
+    const factor4 = factorTimes2 * (3 - 2 * t);
+    out[0] = a[0] * factor1 + b[0] * factor2 + c[0] * factor3 + d[0] * factor4;
+    out[1] = a[1] * factor1 + b[1] * factor2 + c[1] * factor3 + d[1] * factor4;
+    out[2] = a[2] * factor1 + b[2] * factor2 + c[2] * factor3 + d[2] * factor4;
+    return out;
+  }
+  function bezier(out, a, b, c, d, t) {
+    const inverseFactor = 1 - t;
+    const inverseFactorTimesTwo = inverseFactor * inverseFactor;
+    const factorTimes2 = t * t;
+    const factor1 = inverseFactorTimesTwo * inverseFactor;
+    const factor2 = 3 * t * inverseFactorTimesTwo;
+    const factor3 = 3 * factorTimes2 * inverseFactor;
+    const factor4 = factorTimes2 * t;
+    out[0] = a[0] * factor1 + b[0] * factor2 + c[0] * factor3 + d[0] * factor4;
+    out[1] = a[1] * factor1 + b[1] * factor2 + c[1] * factor3 + d[1] * factor4;
+    out[2] = a[2] * factor1 + b[2] * factor2 + c[2] * factor3 + d[2] * factor4;
+    return out;
+  }
+  function random(out, scale2) {
+    scale2 = scale2 === void 0 ? 1 : scale2;
+    const r = RANDOM() * 2 * Math.PI;
+    const z = RANDOM() * 2 - 1;
+    const zScale = Math.sqrt(1 - z * z) * scale2;
+    out[0] = Math.cos(r) * zScale;
+    out[1] = Math.sin(r) * zScale;
+    out[2] = z * scale2;
+    return out;
+  }
+  function transformMat4(out, a, m) {
+    const x = a[0];
+    const y = a[1];
+    const z = a[2];
+    let w = m[3] * x + m[7] * y + m[11] * z + m[15];
+    w = w || 1;
+    out[0] = (m[0] * x + m[4] * y + m[8] * z + m[12]) / w;
+    out[1] = (m[1] * x + m[5] * y + m[9] * z + m[13]) / w;
+    out[2] = (m[2] * x + m[6] * y + m[10] * z + m[14]) / w;
+    return out;
+  }
+  function transformMat3(out, a, m) {
+    const x = a[0];
+    const y = a[1];
+    const z = a[2];
+    out[0] = x * m[0] + y * m[3] + z * m[6];
+    out[1] = x * m[1] + y * m[4] + z * m[7];
+    out[2] = x * m[2] + y * m[5] + z * m[8];
+    return out;
+  }
+  function transformQuat(out, a, q) {
+    const qx = q[0];
+    const qy = q[1];
+    const qz = q[2];
+    const qw = q[3];
+    const x = a[0];
+    const y = a[1];
+    const z = a[2];
+    let uvx = qy * z - qz * y;
+    let uvy = qz * x - qx * z;
+    let uvz = qx * y - qy * x;
+    let uuvx = qy * uvz - qz * uvy;
+    let uuvy = qz * uvx - qx * uvz;
+    let uuvz = qx * uvy - qy * uvx;
+    const w2 = qw * 2;
+    uvx *= w2;
+    uvy *= w2;
+    uvz *= w2;
+    uuvx *= 2;
+    uuvy *= 2;
+    uuvz *= 2;
+    out[0] = x + uvx + uuvx;
+    out[1] = y + uvy + uuvy;
+    out[2] = z + uvz + uuvz;
+    return out;
   }
+  function rotateX(out, a, b, rad) {
+    const p = [];
+    const r = [];
+    p[0] = a[0] - b[0];
+    p[1] = a[1] - b[1];
+    p[2] = a[2] - b[2];
+    r[0] = p[0];
+    r[1] = p[1] * Math.cos(rad) - p[2] * Math.sin(rad);
+    r[2] = p[1] * Math.sin(rad) + p[2] * Math.cos(rad);
+    out[0] = r[0] + b[0];
+    out[1] = r[1] + b[1];
+    out[2] = r[2] + b[2];
+    return out;
+  }
+  function rotateY(out, a, b, rad) {
+    const p = [];
+    const r = [];
+    p[0] = a[0] - b[0];
+    p[1] = a[1] - b[1];
+    p[2] = a[2] - b[2];
+    r[0] = p[2] * Math.sin(rad) + p[0] * Math.cos(rad);
+    r[1] = p[1];
+    r[2] = p[2] * Math.cos(rad) - p[0] * Math.sin(rad);
+    out[0] = r[0] + b[0];
+    out[1] = r[1] + b[1];
+    out[2] = r[2] + b[2];
+    return out;
+  }
+  function rotateZ(out, a, b, rad) {
+    const p = [];
+    const r = [];
+    p[0] = a[0] - b[0];
+    p[1] = a[1] - b[1];
+    p[2] = a[2] - b[2];
+    r[0] = p[0] * Math.cos(rad) - p[1] * Math.sin(rad);
+    r[1] = p[0] * Math.sin(rad) + p[1] * Math.cos(rad);
+    r[2] = p[2];
+    out[0] = r[0] + b[0];
+    out[1] = r[1] + b[1];
+    out[2] = r[2] + b[2];
+    return out;
+  }
+  function angle(a, b) {
+    const ax = a[0];
+    const ay = a[1];
+    const az = a[2];
+    const bx = b[0];
+    const by = b[1];
+    const bz = b[2];
+    const mag = Math.sqrt((ax * ax + ay * ay + az * az) * (bx * bx + by * by + bz * bz));
+    const cosine = mag && dot(a, b) / mag;
+    return Math.acos(Math.min(Math.max(cosine, -1), 1));
+  }
+  function zero(out) {
+    out[0] = 0;
+    out[1] = 0;
+    out[2] = 0;
+    return out;
+  }
+  function str(a) {
+    return "vec3(".concat(a[0], ", ").concat(a[1], ", ").concat(a[2], ")");
+  }
+  function exactEquals(a, b) {
+    return a[0] === b[0] && a[1] === b[1] && a[2] === b[2];
+  }
+  function equals2(a, b) {
+    const a0 = a[0];
+    const a1 = a[1];
+    const a2 = a[2];
+    const b0 = b[0];
+    const b1 = b[1];
+    const b2 = b[2];
+    return Math.abs(a0 - b0) <= EPSILON * Math.max(1, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON * Math.max(1, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= EPSILON * Math.max(1, Math.abs(a2), Math.abs(b2));
+  }
+  var sub = subtract;
+  var mul = multiply;
+  var div = divide;
   var dist = distance;
+  var sqrDist = squaredDistance;
+  var len = length;
+  var sqrLen = squaredLength;
   var forEach = function() {
-    var vec = create();
+    const vec = create();
     return function(a, stride, offset, count, fn, arg) {
-      var i, l;
+      let i;
+      let l;
       if (!stride) {
         stride = 3;
       }
@@ -940,21 +1328,21 @@ vec4 project_position_to_clipspace(
     if (opts && "viewport" in opts) {
       const {
         viewProjectionMatrix,
-        scale
+        scale: scale2
       } = opts.viewport;
       return getMemoizedUniforms({
         viewProjectionMatrix,
-        scale
+        scale: scale2
       });
     }
     return {};
   }
   function calculateUniforms({
     viewProjectionMatrix,
-    scale
+    scale: scale2
   }) {
     const glViewProjectionMatrixFP64 = fp64ifyMatrix42(viewProjectionMatrix);
-    const scaleFP64 = fp64ify2(scale);
+    const scaleFP64 = fp64ify2(scale2);
     return {
       project_uViewProjectionMatrixFP64: glViewProjectionMatrixFP64,
       project64_uViewProjectionMatrix: glViewProjectionMatrixFP64,
@@ -1164,7 +1552,7 @@ attribute float instanceOffsets;
         p = isNested ? path[i] : path.slice(i * positionSize, i * positionSize + positionSize);
         p = this.projectPosition(p);
         if (i > 0) {
-          result[i] = result[i - 1] + dist(prevP, p);
+          result[i] = result[i - 1] + vec3_exports.dist(prevP, p);
         }
         prevP = p;
       }
@@ -1175,11 +1563,11 @@ attribute float instanceOffsets;
   __publicField(PathStyleExtension, "extensionName", "PathStyleExtension");
 
   // src/fill-style/fill-style-extension.ts
-  var import_core11 = __toESM(require_core());
-  var import_core12 = __toESM(require_core2());
+  var import_core12 = __toESM(require_core());
+  var import_core13 = __toESM(require_core2());
 
   // src/fill-style/shaders.glsl.ts
-  var import_core10 = __toESM(require_core());
+  var import_core11 = __toESM(require_core());
   var patternVs = `
 #ifdef NON_INSTANCED_MODEL
   #define FILL_PATTERN_FRAME_ATTRIB fillPatternFrames
@@ -1263,7 +1651,7 @@ const float FILL_UV_SCALE = 512.0 / 40000000.0;
       const {
         project_uCommonOrigin: coordinateOriginCommon
       } = uniforms;
-      const coordinateOriginCommon64Low = [(0, import_core10.fp64LowPart)(coordinateOriginCommon[0]), (0, import_core10.fp64LowPart)(coordinateOriginCommon[1])];
+      const coordinateOriginCommon64Low = [(0, import_core11.fp64LowPart)(coordinateOriginCommon[0]), (0, import_core11.fp64LowPart)(coordinateOriginCommon[1])];
       return {
         fill_uvCoordinateOrigin: coordinateOriginCommon.slice(0, 2),
         fill_uvCoordinateOrigin64Low: coordinateOriginCommon64Low,
@@ -1278,7 +1666,7 @@ const float FILL_UV_SCALE = 512.0 / 40000000.0;
     vs: patternVs,
     fs: patternFs,
     inject: inject3,
-    dependencies: [import_core10.project],
+    dependencies: [import_core11.project],
     getUniforms: getPatternUniforms
   };
 
@@ -1312,7 +1700,7 @@ const float FILL_UV_SCALE = 512.0 / 40000000.0;
       value: [0, 0]
     }
   };
-  var FillStyleExtension = class extends import_core11.LayerExtension {
+  var FillStyleExtension = class extends import_core12.LayerExtension {
     constructor({
       pattern = false
     } = {}) {
@@ -1379,7 +1767,7 @@ const float FILL_UV_SCALE = 512.0 / 40000000.0;
         });
       }
       this.setState({
-        emptyTexture: new import_core12.Texture2D(this.context.gl, {
+        emptyTexture: new import_core13.Texture2D(this.context.gl, {
           data: new Uint8Array(4),
           width: 1,
           height: 1
@@ -1426,7 +1814,7 @@ const float FILL_UV_SCALE = 512.0 / 40000000.0;
   __publicField(FillStyleExtension, "extensionName", "FillStyleExtension");
 
   // src/clip/clip-extension.ts
-  var import_core13 = __toESM(require_core());
+  var import_core14 = __toESM(require_core());
   var defaultProps5 = {
     clipBounds: [0, 0, 1, 1],
     clipByInstance: void 0
@@ -1474,7 +1862,7 @@ varying vec2 clip_commonPosition;
   if (!clip_isInBounds(clip_commonPosition)) discard;
 `
   };
-  var ClipExtension = class extends import_core13.LayerExtension {
+  var ClipExtension = class extends import_core14.LayerExtension {
     getShaders() {
       let clipByInstance = "instancePositions" in this.getAttributeManager().attributes;
       if (this.props.clipByInstance !== void 0) {
@@ -1508,10 +1896,10 @@ varying vec2 clip_commonPosition;
   __publicField(ClipExtension, "extensionName", "ClipExtension");
 
   // src/collision-filter/collision-filter-extension.ts
-  var import_core26 = __toESM(require_core());
+  var import_core27 = __toESM(require_core());
 
   // src/collision-filter/shader-module.ts
-  var import_core14 = __toESM(require_core());
+  var import_core15 = __toESM(require_core());
   var vs3 = `
 #ifdef NON_INSTANCED_MODEL
 attribute float collisionPriorities;
@@ -1606,24 +1994,24 @@ float collision_isVisible(vec2 texCoords, vec3 pickingColor) {
   };
   var shader_module_default2 = {
     name: "collision",
-    dependencies: [import_core14.project],
+    dependencies: [import_core15.project],
     vs: vs3,
     inject: inject4,
     getUniforms: getCollisionUniforms
   };
 
   // src/collision-filter/collision-filter-effect.ts
-  var import_core23 = __toESM(require_core2());
-  var import_core25 = __toESM(require_core());
+  var import_core24 = __toESM(require_core2());
+  var import_core26 = __toESM(require_core());
 
   // src/collision-filter/collision-filter-pass.ts
-  var import_core15 = __toESM(require_core2());
-  var import_core16 = __toESM(require_core());
-  var CollisionFilterPass = class extends import_core16._LayersPass {
+  var import_core16 = __toESM(require_core2());
+  var import_core17 = __toESM(require_core());
+  var CollisionFilterPass = class extends import_core17._LayersPass {
     renderCollisionMap(target, options) {
       const gl = this.gl;
       const padding = 1;
-      return (0, import_core15.withParameters)(gl, {
+      return (0, import_core16.withParameters)(gl, {
         scissorTest: true,
         scissor: [padding, padding, target.width - 2 * padding, target.height - 2 * padding],
         clearColor: [0, 0, 0, 0],
@@ -1647,19 +2035,19 @@ float collision_isVisible(vec2 texCoords, vec3 pickingColor) {
   };
 
   // src/mask/mask-effect.ts
-  var import_core20 = __toESM(require_core());
-  var import_core21 = __toESM(require_core2());
+  var import_core21 = __toESM(require_core());
+  var import_core22 = __toESM(require_core2());
 
   // src/mask/mask-pass.ts
-  var import_core17 = __toESM(require_core2());
-  var import_core18 = __toESM(require_core());
-  var MaskPass = class extends import_core18._LayersPass {
+  var import_core18 = __toESM(require_core2());
+  var import_core19 = __toESM(require_core());
+  var MaskPass = class extends import_core19._LayersPass {
     constructor(gl, props) {
       super(gl, props);
       const {
         mapSize = 2048
       } = props;
-      this.maskMap = new import_core17.Texture2D(gl, {
+      this.maskMap = new import_core18.Texture2D(gl, {
         width: mapSize,
         height: mapSize,
         parameters: {
@@ -1669,7 +2057,7 @@ float collision_isVisible(vec2 texCoords, vec3 pickingColor) {
           [10243]: 33071
         }
       });
-      this.fbo = new import_core17.Framebuffer(gl, {
+      this.fbo = new import_core18.Framebuffer(gl, {
         id: "maskmap",
         width: mapSize,
         height: mapSize,
@@ -1682,7 +2070,7 @@ float collision_isVisible(vec2 texCoords, vec3 pickingColor) {
       const gl = this.gl;
       const colorMask = [false, false, false, false];
       colorMask[options.channel] = true;
-      return (0, import_core17.withParameters)(gl, {
+      return (0, import_core18.withParameters)(gl, {
         clearColor: [255, 255, 255, 255],
         blend: true,
         blendFunc: [0, 1],
@@ -1705,7 +2093,7 @@ float collision_isVisible(vec2 texCoords, vec3 pickingColor) {
   };
 
   // src/utils/projection-utils.ts
-  var import_core19 = __toESM(require_core());
+  var import_core20 = __toESM(require_core());
   function joinLayerBounds(layers, viewport) {
     const bounds = [Infinity, Infinity, -Infinity, -Infinity];
     for (const layer of layers) {
@@ -1752,12 +2140,12 @@ float collision_isVisible(vec2 texCoords, vec3 pickingColor) {
     if (zoom === void 0) {
       width = width - border * 2;
       height = height - border * 2;
-      const scale = Math.min(width / (bounds[2] - bounds[0]), height / (bounds[3] - bounds[1]));
-      zoom = Math.min(Math.log2(scale), 20);
+      const scale2 = Math.min(width / (bounds[2] - bounds[0]), height / (bounds[3] - bounds[1]));
+      zoom = Math.min(Math.log2(scale2), 20);
     } else if (!width || !height) {
-      const scale = 2 ** zoom;
-      width = Math.round(Math.abs(bounds[2] - bounds[0]) * scale);
-      height = Math.round(Math.abs(bounds[3] - bounds[1]) * scale);
+      const scale2 = 2 ** zoom;
+      width = Math.round(Math.abs(bounds[2] - bounds[0]) * scale2);
+      height = Math.round(Math.abs(bounds[3] - bounds[1]) * scale2);
       const maxSize = MAX_VIEWPORT_SIZE - border * 2;
       if (width > maxSize || height > maxSize) {
         const r = maxSize / Math.max(width, height);
@@ -1766,7 +2154,7 @@ float collision_isVisible(vec2 texCoords, vec3 pickingColor) {
         zoom += Math.log2(r);
       }
     }
-    return isGeospatial ? new import_core19.WebMercatorViewport({
+    return isGeospatial ? new import_core20.WebMercatorViewport({
       id: viewport.id,
       x: border,
       y: border,
@@ -1776,7 +2164,7 @@ float collision_isVisible(vec2 texCoords, vec3 pickingColor) {
       latitude: centerWorld[1],
       zoom,
       orthographic: true
-    }) : new import_core19.OrthographicViewport({
+    }) : new import_core20.OrthographicViewport({
       id: viewport.id,
       x: border,
       y: border,
@@ -1842,7 +2230,7 @@ float collision_isVisible(vec2 texCoords, vec3 pickingColor) {
     }) {
       let didRender = false;
       if (!this.dummyMaskMap) {
-        this.dummyMaskMap = new import_core21.Texture2D(gl, {
+        this.dummyMaskMap = new import_core22.Texture2D(gl, {
           width: 1,
           height: 1
         });
@@ -1871,7 +2259,7 @@ float collision_isVisible(vec2 texCoords, vec3 pickingColor) {
       const viewport = viewports[0];
       const viewportChanged = !this.lastViewport || !this.lastViewport.equals(viewport);
       if (viewport.resolution !== void 0) {
-        import_core20.log.warn("MaskExtension is not supported in GlobeView")();
+        import_core21.log.warn("MaskExtension is not supported in GlobeView")();
         return {
           didRender
         };
@@ -1956,7 +2344,7 @@ float collision_isVisible(vec2 texCoords, vec3 pickingColor) {
         let channelInfo = channelMap[id];
         if (!channelInfo) {
           if (++channelCount > 4) {
-            import_core20.log.warn("Too many mask layers. The max supported is 4")();
+            import_core21.log.warn("Too many mask layers. The max supported is 4")();
             continue;
           }
           channelInfo = {
@@ -2029,7 +2417,7 @@ float collision_isVisible(vec2 texCoords, vec3 pickingColor) {
       preRenderStats = {}
     }) {
       if (!this.dummyCollisionMap) {
-        this.dummyCollisionMap = new import_core23.Texture2D(gl, {
+        this.dummyCollisionMap = new import_core24.Texture2D(gl, {
           width: 1,
           height: 1
         });
@@ -2089,7 +2477,7 @@ float collision_isVisible(vec2 texCoords, vec3 pickingColor) {
       if (!oldRenderInfo) {
         return;
       }
-      const needsRender = viewportChanged || renderInfo === oldRenderInfo || !(0, import_core25._deepEqual)(oldRenderInfo.layers, renderInfo.layers, 1) || renderInfo.layerBounds.some((b, i) => !equals(b, oldRenderInfo.layerBounds[i])) || renderInfo.allLayersLoaded !== oldRenderInfo.allLayersLoaded || renderInfo.layers.some((layer) => layer.props.transitions);
+      const needsRender = viewportChanged || renderInfo === oldRenderInfo || !(0, import_core26._deepEqual)(oldRenderInfo.layers, renderInfo.layers, 1) || renderInfo.layerBounds.some((b, i) => !equals(b, oldRenderInfo.layerBounds[i])) || renderInfo.allLayersLoaded !== oldRenderInfo.allLayersLoaded || renderInfo.layers.some((layer) => layer.props.transitions);
       this.channels[collisionGroup] = renderInfo;
       if (needsRender) {
         this.lastViewport = viewport;
@@ -2105,7 +2493,7 @@ float collision_isVisible(vec2 texCoords, vec3 pickingColor) {
           views,
           moduleParameters: {
             dummyCollisionMap: this.dummyCollisionMap,
-            devicePixelRatio: (0, import_core23.cssToDeviceRatio)(collisionFBO.gl) / DOWNSCALE
+            devicePixelRatio: (0, import_core24.cssToDeviceRatio)(collisionFBO.gl) / DOWNSCALE
           }
         });
       }
@@ -2177,7 +2565,7 @@ float collision_isVisible(vec2 texCoords, vec3 pickingColor) {
         width,
         height
       } = gl.canvas;
-      const collisionMap = new import_core23.Texture2D(gl, {
+      const collisionMap = new import_core24.Texture2D(gl, {
         width,
         height,
         parameters: {
@@ -2187,12 +2575,12 @@ float collision_isVisible(vec2 texCoords, vec3 pickingColor) {
           [10243]: 33071
         }
       });
-      const depthBuffer = new import_core23.Renderbuffer(gl, {
+      const depthBuffer = new import_core24.Renderbuffer(gl, {
         format: 33189,
         width,
         height
       });
-      this.collisionFBOs[collisionGroup] = new import_core23.Framebuffer(gl, {
+      this.collisionFBOs[collisionGroup] = new import_core24.Framebuffer(gl, {
         id: `Collision-${collisionGroup}`,
         width,
         height,
@@ -2225,7 +2613,7 @@ float collision_isVisible(vec2 texCoords, vec3 pickingColor) {
     },
     collisionTestProps: {}
   };
-  var CollisionFilterExtension = class extends import_core26.LayerExtension {
+  var CollisionFilterExtension = class extends import_core27.LayerExtension {
     getShaders() {
       return {
         modules: [shader_module_default2]
@@ -2278,10 +2666,10 @@ float collision_isVisible(vec2 texCoords, vec3 pickingColor) {
   __publicField(CollisionFilterExtension, "extensionName", "CollisionFilterExtension");
 
   // src/mask/mask-extension.ts
-  var import_core28 = __toESM(require_core());
+  var import_core29 = __toESM(require_core());
 
   // src/mask/shader-module.ts
-  var import_core27 = __toESM(require_core());
+  var import_core28 = __toESM(require_core());
   var vs4 = `
 uniform vec4 mask_bounds;
 uniform bool mask_maskByInstance;
@@ -2355,7 +2743,7 @@ varying vec2 mask_texCoords;
   };
   var shader_module_default3 = {
     name: "mask",
-    dependencies: [import_core27.project],
+    dependencies: [import_core28.project],
     vs: vs4,
     fs: fs3,
     inject: inject5,
@@ -2368,7 +2756,7 @@ varying vec2 mask_texCoords;
     maskByInstance: void 0,
     maskInverted: false
   };
-  var MaskExtension = class extends import_core28.LayerExtension {
+  var MaskExtension = class extends import_core29.LayerExtension {
     initializeState() {
       this.context.deck?._addDefaultEffect(new MaskEffect());
     }
@@ -2410,8 +2798,8 @@ varying vec2 mask_texCoords;
         uniforms.mask_enabled = true;
         uniforms.mask_channel = index;
         uniforms.mask_inverted = maskInverted;
-        if (fromCoordinateSystem === import_core28.COORDINATE_SYSTEM.DEFAULT) {
-          fromCoordinateSystem = viewport.isGeospatial ? import_core28.COORDINATE_SYSTEM.LNGLAT : import_core28.COORDINATE_SYSTEM.CARTESIAN;
+        if (fromCoordinateSystem === import_core29.COORDINATE_SYSTEM.DEFAULT) {
+          fromCoordinateSystem = viewport.isGeospatial ? import_core29.COORDINATE_SYSTEM.LNGLAT : import_core29.COORDINATE_SYSTEM.CARTESIAN;
         }
         const opts = {
           modelMatrix: null,
@@ -2423,7 +2811,7 @@ varying vec2 mask_texCoords;
         uniforms.mask_bounds = [bl[0], bl[1], tr[0], tr[1]];
       } else {
         if (maskId) {
-          import_core28.log.warn(`Could not find a mask layer with id: ${maskId}`)();
+          import_core29.log.warn(`Could not find a mask layer with id: ${maskId}`)();
         }
         uniforms.mask_enabled = false;
       }
@@ -2433,14 +2821,14 @@ varying vec2 mask_texCoords;
   __publicField(MaskExtension, "extensionName", "MaskExtension");
 
   // src/terrain/terrain-extension.ts
-  var import_core38 = __toESM(require_core());
+  var import_core39 = __toESM(require_core());
 
   // src/terrain/terrain-effect.ts
-  var import_core36 = __toESM(require_core2());
-  var import_core37 = __toESM(require_core());
+  var import_core37 = __toESM(require_core2());
+  var import_core38 = __toESM(require_core());
 
   // src/terrain/shader-module.ts
-  var import_core29 = __toESM(require_core());
+  var import_core30 = __toESM(require_core());
   var TERRAIN_MODE = {
     NONE: 0,
     WRITE_HEIGHT_MAP: 1,
@@ -2452,7 +2840,7 @@ varying vec2 mask_texCoords;
   var TERRAIN_MODE_CONSTANTS = Object.keys(TERRAIN_MODE).map((key) => `const float TERRAIN_MODE_${key} = ${TERRAIN_MODE[key]}.0;`).join("\n");
   var terrainModule = {
     name: "terrain",
-    dependencies: [import_core29.project],
+    dependencies: [import_core30.project],
     inject: {
       "vs:#decl": `
 uniform float terrain_mode;
@@ -2561,14 +2949,14 @@ if ((terrain_mode == TERRAIN_MODE_USE_COVER) || (terrain_mode == TERRAIN_MODE_US
   };
 
   // src/terrain/utils.ts
-  var import_core30 = __toESM(require_core2());
+  var import_core31 = __toESM(require_core2());
   function createRenderTarget(gl, opts) {
-    return new import_core30.Framebuffer(gl, {
+    return new import_core31.Framebuffer(gl, {
       id: opts.id,
       attachments: {
-        [36064]: new import_core30.Texture2D(gl, {
+        [36064]: new import_core31.Texture2D(gl, {
           ...opts.float && {
-            format: (0, import_core30.isWebGL2)(gl) ? 34836 : 6408,
+            format: (0, import_core31.isWebGL2)(gl) ? 34836 : 6408,
             type: 5126
           },
           mipmaps: false,
@@ -2751,9 +3139,9 @@ if ((terrain_mode == TERRAIN_MODE_USE_COVER) || (terrain_mode == TERRAIN_MODE_US
   }
 
   // src/terrain/terrain-pass.ts
-  var import_core31 = __toESM(require_core2());
-  var import_core32 = __toESM(require_core());
-  var TerrainPass = class extends import_core32._LayersPass {
+  var import_core32 = __toESM(require_core2());
+  var import_core33 = __toESM(require_core());
+  var TerrainPass = class extends import_core33._LayersPass {
     getRenderableLayers(viewport, opts) {
       const {
         layers
@@ -2775,7 +3163,7 @@ if ((terrain_mode == TERRAIN_MODE_USE_COVER) || (terrain_mode == TERRAIN_MODE_US
         return;
       }
       target.resize(viewport);
-      (0, import_core31.withParameters)(this.gl, {
+      (0, import_core32.withParameters)(this.gl, {
         clearColor: [0, 0, 0, 0],
         blend: true,
         blendFunc: [1, 1],
@@ -2798,7 +3186,7 @@ if ((terrain_mode == TERRAIN_MODE_USE_COVER) || (terrain_mode == TERRAIN_MODE_US
       }
       const layers = terrainCover.filterLayers(opts.layers);
       target.resize(viewport);
-      (0, import_core31.withParameters)(this.gl, {
+      (0, import_core32.withParameters)(this.gl, {
         clearColor: [0, 0, 0, 0],
         depthTest: false
       }, () => this.render({
@@ -2813,9 +3201,9 @@ if ((terrain_mode == TERRAIN_MODE_USE_COVER) || (terrain_mode == TERRAIN_MODE_US
   };
 
   // src/terrain/terrain-picking-pass.ts
-  var import_core33 = __toESM(require_core());
-  var import_core34 = __toESM(require_core2());
-  var TerrainPickingPass = class extends import_core33._PickLayersPass {
+  var import_core34 = __toESM(require_core());
+  var import_core35 = __toESM(require_core2());
+  var TerrainPickingPass = class extends import_core34._PickLayersPass {
     drawParameters = {};
     getRenderableLayers(viewport, opts) {
       const {
@@ -2846,7 +3234,7 @@ if ((terrain_mode == TERRAIN_MODE_USE_COVER) || (terrain_mode == TERRAIN_MODE_US
         layers.unshift(terrainLayer);
       }
       target.resize(viewport);
-      (0, import_core34.withParameters)(this.gl, {
+      (0, import_core35.withParameters)(this.gl, {
         depthTest: false
       }, () => this.render({
         ...opts,
@@ -2871,7 +3259,7 @@ if ((terrain_mode == TERRAIN_MODE_USE_COVER) || (terrain_mode == TERRAIN_MODE_US
   };
 
   // src/terrain/height-map-builder.ts
-  var import_core35 = __toESM(require_core2());
+  var import_core36 = __toESM(require_core2());
   var MAP_MAX_SIZE = 2048;
   var HeightMapBuilder = class {
     renderViewport = null;
@@ -2881,7 +3269,7 @@ if ((terrain_mode == TERRAIN_MODE_USE_COVER) || (terrain_mode == TERRAIN_MODE_US
     layersBoundsCommon = null;
     lastViewport = null;
     static isSupported(gl) {
-      return import_core35.Framebuffer.isSupported(gl, {
+      return import_core36.Framebuffer.isSupported(gl, {
         colorBufferFloat: true
       });
     }
@@ -2921,9 +3309,9 @@ if ((terrain_mode == TERRAIN_MODE_USE_COVER) || (terrain_mode == TERRAIN_MODE_US
         }
         this.bounds = bounds;
         this.lastViewport = viewport;
-        const scale = viewport.scale;
-        const pixelWidth = (bounds[2] - bounds[0]) * scale;
-        const pixelHeight = (bounds[3] - bounds[1]) * scale;
+        const scale2 = viewport.scale;
+        const pixelWidth = (bounds[2] - bounds[0]) * scale2;
+        const pixelHeight = (bounds[3] - bounds[1]) * scale2;
         this.renderViewport = pixelWidth > 0 || pixelHeight > 0 ? makeViewport({
           bounds: [viewport.center[0] - 1, viewport.center[1] - 1, viewport.center[0] + 1, viewport.center[1] + 1],
           zoom: viewport.zoom,
@@ -2952,7 +3340,7 @@ if ((terrain_mode == TERRAIN_MODE_USE_COVER) || (terrain_mode == TERRAIN_MODE_US
     isDrapingEnabled = false;
     terrainCovers = /* @__PURE__ */ new Map();
     initialize(gl) {
-      this.dummyHeightMap = new import_core36.Texture2D(gl, {
+      this.dummyHeightMap = new import_core37.Texture2D(gl, {
         width: 1,
         height: 1,
         data: new Uint8Array([0, 0, 0, 0])
@@ -2966,9 +3354,9 @@ if ((terrain_mode == TERRAIN_MODE_USE_COVER) || (terrain_mode == TERRAIN_MODE_US
       if (HeightMapBuilder.isSupported(gl)) {
         this.heightMap = new HeightMapBuilder(gl);
       } else {
-        import_core37.log.warn("Terrain offset mode is not supported by this browser")();
+        import_core38.log.warn("Terrain offset mode is not supported by this browser")();
       }
-      import_core36.ProgramManager.getDefaultProgramManager(gl).addDefaultModule(terrainModule);
+      import_core37.ProgramManager.getDefaultProgramManager(gl).addDefaultModule(terrainModule);
     }
     preRender(gl, opts) {
       if (!this.dummyHeightMap) {
@@ -3121,7 +3509,7 @@ if ((terrain_mode == TERRAIN_MODE_USE_COVER) || (terrain_mode == TERRAIN_MODE_US
   var defaultProps8 = {
     terrainDrawMode: void 0
   };
-  var TerrainExtension = class extends import_core38.LayerExtension {
+  var TerrainExtension = class extends import_core39.LayerExtension {
     getShaders() {
       return {
         modules: [terrainModule]