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

package/dist/dist.dev.js

@@ -3224,11 +3224,11 @@ var __exports__ = (() => {
     ARRAY_TYPE = type;
   }
   var degree = Math.PI / 180;
-  function toRadian(a3) {
-    return a3 * degree;
+  function toRadian(a22) {
+    return a22 * degree;
   }
-  function equals(a3, b2) {
-    return Math.abs(a3 - b2) <= EPSILON * Math.max(1, Math.abs(a3), Math.abs(b2));
+  function equals(a22, b2) {
+    return Math.abs(a22 - b2) <= EPSILON * Math.max(1, Math.abs(a22), Math.abs(b2));
   }
   if (!Math.hypot)
     Math.hypot = function() {
@@ -3277,19 +3277,19 @@ var __exports__ = (() => {
     out[3] = 1;
     return out;
   }
-  function clone(a3) {
+  function clone(a22) {
     var out = new ARRAY_TYPE(4);
-    out[0] = a3[0];
-    out[1] = a3[1];
-    out[2] = a3[2];
-    out[3] = a3[3];
+    out[0] = a22[0];
+    out[1] = a22[1];
+    out[2] = a22[2];
+    out[3] = a22[3];
     return out;
   }
-  function copy(out, a3) {
-    out[0] = a3[0];
-    out[1] = a3[1];
-    out[2] = a3[2];
-    out[3] = a3[3];
+  function copy(out, a22) {
+    out[0] = a22[0];
+    out[1] = a22[1];
+    out[2] = a22[2];
+    out[3] = a22[3];
     return out;
   }
   function identity(out) {
@@ -3314,69 +3314,69 @@ var __exports__ = (() => {
     out[3] = m11;
     return out;
   }
-  function transpose(out, a3) {
-    if (out === a3) {
-      var a1 = a3[1];
-      out[1] = a3[2];
+  function transpose(out, a22) {
+    if (out === a22) {
+      var a1 = a22[1];
+      out[1] = a22[2];
       out[2] = a1;
     } else {
-      out[0] = a3[0];
-      out[1] = a3[2];
-      out[2] = a3[1];
-      out[3] = a3[3];
+      out[0] = a22[0];
+      out[1] = a22[2];
+      out[2] = a22[1];
+      out[3] = a22[3];
     }
     return out;
   }
-  function invert(out, a3) {
-    var a0 = a3[0], a1 = a3[1], a22 = a3[2], a32 = a3[3];
-    var det = a0 * a32 - a22 * a1;
+  function invert(out, a22) {
+    var a0 = a22[0], a1 = a22[1], a222 = a22[2], a3 = a22[3];
+    var det = a0 * a3 - a222 * a1;
     if (!det) {
       return null;
     }
     det = 1 / det;
-    out[0] = a32 * det;
+    out[0] = a3 * det;
     out[1] = -a1 * det;
-    out[2] = -a22 * det;
+    out[2] = -a222 * det;
     out[3] = a0 * det;
     return out;
   }
-  function adjoint(out, a3) {
-    var a0 = a3[0];
-    out[0] = a3[3];
-    out[1] = -a3[1];
-    out[2] = -a3[2];
+  function adjoint(out, a22) {
+    var a0 = a22[0];
+    out[0] = a22[3];
+    out[1] = -a22[1];
+    out[2] = -a22[2];
     out[3] = a0;
     return out;
   }
-  function determinant(a3) {
-    return a3[0] * a3[3] - a3[2] * a3[1];
+  function determinant(a22) {
+    return a22[0] * a22[3] - a22[2] * a22[1];
   }
-  function multiply(out, a3, b2) {
-    var a0 = a3[0], a1 = a3[1], a22 = a3[2], a32 = a3[3];
+  function multiply(out, a22, b2) {
+    var a0 = a22[0], a1 = a22[1], a222 = a22[2], a3 = a22[3];
     var b0 = b2[0], b1 = b2[1], b22 = b2[2], b3 = b2[3];
-    out[0] = a0 * b0 + a22 * b1;
-    out[1] = a1 * b0 + a32 * b1;
-    out[2] = a0 * b22 + a22 * b3;
-    out[3] = a1 * b22 + a32 * b3;
+    out[0] = a0 * b0 + a222 * b1;
+    out[1] = a1 * b0 + a3 * b1;
+    out[2] = a0 * b22 + a222 * b3;
+    out[3] = a1 * b22 + a3 * b3;
     return out;
   }
-  function rotate(out, a3, rad) {
-    var a0 = a3[0], a1 = a3[1], a22 = a3[2], a32 = a3[3];
+  function rotate(out, a22, rad) {
+    var a0 = a22[0], a1 = a22[1], a222 = a22[2], a3 = a22[3];
     var s2 = Math.sin(rad);
     var c2 = Math.cos(rad);
-    out[0] = a0 * c2 + a22 * s2;
-    out[1] = a1 * c2 + a32 * s2;
-    out[2] = a0 * -s2 + a22 * c2;
-    out[3] = a1 * -s2 + a32 * c2;
+    out[0] = a0 * c2 + a222 * s2;
+    out[1] = a1 * c2 + a3 * s2;
+    out[2] = a0 * -s2 + a222 * c2;
+    out[3] = a1 * -s2 + a3 * c2;
     return out;
   }
-  function scale(out, a3, v2) {
-    var a0 = a3[0], a1 = a3[1], a22 = a3[2], a32 = a3[3];
+  function scale(out, a22, v2) {
+    var a0 = a22[0], a1 = a22[1], a222 = a22[2], a3 = a22[3];
     var v0 = v2[0], v1 = v2[1];
     out[0] = a0 * v0;
     out[1] = a1 * v0;
-    out[2] = a22 * v1;
-    out[3] = a32 * v1;
+    out[2] = a222 * v1;
+    out[3] = a3 * v1;
     return out;
   }
   function fromRotation(out, rad) {
@@ -3395,53 +3395,53 @@ var __exports__ = (() => {
     out[3] = v2[1];
     return out;
   }
-  function str(a3) {
-    return "mat2(" + a3[0] + ", " + a3[1] + ", " + a3[2] + ", " + a3[3] + ")";
+  function str(a22) {
+    return "mat2(" + a22[0] + ", " + a22[1] + ", " + a22[2] + ", " + a22[3] + ")";
   }
-  function frob(a3) {
-    return Math.hypot(a3[0], a3[1], a3[2], a3[3]);
+  function frob(a22) {
+    return Math.hypot(a22[0], a22[1], a22[2], a22[3]);
   }
-  function LDU(L2, D, U, a3) {
-    L2[2] = a3[2] / a3[0];
-    U[0] = a3[0];
-    U[1] = a3[1];
-    U[3] = a3[3] - L2[2] * U[1];
+  function LDU(L2, D, 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];
   }
-  function add(out, a3, b2) {
-    out[0] = a3[0] + b2[0];
-    out[1] = a3[1] + b2[1];
-    out[2] = a3[2] + b2[2];
-    out[3] = a3[3] + b2[3];
+  function add(out, a22, b2) {
+    out[0] = a22[0] + b2[0];
+    out[1] = a22[1] + b2[1];
+    out[2] = a22[2] + b2[2];
+    out[3] = a22[3] + b2[3];
     return out;
   }
-  function subtract(out, a3, b2) {
-    out[0] = a3[0] - b2[0];
-    out[1] = a3[1] - b2[1];
-    out[2] = a3[2] - b2[2];
-    out[3] = a3[3] - b2[3];
+  function subtract(out, a22, b2) {
+    out[0] = a22[0] - b2[0];
+    out[1] = a22[1] - b2[1];
+    out[2] = a22[2] - b2[2];
+    out[3] = a22[3] - b2[3];
     return out;
   }
-  function exactEquals(a3, b2) {
-    return a3[0] === b2[0] && a3[1] === b2[1] && a3[2] === b2[2] && a3[3] === b2[3];
+  function exactEquals(a22, b2) {
+    return a22[0] === b2[0] && a22[1] === b2[1] && a22[2] === b2[2] && a22[3] === b2[3];
   }
-  function equals2(a3, b2) {
-    var a0 = a3[0], a1 = a3[1], a22 = a3[2], a32 = a3[3];
+  function equals2(a22, b2) {
+    var a0 = a22[0], a1 = a22[1], a222 = a22[2], a3 = a22[3];
     var b0 = b2[0], b1 = b2[1], b22 = b2[2], b3 = b2[3];
-    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(a22 - b22) <= EPSILON * Math.max(1, Math.abs(a22), Math.abs(b22)) && Math.abs(a32 - b3) <= EPSILON * Math.max(1, Math.abs(a32), Math.abs(b3));
+    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(a222 - b22) <= EPSILON * Math.max(1, Math.abs(a222), Math.abs(b22)) && Math.abs(a3 - b3) <= EPSILON * Math.max(1, Math.abs(a3), Math.abs(b3));
   }
-  function multiplyScalar(out, a3, b2) {
-    out[0] = a3[0] * b2;
-    out[1] = a3[1] * b2;
-    out[2] = a3[2] * b2;
-    out[3] = a3[3] * b2;
+  function multiplyScalar(out, a22, b2) {
+    out[0] = a22[0] * b2;
+    out[1] = a22[1] * b2;
+    out[2] = a22[2] * b2;
+    out[3] = a22[3] * b2;
     return out;
   }
-  function multiplyScalarAndAdd(out, a3, b2, scale72) {
-    out[0] = a3[0] + b2[0] * scale72;
-    out[1] = a3[1] + b2[1] * scale72;
-    out[2] = a3[2] + b2[2] * scale72;
-    out[3] = a3[3] + b2[3] * scale72;
+  function multiplyScalarAndAdd(out, a22, b2, scale72) {
+    out[0] = a22[0] + b2[0] * scale72;
+    out[1] = a22[1] + b2[1] * scale72;
+    out[2] = a22[2] + b2[2] * scale72;
+    out[3] = a22[3] + b2[3] * scale72;
     return out;
   }
   var mul = multiply;
@@ -3563,17 +3563,17 @@ var __exports__ = (() => {
     }
     return out;
   }
-  function clone2(a3) {
+  function clone2(a22) {
     var out = new ARRAY_TYPE(3);
-    out[0] = a3[0];
-    out[1] = a3[1];
-    out[2] = a3[2];
+    out[0] = a22[0];
+    out[1] = a22[1];
+    out[2] = a22[2];
     return out;
   }
-  function length(a3) {
-    var x2 = a3[0];
-    var y2 = a3[1];
-    var z = a3[2];
+  function length(a22) {
+    var x2 = a22[0];
+    var y2 = a22[1];
+    var z = a22[2];
     return Math.hypot(x2, y2, z);
   }
   function fromValues2(x2, y2, z) {
@@ -3583,10 +3583,10 @@ var __exports__ = (() => {
     out[2] = z;
     return out;
   }
-  function copy2(out, a3) {
-    out[0] = a3[0];
-    out[1] = a3[1];
-    out[2] = a3[2];
+  function copy2(out, a22) {
+    out[0] = a22[0];
+    out[1] = a22[1];
+    out[2] = a22[2];
     return out;
   }
   function set2(out, x2, y2, z) {
@@ -3595,147 +3595,147 @@ var __exports__ = (() => {
     out[2] = z;
     return out;
   }
-  function add2(out, a3, b2) {
-    out[0] = a3[0] + b2[0];
-    out[1] = a3[1] + b2[1];
-    out[2] = a3[2] + b2[2];
+  function add2(out, a22, b2) {
+    out[0] = a22[0] + b2[0];
+    out[1] = a22[1] + b2[1];
+    out[2] = a22[2] + b2[2];
     return out;
   }
-  function subtract2(out, a3, b2) {
-    out[0] = a3[0] - b2[0];
-    out[1] = a3[1] - b2[1];
-    out[2] = a3[2] - b2[2];
+  function subtract2(out, a22, b2) {
+    out[0] = a22[0] - b2[0];
+    out[1] = a22[1] - b2[1];
+    out[2] = a22[2] - b2[2];
     return out;
   }
-  function multiply2(out, a3, b2) {
-    out[0] = a3[0] * b2[0];
-    out[1] = a3[1] * b2[1];
-    out[2] = a3[2] * b2[2];
+  function multiply2(out, a22, b2) {
+    out[0] = a22[0] * b2[0];
+    out[1] = a22[1] * b2[1];
+    out[2] = a22[2] * b2[2];
     return out;
   }
-  function divide(out, a3, b2) {
-    out[0] = a3[0] / b2[0];
-    out[1] = a3[1] / b2[1];
-    out[2] = a3[2] / b2[2];
+  function divide(out, a22, b2) {
+    out[0] = a22[0] / b2[0];
+    out[1] = a22[1] / b2[1];
+    out[2] = a22[2] / b2[2];
     return out;
   }
-  function ceil(out, a3) {
-    out[0] = Math.ceil(a3[0]);
-    out[1] = Math.ceil(a3[1]);
-    out[2] = Math.ceil(a3[2]);
+  function ceil(out, a22) {
+    out[0] = Math.ceil(a22[0]);
+    out[1] = Math.ceil(a22[1]);
+    out[2] = Math.ceil(a22[2]);
     return out;
   }
-  function floor(out, a3) {
-    out[0] = Math.floor(a3[0]);
-    out[1] = Math.floor(a3[1]);
-    out[2] = Math.floor(a3[2]);
+  function floor(out, a22) {
+    out[0] = Math.floor(a22[0]);
+    out[1] = Math.floor(a22[1]);
+    out[2] = Math.floor(a22[2]);
     return out;
   }
-  function min(out, a3, b2) {
-    out[0] = Math.min(a3[0], b2[0]);
-    out[1] = Math.min(a3[1], b2[1]);
-    out[2] = Math.min(a3[2], b2[2]);
+  function min(out, a22, b2) {
+    out[0] = Math.min(a22[0], b2[0]);
+    out[1] = Math.min(a22[1], b2[1]);
+    out[2] = Math.min(a22[2], b2[2]);
     return out;
   }
-  function max(out, a3, b2) {
-    out[0] = Math.max(a3[0], b2[0]);
-    out[1] = Math.max(a3[1], b2[1]);
-    out[2] = Math.max(a3[2], b2[2]);
+  function max(out, a22, b2) {
+    out[0] = Math.max(a22[0], b2[0]);
+    out[1] = Math.max(a22[1], b2[1]);
+    out[2] = Math.max(a22[2], b2[2]);
     return out;
   }
-  function round(out, a3) {
-    out[0] = Math.round(a3[0]);
-    out[1] = Math.round(a3[1]);
-    out[2] = Math.round(a3[2]);
+  function round(out, a22) {
+    out[0] = Math.round(a22[0]);
+    out[1] = Math.round(a22[1]);
+    out[2] = Math.round(a22[2]);
     return out;
   }
-  function scale2(out, a3, b2) {
-    out[0] = a3[0] * b2;
-    out[1] = a3[1] * b2;
-    out[2] = a3[2] * b2;
+  function scale2(out, a22, b2) {
+    out[0] = a22[0] * b2;
+    out[1] = a22[1] * b2;
+    out[2] = a22[2] * b2;
     return out;
   }
-  function scaleAndAdd(out, a3, b2, scale72) {
-    out[0] = a3[0] + b2[0] * scale72;
-    out[1] = a3[1] + b2[1] * scale72;
-    out[2] = a3[2] + b2[2] * scale72;
+  function scaleAndAdd(out, a22, b2, scale72) {
+    out[0] = a22[0] + b2[0] * scale72;
+    out[1] = a22[1] + b2[1] * scale72;
+    out[2] = a22[2] + b2[2] * scale72;
     return out;
   }
-  function distance(a3, b2) {
-    var x2 = b2[0] - a3[0];
-    var y2 = b2[1] - a3[1];
-    var z = b2[2] - a3[2];
+  function distance(a22, b2) {
+    var x2 = b2[0] - a22[0];
+    var y2 = b2[1] - a22[1];
+    var z = b2[2] - a22[2];
     return Math.hypot(x2, y2, z);
   }
-  function squaredDistance(a3, b2) {
-    var x2 = b2[0] - a3[0];
-    var y2 = b2[1] - a3[1];
-    var z = b2[2] - a3[2];
+  function squaredDistance(a22, b2) {
+    var x2 = b2[0] - a22[0];
+    var y2 = b2[1] - a22[1];
+    var z = b2[2] - a22[2];
     return x2 * x2 + y2 * y2 + z * z;
   }
-  function squaredLength(a3) {
-    var x2 = a3[0];
-    var y2 = a3[1];
-    var z = a3[2];
+  function squaredLength(a22) {
+    var x2 = a22[0];
+    var y2 = a22[1];
+    var z = a22[2];
     return x2 * x2 + y2 * y2 + z * z;
   }
-  function negate(out, a3) {
-    out[0] = -a3[0];
-    out[1] = -a3[1];
-    out[2] = -a3[2];
+  function negate(out, a22) {
+    out[0] = -a22[0];
+    out[1] = -a22[1];
+    out[2] = -a22[2];
     return out;
   }
-  function inverse(out, a3) {
-    out[0] = 1 / a3[0];
-    out[1] = 1 / a3[1];
-    out[2] = 1 / a3[2];
+  function inverse(out, a22) {
+    out[0] = 1 / a22[0];
+    out[1] = 1 / a22[1];
+    out[2] = 1 / a22[2];
     return out;
   }
-  function normalize(out, a3) {
-    var x2 = a3[0];
-    var y2 = a3[1];
-    var z = a3[2];
+  function normalize(out, a22) {
+    var x2 = a22[0];
+    var y2 = a22[1];
+    var z = a22[2];
     var len42 = x2 * x2 + y2 * y2 + z * z;
     if (len42 > 0) {
       len42 = 1 / Math.sqrt(len42);
     }
-    out[0] = a3[0] * len42;
-    out[1] = a3[1] * len42;
-    out[2] = a3[2] * len42;
+    out[0] = a22[0] * len42;
+    out[1] = a22[1] * len42;
+    out[2] = a22[2] * len42;
     return out;
   }
-  function dot(a3, b2) {
-    return a3[0] * b2[0] + a3[1] * b2[1] + a3[2] * b2[2];
+  function dot(a22, b2) {
+    return a22[0] * b2[0] + a22[1] * b2[1] + a22[2] * b2[2];
   }
-  function cross(out, a3, b2) {
-    var ax = a3[0], ay = a3[1], az = a3[2];
+  function cross(out, a22, b2) {
+    var ax = a22[0], ay = a22[1], az = a22[2];
     var bx = b2[0], by = b2[1], bz = b2[2];
     out[0] = ay * bz - az * by;
     out[1] = az * bx - ax * bz;
     out[2] = ax * by - ay * bx;
     return out;
   }
-  function lerp(out, a3, b2, t2) {
-    var ax = a3[0];
-    var ay = a3[1];
-    var az = a3[2];
+  function lerp(out, a22, b2, t2) {
+    var ax = a22[0];
+    var ay = a22[1];
+    var az = a22[2];
     out[0] = ax + t2 * (b2[0] - ax);
     out[1] = ay + t2 * (b2[1] - ay);
     out[2] = az + t2 * (b2[2] - az);
     return out;
   }
-  function hermite(out, a3, b2, c2, d2, t2) {
+  function hermite(out, a22, b2, c2, d2, t2) {
     var factorTimes2 = t2 * t2;
     var factor1 = factorTimes2 * (2 * t2 - 3) + 1;
     var factor2 = factorTimes2 * (t2 - 2) + t2;
     var factor3 = factorTimes2 * (t2 - 1);
     var factor4 = factorTimes2 * (3 - 2 * t2);
-    out[0] = a3[0] * factor1 + b2[0] * factor2 + c2[0] * factor3 + d2[0] * factor4;
-    out[1] = a3[1] * factor1 + b2[1] * factor2 + c2[1] * factor3 + d2[1] * factor4;
-    out[2] = a3[2] * factor1 + b2[2] * factor2 + c2[2] * factor3 + d2[2] * factor4;
+    out[0] = a22[0] * factor1 + b2[0] * factor2 + c2[0] * factor3 + d2[0] * factor4;
+    out[1] = a22[1] * factor1 + b2[1] * factor2 + c2[1] * factor3 + d2[1] * factor4;
+    out[2] = a22[2] * factor1 + b2[2] * factor2 + c2[2] * factor3 + d2[2] * factor4;
     return out;
   }
-  function bezier(out, a3, b2, c2, d2, t2) {
+  function bezier(out, a22, b2, c2, d2, t2) {
     var inverseFactor = 1 - t2;
     var inverseFactorTimesTwo = inverseFactor * inverseFactor;
     var factorTimes2 = t2 * t2;
@@ -3743,9 +3743,9 @@ var __exports__ = (() => {
     var factor2 = 3 * t2 * inverseFactorTimesTwo;
     var factor3 = 3 * factorTimes2 * inverseFactor;
     var factor4 = factorTimes2 * t2;
-    out[0] = a3[0] * factor1 + b2[0] * factor2 + c2[0] * factor3 + d2[0] * factor4;
-    out[1] = a3[1] * factor1 + b2[1] * factor2 + c2[1] * factor3 + d2[1] * factor4;
-    out[2] = a3[2] * factor1 + b2[2] * factor2 + c2[2] * factor3 + d2[2] * factor4;
+    out[0] = a22[0] * factor1 + b2[0] * factor2 + c2[0] * factor3 + d2[0] * factor4;
+    out[1] = a22[1] * factor1 + b2[1] * factor2 + c2[1] * factor3 + d2[1] * factor4;
+    out[2] = a22[2] * factor1 + b2[2] * factor2 + c2[2] * factor3 + d2[2] * factor4;
     return out;
   }
   function random(out, scale72) {
@@ -3758,8 +3758,8 @@ var __exports__ = (() => {
     out[2] = z * scale72;
     return out;
   }
-  function transformMat4(out, a3, m) {
-    var x2 = a3[0], y2 = a3[1], z = a3[2];
+  function transformMat4(out, a22, m) {
+    var x2 = a22[0], y2 = a22[1], z = a22[2];
     var w2 = m[3] * x2 + m[7] * y2 + m[11] * z + m[15];
     w2 = w2 || 1;
     out[0] = (m[0] * x2 + m[4] * y2 + m[8] * z + m[12]) / w2;
@@ -3767,16 +3767,16 @@ var __exports__ = (() => {
     out[2] = (m[2] * x2 + m[6] * y2 + m[10] * z + m[14]) / w2;
     return out;
   }
-  function transformMat3(out, a3, m) {
-    var x2 = a3[0], y2 = a3[1], z = a3[2];
+  function transformMat3(out, a22, m) {
+    var x2 = a22[0], y2 = a22[1], z = a22[2];
     out[0] = x2 * m[0] + y2 * m[3] + z * m[6];
     out[1] = x2 * m[1] + y2 * m[4] + z * m[7];
     out[2] = x2 * m[2] + y2 * m[5] + z * m[8];
     return out;
   }
-  function transformQuat(out, a3, q) {
+  function transformQuat(out, a22, q) {
     var qx = q[0], qy = q[1], qz = q[2], qw = q[3];
-    var x2 = a3[0], y2 = a3[1], z = a3[2];
+    var x2 = a22[0], y2 = a22[1], z = a22[2];
     var uvx = qy * z - qz * y2, uvy = qz * x2 - qx * z, uvz = qx * y2 - qy * x2;
     var uuvx = qy * uvz - qz * uvy, uuvy = qz * uvx - qx * uvz, uuvz = qx * uvy - qy * uvx;
     var w2 = qw * 2;
@@ -3791,11 +3791,11 @@ var __exports__ = (() => {
     out[2] = z + uvz + uuvz;
     return out;
   }
-  function rotateX(out, a3, b2, rad) {
+  function rotateX(out, a22, b2, rad) {
     var p2 = [], r2 = [];
-    p2[0] = a3[0] - b2[0];
-    p2[1] = a3[1] - b2[1];
-    p2[2] = a3[2] - b2[2];
+    p2[0] = a22[0] - b2[0];
+    p2[1] = a22[1] - b2[1];
+    p2[2] = a22[2] - b2[2];
     r2[0] = p2[0];
     r2[1] = p2[1] * Math.cos(rad) - p2[2] * Math.sin(rad);
     r2[2] = p2[1] * Math.sin(rad) + p2[2] * Math.cos(rad);
@@ -3804,11 +3804,11 @@ var __exports__ = (() => {
     out[2] = r2[2] + b2[2];
     return out;
   }
-  function rotateY(out, a3, b2, rad) {
+  function rotateY(out, a22, b2, rad) {
     var p2 = [], r2 = [];
-    p2[0] = a3[0] - b2[0];
-    p2[1] = a3[1] - b2[1];
-    p2[2] = a3[2] - b2[2];
+    p2[0] = a22[0] - b2[0];
+    p2[1] = a22[1] - b2[1];
+    p2[2] = a22[2] - b2[2];
     r2[0] = p2[2] * Math.sin(rad) + p2[0] * Math.cos(rad);
     r2[1] = p2[1];
     r2[2] = p2[2] * Math.cos(rad) - p2[0] * Math.sin(rad);
@@ -3817,11 +3817,11 @@ var __exports__ = (() => {
     out[2] = r2[2] + b2[2];
     return out;
   }
-  function rotateZ(out, a3, b2, rad) {
+  function rotateZ(out, a22, b2, rad) {
     var p2 = [], r2 = [];
-    p2[0] = a3[0] - b2[0];
-    p2[1] = a3[1] - b2[1];
-    p2[2] = a3[2] - b2[2];
+    p2[0] = a22[0] - b2[0];
+    p2[1] = a22[1] - b2[1];
+    p2[2] = a22[2] - b2[2];
     r2[0] = p2[0] * Math.cos(rad) - p2[1] * Math.sin(rad);
     r2[1] = p2[0] * Math.sin(rad) + p2[1] * Math.cos(rad);
     r2[2] = p2[2];
@@ -3830,8 +3830,8 @@ var __exports__ = (() => {
     out[2] = r2[2] + b2[2];
     return out;
   }
-  function angle(a3, b2) {
-    var ax = a3[0], ay = a3[1], az = a3[2], bx = b2[0], by = b2[1], bz = b2[2], mag1 = Math.sqrt(ax * ax + ay * ay + az * az), mag2 = Math.sqrt(bx * bx + by * by + bz * bz), mag = mag1 * mag2, cosine = mag && dot(a3, b2) / mag;
+  function angle(a22, b2) {
+    var ax = a22[0], ay = a22[1], az = a22[2], bx = b2[0], by = b2[1], bz = b2[2], mag1 = Math.sqrt(ax * ax + ay * ay + az * az), mag2 = Math.sqrt(bx * bx + by * by + bz * bz), mag = mag1 * mag2, cosine = mag && dot(a22, b2) / mag;
     return Math.acos(Math.min(Math.max(cosine, -1), 1));
   }
   function zero(out) {
@@ -3840,16 +3840,16 @@ var __exports__ = (() => {
     out[2] = 0;
     return out;
   }
-  function str2(a3) {
-    return "vec3(" + a3[0] + ", " + a3[1] + ", " + a3[2] + ")";
+  function str2(a22) {
+    return "vec3(" + a22[0] + ", " + a22[1] + ", " + a22[2] + ")";
   }
-  function exactEquals2(a3, b2) {
-    return a3[0] === b2[0] && a3[1] === b2[1] && a3[2] === b2[2];
+  function exactEquals2(a22, b2) {
+    return a22[0] === b2[0] && a22[1] === b2[1] && a22[2] === b2[2];
   }
-  function equals3(a3, b2) {
-    var a0 = a3[0], a1 = a3[1], a22 = a3[2];
+  function equals3(a22, b2) {
+    var a0 = a22[0], a1 = a22[1], a222 = a22[2];
     var b0 = b2[0], b1 = b2[1], b22 = b2[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(a22 - b22) <= EPSILON * Math.max(1, Math.abs(a22), Math.abs(b22));
+    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(a222 - b22) <= EPSILON * Math.max(1, Math.abs(a222), Math.abs(b22));
   }
   var sub2 = subtract2;
   var mul2 = multiply2;
@@ -3860,7 +3860,7 @@ var __exports__ = (() => {
   var sqrLen = squaredLength;
   var forEach = function() {
     var vec = create3();
-    return function(a3, stride, offset, count, fn, arg) {
+    return function(a22, stride, offset, count, fn, arg) {
       var i3, l2;
       if (!stride) {
         stride = 3;
@@ -3869,20 +3869,20 @@ var __exports__ = (() => {
         offset = 0;
       }
       if (count) {
-        l2 = Math.min(count * stride + offset, a3.length);
+        l2 = Math.min(count * stride + offset, a22.length);
       } else {
-        l2 = a3.length;
+        l2 = a22.length;
       }
       for (i3 = offset; i3 < l2; i3 += stride) {
-        vec[0] = a3[i3];
-        vec[1] = a3[i3 + 1];
-        vec[2] = a3[i3 + 2];
+        vec[0] = a22[i3];
+        vec[1] = a22[i3 + 1];
+        vec[2] = a22[i3 + 2];
         fn(vec, vec, arg);
-        a3[i3] = vec[0];
-        a3[i3 + 1] = vec[1];
-        a3[i3 + 2] = vec[2];
+        a22[i3] = vec[0];
+        a22[i3 + 1] = vec[1];
+        a22[i3 + 2] = vec[2];
       }
-      return a3;
+      return a22;
     };
   }();
   function create4() {
@@ -3895,12 +3895,12 @@ var __exports__ = (() => {
     }
     return out;
   }
-  function clone3(a3) {
+  function clone3(a22) {
     var out = new ARRAY_TYPE(4);
-    out[0] = a3[0];
-    out[1] = a3[1];
-    out[2] = a3[2];
-    out[3] = a3[3];
+    out[0] = a22[0];
+    out[1] = a22[1];
+    out[2] = a22[2];
+    out[3] = a22[3];
     return out;
   }
   function fromValues3(x2, y2, z, w2) {
@@ -3911,11 +3911,11 @@ var __exports__ = (() => {
     out[3] = w2;
     return out;
   }
-  function copy3(out, a3) {
-    out[0] = a3[0];
-    out[1] = a3[1];
-    out[2] = a3[2];
-    out[3] = a3[3];
+  function copy3(out, a22) {
+    out[0] = a22[0];
+    out[1] = a22[1];
+    out[2] = a22[2];
+    out[3] = a22[3];
     return out;
   }
   function set3(out, x2, y2, z, w2) {
@@ -3925,39 +3925,39 @@ var __exports__ = (() => {
     out[3] = w2;
     return out;
   }
-  function add3(out, a3, b2) {
-    out[0] = a3[0] + b2[0];
-    out[1] = a3[1] + b2[1];
-    out[2] = a3[2] + b2[2];
-    out[3] = a3[3] + b2[3];
+  function add3(out, a22, b2) {
+    out[0] = a22[0] + b2[0];
+    out[1] = a22[1] + b2[1];
+    out[2] = a22[2] + b2[2];
+    out[3] = a22[3] + b2[3];
     return out;
   }
-  function scale3(out, a3, b2) {
-    out[0] = a3[0] * b2;
-    out[1] = a3[1] * b2;
-    out[2] = a3[2] * b2;
-    out[3] = a3[3] * b2;
+  function scale3(out, a22, b2) {
+    out[0] = a22[0] * b2;
+    out[1] = a22[1] * b2;
+    out[2] = a22[2] * b2;
+    out[3] = a22[3] * b2;
     return out;
   }
-  function length2(a3) {
-    var x2 = a3[0];
-    var y2 = a3[1];
-    var z = a3[2];
-    var w2 = a3[3];
+  function length2(a22) {
+    var x2 = a22[0];
+    var y2 = a22[1];
+    var z = a22[2];
+    var w2 = a22[3];
     return Math.hypot(x2, y2, z, w2);
   }
-  function squaredLength2(a3) {
-    var x2 = a3[0];
-    var y2 = a3[1];
-    var z = a3[2];
-    var w2 = a3[3];
+  function squaredLength2(a22) {
+    var x2 = a22[0];
+    var y2 = a22[1];
+    var z = a22[2];
+    var w2 = a22[3];
     return x2 * x2 + y2 * y2 + z * z + w2 * w2;
   }
-  function normalize2(out, a3) {
-    var x2 = a3[0];
-    var y2 = a3[1];
-    var z = a3[2];
-    var w2 = a3[3];
+  function normalize2(out, a22) {
+    var x2 = a22[0];
+    var y2 = a22[1];
+    var z = a22[2];
+    var w2 = a22[3];
     var len42 = x2 * x2 + y2 * y2 + z * z + w2 * w2;
     if (len42 > 0) {
       len42 = 1 / Math.sqrt(len42);
@@ -3968,31 +3968,31 @@ var __exports__ = (() => {
     out[3] = w2 * len42;
     return out;
   }
-  function dot2(a3, b2) {
-    return a3[0] * b2[0] + a3[1] * b2[1] + a3[2] * b2[2] + a3[3] * b2[3];
+  function dot2(a22, b2) {
+    return a22[0] * b2[0] + a22[1] * b2[1] + a22[2] * b2[2] + a22[3] * b2[3];
   }
-  function lerp2(out, a3, b2, t2) {
-    var ax = a3[0];
-    var ay = a3[1];
-    var az = a3[2];
-    var aw = a3[3];
+  function lerp2(out, a22, b2, t2) {
+    var ax = a22[0];
+    var ay = a22[1];
+    var az = a22[2];
+    var aw = a22[3];
     out[0] = ax + t2 * (b2[0] - ax);
     out[1] = ay + t2 * (b2[1] - ay);
     out[2] = az + t2 * (b2[2] - az);
     out[3] = aw + t2 * (b2[3] - aw);
     return out;
   }
-  function exactEquals3(a3, b2) {
-    return a3[0] === b2[0] && a3[1] === b2[1] && a3[2] === b2[2] && a3[3] === b2[3];
+  function exactEquals3(a22, b2) {
+    return a22[0] === b2[0] && a22[1] === b2[1] && a22[2] === b2[2] && a22[3] === b2[3];
   }
-  function equals4(a3, b2) {
-    var a0 = a3[0], a1 = a3[1], a22 = a3[2], a32 = a3[3];
+  function equals4(a22, b2) {
+    var a0 = a22[0], a1 = a22[1], a222 = a22[2], a3 = a22[3];
     var b0 = b2[0], b1 = b2[1], b22 = b2[2], b3 = b2[3];
-    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(a22 - b22) <= EPSILON * Math.max(1, Math.abs(a22), Math.abs(b22)) && Math.abs(a32 - b3) <= EPSILON * Math.max(1, Math.abs(a32), Math.abs(b3));
+    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(a222 - b22) <= EPSILON * Math.max(1, Math.abs(a222), Math.abs(b22)) && Math.abs(a3 - b3) <= EPSILON * Math.max(1, Math.abs(a3), Math.abs(b3));
   }
   var forEach2 = function() {
     var vec = create4();
-    return function(a3, stride, offset, count, fn, arg) {
+    return function(a22, stride, offset, count, fn, arg) {
       var i3, l2;
       if (!stride) {
         stride = 4;
@@ -4001,22 +4001,22 @@ var __exports__ = (() => {
         offset = 0;
       }
       if (count) {
-        l2 = Math.min(count * stride + offset, a3.length);
+        l2 = Math.min(count * stride + offset, a22.length);
       } else {
-        l2 = a3.length;
+        l2 = a22.length;
       }
       for (i3 = offset; i3 < l2; i3 += stride) {
-        vec[0] = a3[i3];
-        vec[1] = a3[i3 + 1];
-        vec[2] = a3[i3 + 2];
-        vec[3] = a3[i3 + 3];
+        vec[0] = a22[i3];
+        vec[1] = a22[i3 + 1];
+        vec[2] = a22[i3 + 2];
+        vec[3] = a22[i3 + 3];
         fn(vec, vec, arg);
-        a3[i3] = vec[0];
-        a3[i3 + 1] = vec[1];
-        a3[i3 + 2] = vec[2];
-        a3[i3 + 3] = vec[3];
+        a22[i3] = vec[0];
+        a22[i3 + 1] = vec[1];
+        a22[i3 + 2] = vec[2];
+        a22[i3 + 3] = vec[3];
       }
-      return a3;
+      return a22;
     };
   }();
   function create5() {
@@ -4059,12 +4059,12 @@ var __exports__ = (() => {
     }
     return rad;
   }
-  function getAngle(a3, b2) {
-    var dotproduct = dot3(a3, b2);
+  function getAngle(a22, b2) {
+    var dotproduct = dot3(a22, b2);
     return Math.acos(2 * dotproduct * dotproduct - 1);
   }
-  function multiply3(out, a3, b2) {
-    var ax = a3[0], ay = a3[1], az = a3[2], aw = a3[3];
+  function multiply3(out, a22, b2) {
+    var ax = a22[0], ay = a22[1], az = a22[2], aw = a22[3];
     var bx = b2[0], by = b2[1], bz = b2[2], bw = b2[3];
     out[0] = ax * bw + aw * bx + ay * bz - az * by;
     out[1] = ay * bw + aw * by + az * bx - ax * bz;
@@ -4072,9 +4072,9 @@ var __exports__ = (() => {
     out[3] = aw * bw - ax * bx - ay * by - az * bz;
     return out;
   }
-  function rotateX2(out, a3, rad) {
+  function rotateX2(out, a22, rad) {
     rad *= 0.5;
-    var ax = a3[0], ay = a3[1], az = a3[2], aw = a3[3];
+    var ax = a22[0], ay = a22[1], az = a22[2], aw = a22[3];
     var bx = Math.sin(rad), bw = Math.cos(rad);
     out[0] = ax * bw + aw * bx;
     out[1] = ay * bw + az * bx;
@@ -4082,9 +4082,9 @@ var __exports__ = (() => {
     out[3] = aw * bw - ax * bx;
     return out;
   }
-  function rotateY2(out, a3, rad) {
+  function rotateY2(out, a22, rad) {
     rad *= 0.5;
-    var ax = a3[0], ay = a3[1], az = a3[2], aw = a3[3];
+    var ax = a22[0], ay = a22[1], az = a22[2], aw = a22[3];
     var by = Math.sin(rad), bw = Math.cos(rad);
     out[0] = ax * bw - az * by;
     out[1] = ay * bw + aw * by;
@@ -4092,9 +4092,9 @@ var __exports__ = (() => {
     out[3] = aw * bw - ay * by;
     return out;
   }
-  function rotateZ2(out, a3, rad) {
+  function rotateZ2(out, a22, rad) {
     rad *= 0.5;
-    var ax = a3[0], ay = a3[1], az = a3[2], aw = a3[3];
+    var ax = a22[0], ay = a22[1], az = a22[2], aw = a22[3];
     var bz = Math.sin(rad), bw = Math.cos(rad);
     out[0] = ax * bw + ay * bz;
     out[1] = ay * bw - ax * bz;
@@ -4102,16 +4102,16 @@ var __exports__ = (() => {
     out[3] = aw * bw - az * bz;
     return out;
   }
-  function calculateW(out, a3) {
-    var x2 = a3[0], y2 = a3[1], z = a3[2];
+  function calculateW(out, a22) {
+    var x2 = a22[0], y2 = a22[1], z = a22[2];
     out[0] = x2;
     out[1] = y2;
     out[2] = z;
     out[3] = Math.sqrt(Math.abs(1 - x2 * x2 - y2 * y2 - z * z));
     return out;
   }
-  function exp(out, a3) {
-    var x2 = a3[0], y2 = a3[1], z = a3[2], w2 = a3[3];
+  function exp(out, a22) {
+    var x2 = a22[0], y2 = a22[1], z = a22[2], w2 = a22[3];
     var r2 = Math.sqrt(x2 * x2 + y2 * y2 + z * z);
     var et = Math.exp(w2);
     var s2 = r2 > 0 ? et * Math.sin(r2) / r2 : 0;
@@ -4121,8 +4121,8 @@ var __exports__ = (() => {
     out[3] = et * Math.cos(r2);
     return out;
   }
-  function ln(out, a3) {
-    var x2 = a3[0], y2 = a3[1], z = a3[2], w2 = a3[3];
+  function ln(out, a22) {
+    var x2 = a22[0], y2 = a22[1], z = a22[2], w2 = a22[3];
     var r2 = Math.sqrt(x2 * x2 + y2 * y2 + z * z);
     var t2 = r2 > 0 ? Math.atan2(r2, w2) / r2 : 0;
     out[0] = x2 * t2;
@@ -4131,14 +4131,14 @@ var __exports__ = (() => {
     out[3] = 0.5 * Math.log(x2 * x2 + y2 * y2 + z * z + w2 * w2);
     return out;
   }
-  function pow(out, a3, b2) {
-    ln(out, a3);
+  function pow(out, a22, b2) {
+    ln(out, a22);
     scale4(out, out, b2);
     exp(out, out);
     return out;
   }
-  function slerp(out, a3, b2, t2) {
-    var ax = a3[0], ay = a3[1], az = a3[2], aw = a3[3];
+  function slerp(out, a22, b2, t2) {
+    var ax = a22[0], ay = a22[1], az = a22[2], aw = a22[3];
     var bx = b2[0], by = b2[1], bz = b2[2], bw = b2[3];
     var omega, cosom, sinom, scale0, scale1;
     cosom = ax * bx + ay * by + az * bz + aw * bw;
@@ -4176,21 +4176,21 @@ var __exports__ = (() => {
     out[3] = sqrtU1 * Math.cos(2 * Math.PI * u3);
     return out;
   }
-  function invert2(out, a3) {
-    var a0 = a3[0], a1 = a3[1], a22 = a3[2], a32 = a3[3];
-    var dot52 = a0 * a0 + a1 * a1 + a22 * a22 + a32 * a32;
+  function invert2(out, a22) {
+    var a0 = a22[0], a1 = a22[1], a222 = a22[2], a3 = a22[3];
+    var dot52 = a0 * a0 + a1 * a1 + a222 * a222 + a3 * a3;
     var invDot = dot52 ? 1 / dot52 : 0;
     out[0] = -a0 * invDot;
     out[1] = -a1 * invDot;
-    out[2] = -a22 * invDot;
-    out[3] = a32 * invDot;
+    out[2] = -a222 * invDot;
+    out[3] = a3 * invDot;
     return out;
   }
-  function conjugate(out, a3) {
-    out[0] = -a3[0];
-    out[1] = -a3[1];
-    out[2] = -a3[2];
-    out[3] = a3[3];
+  function conjugate(out, a22) {
+    out[0] = -a22[0];
+    out[1] = -a22[1];
+    out[2] = -a22[2];
+    out[3] = a22[3];
     return out;
   }
   function fromMat3(out, m) {
@@ -4237,8 +4237,8 @@ var __exports__ = (() => {
     out[3] = cx * cy * cz + sx * sy * sz;
     return out;
   }
-  function str3(a3) {
-    return "quat(" + a3[0] + ", " + a3[1] + ", " + a3[2] + ", " + a3[3] + ")";
+  function str3(a22) {
+    return "quat(" + a22[0] + ", " + a22[1] + ", " + a22[2] + ", " + a22[3] + ")";
   }
   var clone4 = clone3;
   var fromValues4 = fromValues3;
@@ -4260,12 +4260,12 @@ var __exports__ = (() => {
     var tmpvec3 = create3();
     var xUnitVec3 = fromValues2(1, 0, 0);
     var yUnitVec3 = fromValues2(0, 1, 0);
-    return function(out, a3, b2) {
-      var dot52 = dot(a3, b2);
+    return function(out, a22, b2) {
+      var dot52 = dot(a22, b2);
       if (dot52 < -0.999999) {
-        cross(tmpvec3, xUnitVec3, a3);
+        cross(tmpvec3, xUnitVec3, a22);
         if (len(tmpvec3) < 1e-6)
-          cross(tmpvec3, yUnitVec3, a3);
+          cross(tmpvec3, yUnitVec3, a22);
         normalize(tmpvec3, tmpvec3);
         setAxisAngle(out, tmpvec3, Math.PI);
         return out;
@@ -4276,7 +4276,7 @@ var __exports__ = (() => {
         out[3] = 1;
         return out;
       } else {
-        cross(tmpvec3, a3, b2);
+        cross(tmpvec3, a22, b2);
         out[0] = tmpvec3[0];
         out[1] = tmpvec3[1];
         out[2] = tmpvec3[2];
@@ -4288,8 +4288,8 @@ var __exports__ = (() => {
   var sqlerp = function() {
     var temp1 = create5();
     var temp2 = create5();
-    return function(out, a3, b2, c2, d2, t2) {
-      slerp(temp1, a3, d2, t2);
+    return function(out, a22, b2, c2, d2, t2) {
+      slerp(temp1, a22, d2, t2);
       slerp(temp2, b2, c2, t2);
       slerp(out, temp1, temp2, 2 * t2 * (1 - t2));
       return out;
@@ -4366,10 +4366,10 @@ var __exports__ = (() => {
     }
     return out;
   }
-  function clone5(a3) {
+  function clone5(a22) {
     var out = new ARRAY_TYPE(2);
-    out[0] = a3[0];
-    out[1] = a3[1];
+    out[0] = a22[0];
+    out[1] = a22[1];
     return out;
   }
   function fromValues5(x2, y2) {
@@ -4378,9 +4378,9 @@ var __exports__ = (() => {
     out[1] = y2;
     return out;
   }
-  function copy5(out, a3) {
-    out[0] = a3[0];
-    out[1] = a3[1];
+  function copy5(out, a22) {
+    out[0] = a22[0];
+    out[1] = a22[1];
     return out;
   }
   function set5(out, x2, y2) {
@@ -4388,108 +4388,108 @@ var __exports__ = (() => {
     out[1] = y2;
     return out;
   }
-  function add5(out, a3, b2) {
-    out[0] = a3[0] + b2[0];
-    out[1] = a3[1] + b2[1];
+  function add5(out, a22, b2) {
+    out[0] = a22[0] + b2[0];
+    out[1] = a22[1] + b2[1];
     return out;
   }
-  function subtract3(out, a3, b2) {
-    out[0] = a3[0] - b2[0];
-    out[1] = a3[1] - b2[1];
+  function subtract3(out, a22, b2) {
+    out[0] = a22[0] - b2[0];
+    out[1] = a22[1] - b2[1];
     return out;
   }
-  function multiply4(out, a3, b2) {
-    out[0] = a3[0] * b2[0];
-    out[1] = a3[1] * b2[1];
+  function multiply4(out, a22, b2) {
+    out[0] = a22[0] * b2[0];
+    out[1] = a22[1] * b2[1];
     return out;
   }
-  function divide2(out, a3, b2) {
-    out[0] = a3[0] / b2[0];
-    out[1] = a3[1] / b2[1];
+  function divide2(out, a22, b2) {
+    out[0] = a22[0] / b2[0];
+    out[1] = a22[1] / b2[1];
     return out;
   }
-  function ceil2(out, a3) {
-    out[0] = Math.ceil(a3[0]);
-    out[1] = Math.ceil(a3[1]);
+  function ceil2(out, a22) {
+    out[0] = Math.ceil(a22[0]);
+    out[1] = Math.ceil(a22[1]);
     return out;
   }
-  function floor2(out, a3) {
-    out[0] = Math.floor(a3[0]);
-    out[1] = Math.floor(a3[1]);
+  function floor2(out, a22) {
+    out[0] = Math.floor(a22[0]);
+    out[1] = Math.floor(a22[1]);
     return out;
   }
-  function min2(out, a3, b2) {
-    out[0] = Math.min(a3[0], b2[0]);
-    out[1] = Math.min(a3[1], b2[1]);
+  function min2(out, a22, b2) {
+    out[0] = Math.min(a22[0], b2[0]);
+    out[1] = Math.min(a22[1], b2[1]);
     return out;
   }
-  function max2(out, a3, b2) {
-    out[0] = Math.max(a3[0], b2[0]);
-    out[1] = Math.max(a3[1], b2[1]);
+  function max2(out, a22, b2) {
+    out[0] = Math.max(a22[0], b2[0]);
+    out[1] = Math.max(a22[1], b2[1]);
     return out;
   }
-  function round2(out, a3) {
-    out[0] = Math.round(a3[0]);
-    out[1] = Math.round(a3[1]);
+  function round2(out, a22) {
+    out[0] = Math.round(a22[0]);
+    out[1] = Math.round(a22[1]);
     return out;
   }
-  function scale5(out, a3, b2) {
-    out[0] = a3[0] * b2;
-    out[1] = a3[1] * b2;
+  function scale5(out, a22, b2) {
+    out[0] = a22[0] * b2;
+    out[1] = a22[1] * b2;
     return out;
   }
-  function scaleAndAdd2(out, a3, b2, scale72) {
-    out[0] = a3[0] + b2[0] * scale72;
-    out[1] = a3[1] + b2[1] * scale72;
+  function scaleAndAdd2(out, a22, b2, scale72) {
+    out[0] = a22[0] + b2[0] * scale72;
+    out[1] = a22[1] + b2[1] * scale72;
     return out;
   }
-  function distance2(a3, b2) {
-    var x2 = b2[0] - a3[0], y2 = b2[1] - a3[1];
+  function distance2(a22, b2) {
+    var x2 = b2[0] - a22[0], y2 = b2[1] - a22[1];
     return Math.hypot(x2, y2);
   }
-  function squaredDistance2(a3, b2) {
-    var x2 = b2[0] - a3[0], y2 = b2[1] - a3[1];
+  function squaredDistance2(a22, b2) {
+    var x2 = b2[0] - a22[0], y2 = b2[1] - a22[1];
     return x2 * x2 + y2 * y2;
   }
-  function length4(a3) {
-    var x2 = a3[0], y2 = a3[1];
+  function length4(a22) {
+    var x2 = a22[0], y2 = a22[1];
     return Math.hypot(x2, y2);
   }
-  function squaredLength4(a3) {
-    var x2 = a3[0], y2 = a3[1];
+  function squaredLength4(a22) {
+    var x2 = a22[0], y2 = a22[1];
     return x2 * x2 + y2 * y2;
   }
-  function negate2(out, a3) {
-    out[0] = -a3[0];
-    out[1] = -a3[1];
+  function negate2(out, a22) {
+    out[0] = -a22[0];
+    out[1] = -a22[1];
     return out;
   }
-  function inverse2(out, a3) {
-    out[0] = 1 / a3[0];
-    out[1] = 1 / a3[1];
+  function inverse2(out, a22) {
+    out[0] = 1 / a22[0];
+    out[1] = 1 / a22[1];
     return out;
   }
-  function normalize4(out, a3) {
-    var x2 = a3[0], y2 = a3[1];
+  function normalize4(out, a22) {
+    var x2 = a22[0], y2 = a22[1];
     var len42 = x2 * x2 + y2 * y2;
     if (len42 > 0) {
       len42 = 1 / Math.sqrt(len42);
     }
-    out[0] = a3[0] * len42;
-    out[1] = a3[1] * len42;
+    out[0] = a22[0] * len42;
+    out[1] = a22[1] * len42;
     return out;
   }
-  function dot4(a3, b2) {
-    return a3[0] * b2[0] + a3[1] * b2[1];
+  function dot4(a22, b2) {
+    return a22[0] * b2[0] + a22[1] * b2[1];
   }
-  function cross2(out, a3, b2) {
-    var z = a3[0] * b2[1] - a3[1] * b2[0];
+  function cross2(out, a22, b2) {
+    var z = a22[0] * b2[1] - a22[1] * b2[0];
     out[0] = out[1] = 0;
     out[2] = z;
     return out;
   }
-  function lerp4(out, a3, b2, t2) {
-    var ax = a3[0], ay = a3[1];
+  function lerp4(out, a22, b2, t2) {
+    var ax = a22[0], ay = a22[1];
     out[0] = ax + t2 * (b2[0] - ax);
     out[1] = ay + t2 * (b2[1] - ay);
     return out;
@@ -4501,39 +4501,39 @@ var __exports__ = (() => {
     out[1] = Math.sin(r2) * scale72;
     return out;
   }
-  function transformMat2(out, a3, m) {
-    var x2 = a3[0], y2 = a3[1];
+  function transformMat2(out, a22, m) {
+    var x2 = a22[0], y2 = a22[1];
     out[0] = m[0] * x2 + m[2] * y2;
     out[1] = m[1] * x2 + m[3] * y2;
     return out;
   }
-  function transformMat2d(out, a3, m) {
-    var x2 = a3[0], y2 = a3[1];
+  function transformMat2d(out, a22, m) {
+    var x2 = a22[0], y2 = a22[1];
     out[0] = m[0] * x2 + m[2] * y2 + m[4];
     out[1] = m[1] * x2 + m[3] * y2 + m[5];
     return out;
   }
-  function transformMat32(out, a3, m) {
-    var x2 = a3[0], y2 = a3[1];
+  function transformMat32(out, a22, m) {
+    var x2 = a22[0], y2 = a22[1];
     out[0] = m[0] * x2 + m[3] * y2 + m[6];
     out[1] = m[1] * x2 + m[4] * y2 + m[7];
     return out;
   }
-  function transformMat42(out, a3, m) {
-    var x2 = a3[0];
-    var y2 = a3[1];
+  function transformMat42(out, a22, m) {
+    var x2 = a22[0];
+    var y2 = a22[1];
     out[0] = m[0] * x2 + m[4] * y2 + m[12];
     out[1] = m[1] * x2 + m[5] * y2 + m[13];
     return out;
   }
-  function rotate2(out, a3, b2, rad) {
-    var p0 = a3[0] - b2[0], p1 = a3[1] - b2[1], sinC = Math.sin(rad), cosC = Math.cos(rad);
+  function rotate2(out, a22, b2, rad) {
+    var p0 = a22[0] - b2[0], p1 = a22[1] - b2[1], sinC = Math.sin(rad), cosC = Math.cos(rad);
     out[0] = p0 * cosC - p1 * sinC + b2[0];
     out[1] = p0 * sinC + p1 * cosC + b2[1];
     return out;
   }
-  function angle2(a3, b2) {
-    var x1 = a3[0], y1 = a3[1], x2 = b2[0], y2 = b2[1], mag = Math.sqrt(x1 * x1 + y1 * y1) * Math.sqrt(x2 * x2 + y2 * y2), cosine = mag && (x1 * x2 + y1 * y2) / mag;
+  function angle2(a22, b2) {
+    var x1 = a22[0], y1 = a22[1], x2 = b2[0], y2 = b2[1], mag = Math.sqrt(x1 * x1 + y1 * y1) * Math.sqrt(x2 * x2 + y2 * y2), cosine = mag && (x1 * x2 + y1 * y2) / mag;
     return Math.acos(Math.min(Math.max(cosine, -1), 1));
   }
   function zero2(out) {
@@ -4541,14 +4541,14 @@ var __exports__ = (() => {
     out[1] = 0;
     return out;
   }
-  function str4(a3) {
-    return "vec2(" + a3[0] + ", " + a3[1] + ")";
+  function str4(a22) {
+    return "vec2(" + a22[0] + ", " + a22[1] + ")";
   }
-  function exactEquals5(a3, b2) {
-    return a3[0] === b2[0] && a3[1] === b2[1];
+  function exactEquals5(a22, b2) {
+    return a22[0] === b2[0] && a22[1] === b2[1];
   }
-  function equals6(a3, b2) {
-    var a0 = a3[0], a1 = a3[1];
+  function equals6(a22, b2) {
+    var a0 = a22[0], a1 = a22[1];
     var b0 = b2[0], b1 = b2[1];
     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));
   }
@@ -4561,7 +4561,7 @@ var __exports__ = (() => {
   var sqrLen3 = squaredLength4;
   var forEach3 = function() {
     var vec = create6();
-    return function(a3, stride, offset, count, fn, arg) {
+    return function(a22, stride, offset, count, fn, arg) {
       var i3, l2;
       if (!stride) {
         stride = 2;
@@ -4570,18 +4570,18 @@ var __exports__ = (() => {
         offset = 0;
       }
       if (count) {
-        l2 = Math.min(count * stride + offset, a3.length);
+        l2 = Math.min(count * stride + offset, a22.length);
       } else {
-        l2 = a3.length;
+        l2 = a22.length;
       }
       for (i3 = offset; i3 < l2; i3 += stride) {
-        vec[0] = a3[i3];
-        vec[1] = a3[i3 + 1];
+        vec[0] = a22[i3];
+        vec[1] = a22[i3 + 1];
         fn(vec, vec, arg);
-        a3[i3] = vec[0];
-        a3[i3 + 1] = vec[1];
+        a22[i3] = vec[0];
+        a22[i3 + 1] = vec[1];
       }
-      return a3;
+      return a22;
     };
   }();
   var \u03C6 = (1 + Math.sqrt(5)) / 2;
@@ -4592,42 +4592,30 @@ var __exports__ = (() => {
   var dihedralAngle = 2 * Math.atan(\u03C6);
   var interhedralAngle = Math.PI - dihedralAngle;
   var faceEdgeAngle = -0.5 * Math.PI + Math.acos(-1 / Math.sqrt(3 - \u03C6));
-  var distanceToEdge = \u03C6 - 1;
-  var distanceToVertex = distanceToEdge / Math.cos(PI_OVER_5);
-  var WARP_FACTOR = 0.515;
+  var distanceToEdge = (Math.sqrt(5) - 1) / 2;
+  var distanceToVertex = 3 - Math.sqrt(5);
   var Rmidedge = Math.sqrt(3 - \u03C6);
   var Rcircumscribed = Math.sqrt(3) * Rmidedge / \u03C6;
   common_exports.setMatrixArrayType(Float64Array);
-  var Triangle = class {
-    constructor(a3, b2, c2) {
-      this.origin = vec2_exports.clone(a3);
-      this.edge1 = vec2_exports.subtract(vec2_exports.create(), b2, this.origin);
-      this.edge2 = vec2_exports.subtract(vec2_exports.create(), c2, this.origin);
-      this.testPoint = vec2_exports.create();
-      this.dot11 = vec2_exports.dot(this.edge1, this.edge1);
-      this.dot12 = vec2_exports.dot(this.edge1, this.edge2);
-      this.dot22 = vec2_exports.dot(this.edge2, this.edge2);
-      const invDenom = 1 / (this.dot11 * this.dot22 - this.dot12 * this.dot12);
-      this.dot11 *= invDenom;
-      this.dot12 *= invDenom;
-      this.dot22 *= invDenom;
-    }
-    containsPoint(p2) {
-      vec2_exports.subtract(this.testPoint, p2, this.origin);
-      const dotp1 = vec2_exports.dot(this.testPoint, this.edge1);
-      const dotp2 = vec2_exports.dot(this.testPoint, this.edge2);
-      const u2 = this.dot22 * dotp1 - this.dot12 * dotp2;
-      if (u2 < 0)
-        return false;
-      const v2 = this.dot11 * dotp2 - this.dot12 * dotp1;
-      return v2 >= 0 && u2 + v2 <= 1;
-    }
-  };
-  common_exports.setMatrixArrayType(Float64Array);
   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();
+      }
+    }
+    getArea() {
+      let signedArea2 = 0;
+      const N = this.vertices.length;
+      for (let i3 = 0; i3 < N; i3++) {
+        const j = (i3 + 1) % N;
+        signedArea2 += (this.vertices[j][0] - this.vertices[i3][0]) * (this.vertices[j][1] + this.vertices[i3][1]);
+      }
+      return signedArea2;
+    }
+    isWindingCorrect() {
+      return this.getArea() >= 0;
     }
     getVertices() {
       return this.vertices;
@@ -4650,12 +4638,14 @@ var __exports__ = (() => {
     }
     /**
      * Reflects the pentagon over the x-axis (equivalent to negating y)
+     * and reverses the winding order to maintain consistent orientation
      * @returns The reflected pentagon
      */
     reflectY() {
       for (const vertex of this.vertices) {
         vertex[1] = -vertex[1];
       }
+      this.vertices.reverse();
       return this;
     }
     translate(translation2) {
@@ -4687,47 +4677,54 @@ var __exports__ = (() => {
       );
     }
     /**
-     * Tests if a point is inside the pentagon by checking if it's in any of the three triangles
-     * that make up the pentagon. Assumes pentagon is convex.
+     * 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 true if the point is inside the pentagon
+     * @returns -1 if point is inside, otherwise a value proportional to the distance from the point to the edge
      */
     containsPoint(point) {
-      const v0 = this.vertices[0];
-      if (!this.triangles) {
-        this.triangles = [];
-        for (const i3 of [2, 1, 3]) {
-          const v1 = this.vertices[i3];
-          const v2 = this.vertices[i3 + 1];
-          this.triangles.push(new Triangle(v0, v1, v2));
-        }
-      }
-      for (const triangle of this.triangles) {
-        if (triangle.containsPoint(point)) {
-          return true;
+      if (!this.isWindingCorrect()) {
+        throw new Error("Pentagon is not counter-clockwise");
+      }
+      const N = this.vertices.length;
+      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 px = point[0] - v1[0];
+        const py = point[1] - v1[1];
+        const crossProduct = dx * py - dy * px;
+        if (crossProduct > 0) {
+          const pLength = Math.sqrt(px * px + py * py);
+          return crossProduct / pLength;
         }
       }
-      return false;
+      return -1;
     }
     /**
-     * Normalizes longitude values in a contour to handle antimeridian crossing
-     * @param contour Array of [longitude, latitude] points
-     * @returns Normalized contour with consistent longitude values
+     * Splits each edge of the pentagon into the specified number of segments
+     * @param segments Number of segments to split each edge into
+     * @returns A new PentagonShape with more vertices, or the original PentagonShape if segments <= 1
      */
-    static normalizeLongitudes(contour) {
-      const longitudes = contour.map(([lon]) => {
-        return ((lon + 180) % 360 + 360) % 360 - 180;
-      });
-      let centerLon = longitudes.reduce((sum, p2) => sum + p2, 0) / longitudes.length;
-      centerLon = ((centerLon + 180) % 360 + 360) % 360 - 180;
-      return contour.map((point) => {
-        let [longitude, latitude] = point;
-        while (longitude - centerLon > 180)
-          longitude = longitude - 360;
-        while (longitude - centerLon < -180)
-          longitude = longitude + 360;
-        return [longitude, latitude];
-      });
+    splitEdges(segments) {
+      if (segments <= 1) {
+        return this;
+      }
+      const newVertices = [];
+      const N = this.vertices.length;
+      for (let i3 = 0; i3 < N; i3++) {
+        const v1 = this.vertices[i3];
+        const v2 = this.vertices[(i3 + 1) % N];
+        newVertices.push(vec2_exports.clone(v1));
+        for (let j = 1; j < segments; j++) {
+          const t2 = j / segments;
+          const interpolated = vec2_exports.create();
+          vec2_exports.lerp(interpolated, v1, v2, t2);
+          newVertices.push(interpolated);
+        }
+      }
+      return new _PentagonShape(newVertices);
     }
   };
   common_exports.setMatrixArrayType(Float64Array);
@@ -4751,10 +4748,66 @@ var __exports__ = (() => {
   var v = [L * Math.cos(V), L * Math.sin(V)];
   var W = bisectorAngle - PI_OVER_5;
   var w = [L * Math.cos(W), L * Math.sin(W)];
-  var TRIANGLE = new PentagonShape([u, v, w, w, w]);
+  var TRIANGLE = new PentagonShape([u, v, w]);
   var BASIS = mat2_exports.fromValues(v[0], v[1], w[0], w[1]);
   var BASIS_INVERSE = mat2_exports.invert(mat2_exports.create(), BASIS);
+  var GEODETIC_TO_AUTHALIC = new Float64Array([
+    -0.0022392098386786394,
+    21308606513250217e-22,
+    -2559257686421274e-24,
+    33701965267802837e-28,
+    -4667545312611249e-30,
+    667492870384816e-32
+  ]);
+  var AUTHALIC_TO_GEODETIC = new Float64Array([
+    0.0022392089963541657,
+    28831978048607556e-22,
+    508622073997266e-23,
+    102018123778161e-25,
+    21912872306767718e-30,
+    49284235482523806e-33
+  ]);
+  var AuthalicProjection = class {
+    /**
+     * Applies coefficients using Clenshaw summation algorithm (order 6)
+     * @param phi Angle in radians
+     * @param C Array of coefficients
+     * @returns Transformed angle in radians
+     */
+    applyCoefficients(phi, C) {
+      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];
+      return phi + 2 * sinPhi * cosPhi * u0;
+    }
+    /**
+     * Converts geodetic latitude to authalic latitude
+     * @param phi Geodetic latitude in radians
+     * @returns Authalic latitude in radians
+     */
+    forward(phi) {
+      return this.applyCoefficients(phi, GEODETIC_TO_AUTHALIC);
+    }
+    /**
+     * Converts authalic latitude to geodetic latitude
+     * @param phi Authalic latitude in radians
+     * @returns Geodetic latitude in radians
+     */
+    inverse(phi) {
+      return this.applyCoefficients(phi, AUTHALIC_TO_GEODETIC);
+    }
+  };
   common_exports.setMatrixArrayType(Float64Array);
+  var authalic = new AuthalicProjection();
+  function degToRad(deg) {
+    return deg * (Math.PI / 180);
+  }
   function radToDeg(rad) {
     return rad * (180 / Math.PI);
   }
@@ -4763,6 +4816,27 @@ var __exports__ = (() => {
     const gamma = Math.atan2(xy[1], xy[0]);
     return [rho, gamma];
   }
+  function toFace([rho, gamma]) {
+    const x2 = rho * Math.cos(gamma);
+    const y2 = rho * Math.sin(gamma);
+    return [x2, y2];
+  }
+  function faceToBarycentric(p2, [p1, p22, p3]) {
+    const d31 = [p1[0] - p3[0], p1[1] - p3[1]];
+    const d23 = [p3[0] - p22[0], p3[1] - p22[1]];
+    const d3p = [p2[0] - p3[0], p2[1] - p3[1]];
+    const det = d23[0] * d31[1] - d23[1] * d31[0];
+    const b0 = (d23[0] * d3p[1] - d23[1] * d3p[0]) / det;
+    const b1 = (d31[0] * d3p[1] - d31[1] * d3p[0]) / det;
+    const b2 = 1 - (b0 + b1);
+    return [b0, b1, b2];
+  }
+  function barycentricToFace(b2, [p1, p2, p3]) {
+    return [
+      b2[0] * p1[0] + b2[1] * p2[0] + b2[2] * p3[0],
+      b2[0] * p1[1] + b2[1] * p2[1] + b2[2] * p3[1]
+    ];
+  }
   function toSpherical(xyz) {
     const theta = Math.atan2(xyz[1], xyz[0]);
     const r2 = Math.sqrt(xyz[0] * xyz[0] + xyz[1] * xyz[1] + xyz[2] * xyz[2]);
@@ -4770,15 +4844,25 @@ var __exports__ = (() => {
     return [theta, phi];
   }
   function toCartesian([theta, phi]) {
-    const x2 = Math.sin(phi) * Math.cos(theta);
-    const y2 = Math.sin(phi) * Math.sin(theta);
+    const sinPhi = Math.sin(phi);
+    const x2 = sinPhi * Math.cos(theta);
+    const y2 = sinPhi * Math.sin(theta);
     const z = Math.cos(phi);
     return [x2, y2, z];
   }
   var LONGITUDE_OFFSET = 93;
+  function fromLonLat([longitude, latitude]) {
+    const theta = degToRad(longitude + LONGITUDE_OFFSET);
+    const geodeticLat = degToRad(latitude);
+    const authalicLat = authalic.forward(geodeticLat);
+    const phi = Math.PI / 2 - authalicLat;
+    return [theta, phi];
+  }
   function toLonLat([theta, phi]) {
     const longitude = radToDeg(theta) - LONGITUDE_OFFSET;
-    const latitude = 90 - radToDeg(phi);
+    const authalicLat = Math.PI / 2 - phi;
+    const geodeticLat = authalic.inverse(authalicLat);
+    const latitude = radToDeg(geodeticLat);
     return [longitude, latitude];
   }
   function quatFromSpherical(axis) {
@@ -4787,8 +4871,28 @@ var __exports__ = (() => {
     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();
+    for (const point of points) {
+      vec3_exports.add(center2, center2, point);
+    }
+    vec3_exports.normalize(center2, center2);
+    let [centerLon, centerLat] = toLonLat(toSpherical(center2));
+    if (centerLat > 89.99 || centerLat < -89.99) {
+      centerLon = contour[0][0];
+    }
+    centerLon = ((centerLon + 180) % 360 + 360) % 360 - 180;
+    return contour.map((point) => {
+      let [longitude, latitude] = point;
+      while (longitude - centerLon > 180)
+        longitude = longitude - 360;
+      while (longitude - centerLon < -180)
+        longitude = longitude + 360;
+      return [longitude, latitude];
+    });
+  }
   common_exports.setMatrixArrayType(Float64Array);
-  var UP = [0, 0, 1];
   var clockwiseFan = ["vu", "uw", "vw", "vw", "vw"];
   var clockwiseStep = ["wu", "uw", "vw", "vu", "uw"];
   var counterStep = ["wu", "uv", "wv", "wu", "uw"];
@@ -4834,6 +4938,9 @@ var __exports__ = (() => {
   }
   var originId = 0;
   function addOrigin(axis, angle32) {
+    if (originId > 11) {
+      throw new Error(`Too many origins: ${originId}`);
+    }
     const origin = {
       id: originId,
       axis,
@@ -4846,7 +4953,7 @@ var __exports__ = (() => {
     originId++;
   }
   generateOrigins();
-  origins.sort((a3, b2) => ORIGIN_ORDER.indexOf(a3.id) - ORIGIN_ORDER.indexOf(b2.id));
+  origins.sort((a22, b2) => ORIGIN_ORDER.indexOf(a22.id) - ORIGIN_ORDER.indexOf(b2.id));
   origins.forEach((origin, i3) => origin.id = i3);
   function segmentToQuintant(segment, origin) {
     const layout = origin.orientation;
@@ -4856,91 +4963,297 @@ var __exports__ = (() => {
     const quintant = (origin.firstQuintant + step * faceRelativeQuintant + 5) % 5;
     return { quintant, orientation };
   }
-  function movePointToFace(point, fromOrigin, toOrigin) {
-    const inverseQuat = quat_exports.create();
-    quat_exports.invert(inverseQuat, fromOrigin.quat);
-    const toAxis = toCartesian(toOrigin.axis);
-    const localToAxis = vec3_exports.create();
-    vec3_exports.transformQuat(localToAxis, toAxis, inverseQuat);
-    const direction = vec2_exports.create();
-    vec2_exports.normalize(direction, [localToAxis[0], localToAxis[1]]);
-    vec2_exports.scale(direction, direction, 2 * distanceToEdge);
-    const offsetPoint = vec2_exports.create();
-    vec2_exports.subtract(offsetPoint, point, direction);
-    const interfaceQuat = quat_exports.create();
-    quat_exports.rotationTo(interfaceQuat, UP, localToAxis);
-    quat_exports.multiply(interfaceQuat, fromOrigin.quat, interfaceQuat);
-    return { point: offsetPoint, quat: interfaceQuat };
-  }
-  function findNearestOrigin(point) {
-    let minDistance = Infinity;
-    let nearest = origins[0];
-    for (const origin of origins) {
-      const distance32 = haversine(point, origin.axis);
-      if (distance32 < minDistance) {
-        minDistance = distance32;
-        nearest = origin;
-      }
-    }
-    return nearest;
-  }
-  function isNearestOrigin(point, origin) {
-    return haversine(point, origin.axis) > 0.49;
-  }
-  function haversine(point, axis) {
-    const [theta, phi] = point;
-    const [theta2, phi2] = axis;
-    const dtheta = theta2 - theta;
-    const dphi = phi2 - phi;
-    const A1 = Math.sin(dphi / 2);
-    const A2 = Math.sin(dtheta / 2);
-    const angle32 = A1 * A1 + A2 * A2 * Math.sin(phi) * Math.sin(phi2);
-    return angle32;
-  }
-  function normalizeGamma(gamma) {
-    const segment = gamma / TWO_PI_OVER_5;
-    const sCenter = Math.round(segment);
-    const sOffset = segment - sCenter;
-    const beta = sOffset * TWO_PI_OVER_5;
-    return beta;
-  }
-  function _warpBeta(beta) {
-    const shiftedBeta = beta * WARP_FACTOR;
-    return Math.tan(shiftedBeta);
-  }
-  var betaMax = PI_OVER_5;
-  var WARP_SCALER = _warpBeta(betaMax) / betaMax;
-  function warpBeta(beta) {
-    return _warpBeta(beta) / WARP_SCALER;
-  }
-  function warpRho(rho, beta) {
-    const betaRatio = Math.abs(beta) / betaMax;
-    const shiftedRho = rho * (0.95 - 0.05 * betaRatio);
-    return Math.tan(shiftedRho);
-  }
-  function warpPolar([rho, gamma]) {
-    const beta = normalizeGamma(gamma);
-    const beta2 = warpBeta(normalizeGamma(gamma));
-    const deltaBeta = beta2 - beta;
-    const scale72 = Math.cos(beta) / Math.cos(beta2);
-    const rhoOut = scale72 * rho;
-    const rhoMax = distanceToEdge / Math.cos(beta2);
-    const scaler2 = warpRho(rhoMax, beta2) / rhoMax;
-    const rhoWarped = warpRho(rhoOut, beta2) / scaler2;
-    return [rhoWarped, gamma + deltaBeta];
-  }
-  function projectGnomonic([rho, gamma]) {
-    return [gamma, Math.atan(rho)];
+  var GnomonicProjection = class {
+    /**
+     * Projects spherical coordinates to polar coordinates using gnomonic projection
+     * @param spherical Spherical coordinates [theta, phi]
+     * @returns Polar coordinates [rho, gamma]
+     */
+    forward([theta, phi]) {
+      return [Math.tan(phi), theta];
+    }
+    /**
+     * Unprojects polar coordinates to spherical coordinates using gnomonic projection
+     * @param polar Polar coordinates [rho, gamma]
+     * @returns Spherical coordinates [theta, phi]
+     */
+    inverse([rho, gamma]) {
+      return [gamma, Math.atan(rho)];
+    }
+  };
+  var midpointAB = vec3_exports.create();
+  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);
+    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);
+      const halfDistance = 0.5 * vec3_exports.length(AB);
+      return halfDistance;
+    }
+    return D;
   }
-  common_exports.setMatrixArrayType(Float64Array);
-  function projectDodecahedron(unwarped, originTransform, originRotation) {
-    const [rho, gamma] = warpPolar(unwarped);
-    const polar = [rho, gamma + originRotation];
-    const projectedSpherical = projectGnomonic(polar);
-    const projected = toCartesian(projectedSpherical);
-    vec3_exports.transformQuat(projected, projected, originTransform);
-    return toSpherical(projected);
+  function tripleProduct(A, B, C) {
+    vec3_exports.cross(crossCD, B, C);
+    return vec3_exports.dot(A, 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);
+    return vec3_exports.sub(out, scaledB, scaledA);
   }
+  function slerp2(out, A, B, t2) {
+    const gamma = vec3_exports.angle(A, B);
+    if (gamma < 1e-12) {
+      return vec3_exports.lerp(out, A, B, 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);
+    return vec3_exports.add(out, scaledA2, scaledB2);
+  }
+  common_exports.setMatrixArrayType(Float64Array);
+  var midA = vec3_exports.create();
+  var midB = vec3_exports.create();
+  var midC = vec3_exports.create();
+  var center = vec3_exports.create();
+  var SphericalPolygonShape = class {
+    constructor(vertices) {
+      this._area = null;
+      this.vertices = vertices;
+      Object.freeze(this.vertices);
+    }
+    /**
+     * 
+     * @param nSegments Returns a closed boundary of the polygon, with nSegments points per edge
+     * @returns SphericalPolygon
+     */
+    getBoundary(nSegments = 1, closedRing = true) {
+      const points = [];
+      const N = this.vertices.length;
+      for (let s2 = 0; s2 < N * nSegments; s2++) {
+        const t2 = s2 / nSegments;
+        points.push(this.slerp(t2));
+      }
+      if (closedRing) {
+        points.push(points[0]);
+      }
+      return points;
+    }
+    /**
+     * Interpolates along boundary of polygon. Pass t = 1.5 to get the midpoint between 2nd and 3rd vertices
+     * @param t 
+     * @returns Cartesian coordinate
+     */
+    slerp(t2) {
+      const N = this.vertices.length;
+      const f2 = t2 % 1;
+      const i3 = Math.floor(t2 % N);
+      const j = (i3 + 1) % N;
+      return slerp2(vec3_exports.create(), this.vertices[i3], this.vertices[j], f2);
+    }
+    /**
+     * Returns the vertex given by index t, along with the vectors:
+     * - VA: Vector from vertex to point A
+     * - VB: Vector from vertex to point B
+     * @param t 
+     * @returns 
+     */
+    getTransformedVertices(t2) {
+      const N = this.vertices.length;
+      const i3 = Math.floor(t2 % N);
+      const j = (i3 + 1) % N;
+      const k = (i3 + N - 1) % N;
+      const V2 = vec3_exports.clone(this.vertices[i3]);
+      const VA = vec3_exports.clone(this.vertices[j]);
+      const VB = vec3_exports.clone(this.vertices[k]);
+      vec3_exports.sub(VA, VA, V2);
+      vec3_exports.sub(VB, VB, V2);
+      return [V2, VA, VB];
+    }
+    containsPoint(point) {
+      const N = this.vertices.length;
+      let thetaDeltaMin = Infinity;
+      for (let i3 = 0; i3 < N; i3++) {
+        const [V2, VA, VB] = this.getTransformedVertices(i3);
+        const VP = vec3_exports.sub(vec3_exports.create(), point, V2);
+        vec3_exports.normalize(VP, VP);
+        vec3_exports.normalize(VA, VA);
+        vec3_exports.normalize(VB, VB);
+        const crossAP = vec3_exports.cross(vec3_exports.create(), VA, VP);
+        const crossPB = vec3_exports.cross(vec3_exports.create(), VP, VB);
+        const sinAP = vec3_exports.dot(V2, crossAP);
+        const sinPB = vec3_exports.dot(V2, crossPB);
+        thetaDeltaMin = Math.min(thetaDeltaMin, sinAP, sinPB);
+      }
+      return thetaDeltaMin;
+    }
+    /**
+     * Calculate the area of a spherical triangle given three vertices
+     * @param v1 First vertex
+     * @param v2 Second vertex  
+     * @param v3 Third vertex
+     * @returns Area of the spherical triangle in radians
+     */
+    getTriangleArea(v1, v2, v3) {
+      vec3_exports.lerp(midA, v2, v3, 0.5);
+      vec3_exports.lerp(midB, v3, v1, 0.5);
+      vec3_exports.lerp(midC, v1, v2, 0.5);
+      vec3_exports.normalize(midA, midA);
+      vec3_exports.normalize(midB, midB);
+      vec3_exports.normalize(midC, midC);
+      const S = tripleProduct(midA, midB, midC);
+      const clamped = Math.max(-1, Math.min(1, S));
+      if (Math.abs(clamped) < 1e-8) {
+        return 2 * clamped;
+      } else {
+        return Math.asin(clamped) * 2;
+      }
+    }
+    /**
+     * Calculate the area of the spherical polygon by decomposing it into a fan of triangles
+     * @returns The area of the spherical polygon in radians
+     */
+    getArea() {
+      if (this._area === null) {
+        this._area = this._getArea();
+      }
+      return this._area;
+    }
+    _getArea() {
+      if (this.vertices.length < 3) {
+        return 0;
+      }
+      if (this.vertices.length === 3) {
+        this._area = this.getTriangleArea(this.vertices[0], this.vertices[1], this.vertices[2]);
+        return this._area;
+      }
+      vec3_exports.set(center, 0, 0, 0);
+      for (const vertex of this.vertices) {
+        vec3_exports.add(center, center, vertex);
+      }
+      vec3_exports.normalize(center, center);
+      let area2 = 0;
+      for (let i3 = 0; i3 < this.vertices.length; i3++) {
+        const v1 = this.vertices[i3];
+        const v2 = this.vertices[(i3 + 1) % this.vertices.length];
+        const triArea = this.getTriangleArea(center, v1, v2);
+        if (!isNaN(triArea)) {
+          area2 += triArea;
+        }
+      }
+      this._area = area2;
+      return this._area;
+    }
+    /**
+     * For debugging purposes, check if the winding order is correct
+     * In production, should always be correct
+     */
+    isWindingCorrect() {
+      const area2 = this.getArea();
+      const isCorrect = area2 > 0;
+      if (!isCorrect) {
+        debugger;
+      }
+    }
+  };
+  common_exports.setMatrixArrayType(Float64Array);
+  var SphericalTriangleShape = class extends SphericalPolygonShape {
+    constructor(vertices) {
+      if (vertices.length !== 3) {
+        throw new Error("SphericalTriangleShape requires exactly 3 vertices");
+      }
+      super(vertices);
+    }
+  };
+  common_exports.setMatrixArrayType(Float64Array);
+  var PolyhedralProjection = class {
+    /**
+     * Forward projection: converts a spherical point to face coordinates
+     * @param v - The spherical point to project
+     * @param sphericalTriangle - The spherical triangle vertices
+     * @param faceTriangle - The face triangle vertices
+     * @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);
+      vec3_exports.normalize(Z, Z);
+      const p2 = quadrupleProduct(vec3_exports.create(), A, Z, B, C);
+      vec3_exports.normalize(p2, p2);
+      const h = vectorDifference(A, v2) / vectorDifference(A, 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()
+      ];
+      return barycentricToFace(b2, faceTriangle);
+    }
+    /**
+     * Inverse projection: converts face coordinates back to spherical coordinates
+     * @param facePoint - The face coordinates
+     * @param faceTriangle - The face triangle vertices
+     * @param sphericalTriangle - The spherical triangle vertices
+     * @returns The spherical coordinates
+     */
+    inverse(facePoint, faceTriangle, sphericalTriangle) {
+      const [A, B, C] = sphericalTriangle;
+      const triangleShape = new SphericalTriangleShape([A, B, C]);
+      const b2 = faceToBarycentric(facePoint, faceTriangle);
+      const threshold = 1 - 1e-14;
+      if (b2[0] > threshold)
+        return A;
+      if (b2[1] > threshold)
+        return B;
+      if (b2[2] > threshold)
+        return C;
+      const c1 = vec3_exports.create();
+      vec3_exports.cross(c1, B, C);
+      const Area_ABC = triangleShape.getArea();
+      const h = 1 - b2[0];
+      const R = b2[2] / h;
+      const alpha = R * Area_ABC;
+      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 s12 = vec3_exports.length(c1);
+      const V2 = vec3_exports.dot(A, 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 t2 = this.safeAcos(h * K) / this.safeAcos(K);
+      const out = slerp2([0, 0, 0], A, P, t2);
+      return out;
+    }
+    /**
+     * Computes acos(1 - 2 * x * x) without loss of precision for small x
+     * @param x 
+     * @returns acos(1 - x)
+     */
+    safeAcos(x2) {
+      if (x2 < 1e-3) {
+        return 2 * x2 + x2 * x2 * x2 / 3;
+      } else {
+        return Math.acos(1 - 2 * x2 * x2);
+      }
+    }
+  };
   common_exports.setMatrixArrayType(Float64Array);
   var YES = -1;
   var NO = 1;
@@ -4985,6 +5298,35 @@ var __exports__ = (() => {
     return [[NO, NO], [NO, YES], [NO, NO], [YES, NO]][n2];
   };
   var FLIP_SHIFT = vec2_exports.fromValues(-1, 1);
+  function reversePattern(pattern) {
+    return Array.from({ length: pattern.length }, (_, i3) => pattern.indexOf(i3));
+  }
+  var PATTERN = [0, 1, 3, 4, 5, 6, 7, 2];
+  var PATTERN_FLIPPED = [0, 1, 2, 7, 3, 4, 5, 6];
+  var PATTERN_REVERSED = reversePattern(PATTERN);
+  var PATTERN_FLIPPED_REVERSED = reversePattern(PATTERN_FLIPPED);
+  var _shiftDigits = (digits, i3, flips, invertJ, pattern) => {
+    if (i3 <= 0)
+      return;
+    const parentK = digits[i3] || 0;
+    const childK = digits[i3 - 1];
+    const F = flips[0] + flips[1];
+    let needsShift = true;
+    let first = true;
+    if (invertJ !== (F === 0)) {
+      needsShift = parentK === 1 || parentK === 2;
+      first = parentK === 1;
+    } else {
+      needsShift = parentK < 2;
+      first = parentK === 0;
+    }
+    if (!needsShift)
+      return;
+    const src = first ? childK : childK + 4;
+    const dst = pattern[src];
+    digits[i3 - 1] = dst % 4;
+    digits[i3] = (parentK + 4 + Math.floor(dst / 4) - Math.floor(src / 4)) % 4;
+  };
   var sToAnchor = (s2, resolution, orientation) => {
     let input = BigInt(s2);
     const reverse = orientation === "vu" || orientation === "wu" || orientation === "vw";
@@ -4993,7 +5335,7 @@ var __exports__ = (() => {
     if (reverse) {
       input = (1n << BigInt(2 * resolution)) - input - 1n;
     }
-    const anchor = _sToAnchor(input);
+    const anchor = _sToAnchor(input, resolution, invertJ, flipIJ);
     if (flipIJ) {
       const { offset: [_i, _j], flips: [flipX, flipY] } = anchor;
       anchor.offset = [_j, _i];
@@ -5011,22 +5353,29 @@ var __exports__ = (() => {
     }
     return anchor;
   };
-  var _sToAnchor = (s2) => {
-    const k = Number(s2) % 4;
+  var _sToAnchor = (s2, resolution, invertJ, flipIJ) => {
     const offset = vec2_exports.create();
     const flips = [NO, NO];
     let input = BigInt(s2);
     const digits = [];
-    while (input > 0n) {
+    while (input > 0n || digits.length < resolution) {
       digits.push(Number(input % 4n));
       input = input >> 2n;
     }
+    const pattern = flipIJ ? PATTERN_FLIPPED : PATTERN;
+    for (let i3 = digits.length - 1; i3 >= 0; i3--) {
+      _shiftDigits(digits, i3, flips, invertJ, pattern);
+      vec2_exports.multiply(flips, flips, quaternaryToFlips(digits[i3]));
+    }
+    flips[0] = NO;
+    flips[1] = NO;
     for (let i3 = digits.length - 1; i3 >= 0; i3--) {
       vec2_exports.scale(offset, offset, 2);
       const childOffset = quaternaryToKJ(digits[i3], flips);
       vec2_exports.add(offset, offset, childOffset);
       vec2_exports.multiply(flips, flips, quaternaryToFlips(digits[i3]));
     }
+    const k = digits[0] || 0;
     return { flips, k, offset: KJToIJ(offset) };
   };
   common_exports.setMatrixArrayType(Float64Array);
@@ -5034,9 +5383,9 @@ var __exports__ = (() => {
   var shiftRight = vec2_exports.clone(w);
   var shiftLeft = vec2_exports.negate(vec2_exports.create(), w);
   var QUINTANT_ROTATIONS = [0, 1, 2, 3, 4].map((quintant) => {
-    const rotation3 = mat2_exports.create();
-    mat2_exports.fromRotation(rotation3, TWO_PI_OVER_5 * quintant);
-    return rotation3;
+    const rotation2 = mat2_exports.create();
+    mat2_exports.fromRotation(rotation2, TWO_PI_OVER_5 * quintant);
+    return rotation2;
   });
   var translation = vec2_exports.create();
   function getPentagonVertices(resolution, quintant, anchor) {
@@ -5073,48 +5422,211 @@ var __exports__ = (() => {
   }
   function getFaceVertices() {
     const vertices = [];
-    for (const rotation3 of QUINTANT_ROTATIONS) {
-      vertices.push(vec2_exports.transformMat2(vec2_exports.create(), v, rotation3));
+    for (const rotation2 of QUINTANT_ROTATIONS) {
+      vertices.push(vec2_exports.transformMat2(vec2_exports.create(), v, rotation2));
     }
+    vertices.reverse();
     return new PentagonShape(vertices);
   }
   common_exports.setMatrixArrayType(Float64Array);
-  var rotation = mat2_exports.create();
-  function projectPoint(vertex, origin) {
-    const unwarped = toPolar(vertex);
-    const point = projectDodecahedron(unwarped, origin.quat, origin.angle);
-    const closest = isNearestOrigin(point, origin) ? origin : findNearestOrigin(point);
-    if (closest.id !== origin.id) {
-      const dodecPoint2 = vec2_exports.create();
-      mat2_exports.fromRotation(rotation, origin.angle);
-      vec2_exports.transformMat2(dodecPoint2, vertex, rotation);
-      const { point: offsetDodec, quat: interfaceQuat } = movePointToFace(dodecPoint2, origin, closest);
-      let angle22 = 0;
-      if (origin.angle !== closest.angle && closest.angle !== 0) {
-        angle22 = -PI_OVER_5;
-      }
-      let polar2 = toPolar(offsetDodec);
-      polar2[1] = polar2[1] - angle22;
-      const point2 = projectDodecahedron(polar2, interfaceQuat, angle22);
-      point[0] = point2[0];
-      point[1] = point2[1];
-    }
-    return toLonLat(point);
-  }
-  function projectPentagon(pentagon, origin) {
-    const vertices = pentagon.getVertices();
-    const rotatedVertices = vertices.map((vertex) => projectPoint(vertex, origin));
-    const normalizedVertices = PentagonShape.normalizeLongitudes(rotatedVertices);
-    return normalizedVertices;
-  }
-  var FIRST_HILBERT_RESOLUTION = 3;
-  var MAX_RESOLUTION = 31;
+  var CRS = class {
+    constructor() {
+      this.vertices = [];
+      this.invocations = 0;
+      this.addFaceCenters();
+      this.addVertices();
+      this.addMidpoints();
+      if (this.vertices.length !== 62) {
+        throw new Error("Failed to construct CRS: vertices length is not 62");
+      }
+      Object.freeze(this.vertices);
+    }
+    getVertex(point) {
+      this.invocations++;
+      if (this.invocations === 1e4) {
+        console.warn("Too many CRS invocations, results should be cached");
+      }
+      for (const vertex of this.vertices) {
+        if (vec3_exports.distance(point, vertex) < 1e-5) {
+          return vertex;
+        }
+      }
+      throw new Error("Failed to find vertex in CRS");
+    }
+    addFaceCenters() {
+      origins.forEach((origin) => this.add(toCartesian(origin.axis)));
+    }
+    addVertices() {
+      const phiVertex = Math.atan(distanceToVertex);
+      for (const origin of origins) {
+        for (let i3 = 0; i3 < 5; i3++) {
+          const thetaVertex = (2 * i3 + 1) * Math.PI / 5;
+          const vertex = toCartesian([thetaVertex + origin.angle, phiVertex]);
+          vec3_exports.transformQuat(vertex, vertex, origin.quat);
+          this.add(vertex);
+        }
+      }
+    }
+    addMidpoints() {
+      const phiMidpoint = Math.atan(distanceToEdge);
+      for (const origin of origins) {
+        for (let i3 = 0; i3 < 5; i3++) {
+          const thetaMidpoint = 2 * i3 * Math.PI / 5;
+          const midpoint = toCartesian([thetaMidpoint + origin.angle, phiMidpoint]);
+          vec3_exports.transformQuat(midpoint, midpoint, origin.quat);
+          this.add(midpoint);
+        }
+      }
+    }
+    add(newVertex) {
+      const normalized = vec3_exports.normalize(vec3_exports.create(), newVertex);
+      const existingVertex = this.vertices.find((existingVertex2) => vec3_exports.distance(normalized, existingVertex2) < 1e-5);
+      if (existingVertex) {
+        return false;
+      }
+      this.vertices.push(normalized);
+      return true;
+    }
+  };
+  common_exports.setMatrixArrayType(Float64Array);
+  var crs = new CRS();
+  var DodecahedronProjection = class {
+    constructor() {
+      this.faceTriangles = [];
+      this.sphericalTriangles = [];
+      this.polyhedral = new PolyhedralProjection();
+      this.gnomonic = new GnomonicProjection();
+    }
+    /**
+     * Projects spherical coordinates to face coordinates using dodecahedron projection
+     * @param spherical Spherical coordinates [theta, phi]
+     * @param originId Origin ID
+     * @returns Face coordinates [x, y]
+     */
+    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);
+      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);
+      return this.polyhedral.forward(unprojected, sphericalTriangle, faceTriangle);
+    }
+    /**
+     * Unprojects face coordinates to spherical coordinates using dodecahedron projection
+     * @param face Face coordinates [x, y]
+     * @param originId Origin ID
+     * @returns Spherical coordinates [theta, phi]
+     */
+    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 faceTriangle = this.getFaceTriangle(faceTriangleIndex, reflect, false);
+      let sphericalTriangle = this.getSphericalTriangle(faceTriangleIndex, originId2, reflect);
+      const unprojected = this.polyhedral.inverse(face, faceTriangle, sphericalTriangle);
+      return toSpherical(unprojected);
+    }
+    /**
+     * Given a polar coordinate, returns the index of the face triangle it belongs to
+     * @param polar Polar coordinates
+     * @returns Face triangle index, value from 0 to 9
+     */
+    getFaceTriangleIndex([_, gamma]) {
+      return (Math.floor(gamma / PI_OVER_5) + 10) % 10;
+    }
+    /**
+     * Gets the face triangle for a given polar coordinate
+     * @param faceTriangleIndex Face triangle index, value from 0 to 9
+     * @returns FaceTriangle: 3 vertices in counter-clockwise order
+     */
+    getFaceTriangle(faceTriangleIndex, reflected = false, squashed = false) {
+      let index = faceTriangleIndex;
+      if (reflected) {
+        index += squashed ? 20 : 10;
+      }
+      if (this.faceTriangles[index]) {
+        return this.faceTriangles[index];
+      }
+      this.faceTriangles[index] = reflected ? this._getReflectedFaceTriangle(faceTriangleIndex, squashed) : this._getFaceTriangle(faceTriangleIndex);
+      Object.freeze(this.faceTriangles[index]);
+      return this.faceTriangles[index];
+    }
+    _getFaceTriangle(faceTriangleIndex) {
+      const quintant = Math.floor((faceTriangleIndex + 1) / 2) % 5;
+      const [vCenter, vCorner1, vCorner2] = getQuintantVertices(quintant).getVertices();
+      const vEdgeMidpoint = vec2_exports.create();
+      vec2_exports.lerp(vEdgeMidpoint, vCorner1, vCorner2, 0.5);
+      const even = faceTriangleIndex % 2 === 0;
+      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));
+      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];
+    }
+    /**
+     * Gets the spherical triangle for a given face triangle index and origin
+     * @param faceTriangleIndex Face triangle index
+     * @param originId Origin ID
+     * @returns Spherical triangle
+     */
+    getSphericalTriangle(faceTriangleIndex, originId2, reflected = false) {
+      let index = 10 * originId2 + faceTriangleIndex;
+      if (reflected) {
+        index += 120;
+      }
+      if (this.sphericalTriangles[index]) {
+        return this.sphericalTriangles[index];
+      }
+      this.sphericalTriangles[index] = this._getSphericalTriangle(faceTriangleIndex, originId2, reflected);
+      Object.freeze(this.sphericalTriangles[index]);
+      return this.sphericalTriangles[index];
+    }
+    _getSphericalTriangle(faceTriangleIndex, originId2, reflected = false) {
+      const origin = origins[originId2];
+      const faceTriangle = this.getFaceTriangle(faceTriangleIndex, reflected, true);
+      const sphericalTriangle = faceTriangle.map((face) => {
+        const [rho, gamma] = toPolar(face);
+        const rotatedPolar = [rho, gamma + origin.angle];
+        const rotated = toCartesian(this.gnomonic.inverse(rotatedPolar));
+        vec3_exports.transformQuat(rotated, rotated, origin.quat);
+        return crs.getVertex(rotated);
+      });
+      return sphericalTriangle;
+    }
+    /**
+     * Normalizes gamma to the range [-PI_OVER_5, PI_OVER_5]
+     * @param gamma The gamma value to normalize
+     * @returns Normalized gamma value
+     */
+    normalizeGamma(gamma) {
+      const segment = gamma / TWO_PI_OVER_5;
+      const sCenter = Math.round(segment);
+      const sOffset = segment - sCenter;
+      const beta = sOffset * TWO_PI_OVER_5;
+      return beta;
+    }
+  };
+  var FIRST_HILBERT_RESOLUTION = 2;
+  var MAX_RESOLUTION = 30;
   var HILBERT_START_BIT = 58n;
   var REMOVAL_MASK = 0x3ffffffffffffffn;
   function getResolution(index) {
     let resolution = MAX_RESOLUTION - 1;
     let shifted = index >> 1n;
-    while (resolution > 0 && (shifted & 0b1n) === 0n) {
+    while (resolution > -1 && (shifted & 0b1n) === 0n) {
       resolution -= 1;
       shifted = shifted >> (resolution < FIRST_HILBERT_RESOLUTION ? 1n : 2n);
     }
@@ -5122,12 +5634,12 @@ var __exports__ = (() => {
   }
   function deserialize(index) {
     const resolution = getResolution(index);
-    if (resolution === 0) {
+    if (resolution === -1) {
       return { origin: origins[0], segment: 0, S: 0n, resolution };
     }
     const top6Bits = Number(index >> 58n);
     let origin, segment;
-    if (resolution === 1) {
+    if (resolution === 0) {
       const originId2 = top6Bits;
       origin = origins[originId2];
       segment = 0;
@@ -5149,7 +5661,8 @@ var __exports__ = (() => {
     return { origin, segment, S, resolution };
   }
   common_exports.setMatrixArrayType(Float64Array);
-  var rotation2 = mat2_exports.create();
+  var rotation = mat2_exports.create();
+  var dodecahedron = new DodecahedronProjection();
   function _getPentagon({ S, segment, origin, resolution }) {
     const { quintant, orientation } = segmentToQuintant(segment, origin);
     if (resolution === FIRST_HILBERT_RESOLUTION - 1) {
@@ -5162,14 +5675,28 @@ var __exports__ = (() => {
     const anchor = sToAnchor(S, hilbertResolution, orientation);
     return getPentagonVertices(hilbertResolution, quintant, anchor);
   }
-  function cellToBoundary(cellId) {
+  function cellToBoundary(cellId, { closedRing = true, segments = "auto" } = { closedRing: true, segments: "auto" }) {
     const { S, segment, origin, resolution } = deserialize(cellId);
+    if (segments === "auto") {
+      segments = Math.max(1, Math.pow(2, 6 - resolution));
+    }
     const pentagon = _getPentagon({ S, segment, origin, resolution });
-    return projectPentagon(pentagon, origin);
+    const splitPentagon = pentagon.splitEdges(segments);
+    const vertices = splitPentagon.getVertices();
+    const unprojectedVertices = vertices.map((vertex) => dodecahedron.inverse(vertex, origin.id));
+    const boundary = unprojectedVertices.map((vertex) => toLonLat(vertex));
+    const normalizedBoundary = normalizeLongitudes(boundary);
+    if (closedRing) {
+      normalizedBoundary.push(normalizedBoundary[0]);
+    }
+    normalizedBoundary.reverse();
+    return normalizedBoundary;
   }
   function hexToBigInt(hex) {
     return BigInt(`0x${hex}`);
   }
+  var AUTHALIC_RADIUS = 63710072e-1;
+  var AUTHALIC_AREA = 4 * Math.PI * AUTHALIC_RADIUS * AUTHALIC_RADIUS;
   common_exports.setMatrixArrayType(Float64Array);
 
   // src/h3-layers/h3-utils.ts
@@ -7793,7 +8320,7 @@ var __exports__ = (() => {
     out[15] = 1;
     return out;
   }
-  function lookAt(out, eye, center, up) {
+  function lookAt(out, eye, center2, up) {
     let len9;
     let x0;
     let x1;
@@ -7810,9 +8337,9 @@ var __exports__ = (() => {
     const upx = up[0];
     const upy = up[1];
     const upz = up[2];
-    const centerx = center[0];
-    const centery = center[1];
-    const centerz = center[2];
+    const centerx = center2[0];
+    const centery = center2[1];
+    const centerz = center2[2];
     if (Math.abs(eyex - centerx) < EPSILON2 && Math.abs(eyey - centery) < EPSILON2 && Math.abs(eyez - centerz) < EPSILON2) {
       return identity3(out);
     }
@@ -8344,8 +8871,8 @@ var __exports__ = (() => {
      * @returns self
      */
     lookAt(view) {
-      const { eye, center = [0, 0, 0], up = [0, 1, 0] } = view;
-      lookAt(this, eye, center, up);
+      const { eye, center: center2 = [0, 0, 0], up = [0, 1, 0] } = view;
+      lookAt(this, eye, center2, up);
       return this.check();
     }
     /**
@@ -8778,7 +9305,7 @@ var __exports__ = (() => {
     out[3] = Math.sqrt(Math.abs(1 - x2 * x2 - y2 * y2 - z * z));
     return out;
   }
-  function slerp2(out, a3, b2, t2) {
+  function slerp3(out, a3, b2, t2) {
     const ax = a3[0];
     const ay = a3[1];
     const az = a3[2];
@@ -8901,9 +9428,9 @@ var __exports__ = (() => {
     const temp1 = create12();
     const temp2 = create12();
     return function(out, a3, b2, c2, d2, t2) {
-      slerp2(temp1, a3, d2, t2);
-      slerp2(temp2, b2, c2, t2);
-      slerp2(out, temp1, temp2, 2 * t2 * (1 - t2));
+      slerp3(temp1, a3, d2, t2);
+      slerp3(temp2, b2, c2, t2);
+      slerp3(out, temp1, temp2, 2 * t2 * (1 - t2));
       return out;
     };
   }();
@@ -9150,7 +9677,7 @@ var __exports__ = (() => {
           target = arg1;
           ratio = arg2;
       }
-      slerp2(this, start, target, ratio);
+      slerp3(this, start, target, ratio);
       return this.check();
     }
     transformVector4(vector, result = new Vector4()) {
@@ -9226,7 +9753,7 @@ var __exports__ = (() => {
   var TWO_PI2 = Math.PI * 2;
 
   // src/h3-layers/h3-utils.ts
-  function normalizeLongitudes(vertices, refLng) {
+  function normalizeLongitudes2(vertices, refLng) {
     refLng = refLng === void 0 ? vertices[0][0] : refLng;
     for (const pt of vertices) {
       const deltaLng = pt[0] - refLng;
@@ -9240,7 +9767,7 @@ var __exports__ = (() => {
   function scalePolygon(hexId, vertices, factor) {
     const [lat, lng] = (0, import_h3_js.cellToLatLng)(hexId);
     const actualCount = vertices.length;
-    normalizeLongitudes(vertices, lng);
+    normalizeLongitudes2(vertices, lng);
     const vertexCount = vertices[0] === vertices[actualCount - 1] ? actualCount - 1 : actualCount;
     for (let i3 = 0; i3 < vertexCount; i3++) {
       vertices[i3][0] = lerp5(lng, vertices[i3][0], factor);
@@ -9257,7 +9784,7 @@ var __exports__ = (() => {
     if (coverage !== 1) {
       scalePolygon(hexId, vertices, coverage);
     } else {
-      normalizeLongitudes(vertices);
+      normalizeLongitudes2(vertices);
     }
     return vertices;
   }
@@ -9286,9 +9813,9 @@ var __exports__ = (() => {
         getPolygon: (x2, objectInfo) => {
           const pentagon = getPentagon(x2, objectInfo);
           const boundary = cellToBoundary(
-            typeof pentagon === "string" ? hexToBigInt(pentagon) : pentagon
+            typeof pentagon === "string" ? hexToBigInt(pentagon) : pentagon,
+            { closedRing: true, segments: "auto" }
           );
-          boundary.push(boundary[0]);
           return flattenPolygon(boundary);
         }
       };
@@ -10068,14 +10595,14 @@ var __exports__ = (() => {
     assert3(padding > 0);
     return byteLength + (padding - 1) & ~(padding - 1);
   }
-  function copyToArray(source, target, targetOffset) {
+  function copyToArray(source2, target, targetOffset) {
     let sourceArray;
-    if (source instanceof ArrayBuffer) {
-      sourceArray = new Uint8Array(source);
+    if (source2 instanceof ArrayBuffer) {
+      sourceArray = new Uint8Array(source2);
     } else {
-      const srcByteOffset = source.byteOffset;
-      const srcByteLength = source.byteLength;
-      sourceArray = new Uint8Array(source.buffer || source.arrayBuffer, srcByteOffset, srcByteLength);
+      const srcByteOffset = source2.byteOffset;
+      const srcByteLength = source2.byteLength;
+      sourceArray = new Uint8Array(source2.buffer || source2.arrayBuffer, srcByteOffset, srcByteLength);
     }
     target.set(sourceArray, targetOffset);
     return targetOffset + padToNBytes(sourceArray.byteLength, 4);
@@ -10769,9 +11296,9 @@ var __exports__ = (() => {
       abstract: xmlLayer?.Name && String(xmlLayer?.Abstract),
       keywords: getXMLStringArray(xmlLayer.KeywordList?.Keyword)
     };
-    const crs = xmlLayer?.CRS || xmlLayer?.SRS;
-    if (crs && Array.isArray(crs) && crs.every((_) => typeof _ === "string")) {
-      layer.crs = crs;
+    const crs2 = xmlLayer?.CRS || xmlLayer?.SRS;
+    if (crs2 && Array.isArray(crs2) && crs2.every((_) => typeof _ === "string")) {
+      layer.crs = crs2;
     }
     let geographicBoundingBox = xmlLayer?.EX_GeographicBoundingBox && extractEXBoundingBox(xmlLayer?.EX_GeographicBoundingBox);
     if (geographicBoundingBox) {
@@ -10833,10 +11360,10 @@ var __exports__ = (() => {
     return xmlBoxes.map((xmlBox) => extractWMSBoundingBox(xmlBox));
   }
   function extractWMSBoundingBox(xmlBoundingBox) {
-    const { CRS, SRS, minx, miny, maxx, maxy, resx, resy } = xmlBoundingBox;
+    const { CRS: CRS2, SRS, minx, miny, maxx, maxy, resx, resy } = xmlBoundingBox;
     const boundingBox = {
       // CRS in 1.3.0, SRS in 1.1.1
-      crs: CRS || SRS,
+      crs: CRS2 || SRS,
       boundingBox: [
         [getXMLFloat(minx), getXMLFloat(miny)],
         [getXMLFloat(maxx), getXMLFloat(maxy)]
@@ -12454,9 +12981,9 @@ var __exports__ = (() => {
      * @param maximum=[0, 0, 0] The maximum point along the x, y, and z axes.
      * @param center The center of the box; automatically computed if not supplied.
      */
-    constructor(minimum = [0, 0, 0], maximum = [0, 0, 0], center) {
-      center = center || scratchVector.copy(minimum).add(maximum).scale(0.5);
-      this.center = new Vector3(center);
+    constructor(minimum = [0, 0, 0], maximum = [0, 0, 0], center2) {
+      center2 = center2 || scratchVector.copy(minimum).add(maximum).scale(0.5);
+      this.center = new Vector3(center2);
       this.halfDiagonal = new Vector3(maximum).subtract(this.center);
       this.minimum = new Vector3(minimum);
       this.maximum = new Vector3(maximum);
@@ -12538,14 +13065,14 @@ var __exports__ = (() => {
   var scratchVector22 = new Vector3();
   var BoundingSphere = class {
     /** Creates a bounding sphere */
-    constructor(center = [0, 0, 0], radius = 0) {
+    constructor(center2 = [0, 0, 0], radius = 0) {
       this.radius = -0;
       this.center = new Vector3();
-      this.fromCenterRadius(center, radius);
+      this.fromCenterRadius(center2, radius);
     }
     /** Sets the bounding sphere from `center` and `radius`. */
-    fromCenterRadius(center, radius) {
-      this.center.from(center);
+    fromCenterRadius(center2, radius) {
+      this.center.from(center2);
       this.radius = radius;
       return this;
     }
@@ -12622,10 +13149,10 @@ var __exports__ = (() => {
     }
     /** Determines which side of a plane a sphere is located. */
     intersectPlane(plane) {
-      const center = this.center;
+      const center2 = this.center;
       const radius = this.radius;
       const normal = plane.normal;
-      const distanceToPlane = normal.dot(center) + plane.distance;
+      const distanceToPlane = normal.dot(center2) + plane.distance;
       if (distanceToPlane < -radius) {
         return INTERSECTION.OUTSIDE;
       }
@@ -12656,8 +13183,8 @@ var __exports__ = (() => {
     COLUMN2ROW2: 8
   };
   var OrientedBoundingBox = class {
-    constructor(center = [0, 0, 0], halfAxes = [0, 0, 0, 0, 0, 0, 0, 0, 0]) {
-      this.center = new Vector3().from(center);
+    constructor(center2 = [0, 0, 0], halfAxes = [0, 0, 0, 0, 0, 0, 0, 0, 0]) {
+      this.center = new Vector3().from(center2);
       this.halfAxes = new Matrix3(halfAxes);
     }
     /** Returns an array with three halfSizes for the bounding box */
@@ -12680,7 +13207,7 @@ var __exports__ = (() => {
     /**
      * Create OrientedBoundingBox from quaternion based OBB,
      */
-    fromCenterHalfSizeQuaternion(center, halfSize, quaternion) {
+    fromCenterHalfSizeQuaternion(center2, halfSize, quaternion) {
       const quaternionObject = new Quaternion(quaternion);
       const directionsMatrix = new Matrix3().fromQuaternion(quaternionObject);
       directionsMatrix[0] = directionsMatrix[0] * halfSize[0];
@@ -12692,7 +13219,7 @@ var __exports__ = (() => {
       directionsMatrix[6] = directionsMatrix[6] * halfSize[2];
       directionsMatrix[7] = directionsMatrix[7] * halfSize[2];
       directionsMatrix[8] = directionsMatrix[8] * halfSize[2];
-      this.center = new Vector3().from(center);
+      this.center = new Vector3().from(center2);
       this.halfAxes = directionsMatrix;
       return this;
     }
@@ -12717,14 +13244,14 @@ var __exports__ = (() => {
     }
     /** Determines which side of a plane the oriented bounding box is located. */
     intersectPlane(plane) {
-      const center = this.center;
+      const center2 = this.center;
       const normal = plane.normal;
       const halfAxes = this.halfAxes;
       const normalX = normal.x;
       const normalY = normal.y;
       const normalZ = normal.z;
       const radEffective = Math.abs(normalX * halfAxes[MATRIX3.COLUMN0ROW0] + normalY * halfAxes[MATRIX3.COLUMN0ROW1] + normalZ * halfAxes[MATRIX3.COLUMN0ROW2]) + Math.abs(normalX * halfAxes[MATRIX3.COLUMN1ROW0] + normalY * halfAxes[MATRIX3.COLUMN1ROW1] + normalZ * halfAxes[MATRIX3.COLUMN1ROW2]) + Math.abs(normalX * halfAxes[MATRIX3.COLUMN2ROW0] + normalY * halfAxes[MATRIX3.COLUMN2ROW1] + normalZ * halfAxes[MATRIX3.COLUMN2ROW2]);
-      const distanceToPlane = normal.dot(center) + plane.distance;
+      const distanceToPlane = normal.dot(center2) + plane.distance;
       if (distanceToPlane <= -radEffective) {
         return INTERSECTION.OUTSIDE;
       } else if (distanceToPlane >= radEffective) {
@@ -12787,47 +13314,47 @@ var __exports__ = (() => {
     computePlaneDistances(position, direction, result = [-0, -0]) {
       let minDist = Number.POSITIVE_INFINITY;
       let maxDist = Number.NEGATIVE_INFINITY;
-      const center = this.center;
+      const center2 = this.center;
       const halfAxes = this.halfAxes;
       const u2 = halfAxes.getColumn(0, scratchVectorU);
       const v2 = halfAxes.getColumn(1, scratchVectorV);
       const w2 = halfAxes.getColumn(2, scratchVectorW);
-      const corner = scratchCorner.copy(u2).add(v2).add(w2).add(center);
+      const corner = scratchCorner.copy(u2).add(v2).add(w2).add(center2);
       const toCenter = scratchToCenter.copy(corner).subtract(position);
       let mag = direction.dot(toCenter);
       minDist = Math.min(mag, minDist);
       maxDist = Math.max(mag, maxDist);
-      corner.copy(center).add(u2).add(v2).subtract(w2);
+      corner.copy(center2).add(u2).add(v2).subtract(w2);
       toCenter.copy(corner).subtract(position);
       mag = direction.dot(toCenter);
       minDist = Math.min(mag, minDist);
       maxDist = Math.max(mag, maxDist);
-      corner.copy(center).add(u2).subtract(v2).add(w2);
+      corner.copy(center2).add(u2).subtract(v2).add(w2);
       toCenter.copy(corner).subtract(position);
       mag = direction.dot(toCenter);
       minDist = Math.min(mag, minDist);
       maxDist = Math.max(mag, maxDist);
-      corner.copy(center).add(u2).subtract(v2).subtract(w2);
+      corner.copy(center2).add(u2).subtract(v2).subtract(w2);
       toCenter.copy(corner).subtract(position);
       mag = direction.dot(toCenter);
       minDist = Math.min(mag, minDist);
       maxDist = Math.max(mag, maxDist);
-      center.copy(corner).subtract(u2).add(v2).add(w2);
+      center2.copy(corner).subtract(u2).add(v2).add(w2);
       toCenter.copy(corner).subtract(position);
       mag = direction.dot(toCenter);
       minDist = Math.min(mag, minDist);
       maxDist = Math.max(mag, maxDist);
-      center.copy(corner).subtract(u2).add(v2).subtract(w2);
+      center2.copy(corner).subtract(u2).add(v2).subtract(w2);
       toCenter.copy(corner).subtract(position);
       mag = direction.dot(toCenter);
       minDist = Math.min(mag, minDist);
       maxDist = Math.max(mag, maxDist);
-      center.copy(corner).subtract(u2).subtract(v2).add(w2);
+      center2.copy(corner).subtract(u2).subtract(v2).add(w2);
       toCenter.copy(corner).subtract(position);
       mag = direction.dot(toCenter);
       minDist = Math.min(mag, minDist);
       maxDist = Math.max(mag, maxDist);
-      center.copy(corner).subtract(u2).subtract(v2).subtract(w2);
+      center2.copy(corner).subtract(u2).subtract(v2).subtract(w2);
       toCenter.copy(corner).subtract(position);
       mag = direction.dot(toCenter);
       minDist = Math.min(mag, minDist);
@@ -12934,7 +13461,7 @@ var __exports__ = (() => {
      */
     fromBoundingSphere(boundingSphere) {
       this.planes.length = 2 * faces.length;
-      const center = boundingSphere.center;
+      const center2 = boundingSphere.center;
       const radius = boundingSphere.radius;
       let planeIndex = 0;
       for (const faceNormal of faces) {
@@ -12946,9 +13473,9 @@ var __exports__ = (() => {
         if (!plane1) {
           plane1 = this.planes[planeIndex + 1] = new Plane();
         }
-        const plane0Center = scratchPlaneCenter.copy(faceNormal).scale(-radius).add(center);
+        const plane0Center = scratchPlaneCenter.copy(faceNormal).scale(-radius).add(center2);
         plane0.fromPointNormal(plane0Center, faceNormal);
-        const plane1Center = scratchPlaneCenter.copy(faceNormal).scale(radius).add(center);
+        const plane1Center = scratchPlaneCenter.copy(faceNormal).scale(radius).add(center2);
         const negatedFaceNormal = scratchPlaneNormal.copy(faceNormal).negate();
         plane1.fromPointNormal(plane1Center, negatedFaceNormal);
         planeIndex += 2;
@@ -13168,10 +13695,10 @@ var __exports__ = (() => {
     covarianceMatrix[7] = eyz;
     covarianceMatrix[8] = ezz;
     const { unitary } = computeEigenDecomposition(covarianceMatrix, scratchEigenResult);
-    const rotation3 = result.halfAxes.copy(unitary);
-    let v1 = rotation3.getColumn(0, scratchVector4);
-    let v2 = rotation3.getColumn(1, scratchVector5);
-    let v3 = rotation3.getColumn(2, scratchVector6);
+    const rotation2 = result.halfAxes.copy(unitary);
+    let v1 = rotation2.getColumn(0, scratchVector4);
+    let v2 = rotation2.getColumn(1, scratchVector5);
+    let v3 = rotation2.getColumn(2, scratchVector6);
     let u1 = -Number.MAX_VALUE;
     let u2 = -Number.MAX_VALUE;
     let u3 = -Number.MAX_VALUE;
@@ -14536,7 +15063,7 @@ out float vTime;
           const multiPolygon = (0, import_h3_js3.cellsToMultiPolygon)(hexagons, true);
           for (const polygon of multiPolygon) {
             for (const ring of polygon) {
-              normalizeLongitudes(ring);
+              normalizeLongitudes2(ring);
             }
             polygons.push(this.getSubLayerRow({ polygon }, object, objectInfo.index));
           }
@@ -14565,151 +15092,6 @@ out float vTime;
   var import_layers8 = __toESM(require_layers(), 1);
   var import_mesh_layers2 = __toESM(require_mesh_layers(), 1);
 
-  // ../../node_modules/@luma.gl/gltf/dist/pbr/parse-pbr-material.js
-  var import_core18 = __toESM(require_core2(), 1);
-  var GLEnum;
-  (function(GLEnum2) {
-    GLEnum2[GLEnum2["FUNC_ADD"] = 32774] = "FUNC_ADD";
-    GLEnum2[GLEnum2["ONE"] = 1] = "ONE";
-    GLEnum2[GLEnum2["SRC_ALPHA"] = 770] = "SRC_ALPHA";
-    GLEnum2[GLEnum2["ONE_MINUS_SRC_ALPHA"] = 771] = "ONE_MINUS_SRC_ALPHA";
-    GLEnum2[GLEnum2["TEXTURE_MIN_FILTER"] = 10241] = "TEXTURE_MIN_FILTER";
-    GLEnum2[GLEnum2["LINEAR"] = 9729] = "LINEAR";
-    GLEnum2[GLEnum2["LINEAR_MIPMAP_NEAREST"] = 9985] = "LINEAR_MIPMAP_NEAREST";
-    GLEnum2[GLEnum2["UNPACK_FLIP_Y_WEBGL"] = 37440] = "UNPACK_FLIP_Y_WEBGL";
-  })(GLEnum || (GLEnum = {}));
-  function parsePBRMaterial(device, material, attributes, options) {
-    const parsedMaterial = {
-      defines: {
-        // TODO: Use EXT_sRGB if available (Standard in WebGL 2.0)
-        MANUAL_SRGB: 1,
-        SRGB_FAST_APPROXIMATION: 1
-      },
-      bindings: {},
-      uniforms: {
-        // TODO: find better values?
-        camera: [0, 0, 0],
-        // Model should override
-        metallicRoughnessValues: [1, 1]
-        // Default is 1 and 1
-      },
-      parameters: {},
-      glParameters: {},
-      generatedTextures: []
-    };
-    parsedMaterial.defines.USE_TEX_LOD = 1;
-    const { imageBasedLightingEnvironment } = options;
-    if (imageBasedLightingEnvironment) {
-      parsedMaterial.bindings.pbr_diffuseEnvSampler = imageBasedLightingEnvironment.diffuseEnvSampler.texture;
-      parsedMaterial.bindings.pbr_specularEnvSampler = imageBasedLightingEnvironment.specularEnvSampler.texture;
-      parsedMaterial.bindings.pbr_BrdfLUT = imageBasedLightingEnvironment.brdfLutTexture.texture;
-      parsedMaterial.uniforms.scaleIBLAmbient = [1, 1];
-    }
-    if (options?.pbrDebug) {
-      parsedMaterial.defines.PBR_DEBUG = 1;
-      parsedMaterial.uniforms.scaleDiffBaseMR = [0, 0, 0, 0];
-      parsedMaterial.uniforms.scaleFGDSpec = [0, 0, 0, 0];
-    }
-    if (attributes.NORMAL)
-      parsedMaterial.defines.HAS_NORMALS = 1;
-    if (attributes.TANGENT && options?.useTangents)
-      parsedMaterial.defines.HAS_TANGENTS = 1;
-    if (attributes.TEXCOORD_0)
-      parsedMaterial.defines.HAS_UV = 1;
-    if (options?.imageBasedLightingEnvironment)
-      parsedMaterial.defines.USE_IBL = 1;
-    if (options?.lights)
-      parsedMaterial.defines.USE_LIGHTS = 1;
-    if (material) {
-      parseMaterial(device, material, parsedMaterial);
-    }
-    return parsedMaterial;
-  }
-  function parseMaterial(device, material, parsedMaterial) {
-    parsedMaterial.uniforms.unlit = Boolean(material.unlit);
-    if (material.pbrMetallicRoughness) {
-      parsePbrMetallicRoughness(device, material.pbrMetallicRoughness, parsedMaterial);
-    }
-    if (material.normalTexture) {
-      addTexture(device, material.normalTexture, "pbr_normalSampler", "HAS_NORMALMAP", parsedMaterial);
-      const { scale: scale26 = 1 } = material.normalTexture;
-      parsedMaterial.uniforms.normalScale = scale26;
-    }
-    if (material.occlusionTexture) {
-      addTexture(device, material.occlusionTexture, "pbr_occlusionSampler", "HAS_OCCLUSIONMAP", parsedMaterial);
-      const { strength = 1 } = material.occlusionTexture;
-      parsedMaterial.uniforms.occlusionStrength = strength;
-    }
-    if (material.emissiveTexture) {
-      addTexture(device, material.emissiveTexture, "pbr_emissiveSampler", "HAS_EMISSIVEMAP", parsedMaterial);
-      parsedMaterial.uniforms.emissiveFactor = material.emissiveFactor || [0, 0, 0];
-    }
-    switch (material.alphaMode) {
-      case "MASK":
-        const { alphaCutoff = 0.5 } = material;
-        parsedMaterial.defines.ALPHA_CUTOFF = 1;
-        parsedMaterial.uniforms.alphaCutoff = alphaCutoff;
-        break;
-      case "BLEND":
-        import_core18.log.warn("glTF BLEND alphaMode might not work well because it requires mesh sorting")();
-        parsedMaterial.parameters.blendColorOperation = "add";
-        parsedMaterial.parameters.blendColorSrcFactor = "src-alpha";
-        parsedMaterial.parameters.blendColorDstFactor = "one-minus-src-alpha";
-        parsedMaterial.parameters.blendAlphaOperation = "add";
-        parsedMaterial.parameters.blendAlphaSrcFactor = "one";
-        parsedMaterial.parameters.blendAlphaDstFactor = "one-minus-src-alpha";
-        parsedMaterial.glParameters.blend = true;
-        parsedMaterial.glParameters.blendEquation = GLEnum.FUNC_ADD;
-        parsedMaterial.glParameters.blendFunc = [
-          GLEnum.SRC_ALPHA,
-          GLEnum.ONE_MINUS_SRC_ALPHA,
-          GLEnum.ONE,
-          GLEnum.ONE_MINUS_SRC_ALPHA
-        ];
-        break;
-    }
-  }
-  function parsePbrMetallicRoughness(device, pbrMetallicRoughness, parsedMaterial) {
-    if (pbrMetallicRoughness.baseColorTexture) {
-      addTexture(device, pbrMetallicRoughness.baseColorTexture, "pbr_baseColorSampler", "HAS_BASECOLORMAP", parsedMaterial);
-    }
-    parsedMaterial.uniforms.baseColorFactor = pbrMetallicRoughness.baseColorFactor || [1, 1, 1, 1];
-    if (pbrMetallicRoughness.metallicRoughnessTexture) {
-      addTexture(device, pbrMetallicRoughness.metallicRoughnessTexture, "pbr_metallicRoughnessSampler", "HAS_METALROUGHNESSMAP", parsedMaterial);
-    }
-    const { metallicFactor = 1, roughnessFactor = 1 } = pbrMetallicRoughness;
-    parsedMaterial.uniforms.metallicRoughnessValues = [metallicFactor, roughnessFactor];
-  }
-  function addTexture(device, gltfTexture, uniformName, define2 = null, parsedMaterial) {
-    const parameters = gltfTexture?.texture?.sampler?.parameters || {};
-    const image = gltfTexture.texture.source.image;
-    let textureOptions;
-    let specialTextureParameters = {};
-    if (image.compressed) {
-      textureOptions = image;
-      specialTextureParameters = {
-        [GLEnum.TEXTURE_MIN_FILTER]: image.data.length > 1 ? GLEnum.LINEAR_MIPMAP_NEAREST : GLEnum.LINEAR
-      };
-    } else {
-      textureOptions = { data: image };
-    }
-    const texture = device.createTexture({
-      id: gltfTexture.uniformName || gltfTexture.id,
-      parameters: {
-        ...parameters,
-        ...specialTextureParameters
-      },
-      pixelStore: {
-        [GLEnum.UNPACK_FLIP_Y_WEBGL]: false
-      },
-      ...textureOptions
-    });
-    parsedMaterial.bindings[uniformName] = texture;
-    if (define2)
-      parsedMaterial.defines[define2] = 1;
-    parsedMaterial.generatedTextures.push(texture);
-  }
-
   // ../../node_modules/@loaders.gl/textures/dist/lib/utils/version.js
   var VERSION7 = true ? "4.2.1" : "latest";
 
@@ -15183,10 +15565,193 @@ out float vTime;
     parse: parseBasis
   };
 
+  // ../../node_modules/@luma.gl/gltf/dist/parsers/parse-pbr-material.js
+  var import_core18 = __toESM(require_core2(), 1);
+
+  // ../../node_modules/@luma.gl/gltf/dist/webgl-to-webgpu/convert-webgl-sampler.js
+  function convertSampler(gltfSampler) {
+    return {
+      addressModeU: convertSamplerWrapMode(gltfSampler.wrapS),
+      addressModeV: convertSamplerWrapMode(gltfSampler.wrapT),
+      magFilter: convertSamplerMagFilter(gltfSampler.magFilter),
+      ...convertSamplerMinFilter(gltfSampler.minFilter)
+    };
+  }
+  function convertSamplerWrapMode(mode) {
+    switch (mode) {
+      case 33071:
+        return "clamp-to-edge";
+      case 10497:
+        return "repeat";
+      case 33648:
+        return "mirror-repeat";
+      default:
+        return void 0;
+    }
+  }
+  function convertSamplerMagFilter(mode) {
+    switch (mode) {
+      case 9728:
+        return "nearest";
+      case 9729:
+        return "linear";
+      default:
+        return void 0;
+    }
+  }
+  function convertSamplerMinFilter(mode) {
+    switch (mode) {
+      case 9728:
+        return { minFilter: "nearest" };
+      case 9729:
+        return { minFilter: "linear" };
+      case 9984:
+        return { minFilter: "nearest", mipmapFilter: "nearest" };
+      case 9985:
+        return { minFilter: "linear", mipmapFilter: "nearest" };
+      case 9986:
+        return { minFilter: "nearest", mipmapFilter: "linear" };
+      case 9987:
+        return { minFilter: "linear", mipmapFilter: "linear" };
+      default:
+        return {};
+    }
+  }
+
+  // ../../node_modules/@luma.gl/gltf/dist/parsers/parse-pbr-material.js
+  function parsePBRMaterial(device, material, attributes, options) {
+    const parsedMaterial = {
+      defines: {
+        // TODO: Use EXT_sRGB if available (Standard in WebGL 2.0)
+        MANUAL_SRGB: true,
+        SRGB_FAST_APPROXIMATION: true
+      },
+      bindings: {},
+      uniforms: {
+        // TODO: find better values?
+        camera: [0, 0, 0],
+        // Model should override
+        metallicRoughnessValues: [1, 1]
+        // Default is 1 and 1
+      },
+      parameters: {},
+      glParameters: {},
+      generatedTextures: []
+    };
+    parsedMaterial.defines["USE_TEX_LOD"] = true;
+    const { imageBasedLightingEnvironment } = options;
+    if (imageBasedLightingEnvironment) {
+      parsedMaterial.bindings.pbr_diffuseEnvSampler = imageBasedLightingEnvironment.diffuseEnvSampler.texture;
+      parsedMaterial.bindings.pbr_specularEnvSampler = imageBasedLightingEnvironment.specularEnvSampler.texture;
+      parsedMaterial.bindings.pbr_BrdfLUT = imageBasedLightingEnvironment.brdfLutTexture.texture;
+      parsedMaterial.uniforms.scaleIBLAmbient = [1, 1];
+    }
+    if (options?.pbrDebug) {
+      parsedMaterial.defines["PBR_DEBUG"] = true;
+      parsedMaterial.uniforms.scaleDiffBaseMR = [0, 0, 0, 0];
+      parsedMaterial.uniforms.scaleFGDSpec = [0, 0, 0, 0];
+    }
+    if (attributes["NORMAL"])
+      parsedMaterial.defines["HAS_NORMALS"] = true;
+    if (attributes["TANGENT"] && options?.useTangents)
+      parsedMaterial.defines["HAS_TANGENTS"] = true;
+    if (attributes["TEXCOORD_0"])
+      parsedMaterial.defines["HAS_UV"] = true;
+    if (options?.imageBasedLightingEnvironment)
+      parsedMaterial.defines["USE_IBL"] = true;
+    if (options?.lights)
+      parsedMaterial.defines["USE_LIGHTS"] = true;
+    if (material) {
+      parseMaterial(device, material, parsedMaterial);
+    }
+    return parsedMaterial;
+  }
+  function parseMaterial(device, material, parsedMaterial) {
+    parsedMaterial.uniforms.unlit = Boolean(material.unlit);
+    if (material.pbrMetallicRoughness) {
+      parsePbrMetallicRoughness(device, material.pbrMetallicRoughness, parsedMaterial);
+    }
+    if (material.normalTexture) {
+      addTexture(device, material.normalTexture, "pbr_normalSampler", "HAS_NORMALMAP", parsedMaterial);
+      const { scale: scale26 = 1 } = material.normalTexture;
+      parsedMaterial.uniforms.normalScale = scale26;
+    }
+    if (material.occlusionTexture) {
+      addTexture(device, material.occlusionTexture, "pbr_occlusionSampler", "HAS_OCCLUSIONMAP", parsedMaterial);
+      const { strength = 1 } = material.occlusionTexture;
+      parsedMaterial.uniforms.occlusionStrength = strength;
+    }
+    if (material.emissiveTexture) {
+      addTexture(device, material.emissiveTexture, "pbr_emissiveSampler", "HAS_EMISSIVEMAP", parsedMaterial);
+      parsedMaterial.uniforms.emissiveFactor = material.emissiveFactor || [0, 0, 0];
+    }
+    switch (material.alphaMode || "MASK") {
+      case "MASK":
+        const { alphaCutoff = 0.5 } = material;
+        parsedMaterial.defines["ALPHA_CUTOFF"] = true;
+        parsedMaterial.uniforms.alphaCutoff = alphaCutoff;
+        break;
+      case "BLEND":
+        import_core18.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";
+        parsedMaterial.parameters.blendColorDstFactor = "one-minus-src-alpha";
+        parsedMaterial.parameters.blendAlphaOperation = "add";
+        parsedMaterial.parameters.blendAlphaSrcFactor = "one";
+        parsedMaterial.parameters.blendAlphaDstFactor = "one-minus-src-alpha";
+        parsedMaterial.glParameters["blend"] = true;
+        parsedMaterial.glParameters["blendEquation"] = 32774;
+        parsedMaterial.glParameters["blendFunc"] = [
+          770,
+          771,
+          1,
+          771
+        ];
+        break;
+    }
+  }
+  function parsePbrMetallicRoughness(device, pbrMetallicRoughness, parsedMaterial) {
+    if (pbrMetallicRoughness.baseColorTexture) {
+      addTexture(device, pbrMetallicRoughness.baseColorTexture, "pbr_baseColorSampler", "HAS_BASECOLORMAP", parsedMaterial);
+    }
+    parsedMaterial.uniforms.baseColorFactor = pbrMetallicRoughness.baseColorFactor || [1, 1, 1, 1];
+    if (pbrMetallicRoughness.metallicRoughnessTexture) {
+      addTexture(device, pbrMetallicRoughness.metallicRoughnessTexture, "pbr_metallicRoughnessSampler", "HAS_METALROUGHNESSMAP", parsedMaterial);
+    }
+    const { metallicFactor = 1, roughnessFactor = 1 } = pbrMetallicRoughness;
+    parsedMaterial.uniforms.metallicRoughnessValues = [metallicFactor, roughnessFactor];
+  }
+  function addTexture(device, gltfTexture, uniformName, define2, parsedMaterial) {
+    const image = gltfTexture.texture.source.image;
+    let textureOptions;
+    if (image.compressed) {
+      textureOptions = image;
+    } else {
+      textureOptions = { data: image };
+    }
+    const gltfSampler = {
+      wrapS: 10497,
+      // default REPEAT S (U) wrapping mode.
+      wrapT: 10497,
+      // default REPEAT T (V) wrapping mode.
+      ...gltfTexture?.texture?.sampler
+    };
+    const texture = device.createTexture({
+      id: gltfTexture.uniformName || gltfTexture.id,
+      sampler: convertSampler(gltfSampler),
+      ...textureOptions
+    });
+    parsedMaterial.bindings[uniformName] = texture;
+    if (define2)
+      parsedMaterial.defines[define2] = true;
+    parsedMaterial.generatedTextures.push(texture);
+  }
+
   // ../../node_modules/@luma.gl/shadertools/dist/modules/lighting/lights/lighting.js
   var import_core19 = __toESM(require_core2(), 1);
 
-  // ../../node_modules/@luma.gl/shadertools/dist/modules/lighting/lights/lighting-uniforms-glsl.js
+  // ../../node_modules/@luma.gl/shadertools/dist/modules/lighting/lights/lighting-glsl.js
   var lightingUniformsGLSL = (
     /* glsl */
     `precision highp int;
@@ -15266,7 +15831,7 @@ float getPointLightAttenuation(PointLight pointLight, float distance) {
 `
   );
 
-  // ../../node_modules/@luma.gl/shadertools/dist/modules/lighting/lights/lighting-uniforms-wgsl.js
+  // ../../node_modules/@luma.gl/shadertools/dist/modules/lighting/lights/lighting-wgsl.js
   var lightingUniformsWGSL = (
     /* wgsl */
     `// #if (defined(SHADER_TYPE_FRAGMENT) && defined(LIGHTING_FRAGMENT)) || (defined(SHADER_TYPE_VERTEX) && defined(LIGHTING_VERTEX))
@@ -15324,7 +15889,7 @@ fn getPointLightAttenuation(pointLight: PointLight, distance: f32) -> f32 {
   );
 
   // ../../node_modules/@luma.gl/shadertools/dist/modules/lighting/lights/lighting.js
-  var MAX_LIGHTS = 3;
+  var MAX_LIGHTS = 5;
   var COLOR_FACTOR = 255;
   var LIGHT_TYPE;
   (function(LIGHT_TYPE2) {
@@ -15336,14 +15901,14 @@ fn getPointLightAttenuation(pointLight: PointLight, distance: f32) -> f32 {
     uniforms: {},
     name: "lighting",
     defines: {
-      MAX_LIGHTS
+      // MAX_LIGHTS
     },
     uniformTypes: {
       enabled: "i32",
       lightType: "i32",
       directionalLightCount: "i32",
       pointLightCount: "i32",
-      ambientLightColor: "vec3<f32>",
+      ambientColor: "vec3<f32>",
       // TODO define as arrays once we have appropriate uniformTypes
       lightColor0: "vec3<f32>",
       lightPosition0: "vec3<f32>",
@@ -15364,7 +15929,7 @@ fn getPointLightAttenuation(pointLight: PointLight, distance: f32) -> f32 {
       lightType: LIGHT_TYPE.POINT,
       directionalLightCount: 0,
       pointLightCount: 0,
-      ambientLightColor: [0.1, 0.1, 0.1],
+      ambientColor: [0.1, 0.1, 0.1],
       lightColor0: [1, 1, 1],
       lightPosition0: [1, 1, 2],
       // TODO - could combine direction and attenuation
@@ -15409,7 +15974,7 @@ fn getPointLightAttenuation(pointLight: PointLight, distance: f32) -> f32 {
   }
   function getLightSourceUniforms({ ambientLight, pointLights = [], directionalLights = [] }) {
     const lightSourceUniforms = {};
-    lightSourceUniforms.ambientLightColor = convertColor(ambientLight);
+    lightSourceUniforms.ambientColor = convertColor(ambientLight);
     let currentLight = 0;
     for (const pointLight of pointLights) {
       lightSourceUniforms.lightType = LIGHT_TYPE.POINT;
@@ -15456,7 +16021,7 @@ fn getPointLightAttenuation(pointLight: PointLight, distance: f32) -> f32 {
     return color.map((component) => component * intensity / COLOR_FACTOR);
   }
 
-  // ../../node_modules/@luma.gl/shadertools/dist/modules/lighting/pbr-material/pbr-vertex-glsl.js
+  // ../../node_modules/@luma.gl/shadertools/dist/modules/lighting/pbr-material/pbr-material-glsl.js
   var vs = (
     /* glsl */
     `out vec3 pbr_vPosition;
@@ -15494,8 +16059,6 @@ void pbr_setPositionNormalTangentUV(vec4 position, vec4 normal, vec4 tangent, ve
 }
 `
   );
-
-  // ../../node_modules/@luma.gl/shadertools/dist/modules/lighting/pbr-material/pbr-fragment-glsl.js
   var fs = (
     /* glsl */
     `precision highp float;
@@ -15902,6 +16465,425 @@ vec4 pbr_filterColor(vec4 colorUnused)
 `
   );
 
+  // ../../node_modules/@luma.gl/shadertools/dist/modules/lighting/pbr-material/pbr-material-wgsl.js
+  var source = (
+    /* wgsl */
+    `struct PBRFragmentInputs {
+  pbr_vPosition: vec3f,
+  pbr_vUV: vec2f,
+  pbr_vTBN: mat3f,
+  pbr_vNormal: vec3f
+};
+
+var fragmentInputs: PBRFragmentInputs;
+
+fn pbr_setPositionNormalTangentUV(position: vec4f, normal: vec4f, tangent: vec4f, uv: vec2f)
+{
+  var pos: vec4f = pbrProjection.modelMatrix * position;
+  pbr_vPosition = vec3(pos.xyz) / pos.w;
+
+#ifdef HAS_NORMALS
+#ifdef HAS_TANGENTS
+  let normalW: vec3f = normalize(vec3(pbrProjection.normalMatrix * vec4(normal.xyz, 0.0)));
+  let tangentW: vec3f = normalize(vec3(pbrProjection.modelMatrix * vec4(tangent.xyz, 0.0)));
+  let bitangentW: vec3f = cross(normalW, tangentW) * tangent.w;
+  fragmentInputs,pbr_vTBN = mat3(tangentW, bitangentW, normalW);
+#else // HAS_TANGENTS != 1
+  fragmentInputs.pbr_vNormal = normalize(vec3(pbrProjection.modelMatrix * vec4(normal.xyz, 0.0)));
+#endif
+#endif
+
+#ifdef HAS_UV
+  pbr_vUV = uv;
+#else
+  pbr_vUV = vec2(0.,0.);
+#endif
+}
+
+struct pbrMaterialUniforms {
+  // Material is unlit
+  unlit: uint32,
+
+  // Base color map
+  baseColorMapEnabled: uint32,
+  baseColorFactor: vec4f,
+
+  normalMapEnabled : uint32,
+  normalScale: f32,  // #ifdef HAS_NORMALMAP
+
+  emissiveMapEnabled: uint32,
+  emissiveFactor: vec3f, // #ifdef HAS_EMISSIVEMAP
+
+  metallicRoughnessValues: vec2f,
+  metallicRoughnessMapEnabled: uint32,
+
+  occlusionMapEnabled: i32,
+  occlusionStrength: f32, // #ifdef HAS_OCCLUSIONMAP
+  
+  alphaCutoffEnabled: i32,
+  alphaCutoff: f32, // #ifdef ALPHA_CUTOFF
+  
+  // IBL
+  IBLenabled: i32,
+  scaleIBLAmbient: vec2f, // #ifdef USE_IBL
+  
+  // debugging flags used for shader output of intermediate PBR variables
+  // #ifdef PBR_DEBUG
+  scaleDiffBaseMR: vec4f,
+  scaleFGDSpec: vec4f
+  // #endif
+} 
+  
+@binding(2) @group(0) var<uniform> material : pbrMaterialUniforms;
+
+// Samplers
+#ifdef HAS_BASECOLORMAP
+uniform sampler2D pbr_baseColorSampler;
+#endif
+#ifdef HAS_NORMALMAP
+uniform sampler2D pbr_normalSampler;
+#endif
+#ifdef HAS_EMISSIVEMAP
+uniform sampler2D pbr_emissiveSampler;
+#endif
+#ifdef HAS_METALROUGHNESSMAP
+uniform sampler2D pbr_metallicRoughnessSampler;
+#endif
+#ifdef HAS_OCCLUSIONMAP
+uniform sampler2D pbr_occlusionSampler;
+#endif
+#ifdef USE_IBL
+uniform samplerCube pbr_diffuseEnvSampler;
+uniform samplerCube pbr_specularEnvSampler;
+uniform sampler2D pbr_brdfLUT;
+#endif
+
+// Encapsulate the various inputs used by the various functions in the shading equation
+// We store values in this struct to simplify the integration of alternative implementations
+// of the shading terms, outlined in the Readme.MD Appendix.
+struct PBRInfo {
+  NdotL: f32,                  // cos angle between normal and light direction
+  NdotV: f32,                  // cos angle between normal and view direction
+  NdotH: f32,                  // cos angle between normal and half vector
+  LdotH: f32,                  // cos angle between light direction and half vector
+  VdotH: f32,                  // cos angle between view direction and half vector
+  perceptualRoughness: f32,    // roughness value, as authored by the model creator (input to shader)
+  metalness: f32,              // metallic value at the surface
+  reflectance0: vec3f,            // full reflectance color (normal incidence angle)
+  reflectance90: vec3f,           // reflectance color at grazing angle
+  alphaRoughness: f32,         // roughness mapped to a more linear change in the roughness (proposed by [2])
+  diffuseColor: vec3f,            // color contribution from diffuse lighting
+  specularColor: vec3f,           // color contribution from specular lighting
+  n: vec3f,                       // normal at surface point
+  v: vec3f,                       // vector from surface point to camera
+};
+
+const M_PI = 3.141592653589793;
+const c_MinRoughness = 0.04;
+
+fn SRGBtoLINEAR(srgbIn: vec4f ) -> vec4f
+{
+#ifdef MANUAL_SRGB
+#ifdef SRGB_FAST_APPROXIMATION
+  var linOut: vec3f = pow(srgbIn.xyz,vec3(2.2));
+#else // SRGB_FAST_APPROXIMATION
+  var bLess: vec3f = step(vec3(0.04045),srgbIn.xyz);
+  var linOut: vec3f = mix( srgbIn.xyz/vec3(12.92), pow((srgbIn.xyz+vec3(0.055))/vec3(1.055),vec3(2.4)), bLess );
+#endif //SRGB_FAST_APPROXIMATION
+  return vec4f(linOut,srgbIn.w);;
+#else //MANUAL_SRGB
+  return srgbIn;
+#endif //MANUAL_SRGB
+}
+
+// Find the normal for this fragment, pulling either from a predefined normal map
+// or from the interpolated mesh normal and tangent attributes.
+fn getNormal() -> vec3f
+{
+  // Retrieve the tangent space matrix
+#ifndef HAS_TANGENTS
+  var pos_dx: vec3f = dFdx(pbr_vPosition);
+  var pos_dy: vec3f = dFdy(pbr_vPosition);
+  var tex_dx: vec3f = dFdx(vec3(pbr_vUV, 0.0));
+  var tex_dy: vec3f = dFdy(vec3(pbr_vUV, 0.0));
+  var t: vec3f = (tex_dy.t * pos_dx - tex_dx.t * pos_dy) / (tex_dx.s * tex_dy.t - tex_dy.s * tex_dx.t);
+
+#ifdef HAS_NORMALS
+  var ng: vec3f = normalize(pbr_vNormal);
+#else
+  var ng: vec3f = cross(pos_dx, pos_dy);
+#endif
+
+  t = normalize(t - ng * dot(ng, t));
+  var b: vec3f = normalize(cross(ng, t));
+  var tbn: mat3f = mat3f(t, b, ng);
+#else // HAS_TANGENTS
+  var tbn: mat3f = pbr_vTBN;
+#endif
+
+#ifdef HAS_NORMALMAP
+  vec3 n = texture(pbr_normalSampler, pbr_vUV).rgb;
+  n = normalize(tbn * ((2.0 * n - 1.0) * vec3(pbrMaterial.normalScale, pbrMaterial.normalScale, 1.0)));
+#else
+  // The tbn matrix is linearly interpolated, so we need to re-normalize
+  vec3 n = normalize(tbn[2].xyz);
+#endif
+
+  return n;
+}
+
+// Calculation of the lighting contribution from an optional Image Based Light source.
+// Precomputed Environment Maps are required uniform inputs and are computed as outlined in [1].
+// See our README.md on Environment Maps [3] for additional discussion.
+#ifdef USE_IBL
+fn getIBLContribution(PBRInfo pbrInfo, vec3 n, vec3 reflection) -> vec3f
+{
+  float mipCount = 9.0; // resolution of 512x512
+  float lod = (pbrInfo.perceptualRoughness * mipCount);
+  // retrieve a scale and bias to F0. See [1], Figure 3
+  vec3 brdf = SRGBtoLINEAR(texture(pbr_brdfLUT,
+    vec2(pbrInfo.NdotV, 1.0 - pbrInfo.perceptualRoughness))).rgb;
+  vec3 diffuseLight = SRGBtoLINEAR(texture(pbr_diffuseEnvSampler, n)).rgb;
+
+#ifdef USE_TEX_LOD
+  vec3 specularLight = SRGBtoLINEAR(texture(pbr_specularEnvSampler, reflection, lod)).rgb;
+#else
+  vec3 specularLight = SRGBtoLINEAR(texture(pbr_specularEnvSampler, reflection)).rgb;
+#endif
+
+  vec3 diffuse = diffuseLight * pbrInfo.diffuseColor;
+  vec3 specular = specularLight * (pbrInfo.specularColor * brdf.x + brdf.y);
+
+  // For presentation, this allows us to disable IBL terms
+  diffuse *= pbrMaterial.scaleIBLAmbient.x;
+  specular *= pbrMaterial.scaleIBLAmbient.y;
+
+  return diffuse + specular;
+}
+#endif
+
+// Basic Lambertian diffuse
+// Implementation from Lambert's Photometria https://archive.org/details/lambertsphotome00lambgoog
+// See also [1], Equation 1
+fn diffuse(pbrInfo: PBRInfo) -> vec3<f32> {
+  return pbrInfo.diffuseColor / PI;
+}
+
+// The following equation models the Fresnel reflectance term of the spec equation (aka F())
+// Implementation of fresnel from [4], Equation 15
+fn specularReflection(pbrInfo: PBRInfo) -> vec3<f32> {
+  return pbrInfo.reflectance0 +
+    (pbrInfo.reflectance90 - pbrInfo.reflectance0) *
+    pow(clamp(1.0 - pbrInfo.VdotH, 0.0, 1.0), 5.0);
+}
+
+// This calculates the specular geometric attenuation (aka G()),
+// where rougher material will reflect less light back to the viewer.
+// This implementation is based on [1] Equation 4, and we adopt their modifications to
+// alphaRoughness as input as originally proposed in [2].
+fn geometricOcclusion(pbrInfo: PBRInfo) -> f32 {
+  let NdotL: f32 = pbrInfo.NdotL;
+  let NdotV: f32 = pbrInfo.NdotV;
+  let r: f32 = pbrInfo.alphaRoughness;
+
+  let attenuationL = 2.0 * NdotL / (NdotL + sqrt(r * r + (1.0 - r * r) * (NdotL * NdotL)));
+  let attenuationV = 2.0 * NdotV / (NdotV + sqrt(r * r + (1.0 - r * r) * (NdotV * NdotV)));
+  return attenuationL * attenuationV;
+}
+
+// The following equation(s) model the distribution of microfacet normals across
+// the area being drawn (aka D())
+// Implementation from "Average Irregularity Representation of a Roughened Surface
+// for Ray Reflection" by T. S. Trowbridge, and K. P. Reitz
+// Follows the distribution function recommended in the SIGGRAPH 2013 course notes
+// from EPIC Games [1], Equation 3.
+fn microfacetDistribution(pbrInfo: PBRInfo) -> f32 {
+  let roughnessSq = pbrInfo.alphaRoughness * pbrInfo.alphaRoughness;
+  let f = (pbrInfo.NdotH * roughnessSq - pbrInfo.NdotH) * pbrInfo.NdotH + 1.0;
+  return roughnessSq / (PI * f * f);
+}
+
+fn PBRInfo_setAmbientLight(pbrInfo: ptr<function, PBRInfo>) {
+  (*pbrInfo).NdotL = 1.0;
+  (*pbrInfo).NdotH = 0.0;
+  (*pbrInfo).LdotH = 0.0;
+  (*pbrInfo).VdotH = 1.0;
+}
+
+fn PBRInfo_setDirectionalLight(pbrInfo: ptr<function, PBRInfo>, lightDirection: vec3<f32>) {
+  let n = (*pbrInfo).n;
+  let v = (*pbrInfo).v;
+  let l = normalize(lightDirection);             // Vector from surface point to light
+  let h = normalize(l + v);                      // Half vector between both l and v
+
+  (*pbrInfo).NdotL = clamp(dot(n, l), 0.001, 1.0);
+  (*pbrInfo).NdotH = clamp(dot(n, h), 0.0, 1.0);
+  (*pbrInfo).LdotH = clamp(dot(l, h), 0.0, 1.0);
+  (*pbrInfo).VdotH = clamp(dot(v, h), 0.0, 1.0);
+}
+
+fn PBRInfo_setPointLight(pbrInfo: ptr<function, PBRInfo>, pointLight: PointLight) {
+  let light_direction = normalize(pointLight.position - pbr_vPosition);
+  PBRInfo_setDirectionalLight(pbrInfo, light_direction);
+}
+
+fn calculateFinalColor(pbrInfo: PBRInfo, lightColor: vec3<f32>) -> vec3<f32> {
+  // Calculate the shading terms for the microfacet specular shading model
+  let F = specularReflection(pbrInfo);
+  let G = geometricOcclusion(pbrInfo);
+  let D = microfacetDistribution(pbrInfo);
+
+  // Calculation of analytical lighting contribution
+  let diffuseContrib = (1.0 - F) * diffuse(pbrInfo);
+  let specContrib = F * G * D / (4.0 * pbrInfo.NdotL * pbrInfo.NdotV);
+  // Obtain final intensity as reflectance (BRDF) scaled by the energy of the light (cosine law)
+  return pbrInfo.NdotL * lightColor * (diffuseContrib + specContrib);
+}
+
+fn pbr_filterColor(colorUnused: vec4<f32>) -> vec4<f32> {
+  // The albedo may be defined from a base texture or a flat color
+  var baseColor: vec4<f32>;
+  #ifdef HAS_BASECOLORMAP
+  baseColor = SRGBtoLINEAR(textureSample(pbr_baseColorSampler, pbr_baseColorSampler, pbr_vUV)) * pbrMaterial.baseColorFactor;
+  #else
+  baseColor = pbrMaterial.baseColorFactor;
+  #endif
+
+  #ifdef ALPHA_CUTOFF
+  if (baseColor.a < pbrMaterial.alphaCutoff) {
+    discard;
+  }
+  #endif
+
+  var color = vec3<f32>(0.0, 0.0, 0.0);
+
+  if (pbrMaterial.unlit) {
+    color = baseColor.rgb;
+  } else {
+    // Metallic and Roughness material properties are packed together
+    // In glTF, these factors can be specified by fixed scalar values
+    // or from a metallic-roughness map
+    var perceptualRoughness = pbrMaterial.metallicRoughnessValues.y;
+    var metallic = pbrMaterial.metallicRoughnessValues.x;
+    #ifdef HAS_METALROUGHNESSMAP
+    // Roughness is stored in the 'g' channel, metallic is stored in the 'b' channel.
+    // This layout intentionally reserves the 'r' channel for (optional) occlusion map data
+    let mrSample = textureSample(pbr_metallicRoughnessSampler, pbr_metallicRoughnessSampler, pbr_vUV);
+    perceptualRoughness = mrSample.g * perceptualRoughness;
+    metallic = mrSample.b * metallic;
+    #endif
+    perceptualRoughness = clamp(perceptualRoughness, c_MinRoughness, 1.0);
+    metallic = clamp(metallic, 0.0, 1.0);
+    // Roughness is authored as perceptual roughness; as is convention,
+    // convert to material roughness by squaring the perceptual roughness [2].
+    let alphaRoughness = perceptualRoughness * perceptualRoughness;
+
+    let f0 = vec3<f32>(0.04);
+    var diffuseColor = baseColor.rgb * (vec3<f32>(1.0) - f0);
+    diffuseColor *= 1.0 - metallic;
+    let specularColor = mix(f0, baseColor.rgb, metallic);
+
+    // Compute reflectance.
+    let reflectance = max(max(specularColor.r, specularColor.g), specularColor.b);
+
+    // For typical incident reflectance range (between 4% to 100%) set the grazing
+    // reflectance to 100% for typical fresnel effect.
+    // For very low reflectance range on highly diffuse objects (below 4%),
+    // incrementally reduce grazing reflectance to 0%.
+    let reflectance90 = clamp(reflectance * 25.0, 0.0, 1.0);
+    let specularEnvironmentR0 = specularColor;
+    let specularEnvironmentR90 = vec3<f32>(1.0, 1.0, 1.0) * reflectance90;
+
+    let n = getNormal();                          // normal at surface point
+    let v = normalize(pbrProjection.camera - pbr_vPosition);  // Vector from surface point to camera
+
+    let NdotV = clamp(abs(dot(n, v)), 0.001, 1.0);
+    let reflection = -normalize(reflect(v, n));
+
+    var pbrInfo = PBRInfo(
+      0.0, // NdotL
+      NdotV,
+      0.0, // NdotH
+      0.0, // LdotH
+      0.0, // VdotH
+      perceptualRoughness,
+      metallic,
+      specularEnvironmentR0,
+      specularEnvironmentR90,
+      alphaRoughness,
+      diffuseColor,
+      specularColor,
+      n,
+      v
+    );
+
+    #ifdef USE_LIGHTS
+    // Apply ambient light
+    PBRInfo_setAmbientLight(&pbrInfo);
+    color += calculateFinalColor(pbrInfo, lighting.ambientColor);
+
+    // Apply directional light
+    for (var i = 0; i < lighting.directionalLightCount; i++) {
+      if (i < lighting.directionalLightCount) {
+        PBRInfo_setDirectionalLight(&pbrInfo, lighting_getDirectionalLight(i).direction);
+        color += calculateFinalColor(pbrInfo, lighting_getDirectionalLight(i).color);
+      }
+    }
+
+    // Apply point light
+    for (var i = 0; i < lighting.pointLightCount; i++) {
+      if (i < lighting.pointLightCount) {
+        PBRInfo_setPointLight(&pbrInfo, lighting_getPointLight(i));
+        let attenuation = getPointLightAttenuation(lighting_getPointLight(i), distance(lighting_getPointLight(i).position, pbr_vPosition));
+        color += calculateFinalColor(pbrInfo, lighting_getPointLight(i).color / attenuation);
+      }
+    }
+    #endif
+
+    // Calculate lighting contribution from image based lighting source (IBL)
+    #ifdef USE_IBL
+    if (pbrMaterial.IBLenabled) {
+      color += getIBLContribution(pbrInfo, n, reflection);
+    }
+    #endif
+
+    // Apply optional PBR terms for additional (optional) shading
+    #ifdef HAS_OCCLUSIONMAP
+    if (pbrMaterial.occlusionMapEnabled) {
+      let ao = textureSample(pbr_occlusionSampler, pbr_occlusionSampler, pbr_vUV).r;
+      color = mix(color, color * ao, pbrMaterial.occlusionStrength);
+    }
+    #endif
+
+    #ifdef HAS_EMISSIVEMAP
+    if (pbrMaterial.emissiveMapEnabled) {
+      let emissive = SRGBtoLINEAR(textureSample(pbr_emissiveSampler, pbr_emissiveSampler, pbr_vUV)).rgb * pbrMaterial.emissiveFactor;
+      color += emissive;
+    }
+    #endif
+
+    // This section uses mix to override final color for reference app visualization
+    // of various parameters in the lighting equation.
+    #ifdef PBR_DEBUG
+    // TODO: Figure out how to debug multiple lights
+
+    // color = mix(color, F, pbr_scaleFGDSpec.x);
+    // color = mix(color, vec3(G), pbr_scaleFGDSpec.y);
+    // color = mix(color, vec3(D), pbr_scaleFGDSpec.z);
+    // color = mix(color, specContrib, pbr_scaleFGDSpec.w);
+
+    // color = mix(color, diffuseContrib, pbr_scaleDiffBaseMR.x);
+    color = mix(color, baseColor.rgb, pbrMaterial.scaleDiffBaseMR.y);
+    color = mix(color, vec3<f32>(metallic), pbrMaterial.scaleDiffBaseMR.z);
+    color = mix(color, vec3<f32>(perceptualRoughness), pbrMaterial.scaleDiffBaseMR.w);
+    #endif
+  }
+
+  return vec4<f32>(pow(color, vec3<f32>(1.0 / 2.2)), baseColor.a);
+}
+`
+  );
+
   // ../../node_modules/@luma.gl/shadertools/dist/modules/lighting/pbr-material/pbr-projection.js
   var uniformBlock2 = (
     /* glsl */
@@ -15933,19 +16915,19 @@ vec4 pbr_filterColor(vec4 colorUnused)
     uniforms: {},
     name: "pbrMaterial",
     dependencies: [lighting, pbrProjection],
+    source,
     vs,
     fs,
     defines: {
-      LIGHTING_FRAGMENT: 1
-      // TODO defining these as 0 breaks shader
-      // HAS_NORMALMAP: 0
-      // HAS_EMISSIVEMAP: 0,
-      // HAS_OCCLUSIONMAP: 0,
-      // HAS_BASECOLORMAP: 0,
-      // HAS_METALROUGHNESSMAP: 0,
-      // ALPHA_CUTOFF: 0
-      // USE_IBL: 0
-      // PBR_DEBUG: 0
+      LIGHTING_FRAGMENT: true,
+      HAS_NORMALMAP: false,
+      HAS_EMISSIVEMAP: false,
+      HAS_OCCLUSIONMAP: false,
+      HAS_BASECOLORMAP: false,
+      HAS_METALROUGHNESSMAP: false,
+      ALPHA_CUTOFF: false,
+      USE_IBL: false,
+      PBR_DEBUG: false
     },
     getUniforms: (props) => props,
     uniformTypes: {
@@ -16181,8 +17163,7 @@ void main(void) {
         pickFeatureIds: Boolean(featureIds)
       };
       const pbrProjectionProps = {
-        // Needed for PBR (TODO: find better way to get it)
-        camera: model.uniforms.cameraPosition
+        camera: this.context.viewport.cameraPosition
       };
       model.shaderInputs.setProps({
         pbrProjection: pbrProjectionProps,
@@ -18219,7 +19200,7 @@ void main(void) {
     return out;
   }
   var ortho2 = orthoNO2;
-  function lookAt2(out, eye, center, up) {
+  function lookAt2(out, eye, center2, up) {
     let len9;
     let x0;
     let x1;
@@ -18236,9 +19217,9 @@ void main(void) {
     const upx = up[0];
     const upy = up[1];
     const upz = up[2];
-    const centerx = center[0];
-    const centery = center[1];
-    const centerz = center[2];
+    const centerx = center2[0];
+    const centery = center2[1];
+    const centerz = center2[2];
     if (Math.abs(eyex - centerx) < EPSILON21 && Math.abs(eyey - centery) < EPSILON21 && Math.abs(eyez - centerz) < EPSILON21) {
       return identity5(out);
     }
@@ -18603,8 +19584,8 @@ void main(void) {
      * @returns self
      */
     lookAt(view) {
-      const { eye, center = [0, 0, 0], up = [0, 1, 0] } = view;
-      lookAt2(this, eye, center, up);
+      const { eye, center: center2 = [0, 0, 0], up = [0, 1, 0] } = view;
+      lookAt2(this, eye, center2, up);
       return this.check();
     }
     /**
@@ -19037,7 +20018,7 @@ void main(void) {
     out[3] = Math.sqrt(Math.abs(1 - x2 * x2 - y2 * y2 - z * z));
     return out;
   }
-  function slerp3(out, a3, b2, t2) {
+  function slerp4(out, a3, b2, t2) {
     const ax = a3[0];
     const ay = a3[1];
     const az = a3[2];
@@ -19160,9 +20141,9 @@ void main(void) {
     const temp1 = create17();
     const temp2 = create17();
     return function(out, a3, b2, c2, d2, t2) {
-      slerp3(temp1, a3, d2, t2);
-      slerp3(temp2, b2, c2, t2);
-      slerp3(out, temp1, temp2, 2 * t2 * (1 - t2));
+      slerp4(temp1, a3, d2, t2);
+      slerp4(temp2, b2, c2, t2);
+      slerp4(out, temp1, temp2, 2 * t2 * (1 - t2));
       return out;
     };
   }();
@@ -19409,7 +20390,7 @@ void main(void) {
           target = arg1;
           ratio = arg2;
       }
-      slerp3(this, start, target, ratio);
+      slerp4(this, start, target, ratio);
       return this.check();
     }
     transformVector4(vector, result = new Vector42()) {
@@ -20011,7 +20992,7 @@ void main(void) {
     scale: () => scale15,
     scaleAndAdd: () => scaleAndAdd3,
     set: () => set9,
-    slerp: () => slerp4,
+    slerp: () => slerp5,
     sqrDist: () => sqrDist3,
     sqrLen: () => sqrLen4,
     squaredDistance: () => squaredDistance3,
@@ -20198,7 +21179,7 @@ void main(void) {
     out[2] = az + t2 * (b2[2] - az);
     return out;
   }
-  function slerp4(out, a3, b2, t2) {
+  function slerp5(out, a3, b2, t2) {
     const angle10 = Math.acos(Math.min(Math.max(dot11(a3, b2), -1), 1));
     const sinTotal = Math.sin(angle10);
     const ratioA = Math.sin((1 - t2) * angle10) / sinTotal;
@@ -21124,7 +22105,7 @@ void main(void) {
     return out;
   }
   var ortho3 = orthoNO3;
-  function lookAt3(out, eye, center, up) {
+  function lookAt3(out, eye, center2, up) {
     let len9;
     let x0;
     let x1;
@@ -21141,9 +22122,9 @@ void main(void) {
     const upx = up[0];
     const upy = up[1];
     const upz = up[2];
-    const centerx = center[0];
-    const centery = center[1];
-    const centerz = center[2];
+    const centerx = center2[0];
+    const centery = center2[1];
+    const centerz = center2[2];
     if (Math.abs(eyex - centerx) < EPSILON23 && Math.abs(eyey - centery) < EPSILON23 && Math.abs(eyez - centerz) < EPSILON23) {
       return identity7(out);
     }
@@ -21433,8 +22414,8 @@ void main(void) {
      * @returns self
      */
     lookAt(view) {
-      const { eye, center = [0, 0, 0], up = [0, 1, 0] } = view;
-      lookAt3(this, eye, center, up);
+      const { eye, center: center2 = [0, 0, 0], up = [0, 1, 0] } = view;
+      lookAt3(this, eye, center2, up);
       return this.check();
     }
     /**
@@ -22333,7 +23314,7 @@ void main(void) {
     assert3(tileHeader);
     assert3(tile);
     const { rtcCenter, gltfUpAxis } = tile;
-    const { computedTransform, boundingVolume: { center } } = tileHeader;
+    const { computedTransform, boundingVolume: { center: center2 } } = tileHeader;
     let modelMatrix = new Matrix42(computedTransform);
     if (rtcCenter) {
       modelMatrix.translate(rtcCenter);
@@ -22355,7 +23336,7 @@ void main(void) {
     if (tile.isQuantized) {
       modelMatrix.translate(tile.quantizedVolumeOffset).scale(tile.quantizedVolumeScale);
     }
-    const cartesianOrigin = new Vector32(center);
+    const cartesianOrigin = new Vector32(center2);
     tile.cartesianModelMatrix = modelMatrix;
     tile.cartesianOrigin = cartesianOrigin;
     const cartographicOrigin = Ellipsoid.WGS84.cartesianToCartographic(cartesianOrigin, new Vector32());
@@ -24975,7 +25956,7 @@ void main(void) {
     out[15] = 1;
     return out;
   }
-  function lookAt4(out, eye, center, up) {
+  function lookAt4(out, eye, center2, up) {
     let len9;
     let x0;
     let x1;
@@ -24992,9 +25973,9 @@ void main(void) {
     const upx = up[0];
     const upy = up[1];
     const upz = up[2];
-    const centerx = center[0];
-    const centery = center[1];
-    const centerz = center[2];
+    const centerx = center2[0];
+    const centery = center2[1];
+    const centerz = center2[2];
     if (Math.abs(eyex - centerx) < EPSILON25 && Math.abs(eyey - centery) < EPSILON25 && Math.abs(eyez - centerz) < EPSILON25) {
       return identity9(out);
     }
@@ -25430,7 +26411,7 @@ void main(void) {
     out[3] = Math.sqrt(Math.abs(1 - x2 * x2 - y2 * y2 - z * z));
     return out;
   }
-  function slerp5(out, a3, b2, t2) {
+  function slerp6(out, a3, b2, t2) {
     const ax = a3[0];
     const ay = a3[1];
     const az = a3[2];
@@ -25553,9 +26534,9 @@ void main(void) {
     const temp1 = create26();
     const temp2 = create26();
     return function(out, a3, b2, c2, d2, t2) {
-      slerp5(temp1, a3, d2, t2);
-      slerp5(temp2, b2, c2, t2);
-      slerp5(out, temp1, temp2, 2 * t2 * (1 - t2));
+      slerp6(temp1, a3, d2, t2);
+      slerp6(temp2, b2, c2, t2);
+      slerp6(out, temp1, temp2, 2 * t2 * (1 - t2));
       return out;
     };
   }();
@@ -25802,7 +26783,7 @@ void main(void) {
           target = arg1;
           ratio = arg2;
       }
-      slerp5(this, start, target, ratio);
+      slerp6(this, start, target, ratio);
       return this.check();
     }
     transformVector4(vector, result = new Vector43()) {
@@ -25886,14 +26867,14 @@ void main(void) {
   var scratchVector25 = new Vector34();
   var BoundingSphere2 = class {
     /** Creates a bounding sphere */
-    constructor(center = [0, 0, 0], radius = 0) {
+    constructor(center2 = [0, 0, 0], radius = 0) {
       this.radius = -0;
       this.center = new Vector34();
-      this.fromCenterRadius(center, radius);
+      this.fromCenterRadius(center2, radius);
     }
     /** Sets the bounding sphere from `center` and `radius`. */
-    fromCenterRadius(center, radius) {
-      this.center.from(center);
+    fromCenterRadius(center2, radius) {
+      this.center.from(center2);
       this.radius = radius;
       return this;
     }
@@ -25970,10 +26951,10 @@ void main(void) {
     }
     /** Determines which side of a plane a sphere is located. */
     intersectPlane(plane) {
-      const center = this.center;
+      const center2 = this.center;
       const radius = this.radius;
       const normal = plane.normal;
-      const distanceToPlane = normal.dot(center) + plane.distance;
+      const distanceToPlane = normal.dot(center2) + plane.distance;
       if (distanceToPlane < -radius) {
         return INTERSECTION2.OUTSIDE;
       }
@@ -26004,8 +26985,8 @@ void main(void) {
     COLUMN2ROW2: 8
   };
   var OrientedBoundingBox2 = class {
-    constructor(center = [0, 0, 0], halfAxes = [0, 0, 0, 0, 0, 0, 0, 0, 0]) {
-      this.center = new Vector34().from(center);
+    constructor(center2 = [0, 0, 0], halfAxes = [0, 0, 0, 0, 0, 0, 0, 0, 0]) {
+      this.center = new Vector34().from(center2);
       this.halfAxes = new Matrix33(halfAxes);
     }
     /** Returns an array with three halfSizes for the bounding box */
@@ -26028,7 +27009,7 @@ void main(void) {
     /**
      * Create OrientedBoundingBox from quaternion based OBB,
      */
-    fromCenterHalfSizeQuaternion(center, halfSize, quaternion) {
+    fromCenterHalfSizeQuaternion(center2, halfSize, quaternion) {
       const quaternionObject = new Quaternion3(quaternion);
       const directionsMatrix = new Matrix33().fromQuaternion(quaternionObject);
       directionsMatrix[0] = directionsMatrix[0] * halfSize[0];
@@ -26040,7 +27021,7 @@ void main(void) {
       directionsMatrix[6] = directionsMatrix[6] * halfSize[2];
       directionsMatrix[7] = directionsMatrix[7] * halfSize[2];
       directionsMatrix[8] = directionsMatrix[8] * halfSize[2];
-      this.center = new Vector34().from(center);
+      this.center = new Vector34().from(center2);
       this.halfAxes = directionsMatrix;
       return this;
     }
@@ -26065,14 +27046,14 @@ void main(void) {
     }
     /** Determines which side of a plane the oriented bounding box is located. */
     intersectPlane(plane) {
-      const center = this.center;
+      const center2 = this.center;
       const normal = plane.normal;
       const halfAxes = this.halfAxes;
       const normalX = normal.x;
       const normalY = normal.y;
       const normalZ = normal.z;
       const radEffective = Math.abs(normalX * halfAxes[MATRIX32.COLUMN0ROW0] + normalY * halfAxes[MATRIX32.COLUMN0ROW1] + normalZ * halfAxes[MATRIX32.COLUMN0ROW2]) + Math.abs(normalX * halfAxes[MATRIX32.COLUMN1ROW0] + normalY * halfAxes[MATRIX32.COLUMN1ROW1] + normalZ * halfAxes[MATRIX32.COLUMN1ROW2]) + Math.abs(normalX * halfAxes[MATRIX32.COLUMN2ROW0] + normalY * halfAxes[MATRIX32.COLUMN2ROW1] + normalZ * halfAxes[MATRIX32.COLUMN2ROW2]);
-      const distanceToPlane = normal.dot(center) + plane.distance;
+      const distanceToPlane = normal.dot(center2) + plane.distance;
       if (distanceToPlane <= -radEffective) {
         return INTERSECTION2.OUTSIDE;
       } else if (distanceToPlane >= radEffective) {
@@ -26135,47 +27116,47 @@ void main(void) {
     computePlaneDistances(position, direction, result = [-0, -0]) {
       let minDist = Number.POSITIVE_INFINITY;
       let maxDist = Number.NEGATIVE_INFINITY;
-      const center = this.center;
+      const center2 = this.center;
       const halfAxes = this.halfAxes;
       const u2 = halfAxes.getColumn(0, scratchVectorU2);
       const v2 = halfAxes.getColumn(1, scratchVectorV2);
       const w2 = halfAxes.getColumn(2, scratchVectorW2);
-      const corner = scratchCorner2.copy(u2).add(v2).add(w2).add(center);
+      const corner = scratchCorner2.copy(u2).add(v2).add(w2).add(center2);
       const toCenter = scratchToCenter2.copy(corner).subtract(position);
       let mag = direction.dot(toCenter);
       minDist = Math.min(mag, minDist);
       maxDist = Math.max(mag, maxDist);
-      corner.copy(center).add(u2).add(v2).subtract(w2);
+      corner.copy(center2).add(u2).add(v2).subtract(w2);
       toCenter.copy(corner).subtract(position);
       mag = direction.dot(toCenter);
       minDist = Math.min(mag, minDist);
       maxDist = Math.max(mag, maxDist);
-      corner.copy(center).add(u2).subtract(v2).add(w2);
+      corner.copy(center2).add(u2).subtract(v2).add(w2);
       toCenter.copy(corner).subtract(position);
       mag = direction.dot(toCenter);
       minDist = Math.min(mag, minDist);
       maxDist = Math.max(mag, maxDist);
-      corner.copy(center).add(u2).subtract(v2).subtract(w2);
+      corner.copy(center2).add(u2).subtract(v2).subtract(w2);
       toCenter.copy(corner).subtract(position);
       mag = direction.dot(toCenter);
       minDist = Math.min(mag, minDist);
       maxDist = Math.max(mag, maxDist);
-      center.copy(corner).subtract(u2).add(v2).add(w2);
+      center2.copy(corner).subtract(u2).add(v2).add(w2);
       toCenter.copy(corner).subtract(position);
       mag = direction.dot(toCenter);
       minDist = Math.min(mag, minDist);
       maxDist = Math.max(mag, maxDist);
-      center.copy(corner).subtract(u2).add(v2).subtract(w2);
+      center2.copy(corner).subtract(u2).add(v2).subtract(w2);
       toCenter.copy(corner).subtract(position);
       mag = direction.dot(toCenter);
       minDist = Math.min(mag, minDist);
       maxDist = Math.max(mag, maxDist);
-      center.copy(corner).subtract(u2).subtract(v2).add(w2);
+      center2.copy(corner).subtract(u2).subtract(v2).add(w2);
       toCenter.copy(corner).subtract(position);
       mag = direction.dot(toCenter);
       minDist = Math.min(mag, minDist);
       maxDist = Math.max(mag, maxDist);
-      center.copy(corner).subtract(u2).subtract(v2).subtract(w2);
+      center2.copy(corner).subtract(u2).subtract(v2).subtract(w2);
       toCenter.copy(corner).subtract(position);
       mag = direction.dot(toCenter);
       minDist = Math.min(mag, minDist);
@@ -26282,7 +27263,7 @@ void main(void) {
      */
     fromBoundingSphere(boundingSphere) {
       this.planes.length = 2 * faces2.length;
-      const center = boundingSphere.center;
+      const center2 = boundingSphere.center;
       const radius = boundingSphere.radius;
       let planeIndex = 0;
       for (const faceNormal of faces2) {
@@ -26294,9 +27275,9 @@ void main(void) {
         if (!plane1) {
           plane1 = this.planes[planeIndex + 1] = new Plane2();
         }
-        const plane0Center = scratchPlaneCenter2.copy(faceNormal).scale(-radius).add(center);
+        const plane0Center = scratchPlaneCenter2.copy(faceNormal).scale(-radius).add(center2);
         plane0.fromPointNormal(plane0Center, faceNormal);
-        const plane1Center = scratchPlaneCenter2.copy(faceNormal).scale(radius).add(center);
+        const plane1Center = scratchPlaneCenter2.copy(faceNormal).scale(radius).add(center2);
         const negatedFaceNormal = scratchPlaneNormal3.copy(faceNormal).negate();
         plane1.fromPointNormal(plane1Center, negatedFaceNormal);
         planeIndex += 2;
@@ -26516,10 +27497,10 @@ void main(void) {
     covarianceMatrix[7] = eyz;
     covarianceMatrix[8] = ezz;
     const { unitary } = computeEigenDecomposition2(covarianceMatrix, scratchEigenResult2);
-    const rotation3 = result.halfAxes.copy(unitary);
-    let v1 = rotation3.getColumn(0, scratchVector42);
-    let v2 = rotation3.getColumn(1, scratchVector52);
-    let v3 = rotation3.getColumn(2, scratchVector62);
+    const rotation2 = result.halfAxes.copy(unitary);
+    let v1 = rotation2.getColumn(0, scratchVector42);
+    let v2 = rotation2.getColumn(1, scratchVector52);
+    let v3 = rotation2.getColumn(2, scratchVector62);
     let u1 = -Number.MAX_VALUE;
     let u2 = -Number.MAX_VALUE;
     let u3 = -Number.MAX_VALUE;
@@ -26781,8 +27762,8 @@ void main(void) {
     throw new Error("Unkown boundingVolume type");
   }
   function createBox(box, transform2, result) {
-    const center = new Vector32(box[0], box[1], box[2]);
-    transform2.transform(center, center);
+    const center2 = new Vector32(box[0], box[1], box[2]);
+    transform2.transform(center2, center2);
     let origin = [];
     if (box.length === 10) {
       const halfSize = box.slice(3, 6);
@@ -26816,24 +27797,24 @@ void main(void) {
       zAxis[2]
     ]);
     if (defined(result)) {
-      result.center = center;
+      result.center = center2;
       result.halfAxes = halfAxes;
       return result;
     }
-    return new OrientedBoundingBox2(center, halfAxes);
+    return new OrientedBoundingBox2(center2, halfAxes);
   }
   function createSphere(sphere, transform2, result) {
-    const center = new Vector32(sphere[0], sphere[1], sphere[2]);
-    transform2.transform(center, center);
+    const center2 = new Vector32(sphere[0], sphere[1], sphere[2]);
+    transform2.transform(center2, center2);
     const scale26 = transform2.getScale(scratchScale);
     const uniformScale = Math.max(Math.max(scale26[0], scale26[1]), scale26[2]);
     const radius = sphere[3] * uniformScale;
     if (defined(result)) {
-      result.center = center;
+      result.center = center2;
       result.radius = radius;
       return result;
     }
-    return new BoundingSphere2(center, radius);
+    return new BoundingSphere2(center2, radius);
   }
   function createObbFromRegion(region) {
     const [west, south, east, north, minHeight, maxHeight] = region;
@@ -26875,8 +27856,8 @@ void main(void) {
   }
   function boundingSphereToCartographicBounds(boundingVolume) {
     const result = emptyCartographicBounds();
-    const { center, radius } = boundingVolume;
-    const point = Ellipsoid.WGS84.scaleToGeodeticSurface(center, scratchPoint);
+    const { center: center2, radius } = boundingVolume;
+    const point = Ellipsoid.WGS84.scaleToGeodeticSurface(center2, scratchPoint);
     let zAxis;
     if (point) {
       zAxis = Ellipsoid.WGS84.geodeticSurfaceNormal(point);
@@ -26893,7 +27874,7 @@ void main(void) {
     for (const axis of [xAxis, yAxis, zAxis]) {
       scratchScale.copy(axis).scale(radius);
       for (let dir = 0; dir < 2; dir++) {
-        scratchPoint.copy(center);
+        scratchPoint.copy(center2);
         scratchPoint.add(scratchScale);
         addToCartographicBounds(result, scratchPoint);
         scratchScale.negate();
@@ -28554,20 +29535,20 @@ void main(void) {
      */
     calculateViewPropsTiles3D() {
       const root = this.root;
-      const { center } = root.boundingVolume;
-      if (!center) {
+      const { center: center2 } = root.boundingVolume;
+      if (!center2) {
         console.warn("center was not pre-calculated for the root tile");
         this.cartographicCenter = new Vector32();
         this.zoom = 1;
         return;
       }
-      if (center[0] !== 0 || center[1] !== 0 || center[2] !== 0) {
+      if (center2[0] !== 0 || center2[1] !== 0 || center2[2] !== 0) {
         this.cartographicCenter = new Vector32();
-        Ellipsoid.WGS84.cartesianToCartographic(center, this.cartographicCenter);
+        Ellipsoid.WGS84.cartesianToCartographic(center2, this.cartographicCenter);
       } else {
         this.cartographicCenter = new Vector32(0, 0, -Ellipsoid.WGS84.radii[0]);
       }
-      this.cartesianCenter = center;
+      this.cartesianCenter = center2;
       this.zoom = getZoomFromBoundingVolume(root.boundingVolume, this.cartographicCenter);
     }
     _initializeStats() {
@@ -32509,7 +33490,7 @@ void main(void) {
     return out;
   }
   var ortho5 = orthoNO5;
-  function lookAt5(out, eye, center, up) {
+  function lookAt5(out, eye, center2, up) {
     let len9;
     let x0;
     let x1;
@@ -32526,9 +33507,9 @@ void main(void) {
     const upx = up[0];
     const upy = up[1];
     const upz = up[2];
-    const centerx = center[0];
-    const centery = center[1];
-    const centerz = center[2];
+    const centerx = center2[0];
+    const centery = center2[1];
+    const centerz = center2[2];
     if (Math.abs(eyex - centerx) < EPSILON28 && Math.abs(eyey - centery) < EPSILON28 && Math.abs(eyez - centerz) < EPSILON28) {
       return identity11(out);
     }
@@ -32893,8 +33874,8 @@ void main(void) {
      * @returns self
      */
     lookAt(view) {
-      const { eye, center = [0, 0, 0], up = [0, 1, 0] } = view;
-      lookAt5(this, eye, center, up);
+      const { eye, center: center2 = [0, 0, 0], up = [0, 1, 0] } = view;
+      lookAt5(this, eye, center2, up);
       return this.check();
     }
     /**
@@ -33327,7 +34308,7 @@ void main(void) {
     out[3] = Math.sqrt(Math.abs(1 - x2 * x2 - y2 * y2 - z * z));
     return out;
   }
-  function slerp6(out, a3, b2, t2) {
+  function slerp7(out, a3, b2, t2) {
     const ax = a3[0];
     const ay = a3[1];
     const az = a3[2];
@@ -33450,9 +34431,9 @@ void main(void) {
     const temp1 = create33();
     const temp2 = create33();
     return function(out, a3, b2, c2, d2, t2) {
-      slerp6(temp1, a3, d2, t2);
-      slerp6(temp2, b2, c2, t2);
-      slerp6(out, temp1, temp2, 2 * t2 * (1 - t2));
+      slerp7(temp1, a3, d2, t2);
+      slerp7(temp2, b2, c2, t2);
+      slerp7(out, temp1, temp2, 2 * t2 * (1 - t2));
       return out;
     };
   }();
@@ -33699,7 +34680,7 @@ void main(void) {
           target = arg1;
           ratio = arg2;
       }
-      slerp6(this, start, target, ratio);
+      slerp7(this, start, target, ratio);
       return this.check();
     }
     transformVector4(vector, result = new Vector44()) {
@@ -36397,9 +37378,9 @@ void main(void) {
     TRIANGLES: "meshopt_decodeIndexBuffer",
     INDICES: "meshopt_decodeIndexSequence"
   };
-  async function meshoptDecodeGltfBuffer(target, count, size, source, mode, filter = "NONE") {
+  async function meshoptDecodeGltfBuffer(target, count, size, source2, mode, filter = "NONE") {
     const instance = await loadWasmInstance();
-    decode4(instance, instance.exports[DECODERS[mode]], target, count, size, source, instance.exports[FILTERS[filter || "NONE"]]);
+    decode4(instance, instance.exports[DECODERS[mode]], target, count, size, source2, instance.exports[FILTERS[filter || "NONE"]]);
   }
   var wasmPromise;
   async function loadWasmInstance() {
@@ -36430,14 +37411,14 @@ void main(void) {
     }
     return result.buffer.slice(0, write);
   }
-  function decode4(instance, fun, target, count, size, source, filter) {
+  function decode4(instance, fun, target, count, size, source2, filter) {
     const sbrk = instance.exports.sbrk;
     const count4 = count + 3 & ~3;
     const tp = sbrk(count4 * size);
-    const sp = sbrk(source.length);
+    const sp = sbrk(source2.length);
     const heap = new Uint8Array(instance.exports.memory.buffer);
-    heap.set(source, sp);
-    const res = fun(tp, count, size, sp, source.length);
+    heap.set(source2, sp);
+    const res = fun(tp, count, size, sp, source2.length);
     if (res === 0 && filter) {
       filter(tp, count4, size);
     }
@@ -36468,9 +37449,9 @@ void main(void) {
     if (meshoptExtension) {
       const { byteOffset = 0, byteLength = 0, byteStride, count, mode, filter = "NONE", buffer: bufferIndex } = meshoptExtension;
       const buffer = scenegraph.gltf.buffers[bufferIndex];
-      const source = new Uint8Array(buffer.arrayBuffer, buffer.byteOffset + byteOffset, byteLength);
+      const source2 = new Uint8Array(buffer.arrayBuffer, buffer.byteOffset + byteOffset, byteLength);
       const result = new Uint8Array(scenegraph.gltf.buffers[bufferView.buffer].arrayBuffer, bufferView.byteOffset, bufferView.byteLength);
-      await meshoptDecodeGltfBuffer(result, count, byteStride, source, mode, filter);
+      await meshoptDecodeGltfBuffer(result, count, byteStride, source2, mode, filter);
       scenegraph.removeObjectExtension(bufferView, EXT_MESHOPT_COMPRESSION);
     }
   }
@@ -38048,9 +39029,9 @@ void main(void) {
     primitive.attributes[`TEXCOORD_${newTexCoord}`] = accessors.length - 1;
   }
   function makeTransformationMatrix(extensionData) {
-    const { offset = [0, 0], rotation: rotation3 = 0, scale: scale26 = [1, 1] } = extensionData;
+    const { offset = [0, 0], rotation: rotation2 = 0, scale: scale26 = [1, 1] } = extensionData;
     const translationMatrix = new Matrix35().set(1, 0, 0, 0, 1, 0, offset[0], offset[1], 1);
-    const rotationMatrix = scratchRotationMatrix.set(Math.cos(rotation3), Math.sin(rotation3), 0, -Math.sin(rotation3), Math.cos(rotation3), 0, 0, 0, 1);
+    const rotationMatrix = scratchRotationMatrix.set(Math.cos(rotation2), Math.sin(rotation2), 0, -Math.sin(rotation2), Math.cos(rotation2), 0, 0, 0, 1);
     const scaleMatrix = scratchScaleMatrix.set(scale26[0], 0, 0, 0, scale26[1], 0, 0, 0, 1);
     return translationMatrix.multiplyRight(rotationMatrix).multiplyRight(scaleMatrix);
   }
@@ -40563,9 +41544,9 @@ void main(void) {
       maximumHeight: s2VolumeInfo.maximumHeight
     };
     const corners = getS2OrientedBoundingBoxCornerPoints(token, heightInfo);
-    const center = getS2LngLat(token);
-    const centerLng = center[0];
-    const centerLat = center[1];
+    const center2 = getS2LngLat(token);
+    const centerLng = center2[0];
+    const centerLat = center2[1];
     const point = Ellipsoid.WGS84.cartographicToCartesian([
       centerLng,
       centerLat,
@@ -42391,7 +43372,7 @@ void main(void) {
       const elevationDataChanged = props.elevationData !== oldProps.elevationData;
       if (elevationDataChanged) {
         const { elevationData } = props;
-        const isTiled = elevationData && (Array.isArray(elevationData) || elevationData.includes("{x}") && elevationData.includes("{y}"));
+        const isTiled = elevationData && (Array.isArray(elevationData) || isTileSetURL(elevationData));
         this.setState({ isTiled });
       }
       const shouldReload = elevationDataChanged || props.meshMaxError !== oldProps.meshMaxError || props.elevationDecoder !== oldProps.elevationDecoder || props.bounds !== oldProps.bounds;
@@ -42573,6 +43554,7 @@ void main(void) {
   };
   TerrainLayer.defaultProps = defaultProps13;
   TerrainLayer.layerName = "TerrainLayer";
+  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);