@itowns/geographic 2.46.1-next.0 → 2.46.1-next.10

package/lib/OrientationUtils.js

@@ -1,14 +1,13 @@
 import { Euler, MathUtils, Matrix4, Quaternion, Vector3 } from 'three';
 import proj4 from 'proj4';
 import Coordinates from "./Coordinates.js";
-const DEG2RAD = MathUtils.DEG2RAD;
-const matrix = new Matrix4();
-const north = new Vector3();
-const east = new Vector3();
-const axis = new Vector3().set(0, 0, 1);
-const coord = new Coordinates('EPSG:4326', 0, 0, 0);
-const euler = new Euler();
-const quat = new Quaternion();
+const matrix = /* @__PURE__ */new Matrix4();
+const north = /* @__PURE__ */new Vector3();
+const east = /* @__PURE__ */new Vector3();
+const axis = /* @__PURE__ */new Vector3().set(0, 0, 1);
+const coord = /* @__PURE__ */new Coordinates('EPSG:4326', 0, 0, 0);
+const euler = /* @__PURE__ */new Euler();
+const quat = /* @__PURE__ */new Quaternion();
 /**
  * The transform from the platform frame to the local East, North, Up (ENU)
  * frame is `RotationZ(heading).RotationX(pitch).RotationY(roll)`.
@@ -20,14 +19,10 @@ const quat = new Quaternion();
  *
  * @returns The target quaternion
  */
-export function quaternionFromRollPitchHeading() {
-  let roll = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
-  let pitch = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-  let heading = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
-  let target = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : new Quaternion();
-  roll *= DEG2RAD;
-  pitch *= DEG2RAD;
-  heading *= DEG2RAD;
+export function quaternionFromRollPitchHeading(roll = 0, pitch = 0, heading = 0, target = new Quaternion()) {
+  roll *= MathUtils.DEG2RAD;
+  pitch *= MathUtils.DEG2RAD;
+  heading *= MathUtils.DEG2RAD;
   // return setFromEuler(euler.set(pitch, roll, heading , 'ZXY')).conjugate();
   // Below is optimized version of above line
   return target.setFromEuler(euler.set(-pitch, -roll, -heading, 'YXZ'));
@@ -54,14 +49,10 @@ export function quaternionFromRollPitchHeading() {
  *
  * @returns The target quaternion
  */
-export function quaternionFromOmegaPhiKappa() {
-  let omega = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
-  let phi = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-  let kappa = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
-  let target = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : new Quaternion();
-  omega *= DEG2RAD;
-  phi *= DEG2RAD;
-  kappa *= DEG2RAD;
+export function quaternionFromOmegaPhiKappa(omega = 0, phi = 0, kappa = 0, target = new Quaternion()) {
+  omega *= MathUtils.DEG2RAD;
+  phi *= MathUtils.DEG2RAD;
+  kappa *= MathUtils.DEG2RAD;
   target.setFromEuler(euler.set(omega, phi, kappa, 'XYZ'));
   target.set(target.w, target.z, -target.y, -target.x);
   // <=> target.multiply(new THREE.Quaternion(1, 0, 0, 0));
@@ -77,8 +68,7 @@ export function quaternionFromOmegaPhiKappa() {
  *
  * @returns The target quaternion
  */
-export function quaternionFromAttitude(attitude) {
-  let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Quaternion();
+export function quaternionFromAttitude(attitude, target = new Quaternion()) {
   if ('roll' in attitude || 'pitch' in attitude || 'heading' in attitude) {
     return quaternionFromRollPitchHeading(attitude.roll, attitude.pitch, attitude.heading, target);
   }
@@ -98,13 +88,11 @@ export function quaternionFromAttitude(attitude) {
  * @returns The target quaternion if coordinates is defined. Otherwise, a
  * function to compute it from coordinates.
  */
-export function quaternionFromEnuToGeocent(coordinates) {
-  let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Quaternion();
+export function quaternionFromEnuToGeocent(coordinates, target = new Quaternion()) {
   if (coordinates) {
     return quaternionFromEnuToGeocent()(coordinates, target);
   }
-  return function (coordinates) {
-    let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Quaternion();
+  return (coordinates, target = new Quaternion()) => {
     const up = coordinates.geodesicNormal;
     if (up.x == 0 && up.y == 0) {
       return target.set(0, 0, 0, 1);
@@ -128,16 +116,12 @@ export function quaternionFromEnuToGeocent(coordinates) {
  * @returns The target quaternion if coordinates is defined. Otherwise, a
  * function to compute it from coordinates.
  */
-export function quaternionFromGeocentToEnu(coordinates) {
-  let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Quaternion();
+export function quaternionFromGeocentToEnu(coordinates, target = new Quaternion()) {
   if (coordinates) {
     return quaternionFromGeocentToEnu()(coordinates, target);
   }
   const toGeocent = quaternionFromEnuToGeocent();
-  return function (coordinates) {
-    let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Quaternion();
-    return toGeocent(coordinates, target).conjugate();
-  };
+  return (coordinates, target = new Quaternion()) => toGeocent(coordinates, target).conjugate();
 }
 /**
  * Computes the rotation from a Lambert Conformal Conic (LCC) frame to the local
@@ -153,15 +137,13 @@ export function quaternionFromGeocentToEnu(coordinates) {
  * @returns The target quaternion if coordinates is defined. Otherwise, a
  * function to compute it from coordinates.
  */
-export function quaternionFromLCCToEnu(proj, coordinates) {
-  let target = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new Quaternion();
+export function quaternionFromLCCToEnu(proj, coordinates, target = new Quaternion()) {
   if (coordinates) {
     return quaternionFromLCCToEnu(proj)(coordinates, target);
   }
   const sinlat0 = Math.sin(proj.lat0);
-  return function (coordinates) {
-    let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Quaternion();
-    const long = coordinates.as(coord.crs, coord).longitude * DEG2RAD;
+  return (coordinates, target = new Quaternion()) => {
+    const long = coordinates.as(coord.crs, coord).longitude * MathUtils.DEG2RAD;
     return target.setFromAxisAngle(axis, sinlat0 * (proj.long0 - long));
   };
 }
@@ -178,16 +160,12 @@ export function quaternionFromLCCToEnu(proj, coordinates) {
  * @returns The target quaternion if coordinates is defined. Otherwise, a
  * function to compute it from coordinates.
  */
-export function quaternionFromEnuToLCC(proj, coordinates) {
-  let target = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new Quaternion();
+export function quaternionFromEnuToLCC(proj, coordinates, target = new Quaternion()) {
   if (coordinates) {
     return quaternionFromEnuToLCC(proj)(coordinates, target);
   }
   const fromLCC = quaternionFromLCCToEnu(proj);
-  return function (coordinates) {
-    let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Quaternion();
-    return fromLCC(coordinates, target).conjugate();
-  };
+  return (coordinates, target = new Quaternion()) => fromLCC(coordinates, target).conjugate();
 }
 /**
  * Computes the rotation from a Transverse Mercator frame (TMerc) to the
@@ -202,8 +180,7 @@ export function quaternionFromEnuToLCC(proj, coordinates) {
  * @returns The target quaternion if coordinates is defined. Otherwise, a
  * function to compute it from coordinates.
  */
-export function quaternionFromTMercToEnu(proj, coordinates) {
-  let target = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new Quaternion();
+export function quaternionFromTMercToEnu(proj, coordinates, target = new Quaternion()) {
   if (coordinates) {
     return quaternionFromTMercToEnu(proj)(coordinates, target);
   }
@@ -216,11 +193,10 @@ export function quaternionFromTMercToEnu(proj, coordinates) {
     const e2 = proj.e * proj.e;
     eta0 = e2 / (1 - e2);
   }
-  return function (coordinates) {
-    let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Quaternion();
+  return (coordinates, target = new Quaternion()) => {
     coordinates.as(coord.crs, coord);
-    const long = coord.longitude * DEG2RAD;
-    const lat = coord.latitude * DEG2RAD;
+    const long = coord.longitude * MathUtils.DEG2RAD;
+    const lat = coord.latitude * MathUtils.DEG2RAD;
     const dlong = proj.long0 - long;
     const coslat = Math.cos(lat);
     const sinlat = Math.sin(lat);
@@ -245,16 +221,12 @@ export function quaternionFromTMercToEnu(proj, coordinates) {
  * @returns The target quaternion if coordinates is defined. Otherwise, a
  * function to compute it from coordinates.
  */
-export function quaternionFromEnuToTMerc(proj, coordinates) {
-  let target = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new Quaternion();
+export function quaternionFromEnuToTMerc(proj, coordinates, target = new Quaternion()) {
   if (coordinates) {
     return quaternionFromEnuToTMerc(proj)(coordinates, target);
   }
   const fromTMerc = quaternionFromTMercToEnu(proj);
-  return function (coordinates) {
-    let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Quaternion();
-    return fromTMerc(coordinates, target).conjugate();
-  };
+  return (coordinates, target = new Quaternion()) => fromTMerc(coordinates, target).conjugate();
 }
 /**
  * Computes the rotation from a LongLat frame to the local East North Up
@@ -267,12 +239,8 @@ export function quaternionFromEnuToTMerc(proj, coordinates) {
  * @returns The target quaternion if coordinates is defined, otherwise, a
  * function to compute it from coordinates.
  */
-export function quaternionFromLongLatToEnu(coordinates) {
-  let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Quaternion();
-  return coordinates ? target.set(0, 0, 0, 1) : function (coordinates) {
-    let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Quaternion();
-    return quaternionFromLongLatToEnu(coordinates, target);
-  };
+export function quaternionFromLongLatToEnu(coordinates, target = new Quaternion()) {
+  return coordinates ? target.set(0, 0, 0, 1) : (coordinates, target = new Quaternion()) => quaternionFromLongLatToEnu(coordinates, target);
 }
 /**
  * Computes the rotation from the local East North Up (ENU) frame to a
@@ -284,12 +252,8 @@ export function quaternionFromLongLatToEnu(coordinates) {
  * @returns The target quaternion if coordinates is defined, otherwise, a
  * function to compute it from coordinates.
  */
-export function quaternionFromEnuToLongLat(coordinates) {
-  let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Quaternion();
-  return coordinates ? target.set(0, 0, 0, 1) : function (coordinates) {
-    let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Quaternion();
-    return quaternionFromEnuToLongLat(coordinates, target);
-  };
+export function quaternionFromEnuToLongLat(coordinates, target = new Quaternion()) {
+  return coordinates ? target.set(0, 0, 0, 1) : (coordinates, target = new Quaternion()) => quaternionFromEnuToLongLat(coordinates, target);
 }
 /**
  * Warns for an unimplemented projection, sets the quaternion to the
@@ -301,13 +265,9 @@ export function quaternionFromEnuToLongLat(coordinates) {
  * @returns The target quaternion if coordinates is defined, otherwise, a
  * function to compute it from coordinates.
  */
-export function quaternionUnimplemented(proj, coordinates) {
-  let target = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new Quaternion();
+export function quaternionUnimplemented(proj, coordinates, target = new Quaternion()) {
   console.warn('This quaternion function is not implemented for projections of type', proj.projName);
-  return coordinates ? target.set(0, 0, 0, 1) : function (coordinates) {
-    let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Quaternion();
-    return quaternionUnimplemented(proj, coordinates, target);
-  };
+  return coordinates ? target.set(0, 0, 0, 1) : (coordinates, target = new Quaternion()) => quaternionUnimplemented(proj, coordinates, target);
 }
 /**
  * Compute the quaternion that models the rotation from the local East North
@@ -320,14 +280,13 @@ export function quaternionUnimplemented(proj, coordinates) {
  * @returns The target quaternion if coordinates is defined, otherwise, a
  * function to compute it from coordinates.
  */
-export function quaternionFromEnuToCRS(crsOrProj, coordinates) {
-  let target = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new Quaternion();
+export function quaternionFromEnuToCRS(crsOrProj, coordinates, target = new Quaternion()) {
   if (coordinates) {
     return quaternionFromEnuToCRS(crsOrProj)(coordinates, target);
   }
   const proj = typeof crsOrProj === 'string' ? proj4(crsOrProj).oProj : crsOrProj;
-  const names = proj4.Proj.projections.get(proj.projName).names;
-  switch (names[0]) {
+  const projOrFalse = proj4.Proj.projections.get(proj.projName);
+  switch (projOrFalse && projOrFalse.names[0]) {
     case 'Geocentric':
       return quaternionFromEnuToGeocent();
     case 'Lambert Tangential Conformal Conic Projection':
@@ -351,14 +310,13 @@ export function quaternionFromEnuToCRS(crsOrProj, coordinates) {
  * @returns The target quaternion if coordinates is defined, otherwise, a
  * function to compute it from coordinates.
  */
-export function quaternionFromCRSToEnu(crsOrProj, coordinates) {
-  let target = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new Quaternion();
+export function quaternionFromCRSToEnu(crsOrProj, coordinates, target = new Quaternion()) {
   if (coordinates) {
     return quaternionFromCRSToEnu(crsOrProj)(coordinates, target);
   }
   const proj = typeof crsOrProj === 'string' ? proj4(crsOrProj).oProj : crsOrProj;
-  const names = proj4.Proj.projections.get(proj.projName).names;
-  switch (names[0]) {
+  const projOrFalse = proj4.Proj.projections.get(proj.projName);
+  switch (projOrFalse && projOrFalse.names[0]) {
     case 'Geocentric':
       return quaternionFromGeocentToEnu();
     case 'Lambert Tangential Conformal Conic Projection':
@@ -382,23 +340,16 @@ export function quaternionFromCRSToEnu(crsOrProj, coordinates) {
  * @returns The target quaternion if coordinates is defined, otherwise, a
  * function to compute it from coordinates.
  */
-export function quaternionFromCRSToCRS(crsIn, crsOut, coordinates) {
-  let target = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : new Quaternion();
+export function quaternionFromCRSToCRS(crsIn, crsOut, coordinates, target = new Quaternion()) {
   if (coordinates) {
     return quaternionFromCRSToCRS(crsIn, crsOut)(coordinates, target);
   }
   if (crsIn == crsOut) {
-    return function (origin) {
-      let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Quaternion();
-      return target.set(0, 0, 0, 1);
-    };
+    return (origin, target = new Quaternion()) => target.set(0, 0, 0, 1);
   }
 
   // get rotations from the local East/North/Up (ENU) frame to both CRS.
   const fromCrs = quaternionFromCRSToEnu(crsIn);
   const toCrs = quaternionFromEnuToCRS(crsOut);
-  return function (origin) {
-    let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Quaternion();
-    return toCrs(origin, target).multiply(fromCrs(origin, quat));
-  };
+  return (origin, target = new Quaternion()) => toCrs(origin, target).multiply(fromCrs(origin, quat));
 }

package/package.json

@@ -1,20 +1,20 @@
 {
   "name": "@itowns/geographic",
-  "version": "2.46.1-next.0",
+  "version": "2.46.1-next.10",
   "description": "Geodesy",
   "type": "module",
-  "main": "lib/Main.js",
+  "main": "lib/index.js",
   "exports": {
-    "types": "./src/Main.ts",
-    "default": "./lib/Main.js"
+    "types": "./src/index.ts",
+    "default": "./lib/index.js"
   },
-  "types": "./src/Main.ts",
+  "types": "./src/index.ts",
   "scripts": {
     "build": "",
     "lint": "eslint \"src/**/*.{js,ts,tsx}\" \"test/**/*.js\"",
     "transpile": "tsc && cross-env BABEL_DISABLE_CACHE=1 babel src --out-dir lib --extensions .js,.ts",
     "test-unit": "npm run base-test-unit test/unit",
-    "base-test-unit": "cross-env BABEL_DISABLE_CACHE=1 mocha --import=../../config/babel-register/register.mjs",
+    "base-test-unit": "cross-env BABEL_DISABLE_CACHE=1 NODE_OPTIONS=--no-experimental-strip-types mocha --import=../../config/babel-register/register.mjs",
     "test-with-coverage": "c8 -n src -r html cross-env npm run test-unit",
     "test-with-coverage_lcov": "c8 -n src --reporter=lcov cross-env npm run test-unit",
     "watch": "npm run transpile -- --watch",
@@ -35,7 +35,7 @@
     "url": "https://github.com/itowns/itowns/issues"
   },
   "peerDependencies": {
-    "proj4": "^2.19.3",
+    "proj4": "^2.19.10",
     "three": "^0.174.0"
   },
   "homepage": "https://itowns.github.io/"

package/src/Coordinates.ts

@@ -1,16 +1,15 @@
-import * as THREE from 'three';
-import proj4 from 'proj4';
-import type { Converter } from 'proj4/dist/lib/core';
+import { Vector3, type Vector3Like, type Matrix4, MathUtils } from 'three';
+import proj4, { type Converter } from 'proj4';
 import Ellipsoid from './Ellipsoid';
 import * as CRS from './Crs';
 
-import type { ProjectionAlias } from './Crs';
+import type { ProjectionLike } from './Crs';
 
-const ellipsoid = new Ellipsoid();
+const ellipsoid = /* @__PURE__ */ new Ellipsoid();
 const projectionCache: Record<string, Record<string, Converter>> = {};
 
-const v0 = new THREE.Vector3();
-const v1 = new THREE.Vector3();
+const v0 = /* @__PURE__ */ new Vector3();
+const v1 = /* @__PURE__ */ new Vector3();
 
 let coord0: Coordinates;
 let coord1: Coordinates;
@@ -22,7 +21,7 @@ export interface CoordinatesLike {
     readonly z: number;
 }
 
-function proj4cache(crsIn: ProjectionAlias, crsOut: ProjectionAlias): Converter {
+function proj4cache(crsIn: ProjectionLike, crsOut: ProjectionLike): Converter {
     if (!projectionCache[crsIn]) {
         projectionCache[crsIn] = {};
     }
@@ -72,9 +71,9 @@ class Coordinates {
      */
     readonly isCoordinates: boolean;
     /**
-     * A default or user-defined CRS (see {@link ProjectionAlias}).
+     * A default or user-defined CRS (see {@link ProjectionLike}).
      */
-    crs: ProjectionAlias;
+    crs: ProjectionLike;
 
     /** The x value (or longitude) of this coordinate. */
     x: number;
@@ -83,16 +82,16 @@ class Coordinates {
     /** The z value (or altitude) of this coordinate. */
     z: number;
 
-    private _normal: THREE.Vector3;
+    private _normal: Vector3;
     private _normalNeedsUpdate: boolean;
 
     /**
-     * @param crs - A default or user-defined CRS (see {@link ProjectionAlias}).
+     * @param crs - A default or user-defined CRS (see {@link ProjectionLike}).
      * @param x - x or longitude value.
      * @param y - y or latitude value.
      * @param z - z or altitude value.
      */
-    constructor(crs: ProjectionAlias, x: number = 0, y: number = 0, z: number = 0) {
+    constructor(crs: ProjectionLike, x: number = 0, y: number = 0, z: number = 0) {
         this.isCoordinates = true;
 
         CRS.isValid(crs);
@@ -105,7 +104,7 @@ class Coordinates {
         this.z = 0;
 
         // Normal
-        this._normal = new THREE.Vector3();
+        this._normal = new Vector3();
 
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         if ((x as any).length > 0) { // deepscan-disable-line
@@ -134,7 +133,7 @@ class Coordinates {
      * Sets the Coordinate Reference System.
      * @param crs - Coordinate Reference System (e.g. 'EPSG:4978')
      */
-    setCrs(crs: ProjectionAlias): this {
+    setCrs(crs: ProjectionLike): this {
         CRS.isValid(crs);
         this.crs = crs;
         return this;
@@ -180,7 +179,7 @@ class Coordinates {
      *
      * @param v - The source object.
      */
-    setFromVector3(v: THREE.Vector3Like): this {
+    setFromVector3(v: Vector3Like): this {
         return this.setFromValues(v.x, v.y, v.z);
     }
 
@@ -247,7 +246,7 @@ class Coordinates {
      * @returns A vector `(x, y, z)`, or copies x, y and z into the provided
      * vector.
      */
-    toVector3(target: THREE.Vector3 = new THREE.Vector3()): THREE.Vector3 {
+    toVector3(target: Vector3 = new Vector3()): Vector3 {
         return target.copy(this);
     }
 
@@ -262,7 +261,7 @@ class Coordinates {
      * array.
      */
     toArray(array: number[] = [], offset: number = 0): ArrayLike<number> {
-        return THREE.Vector3.prototype.toArray.call(this, array, offset);
+        return Vector3.prototype.toArray.call(this, array, offset);
     }
 
     /**
@@ -306,8 +305,8 @@ class Coordinates {
      *
      * @param mat - The matrix.
      */
-    applyMatrix4(mat: THREE.Matrix4): this {
-        THREE.Vector3.prototype.applyMatrix4.call(this, mat);
+    applyMatrix4(mat: Matrix4): this {
+        Vector3.prototype.applyMatrix4.call(this, mat);
         return this;
     }
 
@@ -341,12 +340,12 @@ class Coordinates {
      * const geographicCoords = geocentricCoords.as('EPSG:4326');
      * ```
      */
-    as(crs: ProjectionAlias, target = new Coordinates(crs)): Coordinates {
+    as(crs: ProjectionLike, target = new Coordinates(crs)): Coordinates {
         if (this.crs == crs) {
             target.copy(this);
         } else {
             if (CRS.is4326(this.crs) && crs == 'EPSG:3857') {
-                this.y = THREE.MathUtils.clamp(this.y, -89.999999, 89.999999);
+                this.y = MathUtils.clamp(this.y, -89.999999, 89.999999);
             }
 
             target.setFromArray(proj4cache(this.crs, crs)
@@ -359,7 +358,7 @@ class Coordinates {
     }
 }
 
-coord0 = new Coordinates('EPSG:4326', 0, 0, 0);
-coord1 = new Coordinates('EPSG:4326', 0, 0, 0);
+coord0 = /* @__PURE__ */ new Coordinates('EPSG:4326', 0, 0, 0);
+coord1 = /* @__PURE__ */ new Coordinates('EPSG:4326', 0, 0, 0);
 
 export default Coordinates;

package/src/Crs.ts

@@ -1,7 +1,14 @@
 import proj4 from 'proj4';
-
 import type { ProjectionDefinition } from 'proj4/dist/lib/defs';
 
+type proj4Def = {
+    type: string,
+    PROJCS: proj4Def,
+    unknown?: string,
+    (alias: string): proj4Def & { name: string },
+    title: string,
+}
+
 proj4.defs('EPSG:4978', '+proj=geocent +datum=WGS84 +units=m +no_defs');
 
 // Redefining proj4 global projections to match epsg.org database axis order.
@@ -15,7 +22,7 @@ proj4.defs('WGS84').axis = 'neu';
  * projection definition previously defined with
  * [`proj4.defs`](https://github.com/proj4js/proj4js#named-projections).
  */
-export type ProjectionAlias = string;
+export type ProjectionLike = string;
 
 function isString(s: unknown): s is string {
     return typeof s === 'string' || s instanceof String;
@@ -53,7 +60,7 @@ export const UNIT = {
  *
  * @param crs - The CRS to test.
  */
-export function is4326(crs: ProjectionAlias) {
+export function is4326(crs: ProjectionLike) {
     return crs === 'EPSG:4326';
 }
 
@@ -79,7 +86,7 @@ function unitFromProj4Unit(proj: ProjectionDefinition) {
  * @param crs - The CRS to extract the unit from.
  * @returns Either `UNIT.METER`, `UNIT.DEGREE`, `UNIT.FOOT` or `undefined`.
  */
-export function getUnit(crs: ProjectionAlias) {
+export function getUnit(crs: ProjectionLike) {
     mustBeString(crs);
     const p = proj4.defs(crs);
     if (!p) {
@@ -94,7 +101,7 @@ export function getUnit(crs: ProjectionAlias) {
  * @param crs - The CRS to check.
  * @throws {@link Error} if the CRS is not valid.
  */
-export function isMetricUnit(crs: ProjectionAlias) {
+export function isMetricUnit(crs: ProjectionLike) {
     return getUnit(crs) === UNIT.METER;
 }
 
@@ -104,7 +111,7 @@ export function isMetricUnit(crs: ProjectionAlias) {
  * @param crs - The CRS to check.
  * @throws {@link Error} if the CRS is not valid.
  */
-export function isGeographic(crs: ProjectionAlias) {
+export function isGeographic(crs: ProjectionLike) {
     return getUnit(crs) === UNIT.DEGREE;
 }
 
@@ -114,7 +121,7 @@ export function isGeographic(crs: ProjectionAlias) {
  * @param crs - The CRS to test.
  * @returns false if the crs isn't defined.
  */
-export function isGeocentric(crs: ProjectionAlias) {
+export function isGeocentric(crs: ProjectionLike) {
     mustBeString(crs);
     const projection = proj4.defs(crs);
     return !projection ? false : projection.projName == 'geocent';
@@ -127,7 +134,7 @@ export function isGeocentric(crs: ProjectionAlias) {
  * @param crs - The CRS to test.
  * @throws {@link Error} if the crs is not valid.
  */
-export function isValid(crs: ProjectionAlias) {
+export function isValid(crs: ProjectionLike) {
     const proj = proj4.defs(crs);
     if (!proj) {
         throw new Error(`Undefined crs '${crs}'. Add it with proj4.defs('${crs}', string)`);
@@ -143,7 +150,7 @@ export function isValid(crs: ProjectionAlias) {
  * @param crs - The CRS to use.
  * @returns 0.01 if the CRS is EPSG:4326, 0.001 otherwise.
  */
-export function reasonableEpsilon(crs: ProjectionAlias) {
+export function reasonableEpsilon(crs: ProjectionLike) {
     if (is4326(crs)) {
         return 0.01;
     } else {
@@ -158,7 +165,7 @@ export function reasonableEpsilon(crs: ProjectionAlias) {
  * @param crs - The CRS to get axis from.
  * @returns the matching proj4 axis string, 'enu' for instance (east, north, up)
  */
-export function axisOrder(crs: ProjectionAlias) {
+export function axisOrder(crs: ProjectionLike) {
     mustBeString(crs);
     const projection = proj4.defs(crs);
     return !projection ? undefined : projection.axis;
@@ -174,3 +181,21 @@ export function axisOrder(crs: ProjectionAlias) {
  * @param proj4def - Proj4 or WKT string of the defined projection.
  */
 export const defs = (code: string, proj4def: string) => proj4.defs(code, proj4def);
+
+export function defsFromWkt(wkt: string) {
+    proj4.defs('unknown', wkt);
+    const proj4Defs = proj4.defs as unknown as proj4Def;
+    let projCS;
+    if (proj4Defs('unknown').type === 'COMPD_CS') {
+        console.warn('Compound coordinate system is not yet supported.');
+        projCS = proj4Defs('unknown').PROJCS;
+    } else {
+        projCS = proj4Defs('unknown');
+    }
+    const crsAlias = projCS.title || projCS.name || 'EPSG:XXXX';
+    if (!(crsAlias in proj4.defs)) {
+        proj4.defs(crsAlias, projCS);
+    }
+    delete proj4Defs.unknown;
+    return crsAlias;
+}