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

package/dist/globe.cjs

@@ -0,0 +1,1002 @@
+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)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  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/globe.js
+var globe_exports = {};
+__export(globe_exports, {
+  EllipsoidOccluder: () => EllipsoidOccluder,
+  LngLatRectangle: () => LngLatRectangle,
+  getGlobeHorizonBounds: () => getGlobeHorizonBounds,
+  makeOBBFromRegion: () => makeOBBFromRegion,
+  splitGlobeBounds: () => splitGlobeBounds,
+  subdivideGlobeMesh: () => subdivideGlobeMesh
+});
+module.exports = __toCommonJS(globe_exports);
+
+// dist/lng-lat-rectangle.js
+var import_core = require("@math.gl/core");
+var LngLatRectangle = class {
+  /**
+   * Creates a new two dimensional region specified as longitude and latitude coordinates.
+   *
+   * @param west The westernmost longitude, in radians, in the range [-Pi, Pi].
+   * @param south The southernmost latitude, in radians, in the range [-Pi/2, Pi/2].
+   * @param east The easternmost longitude, in radians, in the range [-Pi, Pi].
+   * @param north The northernmost latitude, in radians, in the range [-Pi/2, Pi/2].
+   */
+  constructor(west, south, east, north) {
+    this.west = west;
+    this.south = south;
+    this.east = east;
+    this.north = north;
+  }
+  /**
+   * Computes the center of a rectangle.
+   *
+   * @param rectangle The rectangle for which to find the center
+   * @param  [result] The object onto which to store the result.
+   * @returns  The modified result parameter or a new Cartographic instance if none was provided.
+   */
+  static center(rectangle, result) {
+    if (!result)
+      result = new import_core.Vector3();
+    let east = rectangle.east;
+    const west = rectangle.west;
+    if (east < west) {
+      east += import_core._MathUtils.TWO_PI;
+    }
+    const longitude = (0, import_core.normalizeAngle)((west + east) * 0.5, "negative-pi-to-pi");
+    const latitude = (rectangle.south + rectangle.north) * 0.5;
+    result.x = longitude;
+    result.y = latitude;
+    result.z = 0;
+    return result;
+  }
+  get width() {
+    let east = this.east;
+    const west = this.west;
+    if (east < west) {
+      east += import_core._MathUtils.TWO_PI;
+    }
+    return east - west;
+  }
+};
+
+// dist/make-obb-from-region.js
+var import_core7 = require("@math.gl/core");
+var import_culling2 = require("@math.gl/geometry/culling");
+
+// dist/ellipsoid.js
+var import_core5 = 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_core2 = require("@math.gl/core");
+function identity(x) {
+  return x;
+}
+var scratchVector = new import_core2.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_core2.config._cartographicRadians ? identity : import_core2.toRadians);
+}
+function toCartographicFromRadiansComponents(longitude, latitude, height, cartographic) {
+  const map = import_core2.config._cartographicRadians ? identity : import_core2.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;
+}
+
+// dist/ellipsoid-helpers/ellipsoid-transform.js
+var import_core3 = require("@math.gl/core");
+var import_local_frame = require("@math.gl/core/local-frame");
+var EPSILON14 = 1e-14;
+var scratchOrigin = new import_core3.Vector3();
+var scratchBasis = (0, import_local_frame.createLocalFrameBasis)();
+var 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"
+  }
+};
+var 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]
+};
+var scratchAxisVectors = {
+  east: new import_core3.Vector3(),
+  north: new import_core3.Vector3(),
+  up: new import_core3.Vector3(),
+  west: new import_core3.Vector3(),
+  south: new import_core3.Vector3(),
+  down: new import_core3.Vector3()
+};
+var scratchVector1 = new import_core3.Vector3();
+var scratchVector2 = new import_core3.Vector3();
+var scratchVector3 = new import_core3.Vector3();
+function localFrameToFixedFrame(ellipsoid, firstAxis, secondAxis, thirdAxis, cartesianOrigin, result) {
+  const thirdAxisInferred = VECTOR_PRODUCT_LOCAL_FRAME[firstAxis] && VECTOR_PRODUCT_LOCAL_FRAME[firstAxis][secondAxis];
+  (0, import_core3.assert)(thirdAxisInferred && (!thirdAxis || thirdAxis === thirdAxisInferred));
+  let firstAxisVector;
+  let secondAxisVector;
+  let thirdAxisVector;
+  const origin = scratchOrigin.copy(cartesianOrigin);
+  const atPole = (0, import_core3.equals)(origin.x, 0, EPSILON14) && (0, import_core3.equals)(origin.y, 0, EPSILON14);
+  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 {
+      east.set(-origin.y, origin.x, 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))
+      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);
+    }
+  } 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;
+}
+
+// dist/ellipsoid-helpers/scale-to-geodetic-surface.js
+var import_core4 = require("@math.gl/core");
+var scratchVector4 = new import_core4.Vector3();
+var scaleToGeodeticSurfaceIntersection = new import_core4.Vector3();
+var scaleToGeodeticSurfaceGradient = new import_core4.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;
+  }
+  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;
+  }
+  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) <= import_core4._MathUtils.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;
+}
+function writeResult(result, x, y, z) {
+  if ((0, import_core4.isArray)(result)) {
+    result[0] = x;
+    result[1] = y;
+    result[2] = z;
+  } else {
+    const point = result;
+    point.x = x;
+    point.y = y;
+    point.z = z;
+  }
+  return result;
+}
+
+// dist/ellipsoid.js
+var spheroidScratch = { x: 0, y: 0, z: 0 };
+var scratchVector5 = new import_core5.Vector3();
+var scratchNormal = new import_core5.Vector3();
+var scratchK = new import_core5.Vector3();
+var scratchPosition = new import_core5.Vector3();
+var scratchHeight = 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.
+   */
+  static fromSpheroid(parameters) {
+    const { semiMajorAxis, semiMinorAxis } = parameters;
+    validateSpheroid(semiMajorAxis, semiMinorAxis);
+    return new _Ellipsoid(semiMajorAxis, semiMajorAxis, semiMinorAxis);
+  }
+  constructor(x = 0, y = 0, z = 0) {
+    this.centerToleranceSquared = import_core5._MathUtils.EPSILON1;
+    (0, import_core5.assert)(x >= 0);
+    (0, import_core5.assert)(y >= 0);
+    (0, import_core5.assert)(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 (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
+      });
+    Object.freeze(this);
+  }
+  /** Return an owned geometry snapshot for a sphere or oblate spheroid.
+   * Triaxial, prolate and degenerate ellipsoids cannot be represented by this contract.
+   * Call during setup, outside coordinate loops.
+   */
+  toSpheroid() {
+    const { x, y, z } = this.radii;
+    if (x !== y)
+      throw new Error("Spheroid requires equal X/Y radii");
+    validateSpheroid(x, z);
+    return Object.freeze({ semiMajorAxis: x, semiMinorAxis: z });
+  }
+  /** Compares this Ellipsoid against the provided Ellipsoid componentwise */
+  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)'. */
+  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];
+      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);
+  }
+  cartesianToCartographic(cartesian, result = [0, 0, 0]) {
+    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 (this.spheroidGeometry && Number.isFinite(x * x + y * y + z * z) && Number.isFinite(this.oneOverRadiiSquared.x) && Number.isFinite(this.oneOverRadiiSquared.z)) {
+      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);
+    }
+    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);
+    return toCartographicFromRadiansComponents(longitude, latitude, height, result);
+  }
+  eastNorthUpToFixedFrame(origin, result = new import_core5.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_core5.Matrix4()) {
+    return localFrameToFixedFrame(this, firstAxis, secondAxis, thirdAxis, origin, result);
+  }
+  geocentricSurfaceNormal(cartesian, result = [0, 0, 0]) {
+    return scratchVector5.from(cartesian).normalize().to(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);
+  }
+  geodeticSurfaceNormal(cartesian, result = [0, 0, 0]) {
+    return scratchVector5.from(cartesian).scale(this.oneOverRadiiSquared).normalize().to(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
+   * at the center of the ellipsoid, this function returns undefined. */
+  scaleToGeodeticSurface(cartesian, result) {
+    return scaleToGeodeticSurface(cartesian, this, result);
+  }
+  /** 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);
+  }
+  /** 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);
+  }
+  /** 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);
+  }
+  /** 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_core5.assert)((0, import_core5.equals)(this.radii.x, this.radii.y, import_core5._MathUtils.EPSILON15));
+    (0, import_core5.assert)(this.radii.z > 0);
+    scratchPosition.from(position);
+    const z = scratchPosition.z * (1 - this.squaredXOverSquaredZ);
+    if (Math.abs(z) >= this.radii.z - buffer) {
+      return void 0;
+    }
+    return scratchPosition.set(0, 0, z).to(result);
+  }
+};
+Ellipsoid.WGS84 = new Ellipsoid(WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z);
+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");
+}
+
+// dist/ellipsoid-tangent-plane.js
+var import_core6 = require("@math.gl/core");
+var import_culling = require("@math.gl/geometry/culling");
+var scratchOrigin2 = new import_core6.Vector3();
+var scratchCart3 = new import_core6.Vector3();
+var scratchEastNorthUp = new import_core6.Matrix4();
+var scratchProjectPointOntoPlaneCartesian3 = new import_core6.Vector3();
+var EllipsoidTangentPlane = class {
+  /**
+   * Creates a new plane tangent to the WGS84 ellipsoid at the provided origin.
+   * If origin is not on the surface of the ellipsoid, its surface projection will be used.
+   *
+   * @param origin A nonzero Cartesian point on or near the ellipsoid.
+   * @param ellipsoid The ellipsoid to which the origin belongs. Defaults to WGS84.
+   */
+  constructor(origin, ellipsoid = Ellipsoid.WGS84) {
+    const originOnSurface = ellipsoid.scaleToGeodeticSurface(origin, scratchOrigin2);
+    const eastNorthUp = ellipsoid.eastNorthUpToFixedFrame(originOnSurface, scratchEastNorthUp);
+    this._origin = new import_core6.Vector3(originOnSurface);
+    this._xAxis = new import_core6.Vector3(scratchCart3.from(eastNorthUp.getColumn(0)));
+    this._yAxis = new import_core6.Vector3(scratchCart3.from(eastNorthUp.getColumn(1)));
+    const normal = new import_core6.Vector3(scratchCart3.from(eastNorthUp.getColumn(2)));
+    this._plane = new import_culling.Plane().fromPointNormal(this._origin, normal);
+  }
+  /**
+   * Computes the projection of the provided 3D position onto the 2D plane, along the plane normal.
+   *
+   * @param cartesian The WGS84 Cartesian point to project.
+   * @param result The optional object in which to store the local east-north coordinates.
+   * @returns The supplied result or a new Vector2.
+   */
+  projectPointToNearestOnPlane(cartesian, result) {
+    if (!result)
+      result = new import_core6.Vector2();
+    const intersectionPoint = this._plane.projectPointOntoPlane(cartesian, scratchProjectPointOntoPlaneCartesian3);
+    const v = intersectionPoint.subtract(this._origin);
+    const x = this._xAxis.dot(v);
+    const y = this._yAxis.dot(v);
+    result.x = x;
+    result.y = y;
+    return result;
+  }
+  get plane() {
+    return this._plane;
+  }
+  get origin() {
+    return this._origin;
+  }
+  get xAxis() {
+    return this._xAxis;
+  }
+  get yAxis() {
+    return this._yAxis;
+  }
+  get zAxis() {
+    return this._plane.normal;
+  }
+};
+
+// dist/make-obb-from-region.js
+var scratchOffset = new import_core7.Vector3();
+var scratchTangentPoint = new import_core7.Vector3();
+var scratchPerimeterCartographicNC = new import_core7.Vector3();
+var scratchPerimeterCartographicNW = new import_core7.Vector3();
+var scratchPerimeterCartographicCW = new import_core7.Vector3();
+var scratchPerimeterCartographicSW = new import_core7.Vector3();
+var scratchPerimeterCartographicSC = new import_core7.Vector3();
+var scratchPerimeterCartesianNC = new import_core7.Vector3();
+var scratchPerimeterCartesianNW = new import_core7.Vector3();
+var scratchPerimeterCartesianCW = new import_core7.Vector3();
+var scratchPerimeterCartesianSW = new import_core7.Vector3();
+var scratchPerimeterCartesianSC = new import_core7.Vector3();
+var scratchPerimeterProjectedNC = new import_core7.Vector2();
+var scratchPerimeterProjectedNW = new import_core7.Vector2();
+var scratchPerimeterProjectedCW = new import_core7.Vector2();
+var scratchPerimeterProjectedSW = new import_core7.Vector2();
+var scratchPerimeterProjectedSC = new import_core7.Vector2();
+var scratchPlane = new import_culling2.Plane();
+var scratchPlaneOrigin = new import_core7.Vector3();
+var scratchPlaneNormal = new import_core7.Vector3();
+var scratchPlaneXAxis = new import_core7.Vector3();
+var scratchHorizonCartesian = new import_core7.Vector3();
+var scratchHorizonProjected = new import_core7.Vector2();
+var scratchMaxY = new import_core7.Vector3();
+var scratchZ = new import_core7.Vector3();
+var VECTOR3_UNIT_X = new import_core7.Vector3(1, 0, 0);
+var VECTOR3_UNIT_Z = new import_core7.Vector3(0, 0, 1);
+function makeOBBFromRegion(region, ellipsoid = Ellipsoid.WGS84, options = {}) {
+  if (!region || region.length !== 6 || region.some((value) => !Number.isFinite(value))) {
+    throw new Error("makeOBBFromRegion: region must contain exactly six finite numbers");
+  }
+  const unitScale = options.units === "degrees" ? (0, import_core7.radians)(1) : 1;
+  const [rawWest, rawSouth, rawEast, rawNorth, minimumHeight, maximumHeight] = region;
+  if (minimumHeight > maximumHeight) {
+    throw new Error("makeOBBFromRegion: minimumHeight must not exceed maximumHeight");
+  }
+  const south = rawSouth * unitScale;
+  const north = rawNorth * unitScale;
+  const west = normalizeLongitude(rawWest * unitScale);
+  let east = normalizeLongitude(rawEast * unitScale);
+  const directedSpan = rawEast * unitScale - rawWest * unitScale;
+  if (directedSpan >= import_core7._MathUtils.TWO_PI - 1e-12) {
+    east = west + import_core7._MathUtils.TWO_PI;
+  }
+  const latitudeTolerance = 1e-12;
+  if (south > north || south < -import_core7._MathUtils.PI_OVER_TWO - latitudeTolerance || north > import_core7._MathUtils.PI_OVER_TWO + latitudeTolerance) {
+    throw new Error("makeOBBFromRegion: latitude must be within [-\u03C0/2, \u03C0/2] and south \u2264 north");
+  }
+  const clampedSouth = Math.max(-import_core7._MathUtils.PI_OVER_TWO, Math.min(import_core7._MathUtils.PI_OVER_TWO, south));
+  const clampedNorth = Math.max(-import_core7._MathUtils.PI_OVER_TWO, Math.min(import_core7._MathUtils.PI_OVER_TWO, north));
+  return makeOBBFromNormalizedRegion([west, clampedSouth, east, clampedNorth, minimumHeight, maximumHeight], ellipsoid, options.transform);
+}
+function normalizeLongitude(value) {
+  const normalized = ((value + Math.PI) % import_core7._MathUtils.TWO_PI + import_core7._MathUtils.TWO_PI) % import_core7._MathUtils.TWO_PI - Math.PI;
+  return normalized === -Math.PI && value > 0 ? Math.PI : normalized;
+}
+function makeOBBFromNormalizedRegion(region, ellipsoid, transform) {
+  const obb = new import_culling2.OrientedBoundingBox();
+  const [west, south, east, north, minimumHeight, maximumHeight] = region;
+  const northDeg = (0, import_core7.degrees)(north);
+  const southDeg = (0, import_core7.degrees)(south);
+  let maxX;
+  let maxY;
+  let maxZ;
+  let minX;
+  let minY;
+  let minZ;
+  let plane;
+  const rectangle = new LngLatRectangle(west, south, east, north);
+  const tangentPoint = LngLatRectangle.center(rectangle, scratchTangentPoint);
+  const tangentPointCartographic = new import_core7.Vector3([
+    (0, import_core7.degrees)(tangentPoint.x),
+    (0, import_core7.degrees)(tangentPoint.y),
+    0
+  ]);
+  const lonCenter = tangentPoint.x;
+  const lonCenterDeg = tangentPointCartographic.x;
+  if (rectangle.width <= import_core7._MathUtils.PI) {
+    const westDeg = (0, import_core7.degrees)(west);
+    const tangentPoint2 = ellipsoid.cartographicToCartesian(tangentPointCartographic);
+    const ellipsoidTangentPlane = new EllipsoidTangentPlane(tangentPoint2, ellipsoid);
+    const latCenter = southDeg < 0 && northDeg > 0 ? 0 : tangentPointCartographic.y;
+    const perimeterCartographicNC = scratchPerimeterCartographicNC.copy([
+      lonCenterDeg,
+      northDeg,
+      maximumHeight
+    ]);
+    const perimeterCartographicNW = scratchPerimeterCartographicNW.copy([
+      westDeg,
+      northDeg,
+      maximumHeight
+    ]);
+    const perimeterCartographicCW = scratchPerimeterCartographicCW.copy([
+      westDeg,
+      latCenter,
+      maximumHeight
+    ]);
+    const perimeterCartographicSW = scratchPerimeterCartographicSW.copy([
+      westDeg,
+      southDeg,
+      maximumHeight
+    ]);
+    const perimeterCartographicSC = scratchPerimeterCartographicSC.copy([
+      lonCenterDeg,
+      southDeg,
+      maximumHeight
+    ]);
+    const perimeterCartesianNC = ellipsoid.cartographicToCartesian(perimeterCartographicNC, scratchPerimeterCartesianNC);
+    let perimeterCartesianNW = ellipsoid.cartographicToCartesian(perimeterCartographicNW, scratchPerimeterCartesianNW);
+    const perimeterCartesianCW = ellipsoid.cartographicToCartesian(perimeterCartographicCW, scratchPerimeterCartesianCW);
+    let perimeterCartesianSW = ellipsoid.cartographicToCartesian(perimeterCartographicSW, scratchPerimeterCartesianSW);
+    const perimeterCartesianSC = ellipsoid.cartographicToCartesian(perimeterCartographicSC, scratchPerimeterCartesianSC);
+    const perimeterProjectedNC = ellipsoidTangentPlane.projectPointToNearestOnPlane(perimeterCartesianNC, scratchPerimeterProjectedNC);
+    const perimeterProjectedNW = ellipsoidTangentPlane.projectPointToNearestOnPlane(perimeterCartesianNW, scratchPerimeterProjectedNW);
+    const perimeterProjectedCW = ellipsoidTangentPlane.projectPointToNearestOnPlane(perimeterCartesianCW, scratchPerimeterProjectedCW);
+    const perimeterProjectedSW = ellipsoidTangentPlane.projectPointToNearestOnPlane(perimeterCartesianSW, scratchPerimeterProjectedSW);
+    const perimeterProjectedSC = ellipsoidTangentPlane.projectPointToNearestOnPlane(perimeterCartesianSC, scratchPerimeterProjectedSC);
+    minX = Math.min(perimeterProjectedNW.x, perimeterProjectedCW.x, perimeterProjectedSW.x);
+    maxX = -minX;
+    maxY = Math.max(perimeterProjectedNW.y, perimeterProjectedNC.y);
+    minY = Math.min(perimeterProjectedSW.y, perimeterProjectedSC.y);
+    perimeterCartographicNW.z = perimeterCartographicSW.z = minimumHeight;
+    perimeterCartesianNW = ellipsoid.cartographicToCartesian(perimeterCartographicNW, scratchPerimeterCartesianNW);
+    perimeterCartesianSW = ellipsoid.cartographicToCartesian(perimeterCartographicSW, scratchPerimeterCartesianSW);
+    plane = ellipsoidTangentPlane.plane;
+    minZ = Math.min(plane.getPointDistance(perimeterCartesianNW), plane.getPointDistance(perimeterCartesianSW));
+    maxZ = maximumHeight;
+    return applyTransform(fromPlaneExtents(ellipsoidTangentPlane.origin, ellipsoidTangentPlane.xAxis, ellipsoidTangentPlane.yAxis, ellipsoidTangentPlane.zAxis, minX, maxX, minY, maxY, minZ, maxZ, obb), transform);
+  }
+  const eastDeg = (0, import_core7.degrees)(east);
+  const fullyAboveEquator = south > 0;
+  const fullyBelowEquator = north < 0;
+  const latitudeNearestToEquator = fullyAboveEquator ? southDeg : fullyBelowEquator ? northDeg : 0;
+  const planeOrigin = ellipsoid.cartographicToCartesian([lonCenterDeg, latitudeNearestToEquator, maximumHeight], scratchPlaneOrigin);
+  planeOrigin.z = 0;
+  const isPole = Math.abs(planeOrigin.x) < import_core7._MathUtils.EPSILON10 && Math.abs(planeOrigin.y) < import_core7._MathUtils.EPSILON10;
+  const planeNormal = !isPole ? scratchPlaneNormal.copy(planeOrigin).normalize() : VECTOR3_UNIT_X;
+  const planeYAxis = VECTOR3_UNIT_Z;
+  const planeXAxis = scratchPlaneXAxis.copy(planeNormal).cross(planeYAxis);
+  plane = scratchPlane.fromPointNormal(planeOrigin, planeNormal);
+  const horizonCartesian = ellipsoid.cartographicToCartesian([(0, import_core7.degrees)(lonCenter + import_core7._MathUtils.PI_OVER_TWO), latitudeNearestToEquator, maximumHeight], scratchHorizonCartesian);
+  const projectedPoint = plane.projectPointOntoPlane(horizonCartesian, scratchHorizonProjected);
+  maxX = projectedPoint.dot(planeXAxis);
+  minX = -maxX;
+  const northHeight = fullyBelowEquator ? minimumHeight : maximumHeight;
+  const southHeight = fullyAboveEquator ? minimumHeight : maximumHeight;
+  maxY = latitudeZExtent(ellipsoid, northDeg, northHeight, true);
+  minY = latitudeZExtent(ellipsoid, southDeg, southHeight, false);
+  const farZ = ellipsoid.cartographicToCartesian([eastDeg, latitudeNearestToEquator, maximumHeight], scratchZ);
+  minZ = plane.getPointDistance(farZ);
+  maxZ = 0;
+  return applyTransform(fromPlaneExtents(planeOrigin, planeXAxis, planeYAxis, planeNormal, minX, maxX, minY, maxY, minZ, maxZ, obb), transform);
+}
+function applyTransform(obb, transform) {
+  if (!transform)
+    return obb;
+  const axes = [0, 1, 2].map((column) => obb.halfAxes.getColumn(column, new import_core7.Vector3()));
+  const center = transform.transformAsPoint(obb.center);
+  const minimum = [Infinity, Infinity, Infinity];
+  const maximum = [-Infinity, -Infinity, -Infinity];
+  for (let mask = 0; mask < 8; mask++) {
+    const corner = new import_core7.Vector3(center);
+    for (let axis = 0; axis < 3; axis++) {
+      const transformedAxis = transform.transformAsVector(axes[axis]);
+      corner.add(new import_core7.Vector3(transformedAxis).scale((mask & 1 << axis) === 0 ? -1 : 1));
+    }
+    for (let component = 0; component < 3; component++) {
+      minimum[component] = Math.min(minimum[component], corner[component]);
+      maximum[component] = Math.max(maximum[component], corner[component]);
+    }
+  }
+  obb.center.copy(minimum).add(maximum).scale(0.5);
+  const halfSize = new import_core7.Vector3(maximum).subtract(minimum).scale(0.5);
+  obb.halfAxes = new import_core7.Matrix3().set(halfSize.x, 0, 0, 0, halfSize.y, 0, 0, 0, halfSize.z);
+  return obb;
+}
+function latitudeZExtent(ellipsoid, latitude, height, maximum) {
+  let extent = maximum ? -Infinity : Infinity;
+  for (const longitude of [0, 90, 180, 270]) {
+    const z = ellipsoid.cartographicToCartesian([longitude, latitude, height], scratchMaxY).z;
+    extent = maximum ? Math.max(extent, z) : Math.min(extent, z);
+  }
+  return extent;
+}
+function fromPlaneExtents(planeOrigin, planeXAxis, planeYAxis, planeZAxis, minimumX, maximumX, minimumY, maximumY, minimumZ, maximumZ, result) {
+  const center = result.center;
+  const halfAxes = result.halfAxes;
+  halfAxes.setColumn(0, planeXAxis);
+  halfAxes.setColumn(1, planeYAxis);
+  halfAxes.setColumn(2, planeZAxis);
+  const centerOffset = scratchOffset.set((minimumX + maximumX) / 2, (minimumY + maximumY) / 2, (minimumZ + maximumZ) / 2).transformByMatrix3(halfAxes);
+  const scaleX = (maximumX - minimumX) / 2;
+  const scaleY = (maximumY - minimumY) / 2;
+  const scaleZ = (maximumZ - minimumZ) / 2;
+  halfAxes[0] *= scaleX;
+  halfAxes[1] *= scaleX;
+  halfAxes[2] *= scaleX;
+  halfAxes[3] *= scaleY;
+  halfAxes[4] *= scaleY;
+  halfAxes[5] *= scaleY;
+  halfAxes[6] *= scaleZ;
+  halfAxes[7] *= scaleZ;
+  halfAxes[8] *= scaleZ;
+  center.copy(planeOrigin).add(centerOffset);
+  return result;
+}
+
+// dist/ellipsoid-occluder.js
+var EllipsoidOccluder = class {
+  constructor(radii, center = [0, 0, 0]) {
+    validateVector(radii);
+    validateVector(center);
+    if (Array.from(radii).some((value) => value <= 0))
+      throw new RangeError("Radii must be positive");
+    this.radii = Object.freeze(Array.from(radii));
+    this.center = Object.freeze(Array.from(center));
+  }
+  /** Nonnegative ray parameter interval, including tangency and inside-origin rays.
+   * Direction need not be normalized. Undefined is a true miss; never clamps a miss
+   * to the limb. Result is untouched on miss. Distances equal parameters only for
+   * unit directions. Zero direction is a miss.
+   */
+  intersectRay(origin, direction, result = [0, 0]) {
+    validateVector(origin);
+    validateVector(direction);
+    const [x, y, z] = this.scalePoint(origin);
+    const dx = direction[0] / this.radii[0];
+    const dy = direction[1] / this.radii[1];
+    const dz = direction[2] / this.radii[2];
+    const length2 = Math.hypot(dx, dy, dz);
+    if (length2 === 0 || !Number.isFinite(length2))
+      return void 0;
+    const ux = dx / length2, uy = dy / length2, uz = dz / length2;
+    const along = -(x * ux + y * uy + z * uz);
+    const perpendicular = Math.hypot(y * uz - z * uy, z * ux - x * uz, x * uy - y * ux);
+    if (perpendicular > 1)
+      return void 0;
+    const half = Math.sqrt((1 - perpendicular) * (1 + perpendicular));
+    let near = along - half;
+    let far = along + half;
+    const radius = Math.hypot(x, y, z);
+    if (!Number.isFinite(radius))
+      throw new RangeError("Scaled origin magnitude must be finite");
+    if (half > 0 && along > 0 && far !== 0)
+      near = (radius - 1) / far * (radius + 1);
+    if (half > 0 && along < 0 && near !== 0)
+      far = (radius - 1) / near * (radius + 1);
+    if (far < 0)
+      return void 0;
+    result[0] = Math.max(0, Math.min(near, far)) / length2;
+    result[1] = Math.max(0, far) / length2;
+    return result;
+  }
+  /** True if the finite camera-to-point segment enters the solid interior.
+   * Surface contact/tangency alone is not occlusion. Works for elevated points;
+   * unlike a facing-normal test it does not discard visible points beyond the
+   * surface horizon. tolerance is a nonnegative scaled-space squared-radius margin.
+   */
+  isPointOccluded(camera, point, tolerance = 1e-12) {
+    validateVector(camera);
+    validateVector(point);
+    if (!Number.isFinite(tolerance) || tolerance < 0 || tolerance >= 1)
+      throw new RangeError("Tolerance must be in [0, 1)");
+    const a = this.scalePoint(camera);
+    const b = this.scalePoint(point);
+    const dx = b[0] - a[0], dy = b[1] - a[1], dz = b[2] - a[2];
+    const length2 = Math.hypot(dx, dy, dz);
+    if (!Number.isFinite(length2))
+      throw new RangeError("Segment magnitude must be finite");
+    if (length2 === 0)
+      return Math.hypot(...a) ** 2 < 1 - tolerance;
+    const ux = dx / length2, uy = dy / length2, uz = dz / length2;
+    const distance = Math.max(0, Math.min(length2, -(a[0] * ux + a[1] * uy + a[2] * uz)));
+    return Math.hypot(a[0] + distance * ux, a[1] + distance * uy, a[2] + distance * uz) ** 2 < 1 - tolerance;
+  }
+  /** Exact apparent limb ellipse for an exterior camera; undefined on/inside surface. */
+  getHorizon(camera) {
+    validateVector(camera);
+    const scaled = this.scalePoint(camera);
+    const distance = Math.hypot(...scaled);
+    if (!Number.isFinite(distance))
+      throw new RangeError("Camera magnitude must be finite");
+    if (distance <= 1)
+      return void 0;
+    const normal = scaled.map((value) => value / distance);
+    const reference = Math.abs(normal[2]) < 0.9 ? [0, 0, 1] : [0, 1, 0];
+    const u = cross(normal, reference);
+    const uLength = Math.hypot(...u);
+    const v = cross(normal, u.map((value) => value / uLength));
+    const radius = Math.sqrt((1 - 1 / distance) * (1 + 1 / distance));
+    return {
+      center: normal.map((value, i) => this.center[i] + this.radii[i] * value / distance),
+      axis1: u.map((value, i) => this.radii[i] * radius * value / uLength),
+      axis2: v.map((value, i) => this.radii[i] * radius * value)
+    };
+  }
+  scalePoint(point) {
+    const result = this.radii.map((radius, i) => (point[i] - this.center[i]) / radius);
+    if (!result.every(Number.isFinite))
+      throw new RangeError("Scaled coordinates must be finite");
+    return result;
+  }
+};
+function validateVector(vector) {
+  if (vector.length !== 3 || !Array.from(vector).every(Number.isFinite))
+    throw new RangeError("Expected three finite Cartesian components");
+}
+function cross(a, b) {
+  return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+}
+
+// dist/globe-horizon-bounds.js
+function getGlobeHorizonBounds(camera, radius) {
+  if (camera.length !== 3 || !Array.from(camera).every(Number.isFinite) || !Number.isFinite(radius) || radius <= 0)
+    throw new RangeError("Expected a finite camera and positive sphere radius");
+  const distance = Math.hypot(camera[0], camera[1], camera[2]);
+  if (!Number.isFinite(distance))
+    throw new RangeError("Camera magnitude must be finite");
+  if (distance <= radius)
+    return void 0;
+  const latitude = Math.atan2(camera[2], Math.hypot(camera[0], camera[1]));
+  const longitude = Math.atan2(camera[1], camera[0]);
+  const angle = Math.acos(radius / distance);
+  const degrees2 = 180 / Math.PI;
+  const padding = 1e-10;
+  const south = Math.max(-90, (latitude - angle) * degrees2 - padding);
+  const north = Math.min(90, (latitude + angle) * degrees2 + padding);
+  if (Math.abs(latitude) + angle >= Math.PI / 2 - 1e-12)
+    return [-180, south, 180, north];
+  const extent = Math.asin(Math.min(1, Math.sin(angle) / Math.cos(latitude))) * degrees2 + padding;
+  return [wrap(longitude * degrees2 - extent), south, wrap(longitude * degrees2 + extent), north];
+}
+function splitGlobeBounds(bounds) {
+  const [west, south, east, north] = bounds;
+  if (bounds.length !== 4 || !bounds.every(Number.isFinite) || west < -180 || west > 180 || east < -180 || east > 180 || south < -90 || north > 90 || south > north)
+    throw new RangeError("Invalid degree bounds");
+  return west <= east ? [[west, south, east, north]] : [
+    [west, south, 180, north],
+    [-180, south, east, north]
+  ];
+}
+function wrap(longitude) {
+  return ((longitude + 180) % 360 + 360) % 360 - 180;
+}
+
+// dist/subdivide-globe-mesh.js
+var import_spheroid2 = require("@math.gl/core/spheroid");
+var import_polygon = require("@math.gl/geometry/polygon");
+function subdivideGlobeMesh(mesh, options) {
+  const { semiMajorAxis = 6371e3, semiMinorAxis = semiMajorAxis, size = 2, ...limits } = options;
+  if (size !== 2 && size !== 3)
+    throw new RangeError("Source size must be 2 or 3");
+  if (!Number.isFinite(semiMajorAxis) || !Number.isFinite(semiMinorAxis) || semiMajorAxis <= 0 || semiMinorAxis <= 0 || semiMinorAxis > semiMajorAxis)
+    throw new RangeError("Expected positive sphere/oblate axes");
+  for (let i = 1; i < mesh.positions.length; i += size)
+    if (Math.abs(mesh.positions[i]) > 90)
+      throw new RangeError("Latitude outside [-90, 90]");
+  for (let i = 0; i < mesh.indices.length; i += 3) {
+    const longitudes = [0, 1, 2].map((j) => mesh.positions[mesh.indices[i + j] * size]);
+    if (Math.max(...longitudes) - Math.min(...longitudes) > 180)
+      throw new RangeError("Unwrap longitude seams before globe subdivision");
+  }
+  const geometry = {
+    semiMajorAxis,
+    semiMinorAxis,
+    eccentricitySquared: 1 - (semiMinorAxis / semiMajorAxis) ** 2
+  };
+  return (0, import_polygon.subdivideTriangleMesh)(mesh, {
+    ...limits,
+    size,
+    targetSize: 3,
+    transform(position) {
+      const point = {
+        x: position[0] * Math.PI / 180,
+        y: position[1] * Math.PI / 180,
+        z: size === 3 ? position[2] : 0
+      };
+      if (!(0, import_spheroid2.spheroidToCartesian)(point, geometry))
+        return null;
+      return [point.x, point.y, point.z];
+    }
+  });
+}
+//# sourceMappingURL=globe.cjs.map