@math.gl/geospatial 5.0.0-alpha.9 → 5.0.0-beta.1

package/src/discontinuous/world-kernels.ts

@@ -0,0 +1,249 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import {gilbertRaw, rectangularGringortenRaw} from './world-composite-kernels';
+import {aitoffRaw} from './world-kernels/aitoff.js';
+import {augustRaw} from './world-kernels/august.js';
+import {bakerRaw} from './world-kernels/baker.js';
+import {bertin1953Raw} from './world-kernels/bertin.js';
+import {boggsRaw} from './world-kernels/boggs.js';
+import {bromleyRaw} from './world-kernels/bromley.js';
+import {collignonRaw} from './world-kernels/collignon.js';
+import {crasterRaw} from './world-kernels/craster.js';
+import {eckert1Raw} from './world-kernels/eckert1.js';
+import {eckert2Raw} from './world-kernels/eckert2.js';
+import {eckert3Raw} from './world-kernels/eckert3.js';
+import {eckert4Raw} from './world-kernels/eckert4.js';
+import {eckert5Raw} from './world-kernels/eckert5.js';
+import {eckert6Raw} from './world-kernels/eckert6.js';
+import {eisenlohrRaw} from './world-kernels/eisenlohr.js';
+import {faheyRaw} from './world-kernels/fahey.js';
+import {foucautRaw} from './world-kernels/foucaut.js';
+import {ginzburg4Raw} from './world-kernels/ginzburg4.js';
+import {ginzburg5Raw} from './world-kernels/ginzburg5.js';
+import {ginzburg6Raw} from './world-kernels/ginzburg6.js';
+import {ginzburg8Raw} from './world-kernels/ginzburg8.js';
+import {ginzburg9Raw} from './world-kernels/ginzburg9.js';
+import {homolosineRaw} from './world-kernels/homolosine.js';
+import {kavrayskiy7Raw} from './world-kernels/kavrayskiy7.js';
+import {larriveeRaw} from './world-kernels/larrivee.js';
+import {laskowskiRaw} from './world-kernels/laskowski.js';
+import {millerRaw} from './world-kernels/miller.js';
+import {mollweideRaw} from './world-kernels/mollweide.js';
+import {mtFlatPolarParabolicRaw} from './world-kernels/mtFlatPolarParabolic.js';
+import {mtFlatPolarQuarticRaw} from './world-kernels/mtFlatPolarQuartic.js';
+import {mtFlatPolarSinusoidalRaw} from './world-kernels/mtFlatPolarSinusoidal.js';
+import {naturalEarth2Raw} from './world-kernels/naturalEarth2.js';
+import {nellHammerRaw} from './world-kernels/nellHammer.js';
+import {nicolosiRaw} from './world-kernels/nicolosi.js';
+import {pattersonRaw} from './world-kernels/patterson.js';
+import {polyconicRaw} from './world-kernels/polyconic.js';
+import {robinsonRaw} from './world-kernels/robinson.js';
+import {sinuMollweideRaw} from './world-kernels/sinuMollweide.js';
+import {sinusoidalRaw} from './world-kernels/sinusoidal.js';
+import {timesRaw} from './world-kernels/times.js';
+import {vanDerGrintenRaw} from './world-kernels/vanDerGrinten.js';
+import {vanDerGrinten2Raw} from './world-kernels/vanDerGrinten2.js';
+import {vanDerGrinten3Raw} from './world-kernels/vanDerGrinten3.js';
+import {vanDerGrinten4Raw} from './world-kernels/vanDerGrinten4.js';
+import {wagner4Raw} from './world-kernels/wagner4.js';
+import {wagner6Raw} from './world-kernels/wagner6.js';
+import {winkel3Raw} from './world-kernels/winkel3.js';
+import {bonneRaw} from './world-kernels/bonne.js';
+import {bottomleyRaw} from './world-kernels/bottomley.js';
+import {cylindricalEqualAreaRaw} from './world-kernels/cylindricalEqualArea.js';
+import {cylindricalStereographicRaw} from './world-kernels/cylindricalStereographic.js';
+import {foucautSinusoidalRaw} from './world-kernels/foucautSinusoidal.js';
+import {hammerRaw} from './world-kernels/hammer.js';
+import {hillRaw} from './world-kernels/hill.js';
+import {hufnagelRaw} from './world-kernels/hufnagel.js';
+import {hyperellipticalRaw} from './world-kernels/hyperelliptical.js';
+import {lagrangeRaw} from './world-kernels/lagrange.js';
+import {loximuthalRaw} from './world-kernels/loximuthal.js';
+import {rectangularPolyconicRaw} from './world-kernels/rectangularPolyconic.js';
+import {wagnerRaw} from './world-kernels/wagner.js';
+export type WorldKernel = ((lambda: number, phi: number) => number[]) & {
+  invert?: (x: number, y: number) => number[] | null | undefined;
+};
+function lazy(factory: () => WorldKernel): WorldKernel {
+  let kernel: WorldKernel;
+  const forward: WorldKernel = (x, y) => {
+    kernel ??= factory();
+    return kernel(x, y);
+  };
+  forward.invert = (x, y) => {
+    kernel ??= factory();
+    return kernel.invert?.(x, y);
+  };
+  return forward;
+}
+export const worldKernels = {
+  gilbert: gilbertRaw,
+  gringorten: rectangularGringortenRaw,
+  aitoff: aitoffRaw,
+  august: augustRaw,
+  baker: bakerRaw,
+  bertin1953: lazy(() => bertin1953Raw()),
+  boggs: boggsRaw,
+  bromley: bromleyRaw,
+  collignon: collignonRaw,
+  craster: crasterRaw,
+  eckert1: eckert1Raw,
+  eckert2: eckert2Raw,
+  eckert3: eckert3Raw,
+  eckert4: eckert4Raw,
+  eckert5: eckert5Raw,
+  eckert6: eckert6Raw,
+  eisenlohr: eisenlohrRaw,
+  fahey: faheyRaw,
+  foucaut: foucautRaw,
+  ginzburg4: ginzburg4Raw,
+  ginzburg5: ginzburg5Raw,
+  ginzburg6: ginzburg6Raw,
+  ginzburg8: ginzburg8Raw,
+  ginzburg9: ginzburg9Raw,
+  homolosine: homolosineRaw,
+  kavrayskiy7: kavrayskiy7Raw,
+  larrivee: larriveeRaw,
+  laskowski: laskowskiRaw,
+  miller: millerRaw,
+  mollweide: mollweideRaw,
+  'mt-flat-polar-parabolic': mtFlatPolarParabolicRaw,
+  'mt-flat-polar-quartic': mtFlatPolarQuarticRaw,
+  'mt-flat-polar-sinusoidal': mtFlatPolarSinusoidalRaw,
+  'natural-earth2': naturalEarth2Raw,
+  'nell-hammer': nellHammerRaw,
+  nicolosi: nicolosiRaw,
+  patterson: pattersonRaw,
+  polyconic: polyconicRaw,
+  robinson: robinsonRaw,
+  'sinu-mollweide': sinuMollweideRaw,
+  sinusoidal: sinusoidalRaw,
+  times: timesRaw,
+  'van-der-grinten': vanDerGrintenRaw,
+  'van-der-grinten2': vanDerGrinten2Raw,
+  'van-der-grinten3': vanDerGrinten3Raw,
+  'van-der-grinten4': vanDerGrinten4Raw,
+  wagner4: wagner4Raw,
+  wagner6: wagner6Raw,
+  winkel3: winkel3Raw,
+  bonne: lazy(() => bonneRaw((45 * Math.PI) / 180)),
+  bottomley: lazy(() => bottomleyRaw(0.5)),
+  'cylindrical-equal-area': lazy(() => cylindricalEqualAreaRaw((38.58 * Math.PI) / 180)),
+  'cylindrical-stereographic': lazy(() => cylindricalStereographicRaw((0 * Math.PI) / 180)),
+  'foucaut-sinusoidal': lazy(() => foucautSinusoidalRaw(0.5)),
+  hammer: lazy(() => hammerRaw(2)),
+  hill: lazy(() => hillRaw(1)),
+  hufnagel: lazy(() => hufnagelRaw(1, 0, (45 * Math.PI) / 180, 2)),
+  hyperelliptical: lazy(() => hyperellipticalRaw(0, 2.5, 1.183136)),
+  lagrange: lazy(() => lagrangeRaw(0.5)),
+  loximuthal: lazy(() => loximuthalRaw((40 * Math.PI) / 180)),
+  'rectangular-polyconic': lazy(() => rectangularPolyconicRaw((0 * Math.PI) / 180)),
+  wagner7: lazy(() => wagnerRaw((65 * Math.PI) / 180, Math.PI / 3, 0, 200)),
+  'quartic-authalic': lazy(() => hammerRaw(Infinity)),
+  wagner: lazy(() => wagnerRaw((65 * Math.PI) / 180, (60 * Math.PI) / 180, 20, 200))
+};
+export type WorldProjection = keyof typeof worldKernels;
+
+export type WorldProjectionParameters = {
+  a?: number;
+  alpha?: number;
+  b?: number;
+  coefficient?: number;
+  fraction?: number;
+  gamma?: number;
+  inflation?: number;
+  k?: number;
+  parallel?: number;
+  parallels?: number;
+  poleline?: number;
+  psiMax?: number;
+  ratio?: number;
+  spacing?: number;
+};
+
+export function createWorldKernel(
+  name: WorldProjection,
+  parameters: WorldProjectionParameters = {}
+): WorldKernel {
+  const table: Partial<
+    Record<
+      WorldProjection,
+      {
+        make: (...args: number[]) => WorldKernel;
+        fields: [keyof WorldProjectionParameters, number, number, number, boolean][];
+      }
+    >
+  > = {
+    bonne: {make: bonneRaw, fields: [['parallel', 45, -90, 90, true]]},
+    bottomley: {make: bottomleyRaw, fields: [['fraction', 0.5, 1e-6, 1, false]]},
+    'cylindrical-equal-area': {
+      make: cylindricalEqualAreaRaw,
+      fields: [['parallel', 38.58, -89.999, 89.999, true]]
+    },
+    'cylindrical-stereographic': {
+      make: cylindricalStereographicRaw,
+      fields: [['parallel', 0, -90, 90, true]]
+    },
+    'foucaut-sinusoidal': {make: foucautSinusoidalRaw, fields: [['alpha', 0.5, 0, 1, false]]},
+    hammer: {make: hammerRaw, fields: [['coefficient', 2, 1, 100, false]]},
+    hill: {make: hillRaw, fields: [['ratio', 1, 0, 100, false]]},
+    hufnagel: {
+      make: hufnagelRaw,
+      fields: [
+        ['a', 1, -10, 10, false],
+        ['b', 0, -10, 10, false],
+        ['psiMax', 45, 0.001, 90, true],
+        ['ratio', 2, 0.001, 1000, false]
+      ]
+    },
+    hyperelliptical: {
+      make: hyperellipticalRaw,
+      fields: [
+        ['alpha', 0, 0, 1, false],
+        ['k', 2.5, 0.1, 100, false],
+        ['gamma', 1.183136, 0.001, 1000, false]
+      ]
+    },
+    lagrange: {make: lagrangeRaw, fields: [['spacing', 0.5, 0.001, 1, false]]},
+    loximuthal: {make: loximuthalRaw, fields: [['parallel', 40, -89.999, 89.999, true]]},
+    'rectangular-polyconic': {
+      make: rectangularPolyconicRaw,
+      fields: [['parallel', 0, -90, 90, true]]
+    },
+    wagner: {
+      make: wagnerRaw,
+      fields: [
+        ['poleline', 65, 0.001, 90, true],
+        ['parallels', 60, 0.001, 179.999, true],
+        ['inflation', 20, 0, 99.999, false],
+        ['ratio', 200, 0.001, 10000, false]
+      ]
+    }
+  };
+  const entry = table[name];
+  for (const key of Object.keys(parameters))
+    if (!entry?.fields.some(f => f[0] === key))
+      throw new Error(`Unsupported ${name} parameter: ${key}`);
+  if (!entry || !Object.keys(parameters).length) return worldKernels[name] as WorldKernel;
+  const values = entry.fields.map(([key, fallback, low, high, degrees]) => {
+    const value = parameters[key] ?? fallback;
+    if (!Number.isFinite(value) || value < low || value > high)
+      throw new Error(`Invalid ${name} ${key}; expected [${low}, ${high}]`);
+    return degrees ? (value * Math.PI) / 180 : value;
+  });
+  if ((name === 'hammer' && values[0] === 1) || (name === 'lagrange' && values[0] === 1))
+    throw new Error(`Invalid ${name} parameter: the endpoint requires an antipodal clip`);
+  if (
+    ['cylindrical-stereographic', 'rectangular-polyconic'].includes(name) &&
+    Math.abs(values[0]) === Math.PI / 2
+  )
+    throw new Error(`Invalid ${name} parallel: polar endpoints are singular`);
+  const kernel = entry.make(...values);
+  for (const lat of [-1.5, -1, -0.5, 0, 0.5, 1, 1.5])
+    if (!kernel(1, lat).every(Number.isFinite))
+      throw new Error('Parameters do not define a finite world projection');
+  return kernel;
+}
+export const WORLD_PROJECTIONS = Object.freeze(Object.keys(worldKernels) as WorldProjection[]);

package/src/discontinuous/world-map.ts

@@ -0,0 +1,257 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import {CapMap} from './cap-map';
+import {DiscontinuousMap, type MapRegion} from './map-layout';
+import {RAD, geographic, coordinates, dot, type Vector, type Position} from './math';
+import {
+  worldKernels,
+  createWorldKernel,
+  type WorldProjectionParameters,
+  type WorldProjection
+} from './world-kernels';
+export type {WorldProjection, WorldProjectionParameters} from './world-kernels';
+export type WorldMapOptions = {
+  projection: WorldProjection;
+  parameters?: WorldProjectionParameters;
+  radius?: number;
+  centralMeridian?: number;
+};
+type Kernel = ((lambda: number, phi: number) => number[]) & {
+  invert?: (x: number, y: number) => number[] | null | undefined;
+};
+const PI = Math.PI,
+  HALF = PI / 2;
+const clamp = (x: number, low: number, high: number) => Math.max(low, Math.min(high, x));
+const wrap = (x: number) => ((((x + PI) % (2 * PI)) + 2 * PI) % (2 * PI)) - PI;
+
+/** Ordinary world projections with chart-local antimeridian limits and inverses. */
+export function createWorldMap({
+  projection,
+  parameters,
+  radius = 1,
+  centralMeridian = 0
+}: WorldMapOptions) {
+  if (!Object.prototype.hasOwnProperty.call(worldKernels, projection))
+    throw new Error('Unknown world projection');
+  if (!Number.isFinite(radius) || radius <= 0 || !Number.isFinite(centralMeridian))
+    throw new Error('Expected positive finite radius and finite centralMeridian');
+  const kernel = createWorldKernel(projection, parameters) as Kernel;
+  const aspect: Position =
+    projection === 'bertin1953'
+      ? [-16.5, -42]
+      : projection === 'sinu-mollweide'
+        ? [-20, -55]
+        : [0, 0];
+  return createKernelMap({kernel, radius, centralMeridian, aspect});
+}
+
+/** Internal chart builder shared by world and cap-clipped formulas. */
+export function createKernelMap({
+  kernel,
+  radius = 1,
+  centralMeridian = 0,
+  aspect = [0, 0],
+  clipAngle,
+  frame
+}: {
+  kernel: Kernel;
+  radius?: number;
+  centralMeridian?: number;
+  aspect?: readonly [number, number, number?];
+  frame?: readonly [Vector, Vector, Vector];
+  clipAngle?: number;
+}): DiscontinuousMap {
+  const cap = (clipAngle ?? 180) * RAD;
+  const raw: Kernel = (lambda, phi) => {
+    const x = Math.cos(lambda) * Math.cos(phi),
+      theta = Math.acos(clamp(x, -1, 1));
+    if (!clipAngle || theta <= cap) return kernel(lambda, phi);
+    const y = Math.sin(lambda) * Math.cos(phi),
+      z = Math.sin(phi),
+      n = Math.hypot(y, z);
+    if (n < 1e-14) return [0, 0];
+    const q = coordinates([Math.cos(cap), (Math.sin(cap) * y) / n, (Math.sin(cap) * z) / n]);
+    const p = kernel(q[0] * RAD, q[1] * RAD),
+      taper = (PI - theta) / (PI - cap);
+    return [p[0] * taper, p[1] * taper];
+  };
+  raw.invert = kernel.invert;
+  const offset = wrap((centralMeridian - aspect[0]) * RAD);
+  const pitch = aspect[1] * RAD;
+  const rotateLatitude = (p: Position, angle: number): Position => {
+    const [x, y, z] = geographic(p),
+      c = Math.cos(angle),
+      s = Math.sin(angle);
+    return coordinates([c * x - s * z, y, s * x + c * z]);
+  };
+  const roll = (aspect[2] ?? 0) * RAD;
+  const rotateRoll = (p: Position, angle: number): Position => {
+    const [x, y, z] = geographic(p),
+      c = Math.cos(angle),
+      s = Math.sin(angle);
+    return coordinates([x, c * y - s * z, s * y + c * z]);
+  };
+  const local = (p: readonly number[]): Position => {
+    if (frame) {
+      const v = geographic(p);
+      return coordinates([dot(v, frame[0]), dot(v, frame[1]), dot(v, frame[2])]);
+    }
+    let q: Position = [p[0] - offset / RAD, p[1]];
+    if (pitch) q = rotateLatitude(q, pitch);
+    if (roll) q = rotateRoll(q, roll);
+    return q;
+  };
+  const source = (p: Position): Position => {
+    if (frame) {
+      const v = geographic(p);
+      return coordinates(
+        [0, 1, 2].map(i => v[0] * frame[0][i] + v[1] * frame[1][i] + v[2] * frame[2][i]) as Vector
+      );
+    }
+    let q = roll ? rotateRoll(p, -roll) : p;
+    if (pitch) q = rotateLatitude(q, -pitch);
+    return [wrap(q[0] * RAD + offset) / RAD, q[1]];
+  };
+  const regions: MapRegion[] = [];
+  for (const sign of [1, -1])
+    for (let i = 0; i < 4; i++) {
+      if (clipAngle && clipAngle <= 90 && (i === 0 || i === 3)) continue;
+      const west = -PI + i * HALF,
+        east = west + HALF,
+        center = (west + east) / 2;
+      const south = sign < 0 ? -HALF : 0,
+        north = sign < 0 ? 0 : HALF;
+      const seeds: Position[] = [];
+      for (let x = 0; x <= 4; x++)
+        for (let y = 0; y <= 4; y++)
+          seeds.push([west + ((east - west) * x) / 4, south + ((north - south) * y) / 4]);
+      const projectedSeeds = seeds.map(p => raw(...p));
+      const inside = (p: number[]) =>
+        p?.length === 2 &&
+        p.every(Number.isFinite) &&
+        p[0] >= west - 1e-9 &&
+        p[0] <= east + 1e-9 &&
+        p[1] >= south - 1e-9 &&
+        p[1] <= north + 1e-9 &&
+        (!clipAngle || Math.cos(p[0]) * Math.cos(p[1]) >= Math.cos(cap) - 1e-12);
+      const error = (p: number[], target: readonly number[]) =>
+        Math.hypot(p[0] - target[0], p[1] - target[1]);
+      const invert = (target: readonly number[]): Position | null => {
+        // A flat pole edge is singular for a two-dimensional Newton solve.
+        // Invert its one-dimensional limit before trying interior seeds.
+        const pole = sign * HALF,
+          left = raw(west, pole),
+          right = raw(east, pole);
+        const dx = right[0] - left[0],
+          dy = right[1] - left[1],
+          length = dx * dx + dy * dy;
+        const fraction = length
+          ? clamp(((target[0] - left[0]) * dx + (target[1] - left[1]) * dy) / length, 0, 1)
+          : 0.5;
+        const poleLambda = west + fraction * (east - west);
+        if (inside([poleLambda, pole]) && error(raw(poleLambda, pole), target) < 1e-13)
+          return [poleLambda, pole];
+
+        const candidate = raw.invert?.(target[0], target[1]);
+        if (
+          candidate &&
+          inside(candidate) &&
+          error(raw(candidate[0], candidate[1]), target) < 1e-10
+        )
+          return [clamp(candidate[0], west, east), clamp(candidate[1], south, north)];
+        const ordered = seeds
+          .map((p, j) => ({p, error: error(projectedSeeds[j], target)}))
+          .filter(s => Number.isFinite(s.error) && inside(s.p) && Math.abs(s.p[1]) < HALF - 1e-10)
+          .sort((a, b) => a.error - b.error);
+        const starts: Position[] = candidate && inside(candidate) ? [candidate as Position] : [];
+        starts.push(...ordered.slice(0, 3).map(s => s.p));
+        for (const seed of starts) {
+          let lambda = clamp(seed[0], west, east),
+            phi = clamp(seed[1], south, north);
+          for (let iteration = 0; iteration < 35; iteration++) {
+            const q = raw(lambda, phi),
+              residual = error(q, target);
+            if (residual < 1e-10) return [lambda, phi];
+            const step = 1e-6;
+            const lx = clamp(lambda + step, west, east),
+              rx = lx === lambda ? lambda - step : lambda;
+            const ly = clamp(phi + step, south, north),
+              ry = ly === phi ? phi - step : phi;
+            const x0 = raw(rx, phi),
+              x1 = raw(lx, phi),
+              y0 = raw(lambda, ry),
+              y1 = raw(lambda, ly);
+            const a = (x1[0] - x0[0]) / (lx - rx),
+              b = (y1[0] - y0[0]) / (ly - ry),
+              c = (x1[1] - x0[1]) / (lx - rx),
+              d = (y1[1] - y0[1]) / (ly - ry);
+            const determinant = a * d - b * c;
+            if (!Number.isFinite(determinant) || Math.abs(determinant) < 1e-14) break;
+            const dx = (d * (q[0] - target[0]) - b * (q[1] - target[1])) / determinant;
+            const dy = (a * (q[1] - target[1]) - c * (q[0] - target[0])) / determinant;
+            let improved = false;
+            for (let damping = 1; damping >= 1 / 1024; damping /= 2) {
+              const x = clamp(lambda - damping * dx, west, east),
+                y = clamp(phi - damping * dy, south, north);
+              if (inside([x, y]) && error(raw(x, y), target) < residual) {
+                lambda = x;
+                phi = y;
+                improved = true;
+                break;
+              }
+            }
+            if (!improved) break;
+          }
+        }
+        return null;
+      };
+      regions.push({
+        id: `${sign > 0 ? 'north' : 'south'}-${i}`,
+        boundary: [
+          source([west / RAD, sign * 90]),
+          source([west / RAD, 0]),
+          source([east / RAD, 0])
+        ],
+        interior: source([center / RAD, sign * 45]),
+        placement: [radius, 0, 0, radius, 0, 0],
+        project: p => {
+          const [lon, lat] = local(p);
+          return raw(clamp(center + wrap(lon * RAD - center), west, east), lat * RAD) as Position;
+        },
+        unproject: p => {
+          const q = invert(p);
+          return q ? source([q[0] / RAD, q[1] / RAD]) : null;
+        }
+      });
+    }
+  return clipAngle
+    ? new CapMap(regions, local, source, cap, radius)
+    : new WorldMap(regions, !pitch);
+}
+
+class WorldMap extends DiscontinuousMap {
+  constructor(
+    regions: MapRegion[],
+    private readonly polarLimits: boolean
+  ) {
+    super(regions);
+  }
+  override containsConvexPolygon(
+    ring: readonly (readonly [number, number])[],
+    id: string
+  ): boolean {
+    // Pole vertices may have different incoming and outgoing meridian limits.
+    return !ring.some(p => Math.abs(p[1]) === 90) && super.containsConvexPolygon(ring, id);
+  }
+  protected override resolveSourceLimit(point: Vector, towards: Vector): Vector {
+    if (
+      this.polarLimits &&
+      Math.hypot(point[0], point[1]) < 1e-14 &&
+      Math.hypot(towards[0], towards[1]) > 1e-14
+    )
+      return geographic([Math.atan2(towards[1], towards[0]) / RAD, point[2] > 0 ? 90 : -90]);
+    return point;
+  }
+}

package/src/discontinuous.ts

@@ -0,0 +1,142 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+/** Experimental static discontinuous spherical maps. */
+export {createHealpixMap} from './discontinuous/healpix';
+export type {HealpixMapOptions} from './discontinuous/healpix';
+export {createGingeryMap} from './discontinuous/quincuncial-star';
+export type {GingeryMapOptions} from './discontinuous/quincuncial-star';
+export {createInterruptedMap} from './discontinuous/presets';
+export type {
+  InterruptedProjection,
+  InterruptedLobe,
+  InterruptedMapOptions
+} from './discontinuous/presets';
+export {DiscontinuousMap} from './discontinuous/map-layout';
+export type {
+  GeographicPosition,
+  MapPlacement,
+  MapRegion,
+  MapSeam,
+  MapPoint,
+  MapLine,
+  MapPolygon,
+  MapSamplingOptions
+} from './discontinuous/map-layout';
+export {
+  createGoodeMap,
+  createAirOceanMap,
+  createInterruptedSinusoidalMap,
+  createInterruptedMollweideMap,
+  createInterruptedHomolosineMap
+} from './discontinuous/presets';
+
+export {createAlbersUsaMap} from './discontinuous/albers-usa';
+export {
+  createPeirceQuincuncialMap,
+  createBerghausMap
+} from './discontinuous/quincuncial-star';
+export type {
+  QuincuncialMapOptions,
+  BerghausMapOptions
+} from './discontinuous/quincuncial-star';
+export {
+  getMapLayout,
+  fitMapLayout,
+  pickMapLayout
+} from './discontinuous/layout';
+export type {MapBounds, MapRegionLayout} from './discontinuous/map-layout';
+export type {
+  MapLayout,
+  MapLayoutRegion,
+  MapViewportOptions
+} from './discontinuous/layout';
+
+export {
+  createMyriahedralMap,
+  createMyriahedralLayout,
+  MyriahedralMap,
+  MYRIAHEDRAL_PRESETS
+} from './discontinuous/myriahedral';
+export {MapEngine} from './discontinuous/map-engine';
+export type {
+  MapDescription,
+  PreparedMap,
+  MapDefinition,
+  MapChartDescription,
+  MapEngineOptions,
+  MapCapabilities,
+  MapState,
+  MapPosition3D,
+  MapTransitionPlan
+} from './discontinuous/map-engine';
+export type {
+  MyriahedralOptions,
+  MyriahedralPreset,
+  MyriahedralMesh,
+  MyriahedralSolid,
+  MyriahedralEdge,
+  MyriahedralLayout
+} from './discontinuous/myriahedral';
+
+export {createGuyouMap} from './discontinuous/quincuncial-star';
+export {createGringortenQuincuncialMap} from './discontinuous/quincuncial-star';
+export {createButterflyMap} from './discontinuous/polyhedral';
+export {createCollignonButterflyMap} from './discontinuous/polyhedral';
+export {createWatermanMap} from './discontinuous/polyhedral';
+export {createGoodeOceanMap} from './discontinuous/presets';
+export {createInterruptedBoggsMap} from './discontinuous/presets';
+export {createInterruptedSinuMollweideMap} from './discontinuous/presets';
+export {createInterruptedQuarticAuthalicMap} from './discontinuous/presets';
+export {createInterruptedMollweideHemispheresMap} from './discontinuous/presets';
+export type {PolyhedralMapOptions} from './discontinuous/polyhedral';
+
+export {createGrayFullerMap} from './discontinuous/presets';
+export {createPetroffMap} from './discontinuous/petroff';
+export {createIcosahedralSnyderMap, createDodecahedralSnyderMap} from './discontinuous/snyder';
+export type {SnyderMapOptions} from './discontinuous/snyder';
+
+export {createWorldMap} from './discontinuous/world-map';
+export type {
+  WorldMapOptions,
+  WorldProjection,
+  WorldProjectionParameters
+} from './discontinuous/world-map';
+
+export {WORLD_PROJECTIONS} from './discontinuous/world-kernels';
+
+export {createRegionalMap, REGIONAL_PROJECTIONS} from './discontinuous/regional-map';
+export type {RegionalProjection, RegionalMapOptions} from './discontinuous/regional-map';
+
+export {createProjectionMap, MAP_PROJECTIONS} from './discontinuous/projection-catalog';
+export type {MapProjection, ProjectionMapOptions} from './discontinuous/projection-catalog';
+
+export {createElasticMap} from './discontinuous/elastic/map';
+export {parseElasticMap} from './discontinuous/elastic/data';
+export type {ElasticMapData, ElasticSection} from './discontinuous/elastic/data';
+export type {MapSurface} from './discontinuous/map-layout';
+
+export {MapTransition, MapTransitionGeometry} from './discontinuous/map-transition';
+export type {
+  MapTransitionOptions,
+  MapTransitionPart,
+  MapTransitionFrame
+} from './discontinuous/map-transition';
+
+export type {
+  MapFeatureGeometry,
+  MapFeature,
+  PreparedMapPart,
+  PreparedMapPathPart,
+  PreparedMapVertices,
+  PreparedMapGeometry,
+  MapPrepareFeaturesOptions
+} from './discontinuous/prepare-features';
+
+export {cutSphericalPolygon, projectSphericalPolygon} from './discontinuous/global-polygons';
+export type {
+  SphericalCutOptions,
+  SphericalCutPolygon,
+  SphericalCutEdge
+} from './discontinuous/global-polygons';

package/src/elastic.ts

@@ -0,0 +1,7 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+/** Optional, published Elastic datasets. Not imported by the main map API. */
+export {elasticI} from './discontinuous/elastic/elasticI';
+export {elasticII} from './discontinuous/elastic/elasticII';
+export {elasticIII} from './discontinuous/elastic/elasticIII';