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

package/dist/globe.cjs

@@ -0,0 +1,4155 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// dist/globe.js
+var globe_exports = {};
+__export(globe_exports, {
+  EllipsoidOccluder: () => EllipsoidOccluder,
+  GeographicSeamError: () => GeographicSeamError,
+  LngLatRectangle: () => LngLatRectangle,
+  getGlobeHorizonBounds: () => getGlobeHorizonBounds,
+  makeOBBFromRegion: () => makeOBBFromRegion,
+  splitGeographicPolygon: () => splitGeographicPolygon,
+  splitGeographicPolyline: () => splitGeographicPolyline,
+  splitGlobeBounds: () => splitGlobeBounds,
+  subdivideGeodesicPolyline: () => subdivideGeodesicPolyline,
+  subdivideGlobeMesh: () => subdivideGlobeMesh,
+  subdivideRhumbPolyline: () => subdivideRhumbPolyline
+});
+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_core6 = require("@math.gl/core");
+var import_culling2 = require("@math.gl/geometry/culling");
+
+// dist/ellipsoid.js
+var import_core4 = 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_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/scale-to-geodetic-surface.js
+var import_core3 = 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;
+    }
+    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 false;
+  function commit(t, unit2) {
+    const output2 = squares.map((r2, i) => {
+      const denominator = offsets[i] * unit2 + t;
+      return denominator === 0n ? 0 : ratio(r2 * integers[i + 3] * unit2, denominator, exponent);
+    });
+    if (!output2.every(Number.isFinite))
+      return false;
+    const qx = Math.sign(x) * output2[0], qy = Math.sign(y) * output2[1], qz = Math.sign(z) * output2[2];
+    result.x = qx;
+    result.y = qy;
+    result.z = qz;
+    return true;
+  }
+}
+function ratio(n, d, exponent) {
+  if (n === 0n)
+    return 0;
+  const shift2 = 52 - (n.toString(2).length - d.toString(2).length);
+  const numerator = shift2 >= 0 ? n << BigInt(shift2) : n;
+  const denominator = shift2 >= 0 ? d : d << BigInt(-shift2);
+  let quotient = numerator / denominator;
+  const remainder = numerator % denominator;
+  if (2n * remainder > denominator || 2n * remainder === denominator && quotient & 1n)
+    quotient++;
+  const power = exponent - shift2;
+  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)) {
+    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 scratchVector2 = new import_core4.Vector3();
+var scratchNormal = new import_core4.Vector3();
+var scratchPosition = new import_core4.Vector3();
+var scratchCartesian = new import_core4.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_core4._MathUtils.EPSILON1;
+    (0, import_core4.assert)(Number.isFinite(x) && x >= 0);
+    (0, import_core4.assert)(Number.isFinite(y) && y >= 0);
+    (0, import_core4.assert)(Number.isFinite(z) && 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.minimumRadius = Math.min(x, y, z);
+    this.maximumRadius = Math.max(x, y, 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 - (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.
+   * 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]) {
+    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_core4.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;
+    this.geodeticSurfaceNormalCartographic(cartographic, normal);
+    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;
+    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;
+      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 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);
+  }
+  geocentricSurfaceNormal(cartesian, result = [0, 0, 0]) {
+    fromCartographic(cartesian, scratchVector2);
+    const point = scratchVector2;
+    return normalResult(point.x, point.y, point.z, result);
+  }
+  geodeticSurfaceNormalCartographic(cartographic, result = [0, 0, 0]) {
+    const point = fromCartographic(cartographic, scratchCartesian);
+    const longitude = import_core4.config._cartographicRadians ? point[0] : point[0] * Math.PI / 180;
+    const latitude = import_core4.config._cartographicRadians ? point[1] : point[1] * Math.PI / 180;
+    const polarDegrees = !import_core4.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]) {
+    if (!(this.minimumRadius > 0))
+      return void 0;
+    fromCartographic(cartesian, scratchVector2);
+    const point = scratchVector2;
+    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
+   * 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]) {
+    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]) {
+    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]) {
+    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)(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 writeResult(result, 0, 0, z);
+  }
+};
+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");
+}
+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/ellipsoid-tangent-plane.js
+var import_core5 = require("@math.gl/core");
+var import_culling = require("@math.gl/geometry/culling");
+
+// dist/ellipsoid-helpers/tangent-plane-numerics.js
+var SPLITTER = 134217729;
+function productError2(a, b, product) {
+  const ca = SPLITTER * a, cb = SPLITTER * b;
+  const ah = ca - (ca - a), al = a - ah;
+  const bh = cb - (cb - b), bl = b - bh;
+  return ah * bh - product + ah * bl + al * bh + al * bl;
+}
+function sumError2(a, b, sum) {
+  const v = sum - a;
+  return a - (sum - v) + (b - v);
+}
+function binaryScale(value) {
+  return 2 ** Math.min(1023, Math.floor(Math.log2(value)));
+}
+function compensatedDot3(x, y, z, a, b, c) {
+  const magnitude = Math.max(Math.abs(x), Math.abs(y), Math.abs(z));
+  if (magnitude === 0)
+    return 0;
+  const scale = binaryScale(magnitude);
+  const sx = x / scale, sy = y / scale, sz = z / scale;
+  const p = sx * a, q = sy * b, r = sz * c;
+  const s = p + q, t = s + r;
+  return (t + (sumError2(p, q, s) + sumError2(s, r, t) + productError2(sx, a, p) + productError2(sy, b, q) + productError2(sz, c, r))) * scale;
+}
+function exactNormalIntersection(radii, origin, east, north, normal, point, sphereRadius) {
+  const values = sphereRadius ? [
+    sphereRadius,
+    sphereRadius,
+    sphereRadius,
+    sphereRadius,
+    0,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    1,
+    1,
+    0,
+    0,
+    point[0],
+    point[1]
+  ] : [...radii, ...origin, ...east, ...north, ...normal, ...point];
+  const v = values.map((value2) => {
+    const [whole, fraction = ""] = Math.abs(value2).toString(2).split(".");
+    return (value2 < 0 ? -1n : 1n) * BigInt("0b" + whole + fraction) << BigInt(1074 - fraction.length);
+  });
+  const unit = 1n << 1074n, q = 1n << 64n;
+  const factors = [v[1] * v[2], v[0] * v[2], v[0] * v[1]];
+  const p = [0, 1, 2].map((i) => (v[3 + i] * unit + v[6 + i] * v[15] + v[9 + i] * v[16]) * factors[i]);
+  const n = v.slice(12, 15).map((x, i) => x * factors[i]);
+  const dot = (x, y) => x.reduce((s, v2, i) => s + v2 * y[i], 0n);
+  const a = dot(n, n), b = dot(n, p), c = dot(p, p) - (v[0] * v[1] * v[2] * unit) ** 2n;
+  const discriminant = b * b - a * c;
+  if (a === 0n || discriminant < 0n)
+    return void 0;
+  const value = discriminant << 128n;
+  let root2 = value === 0n ? 0n : 1n << BigInt(Math.ceil(value.toString(2).length / 2));
+  if (root2)
+    for (; ; ) {
+      const next = root2 + value / root2 >> 1n;
+      if (next >= root2)
+        break;
+      root2 = next;
+    }
+  const output2 = p.map((x, i) => signedRatio(x * a * q + n[i] * (root2 - b * q), a * q * factors[i]));
+  return sphereRadius ? output2.map((_, i) => east[i] * output2[1] + north[i] * output2[2] + normal[i] * output2[0]) : output2;
+}
+function signedRatio(n, d) {
+  return Math.sign(Number(n)) * ratio(n < 0n ? -n : n, d, -2148);
+}
+
+// dist/ellipsoid-tangent-plane.js
+var EllipsoidTangentPlane = class {
+  /**
+   * Creates a new plane tangent to an 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) {
+    finiteInput(origin, 3);
+    this.radii = Object.freeze(Array.from(ellipsoid.radii));
+    if (this.radii[0] === this.radii[1] && this.radii[1] === this.radii[2])
+      this.radius = this.radii[0];
+    if (!this.radii.every((radius) => radius > 0 && Number.isFinite(radius))) {
+      throw new RangeError("Tangent plane requires positive finite ellipsoid radii");
+    }
+    const originOnSurface = ellipsoid.scaleToGeodeticSurface(Array.from(origin), new import_core5.Vector3());
+    if (!originOnSurface)
+      throw new RangeError("Origin has no unique ellipsoid surface point");
+    this.anchor = new import_core5.Vector3(originOnSurface);
+    const normal = new import_core5.Vector3(ellipsoid.geodeticSurfaceNormal(originOnSurface));
+    if (!normal.every(Number.isFinite) || !(normal.len() > 0)) {
+      throw new RangeError("Cannot resolve tangent-plane normal");
+    }
+    normal.normalize();
+    const horizontal = Math.hypot(normal[0], normal[1]);
+    this.east = horizontal > 0 ? new import_core5.Vector3(-normal[1] / horizontal, normal[0] / horizontal, 0) : new import_core5.Vector3(0, 1, 0);
+    this.north = new import_core5.Vector3(normal).cross(this.east).normalize();
+    this._plane = new import_culling.Plane().fromPointNormal(this.anchor, normal);
+  }
+  /**
+   * Computes the projection of the provided 3D position onto the 2D plane, along the plane normal.
+   *
+   * @param cartesian The fixed 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 = new import_core5.Vector2()) {
+    finiteInput(cartesian, 3);
+    const x = cartesian[0] - this.anchor[0];
+    const y = cartesian[1] - this.anchor[1];
+    const z = cartesian[2] - this.anchor[2];
+    const projected = writePlanePoint(this, x, y, z, result, this.radius);
+    if (!projected)
+      throw new RangeError("Tangent-plane projection overflow");
+    return projected;
+  }
+  /** Project along the outward ray from the ellipsoid center.
+   * Back-facing, horizon and nonfinite intersections return undefined without writing result.
+   */
+  projectPointRadiallyOntoPlane(cartesian, result = new import_core5.Vector2()) {
+    finiteInput(cartesian, 3);
+    const scale = Math.max(Math.abs(cartesian[0]), Math.abs(cartesian[1]), Math.abs(cartesian[2]));
+    if (scale === 0)
+      return void 0;
+    const sx = cartesian[0] / scale, sy = cartesian[1] / scale, sz = cartesian[2] / scale;
+    const length = Math.hypot(sx, sy, sz);
+    const x = sx / length;
+    const y = sy / length;
+    const z = sz / length;
+    const n = this.zAxis;
+    const denominator = x * n[0] + y * n[1] + z * n[2];
+    if (denominator <= 1e-14)
+      return void 0;
+    const distance = this.anchor.dot(n) / denominator;
+    return writePlanePoint(this, x * distance - this.anchor[0], y * distance - this.anchor[1], z * distance - this.anchor[2], result, this.radius);
+  }
+  /** Lift a local east/north point to the ellipsoid. Radial is the inverse of radial
+   * projection. Normal selects the nearest-facing line intersection and can miss.
+   * Neither operation restores a source point's height. Failure leaves result untouched.
+   */
+  projectPointOntoEllipsoid(point, mode = "radial", result = new import_core5.Vector3()) {
+    finiteInput(point, 2);
+    checkMode(mode);
+    const [rx, ry, rz] = this.radii;
+    if (mode === "radial") {
+      const scale = Math.max(Math.abs(this.anchor[0]), Math.abs(this.anchor[1]), Math.abs(this.anchor[2]), Math.abs(point[0]), Math.abs(point[1]));
+      const u = point[0] / scale, v = point[1] / scale;
+      const x = this.anchor[0] / scale + this.east[0] * u + this.north[0] * v;
+      const y = this.anchor[1] / scale + this.east[1] * u + this.north[1] * v;
+      const z = this.anchor[2] / scale + this.east[2] * u + this.north[2] * v;
+      const minimum = Math.min(rx, ry, rz);
+      const ax2 = x * (minimum / rx), ay2 = y * (minimum / ry), az2 = z * (minimum / rz);
+      const length = Math.hypot(ax2, ay2, az2);
+      if (!(length > 0 && Number.isFinite(length)))
+        return void 0;
+      return writeSurfacePoint(rx * (ax2 / length), ry * (ay2 / length), rz * (az2 / length), result);
+    }
+    const n = this.zAxis;
+    const p = [
+      this.anchor[0] + this.east[0] * point[0] + this.north[0] * point[1],
+      this.anchor[1] + this.east[1] * point[0] + this.north[1] * point[1],
+      this.anchor[2] + this.east[2] * point[0] + this.north[2] * point[1]
+    ];
+    if (!p.every(Number.isFinite))
+      return void 0;
+    const ax = n[0] / rx, ay = n[1] / ry, az = n[2] / rz;
+    const px = p[0] / rx, py = p[1] / ry, pz = p[2] / rz;
+    const a = ax * ax + ay * ay + az * az;
+    const b = ax * px + ay * py + az * pz;
+    const c = px * px + py * py + pz * pz - 1;
+    const squaredB = b * b, ac = a * c;
+    const error = 1e-6 * (Math.abs(squaredB) + Math.abs(ac));
+    const discriminant = squaredB - ac;
+    if (!(a > 0) || !Number.isFinite(discriminant) || Math.abs(discriminant) <= error) {
+      const exact2 = exactNormalIntersection(this.radii, this.anchor, this.east, this.north, n, point, this.radius);
+      return exact2 && writeSurfacePoint(exact2[0], exact2[1], exact2[2], result);
+    }
+    if (discriminant < 0)
+      return void 0;
+    const root2 = Math.sqrt(Math.max(0, discriminant));
+    const t = b > 0 ? -c / (b + root2) : (-b + root2) / a;
+    return writeSurfacePoint(p[0] + t * n[0], p[1] + t * n[1], p[2] + t * n[2], result);
+  }
+  /** Packed XYZ to packed east/north. Invalid radial points produce NaN pairs and a zero mask.
+   * Optional output must have exactly two components per point and must not overlap input.
+   */
+  projectPointsFlat(input, mode = "normal", output2) {
+    checkMode(mode);
+    if (input.length % 3)
+      throw new RangeError("Expected packed XYZ coordinates");
+    const count = input.length / 3;
+    const positions = output2 || new Float64Array(count * 2);
+    if (positions.length !== count * 2)
+      throw new RangeError("Invalid tangent-plane output length");
+    if (ArrayBuffer.isView(input) && input.buffer === positions.buffer && input.byteOffset < positions.byteOffset + positions.byteLength && positions.byteOffset < input.byteOffset + input.byteLength) {
+      throw new RangeError("Input and output buffers must not overlap");
+    }
+    for (let i = 0; i < input.length; i++) {
+      if (!Number.isFinite(input[i]))
+        throw new RangeError("Expected finite coordinates");
+    }
+    const valid = new Uint8Array(count);
+    const point = new import_core5.Vector3();
+    const projected = new import_core5.Vector2();
+    for (let i = 0; i < count; i++) {
+      point.set(input[i * 3], input[i * 3 + 1], input[i * 3 + 2]);
+      const value = mode === "normal" ? this.projectPointToNearestOnPlane(point, projected) : this.projectPointRadiallyOntoPlane(point, projected);
+      valid[i] = value ? 1 : 0;
+      positions[i * 2] = value ? value[0] : NaN;
+      positions[i * 2 + 1] = value ? value[1] : NaN;
+    }
+    return { positions, valid };
+  }
+  get plane() {
+    return this._plane;
+  }
+  get origin() {
+    return this.anchor;
+  }
+  get xAxis() {
+    return this.east;
+  }
+  get yAxis() {
+    return this.north;
+  }
+  get zAxis() {
+    return this._plane.normal;
+  }
+};
+function finiteInput(point, length) {
+  if (point.length !== length)
+    throw new RangeError(`Expected ${length} finite coordinates`);
+  for (let i = 0; i < length; i++) {
+    if (!Number.isFinite(point[i]))
+      throw new RangeError(`Expected ${length} finite coordinates`);
+  }
+}
+function checkMode(mode) {
+  if (mode !== "normal" && mode !== "radial")
+    throw new RangeError("Invalid tangent-plane mode");
+}
+function writePlanePoint(plane, x, y, z, result, radius) {
+  let east = x * plane.xAxis[0] + y * plane.xAxis[1] + z * plane.xAxis[2];
+  let north = x * plane.yAxis[0] + y * plane.yAxis[1] + z * plane.yAxis[2];
+  if (radius !== void 0 && Math.abs((east / radius) ** 2 + (north / radius) ** 2 - 1) <= 32 * Number.EPSILON) {
+    east = compensatedDot3(x, y, z, plane.xAxis[0], plane.xAxis[1], plane.xAxis[2]);
+    north = compensatedDot3(x, y, z, plane.yAxis[0], plane.yAxis[1], plane.yAxis[2]);
+  }
+  if (!Number.isFinite(east) || !Number.isFinite(north))
+    return void 0;
+  return result.set(east, north);
+}
+function writeSurfacePoint(x, y, z, result) {
+  if (![x, y, z].every(Number.isFinite))
+    return void 0;
+  return result.set(x, y, z);
+}
+
+// dist/make-obb-from-region.js
+var scratchOffset = new import_core6.Vector3();
+var scratchTangentPoint = new import_core6.Vector3();
+var scratchPerimeterCartographicNC = new import_core6.Vector3();
+var scratchPerimeterCartographicNW = new import_core6.Vector3();
+var scratchPerimeterCartographicCW = new import_core6.Vector3();
+var scratchPerimeterCartographicSW = new import_core6.Vector3();
+var scratchPerimeterCartographicSC = new import_core6.Vector3();
+var scratchPerimeterCartesianNC = new import_core6.Vector3();
+var scratchPerimeterCartesianNW = new import_core6.Vector3();
+var scratchPerimeterCartesianCW = new import_core6.Vector3();
+var scratchPerimeterCartesianSW = new import_core6.Vector3();
+var scratchPerimeterCartesianSC = new import_core6.Vector3();
+var scratchPerimeterProjectedNC = new import_core6.Vector2();
+var scratchPerimeterProjectedNW = new import_core6.Vector2();
+var scratchPerimeterProjectedCW = new import_core6.Vector2();
+var scratchPerimeterProjectedSW = new import_core6.Vector2();
+var scratchPerimeterProjectedSC = new import_core6.Vector2();
+var scratchPlane = new import_culling2.Plane();
+var scratchPlaneOrigin = new import_core6.Vector3();
+var scratchPlaneNormal = new import_core6.Vector3();
+var scratchPlaneXAxis = new import_core6.Vector3();
+var scratchHorizonCartesian = new import_core6.Vector3();
+var scratchHorizonProjected = new import_core6.Vector2();
+var scratchMaxY = new import_core6.Vector3();
+var scratchZ = new import_core6.Vector3();
+var VECTOR3_UNIT_X = new import_core6.Vector3(1, 0, 0);
+var VECTOR3_UNIT_Z = new import_core6.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_core6.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_core6._MathUtils.TWO_PI - 1e-12) {
+    east = west + import_core6._MathUtils.TWO_PI;
+  }
+  const latitudeTolerance = 1e-12;
+  if (south > north || south < -import_core6._MathUtils.PI_OVER_TWO - latitudeTolerance || north > import_core6._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_core6._MathUtils.PI_OVER_TWO, Math.min(import_core6._MathUtils.PI_OVER_TWO, south));
+  const clampedNorth = Math.max(-import_core6._MathUtils.PI_OVER_TWO, Math.min(import_core6._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_core6._MathUtils.TWO_PI + import_core6._MathUtils.TWO_PI) % import_core6._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_core6.degrees)(north);
+  const southDeg = (0, import_core6.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_core6.Vector3([
+    (0, import_core6.degrees)(tangentPoint.x),
+    (0, import_core6.degrees)(tangentPoint.y),
+    0
+  ]);
+  const lonCenter = tangentPoint.x;
+  const lonCenterDeg = tangentPointCartographic.x;
+  if (rectangle.width <= import_core6._MathUtils.PI) {
+    const westDeg = (0, import_core6.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_core6.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_core6._MathUtils.EPSILON10 && Math.abs(planeOrigin.y) < import_core6._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_core6.degrees)(lonCenter + import_core6._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_core6.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_core6.Vector3(center);
+    for (let axis = 0; axis < 3; axis++) {
+      const transformedAxis = transform.transformAsVector(axes[axis]);
+      corner.add(new import_core6.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_core6.Vector3(maximum).subtract(minimum).scale(0.5);
+  obb.halfAxes = new import_core6.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 length = Math.hypot(dx, dy, dz);
+    if (length === 0 || !Number.isFinite(length))
+      return void 0;
+    const ux = dx / length, uy = dy / length, uz = dz / length;
+    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)) / length;
+    result[1] = Math.max(0, far) / length;
+    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 length = Math.hypot(dx, dy, dz);
+    if (!Number.isFinite(length))
+      throw new RangeError("Segment magnitude must be finite");
+    if (length === 0)
+      return Math.hypot(...a) ** 2 < 1 - tolerance;
+    const ux = dx / length, uy = dy / length, uz = dz / length;
+    const distance = Math.max(0, Math.min(length, -(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 angle2 = Math.acos(radius / distance);
+  const degrees2 = 180 / Math.PI;
+  const padding = 1e-10;
+  const south = Math.max(-90, (latitude - angle2) * degrees2 - padding);
+  const north = Math.min(90, (latitude + angle2) * degrees2 + padding);
+  if (Math.abs(latitude) + angle2 >= Math.PI / 2 - 1e-12)
+    return [-180, south, 180, north];
+  const extent = Math.asin(Math.min(1, Math.sin(angle2) / 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];
+    }
+  });
+}
+
+// dist/subdivide-geodesic-polyline.js
+var import_polygon2 = require("@math.gl/geometry/polygon");
+
+// dist/vendor/geographiclib-geodesic/runtime.js
+var geodesic = {};
+geodesic.Constants = {};
+geodesic.Math = {};
+geodesic.Accumulator = {};
+(function(c) {
+  "use strict";
+  c.WGS84 = { a: 6378137, f: 1 / 298.257223563 };
+  c.version = {
+    major: 2,
+    minor: 2,
+    patch: 0
+  };
+  c.version_string = "2.2.0";
+})(geodesic.Constants);
+(function(m) {
+  "use strict";
+  m.digits = 53;
+  m.epsilon = Math.pow(0.5, m.digits - 1);
+  m.degree = Math.PI / 180;
+  m.sq = function(x) {
+    return x * x;
+  };
+  m.hypot = function(x, y) {
+    return Math.sqrt(x * x + y * y);
+  };
+  m.cbrt = Math.cbrt || function(x) {
+    var y = Math.pow(Math.abs(x), 1 / 3);
+    return x > 0 ? y : x < 0 ? -y : x;
+  };
+  m.log1p = Math.log1p || function(x) {
+    var y = 1 + x, z = y - 1;
+    return z === 0 ? x : x * Math.log(y) / z;
+  };
+  m.atanh = Math.atanh || function(x) {
+    var y = Math.abs(x);
+    y = m.log1p(2 * y / (1 - y)) / 2;
+    return x > 0 ? y : x < 0 ? -y : x;
+  };
+  m.copysign = function(x, y) {
+    return Math.abs(x) * (y < 0 || y === 0 && 1 / y < 0 ? -1 : 1);
+  };
+  m.sum = function(u, v) {
+    var s = u + v, up = s - v, vpp = s - up, t;
+    up -= u;
+    vpp -= v;
+    t = s ? 0 - (up + vpp) : s;
+    return { s, t };
+  };
+  m.polyval = function(N, p, s, x) {
+    var y = N < 0 ? 0 : p[s++];
+    while (--N >= 0)
+      y = y * x + p[s++];
+    return y;
+  };
+  m.AngRound = function(x) {
+    var z = 1 / 16, y = Math.abs(x);
+    y = y < z ? z - (z - y) : y;
+    return m.copysign(y, x);
+  };
+  m.remainder = function(x, y) {
+    x %= y;
+    return x < -y / 2 ? x + y : x < y / 2 ? x : x - y;
+  };
+  m.AngNormalize = function(x) {
+    var y = m.remainder(x, 360);
+    return Math.abs(y) === 180 ? m.copysign(180, x) : y;
+  };
+  m.LatFix = function(x) {
+    return Math.abs(x) > 90 ? NaN : x;
+  };
+  m.AngDiff = function(x, y) {
+    var r = m.sum(m.remainder(-x, 360), m.remainder(y, 360)), d, e;
+    r = m.sum(m.remainder(r.s, 360), r.t);
+    d = r.s;
+    e = r.t;
+    if (d === 0 || Math.abs(d) === 180)
+      d = m.copysign(d, e === 0 ? y - x : -e);
+    return { d, e };
+  };
+  m.sincosd = function(x) {
+    var d, r, q, s, c, sinx, cosx;
+    d = x % 360;
+    q = Math.round(d / 90);
+    d -= 90 * q;
+    r = d * this.degree;
+    s = Math.sin(r);
+    c = Math.cos(r);
+    if (Math.abs(d) === 45) {
+      c = Math.sqrt(0.5);
+      s = m.copysign(c, r);
+    } else if (Math.abs(d) === 30) {
+      c = Math.sqrt(0.75);
+      s = m.copysign(0.5, r);
+    }
+    switch (q & 3) {
+      case 0:
+        sinx = s;
+        cosx = c;
+        break;
+      case 1:
+        sinx = c;
+        cosx = -s;
+        break;
+      case 2:
+        sinx = -s;
+        cosx = -c;
+        break;
+      default:
+        sinx = -c;
+        cosx = s;
+        break;
+    }
+    cosx += 0;
+    if (sinx === 0)
+      sinx = m.copysign(sinx, x);
+    return { s: sinx, c: cosx };
+  };
+  m.sincosde = function(x, t) {
+    var d, r, q, s, c, sinx, cosx;
+    d = x % 360;
+    q = Math.round(d / 90);
+    d = m.AngRound(d - 90 * q + t);
+    r = d * this.degree;
+    s = Math.sin(r);
+    c = Math.cos(r);
+    if (Math.abs(d) === 45) {
+      c = Math.sqrt(0.5);
+      s = m.copysign(c, r);
+    } else if (Math.abs(d) === 30) {
+      c = Math.sqrt(0.75);
+      s = m.copysign(0.5, r);
+    }
+    switch (q & 3) {
+      case 0:
+        sinx = s;
+        cosx = c;
+        break;
+      case 1:
+        sinx = c;
+        cosx = -s;
+        break;
+      case 2:
+        sinx = -s;
+        cosx = -c;
+        break;
+      default:
+        sinx = -c;
+        cosx = s;
+        break;
+    }
+    cosx += 0;
+    if (sinx === 0)
+      sinx = m.copysign(sinx, x + t);
+    return { s: sinx, c: cosx };
+  };
+  m.atan2d = function(y, x) {
+    var q = 0, ang;
+    if (Math.abs(y) > Math.abs(x)) {
+      [y, x] = [x, y];
+      q = 2;
+    }
+    if (m.copysign(1, x) < 0) {
+      x = -x;
+      ++q;
+    }
+    ang = Math.atan2(y, x) / this.degree;
+    switch (q) {
+      // Note that atan2d(-0.0, 1.0) will return -0.  However, we expect that
+      // atan2d will not be called with y = -0.  If need be, include
+      //
+      //   case 0: ang = 0 + ang; break;
+      //
+      // and handle mpfr as in AngRound.
+      case 1:
+        ang = m.copysign(180, y) - ang;
+        break;
+      case 2:
+        ang = 90 - ang;
+        break;
+      case 3:
+        ang = -90 + ang;
+        break;
+      default:
+        break;
+    }
+    return ang;
+  };
+})(geodesic.Math);
+(function(a, m) {
+  "use strict";
+  a.Accumulator = function(y) {
+    this.Set(y);
+  };
+  a.Accumulator.prototype.Set = function(y) {
+    if (!y)
+      y = 0;
+    if (y.constructor === a.Accumulator) {
+      this._s = y._s;
+      this._t = y._t;
+    } else {
+      this._s = y;
+      this._t = 0;
+    }
+  };
+  a.Accumulator.prototype.Add = function(y) {
+    var u = m.sum(y, this._t), v = m.sum(u.s, this._s);
+    u = u.t;
+    this._s = v.s;
+    this._t = v.t;
+    if (this._s === 0)
+      this._s = u;
+    else
+      this._t += u;
+  };
+  a.Accumulator.prototype.Sum = function(y) {
+    var b;
+    if (!y)
+      return this._s;
+    else {
+      b = new a.Accumulator(this);
+      b.Add(y);
+      return b._s;
+    }
+  };
+  a.Accumulator.prototype.Negate = function() {
+    this._s *= -1;
+    this._t *= -1;
+  };
+  a.Accumulator.prototype.Remainder = function(y) {
+    this._s = m.remainder(this._s, y);
+    this.Add(0);
+  };
+})(geodesic.Accumulator, geodesic.Math);
+geodesic.Geodesic = {};
+geodesic.GeodesicLine = {};
+geodesic.PolygonArea = {};
+(function(g, l, p, m, c) {
+  "use strict";
+  var GEOGRAPHICLIB_GEODESIC_ORDER = 6, nA1_ = GEOGRAPHICLIB_GEODESIC_ORDER, nA2_ = GEOGRAPHICLIB_GEODESIC_ORDER, nA3_ = GEOGRAPHICLIB_GEODESIC_ORDER, nA3x_ = nA3_, nC3x_, nC4x_, maxit1_ = 20, maxit2_ = maxit1_ + m.digits + 10, tol0_ = m.epsilon, tol1_ = 200 * tol0_, tol2_ = Math.sqrt(tol0_), tolb_ = tol0_, xthresh_ = 1e3 * tol2_, CAP_NONE = 0, CAP_ALL = 31, OUT_ALL = 32640, astroid, A1m1f_coeff, C1f_coeff, C1pf_coeff, A2m1f_coeff, C2f_coeff, A3_coeff, C3_coeff, C4_coeff;
+  g.tiny_ = Math.sqrt(Number.MIN_VALUE / Number.EPSILON);
+  g.nC1_ = GEOGRAPHICLIB_GEODESIC_ORDER;
+  g.nC1p_ = GEOGRAPHICLIB_GEODESIC_ORDER;
+  g.nC2_ = GEOGRAPHICLIB_GEODESIC_ORDER;
+  g.nC3_ = GEOGRAPHICLIB_GEODESIC_ORDER;
+  g.nC4_ = GEOGRAPHICLIB_GEODESIC_ORDER;
+  nC3x_ = g.nC3_ * (g.nC3_ - 1) / 2;
+  nC4x_ = g.nC4_ * (g.nC4_ + 1) / 2;
+  g.CAP_C1 = 1 << 0;
+  g.CAP_C1p = 1 << 1;
+  g.CAP_C2 = 1 << 2;
+  g.CAP_C3 = 1 << 3;
+  g.CAP_C4 = 1 << 4;
+  g.NONE = 0;
+  g.ARC = 1 << 6;
+  g.LATITUDE = 1 << 7 | CAP_NONE;
+  g.LONGITUDE = 1 << 8 | g.CAP_C3;
+  g.AZIMUTH = 1 << 9 | CAP_NONE;
+  g.DISTANCE = 1 << 10 | g.CAP_C1;
+  g.STANDARD = g.LATITUDE | g.LONGITUDE | g.AZIMUTH | g.DISTANCE;
+  g.DISTANCE_IN = 1 << 11 | g.CAP_C1 | g.CAP_C1p;
+  g.REDUCEDLENGTH = 1 << 12 | g.CAP_C1 | g.CAP_C2;
+  g.GEODESICSCALE = 1 << 13 | g.CAP_C1 | g.CAP_C2;
+  g.AREA = 1 << 14 | g.CAP_C4;
+  g.ALL = OUT_ALL | CAP_ALL;
+  g.LONG_UNROLL = 1 << 15;
+  g.OUT_MASK = OUT_ALL | g.LONG_UNROLL;
+  g.SinCosSeries = function(sinp, sinx, cosx, c2, delta) {
+    if (delta !== void 0) {
+      var h = delta / 2, sh = Math.sin(h), ch = Math.cos(h);
+      return -2 * g.SinCosSeries(false, cosx * ch - sinx * sh, sinx * ch + cosx * sh, c2.map(function(v, i) {
+        return (i % 2 ? -v : v) * Math.sin((2 * i + 1) * h);
+      }));
+    }
+    var k = c2.length, n = k - (sinp ? 1 : 0), ar = 2 * (cosx - sinx) * (cosx + sinx), y0 = n & 1 ? c2[--k] : 0, y1 = 0;
+    n = Math.floor(n / 2);
+    while (n--) {
+      y1 = ar * y0 - y1 + c2[--k];
+      y0 = ar * y1 - y0 + c2[--k];
+    }
+    return sinp ? 2 * sinx * cosx * y0 : (
+      // sin(2 * x) * y0
+      cosx * (y0 - y1)
+    );
+  };
+  astroid = function(x, y) {
+    var k, p2 = m.sq(x), q = m.sq(y), r = (p2 + q - 1) / 6, S, r2, r3, disc, u, T3, T, ang, v, uv, w;
+    if (!(q === 0 && r <= 0)) {
+      S = p2 * q / 4;
+      r2 = m.sq(r);
+      r3 = r * r2;
+      disc = S * (S + 2 * r3);
+      u = r;
+      if (disc >= 0) {
+        T3 = S + r3;
+        T3 += T3 < 0 ? -Math.sqrt(disc) : Math.sqrt(disc);
+        T = m.cbrt(T3);
+        u += T + (T !== 0 ? r2 / T : 0);
+      } else {
+        ang = Math.atan2(Math.sqrt(-disc), -(S + r3));
+        u += 2 * r * Math.cos(ang / 3);
+      }
+      v = Math.sqrt(m.sq(u) + q);
+      uv = u < 0 ? q / (v - u) : u + v;
+      w = (uv - q) / (2 * v);
+      k = uv / (Math.sqrt(uv + m.sq(w)) + w);
+    } else {
+      k = 0;
+    }
+    return k;
+  };
+  A1m1f_coeff = [
+    // (1-eps)*A1-1, polynomial in eps2 of order 3
+    1,
+    4,
+    64,
+    0,
+    256
+  ];
+  g.A1m1f = function(eps) {
+    var p2 = Math.floor(nA1_ / 2), t = m.polyval(p2, A1m1f_coeff, 0, m.sq(eps)) / A1m1f_coeff[p2 + 1];
+    return (t + eps) / (1 - eps);
+  };
+  C1f_coeff = [
+    // C1[1]/eps^1, polynomial in eps2 of order 2
+    -1,
+    6,
+    -16,
+    32,
+    // C1[2]/eps^2, polynomial in eps2 of order 2
+    -9,
+    64,
+    -128,
+    2048,
+    // C1[3]/eps^3, polynomial in eps2 of order 1
+    9,
+    -16,
+    768,
+    // C1[4]/eps^4, polynomial in eps2 of order 1
+    3,
+    -5,
+    512,
+    // C1[5]/eps^5, polynomial in eps2 of order 0
+    -7,
+    1280,
+    // C1[6]/eps^6, polynomial in eps2 of order 0
+    -7,
+    2048
+  ];
+  g.C1f = function(eps, c2) {
+    var eps2 = m.sq(eps), d = eps, o = 0, l2, p2;
+    for (l2 = 1; l2 <= g.nC1_; ++l2) {
+      p2 = Math.floor((g.nC1_ - l2) / 2);
+      c2[l2] = d * m.polyval(p2, C1f_coeff, o, eps2) / C1f_coeff[o + p2 + 1];
+      o += p2 + 2;
+      d *= eps;
+    }
+  };
+  C1pf_coeff = [
+    // C1p[1]/eps^1, polynomial in eps2 of order 2
+    205,
+    -432,
+    768,
+    1536,
+    // C1p[2]/eps^2, polynomial in eps2 of order 2
+    4005,
+    -4736,
+    3840,
+    12288,
+    // C1p[3]/eps^3, polynomial in eps2 of order 1
+    -225,
+    116,
+    384,
+    // C1p[4]/eps^4, polynomial in eps2 of order 1
+    -7173,
+    2695,
+    7680,
+    // C1p[5]/eps^5, polynomial in eps2 of order 0
+    3467,
+    7680,
+    // C1p[6]/eps^6, polynomial in eps2 of order 0
+    38081,
+    61440
+  ];
+  g.C1pf = function(eps, c2) {
+    var eps2 = m.sq(eps), d = eps, o = 0, l2, p2;
+    for (l2 = 1; l2 <= g.nC1p_; ++l2) {
+      p2 = Math.floor((g.nC1p_ - l2) / 2);
+      c2[l2] = d * m.polyval(p2, C1pf_coeff, o, eps2) / C1pf_coeff[o + p2 + 1];
+      o += p2 + 2;
+      d *= eps;
+    }
+  };
+  A2m1f_coeff = [
+    // (eps+1)*A2-1, polynomial in eps2 of order 3
+    -11,
+    -28,
+    -192,
+    0,
+    256
+  ];
+  g.A2m1f = function(eps) {
+    var p2 = Math.floor(nA2_ / 2), t = m.polyval(p2, A2m1f_coeff, 0, m.sq(eps)) / A2m1f_coeff[p2 + 1];
+    return (t - eps) / (1 + eps);
+  };
+  C2f_coeff = [
+    // C2[1]/eps^1, polynomial in eps2 of order 2
+    1,
+    2,
+    16,
+    32,
+    // C2[2]/eps^2, polynomial in eps2 of order 2
+    35,
+    64,
+    384,
+    2048,
+    // C2[3]/eps^3, polynomial in eps2 of order 1
+    15,
+    80,
+    768,
+    // C2[4]/eps^4, polynomial in eps2 of order 1
+    7,
+    35,
+    512,
+    // C2[5]/eps^5, polynomial in eps2 of order 0
+    63,
+    1280,
+    // C2[6]/eps^6, polynomial in eps2 of order 0
+    77,
+    2048
+  ];
+  g.C2f = function(eps, c2) {
+    var eps2 = m.sq(eps), d = eps, o = 0, l2, p2;
+    for (l2 = 1; l2 <= g.nC2_; ++l2) {
+      p2 = Math.floor((g.nC2_ - l2) / 2);
+      c2[l2] = d * m.polyval(p2, C2f_coeff, o, eps2) / C2f_coeff[o + p2 + 1];
+      o += p2 + 2;
+      d *= eps;
+    }
+  };
+  g.Geodesic = function(a, f) {
+    this.a = a;
+    this.f = f;
+    this._f1 = 1 - this.f;
+    this._e2 = this.f * (2 - this.f);
+    this._ep2 = this._e2 / m.sq(this._f1);
+    this._n = this.f / (2 - this.f);
+    this._b = this.a * this._f1;
+    this._c2 = (m.sq(this.a) + m.sq(this._b) * (this._e2 === 0 ? 1 : (this._e2 > 0 ? m.atanh(Math.sqrt(this._e2)) : Math.atan(Math.sqrt(-this._e2))) / Math.sqrt(Math.abs(this._e2)))) / 2;
+    this._etol2 = 0.1 * tol2_ / Math.sqrt(Math.max(1e-3, Math.abs(this.f)) * Math.min(1, 1 - this.f / 2) / 2);
+    if (!(isFinite(this.a) && this.a > 0))
+      throw new Error("Equatorial radius is not positive");
+    if (!(isFinite(this._b) && this._b > 0))
+      throw new Error("Polar semi-axis is not positive");
+    this._A3x = new Array(nA3x_);
+    this._C3x = new Array(nC3x_);
+    this._C4x = new Array(nC4x_);
+    this.A3coeff();
+    this.C3coeff();
+    this.C4coeff();
+  };
+  A3_coeff = [
+    // A3, coeff of eps^5, polynomial in n of order 0
+    -3,
+    128,
+    // A3, coeff of eps^4, polynomial in n of order 1
+    -2,
+    -3,
+    64,
+    // A3, coeff of eps^3, polynomial in n of order 2
+    -1,
+    -3,
+    -1,
+    16,
+    // A3, coeff of eps^2, polynomial in n of order 2
+    3,
+    -1,
+    -2,
+    8,
+    // A3, coeff of eps^1, polynomial in n of order 1
+    1,
+    -1,
+    2,
+    // A3, coeff of eps^0, polynomial in n of order 0
+    1,
+    1
+  ];
+  g.Geodesic.prototype.A3coeff = function() {
+    var o = 0, k = 0, j, p2;
+    for (j = nA3_ - 1; j >= 0; --j) {
+      p2 = Math.min(nA3_ - j - 1, j);
+      this._A3x[k++] = m.polyval(p2, A3_coeff, o, this._n) / A3_coeff[o + p2 + 1];
+      o += p2 + 2;
+    }
+  };
+  C3_coeff = [
+    // C3[1], coeff of eps^5, polynomial in n of order 0
+    3,
+    128,
+    // C3[1], coeff of eps^4, polynomial in n of order 1
+    2,
+    5,
+    128,
+    // C3[1], coeff of eps^3, polynomial in n of order 2
+    -1,
+    3,
+    3,
+    64,
+    // C3[1], coeff of eps^2, polynomial in n of order 2
+    -1,
+    0,
+    1,
+    8,
+    // C3[1], coeff of eps^1, polynomial in n of order 1
+    -1,
+    1,
+    4,
+    // C3[2], coeff of eps^5, polynomial in n of order 0
+    5,
+    256,
+    // C3[2], coeff of eps^4, polynomial in n of order 1
+    1,
+    3,
+    128,
+    // C3[2], coeff of eps^3, polynomial in n of order 2
+    -3,
+    -2,
+    3,
+    64,
+    // C3[2], coeff of eps^2, polynomial in n of order 2
+    1,
+    -3,
+    2,
+    32,
+    // C3[3], coeff of eps^5, polynomial in n of order 0
+    7,
+    512,
+    // C3[3], coeff of eps^4, polynomial in n of order 1
+    -10,
+    9,
+    384,
+    // C3[3], coeff of eps^3, polynomial in n of order 2
+    5,
+    -9,
+    5,
+    192,
+    // C3[4], coeff of eps^5, polynomial in n of order 0
+    7,
+    512,
+    // C3[4], coeff of eps^4, polynomial in n of order 1
+    -14,
+    7,
+    512,
+    // C3[5], coeff of eps^5, polynomial in n of order 0
+    21,
+    2560
+  ];
+  g.Geodesic.prototype.C3coeff = function() {
+    var o = 0, k = 0, l2, j, p2;
+    for (l2 = 1; l2 < g.nC3_; ++l2) {
+      for (j = g.nC3_ - 1; j >= l2; --j) {
+        p2 = Math.min(g.nC3_ - j - 1, j);
+        this._C3x[k++] = m.polyval(p2, C3_coeff, o, this._n) / C3_coeff[o + p2 + 1];
+        o += p2 + 2;
+      }
+    }
+  };
+  C4_coeff = [
+    // C4[0], coeff of eps^5, polynomial in n of order 0
+    97,
+    15015,
+    // C4[0], coeff of eps^4, polynomial in n of order 1
+    1088,
+    156,
+    45045,
+    // C4[0], coeff of eps^3, polynomial in n of order 2
+    -224,
+    -4784,
+    1573,
+    45045,
+    // C4[0], coeff of eps^2, polynomial in n of order 3
+    -10656,
+    14144,
+    -4576,
+    -858,
+    45045,
+    // C4[0], coeff of eps^1, polynomial in n of order 4
+    64,
+    624,
+    -4576,
+    6864,
+    -3003,
+    15015,
+    // C4[0], coeff of eps^0, polynomial in n of order 5
+    100,
+    208,
+    572,
+    3432,
+    -12012,
+    30030,
+    45045,
+    // C4[1], coeff of eps^5, polynomial in n of order 0
+    1,
+    9009,
+    // C4[1], coeff of eps^4, polynomial in n of order 1
+    -2944,
+    468,
+    135135,
+    // C4[1], coeff of eps^3, polynomial in n of order 2
+    5792,
+    1040,
+    -1287,
+    135135,
+    // C4[1], coeff of eps^2, polynomial in n of order 3
+    5952,
+    -11648,
+    9152,
+    -2574,
+    135135,
+    // C4[1], coeff of eps^1, polynomial in n of order 4
+    -64,
+    -624,
+    4576,
+    -6864,
+    3003,
+    135135,
+    // C4[2], coeff of eps^5, polynomial in n of order 0
+    8,
+    10725,
+    // C4[2], coeff of eps^4, polynomial in n of order 1
+    1856,
+    -936,
+    225225,
+    // C4[2], coeff of eps^3, polynomial in n of order 2
+    -8448,
+    4992,
+    -1144,
+    225225,
+    // C4[2], coeff of eps^2, polynomial in n of order 3
+    -1440,
+    4160,
+    -4576,
+    1716,
+    225225,
+    // C4[3], coeff of eps^5, polynomial in n of order 0
+    -136,
+    63063,
+    // C4[3], coeff of eps^4, polynomial in n of order 1
+    1024,
+    -208,
+    105105,
+    // C4[3], coeff of eps^3, polynomial in n of order 2
+    3584,
+    -3328,
+    1144,
+    315315,
+    // C4[4], coeff of eps^5, polynomial in n of order 0
+    -128,
+    135135,
+    // C4[4], coeff of eps^4, polynomial in n of order 1
+    -2560,
+    832,
+    405405,
+    // C4[5], coeff of eps^5, polynomial in n of order 0
+    128,
+    99099
+  ];
+  g.Geodesic.prototype.C4coeff = function() {
+    var o = 0, k = 0, l2, j, p2;
+    for (l2 = 0; l2 < g.nC4_; ++l2) {
+      for (j = g.nC4_ - 1; j >= l2; --j) {
+        p2 = g.nC4_ - j - 1;
+        this._C4x[k++] = m.polyval(p2, C4_coeff, o, this._n) / C4_coeff[o + p2 + 1];
+        o += p2 + 2;
+      }
+    }
+  };
+  g.Geodesic.prototype.A3f = function(eps) {
+    return m.polyval(nA3x_ - 1, this._A3x, 0, eps);
+  };
+  g.Geodesic.prototype.C3f = function(eps, c2) {
+    var mult = 1, o = 0, l2, p2;
+    for (l2 = 1; l2 < g.nC3_; ++l2) {
+      p2 = g.nC3_ - l2 - 1;
+      mult *= eps;
+      c2[l2] = mult * m.polyval(p2, this._C3x, o, eps);
+      o += p2 + 1;
+    }
+  };
+  g.Geodesic.prototype.C4f = function(eps, c2) {
+    var mult = 1, o = 0, l2, p2;
+    for (l2 = 0; l2 < g.nC4_; ++l2) {
+      p2 = g.nC4_ - l2 - 1;
+      c2[l2] = mult * m.polyval(p2, this._C4x, o, eps);
+      o += p2 + 1;
+      mult *= eps;
+    }
+  };
+  g.Geodesic.prototype.Lengths = function(eps, sig12, ssig1, csig1, dn1, ssig2, csig2, dn2, cbet1, cbet2, outmask, C1a, C2a) {
+    outmask &= g.OUT_MASK;
+    var vals = {}, m0x = 0, J12 = 0, A1 = 0, A2 = 0, B1, B2, l2, csig12, t;
+    if (outmask & (g.DISTANCE | g.REDUCEDLENGTH | g.GEODESICSCALE)) {
+      A1 = g.A1m1f(eps);
+      g.C1f(eps, C1a);
+      if (outmask & (g.REDUCEDLENGTH | g.GEODESICSCALE)) {
+        A2 = g.A2m1f(eps);
+        g.C2f(eps, C2a);
+        m0x = A1 - A2;
+        A2 = 1 + A2;
+      }
+      A1 = 1 + A1;
+    }
+    if (outmask & g.DISTANCE) {
+      B1 = g.SinCosSeries(true, ssig2, csig2, C1a) - g.SinCosSeries(true, ssig1, csig1, C1a);
+      vals.s12b = A1 * (sig12 + B1);
+      if (outmask & (g.REDUCEDLENGTH | g.GEODESICSCALE)) {
+        B2 = g.SinCosSeries(true, ssig2, csig2, C2a) - g.SinCosSeries(true, ssig1, csig1, C2a);
+        J12 = m0x * sig12 + (A1 * B1 - A2 * B2);
+      }
+    } else if (outmask & (g.REDUCEDLENGTH | g.GEODESICSCALE)) {
+      for (l2 = 1; l2 <= g.nC2_; ++l2)
+        C2a[l2] = A1 * C1a[l2] - A2 * C2a[l2];
+      J12 = m0x * sig12 + (g.SinCosSeries(true, ssig2, csig2, C2a) - g.SinCosSeries(true, ssig1, csig1, C2a));
+    }
+    if (outmask & g.REDUCEDLENGTH) {
+      vals.m0 = m0x;
+      vals.m12b = dn2 * (csig1 * ssig2) - dn1 * (ssig1 * csig2) - csig1 * csig2 * J12;
+    } else
+      vals.m12b = NaN;
+    if (outmask & g.GEODESICSCALE) {
+      csig12 = csig1 * csig2 + ssig1 * ssig2;
+      t = this._ep2 * (cbet1 - cbet2) * (cbet1 + cbet2) / (dn1 + dn2);
+      vals.M12 = csig12 + (t * ssig2 - csig2 * J12) * ssig1 / dn1;
+      vals.M21 = csig12 - (t * ssig1 - csig1 * J12) * ssig2 / dn2;
+    }
+    return vals;
+  };
+  g.Geodesic.prototype.InverseStart = function(sbet1, cbet1, dn1, sbet2, cbet2, dn2, lam12, slam12, clam12, C1a, C2a) {
+    var vals = {}, sbet12 = sbet2 * cbet1 - cbet2 * sbet1, cbet12 = cbet2 * cbet1 + sbet2 * sbet1, sbet12a, shortline, omg12, sbetm2, somg12, comg12, t, ssig12, csig12, x, y, lamscale, betscale, k2, eps, cbet12a, bet12a, m12b, m0, nvals, k, omg12a, lam12x;
+    vals.sig12 = -1;
+    sbet12a = sbet2 * cbet1;
+    sbet12a += cbet2 * sbet1;
+    shortline = cbet12 >= 0 && sbet12 < 0.5 && cbet2 * lam12 < 0.5;
+    if (shortline) {
+      sbetm2 = m.sq(sbet1 + sbet2);
+      sbetm2 /= sbetm2 + m.sq(cbet1 + cbet2);
+      vals.dnm = Math.sqrt(1 + this._ep2 * sbetm2);
+      omg12 = lam12 / (this._f1 * vals.dnm);
+      somg12 = Math.sin(omg12);
+      comg12 = Math.cos(omg12);
+    } else {
+      somg12 = slam12;
+      comg12 = clam12;
+    }
+    vals.salp1 = cbet2 * somg12;
+    vals.calp1 = comg12 >= 0 ? sbet12 + cbet2 * sbet1 * m.sq(somg12) / (1 + comg12) : sbet12a - cbet2 * sbet1 * m.sq(somg12) / (1 - comg12);
+    ssig12 = m.hypot(vals.salp1, vals.calp1);
+    csig12 = sbet1 * sbet2 + cbet1 * cbet2 * comg12;
+    if (shortline && ssig12 < this._etol2) {
+      vals.salp2 = cbet1 * somg12;
+      vals.calp2 = sbet12 - cbet1 * sbet2 * (comg12 >= 0 ? m.sq(somg12) / (1 + comg12) : 1 - comg12);
+      t = m.hypot(vals.salp2, vals.calp2);
+      vals.salp2 /= t;
+      vals.calp2 /= t;
+      vals.sig12 = Math.atan2(ssig12, csig12);
+    } else if (Math.abs(this._n) > 0.1 || // Skip astroid calc if too eccentric
+    csig12 >= 0 || ssig12 >= 6 * Math.abs(this._n) * Math.PI * m.sq(cbet1)) {
+    } else {
+      lam12x = Math.atan2(-slam12, -clam12);
+      if (this.f >= 0) {
+        k2 = m.sq(sbet1) * this._ep2;
+        eps = k2 / (2 * (1 + Math.sqrt(1 + k2)) + k2);
+        lamscale = this.f * cbet1 * this.A3f(eps) * Math.PI;
+        betscale = lamscale * cbet1;
+        x = lam12x / lamscale;
+        y = sbet12a / betscale;
+      } else {
+        cbet12a = cbet2 * cbet1 - sbet2 * sbet1;
+        bet12a = Math.atan2(sbet12a, cbet12a);
+        nvals = this.Lengths(this._n, Math.PI + bet12a, sbet1, -cbet1, dn1, sbet2, cbet2, dn2, cbet1, cbet2, g.REDUCEDLENGTH, C1a, C2a);
+        m12b = nvals.m12b;
+        m0 = nvals.m0;
+        x = -1 + m12b / (cbet1 * cbet2 * m0 * Math.PI);
+        betscale = x < -0.01 ? sbet12a / x : -this.f * m.sq(cbet1) * Math.PI;
+        lamscale = betscale / cbet1;
+        y = lam12 / lamscale;
+      }
+      if (y > -tol1_ && x > -1 - xthresh_) {
+        if (this.f >= 0) {
+          vals.salp1 = Math.min(1, -x);
+          vals.calp1 = -Math.sqrt(1 - m.sq(vals.salp1));
+        } else {
+          vals.calp1 = Math.max(x > -tol1_ ? 0 : -1, x);
+          vals.salp1 = Math.sqrt(1 - m.sq(vals.calp1));
+        }
+      } else {
+        k = astroid(x, y);
+        omg12a = lamscale * (this.f >= 0 ? -x * k / (1 + k) : -y * (1 + k) / k);
+        somg12 = Math.sin(omg12a);
+        comg12 = -Math.cos(omg12a);
+        vals.salp1 = cbet2 * somg12;
+        vals.calp1 = sbet12a - cbet2 * sbet1 * m.sq(somg12) / (1 - comg12);
+      }
+    }
+    if (!(vals.salp1 <= 0)) {
+      t = m.hypot(vals.salp1, vals.calp1);
+      vals.salp1 /= t;
+      vals.calp1 /= t;
+    } else {
+      vals.salp1 = 1;
+      vals.calp1 = 0;
+    }
+    return vals;
+  };
+  g.Geodesic.prototype.Lambda12 = function(sbet1, cbet1, dn1, sbet2, cbet2, dn2, salp1, calp1, slam120, clam120, diffp, C1a, C2a, C3a) {
+    var vals = {}, t, salp0, calp0, somg1, comg1, somg2, comg2, somg12, comg12, B312, eta, k2, nvals;
+    if (sbet1 === 0 && calp1 === 0)
+      calp1 = -g.tiny_;
+    salp0 = salp1 * cbet1;
+    calp0 = m.hypot(calp1, salp1 * sbet1);
+    vals.ssig1 = sbet1;
+    somg1 = salp0 * sbet1;
+    vals.csig1 = comg1 = calp1 * cbet1;
+    t = m.hypot(vals.ssig1, vals.csig1);
+    vals.ssig1 /= t;
+    vals.csig1 /= t;
+    vals.salp2 = cbet2 !== cbet1 ? salp0 / cbet2 : salp1;
+    vals.calp2 = cbet2 !== cbet1 || Math.abs(sbet2) !== -sbet1 ? Math.sqrt(m.sq(calp1 * cbet1) + (cbet1 < -sbet1 ? (cbet2 - cbet1) * (cbet1 + cbet2) : (sbet1 - sbet2) * (sbet1 + sbet2))) / cbet2 : Math.abs(calp1);
+    vals.ssig2 = sbet2;
+    somg2 = salp0 * sbet2;
+    vals.csig2 = comg2 = vals.calp2 * cbet2;
+    t = m.hypot(vals.ssig2, vals.csig2);
+    vals.ssig2 /= t;
+    vals.csig2 /= t;
+    vals.sig12 = Math.atan2(Math.max(0, vals.csig1 * vals.ssig2 - vals.ssig1 * vals.csig2), vals.csig1 * vals.csig2 + vals.ssig1 * vals.ssig2);
+    somg12 = Math.max(0, comg1 * somg2 - somg1 * comg2);
+    comg12 = comg1 * comg2 + somg1 * somg2;
+    eta = Math.atan2(somg12 * clam120 - comg12 * slam120, comg12 * clam120 + somg12 * slam120);
+    k2 = m.sq(calp0) * this._ep2;
+    vals.eps = k2 / (2 * (1 + Math.sqrt(1 + k2)) + k2);
+    this.C3f(vals.eps, C3a);
+    B312 = g.SinCosSeries(true, vals.ssig2, vals.csig2, C3a) - g.SinCosSeries(true, vals.ssig1, vals.csig1, C3a);
+    vals.domg12 = -this.f * this.A3f(vals.eps) * salp0 * (vals.sig12 + B312);
+    vals.lam12 = eta + vals.domg12;
+    if (diffp) {
+      if (vals.calp2 === 0)
+        vals.dlam12 = -2 * this._f1 * dn1 / sbet1;
+      else {
+        nvals = this.Lengths(vals.eps, vals.sig12, vals.ssig1, vals.csig1, dn1, vals.ssig2, vals.csig2, dn2, cbet1, cbet2, g.REDUCEDLENGTH, C1a, C2a);
+        vals.dlam12 = nvals.m12b;
+        vals.dlam12 *= this._f1 / (vals.calp2 * cbet2);
+      }
+    }
+    return vals;
+  };
+  g.Geodesic.prototype.Inverse = function(lat1, lon1, lat2, lon2, outmask) {
+    var r, vals;
+    if (!outmask)
+      outmask = g.STANDARD;
+    if (outmask === g.LONG_UNROLL)
+      outmask |= g.STANDARD;
+    outmask &= g.OUT_MASK;
+    r = this.InverseInt(lat1, lon1, lat2, lon2, outmask);
+    vals = r.vals;
+    if (outmask & g.AZIMUTH) {
+      vals.azi1 = m.atan2d(r.salp1, r.calp1);
+      vals.azi2 = m.atan2d(r.salp2, r.calp2);
+    }
+    return vals;
+  };
+  g.Geodesic.prototype.InverseInt = function(lat1, lon1, lat2, lon2, outmask) {
+    var vals = {}, lon12, lon12s, lonsign, t, swapp, latsign, sbet1, cbet1, sbet2, cbet2, s12x, m12x, dn1, dn2, lam12, slam12, clam12, sig12, calp1, salp1, calp2, salp2, C1a, C2a, C3a, meridian, nvals, ssig1, csig1, ssig2, csig2, eps, omg12, dnm, numit, salp1a, calp1a, salp1b, calp1b, tripn, tripb, v, dv, dalp1, sdalp1, cdalp1, nsalp1, lengthmask, salp0, calp0, alp12, k2, A4, C4a, B41, B42, somg12, comg12, domg12, dbet1, dbet2, salp12, calp12, sdomg12, cdomg12;
+    vals.lat1 = lat1 = m.LatFix(lat1);
+    vals.lat2 = lat2 = m.LatFix(lat2);
+    lat1 = m.AngRound(lat1);
+    lat2 = m.AngRound(lat2);
+    lon12 = m.AngDiff(lon1, lon2);
+    lon12s = lon12.e;
+    lon12 = lon12.d;
+    if (outmask & g.LONG_UNROLL) {
+      vals.lon1 = lon1;
+      vals.lon2 = lon1 + lon12 + lon12s;
+    } else {
+      vals.lon1 = m.AngNormalize(lon1);
+      vals.lon2 = m.AngNormalize(lon2);
+    }
+    lonsign = m.copysign(1, lon12);
+    lon12 *= lonsign;
+    lon12s *= lonsign;
+    lam12 = lon12 * m.degree;
+    t = m.sincosde(lon12, lon12s);
+    slam12 = t.s;
+    clam12 = t.c;
+    lon12s = 180 - lon12 - lon12s;
+    swapp = Math.abs(lat1) < Math.abs(lat2) || isNaN(lat2) ? -1 : 1;
+    if (swapp < 0) {
+      lonsign *= -1;
+      [lat2, lat1] = [lat1, lat2];
+    }
+    latsign = m.copysign(1, -lat1);
+    lat1 *= latsign;
+    lat2 *= latsign;
+    t = m.sincosd(lat1);
+    sbet1 = this._f1 * t.s;
+    cbet1 = t.c;
+    t = m.hypot(sbet1, cbet1);
+    sbet1 /= t;
+    cbet1 /= t;
+    cbet1 = Math.max(g.tiny_, cbet1);
+    t = m.sincosd(lat2);
+    sbet2 = this._f1 * t.s;
+    cbet2 = t.c;
+    t = m.hypot(sbet2, cbet2);
+    sbet2 /= t;
+    cbet2 /= t;
+    cbet2 = Math.max(g.tiny_, cbet2);
+    if (cbet1 < -sbet1) {
+      if (cbet2 === cbet1)
+        sbet2 = m.copysign(sbet1, sbet2);
+    } else {
+      if (Math.abs(sbet2) === -sbet1)
+        cbet2 = cbet1;
+    }
+    dn1 = Math.sqrt(1 + this._ep2 * m.sq(sbet1));
+    dn2 = Math.sqrt(1 + this._ep2 * m.sq(sbet2));
+    C1a = new Array(g.nC1_ + 1);
+    C2a = new Array(g.nC2_ + 1);
+    C3a = new Array(g.nC3_);
+    meridian = lat1 === -90 || slam12 === 0;
+    if (meridian) {
+      calp1 = clam12;
+      salp1 = slam12;
+      calp2 = 1;
+      salp2 = 0;
+      ssig1 = sbet1;
+      csig1 = calp1 * cbet1;
+      ssig2 = sbet2;
+      csig2 = calp2 * cbet2;
+      sig12 = Math.atan2(Math.max(0, csig1 * ssig2 - ssig1 * csig2), csig1 * csig2 + ssig1 * ssig2);
+      nvals = this.Lengths(this._n, sig12, ssig1, csig1, dn1, ssig2, csig2, dn2, cbet1, cbet2, outmask | g.DISTANCE | g.REDUCEDLENGTH, C1a, C2a);
+      s12x = nvals.s12b;
+      m12x = nvals.m12b;
+      if (outmask & g.GEODESICSCALE) {
+        vals.M12 = nvals.M12;
+        vals.M21 = nvals.M21;
+      }
+      if (sig12 < tol2_ || m12x >= 0) {
+        if (sig12 < 3 * g.tiny_ || // Prevent negative s12 or m12 for short lines
+        sig12 < tol0_ && (s12x < 0 || m12x < 0))
+          sig12 = m12x = s12x = 0;
+        m12x *= this._b;
+        s12x *= this._b;
+        vals.a12 = sig12 / m.degree;
+      } else
+        meridian = false;
+    }
+    somg12 = 2;
+    if (!meridian && sbet1 === 0 && // and sbet2 == 0
+    (this.f <= 0 || lon12s >= this.f * 180)) {
+      calp1 = calp2 = 0;
+      salp1 = salp2 = 1;
+      s12x = this.a * lam12;
+      sig12 = omg12 = lam12 / this._f1;
+      m12x = this._b * Math.sin(sig12);
+      if (outmask & g.GEODESICSCALE)
+        vals.M12 = vals.M21 = Math.cos(sig12);
+      vals.a12 = lon12 / this._f1;
+    } else if (!meridian) {
+      nvals = this.InverseStart(sbet1, cbet1, dn1, sbet2, cbet2, dn2, lam12, slam12, clam12, C1a, C2a);
+      sig12 = nvals.sig12;
+      salp1 = nvals.salp1;
+      calp1 = nvals.calp1;
+      if (sig12 >= 0) {
+        salp2 = nvals.salp2;
+        calp2 = nvals.calp2;
+        dnm = nvals.dnm;
+        s12x = sig12 * this._b * dnm;
+        m12x = m.sq(dnm) * this._b * Math.sin(sig12 / dnm);
+        if (outmask & g.GEODESICSCALE)
+          vals.M12 = vals.M21 = Math.cos(sig12 / dnm);
+        vals.a12 = sig12 / m.degree;
+        omg12 = lam12 / (this._f1 * dnm);
+      } else {
+        numit = 0;
+        salp1a = g.tiny_;
+        calp1a = 1;
+        salp1b = g.tiny_;
+        calp1b = -1;
+        for (tripn = false, tripb = false; ; ++numit) {
+          nvals = this.Lambda12(sbet1, cbet1, dn1, sbet2, cbet2, dn2, salp1, calp1, slam12, clam12, numit < maxit1_, C1a, C2a, C3a);
+          v = nvals.lam12;
+          salp2 = nvals.salp2;
+          calp2 = nvals.calp2;
+          sig12 = nvals.sig12;
+          ssig1 = nvals.ssig1;
+          csig1 = nvals.csig1;
+          ssig2 = nvals.ssig2;
+          csig2 = nvals.csig2;
+          eps = nvals.eps;
+          domg12 = nvals.domg12;
+          dv = nvals.dlam12;
+          if (tripb || !(Math.abs(v) >= (tripn ? 8 : 1) * tol0_) || numit == maxit2_)
+            break;
+          if (v > 0 && (numit < maxit1_ || calp1 / salp1 > calp1b / salp1b)) {
+            salp1b = salp1;
+            calp1b = calp1;
+          } else if (v < 0 && (numit < maxit1_ || calp1 / salp1 < calp1a / salp1a)) {
+            salp1a = salp1;
+            calp1a = calp1;
+          }
+          if (numit < maxit1_ && dv > 0) {
+            dalp1 = -v / dv;
+            if (Math.abs(dalp1) < Math.PI) {
+              sdalp1 = Math.sin(dalp1);
+              cdalp1 = Math.cos(dalp1);
+              nsalp1 = salp1 * cdalp1 + calp1 * sdalp1;
+              if (nsalp1 > 0) {
+                calp1 = calp1 * cdalp1 - salp1 * sdalp1;
+                salp1 = nsalp1;
+                t = m.hypot(salp1, calp1);
+                salp1 /= t;
+                calp1 /= t;
+                tripn = Math.abs(v) <= 16 * tol0_;
+                continue;
+              }
+            }
+          }
+          salp1 = (salp1a + salp1b) / 2;
+          calp1 = (calp1a + calp1b) / 2;
+          t = m.hypot(salp1, calp1);
+          salp1 /= t;
+          calp1 /= t;
+          tripn = false;
+          tripb = Math.abs(salp1a - salp1) + (calp1a - calp1) < tolb_ || Math.abs(salp1 - salp1b) + (calp1 - calp1b) < tolb_;
+        }
+        lengthmask = outmask | (outmask & (g.REDUCEDLENGTH | g.GEODESICSCALE) ? g.DISTANCE : g.NONE);
+        nvals = this.Lengths(eps, sig12, ssig1, csig1, dn1, ssig2, csig2, dn2, cbet1, cbet2, lengthmask, C1a, C2a);
+        s12x = nvals.s12b;
+        m12x = nvals.m12b;
+        if (outmask & g.GEODESICSCALE) {
+          vals.M12 = nvals.M12;
+          vals.M21 = nvals.M21;
+        }
+        m12x *= this._b;
+        s12x *= this._b;
+        vals.a12 = sig12 / m.degree;
+        if (outmask & g.AREA) {
+          sdomg12 = Math.sin(domg12);
+          cdomg12 = Math.cos(domg12);
+          somg12 = slam12 * cdomg12 - clam12 * sdomg12;
+          comg12 = clam12 * cdomg12 + slam12 * sdomg12;
+        }
+      }
+    }
+    if (outmask & g.DISTANCE)
+      vals.s12 = 0 + s12x;
+    if (outmask & g.REDUCEDLENGTH)
+      vals.m12 = 0 + m12x;
+    if (outmask & g.AREA) {
+      salp0 = salp1 * cbet1;
+      calp0 = m.hypot(calp1, salp1 * sbet1);
+      if (calp0 !== 0 && salp0 !== 0) {
+        ssig1 = sbet1;
+        csig1 = calp1 * cbet1;
+        ssig2 = sbet2;
+        csig2 = calp2 * cbet2;
+        k2 = m.sq(calp0) * this._ep2;
+        eps = k2 / (2 * (1 + Math.sqrt(1 + k2)) + k2);
+        A4 = m.sq(this.a) * calp0 * salp0 * this._e2;
+        t = m.hypot(ssig1, csig1);
+        ssig1 /= t;
+        csig1 /= t;
+        t = m.hypot(ssig2, csig2);
+        ssig2 /= t;
+        csig2 /= t;
+        C4a = new Array(g.nC4_);
+        this.C4f(eps, C4a);
+        B41 = g.SinCosSeries(false, ssig1, csig1, C4a);
+        B42 = g.SinCosSeries(false, ssig2, csig2, C4a);
+        vals.S12 = A4 * (sig12 < 0.01 ? g.SinCosSeries(false, ssig1, csig1, C4a, sig12) : B42 - B41);
+      } else
+        vals.S12 = 0;
+      if (!meridian && somg12 == 2) {
+        somg12 = Math.sin(omg12);
+        comg12 = Math.cos(omg12);
+      }
+      if (!meridian && comg12 > -0.7071 && // Long difference not too big
+      sbet2 - sbet1 < 1.75) {
+        domg12 = 1 + comg12;
+        dbet1 = 1 + cbet1;
+        dbet2 = 1 + cbet2;
+        alp12 = 2 * Math.atan2(somg12 * (sbet1 * dbet2 + sbet2 * dbet1), domg12 * (sbet1 * sbet2 + dbet1 * dbet2));
+      } else {
+        salp12 = salp2 * calp1 - calp2 * salp1;
+        calp12 = calp2 * calp1 + salp2 * salp1;
+        if (salp12 === 0 && calp12 < 0) {
+          salp12 = g.tiny_ * calp1;
+          calp12 = -1;
+        }
+        alp12 = Math.atan2(salp12, calp12);
+      }
+      vals.S12 += this._c2 * alp12;
+      vals.S12 *= swapp * lonsign * latsign;
+      vals.S12 += 0;
+    }
+    if (swapp < 0) {
+      [salp2, salp1] = [salp1, salp2];
+      [calp2, calp1] = [calp1, calp2];
+      if (outmask & g.GEODESICSCALE) {
+        [vals.M21, vals.M12] = [vals.M12, vals.M21];
+      }
+    }
+    salp1 *= swapp * lonsign;
+    calp1 *= swapp * latsign;
+    salp2 *= swapp * lonsign;
+    calp2 *= swapp * latsign;
+    return {
+      vals,
+      salp1,
+      calp1,
+      salp2,
+      calp2
+    };
+  };
+  g.Geodesic.prototype.GenDirect = function(lat1, lon1, azi1, arcmode, s12_a12, outmask) {
+    var line;
+    if (!outmask)
+      outmask = g.STANDARD;
+    else if (outmask === g.LONG_UNROLL)
+      outmask |= g.STANDARD;
+    if (!arcmode)
+      outmask |= g.DISTANCE_IN;
+    line = new l.GeodesicLine(this, lat1, lon1, azi1, outmask);
+    return line.GenPosition(arcmode, s12_a12, outmask);
+  };
+  g.Geodesic.prototype.Direct = function(lat1, lon1, azi1, s12, outmask) {
+    return this.GenDirect(lat1, lon1, azi1, false, s12, outmask);
+  };
+  g.Geodesic.prototype.ArcDirect = function(lat1, lon1, azi1, a12, outmask) {
+    return this.GenDirect(lat1, lon1, azi1, true, a12, outmask);
+  };
+  g.Geodesic.prototype.Line = function(lat1, lon1, azi1, caps) {
+    return new l.GeodesicLine(this, lat1, lon1, azi1, caps);
+  };
+  g.Geodesic.prototype.DirectLine = function(lat1, lon1, azi1, s12, caps) {
+    return this.GenDirectLine(lat1, lon1, azi1, false, s12, caps);
+  };
+  g.Geodesic.prototype.ArcDirectLine = function(lat1, lon1, azi1, a12, caps) {
+    return this.GenDirectLine(lat1, lon1, azi1, true, a12, caps);
+  };
+  g.Geodesic.prototype.GenDirectLine = function(lat1, lon1, azi1, arcmode, s12_a12, caps) {
+    var t;
+    if (!caps)
+      caps = g.STANDARD | g.DISTANCE_IN;
+    if (!arcmode)
+      caps |= g.DISTANCE_IN;
+    t = new l.GeodesicLine(this, lat1, lon1, azi1, caps);
+    t.GenSetDistance(arcmode, s12_a12);
+    return t;
+  };
+  g.Geodesic.prototype.InverseLine = function(lat1, lon1, lat2, lon2, caps) {
+    var r, t, azi1;
+    if (!caps)
+      caps = g.STANDARD | g.DISTANCE_IN;
+    r = this.InverseInt(lat1, lon1, lat2, lon2, g.ARC);
+    azi1 = m.atan2d(r.salp1, r.calp1);
+    if (caps & (g.OUT_MASK & g.DISTANCE_IN))
+      caps |= g.DISTANCE;
+    t = new l.GeodesicLine(this, lat1, lon1, azi1, caps, r.salp1, r.calp1);
+    t.SetArc(r.vals.a12);
+    return t;
+  };
+  g.Geodesic.prototype.Polygon = function(polyline) {
+    return new p.PolygonArea(this, polyline);
+  };
+  g.WGS84 = new g.Geodesic(c.WGS84.a, c.WGS84.f);
+})(geodesic.Geodesic, geodesic.GeodesicLine, geodesic.PolygonArea, geodesic.Math, geodesic.Constants);
+(function(g, l, m) {
+  "use strict";
+  l.GeodesicLine = function(geod, lat1, lon1, azi1, caps, salp1, calp1) {
+    var t, cbet1, sbet1, eps, s, c;
+    if (!caps)
+      caps = g.STANDARD | g.DISTANCE_IN;
+    this.a = geod.a;
+    this.f = geod.f;
+    this._b = geod._b;
+    this._c2 = geod._c2;
+    this._f1 = geod._f1;
+    this.caps = caps | g.LATITUDE | g.AZIMUTH | g.LONG_UNROLL;
+    this.lat1 = m.LatFix(lat1);
+    this.lon1 = lon1;
+    if (typeof salp1 === "undefined" || typeof calp1 === "undefined") {
+      this.azi1 = m.AngNormalize(azi1);
+      t = m.sincosd(m.AngRound(this.azi1));
+      this.salp1 = t.s;
+      this.calp1 = t.c;
+    } else {
+      this.azi1 = azi1;
+      this.salp1 = salp1;
+      this.calp1 = calp1;
+    }
+    t = m.sincosd(m.AngRound(this.lat1));
+    sbet1 = this._f1 * t.s;
+    cbet1 = t.c;
+    t = m.hypot(sbet1, cbet1);
+    sbet1 /= t;
+    cbet1 /= t;
+    cbet1 = Math.max(g.tiny_, cbet1);
+    this._dn1 = Math.sqrt(1 + geod._ep2 * m.sq(sbet1));
+    this._salp0 = this.salp1 * cbet1;
+    this._calp0 = m.hypot(this.calp1, this.salp1 * sbet1);
+    this._ssig1 = sbet1;
+    this._somg1 = this._salp0 * sbet1;
+    this._csig1 = this._comg1 = sbet1 !== 0 || this.calp1 !== 0 ? cbet1 * this.calp1 : 1;
+    t = m.hypot(this._ssig1, this._csig1);
+    this._ssig1 /= t;
+    this._csig1 /= t;
+    this._k2 = m.sq(this._calp0) * geod._ep2;
+    eps = this._k2 / (2 * (1 + Math.sqrt(1 + this._k2)) + this._k2);
+    if (this.caps & g.CAP_C1) {
+      this._A1m1 = g.A1m1f(eps);
+      this._C1a = new Array(g.nC1_ + 1);
+      g.C1f(eps, this._C1a);
+      this._B11 = g.SinCosSeries(true, this._ssig1, this._csig1, this._C1a);
+      s = Math.sin(this._B11);
+      c = Math.cos(this._B11);
+      this._stau1 = this._ssig1 * c + this._csig1 * s;
+      this._ctau1 = this._csig1 * c - this._ssig1 * s;
+    }
+    if (this.caps & g.CAP_C1p) {
+      this._C1pa = new Array(g.nC1p_ + 1);
+      g.C1pf(eps, this._C1pa);
+    }
+    if (this.caps & g.CAP_C2) {
+      this._A2m1 = g.A2m1f(eps);
+      this._C2a = new Array(g.nC2_ + 1);
+      g.C2f(eps, this._C2a);
+      this._B21 = g.SinCosSeries(true, this._ssig1, this._csig1, this._C2a);
+    }
+    if (this.caps & g.CAP_C3) {
+      this._C3a = new Array(g.nC3_);
+      geod.C3f(eps, this._C3a);
+      this._A3c = -this.f * this._salp0 * geod.A3f(eps);
+      this._B31 = g.SinCosSeries(true, this._ssig1, this._csig1, this._C3a);
+    }
+    if (this.caps & g.CAP_C4) {
+      this._C4a = new Array(g.nC4_);
+      geod.C4f(eps, this._C4a);
+      this._A4 = m.sq(this.a) * this._calp0 * this._salp0 * geod._e2;
+      this._B41 = g.SinCosSeries(false, this._ssig1, this._csig1, this._C4a);
+    }
+    this.a13 = this.s13 = NaN;
+  };
+  l.GeodesicLine.prototype.GenPosition = function(arcmode, s12_a12, outmask) {
+    var vals = {}, sig12, ssig12, csig12, B12, AB1, ssig2, csig2, tau12, s, c, serr, omg12, lam12, lon12, E, sbet2, cbet2, somg2, comg2, salp2, calp2, dn2, B22, AB2, J12, t, B42, salp12, calp12;
+    if (!outmask)
+      outmask = g.STANDARD;
+    else if (outmask === g.LONG_UNROLL)
+      outmask |= g.STANDARD;
+    outmask &= this.caps & g.OUT_MASK;
+    vals.lat1 = this.lat1;
+    vals.azi1 = this.azi1;
+    vals.lon1 = outmask & g.LONG_UNROLL ? this.lon1 : m.AngNormalize(this.lon1);
+    if (arcmode)
+      vals.a12 = s12_a12;
+    else
+      vals.s12 = s12_a12;
+    if (!(arcmode || this.caps & g.DISTANCE_IN & g.OUT_MASK)) {
+      vals.a12 = NaN;
+      return vals;
+    }
+    B12 = 0;
+    AB1 = 0;
+    if (arcmode) {
+      sig12 = s12_a12 * m.degree;
+      t = m.sincosd(s12_a12);
+      ssig12 = t.s;
+      csig12 = t.c;
+    } else {
+      tau12 = s12_a12 / (this._b * (1 + this._A1m1));
+      s = Math.sin(tau12);
+      c = Math.cos(tau12);
+      B12 = -g.SinCosSeries(true, this._stau1 * c + this._ctau1 * s, this._ctau1 * c - this._stau1 * s, this._C1pa);
+      sig12 = tau12 - (B12 - this._B11);
+      ssig12 = Math.sin(sig12);
+      csig12 = Math.cos(sig12);
+      if (Math.abs(this.f) > 0.01) {
+        ssig2 = this._ssig1 * csig12 + this._csig1 * ssig12;
+        csig2 = this._csig1 * csig12 - this._ssig1 * ssig12;
+        B12 = g.SinCosSeries(true, ssig2, csig2, this._C1a);
+        serr = (1 + this._A1m1) * (sig12 + (B12 - this._B11)) - s12_a12 / this._b;
+        sig12 = sig12 - serr / Math.sqrt(1 + this._k2 * m.sq(ssig2));
+        ssig12 = Math.sin(sig12);
+        csig12 = Math.cos(sig12);
+      }
+    }
+    ssig2 = this._ssig1 * csig12 + this._csig1 * ssig12;
+    csig2 = this._csig1 * csig12 - this._ssig1 * ssig12;
+    dn2 = Math.sqrt(1 + this._k2 * m.sq(ssig2));
+    if (outmask & (g.DISTANCE | g.REDUCEDLENGTH | g.GEODESICSCALE)) {
+      if (arcmode || Math.abs(this.f) > 0.01)
+        B12 = g.SinCosSeries(true, ssig2, csig2, this._C1a);
+      AB1 = (1 + this._A1m1) * (B12 - this._B11);
+    }
+    sbet2 = this._calp0 * ssig2;
+    cbet2 = m.hypot(this._salp0, this._calp0 * csig2);
+    if (cbet2 === 0)
+      cbet2 = csig2 = g.tiny_;
+    salp2 = this._salp0;
+    calp2 = this._calp0 * csig2;
+    if (arcmode && outmask & g.DISTANCE)
+      vals.s12 = this._b * ((1 + this._A1m1) * sig12 + AB1);
+    if (outmask & g.LONGITUDE) {
+      somg2 = this._salp0 * ssig2;
+      comg2 = csig2;
+      E = m.copysign(1, this._salp0);
+      omg12 = outmask & g.LONG_UNROLL ? E * (sig12 - (Math.atan2(ssig2, csig2) - Math.atan2(this._ssig1, this._csig1)) + (Math.atan2(E * somg2, comg2) - Math.atan2(E * this._somg1, this._comg1))) : Math.atan2(somg2 * this._comg1 - comg2 * this._somg1, comg2 * this._comg1 + somg2 * this._somg1);
+      lam12 = omg12 + this._A3c * (sig12 + (g.SinCosSeries(true, ssig2, csig2, this._C3a) - this._B31));
+      lon12 = lam12 / m.degree;
+      vals.lon2 = outmask & g.LONG_UNROLL ? this.lon1 + lon12 : m.AngNormalize(m.AngNormalize(this.lon1) + m.AngNormalize(lon12));
+    }
+    if (outmask & g.LATITUDE)
+      vals.lat2 = m.atan2d(sbet2, this._f1 * cbet2);
+    if (outmask & g.AZIMUTH)
+      vals.azi2 = m.atan2d(salp2, calp2);
+    if (outmask & (g.REDUCEDLENGTH | g.GEODESICSCALE)) {
+      B22 = g.SinCosSeries(true, ssig2, csig2, this._C2a);
+      AB2 = (1 + this._A2m1) * (B22 - this._B21);
+      J12 = (this._A1m1 - this._A2m1) * sig12 + (AB1 - AB2);
+      if (outmask & g.REDUCEDLENGTH)
+        vals.m12 = this._b * (dn2 * (this._csig1 * ssig2) - this._dn1 * (this._ssig1 * csig2) - this._csig1 * csig2 * J12);
+      if (outmask & g.GEODESICSCALE) {
+        t = this._k2 * (ssig2 - this._ssig1) * (ssig2 + this._ssig1) / (this._dn1 + dn2);
+        vals.M12 = csig12 + (t * ssig2 - csig2 * J12) * this._ssig1 / this._dn1;
+        vals.M21 = csig12 - (t * this._ssig1 - this._csig1 * J12) * ssig2 / dn2;
+      }
+    }
+    if (outmask & g.AREA) {
+      B42 = g.SinCosSeries(false, ssig2, csig2, this._C4a);
+      if (this._calp0 === 0 || this._salp0 === 0) {
+        salp12 = salp2 * this.calp1 - calp2 * this.salp1;
+        calp12 = calp2 * this.calp1 + salp2 * this.salp1;
+      } else {
+        salp12 = this._calp0 * this._salp0 * (csig12 <= 0 ? this._csig1 * (1 - csig12) + ssig12 * this._ssig1 : ssig12 * (this._csig1 * ssig12 / (1 + csig12) + this._ssig1));
+        calp12 = m.sq(this._salp0) + m.sq(this._calp0) * this._csig1 * csig2;
+      }
+      vals.S12 = this._c2 * Math.atan2(salp12, calp12) + this._A4 * (Math.abs(sig12) < 0.01 ? g.SinCosSeries(false, this._ssig1, this._csig1, this._C4a, sig12) : B42 - this._B41);
+    }
+    if (!arcmode)
+      vals.a12 = sig12 / m.degree;
+    return vals;
+  };
+  l.GeodesicLine.prototype.Position = function(s12, outmask) {
+    return this.GenPosition(false, s12, outmask);
+  };
+  l.GeodesicLine.prototype.ArcPosition = function(a12, outmask) {
+    return this.GenPosition(true, a12, outmask);
+  };
+  l.GeodesicLine.prototype.GenSetDistance = function(arcmode, s13_a13) {
+    if (arcmode)
+      this.SetArc(s13_a13);
+    else
+      this.SetDistance(s13_a13);
+  };
+  l.GeodesicLine.prototype.SetDistance = function(s13) {
+    var r;
+    this.s13 = s13;
+    r = this.GenPosition(false, this.s13, g.ARC);
+    this.a13 = 0 + r.a12;
+  };
+  l.GeodesicLine.prototype.SetArc = function(a13) {
+    var r;
+    this.a13 = a13;
+    r = this.GenPosition(true, this.a13, g.DISTANCE);
+    this.s13 = 0 + r.s12;
+  };
+})(geodesic.Geodesic, geodesic.GeodesicLine, geodesic.Math);
+
+// dist/ellipsoid-geodesic.js
+var library = geodesic.Geodesic;
+var EllipsoidGeodesic = class {
+  constructor({ semiMajorAxis: a, semiMinorAxis: b }) {
+    this.engine = createGeodesicEngine({ semiMajorAxis: a, semiMinorAxis: b });
+  }
+  /** Total area in squared axis units, with the same normalization as S12. */
+  get surfaceArea() {
+    return 4 * Math.PI * this.engine._c2;
+  }
+  inverse(lat1, lon1, lat2, lon2, options = {}) {
+    validatePoint(lat1, lon1);
+    validatePoint(lat2, lon2);
+    return this.engine.Inverse(lat1, lon1, lat2, lon2, outputMask(options));
+  }
+  direct(latitude, longitude, azimuth, distance, options = {}) {
+    return this.line(latitude, longitude, azimuth, options).position(distance);
+  }
+  arcDirect(latitude, longitude, azimuth, arc, options = {}) {
+    return this.line(latitude, longitude, azimuth, options).arcPosition(arc);
+  }
+  line(latitude, longitude, azimuth, options = {}) {
+    validatePoint(latitude, longitude);
+    validateFinite(azimuth);
+    const selectedMask = outputMask(options);
+    const line = this.engine.Line(latitude, longitude, azimuth, selectedMask | library.DISTANCE_IN);
+    return {
+      position(distance) {
+        validateFinite(distance);
+        return line.Position(distance, selectedMask);
+      },
+      arcPosition(arc) {
+        validateFinite(arc);
+        return line.ArcPosition(arc, selectedMask);
+      }
+    };
+  }
+};
+function validatePoint(latitude, longitude) {
+  if (!(Number.isFinite(latitude) && Math.abs(latitude) <= 90 && Number.isFinite(longitude))) {
+    throw new Error("Invalid geodesic coordinates");
+  }
+}
+function outputMask(options) {
+  return library.ALL & ~(options.area ? 0 : library.AREA) | (options.unrollLongitude ? library.LONG_UNROLL : 0);
+}
+function validateFinite(value) {
+  if (!Number.isFinite(value))
+    throw new Error("Geodesic axes, azimuth, distance and arc must be finite");
+}
+var nonAreaGeodesicMask = library.ALL & ~library.AREA;
+function createGeodesicEngine({ semiMajorAxis: a, semiMinorAxis: b }) {
+  validateFinite(a);
+  validateFinite(b);
+  return new library.Geodesic(a, (a - b) / a);
+}
+
+// dist/geodesic-path.js
+var wgs84;
+var GeodesicPath = class {
+  constructor(start, end, options = {}) {
+    validateGeographicPosition(start);
+    validateGeographicPosition(end);
+    if (start.length !== end.length)
+      throw new RangeError("Geodesic endpoint dimensions must match");
+    const solver = options.geodesic || getDefaultGeodesic();
+    const inverse = solver.inverse(start[1], start[0], end[1], end[0], { unrollLongitude: true });
+    if (!Number.isFinite(inverse.s12) || inverse.s12 < 0 || !Number.isFinite(inverse.azi1) || !Number.isFinite(inverse.lon2)) {
+      throw new RangeError("Unresolved geodesic path");
+    }
+    this.size = start.length;
+    this.length = inverse.s12;
+    this.first = Object.freeze(Array.from(start));
+    const last = Array.from(end);
+    last[0] = inverse.lon2;
+    if (this.length === 0) {
+      last[0] = start[0];
+      last[1] = start[1];
+    }
+    this.last = Object.freeze(last);
+    this.line = solver.line(start[1], start[0], inverse.azi1, { unrollLongitude: true });
+  }
+  get start() {
+    return this.first.slice();
+  }
+  get end() {
+    return this.last.slice();
+  }
+  sample(fraction, result = new Array(this.size)) {
+    if (!Number.isFinite(fraction) || fraction < 0 || fraction > 1) {
+      throw new RangeError("Geodesic fraction must be in [0, 1]");
+    }
+    if (result.length !== this.size)
+      throw new RangeError("Invalid geodesic sample output length");
+    let longitude;
+    let latitude;
+    if (fraction === 0 || this.length === 0) {
+      longitude = this.first[0];
+      latitude = this.first[1];
+    } else if (fraction === 1) {
+      longitude = this.last[0];
+      latitude = this.last[1];
+    } else {
+      const value = this.line.position(this.length * fraction);
+      longitude = value.lon2;
+      latitude = value.lat2;
+    }
+    const height = this.size === 3 ? this.first[2] * (1 - fraction) + this.last[2] * fraction : 0;
+    if (![longitude, latitude, height].every(Number.isFinite) || result instanceof Float32Array && ![longitude, latitude, height].every((value) => Number.isFinite(Math.fround(value)))) {
+      throw new RangeError("Unrepresentable geodesic sample");
+    }
+    result[0] = longitude;
+    result[1] = latitude;
+    if (this.size === 3)
+      result[2] = height;
+    return result;
+  }
+  sampleByDistance(distance, result = new Array(this.size)) {
+    if (!Number.isFinite(distance) || distance < 0 || distance > this.length) {
+      throw new RangeError("Distance must be within the geodesic path");
+    }
+    return this.sample(this.length === 0 ? 0 : distance / this.length, result);
+  }
+};
+function validateGeographicPosition(point) {
+  if (point.length !== 2 && point.length !== 3 || !Array.from(point).every(Number.isFinite) || Math.abs(point[1]) > 90) {
+    throw new RangeError("Expected finite longitude/latitude[/height], latitude in [-90, 90]");
+  }
+}
+function getDefaultGeodesic() {
+  if (!wgs84) {
+    wgs84 = new EllipsoidGeodesic({ semiMajorAxis: WGS84_RADIUS_X, semiMinorAxis: WGS84_RADIUS_Z });
+  }
+  return wgs84;
+}
+
+// dist/subdivide-geodesic-polyline.js
+function subdivideGeodesicPolyline(input, options) {
+  const { geodesic: geodesic2, size = 2, maxSurfaceDistance = Infinity, ...subdivision } = options;
+  if (size !== 2 && size !== 3 || !Number.isSafeInteger(input.length) || input.length < 0 || input.length % size !== 0) {
+    throw new RangeError("Expected packed longitude/latitude[/height] positions");
+  }
+  const maxVertices = subdivision.maxVertices ?? 65536;
+  if (!Number.isSafeInteger(maxVertices) || maxVertices < 1 || maxVertices > 4294967295 || input.length / size > maxVertices) {
+    throw new RangeError("Invalid or exceeded maxVertices");
+  }
+  if (!(maxSurfaceDistance > 0) || maxSurfaceDistance !== Infinity && !Number.isFinite(maxSurfaceDistance)) {
+    throw new RangeError("maxSurfaceDistance must be positive");
+  }
+  const positions = Array.from(input);
+  for (let i = 0; i < positions.length; i += size)
+    validateGeographicPosition(positions.slice(i, i + size));
+  const paths = [];
+  for (let i = size; i < positions.length; i += size) {
+    const path = new GeodesicPath(positions.slice(i - size, i), positions.slice(i, i + size), {
+      geodesic: geodesic2
+    });
+    paths.push(path);
+    const end = path.end;
+    for (let component = 0; component < size; component++)
+      positions[i + component] = end[component];
+  }
+  return (0, import_polygon2.subdividePolyline)(positions, {
+    ...subdivision,
+    size,
+    maxSegmentLength: maxSurfaceDistance,
+    createEdgeSampler: (_start, _end, index) => paths[index]
+  });
+}
+
+// dist/subdivide-rhumb-polyline.js
+var import_polygon3 = require("@math.gl/geometry/polygon");
+
+// dist/ellipsoid-helpers/rhumb-pole-distance.js
+var Q = 10n ** 48n;
+var PI = 3141592653589793238462643383279502884197169399375n;
+var mul = (x, y) => x * y / Q;
+var div = (x, y) => x * Q / y;
+function exact(x) {
+  const bytes = new DataView(new ArrayBuffer(8));
+  bytes.setFloat64(0, x);
+  const bits = bytes.getBigUint64(0), exponent = Number(bits >> 52n & 2047n);
+  const mantissa = bits & (1n << 52n) - 1n | (exponent ? 1n << 52n : 0n);
+  const shift2 = exponent ? exponent - 1075 : -1074;
+  const value = shift2 >= 0 ? mantissa * Q << BigInt(shift2) : mantissa * Q >> BigInt(-shift2);
+  return bits >> 63n ? -value : value;
+}
+function sc(x) {
+  let s = x, c = Q, ts = x, tc = Q;
+  const square = mul(x, x);
+  for (let n = 1n; n < 160n; n++) {
+    ts = -mul(ts, square) / (2n * n * (2n * n + 1n));
+    tc = -mul(tc, square) / ((2n * n - 1n) * (2n * n));
+    s += ts;
+    c += tc;
+    if (ts === 0n && tc === 0n)
+      break;
+  }
+  return [s, c];
+}
+function remainingPoleDistance(a, b, latitude, azimuth, distance, sign) {
+  const unit = 2 ** Math.floor(Math.log2(a));
+  a /= unit;
+  b /= unit;
+  distance /= unit;
+  const ratio2 = div(exact(b), exact(a));
+  const theta = mul(90n * Q - BigInt(sign) * exact(latitude), PI) / 180n;
+  const [s, c] = sc(theta), prolate = ratio2 > Q;
+  const square = mul(ratio2, ratio2);
+  const k = prolate ? Q - div(Q, square) : Q - square;
+  const z = prolate ? s : c, other = prolate ? c : s;
+  const zz = mul(z, z);
+  let integral = theta, total = theta, coefficient = Q, power = z;
+  for (let n = 1n; n < 480n; n++) {
+    integral = ((2n * n - 1n) * integral + (prolate ? -1n : 1n) * mul(power, other)) / (2n * n);
+    coefficient = mul(coefficient, k) * (2n * n + 1n) / (2n * n);
+    const term = mul(coefficient, integral);
+    total += term;
+    power = mul(power, zz);
+    if (term === 0n)
+      break;
+  }
+  const gap = prolate ? div(total, ratio2) : mul(total, square);
+  const angle2 = mul(exact(azimuth % 360), PI) / 180n;
+  const north = mul(div(exact(distance), exact(a)), sc(angle2)[1]);
+  return Number(gap - BigInt(sign) * north) / Number(Q);
+}
+
+// dist/ellipsoid-metrics.js
+var DEG = Math.PI / 180;
+var NODES = [
+  0.09501250983763744,
+  0.2816035507792589,
+  0.4580167776572274,
+  0.6178762444026438,
+  0.755404408355003,
+  0.8656312023878318,
+  0.9445750230732326,
+  0.9894009349916499
+];
+var WEIGHTS = [
+  0.1894506104550685,
+  0.1826034150449236,
+  0.16915651939500254,
+  0.14959598881657674,
+  0.12462897125553388,
+  0.09515851168249279,
+  0.06225352393864789,
+  0.027152459411754096
+];
+var KINDS = [
+  "geocentric",
+  "parametric",
+  "rectifying",
+  "authalic",
+  "conformal",
+  "isometric"
+];
+var EllipsoidMetrics = class {
+  constructor({ semiMajorAxis: a, semiMinorAxis: b }) {
+    const r = b / a;
+    if (!(Number.isFinite(a) && Number.isFinite(b) && a > 0 && b > 0 && r >= 0.5 && r <= 2)) {
+      throw new Error("Ellipsoid metrics require finite positive axes with 0.5 <= b/a <= 2");
+    }
+    this.semiMajorAxis = a;
+    this.semiMinorAxis = b;
+    this.ratio = r;
+    this.e2 = (1 - r) * (1 + r);
+    this.qPole = 1 + r * r * this.eccentricIntegral(1);
+    this.quarter = integrate((t) => this.meridianIntegrand(t), 0, Math.PI / 2);
+    this.quarterMeridian = a * this.quarter;
+    this.surfaceArea = 2 * Math.PI * a * a * this.qPole;
+    this.volume = 4 * Math.PI / 3 * a * b * a;
+    if (![this.quarterMeridian, this.surfaceArea, this.volume].every((v) => Number.isFinite(v) && v > 0)) {
+      throw new Error("Ellipsoid metrics exceed representable length/area/volume range");
+    }
+    Object.freeze(this);
+  }
+  meridianDistance(latitude) {
+    validateLatitude(latitude);
+    return Math.sign(latitude) * this.semiMajorAxis * this.meridian(Math.abs(latitude));
+  }
+  meridionalCurvatureRadius(latitude) {
+    validateLatitude(latitude);
+    return this.semiMajorAxis * this.meridianIntegrand(latitude * DEG);
+  }
+  transverseCurvatureRadius(latitude) {
+    validateLatitude(latitude);
+    const [s, c] = sincos(latitude);
+    return this.semiMajorAxis / Math.hypot(c, this.ratio * s);
+  }
+  normalCurvatureRadius(latitude, azimuth) {
+    if (!Number.isFinite(azimuth))
+      throw new Error("Azimuth must be finite");
+    const [s, c] = sincos(azimuth % 180);
+    return 1 / (c * c / this.meridionalCurvatureRadius(latitude) + s * s / this.transverseCurvatureRadius(latitude));
+  }
+  latitudeToAuxiliary(latitude, kind) {
+    validateKind(kind);
+    validateLatitude(latitude);
+    if (latitude === 0)
+      return latitude;
+    if (Math.abs(latitude) === 90)
+      return kind === "isometric" ? Math.sign(latitude) * Infinity : latitude;
+    if (this.ratio === 1 && kind !== "isometric")
+      return latitude;
+    const sign = Math.sign(latitude);
+    const phi = Math.abs(latitude);
+    const [s, c] = sincos(phi);
+    switch (kind) {
+      case "geocentric":
+        return sign * angle(this.ratio * this.ratio * s, c);
+      case "parametric":
+        return sign * angle(this.ratio * s, c);
+      case "rectifying":
+        return sign * (phi <= 45 ? this.meridian(phi) / this.quarter * 90 : 90 - integrate((t) => this.meridianIntegrand(Math.PI / 2 - t), 0, (90 - phi) * DEG) / this.quarter * 90);
+      case "authalic": {
+        if (phi <= 45) {
+          const q = this.ratio ** 2 * (s / (c * c + (this.ratio * s) ** 2) + this.eccentricIntegral(s));
+          return sign * Math.asin(q / this.qPole) / DEG;
+        }
+        const cap = integrate((t) => {
+          const st = Math.sin(t), ct = Math.cos(t);
+          const d = st * st + (this.ratio * ct) ** 2;
+          return 2 * this.ratio ** 2 * st / (d * d);
+        }, 0, (90 - phi) * DEG);
+        return sign * (90 - 2 * Math.asin(Math.sqrt(cap / (2 * this.qPole))) / DEG);
+      }
+      default: {
+        const psi = Math.asinh(s / c) - this.e2 * this.eccentricIntegral(s);
+        return sign * (kind === "isometric" ? psi / DEG : psi < 1 ? Math.atan(Math.sinh(psi)) / DEG : 90 - 2 * Math.atan(Math.exp(-psi)) / DEG);
+      }
+    }
+  }
+  latitudeFromAuxiliary(latitude, kind) {
+    validateKind(kind);
+    if (kind === "isometric" && Math.abs(latitude) === Infinity)
+      return Math.sign(latitude) * 90;
+    if (kind !== "isometric")
+      validateLatitude(latitude);
+    else if (!Number.isFinite(latitude))
+      throw new Error("Isometric latitude must be finite or a pole infinity");
+    if (latitude === 0)
+      return latitude;
+    if (kind !== "isometric" && Math.abs(latitude) === 90)
+      return latitude;
+    if (this.ratio === 1 && kind !== "isometric")
+      return latitude;
+    const sign = Math.sign(latitude), target = Math.abs(latitude);
+    if (kind === "geocentric" || kind === "parametric") {
+      const [s, c] = sincos(target);
+      return sign * angle(s, c * (kind === "geocentric" ? this.ratio ** 2 : this.ratio));
+    }
+    let lo = 0, hi = 90;
+    for (let i = 0; i < 64; ++i) {
+      const mid = (lo + hi) / 2;
+      if (mid === lo || mid === hi)
+        break;
+      if (this.latitudeToAuxiliary(mid, kind) < target)
+        lo = mid;
+      else
+        hi = mid;
+    }
+    return sign * ((lo + hi) / 2);
+  }
+  eccentricIntegral(s) {
+    const e = Math.sqrt(Math.abs(this.e2));
+    return e === 0 ? s : (this.e2 > 0 ? Math.atanh(e * s) : Math.atan(e * s)) / e;
+  }
+  meridianIntegrand(t) {
+    return this.ratio ** 2 / Math.hypot(Math.cos(t), this.ratio * Math.sin(t)) ** 3;
+  }
+  meridian(phi) {
+    return phi <= 45 ? integrate((t) => this.meridianIntegrand(t), 0, phi * DEG) : this.quarter - integrate((t) => this.meridianIntegrand(Math.PI / 2 - t), 0, (90 - phi) * DEG);
+  }
+};
+function validateLatitude(value) {
+  if (!(Number.isFinite(value) && Math.abs(value) <= 90))
+    throw new Error("Latitude must be in [-90, 90] degrees");
+}
+function validateKind(kind) {
+  if (!KINDS.includes(kind))
+    throw new Error("Unknown auxiliary latitude");
+}
+function sincos(degrees2) {
+  const a = Math.abs(degrees2);
+  if (a <= 45)
+    return [Math.sin(degrees2 * DEG), Math.cos(degrees2 * DEG)];
+  return [Math.sign(degrees2) * Math.cos((90 - a) * DEG), Math.sin((90 - a) * DEG)];
+}
+function angle(s, c) {
+  return s > c ? 90 - Math.atan2(c, s) / DEG : Math.atan2(s, c) / DEG;
+}
+function integrate(f, lo, hi) {
+  let sum = 0;
+  for (let j = 0; j < 8; ++j) {
+    const h = (hi - lo) / 16, mid = lo + (2 * j + 1) * h;
+    let part = 0;
+    for (let i = 0; i < 8; ++i)
+      part += WEIGHTS[i] * (f(mid - h * NODES[i]) + f(mid + h * NODES[i]));
+    sum += h * part;
+  }
+  return sum;
+}
+
+// dist/ellipsoid-rhumb.js
+var RhumbDomainError = class extends RangeError {
+  constructor(reason) {
+    super(reason === "pole" ? "Rhumb longitude/bearing is undefined at an exact pole" : "Rhumb crosses a pole; continuation longitude is undefined");
+    this.reason = reason;
+    this.name = "RhumbDomainError";
+  }
+};
+var DEG2 = Math.PI / 180;
+var EllipsoidRhumb = class {
+  constructor({ semiMajorAxis: a, semiMinorAxis: b }) {
+    if (!(Number.isFinite(a) && Number.isFinite(b) && a > 0 && b > 0))
+      throw new RangeError("Rhumbs require finite positive axes");
+    this.a = a;
+    this.b = b;
+    this.r = b / a;
+    this.metrics = new EllipsoidMetrics({ semiMajorAxis: 1, semiMinorAxis: this.r });
+    this.surfaceArea = a * this.metrics.surfaceArea * a;
+    if (!(Number.isFinite(this.surfaceArea) && this.surfaceArea > 0))
+      throw new RangeError("Rhumb surface area is unrepresentable");
+    Object.freeze(this);
+  }
+  inverse(lat1, lon1, lat2, lon2, options = {}) {
+    validateRhumbPoint(lat1, lon1);
+    validateRhumbPoint(lat2, lon2);
+    const turns = options.longitudeTurns ?? 0;
+    if (!Number.isSafeInteger(turns))
+      throw new RangeError("Rhumb longitudeTurns must be a safe integer");
+    const longitude = angleDifference(lon1, lon2) + 360 * turns;
+    if (!Number.isFinite(longitude))
+      throw new RangeError("Unrepresentable rhumb winding");
+    const dphi = (lat2 - lat1) * DEG2;
+    const [meanM, meanP] = this.means(lat1, lat2);
+    const dx = longitude * DEG2 * meanM / meanP;
+    const distance = this.a * Math.hypot(dphi * meanM, dx);
+    const azi = Math.atan2(longitude * DEG2, dphi * meanP) / DEG2;
+    const result = {
+      lat1,
+      lon1,
+      lat2,
+      lon2: options.unrollLongitude ? lon1 + longitude : normalize(lon2),
+      azi12: azi,
+      s12: distance
+    };
+    if (options.area)
+      result.S12 = this.area(lat1, lat2, longitude * DEG2);
+    if (!Number.isFinite(distance))
+      throw new RangeError("Unrepresentable rhumb distance");
+    return result;
+  }
+  direct(latitude, longitude, azimuth, distance, options = {}) {
+    return this.line(latitude, longitude, azimuth, options).position(distance);
+  }
+  line(latitude, longitude, azimuth, options = {}) {
+    validateRhumbPoint(latitude, longitude);
+    if (!Number.isFinite(azimuth))
+      throw new RangeError("Rhumb azimuth must be finite");
+    const [sa, ca] = sincosDegrees(azimuth);
+    const area = Boolean(options.area), unroll = Boolean(options.unrollLongitude);
+    const azi = normalize(azimuth);
+    return {
+      position: (distance) => {
+        if (!Number.isFinite(distance))
+          throw new RangeError("Rhumb distance must be finite");
+        const delta = distance / this.a;
+        if (!Number.isFinite(delta))
+          throw new RangeError("Unrepresentable rhumb distance");
+        const north = delta * ca;
+        let poleDistance;
+        if (north !== 0) {
+          const gap = north > 0 ? this.meridianDelta(latitude, 90) : this.meridianDelta(-90, latitude);
+          poleDistance = gap - Math.abs(north);
+          if (Math.abs(poleDistance) < 1e-4 * gap)
+            poleDistance = remainingPoleDistance(this.a, this.b, latitude, azimuth, distance, Math.sign(north));
+          if (poleDistance < 0)
+            throw new RhumbDomainError("pole-crossing");
+          if (poleDistance === 0)
+            throw new RhumbDomainError("pole");
+        }
+        const polar = north === 0 ? void 0 : this.polarEndpoint(latitude, north, poleDistance);
+        const lat2 = north === 0 ? latitude : (polar == null ? void 0 : polar.latitude) ?? this.inverseMeridian(latitude, north);
+        if (Math.abs(lat2) === 90)
+          throw new RhumbDomainError("pole");
+        const [meanM, meanP] = (polar == null ? void 0 : polar.means) ?? this.means(latitude, lat2);
+        const dlon = delta * sa * meanP / meanM / DEG2;
+        const lon2 = unroll ? longitude + dlon : normalize(normalize(longitude) + dlon);
+        if (!Number.isFinite(lon2))
+          throw new RangeError("Unrepresentable rhumb longitude");
+        const result = {
+          lat1: latitude,
+          lon1: longitude,
+          lat2,
+          lon2,
+          azi12: azi,
+          s12: distance
+        };
+        if (area)
+          result.S12 = this.area(latitude, lat2, dlon * DEG2, polar == null ? void 0 : polar.psi);
+        return result;
+      }
+    };
+  }
+  means(lat1, lat2) {
+    const d = (lat2 - lat1) * DEG2;
+    const mid = (lat1 + lat2) / 2;
+    const meanM = this.meridianMean(lat1, lat2);
+    const cmin = Math.min(latitudeSinCos(lat1)[1], latitudeSinCos(lat2)[1]);
+    const meanP = Math.abs(d) < 0.25 * cmin ? integrate((t) => {
+      const [s, c] = latitudeSinCos(mid + t * (lat2 - lat1) / 2);
+      return this.r ** 2 / (c * (c * c + (this.r * s) ** 2));
+    }, -1, 1) / 2 : (this.psi(lat2) - this.psi(lat1)) / d;
+    return [meanM, meanP];
+  }
+  psi(latitude) {
+    return this.metrics.latitudeToAuxiliary(latitude, "isometric") * DEG2;
+  }
+  polarEndpoint(latitude, north, poleDistance) {
+    const sign = Math.abs(latitude) > 80 && Math.abs(north) < Math.abs(this.meridianDelta(0, latitude)) ? Math.sign(latitude) : Math.sign(north), theta1 = (90 - sign * latitude) * DEG2, limit = 10 * DEG2;
+    const density = (theta2) => this.r ** 2 / Math.hypot(Math.sin(theta2), this.r * Math.cos(theta2)) ** 3;
+    const gap = (theta2) => integrate(density, 0, theta2);
+    const target = sign === Math.sign(north) ? poleDistance : this.meridianDelta(sign > 0 ? latitude : -90, sign > 0 ? 90 : latitude) - sign * north;
+    if (!(target > 0 && target < gap(limit)))
+      return void 0;
+    let lo = 0, hi = limit, theta = target * this.r;
+    if (!(theta > lo && theta < hi))
+      theta = theta1;
+    for (let i = 0; i < 64; i++) {
+      const residual = gap(theta) - target;
+      if (residual === 0)
+        break;
+      if (residual < 0)
+        lo = theta;
+      else
+        hi = theta;
+      const next = theta - residual / density(theta);
+      if (next === theta)
+        break;
+      theta = next > lo && next < hi ? next : (lo + hi) / 2;
+      if (theta === lo || theta === hi)
+        break;
+      if (i === 63)
+        throw new Error("Rhumb polar meridian inversion did not converge");
+    }
+    const span = theta - theta1, mid = (theta + theta1) / 2;
+    const meanM = integrate((t) => density(mid + t * span / 2), -1, 1) / 2;
+    const meanP = Math.abs(span) < 0.25 * Math.min(Math.sin(theta), Math.sin(theta1)) ? integrate((t) => {
+      const x = mid + t * span / 2, c = Math.sin(x), s = Math.cos(x);
+      return this.r ** 2 / (c * (c * c + (this.r * s) ** 2));
+    }, -1, 1) / 2 : -(this.polarPsi(theta) - this.polarPsi(theta1)) / span;
+    return {
+      latitude: sign * (90 - theta / DEG2),
+      means: [meanM, meanP],
+      psi: sign * this.polarPsi(theta)
+    };
+  }
+  polarPsi(theta) {
+    const s = Math.cos(theta), c = Math.sin(theta), e2 = (1 - this.r) * (1 + this.r), e = Math.sqrt(Math.abs(e2));
+    const I = e === 0 ? s : (e2 > 0 ? Math.atanh(e * s) : Math.atan(e * s)) / e;
+    return Math.asinh(s / c) - e2 * I;
+  }
+  meridianMean(lat1, lat2) {
+    const mid = (lat1 + lat2) / 2;
+    return integrate((t) => {
+      const [s, c] = latitudeSinCos(mid + t * (lat2 - lat1) / 2);
+      return this.r ** 2 / Math.hypot(c, this.r * s) ** 3;
+    }, -1, 1) / 2;
+  }
+  meridianDelta(lat1, lat2) {
+    return (lat2 - lat1) * DEG2 * this.meridianMean(lat1, lat2);
+  }
+  inverseMeridian(start, displacement) {
+    let lo = -90, hi = 90;
+    let phi = start + displacement / this.metrics.meridionalCurvatureRadius(start) / DEG2;
+    if (!(phi > lo && phi < hi))
+      phi = (start + Math.sign(displacement) * 90) / 2;
+    for (let i = 0; i < 64; i++) {
+      const residual = this.meridianDelta(start, phi) - displacement;
+      if (residual === 0)
+        return phi;
+      if (residual < 0)
+        lo = phi;
+      else
+        hi = phi;
+      const next = phi - residual / this.metrics.meridionalCurvatureRadius(phi) / DEG2;
+      if (next === phi)
+        return phi;
+      phi = next > lo && next < hi ? next : (lo + hi) / 2;
+      if (phi === lo || phi === hi) {
+        const candidates = [lo, hi].filter((v) => Math.abs(v) < 90);
+        return candidates.reduce((best, v) => Math.abs(this.meridianDelta(start, v) - displacement) < Math.abs(this.meridianDelta(start, best) - displacement) ? v : best);
+      }
+    }
+    throw new Error("Rhumb meridian inversion did not converge");
+  }
+  inversePsi(psi) {
+    let lo = -90, hi = 90, phi = Math.atan(Math.sinh(psi)) / DEG2;
+    if (Math.abs(phi) === 90)
+      phi = Math.sign(psi) * (90 - 2 ** -46);
+    for (let i = 0; i < 32; i++) {
+      const value = this.psi(phi) - psi;
+      if (value === 0)
+        return phi;
+      if (value < 0)
+        lo = phi;
+      else
+        hi = phi;
+      const [s, c] = latitudeSinCos(phi);
+      const next = phi - value * c * (c * c + (this.r * s) ** 2) / this.r ** 2 / DEG2;
+      if (next === phi)
+        return phi;
+      phi = next > lo && next < hi ? next : (lo + hi) / 2;
+      if (phi === lo || phi === hi)
+        return phi;
+    }
+    throw new Error("Rhumb isometric inversion did not converge");
+  }
+  potential(latitude) {
+    const [s, c] = latitudeSinCos(latitude), e2 = (1 - this.r) * (1 + this.r), e = Math.sqrt(Math.abs(e2));
+    const I = e === 0 ? s : (e2 > 0 ? Math.atanh(e * s) : Math.atan(e * s)) / e;
+    return this.r ** 2 * (s / (c * c + (this.r * s) ** 2) + I) / 2;
+  }
+  area(lat1, lat2, dlon, endpointPsi) {
+    if (dlon === 0 || lat1 === -lat2)
+      return 0;
+    if (lat1 === lat2) {
+      const value2 = this.a * dlon * (this.a * this.potential(lat1));
+      if (!Number.isFinite(value2))
+        throw new RangeError("Unrepresentable rhumb area");
+      return value2;
+    }
+    const p1 = this.psi(lat1), p2 = endpointPsi ?? this.psi(lat2), mid = (p1 + p2) / 2, half = (p2 - p1) / 2;
+    const pieces = Math.max(1, Math.ceil(Math.abs(p2 - p1) / 2));
+    let sum = 0;
+    for (let j = 0; j < pieces; j++)
+      sum += integrate((t) => this.potential(this.inversePsi(mid + half * t)), -1 + 2 * j / pieces, -1 + 2 * (j + 1) / pieces);
+    const value = this.a * dlon * (this.a * (sum / 2));
+    if (!Number.isFinite(value))
+      throw new RangeError("Unrepresentable rhumb area");
+    return value;
+  }
+};
+function validateRhumbPoint(latitude, longitude) {
+  if (!(Number.isFinite(latitude) && Math.abs(latitude) <= 90 && Number.isFinite(longitude)))
+    throw new RangeError("Rhumb coordinates require finite longitude and latitude in [-90,90]");
+  if (Math.abs(latitude) === 90)
+    throw new RhumbDomainError("pole");
+}
+function latitudeSinCos(phi) {
+  const p = Math.abs(phi);
+  return p <= 45 ? [Math.sin(phi * DEG2), Math.cos(phi * DEG2)] : [Math.sign(phi) * Math.cos((90 - p) * DEG2), Math.sin((90 - p) * DEG2)];
+}
+function sincosDegrees(angle2) {
+  const reduced = angle2 % 360, q = Math.round(reduced / 90), d = reduced - 90 * q, x = d * DEG2;
+  const s = Math.sin(x), c = Math.cos(x);
+  switch ((q % 4 + 4) % 4) {
+    case 0:
+      return [s, c];
+    case 1:
+      return [c, -s];
+    case 2:
+      return [-s, -c];
+    default:
+      return [-c, s];
+  }
+}
+function normalize(angle2) {
+  let a = angle2 % 360;
+  if (a > 180)
+    a -= 360;
+  if (a < -180)
+    a += 360;
+  return a;
+}
+function angleDifference(a, b) {
+  let [d, e] = twoSum(-normalize(a), normalize(b));
+  [d, e] = twoSum(normalize(d), e);
+  if (Math.abs(d) === 180)
+    return (e === 0 ? b < a : e > 0) ? -180 : 180;
+  return d === 0 ? b < a ? -0 : 0 : d;
+}
+function twoSum(a, b) {
+  const s = a + b, v = s - a;
+  return [s, a - (s - v) + (b - v)];
+}
+
+// dist/rhumb-path.js
+var wgs842;
+function getDefaultRhumb() {
+  if (!wgs842)
+    wgs842 = new EllipsoidRhumb({ semiMajorAxis: WGS84_RADIUS_X, semiMinorAxis: WGS84_RADIUS_Z });
+  return wgs842;
+}
+var RhumbPath = class {
+  constructor(start, end, options = {}) {
+    validateGeographicPosition(start);
+    validateGeographicPosition(end);
+    if (start.length !== end.length)
+      throw new RangeError("Rhumb endpoint dimensions must match");
+    const solver = options.rhumb || getDefaultRhumb();
+    if (options.longitudeMode !== void 0 && !["shortest", "unrolled"].includes(options.longitudeMode) || options.longitudeMode === "unrolled" && options.longitudeTurns !== void 0)
+      throw new RangeError("Choose explicit turns or unrolled endpoint longitudes");
+    let inverse = solver.inverse(start[1], start[0], end[1], end[0], {
+      longitudeTurns: options.longitudeTurns,
+      unrollLongitude: true
+    });
+    if (options.longitudeMode === "unrolled") {
+      const turns2 = Math.round((end[0] - inverse.lon2) / 360);
+      if (turns2 !== 0)
+        inverse = solver.inverse(start[1], start[0], end[1], end[0], {
+          longitudeTurns: turns2,
+          unrollLongitude: true
+        });
+    }
+    if (![inverse.s12, inverse.azi12, inverse.lon2].every(Number.isFinite) || inverse.s12 < 0)
+      throw new RangeError("Unresolved rhumb path");
+    this.size = start.length;
+    this.length = inverse.s12;
+    this.first = Object.freeze(Array.from(start));
+    const last = Array.from(end);
+    const turns = Math.round((inverse.lon2 - end[0]) / 360);
+    const endpoint = end[0] + 360 * turns;
+    const retainsPhase = Number.isSafeInteger(turns) && Number.isFinite(endpoint) && Math.abs(endpoint - inverse.lon2) <= 4 * Number.EPSILON * Math.max(360, Math.abs(inverse.lon2));
+    last[0] = inverse.s12 === 0 ? start[0] : retainsPhase ? endpoint : inverse.lon2;
+    if (inverse.s12 === 0)
+      last[1] = start[1];
+    this.last = Object.freeze(last);
+    this.line = solver.line(start[1], start[0], inverse.azi12, { unrollLongitude: true });
+  }
+  get start() {
+    return this.first.slice();
+  }
+  get end() {
+    return this.last.slice();
+  }
+  sample(fraction, result = new Array(this.size)) {
+    if (!Number.isFinite(fraction) || fraction < 0 || fraction > 1)
+      throw new RangeError("Rhumb fraction must be in [0, 1]");
+    if (result.length !== this.size || ArrayBuffer.isView(result) && !(result instanceof Float32Array) && !(result instanceof Float64Array))
+      throw new RangeError("Expected a floating rhumb output with matching dimensions");
+    let longitude = this.first[0], latitude = this.first[1];
+    if (fraction === 1) {
+      longitude = this.last[0];
+      latitude = this.last[1];
+    } else if (fraction !== 0 && this.length !== 0) {
+      const p = this.line.position(this.length * fraction);
+      longitude = p.lon2;
+      latitude = p.lat2;
+    }
+    const height = this.size === 3 ? this.first[2] * (1 - fraction) + this.last[2] * fraction : 0;
+    const values = [longitude, latitude, height];
+    if (!values.every(Number.isFinite) || result instanceof Float32Array && !values.every((x) => Number.isFinite(Math.fround(x))))
+      throw new RangeError("Unrepresentable rhumb sample");
+    result[0] = longitude;
+    result[1] = latitude;
+    if (this.size === 3)
+      result[2] = height;
+    return result;
+  }
+  sampleByDistance(distance, result = new Array(this.size)) {
+    if (!Number.isFinite(distance) || distance < 0 || distance > this.length)
+      throw new RangeError("Distance must be within the rhumb path");
+    return this.sample(this.length === 0 ? 0 : distance / this.length, result);
+  }
+};
+
+// dist/subdivide-rhumb-polyline.js
+function subdivideRhumbPolyline(input, options) {
+  const { rhumb, longitudeTurns, longitudeMode, size = 2, maxSurfaceDistance = Infinity, ...subdivision } = options;
+  const maxVertices = subdivision.maxVertices ?? 65536;
+  if (longitudeMode !== void 0 && !["shortest", "unrolled"].includes(longitudeMode) || longitudeMode === "unrolled" && longitudeTurns !== void 0 || size !== 2 && size !== 3 || !Number.isSafeInteger(input.length) || input.length < 0 || input.length % size !== 0 || !Number.isSafeInteger(maxVertices) || maxVertices < 1 || maxVertices > 4294967295 || input.length / size > maxVertices || !(maxSurfaceDistance > 0) || maxSurfaceDistance !== Infinity && !Number.isFinite(maxSurfaceDistance))
+    throw new RangeError("Invalid rhumb subdivision dimensions or limits");
+  const count = Math.max(0, input.length / size - 1);
+  const turns = longitudeTurns ? Array.from(longitudeTurns) : void 0;
+  if (turns && (turns.length !== count || !turns.every(Number.isSafeInteger)))
+    throw new RangeError("Expected one integer longitudeTurns value per rhumb edge");
+  const positions = Array.from(input);
+  for (let i = 0; i < positions.length; i += size)
+    validateGeographicPosition(positions.slice(i, i + size));
+  const original = positions.slice();
+  const paths = [];
+  for (let i = size; i < positions.length; i += size) {
+    const path = new RhumbPath(original.slice(i - size, i), original.slice(i, i + size), {
+      rhumb,
+      longitudeMode,
+      longitudeTurns: turns == null ? void 0 : turns[paths.length]
+    });
+    const first = positions.slice(i - size, i);
+    const worldTurns = Math.round((first[0] - original[i - size]) / 360);
+    const offset2 = 360 * worldTurns;
+    if (!Number.isSafeInteger(worldTurns) || original[i - size] + offset2 !== first[0])
+      throw new RangeError("Unrepresentable rhumb longitude chart");
+    const last = path.end;
+    const endTurns = Math.round((last[0] - original[i]) / 360);
+    const translated = last[0] + offset2;
+    const endpoint = original[i] + (offset2 + 360 * endTurns);
+    last[0] = Number.isSafeInteger(endTurns) && Number.isFinite(endpoint) && Math.abs(endpoint - translated) <= 4 * Number.EPSILON * Math.max(360, Math.abs(translated)) ? endpoint : translated;
+    if (path.length === 0) {
+      last[0] = first[0];
+      last[1] = first[1];
+    }
+    const sample = (fraction) => {
+      if (fraction === 0)
+        return first.slice();
+      if (fraction === 1)
+        return last.slice();
+      const p = path.sample(fraction);
+      p[0] += offset2;
+      return p;
+    };
+    paths.push({ length: path.length, sample });
+    positions.splice(i, size, ...sample(1));
+  }
+  return (0, import_polygon3.subdividePolyline)(positions, {
+    ...subdivision,
+    size,
+    maxSegmentLength: maxSurfaceDistance,
+    createEdgeSampler: (_start, _end, index) => paths[index]
+  });
+}
+
+// dist/geographic-seams/types.js
+var GeographicSeamError = class extends RangeError {
+  constructor(reason, message) {
+    super(message);
+    this.reason = reason;
+    this.name = "GeographicSeamError";
+  }
+};
+
+// dist/geographic-seams/edge.js
+var ANGULAR_TOLERANCE = 1e-10;
+var MAX_LONGITUDE = 65536;
+var wgs843;
+function getDefaultGeodesic2() {
+  if (!wgs843)
+    wgs843 = new EllipsoidGeodesic({ semiMajorAxis: WGS84_RADIUS_X, semiMinorAxis: WGS84_RADIUS_Z });
+  return wgs843;
+}
+var Context = class {
+  constructor(options) {
+    this.options = options;
+    this.work = 0;
+    this.vertices = 0;
+    this.longitudeAliases = /* @__PURE__ */ new Map();
+    this.options = { ...options };
+    this.size = this.options.size ?? 2;
+    this.right = this.options.seamLongitude ?? 180;
+    this.left = this.right - 360;
+    this.iterations = this.options.maxIterations ?? 64;
+    this.maxVertices = this.options.maxVertices ?? 65536;
+    this.maxWork = this.options.maxWork ?? 1e6;
+    if (!["linear", "geodesic", "rhumb"].includes(this.options.edgeModel) || this.options.linearLongitude !== void 0 && !["supplied", "shortest"].includes(this.options.linearLongitude) || !Number.isSafeInteger(this.size) || this.size < 2 || this.size > 64 || !Number.isFinite(this.right) || Math.abs(this.right) > MAX_LONGITUDE || !Number.isSafeInteger(this.maxVertices) || this.maxVertices < 1 || this.maxVertices > 4294967295 || !Number.isSafeInteger(this.maxWork) || this.maxWork < 1 || this.maxWork > 1e8 || !Number.isInteger(this.iterations) || this.iterations < 1 || this.iterations > 128)
+      throw new GeographicSeamError("input", "Invalid seam model, dimensions or limits");
+  }
+  tick(n = 1) {
+    this.work += n;
+    if (this.work > this.maxWork)
+      throw new GeographicSeamError("limit", "Exceeded maxWork");
+  }
+  canonicalLongitude(longitude) {
+    while (this.longitudeAliases.has(longitude)) {
+      this.tick();
+      longitude = this.longitudeAliases.get(longitude);
+    }
+    return longitude;
+  }
+  aliasLongitude(from, to) {
+    const a = this.canonicalLongitude(from), b = this.canonicalLongitude(to);
+    if (a !== b)
+      this.longitudeAliases.set(a, b);
+  }
+  projectLongitude(longitude, shift2) {
+    const world = Math.round((longitude - this.right) / 360);
+    const translated = longitude === this.right + 360 * world ? this.right + 360 * (world + shift2 / 360) : longitude + shift2;
+    return this.canonicalLongitude(translated);
+  }
+  addVertices(n) {
+    this.vertices += n;
+    if (this.vertices > this.maxVertices)
+      throw new GeographicSeamError("limit", "Exceeded maxVertices");
+  }
+  read(input) {
+    if (!Number.isSafeInteger(input.length) || input.length < 0 || input.length % this.size)
+      throw new GeographicSeamError("input", "Invalid packed geographic positions or vertex limit");
+    this.addVertices(input.length / this.size);
+    const result = [];
+    for (let i = 0; i < input.length; i += this.size) {
+      this.tick();
+      const p = Array.from({ length: this.size }, (_, k) => input[i + k]);
+      if (!p.every(Number.isFinite) || Math.abs(p[0]) > MAX_LONGITUDE || Math.abs(p[1]) > 90)
+        throw new GeographicSeamError("input", "Expected finite positions, latitude in [-90,90], |longitude| <= 65536");
+      result.push(p);
+    }
+    return result;
+  }
+};
+function same(a, b) {
+  return a.length === b.length && a.every((x, i) => x === b[i]);
+}
+function shortDifference(delta) {
+  const value = delta % 360;
+  return value > 180 ? value - 360 : value < -180 ? value + 360 : value;
+}
+function shortLongitudeTurns(a, b) {
+  const delta = b - a, virtual = delta - b;
+  const low = b - (delta - virtual) + (-a - virtual);
+  const remainder = delta % 360;
+  let turns = -Math.trunc(delta / 360);
+  if (remainder > 180 || remainder === 180 && low > 0)
+    turns--;
+  if (remainder < -180 || remainder === -180 && low < 0)
+    turns++;
+  return turns;
+}
+function oppositeMeridians(a, b) {
+  const x = shortDifference(b), y = -shortDifference(a), sum = x + y, virtual = sum - x;
+  return Math.abs(sum) === 180 && x - (sum - virtual) + (y - virtual) === 0;
+}
+function worldAt(x, context) {
+  let world = Math.floor((x - context.right) / 360) + 1;
+  while (x < context.right + 360 * (world - 1))
+    world--;
+  while (x >= context.right + 360 * world)
+    world++;
+  return world;
+}
+function chartPoint(point, world, context) {
+  const p = point.slice();
+  p[0] -= 360 * world;
+  const onLeft = point[0] === context.right + 360 * (world - 1);
+  const onRight = point[0] === context.right + 360 * world;
+  if (onLeft)
+    p[0] = context.left;
+  if (onRight)
+    p[0] = context.right;
+  if (!onLeft && p[0] === context.left || !onRight && p[0] === context.right)
+    throw new GeographicSeamError("precision", "Longitude displacement cannot be represented in this chart");
+  return p;
+}
+function straight(a, b) {
+  return { a, b, source: null, sample: (t) => a.map((x, i) => x * (1 - t) + b[i] * t) };
+}
+function slice(edge, lo, hi) {
+  const a = lo === 0 ? edge.a : lo === 1 ? edge.b : edge.sample(lo);
+  const b = hi === 0 ? edge.a : hi === 1 ? edge.b : edge.sample(hi);
+  const source = edge.source && {
+    ...edge.source,
+    startFraction: edge.source.startFraction + (edge.source.endFraction - edge.source.startFraction) * lo,
+    endFraction: edge.source.startFraction + (edge.source.endFraction - edge.source.startFraction) * hi
+  };
+  return {
+    a,
+    b,
+    source,
+    sample: (t) => t === 0 ? a.slice() : t === 1 ? b.slice() : edge.sample(lo + (hi - lo) * t)
+  };
+}
+function shift(edge, delta) {
+  const move = (p) => [p[0] + delta, ...p.slice(1)];
+  return {
+    a: move(edge.a),
+    b: move(edge.b),
+    source: edge.source && { ...edge.source, longitudeShift: edge.source.longitudeShift + delta },
+    sample: (t) => move(edge.sample(t))
+  };
+}
+function createEdges(start, end, originalStart, edgeIndex, ringIndex, turns, context, splitLatitude = true) {
+  context.tick();
+  const { edgeModel, linearLongitude = "supplied" } = context.options;
+  if (!Number.isSafeInteger(turns) || Math.abs(turns) > 128 || turns !== 0 && edgeModel !== "rhumb")
+    throw new GeographicSeamError("input", "Turns require rhumb edges and |turns| <= 128");
+  let offset2 = 360 * Math.round((start[0] - originalStart[0]) / 360);
+  const source = {
+    ringIndex,
+    edgeIndex,
+    startFraction: 0,
+    endFraction: 1,
+    longitudeShift: offset2
+  };
+  const first = start.slice(), last = end.slice();
+  let horizontal;
+  let critical;
+  let pole;
+  if (edgeModel === "linear") {
+    last[0] = end[0] + (offset2 + (linearLongitude === "shortest" ? 360 * shortLongitudeTurns(originalStart[0], end[0]) : 0));
+    horizontal = (t) => [first[0] * (1 - t) + last[0] * t, first[1] * (1 - t) + last[1] * t];
+  } else if (edgeModel === "rhumb") {
+    context.tick(2);
+    const path = new RhumbPath(originalStart.slice(0, 2), last.slice(0, 2), {
+      rhumb: context.options.rhumb,
+      longitudeTurns: turns
+    });
+    last[0] = end[0] + (360 * Math.round((path.end[0] - end[0]) / 360) + offset2);
+    horizontal = (t) => {
+      const p = path.sample(t);
+      p[0] += offset2;
+      return p;
+    };
+  } else {
+    context.tick(3);
+    const solver = context.options.geodesic || getDefaultGeodesic2();
+    const path = new GeodesicPath(originalStart.slice(0, 2), last.slice(0, 2), { geodesic: solver });
+    if (Math.abs(first[1]) === 90) {
+      context.tick(2);
+      const incomingChart = new GeodesicPath(first.slice(0, 2), last.slice(0, 2), {
+        geodesic: solver
+      });
+      offset2 = 360 * Math.round((incomingChart.end[0] - path.end[0]) / 360);
+      source.longitudeShift = offset2;
+    }
+    last[0] = end[0] + (360 * Math.round((path.end[0] - end[0]) / 360) + offset2);
+    horizontal = (t) => {
+      const p = path.sample(t);
+      p[0] += offset2;
+      return p;
+    };
+    if (Math.abs(first[1]) === 90)
+      first[0] = last[0];
+    if (Math.abs(last[1]) === 90)
+      last[0] = first[0];
+    const inverse = solver.inverse(originalStart[1], originalStart[0], end[1], end[0]);
+    const c1 = Math.cos(inverse.azi1 * Math.PI / 180), c2 = Math.cos(inverse.azi2 * Math.PI / 180);
+    if (path.length > 0 && oppositeMeridians(originalStart[0], end[0]) && (inverse.azi1 === 0 || Math.abs(inverse.azi1) === 180) && Math.abs(first[1]) !== 90 && Math.abs(last[1]) !== 90) {
+      const latitude = c1 > 0 ? 90 : -90;
+      context.tick(2);
+      const fraction = solver.inverse(start[1], start[0], latitude, start[0]).s12 / path.length;
+      if (fraction > 0 && fraction < 1 && Math.abs(path.sample(fraction)[1] - latitude) < ANGULAR_TOLERANCE)
+        pole = { fraction, latitude };
+    } else if (splitLatitude && c1 * c2 < 0 && path.length > 0) {
+      context.tick();
+      const line = solver.line(originalStart[1], originalStart[0], inverse.azi1, {
+        unrollLongitude: true
+      });
+      let lo = 0, hi = 1;
+      for (let i = 0; i < 64; i++) {
+        context.tick();
+        const mid = (lo + hi) / 2;
+        const c = Math.cos(line.position(path.length * mid).azi2 * Math.PI / 180);
+        if (c > 0 === c1 > 0)
+          lo = mid;
+        else
+          hi = mid;
+      }
+      critical = (lo + hi) / 2;
+    }
+  }
+  if (Math.abs(last[0]) > MAX_LONGITUDE)
+    throw new GeographicSeamError("input", "Unrolled longitude exceeds the declared seam profile");
+  const sample = (t) => {
+    context.tick();
+    const p = t === 0 ? first.slice(0, 2) : t === 1 ? last.slice(0, 2) : horizontal(t);
+    for (let i = 2; i < first.length; i++)
+      p[i] = first[i] * (1 - t) + last[i] * t;
+    if (!p.every(Number.isFinite))
+      throw new GeographicSeamError("precision", "Nonfinite edge sample");
+    return p;
+  };
+  const edge = { a: first, b: last, source, sample };
+  if (pole) {
+    const incoming = slice(edge, 0, pole.fraction), outgoing = slice(edge, pole.fraction, 1);
+    incoming.b = [first[0], pole.latitude, ...sample(pole.fraction).slice(2)];
+    outgoing.a = [last[0], pole.latitude, ...incoming.b.slice(2)];
+    const incomingSample = incoming.sample, outgoingSample = outgoing.sample;
+    incoming.sample = (t) => t === 1 ? incoming.b.slice() : incomingSample(t);
+    outgoing.sample = (t) => t === 0 ? outgoing.a.slice() : outgoingSample(t);
+    return [incoming, straight(incoming.b, outgoing.a), outgoing];
+  }
+  return critical !== void 0 && critical > 0 && critical < 1 ? [slice(edge, 0, critical), slice(edge, critical, 1)] : [edge];
+}
+function root(edge, axis, value, context) {
+  if (edge.a[axis] === value)
+    return 0;
+  if (edge.b[axis] === value)
+    return 1;
+  if (!(value > Math.min(edge.a[axis], edge.b[axis]) && value < Math.max(edge.a[axis], edge.b[axis])))
+    throw new GeographicSeamError("precision", "Unbracketed seam root");
+  let lo = 0, hi = 1, a = edge.a, b = edge.b;
+  for (let i = 0; i < context.iterations; i++) {
+    context.tick();
+    const t = (lo + hi) / 2, p = edge.sample(t);
+    if (p[axis] === value)
+      return t;
+    if (hi - lo <= 4 * Number.EPSILON && Math.abs(a[0] - b[0]) * Math.max(Math.abs(Math.cos(a[1] * Math.PI / 180)), Math.abs(Math.cos(b[1] * Math.PI / 180))) <= ANGULAR_TOLERANCE && Math.abs(a[1] - b[1]) <= ANGULAR_TOLERANCE)
+      return t;
+    if (t === lo || t === hi)
+      break;
+    if (p[axis] < value === edge.a[axis] < edge.b[axis]) {
+      lo = t;
+      a = p;
+    } else {
+      hi = t;
+      b = p;
+    }
+  }
+  throw new GeographicSeamError("precision", "Seam root exhausted its precision/iteration budget");
+}
+function cut(edge, context) {
+  const low = Math.min(edge.a[0], edge.b[0]), high = Math.max(edge.a[0], edge.b[0]);
+  const fractions = [0, 1];
+  for (let k = worldAt(low, context); context.right + 360 * k < high; k++) {
+    context.tick();
+    fractions.push(root(edge, 0, context.right + 360 * k, context));
+    if (fractions.length > context.maxVertices)
+      throw new GeographicSeamError("limit", "Too many seam crossings");
+  }
+  fractions.sort((a, b) => a - b);
+  const result = [];
+  for (let i = 1; i < fractions.length; i++) {
+    context.tick();
+    context.addVertices(2);
+    const piece = slice(edge, fractions[i - 1], fractions[i]);
+    for (const p of [piece.a, piece.b]) {
+      const k = Math.round((p[0] - context.right) / 360), boundary = context.right + 360 * k;
+      if (fractions[i - 1] !== 0 && p === piece.a || fractions[i] !== 1 && p === piece.b)
+        p[0] = boundary;
+    }
+    const onBoundary = (x) => x === context.right + 360 * Math.round((x - context.right) / 360);
+    const reference = !onBoundary(piece.a[0]) ? piece.a[0] : !onBoundary(piece.b[0]) ? piece.b[0] : (piece.a[0] + piece.b[0]) / 2;
+    const world = worldAt(reference, context);
+    const shifted = shift(piece, -360 * world);
+    shifted.a = chartPoint(piece.a, world, context);
+    shifted.b = chartPoint(piece.b, world, context);
+    const previousSample = shifted.sample;
+    shifted.sample = (t) => t === 0 ? shifted.a.slice() : t === 1 ? shifted.b.slice() : previousSample(t);
+    result.push({ edge: shifted, world });
+  }
+  return result;
+}
+
+// dist/geographic-seams/polygon.js
+function winding(edges, point, context, side, generatedBoundary = true, longitudeShift = 0) {
+  let value = 0, boundary = false;
+  for (const edge of edges) {
+    context.tick();
+    const a = edge.a, b = edge.b;
+    if (a[1] === b[1]) {
+      if ((generatedBoundary || edge.source) && point[1] === a[1] && point[0] >= Math.min(context.projectLongitude(a[0], longitudeShift), context.projectLongitude(b[0], longitudeShift)) && point[0] <= Math.max(context.projectLongitude(a[0], longitudeShift), context.projectLongitude(b[0], longitudeShift)))
+        boundary = true;
+      continue;
+    }
+    if (point[1] >= Math.min(a[1], b[1]) && point[1] <= Math.max(a[1], b[1])) {
+      const t = root(edge, 1, point[1], context), x = context.projectLongitude(edge.sample(t)[0], longitudeShift);
+      if ((generatedBoundary || edge.source) && Math.abs(x - point[0]) <= ANGULAR_TOLERANCE)
+        boundary = true;
+      if (a[1] > point[1] !== b[1] > point[1] && (side === "left" ? x >= point[0] : x > point[0]))
+        value += b[1] > a[1] ? 1 : -1;
+    }
+  }
+  return { value, boundary };
+}
+function contains(ring, p, context, side) {
+  context.tick();
+  for (let k = Math.ceil((ring.min - p[0]) / 360) - 1; k <= Math.floor((ring.max - p[0]) / 360) + 1; k++) {
+    context.tick();
+    if (winding(ring.membership, p, context, side, false, -360 * k).value !== 0)
+      return true;
+  }
+  return false;
+}
+function filled(rings, p, context, side) {
+  return contains(rings[0], p, context, side) && !rings.slice(1).some((r) => contains(r, p, context, side));
+}
+function prepare(input, index, context) {
+  const positions = context.read(input.positions);
+  if (positions.length > 1 && positions[0][0] === positions[positions.length - 1][0] && positions[0][1] === positions[positions.length - 1][1]) {
+    if (!same(positions[0], positions[positions.length - 1]))
+      throw new GeographicSeamError("input", "Closing polygon attributes must match");
+    positions.pop();
+  }
+  if (new Set(positions.map((p) => `${p[0]},${p[1]}`)).size < 3)
+    throw new GeographicSeamError("topology", "Polygon ring needs three distinct positions");
+  const turns = input.longitudeTurns ? Array.from(input.longitudeTurns) : new Array(positions.length).fill(0);
+  if (turns.length !== positions.length)
+    throw new GeographicSeamError("input", "Expected a turn count per ring edge");
+  const edges = [];
+  let cursor = positions[0];
+  for (let i = 0; i < positions.length; i++) {
+    const end = positions[(i + 1) % positions.length];
+    const pieces = createEdges(cursor, end, positions[i], i, index, turns[i], context);
+    if (edges.length && !same(cursor, pieces[0].a)) {
+      if (Math.abs(cursor[1]) !== 90 || cursor[1] !== pieces[0].a[1])
+        throw new GeographicSeamError("precision", "Discontinuous ring edge");
+      edges.push(straight(cursor, pieces[0].a));
+    }
+    for (const edge of pieces) {
+      if (edge.a[0] === edge.b[0] && edge.a[1] === edge.b[1]) {
+        if (!same(edge.a, edge.b))
+          throw new GeographicSeamError("topology", "Zero-length polygon edge changes attributes");
+      } else
+        edges.push(edge);
+    }
+    cursor = pieces[pieces.length - 1].b;
+  }
+  if (!edges.length)
+    throw new GeographicSeamError("topology", "Empty polygon boundary");
+  const first = edges[0].a;
+  if (Math.abs(first[1]) === 90) {
+    const closing = first.slice();
+    closing[0] += 360 * Math.round((cursor[0] - first[0]) / 360);
+    if (!same(cursor, closing))
+      edges.push(straight(cursor, closing));
+    cursor = closing;
+  }
+  const turnsAround = Math.round((cursor[0] - first[0]) / 360);
+  if (Math.abs(cursor[0] - first[0] - 360 * turnsAround) > ANGULAR_TOLERANCE || cursor[1] !== first[1] || Math.abs(turnsAround) > 1)
+    throw new GeographicSeamError("topology", "Unsupported ring winding");
+  let min = Infinity, max = -Infinity;
+  for (const e of edges) {
+    min = Math.min(min, e.a[0], e.b[0]);
+    max = Math.max(max, e.a[0], e.b[0]);
+  }
+  if (max - min > 360 + ANGULAR_TOLERANCE)
+    throw new GeographicSeamError("topology", "Ring exceeds a single longitude chart");
+  const membership = edges.slice();
+  const poleAttributes = input.poleAttributes ? Array.from(input.poleAttributes) : [];
+  if (turnsAround !== 0) {
+    if (!["north", "south"].includes(input.pole) || edges.some((e) => Math.abs(e.a[1]) === 90 || (e.b[0] - e.a[0]) * turnsAround < 0))
+      throw new GeographicSeamError("topology", "Polar rings require an explicit pole and monotone longitude winding");
+    if (poleAttributes.length !== context.size - 2 || !poleAttributes.every(Number.isFinite))
+      throw new GeographicSeamError("input", "Explicit poleAttributes are required for polar attributes");
+    const latitude = input.pole === "north" ? 90 : -90;
+    const a = [cursor[0], latitude, ...poleAttributes], b = [first[0], latitude, ...poleAttributes];
+    membership.push(straight(cursor, a), straight(a, b), straight(b, first));
+  } else if (input.pole !== void 0 || poleAttributes.length) {
+    throw new GeographicSeamError("input", "Pole selection applies only to once-winding polar rings");
+  }
+  return { edges, membership, min, max, pole: input.pole, poleAttributes };
+}
+function reverse(edge) {
+  return {
+    a: edge.b,
+    b: edge.a,
+    sample: (t) => edge.sample(1 - t),
+    source: edge.source && {
+      ...edge.source,
+      startFraction: edge.source.endFraction,
+      endFraction: edge.source.startFraction
+    }
+  };
+}
+function canonicalAlias(edge, context) {
+  const move = (p) => {
+    const longitude = context.canonicalLongitude(p[0]);
+    return longitude === p[0] ? p : [longitude, ...p.slice(1)];
+  };
+  return { ...edge, a: move(edge.a), b: move(edge.b), sample: (t) => move(edge.sample(t)) };
+}
+function interior(edges, context) {
+  const ys = Array.from(new Set(edges.flatMap((e) => [e.a[1], e.b[1]]))).sort((a, b) => a - b);
+  let index = 1;
+  for (let i = 2; i < ys.length; i++)
+    if (ys[i] - ys[i - 1] > ys[index] - ys[index - 1])
+      index = i;
+  if (ys.length < 2 || ys[index] - ys[index - 1] < 8 * ANGULAR_TOLERANCE)
+    throw new GeographicSeamError("precision", "Polygon height below the topology budget");
+  const y = (ys[index] + ys[index - 1]) / 2, xs = [];
+  for (const edge of edges) {
+    context.tick();
+    if (edge.a[1] > y !== edge.b[1] > y)
+      xs.push(edge.sample(root(edge, 1, y, context))[0]);
+  }
+  xs.sort((a, b) => a - b);
+  for (let i = 1; i < xs.length; i++) {
+    context.tick();
+    if (xs[i] - xs[i - 1] < 8 * ANGULAR_TOLERANCE)
+      continue;
+    const point = [(xs[i] + xs[i - 1]) / 2, y], w = winding(edges, point, context);
+    if (w.value && !w.boundary) {
+      if (Math.abs(w.value) !== 1)
+        throw new GeographicSeamError("topology", "Non-simple polygon winding");
+      return { point, sign: Math.sign(w.value) };
+    }
+  }
+  throw new GeographicSeamError("topology", "No resolvable polygon interior");
+}
+function output(edges, sign, context) {
+  if (interior(edges, context).sign !== sign)
+    edges = edges.slice().reverse().map(reverse);
+  context.addVertices(edges.length + 1);
+  return {
+    positions: new Float64Array([...edges.flatMap((e) => e.a), ...edges[0].a]),
+    edges: edges.map((e) => e.source && { ...e.source })
+  };
+}
+function splitGeographicPolygon(inputs, options) {
+  const context = new Context(options);
+  if (!inputs.length)
+    return [];
+  context.tick(inputs.length);
+  const rings = inputs.map((ring, i) => prepare(ring, i, context));
+  const graph = [], nodes = /* @__PURE__ */ new Map();
+  const key = (p) => `${p[0]},${p[1]}`;
+  const add = (edge) => {
+    context.tick();
+    if (edge.a[0] === edge.b[0] && edge.a[1] === edge.b[1])
+      return;
+    const id = graph.length;
+    graph.push(edge);
+    for (const p of [edge.a, edge.b]) {
+      const k = key(p), node = nodes.get(k);
+      if (node) {
+        if (!same(node.p, p))
+          throw new GeographicSeamError("topology", "Touching boundaries have inconsistent attributes");
+        node.edges.push(id);
+      } else
+        nodes.set(k, { p, edges: [id] });
+    }
+  };
+  const pieces = [];
+  const meridians = /* @__PURE__ */ new Map();
+  for (const ring of rings) {
+    if (ring.max - ring.min === 360) {
+      const low = chartPoint([ring.min, 0], worldAt(ring.min, context), context)[0];
+      const high = chartPoint([ring.max, 0], worldAt(ring.max, context), context)[0];
+      const roundoff = 4 * Number.EPSILON * Math.max(360, Math.abs(ring.min), Math.abs(ring.max), Math.abs(context.left), Math.abs(context.right));
+      if (Math.abs(high - low) > Math.min(roundoff, ANGULAR_TOLERANCE))
+        throw new GeographicSeamError("precision", "Unresolvable full-width longitude alias");
+      if (high === context.left)
+        context.aliasLongitude(low, high);
+      else
+        context.aliasLongitude(high, low);
+    }
+  }
+  for (const ring of rings) {
+    for (const original of ring.edges)
+      for (const { edge: part } of cut(original, context)) {
+        const edge = canonicalAlias(part, context);
+        pieces.push(edge);
+        if (edge.a[0] === edge.b[0]) {
+          const events = meridians.get(edge.a[0]) || /* @__PURE__ */ new Set();
+          events.add(edge.a[1]);
+          events.add(edge.b[1]);
+          meridians.set(edge.a[0], events);
+        }
+      }
+  }
+  for (const edge of pieces) {
+    if (edge.a[0] !== edge.b[0]) {
+      add(edge);
+      continue;
+    }
+    const fractions = [0, 1];
+    const latitudes = /* @__PURE__ */ new Map();
+    for (const y of meridians.get(edge.a[0])) {
+      context.tick();
+      if (y > Math.min(edge.a[1], edge.b[1]) && y < Math.max(edge.a[1], edge.b[1])) {
+        const fraction = root(edge, 1, y, context);
+        if (latitudes.has(fraction) && latitudes.get(fraction) !== y)
+          throw new GeographicSeamError("precision", "Unresolvable meridian event separation");
+        fractions.push(fraction);
+        latitudes.set(fraction, y);
+      }
+    }
+    fractions.sort((a, b) => a - b);
+    for (let i = 1; i < fractions.length; i++) {
+      context.tick();
+      const piece = slice(edge, fractions[i - 1], fractions[i]);
+      if (latitudes.has(fractions[i - 1]))
+        piece.a[1] = latitudes.get(fractions[i - 1]);
+      if (latitudes.has(fractions[i]))
+        piece.b[1] = latitudes.get(fractions[i]);
+      if (fractions.length > 2)
+        context.addVertices(2);
+      const x = piece.a[0], latitude = (piece.a[1] + piece.b[1]) / 2;
+      const seam = x === context.left;
+      const ring = piece.source && rings[piece.source.ringIndex];
+      if (ring && ring.max - ring.min >= 360 - ANGULAR_TOLERANCE && contains(ring, [x, latitude], context, seam ? "right" : "left") && contains(ring, [seam ? context.right : x, latitude], context, seam ? "left" : "right"))
+        continue;
+      const left = filled(rings, [x, latitude], context, seam ? "right" : "left");
+      const right = filled(rings, [seam ? context.right : x, latitude], context, seam ? "left" : "right");
+      if (left && right)
+        continue;
+      if (!left && !right)
+        throw new GeographicSeamError("topology", "Unresolvable meridian-coincident boundary");
+      if (seam && !left) {
+        const assigned = shift(piece, 360), sample = assigned.sample;
+        assigned.a[0] = assigned.b[0] = context.right;
+        assigned.sample = (t) => {
+          const p = sample(t);
+          p[0] = context.right;
+          return p;
+        };
+        add(assigned);
+      } else
+        add(piece);
+    }
+  }
+  const pole = rings[0].pole;
+  if (pole && !rings.slice(1).some((r) => r.pole === pole)) {
+    const latitude = pole === "north" ? 90 : -90;
+    add(straight([context.left, latitude, ...rings[0].poleAttributes], [context.right, latitude, ...rings[0].poleAttributes]));
+  }
+  for (const boundary of [context.left, context.right]) {
+    const boundaryNodes = Array.from(nodes.values()).filter((n) => n.p[0] === boundary).sort((a, b) => a.p[1] - b.p[1]);
+    const aligned = graph.filter((e) => e.a[0] === boundary && e.b[0] === boundary);
+    for (let i = 1; i < boundaryNodes.length; i++) {
+      context.tick();
+      const a = boundaryNodes[i - 1].p, b = boundaryNodes[i].p, latitude = (a[1] + b[1]) / 2;
+      if (latitude === a[1] || latitude === b[1])
+        throw new GeographicSeamError("precision", "Unresolvable seam event separation");
+      if (filled(rings, [boundary, latitude], context, boundary === context.left ? "right" : "left") && !aligned.some((e) => {
+        context.tick();
+        return latitude > Math.min(e.a[1], e.b[1]) && latitude < Math.max(e.a[1], e.b[1]);
+      }))
+        add(straight(a, b));
+    }
+  }
+  for (const node of nodes.values())
+    if (node.edges.length !== 2)
+      throw new GeographicSeamError("topology", "Touching, coincident or unresolved polygon boundaries");
+  const used = /* @__PURE__ */ new Set(), cycles = [];
+  for (let seed = 0; seed < graph.length; seed++) {
+    if (used.has(seed))
+      continue;
+    const cycle = [], start = key(graph[seed].a);
+    let id = seed, current = start;
+    do {
+      context.tick();
+      if (used.has(id))
+        throw new GeographicSeamError("topology", "Non-simple boundary graph");
+      used.add(id);
+      const edge = key(graph[id].a) === current ? graph[id] : reverse(graph[id]);
+      cycle.push(edge);
+      current = key(edge.b);
+      const adjacent = nodes.get(current).edges;
+      id = adjacent[0] === id ? adjacent[1] : adjacent[0];
+    } while (current !== start);
+    if (cycle.length < 3)
+      throw new GeographicSeamError("topology", "Degenerate polygon component");
+    cycles.push(cycle);
+  }
+  const parents = cycles.map((cycle, i) => {
+    const containers = [];
+    for (let j = 0; j < cycles.length; j++)
+      if (j !== i) {
+        const w = winding(cycles[j], cycle[0].a, context);
+        if (w.boundary)
+          throw new GeographicSeamError("topology", "Polygon components touch");
+        if (w.value)
+          containers.push(j);
+      }
+    if (containers.length > 1)
+      throw new GeographicSeamError("topology", "Nested holes or overlapping polygon components");
+    return containers[0];
+  });
+  const sign = interior(rings[0].membership, context).sign;
+  const result = [], groups = /* @__PURE__ */ new Map();
+  for (let i = 0; i < cycles.length; i++)
+    if (parents[i] === void 0) {
+      if (cycles[i].every((e) => e.source && e.source.ringIndex !== 0))
+        throw new GeographicSeamError("topology", "Hole is outside the outer ring");
+      const polygon = { rings: [output(cycles[i], sign, context)] };
+      result.push(polygon);
+      groups.set(i, polygon);
+    }
+  for (let i = 0; i < cycles.length; i++)
+    if (parents[i] !== void 0) {
+      const group = groups.get(parents[i]);
+      if (!group)
+        throw new GeographicSeamError("topology", "Nested polygon rings");
+      group.rings.push(output(cycles[i], -sign, context));
+    }
+  return result;
+}
+
+// dist/geographic-seams.js
+function splitGeographicPolyline(input, options) {
+  const context = new Context(options), points = context.read(input);
+  const turns = options.longitudeTurns ? Array.from(options.longitudeTurns) : new Array(Math.max(0, points.length - 1)).fill(0);
+  if (turns.length !== Math.max(0, points.length - 1))
+    throw new GeographicSeamError("input", "Expected one turn count per line edge");
+  if (!points.length)
+    return [];
+  if (points.length === 1) {
+    context.addVertices(1);
+    const world = worldAt(points[0][0], context), p = chartPoint(points[0], world, context);
+    return [{ positions: new Float64Array(p), edges: [], world }];
+  }
+  const parts = [];
+  let cursor = points[0];
+  for (let i = 1; i < points.length; i++) {
+    const edges = createEdges(cursor, points[i], points[i - 1], i - 1, 0, turns[i - 1], context, false);
+    for (const original of edges) {
+      if (!original.source)
+        continue;
+      for (const { edge, world } of cut(original, context)) {
+        const previous = parts[parts.length - 1];
+        if (previous && previous.world === world && same(previous.points[previous.points.length - 1], edge.a)) {
+          previous.points.push(edge.b);
+          previous.edges.push(edge.source);
+        } else
+          parts.push({ points: [edge.a, edge.b], edges: [edge.source], world });
+      }
+    }
+    cursor = edges[edges.length - 1].b;
+  }
+  return parts.map((part) => ({
+    positions: new Float64Array(part.points.flat()),
+    edges: part.edges,
+    world: part.world
+  }));
+}
+//# sourceMappingURL=globe.cjs.map