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

package/src/discontinuous/world-kernels/modifiedStereographic.js

@@ -0,0 +1,112 @@
+// math.gl
+// SPDX-License-Identifier: ISC
+// SPDX-FileCopyrightText: Copyright 2013-2021 Mike Bostock
+// Adapted from d3-geo-projection 4.0.0; see ../D3-LICENSE.txt.
+
+import {abs, asin, atan, atan2, cos, epsilon, sin, sqrt} from './math.js';
+
+export function modifiedStereographicRaw(C) {
+  var m = C.length - 1;
+
+  function forward(lambda, phi) {
+    var cosPhi = cos(phi),
+      k = 2 / (1 + cosPhi * cos(lambda)),
+      zr = k * cosPhi * sin(lambda),
+      zi = k * sin(phi),
+      i = m,
+      w = C[i],
+      ar = w[0],
+      ai = w[1],
+      t;
+    while (--i >= 0) {
+      w = C[i];
+      ar = w[0] + zr * (t = ar) - zi * ai;
+      ai = w[1] + zr * ai + zi * t;
+    }
+    ar = zr * (t = ar) - zi * ai;
+    ai = zr * ai + zi * t;
+    return [ar, ai];
+  }
+
+  forward.invert = function (x, y) {
+    var i = 20,
+      zr = x,
+      zi = y;
+    do {
+      var j = m,
+        w = C[j],
+        ar = w[0],
+        ai = w[1],
+        br = 0,
+        bi = 0,
+        t;
+
+      while (--j >= 0) {
+        w = C[j];
+        br = ar + zr * (t = br) - zi * bi;
+        bi = ai + zr * bi + zi * t;
+        ar = w[0] + zr * (t = ar) - zi * ai;
+        ai = w[1] + zr * ai + zi * t;
+      }
+      br = ar + zr * (t = br) - zi * bi;
+      bi = ai + zr * bi + zi * t;
+      ar = zr * (t = ar) - zi * ai - x;
+      ai = zr * ai + zi * t - y;
+
+      var denominator = br * br + bi * bi,
+        deltar,
+        deltai;
+      zr -= deltar = (ar * br + ai * bi) / denominator;
+      zi -= deltai = (ai * br - ar * bi) / denominator;
+    } while (abs(deltar) + abs(deltai) > epsilon * epsilon && --i > 0);
+
+    if (i) {
+      var rho = sqrt(zr * zr + zi * zi),
+        c = 2 * atan(rho * 0.5),
+        sinc = sin(c);
+      return [atan2(zr * sinc, rho * cos(c)), rho ? asin((zi * sinc) / rho) : 0];
+    }
+  };
+
+  return forward;
+}
+
+var alaska = [
+    [0.9972523, 0],
+    [0.0052513, -0.0041175],
+    [0.0074606, 0.0048125],
+    [-0.0153783, -0.1968253],
+    [0.0636871, -0.1408027],
+    [0.3660976, -0.2937382]
+  ],
+  gs48 = [
+    [0.98879, 0],
+    [0, 0],
+    [-0.050909, 0],
+    [0, 0],
+    [0.075528, 0]
+  ],
+  gs50 = [
+    [0.984299, 0],
+    [0.0211642, 0.0037608],
+    [-0.1036018, -0.0575102],
+    [-0.0329095, -0.0320119],
+    [0.0499471, 0.1223335],
+    [0.026046, 0.0899805],
+    [0.0007388, -0.1435792],
+    [0.0075848, -0.1334108],
+    [-0.0216473, 0.0776645],
+    [-0.0225161, 0.0853673]
+  ],
+  miller = [
+    [0.9245, 0],
+    [0, 0],
+    [0.01943, 0]
+  ],
+  lee = [
+    [0.721316, 0],
+    [0, 0],
+    [-0.00881625, -0.00617325]
+  ];
+
+export const coefficients = {alaska, gs48, gs50, miller, lee};

package/src/discontinuous/world-kernels/mollweide.js

@@ -0,0 +1,30 @@
+// math.gl
+// SPDX-License-Identifier: ISC
+// SPDX-FileCopyrightText: Copyright 2013-2021 Mike Bostock
+// Adapted from d3-geo-projection 4.0.0; see ../D3-LICENSE.txt.
+// Display factories removed; numeric kernel retained for MapEngine.
+
+import {abs, asin, cos, epsilon, halfPi, pi, sin, sqrt2} from './math.js';
+
+export function mollweideBromleyTheta(cp, phi) {
+  var cpsinPhi = cp * sin(phi),
+    i = 30,
+    delta;
+  do phi -= delta = (phi + sin(phi) - cpsinPhi) / (1 + cos(phi));
+  while (abs(delta) > epsilon && --i > 0);
+  return phi / 2;
+}
+
+export function mollweideBromleyRaw(cx, cy, cp) {
+  function forward(lambda, phi) {
+    return [cx * lambda * cos((phi = mollweideBromleyTheta(cp, phi))), cy * sin(phi)];
+  }
+
+  forward.invert = function (x, y) {
+    return (y = asin(y / cy)), [x / (cx * cos(y)), asin((2 * y + sin(2 * y)) / cp)];
+  };
+
+  return forward;
+}
+
+export var mollweideRaw = mollweideBromleyRaw(sqrt2 / halfPi, sqrt2, pi);

package/src/discontinuous/world-kernels/mtFlatPolarParabolic.js

@@ -0,0 +1,23 @@
+// math.gl
+// SPDX-License-Identifier: ISC
+// SPDX-FileCopyrightText: Copyright 2013-2021 Mike Bostock
+// Adapted from d3-geo-projection 4.0.0; see ../D3-LICENSE.txt.
+// Display factories removed; numeric kernel retained for MapEngine.
+
+import {asin, cos, sin, sqrt} from './math.js';
+
+var sqrt6 = sqrt(6),
+  sqrt7 = sqrt(7);
+
+export function mtFlatPolarParabolicRaw(lambda, phi) {
+  var theta = asin((7 * sin(phi)) / (3 * sqrt6));
+  return [(sqrt6 * lambda * (2 * cos((2 * theta) / 3) - 1)) / sqrt7, (9 * sin(theta / 3)) / sqrt7];
+}
+
+mtFlatPolarParabolicRaw.invert = function (x, y) {
+  var theta = 3 * asin((y * sqrt7) / 9);
+  return [
+    (x * sqrt7) / (sqrt6 * (2 * cos((2 * theta) / 3) - 1)),
+    asin((sin(theta) * 3 * sqrt6) / 7)
+  ];
+};

package/src/discontinuous/world-kernels/mtFlatPolarQuartic.js

@@ -0,0 +1,29 @@
+// math.gl
+// SPDX-License-Identifier: ISC
+// SPDX-FileCopyrightText: Copyright 2013-2021 Mike Bostock
+// Adapted from d3-geo-projection 4.0.0; see ../D3-LICENSE.txt.
+// Display factories removed; numeric kernel retained for MapEngine.
+
+import {abs, asin, cos, epsilon, sin, sqrt, sqrt1_2, sqrt2} from './math.js';
+
+export function mtFlatPolarQuarticRaw(lambda, phi) {
+  var k = (1 + sqrt1_2) * sin(phi),
+    theta = phi;
+  for (var i = 0, delta; i < 25; i++) {
+    theta -= delta = (sin(theta / 2) + sin(theta) - k) / (0.5 * cos(theta / 2) + cos(theta));
+    if (abs(delta) < epsilon) break;
+  }
+  return [
+    (lambda * (1 + (2 * cos(theta)) / cos(theta / 2))) / (3 * sqrt2),
+    (2 * sqrt(3) * sin(theta / 2)) / sqrt(2 + sqrt2)
+  ];
+}
+
+mtFlatPolarQuarticRaw.invert = function (x, y) {
+  var sinTheta_2 = (y * sqrt(2 + sqrt2)) / (2 * sqrt(3)),
+    theta = 2 * asin(sinTheta_2);
+  return [
+    (3 * sqrt2 * x) / (1 + (2 * cos(theta)) / cos(theta / 2)),
+    asin((sinTheta_2 + sin(theta)) / (1 + sqrt1_2))
+  ];
+};

package/src/discontinuous/world-kernels/mtFlatPolarSinusoidal.js

@@ -0,0 +1,25 @@
+// math.gl
+// SPDX-License-Identifier: ISC
+// SPDX-FileCopyrightText: Copyright 2013-2021 Mike Bostock
+// Adapted from d3-geo-projection 4.0.0; see ../D3-LICENSE.txt.
+// Display factories removed; numeric kernel retained for MapEngine.
+
+import {abs, asin, cos, epsilon, halfPi, pi, sin, sqrt} from './math.js';
+
+export function mtFlatPolarSinusoidalRaw(lambda, phi) {
+  var A = sqrt(6 / (4 + pi)),
+    k = (1 + pi / 4) * sin(phi),
+    theta = phi / 2;
+  for (var i = 0, delta; i < 25; i++) {
+    theta -= delta = (theta / 2 + sin(theta) - k) / (0.5 + cos(theta));
+    if (abs(delta) < epsilon) break;
+  }
+  return [(A * (0.5 + cos(theta)) * lambda) / 1.5, A * theta];
+}
+
+mtFlatPolarSinusoidalRaw.invert = function (x, y) {
+  var A = sqrt(6 / (4 + pi)),
+    theta = y / A;
+  if (abs(abs(theta) - halfPi) < epsilon) theta = theta < 0 ? -halfPi : halfPi;
+  return [(1.5 * x) / (A * (0.5 + cos(theta))), asin((theta / 2 + sin(theta)) / (1 + pi / 4))];
+};

package/src/discontinuous/world-kernels/naturalEarth2.js

@@ -0,0 +1,46 @@
+// math.gl
+// SPDX-License-Identifier: ISC
+// SPDX-FileCopyrightText: Copyright 2013-2021 Mike Bostock
+// Adapted from d3-geo-projection 4.0.0; see ../D3-LICENSE.txt.
+// Display factories removed; numeric kernel retained for MapEngine.
+
+import {abs, epsilon2} from './math.js';
+
+export function naturalEarth2Raw(lambda, phi) {
+  var phi2 = phi * phi,
+    phi4 = phi2 * phi2,
+    phi6 = phi2 * phi4;
+  return [
+    lambda *
+      (0.84719 -
+        0.13063 * phi2 +
+        phi6 * phi6 * (-0.04515 + 0.05494 * phi2 - 0.02326 * phi4 + 0.00331 * phi6)),
+    phi * (1.01183 + phi4 * phi4 * (-0.02625 + 0.01926 * phi2 - 0.00396 * phi4))
+  ];
+}
+
+naturalEarth2Raw.invert = function (x, y) {
+  var phi = y,
+    i = 25,
+    delta,
+    phi2,
+    phi4,
+    phi6;
+  do {
+    phi2 = phi * phi;
+    phi4 = phi2 * phi2;
+    phi -= delta =
+      (phi * (1.01183 + phi4 * phi4 * (-0.02625 + 0.01926 * phi2 - 0.00396 * phi4)) - y) /
+      (1.01183 + phi4 * phi4 * (9 * -0.02625 + 11 * 0.01926 * phi2 + 13 * -0.00396 * phi4));
+  } while (abs(delta) > epsilon2 && --i > 0);
+  phi2 = phi * phi;
+  phi4 = phi2 * phi2;
+  phi6 = phi2 * phi4;
+  return [
+    x /
+      (0.84719 -
+        0.13063 * phi2 +
+        phi6 * phi6 * (-0.04515 + 0.05494 * phi2 - 0.02326 * phi4 + 0.00331 * phi6)),
+    phi
+  ];
+};

package/src/discontinuous/world-kernels/nellHammer.js

@@ -0,0 +1,20 @@
+// math.gl
+// SPDX-License-Identifier: ISC
+// SPDX-FileCopyrightText: Copyright 2013-2021 Mike Bostock
+// Adapted from d3-geo-projection 4.0.0; see ../D3-LICENSE.txt.
+// Display factories removed; numeric kernel retained for MapEngine.
+
+import {abs, cos, epsilon, tan} from './math.js';
+
+export function nellHammerRaw(lambda, phi) {
+  return [(lambda * (1 + cos(phi))) / 2, 2 * (phi - tan(phi / 2))];
+}
+
+nellHammerRaw.invert = function (x, y) {
+  var p = y / 2;
+  for (var i = 0, delta = Infinity; i < 10 && abs(delta) > epsilon; ++i) {
+    var c = cos(y / 2);
+    y -= delta = (y - tan(y / 2) - p) / (1 - 0.5 / (c * c));
+  }
+  return [(2 * x) / (1 + cos(y)), y];
+};

package/src/discontinuous/world-kernels/newton.js

@@ -0,0 +1,77 @@
+// math.gl
+// SPDX-License-Identifier: ISC
+// SPDX-FileCopyrightText: Copyright 2013-2021 Mike Bostock
+// Adapted from d3-geo-projection 4.0.0; see ../D3-LICENSE.txt.
+// Display factories removed; numeric kernel retained for MapEngine.
+
+import {abs} from './math.js';
+
+// Finite differences need a larger step than the convergence tolerance.
+const epsilon = 1e-6,
+  epsilon2 = 1e-12;
+
+// Approximate Newton-Raphson
+// Solve f(x) = y, start from x
+export function solve(f, y, x) {
+  var steps = 100,
+    delta,
+    f0,
+    f1;
+  x = x === undefined ? 0 : +x;
+  y = +y;
+  do {
+    f0 = f(x);
+    f1 = f(x + epsilon);
+    if (f0 === f1) f1 = f0 + epsilon;
+    x -= delta = (-1 * epsilon * (f0 - y)) / (f0 - f1);
+  } while (steps-- > 0 && abs(delta) > epsilon);
+  return steps < 0 ? NaN : x;
+}
+
+// Approximate Newton-Raphson in 2D
+// Solve f(a,b) = [x,y]
+export function solve2d(f, MAX_ITERATIONS, eps) {
+  if (MAX_ITERATIONS === undefined) MAX_ITERATIONS = 40;
+  if (eps === undefined) eps = epsilon2;
+  return function (x, y, a, b) {
+    var err2, da, db;
+    a = a === undefined ? 0 : +a;
+    b = b === undefined ? 0 : +b;
+    for (var i = 0; i < MAX_ITERATIONS; i++) {
+      var p = f(a, b),
+        // diffs
+        tx = p[0] - x,
+        ty = p[1] - y;
+      if (abs(tx) < eps && abs(ty) < eps) break; // we're there!
+
+      // backtrack if we overshot
+      var h = tx * tx + ty * ty;
+      if (h > err2) {
+        a -= da /= 2;
+        b -= db /= 2;
+        continue;
+      }
+      err2 = h;
+
+      // partial derivatives
+      var ea = (a > 0 ? -1 : 1) * 1e-6,
+        eb = (b > 0 ? -1 : 1) * 1e-6,
+        pa = f(a + ea, b),
+        pb = f(a, b + eb),
+        dxa = (pa[0] - p[0]) / ea,
+        dya = (pa[1] - p[1]) / ea,
+        dxb = (pb[0] - p[0]) / eb,
+        dyb = (pb[1] - p[1]) / eb,
+        // determinant
+        D = dyb * dxa - dya * dxb,
+        // newton step — or half-step for small D
+        l = (abs(D) < 0.5 ? 0.5 : 1) / D;
+      da = (ty * dxb - tx * dyb) * l;
+      db = (tx * dya - ty * dxa) * l;
+      a += da;
+      b += db;
+      if (abs(da) < eps && abs(db) < eps) break; // we're crawling
+    }
+    return [a, b];
+  };
+}

package/src/discontinuous/world-kernels/nicolosi.js

@@ -0,0 +1,60 @@
+// math.gl
+// SPDX-License-Identifier: ISC
+// SPDX-FileCopyrightText: Copyright 2013-2021 Mike Bostock
+// Adapted from d3-geo-projection 4.0.0; see ../D3-LICENSE.txt.
+// Display factories removed; numeric kernel retained for MapEngine.
+
+import {abs, cos, halfPi, pi, sign, sin, sqrt} from './math.js';
+import {solve} from './newton.js';
+
+// Based on Torben Jansen's implementation
+// https://beta.observablehq.com/@toja/nicolosi-globular-projection
+// https://beta.observablehq.com/@toja/nicolosi-globular-inverse
+
+export function nicolosiRaw(lambda, phi) {
+  var sinPhi = sin(phi),
+    q = cos(phi),
+    s = sign(lambda);
+
+  if (lambda === 0 || abs(phi) === halfPi) return [0, phi];
+  else if (phi === 0) return [lambda, 0];
+  else if (abs(lambda) === halfPi) return [lambda * q, halfPi * sinPhi];
+
+  var b = pi / (2 * lambda) - (2 * lambda) / pi,
+    c = (2 * phi) / pi,
+    d = (1 - c * c) / (sinPhi - c);
+
+  var b2 = b * b,
+    d2 = d * d,
+    b2d2 = 1 + b2 / d2,
+    d2b2 = 1 + d2 / b2;
+
+  var M = ((b * sinPhi) / d - b / 2) / b2d2,
+    N = ((d2 * sinPhi) / b2 + d / 2) / d2b2,
+    m = M * M + (q * q) / b2d2,
+    n = N * N - ((d2 * sinPhi * sinPhi) / b2 + d * sinPhi - 1) / d2b2;
+
+  return [halfPi * (M + sqrt(m) * s), halfPi * (N + sqrt(n < 0 ? 0 : n) * sign(-phi * b) * s)];
+}
+
+nicolosiRaw.invert = function (x, y) {
+  x /= halfPi;
+  y /= halfPi;
+
+  var x2 = x * x,
+    y2 = y * y,
+    x2y2 = x2 + y2,
+    pi2 = pi * pi;
+
+  return [
+    x ? ((x2y2 - 1 + sqrt((1 - x2y2) * (1 - x2y2) + 4 * x2)) / (2 * x)) * halfPi : 0,
+    solve(function (phi) {
+      return (
+        x2y2 * (pi * sin(phi) - 2 * phi) * pi +
+        4 * phi * phi * (y - sin(phi)) +
+        2 * pi * phi -
+        pi2 * y
+      );
+    }, 0)
+  ];
+};

package/src/discontinuous/world-kernels/patterson.js

@@ -0,0 +1,45 @@
+// math.gl
+// SPDX-License-Identifier: ISC
+// SPDX-FileCopyrightText: Copyright 2013-2021 Mike Bostock
+// Adapted from d3-geo-projection 4.0.0; see ../D3-LICENSE.txt.
+// Display factories removed; numeric kernel retained for MapEngine.
+
+import {abs, epsilon} from './math.js';
+
+// Based on Java implementation by Bojan Savric.
+// https://github.com/OSUCartography/JMapProjLib/blob/master/src/com/jhlabs/map/proj/PattersonProjection.java
+
+var pattersonK1 = 1.0148,
+  pattersonK2 = 0.23185,
+  pattersonK3 = -0.14499,
+  pattersonK4 = 0.02406,
+  pattersonC1 = pattersonK1,
+  pattersonC2 = 5 * pattersonK2,
+  pattersonC3 = 7 * pattersonK3,
+  pattersonC4 = 9 * pattersonK4,
+  pattersonYmax = 1.790857183;
+
+export function pattersonRaw(lambda, phi) {
+  var phi2 = phi * phi;
+  return [
+    lambda,
+    phi * (pattersonK1 + phi2 * phi2 * (pattersonK2 + phi2 * (pattersonK3 + pattersonK4 * phi2)))
+  ];
+}
+
+pattersonRaw.invert = function (x, y) {
+  if (y > pattersonYmax) y = pattersonYmax;
+  else if (y < -pattersonYmax) y = -pattersonYmax;
+  var yc = y,
+    delta;
+
+  do {
+    // Newton-Raphson
+    var y2 = yc * yc;
+    yc -= delta =
+      (yc * (pattersonK1 + y2 * y2 * (pattersonK2 + y2 * (pattersonK3 + pattersonK4 * y2))) - y) /
+      (pattersonC1 + y2 * y2 * (pattersonC2 + y2 * (pattersonC3 + pattersonC4 * y2)));
+  } while (abs(delta) > epsilon);
+
+  return [x, yc];
+};

package/src/discontinuous/world-kernels/polyconic.js

@@ -0,0 +1,36 @@
+// math.gl
+// SPDX-License-Identifier: ISC
+// SPDX-FileCopyrightText: Copyright 2013-2021 Mike Bostock
+// Adapted from d3-geo-projection 4.0.0; see ../D3-LICENSE.txt.
+// Display factories removed; numeric kernel retained for MapEngine.
+
+import {abs, acos, asin, cos, epsilon, halfPi, sign, sin, tan} from './math.js';
+
+export function polyconicRaw(lambda, phi) {
+  if (abs(phi) < epsilon) return [lambda, 0];
+  var tanPhi = tan(phi),
+    k = lambda * sin(phi);
+  return [sin(k) / tanPhi, phi + (1 - cos(k)) / tanPhi];
+}
+
+polyconicRaw.invert = function (x, y) {
+  if (abs(y) < epsilon) return [x, 0];
+  var k = x * x + y * y,
+    phi = y * 0.5,
+    i = 10,
+    delta;
+  do {
+    var tanPhi = tan(phi),
+      secPhi = 1 / cos(phi),
+      j = k - 2 * y * phi + phi * phi;
+    phi -= delta =
+      (tanPhi * j + 2 * (phi - y)) / (2 + j * secPhi * secPhi + 2 * (phi - y) * tanPhi);
+  } while (abs(delta) > epsilon && --i > 0);
+  tanPhi = tan(phi);
+  return [
+    (abs(y) < abs(phi + 1 / tanPhi)
+      ? asin(x * tanPhi)
+      : sign(y) * sign(x) * (acos(abs(x * tanPhi)) + halfPi)) / sin(phi),
+    phi
+  ];
+};

package/src/discontinuous/world-kernels/rectangularPolyconic.js

@@ -0,0 +1,41 @@
+// math.gl
+// SPDX-License-Identifier: ISC
+// SPDX-FileCopyrightText: Copyright 2013-2021 Mike Bostock
+// Adapted from d3-geo-projection 4.0.0; see ../D3-LICENSE.txt.
+// Display factories removed; numeric kernel retained for MapEngine.
+
+import {abs, acos, asin, atan, cos, epsilon, pi, sin, tan} from './math.js';
+
+export function rectangularPolyconicRaw(phi0) {
+  var sinPhi0 = sin(phi0);
+
+  function forward(lambda, phi) {
+    var A = sinPhi0 ? tan((lambda * sinPhi0) / 2) / sinPhi0 : lambda / 2;
+    if (!phi) return [2 * A, -phi0];
+    var E = 2 * atan(A * sin(phi)),
+      cotPhi = 1 / tan(phi);
+    return [sin(E) * cotPhi, phi + (1 - cos(E)) * cotPhi - phi0];
+  }
+
+  // TODO return null for points outside outline.
+  forward.invert = function (x, y) {
+    if (abs((y += phi0)) < epsilon)
+      return [sinPhi0 ? (2 * atan((sinPhi0 * x) / 2)) / sinPhi0 : x, 0];
+    var k = x * x + y * y,
+      phi = 0,
+      i = 10,
+      delta;
+    do {
+      var tanPhi = tan(phi),
+        secPhi = 1 / cos(phi),
+        j = k - 2 * y * phi + phi * phi;
+      phi -= delta =
+        (tanPhi * j + 2 * (phi - y)) / (2 + j * secPhi * secPhi + 2 * (phi - y) * tanPhi);
+    } while (abs(delta) > epsilon && --i > 0);
+    var E = x * (tanPhi = tan(phi)),
+      A = tan(abs(y) < abs(phi + 1 / tanPhi) ? asin(E) * 0.5 : acos(E) * 0.5 + pi / 4) / sin(phi);
+    return [sinPhi0 ? (2 * atan(sinPhi0 * A)) / sinPhi0 : 2 * A, phi];
+  };
+
+  return forward;
+}

package/src/discontinuous/world-kernels/robinson.js

@@ -0,0 +1,88 @@
+// math.gl
+// SPDX-License-Identifier: ISC
+// SPDX-FileCopyrightText: Copyright 2013-2021 Mike Bostock
+// Adapted from d3-geo-projection 4.0.0; see ../D3-LICENSE.txt.
+// Display factories removed; numeric kernel retained for MapEngine.
+
+import {abs, degrees, epsilon2, floor, max, min, pi, radians, sign} from './math.js';
+
+var K = [
+  [0.9986, -0.062],
+  [1.0, 0.0],
+  [0.9986, 0.062],
+  [0.9954, 0.124],
+  [0.99, 0.186],
+  [0.9822, 0.248],
+  [0.973, 0.31],
+  [0.96, 0.372],
+  [0.9427, 0.434],
+  [0.9216, 0.4958],
+  [0.8962, 0.5571],
+  [0.8679, 0.6176],
+  [0.835, 0.6769],
+  [0.7986, 0.7346],
+  [0.7597, 0.7903],
+  [0.7186, 0.8435],
+  [0.6732, 0.8936],
+  [0.6213, 0.9394],
+  [0.5722, 0.9761],
+  [0.5322, 1.0]
+];
+
+K.forEach(function (d) {
+  d[1] *= 1.593415793900743;
+});
+
+export function robinsonRaw(lambda, phi) {
+  var i = min(18, (abs(phi) * 36) / pi),
+    i0 = floor(i),
+    di = i - i0,
+    ax = (k = K[i0])[0],
+    ay = k[1],
+    bx = (k = K[++i0])[0],
+    by = k[1],
+    cx = (k = K[min(19, ++i0)])[0],
+    cy = k[1],
+    k;
+  return [
+    lambda * (bx + (di * (cx - ax)) / 2 + (di * di * (cx - 2 * bx + ax)) / 2),
+    sign(phi) * (by + (di * (cy - ay)) / 2 + (di * di * (cy - 2 * by + ay)) / 2)
+  ];
+}
+
+robinsonRaw.invert = function (x, y) {
+  var phi = y * 90,
+    i = min(18, abs(phi / 5)),
+    i0 = max(0, floor(i));
+  do {
+    var ay = K[i0][1],
+      by = K[i0 + 1][1],
+      cy = K[min(19, i0 + 2)][1],
+      u = cy - ay,
+      v = cy - 2 * by + ay,
+      t = (2 * (abs(y) - by)) / u,
+      c = v / u,
+      di = t * (1 - c * t * (1 - 2 * c * t));
+    if (di >= 0 || i0 === 1) {
+      phi = (y >= 0 ? 5 : -5) * (di + i);
+      var j = 50,
+        delta;
+      do {
+        i = min(18, abs(phi) / 5);
+        i0 = floor(i);
+        di = i - i0;
+        ay = K[i0][1];
+        by = K[i0 + 1][1];
+        cy = K[min(19, i0 + 2)][1];
+        phi -=
+          (delta = sign(y) * (by + (di * (cy - ay)) / 2 + (di * di * (cy - 2 * by + ay)) / 2) - y) *
+          degrees;
+      } while (abs(delta) > epsilon2 && --j > 0);
+      break;
+    }
+  } while (--i0 >= 0);
+  var ax = K[i0][0],
+    bx = K[i0 + 1][0],
+    cx = K[min(19, i0 + 2)][0];
+  return [x / (bx + (di * (cx - ax)) / 2 + (di * di * (cx - 2 * bx + ax)) / 2), phi * radians];
+};

package/src/discontinuous/world-kernels/satellite.js

@@ -0,0 +1,44 @@
+// math.gl
+// SPDX-License-Identifier: ISC
+// SPDX-FileCopyrightText: Copyright 2013-2021 Mike Bostock
+// Adapted from d3-geo-projection 4.0.0; see ../D3-LICENSE.txt.
+
+import {asin, atan2, cos, sin, sqrt} from './math.js';
+
+function satelliteVerticalRaw(P) {
+  function forward(lambda, phi) {
+    var cosPhi = cos(phi),
+      k = (P - 1) / (P - cosPhi * cos(lambda));
+    return [k * cosPhi * sin(lambda), k * sin(phi)];
+  }
+
+  forward.invert = function (x, y) {
+    var rho2 = x * x + y * y,
+      rho = sqrt(rho2),
+      sinc = (P - sqrt(1 - (rho2 * (P + 1)) / (P - 1))) / ((P - 1) / rho + rho / (P - 1));
+    return [atan2(x * sinc, rho * sqrt(1 - sinc * sinc)), rho ? asin((y * sinc) / rho) : 0];
+  };
+
+  return forward;
+}
+
+export function satelliteRaw(P, omega) {
+  var vertical = satelliteVerticalRaw(P);
+  if (!omega) return vertical;
+  var cosOmega = cos(omega),
+    sinOmega = sin(omega);
+
+  function forward(lambda, phi) {
+    var coordinates = vertical(lambda, phi),
+      y = coordinates[1],
+      A = (y * sinOmega) / (P - 1) + cosOmega;
+    return [(coordinates[0] * cosOmega) / A, y / A];
+  }
+
+  forward.invert = function (x, y) {
+    var k = (P - 1) / (P - 1 - y * sinOmega);
+    return vertical.invert(k * x, k * y * cosOmega);
+  };
+
+  return forward;
+}