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

package/src/geodesic-exact/area.ts

@@ -0,0 +1,70 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) Charles Karney (2012-2025)
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Area decomposition and I4 integrand adapted from GeographicLib 2.7 GeodesicExact/GeodesicLineExact (MIT). Original derivative-integral divided difference avoids cancellation. See ../../GEOGRAPHICLIB-LICENSE.txt.
+import {integrate} from './quadrature';
+/** Derivative of t(x) = x + sqrt(1+x) asinh(sqrt(x))/sqrt(x) - 1,
+ * analytically continued to negative x. Taylor evaluation avoids subtraction at 0.
+ */
+function derivative(x: number): number {
+  if (Math.abs(x) < 0.125) {
+    let coefficient = 1 / 3,
+      power = 1,
+      sum = 1;
+    for (let n = 1; n <= 24; n++) {
+      sum += n * coefficient * power;
+      coefficient *= (-2 * n) / (2 * n + 3);
+      power *= x;
+    }
+    return sum;
+  }
+  const root = Math.sqrt(Math.abs(x));
+  const ratio = (x > 0 ? Math.asinh(root) : Math.asin(root)) / root;
+  return 1 + (1 - ratio / Math.sqrt(1 + x)) / (2 * x);
+}
+/** Stable t value for a well-separated divided difference. */
+function value(x: number): number {
+  if (Math.abs(x) < 0.125) {
+    let term = x / 3,
+      sum = x;
+    for (let n = 1; n <= 24; n++) {
+      const next = sum + term;
+      if (next === sum) break;
+      sum = next;
+      term *= (-2 * n * x) / (2 * n + 3);
+    }
+    return sum;
+  }
+  const root = Math.sqrt(Math.abs(x));
+  return x + ((Math.sqrt(1 + x) * (x > 0 ? Math.asinh(root) : Math.asin(root))) / root - 1);
+}
+/** Integrate the smooth correction, evaluating t's divided difference as an
+ * integral of its derivative rather than subtracting nearly equal t values.
+ */
+export function areaCorrection(
+  ep2: number,
+  k2: number,
+  s1: number,
+  c1: number,
+  delta: number
+): number {
+  // I4 is anti-periodic after pi and has zero integral over a full circuit.
+  const remainder = delta % (2 * Math.PI),
+    tX = value(ep2);
+  return integrate(
+    theta => {
+      const s = s1 * Math.cos(theta) + c1 * Math.sin(theta),
+        y = k2 * s * s;
+      const divided =
+        ep2 === y
+          ? derivative(y)
+          : Math.abs(y) <= 1e-8 * Math.abs(ep2)
+            ? (tX - value(y)) / (ep2 - y)
+            : integrate(u => derivative(y + (ep2 - y) * u), 0, 1);
+      return (-s * divided) / 2;
+    },
+    0,
+    remainder
+  );
+}

package/src/geodesic-exact/inverse-engine.ts

@@ -0,0 +1,166 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) Charles Karney (2012-2025)
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Length/Jacobi and Cayley-longitude formulae adapted from GeographicLib 2.7 GeodesicExact.cpp; original quadrature bridge. See ../../GEOGRAPHICLIB-LICENSE.txt.
+import {geodesic} from '../vendor/geographiclib-geodesic/runtime';
+import type {GeodesicResult} from '../ellipsoid-geodesic';
+import {ellipticIntegrals} from './quadrature';
+type State = {
+  sig12: number;
+  eps: number;
+  ssig1: number;
+  csig1: number;
+  ssig2: number;
+  csig2: number;
+  salp2: number;
+  calp2: number;
+  lam12: number;
+  domg12: number;
+  dlam12: number;
+};
+type Lengths = {s12b: number; m12b: number; m0: number; M12: number; M21: number};
+interface Engine {
+  a: number;
+  f: number;
+  _b: number;
+  _f1: number;
+  _ep2: number;
+  _e2: number;
+  _c2: number;
+  Inverse: (a: number, b: number, c: number, d: number, mask: number) => GeodesicResult;
+  Lengths: (
+    eps: number,
+    sig12: number,
+    s1: number,
+    c1: number,
+    d1: number,
+    s2: number,
+    c2: number,
+    d2: number,
+    cb1: number,
+    cb2: number,
+    mask: number,
+    c1a?: number[],
+    c2a?: number[]
+  ) => Lengths;
+  Lambda12: (
+    sb1: number,
+    cb1: number,
+    dn1: number,
+    sb2: number,
+    cb2: number,
+    dn2: number,
+    sa1: number,
+    ca1: number,
+    sl: number,
+    cl: number,
+    diff: boolean,
+    c1a: number[],
+    c2a: number[],
+    c3a: number[]
+  ) => State;
+  InverseStart: (
+    sb1: number,
+    cb1: number,
+    dn1: number,
+    sb2: number,
+    cb2: number,
+    dn2: number,
+    lam: number,
+    sl: number,
+    cl: number,
+    c1a: number[],
+    c2a: number[]
+  ) => {sig12: number; salp1: number; calp1: number};
+}
+type Namespace = {
+  Geodesic: new (a: number, f: number) => Engine;
+  ALL: number;
+  AREA: number;
+  LONG_UNROLL: number;
+};
+export const library = geodesic.Geodesic as unknown as Namespace;
+export const angleMath = (
+  geodesic as unknown as {
+    Math: {
+      sincosd: (x: number) => {s: number; c: number};
+      AngNormalize: (x: number) => number;
+      atan2d: (y: number, x: number) => number;
+    };
+  }
+).Math;
+/** Per-instance overrides only: the existing series engine and its prototype remain unchanged. */
+export function exactInverseEngine(a: number, b: number): Engine {
+  const engine = new library.Geodesic(a, (a - b) / a);
+  engine.Lengths = function (eps, delta, s1, c1, d1, s2, c2, d2, cb1, cb2) {
+    const k2 = (4 * eps) / (1 - eps) ** 2,
+      I = ellipticIntegrals(k2, this._ep2),
+      start = Math.atan2(s1, c1);
+    const J = I.J(start, delta),
+      t = (this._ep2 * (cb1 - cb2) * (cb1 + cb2)) / (d1 + d2);
+    const cosine = c1 * c2 + s1 * s2;
+    return {
+      s12b: I.E(start, delta),
+      m12b: d2 * (c1 * s2) - d1 * (s1 * c2) - c1 * c2 * J,
+      m0: I.meanJ(),
+      M12: cosine + ((t * s2 - c2 * J) * s1) / d1,
+      M21: cosine - ((t * s1 - c1 * J) * s2) / d2
+    };
+  };
+  // Force the bracketed solve rather than a series short-line approximation.
+  engine.InverseStart = function (sb1, cb1, _d1, sb2, cb2, _d2, _lam, sl, cl) {
+    let s = cb2 * sl,
+      c = cb1 * sb2 - sb1 * cb2 * cl;
+    const length = Math.hypot(s, c);
+    if (length > 0 && s > 0) {
+      s /= length;
+      c /= length;
+    } else {
+      s = 1;
+      c = 0;
+    }
+    return {sig12: -1, salp1: s, calp1: c};
+  };
+  const baseLambda = engine.Lambda12;
+  engine.Lambda12 = function (sb1, cb1, dn1, sb2, cb2, dn2, sa1, ca1, sl, cl, diff, c1a, c2a, c3a) {
+    const result = baseLambda.call(
+      this,
+      sb1,
+      cb1,
+      dn1,
+      sb2,
+      cb2,
+      dn2,
+      sa1,
+      ca1,
+      sl,
+      cl,
+      diff,
+      c1a,
+      c2a,
+      c3a
+    );
+    const sa0 = sa1 * cb1,
+      ca0 = Math.hypot(ca1, sa1 * sb1),
+      k2 = ca0 * ca0 * this._ep2;
+    const om1 = sa0 * sb1,
+      co1 = ca1 * cb1,
+      om2 = sa0 * sb2,
+      co2 = result.calp2 * cb2;
+    const ch1 = this._f1 * dn1 * co1,
+      ch2 = this._f1 * dn2 * co2;
+    const sch = Math.max(0, ch1 * om2 - om1 * ch2),
+      cch = ch1 * ch2 + om1 * om2;
+    const so = Math.max(0, co1 * om2 - om1 * co2),
+      co = co1 * co2 + om1 * om2;
+    const correction =
+      (-this._e2 / this._f1) *
+      sa0 *
+      ellipticIntegrals(k2, this._ep2).H(Math.atan2(result.ssig1, result.csig1), result.sig12);
+    result.lam12 = Math.atan2(sch * cl - cch * sl, cch * cl + sch * sl) + correction;
+    result.domg12 = correction + Math.atan2(sch * co - cch * so, cch * co + sch * so);
+    return result;
+  };
+  return engine;
+}

package/src/geodesic-exact/polygon.ts

@@ -0,0 +1,36 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Exact solver facade over the attributed compensated SurfacePolygon kernel; see ../../GEOGRAPHICLIB-LICENSE.txt.
+import {EllipsoidGeodesicExact} from '../geodesic-exact';
+import type {GeodesicParameters} from '../ellipsoid-geodesic';
+import {SurfacePolygon} from '../ellipsoid-helpers/surface-polygon';
+/** Compensated exact-geodesic polygon or open polyline. Angles are degrees. */
+export class GeodesicPolygonExact extends SurfacePolygon {
+  constructor(parameters: GeodesicParameters, options: {polyline?: boolean} = {}) {
+    const solver = new EllipsoidGeodesicExact(parameters);
+    // Preserve the 360-degree transit parity while bounding internal labels.
+    // External point inputs retain the solver's documented magnitude limit.
+    super(
+      {
+        surfaceArea: solver.surfaceArea,
+        inverse: (a, b, c, d, opts) => solver.inverse(a, b % 720, c, d % 720, opts),
+        direct: (a, b, c, d, opts) => solver.direct(a, b % 720, c, d, opts)
+      },
+      options
+    );
+  }
+  override addPoint(
+    latitude: number,
+    longitude: number,
+    options: {longitudeTurns?: number} = {}
+  ): this {
+    if (Math.abs(longitude) > 1e6)
+      throw new RangeError('Exact polygon longitude exceeds input profile');
+    if (options.longitudeTurns !== undefined && options.longitudeTurns !== 0)
+      throw new RangeError(
+        'Exact geodesic point insertion does not select winding routes; use addEdge'
+      );
+    return super.addPoint(latitude, longitude);
+  }
+}

package/src/geodesic-exact/quadrature.ts

@@ -0,0 +1,60 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Original bounded adaptive Gauss-Legendre evaluation of elliptic geodesic integrals.
+const X16 = [
+  0.09501250983763744, 0.2816035507792589, 0.4580167776572274, 0.6178762444026438,
+  0.755404408355003, 0.8656312023878318, 0.9445750230732326, 0.9894009349916499
+];
+const W16 = [
+  0.1894506104550685, 0.1826034150449236, 0.16915651939500254, 0.14959598881657673,
+  0.12462897125553387, 0.09515851168249278, 0.06225352393864789, 0.027152459411754096
+];
+const X8 = [0.1834346424956498, 0.525532409916329, 0.7966664774136267, 0.9602898564975363];
+const W8 = [0.362683783378362, 0.3137066458778873, 0.2223810344533745, 0.1012285362903763];
+export function integrate(f: (x: number) => number, start: number, length: number): number {
+  if (length === 0) return 0;
+  function rule(x: readonly number[], w: readonly number[], a: number, h: number) {
+    const mid = a + h / 2,
+      half = h / 2;
+    let sum = 0;
+    for (let i = 0; i < x.length; i++) sum += w[i] * (f(mid - half * x[i]) + f(mid + half * x[i]));
+    return half * sum;
+  }
+  function visit(a: number, h: number, depth: number): number {
+    const high = rule(X16, W16, a, h),
+      low = rule(X8, W8, a, h);
+    if (!Number.isFinite(high)) throw new RangeError('Nonfinite elliptic integral');
+    if (Math.abs(high - low) <= 2e-15 * Math.abs(h) + 8 * Number.EPSILON * Math.abs(high))
+      return high;
+    if (depth === 16) throw new RangeError('Elliptic quadrature did not converge');
+    return visit(a, h / 2, depth + 1) + visit(a + h / 2, h / 2, depth + 1);
+  }
+  return visit(start, length, 0);
+}
+export function ellipticIntegrals(k2: number, ep2: number) {
+  const dn = (x: number) => Math.sqrt(1 + k2 * Math.sin(x) ** 2);
+  const densityD = (x: number) => Math.sin(x) ** 2 / dn(x);
+  const densityH = (x: number) => Math.cos(x) ** 2 / ((1 + ep2 * Math.sin(x) ** 2) * dn(x));
+  const complete = new Map<Function, number>();
+  const total = (f: (x: number) => number) => {
+    let v = complete.get(f);
+    if (v === undefined) {
+      v = integrate(f, 0, Math.PI);
+      complete.set(f, v);
+    }
+    return v;
+  };
+  const periodic = (f: (x: number) => number, start: number, delta: number) => {
+    const turns = Math.trunc(delta / Math.PI),
+      remainder = delta - turns * Math.PI;
+    return (turns ? turns * total(f) : 0) + integrate(f, start % Math.PI, remainder);
+  };
+  return {
+    E: (s: number, d: number) => periodic(dn, s, d),
+    J: (s: number, d: number) => k2 * periodic(densityD, s, d),
+    H: (s: number, d: number) => periodic(densityH, s, d),
+    meanE: () => total(dn) / Math.PI,
+    meanJ: () => (k2 * total(densityD)) / Math.PI
+  };
+}

package/src/geodesic-exact.ts

@@ -0,0 +1,290 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) Charles Karney (2012-2025)
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Auxiliary-sphere, Cayley longitude and Jacobi formulae adapted from GeographicLib 2.7 GeodesicExact/GeodesicLineExact. Original quadrature and typed API. See ../GEOGRAPHICLIB-LICENSE.txt.
+import type {GeodesicParameters, GeodesicResult, GeodesicLine} from './ellipsoid-geodesic';
+import {exactInverseEngine, angleMath, library} from './geodesic-exact/inverse-engine';
+import {ellipticIntegrals} from './geodesic-exact/quadrature';
+import {areaCorrection} from './geodesic-exact/area';
+export type ExactGeodesicOptions = {unrollLongitude?: boolean; area?: boolean};
+const DEG = Math.PI / 180;
+function point(lat: number, lon: number) {
+  if (!Number.isFinite(lat) || Math.abs(lat) > 90 || !Number.isFinite(lon) || Math.abs(lon) > 1e6)
+    throw new RangeError('Expected latitude in [-90,90] and longitude in [-1e6,1e6]');
+}
+function finite(x: number) {
+  if (!Number.isFinite(x)) throw new RangeError('Expected finite geodesic argument');
+}
+/** Elliptic-integral revolution geodesics, independently selected from the series solver.
+ * Angles are degrees. Qualified axis ratio b/a is [0.25,4], axis scales [1e-60,1e60].
+ * Signed edge area is opt-in and uses squared axis units.
+ */
+export class EllipsoidGeodesicExact {
+  private readonly engine: ReturnType<typeof exactInverseEngine>;
+  private readonly axes: readonly [number, number];
+  constructor({semiMajorAxis: a, semiMinorAxis: b}: GeodesicParameters) {
+    if (
+      !Number.isFinite(a) ||
+      !Number.isFinite(b) ||
+      Math.min(a, b) < 1e-60 ||
+      Math.max(a, b) > 1e60 ||
+      b / a < 0.25 ||
+      b / a > 4
+    )
+      throw new RangeError('Exact geodesics require axes in [1e-60,1e60] and b/a in [0.25,4]');
+    this.axes = Object.freeze([a, b] as const);
+    this.engine = exactInverseEngine(a, b);
+  }
+  get semiMajorAxis(): number {
+    return this.axes[0];
+  }
+  get semiMinorAxis(): number {
+    return this.axes[1];
+  }
+  get surfaceArea(): number {
+    return 4 * Math.PI * this.engine._c2;
+  }
+  inverse(
+    lat1: number,
+    lon1: number,
+    lat2: number,
+    lon2: number,
+    options: ExactGeodesicOptions = {}
+  ): GeodesicResult {
+    point(lat1, lon1);
+    point(lat2, lon2);
+    const result = this.engine.Inverse(
+      lat1,
+      lon1,
+      lat2,
+      lon2,
+      (library.ALL & ~library.AREA) | (options.unrollLongitude ? library.LONG_UNROLL : 0)
+    );
+    if (
+      ![result.s12, result.azi1, result.azi2, result.m12, result.M12, result.M21, result.a12].every(
+        Number.isFinite
+      )
+    )
+      throw new RangeError('Exact inverse did not converge');
+    let azimuth = result.azi1,
+      distance = result.s12;
+    const target = angleMath.sincosd(lat2),
+      f1 = this.semiMinorAxis / this.semiMajorAxis;
+    const denominator = Math.sqrt(1 - (1 - f1 * f1) * target.s * target.s);
+    const meridian = (this.semiMajorAxis * f1 * f1) / denominator ** 3;
+    const parallel = (this.semiMajorAxis * target.c) / denominator;
+    for (let iteration = 0; iteration < 8; iteration++) {
+      const endpoint = this.direct(lat1, lon1, azimuth, distance, {area: options.area});
+      const north = meridian * (lat2 - endpoint.lat2) * DEG;
+      const east =
+        parallel * angleMath.AngNormalize(angleMath.AngNormalize(lon2) - endpoint.lon2) * DEG;
+      // Propagate angular subtraction roundoff into physical endpoint units.
+      // Longitude labels near 180 degrees can lose several ulps even on short routes.
+      const rounding =
+        8 *
+          Number.EPSILON *
+          (options.area &&
+          distance !== 0 &&
+          Math.abs(distance) < 1e-5 * Math.max(this.semiMajorAxis, this.semiMinorAxis)
+            ? Math.abs(distance)
+            : Math.max(this.semiMajorAxis, this.semiMinorAxis)) +
+        4 *
+          Number.EPSILON *
+          DEG *
+          (Math.abs(meridian) * (Math.abs(lat2) + Math.abs(endpoint.lat2)) +
+            Math.abs(parallel) *
+              (Math.abs(angleMath.AngNormalize(lon2)) + Math.abs(endpoint.lon2)));
+      if (Math.hypot(north, east) <= rounding) {
+        let edgeArea = endpoint.S12;
+        if (options.area && Math.abs(lat1) < Math.abs(lat2) && Math.abs(lat2) < 90) {
+          // Evaluate area from the more polar endpoint, so terminal bearing
+          // roundoff is not amplified at a nearly polar endpoint. Reversal is
+          // algebraically exact; the reversed call cannot take this branch.
+          edgeArea = -this.inverse(lat2, lon2, lat1, lon1, {area: true}).S12!;
+        }
+        return {
+          ...endpoint,
+          lat2,
+          lon1: result.lon1,
+          lon2: result.lon2,
+          ...(options.area ? {S12: edgeArea} : {}),
+          ...(options.area && Math.abs(lat2) === 90
+            ? {S12: this.engine._c2 * angleMath.AngNormalize(result.azi2 - result.azi1) * DEG}
+            : {}),
+          // At an exact pole, preserve the inverse framework's requested-meridian
+          // bearing; a rounded direct endpoint cannot determine that convention.
+          azi2: Math.abs(lat2) === 90 ? result.azi2 : endpoint.azi2
+        };
+      }
+      if (
+        distance === 0 ||
+        (options.area ? endpoint.m12 === 0 : Math.abs(endpoint.m12) < 1e-15 * this.semiMajorAxis)
+      )
+        break;
+      const heading = angleMath.sincosd(endpoint.azi2);
+      distance += heading.c * north + heading.s * east;
+      azimuth += (heading.c * east - heading.s * north) / endpoint.m12 / DEG;
+    }
+    throw new RangeError('Exact inverse endpoint residual');
+  }
+
+  direct(
+    lat: number,
+    lon: number,
+    azimuth: number,
+    distance: number,
+    options: ExactGeodesicOptions = {}
+  ): GeodesicResult {
+    return this.line(lat, lon, azimuth, options).position(distance);
+  }
+  line(
+    lat: number,
+    lon: number,
+    azimuth: number,
+    options: ExactGeodesicOptions = {}
+  ): GeodesicLine {
+    point(lat, lon);
+    finite(azimuth);
+    const a = this.semiMajorAxis,
+      b = this.semiMinorAxis,
+      f1 = b / a,
+      ep2 = (a / b) ** 2 - 1,
+      e2 = 1 - f1 * f1;
+    const phi = angleMath.sincosd(lat),
+      alpha = angleMath.sincosd(angleMath.AngNormalize(azimuth));
+    const norm = Math.hypot(phi.s * f1, phi.c),
+      sb1 = (phi.s * f1) / norm,
+      cb1 = Math.max(1e-150, phi.c / norm);
+    const sa0 = alpha.s * cb1,
+      ca0 = Math.hypot(alpha.c, alpha.s * sb1);
+    let s1 = sb1,
+      c1 = sb1 !== 0 || alpha.c !== 0 ? cb1 * alpha.c : 1;
+    const sigmaNorm = Math.hypot(s1, c1);
+    s1 /= sigmaNorm;
+    c1 /= sigmaNorm;
+    const sig1 = Math.atan2(s1, c1);
+    const k2 = ca0 * ca0 * ep2,
+      I = ellipticIntegrals(k2, ep2),
+      dn1 = Math.sqrt(1 + k2 * s1 * s1);
+    const sign = sa0 < 0 || Object.is(sa0, -0) ? -1 : 1;
+    const includeArea = Boolean(options.area);
+    const unroll = Boolean(options.unrollLongitude),
+      azi1 = angleMath.AngNormalize(azimuth);
+    const distanceLimit = b * I.E(sig1, 4 * Math.PI);
+    const evaluate = (delta: number, distance?: number, arcDegrees?: number): GeodesicResult => {
+      const phase =
+        arcDegrees === undefined
+          ? {s: Math.sin(delta), c: Math.cos(delta)}
+          : angleMath.sincosd(arcDegrees);
+      const s2 = s1 * phase.c + c1 * phase.s,
+        c2 = c1 * phase.c - s1 * phase.s;
+      const dn2 = Math.sqrt(1 + k2 * s2 * s2),
+        J = I.J(sig1, delta);
+      const chi2 = Math.atan2(sign * sa0 * s2, f1 * dn2 * c2),
+        signedChi1 = Math.atan2(sign * sa0 * s1, f1 * dn1 * c1);
+      const t = (k2 * (s2 - s1) * (s2 + s1)) / (dn1 + dn2);
+      // Form short angular differences from cross/dot products, avoiding subtraction
+      // of near-pi phases on tiny edges. The dn difference is rationalized above.
+      const turns = Math.trunc(arcDegrees === undefined ? delta / Math.PI : arcDegrees / 180),
+        remainder = arcDegrees === undefined ? delta - turns * Math.PI : arcDegrees - turns * 180;
+      const parity = Math.abs(turns % 2) === 1 ? -1 : 1;
+      const sr = phase.s * parity;
+      const endS = s2 * parity,
+        endC = c2 * parity;
+      const chi =
+        sa0 === 0
+          ? Math.round(
+              (sign * (delta - (Math.atan2(s2, c2) - Math.atan2(s1, c1)) + (chi2 - signedChi1))) /
+                Math.PI
+            ) * Math.PI
+          : sign *
+            (turns * Math.PI +
+              (remainder === 0
+                ? 0
+                : Math.atan2(
+                    sign * sa0 * f1 * (dn1 * sr - t * s1 * endC),
+                    f1 * f1 * dn1 * dn2 * c1 * endC + sa0 * sa0 * s1 * endS
+                  )));
+      const longitude =
+        (unroll ? lon : angleMath.AngNormalize(lon)) +
+        (chi - (e2 / f1) * sa0 * I.H(sig1, delta)) / DEG;
+      const cosine = phase.c;
+      return {
+        lat1: lat,
+        lon1: unroll ? lon : angleMath.AngNormalize(lon),
+        azi1,
+        lat2: angleMath.atan2d(ca0 * s2, f1 * Math.hypot(sa0, ca0 * c2)),
+        lon2: unroll ? longitude : angleMath.AngNormalize(longitude),
+        azi2: angleMath.atan2d(sa0, ca0 * c2),
+        s12: distance === undefined ? b * I.E(sig1, delta) : distance,
+        a12: delta / DEG,
+        m12: b * (dn2 * (c1 * s2) - dn1 * (s1 * c2) - c1 * c2 * J),
+        M12: cosine + ((t * s2 - c2 * J) * s1) / dn1,
+        M21: cosine - ((t * s1 - c1 * J) * s2) / dn2,
+        ...(includeArea
+          ? {
+              S12: (() => {
+                const sd = phase.s,
+                  cd = phase.c;
+                const sine =
+                  ca0 *
+                  sa0 *
+                  (cd <= 0 ? c1 * (1 - cd) + sd * s1 : sd * ((c1 * sd) / (1 + cd) + s1));
+                const cosine = sa0 * sa0 + ca0 * ca0 * c1 * c2;
+                const angle =
+                  ca0 === 0 || sa0 === 0
+                    ? Math.atan2(
+                        sa0 * alpha.c - ca0 * c2 * alpha.s,
+                        ca0 * c2 * alpha.c + sa0 * alpha.s
+                      )
+                    : Math.atan2(sine, cosine);
+                return (
+                  this.engine._c2 * angle +
+                  (a * a * e2 * ca0 * sa0 === 0
+                    ? 0
+                    : a * a * e2 * ca0 * sa0 * areaCorrection(ep2, k2, s1, c1, delta))
+                );
+              })()
+            }
+          : {})
+      };
+    };
+    return {
+      arcPosition: (arc: number) => {
+        finite(arc);
+        if (Math.abs(arc) > 720) throw new RangeError('Exact line arc exceeds 720 degrees');
+        return evaluate(arc * DEG, undefined, arc);
+      },
+      position: (distance: number) => {
+        finite(distance);
+        if (Math.abs(distance) > distanceLimit)
+          throw new RangeError('Exact line distance exceeds support profile');
+        const target = distance / b,
+          lowDn = Math.min(1, a / b),
+          highDn = Math.max(1, a / b);
+        let lower = Math.max(-4 * Math.PI, Math.min(target / lowDn, target / highDn)),
+          upper = Math.min(4 * Math.PI, Math.max(target / lowDn, target / highDn));
+        let delta = Math.max(lower, Math.min(upper, target / I.meanE()));
+        for (let i = 0; i < 80; i++) {
+          const residual = I.E(sig1, delta) - target;
+          if (Math.abs(residual) <= Number.EPSILON * Math.max(Math.abs(target), 1e-300))
+            return evaluate(delta, distance);
+          if (residual > 0) upper = delta;
+          else lower = delta;
+          const next = delta - residual / Math.sqrt(1 + k2 * Math.sin(sig1 + delta) ** 2);
+          const value = next > lower && next < upper ? next : (lower + upper) / 2;
+          if (value === delta) return evaluate(delta, distance);
+          delta = value;
+        }
+        throw new RangeError('Exact distance inversion did not converge');
+      }
+    };
+  }
+}
+
+export {GeodesicPolygonExact} from './geodesic-exact/polygon';
+export type {
+  SurfacePolygonOptions as ExactPolygonOptions,
+  SurfacePolygonResult as ExactPolygonResult
+} from './ellipsoid-helpers/surface-polygon';