@loaders.gl/tiles 5.0.0-alpha.13 → 5.0.0-alpha.14

package/dist/dist.dev.js

@@ -741,10 +741,10 @@ var __exports__ = (() => {
       }
     }
   }
-  function getSourceLocation(source, offset) {
+  function getSourceLocation(source, offset2) {
     let line = 1;
     let column = 1;
-    for (let index = 0; index < offset && index < source.length; index++) {
+    for (let index = 0; index < offset2 && index < source.length; index++) {
       if (source[index] === "\n") {
         line++;
         column = 1;
@@ -759,11 +759,11 @@ var __exports__ = (() => {
     "../../node_modules/@math.gl/geospatial/dist/crs/wkt-crs.js"() {
       WKTCRSSyntaxError = class extends SyntaxError {
         /** Create a WKT syntax error at a source location. */
-        constructor(message, source, offset) {
-          const location = getSourceLocation(source, offset);
+        constructor(message, source, offset2) {
+          const location = getSourceLocation(source, offset2);
           super(`${message} at ${location.line}:${location.column}`);
           this.name = "WKTCRSSyntaxError";
-          this.offset = offset;
+          this.offset = offset2;
           this.line = location.line;
           this.column = location.column;
         }
@@ -1080,85 +1080,85 @@ var __exports__ = (() => {
     const parameters = tokens.map((token) => parseParameter(token.raw, token.offset, text));
     return { type: "proj-string", parameters };
   }
-  function parseParameter(rawToken, offset, source) {
+  function parseParameter(rawToken, offset2, source) {
     const token = rawToken.startsWith("+") ? rawToken.slice(1) : rawToken;
     if (!token) {
-      throw new PROJStringSyntaxError("Expected a parameter after '+'", source, offset);
+      throw new PROJStringSyntaxError("Expected a parameter after '+'", source, offset2);
     }
     const equalsIndex = token.indexOf("=");
     const name = equalsIndex < 0 ? token : token.slice(0, equalsIndex);
     if (!name || /[\s+=]/.test(name)) {
-      throw new PROJStringSyntaxError(`Invalid PROJ parameter name '${name}'`, source, offset);
+      throw new PROJStringSyntaxError(`Invalid PROJ parameter name '${name}'`, source, offset2);
     }
     if (equalsIndex < 0) {
       return { type: "parameter", name };
     }
     const rawValue = token.slice(equalsIndex + 1);
-    const value = decodeParameterValue(rawValue, source, offset + equalsIndex + 1);
+    const value = decodeParameterValue(rawValue, source, offset2 + equalsIndex + 1);
     return { type: "parameter", name, value, rawValue };
   }
   function tokenizePROJString(source) {
     const tokens = [];
-    let offset = 0;
-    while (offset < source.length) {
-      while (offset < source.length && /\s/.test(source[offset])) {
-        offset++;
+    let offset2 = 0;
+    while (offset2 < source.length) {
+      while (offset2 < source.length && /\s/.test(source[offset2])) {
+        offset2++;
       }
-      if (offset >= source.length) {
+      if (offset2 >= source.length) {
         break;
       }
-      const start = offset;
+      const start = offset2;
       let quote = null;
       let escaped = false;
-      while (offset < source.length) {
-        const character = source[offset];
+      while (offset2 < source.length) {
+        const character = source[offset2];
         if (escaped) {
           escaped = false;
-          offset++;
+          offset2++;
           continue;
         }
         if (character === "\\" && quote) {
           escaped = true;
-          offset++;
+          offset2++;
           continue;
         }
         if (quote) {
           if (character === quote) {
             quote = null;
           }
-          offset++;
+          offset2++;
           continue;
         }
-        if ((character === '"' || character === "'") && source[offset - 1] === "=") {
+        if ((character === '"' || character === "'") && source[offset2 - 1] === "=") {
           quote = character;
-          offset++;
+          offset2++;
           continue;
         }
         if (/\s/.test(character)) {
           break;
         }
-        offset++;
+        offset2++;
       }
       if (quote) {
         throw new PROJStringSyntaxError("Unterminated quoted PROJ value", source, start);
       }
-      tokens.push({ raw: source.slice(start, offset), offset: start });
+      tokens.push({ raw: source.slice(start, offset2), offset: start });
     }
     return tokens;
   }
-  function decodeParameterValue(rawValue, source, offset) {
+  function decodeParameterValue(rawValue, source, offset2) {
     if (!rawValue) {
       return "";
     }
     const first = rawValue[0];
     if (first !== '"' && first !== "'") {
       if ((rawValue.includes('"') || rawValue.includes("'")) && !DMS_VALUE.test(rawValue)) {
-        throw new PROJStringSyntaxError("Quote must begin a PROJ parameter value", source, offset);
+        throw new PROJStringSyntaxError("Quote must begin a PROJ parameter value", source, offset2);
       }
       return rawValue;
     }
     if (rawValue[rawValue.length - 1] !== first) {
-      throw new PROJStringSyntaxError("Unterminated quoted PROJ value", source, offset);
+      throw new PROJStringSyntaxError("Unterminated quoted PROJ value", source, offset2);
     }
     let value = "";
     for (let index = 1; index < rawValue.length - 1; index++) {
@@ -1171,10 +1171,10 @@ var __exports__ = (() => {
     }
     return value;
   }
-  function getSourceLocation2(source, offset) {
+  function getSourceLocation2(source, offset2) {
     let line = 1;
     let column = 1;
-    for (let index = 0; index < offset && index < source.length; index++) {
+    for (let index = 0; index < offset2 && index < source.length; index++) {
       if (source[index] === "\n") {
         line++;
         column = 1;
@@ -1189,11 +1189,11 @@ var __exports__ = (() => {
     "../../node_modules/@math.gl/geospatial/dist/crs/proj-string.js"() {
       PROJStringSyntaxError = class extends SyntaxError {
         /** Create a PROJ string syntax error at a source location. */
-        constructor(message, source, offset) {
-          const location = getSourceLocation2(source, offset);
+        constructor(message, source, offset2) {
+          const location = getSourceLocation2(source, offset2);
           super(`${message} at ${location.line}:${location.column}`);
           this.name = "PROJStringSyntaxError";
-          this.offset = offset;
+          this.offset = offset2;
           this.line = location.line;
           this.column = location.column;
         }
@@ -1379,15 +1379,15 @@ var __exports__ = (() => {
         clone() {
           return new this.constructor().copy(this);
         }
-        fromArray(array, offset = 0) {
+        fromArray(array, offset2 = 0) {
           for (let i = 0; i < this.ELEMENTS; ++i) {
-            this[i] = array[i + offset];
+            this[i] = array[i + offset2];
           }
           return this.check();
         }
-        toArray(targetArray = [], offset = 0) {
+        toArray(targetArray = [], offset2 = 0) {
           for (let i = 0; i < this.ELEMENTS; ++i) {
-            targetArray[offset + i] = this[i];
+            targetArray[offset2 + i] = this[i];
           }
           return targetArray;
         }
@@ -3815,19 +3815,19 @@ var __exports__ = (() => {
         slerp(arg0, arg1, arg2) {
           let start;
           let target;
-          let ratio;
+          let ratio2;
           switch (arguments.length) {
             case 2:
               start = this;
               target = arg0;
-              ratio = arg1;
+              ratio2 = arg1;
               break;
             default:
               start = arg0;
               target = arg1;
-              ratio = arg2;
+              ratio2 = arg2;
           }
-          slerp(this, start, target, ratio);
+          slerp(this, start, target, ratio2);
           return this.check();
         }
         // THREE.js Math API compatibility
@@ -3863,29 +3863,30 @@ var __exports__ = (() => {
   function spheroidToCartesian(point, geometry, result = point) {
     const longitude = point.x, latitude = point.y, height = point.z;
     const { semiMajorAxis: a, semiMinorAxis: b, eccentricitySquared: es } = geometry;
-    const sin = Math.sin(latitude), cos = Math.cos(latitude);
-    const ratio = b / a;
-    const radius = es < 0.9 ? a / Math.sqrt(1 - es * sin * sin) : a / Math.hypot(cos, ratio * sin);
+    const sin = Math.sin(latitude), cos = Math.abs(latitude) === Math.PI / 2 ? 0 : Math.cos(latitude);
+    const ratio2 = b / a;
+    const radius = es < 0.9 ? a / Math.sqrt(1 - es * sin * sin) : a / Math.hypot(cos, ratio2 * sin);
     const x = (radius + height) * cos * Math.cos(longitude);
     const y = (radius + height) * cos * Math.sin(longitude);
-    const z = (radius * (es < 0.9 ? 1 - es : ratio * ratio) + height) * sin;
+    const z = (radius * (es < 0.9 ? 1 - es : ratio2 * ratio2) + height) * sin;
     return commit(result, x, y, z);
   }
   function cartesianToSpheroid(point, geometry, result = point) {
     const x = point.x, y = point.y, z = point.z;
     const { semiMajorAxis: a, semiMinorAxis: b, eccentricitySquared: es } = geometry;
+    const longitude = Math.atan2(y, x);
     const p = Math.hypot(x, y), rr = Math.hypot(x, y, z);
     if (!(rr > 0) || !Number.isFinite(rr))
       return false;
     if (es === 0)
-      return commit(result, p === 0 ? 0 : Math.atan2(y, x), Math.atan2(z, p), rr - a);
+      return commit(result, p === 0 ? 0 : longitude, Math.atan2(z, p), rr - a);
     if (p === 0)
       return commit(result, 0, Math.sign(z) * Math.PI / 2, Math.abs(z) - b);
     const horizontal = p / a, vertical = z / b;
-    if (horizontal * horizontal + vertical * vertical < 1 - 16 * Number.EPSILON)
+    if (horizontal * horizontal + vertical * vertical < 1 - 16 * EPSILON21)
       return interiorInverse(x, y, z, p, a, b, result);
     if (es >= 0.9)
-      return exteriorInverse(x, y, z, p, a, b, result);
+      return interiorInverse(x, y, z, p, a, b, result);
     const ct = z / rr, st = p / rr;
     let rx = 1 / Math.sqrt(1 - es * (2 - es) * st * st);
     let cos = st * (1 - es) * rx, sin = ct * rx;
@@ -3896,64 +3897,65 @@ var __exports__ = (() => {
       rx = 1 / Math.sqrt(1 - rk * (2 - rk) * st * st);
       const nextCos = st * (1 - rk) * rx, nextSin = ct * rx;
       if (Math.abs(nextSin * cos - nextCos * sin) <= 1e-12) {
-        if (!Number.isFinite(height) || !Number.isFinite(nextSin) || !Number.isFinite(nextCos))
+        if (!Number.isFinite(height))
           break;
-        return commit(result, Math.atan2(y, x), Math.atan2(nextSin, Math.abs(nextCos)), height);
+        return commit(result, longitude, Math.atan2(nextSin, Math.abs(nextCos)), height);
       }
       cos = nextCos;
       sin = nextSin;
     }
-    return exteriorInverse(x, y, z, p, a, b, result);
+    return interiorInverse(x, y, z, p, a, b, result);
   }
   function interiorInverse(x, y, z, p, a, b, result) {
-    const ratio = b / a, ratio2 = ratio * ratio;
-    const horizontal = p / a, vertical = z / a, delta = 1 - ratio2;
-    if (!(ratio2 > 0) || ratio > 1)
+    const longitude = Math.atan2(y, x);
+    const ratio2 = b / a, ratio22 = ratio2 * ratio2;
+    const horizontal = p / a, vertical = z / a, delta = 1 - ratio22;
+    if (!(ratio22 > 0) || ratio2 > 1)
       return false;
-    if (z === 0) {
-      if (horizontal < delta)
-        return false;
-      return commit(result, Math.atan2(y, x), 0, p - a);
-    }
     const aa = a * a, bb = b * b;
-    const ratioError = Number.isFinite(aa) && aa > 0 ? (bb - ratio2 * aa + productError(b, b, bb) - ratio2 * productError(a, a, aa) - productError(ratio2, aa, ratio2 * aa)) / aa : 0;
+    const ratioError = Number.isFinite(aa) && aa > 0 ? (bb - ratio22 * aa + productError(b, b, bb) - ratio22 * productError(a, a, aa) - productError(ratio22, aa, ratio22 * aa)) / aa : 0;
     const pp = p * p, xx = x * x, yy = y * y, sum = xx + yy;
     const radiusError = Number.isFinite(pp) && pp > 0 ? (sum - pp + sumError(xx, yy, sum) + productError(x, x, xx) + productError(y, y, yy) - productError(p, p, pp)) / (2 * p) : 0;
-    const shift = a * ratio2, base = p - a + shift;
-    const correction = radiusError + sumError(p - a, shift, base) + productError(a, ratio2, shift) + a * ratioError;
-    const weighted = Math.abs(vertical) * ratio;
-    if (!(weighted > 0))
+    const shift = a * ratio22, distance = p - a, base = distance + shift;
+    const correction = radiusError + sumError(p, -a, distance) + sumError(distance, shift, base) + productError(a, ratio22, shift) + a * ratioError;
+    if (z === 0) {
+      if (base + correction < 0)
+        return false;
+      return commit(result, longitude, 0, distance);
+    }
+    const weighted = Math.abs(vertical) * ratio2;
+    let lower = 0, upper = ratio22 + Math.hypot(horizontal, vertical * ratio2);
+    if (!Number.isFinite(upper))
       return false;
-    let lower = 0, upper = ratio2;
     let t = Math.max(weighted, horizontal - delta);
     if (!(t > lower && t < upper))
       t = upper / 2;
-    for (let i = 0; i < 128; i++) {
+    const gap = -(base + correction) / a;
+    const limiting = Math.sqrt(gap * (horizontal + delta)) / delta;
+    let latitude = gap > 0 && Math.abs(z) / limiting / a * ratio2 <= EPSILON21 * gap ? Math.atan2(Math.sign(z) * limiting / ratio2, horizontal / delta) : void 0;
+    for (let i = 0; i < 1024 && latitude === void 0; i++) {
       const equatorial = delta + t;
-      const u = horizontal / equatorial, v = weighted / t;
+      const u = horizontal / equatorial, verticalAt = z / t / a, v = verticalAt * ratio2;
       const at = a * t, difference = base - at;
-      const offset = (difference + (sumError(base, -at, difference) + correction - productError(a, t, at))) / (a * equatorial);
-      const term = offset * (u + 1);
+      const offset2 = (difference + (sumError(base, -at, difference) + correction - productError(a, t, at))) / (a * equatorial);
+      const term = offset2 * (u + 1);
       const residual = term + v * v;
-      if (Math.abs(residual) <= 4 * Number.EPSILON * (Math.abs(term) + v * v) || upper - lower <= 4 * Number.EPSILON * t) {
-        const latitude = Math.atan2(vertical / t, horizontal / equatorial);
-        const sin = Math.sin(latitude), cos = Math.cos(latitude);
-        return commit(result, Math.atan2(y, x), latitude, p * cos + z * sin - a * Math.hypot(cos, ratio * sin));
-      }
+      if (!Number.isFinite(residual))
+        return false;
       if (residual > 0)
         lower = t;
       else
         upper = t;
       const derivative = -2 * (u * u / equatorial + v * v / t);
       const next = t - residual / derivative;
-      const candidate = Number.isFinite(next) && next > lower && next < upper ? next : lower + (upper - lower) / 2;
-      if (candidate === t) {
-        const latitude = Math.atan2(vertical / t, horizontal / equatorial);
-        return commit(result, Math.atan2(y, x), latitude, p * Math.cos(latitude) + z * Math.sin(latitude) - a * Math.hypot(Math.cos(latitude), ratio * Math.sin(latitude)));
+      const candidate = next > lower && next < upper ? next : lower + (upper - lower) / 2;
+      if (Math.abs(residual) <= 4 * EPSILON21 * (Math.abs(term) + v * v) || upper - lower <= 4 * EPSILON21 * t) {
+        latitude = Math.atan2(verticalAt, u);
+        break;
       }
       t = candidate;
     }
-    return false;
+    return latitude !== void 0 && commitNormal(result, longitude, latitude, p, z, a, ratio2);
   }
   function sumError(x, y, sum) {
     const part = sum - x;
@@ -3966,35 +3968,9 @@ var __exports__ = (() => {
     const hx = sx - (sx - x), hy = sy - (sy - y), lx = x - hx, ly = y - hy;
     return hx * hy - product + hx * ly + lx * hy + lx * ly;
   }
-  function exteriorInverse(x, y, z, p, a, b, result) {
-    const ratio = b / a, ratio2 = ratio * ratio, horizontal = p / a, vertical = z / a;
-    const norm = Math.hypot(horizontal, z / b);
-    if (!Number.isFinite(norm) || norm < 1 - 8 * Number.EPSILON || !(ratio2 > 0))
-      return false;
-    let lower = 0, upper = Math.hypot(horizontal, vertical * ratio);
-    if (!Number.isFinite(upper))
-      return false;
-    let multiplier = norm <= 1 + 8 * Number.EPSILON ? 0 : upper / 2;
-    for (let i = 0; i < 96; i++) {
-      const equatorial = 1 + multiplier, polar = ratio2 + multiplier;
-      const u = horizontal / equatorial, v = vertical * ratio / polar;
-      const length4 = Math.hypot(u, v);
-      const residual = length4 - 1;
-      if (Math.abs(residual) <= 4 * Number.EPSILON) {
-        const latitude = Math.atan2(vertical / polar, horizontal / equatorial);
-        const sin = Math.sin(latitude), cos = Math.cos(latitude);
-        const height = p * cos + z * sin - a * Math.hypot(cos, ratio * sin);
-        return commit(result, Math.atan2(y, x), latitude, height);
-      }
-      if (residual > 0)
-        lower = multiplier;
-      else
-        upper = multiplier;
-      const derivative = -(u * u / equatorial + v * v / polar) / length4;
-      const next = multiplier - residual / derivative;
-      multiplier = Number.isFinite(next) && next > lower && next < upper ? next : (lower + upper) / 2;
-    }
-    return false;
+  function commitNormal(result, longitude, latitude, p, z, a, ratio2) {
+    const sin = Math.sin(latitude), cos = Math.cos(latitude);
+    return commit(result, longitude, latitude, p * cos + z * sin - a * Math.hypot(cos, ratio2 * sin));
   }
   function commit(result, x, y, z) {
     if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z))
@@ -4004,15 +3980,10 @@ var __exports__ = (() => {
     result.z = z;
     return true;
   }
+  var EPSILON21;
   var init_spheroid = __esm({
     "../../node_modules/@math.gl/core/dist/spheroid.js"() {
-    }
-  });
-
-  // ../../node_modules/@math.gl/core/dist/vec3.js
-  var init_vec32 = __esm({
-    "../../node_modules/@math.gl/core/dist/vec3.js"() {
-      init_vec3();
+      EPSILON21 = Number.EPSILON;
     }
   });
 
@@ -4092,298 +4063,222 @@ var __exports__ = (() => {
     }
   });
 
-  // ../../node_modules/@math.gl/core/dist/local-frame.js
-  function createLocalFrameBasis() {
-    return { eastX: 0, eastY: 1, northZ: 1, upX: 1, upY: 0, upZ: 0 };
-  }
-  function eastNorthUpBasisFromDirections(east, up, result) {
-    const ex = east.x, ey = east.y, ez = east.z;
-    const ux = up.x, uy = up.y, uz = up.z;
-    if (ez !== 0)
-      return false;
-    return commitBasis(result, ex, ey, ux * ey - uy * ex, ux, uy, uz);
-  }
-  function localFrameToMatrix(basis, origin, firstAxis, secondAxis, thirdAxis, result) {
-    const first = axisCode(firstAxis), second = axisCode(secondAxis), third = axisCode(thirdAxis);
-    const a = Math.abs(first), b = Math.abs(second), c = Math.abs(third);
-    if (!a || !b || !c || a === b || a === c || b === c)
-      return false;
-    const parity = a % 3 + 1 === b ? 1 : -1;
-    if (parity * Math.sign(first * second * third) !== 1 || !Array.isArray(result) && result.length < 16)
-      return false;
-    const ex = basis.eastX, ey = basis.eastY, nz = basis.northZ;
-    const ux = basis.upX, uy = basis.upY, uz = basis.upZ;
-    const nx = -uz * ey, ny = uz * ex;
-    const x = origin.x, y = origin.y, z = origin.z;
-    const ax = (a === 1 ? ex : a === 2 ? nx : ux) * Math.sign(first);
-    const ay = (a === 1 ? ey : a === 2 ? ny : uy) * Math.sign(first);
-    const az = (a === 1 ? 0 : a === 2 ? nz : uz) * Math.sign(first);
-    const bx = (b === 1 ? ex : b === 2 ? nx : ux) * Math.sign(second);
-    const by = (b === 1 ? ey : b === 2 ? ny : uy) * Math.sign(second);
-    const bz = (b === 1 ? 0 : b === 2 ? nz : uz) * Math.sign(second);
-    const cx = (c === 1 ? ex : c === 2 ? nx : ux) * Math.sign(third);
-    const cy = (c === 1 ? ey : c === 2 ? ny : uy) * Math.sign(third);
-    const cz = (c === 1 ? 0 : c === 2 ? nz : uz) * Math.sign(third);
-    if (!Number.isFinite(ax) || !Number.isFinite(ay) || !Number.isFinite(az) || !Number.isFinite(bx) || !Number.isFinite(by) || !Number.isFinite(bz) || !Number.isFinite(cx) || !Number.isFinite(cy) || !Number.isFinite(cz) || !Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z))
-      return false;
-    if (result instanceof Float32Array && (!Number.isFinite(Math.fround(ax)) || !Number.isFinite(Math.fround(ay)) || !Number.isFinite(Math.fround(az)) || !Number.isFinite(Math.fround(bx)) || !Number.isFinite(Math.fround(by)) || !Number.isFinite(Math.fround(bz)) || !Number.isFinite(Math.fround(cx)) || !Number.isFinite(Math.fround(cy)) || !Number.isFinite(Math.fround(cz)) || !Number.isFinite(Math.fround(x)) || !Number.isFinite(Math.fround(y)) || !Number.isFinite(Math.fround(z))))
+  // ../../node_modules/@math.gl/geospatial/dist/ellipsoid-helpers/exact-nearest-surface.js
+  function exactNearestSurface(x, y, z, a, b, c, result) {
+    const values = [a, b, c, Math.abs(x), Math.abs(y), Math.abs(z)];
+    const parts = values.map((value) => {
+      const bits = value.toString(2);
+      const dot4 = bits.indexOf(".");
+      return {
+        integer: BigInt("0b" + bits.replace(".", "")),
+        exponent: dot4 < 0 ? 0 : dot4 + 1 - bits.length
+      };
+    });
+    const exponent = Math.min(...parts.filter((p) => p.integer !== 0n).map((p) => p.exponent));
+    const integers = parts.map((p) => p.integer << BigInt(p.exponent - exponent));
+    const squares = integers.slice(0, 3).map((v) => v * v);
+    const minimum = squares.reduce((p, v) => p < v ? p : v);
+    const offsets = squares.map((v) => v - minimum);
+    const products = squares.map((_, i) => integers[i] * integers[i + 3]);
+    let precision = 64;
+    if (!products.some((u3, i) => offsets[i] === 0n && u3 !== 0n)) {
+      let numerator = -1n, denominator = 1n;
+      for (let i = 0; i < 3; i++) {
+        if (offsets[i] === 0n)
+          continue;
+        const d2 = offsets[i] * offsets[i];
+        numerator = numerator * d2 + products[i] * products[i] * denominator;
+        denominator *= d2;
+      }
+      if (numerator < 0n)
+        return false;
+      if (numerator === 0n) {
+        return commit2(0n, 1n);
+      }
+      const positive = offsets.filter((d2) => d2 > 0n);
+      const least = positive.reduce((p, v) => p < v ? p : v);
+      precision = Math.max(64, (2n * (denominator + numerator)).toString(2).length - (numerator * least).toString(2).length + 128);
+    }
+    const unit = 1n << BigInt(precision);
+    const d = offsets.map((v) => v * unit);
+    const u = products.map((v) => v * unit);
+    const u2 = u.map((v) => v * v);
+    let lower = 0n, upper = u.reduce((sum, v) => sum + v, 0n);
+    if (upper === 0n)
       return false;
-    result[0] = ax;
-    result[1] = ay;
-    result[2] = az;
-    result[3] = 0;
-    result[4] = bx;
-    result[5] = by;
-    result[6] = bz;
-    result[7] = 0;
-    result[8] = cx;
-    result[9] = cy;
-    result[10] = cz;
-    result[11] = 0;
-    result[12] = x;
-    result[13] = y;
-    result[14] = z;
-    result[15] = 1;
-    return true;
-  }
-  function axisCode(axis) {
-    switch (axis) {
-      case "east":
-        return 1;
-      case "west":
-        return -1;
-      case "north":
-        return 2;
-      case "south":
-        return -2;
-      case "up":
-        return 3;
-      case "down":
-        return -3;
-      default:
-        return 0;
+    for (let iteration = 0; iteration < 4096; iteration++) {
+      const t = lower + upper >> 1n;
+      if (t === lower)
+        return false;
+      const dx = d[0] + t, dy = d[1] + t, dz = d[2] + t;
+      const xx = dx * dx, yy = dy * dy, zz = dz * dz;
+      const sign = u2[0] * yy * zz + u2[1] * xx * zz + u2[2] * xx * yy - xx * yy * zz;
+      if (sign === 0n)
+        return commit2(t, unit);
+      if (sign > 0n)
+        lower = t;
+      else
+        upper = t;
+      if (lower > 0n && upper - lower <= lower >> 60n)
+        return commit2(lower + upper >> 1n, unit);
+    }
+    return false;
+    function commit2(t, unit2) {
+      const output = squares.map((r2, i) => {
+        const denominator = offsets[i] * unit2 + t;
+        return denominator === 0n ? 0 : ratio(r2 * integers[i + 3] * unit2, denominator, exponent);
+      });
+      if (!output.every(Number.isFinite))
+        return false;
+      const qx = Math.sign(x) * output[0], qy = Math.sign(y) * output[1], qz = Math.sign(z) * output[2];
+      result.x = qx;
+      result.y = qy;
+      result.z = qz;
+      return true;
     }
   }
-  function commitBasis(result, ex, ey, nz, ux, uy, uz) {
-    if (!Number.isFinite(ex) || !Number.isFinite(ey) || !Number.isFinite(nz) || !Number.isFinite(ux) || !Number.isFinite(uy) || !Number.isFinite(uz))
-      return false;
-    result.eastX = ex;
-    result.eastY = ey;
-    result.northZ = nz;
-    result.upX = ux;
-    result.upY = uy;
-    result.upZ = uz;
-    return true;
-  }
-  var init_local_frame = __esm({
-    "../../node_modules/@math.gl/core/dist/local-frame.js"() {
+  function ratio(n, d, exponent) {
+    if (n === 0n)
+      return 0;
+    const shift = 52 - (n.toString(2).length - d.toString(2).length);
+    const numerator = shift >= 0 ? n << BigInt(shift) : n;
+    const denominator = shift >= 0 ? d : d << BigInt(-shift);
+    let quotient = numerator / denominator;
+    const remainder = numerator % denominator;
+    if (2n * remainder > denominator || 2n * remainder === denominator && quotient & 1n)
+      quotient++;
+    const power = exponent - shift;
+    const first = Math.max(-1022, Math.min(1023, power));
+    return Number(quotient) * 2 ** first * 2 ** (power - first);
+  }
+  var init_exact_nearest_surface = __esm({
+    "../../node_modules/@math.gl/geospatial/dist/ellipsoid-helpers/exact-nearest-surface.js"() {
     }
   });
 
-  // ../../node_modules/@math.gl/geospatial/dist/ellipsoid-helpers/ellipsoid-transform.js
-  function localFrameToFixedFrame(ellipsoid, firstAxis, secondAxis, thirdAxis, cartesianOrigin, result) {
-    const thirdAxisInferred = VECTOR_PRODUCT_LOCAL_FRAME[firstAxis] && VECTOR_PRODUCT_LOCAL_FRAME[firstAxis][secondAxis];
-    assert2(thirdAxisInferred && (!thirdAxis || thirdAxis === thirdAxisInferred));
-    let firstAxisVector;
-    let secondAxisVector;
-    let thirdAxisVector;
-    const origin = scratchOrigin.copy(cartesianOrigin);
-    const atPole = equals(origin.x, 0, EPSILON142) && equals(origin.y, 0, EPSILON142);
-    const radii = ellipsoid.radii;
-    if (radii.x === radii.y && radii.x > 0 && radii.z > 0 && radii.z <= radii.x && (!atPole || origin.z !== 0)) {
-      const { east, up } = scratchAxisVectors;
-      if (atPole) {
-        east.set(0, 1, 0);
-        up.set(0, 0, Math.sign(origin.z));
+  // ../../node_modules/@math.gl/geospatial/dist/ellipsoid-helpers/nearest-surface.js
+  function nearestSurface(x, y, z, a, b, c, result) {
+    const minimum = Math.min(a, b, c);
+    const minimumSquared = minimum * minimum;
+    const aa = a * a, bb = b * b, cc = c * c;
+    if (!(minimum > 0) || !(minimumSquared > 0) || !Number.isFinite(Math.max(aa, bb, cc)))
+      return false;
+    const minimumError = productError2(minimum, minimum, minimumSquared);
+    const dx = aa - minimumSquared, dy = bb - minimumSquared, dz = cc - minimumSquared;
+    const ex = sumError2(aa, -minimumSquared, dx) + productError2(a, a, aa) - minimumError;
+    const ey = sumError2(bb, -minimumSquared, dy) + productError2(b, b, bb) - minimumError;
+    const ez = sumError2(cc, -minimumSquared, dz) + productError2(c, c, cc) - minimumError;
+    const ux = a * Math.abs(x), uy = b * Math.abs(y), uz = c * Math.abs(z);
+    if (minimumSquared < 2 ** -1022 || x !== 0 && ux < 2 ** -1022 || y !== 0 && uy < 2 ** -1022 || z !== 0 && uz < 2 ** -1022)
+      return exactNearestSurface(x, y, z, a, b, c, result);
+    const fx = productError2(a, Math.abs(x), ux);
+    const fy = productError2(b, Math.abs(y), uy);
+    const fz = productError2(c, Math.abs(z), uz);
+    const limit = Math.hypot(dx === 0 ? ux === 0 ? 0 : Infinity : ux / (dx + ex), dy === 0 ? uy === 0 ? 0 : Infinity : uy / (dy + ey), dz === 0 ? uz === 0 ? 0 : Infinity : uz / (dz + ez));
+    if (limit <= 1 + 64 * Number.EPSILON)
+      return exactNearestSurface(x, y, z, a, b, c, result);
+    if ((x !== 0 ? 1 : 0) + (y !== 0 ? 1 : 0) + (z !== 0 ? 1 : 0) === 1) {
+      result.x = x === 0 ? x : Math.sign(x) * a;
+      result.y = y === 0 ? y : Math.sign(y) * b;
+      result.z = z === 0 ? z : Math.sign(z) * c;
+      return true;
+    }
+    let lower = Math.hypot(dx === 0 ? ux : 0, dy === 0 ? uy : 0, dz === 0 ? uz : 0);
+    let upper = Math.hypot(ux, uy, uz);
+    if (!(upper > 0) || !Number.isFinite(upper))
+      return exactNearestSurface(x, y, z, a, b, c, result);
+    let t = lower > 0 ? lower : upper;
+    for (let iteration = 0; iteration < 512; iteration++) {
+      const hx = dx + t, hy = dy + t, hz = dz + t;
+      const lx = sumError2(dx, t, hx) + ex;
+      const ly = sumError2(dy, t, hy) + ey;
+      const lz = sumError2(dz, t, hz) + ez;
+      const vx = ux / hx, vy = uy / hy, vz = uz / hz;
+      let term, rest;
+      if (vx >= vy && vx >= vz) {
+        term = offset(ux, fx, dx, ex, t, hx) * (vx + 1);
+        rest = (vy * (1 - ly / hy)) ** 2 + (vz * (1 - lz / hz)) ** 2;
+      } else if (vy >= vz) {
+        term = offset(uy, fy, dy, ey, t, hy) * (vy + 1);
+        rest = (vx * (1 - lx / hx)) ** 2 + (vz * (1 - lz / hz)) ** 2;
       } else {
-        east.set(-origin.y, origin.x, 0).normalize();
-        ellipsoid.geodeticSurfaceNormal(origin, up);
-      }
-      if (!eastNorthUpBasisFromDirections(east, up, scratchBasis) || !localFrameToMatrix(scratchBasis, origin, firstAxis, secondAxis, thirdAxis, result))
-        throw new Error("Unsupported local frame");
-      return result;
-    }
-    if (atPole) {
-      const sign = Math.sign(origin.z);
-      firstAxisVector = scratchVector1.fromArray(degeneratePositionLocalFrame[firstAxis]);
-      if (firstAxis !== "east" && firstAxis !== "west") {
-        firstAxisVector.scale(sign);
-      }
-      secondAxisVector = scratchVector2.fromArray(degeneratePositionLocalFrame[secondAxis]);
-      if (secondAxis !== "east" && secondAxis !== "west") {
-        secondAxisVector.scale(sign);
-      }
-      thirdAxisVector = scratchVector3.fromArray(degeneratePositionLocalFrame[thirdAxis]);
-      if (thirdAxis !== "east" && thirdAxis !== "west") {
-        thirdAxisVector.scale(sign);
+        term = offset(uz, fz, dz, ez, t, hz) * (vz + 1);
+        rest = (vx * (1 - lx / hx)) ** 2 + (vy * (1 - ly / hy)) ** 2;
+      }
+      const derivative = -2 * (vx * vx / hx + vy * vy / hy + vz * vz / hz);
+      const roundoff = 4 * Number.EPSILON * (Math.abs(term) + rest);
+      const residual = term + rest;
+      if (!Number.isFinite(residual))
+        return exactNearestSurface(x, y, z, a, b, c, result);
+      if (Math.abs(residual) <= 4 * Number.EPSILON * (Math.abs(term) + rest) || upper - lower <= 4 * Number.EPSILON * t) {
+        const uncertainty = roundoff / Math.abs(derivative);
+        if (!Number.isFinite(derivative) || !(Math.abs(derivative) > 0) || uncertainty > 2e-13 * t)
+          return exactNearestSurface(x, y, z, a, b, c, result);
+        const qx = Math.sign(x) * a * (vx * (1 - lx / hx));
+        const qy = Math.sign(y) * b * (vy * (1 - ly / hy));
+        const qz = Math.sign(z) * c * (vz * (1 - lz / hz));
+        const displacement = 2 * uncertainty * Math.max(Math.abs(qx / hx), Math.abs(qy / hy), Math.abs(qz / hz));
+        if (!Number.isFinite(displacement) || displacement > 2e-13 * Math.max(a, b, c))
+          return exactNearestSurface(x, y, z, a, b, c, result);
+        if (!Number.isFinite(qx) || !Number.isFinite(qy) || !Number.isFinite(qz))
+          return exactNearestSurface(x, y, z, a, b, c, result);
+        result.x = qx;
+        result.y = qy;
+        result.z = qz;
+        return true;
       }
-    } else {
-      const { up, east, north } = scratchAxisVectors;
-      east.set(-origin.y, origin.x, 0).normalize();
-      ellipsoid.geodeticSurfaceNormal(origin, up);
-      north.copy(up).cross(east);
-      const { down, west, south } = scratchAxisVectors;
-      down.copy(up).scale(-1);
-      west.copy(east).scale(-1);
-      south.copy(north).scale(-1);
-      firstAxisVector = scratchAxisVectors[firstAxis];
-      secondAxisVector = scratchAxisVectors[secondAxis];
-      thirdAxisVector = scratchAxisVectors[thirdAxis];
-    }
-    const ax = firstAxisVector.x, ay = firstAxisVector.y, az = firstAxisVector.z;
-    const bx = secondAxisVector.x, by = secondAxisVector.y, bz = secondAxisVector.z;
-    const cx = thirdAxisVector.x, cy = thirdAxisVector.y, cz = thirdAxisVector.z;
-    const x = origin.x, y = origin.y, z = origin.z;
-    result[0] = ax;
-    result[1] = ay;
-    result[2] = az;
-    result[3] = 0;
-    result[4] = bx;
-    result[5] = by;
-    result[6] = bz;
-    result[7] = 0;
-    result[8] = cx;
-    result[9] = cy;
-    result[10] = cz;
-    result[11] = 0;
-    result[12] = x;
-    result[13] = y;
-    result[14] = z;
-    result[15] = 1;
-    return result;
+      if (residual > 0)
+        lower = t;
+      else
+        upper = t;
+      const candidate = t - residual / derivative;
+      const next = candidate > lower && candidate < upper ? candidate : lower + (upper - lower) / 2;
+      if (next === t)
+        return exactNearestSurface(x, y, z, a, b, c, result);
+      t = next;
+    }
+    return exactNearestSurface(x, y, z, a, b, c, result);
+  }
+  function offset(u, error, d, dError, t, denominator) {
+    const difference = u - d;
+    const correction = sumError2(u, -d, difference) + error - dError;
+    const base = difference + correction;
+    const low = sumError2(difference, correction, base);
+    const shifted = base - t;
+    return (shifted + (sumError2(base, -t, shifted) + low)) / denominator;
+  }
+  function sumError2(x, y, sum) {
+    const part = sum - x;
+    return x - (sum - part) + (y - part);
   }
-  var EPSILON142, scratchOrigin, scratchBasis, VECTOR_PRODUCT_LOCAL_FRAME, degeneratePositionLocalFrame, scratchAxisVectors, scratchVector1, scratchVector2, scratchVector3;
-  var init_ellipsoid_transform = __esm({
-    "../../node_modules/@math.gl/geospatial/dist/ellipsoid-helpers/ellipsoid-transform.js"() {
-      init_dist();
-      init_local_frame();
-      EPSILON142 = 1e-14;
-      scratchOrigin = new Vector3();
-      scratchBasis = createLocalFrameBasis();
-      VECTOR_PRODUCT_LOCAL_FRAME = {
-        up: {
-          south: "east",
-          north: "west",
-          west: "south",
-          east: "north"
-        },
-        down: {
-          south: "west",
-          north: "east",
-          west: "north",
-          east: "south"
-        },
-        south: {
-          up: "west",
-          down: "east",
-          west: "down",
-          east: "up"
-        },
-        north: {
-          up: "east",
-          down: "west",
-          west: "up",
-          east: "down"
-        },
-        west: {
-          up: "north",
-          down: "south",
-          north: "down",
-          south: "up"
-        },
-        east: {
-          up: "south",
-          down: "north",
-          north: "up",
-          south: "down"
-        }
-      };
-      degeneratePositionLocalFrame = {
-        north: [-1, 0, 0],
-        east: [0, 1, 0],
-        up: [0, 0, 1],
-        south: [1, 0, 0],
-        west: [0, -1, 0],
-        down: [0, 0, -1]
-      };
-      scratchAxisVectors = {
-        east: new Vector3(),
-        north: new Vector3(),
-        up: new Vector3(),
-        west: new Vector3(),
-        south: new Vector3(),
-        down: new Vector3()
-      };
-      scratchVector1 = new Vector3();
-      scratchVector2 = new Vector3();
-      scratchVector3 = new Vector3();
+  function productError2(x, y, product) {
+    const sx = 134217729 * x, sy = 134217729 * y;
+    if (!Number.isFinite(sx) || !Number.isFinite(sy))
+      return 0;
+    const hx = sx - (sx - x), hy = sy - (sy - y);
+    const lx = x - hx, ly = y - hy;
+    return hx * hy - product + hx * ly + lx * hy + lx * ly;
+  }
+  var init_nearest_surface = __esm({
+    "../../node_modules/@math.gl/geospatial/dist/ellipsoid-helpers/nearest-surface.js"() {
+      init_exact_nearest_surface();
     }
   });
 
   // ../../node_modules/@math.gl/geospatial/dist/ellipsoid-helpers/scale-to-geodetic-surface.js
   function scaleToGeodeticSurface(cartesian, ellipsoid, result = []) {
-    const { oneOverRadii, oneOverRadiiSquared, centerToleranceSquared } = ellipsoid;
     const object = cartesian;
-    const positionX = "x" in cartesian ? object.x : cartesian[0];
-    const positionY = "x" in cartesian ? object.y : cartesian[1];
-    const positionZ = "x" in cartesian ? object.z : cartesian[2];
-    if (!Number.isFinite(positionX) || !Number.isFinite(positionY) || !Number.isFinite(positionZ)) {
+    const x = "x" in cartesian ? object.x : cartesian[0];
+    const y = "x" in cartesian ? object.y : cartesian[1];
+    const z = "x" in cartesian ? object.z : cartesian[2];
+    if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z))
       return void 0;
-    }
-    scratchVector4.set(positionX, positionY, positionZ);
-    const oneOverRadiiX = oneOverRadii.x;
-    const oneOverRadiiY = oneOverRadii.y;
-    const oneOverRadiiZ = oneOverRadii.z;
-    const x2 = positionX * positionX * oneOverRadiiX * oneOverRadiiX;
-    const y2 = positionY * positionY * oneOverRadiiY * oneOverRadiiY;
-    const z2 = positionZ * positionZ * oneOverRadiiZ * oneOverRadiiZ;
-    const squaredNorm = x2 + y2 + z2;
-    const ratio = Math.sqrt(1 / squaredNorm);
-    if (!Number.isFinite(ratio) || !Number.isFinite(squaredNorm)) {
+    if (!Number.isFinite(x * x + y * y + z * z))
       return void 0;
-    }
-    const intersection = scaleToGeodeticSurfaceIntersection;
-    intersection.set(positionX, positionY, positionZ).scale(ratio);
-    if (squaredNorm < centerToleranceSquared) {
-      return writeResult(result, intersection.x, intersection.y, intersection.z);
-    }
-    const oneOverRadiiSquaredX = oneOverRadiiSquared.x;
-    const oneOverRadiiSquaredY = oneOverRadiiSquared.y;
-    const oneOverRadiiSquaredZ = oneOverRadiiSquared.z;
-    const gradient = scaleToGeodeticSurfaceGradient;
-    gradient.set(intersection.x * oneOverRadiiSquaredX * 2, intersection.y * oneOverRadiiSquaredY * 2, intersection.z * oneOverRadiiSquaredZ * 2);
-    let lambda = (1 - ratio) * scratchVector4.len() / (0.5 * gradient.len());
-    let correction = 0;
-    let xMultiplier;
-    let yMultiplier;
-    let zMultiplier;
-    let func;
-    for (let iteration = 0; iteration < 64; iteration++) {
-      lambda -= correction;
-      xMultiplier = 1 / (1 + lambda * oneOverRadiiSquaredX);
-      yMultiplier = 1 / (1 + lambda * oneOverRadiiSquaredY);
-      zMultiplier = 1 / (1 + lambda * oneOverRadiiSquaredZ);
-      const xMultiplier2 = xMultiplier * xMultiplier;
-      const yMultiplier2 = yMultiplier * yMultiplier;
-      const zMultiplier2 = zMultiplier * zMultiplier;
-      const xMultiplier3 = xMultiplier2 * xMultiplier;
-      const yMultiplier3 = yMultiplier2 * yMultiplier;
-      const zMultiplier3 = zMultiplier2 * zMultiplier;
-      func = x2 * xMultiplier2 + y2 * yMultiplier2 + z2 * zMultiplier2 - 1;
-      if (!Number.isFinite(func))
-        return void 0;
-      if (Math.abs(func) <= math_utils_exports.EPSILON12) {
-        return writeResult(result, positionX * xMultiplier, positionY * yMultiplier, positionZ * zMultiplier);
-      }
-      const denominator = x2 * xMultiplier3 * oneOverRadiiSquaredX + y2 * yMultiplier3 * oneOverRadiiSquaredY + z2 * zMultiplier3 * oneOverRadiiSquaredZ;
-      const derivative = -2 * denominator;
-      if (!Number.isFinite(derivative) || derivative === 0)
-        return void 0;
-      correction = func / derivative;
-      if (!Number.isFinite(correction))
-        return void 0;
-    }
-    return void 0;
+    const { radii } = ellipsoid;
+    if (!nearestSurface(x, y, z, radii.x, radii.y, radii.z, surface))
+      return void 0;
+    return writeResult(result, surface.x, surface.y, surface.z);
   }
   function writeResult(result, x, y, z) {
     if (isArray(result)) {
@@ -4398,13 +4293,12 @@ var __exports__ = (() => {
     }
     return result;
   }
-  var scratchVector4, scaleToGeodeticSurfaceIntersection, scaleToGeodeticSurfaceGradient;
+  var surface;
   var init_scale_to_geodetic_surface = __esm({
     "../../node_modules/@math.gl/geospatial/dist/ellipsoid-helpers/scale-to-geodetic-surface.js"() {
       init_dist();
-      scratchVector4 = new Vector3();
-      scaleToGeodeticSurfaceIntersection = new Vector3();
-      scaleToGeodeticSurfaceGradient = new Vector3();
+      init_nearest_surface();
+      surface = { x: 0, y: 0, z: 0 };
     }
   });
 
@@ -4413,22 +4307,26 @@ var __exports__ = (() => {
     if (!Number.isFinite(a) || !Number.isFinite(b) || a <= 0 || b <= 0 || b > a)
       throw new Error("Spheroid requires finite positive axes with semiMinorAxis <= semiMajorAxis");
   }
-  var spheroidScratch, scratchVector5, scratchNormal, scratchK, scratchPosition, scratchHeight, scratchCartesian, Ellipsoid;
+  function normalResult(x, y, z, result) {
+    const scale4 = Math.max(Math.abs(x), Math.abs(y), Math.abs(z));
+    if (!(scale4 > 0) || !Number.isFinite(scale4))
+      return void 0;
+    const nx = x / scale4, ny = y / scale4, nz = z / scale4;
+    const length4 = Math.hypot(nx, ny, nz);
+    return writeResult(result, nx / length4, ny / length4, nz / length4);
+  }
+  var spheroidScratch, scratchVector2, scratchNormal, scratchPosition, scratchCartesian, Ellipsoid;
   var init_ellipsoid = __esm({
     "../../node_modules/@math.gl/geospatial/dist/ellipsoid.js"() {
       init_dist();
       init_spheroid();
-      init_vec32();
       init_constants();
       init_type_utils();
-      init_ellipsoid_transform();
       init_scale_to_geodetic_surface();
       spheroidScratch = { x: 0, y: 0, z: 0 };
-      scratchVector5 = new Vector3();
+      scratchVector2 = new Vector3();
       scratchNormal = new Vector3();
-      scratchK = new Vector3();
       scratchPosition = new Vector3();
-      scratchHeight = new Vector3();
       scratchCartesian = new Vector3();
       Ellipsoid = class _Ellipsoid {
         /** Construct from two-axis geometry, including normalized projection ellipsoids.
@@ -4441,9 +4339,9 @@ var __exports__ = (() => {
         }
         constructor(x = 0, y = 0, z = 0) {
           this.centerToleranceSquared = math_utils_exports.EPSILON1;
-          assert2(x >= 0);
-          assert2(y >= 0);
-          assert2(z >= 0);
+          assert2(Number.isFinite(x) && x >= 0);
+          assert2(Number.isFinite(y) && y >= 0);
+          assert2(Number.isFinite(z) && z >= 0);
           this.radii = new Vector3(x, y, z);
           this.radiiSquared = new Vector3(x * x, y * y, z * z);
           this.radiiToTheFourth = new Vector3(x * x * x * x, y * y * y * y, z * z * z * z);
@@ -4451,15 +4349,20 @@ var __exports__ = (() => {
           this.oneOverRadiiSquared = new Vector3(x === 0 ? 0 : 1 / (x * x), y === 0 ? 0 : 1 / (y * y), z === 0 ? 0 : 1 / (z * z));
           this.minimumRadius = Math.min(x, y, z);
           this.maximumRadius = Math.max(x, y, z);
-          if (this.radiiSquared.z !== 0) {
-            this.squaredXOverSquaredZ = this.radiiSquared.x / this.radiiSquared.z;
+          if (z !== 0) {
+            this.squaredXOverSquaredZ = (x / z) ** 2;
           }
           if (x === y && z > 0 && z <= x && Number.isFinite(this.radiiSquared.x) && this.radiiSquared.z > 0)
             this.spheroidGeometry = Object.freeze({
               semiMajorAxis: x,
               semiMinorAxis: z,
-              eccentricitySquared: 1 - this.radiiSquared.z / this.radiiSquared.x
+              eccentricitySquared: 1 - (z / x) ** 2
             });
+          Object.freeze(this.radii);
+          Object.freeze(this.radiiSquared);
+          Object.freeze(this.radiiToTheFourth);
+          Object.freeze(this.oneOverRadii);
+          Object.freeze(this.oneOverRadiiSquared);
           Object.freeze(this);
         }
         /** Return an owned geometry snapshot for a sphere or oblate spheroid.
@@ -4477,30 +4380,34 @@ var __exports__ = (() => {
         equals(right) {
           return this === right || Boolean(right && this.radii.equals(right.radii));
         }
-        /** Creates a string representing this Ellipsoid in the format '(radii.x, radii.y, radii.z)'. */
+        /** Creates a string representing this Ellipsoid in the format '[radii.x, radii.y, radii.z]'. */
         toString() {
           return this.radii.toString();
         }
         cartographicToCartesian(cartographic, result = [0, 0, 0]) {
-          if (this.spheroidGeometry) {
-            const llh = fromCartographicToRadians(cartographic, scratchCartesian);
-            spheroidScratch.x = llh[0];
-            spheroidScratch.y = llh[1];
-            spheroidScratch.z = llh[2];
+          const llh = fromCartographicToRadians(cartographic, scratchCartesian);
+          const longitude = llh[0], latitude = llh[1], height = llh[2];
+          if (!Number.isFinite(longitude) || !Number.isFinite(latitude) || !Number.isFinite(height) || !(this.minimumRadius > 0) || !Number.isFinite(this.maximumRadius * this.maximumRadius))
+            return void 0;
+          if (this.spheroidGeometry && (config._cartographicRadians || Math.abs(latitude) <= Math.PI / 4)) {
+            spheroidScratch.x = longitude;
+            spheroidScratch.y = latitude;
+            spheroidScratch.z = height;
             if (!spheroidToCartesian(spheroidScratch, this.spheroidGeometry))
               return void 0;
             return writeResult(result, spheroidScratch.x, spheroidScratch.y, spheroidScratch.z);
           }
           const normal = scratchNormal;
-          const k = scratchK;
-          const [, , height] = cartographic;
           this.geodeticSurfaceNormalCartographic(cartographic, normal);
-          k.copy(this.radiiSquared).scale(normal);
-          const gamma = Math.sqrt(normal.dot(k));
-          k.scale(1 / gamma);
-          normal.scale(height);
-          k.add(normal);
-          return k.to(result);
+          const nx = normal.x, ny = normal.y, nz = normal.z;
+          const rx = this.radii.x, ry = this.radii.y, rz = this.radii.z;
+          const gamma = Math.hypot(rx * nx, ry * ny, rz * nz);
+          const x = rx * (rx * nx / gamma) + height * nx;
+          const y = ry * (ry * ny / gamma) + height * ny;
+          const z = rz * (rz * nz / gamma) + height * nz;
+          if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z))
+            return void 0;
+          return writeResult(result, x, y, z);
         }
         cartesianToCartographic(cartesian, result = [0, 0, 0]) {
           const object = cartesian;
@@ -4513,45 +4420,68 @@ var __exports__ = (() => {
             spheroidScratch.x = x;
             spheroidScratch.y = y;
             spheroidScratch.z = z;
-            if (!cartesianToSpheroid(spheroidScratch, this.spheroidGeometry))
-              return void 0;
-            const longitude2 = x === 0 && y === 0 ? Math.atan2(y, x) : spheroidScratch.x;
-            return toCartographicFromRadiansComponents(longitude2, spheroidScratch.y, spheroidScratch.z, result);
+            const shape = this.spheroidGeometry;
+            const nearBoundary = z === 0 && shape.semiMinorAxis < shape.semiMajorAxis && Math.abs(Math.hypot(x, y) - shape.semiMajorAxis * shape.eccentricitySquared) <= 64 * Number.EPSILON * shape.semiMajorAxis;
+            if (!nearBoundary && cartesianToSpheroid(spheroidScratch, shape)) {
+              const longitude2 = x === 0 && y === 0 ? Math.atan2(y, x) : spheroidScratch.x;
+              return toCartographicFromRadiansComponents(longitude2, spheroidScratch.y, spheroidScratch.z, result);
+            }
           }
+          if (!(this.minimumRadius > 0) || !Number.isFinite(this.maximumRadius * this.maximumRadius) || !Number.isFinite(1 / (this.minimumRadius * this.minimumRadius)))
+            return void 0;
           scratchCartesian.set(x, y, z);
           const point = this.scaleToGeodeticSurface(scratchCartesian, scratchPosition);
           if (!point) {
             return void 0;
           }
-          const normal = this.geodeticSurfaceNormal(point, scratchNormal);
-          const h = scratchHeight;
-          h.copy(scratchCartesian).subtract(point);
-          const longitude = Math.atan2(normal.y, normal.x);
-          const latitude = Math.atan2(normal.z, Math.hypot(normal.x, normal.y));
-          const height = Math.sign(dot(h, scratchCartesian)) * length(h);
+          const gx = point[0] * this.oneOverRadiiSquared.x;
+          const gy = point[1] * this.oneOverRadiiSquared.y;
+          const gz = point[2] * this.oneOverRadiiSquared.z;
+          const length4 = Math.hypot(gx, gy, gz);
+          if (!(length4 > 0) || !Number.isFinite(length4))
+            return void 0;
+          const nx = gx / length4, ny = gy / length4, nz = gz / length4;
+          const longitude = Math.atan2(ny, nx);
+          const latitude = Math.atan2(nz, Math.hypot(nx, ny));
+          const height = (x - point[0]) * nx + (y - point[1]) * ny + (z - point[2]) * nz;
           return toCartographicFromRadiansComponents(longitude, latitude, height, result);
         }
-        eastNorthUpToFixedFrame(origin, result = new Matrix4()) {
-          return localFrameToFixedFrame(this, "east", "north", "up", origin, result);
-        }
-        // Computes a 4x4 transformation matrix from a reference frame centered at
-        // the provided origin to the ellipsoid's fixed reference frame.
-        localFrameToFixedFrame(firstAxis, secondAxis, thirdAxis, origin, result = new Matrix4()) {
-          return localFrameToFixedFrame(this, firstAxis, secondAxis, thirdAxis, origin, result);
-        }
         geocentricSurfaceNormal(cartesian, result = [0, 0, 0]) {
-          return scratchVector5.from(cartesian).normalize().to(result);
+          fromCartographic(cartesian, scratchVector2);
+          const point = scratchVector2;
+          return normalResult(point.x, point.y, point.z, result);
         }
         geodeticSurfaceNormalCartographic(cartographic, result = [0, 0, 0]) {
-          const cartographicVectorRadians = fromCartographicToRadians(cartographic);
-          const longitude = cartographicVectorRadians[0];
-          const latitude = cartographicVectorRadians[1];
-          const cosLatitude = Math.cos(latitude);
-          scratchVector5.set(cosLatitude * Math.cos(longitude), cosLatitude * Math.sin(longitude), Math.sin(latitude)).normalize();
-          return scratchVector5.to(result);
+          const point = fromCartographic(cartographic, scratchCartesian);
+          const longitude = config._cartographicRadians ? point[0] : point[0] * Math.PI / 180;
+          const latitude = config._cartographicRadians ? point[1] : point[1] * Math.PI / 180;
+          const polarDegrees = !config._cartographicRadians && Math.abs(point[1]) > 45;
+          const complement = (90 - Math.abs(point[1])) * Math.PI / 180;
+          const cosLatitude = polarDegrees ? Math.sin(complement) : Math.abs(latitude) === Math.PI / 2 ? 0 : Math.cos(latitude);
+          const sinLatitude = polarDegrees ? Math.sign(point[1]) * Math.cos(complement) : Math.sin(latitude);
+          return normalResult(cosLatitude * Math.cos(longitude), cosLatitude * Math.sin(longitude), sinLatitude, result);
         }
         geodeticSurfaceNormal(cartesian, result = [0, 0, 0]) {
-          return scratchVector5.from(cartesian).scale(this.oneOverRadiiSquared).normalize().to(result);
+          if (!(this.minimumRadius > 0))
+            return void 0;
+          fromCartographic(cartesian, scratchVector2);
+          const point = scratchVector2;
+          const scale4 = Math.max(Math.abs(point.x), Math.abs(point.y), Math.abs(point.z));
+          if (!(scale4 > 0) || !Number.isFinite(scale4))
+            return void 0;
+          const nx = point.x / scale4 * (this.minimumRadius / this.radii.x) ** 2;
+          const ny = point.y / scale4 * (this.minimumRadius / this.radii.y) ** 2;
+          const nz = point.z / scale4 * (this.minimumRadius / this.radii.z) ** 2;
+          if ((point.x === 0 || Math.abs(nx) >= 2 ** -1022) && (point.y === 0 || Math.abs(ny) >= 2 ** -1022) && (point.z === 0 || Math.abs(nz) >= 2 ** -1022))
+            return normalResult(nx, ny, nz, result);
+          const ex = point.x === 0 ? 0 : Math.min(1023, Math.floor(Math.log2(Math.abs(point.x))));
+          const ey = point.y === 0 ? 0 : Math.min(1023, Math.floor(Math.log2(Math.abs(point.y))));
+          const ez = point.z === 0 ? 0 : Math.min(1023, Math.floor(Math.log2(Math.abs(point.z))));
+          const ax = Math.min(1023, Math.floor(Math.log2(this.radii.x)));
+          const ay = Math.min(1023, Math.floor(Math.log2(this.radii.y)));
+          const az = Math.min(1023, Math.floor(Math.log2(this.radii.z)));
+          const common = Math.max(point.x === 0 ? -Infinity : ex - 2 * ax, point.y === 0 ? -Infinity : ey - 2 * ay, point.z === 0 ? -Infinity : ez - 2 * az);
+          return normalResult(point.x === 0 ? point.x : point.x / 2 ** ex / (this.radii.x / 2 ** ax) ** 2 * 2 ** (ex - 2 * ax - common), point.y === 0 ? point.y : point.y / 2 ** ey / (this.radii.y / 2 ** ay) ** 2 * 2 ** (ey - 2 * ay - common), point.z === 0 ? point.z : point.z / 2 ** ez / (this.radii.z / 2 ** az) ** 2 * 2 ** (ez - 2 * az - common), result);
         }
         /** Scales the provided Cartesian position along the geodetic surface normal
          * so that it is on the surface of this ellipsoid.  If the position is
@@ -4562,34 +4492,49 @@ var __exports__ = (() => {
         /** Scales the provided Cartesian position along the geocentric surface normal
          * so that it is on the surface of this ellipsoid. */
         scaleToGeocentricSurface(cartesian, result = [0, 0, 0]) {
-          scratchPosition.from(cartesian);
-          const positionX = scratchPosition.x;
-          const positionY = scratchPosition.y;
-          const positionZ = scratchPosition.z;
-          const oneOverRadiiSquared = this.oneOverRadiiSquared;
-          const beta = 1 / Math.sqrt(positionX * positionX * oneOverRadiiSquared.x + positionY * positionY * oneOverRadiiSquared.y + positionZ * positionZ * oneOverRadiiSquared.z);
-          return scratchPosition.multiplyByScalar(beta).to(result);
+          fromCartographic(cartesian, scratchPosition);
+          const point = scratchPosition;
+          const scale4 = Math.max(Math.abs(point.x), Math.abs(point.y), Math.abs(point.z));
+          if (!(this.minimumRadius > 0) || !(scale4 > 0) || !Number.isFinite(scale4))
+            return void 0;
+          const squared = point.x * point.x * this.oneOverRadiiSquared.x + point.y * point.y * this.oneOverRadiiSquared.y + point.z * point.z * this.oneOverRadiiSquared.z;
+          if (squared >= 2 ** -1022 && Number.isFinite(squared) && scale4 * scale4 >= 2 ** -1022 && Number.isFinite(scale4 * scale4)) {
+            const beta = 1 / Math.sqrt(squared);
+            return writeResult(result, point.x * beta, point.y * beta, point.z * beta);
+          }
+          const x = point.x / scale4, y = point.y / scale4, z = point.z / scale4;
+          const norm = Math.hypot(x / this.radii.x, y / this.radii.y, z / this.radii.z);
+          if (!(norm > 0) || !Number.isFinite(norm))
+            return void 0;
+          return writeResult(result, x / norm, y / norm, z / norm);
         }
         /** Transforms a Cartesian X, Y, Z position to the ellipsoid-scaled space by multiplying
          * its components by the result of `Ellipsoid#oneOverRadii` */
         transformPositionToScaledSpace(position, result = [0, 0, 0]) {
-          return scratchPosition.from(position).scale(this.oneOverRadii).to(result);
+          fromCartographic(position, scratchPosition);
+          const point = scratchPosition.scale(this.oneOverRadii);
+          return writeResult(result, point.x, point.y, point.z);
         }
         /** Transforms a Cartesian X, Y, Z position from the ellipsoid-scaled space by multiplying
          * its components by the result of `Ellipsoid#radii`. */
         transformPositionFromScaledSpace(position, result = [0, 0, 0]) {
-          return scratchPosition.from(position).scale(this.radii).to(result);
+          fromCartographic(position, scratchPosition);
+          const point = scratchPosition.scale(this.radii);
+          return writeResult(result, point.x, point.y, point.z);
         }
         /** Computes a point which is the intersection of the surface normal with the z-axis. */
         getSurfaceNormalIntersectionWithZAxis(position, buffer = 0, result = [0, 0, 0]) {
-          assert2(equals(this.radii.x, this.radii.y, math_utils_exports.EPSILON15));
-          assert2(this.radii.z > 0);
-          scratchPosition.from(position);
+          assert2(this.radii.x === this.radii.y && this.minimumRadius > 0);
+          fromCartographic(position, scratchPosition);
+          if (!Number.isFinite(scratchPosition.x) || !Number.isFinite(scratchPosition.y) || !Number.isFinite(scratchPosition.z) || !Number.isFinite(buffer))
+            return void 0;
           const z = scratchPosition.z * (1 - this.squaredXOverSquaredZ);
+          if (!Number.isFinite(z))
+            return void 0;
           if (Math.abs(z) >= this.radii.z - buffer) {
             return void 0;
           }
-          return scratchPosition.set(0, 0, z).to(result);
+          return writeResult(result, 0, 0, z);
         }
       };
       Ellipsoid.WGS84 = new Ellipsoid(WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z);
@@ -4604,12 +4549,12 @@ var __exports__ = (() => {
   });
 
   // ../../node_modules/@math.gl/geometry/dist/culling/lib/bounding-volumes/bounding-sphere.js
-  var scratchVector6, scratchVector22, BoundingSphere;
+  var scratchVector3, scratchVector22, BoundingSphere;
   var init_bounding_sphere = __esm({
     "../../node_modules/@math.gl/geometry/dist/culling/lib/bounding-volumes/bounding-sphere.js"() {
       init_dist();
       init_mat42();
-      scratchVector6 = new Vector3();
+      scratchVector3 = new Vector3();
       scratchVector22 = new Vector3();
       BoundingSphere = class _BoundingSphere {
         /** Creates a bounding sphere */
@@ -4629,7 +4574,7 @@ var __exports__ = (() => {
          * tightly and fully encompasses the box.
          */
         fromCornerPoints(corner, oppositeCorner) {
-          oppositeCorner = scratchVector6.from(oppositeCorner);
+          oppositeCorner = scratchVector3.from(oppositeCorner);
           this.center = new Vector3().from(corner).add(oppositeCorner).scale(0.5);
           this.radius = this.center.distance(oppositeCorner);
           return this;
@@ -4648,7 +4593,7 @@ var __exports__ = (() => {
           const leftRadius = this.radius;
           const rightCenter = boundingSphere.center;
           const rightRadius = boundingSphere.radius;
-          const toRightCenter = scratchVector6.copy(rightCenter).subtract(leftCenter);
+          const toRightCenter = scratchVector3.copy(rightCenter).subtract(leftCenter);
           const centerSeparation = toRightCenter.magnitude();
           if (leftRadius >= centerSeparation + rightRadius) {
             return this.clone();
@@ -4664,7 +4609,7 @@ var __exports__ = (() => {
         }
         /** Computes a bounding sphere by enlarging the provided sphere to contain the provided point. */
         expand(point) {
-          const scratchPoint = scratchVector6.from(point);
+          const scratchPoint = scratchVector3.from(point);
           const radius = scratchPoint.subtract(this.center).magnitude();
           if (radius > this.radius) {
             this.radius = radius;
@@ -4680,7 +4625,7 @@ var __exports__ = (() => {
          */
         transform(transform) {
           this.center.transform(transform);
-          const scale4 = getScaling(scratchVector6, transform);
+          const scale4 = getScaling(scratchVector3, transform);
           this.radius = Math.max(scale4[0], Math.max(scale4[1], scale4[2])) * this.radius;
           return this;
         }
@@ -4691,7 +4636,7 @@ var __exports__ = (() => {
         }
         /** Computes the estimated distance from the closest point on a bounding sphere to a point. */
         distanceTo(point) {
-          const scratchPoint = scratchVector6.from(point);
+          const scratchPoint = scratchVector3.from(point);
           const delta = scratchPoint.subtract(this.center);
           return Math.max(0, delta.len() - this.radius);
         }
@@ -4905,10 +4850,255 @@ var __exports__ = (() => {
     }
   });
 
+  // ../../node_modules/@math.gl/core/dist/local-frame.js
+  function createLocalFrameBasis() {
+    return { eastX: 0, eastY: 1, northZ: 1, upX: 1, upY: 0, upZ: 0 };
+  }
+  function eastNorthUpBasisFromDirections(east, up, result) {
+    const ex = east.x, ey = east.y, ez = east.z;
+    const ux = up.x, uy = up.y, uz = up.z;
+    if (ez !== 0)
+      return false;
+    return commitBasis(result, ex, ey, ux * ey - uy * ex, ux, uy, uz);
+  }
+  function localFrameToMatrix(basis, origin, firstAxis, secondAxis, thirdAxis, result) {
+    const first = axisCode(firstAxis), second = axisCode(secondAxis), third = axisCode(thirdAxis);
+    const a = Math.abs(first), b = Math.abs(second), c = Math.abs(third);
+    if (!a || !b || !c || a === b || a === c || b === c)
+      return false;
+    const parity = a % 3 + 1 === b ? 1 : -1;
+    if (parity * Math.sign(first * second * third) !== 1 || !Array.isArray(result) && result.length < 16)
+      return false;
+    const ex = basis.eastX, ey = basis.eastY, nz = basis.northZ;
+    const ux = basis.upX, uy = basis.upY, uz = basis.upZ;
+    const nx = -uz * ey, ny = uz * ex;
+    const x = origin.x, y = origin.y, z = origin.z;
+    const ax = (a === 1 ? ex : a === 2 ? nx : ux) * Math.sign(first);
+    const ay = (a === 1 ? ey : a === 2 ? ny : uy) * Math.sign(first);
+    const az = (a === 1 ? 0 : a === 2 ? nz : uz) * Math.sign(first);
+    const bx = (b === 1 ? ex : b === 2 ? nx : ux) * Math.sign(second);
+    const by = (b === 1 ? ey : b === 2 ? ny : uy) * Math.sign(second);
+    const bz = (b === 1 ? 0 : b === 2 ? nz : uz) * Math.sign(second);
+    const cx = (c === 1 ? ex : c === 2 ? nx : ux) * Math.sign(third);
+    const cy = (c === 1 ? ey : c === 2 ? ny : uy) * Math.sign(third);
+    const cz = (c === 1 ? 0 : c === 2 ? nz : uz) * Math.sign(third);
+    if (!Number.isFinite(ax) || !Number.isFinite(ay) || !Number.isFinite(az) || !Number.isFinite(bx) || !Number.isFinite(by) || !Number.isFinite(bz) || !Number.isFinite(cx) || !Number.isFinite(cy) || !Number.isFinite(cz) || !Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z))
+      return false;
+    if (result instanceof Float32Array && (!Number.isFinite(Math.fround(ax)) || !Number.isFinite(Math.fround(ay)) || !Number.isFinite(Math.fround(az)) || !Number.isFinite(Math.fround(bx)) || !Number.isFinite(Math.fround(by)) || !Number.isFinite(Math.fround(bz)) || !Number.isFinite(Math.fround(cx)) || !Number.isFinite(Math.fround(cy)) || !Number.isFinite(Math.fround(cz)) || !Number.isFinite(Math.fround(x)) || !Number.isFinite(Math.fround(y)) || !Number.isFinite(Math.fround(z))))
+      return false;
+    result[0] = ax;
+    result[1] = ay;
+    result[2] = az;
+    result[3] = 0;
+    result[4] = bx;
+    result[5] = by;
+    result[6] = bz;
+    result[7] = 0;
+    result[8] = cx;
+    result[9] = cy;
+    result[10] = cz;
+    result[11] = 0;
+    result[12] = x;
+    result[13] = y;
+    result[14] = z;
+    result[15] = 1;
+    return true;
+  }
+  function axisCode(axis) {
+    switch (axis) {
+      case "east":
+        return 1;
+      case "west":
+        return -1;
+      case "north":
+        return 2;
+      case "south":
+        return -2;
+      case "up":
+        return 3;
+      case "down":
+        return -3;
+      default:
+        return 0;
+    }
+  }
+  function commitBasis(result, ex, ey, nz, ux, uy, uz) {
+    if (!Number.isFinite(ex) || !Number.isFinite(ey) || !Number.isFinite(nz) || !Number.isFinite(ux) || !Number.isFinite(uy) || !Number.isFinite(uz))
+      return false;
+    result.eastX = ex;
+    result.eastY = ey;
+    result.northZ = nz;
+    result.upX = ux;
+    result.upY = uy;
+    result.upZ = uz;
+    return true;
+  }
+  var init_local_frame = __esm({
+    "../../node_modules/@math.gl/core/dist/local-frame.js"() {
+    }
+  });
+
+  // ../../node_modules/@math.gl/geospatial/dist/ellipsoid-helpers/ellipsoid-transform.js
+  function localFrameToFixedFrame(ellipsoid, firstAxis, secondAxis, thirdAxis, cartesianOrigin, result) {
+    const thirdAxisInferred = VECTOR_PRODUCT_LOCAL_FRAME[firstAxis] && VECTOR_PRODUCT_LOCAL_FRAME[firstAxis][secondAxis];
+    assert2(thirdAxisInferred && (!thirdAxis || thirdAxis === thirdAxisInferred));
+    let firstAxisVector;
+    let secondAxisVector;
+    let thirdAxisVector;
+    const origin = scratchOrigin.copy(cartesianOrigin);
+    if (!Number.isFinite(origin.x) || !Number.isFinite(origin.y) || !Number.isFinite(origin.z) || !Array.isArray(result) && result.length < 16)
+      throw new Error("Unsupported local frame");
+    const poleTolerance = EPSILON142 * Math.min(1, ellipsoid.maximumRadius);
+    const atPole = Math.abs(origin.x) <= poleTolerance && Math.abs(origin.y) <= poleTolerance;
+    const radii = ellipsoid.radii;
+    if (radii.x === radii.y && radii.x > 0 && radii.z > 0 && radii.z <= radii.x && (!atPole || origin.z !== 0)) {
+      const { east, up } = scratchAxisVectors;
+      if (atPole) {
+        east.set(0, 1, 0);
+        up.set(0, 0, Math.sign(origin.z));
+      } else {
+        const scale4 = Math.max(Math.abs(origin.x), Math.abs(origin.y));
+        east.set(-origin.y / scale4, origin.x / scale4, 0).normalize();
+        ellipsoid.geodeticSurfaceNormal(origin, up);
+      }
+      if (!eastNorthUpBasisFromDirections(east, up, scratchBasis) || !localFrameToMatrix(scratchBasis, origin, firstAxis, secondAxis, thirdAxis, result))
+        throw new Error("Unsupported local frame");
+      return result;
+    }
+    if (atPole) {
+      const sign = Math.sign(origin.z);
+      firstAxisVector = scratchVector1.fromArray(degeneratePositionLocalFrame[firstAxis]);
+      if (firstAxis !== "east" && firstAxis !== "west") {
+        firstAxisVector.scale(sign);
+      }
+      secondAxisVector = scratchVector23.fromArray(degeneratePositionLocalFrame[secondAxis]);
+      if (secondAxis !== "east" && secondAxis !== "west") {
+        secondAxisVector.scale(sign);
+      }
+      thirdAxisVector = scratchVector32.fromArray(degeneratePositionLocalFrame[thirdAxis]);
+      if (thirdAxis !== "east" && thirdAxis !== "west") {
+        thirdAxisVector.scale(sign);
+      }
+    } else {
+      const { up, east, north } = scratchAxisVectors;
+      const scale4 = Math.max(Math.abs(origin.x), Math.abs(origin.y));
+      east.set(-origin.y / scale4, origin.x / scale4, 0).normalize();
+      ellipsoid.geodeticSurfaceNormal(origin, up);
+      north.copy(up).cross(east);
+      const { down, west, south } = scratchAxisVectors;
+      down.copy(up).scale(-1);
+      west.copy(east).scale(-1);
+      south.copy(north).scale(-1);
+      firstAxisVector = scratchAxisVectors[firstAxis];
+      secondAxisVector = scratchAxisVectors[secondAxis];
+      thirdAxisVector = scratchAxisVectors[thirdAxis];
+    }
+    const ax = firstAxisVector.x, ay = firstAxisVector.y, az = firstAxisVector.z;
+    const bx = secondAxisVector.x, by = secondAxisVector.y, bz = secondAxisVector.z;
+    const cx = thirdAxisVector.x, cy = thirdAxisVector.y, cz = thirdAxisVector.z;
+    const x = origin.x, y = origin.y, z = origin.z;
+    result[0] = ax;
+    result[1] = ay;
+    result[2] = az;
+    result[3] = 0;
+    result[4] = bx;
+    result[5] = by;
+    result[6] = bz;
+    result[7] = 0;
+    result[8] = cx;
+    result[9] = cy;
+    result[10] = cz;
+    result[11] = 0;
+    result[12] = x;
+    result[13] = y;
+    result[14] = z;
+    result[15] = 1;
+    return result;
+  }
+  var EPSILON142, scratchOrigin, scratchBasis, VECTOR_PRODUCT_LOCAL_FRAME, degeneratePositionLocalFrame, scratchAxisVectors, scratchVector1, scratchVector23, scratchVector32;
+  var init_ellipsoid_transform = __esm({
+    "../../node_modules/@math.gl/geospatial/dist/ellipsoid-helpers/ellipsoid-transform.js"() {
+      init_dist();
+      init_local_frame();
+      EPSILON142 = 1e-14;
+      scratchOrigin = new Vector3();
+      scratchBasis = createLocalFrameBasis();
+      VECTOR_PRODUCT_LOCAL_FRAME = {
+        up: {
+          south: "east",
+          north: "west",
+          west: "south",
+          east: "north"
+        },
+        down: {
+          south: "west",
+          north: "east",
+          west: "north",
+          east: "south"
+        },
+        south: {
+          up: "west",
+          down: "east",
+          west: "down",
+          east: "up"
+        },
+        north: {
+          up: "east",
+          down: "west",
+          west: "up",
+          east: "down"
+        },
+        west: {
+          up: "north",
+          down: "south",
+          north: "down",
+          south: "up"
+        },
+        east: {
+          up: "south",
+          down: "north",
+          north: "up",
+          south: "down"
+        }
+      };
+      degeneratePositionLocalFrame = {
+        north: [-1, 0, 0],
+        east: [0, 1, 0],
+        up: [0, 0, 1],
+        south: [1, 0, 0],
+        west: [0, -1, 0],
+        down: [0, 0, -1]
+      };
+      scratchAxisVectors = {
+        east: new Vector3(),
+        north: new Vector3(),
+        up: new Vector3(),
+        west: new Vector3(),
+        south: new Vector3(),
+        down: new Vector3()
+      };
+      scratchVector1 = new Vector3();
+      scratchVector23 = new Vector3();
+      scratchVector32 = new Vector3();
+    }
+  });
+
+  // ../../node_modules/@math.gl/geospatial/dist/ellipsoid-transforms.js
+  function eastNorthUpToFixedFrame(ellipsoid, origin, result = new Matrix4()) {
+    return localFrameToFixedFrame(ellipsoid, "east", "north", "up", origin, result);
+  }
+  var init_ellipsoid_transforms = __esm({
+    "../../node_modules/@math.gl/geospatial/dist/ellipsoid-transforms.js"() {
+      init_dist();
+      init_ellipsoid_transform();
+    }
+  });
+
   // ../../node_modules/@math.gl/geospatial/dist/entries/ellipsoid.js
   var init_ellipsoid2 = __esm({
     "../../node_modules/@math.gl/geospatial/dist/entries/ellipsoid.js"() {
       init_ellipsoid();
+      init_ellipsoid_transforms();
     }
   });
 
@@ -6585,6 +6775,7 @@ var __exports__ = (() => {
 
   // ../tiles-3d/src/tileset-3d/helpers/transform-utils.ts
   init_dist2();
+  init_ellipsoid2();
   init_dist();
   init_loader_utils();
   function calculateTransformProps(tileHeader, tile) {
@@ -6623,7 +6814,7 @@ var __exports__ = (() => {
       cartesianOrigin,
       new Vector3()
     );
-    const fromFixedFrameMatrix = Ellipsoid.WGS84.eastNorthUpToFixedFrame(cartesianOrigin);
+    const fromFixedFrameMatrix = eastNorthUpToFixedFrame(Ellipsoid.WGS84, cartesianOrigin);
     const toFixedFrameMatrix = fromFixedFrameMatrix.invert();
     tile.cartographicModelMatrix = toFixedFrameMatrix.multiplyRight(modelMatrix);
     tile.cartographicOrigin = cartographicOrigin;
@@ -6639,13 +6830,14 @@ var __exports__ = (() => {
   }
   var TRANSLATION_LIMIT_SQUARED = 1e6 ** 2;
   function _getRootNode(tile) {
-    const gltf = tile.gltf;
+    const gltf = tile.gltf?.json;
     if (!gltf) {
       return null;
     }
     const sceneIndex = typeof gltf.scene === "number" ? gltf.scene : 0;
     const scene = gltf.scenes?.[sceneIndex];
-    const rootNode = scene?.nodes?.[0];
+    const rootNodeIndex = scene?.nodes?.[0];
+    const rootNode = rootNodeIndex === void 0 ? void 0 : gltf.nodes?.[rootNodeIndex];
     if (!rootNode?.matrix) return null;
     const m = rootNode.matrix;
     const translationMagnitude = m[12] * m[12] + m[13] * m[13] + m[14] * m[14];
@@ -6657,7 +6849,8 @@ var __exports__ = (() => {
   init_dist();
   init_culling();
   init_dist2();
-  var scratchVector7 = new Vector3();
+  init_ellipsoid2();
+  var scratchVector4 = new Vector3();
   var scratchPosition3 = new Vector3();
   var CAMERA_POSITION_EPSILON = 1e-5;
   var CAMERA_DIRECTION_EPSILON = 1e-7;
@@ -6674,7 +6867,7 @@ var __exports__ = (() => {
     const cameraDirection = viewport.cameraDirection;
     const { metersPerUnit } = viewport.distanceScales;
     const viewportCenterCartesian = worldToCartesian(viewport, viewport.center);
-    const enuToFixedTransform = Ellipsoid.WGS84.eastNorthUpToFixedFrame(viewportCenterCartesian);
+    const enuToFixedTransform = eastNorthUpToFixedFrame(Ellipsoid.WGS84, viewportCenterCartesian);
     const cameraPositionCartographic = viewport.unprojectPosition(viewport.cameraPosition);
     const cameraPositionCartesian = Ellipsoid.WGS84.cartographicToCartesian(
       cameraPositionCartographic,
@@ -6782,7 +6975,7 @@ var __exports__ = (() => {
     let i = 0;
     cullingVolume.planes[i++].fromPointNormal(
       nearCenterCartesian,
-      scratchVector7.copy(nearCenterCartesian).subtract(cameraCartesian)
+      scratchVector4.copy(nearCenterCartesian).subtract(cameraCartesian)
     );
     for (const dir in frustumPlanes) {
       if (dir === "near") {
@@ -6794,7 +6987,7 @@ var __exports__ = (() => {
       cullingVolume.planes[i++].fromPointNormal(
         cartesianPos,
         // Want the normal to point into the frustum since that's what culling expects
-        scratchVector7.copy(nearCenterCartesian).subtract(cartesianPos)
+        scratchVector4.copy(nearCenterCartesian).subtract(cartesianPos)
       );
     }
   }