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

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

@@ -0,0 +1,85 @@
+// 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 numeric-buffer traversal around kinematic-helmert.ts's existing attributed equations and prepared coefficients. Exact matrix application follows the PROJ adaptation; small-angle matrix application follows the proj4js adaptation. See ../../../projection/PROJ-LICENSE.txt and ../../../projection/PROJ4-LICENSE.md. No model data is included.
+import type {NumericFlatOperation} from './numeric-flat';
+
+/** Borrow the stage's owned coefficients, with exactly the scalar epoch preparation. */
+export function createKinematicHelmertFlat(
+  coefficients: Float64Array,
+  prepare: (epoch: number | undefined) => void,
+  inverse: boolean
+): NumericFlatOperation {
+  return (coordinates, dimension, epochs) => {
+    const float32 = coordinates instanceof Float32Array;
+    const epochBuffer = typeof epochs === 'number' ? undefined : epochs;
+    const batchEpoch = typeof epochs === 'number' ? epochs : undefined;
+    // Call-local numeric bindings do not escape into a mutable closure or point.
+    let a = 0,
+      b = 0,
+      c = 0,
+      d = 0,
+      e = 0,
+      f = 0,
+      g = 0,
+      h = 0,
+      j = 0;
+    let dx = 0,
+      dy = 0,
+      dz = 0,
+      scale = 1;
+    for (let offset = 0, record = 0; offset < coordinates.length; offset += dimension, record++) {
+      let x = coordinates[offset],
+        y = coordinates[offset + 1],
+        z = coordinates[offset + 2];
+      const epoch = epochBuffer ? epochBuffer[record] : batchEpoch;
+      if (epochBuffer && !Number.isFinite(epoch))
+        throw new Error('Coordinate epoch must be a finite decimal year');
+      if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z))
+        throw new Error('Pipeline coordinate must be finite');
+      if (epochBuffer || offset === 0) {
+        // Preserve precedence and empty-buffer behavior: first validate XYZ, then
+        // prepare the epoch-adjusted parameters. A constant batch prepares once.
+        prepare(epoch);
+        a = coefficients[0];
+        b = coefficients[1];
+        c = coefficients[2];
+        d = coefficients[3];
+        e = coefficients[4];
+        f = coefficients[5];
+        g = coefficients[6];
+        h = coefficients[7];
+        j = coefficients[8];
+        dx = coefficients[9];
+        dy = coefficients[10];
+        dz = coefficients[11];
+        scale = coefficients[12];
+      }
+      let outX: number, outY: number, outZ: number;
+      if (inverse) {
+        x = (x - dx) / scale;
+        y = (y - dy) / scale;
+        z = (z - dz) / scale;
+        outX = a * x + d * y + g * z;
+        outY = b * x + e * y + h * z;
+        outZ = c * x + f * y + j * z;
+      } else {
+        outX = scale * (a * x + b * y + c * z) + dx;
+        outY = scale * (d * x + e * y + f * z) + dy;
+        outZ = scale * (g * x + h * y + j * z) + dz;
+      }
+      if (!Number.isFinite(outX) || !Number.isFinite(outY) || !Number.isFinite(outZ))
+        throw new Error('Pipeline coordinate must be finite');
+      if (
+        float32 &&
+        Math.max(Math.abs(outX), Math.abs(outY), Math.abs(outZ)) > 3.4028234663852886e38
+      )
+        throw new Error('Pipeline output exceeds Float32 range');
+      coordinates[offset] = outX;
+      coordinates[offset + 1] = outY;
+      coordinates[offset + 2] = outZ;
+    }
+  };
+}

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 ../../../projection/PROJ-LICENSE.txt. Small-angle equations follow the attributed proj4js adaptation in datum.ts. See ../../../projection/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,190 @@
+// 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 './engine-options';
+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,
+      this.options.resolver
+        ? async (input, config) => (await import('./crs/resolve')).prepareCRSInput(input, config)
+        : undefined
+    );
+  }
+
+  createProjection(
+    options: CreateProjectionOptions = {}
+  ): ProjectionTransform<ProjectionDescriptor> {
+    const config = {...this.options, ...options};
+    return new ProjectionTransform({
+      ...config,
+      projections: configuredProjections(config)
+    });
+  }
+
+  async createProjectionAsync(options: CreateProjectionOptions = {}): Promise<ProjectionTransform> {
+    // Public call options contain only JSON CRS metadata and primitive conventions.
+    // Capture them before optional imports yield to caller mutations.
+    let config: ProjectionEngineOptions<ProjectionDescriptor> & CreateProjectionOptions = {
+      ...this.options,
+      ...JSON.parse(JSON.stringify(options))
+    };
+    if (config.resolver) {
+      config = await (await import('./crs/resolve')).prepareEngineOptions(config);
+    }
+    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';