@math.gl/geospatial 5.0.0-alpha.19 → 5.0.0-alpha.20

package/dist/expressions.cjs

@@ -1,8 +1,6 @@
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -16,14 +14,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // dist/expressions.js
@@ -33,93 +23,14 @@ __export(expressions_exports, {
 });
 module.exports = __toCommonJS(expressions_exports);
 
-// dist/ellipsoid.js
-var import_core4 = require("@math.gl/core");
-var import_spheroid = require("@math.gl/core/spheroid");
-var vec3 = __toESM(require("@math.gl/core/vec3"), 1);
-
-// dist/constants.js
-var WGS84_RADIUS_X = 6378137;
-var WGS84_RADIUS_Y = 6378137;
-var WGS84_RADIUS_Z = 6356752314245179e-9;
-var WGS84_CONSTANTS = {
-  radii: [WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z],
-  radiiSquared: [
-    WGS84_RADIUS_X * WGS84_RADIUS_X,
-    WGS84_RADIUS_Y * WGS84_RADIUS_Y,
-    WGS84_RADIUS_Z * WGS84_RADIUS_Z
-  ],
-  oneOverRadii: [1 / WGS84_RADIUS_X, 1 / WGS84_RADIUS_Y, 1 / WGS84_RADIUS_Z],
-  oneOverRadiiSquared: [
-    1 / (WGS84_RADIUS_X * WGS84_RADIUS_X),
-    1 / (WGS84_RADIUS_Y * WGS84_RADIUS_Y),
-    1 / (WGS84_RADIUS_Z * WGS84_RADIUS_Z)
-  ],
-  maximumRadius: Math.max(WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z),
-  centerToleranceSquared: 0.1
-  // EPSILON1;
-};
-
-// dist/type-utils.js
-var import_core = require("@math.gl/core");
-function identity(x) {
-  return x;
-}
-var scratchVector = new import_core.Vector3();
-function fromCartographic(cartographic, result = [], map = identity) {
-  if ("longitude" in cartographic) {
-    result[0] = map(cartographic.longitude);
-    result[1] = map(cartographic.latitude);
-    result[2] = cartographic.height;
-  } else if ("x" in cartographic) {
-    result[0] = map(cartographic.x);
-    result[1] = map(cartographic.y);
-    result[2] = cartographic.z;
-  } else {
-    result[0] = map(cartographic[0]);
-    result[1] = map(cartographic[1]);
-    result[2] = cartographic[2];
-  }
-  return result;
-}
-function fromCartographicToRadians(cartographic, vector = []) {
-  return fromCartographic(cartographic, vector, import_core.config._cartographicRadians ? identity : import_core.toRadians);
-}
-function toCartographicFromRadiansComponents(longitude, latitude, height, cartographic) {
-  const map = import_core.config._cartographicRadians ? identity : import_core.toDegrees;
-  const mappedLongitude = map(longitude), mappedLatitude = map(latitude);
-  if ("longitude" in cartographic) {
-    cartographic.longitude = mappedLongitude;
-    cartographic.latitude = mappedLatitude;
-    cartographic.height = height;
-  } else if ("x" in cartographic) {
-    cartographic.x = mappedLongitude;
-    cartographic.y = mappedLatitude;
-    cartographic.z = height;
-  } else {
-    cartographic[0] = mappedLongitude;
-    cartographic[1] = mappedLatitude;
-    cartographic[2] = height;
-  }
-  return cartographic;
-}
-function isWGS84(vector) {
-  if (!vector) {
-    return false;
-  }
-  scratchVector.from(vector);
-  const { oneOverRadiiSquared, centerToleranceSquared } = WGS84_CONSTANTS;
-  const x2 = vector[0] * vector[0] * oneOverRadiiSquared[0];
-  const y2 = vector[1] * vector[1] * oneOverRadiiSquared[1];
-  const z2 = vector[2] * vector[2] * oneOverRadiiSquared[2];
-  return Math.abs(x2 + y2 + z2 - 1) < centerToleranceSquared;
-}
+// dist/ellipsoid-transforms.js
+var import_core2 = require("@math.gl/core");
 
 // dist/ellipsoid-helpers/ellipsoid-transform.js
-var import_core2 = require("@math.gl/core");
+var import_core = require("@math.gl/core");
 var import_local_frame = require("@math.gl/core/local-frame");
 var EPSILON14 = 1e-14;
-var scratchOrigin = new import_core2.Vector3();
+var scratchOrigin = new import_core.Vector3();
 var scratchBasis = (0, import_local_frame.createLocalFrameBasis)();
 var VECTOR_PRODUCT_LOCAL_FRAME = {
   up: {
@@ -168,24 +79,27 @@ var degeneratePositionLocalFrame = {
   down: [0, 0, -1]
 };
 var scratchAxisVectors = {
-  east: new import_core2.Vector3(),
-  north: new import_core2.Vector3(),
-  up: new import_core2.Vector3(),
-  west: new import_core2.Vector3(),
-  south: new import_core2.Vector3(),
-  down: new import_core2.Vector3()
+  east: new import_core.Vector3(),
+  north: new import_core.Vector3(),
+  up: new import_core.Vector3(),
+  west: new import_core.Vector3(),
+  south: new import_core.Vector3(),
+  down: new import_core.Vector3()
 };
-var scratchVector1 = new import_core2.Vector3();
-var scratchVector2 = new import_core2.Vector3();
-var scratchVector3 = new import_core2.Vector3();
+var scratchVector1 = new import_core.Vector3();
+var scratchVector2 = new import_core.Vector3();
+var scratchVector3 = new import_core.Vector3();
 function localFrameToFixedFrame(ellipsoid, firstAxis, secondAxis, thirdAxis, cartesianOrigin, result) {
   const thirdAxisInferred = VECTOR_PRODUCT_LOCAL_FRAME[firstAxis] && VECTOR_PRODUCT_LOCAL_FRAME[firstAxis][secondAxis];
-  (0, import_core2.assert)(thirdAxisInferred && (!thirdAxis || thirdAxis === thirdAxisInferred));
+  (0, import_core.assert)(thirdAxisInferred && (!thirdAxis || thirdAxis === thirdAxisInferred));
   let firstAxisVector;
   let secondAxisVector;
   let thirdAxisVector;
   const origin = scratchOrigin.copy(cartesianOrigin);
-  const atPole = (0, import_core2.equals)(origin.x, 0, EPSILON14) && (0, import_core2.equals)(origin.y, 0, EPSILON14);
+  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 = EPSILON14 * 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;
@@ -193,7 +107,8 @@ function localFrameToFixedFrame(ellipsoid, firstAxis, secondAxis, thirdAxis, car
       east.set(0, 1, 0);
       up.set(0, 0, Math.sign(origin.z));
     } else {
-      east.set(-origin.y, origin.x, 0).normalize();
+      const scale = Math.max(Math.abs(origin.x), Math.abs(origin.y));
+      east.set(-origin.y / scale, origin.x / scale, 0).normalize();
       ellipsoid.geodeticSurfaceNormal(origin, up);
     }
     if (!(0, import_local_frame.eastNorthUpBasisFromDirections)(east, up, scratchBasis) || !(0, import_local_frame.localFrameToMatrix)(scratchBasis, origin, firstAxis, secondAxis, thirdAxis, result))
@@ -216,7 +131,8 @@ function localFrameToFixedFrame(ellipsoid, firstAxis, secondAxis, thirdAxis, car
     }
   } else {
     const { up, east, north } = scratchAxisVectors;
-    east.set(-origin.y, origin.x, 0).normalize();
+    const scale = Math.max(Math.abs(origin.x), Math.abs(origin.y));
+    east.set(-origin.y / scale, origin.x / scale, 0).normalize();
     ellipsoid.geodeticSurfaceNormal(origin, up);
     north.copy(up).cross(east);
     const { down, west, south } = scratchAxisVectors;
@@ -250,77 +166,306 @@ function localFrameToFixedFrame(ellipsoid, firstAxis, secondAxis, thirdAxis, car
   return result;
 }
 
-// dist/ellipsoid-helpers/scale-to-geodetic-surface.js
+// dist/ellipsoid-transforms.js
+function eastNorthUpToFixedFrame(ellipsoid, origin, result = new import_core2.Matrix4()) {
+  return localFrameToFixedFrame(ellipsoid, "east", "north", "up", origin, result);
+}
+
+// dist/ellipsoid.js
+var import_core5 = require("@math.gl/core");
+var import_spheroid = require("@math.gl/core/spheroid");
+
+// dist/constants.js
+var WGS84_RADIUS_X = 6378137;
+var WGS84_RADIUS_Y = 6378137;
+var WGS84_RADIUS_Z = 6356752314245179e-9;
+var WGS84_CONSTANTS = {
+  radii: [WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z],
+  radiiSquared: [
+    WGS84_RADIUS_X * WGS84_RADIUS_X,
+    WGS84_RADIUS_Y * WGS84_RADIUS_Y,
+    WGS84_RADIUS_Z * WGS84_RADIUS_Z
+  ],
+  oneOverRadii: [1 / WGS84_RADIUS_X, 1 / WGS84_RADIUS_Y, 1 / WGS84_RADIUS_Z],
+  oneOverRadiiSquared: [
+    1 / (WGS84_RADIUS_X * WGS84_RADIUS_X),
+    1 / (WGS84_RADIUS_Y * WGS84_RADIUS_Y),
+    1 / (WGS84_RADIUS_Z * WGS84_RADIUS_Z)
+  ],
+  maximumRadius: Math.max(WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z),
+  centerToleranceSquared: 0.1
+  // EPSILON1;
+};
+
+// dist/type-utils.js
 var import_core3 = require("@math.gl/core");
-var scratchVector4 = new import_core3.Vector3();
-var scaleToGeodeticSurfaceIntersection = new import_core3.Vector3();
-var scaleToGeodeticSurfaceGradient = new import_core3.Vector3();
-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)) {
-    return void 0;
+function identity(x) {
+  return x;
+}
+var scratchVector = new import_core3.Vector3();
+function fromCartographic(cartographic, result = [], map = identity) {
+  if ("longitude" in cartographic) {
+    result[0] = map(cartographic.longitude);
+    result[1] = map(cartographic.latitude);
+    result[2] = cartographic.height;
+  } else if ("x" in cartographic) {
+    result[0] = map(cartographic.x);
+    result[1] = map(cartographic.y);
+    result[2] = cartographic.z;
+  } else {
+    result[0] = map(cartographic[0]);
+    result[1] = map(cartographic[1]);
+    result[2] = cartographic[2];
   }
-  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)) {
-    return void 0;
+  return result;
+}
+function fromCartographicToRadians(cartographic, vector = []) {
+  return fromCartographic(cartographic, vector, import_core3.config._cartographicRadians ? identity : import_core3.toRadians);
+}
+function toCartographicFromRadiansComponents(longitude, latitude, height, cartographic) {
+  const map = import_core3.config._cartographicRadians ? identity : import_core3.toDegrees;
+  const mappedLongitude = map(longitude), mappedLatitude = map(latitude);
+  if ("longitude" in cartographic) {
+    cartographic.longitude = mappedLongitude;
+    cartographic.latitude = mappedLatitude;
+    cartographic.height = height;
+  } else if ("x" in cartographic) {
+    cartographic.x = mappedLongitude;
+    cartographic.y = mappedLatitude;
+    cartographic.z = height;
+  } else {
+    cartographic[0] = mappedLongitude;
+    cartographic[1] = mappedLatitude;
+    cartographic[2] = height;
   }
-  const intersection = scaleToGeodeticSurfaceIntersection;
-  intersection.set(positionX, positionY, positionZ).scale(ratio);
-  if (squaredNorm < centerToleranceSquared) {
-    return writeResult(result, intersection.x, intersection.y, intersection.z);
+  return cartographic;
+}
+function isWGS84(vector) {
+  if (!vector) {
+    return false;
   }
-  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) <= import_core3._MathUtils.EPSILON12) {
-      return writeResult(result, positionX * xMultiplier, positionY * yMultiplier, positionZ * zMultiplier);
+  scratchVector.from(vector);
+  const { oneOverRadiiSquared, centerToleranceSquared } = WGS84_CONSTANTS;
+  const x2 = vector[0] * vector[0] * oneOverRadiiSquared[0];
+  const y2 = vector[1] * vector[1] * oneOverRadiiSquared[1];
+  const z2 = vector[2] * vector[2] * oneOverRadiiSquared[2];
+  return Math.abs(x2 + y2 + z2 - 1) < centerToleranceSquared;
+}
+
+// dist/ellipsoid-helpers/scale-to-geodetic-surface.js
+var import_core4 = require("@math.gl/core");
+
+// 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 dot = bits.indexOf(".");
+    return {
+      integer: BigInt("0b" + bits.replace(".", "")),
+      exponent: dot < 0 ? 0 : dot + 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;
     }
-    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;
+    if (numerator < 0n)
+      return false;
+    if (numerator === 0n) {
+      return commit(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;
+  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 commit(t, unit);
+    if (sign > 0n)
+      lower = t;
+    else
+      upper = t;
+    if (lower > 0n && upper - lower <= lower >> 60n)
+      return commit(lower + upper >> 1n, unit);
   }
-  return void 0;
+  return false;
+  function commit(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 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);
+}
+
+// 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 = productError(minimum, minimum, minimumSquared);
+  const dx = aa - minimumSquared, dy = bb - minimumSquared, dz = cc - minimumSquared;
+  const ex = sumError(aa, -minimumSquared, dx) + productError(a, a, aa) - minimumError;
+  const ey = sumError(bb, -minimumSquared, dy) + productError(b, b, bb) - minimumError;
+  const ez = sumError(cc, -minimumSquared, dz) + productError(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 = productError(a, Math.abs(x), ux);
+  const fy = productError(b, Math.abs(y), uy);
+  const fz = productError(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 = sumError(dx, t, hx) + ex;
+    const ly = sumError(dy, t, hy) + ey;
+    const lz = sumError(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 {
+      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;
+    }
+    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 = sumError(u, -d, difference) + error - dError;
+  const base = difference + correction;
+  const low = sumError(difference, correction, base);
+  const shifted = base - t;
+  return (shifted + (sumError(base, -t, shifted) + low)) / denominator;
+}
+function sumError(x, y, sum) {
+  const part = sum - x;
+  return x - (sum - part) + (y - part);
+}
+function productError(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;
+}
+
+// dist/ellipsoid-helpers/scale-to-geodetic-surface.js
+var surface = { x: 0, y: 0, z: 0 };
+function scaleToGeodeticSurface(cartesian, ellipsoid, result = []) {
+  const object = cartesian;
+  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;
+  if (!Number.isFinite(x * x + y * y + z * z))
+    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 ((0, import_core3.isArray)(result)) {
+  if ((0, import_core4.isArray)(result)) {
     result[0] = x;
     result[1] = y;
     result[2] = z;
@@ -335,12 +480,10 @@ function writeResult(result, x, y, z) {
 
 // dist/ellipsoid.js
 var spheroidScratch = { x: 0, y: 0, z: 0 };
-var scratchVector5 = new import_core4.Vector3();
-var scratchNormal = new import_core4.Vector3();
-var scratchK = new import_core4.Vector3();
-var scratchPosition = new import_core4.Vector3();
-var scratchHeight = new import_core4.Vector3();
-var scratchCartesian = new import_core4.Vector3();
+var scratchVector4 = new import_core5.Vector3();
+var scratchNormal = new import_core5.Vector3();
+var scratchPosition = new import_core5.Vector3();
+var scratchCartesian = new import_core5.Vector3();
 var Ellipsoid = class _Ellipsoid {
   /** Construct from two-axis geometry, including normalized projection ellipsoids.
    * The equatorial X/Y radii are equal; no CRS or datum information is inferred.
@@ -351,26 +494,31 @@ var Ellipsoid = class _Ellipsoid {
     return new _Ellipsoid(semiMajorAxis, semiMajorAxis, semiMinorAxis);
   }
   constructor(x = 0, y = 0, z = 0) {
-    this.centerToleranceSquared = import_core4._MathUtils.EPSILON1;
-    (0, import_core4.assert)(x >= 0);
-    (0, import_core4.assert)(y >= 0);
-    (0, import_core4.assert)(z >= 0);
-    this.radii = new import_core4.Vector3(x, y, z);
-    this.radiiSquared = new import_core4.Vector3(x * x, y * y, z * z);
-    this.radiiToTheFourth = new import_core4.Vector3(x * x * x * x, y * y * y * y, z * z * z * z);
-    this.oneOverRadii = new import_core4.Vector3(x === 0 ? 0 : 1 / x, y === 0 ? 0 : 1 / y, z === 0 ? 0 : 1 / z);
-    this.oneOverRadiiSquared = new import_core4.Vector3(x === 0 ? 0 : 1 / (x * x), y === 0 ? 0 : 1 / (y * y), z === 0 ? 0 : 1 / (z * z));
+    this.centerToleranceSquared = import_core5._MathUtils.EPSILON1;
+    (0, import_core5.assert)(Number.isFinite(x) && x >= 0);
+    (0, import_core5.assert)(Number.isFinite(y) && y >= 0);
+    (0, import_core5.assert)(Number.isFinite(z) && z >= 0);
+    this.radii = new import_core5.Vector3(x, y, z);
+    this.radiiSquared = new import_core5.Vector3(x * x, y * y, z * z);
+    this.radiiToTheFourth = new import_core5.Vector3(x * x * x * x, y * y * y * y, z * z * z * z);
+    this.oneOverRadii = new import_core5.Vector3(x === 0 ? 0 : 1 / x, y === 0 ? 0 : 1 / y, z === 0 ? 0 : 1 / z);
+    this.oneOverRadiiSquared = new import_core5.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.
@@ -388,30 +536,34 @@ var Ellipsoid = class _Ellipsoid {
   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 && (import_core5.config._cartographicRadians || Math.abs(latitude) <= Math.PI / 4)) {
+      spheroidScratch.x = longitude;
+      spheroidScratch.y = latitude;
+      spheroidScratch.z = height;
       if (!(0, import_spheroid.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;
@@ -424,45 +576,68 @@ var Ellipsoid = class _Ellipsoid {
       spheroidScratch.x = x;
       spheroidScratch.y = y;
       spheroidScratch.z = z;
-      if (!(0, import_spheroid.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 && (0, import_spheroid.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(vec3.dot(h, scratchCartesian)) * vec3.length(h);
+    const gx = point[0] * this.oneOverRadiiSquared.x;
+    const gy = point[1] * this.oneOverRadiiSquared.y;
+    const gz = point[2] * this.oneOverRadiiSquared.z;
+    const length = Math.hypot(gx, gy, gz);
+    if (!(length > 0) || !Number.isFinite(length))
+      return void 0;
+    const nx = gx / length, ny = gy / length, nz = gz / length;
+    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 import_core4.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 import_core4.Matrix4()) {
-    return localFrameToFixedFrame(this, firstAxis, secondAxis, thirdAxis, origin, result);
-  }
   geocentricSurfaceNormal(cartesian, result = [0, 0, 0]) {
-    return scratchVector5.from(cartesian).normalize().to(result);
+    fromCartographic(cartesian, scratchVector4);
+    const point = scratchVector4;
+    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 = import_core5.config._cartographicRadians ? point[0] : point[0] * Math.PI / 180;
+    const latitude = import_core5.config._cartographicRadians ? point[1] : point[1] * Math.PI / 180;
+    const polarDegrees = !import_core5.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, scratchVector4);
+    const point = scratchVector4;
+    const scale = Math.max(Math.abs(point.x), Math.abs(point.y), Math.abs(point.z));
+    if (!(scale > 0) || !Number.isFinite(scale))
+      return void 0;
+    const nx = point.x / scale * (this.minimumRadius / this.radii.x) ** 2;
+    const ny = point.y / scale * (this.minimumRadius / this.radii.y) ** 2;
+    const nz = point.z / scale * (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
@@ -473,34 +648,49 @@ var Ellipsoid = class _Ellipsoid {
   /** 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 scale = Math.max(Math.abs(point.x), Math.abs(point.y), Math.abs(point.z));
+    if (!(this.minimumRadius > 0) || !(scale > 0) || !Number.isFinite(scale))
+      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) && scale * scale >= 2 ** -1022 && Number.isFinite(scale * scale)) {
+      const beta = 1 / Math.sqrt(squared);
+      return writeResult(result, point.x * beta, point.y * beta, point.z * beta);
+    }
+    const x = point.x / scale, y = point.y / scale, z = point.z / scale;
+    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]) {
-    (0, import_core4.assert)((0, import_core4.equals)(this.radii.x, this.radii.y, import_core4._MathUtils.EPSILON15));
-    (0, import_core4.assert)(this.radii.z > 0);
-    scratchPosition.from(position);
+    (0, import_core5.assert)(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);
@@ -508,20 +698,28 @@ function validateSpheroid(a, b) {
   if (!Number.isFinite(a) || !Number.isFinite(b) || a <= 0 || b <= 0 || b > a)
     throw new Error("Spheroid requires finite positive axes with semiMinorAxis <= semiMajorAxis");
 }
+function normalResult(x, y, z, result) {
+  const scale = Math.max(Math.abs(x), Math.abs(y), Math.abs(z));
+  if (!(scale > 0) || !Number.isFinite(scale))
+    return void 0;
+  const nx = x / scale, ny = y / scale, nz = z / scale;
+  const length = Math.hypot(nx, ny, nz);
+  return writeResult(result, nx / length, ny / length, nz / length);
+}
 
 // dist/expressions.js
-var import_core5 = require("@math.gl/core");
+var import_core6 = require("@math.gl/core");
 var GEOSPATIAL_FUNCTION_LIBRARY = {
   cartesianToCartographic: (cartesian, result) => Ellipsoid.WGS84.cartesianToCartographic(cartesian, result),
   cartographicToCartesian: (cartographic, result) => Ellipsoid.WGS84.cartographicToCartesian(cartographic, result),
-  eastNorthUpToFixedFrame: (origin, result) => Ellipsoid.WGS84.eastNorthUpToFixedFrame(origin, result),
+  eastNorthUpToFixedFrame: (origin, result) => eastNorthUpToFixedFrame(Ellipsoid.WGS84, origin, result),
   geodeticSurfaceNormal: (cartesian, result) => Ellipsoid.WGS84.geodeticSurfaceNormal(cartesian, result),
   geodeticSurfaceNormalCartographic: (cartographic, result) => Ellipsoid.WGS84.geodeticSurfaceNormalCartographic(cartographic, result),
   isWGS84,
   scaleToGeocentricSurface: (cartesian, result) => Ellipsoid.WGS84.scaleToGeocentricSurface(cartesian, result),
   scaleToGeodeticSurface: (cartesian, result) => Ellipsoid.WGS84.scaleToGeodeticSurface(cartesian, result),
-  toDegrees: import_core5.toDegrees,
-  toRadians: import_core5.toRadians,
+  toDegrees: import_core6.toDegrees,
+  toRadians: import_core6.toRadians,
   transformPositionFromScaledSpace: (position, result) => Ellipsoid.WGS84.transformPositionFromScaledSpace(position, result),
   transformPositionToScaledSpace: (position, result) => Ellipsoid.WGS84.transformPositionToScaledSpace(position, result)
 };