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

package/src/Ellipsoid.ts

@@ -1,4 +1,4 @@
-import * as THREE from 'three';
+import { Vector3, type Vector3Like, type Ray, MathUtils } from 'three';
 import proj4 from 'proj4';
 import Coordinates from './Coordinates';
 
@@ -6,34 +6,35 @@ import Coordinates from './Coordinates';
  * Length of the semi-axes of the WGS84 ellipsoid.
  * @internal
  */
-export const ellipsoidSizes = new THREE.Vector3(
+export const ellipsoidSizes = /* @__PURE__ */ (() => new Vector3(
     proj4.WGS84.a,
     proj4.WGS84.a,
-    proj4.WGS84.b);
+    proj4.WGS84.b,
+))();
 
-const normal = new THREE.Vector3();
+const normal = /* @__PURE__ */ new Vector3();
 
 class Ellipsoid {
     /**
      * Length of the semi-axes of the ellipsoid.
      */
-    size: THREE.Vector3;
+    size: Vector3;
     /**
      * Eccentricity of the ellipsoid.
      */
     eccentricity: number;
 
-    private _radiiSquared: THREE.Vector3;
-    private _invRadiiSquared: THREE.Vector3;
+    private _radiiSquared: Vector3;
+    private _invRadiiSquared: Vector3;
 
     /**
      * @param size - Length of the semi-axes of the ellipsoid. Defaults to those
      * defined by the WGS84 ellipsoid.
      */
-    constructor(size: THREE.Vector3 = ellipsoidSizes) {
-        this.size = new THREE.Vector3();
-        this._radiiSquared = new THREE.Vector3();
-        this._invRadiiSquared = new THREE.Vector3();
+    constructor(size: Vector3 = ellipsoidSizes) {
+        this.size = new Vector3();
+        this._radiiSquared = new Vector3();
+        this._invRadiiSquared = new Vector3();
         this.eccentricity = 0;
 
         this.setSize(size);
@@ -49,8 +50,8 @@ class Ellipsoid {
      */
     geodeticSurfaceNormal(
         cartesian: Coordinates,
-        target = new THREE.Vector3(),
-    ): THREE.Vector3 {
+        target = new Vector3(),
+    ): Vector3 {
         return cartesian.toVector3(target).multiply(this._invRadiiSquared).normalize();
     }
 
@@ -64,10 +65,10 @@ class Ellipsoid {
      */
     geodeticSurfaceNormalCartographic(
         coordCarto: Coordinates,
-        target = new THREE.Vector3(),
-    ): THREE.Vector3 {
-        const longitude = THREE.MathUtils.degToRad(coordCarto.longitude);
-        const latitude = THREE.MathUtils.degToRad(coordCarto.latitude);
+        target = new Vector3(),
+    ): Vector3 {
+        const longitude = MathUtils.degToRad(coordCarto.longitude);
+        const latitude = MathUtils.degToRad(coordCarto.latitude);
         const cosLatitude = Math.cos(latitude);
 
         return target.set(cosLatitude * Math.cos(longitude),
@@ -82,7 +83,7 @@ class Ellipsoid {
      *
      * @param size - The source vector.
      */
-    setSize(size: THREE.Vector3Like): this {
+    setSize(size: Vector3Like): this {
         this.size.set(size.x, size.y, size.z);
 
         this._radiiSquared.multiplyVectors(size, size);
@@ -98,8 +99,8 @@ class Ellipsoid {
 
     cartographicToCartesian(
         coordCarto: Coordinates,
-        target = new THREE.Vector3(),
-    ): THREE.Vector3 {
+        target = new Vector3(),
+    ): Vector3 {
         normal.copy(coordCarto.geodesicNormal);
 
         target.multiplyVectors(this._radiiSquared, normal);
@@ -122,7 +123,7 @@ class Ellipsoid {
      * angles are in degree
      */
     cartesianToCartographic(
-        position: THREE.Vector3Like,
+        position: Vector3Like,
         target = new Coordinates('EPSG:4326', 0, 0, 0),
     ): Coordinates {
         // for details, see for example http://www.linz.govt.nz/data/geodetic-system/coordinate-conversion/geodetic-datum-conversions/equations-used-datum
@@ -152,13 +153,13 @@ class Ellipsoid {
             a * Math.sqrt(1 - e * Math.sin(phi) * Math.sin(phi));
 
         return target.setFromValues(
-            THREE.MathUtils.radToDeg(theta),
-            THREE.MathUtils.radToDeg(phi),
+            MathUtils.radToDeg(theta),
+            MathUtils.radToDeg(phi),
             h,
         );
     }
 
-    cartographicToCartesianArray(coordCartoArray: Coordinates[]): THREE.Vector3[] {
+    cartographicToCartesianArray(coordCartoArray: Coordinates[]): Vector3[] {
         const cartesianArray = [];
         for (let i = 0; i < coordCartoArray.length; i++) {
             cartesianArray.push(this.cartographicToCartesian(coordCartoArray[i]));
@@ -167,7 +168,7 @@ class Ellipsoid {
         return cartesianArray;
     }
 
-    intersection(ray: THREE.Ray): THREE.Vector3 | false {
+    intersection(ray: Ray): Vector3 | false {
         const EPSILON = 0.0001;
         const O_C = ray.origin;
         const dir = ray.direction;
@@ -207,7 +208,7 @@ class Ellipsoid {
 
         if (t < EPSILON) { return false; } // Too close to intersection
 
-        const inter = new THREE.Vector3();
+        const inter = new Vector3();
 
         inter.addVectors(ray.origin, dir.clone().setLength(t));
 
@@ -228,10 +229,10 @@ class Ellipsoid {
         // The formula uses the distance on approximated sphere,
         // with the nearest local radius of curvature of the ellipsoid
         // https://geodesie.ign.fr/contenu/fichiers/Distance_longitude_latitude.pdf
-        const longitude1 = THREE.MathUtils.degToRad(coordCarto1.longitude);
-        const latitude1 = THREE.MathUtils.degToRad(coordCarto1.latitude);
-        const longitude2 = THREE.MathUtils.degToRad(coordCarto2.longitude);
-        const latitude2 = THREE.MathUtils.degToRad(coordCarto2.latitude);
+        const longitude1 = MathUtils.degToRad(coordCarto1.longitude);
+        const latitude1 = MathUtils.degToRad(coordCarto1.latitude);
+        const longitude2 = MathUtils.degToRad(coordCarto2.longitude);
+        const latitude2 = MathUtils.degToRad(coordCarto2.latitude);
 
         const distRad = Math.acos(
             Math.sin(latitude1) * Math.sin(latitude2) +

package/src/Extent.ts

@@ -1,29 +1,35 @@
-import * as THREE from 'three';
+import { Vector2, Vector3, Vector4, Box3, type Matrix4 } from 'three';
 import Coordinates from './Coordinates';
 import * as CRS from './Crs';
 
-import type { ProjectionAlias } from './Crs';
+import type { ProjectionLike } from './Crs';
 
-const _dim = new THREE.Vector2();
-const _dim2 = new THREE.Vector2();
-const _box = new THREE.Box3();
-const defaultScheme = new THREE.Vector2(2, 2);
+const _dim = /* @__PURE__ */ new Vector2();
+const _dim2 = /* @__PURE__ */ new Vector2();
+const _box = /* @__PURE__ */ new Box3();
+const defaultScheme = /* @__PURE__ */ new Vector2(2, 2);
 
-const cNorthWest =  new Coordinates('EPSG:4326', 0, 0, 0);
-const cSouthWest =  new Coordinates('EPSG:4326', 0, 0, 0);
-const cNorthEast =  new Coordinates('EPSG:4326', 0, 0, 0);
+const cNorthWest =  /* @__PURE__ */ new Coordinates('EPSG:4326', 0, 0, 0);
+const cSouthWest =  /* @__PURE__ */ new Coordinates('EPSG:4326', 0, 0, 0);
+const cNorthEast =  /* @__PURE__ */ new Coordinates('EPSG:4326', 0, 0, 0);
 
-const southWest = new THREE.Vector3();
-const northEast = new THREE.Vector3();
+const southWest = /* @__PURE__ */ new Vector3();
+const northEast = /* @__PURE__ */ new Vector3();
 
 let _extent: Extent;
 
-const cardinals = new Array(8);
-for (let i = cardinals.length - 1; i >= 0; i--) {
-    cardinals[i] = new Coordinates('EPSG:4326', 0, 0, 0);
-}
+const cardinals = [
+    /* @__PURE__ */ new Coordinates('EPSG:4326', 0, 0, 0),
+    /* @__PURE__ */ new Coordinates('EPSG:4326', 0, 0, 0),
+    /* @__PURE__ */ new Coordinates('EPSG:4326', 0, 0, 0),
+    /* @__PURE__ */ new Coordinates('EPSG:4326', 0, 0, 0),
+    /* @__PURE__ */ new Coordinates('EPSG:4326', 0, 0, 0),
+    /* @__PURE__ */ new Coordinates('EPSG:4326', 0, 0, 0),
+    /* @__PURE__ */ new Coordinates('EPSG:4326', 0, 0, 0),
+    /* @__PURE__ */ new Coordinates('EPSG:4326', 0, 0, 0),
+] as const;
 
-const _c = new Coordinates('EPSG:4326', 0, 0);
+const _c = /* @__PURE__ */ new Coordinates('EPSG:4326', 0, 0);
 
 export interface ExtentLike {
     readonly west: number;
@@ -47,9 +53,9 @@ class Extent {
      */
     readonly isExtent: true;
     /**
-     * A default or user-defined CRS (see {@link ProjectionAlias}).
+     * A default or user-defined CRS (see {@link ProjectionLike}).
      */
-    crs: ProjectionAlias;
+    crs: ProjectionLike;
     /**
      * West longitude bound of this extent.
      */
@@ -68,13 +74,13 @@ class Extent {
     north: number;
 
     /**
-     * @param crs - A default or user-defined CRS (see {@link ProjectionAlias}).
+     * @param crs - A default or user-defined CRS (see {@link ProjectionLike}).
      * @param west - the `west` value of this extent. Default is 0.
      * @param east - the `east` value of this extent. Default is 0.
      * @param south - the `south` value of this extent. Default is 0.
      * @param north - the `north` value of this extent. Default is 0.
      */
-    constructor(crs: ProjectionAlias, west = 0, east = 0, south = 0, north = 0) {
+    constructor(crs: ProjectionLike, west = 0, east = 0, south = 0, north = 0) {
         if (CRS.isGeocentric(crs)) {
             throw new Error(
                 `Non-compatible geocentric projection ${crs} to build a geographical extent`,
@@ -167,7 +173,7 @@ class Extent {
      *
      * @param target - optional target
      */
-    planarDimensions(target = new THREE.Vector2()) {
+    planarDimensions(target = new Vector2()) {
         // Calculte the dimensions for x and y
         return target.set(Math.abs(this.east - this.west), Math.abs(this.north - this.south));
     }
@@ -180,7 +186,7 @@ class Extent {
      *
      * @param target - optional target
      */
-    geodeticDimensions(target = new THREE.Vector2()) {
+    geodeticDimensions(target = new Vector2()) {
         // set 3 corners extent
         cNorthWest.crs = this.crs;
         cSouthWest.crs = this.crs;
@@ -204,7 +210,7 @@ class Extent {
      *
      * @param target - optional target
      */
-    spatialEuclideanDimensions(target = new THREE.Vector2()) {
+    spatialEuclideanDimensions(target = new Vector2()) {
         // set 3 corners extent
         cNorthWest.crs = this.crs;
         cSouthWest.crs = this.crs;
@@ -267,7 +273,7 @@ class Extent {
      * south-north, the `z` property the scale on west-east, the `w` property
      * the scale on south-north.
      */
-    offsetToParent(extent: Extent, target = new THREE.Vector4()) {
+    offsetToParent(extent: Extent, target = new Vector4()) {
         if (this.crs != extent.crs) {
             throw new Error('unsupported mix');
         }
@@ -470,7 +476,7 @@ class Extent {
      * @param crs - Projection of extent to instancied.
      * @param box - Bounding-box
      */
-    static fromBox3(crs: ProjectionAlias, box: THREE.Box3) {
+    static fromBox3(crs: ProjectionLike, box: Box3) {
         if (CRS.isGeocentric(crs)) {
             // if geocentric reproject box on 'EPSG:4326'
             crs = 'EPSG:4326';
@@ -539,7 +545,7 @@ class Extent {
      * @param matrix - The matrix
      * @returns return this extent instance.
      */
-    applyMatrix4(matrix: THREE.Matrix4): this {
+    applyMatrix4(matrix: Matrix4): this {
         southWest.set(this.west, this.south, 0).applyMatrix4(matrix);
         northEast.set(this.east, this.north, 0).applyMatrix4(matrix);
         this.west = southWest.x;
@@ -597,6 +603,6 @@ class Extent {
     }
 }
 
-_extent = new Extent('EPSG:4326');
+_extent = /* @__PURE__ */ new Extent('EPSG:4326');
 
 export default Extent;

package/src/OrientationUtils.ts

@@ -1,16 +1,14 @@
 import { Euler, MathUtils, Matrix4, Quaternion, Vector3 } from 'three';
-import proj4 from 'proj4';
-import type { ProjectionDefinition } from 'proj4/dist/lib/defs';
+import proj4, { type ProjectionDefinition } from 'proj4';
 import Coordinates from './Coordinates';
 
-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();
 
 interface EulerAngles {
     /** angle in degrees */
@@ -55,9 +53,9 @@ export function quaternionFromRollPitchHeading(
     heading = 0,
     target = new Quaternion(),
 ) {
-    roll *= DEG2RAD;
-    pitch *= DEG2RAD;
-    heading *= DEG2RAD;
+    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'));
@@ -90,9 +88,9 @@ export function quaternionFromOmegaPhiKappa(
     kappa = 0,
     target = new Quaternion(),
 ) {
-    omega *= DEG2RAD;
-    phi *= DEG2RAD;
-    kappa *= DEG2RAD;
+    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));
@@ -202,7 +200,7 @@ export function quaternionFromLCCToEnu(
     if (coordinates) { return quaternionFromLCCToEnu(proj)(coordinates, target); }
     const sinlat0 = Math.sin(proj.lat0);
     return (coordinates: Coordinates, target = new Quaternion()) => {
-        const long = coordinates.as(coord.crs, coord).longitude * DEG2RAD;
+        const long = coordinates.as(coord.crs, coord).longitude * MathUtils.DEG2RAD;
         return target.setFromAxisAngle(axis, sinlat0 * (proj.long0 - long));
     };
 }
@@ -273,8 +271,8 @@ export function quaternionFromTMercToEnu(
     }
     return (coordinates: 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);
@@ -413,8 +411,8 @@ export function quaternionFromEnuToCRS(
     const proj = typeof crsOrProj === 'string' ?
         proj4(crsOrProj).oProj as ProjectionDefinition :
         crsOrProj;
-    const names = proj4.Proj.projections.get(proj.projName).names;
-    switch (names[0]) {
+    const projOrFalse = proj4.Proj.projections.get(proj.projName as string);
+    switch (projOrFalse && projOrFalse.names[0]) {
         case 'Geocentric': return quaternionFromEnuToGeocent();
         case 'Lambert Tangential Conformal Conic Projection':
             return quaternionFromEnuToLCC(proj as LCCProjection);
@@ -450,8 +448,8 @@ export function quaternionFromCRSToEnu(
     const proj = typeof crsOrProj === 'string' ?
         proj4(crsOrProj).oProj as ProjectionDefinition :
         crsOrProj;
-    const names = proj4.Proj.projections.get(proj.projName).names;
-    switch (names[0]) {
+    const projOrFalse = proj4.Proj.projections.get(proj.projName as string);
+    switch (projOrFalse && projOrFalse.names[0]) {
         case 'Geocentric': return quaternionFromGeocentToEnu();
         case 'Lambert Tangential Conformal Conic Projection':
             return quaternionFromLCCToEnu(proj as LCCProjection);

package/src/{Main.ts → index.ts}

@@ -1,7 +1,8 @@
 // Geodesic tools
-export { default as Extent } from './Extent';
-export { default as Coordinates } from './Coordinates';
+export { default as Extent, type ExtentLike } from './Extent';
+export { default as Coordinates, type CoordinatesLike } from './Coordinates';
 export * as CRS from './Crs';
+export { type ProjectionLike } from './Crs';
 export { default as CoordStars } from './CoordStars';
 export * as OrientationUtils from './OrientationUtils';
 export { default as Ellipsoid, ellipsoidSizes } from './Ellipsoid';

package/lib/CoordStars.d.ts

@@ -1,13 +0,0 @@
-declare const CoordStars: {
-    getSunPosition(): (date: Date | number, lat: number, lon: number) => {
-        EclipticLongitude: number;
-        declinaison: number;
-        ascension: number;
-        H: number;
-        SiderealTime: number;
-        altitude: number;
-        azimuth: number;
-    };
-    getSunPositionInScene(date: Date | number, lat: number, lon: number): import("three").Vector3;
-};
-export default CoordStars;

package/lib/Coordinates.d.ts

@@ -1,196 +0,0 @@
-import * as THREE from 'three';
-import type { ProjectionAlias } from './Crs';
-export interface CoordinatesLike {
-    readonly crs: string;
-    readonly x: number;
-    readonly y: number;
-    readonly z: number;
-}
-/**
- * A class representing a geographic or geocentric coordinate.
- *
- * A coordinate is defined by a [CRS](http://inspire.ec.europa.eu/theme/rs)
- * (Coordinate Reference System) and a 3-dimensional vector `(x, y, z)`.
- * For geocentric projections, it is recommended to use the `latitude`,
- * `longitude` and `altitude` aliases to refer to vector components.
- *
- * To change a value, prefer the use of the `set*` methods.
- *
- * By default, the `EPSG:4978` and `EPSG:4326` projections are supported. To use
- * a different projection, it must have been declared previously with `proj4`.
- * A comprehensive list of projections and their corresponding proj4 string can
- * be found at [epsg.io](https://epsg.io/).
- *
- * @example Geocentric coordinates
- * ```js
- * new Coordinates('EPSG:4978', 20885167, 849862, 23385912);
- * ```
- *
- * @example Geographic coordinates
- * ```js
- * new Coordinates('EPSG:4326', 2.33, 48.24, 24999549);
- * ```
- *
- * @example Defining the EPSG:2154 projection with proj4
- * ```js
- * proj4.defs('EPSG:2154', `+proj=lcc +lat_0=46.5 +lon_0=3 +lat_1=49 +lat_2=44
- * +x_0=700000 +y_0=6600000 +ellps=GRS80 +towgs84=0,0,0,0,0,0,0 +units=m
- * +no_defs +type=crs`);
- * ```
- */
-declare class Coordinates {
-    /**
-     * Read-only flag to check if a given object is of type `Coordinates`.
-     */
-    readonly isCoordinates: boolean;
-    /**
-     * A default or user-defined CRS (see {@link ProjectionAlias}).
-     */
-    crs: ProjectionAlias;
-    /** The x value (or longitude) of this coordinate. */
-    x: number;
-    /** The y value (or latitude) of this coordinate. */
-    y: number;
-    /** The z value (or altitude) of this coordinate. */
-    z: number;
-    private _normal;
-    private _normalNeedsUpdate;
-    /**
-     * @param crs - A default or user-defined CRS (see {@link ProjectionAlias}).
-     * @param x - x or longitude value.
-     * @param y - y or latitude value.
-     * @param z - z or altitude value.
-     */
-    constructor(crs: ProjectionAlias, x?: number, y?: number, z?: number);
-    /**
-     * Sets the Coordinate Reference System.
-     * @param crs - Coordinate Reference System (e.g. 'EPSG:4978')
-     */
-    setCrs(crs: ProjectionAlias): this;
-    /**
-     * Sets the x, y and z components of this coordinate.
-     *
-     * @param x - x or longitude value.
-     * @param y - y or latitude value.
-     * @param z - z or altitude value.
-     */
-    setFromValues(x?: number, y?: number, z?: number): this;
-    /**
-     * Sets the coordinates's {@link Coordinates#x | x} component to
-     * `array[offset + 0]`, {@link Coordinates#y | y} component to
-     * `array[offset + 1]` and {@link Coordinates#z | z} component to
-     * `array[offset + 2]`.
-     *
-     * @param array - The source array.
-     * @param offset - Optional offset into the array. Default is 0.
-     */
-    setFromArray(array: number[], offset?: number): this;
-    /**
-     * Sets the `(x, y, z)` vector of this coordinate from a 3-dimensional
-     * vector-like object. This object shall have both `x`, `y` and `z`
-     * properties.
-     *
-     * @param v - The source object.
-     */
-    setFromVector3(v: THREE.Vector3Like): this;
-    /**
-     * Returns a new coordinate with the same `(x, y, z)` vector and crs as this
-     * one.
-     */
-    clone(): Coordinates;
-    /**
-     * Copies the `(x, y, z)` vector components and crs of the passed coordinate
-     * to this coordinate.
-     *
-     * @param src - The source coordinate to copy from.
-     */
-    copy(src: CoordinatesLike): this;
-    get longitude(): number;
-    get latitude(): number;
-    get altitude(): number;
-    set altitude(value: number);
-    /**
-     * The geodesic normal of the coordinate.
-     */
-    get geodesicNormal(): THREE.Vector3;
-    /**
-     * Copies the `x`, `y` and `z` components into the provided `THREE.Vector3`.
-     *
-     * @param target - An object to store this vector to. If this is not
-     * specified, a new vector will be created.
-     *
-     * @returns A vector `(x, y, z)`, or copies x, y and z into the provided
-     * vector.
-     */
-    toVector3(target?: THREE.Vector3): THREE.Vector3;
-    /**
-     * Copies the `x`, `y` and `z` components into the provided array.
-     *
-     * @param array - An array to store this vector to. If this is not
-     * provided a new array will be created.
-     * @param offset - An optional offset into the array.
-     *
-     * @returns An array [x, y, z], or copies x, y and z into the provided
-     * array.
-     */
-    toArray(array?: number[], offset?: number): ArrayLike<number>;
-    /**
-     * Computes the planar distance from this coordinates to `coord`.
-     * **Planar distance** is the straight-line euclidean distance calculated in
-     * a 2D cartesian coordinate system.
-     */
-    planarDistanceTo(coord: Coordinates): number;
-    /**
-     * Computes the geodetic distance from this coordinates to `coord`.
-     * **Geodetic distance** is calculated in an ellipsoid space as the shortest
-     * distance across the curved surface of the ellipsoid.
-     */
-    geodeticDistanceTo(coord: Coordinates): number;
-    /**
-     * Computes the euclidean distance from this coordinates to `coord` in a
-     * WGS84 projection.
-     *
-     * @param coord - The coordinate
-     * @returns earth euclidean distance
-     */
-    spatialEuclideanDistanceTo(coord: Coordinates): number;
-    /**
-     * Multiplies this coordinate (with an implicit 1 in the 4th dimension)
-     * by `mat`, and divides by perspective.
-     *
-     * @param mat - The matrix.
-     */
-    applyMatrix4(mat: THREE.Matrix4): this;
-    /**
-     * Projects this coordinate to the specified
-     * [CRS](http://inspire.ec.europa.eu/theme/rs).
-     *
-     * @param crs - The target CRS to which the coordinate will be converted.
-     * @param target - The target to store the projected coordinate. If this not
-     * provided a new coordinate will be created.
-     *
-     * @returns The coordinate projected into the specified CRS.
-     *
-     * @example Conversion from a geographic to a geocentric reference system
-     * ```js
-     * const geographicCoords = new Coordinates('EPSG:4326',
-     *     2.33,        // longitude
-     *     48.24,       // latitude
-     *     24999549,    // altitude
-     * );
-     * const geocentricCoords = geographicCoords.as('EPSG:4978');
-     * ```
-     *
-     * @example Conversion from a geocentric to a geographic reference system
-     * ```js
-     * const geocentricCoords = new Coordinates('EPSG:4978',
-     *     20885167,    // x
-     *     849862,      // y
-     *     23385912,    // z
-     * );
-     * const geographicCoords = geocentricCoords.as('EPSG:4326');
-     * ```
-     */
-    as(crs: ProjectionAlias, target?: Coordinates): Coordinates;
-}
-export default Coordinates;