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

package/src/projection/experimental/kernels/aea.ts

@@ -0,0 +1,170 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2014 Mike Adair, Richard Greenwood, Didier Richard, Stephen Irons, Olivier Terral and Calvin Metcalf (proj4js)
+// SPDX-FileComment: Direct TypeScript port of proj4js 2.22.0. See ../../../PROJ4-LICENSE.md for the upstream license and attribution.
+
+import type {KernelParameters, Point} from '../kernel';
+export type State = KernelParameters & {
+  temp: number;
+  e3: number;
+  sin_po: number;
+  cos_po: number;
+  t1: number;
+  con: number;
+  ms1: number;
+  qs1: number;
+  t2: number;
+  ms2: number;
+  qs2: number;
+  t3: number;
+  qs0: number;
+  ns0: number;
+  c: number;
+  rh: number;
+  sin_phi: number;
+  cos_phi: number;
+};
+import msfnz from '../common/msfnz';
+import qsfnz from '../common/qsfnz';
+import adjust_lon from '../common/adjust_lon';
+import asinz from '../common/asinz';
+import {EPSLN} from '../common/constants';
+
+function initialize(state: State): void {
+  if (Math.abs(state.lat1 + state.lat2) < EPSLN) {
+    return;
+  }
+  state.temp = state.b / state.a;
+  state.es = 1 - Math.pow(state.temp, 2);
+  state.e3 = Math.sqrt(state.es);
+
+  state.sin_po = Math.sin(state.lat1);
+  state.cos_po = Math.cos(state.lat1);
+  state.t1 = state.sin_po;
+  state.con = state.sin_po;
+  state.ms1 = msfnz(state.e3, state.sin_po, state.cos_po);
+  state.qs1 = qsfnz(state.e3, state.sin_po);
+
+  state.sin_po = Math.sin(state.lat2);
+  state.cos_po = Math.cos(state.lat2);
+  state.t2 = state.sin_po;
+  state.ms2 = msfnz(state.e3, state.sin_po, state.cos_po);
+  state.qs2 = qsfnz(state.e3, state.sin_po);
+
+  state.sin_po = Math.sin(state.lat0);
+  state.cos_po = Math.cos(state.lat0);
+  state.t3 = state.sin_po;
+  state.qs0 = qsfnz(state.e3, state.sin_po);
+
+  if (Math.abs(state.lat1 - state.lat2) > EPSLN) {
+    state.ns0 = (state.ms1 * state.ms1 - state.ms2 * state.ms2) / (state.qs2 - state.qs1);
+  } else {
+    state.ns0 = state.con;
+  }
+  state.c = state.ms1 * state.ms1 + state.ns0 * state.qs1;
+  state.rh = (state.a * Math.sqrt(state.c - state.ns0 * state.qs0)) / state.ns0;
+}
+
+/* Albers Conical Equal Area forward equations--mapping lat,long to x,y
+  ------------------------------------------------------------------- */
+
+export function forward(state: State, p: Point): Point | null | undefined | number {
+  var lon = p.x;
+  var lat = p.y;
+
+  state.sin_phi = Math.sin(lat);
+  state.cos_phi = Math.cos(lat);
+
+  var qs = qsfnz(state.e3, state.sin_phi);
+  var rh1 = (state.a * Math.sqrt(state.c - state.ns0 * qs)) / state.ns0;
+  var theta = state.ns0 * adjust_lon(lon - state.long0, state.over);
+  var x = rh1 * Math.sin(theta) + state.x0;
+  var y = state.rh - rh1 * Math.cos(theta) + state.y0;
+
+  p.x = x;
+  p.y = y;
+  return p;
+}
+
+export function inverse(state: State, p: Point): Point | null | undefined | number {
+  var rh1, qs, con, theta, lon, lat;
+
+  p.x -= state.x0;
+  p.y = state.rh - p.y + state.y0;
+  if (state.ns0 >= 0) {
+    rh1 = Math.sqrt(p.x * p.x + p.y * p.y);
+    con = 1;
+  } else {
+    rh1 = -Math.sqrt(p.x * p.x + p.y * p.y);
+    con = -1;
+  }
+  theta = 0;
+  if (rh1 !== 0) {
+    theta = Math.atan2(con * p.x, con * p.y);
+  }
+  con = (rh1 * state.ns0) / state.a;
+  if (state.sphere) {
+    lat = Math.asin((state.c - con * con) / (2 * state.ns0));
+  } else {
+    qs = (state.c - con * con) / state.ns0;
+    lat = phi1z(state.e3, qs);
+  }
+
+  lon = adjust_lon(theta / state.ns0 + state.long0, state.over);
+  p.x = lon;
+  p.y = lat;
+  return p;
+}
+
+/* Function to compute phi1, the latitude for the inverse of the
+   Albers Conical Equal-Area projection.
+------------------------------------------- */
+function phi1z(eccent: number, qs: number): number | null {
+  var sinphi, cosphi, con, com, dphi;
+  var phi = asinz(0.5 * qs);
+  if (eccent < EPSLN) {
+    return phi;
+  }
+
+  var eccnts = eccent * eccent;
+  for (var i = 1; i <= 25; i++) {
+    sinphi = Math.sin(phi);
+    cosphi = Math.cos(phi);
+    con = eccent * sinphi;
+    com = 1 - con * con;
+    dphi =
+      ((0.5 * com * com) / cosphi) *
+      (qs / (1 - eccnts) - sinphi / com + (0.5 / eccent) * Math.log((1 - con) / (1 + con)));
+    phi = phi + dphi;
+    if (Math.abs(dphi) <= 1e-7) {
+      return phi;
+    }
+  }
+  return null;
+}
+
+export function createState(base: KernelParameters): State {
+  const state: State = {
+    ...base,
+    temp: 0,
+    e3: 0,
+    sin_po: 0,
+    cos_po: 0,
+    t1: 0,
+    con: 0,
+    ms1: 0,
+    qs1: 0,
+    t2: 0,
+    ms2: 0,
+    qs2: 0,
+    t3: 0,
+    qs0: 0,
+    ns0: 0,
+    c: 0,
+    rh: 0,
+    sin_phi: 0,
+    cos_phi: 0
+  };
+  initialize(state);
+  return state;
+}

package/src/projection/experimental/kernels/aeqd.ts

@@ -0,0 +1,171 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2014 Mike Adair, Richard Greenwood, Didier Richard, Stephen Irons, Olivier Terral and Calvin Metcalf (proj4js)
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Adapted from proj4js 2.22.0; polar meridian integration/inversion is original math.gl code. See ../../../PROJ4-LICENSE.md for the upstream license and attribution.
+
+import type {KernelParameters, Point} from '../kernel';
+export type State = KernelParameters & {
+  sin_p12: number;
+  cos_p12: number;
+  f: number;
+};
+import adjust_lon from '../common/adjust_lon';
+import {HALF_PI, EPSLN} from '../common/constants';
+import asinz from '../common/asinz';
+import {meridianDistance, inverseMeridianDistance} from '../common/meridian-distance';
+import {vincentyDirect, vincentyInverse} from '../common/vincenty';
+
+function initialize(state: State): void {
+  state.sin_p12 = Math.sin(state.lat0);
+  state.cos_p12 = Math.cos(state.lat0);
+  state.x0 = state.x0 || 0;
+  state.y0 = state.y0 || 0;
+  state.long0 = state.long0 || 0;
+  // flattening for ellipsoid
+  state.f = state.es / (1 + Math.sqrt(1 - state.es));
+}
+
+export function forward(state: State, p: Point): Point | null | undefined | number {
+  var lon = p.x;
+  var lat = p.y;
+  var sinphi = Math.sin(p.y);
+  var cosphi = Math.cos(p.y);
+  var dlon = adjust_lon(lon - state.long0, state.over);
+  var distance, c, kp, cos_c, azi1;
+  if (state.sphere) {
+    if (Math.abs(state.sin_p12 - 1) <= EPSLN) {
+      // North Pole case
+      p.x = state.x0 + state.a * (HALF_PI - lat) * Math.sin(dlon);
+      p.y = state.y0 - state.a * (HALF_PI - lat) * Math.cos(dlon);
+      return p;
+    } else if (Math.abs(state.sin_p12 + 1) <= EPSLN) {
+      // South Pole case
+      p.x = state.x0 + state.a * (HALF_PI + lat) * Math.sin(dlon);
+      p.y = state.y0 + state.a * (HALF_PI + lat) * Math.cos(dlon);
+      return p;
+    } else {
+      // default case
+      cos_c = state.sin_p12 * sinphi + state.cos_p12 * cosphi * Math.cos(dlon);
+      c = Math.acos(cos_c);
+      kp = c ? c / Math.sin(c) : 1;
+      p.x = state.x0 + state.a * kp * cosphi * Math.sin(dlon);
+      p.y =
+        state.y0 +
+        state.a * kp * (state.cos_p12 * sinphi - state.sin_p12 * cosphi * Math.cos(dlon));
+      return p;
+    }
+  } else {
+    if (Math.abs(state.sin_p12 - 1) <= EPSLN) {
+      // North Pole case
+      distance = meridianDistance(state.a, state.es, lat, HALF_PI);
+      p.x = state.x0 + distance * Math.sin(dlon);
+      p.y = state.y0 - distance * Math.cos(dlon);
+      return p;
+    } else if (Math.abs(state.sin_p12 + 1) <= EPSLN) {
+      // South Pole case
+      distance = meridianDistance(state.a, state.es, -HALF_PI, lat);
+      p.x = state.x0 + distance * Math.sin(dlon);
+      p.y = state.y0 + distance * Math.cos(dlon);
+      return p;
+    } else {
+      // Default case
+      // Correct the upstream origin shortcut to use longitude relative to lon_0.
+      if (Math.abs(dlon) < EPSLN && Math.abs(lat - state.lat0) < EPSLN) {
+        p.x = state.x0;
+        p.y = state.y0;
+        return p;
+      }
+      vincentyInverse(state.lat0, state.long0, lat, lon, state.a, state.f, p);
+      azi1 = p.x;
+      const distance = p.y;
+      p.x = state.x0 + distance * Math.sin(azi1);
+      p.y = state.y0 + distance * Math.cos(azi1);
+      return p;
+    }
+  }
+}
+
+export function inverse(state: State, p: Point): Point | null | undefined | number {
+  p.x -= state.x0;
+  p.y -= state.y0;
+  var rh, z, sinz, cosz, lon, lat, con, Mlp, M, azi1, s12;
+  if (state.sphere) {
+    rh = Math.sqrt(p.x * p.x + p.y * p.y);
+    if (rh > 2 * HALF_PI * state.a) {
+      return null;
+    }
+    z = rh / state.a;
+
+    sinz = Math.sin(z);
+    cosz = Math.cos(z);
+
+    lon = state.long0;
+    if (Math.abs(rh) <= EPSLN) {
+      lat = state.lat0;
+    } else {
+      lat = asinz(cosz * state.sin_p12 + (p.y * sinz * state.cos_p12) / rh);
+      con = Math.abs(state.lat0) - HALF_PI;
+      if (Math.abs(con) <= EPSLN) {
+        if (state.lat0 >= 0) {
+          if (!Number.isFinite(lat)) return null;
+          lon = adjust_lon(state.long0 + Math.atan2(p.x, -p.y), state.over);
+        } else {
+          lon = adjust_lon(state.long0 - Math.atan2(-p.x, p.y), state.over);
+        }
+      } else {
+        lon = adjust_lon(
+          state.long0 +
+            Math.atan2(p.x * sinz, rh * state.cos_p12 * cosz - p.y * state.sin_p12 * sinz),
+          state.over
+        );
+      }
+    }
+
+    p.x = lon;
+    p.y = lat;
+    return p;
+  } else {
+    if (Math.abs(state.sin_p12 - 1) <= EPSLN) {
+      // North pole case
+      Mlp = meridianDistance(state.a, state.es, 0, HALF_PI);
+      rh = Math.sqrt(p.x * p.x + p.y * p.y);
+      M = Mlp - rh;
+      lat = inverseMeridianDistance(state.a, state.es, M);
+      if (!Number.isFinite(lat)) return null;
+      lon = adjust_lon(state.long0 + Math.atan2(p.x, -1 * p.y), state.over);
+      p.x = lon;
+      p.y = lat;
+      return p;
+    } else if (Math.abs(state.sin_p12 + 1) <= EPSLN) {
+      // South pole case
+      Mlp = meridianDistance(state.a, state.es, 0, HALF_PI);
+      rh = Math.sqrt(p.x * p.x + p.y * p.y);
+      M = rh - Mlp;
+
+      lat = inverseMeridianDistance(state.a, state.es, M);
+      if (!Number.isFinite(lat)) return null;
+      lon = adjust_lon(state.long0 + Math.atan2(p.x, p.y), state.over);
+      p.x = lon;
+      p.y = lat;
+      return p;
+    } else {
+      // default case
+      azi1 = Math.atan2(p.x, p.y);
+      s12 = Math.sqrt(p.x * p.x + p.y * p.y);
+      vincentyDirect(state.lat0, state.long0, azi1, s12, state.a, state.f, p);
+      return p;
+    }
+  }
+}
+
+export function createState(base: KernelParameters): State {
+  const state: State = {
+    ...base,
+    sin_p12: 0,
+    cos_p12: 0,
+    f: 0
+  };
+  initialize(state);
+  return state;
+}

package/src/projection/experimental/kernels/bonne.ts

@@ -0,0 +1,141 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2014 Mike Adair, Richard Greenwood, Didier Richard, Stephen Irons, Olivier Terral and Calvin Metcalf (proj4js)
+// SPDX-FileComment: Direct TypeScript port of proj4js 2.22.0. See ../../../PROJ4-LICENSE.md for the upstream license and attribution.
+
+import type {KernelParameters, Point} from '../kernel';
+export type State = KernelParameters & {
+  phi1: number;
+  en: number[];
+  m1: number;
+  am1: number;
+  cphi1: number;
+};
+import adjust_lat from '../common/adjust_lat';
+import adjust_lon from '../common/adjust_lon';
+import hypot from '../common/hypot';
+import pj_enfn from '../common/pj_enfn';
+import pj_inv_mlfn from '../common/pj_inv_mlfn';
+import pj_mlfn from '../common/pj_mlfn';
+import {HALF_PI} from '../common/constants';
+
+var EPS10 = 1e-10;
+
+function initialize(state: State): void {
+  var c;
+
+  state.phi1 = state.lat1;
+  if (Math.abs(state.phi1) < EPS10) {
+    throw new Error();
+  }
+  if (state.es) {
+    state.en = pj_enfn(state.es);
+    state.am1 = Math.sin(state.phi1);
+    c = Math.cos(state.phi1);
+    state.m1 = pj_mlfn(state.phi1, state.am1, c, state.en);
+    state.am1 = c / (Math.sqrt(1 - state.es * state.am1 * state.am1) * state.am1);
+  } else {
+    if (Math.abs(state.phi1) + EPS10 >= HALF_PI) {
+      state.cphi1 = 0;
+    } else {
+      state.cphi1 = 1 / Math.tan(state.phi1);
+    }
+  }
+}
+
+function e_fwd(state: State, p: Point): Point {
+  var lam = adjust_lon(p.x - (state.long0 || 0), state.over);
+  var phi = p.y;
+  var rh, E, c;
+  E = Math.sin(phi);
+  c = Math.cos(phi);
+  rh = state.am1 + state.m1 - pj_mlfn(phi, E, c, state.en);
+  E = (c * lam) / (rh * Math.sqrt(1 - state.es * E * E));
+  p.x = rh * Math.sin(E);
+  p.y = state.am1 - rh * Math.cos(E);
+
+  p.x = state.a * p.x + (state.x0 || 0);
+  p.y = state.a * p.y + (state.y0 || 0);
+  return p;
+}
+
+function e_inv(state: State, p: Point): Point {
+  p.x = (p.x - (state.x0 || 0)) / state.a;
+  p.y = (p.y - (state.y0 || 0)) / state.a;
+
+  var s, rh, lam, phi;
+  p.y = state.am1 - p.y;
+  rh = hypot(p.x, p.y);
+  if (state.phi1 < 0) rh = -rh;
+  phi = pj_inv_mlfn(state.am1 + state.m1 - rh, state.es, state.en);
+  s = Math.abs(phi);
+  if (s < HALF_PI) {
+    s = Math.sin(phi);
+    lam =
+      (rh *
+        Math.atan2(Math.sign(state.phi1) * p.x, Math.sign(state.phi1) * p.y) *
+        Math.sqrt(1 - state.es * s * s)) /
+      Math.cos(phi);
+  } else if (Math.abs(s - HALF_PI) <= EPS10) {
+    lam = 0;
+  } else {
+    throw new Error();
+  }
+  p.x = adjust_lon(lam + (state.long0 || 0), state.over);
+  p.y = adjust_lat(phi);
+  return p;
+}
+
+function s_fwd(state: State, p: Point): Point {
+  var lam = adjust_lon(p.x - (state.long0 || 0), state.over);
+  var phi = p.y;
+  var E, rh;
+  rh = state.cphi1 + state.phi1 - phi;
+  if (Math.abs(rh) > EPS10) {
+    E = (lam * Math.cos(phi)) / rh;
+    p.x = rh * Math.sin(E);
+    p.y = state.cphi1 - rh * Math.cos(E);
+  } else {
+    p.x = p.y = 0;
+  }
+
+  p.x = state.a * p.x + (state.x0 || 0);
+  p.y = state.a * p.y + (state.y0 || 0);
+  return p;
+}
+
+function s_inv(state: State, p: Point): Point {
+  p.x = (p.x - (state.x0 || 0)) / state.a;
+  p.y = (p.y - (state.y0 || 0)) / state.a;
+
+  var lam, phi;
+  p.y = state.cphi1 - p.y;
+  var rh = hypot(p.x, p.y);
+  if (state.phi1 < 0) rh = -rh;
+  phi = state.cphi1 + state.phi1 - rh;
+  if (Math.abs(phi) > HALF_PI) {
+    throw new Error();
+  }
+  if (Math.abs(Math.abs(phi) - HALF_PI) <= EPS10) {
+    lam = 0;
+  } else {
+    lam =
+      (rh * Math.atan2(Math.sign(state.phi1) * p.x, Math.sign(state.phi1) * p.y)) / Math.cos(phi);
+  }
+  p.x = adjust_lon(lam + (state.long0 || 0), state.over);
+  p.y = adjust_lat(phi);
+  return p;
+}
+
+export function forward(state: State, p: Point): Point {
+  return state.es ? e_fwd(state, p) : s_fwd(state, p);
+}
+export function inverse(state: State, p: Point): Point {
+  return state.es ? e_inv(state, p) : s_inv(state, p);
+}
+
+export function createState(base: KernelParameters, options: Partial<State> = {}): State {
+  const state: State = {...base, phi1: 0, en: [], m1: 0, am1: 0, cphi1: 0, ...options};
+  initialize(state);
+  return state;
+}

package/src/projection/experimental/kernels/cass.ts

@@ -0,0 +1,140 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2014 Mike Adair, Richard Greenwood, Didier Richard, Stephen Irons, Olivier Terral and Calvin Metcalf (proj4js)
+// SPDX-FileComment: Direct TypeScript port of proj4js 2.22.0. See ../../../PROJ4-LICENSE.md for the upstream license and attribution. Corrected series signs and inverse refinement informed by PROJ 9.5.1 cass.cpp. See ../../../PROJ-LICENSE.txt. Newton solver implementation is original math.gl code.
+
+import type {KernelParameters, Point} from '../kernel';
+export type State = KernelParameters & {
+  en: number[];
+  scratch: Point;
+  ml0: number;
+};
+import pj_enfn from '../common/pj_enfn';
+import pj_mlfn from '../common/pj_mlfn';
+import pj_inv_mlfn from '../common/pj_inv_mlfn';
+import gN from '../common/gN';
+import adjust_lon from '../common/adjust_lon';
+import adjust_lat from '../common/adjust_lat';
+import {HALF_PI, EPSLN} from '../common/constants';
+
+function initialize(state: State): void {
+  if (!state.sphere) {
+    state.en = pj_enfn(state.es);
+    state.ml0 = state.a * pj_mlfn(state.lat0, Math.sin(state.lat0), Math.cos(state.lat0), state.en);
+  }
+}
+
+/* Cassini forward equations--mapping lat,long to x,y
+  ----------------------------------------------------------------------- */
+export function forward(state: State, p: Point): Point | null | undefined | number {
+  /* Forward equations
+      ----------------- */
+  var x, y;
+  var lam = p.x;
+  var phi = p.y;
+  lam = adjust_lon(lam - state.long0, state.over);
+
+  if (state.sphere) {
+    x = state.a * Math.asin(Math.cos(phi) * Math.sin(lam));
+    y = state.a * (Math.atan2(Math.tan(phi), Math.cos(lam)) - state.lat0);
+  } else {
+    // ellipsoid
+    var sinphi = Math.sin(phi);
+    var cosphi = Math.cos(phi);
+    var nl = gN(state.a, state.e, sinphi);
+    var tl = Math.tan(phi) * Math.tan(phi);
+    var al = lam * Math.cos(phi);
+    var asq = al * al;
+    var cl = (state.es * cosphi * cosphi) / (1 - state.es);
+    var ml = state.a * pj_mlfn(phi, sinphi, cosphi, state.en);
+
+    x = nl * al * (1 - asq * tl * (1 / 6 + ((8 - tl + 8 * cl) * asq) / 120));
+    y = ml - state.ml0 + ((nl * sinphi) / cosphi) * asq * (0.5 + ((5 - tl + 6 * cl) * asq) / 24);
+  }
+
+  p.x = x + state.x0;
+  p.y = y + state.y0;
+  return p;
+}
+
+/* Inverse equations
+  ----------------- */
+export function inverse(state: State, p: Point): Point | null | undefined | number {
+  p.x -= state.x0;
+  p.y -= state.y0;
+  var x = p.x / state.a;
+  var y = p.y / state.a;
+  var phi, lam;
+
+  if (state.sphere) {
+    var dd = y + state.lat0;
+    phi = Math.asin(Math.sin(dd) * Math.cos(x));
+    lam = Math.atan2(Math.tan(x), Math.cos(dd));
+  } else {
+    /* ellipsoid */
+    var ml1 = state.ml0 / state.a + y;
+    var phi1 = pj_inv_mlfn(ml1, state.es, state.en);
+    if (Math.abs(Math.abs(phi1) - HALF_PI) <= EPSLN) {
+      p.x = state.long0;
+      p.y = Math.sign(phi1) * HALF_PI;
+      return p;
+    }
+    var nl1 = gN(state.a, state.e, Math.sin(phi1));
+
+    var rl1 = ((nl1 * nl1 * nl1) / state.a / state.a) * (1 - state.es);
+    var tl1 = Math.pow(Math.tan(phi1), 2);
+    var dl = (x * state.a) / nl1;
+    var dsq = dl * dl;
+    phi = phi1 - ((nl1 * Math.tan(phi1)) / rl1) * dl * dl * (0.5 - ((1 + 3 * tl1) * dl * dl) / 24);
+    lam = (dl * (1 - dsq * (tl1 / 3 - ((1 + 3 * tl1) * tl1 * dsq) / 15))) / Math.cos(phi1);
+  }
+
+  if (!state.sphere) {
+    // Invert the actual forward series rather than accepting the truncated inverse.
+    // Reuse instance scratch storage, including for typed-array batches.
+    const targetX = p.x + state.x0,
+      targetY = p.y + state.y0;
+    const q = state.scratch;
+    let converged = false;
+    for (let iteration = 0; iteration < 12; iteration++) {
+      evaluate(state, lam, phi);
+      const rx = q.x - targetX,
+        ry = q.y - targetY;
+      if (Math.max(Math.abs(rx), Math.abs(ry)) < 1e-7) {
+        converged = true;
+        break;
+      }
+      const h = 1e-7,
+        stepPhi = phi > HALF_PI - h ? -h : h;
+      const x0 = q.x,
+        y0 = q.y;
+      evaluate(state, lam + h, phi);
+      const a = (q.x - x0) / h,
+        c = (q.y - y0) / h;
+      evaluate(state, lam, phi + stepPhi);
+      const b = (q.x - x0) / stepPhi,
+        d = (q.y - y0) / stepPhi;
+      const determinant = a * d - b * c;
+      if (!Number.isFinite(determinant) || Math.abs(determinant) < 1e-12) break;
+      lam -= (d * rx - b * ry) / determinant;
+      phi -= (a * ry - c * rx) / determinant;
+      if (!Number.isFinite(lam) || Math.abs(phi) > HALF_PI) break;
+    }
+    if (!converged) throw new Error('Cassini inverse did not converge');
+  }
+  p.x = adjust_lon(lam + state.long0, state.over);
+  p.y = adjust_lat(phi);
+  return p;
+}
+
+function evaluate(state: State, longitude: number, latitude: number): void {
+  state.scratch.x = longitude + state.long0;
+  state.scratch.y = latitude;
+  forward(state, state.scratch);
+}
+
+export function createState(base: KernelParameters, options: Partial<State> = {}): State {
+  const state: State = {...base, en: [], scratch: {x: 0, y: 0}, ml0: 0, ...options};
+  initialize(state);
+  return state;
+}

package/src/projection/experimental/kernels/cea.ts

@@ -0,0 +1,71 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2014 Mike Adair, Richard Greenwood, Didier Richard, Stephen Irons, Olivier Terral and Calvin Metcalf (proj4js)
+// SPDX-FileComment: Direct TypeScript port of proj4js 2.22.0. See ../../../PROJ4-LICENSE.md for the upstream license and attribution.
+
+import type {KernelParameters, Point} from '../kernel';
+export type State = KernelParameters & {};
+import adjust_lon from '../common/adjust_lon';
+import qsfnz from '../common/qsfnz';
+import msfnz from '../common/msfnz';
+import iqsfnz from '../common/iqsfnz';
+
+function initialize(state: State): void {
+  // no-op
+  if (!state.sphere) {
+    state.k0 = msfnz(state.e, Math.sin(state.lat_ts), Math.cos(state.lat_ts));
+  }
+}
+
+/* Cylindrical Equal Area forward equations--mapping lat,long to x,y
+    ------------------------------------------------------------ */
+export function forward(state: State, p: Point): Point | null | undefined | number {
+  var lon = p.x;
+  var lat = p.y;
+  var x, y;
+  /* Forward equations
+      ----------------- */
+  var dlon = adjust_lon(lon - state.long0, state.over);
+  if (state.sphere) {
+    x = state.x0 + state.a * dlon * Math.cos(state.lat_ts);
+    y = state.y0 + (state.a * Math.sin(lat)) / Math.cos(state.lat_ts);
+  } else {
+    var qs = qsfnz(state.e, Math.sin(lat));
+    x = state.x0 + state.a * state.k0 * dlon;
+    y = state.y0 + (state.a * qs * 0.5) / state.k0;
+  }
+
+  p.x = x;
+  p.y = y;
+  return p;
+}
+
+/* Cylindrical Equal Area inverse equations--mapping x,y to lat/long
+    ------------------------------------------------------------ */
+export function inverse(state: State, p: Point): Point | null | undefined | number {
+  p.x -= state.x0;
+  p.y -= state.y0;
+  var lon, lat;
+
+  if (state.sphere) {
+    lon = adjust_lon(state.long0 + p.x / state.a / Math.cos(state.lat_ts), state.over);
+    lat = Math.asin((p.y / state.a) * Math.cos(state.lat_ts));
+  } else {
+    lat = iqsfnz(state.e, (2 * p.y * state.k0) / state.a);
+    lon = adjust_lon(state.long0 + p.x / (state.a * state.k0), state.over);
+  }
+
+  p.x = lon;
+  p.y = lat;
+  return p;
+}
+
+export function createState(base: KernelParameters, options: Partial<State> = {}): State {
+  const state: State = {
+    ...base,
+
+    ...options
+  };
+  initialize(state);
+  return state;
+}