@math.gl/projection 0.0.0-stage → 5.0.0-alpha.12

package/src/experimental/crs/wkt.ts

@@ -0,0 +1,192 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Original adapter; named-axis fallback inspired by proj4js 2.22.0 / wkt-parser (MIT). See ../../../PROJ4-LICENSE.md for upstream attribution.
+import {inferCRSRepresentation} from '@math.gl/crs/spatial-reference';
+import {parseWKTCRS} from '@math.gl/crs/wkt';
+import type {WKTCRSNode} from '@math.gl/crs';
+import type {CRSParser} from './types';
+import {unsupportedStage} from './types';
+import {readStructuredCRS} from './structured';
+import type {RecordValue} from './structured';
+
+function children(node: WKTCRSNode, ...names: string[]): WKTCRSNode[] {
+  return node.values.filter(
+    (value): value is WKTCRSNode =>
+      value.type === 'node' && names.includes(value.keyword.toUpperCase())
+  );
+}
+function child(node: WKTCRSNode, ...names: string[]): WKTCRSNode | undefined {
+  return children(node, ...names)[0];
+}
+function value(node: WKTCRSNode, index = 0): string | number | undefined {
+  const item = node.values[index];
+  return item && item.type !== 'node' ? item.value : undefined;
+}
+function units(node?: WKTCRSNode): unknown {
+  return node ? {name: value(node), conversion_factor: value(node, 1)} : undefined;
+}
+// Original WKT adapters. UNKNOWN is only recoverable from an explicit grid-axis name.
+function legacyAxisDirection(axis: WKTCRSNode, projected: boolean): string | number | undefined {
+  const direction = value(axis, 1);
+  if (projected && String(direction).toLowerCase() === 'unknown') {
+    const name = String(value(axis)).toLowerCase();
+    const match = /^(easting|northing|westing|southing)(?:\s*\([a-z]\))?$/.exec(name);
+    if (match)
+      return {easting: 'east', northing: 'north', westing: 'west', southing: 'south'}[match[1]];
+  }
+  return direction;
+}
+function axisMeridian(axis: WKTCRSNode): RecordValue | undefined {
+  const meridian = child(axis, 'MERIDIAN');
+  if (!meridian) return undefined;
+  return {longitude: {value: value(meridian), unit: units(child(meridian, 'ANGLEUNIT'))}};
+}
+function operation(node: WKTCRSNode): RecordValue {
+  const method = child(node, 'METHOD', 'PROJECTION');
+  if (!method) throw new Error('WKT conversion requires a METHOD or PROJECTION');
+  if (child(node, 'PARAMETERFILE')) unsupportedStage('Grid-based WKT operation is not implemented');
+  return {
+    method: {name: value(method)},
+    parameters: children(node, 'PARAMETER').map(parameter => ({
+      name: value(parameter),
+      value: value(parameter, 1),
+      unit: units(child(parameter, 'ANGLEUNIT', 'LENGTHUNIT', 'SCALEUNIT'))
+    }))
+  };
+}
+function readWKT(node: WKTCRSNode): RecordValue {
+  const keyword = node.keyword.toUpperCase();
+  if (keyword === 'COMPD_CS' || keyword === 'COMPOUNDCRS') {
+    return {
+      type: 'CompoundCRS',
+      components: children(
+        node,
+        'PROJCS',
+        'PROJCRS',
+        'GEOGCS',
+        'GEOGCRS',
+        'GEODCRS',
+        'BOUNDCRS',
+        'VERT_CS',
+        'VERTCRS'
+      ).map(readWKT)
+    };
+  }
+  if (keyword === 'BOUNDCRS') {
+    const source = child(node, 'SOURCECRS'),
+      target = child(node, 'TARGETCRS'),
+      transform = child(node, 'ABRIDGEDTRANSFORMATION');
+    if (!source || !target || !transform) throw new Error('Incomplete WKT BoundCRS');
+    const root = (wrapper: WKTCRSNode): WKTCRSNode => {
+      const entry = wrapper.values.find((value): value is WKTCRSNode => value.type === 'node');
+      if (!entry) throw new Error('Missing bound CRS component');
+      return entry;
+    };
+    // Abridged transformations express scale as a multiplier; PROJJSON uses ppm.
+    const op = operation(transform);
+    const parameters = op['parameters'] as RecordValue[];
+    for (const parameter of parameters) {
+      if (
+        String(parameter['name']).toLowerCase() === 'scale difference' &&
+        parameter['unit'] === undefined
+      )
+        parameter['value'] = (Number(parameter['value']) - 1) * 1e6;
+    }
+    return {
+      type: 'BoundCRS',
+      source_crs: readWKT(root(source)),
+      target_crs: readWKT(root(target)),
+      transformation: op
+    };
+  }
+  if (['VERT_CS', 'VERTCRS'].includes(keyword)) return {type: 'VerticalCRS'};
+  const projected = ['PROJCS', 'PROJCRS', 'PROJECTEDCRS'].includes(keyword);
+  const geographic = [
+    'GEOGCS',
+    'GEOGCRS',
+    'GEODCRS',
+    'GEODETICCRS',
+    'GEOGRAPHICCRS',
+    'BASEGEOGCRS',
+    'BASEGEODCRS',
+    'GEOCCS'
+  ].includes(keyword);
+  if (!projected && !geographic) unsupportedStage('Unsupported WKT CRS: ' + keyword);
+  if (child(node, 'DYNAMIC', 'DERIVINGCONVERSION', 'VELOCITYGRID', 'EXTENSION'))
+    unsupportedStage('Unsupported WKT dynamic/extension operation');
+  const cs = child(node, 'CS');
+  const geocentric =
+    keyword === 'GEOCCS' || (String(value(cs || node)).toLowerCase() === 'cartesian' && !projected);
+  const localUnit = child(node, projected || geocentric ? 'LENGTHUNIT' : 'ANGLEUNIT', 'UNIT');
+  const axes = children(node, 'AXIS')
+    .sort((a, b) => Number(value(child(a, 'ORDER') || a)) - Number(value(child(b, 'ORDER') || b)))
+    .map((axis, index) => ({
+      name: value(axis),
+      direction:
+        keyword === 'GEOCCS'
+          ? ['geocentricX', 'geocentricY', 'geocentricZ'][index]
+          : legacyAxisDirection(axis, projected),
+      unit: units(
+        child(axis, 'ANGLEUNIT', 'LENGTHUNIT') ||
+          (!geocentric && !projected && /^(up|down)$/i.test(String(value(axis, 1)))
+            ? undefined
+            : localUnit)
+      ),
+      meridian: axisMeridian(axis)
+    }));
+  if (!axes.length) {
+    for (const direction of geocentric
+      ? ['geocentricX', 'geocentricY', 'geocentricZ']
+      : ['east', 'north'])
+      axes.push({name: direction, direction, unit: units(localUnit), meridian: undefined});
+  }
+  const id = keyword === 'GEOGCS' ? undefined : child(node, 'ID');
+  const result: RecordValue = {
+    type: projected ? 'ProjectedCRS' : geocentric ? 'GeodeticCRS' : 'GeographicCRS',
+    name: value(node),
+    // WKT1 uses datum names; WKT2 base-CRS IDs select the upstream authority table.
+    id: id ? {authority: value(id), code: value(id, 1)} : undefined,
+    coordinate_system: {subtype: projected || geocentric ? 'Cartesian' : 'ellipsoidal', axis: axes}
+  };
+  if (projected) {
+    const base = child(node, 'GEOGCS', 'BASEGEOGCRS', 'BASEGEODCRS', 'GEODCRS', 'GEOGCRS');
+    if (!base) throw new Error('Projected WKT requires a base geographic CRS');
+    result['base_crs'] = readWKT(base);
+    result['conversion'] = operation(child(node, 'CONVERSION') || node);
+  } else {
+    const datum = child(node, 'DATUM', 'GEODETICDATUM', 'ENSEMBLE');
+    if (!datum) throw new Error('WKT requires a geodetic datum');
+    if (child(datum, 'EXTENSION', 'DYNAMIC')) unsupportedStage('Unsupported datum extension');
+    const ellipsoid = child(datum, 'SPHEROID', 'ELLIPSOID');
+    if (!ellipsoid) throw new Error('WKT datum requires an ellipsoid');
+    const shift = child(datum, 'TOWGS84');
+    result['datum'] = {
+      name: value(datum),
+      ellipsoid: {
+        name: value(ellipsoid),
+        semi_major_axis: value(ellipsoid, 1),
+        inverse_flattening: value(ellipsoid, 2),
+        unit: units(child(ellipsoid, 'LENGTHUNIT'))
+      },
+      towgs84: shift?.values.map((_, index) => value(shift, index))
+    };
+    const pm = child(node, 'PRIMEM');
+    if (pm)
+      result['prime_meridian'] = {
+        name: value(pm),
+        longitude: value(pm, 1),
+        unit: units(child(pm, 'ANGLEUNIT') || (geocentric ? undefined : localUnit))
+      };
+    result['angular_unit'] = geocentric ? undefined : units(localUnit);
+  }
+  return result;
+}
+export const wktCRSParser: CRSParser = {
+  name: 'wkt',
+  canParse: definition => inferCRSRepresentation(definition) === 'wkt',
+  parse(definition, options) {
+    if (typeof definition !== 'string') throw new Error('Expected serialized WKT');
+    return readStructuredCRS(readWKT(parseWKTCRS(definition).root), options);
+  }
+};

package/src/experimental/datum.ts

@@ -0,0 +1,185 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2014 Mike Adair, Richard Greenwood, Didier Richard, Stephen Irons, Olivier Terral and Calvin Metcalf (proj4js)
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Helmert equations directly adapted from proj4js 2.22.0 datumUtils.js. See ../../PROJ4-LICENSE.md. Geocentric equations now delegate to the attributed @math.gl/core/spheroid leaf.
+import {spheroidToCartesian, cartesianToSpheroid} from '@math.gl/core/spheroid';
+import type {Datum, Ellipsoid} from './crs/types';
+import type {ProjectionPoint} from './types';
+export type Coordinate3D = [number, number, number];
+const ARC_SECOND = Math.PI / (180 * 3600);
+const WGS84: Datum = {
+  ellipsoid: {
+    semiMajorAxis: 6378137,
+    semiMinorAxis: 6356752.314245179,
+    eccentricitySquared: 0.0066943799901413165
+  },
+  towgs84: [0, 0, 0]
+};
+
+export function geodeticToGeocentricInPlace(point: ProjectionPoint, ellipsoid: Ellipsoid): void {
+  if (Math.abs(point.y) > Math.PI / 2) throw new Error('Latitude outside geocentric domain');
+  if (!spheroidToCartesian(point, ellipsoid))
+    throw new Error('Geocentric coordinate must be finite');
+}
+
+/** Projection retains its center error and historical near-axis canonicalization. */
+export function geocentricToGeodeticInPlace(point: ProjectionPoint, ellipsoid: Ellipsoid): void {
+  const x = point.x,
+    y = point.y,
+    z = point.z;
+  const {semiMajorAxis: a, semiMinorAxis: b, eccentricitySquared: es} = ellipsoid;
+  if (x === 0 && y === 0 && z === 0)
+    throw new Error('Geodetic coordinates are undefined at the Earth center');
+  if (
+    es !== 0 &&
+    Math.abs(x) < 1e-12 * a &&
+    Math.abs(y) < 1e-12 * a &&
+    Math.hypot(x, y) < 1e-12 * a
+  ) {
+    if (!Number.isFinite(Math.hypot(x, y, z))) throw new Error('Geocentric radius must be finite');
+    point.x = 0;
+    point.y = (Math.sign(z) * Math.PI) / 2;
+    point.z = Math.abs(z) - b;
+    return;
+  }
+  if (!cartesianToSpheroid(point, ellipsoid)) {
+    if (!Number.isFinite(Math.hypot(x, y, z))) throw new Error('Geocentric radius must be finite');
+    throw new Error('Geocentric inverse did not converge');
+  }
+}
+
+/** Convert rotation units and scale once for the lifetime of a compiled datum stage. */
+export function createHelmert(values: readonly number[], inverse: boolean): DatumOperation {
+  const dx = values[0],
+    dy = values[1],
+    dz = values[2];
+  const rx = (values[3] || 0) * ARC_SECOND,
+    ry = (values[4] || 0) * ARC_SECOND,
+    rz = (values[5] || 0) * ARC_SECOND;
+  const scale = 1 + (values[6] || 0) / 1e6;
+  return inverse
+    ? point => {
+        const x = (point.x - dx) / scale,
+          y = (point.y - dy) / scale,
+          z = (point.z - dz) / scale;
+        point.x = x + rz * y - ry * z;
+        point.y = -rz * x + y + rx * z;
+        point.z = ry * x - rx * y + z;
+      }
+    : point => {
+        const x = point.x,
+          y = point.y,
+          z = point.z;
+        point.x = scale * (x - rz * y + ry * z) + dx;
+        point.y = scale * (rz * x + y - rx * z) + dy;
+        point.z = scale * (-ry * x + rx * y + z) + dz;
+      };
+}
+function shifted(datum: Datum): boolean {
+  return Boolean(datum.towgs84?.some(value => value !== 0));
+}
+type DatumOperation = (point: ProjectionPoint) => void;
+/** Resolve identity, grid and Helmert stages once, outside coordinate loops. */
+export function createDatumTransform(
+  source: Datum,
+  destination: Datum
+): DatumOperation | undefined {
+  // datum=none disables the entire chain, including a shifted opposite endpoint.
+  if (!source.towgs84 || !destination.towgs84) return undefined;
+  if (source.grids || destination.grids) {
+    if (
+      source.grids &&
+      destination.grids &&
+      source.ellipsoid.semiMajorAxis === destination.ellipsoid.semiMajorAxis &&
+      source.ellipsoid.eccentricitySquared === destination.ellipsoid.eccentricitySquared &&
+      source.grids.length === destination.grids.length &&
+      source.grids.every(
+        (entry, i) =>
+          entry.name === destination.grids[i].name &&
+          entry.optional === destination.grids[i].optional &&
+          entry.grid === destination.grids[i].grid
+      )
+    )
+      return undefined;
+    const middle = createDatumTransform(
+      source.grids ? WGS84 : source,
+      destination.grids ? WGS84 : destination
+    );
+    return point => {
+      if (source.grids) applyDatumGrids(point, source, false);
+      middle?.(point);
+      if (destination.grids) applyDatumGrids(point, destination, true);
+    };
+  }
+  if (shifted(source) || shifted(destination)) {
+    const first = convertDatum(source, WGS84),
+      second = convertDatum(WGS84, destination);
+    return point => {
+      first?.(point);
+      second?.(point);
+    };
+  }
+  return convertDatum(source, destination);
+}
+function convertDatum(from: Datum, to: Datum): DatumOperation | undefined {
+  if (!from.towgs84 || !to.towgs84) return undefined;
+  const a = from.ellipsoid,
+    b = to.ellipsoid;
+  let sameParameters = true;
+  for (let i = 0; i < 7; i++)
+    if ((from.towgs84[i] || 0) !== (to.towgs84[i] || 0)) sameParameters = false;
+  if (
+    a.semiMajorAxis === b.semiMajorAxis &&
+    Math.abs(a.eccentricitySquared - b.eccentricitySquared) <= 5e-11 &&
+    sameParameters
+  )
+    return undefined;
+  const sourceShift = shifted(from) ? createHelmert(from.towgs84, false) : undefined,
+    targetShift = shifted(to) ? createHelmert(to.towgs84, true) : undefined;
+  return point => {
+    geodeticToGeocentricInPlace(point, a);
+    sourceShift?.(point);
+    targetShift?.(point);
+    geocentricToGeodeticInPlace(point, b);
+  };
+}
+/** Original per-instance dispatch informed by proj4js grid list semantics. */
+export function applyDatumGrids(point: ProjectionPoint, datum: Datum, inverse: boolean): void {
+  for (const reference of datum.grids) {
+    if (reference.name === 'null') return;
+    if (!reference.grid) {
+      if (reference.optional) continue;
+      throw new Error('Required datum grid is not registered: ' + reference.name);
+    }
+    let found = false;
+    if (reference.grid.shiftInPlace) found = reference.grid.shiftInPlace(point, inverse);
+    else {
+      const output = reference.grid.shift(point.x, point.y, inverse);
+      if (output) {
+        point.x = output[0];
+        point.y = output[1];
+        found = true;
+      }
+    }
+    if (found) {
+      if (!Number.isFinite(point.x) || !Number.isFinite(point.y) || Math.abs(point.y) > Math.PI / 2)
+        throw new Error('Datum grid produced a coordinate outside the geographic domain');
+      return;
+    }
+  }
+  throw new Error(
+    'No datum grid covers coordinate: ' + datum.grids.map(grid => grid.name).join(',')
+  );
+}
+// Scalar adapters retain the internal tuple API for existing callers.
+export function geodeticToGeocentric(coordinate: Coordinate3D, ellipsoid: Ellipsoid): Coordinate3D {
+  const point = {x: coordinate[0], y: coordinate[1], z: coordinate[2]};
+  geodeticToGeocentricInPlace(point, ellipsoid);
+  return [point.x, point.y, point.z];
+}
+export function geocentricToGeodetic(coordinate: Coordinate3D, ellipsoid: Ellipsoid): Coordinate3D {
+  const point = {x: coordinate[0], y: coordinate[1], z: coordinate[2]};
+  geocentricToGeodeticInPlace(point, ellipsoid);
+  return [point.x, point.y, point.z];
+}

package/src/experimental/deformation.ts

@@ -0,0 +1,134 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Original ENU basis rotation and inverse, inspired by PROJ's documented deformation contract; no PROJ implementation is copied or forked. Geocentric conversion reuses the attributed proj4js adaptation in datum.ts.
+import {geocentricToGeodeticInPlace} from './datum';
+import type {ProjectionPoint} from './types';
+import type {VelocityGrid} from './grids/velocity';
+
+/** Both methods take the ORIGINAL source/target epoch pair. inverse solves forward,
+ * rather than sampling the endpoint with a negated duration. XYZ are ECEF metres.
+ * Successful calls mutate XYZ; a failure restores the input. No per-point allocations.
+ */
+export type DeformationModel = {
+  forward(point: ProjectionPoint, sourceEpoch: number, targetEpoch: number): void;
+  inverse(point: ProjectionPoint, sourceEpoch: number, targetEpoch: number): void;
+};
+export type DeformationModelOptions = {
+  readonly grid: VelocityGrid;
+  /** Inclusive, application-reviewed validity interval in decimal years. */
+  readonly epochRange: readonly [number, number];
+  /** Must match the velocity model's geographic reference frame. Default WGS84. */
+  readonly ellipsoid?: {readonly semiMajorAxis: number; readonly flattening: number};
+};
+
+/** Linear, time-invariant ENU velocity model, applied in geocentric space.
+ * No event offsets, time-varying components, extrapolation or automatic model loading.
+ */
+export function createDeformationModel(options: DeformationModelOptions): DeformationModel {
+  const grid = options.grid;
+  if (!grid || typeof grid.sample !== 'function')
+    throw new Error('Prepared velocity grid required');
+  const sample = grid.sample.bind(grid);
+  const range = options.epochRange;
+  if (
+    !Array.isArray(range) ||
+    range.length !== 2 ||
+    !range.every(Number.isFinite) ||
+    range[0] > range[1]
+  )
+    throw new Error('Finite ordered deformation epochRange required');
+  const start = range[0],
+    end = range[1];
+  const a = options.ellipsoid?.semiMajorAxis ?? 6378137;
+  const f = options.ellipsoid?.flattening ?? 1 / 298.257223563;
+  if (!Number.isFinite(a) || a <= 0 || !Number.isFinite(f) || f < 0 || f >= 1)
+    throw new Error('Invalid deformation ellipsoid');
+  if (!(a * (1 - f) > 0) || !(f * (2 - f) < 1)) throw new Error('Invalid deformation ellipsoid');
+  const ellipsoid = Object.freeze({
+    semiMajorAxis: a,
+    semiMinorAxis: a * (1 - f),
+    eccentricitySquared: f * (2 - f)
+  });
+  const duration = (source: number, target: number): number => {
+    if (
+      !Number.isFinite(source) ||
+      !Number.isFinite(target) ||
+      source < start ||
+      source > end ||
+      target < start ||
+      target > end
+    )
+      throw new Error('Deformation epochs outside model epochRange or non-finite');
+    const dt = target - source;
+    if (!Number.isFinite(dt)) throw new Error('Non-finite deformation duration');
+    return dt;
+  };
+  // Scratch belongs to the caller. Recursive custom sampling cannot overwrite shared state.
+  const velocity = (point: ProjectionPoint): void => {
+    geocentricToGeodeticInPlace(point, ellipsoid);
+    const longitude = point.x,
+      latitude = point.y;
+    if (!sample(longitude, latitude, point)) throw new Error('No velocity grid covers coordinate');
+    const east = point.x,
+      north = point.y,
+      up = point.z;
+    const sp = Math.sin(latitude),
+      cp = Math.cos(latitude),
+      sl = Math.sin(longitude),
+      cl = Math.cos(longitude);
+    // Rotate north/up into the radial/Z plane, then rotate radial/east by longitude.
+    const radial = up * cp - north * sp;
+    point.x = radial * cl - east * sl;
+    point.y = radial * sl + east * cl;
+    point.z = up * sp + north * cp;
+  };
+  const apply = (
+    point: ProjectionPoint,
+    source: number,
+    target: number,
+    inverse: boolean
+  ): void => {
+    const dt = duration(source, target);
+    const x = point.x,
+      y = point.y,
+      z = point.z;
+    if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z))
+      throw new Error('Finite deformation XYZ required');
+    try {
+      let px = x,
+        py = y,
+        pz = z;
+      for (let iteration = 0; iteration < (inverse ? 32 : 1); iteration++) {
+        point.x = px;
+        point.y = py;
+        point.z = pz;
+        velocity(point);
+        const nx = x + (inverse ? -dt : dt) * point.x,
+          ny = y + (inverse ? -dt : dt) * point.y,
+          nz = z + (inverse ? -dt : dt) * point.z;
+        if (!Number.isFinite(nx) || !Number.isFinite(ny) || !Number.isFinite(nz))
+          throw new Error('Non-finite deformation output');
+        if (!inverse || Math.hypot(nx - px, ny - py, nz - pz) <= 1e-8) {
+          point.x = nx;
+          point.y = ny;
+          point.z = nz;
+          return;
+        }
+        px = nx;
+        py = ny;
+        pz = nz;
+      }
+      throw new Error('Deformation inverse did not converge');
+    } catch (error) {
+      point.x = x;
+      point.y = y;
+      point.z = z;
+      throw error;
+    }
+  };
+  return Object.freeze({
+    forward: (point, source, target) => apply(point, source, target, false),
+    inverse: (point, source, target) => apply(point, source, target, true)
+  });
+}

package/src/experimental/entries/projections/aea.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {albersEqualArea} from '../../projections/aea';

package/src/experimental/entries/projections/aeqd.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {azimuthalEquidistant} from '../../projections/aeqd';

package/src/experimental/entries/projections/bonne.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {bonne} from '../../projections/bonne';

package/src/experimental/entries/projections/cass.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {cassiniSoldner} from '../../projections/cass';

package/src/experimental/entries/projections/cea.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {cylindricalEqualArea} from '../../projections/cea';

package/src/experimental/entries/projections/eck6.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {eckertVI} from '../../projections/eck6';

package/src/experimental/entries/projections/eqc.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {equidistantCylindrical} from '../../projections/equidistant-cylindrical';

package/src/experimental/entries/projections/eqdc.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {equidistantConic} from '../../projections/eqdc';

package/src/experimental/entries/projections/eqearth.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {equalEarth} from '../../projections/eqearth';

package/src/experimental/entries/projections/equi.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {equirectangular} from '../../projections/equi';

package/src/experimental/entries/projections/etmerc.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {extendedTransverseMercator} from '../../projections/transverse-mercator';

package/src/experimental/entries/projections/geocent.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {geocentric} from '../../projections/geocentric';

package/src/experimental/entries/projections/geos.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {geostationary} from '../../projections/geos';

package/src/experimental/entries/projections/gnom.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {gnomonic} from '../../projections/gnom';

package/src/experimental/entries/projections/gstmerc.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {gaussSchreiberTransverseMercator} from '../../projections/gstmerc';

package/src/experimental/entries/projections/krovak.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {krovak} from '../../projections/krovak';

package/src/experimental/entries/projections/laea.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {lambertAzimuthalEqualArea} from '../../projections/laea';

package/src/experimental/entries/projections/lcc.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {lambertConformalConic} from '../../projections/lcc';

package/src/experimental/entries/projections/merc.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {mercator} from '../../projections/mercator';

package/src/experimental/entries/projections/mill.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {millerCylindrical} from '../../projections/mill';

package/src/experimental/entries/projections/moll.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {mollweide} from '../../projections/moll';

package/src/experimental/entries/projections/nzmg.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export {newZealandMapGrid} from '../../projections/nzmg';