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

package/src/projection/experimental/kinematic-helmert.ts

@@ -0,0 +1,132 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileCopyrightText: Copyright (c) 2016, Thomas Knudsen / SDFE (PROJ)
+// SPDX-FileCopyrightText: 2014 Mike Adair, Richard Greenwood, Didier Richard, Stephen Irons, Olivier Terral and Calvin Metcalf (proj4js)
+// SPDX-FileComment: Original epoch propagation follows PROJ's kinematic Helmert contract. Exact matrix/convention transpose adapted from PROJ 9.5.1 helmert.cpp. See ../../PROJ-LICENSE.txt. Small-angle equations follow the attributed proj4js adaptation in datum.ts. See ../../PROJ4-LICENSE.md for the small-angle adaptation license.
+import {createKinematicHelmertFlat} from './kinematic-helmert-flat';
+import type {NumericFlatOperation} from './numeric-flat';
+import type {ProjectionPoint} from './types';
+import type {PipelineHelmertRates} from './projection-pipeline';
+
+/** Own coefficient snapshots; no arrays/objects are allocated inside point operations. */
+export function createKinematicHelmert(
+  translation: readonly number[],
+  rotation: readonly number[],
+  scalePPM: number,
+  rates: PipelineHelmertRates,
+  referenceEpoch: number,
+  coordinateFrame: boolean,
+  exact: boolean
+): {
+  forward: (point: ProjectionPoint, epoch?: number) => void;
+  inverse: (point: ProjectionPoint, epoch?: number) => void;
+  forwardFlat: NumericFlatOperation;
+  inverseFlat: NumericFlatOperation;
+} {
+  const base = [...translation, ...rotation, scalePPM];
+  const velocity = [
+    ...(rates.translation || [0, 0, 0]),
+    ...(rates.rotation || [0, 0, 0]),
+    rates.scalePPM || 0
+  ];
+  const arcsecond = Math.PI / (180 * 3600);
+  // Updating captured numeric bindings can box each changed coefficient. Keep
+  // mutable coefficients and the last epoch in owned typed storage instead.
+  // Row-major rotation [0..8], translation [9..11], scale [12], epoch [13].
+  const coefficients = new Float64Array(14);
+  coefficients[0] = coefficients[4] = coefficients[8] = coefficients[12] = 1;
+  coefficients[13] = NaN;
+  function prepare(epoch: number | undefined): void {
+    if (typeof epoch !== 'number' || !Number.isFinite(epoch))
+      throw new Error('Kinematic Helmert requires a finite coordinate epoch');
+    if (epoch === coefficients[13]) return;
+    const elapsed = epoch - referenceEpoch;
+    const x = base[0] + velocity[0] * elapsed,
+      y = base[1] + velocity[1] * elapsed,
+      z = base[2] + velocity[2] * elapsed,
+      rx = (base[3] + velocity[3] * elapsed) * arcsecond,
+      ry = (base[4] + velocity[4] * elapsed) * arcsecond,
+      rz = (base[5] + velocity[5] * elapsed) * arcsecond,
+      nextScale = 1 + (base[6] + velocity[6] * elapsed) / 1e6;
+    if (
+      !Number.isFinite(x) ||
+      !Number.isFinite(y) ||
+      !Number.isFinite(z) ||
+      !Number.isFinite(rx) ||
+      !Number.isFinite(ry) ||
+      !Number.isFinite(rz) ||
+      !Number.isFinite(nextScale) ||
+      nextScale <= 0
+    )
+      throw new Error('Invalid epoch-adjusted Helmert parameters or scale');
+    if (exact) {
+      const cx = Math.cos(rx),
+        sx = Math.sin(rx),
+        cy = Math.cos(ry),
+        sy = Math.sin(ry),
+        cz = Math.cos(rz),
+        sz = Math.sin(rz);
+      coefficients[0] = cy * cz;
+      coefficients[1] = cx * sz + sx * sy * cz;
+      coefficients[2] = sx * sz - cx * sy * cz;
+      coefficients[3] = -cy * sz;
+      coefficients[4] = cx * cz - sx * sy * sz;
+      coefficients[5] = sx * cz + cx * sy * sz;
+      coefficients[6] = sy;
+      coefficients[7] = -sx * cy;
+      coefficients[8] = cx * cy;
+      if (!coordinateFrame) {
+        // Transpose the full matrix without destructuring's temporary arrays.
+        let saved = coefficients[1];
+        coefficients[1] = coefficients[3];
+        coefficients[3] = saved;
+        saved = coefficients[2];
+        coefficients[2] = coefficients[6];
+        coefficients[6] = saved;
+        saved = coefficients[5];
+        coefficients[5] = coefficients[7];
+        coefficients[7] = saved;
+      }
+    } else {
+      const sign = coordinateFrame ? -1 : 1;
+      coefficients[1] = -sign * rz;
+      coefficients[2] = sign * ry;
+      coefficients[3] = sign * rz;
+      coefficients[5] = -sign * rx;
+      coefficients[6] = -sign * ry;
+      coefficients[7] = sign * rx;
+    }
+    coefficients[9] = x;
+    coefficients[10] = y;
+    coefficients[11] = z;
+    coefficients[12] = nextScale;
+    coefficients[13] = epoch;
+  }
+  return {
+    forwardFlat: createKinematicHelmertFlat(coefficients, prepare, false),
+    inverseFlat: createKinematicHelmertFlat(coefficients, prepare, true),
+    forward(point, epoch) {
+      prepare(epoch);
+      const {x, y, z} = point;
+      point.x =
+        coefficients[12] * (coefficients[0] * x + coefficients[1] * y + coefficients[2] * z) +
+        coefficients[9];
+      point.y =
+        coefficients[12] * (coefficients[3] * x + coefficients[4] * y + coefficients[5] * z) +
+        coefficients[10];
+      point.z =
+        coefficients[12] * (coefficients[6] * x + coefficients[7] * y + coefficients[8] * z) +
+        coefficients[11];
+    },
+    inverse(point, epoch) {
+      prepare(epoch);
+      const x = (point.x - coefficients[9]) / coefficients[12],
+        y = (point.y - coefficients[10]) / coefficients[12],
+        z = (point.z - coefficients[11]) / coefficients[12];
+      point.x = coefficients[0] * x + coefficients[3] * y + coefficients[6] * z;
+      point.y = coefficients[1] * x + coefficients[4] * y + coefficients[7] * z;
+      point.z = coefficients[2] * x + coefficients[5] * y + coefficients[8] * z;
+    }
+  };
+}

package/src/projection/experimental/lazy-projection.ts

@@ -0,0 +1,179 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Original convenience API over projection descriptors. Deferred kernels retain their proj4js/PROJ port notices and licenses.
+import {resolveCRSDescriptor} from './crs-descriptor';
+import type {TypeScriptCRSInput} from './crs/spatial-reference';
+import {ProjectionTransform} from './typescript-projection';
+import type {ProjectionTransformOptions} from './typescript-projection';
+import type {CRSEngine, CRSDescriptor, GetCRSOptions} from './types';
+import type {ProjectionEngineOptions, CreateProjectionOptions} from '../types';
+import {hasCRSOverrides, snapshotEngineOptions} from './projection-engine';
+import {createProjectionDescriptor, preloadProjection} from './projection-descriptor';
+import type {ProjectionDescriptor} from './projection-descriptor';
+import type {ProjectionPlugin} from './types';
+import {CORE_PARAMETERS, normalizeCRS} from './crs/normalize';
+import {lazyObliqueTransformation} from './lazy-projections/ob_tran';
+import {lazyAlbersEqualArea} from './lazy-projections/aea';
+import {lazyAzimuthalEquidistant} from './lazy-projections/aeqd';
+import {lazyBonne} from './lazy-projections/bonne';
+import {lazyCassiniSoldner} from './lazy-projections/cass';
+import {lazyCylindricalEqualArea} from './lazy-projections/cea';
+import {lazyEckertVI} from './lazy-projections/eck6';
+import {lazyEquidistantCylindrical} from './lazy-projections/eqc';
+import {lazyEquidistantConic} from './lazy-projections/eqdc';
+import {lazyEqualEarth} from './lazy-projections/eqearth';
+import {lazyEquirectangular} from './lazy-projections/equi';
+import {lazyExtendedTransverseMercator} from './lazy-projections/etmerc';
+import {lazyGeocentric} from './lazy-projections/geocent';
+import {lazyGeostationary} from './lazy-projections/geos';
+import {lazyGnomonic} from './lazy-projections/gnom';
+import {lazyGaussSchreiberTransverseMercator} from './lazy-projections/gstmerc';
+import {lazyKrovak} from './lazy-projections/krovak';
+import {lazyLambertAzimuthalEqualArea} from './lazy-projections/laea';
+import {lazyLambertConformalConic} from './lazy-projections/lcc';
+import {lazyMercator} from './lazy-projections/merc';
+import {lazyMillerCylindrical} from './lazy-projections/mill';
+import {lazyMollweide} from './lazy-projections/moll';
+import {lazyNewZealandMapGrid} from './lazy-projections/nzmg';
+import {lazyObliqueMercator} from './lazy-projections/omerc';
+import {lazyOrthographic} from './lazy-projections/ortho';
+import {lazyPolyconic} from './lazy-projections/poly';
+import {lazyQuadrilateralizedSphericalCube} from './lazy-projections/qsc';
+import {lazyRobinson} from './lazy-projections/robin';
+import {lazySinusoidal} from './lazy-projections/sinu';
+import {lazySwissObliqueMercator} from './lazy-projections/somerc';
+import {lazyStereographic} from './lazy-projections/stere';
+import {lazyObliqueStereographic} from './lazy-projections/sterea';
+import {lazyTransverseMercator} from './lazy-projections/tmerc';
+import {lazyTiltedPerspective} from './lazy-projections/tpers';
+import {lazyUniversalTransverseMercator} from './lazy-projections/utm';
+import {lazyVanDerGrinten} from './lazy-projections/vandg';
+
+type LazyTransformOptions = Omit<ProjectionTransformOptions<ProjectionDescriptor>, 'projections'>;
+const catalogue: readonly ProjectionDescriptor[] = [
+  lazyAlbersEqualArea,
+  lazyAzimuthalEquidistant,
+  lazyBonne,
+  lazyCassiniSoldner,
+  lazyCylindricalEqualArea,
+  lazyEckertVI,
+  lazyEquidistantCylindrical,
+  lazyEquidistantConic,
+  lazyEqualEarth,
+  lazyEquirectangular,
+  lazyExtendedTransverseMercator,
+  lazyGeocentric,
+  lazyGeostationary,
+  lazyGnomonic,
+  lazyGaussSchreiberTransverseMercator,
+  lazyKrovak,
+  lazyLambertAzimuthalEqualArea,
+  lazyLambertConformalConic,
+  lazyMercator,
+  lazyMillerCylindrical,
+  lazyMollweide,
+  lazyNewZealandMapGrid,
+  lazyObliqueMercator,
+  lazyOrthographic,
+  lazyPolyconic,
+  lazyQuadrilateralizedSphericalCube,
+  lazyRobinson,
+  lazySinusoidal,
+  lazySwissObliqueMercator,
+  lazyStereographic,
+  lazyObliqueStereographic,
+  lazyTransverseMercator,
+  lazyTiltedPerspective,
+  lazyUniversalTransverseMercator,
+  lazyVanDerGrinten
+];
+const key = (name: string) => name.toLowerCase().replace(/[\s_-]/g, '');
+
+/** Reusable built-in catalogue whose algorithms load only for requested CRS pairs. */
+export class LazyProjectionEngine implements CRSEngine {
+  private readonly options: Omit<ProjectionEngineOptions<ProjectionDescriptor>, 'projections'>;
+  private readonly useDefinitionSignature: boolean;
+
+  constructor(options: Omit<ProjectionEngineOptions<ProjectionDescriptor>, 'projections'> = {}) {
+    this.options = snapshotEngineOptions(options);
+    this.useDefinitionSignature = !hasCRSOverrides(options);
+  }
+
+  /** Resolve a CRS and load only its required algorithms before exposing sync conversions. */
+  getCRS(definition: TypeScriptCRSInput, options: GetCRSOptions = {}): Promise<CRSDescriptor> {
+    return resolveCRSDescriptor(
+      this,
+      definition,
+      this.options,
+      options,
+      this.useDefinitionSignature
+    );
+  }
+
+  createProjection(
+    options: CreateProjectionOptions = {}
+  ): ProjectionTransform<ProjectionDescriptor> {
+    const config = {...this.options, ...options};
+    return new ProjectionTransform({
+      ...config,
+      projections: configuredProjections(config)
+    });
+  }
+
+  createProjectionAsync(options: CreateProjectionOptions = {}): Promise<ProjectionTransform> {
+    const config = {...this.options, ...options};
+    return ProjectionTransform.create({
+      ...config,
+      projections: configuredProjections(config)
+    });
+  }
+}
+
+export const lazyProjectionEngine = new LazyProjectionEngine();
+
+function configuredProjections(options: LazyTransformOptions): ProjectionDescriptor[] {
+  const children = new Map<string, ProjectionDescriptor>();
+  for (const definition of [options.from ?? 'WGS84', options.to ?? 'WGS84']) {
+    const crs = normalizeCRS(definition, options);
+    if (key(crs.projection) !== 'obtran') continue;
+    const requested = crs.parameters['o_proj'];
+    if (!requested) throw new Error('Oblique transformation requires +o_proj');
+    const name = key(requested);
+    if (children.has(name)) continue;
+    const child = ['longlat', 'latlong', 'latlon', 'lonlat', 'identity'].includes(name)
+      ? 'longlat'
+      : catalogue.find(p => [p.name, ...(p.aliases || [])].some(alias => key(alias) === name));
+    if (!child) throw new Error('Unknown oblique transformation projection: ' + requested);
+    children.set(name, lazyObliqueTransformation(child));
+  }
+  const projections = [...catalogue];
+  if (children.size) {
+    projections.push(
+      createProjectionDescriptor({name: 'ob_tran'}, async () => {
+        const plugins = new Map<string, ProjectionPlugin>();
+        await Promise.all(
+          [...children].map(async ([name, descriptor]) => {
+            plugins.set(name, await preloadProjection(descriptor));
+          })
+        );
+        return {
+          name: 'ob_tran',
+          parameters: [...new Set([...plugins.values()].flatMap(p => p.parameters))],
+          flags: [...new Set([...plugins.values()].flatMap(p => p.flags || []))],
+          create(context) {
+            const plugin = plugins.get(key(context.parameters['o_proj'] || ''));
+            if (!plugin) throw new Error('Unregistered oblique transformation child');
+            const allowed = new Set([...CORE_PARAMETERS, ...plugin.parameters]);
+            for (const parameter of Object.keys(context.parameters)) {
+              if (!allowed.has(parameter))
+                throw new Error('Unsupported PROJ parameter: +' + parameter);
+            }
+            return plugin.create(context);
+          }
+        };
+      })
+    );
+  }
+  return projections;
+}

package/src/projection/experimental/lazy-projections/aea.ts

@@ -0,0 +1,10 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Lazy metadata for the projection engine; the algorithm retains its upstream notices.
+import {createProjectionDescriptor} from '../projection-descriptor';
+import type {ProjectionDescriptor} from '../projection-descriptor';
+export const lazyAlbersEqualArea: ProjectionDescriptor = /* @__PURE__ */ createProjectionDescriptor(
+  {name: 'aea', aliases: ['Albers_Conic_Equal_Area', 'Albers_Equal_Area', 'Albers']},
+  async () => (await import('@math.gl/geospatial/projection/projections/aea')).albersEqualArea
+);

package/src/projection/experimental/lazy-projections/aeqd.ts

@@ -0,0 +1,12 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Lazy metadata for the projection engine; the algorithm retains its upstream notices.
+import {createProjectionDescriptor} from '../projection-descriptor';
+import type {ProjectionDescriptor} from '../projection-descriptor';
+export const lazyAzimuthalEquidistant: ProjectionDescriptor =
+  /* @__PURE__ */ createProjectionDescriptor(
+    {name: 'aeqd', aliases: ['Azimuthal_Equidistant']},
+    async () =>
+      (await import('@math.gl/geospatial/projection/projections/aeqd')).azimuthalEquidistant
+  );

package/src/projection/experimental/lazy-projections/bonne.ts

@@ -0,0 +1,10 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Lazy metadata for the projection engine; the algorithm retains its upstream notices.
+import {createProjectionDescriptor} from '../projection-descriptor';
+import type {ProjectionDescriptor} from '../projection-descriptor';
+export const lazyBonne: ProjectionDescriptor = /* @__PURE__ */ createProjectionDescriptor(
+  {name: 'bonne', aliases: ['Bonne (Werner lat_1=90)']},
+  async () => (await import('@math.gl/geospatial/projection/projections/bonne')).bonne
+);

package/src/projection/experimental/lazy-projections/cass.ts

@@ -0,0 +1,10 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Lazy metadata for the projection engine; the algorithm retains its upstream notices.
+import {createProjectionDescriptor} from '../projection-descriptor';
+import type {ProjectionDescriptor} from '../projection-descriptor';
+export const lazyCassiniSoldner: ProjectionDescriptor = /* @__PURE__ */ createProjectionDescriptor(
+  {name: 'cass', aliases: ['Cassini', 'Cassini_Soldner']},
+  async () => (await import('@math.gl/geospatial/projection/projections/cass')).cassiniSoldner
+);

package/src/projection/experimental/lazy-projections/cea.ts

@@ -0,0 +1,12 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Lazy metadata for the projection engine; the algorithm retains its upstream notices.
+import {createProjectionDescriptor} from '../projection-descriptor';
+import type {ProjectionDescriptor} from '../projection-descriptor';
+export const lazyCylindricalEqualArea: ProjectionDescriptor =
+  /* @__PURE__ */ createProjectionDescriptor(
+    {name: 'cea', aliases: []},
+    async () =>
+      (await import('@math.gl/geospatial/projection/projections/cea')).cylindricalEqualArea
+  );

package/src/projection/experimental/lazy-projections/eck6.ts

@@ -0,0 +1,10 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Lazy metadata for the projection engine; the algorithm retains its upstream notices.
+import {createProjectionDescriptor} from '../projection-descriptor';
+import type {ProjectionDescriptor} from '../projection-descriptor';
+export const lazyEckertVI: ProjectionDescriptor = /* @__PURE__ */ createProjectionDescriptor(
+  {name: 'eck6', aliases: ['Eckert_VI']},
+  async () => (await import('@math.gl/geospatial/projection/projections/eck6')).eckertVI
+);

package/src/projection/experimental/lazy-projections/eqc.ts

@@ -0,0 +1,15 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Lazy metadata for the projection engine; the algorithm retains its upstream notices.
+import {createProjectionDescriptor} from '../projection-descriptor';
+import type {ProjectionDescriptor} from '../projection-descriptor';
+export const lazyEquidistantCylindrical: ProjectionDescriptor =
+  /* @__PURE__ */ createProjectionDescriptor(
+    {
+      name: 'eqc',
+      aliases: ['Equirectangular', 'Equidistant_Cylindrical', 'Equidistant_Cylindrical_Spherical']
+    },
+    async () =>
+      (await import('@math.gl/geospatial/projection/projections/eqc')).equidistantCylindrical
+  );

package/src/projection/experimental/lazy-projections/eqdc.ts

@@ -0,0 +1,11 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Lazy metadata for the projection engine; the algorithm retains its upstream notices.
+import {createProjectionDescriptor} from '../projection-descriptor';
+import type {ProjectionDescriptor} from '../projection-descriptor';
+export const lazyEquidistantConic: ProjectionDescriptor =
+  /* @__PURE__ */ createProjectionDescriptor(
+    {name: 'eqdc', aliases: ['Equidistant_Conic']},
+    async () => (await import('@math.gl/geospatial/projection/projections/eqdc')).equidistantConic
+  );

package/src/projection/experimental/lazy-projections/eqearth.ts

@@ -0,0 +1,10 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Lazy metadata for the projection engine; the algorithm retains its upstream notices.
+import {createProjectionDescriptor} from '../projection-descriptor';
+import type {ProjectionDescriptor} from '../projection-descriptor';
+export const lazyEqualEarth: ProjectionDescriptor = /* @__PURE__ */ createProjectionDescriptor(
+  {name: 'eqearth', aliases: ['Equal Earth', 'Equal_Earth']},
+  async () => (await import('@math.gl/geospatial/projection/projections/eqearth')).equalEarth
+);

package/src/projection/experimental/lazy-projections/equi.ts

@@ -0,0 +1,10 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Lazy metadata for the projection engine; the algorithm retains its upstream notices.
+import {createProjectionDescriptor} from '../projection-descriptor';
+import type {ProjectionDescriptor} from '../projection-descriptor';
+export const lazyEquirectangular: ProjectionDescriptor = /* @__PURE__ */ createProjectionDescriptor(
+  {name: 'equi', aliases: []},
+  async () => (await import('@math.gl/geospatial/projection/projections/equi')).equirectangular
+);

package/src/projection/experimental/lazy-projections/etmerc.ts

@@ -0,0 +1,12 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Lazy metadata for the projection engine; the algorithm retains its upstream notices.
+import {createProjectionDescriptor} from '../projection-descriptor';
+import type {ProjectionDescriptor} from '../projection-descriptor';
+export const lazyExtendedTransverseMercator: ProjectionDescriptor =
+  /* @__PURE__ */ createProjectionDescriptor(
+    {name: 'etmerc', aliases: ['Extended_Transverse_Mercator', 'Extended Transverse Mercator']},
+    async () =>
+      (await import('@math.gl/geospatial/projection/projections/etmerc')).extendedTransverseMercator
+  );

package/src/projection/experimental/lazy-projections/geocent.ts

@@ -0,0 +1,10 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Lazy metadata for the projection engine; the algorithm retains its upstream notices.
+import {createProjectionDescriptor} from '../projection-descriptor';
+import type {ProjectionDescriptor} from '../projection-descriptor';
+export const lazyGeocentric: ProjectionDescriptor = /* @__PURE__ */ createProjectionDescriptor(
+  {name: 'geocent', aliases: ['Geocentric', 'geocentric', 'Geocent']},
+  async () => (await import('@math.gl/geospatial/projection/projections/geocent')).geocentric
+);

package/src/projection/experimental/lazy-projections/geos.ts

@@ -0,0 +1,10 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Lazy metadata for the projection engine; the algorithm retains its upstream notices.
+import {createProjectionDescriptor} from '../projection-descriptor';
+import type {ProjectionDescriptor} from '../projection-descriptor';
+export const lazyGeostationary: ProjectionDescriptor = /* @__PURE__ */ createProjectionDescriptor(
+  {name: 'geos', aliases: ['Geostationary Satellite View', 'Geostationary_Satellite']},
+  async () => (await import('@math.gl/geospatial/projection/projections/geos')).geostationary
+);

package/src/projection/experimental/lazy-projections/gnom.ts

@@ -0,0 +1,10 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Lazy metadata for the projection engine; the algorithm retains its upstream notices.
+import {createProjectionDescriptor} from '../projection-descriptor';
+import type {ProjectionDescriptor} from '../projection-descriptor';
+export const lazyGnomonic: ProjectionDescriptor = /* @__PURE__ */ createProjectionDescriptor(
+  {name: 'gnom', aliases: []},
+  async () => (await import('@math.gl/geospatial/projection/projections/gnom')).gnomonic
+);

package/src/projection/experimental/lazy-projections/gstmerc.ts

@@ -0,0 +1,13 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Lazy metadata for the projection engine; the algorithm retains its upstream notices.
+import {createProjectionDescriptor} from '../projection-descriptor';
+import type {ProjectionDescriptor} from '../projection-descriptor';
+export const lazyGaussSchreiberTransverseMercator: ProjectionDescriptor =
+  /* @__PURE__ */ createProjectionDescriptor(
+    {name: 'gstmerc', aliases: ['gstmerg']},
+    async () =>
+      (await import('@math.gl/geospatial/projection/projections/gstmerc'))
+        .gaussSchreiberTransverseMercator
+  );

package/src/projection/experimental/lazy-projections/index.ts

@@ -0,0 +1,41 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+export {lazyMercator} from './merc';
+export {lazyEquidistantCylindrical} from './eqc';
+export {lazyLambertConformalConic} from './lcc';
+export {lazyAlbersEqualArea} from './aea';
+export {lazyEquidistantConic} from './eqdc';
+export {lazyLambertAzimuthalEqualArea} from './laea';
+export {lazyStereographic} from './stere';
+export {lazyObliqueStereographic} from './sterea';
+export {lazyAzimuthalEquidistant} from './aeqd';
+export {lazyTransverseMercator} from './tmerc';
+export {lazyExtendedTransverseMercator} from './etmerc';
+export {lazyUniversalTransverseMercator} from './utm';
+export {lazyGeocentric} from './geocent';
+export {lazyBonne} from './bonne';
+export {lazyCassiniSoldner} from './cass';
+export {lazyCylindricalEqualArea} from './cea';
+export {lazyEckertVI} from './eck6';
+export {lazyEqualEarth} from './eqearth';
+export {lazyEquirectangular} from './equi';
+export {lazyGeostationary} from './geos';
+export {lazyGnomonic} from './gnom';
+export {lazyGaussSchreiberTransverseMercator} from './gstmerc';
+export {lazyKrovak} from './krovak';
+export {lazyMillerCylindrical} from './mill';
+export {lazyMollweide} from './moll';
+export {lazyNewZealandMapGrid} from './nzmg';
+export {lazyObliqueMercator} from './omerc';
+export {lazyOrthographic} from './ortho';
+export {lazyPolyconic} from './poly';
+export {lazyQuadrilateralizedSphericalCube} from './qsc';
+export {lazyRobinson} from './robin';
+export {lazySinusoidal} from './sinu';
+export {lazySwissObliqueMercator} from './somerc';
+export {lazyTiltedPerspective} from './tpers';
+export {lazyVanDerGrinten} from './vandg';
+export {lazyObliqueTransformation} from './ob_tran';
+
+export {LazyProjectionEngine, lazyProjectionEngine} from '../lazy-projection';

package/src/projection/experimental/lazy-projections/krovak.ts

@@ -0,0 +1,18 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Lazy metadata for the projection engine; the algorithm retains its upstream notices.
+import {createProjectionDescriptor} from '../projection-descriptor';
+import type {ProjectionDescriptor} from '../projection-descriptor';
+export const lazyKrovak: ProjectionDescriptor = /* @__PURE__ */ createProjectionDescriptor(
+  {
+    name: 'krovak',
+    aliases: [
+      'Krovak',
+      'Krovak Modified',
+      'Krovak (North Orientated)',
+      'Krovak Modified (North Orientated)'
+    ]
+  },
+  async () => (await import('@math.gl/geospatial/projection/projections/krovak')).krovak
+);

package/src/projection/experimental/lazy-projections/laea.ts

@@ -0,0 +1,12 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Lazy metadata for the projection engine; the algorithm retains its upstream notices.
+import {createProjectionDescriptor} from '../projection-descriptor';
+import type {ProjectionDescriptor} from '../projection-descriptor';
+export const lazyLambertAzimuthalEqualArea: ProjectionDescriptor =
+  /* @__PURE__ */ createProjectionDescriptor(
+    {name: 'laea', aliases: ['Lambert Azimuthal Equal Area', 'Lambert_Azimuthal_Equal_Area']},
+    async () =>
+      (await import('@math.gl/geospatial/projection/projections/laea')).lambertAzimuthalEqualArea
+  );

package/src/projection/experimental/lazy-projections/lcc.ts

@@ -0,0 +1,22 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Lazy metadata for the projection engine; the algorithm retains its upstream notices.
+import {createProjectionDescriptor} from '../projection-descriptor';
+import type {ProjectionDescriptor} from '../projection-descriptor';
+export const lazyLambertConformalConic: ProjectionDescriptor =
+  /* @__PURE__ */ createProjectionDescriptor(
+    {
+      name: 'lcc',
+      aliases: [
+        'Lambert Tangential Conformal Conic Projection',
+        'Lambert_Conformal_Conic',
+        'Lambert_Conformal_Conic_1SP',
+        'Lambert_Conformal_Conic_2SP',
+        'Lambert Conic Conformal (1SP)',
+        'Lambert Conic Conformal (2SP)'
+      ]
+    },
+    async () =>
+      (await import('@math.gl/geospatial/projection/projections/lcc')).lambertConformalConic
+  );

package/src/projection/experimental/lazy-projections/merc.ts

@@ -0,0 +1,19 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Lazy metadata for the projection engine; the algorithm retains its upstream notices.
+import {createProjectionDescriptor} from '../projection-descriptor';
+import type {ProjectionDescriptor} from '../projection-descriptor';
+export const lazyMercator: ProjectionDescriptor = /* @__PURE__ */ createProjectionDescriptor(
+  {
+    name: 'merc',
+    aliases: [
+      'Mercator',
+      'Popular Visualisation Pseudo Mercator',
+      'Mercator_1SP',
+      'Mercator_Auxiliary_Sphere',
+      'Mercator_Variant_A'
+    ]
+  },
+  async () => (await import('@math.gl/geospatial/projection/projections/merc')).mercator
+);

package/src/projection/experimental/lazy-projections/mill.ts

@@ -0,0 +1,11 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Lazy metadata for the projection engine; the algorithm retains its upstream notices.
+import {createProjectionDescriptor} from '../projection-descriptor';
+import type {ProjectionDescriptor} from '../projection-descriptor';
+export const lazyMillerCylindrical: ProjectionDescriptor =
+  /* @__PURE__ */ createProjectionDescriptor(
+    {name: 'mill', aliases: ['Miller_Cylindrical']},
+    async () => (await import('@math.gl/geospatial/projection/projections/mill')).millerCylindrical
+  );

package/src/projection/experimental/lazy-projections/moll.ts

@@ -0,0 +1,10 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Lazy metadata for the projection engine; the algorithm retains its upstream notices.
+import {createProjectionDescriptor} from '../projection-descriptor';
+import type {ProjectionDescriptor} from '../projection-descriptor';
+export const lazyMollweide: ProjectionDescriptor = /* @__PURE__ */ createProjectionDescriptor(
+  {name: 'moll', aliases: ['Mollweide']},
+  async () => (await import('@math.gl/geospatial/projection/projections/moll')).mollweide
+);