@deck.gl/geo-layers 9.2.0-alpha.3 → 9.2.0-beta.2

package/dist/dist.dev.js

@@ -3401,12 +3401,12 @@ var __exports__ = (() => {
   function frob(a22) {
     return Math.hypot(a22[0], a22[1], a22[2], a22[3]);
   }
-  function LDU(L2, D, U, a22) {
+  function LDU(L2, D2, U, a22) {
     L2[2] = a22[2] / a22[0];
     U[0] = a22[0];
     U[1] = a22[1];
     U[3] = a22[3] - L2[2] * U[1];
-    return [L2, D, U];
+    return [L2, D2, U];
   }
   function add(out, a22, b2) {
     out[0] = a22[0] + b2[0];
@@ -4600,7 +4600,6 @@ var __exports__ = (() => {
   var PentagonShape = class _PentagonShape {
     constructor(vertices) {
       this.vertices = vertices;
-      this.id = { i: 0, j: 0, k: 0, resolution: 1 };
       if (!this.isWindingCorrect()) {
         this.vertices.reverse();
       }
@@ -4671,36 +4670,36 @@ var __exports__ = (() => {
       return newPentagon;
     }
     getCenter() {
-      return this.vertices.reduce(
-        (sum, v2) => [sum[0] + v2[0] / 5, sum[1] + v2[1] / 5],
-        [0, 0]
-      );
+      const n2 = this.vertices.length;
+      const sum = this.vertices.reduce((sum2, v2) => [sum2[0] + v2[0] / n2, sum2[1] + v2[1] / n2], [0, 0]);
+      return sum;
     }
     /**
      * Tests if a point is inside the pentagon by checking if it's on the correct side of all edges.
      * Assumes consistent winding order (counter-clockwise).
      * @param point The point to test
-     * @returns -1 if point is inside, otherwise a value proportional to the distance from the point to the edge
+     * @returns 1 if point is inside, otherwise a negative value proportional to the distance from the point to the edge
      */
     containsPoint(point) {
       if (!this.isWindingCorrect()) {
         throw new Error("Pentagon is not counter-clockwise");
       }
       const N = this.vertices.length;
+      let dMax = 1;
       for (let i3 = 0; i3 < N; i3++) {
         const v1 = this.vertices[i3];
         const v2 = this.vertices[(i3 + 1) % N];
-        const dx = v2[0] - v1[0];
-        const dy = v2[1] - v1[1];
+        const dx = v1[0] - v2[0];
+        const dy = v1[1] - v2[1];
         const px = point[0] - v1[0];
         const py = point[1] - v1[1];
         const crossProduct = dx * py - dy * px;
-        if (crossProduct > 0) {
+        if (crossProduct < 0) {
           const pLength = Math.sqrt(px * px + py * py);
-          return crossProduct / pLength;
+          dMax = Math.min(dMax, crossProduct / pLength);
         }
       }
-      return -1;
+      return dMax;
     }
     /**
      * Splits each edge of the pentagon into the specified number of segments
@@ -4774,16 +4773,16 @@ var __exports__ = (() => {
      * @param C Array of coefficients
      * @returns Transformed angle in radians
      */
-    applyCoefficients(phi, C) {
+    applyCoefficients(phi, C2) {
       const sinPhi = Math.sin(phi);
       const cosPhi = Math.cos(phi);
       const X = 2 * (cosPhi - sinPhi) * (cosPhi + sinPhi);
       let u0, u1;
-      u0 = X * C[5] + C[4];
-      u1 = X * u0 + C[3];
-      u0 = X * u1 - u0 + C[2];
-      u1 = X * u0 - u1 + C[1];
-      u0 = X * u1 - u0 + C[0];
+      u0 = X * C2[5] + C2[4];
+      u1 = X * u0 + C2[3];
+      u0 = X * u1 - u0 + C2[2];
+      u1 = X * u0 - u1 + C2[1];
+      u0 = X * u1 - u0 + C2[0];
       return phi + 2 * sinPhi * cosPhi * u0;
     }
     /**
@@ -4865,12 +4864,6 @@ var __exports__ = (() => {
     const latitude = radToDeg(geodeticLat);
     return [longitude, latitude];
   }
-  function quatFromSpherical(axis) {
-    const cartesian = toCartesian(axis);
-    const Q = quat_exports.create();
-    quat_exports.rotationTo(Q, [0, 0, 1], cartesian);
-    return Q;
-  }
   function normalizeLongitudes(contour) {
     const points = contour.map((lonLat) => toCartesian(fromLonLat(lonLat)));
     const center2 = vec3_exports.create();
@@ -4893,6 +4886,53 @@ var __exports__ = (() => {
     });
   }
   common_exports.setMatrixArrayType(Float64Array);
+  var SQRT5 = Math.sqrt(5);
+  var INV_SQRT5 = Math.sqrt(0.2);
+  var sinAlpha = Math.sqrt((1 - INV_SQRT5) / 2);
+  var cosAlpha = Math.sqrt((1 + INV_SQRT5) / 2);
+  var A = 0.5;
+  var B = Math.sqrt((2.5 - SQRT5) / 10);
+  var C = Math.sqrt((2.5 + SQRT5) / 10);
+  var D = Math.sqrt((1 + INV_SQRT5) / 8);
+  var E = Math.sqrt((1 - INV_SQRT5) / 8);
+  var F = Math.sqrt((3 - SQRT5) / 8);
+  var G = Math.sqrt((3 + SQRT5) / 8);
+  var faceCenters = [
+    [0, 0],
+    // Doesn't actually matter as rotation is 0
+    // First ring: five vertices, CCW, multiplied by sinAlpha
+    [sinAlpha, 0],
+    // [cos0, sin0]
+    [B, A],
+    // [cos72, sin72]
+    [-D, F],
+    // [-cos36, sin36]
+    [-D, -F],
+    // [-cos36, -sin36]
+    [B, -A],
+    // [cos72, -sin72]
+    // Second ring: the same five vertices but negated (180deg rotation), multiplied by cosAlpha
+    [-cosAlpha, 0],
+    // [-cos0, -sin0]
+    [-E, -G],
+    // [-cos72, -sin72]
+    [C, -A],
+    // [cos36, -sin36]
+    [C, A],
+    // [cos36, sin36]
+    [-E, G],
+    // [-cos72, sin72]
+    [0, 0]
+  ];
+  var axes = faceCenters.map(([x2, y2]) => [-y2, x2]);
+  var quaternions = axes.map((axis, i3) => {
+    if (i3 === 0)
+      return [0, 0, 0, 1];
+    if (i3 === 11)
+      return [0, -1, 0, 0];
+    return [...axis, 0, i3 < 6 ? cosAlpha : sinAlpha];
+  });
+  common_exports.setMatrixArrayType(Float64Array);
   var clockwiseFan = ["vu", "uw", "vw", "vw", "vw"];
   var clockwiseStep = ["wu", "uw", "vw", "vu", "uw"];
   var counterStep = ["wu", "uv", "wv", "wu", "uw"];
@@ -4927,24 +4967,27 @@ var __exports__ = (() => {
   var ORIGIN_ORDER = [0, 1, 2, 4, 3, 5, 7, 8, 6, 11, 10, 9];
   var origins = [];
   function generateOrigins() {
-    addOrigin([0, 0], 0);
+    addOrigin([0, 0], 0, quaternions[0]);
     for (let i3 = 0; i3 < 5; i3++) {
       const alpha = i3 * TWO_PI_OVER_5;
       const alpha2 = alpha + PI_OVER_5;
-      addOrigin([alpha, interhedralAngle], PI_OVER_5);
-      addOrigin([alpha2, Math.PI - interhedralAngle], PI_OVER_5);
+      addOrigin([alpha, interhedralAngle], PI_OVER_5, quaternions[i3 + 1]);
+      addOrigin([alpha2, Math.PI - interhedralAngle], PI_OVER_5, quaternions[(i3 + 3) % 5 + 6]);
     }
-    addOrigin([0, Math.PI], 0);
+    addOrigin([0, Math.PI], 0, quaternions[11]);
   }
   var originId = 0;
-  function addOrigin(axis, angle32) {
+  function addOrigin(axis, angle32, quaternion) {
     if (originId > 11) {
       throw new Error(`Too many origins: ${originId}`);
     }
+    const inverseQuat = quat_exports.create();
+    quat_exports.conjugate(inverseQuat, quaternion);
     const origin = {
       id: originId,
       axis,
-      quat: quatFromSpherical(axis),
+      quat: quaternion,
+      inverseQuat,
       angle: angle32,
       orientation: QUINTANT_ORIENTATIONS[originId],
       firstQuintant: QUINTANT_FIRST[originId]
@@ -4985,39 +5028,39 @@ var __exports__ = (() => {
   var crossCD = vec3_exports.create();
   var scaledA = vec3_exports.create();
   var scaledB = vec3_exports.create();
-  function vectorDifference(A, B) {
-    vec3_exports.lerp(midpointAB, A, B, 0.5);
+  function vectorDifference(A2, B2) {
+    vec3_exports.lerp(midpointAB, A2, B2, 0.5);
     vec3_exports.normalize(midpointAB, midpointAB);
-    vec3_exports.cross(midpointAB, A, midpointAB);
-    const D = vec3_exports.length(midpointAB);
-    if (D < 1e-8) {
-      const AB = vec3_exports.subtract(vec3_exports.create(), A, B);
+    vec3_exports.cross(midpointAB, A2, midpointAB);
+    const D2 = vec3_exports.length(midpointAB);
+    if (D2 < 1e-8) {
+      const AB = vec3_exports.subtract(vec3_exports.create(), A2, B2);
       const halfDistance = 0.5 * vec3_exports.length(AB);
       return halfDistance;
     }
-    return D;
+    return D2;
   }
-  function tripleProduct(A, B, C) {
-    vec3_exports.cross(crossCD, B, C);
-    return vec3_exports.dot(A, crossCD);
+  function tripleProduct(A2, B2, C2) {
+    vec3_exports.cross(crossCD, B2, C2);
+    return vec3_exports.dot(A2, crossCD);
   }
-  function quadrupleProduct(out, A, B, C, D) {
-    vec3_exports.cross(crossCD, C, D);
-    const tripleProductACD = vec3_exports.dot(A, crossCD);
-    const tripleProductBCD = vec3_exports.dot(B, crossCD);
-    vec3_exports.scale(scaledA, A, tripleProductBCD);
-    vec3_exports.scale(scaledB, B, tripleProductACD);
+  function quadrupleProduct(out, A2, B2, C2, D2) {
+    vec3_exports.cross(crossCD, C2, D2);
+    const tripleProductACD = vec3_exports.dot(A2, crossCD);
+    const tripleProductBCD = vec3_exports.dot(B2, crossCD);
+    vec3_exports.scale(scaledA, A2, tripleProductBCD);
+    vec3_exports.scale(scaledB, B2, tripleProductACD);
     return vec3_exports.sub(out, scaledB, scaledA);
   }
-  function slerp2(out, A, B, t2) {
-    const gamma = vec3_exports.angle(A, B);
+  function slerp2(out, A2, B2, t2) {
+    const gamma = vec3_exports.angle(A2, B2);
     if (gamma < 1e-12) {
-      return vec3_exports.lerp(out, A, B, t2);
+      return vec3_exports.lerp(out, A2, B2, t2);
     }
     const weightA = Math.sin((1 - t2) * gamma) / Math.sin(gamma);
     const weightB = Math.sin(t2 * gamma) / Math.sin(gamma);
-    const scaledA2 = vec3_exports.scale(vec3_exports.create(), A, weightA);
-    const scaledB2 = vec3_exports.scale(vec3_exports.create(), B, weightB);
+    const scaledA2 = vec3_exports.scale(vec3_exports.create(), A2, weightA);
+    const scaledB2 = vec3_exports.scale(vec3_exports.create(), B2, weightB);
     return vec3_exports.add(out, scaledA2, scaledB2);
   }
   common_exports.setMatrixArrayType(Float64Array);
@@ -5184,19 +5227,19 @@ var __exports__ = (() => {
      * @returns The face coordinates
      */
     forward(v2, sphericalTriangle, faceTriangle) {
-      const [A, B, C] = sphericalTriangle;
-      const triangleShape = new SphericalTriangleShape([A, B, C]);
-      const Z = vec3_exports.subtract(vec3_exports.create(), v2, A);
+      const [A2, B2, C2] = sphericalTriangle;
+      const triangleShape = new SphericalTriangleShape([A2, B2, C2]);
+      const Z = vec3_exports.subtract(vec3_exports.create(), v2, A2);
       vec3_exports.normalize(Z, Z);
-      const p2 = quadrupleProduct(vec3_exports.create(), A, Z, B, C);
+      const p2 = quadrupleProduct(vec3_exports.create(), A2, Z, B2, C2);
       vec3_exports.normalize(p2, p2);
-      const h = vectorDifference(A, v2) / vectorDifference(A, p2);
+      const h = vectorDifference(A2, v2) / vectorDifference(A2, p2);
       const Area_ABC = triangleShape.getArea();
       const scaledArea = h / Area_ABC;
       const b2 = [
         1 - h,
-        scaledArea * new SphericalTriangleShape([A, p2, C]).getArea(),
-        scaledArea * new SphericalTriangleShape([A, B, p2]).getArea()
+        scaledArea * new SphericalTriangleShape([A2, p2, C2]).getArea(),
+        scaledArea * new SphericalTriangleShape([A2, B2, p2]).getArea()
       ];
       return barycentricToFace(b2, faceTriangle);
     }
@@ -5208,18 +5251,18 @@ var __exports__ = (() => {
      * @returns The spherical coordinates
      */
     inverse(facePoint, faceTriangle, sphericalTriangle) {
-      const [A, B, C] = sphericalTriangle;
-      const triangleShape = new SphericalTriangleShape([A, B, C]);
+      const [A2, B2, C2] = sphericalTriangle;
+      const triangleShape = new SphericalTriangleShape([A2, B2, C2]);
       const b2 = faceToBarycentric(facePoint, faceTriangle);
       const threshold = 1 - 1e-14;
       if (b2[0] > threshold)
-        return A;
+        return A2;
       if (b2[1] > threshold)
-        return B;
+        return B2;
       if (b2[2] > threshold)
-        return C;
+        return C2;
       const c1 = vec3_exports.create();
-      vec3_exports.cross(c1, B, C);
+      vec3_exports.cross(c1, B2, C2);
       const Area_ABC = triangleShape.getArea();
       const h = 1 - b2[0];
       const R = b2[2] / h;
@@ -5227,18 +5270,18 @@ var __exports__ = (() => {
       const S = Math.sin(alpha);
       const halfC = Math.sin(alpha / 2);
       const CC = 2 * halfC * halfC;
-      const c01 = vec3_exports.dot(A, B);
-      const c12 = vec3_exports.dot(B, C);
-      const c20 = vec3_exports.dot(C, A);
+      const c01 = vec3_exports.dot(A2, B2);
+      const c12 = vec3_exports.dot(B2, C2);
+      const c20 = vec3_exports.dot(C2, A2);
       const s12 = vec3_exports.length(c1);
-      const V2 = vec3_exports.dot(A, c1);
+      const V2 = vec3_exports.dot(A2, c1);
       const f2 = S * V2 + CC * (c01 * c12 - c20);
       const g = CC * s12 * (1 + c01);
       const q = 2 / Math.acos(c12) * Math.atan2(g, f2);
-      const P = slerp2(vec3_exports.create(), B, C, q);
-      const K = vectorDifference(A, P);
+      const P = slerp2(vec3_exports.create(), B2, C2, q);
+      const K = vectorDifference(A2, P);
       const t2 = this.safeAcos(h * K) / this.safeAcos(K);
-      const out = slerp2([0, 0, 0], A, P, t2);
+      const out = slerp2([0, 0, 0], A2, P, t2);
       return out;
     }
     /**
@@ -5310,10 +5353,10 @@ var __exports__ = (() => {
       return;
     const parentK = digits[i3] || 0;
     const childK = digits[i3 - 1];
-    const F = flips[0] + flips[1];
+    const F2 = flips[0] + flips[1];
     let needsShift = true;
     let first = true;
-    if (invertJ !== (F === 0)) {
+    if (invertJ !== (F2 === 0)) {
       needsShift = parentK === 1 || parentK === 2;
       first = parentK === 1;
     } else {
@@ -5395,11 +5438,11 @@ var __exports__ = (() => {
       pentagon.rotate180();
     }
     const { k } = anchor;
-    const F = anchor.flips[0] + anchor.flips[1];
+    const F2 = anchor.flips[0] + anchor.flips[1];
     if (
       // Orient last two pentagons when both or neither flips are YES
-      (F === -2 || F === 2) && k > 1 || // Orient first & last pentagons when only one of flips is YES
-      F === 0 && (k === 0 || k === 3)
+      (F2 === -2 || F2 === 2) && k > 1 || // Orient first & last pentagons when only one of flips is YES
+      F2 === 0 && (k === 0 || k === 3)
     ) {
       pentagon.reflectY();
     }
@@ -5506,16 +5549,15 @@ var __exports__ = (() => {
     forward(spherical, originId2) {
       const origin = origins[originId2];
       const unprojected = toCartesian(spherical);
-      const inverseQuat = quat_exports.create();
-      quat_exports.invert(inverseQuat, origin.quat);
       const out = vec3_exports.create();
-      vec3_exports.transformQuat(out, unprojected, inverseQuat);
+      vec3_exports.transformQuat(out, unprojected, origin.inverseQuat);
       const projectedSpherical = toSpherical(out);
       const polar = this.gnomonic.forward(projectedSpherical);
       polar[1] = polar[1] - origin.angle;
       const faceTriangleIndex = this.getFaceTriangleIndex(polar);
-      let faceTriangle = this.getFaceTriangle(faceTriangleIndex);
-      let sphericalTriangle = this.getSphericalTriangle(faceTriangleIndex, originId2, false);
+      const reflect = this.shouldReflect(polar);
+      let faceTriangle = this.getFaceTriangle(faceTriangleIndex, reflect, false);
+      let sphericalTriangle = this.getSphericalTriangle(faceTriangleIndex, originId2, reflect);
       return this.polyhedral.forward(unprojected, sphericalTriangle, faceTriangle);
     }
     /**
@@ -5527,14 +5569,26 @@ var __exports__ = (() => {
     inverse(face, originId2) {
       const polar = toPolar(face);
       const faceTriangleIndex = this.getFaceTriangleIndex(polar);
-      const [rho, gamma] = polar;
-      const D = toFace([rho, this.normalizeGamma(gamma)])[0];
-      const reflect = D > distanceToEdge;
+      const reflect = this.shouldReflect(polar);
       const faceTriangle = this.getFaceTriangle(faceTriangleIndex, reflect, false);
-      let sphericalTriangle = this.getSphericalTriangle(faceTriangleIndex, originId2, reflect);
+      const sphericalTriangle = this.getSphericalTriangle(faceTriangleIndex, originId2, reflect);
       const unprojected = this.polyhedral.inverse(face, faceTriangle, sphericalTriangle);
       return toSpherical(unprojected);
     }
+    /**
+     * Detects when point is beyond the edge of the dodecahedron face
+     * In the standard case (reflect = false), the face and spherical triangle can be
+     * used directly.
+     * In the reflected case (reflect = true), the point is beyond the edge of the dodecahedron face,
+     * and so the face triangle is squashed to unproject correctly onto the neighboring dodecahedron face.
+     * @param polar Polar coordinates
+     * @returns True if point is beyond the edge of the dodecahedron face
+     */
+    shouldReflect(polar) {
+      const [rho, gamma] = polar;
+      const D2 = toFace([rho, this.normalizeGamma(gamma)])[0];
+      return D2 > distanceToEdge;
+    }
     /**
      * Given a polar coordinate, returns the index of the face triangle it belongs to
      * @param polar Polar coordinates
@@ -5569,12 +5623,12 @@ var __exports__ = (() => {
       return even ? [vCenter, vEdgeMidpoint, vCorner1] : [vCenter, vCorner2, vEdgeMidpoint];
     }
     _getReflectedFaceTriangle(faceTriangleIndex, squashed = false) {
-      let [A, B, C] = this._getFaceTriangle(faceTriangleIndex).map((face) => vec2_exports.clone(face));
+      let [A2, B2, C2] = this._getFaceTriangle(faceTriangleIndex).map((face) => vec2_exports.clone(face));
       const even = faceTriangleIndex % 2 === 0;
-      vec2_exports.negate(A, A);
-      const midpoint = even ? B : C;
-      vec2_exports.scaleAndAdd(A, A, midpoint, squashed ? 1 + 1 / Math.cos(interhedralAngle) : 2);
-      return [A, C, B];
+      vec2_exports.negate(A2, A2);
+      const midpoint = even ? B2 : C2;
+      vec2_exports.scaleAndAdd(A2, A2, midpoint, squashed ? 1 + 1 / Math.cos(interhedralAngle) : 2);
+      return [A2, C2, B2];
     }
     /**
      * Gets the spherical triangle for a given face triangle index and origin
@@ -5692,7 +5746,7 @@ var __exports__ = (() => {
     normalizedBoundary.reverse();
     return normalizedBoundary;
   }
-  function hexToBigInt(hex) {
+  function hexToU64(hex) {
     return BigInt(`0x${hex}`);
   }
   var AUTHALIC_RADIUS = 63710072e-1;
@@ -9813,7 +9867,7 @@ var __exports__ = (() => {
         getPolygon: (x2, objectInfo) => {
           const pentagon = getPentagon(x2, objectInfo);
           const boundary = cellToBoundary(
-            typeof pentagon === "string" ? hexToBigInt(pentagon) : pentagon,
+            typeof pentagon === "string" ? hexToU64(pentagon) : pentagon,
             { closedRing: true, segments: "auto" }
           );
           return flattenPolygon(boundary);
@@ -14291,7 +14345,7 @@ var __exports__ = (() => {
       return this._frameNumber;
     }
     // eslint-disable-next-line complexity
-    isTileVisible(tile, cullRect) {
+    isTileVisible(tile, cullRect, modelMatrix) {
       if (!tile.isVisible) {
         return false;
       }
@@ -14301,12 +14355,19 @@ var __exports__ = (() => {
           z: this._zRange,
           cullRect
         });
-        const { bbox } = tile;
+        let { bbox } = tile;
         for (const [minX, minY, maxX, maxY] of boundsArr) {
           let overlaps;
           if ("west" in bbox) {
             overlaps = bbox.west < maxX && bbox.east > minX && bbox.south < maxY && bbox.north > minY;
           } else {
+            if (modelMatrix && !Matrix4.IDENTITY.equals(modelMatrix)) {
+              const [left, top, right, bottom] = transformBox(
+                [bbox.left, bbox.top, bbox.right, bbox.bottom],
+                modelMatrix
+              );
+              bbox = { left, top, right, bottom };
+            }
             const y0 = Math.min(bbox.top, bbox.bottom);
             const y1 = Math.max(bbox.top, bbox.bottom);
             overlaps = bbox.left < maxX && bbox.right > minX && y0 < maxY && y1 > minY;
@@ -14736,7 +14797,12 @@ var __exports__ = (() => {
     }
     filterSubLayer({ layer, cullRect }) {
       const { tile } = layer.props;
-      return this.state.tileset.isTileVisible(tile, cullRect);
+      const { modelMatrix } = this.props;
+      return this.state.tileset.isTileVisible(
+        tile,
+        cullRect,
+        modelMatrix ? new Matrix4(modelMatrix) : null
+      );
     }
   };
   TileLayer.defaultProps = defaultProps7;
@@ -14828,11 +14894,11 @@ out float vTime;
 
   // src/h3-layers/h3-cluster-layer.ts
   var import_h3_js3 = __toESM(require_h3_js(), 1);
-  var import_core17 = __toESM(require_core(), 1);
+  var import_core18 = __toESM(require_core(), 1);
 
   // src/h3-layers/h3-hexagon-layer.ts
   var import_h3_js2 = __toESM(require_h3_js(), 1);
-  var import_core16 = __toESM(require_core(), 1);
+  var import_core17 = __toESM(require_core(), 1);
   var import_layers7 = __toESM(require_layers(), 1);
   var UPDATE_THRESHOLD_KM = 10;
   function mergeTriggers(getHexagon, coverage) {
@@ -14854,7 +14920,7 @@ out float vTime;
     getHexagon: { type: "accessor", value: (x2) => x2.hexagon },
     extruded: true
   };
-  var _H3HexagonLayer = class extends import_core16.CompositeLayer {
+  var _H3HexagonLayer = class extends import_core17.CompositeLayer {
     initializeState() {
       _H3HexagonLayer._checkH3Lib();
       this.state = {
@@ -14876,7 +14942,7 @@ out float vTime;
       let resolution = -1;
       let hasPentagon = false;
       let hasMultipleRes = false;
-      const { iterable, objectInfo } = (0, import_core16.createIterable)(this.props.data);
+      const { iterable, objectInfo } = (0, import_core17.createIterable)(this.props.data);
       for (const object of iterable) {
         objectInfo.index++;
         const hexId = this.props.getHexagon(object, objectInfo);
@@ -15056,7 +15122,7 @@ out float vTime;
       if (changeFlags.dataChanged || changeFlags.updateTriggersChanged && changeFlags.updateTriggersChanged.getHexagons) {
         const { data, getHexagons } = props;
         const polygons = [];
-        const { iterable, objectInfo } = (0, import_core17.createIterable)(data);
+        const { iterable, objectInfo } = (0, import_core18.createIterable)(data);
         for (const object of iterable) {
           objectInfo.index++;
           const hexagons = getHexagons(object, objectInfo);
@@ -15088,7 +15154,7 @@ out float vTime;
 
   // src/tile-3d-layer/tile-3d-layer.ts
   var import_engine2 = __toESM(require_engine(), 1);
-  var import_core53 = __toESM(require_core(), 1);
+  var import_core54 = __toESM(require_core(), 1);
   var import_layers8 = __toESM(require_layers(), 1);
   var import_mesh_layers2 = __toESM(require_mesh_layers(), 1);
 
@@ -15566,7 +15632,7 @@ out float vTime;
   };
 
   // ../../node_modules/@luma.gl/gltf/dist/parsers/parse-pbr-material.js
-  var import_core18 = __toESM(require_core2(), 1);
+  var import_core19 = __toESM(require_core2(), 1);
 
   // ../../node_modules/@luma.gl/gltf/dist/webgl-to-webgpu/convert-webgl-sampler.js
   function convertSampler(gltfSampler) {
@@ -15692,7 +15758,7 @@ out float vTime;
         parsedMaterial.uniforms.alphaCutoff = alphaCutoff;
         break;
       case "BLEND":
-        import_core18.log.warn("glTF BLEND alphaMode might not work well because it requires mesh sorting")();
+        import_core19.log.warn("glTF BLEND alphaMode might not work well because it requires mesh sorting")();
         parsedMaterial.parameters.blend = true;
         parsedMaterial.parameters.blendColorOperation = "add";
         parsedMaterial.parameters.blendColorSrcFactor = "src-alpha";
@@ -15749,7 +15815,7 @@ out float vTime;
   }
 
   // ../../node_modules/@luma.gl/shadertools/dist/modules/lighting/lights/lighting.js
-  var import_core19 = __toESM(require_core2(), 1);
+  var import_core20 = __toESM(require_core2(), 1);
 
   // ../../node_modules/@luma.gl/shadertools/dist/modules/lighting/lights/lighting-glsl.js
   var lightingUniformsGLSL = (
@@ -15992,7 +16058,7 @@ fn getPointLightAttenuation(pointLight: PointLight, distance: f32) -> f32 {
       currentLight++;
     }
     if (currentLight > MAX_LIGHTS) {
-      import_core19.log.warn("MAX_LIGHTS exceeded")();
+      import_core20.log.warn("MAX_LIGHTS exceeded")();
     }
     lightSourceUniforms.directionalLightCount = directionalLights.length;
     lightSourceUniforms.pointLightCount = pointLights.length;
@@ -17248,7 +17314,7 @@ void main(void) {
   MeshLayer.defaultProps = defaultProps11;
 
   // src/tile-3d-layer/tile-3d-layer.ts
-  var import_core54 = __toESM(require_core3(), 1);
+  var import_core55 = __toESM(require_core3(), 1);
 
   // ../../node_modules/@loaders.gl/tiles/node_modules/@math.gl/core/dist/lib/common.js
   var RADIANS_TO_DEGREES3 = 1 / Math.PI * 180;
@@ -27675,7 +27741,7 @@ void main(void) {
   }
 
   // ../../node_modules/@loaders.gl/tiles/dist/tileset/tile-3d.js
-  var import_core40 = __toESM(require_core3(), 1);
+  var import_core41 = __toESM(require_core3(), 1);
 
   // ../../node_modules/@loaders.gl/tiles/dist/constants.js
   var TILE_CONTENT_STATE = {
@@ -28643,7 +28709,7 @@ void main(void) {
             ...this._getLoaderSpecificOptions(loader.id)
           }
         };
-        this.content = await (0, import_core40.load)(contentUrl, loader, options);
+        this.content = await (0, import_core41.load)(contentUrl, loader, options);
         if (this.tileset.options.contentLoader) {
           await this.tileset.options.contentLoader(this);
         }
@@ -28926,7 +28992,7 @@ void main(void) {
   };
 
   // ../../node_modules/@loaders.gl/tiles/dist/tileset/format-i3s/i3s-tileset-traverser.js
-  var import_core41 = __toESM(require_core3(), 1);
+  var import_core42 = __toESM(require_core3(), 1);
 
   // ../../node_modules/@loaders.gl/tiles/dist/tileset/format-i3s/i3s-pending-tiles-register.js
   var I3SPendingTilesRegister = class {
@@ -29090,7 +29156,7 @@ void main(void) {
           isTileHeader: true
         }
       };
-      return await (0, import_core41.load)(nodeUrl, loader, options);
+      return await (0, import_core42.load)(nodeUrl, loader, options);
     }
     /**
      * The callback to init Tile3D instance after loading the tile JSON
@@ -40357,10 +40423,10 @@ void main(void) {
   };
 
   // ../../node_modules/@loaders.gl/3d-tiles/dist/lib/parsers/parse-3d-tile-header.js
-  var import_core52 = __toESM(require_core3(), 1);
+  var import_core53 = __toESM(require_core3(), 1);
 
   // ../../node_modules/@loaders.gl/3d-tiles/dist/lib/parsers/helpers/parse-3d-implicit-tiles.js
-  var import_core51 = __toESM(require_core3(), 1);
+  var import_core52 = __toESM(require_core3(), 1);
 
   // ../../node_modules/@loaders.gl/3d-tiles/node_modules/long/index.js
   var wasm = null;
@@ -41522,16 +41588,16 @@ void main(void) {
     const region = getS2Region(s2cell);
     const W2 = region.west;
     const S = region.south;
-    const E = region.east;
+    const E2 = region.east;
     const N = region.north;
     const points = [];
     points.push(new Vector36(W2, N, min4));
-    points.push(new Vector36(E, N, min4));
-    points.push(new Vector36(E, S, min4));
+    points.push(new Vector36(E2, N, min4));
+    points.push(new Vector36(E2, S, min4));
     points.push(new Vector36(W2, S, min4));
     points.push(new Vector36(W2, N, max4));
-    points.push(new Vector36(E, N, max4));
-    points.push(new Vector36(E, S, max4));
+    points.push(new Vector36(E2, N, max4));
+    points.push(new Vector36(E2, S, max4));
     points.push(new Vector36(W2, S, max4));
     return points;
   }
@@ -41639,7 +41705,7 @@ void main(void) {
     if (isChildSubtreeAvailable) {
       const subtreePath = `${basePath}/${subtreesUriTemplate}`;
       const childSubtreeUrl = replaceContentUrlTemplate(subtreePath, lev, x2, y2, z);
-      const childSubtree = await (0, import_core51.load)(childSubtreeUrl, Tile3DSubtreeLoader, loaderOptions);
+      const childSubtree = await (0, import_core52.load)(childSubtreeUrl, Tile3DSubtreeLoader, loaderOptions);
       subtree = childSubtree;
       globalData = {
         mortonIndex: childTileMortonIndex,
@@ -41867,7 +41933,7 @@ void main(void) {
     const { subdivisionScheme, maximumLevel, availableLevels, subtreeLevels, subtrees: { uri: subtreesUriTemplate } } = implicitTilingExtension;
     const replacedUrlTemplate = replaceContentUrlTemplate(subtreesUriTemplate, 0, 0, 0, 0);
     const subtreeUrl = resolveUri(replacedUrlTemplate, basePath);
-    const subtree = await (0, import_core52.load)(subtreeUrl, Tile3DSubtreeLoader, options);
+    const subtree = await (0, import_core53.load)(subtreeUrl, Tile3DSubtreeLoader, options);
     const tileContentUri = tile.content?.uri;
     const contentUrlTemplate = tileContentUri ? resolveUri(tileContentUri, basePath) : "";
     const refine = tileset?.root?.refine;
@@ -42011,10 +42077,10 @@ void main(void) {
     } },
     _getMeshColor: { type: "function", value: (tileHeader) => [255, 255, 255] }
   };
-  var Tile3DLayer = class extends import_core53.CompositeLayer {
+  var Tile3DLayer = class extends import_core54.CompositeLayer {
     initializeState() {
       if ("onTileLoadFail" in this.props) {
-        import_core53.log.removed("onTileLoadFail", "onTileError")();
+        import_core54.log.removed("onTileLoadFail", "onTileError")();
       }
       this.state = {
         layerMap: {},
@@ -42098,7 +42164,7 @@ void main(void) {
         }
         Object.assign(options, preloadOptions);
       }
-      const tilesetJson = await (0, import_core54.load)(actualTilesetUrl, loader, options.loadOptions);
+      const tilesetJson = await (0, import_core55.load)(actualTilesetUrl, loader, options.loadOptions);
       const tileset3d = new Tileset3D(tilesetJson, {
         onTileLoad: this._onTileLoad.bind(this),
         onTileUnload: this._onTileUnload.bind(this),
@@ -42183,7 +42249,7 @@ void main(void) {
           id: `${this.id}-pointcloud-${tileHeader.id}`,
           tile: tileHeader,
           data,
-          coordinateSystem: import_core53.COORDINATE_SYSTEM.METER_OFFSETS,
+          coordinateSystem: import_core54.COORDINATE_SYSTEM.METER_OFFSETS,
           coordinateOrigin: cartographicOrigin,
           modelMatrix,
           getColor: constantRGBA || getPointColor,
@@ -42206,7 +42272,7 @@ void main(void) {
           tile: tileHeader,
           data: instances || SINGLE_DATA,
           scenegraph: gltf,
-          coordinateSystem: import_core53.COORDINATE_SYSTEM.METER_OFFSETS,
+          coordinateSystem: import_core54.COORDINATE_SYSTEM.METER_OFFSETS,
           coordinateOrigin: cartographicOrigin,
           modelMatrix,
           getTransformMatrix: (instance) => instance.modelMatrix,
@@ -42222,7 +42288,7 @@ void main(void) {
         indices,
         modelMatrix,
         cartographicOrigin,
-        coordinateSystem = import_core53.COORDINATE_SYSTEM.METER_OFFSETS,
+        coordinateSystem = import_core54.COORDINATE_SYSTEM.METER_OFFSETS,
         material,
         featureIds
       } = content;
@@ -42297,9 +42363,9 @@ void main(void) {
   }
 
   // src/terrain-layer/terrain-layer.ts
-  var import_core55 = __toESM(require_core(), 1);
-  var import_mesh_layers3 = __toESM(require_mesh_layers(), 1);
   var import_core56 = __toESM(require_core(), 1);
+  var import_mesh_layers3 = __toESM(require_mesh_layers(), 1);
+  var import_core57 = __toESM(require_core(), 1);
 
   // ../../node_modules/@loaders.gl/terrain/dist/lib/decode-quantized-mesh.js
   var QUANTIZED_MESH_HEADER = /* @__PURE__ */ new Map([
@@ -43367,7 +43433,7 @@ void main(void) {
     }
     return template || "";
   }
-  var TerrainLayer = class extends import_core55.CompositeLayer {
+  var TerrainLayer = class extends import_core56.CompositeLayer {
     updateState({ props, oldProps }) {
       const elevationDataChanged = props.elevationData !== oldProps.elevationData;
       if (elevationDataChanged) {
@@ -43381,7 +43447,7 @@ void main(void) {
         this.setState({ terrain });
       }
       if (props.workerUrl) {
-        import_core55.log.removed("workerUrl", "loadOptions.terrain.workerUrl")();
+        import_core56.log.removed("workerUrl", "loadOptions.terrain.workerUrl")();
       }
     }
     loadTerrain({
@@ -43452,7 +43518,7 @@ void main(void) {
         mesh,
         texture,
         _instanced: false,
-        coordinateSystem: import_core56.COORDINATE_SYSTEM.CARTESIAN,
+        coordinateSystem: import_core57.COORDINATE_SYSTEM.CARTESIAN,
         getPosition: (d2) => [0, 0, 0],
         getColor: color,
         wireframe,
@@ -43557,7 +43623,7 @@ void main(void) {
   var isTileSetURL = (url) => url.includes("{x}") && (url.includes("{y}") || url.includes("{-y}"));
 
   // src/mvt-layer/mvt-layer.ts
-  var import_core58 = __toESM(require_core(), 1);
+  var import_core59 = __toESM(require_core(), 1);
   var import_layers9 = __toESM(require_layers(), 1);
   var import_extensions = __toESM(require_extensions(), 1);
 
@@ -45478,12 +45544,12 @@ void main(void) {
       if (!this.context.viewport.resolution) {
         props.modelMatrix = modelMatrix;
         props.coordinateOrigin = [xOffset, yOffset, 0];
-        props.coordinateSystem = import_core58.COORDINATE_SYSTEM.CARTESIAN;
+        props.coordinateSystem = import_core59.COORDINATE_SYSTEM.CARTESIAN;
         props.extensions = [...props.extensions || [], new import_extensions.ClipExtension()];
       }
       const subLayers = super.renderSubLayers(props);
       if (this.state.binary && !(subLayers instanceof import_layers9.GeoJsonLayer)) {
-        import_core58.log.warn("renderSubLayers() must return GeoJsonLayer when using binary:true")();
+        import_core59.log.warn("renderSubLayers() must return GeoJsonLayer when using binary:true")();
       }
       return subLayers;
     }