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

package/dist/entries/ellipsoid.cjs

@@ -0,0 +1,3910 @@
+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/entries/ellipsoid.js
+var ellipsoid_exports = {};
+__export(ellipsoid_exports, {
+  Ellipsoid: () => Ellipsoid,
+  EllipsoidGeodesic: () => EllipsoidGeodesic,
+  EllipsoidMetrics: () => EllipsoidMetrics,
+  EllipsoidRhumb: () => EllipsoidRhumb,
+  EllipsoidTangentPlane: () => EllipsoidTangentPlane,
+  GeodesicIntersections: () => GeodesicIntersections,
+  GeodesicPath: () => GeodesicPath,
+  GeodesicPolygon: () => GeodesicPolygon,
+  LocalReferenceFrame: () => LocalReferenceFrame,
+  RhumbDomainError: () => RhumbDomainError,
+  RhumbPath: () => RhumbPath,
+  RhumbPolygon: () => RhumbPolygon,
+  eastNorthUpToFixedFrame: () => eastNorthUpToFixedFrame,
+  isWGS84: () => isWGS84,
+  localFrameToFixedFrame: () => localFrameToFixedFrame2
+});
+module.exports = __toCommonJS(ellipsoid_exports);
+
+// dist/ellipsoid.js
+var import_core3 = 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_core = require("@math.gl/core");
+function identity(x) {
+  return x;
+}
+var scratchVector = new import_core.Vector3();
+function fromCartographic(cartographic, result = [], map = identity) {
+  if ("longitude" in cartographic) {
+    result[0] = map(cartographic.longitude);
+    result[1] = map(cartographic.latitude);
+    result[2] = cartographic.height;
+  } else if ("x" in cartographic) {
+    result[0] = map(cartographic.x);
+    result[1] = map(cartographic.y);
+    result[2] = cartographic.z;
+  } else {
+    result[0] = map(cartographic[0]);
+    result[1] = map(cartographic[1]);
+    result[2] = cartographic[2];
+  }
+  return result;
+}
+function fromCartographicToRadians(cartographic, vector = []) {
+  return fromCartographic(cartographic, vector, import_core.config._cartographicRadians ? identity : import_core.toRadians);
+}
+function toCartographicFromRadiansComponents(longitude, latitude, height, cartographic) {
+  const map = import_core.config._cartographicRadians ? identity : import_core.toDegrees;
+  const mappedLongitude = map(longitude), mappedLatitude = map(latitude);
+  if ("longitude" in cartographic) {
+    cartographic.longitude = mappedLongitude;
+    cartographic.latitude = mappedLatitude;
+    cartographic.height = height;
+  } else if ("x" in cartographic) {
+    cartographic.x = mappedLongitude;
+    cartographic.y = mappedLatitude;
+    cartographic.z = height;
+  } else {
+    cartographic[0] = mappedLongitude;
+    cartographic[1] = mappedLatitude;
+    cartographic[2] = height;
+  }
+  return cartographic;
+}
+function isWGS84(vector) {
+  if (!vector) {
+    return false;
+  }
+  scratchVector.from(vector);
+  const { oneOverRadiiSquared, centerToleranceSquared } = WGS84_CONSTANTS;
+  const x2 = vector[0] * vector[0] * oneOverRadiiSquared[0];
+  const y2 = vector[1] * vector[1] * oneOverRadiiSquared[1];
+  const z2 = vector[2] * vector[2] * oneOverRadiiSquared[2];
+  return Math.abs(x2 + y2 + z2 - 1) < centerToleranceSquared;
+}
+
+// dist/ellipsoid-helpers/scale-to-geodetic-surface.js
+var import_core2 = 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 dot2 = bits.indexOf(".");
+    return {
+      integer: BigInt("0b" + bits.replace(".", "")),
+      exponent: dot2 < 0 ? 0 : dot2 + 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 output = squares.map((r2, i) => {
+      const denominator = offsets[i] * unit2 + t;
+      return denominator === 0n ? 0 : ratio(r2 * integers[i + 3] * unit2, denominator, exponent);
+    });
+    if (!output.every(Number.isFinite))
+      return false;
+    const qx = Math.sign(x) * output[0], qy = Math.sign(y) * output[1], qz = Math.sign(z) * output[2];
+    result.x = qx;
+    result.y = qy;
+    result.z = qz;
+    return true;
+  }
+}
+function ratio(n, d, exponent) {
+  if (n === 0n)
+    return 0;
+  const shift = 52 - (n.toString(2).length - d.toString(2).length);
+  const numerator = shift >= 0 ? n << BigInt(shift) : n;
+  const denominator = shift >= 0 ? d : d << BigInt(-shift);
+  let quotient = numerator / denominator;
+  const remainder = numerator % denominator;
+  if (2n * remainder > denominator || 2n * remainder === denominator && quotient & 1n)
+    quotient++;
+  const power = exponent - shift;
+  const first = Math.max(-1022, Math.min(1023, power));
+  return Number(quotient) * 2 ** first * 2 ** (power - first);
+}
+
+// dist/ellipsoid-helpers/nearest-surface.js
+function nearestSurface(x, y, z, a, b, c, result) {
+  const minimum = Math.min(a, b, c);
+  const minimumSquared = minimum * minimum;
+  const aa = a * a, bb = b * b, cc = c * c;
+  if (!(minimum > 0) || !(minimumSquared > 0) || !Number.isFinite(Math.max(aa, bb, cc)))
+    return false;
+  const minimumError = productError(minimum, minimum, minimumSquared);
+  const dx = aa - minimumSquared, dy = bb - minimumSquared, dz = cc - minimumSquared;
+  const ex = sumError(aa, -minimumSquared, dx) + productError(a, a, aa) - minimumError;
+  const ey = sumError(bb, -minimumSquared, dy) + productError(b, b, bb) - minimumError;
+  const ez = sumError(cc, -minimumSquared, dz) + productError(c, c, cc) - minimumError;
+  const ux = a * Math.abs(x), uy = b * Math.abs(y), uz = c * Math.abs(z);
+  if (minimumSquared < 2 ** -1022 || x !== 0 && ux < 2 ** -1022 || y !== 0 && uy < 2 ** -1022 || z !== 0 && uz < 2 ** -1022)
+    return exactNearestSurface(x, y, z, a, b, c, result);
+  const fx = productError(a, Math.abs(x), ux);
+  const fy = productError(b, Math.abs(y), uy);
+  const fz = productError(c, Math.abs(z), uz);
+  const limit = Math.hypot(dx === 0 ? ux === 0 ? 0 : Infinity : ux / (dx + ex), dy === 0 ? uy === 0 ? 0 : Infinity : uy / (dy + ey), dz === 0 ? uz === 0 ? 0 : Infinity : uz / (dz + ez));
+  if (limit <= 1 + 64 * Number.EPSILON)
+    return exactNearestSurface(x, y, z, a, b, c, result);
+  if ((x !== 0 ? 1 : 0) + (y !== 0 ? 1 : 0) + (z !== 0 ? 1 : 0) === 1) {
+    result.x = x === 0 ? x : Math.sign(x) * a;
+    result.y = y === 0 ? y : Math.sign(y) * b;
+    result.z = z === 0 ? z : Math.sign(z) * c;
+    return true;
+  }
+  let lower = Math.hypot(dx === 0 ? ux : 0, dy === 0 ? uy : 0, dz === 0 ? uz : 0);
+  let upper = Math.hypot(ux, uy, uz);
+  if (!(upper > 0) || !Number.isFinite(upper))
+    return exactNearestSurface(x, y, z, a, b, c, result);
+  let t = lower > 0 ? lower : upper;
+  for (let iteration = 0; iteration < 512; iteration++) {
+    const hx = dx + t, hy = dy + t, hz = dz + t;
+    const lx = sumError(dx, t, hx) + ex;
+    const ly = sumError(dy, t, hy) + ey;
+    const lz = sumError(dz, t, hz) + ez;
+    const vx = ux / hx, vy = uy / hy, vz = uz / hz;
+    let term, rest;
+    if (vx >= vy && vx >= vz) {
+      term = offset(ux, fx, dx, ex, t, hx) * (vx + 1);
+      rest = (vy * (1 - ly / hy)) ** 2 + (vz * (1 - lz / hz)) ** 2;
+    } else if (vy >= vz) {
+      term = offset(uy, fy, dy, ey, t, hy) * (vy + 1);
+      rest = (vx * (1 - lx / hx)) ** 2 + (vz * (1 - lz / hz)) ** 2;
+    } else {
+      term = offset(uz, fz, dz, ez, t, hz) * (vz + 1);
+      rest = (vx * (1 - lx / hx)) ** 2 + (vy * (1 - ly / hy)) ** 2;
+    }
+    const derivative = -2 * (vx * vx / hx + vy * vy / hy + vz * vz / hz);
+    const roundoff = 4 * Number.EPSILON * (Math.abs(term) + rest);
+    const residual = term + rest;
+    if (!Number.isFinite(residual))
+      return exactNearestSurface(x, y, z, a, b, c, result);
+    if (Math.abs(residual) <= 4 * Number.EPSILON * (Math.abs(term) + rest) || upper - lower <= 4 * Number.EPSILON * t) {
+      const uncertainty = roundoff / Math.abs(derivative);
+      if (!Number.isFinite(derivative) || !(Math.abs(derivative) > 0) || uncertainty > 2e-13 * t)
+        return exactNearestSurface(x, y, z, a, b, c, result);
+      const qx = Math.sign(x) * a * (vx * (1 - lx / hx));
+      const qy = Math.sign(y) * b * (vy * (1 - ly / hy));
+      const qz = Math.sign(z) * c * (vz * (1 - lz / hz));
+      const displacement = 2 * uncertainty * Math.max(Math.abs(qx / hx), Math.abs(qy / hy), Math.abs(qz / hz));
+      if (!Number.isFinite(displacement) || displacement > 2e-13 * Math.max(a, b, c))
+        return exactNearestSurface(x, y, z, a, b, c, result);
+      if (!Number.isFinite(qx) || !Number.isFinite(qy) || !Number.isFinite(qz))
+        return exactNearestSurface(x, y, z, a, b, c, result);
+      result.x = qx;
+      result.y = qy;
+      result.z = qz;
+      return true;
+    }
+    if (residual > 0)
+      lower = t;
+    else
+      upper = t;
+    const candidate = t - residual / derivative;
+    const next = candidate > lower && candidate < upper ? candidate : lower + (upper - lower) / 2;
+    if (next === t)
+      return exactNearestSurface(x, y, z, a, b, c, result);
+    t = next;
+  }
+  return exactNearestSurface(x, y, z, a, b, c, result);
+}
+function offset(u, error, d, dError, t, denominator) {
+  const difference = u - d;
+  const correction = sumError(u, -d, difference) + error - dError;
+  const base = difference + correction;
+  const low = sumError(difference, correction, base);
+  const shifted = base - t;
+  return (shifted + (sumError(base, -t, shifted) + low)) / denominator;
+}
+function sumError(x, y, sum) {
+  const part = sum - x;
+  return x - (sum - part) + (y - part);
+}
+function productError(x, y, product) {
+  const sx = 134217729 * x, sy = 134217729 * y;
+  if (!Number.isFinite(sx) || !Number.isFinite(sy))
+    return 0;
+  const hx = sx - (sx - x), hy = sy - (sy - y);
+  const lx = x - hx, ly = y - hy;
+  return hx * hy - product + hx * ly + lx * hy + lx * ly;
+}
+
+// dist/ellipsoid-helpers/scale-to-geodetic-surface.js
+var surface = { x: 0, y: 0, z: 0 };
+function scaleToGeodeticSurface(cartesian, ellipsoid, result = []) {
+  const object = cartesian;
+  const x = "x" in cartesian ? object.x : cartesian[0];
+  const y = "x" in cartesian ? object.y : cartesian[1];
+  const z = "x" in cartesian ? object.z : cartesian[2];
+  if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z))
+    return void 0;
+  if (!Number.isFinite(x * x + y * y + z * z))
+    return void 0;
+  const { radii } = ellipsoid;
+  if (!nearestSurface(x, y, z, radii.x, radii.y, radii.z, surface))
+    return void 0;
+  return writeResult(result, surface.x, surface.y, surface.z);
+}
+function writeResult(result, x, y, z) {
+  if ((0, import_core2.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_core3.Vector3();
+var scratchNormal = new import_core3.Vector3();
+var scratchPosition = new import_core3.Vector3();
+var scratchCartesian = new import_core3.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_core3._MathUtils.EPSILON1;
+    (0, import_core3.assert)(Number.isFinite(x) && x >= 0);
+    (0, import_core3.assert)(Number.isFinite(y) && y >= 0);
+    (0, import_core3.assert)(Number.isFinite(z) && z >= 0);
+    this.radii = new import_core3.Vector3(x, y, z);
+    this.radiiSquared = new import_core3.Vector3(x * x, y * y, z * z);
+    this.radiiToTheFourth = new import_core3.Vector3(x * x * x * x, y * y * y * y, z * z * z * z);
+    this.oneOverRadii = new import_core3.Vector3(x === 0 ? 0 : 1 / x, y === 0 ? 0 : 1 / y, z === 0 ? 0 : 1 / z);
+    this.oneOverRadiiSquared = new import_core3.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_core3.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_core3.config._cartographicRadians ? point[0] : point[0] * Math.PI / 180;
+    const latitude = import_core3.config._cartographicRadians ? point[1] : point[1] * Math.PI / 180;
+    const polarDegrees = !import_core3.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_core3.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_core4 = 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 dot2 = (x, y) => x.reduce((s, v2, i) => s + v2 * y[i], 0n);
+  const a = dot2(n, n), b = dot2(n, p), c = dot2(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 root = value === 0n ? 0n : 1n << BigInt(Math.ceil(value.toString(2).length / 2));
+  if (root)
+    for (; ; ) {
+      const next = root + value / root >> 1n;
+      if (next >= root)
+        break;
+      root = next;
+    }
+  const output = p.map((x, i) => signedRatio(x * a * q + n[i] * (root - b * q), a * q * factors[i]));
+  return sphereRadius ? output.map((_, i) => east[i] * output[1] + north[i] * output[2] + normal[i] * output[0]) : output;
+}
+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_core4.Vector3());
+    if (!originOnSurface)
+      throw new RangeError("Origin has no unique ellipsoid surface point");
+    this.anchor = new import_core4.Vector3(originOnSurface);
+    const normal = new import_core4.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_core4.Vector3(-normal[1] / horizontal, normal[0] / horizontal, 0) : new import_core4.Vector3(0, 1, 0);
+    this.north = new import_core4.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_core4.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_core4.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_core4.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 root = Math.sqrt(Math.max(0, discriminant));
+    const t = b > 0 ? -c / (b + root) : (-b + root) / 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", output) {
+    checkMode(mode);
+    if (input.length % 3)
+      throw new RangeError("Expected packed XYZ coordinates");
+    const count = input.length / 3;
+    const positions = output || 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_core4.Vector3();
+    const projected = new import_core4.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/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/local-reference-frame.js
+var import_core5 = require("@math.gl/core");
+var import_local_frame = require("@math.gl/core/local-frame");
+var LocalReferenceFrame = class {
+  constructor(origin, options = {}) {
+    finiteCoordinate(origin);
+    const ellipsoid = options.ellipsoid || Ellipsoid.WGS84;
+    const { x: a, y, z: b } = ellipsoid.radii;
+    if (!(a > 0 && a === y && b > 0 && b <= a && Number.isFinite(a))) {
+      throw new RangeError("LocalReferenceFrame requires a positive sphere or oblate spheroid");
+    }
+    const llh = ellipsoid.cartesianToCartographic(origin);
+    if (!llh)
+      throw new RangeError("Origin has no unique geodetic frame");
+    const basis = (0, import_local_frame.createLocalFrameBasis)();
+    const radians = import_core5.config._cartographicRadians ? 1 : Math.PI / 180;
+    if (!(0, import_local_frame.eastNorthUpBasis)(llh[0] * radians, llh[1] * radians, basis))
+      throw new RangeError("Cannot resolve local geodetic basis");
+    const axes = options.axes || ["east", "north", "up"];
+    const matrix = [];
+    if (!(0, import_local_frame.localFrameToMatrix)(basis, { x: origin[0], y: origin[1], z: origin[2] }, ...axes, matrix)) {
+      throw new RangeError("Expected three right-handed geographic axes");
+    }
+    this.matrix = Object.freeze(matrix);
+    this.up = Object.freeze([basis.upX, basis.upY, basis.upZ]);
+  }
+  /** Independent copies: callers cannot mutate the cached frame. */
+  get localToFixedMatrix() {
+    return new import_core5.Matrix4(this.matrix);
+  }
+  get fixedToLocalMatrix() {
+    return new import_core5.Matrix4(this.matrix).invert();
+  }
+  localToFixedPoint(point, result = new import_core5.Vector3()) {
+    return this.transform(point, result, false, true);
+  }
+  fixedToLocalPoint(point, result = new import_core5.Vector3()) {
+    return this.transform(point, result, true, true);
+  }
+  localToFixedVector(vector, result = new import_core5.Vector3()) {
+    return this.transform(vector, result, false, false);
+  }
+  fixedToLocalVector(vector, result = new import_core5.Vector3()) {
+    return this.transform(vector, result, true, false);
+  }
+  /** Packed XYZ points. Exact in-place operation is supported; other overlap is rejected.
+   * All validation and representability checks finish before writing caller storage.
+   */
+  localToFixedPointsFlat(input, result) {
+    return this.transformFlat(input, result, false, true);
+  }
+  fixedToLocalPointsFlat(input, result) {
+    return this.transformFlat(input, result, true, true);
+  }
+  localToFixedVectorsFlat(input, result) {
+    return this.transformFlat(input, result, false, false);
+  }
+  fixedToLocalVectorsFlat(input, result) {
+    return this.transformFlat(input, result, true, false);
+  }
+  /** Model-to-fixed affine pose, with unit scale. Angles are radians. */
+  headingPitchRollToFixedFrame(attitude, result = new import_core5.Matrix4()) {
+    const { heading, pitch, roll } = attitude;
+    if (![heading, pitch, roll].every(Number.isFinite))
+      throw new RangeError("Nonfinite attitude");
+    return result.copy(this.matrix).rotateZ(-heading).rotateY(-pitch).rotateX(roll);
+  }
+  headingPitchRollQuaternion(attitude, result = new import_core5.Quaternion()) {
+    const m = this.headingPitchRollToFixedFrame(attitude);
+    return result.fromMatrix3([m[0], m[1], m[2], m[4], m[5], m[6], m[8], m[9], m[10]]).normalize();
+  }
+  /** Extract attitude from a rigid model-to-fixed pose. Translation is ignored.
+   * Pitch is canonicalized to [-pi/2, pi/2]. At gimbal lock, roll is zero.
+   */
+  fixedFrameToHeadingPitchRoll(pose) {
+    validateRigidPose(pose);
+    const local = new import_core5.Matrix4();
+    const m = this.matrix;
+    for (let column = 0; column < 3; column++) {
+      for (let row = 0; row < 3; row++) {
+        local[column * 4 + row] = m[row * 4] * pose[column * 4] + m[row * 4 + 1] * pose[column * 4 + 1] + m[row * 4 + 2] * pose[column * 4 + 2];
+      }
+    }
+    const pitchY = Math.atan2(-local[2], Math.hypot(local[0], local[1]));
+    const locked = Math.hypot(local[0], local[1]) < 1e-12;
+    const roll = locked ? 0 : Math.atan2(local[6], local[10]);
+    const yaw = locked ? Math.atan2(-local[4], local[5]) : Math.atan2(local[1], local[0]);
+    return { heading: -yaw, pitch: -pitchY, roll };
+  }
+  /** Fixed-space velocity defines model +X. +Z is as close as possible to geodetic up.
+   * Returns undefined without writing result for zero or nearly vertical velocity.
+   * Stateless: callers own temporal continuity across these singularities.
+   */
+  velocityQuaternion(velocity, result = new import_core5.Quaternion()) {
+    finiteCoordinate(velocity);
+    const scale = Math.max(Math.abs(velocity[0]), Math.abs(velocity[1]), Math.abs(velocity[2]));
+    if (scale === 0)
+      return void 0;
+    const x = new import_core5.Vector3(velocity[0] / scale, velocity[1] / scale, velocity[2] / scale);
+    x.scale(1 / Math.hypot(x[0], x[1], x[2]));
+    const y = new import_core5.Vector3(this.up).cross(x);
+    if (y.len() < 1e-12)
+      return void 0;
+    y.normalize();
+    const z = new import_core5.Vector3(x).cross(y).normalize();
+    return result.fromMatrix3([...x, ...y, ...z]).normalize();
+  }
+  transformFlat(input, result, inverse, position) {
+    if (!Number.isSafeInteger(input.length) || input.length % 3 || result && (!(result instanceof Float64Array) || result.length !== input.length))
+      throw new RangeError("Expected packed XYZ and matching Float64 output");
+    if (result && input !== result && ArrayBuffer.isView(input) && input.buffer === result.buffer && input.byteOffset < result.byteOffset + result.byteLength && result.byteOffset < input.byteOffset + input.byteLength)
+      throw new RangeError("Packed frame buffers overlap");
+    let bounded = !position || Math.max(Math.abs(this.matrix[12]), Math.abs(this.matrix[13]), Math.abs(this.matrix[14])) <= Number.MAX_VALUE / 8;
+    for (let i = 0; i < input.length; i++) {
+      if (!Number.isFinite(input[i]))
+        throw new RangeError("Expected finite packed coordinates");
+      bounded && (bounded = Math.abs(input[i]) <= Number.MAX_VALUE / 8);
+    }
+    const scratch = bounded ? void 0 : new import_core5.Vector3();
+    if (scratch)
+      for (let i = 0; i < input.length; i += 3)
+        this.transform(scratch.set(input[i], input[i + 1], input[i + 2]), scratch, inverse, position);
+    const output = result || new Float64Array(input.length), [xx, xy, xz, , yx, yy, yz, , zx, zy, zz, , ox, oy, oz] = this.matrix;
+    for (let i = 0; i < input.length; i += 3) {
+      const x = input[i] - (inverse && position ? ox : 0), y = input[i + 1] - (inverse && position ? oy : 0), z = input[i + 2] - (inverse && position ? oz : 0);
+      if (scratch) {
+        this.transform(scratch.set(input[i], input[i + 1], input[i + 2]), scratch, inverse, position);
+        output.set(scratch, i);
+      } else {
+        output[i] = inverse ? xx * x + xy * y + xz * z : xx * x + yx * y + zx * z + (position ? ox : 0);
+        output[i + 1] = inverse ? yx * x + yy * y + yz * z : xy * x + yy * y + zy * z + (position ? oy : 0);
+        output[i + 2] = inverse ? zx * x + zy * y + zz * z : xz * x + yz * y + zz * z + (position ? oz : 0);
+      }
+    }
+    return output;
+  }
+  transform(point, result, inverse, position) {
+    finiteCoordinate(point);
+    const m = this.matrix;
+    const x = point[0] - (inverse && position ? m[12] : 0);
+    const y = point[1] - (inverse && position ? m[13] : 0);
+    const z = point[2] - (inverse && position ? m[14] : 0);
+    let ox = inverse ? m[0] * x + m[1] * y + m[2] * z : m[0] * x + m[4] * y + m[8] * z + (position ? m[12] : 0);
+    let oy = inverse ? m[4] * x + m[5] * y + m[6] * z : m[1] * x + m[5] * y + m[9] * z + (position ? m[13] : 0);
+    let oz = inverse ? m[8] * x + m[9] * y + m[10] * z : m[2] * x + m[6] * y + m[10] * z + (position ? m[14] : 0);
+    if (!Number.isFinite(ox) || !Number.isFinite(oy) || !Number.isFinite(oz)) {
+      const scale = Math.max(Math.abs(point[0]), Math.abs(point[1]), Math.abs(point[2]), position ? Math.abs(m[12]) : 0, position ? Math.abs(m[13]) : 0, position ? Math.abs(m[14]) : 0);
+      const sx = point[0] / scale - (inverse && position ? m[12] / scale : 0);
+      const sy = point[1] / scale - (inverse && position ? m[13] / scale : 0);
+      const sz = point[2] / scale - (inverse && position ? m[14] / scale : 0);
+      ox = (inverse ? m[0] * sx + m[1] * sy + m[2] * sz : m[0] * sx + m[4] * sy + m[8] * sz + (position ? m[12] / scale : 0)) * scale;
+      oy = (inverse ? m[4] * sx + m[5] * sy + m[6] * sz : m[1] * sx + m[5] * sy + m[9] * sz + (position ? m[13] / scale : 0)) * scale;
+      oz = (inverse ? m[8] * sx + m[9] * sy + m[10] * sz : m[2] * sx + m[6] * sy + m[10] * sz + (position ? m[14] / scale : 0)) * scale;
+    }
+    if (!Number.isFinite(ox) || !Number.isFinite(oy) || !Number.isFinite(oz))
+      throw new RangeError("Frame transformation overflow");
+    return result.set(ox, oy, oz);
+  }
+};
+function finiteCoordinate(point) {
+  if (point.length !== 3 || !Number.isFinite(point[0]) || !Number.isFinite(point[1]) || !Number.isFinite(point[2])) {
+    throw new RangeError("Expected three finite coordinates");
+  }
+}
+function validateRigidPose(pose) {
+  if (pose.length !== 16 || !Array.from(pose).every(Number.isFinite) || pose[3] !== 0 || pose[7] !== 0 || pose[11] !== 0 || pose[15] !== 1) {
+    throw new RangeError("Expected a finite affine pose");
+  }
+  const x = new import_core5.Vector3(pose[0], pose[1], pose[2]);
+  const y = new import_core5.Vector3(pose[4], pose[5], pose[6]);
+  const z = new import_core5.Vector3(pose[8], pose[9], pose[10]);
+  for (const axis of [x, y, z]) {
+    if (Math.abs(Math.hypot(axis[0], axis[1], axis[2]) - 1) > 1e-6) {
+      throw new RangeError("Pose rotation must be orthonormal and right-handed");
+    }
+  }
+  const errors = [
+    Math.abs(x.len() - 1),
+    Math.abs(y.len() - 1),
+    Math.abs(z.len() - 1),
+    Math.abs(x.dot(y)),
+    Math.abs(x.dot(z)),
+    Math.abs(y.dot(z)),
+    Math.abs(new import_core5.Vector3(x).cross(y).dot(z) - 1)
+  ];
+  if (!errors.every(Number.isFinite) || Math.max(...errors) > 1e-6) {
+    throw new RangeError("Pose rotation must be orthonormal and right-handed");
+  }
+}
+
+// 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(degrees) {
+  const a = Math.abs(degrees);
+  if (a <= 45)
+    return [Math.sin(degrees * DEG), Math.cos(degrees * DEG)];
+  return [Math.sign(degrees) * 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-helpers/surface-polygon.js
+var Accumulator = geodesic.Accumulator.Accumulator;
+var math = geodesic.Math;
+var SurfacePolygon = class {
+  constructor(solver, options = {}) {
+    this.count = 0;
+    this.firstLat = 0;
+    this.firstLon = 0;
+    this.lastLat = 0;
+    this.lastLon = 0;
+    this.crossings = 0;
+    this.perimeter = new Accumulator();
+    this.area = new Accumulator();
+    this.geodesic = solver;
+    this.polyline = Boolean(options.polyline);
+    this.area0 = this.geodesic.surfaceArea;
+    if (!(Number.isFinite(this.area0) && this.area0 > 0)) {
+      throw new Error("Polygon area exceeds representable range");
+    }
+  }
+  get number() {
+    return this.count;
+  }
+  clear() {
+    this.count = this.crossings = 0;
+    this.firstLat = this.firstLon = this.lastLat = this.lastLon = 0;
+    this.perimeter = new Accumulator();
+    this.area = new Accumulator();
+    return this;
+  }
+  addPoint(latitude, longitude, options = {}) {
+    if (!(Number.isFinite(latitude) && Math.abs(latitude) <= 90 && Number.isFinite(longitude))) {
+      throw new Error("Polygon point requires finite longitude and latitude in [-90, 90]");
+    }
+    if (this.count) {
+      const edge = this.geodesic.inverse(this.lastLat, this.lastLon, latitude, longitude, {
+        area: !this.polyline,
+        longitudeTurns: options.longitudeTurns,
+        unrollLongitude: Boolean(options.longitudeTurns)
+      });
+      this.accumulate(edge.s12, this.polyline ? 0 : edge.S12);
+      if (!this.polyline) {
+        this.crossings = (this.crossings + (options.longitudeTurns ? transitDirect(this.lastLon, edge.lon2) : transit(this.lastLon, longitude))) % 2;
+      }
+    } else {
+      this.firstLat = latitude;
+      this.firstLon = longitude;
+    }
+    this.lastLat = latitude;
+    this.lastLon = longitude;
+    ++this.count;
+    return this;
+  }
+  addEdge(azimuth, distance) {
+    if (!this.count)
+      throw new Error("Add a starting point before adding an edge");
+    const edge = this.geodesic.direct(this.lastLat, this.lastLon, azimuth, distance, {
+      area: !this.polyline,
+      unrollLongitude: true
+    });
+    if (!(Number.isFinite(edge.lat2) && Number.isFinite(edge.lon2)))
+      throw new Error("Unrepresentable geodesic edge");
+    this.accumulate(distance, this.polyline ? 0 : edge.S12);
+    if (!this.polyline) {
+      this.crossings = (this.crossings + transitDirect(this.lastLon, edge.lon2)) % 2;
+    }
+    this.lastLat = edge.lat2;
+    this.lastLon = edge.lon2;
+    ++this.count;
+    return this;
+  }
+  compute(options = {}) {
+    if (this.count < 2)
+      return this.polyline ? { number: this.count, perimeter: 0 } : { number: this.count, perimeter: 0, area: 0 };
+    if (this.polyline)
+      return { number: this.count, perimeter: this.perimeter.Sum() };
+    const edge = this.geodesic.inverse(this.lastLat, this.lastLon, this.firstLat, this.firstLon, {
+      area: true
+    });
+    const total = new Accumulator(this.area);
+    total.Add(edge.S12);
+    const area0 = this.area0;
+    total.Remainder(area0);
+    if ((this.crossings + transit(this.lastLon, this.firstLon)) % 2 !== 0) {
+      total.Add((total.Sum() < 0 ? 1 : -1) * area0 / 2);
+    }
+    if (!options.reverse)
+      total.Negate();
+    if (options.unsigned) {
+      if (total.Sum() >= area0)
+        total.Add(-area0);
+      else if (total.Sum() < 0)
+        total.Add(area0);
+    } else {
+      if (total.Sum() > area0 / 2)
+        total.Add(-area0);
+      else if (total.Sum() <= -area0 / 2)
+        total.Add(area0);
+    }
+    return { number: this.count, perimeter: this.perimeter.Sum(edge.s12), area: 0 + total.Sum() };
+  }
+  /** Nonmutating preview, with the same compensated arithmetic as insertion. */
+  testPoint(latitude, longitude, options = {}) {
+    return this.copy().addPoint(latitude, longitude, options).compute(options);
+  }
+  testEdge(azimuth, distance, options = {}) {
+    return this.copy().addEdge(azimuth, distance).compute(options);
+  }
+  accumulate(distance, area) {
+    if (![distance, area, this.perimeter.Sum(distance), this.area.Sum(area)].every(Number.isFinite)) {
+      throw new Error("Unrepresentable geodesic sum");
+    }
+    this.perimeter.Add(distance);
+    if (!this.polyline)
+      this.area.Add(area);
+  }
+  copy() {
+    const copy = Object.create(Object.getPrototypeOf(this));
+    Object.assign(copy, this);
+    copy.perimeter = new Accumulator(this.perimeter);
+    copy.area = new Accumulator(this.area);
+    return copy;
+  }
+};
+function transit(a, b) {
+  const delta = math.AngDiff(a, b).d;
+  a = math.AngNormalize(a);
+  b = math.AngNormalize(b);
+  return delta > 0 && (a < 0 && b >= 0 || a > 0 && b === 0) ? 1 : delta < 0 && a >= 0 && b < 0 ? -1 : 0;
+}
+function transitDirect(a, b) {
+  a %= 720;
+  b %= 720;
+  return (b >= 0 && b < 360 || b < -360 ? 0 : 1) - (a >= 0 && a < 360 || a < -360 ? 0 : 1);
+}
+
+// dist/geodesic-polygon.js
+var GeodesicPolygon = class extends SurfacePolygon {
+  constructor(parameters, options = {}) {
+    super(new EllipsoidGeodesic(parameters), options);
+  }
+  addPoint(latitude, longitude) {
+    return super.addPoint(latitude, longitude);
+  }
+};
+
+// 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 shift = exponent ? exponent - 1075 : -1074;
+  const value = shift >= 0 ? mantissa * Q << BigInt(shift) : mantissa * Q >> BigInt(-shift);
+  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-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-polygon.js
+var RhumbPolygon = class extends SurfacePolygon {
+  constructor(parameters, options = {}) {
+    super(new EllipsoidRhumb(parameters), options);
+  }
+  addPoint(latitude, longitude, options = {}) {
+    validateRhumbPoint(latitude, longitude);
+    if (!Number.isSafeInteger(options.longitudeTurns ?? 0))
+      throw new RangeError("Rhumb longitudeTurns must be a safe integer");
+    return super.addPoint(latitude, longitude, options);
+  }
+};
+
+// dist/ellipsoid-helpers/intersection-bounds.js
+var IntersectionBounds = class {
+  constructor(solver, ratio2, radius) {
+    this.solver = solver;
+    this.halfCircumference = Math.PI * radius;
+    this.margin = this.halfCircumference * Number.EPSILON ** (1 / 5);
+    this.capture = ratio2 <= 1 ? Math.PI * ratio2 : this.polarMinimum(ratio2);
+    this.spacing = this.capture - this.margin;
+    if (!(Number.isFinite(this.spacing) && this.spacing > 0))
+      throw new Error("Unresolved geodesic capture bound");
+  }
+  conjugate(line, guess, semi = false, reference = { m12: 0, M12: 1, M21: 1 }) {
+    const { m12, M12, M21 } = reference;
+    let s = guess;
+    for (let i = 0; i < 100; i++) {
+      const p = line.position(s);
+      const m = p.m12 * M12 - m12 * p.M12;
+      const forward = p.M12 * M21 + (m12 === 0 ? 0 : (1 - M12 * M21) * p.m12 / m12);
+      const reverse = p.M21 * M12 + (p.m12 === 0 ? 0 : (1 - p.M12 * p.M21) * m12 / p.m12);
+      const step = semi ? m * forward / (1 - forward * reverse) : -m / reverse;
+      if (!Number.isFinite(step))
+        throw new Error("Unresolved conjugate distance");
+      const next = s + step;
+      if (next === s || Math.abs(step) <= 5e-14)
+        return next;
+      s = next;
+    }
+    throw new Error("Conjugate distance did not converge");
+  }
+  polarDistance(latitude, ratio2) {
+    return this.conjugate(this.solver.line(latitude, 0, 0), (1 + (1 - ratio2) / 2) * Math.PI / 2, true);
+  }
+  polarMinimum(ratio2) {
+    let lat0 = 63, lat1 = 65, lat2 = 64;
+    let s0 = this.polarDistance(lat0, ratio2), s1 = this.polarDistance(lat1, ratio2), s2 = this.polarDistance(lat2, ratio2);
+    let best = s2;
+    for (let i = 0; i < 10; i++) {
+      const denominator = (lat1 - lat0) * s2 + (lat0 - lat2) * s1 + (lat2 - lat1) * s0;
+      if (denominator === 0)
+        break;
+      const next = ((lat1 - lat0) * (lat1 + lat0) * s2 + (lat0 - lat2) * (lat0 + lat2) * s1 + (lat2 - lat1) * (lat2 + lat1) * s0) / (2 * denominator);
+      if (!(Number.isFinite(next) && next >= 0 && next <= 90))
+        break;
+      lat0 = lat1;
+      s0 = s1;
+      lat1 = lat2;
+      s1 = s2;
+      lat2 = next;
+      s2 = this.polarDistance(lat2, ratio2);
+      best = Math.min(best, s2);
+    }
+    return 2 * best;
+  }
+};
+
+// dist/geodesic-intersections.js
+var DEG3 = Math.PI / 180;
+var EPS = 3 * Number.EPSILON;
+var math2 = geodesic.Math;
+var GeodesicIntersections = class {
+  constructor({ semiMajorAxis: a, semiMinorAxis: b }) {
+    this.tolerance = 5e-14;
+    const r = b / a;
+    if (!(Number.isFinite(a) && Number.isFinite(b) && a > 0 && b > 0 && r >= 0.99 && r <= 1.01))
+      throw new RangeError("Intersections require finite positive axes with 0.99 <= b/a <= 1.01");
+    this.a = a;
+    this.r = r;
+    this.solver = new EllipsoidGeodesic({ semiMajorAxis: 1, semiMinorAxis: r });
+    this.radius = Math.sqrt(this.solver.surfaceArea / (4 * Math.PI));
+    this.bounds = new IntersectionBounds(this.solver, r, this.radius);
+    Object.freeze(this);
+  }
+  /** Find all discovered roots in the L1 ball |s-originS|+|t-originT| <= maxDistance. */
+  all(a, b, options) {
+    return this.search(a, b, options, false);
+  }
+  search(a, b, options, normalized) {
+    const A = this.solver.line(a.latitude, a.longitude, a.azimuth), B = this.solver.line(b.latitude, b.longitude, b.azimuth);
+    const d = normalized ? options.maxDistance : options.maxDistance / this.a, origin = options.origin ?? [0, 0];
+    const x = origin[0] / this.a, y = origin[1] / this.a;
+    if (!(Number.isFinite(d) && d > 0 && (normalized ? d <= 4 * this.bounds.halfCircumference : options.maxDistance <= 4 * this.bounds.halfCircumference * this.a) && Number.isFinite(x) && Number.isFinite(y) && Math.max(Math.abs(origin[0]), Math.abs(origin[1])) <= 4 * this.bounds.halfCircumference * this.a))
+      throw new RangeError("Intersection search requires finite bounds within four half-circumferences");
+    if (this.r === 1) {
+      const analytic = this.sphere(a, b, A, B, d, x, y);
+      if (analytic)
+        return analytic;
+    }
+    const extended = d + this.bounds.margin;
+    const m = Math.ceil(extended / this.bounds.spacing), n = m - 1;
+    const spacing = extended / m;
+    const seeds = [[x, y, spacing, 0]];
+    for (let i = -n; i <= n; i += 2)
+      for (let j = -n; j <= n; j += 2)
+        if (i || j)
+          seeds.push([x + spacing * (i + j) / 2, y + spacing * (i - j) / 2, spacing, 0]);
+    let failed = 0, unresolved = 0;
+    const isolated = [], lines = [];
+    const equal = (p, q) => Math.abs(p.x - q.x) + Math.abs(p.y - q.y) <= this.bounds.margin;
+    const canonical = (p, c) => {
+      const shift = (x + c * y - (p.x + c * p.y)) / 2;
+      return { ...p, x: p.x + shift, y: p.y + c * shift, c };
+    };
+    const retry = (seed) => {
+      ++failed;
+      if (seed[3] === 3) {
+        ++unresolved;
+        return;
+      }
+      const half = seed[2] / 2, depth = seed[3] + 1;
+      for (const [dx, dy] of [
+        [half, 0],
+        [-half, 0],
+        [0, half],
+        [0, -half]
+      ])
+        seeds.push([seed[0] + dx, seed[1] + dy, half, depth]);
+    };
+    for (const seed of seeds) {
+      const root = this.refine(A, B, seed[0], seed[1]);
+      if (!root) {
+        retry(seed);
+        continue;
+      }
+      if (root.c) {
+        const q = canonical(root, root.c);
+        if (!this.point(A, B, q)) {
+          retry(seed);
+          continue;
+        }
+        if (!lines.some((p) => p.c === q.c && equal(p, q)))
+          lines.push(q);
+      } else if (!isolated.some((p) => equal(p, root)))
+        isolated.push(root);
+    }
+    const roots = [], coincidences = [];
+    for (const p of isolated) {
+      if (lines.some((q) => equal(canonical(p, q.c), q)))
+        continue;
+      if (Math.abs(p.x - x) + Math.abs(p.y - y) > d + this.tolerance)
+        continue;
+      const point = this.point(A, B, p);
+      if (point)
+        roots.push(point);
+      else {
+        ++failed;
+        ++unresolved;
+      }
+    }
+    for (const p of lines) {
+      if (Math.abs(p.x - x) + Math.abs(p.y - y) <= d + this.tolerance)
+        coincidences.push({
+          s: p.x * this.a,
+          t: p.y * this.a,
+          direction: p.c
+        });
+    }
+    this.sort(roots, origin);
+    this.sort(coincidences, origin);
+    return {
+      intersections: roots,
+      coincidences,
+      complete: unresolved === 0,
+      attemptedSeeds: seeds.length,
+      failedSeeds: failed
+    };
+  }
+  /** Without an explicit radius, search the full native global profile.
+   * A returned root from any complete centered L1 search is globally closest:
+   * every point outside that ball is farther from its center.
+   */
+  closest(a, b, options = {}) {
+    const settings = {
+      ...options,
+      maxDistance: options.maxDistance ?? 4 * this.bounds.halfCircumference
+    };
+    const search = this.search(a, b, settings, options.maxDistance === void 0);
+    const candidates = [...search.intersections];
+    for (const c of search.coincidences) {
+      const point = this.coincidencePoint(a, b, c);
+      if (point)
+        candidates.push(point);
+      else {
+        search.complete = false;
+        ++search.failedSeeds;
+      }
+    }
+    this.sort(candidates, settings.origin ?? [0, 0]);
+    return { ...search, intersection: candidates[0] };
+  }
+  /** Global next crossing, excluding the shared parameter origin. For a
+   * coincident continuum use GeographicLib's nearest-conjugate convention.
+   */
+  next(latitude, longitude, azimuthA, azimuthB, maxDistance) {
+    const a = { latitude, longitude, azimuth: azimuthA }, b = { latitude, longitude, azimuth: azimuthB };
+    const bound = maxDistance === void 0 ? 4 * this.bounds.halfCircumference : maxDistance / this.a;
+    const search = this.search(a, b, { maxDistance: maxDistance ?? bound }, maxDistance === void 0);
+    search.intersections = search.intersections.filter((p) => Math.abs(p.s / this.a) + Math.abs(p.t / this.a) > this.bounds.margin);
+    const candidates = [...search.intersections];
+    const A = this.solver.line(latitude, longitude, azimuthA);
+    for (const c of search.coincidences) {
+      if (Math.abs(c.s / this.a) + Math.abs(c.t / this.a) > this.bounds.margin) {
+        const point = this.coincidencePoint(a, b, c);
+        if (point)
+          candidates.push(point);
+        else {
+          search.complete = false;
+          ++search.failedSeeds;
+        }
+      } else {
+        for (const sign of [-1, 1]) {
+          try {
+            const s = this.bounds.conjugate(A, sign * this.bounds.halfCircumference);
+            const point = this.coincidencePoint(a, b, {
+              s: s * this.a,
+              t: c.direction * s * this.a,
+              direction: c.direction
+            });
+            if (point)
+              candidates.push(point);
+            else {
+              search.complete = false;
+              ++search.failedSeeds;
+            }
+          } catch {
+            search.complete = false;
+            ++search.failedSeeds;
+          }
+        }
+      }
+    }
+    const bounded = candidates.filter((p) => Math.abs(p.s / this.a) + Math.abs(p.t / this.a) <= bound + this.tolerance);
+    this.sort(bounded, [0, 0]);
+    return { ...search, intersection: bounded[0] };
+  }
+  coincidencePoint(a, b, c) {
+    return this.point(this.solver.line(a.latitude, a.longitude, a.azimuth), this.solver.line(b.latitude, b.longitude, b.azimuth), { x: c.s / this.a, y: c.t / this.a, c: c.direction, iterations: 0 });
+  }
+  segments(a0, a1, b0, b1) {
+    const ia = this.solver.inverse(...a0, ...a1), ib = this.solver.inverse(...b0, ...b1);
+    if (this.ambiguous(a0, a1, ia) || this.ambiguous(b0, b1, ib))
+      return { status: "ambiguous", complete: false };
+    const sa = ia.s12, sb = ib.s12;
+    if (sa === 0 || sb === 0) {
+      const p = sa === 0 ? a0 : b0, start = sa === 0 ? b0 : a0, end = sa === 0 ? b1 : a1, len = sa === 0 ? sb : sa;
+      const ip = this.solver.inverse(...start, ...p);
+      const d0 = ip.s12;
+      const route = this.solver.inverse(...start, ...end);
+      const projected = this.solver.direct(start[0], start[1], route.azi1, d0);
+      const residual = this.solver.inverse(projected.lat2, projected.lon2, ...p).s12;
+      if (d0 > len + this.tolerance || residual > this.tolerance)
+        return { status: "disjoint", complete: true };
+      return {
+        status: "intersection",
+        complete: true,
+        point: {
+          s: (sa === 0 ? 0 : d0) * this.a,
+          t: (sb === 0 ? 0 : d0) * this.a,
+          latitude: p[0],
+          longitude: p[1],
+          residual: residual * this.a,
+          crossingAngle: 0,
+          iterations: 0
+        }
+      };
+    }
+    const search = this.all({ latitude: a0[0], longitude: a0[1], azimuth: ia.azi1 }, { latitude: b0[0], longitude: b0[1], azimuth: ib.azi1 }, {
+      origin: [sa * this.a / 2, sb * this.a / 2],
+      maxDistance: (sa + sb) * this.a / 2 + this.tolerance * this.a
+    });
+    for (const c of search.coincidences) {
+      const offset2 = c.t / this.a - c.direction * c.s / this.a;
+      const lo = Math.max(0, c.direction === 1 ? -offset2 : offset2 - sb), hi = Math.min(sa, c.direction === 1 ? sb - offset2 : offset2);
+      if (hi >= lo - this.tolerance) {
+        if (hi - lo > this.tolerance)
+          return {
+            status: "overlap",
+            intervalA: [lo * this.a, hi * this.a],
+            intervalB: [(c.direction * lo + offset2) * this.a, (c.direction * hi + offset2) * this.a],
+            complete: search.complete
+          };
+        const s = (lo + hi) / 2, t = c.direction * s + offset2;
+        const A = this.solver.line(a0[0], a0[1], ia.azi1), B = this.solver.line(b0[0], b0[1], ib.azi1);
+        const point2 = this.point(A, B, { x: s, y: t, c: 0, iterations: 0 });
+        if (point2)
+          return { status: "intersection", point: point2, complete: search.complete };
+        search.complete = false;
+        ++search.failedSeeds;
+      }
+    }
+    const point = search.intersections.find((p) => p.s / this.a >= -this.tolerance && p.s / this.a <= sa + this.tolerance && p.t / this.a >= -this.tolerance && p.t / this.a <= sb + this.tolerance);
+    return point ? { status: "intersection", point, complete: search.complete } : { status: search.complete ? "disjoint" : "not-found", complete: search.complete };
+  }
+  ambiguous(start, end, path) {
+    if (path.a12 > 180 - 1e-10)
+      return true;
+    if (Math.abs(start[0]) === 90 || Math.abs(end[0]) === 90)
+      return false;
+    if (start[0] === -end[0] && math2.AngDiff(path.azi1, path.azi2).d !== 0)
+      return true;
+    const longitude = math2.AngDiff(start[1], end[1]);
+    return Math.abs(longitude.d) === 180 && longitude.e === 0 && path.azi1 !== 0 && Math.abs(path.azi1) !== 180;
+  }
+  refine(A, B, x, y) {
+    for (let i = 0; i < 100; i++) {
+      const a = A.position(x), b = B.position(y), v = this.solver.inverse(a.lat2, a.lon2, b.lat2, b.lon2);
+      const X = math2.AngDiff(a.azi2, v.azi1), Y = math2.AngDiff(b.azi2, v.azi2), XY = math2.AngDiff(X.d, Y.d);
+      const orientation = XY.d + (XY.e + Y.e - X.e) < 0 ? -1 : 1;
+      const sx = math2.sincosde(orientation * X.d, orientation * X.e), sy = math2.sincosde(orientation * Y.d, orientation * Y.e);
+      let dx, dy, c = 0;
+      if (v.s12 <= EPS * this.radius) {
+        if (Math.abs(sx.s - sy.s) <= EPS && Math.abs(sx.c - sy.c) <= EPS)
+          c = 1;
+        else if (Math.abs(sx.s + sy.s) <= EPS && Math.abs(sx.c + sy.c) <= EPS)
+          c = -1;
+        return { x, y, c, iterations: i };
+      }
+      if (Math.abs(sx.s) <= EPS && Math.abs(sy.s) <= EPS) {
+        c = sx.c * sy.c > 0 ? 1 : -1;
+        dx = sx.c * v.s12 / 2;
+        dy = -sy.c * v.s12 / 2;
+      } else {
+        const sz = Math.sin(v.s12 / this.radius), cz = Math.cos(v.s12 / this.radius);
+        dx = this.radius * Math.atan2(sy.s * sz, sy.s * sx.c * cz - sy.c * sx.s);
+        dy = this.radius * Math.atan2(sx.s * sz, -sx.s * sy.c * cz + sx.c * sy.s);
+      }
+      if (!(Number.isFinite(dx) && Number.isFinite(dy)))
+        return void 0;
+      x += dx;
+      y += dy;
+      if (Math.max(Math.abs(x), Math.abs(y)) > 12 * Math.PI * this.radius)
+        return void 0;
+      if (c)
+        return { x, y, c, iterations: i + 1 };
+      if (Math.abs(dx) + Math.abs(dy) <= this.tolerance) {
+        const root = { x, y, c, iterations: i + 1 };
+        if (this.point(A, B, root))
+          return root;
+      }
+    }
+    return void 0;
+  }
+  point(A, B, p) {
+    const s = p.x * this.a, t = p.y * this.a;
+    if (!(Number.isFinite(s) && Number.isFinite(t)) || Math.abs(s / this.a - p.x) > this.tolerance || Math.abs(t / this.a - p.y) > this.tolerance)
+      return void 0;
+    const a = A.position(p.x), b = B.position(p.y), v = this.solver.inverse(a.lat2, a.lon2, b.lat2, b.lon2);
+    if (!(Number.isFinite(v.s12) && v.s12 <= this.tolerance && Number.isFinite(p.x * this.a) && Number.isFinite(p.y * this.a)))
+      return void 0;
+    const ta = frame({ latitude: a.lat2, longitude: a.lon2, azimuth: a.azi2 })[1];
+    const tb = frame({ latitude: b.lat2, longitude: b.lon2, azimuth: b.azi2 })[1];
+    const angle2 = Math.atan2(Math.hypot(...cross(ta, tb)), Math.abs(dot(ta, tb))) / DEG3;
+    return {
+      s: p.x * this.a,
+      t: p.y * this.a,
+      latitude: a.lat2,
+      longitude: a.lon2,
+      residual: v.s12 * this.a,
+      crossingAngle: angle2,
+      iterations: p.iterations,
+      ...p.c ? { coincidence: p.c } : {}
+    };
+  }
+  sphere(a, b, A, B, d, x, y) {
+    const [pa, ta, na] = frame(a), [pb, tb, nb] = frame(b), crossing = cross(na, nb), length = Math.hypot(...crossing);
+    if (length > 0 && length < Math.sqrt(Number.EPSILON))
+      return void 0;
+    if (length <= EPS) {
+      const sign = dot(na, nb) >= 0 ? 1 : -1;
+      const offset2 = Math.atan2(dot(pa, tb), dot(pa, pb));
+      const coincidences = [];
+      for (let k = Math.ceil((y - sign * x - d - offset2) / (2 * Math.PI)); k <= Math.floor((y - sign * x + d - offset2) / (2 * Math.PI)); k++) {
+        const shift = offset2 + 2 * Math.PI * k;
+        const sx = (x + sign * (y - shift)) / 2;
+        const sy = sign * sx + shift;
+        if (Math.abs(sx - x) + Math.abs(sy - y) <= d + this.tolerance)
+          coincidences.push({ s: sx * this.a, t: sy * this.a, direction: sign });
+      }
+      let failed2 = 0;
+      const checked = coincidences.filter((c) => {
+        const p = this.point(A, B, {
+          x: c.s / this.a,
+          y: c.t / this.a,
+          c: c.direction,
+          iterations: 0
+        });
+        if (!p)
+          ++failed2;
+        return Boolean(p);
+      });
+      return {
+        intersections: [],
+        coincidences: checked,
+        complete: failed2 === 0,
+        attemptedSeeds: 0,
+        failedSeeds: failed2
+      };
+    }
+    const result = [];
+    let failed = 0;
+    for (const sign of [-1, 1]) {
+      const p = crossing.map((v) => sign * v / length);
+      const s = Math.atan2(dot(p, ta), dot(p, pa)), t = Math.atan2(dot(p, tb), dot(p, pb));
+      const k0 = Math.ceil((x - d - s) / (2 * Math.PI)), k1 = Math.floor((x + d - s) / (2 * Math.PI));
+      const l0 = Math.ceil((y - d - t) / (2 * Math.PI)), l1 = Math.floor((y + d - t) / (2 * Math.PI));
+      for (let k = k0; k <= k1; k++)
+        for (let l = l0; l <= l1; l++) {
+          const sx = s + 2 * Math.PI * k, sy = t + 2 * Math.PI * l;
+          if (Math.abs(sx - x) + Math.abs(sy - y) > d + this.tolerance)
+            continue;
+          const point = this.point(A, B, { x: sx, y: sy, c: 0, iterations: 0 });
+          if (point)
+            result.push(point);
+          else
+            ++failed;
+        }
+    }
+    this.sort(result, [x * this.a, y * this.a]);
+    return {
+      intersections: result,
+      coincidences: [],
+      complete: failed === 0,
+      attemptedSeeds: 0,
+      failedSeeds: failed
+    };
+  }
+  sort(points, origin) {
+    const x = origin[0] / this.a, y = origin[1] / this.a;
+    points.sort((p, q) => Math.abs(p.s / this.a - x) + Math.abs(p.t / this.a - y) - (Math.abs(q.s / this.a - x) + Math.abs(q.t / this.a - y)) || p.s / this.a - q.s / this.a || p.t / this.a - q.t / this.a);
+  }
+};
+function frame(p) {
+  const [s, c] = sincos2(p.latitude), [sl, cl] = sincos2(p.longitude), [sa, ca] = sincos2(p.azimuth);
+  const point = [c * cl, c * sl, s], north = [-s * cl, -s * sl, c], east = [-sl, cl, 0];
+  const tangent = north.map((v, i) => ca * v + sa * east[i]);
+  return [point, tangent, cross(point, tangent)];
+}
+function sincos2(degrees) {
+  const a = degrees % 360, q = Math.round(a / 90), d = (a - 90 * q) * DEG3, s = Math.sin(d), c = Math.cos(d);
+  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 dot(a, b) {
+  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+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/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/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/ellipsoid-transforms.js
+var import_core7 = require("@math.gl/core");
+
+// dist/ellipsoid-helpers/ellipsoid-transform.js
+var import_core6 = require("@math.gl/core");
+var import_local_frame2 = require("@math.gl/core/local-frame");
+var EPSILON14 = 1e-14;
+var scratchOrigin = new import_core6.Vector3();
+var scratchBasis = (0, import_local_frame2.createLocalFrameBasis)();
+var VECTOR_PRODUCT_LOCAL_FRAME = {
+  up: {
+    south: "east",
+    north: "west",
+    west: "south",
+    east: "north"
+  },
+  down: {
+    south: "west",
+    north: "east",
+    west: "north",
+    east: "south"
+  },
+  south: {
+    up: "west",
+    down: "east",
+    west: "down",
+    east: "up"
+  },
+  north: {
+    up: "east",
+    down: "west",
+    west: "up",
+    east: "down"
+  },
+  west: {
+    up: "north",
+    down: "south",
+    north: "down",
+    south: "up"
+  },
+  east: {
+    up: "south",
+    down: "north",
+    north: "up",
+    south: "down"
+  }
+};
+var degeneratePositionLocalFrame = {
+  north: [-1, 0, 0],
+  east: [0, 1, 0],
+  up: [0, 0, 1],
+  south: [1, 0, 0],
+  west: [0, -1, 0],
+  down: [0, 0, -1]
+};
+var scratchAxisVectors = {
+  east: new import_core6.Vector3(),
+  north: new import_core6.Vector3(),
+  up: new import_core6.Vector3(),
+  west: new import_core6.Vector3(),
+  south: new import_core6.Vector3(),
+  down: new import_core6.Vector3()
+};
+var scratchVector1 = new import_core6.Vector3();
+var scratchVector22 = new import_core6.Vector3();
+var scratchVector3 = new import_core6.Vector3();
+function localFrameToFixedFrame(ellipsoid, firstAxis, secondAxis, thirdAxis, cartesianOrigin, result) {
+  const thirdAxisInferred = VECTOR_PRODUCT_LOCAL_FRAME[firstAxis] && VECTOR_PRODUCT_LOCAL_FRAME[firstAxis][secondAxis];
+  (0, import_core6.assert)(thirdAxisInferred && (!thirdAxis || thirdAxis === thirdAxisInferred));
+  let firstAxisVector;
+  let secondAxisVector;
+  let thirdAxisVector;
+  const origin = scratchOrigin.copy(cartesianOrigin);
+  if (!Number.isFinite(origin.x) || !Number.isFinite(origin.y) || !Number.isFinite(origin.z) || !Array.isArray(result) && result.length < 16)
+    throw new Error("Unsupported local frame");
+  const poleTolerance = EPSILON14 * Math.min(1, ellipsoid.maximumRadius);
+  const atPole = Math.abs(origin.x) <= poleTolerance && Math.abs(origin.y) <= poleTolerance;
+  const radii = ellipsoid.radii;
+  if (radii.x === radii.y && radii.x > 0 && radii.z > 0 && radii.z <= radii.x && (!atPole || origin.z !== 0)) {
+    const { east, up } = scratchAxisVectors;
+    if (atPole) {
+      east.set(0, 1, 0);
+      up.set(0, 0, Math.sign(origin.z));
+    } else {
+      const scale = Math.max(Math.abs(origin.x), Math.abs(origin.y));
+      east.set(-origin.y / scale, origin.x / scale, 0).normalize();
+      ellipsoid.geodeticSurfaceNormal(origin, up);
+    }
+    if (!(0, import_local_frame2.eastNorthUpBasisFromDirections)(east, up, scratchBasis) || !(0, import_local_frame2.localFrameToMatrix)(scratchBasis, origin, firstAxis, secondAxis, thirdAxis, result))
+      throw new Error("Unsupported local frame");
+    return result;
+  }
+  if (atPole) {
+    const sign = Math.sign(origin.z);
+    firstAxisVector = scratchVector1.fromArray(degeneratePositionLocalFrame[firstAxis]);
+    if (firstAxis !== "east" && firstAxis !== "west") {
+      firstAxisVector.scale(sign);
+    }
+    secondAxisVector = scratchVector22.fromArray(degeneratePositionLocalFrame[secondAxis]);
+    if (secondAxis !== "east" && secondAxis !== "west") {
+      secondAxisVector.scale(sign);
+    }
+    thirdAxisVector = scratchVector3.fromArray(degeneratePositionLocalFrame[thirdAxis]);
+    if (thirdAxis !== "east" && thirdAxis !== "west") {
+      thirdAxisVector.scale(sign);
+    }
+  } else {
+    const { up, east, north } = scratchAxisVectors;
+    const scale = Math.max(Math.abs(origin.x), Math.abs(origin.y));
+    east.set(-origin.y / scale, origin.x / scale, 0).normalize();
+    ellipsoid.geodeticSurfaceNormal(origin, up);
+    north.copy(up).cross(east);
+    const { down, west, south } = scratchAxisVectors;
+    down.copy(up).scale(-1);
+    west.copy(east).scale(-1);
+    south.copy(north).scale(-1);
+    firstAxisVector = scratchAxisVectors[firstAxis];
+    secondAxisVector = scratchAxisVectors[secondAxis];
+    thirdAxisVector = scratchAxisVectors[thirdAxis];
+  }
+  const ax = firstAxisVector.x, ay = firstAxisVector.y, az = firstAxisVector.z;
+  const bx = secondAxisVector.x, by = secondAxisVector.y, bz = secondAxisVector.z;
+  const cx = thirdAxisVector.x, cy = thirdAxisVector.y, cz = thirdAxisVector.z;
+  const x = origin.x, y = origin.y, z = origin.z;
+  result[0] = ax;
+  result[1] = ay;
+  result[2] = az;
+  result[3] = 0;
+  result[4] = bx;
+  result[5] = by;
+  result[6] = bz;
+  result[7] = 0;
+  result[8] = cx;
+  result[9] = cy;
+  result[10] = cz;
+  result[11] = 0;
+  result[12] = x;
+  result[13] = y;
+  result[14] = z;
+  result[15] = 1;
+  return result;
+}
+
+// dist/ellipsoid-transforms.js
+function eastNorthUpToFixedFrame(ellipsoid, origin, result = new import_core7.Matrix4()) {
+  return localFrameToFixedFrame(ellipsoid, "east", "north", "up", origin, result);
+}
+function localFrameToFixedFrame2(ellipsoid, firstAxis, secondAxis, thirdAxis, origin, result = new import_core7.Matrix4()) {
+  return localFrameToFixedFrame(ellipsoid, firstAxis, secondAxis, thirdAxis, origin, result);
+}
+//# sourceMappingURL=ellipsoid.cjs.map