proj4 2.17.0 → 2.19.0

package/dist/projs.d.ts

@@ -0,0 +1 @@
+export default function _default(proj4: any): void;

package/lib/Point.js

@@ -1,5 +1,11 @@
 import { toPoint, forward } from 'mgrs';
 
+/**
+ * @deprecated v3.0.0 - use proj4.toPoint instead
+ * @param {number | import('./core').TemplateCoordinates | string} x
+ * @param {number} [y]
+ * @param {number} [z]
+ */
 function Point(x, y, z) {
   if (!(this instanceof Point)) {
     return new Point(x, y, z);
@@ -14,9 +20,9 @@ function Point(x, y, z) {
     this.z = x.z || 0.0;
   } else if (typeof x === 'string' && typeof y === 'undefined') {
     var coords = x.split(',');
-    this.x = parseFloat(coords[0], 10);
-    this.y = parseFloat(coords[1], 10);
-    this.z = parseFloat(coords[2], 10) || 0.0;
+    this.x = parseFloat(coords[0]);
+    this.y = parseFloat(coords[1]);
+    this.z = parseFloat(coords[2]) || 0.0;
   } else {
     this.x = x;
     this.y = y;

package/lib/Proj.js

@@ -7,10 +7,31 @@ import datum from './datum';
 import match from './match';
 import { getNadgrids } from './nadgrid';
 
+/**
+ * @typedef {Object} DatumDefinition
+ * @property {number} datum_type - The type of datum.
+ * @property {number} a - Semi-major axis of the ellipsoid.
+ * @property {number} b - Semi-minor axis of the ellipsoid.
+ * @property {number} es - Eccentricity squared of the ellipsoid.
+ * @property {number} ep2 - Second eccentricity squared of the ellipsoid.
+ */
+
+/**
+ * @param {string | import('./core').PROJJSONDefinition | import('./defs').ProjectionDefinition} srsCode
+ * @param {(errorMessage?: string, instance?: Projection) => void} [callback]
+ */
 function Projection(srsCode, callback) {
   if (!(this instanceof Projection)) {
     return new Projection(srsCode);
   }
+  /** @type {<T extends import('./core').TemplateCoordinates>(coordinates: T, enforceAxis?: boolean) => T} */
+  this.forward = null;
+  /** @type {<T extends import('./core').TemplateCoordinates>(coordinates: T, enforceAxis?: boolean) => T} */
+  this.inverse = null;
+  /** @type {string} */
+  this.name;
+  /** @type {string} */
+  this.title;
   callback = callback || function (error) {
     if (error) {
       throw error;
@@ -42,6 +63,7 @@ function Projection(srsCode, callback) {
   var sphere_ = dc_sphere(json.a, json.b, json.rf, json.ellps, json.sphere);
   var ecc = dc_eccentricity(sphere_.a, sphere_.b, sphere_.rf, json.R_A);
   var nadgrids = getNadgrids(json.nadgrids);
+  /** @type {DatumDefinition} */
   var datumObj = json.datum || datum(json.datumCode, json.datum_params, sphere_.a, sphere_.b, ecc.es, ecc.ep2,
     nadgrids);
 
@@ -63,7 +85,9 @@ function Projection(srsCode, callback) {
   this.datum = datumObj;
 
   // init the projection
-  this.init();
+  if ('init' in this && typeof this.init === 'function') {
+    this.init();
+  }
 
   // legecy callback from back in the day when it went to spatialreference.org
   callback(null, this);

package/lib/adjust_axis.js

@@ -3,6 +3,7 @@ export default function (crs, denorm, point) {
     yin = point.y,
     zin = point.z || 0.0;
   var v, t, i;
+  /** @type {import("./core").InterfaceCoordinates} */
   var out = {};
   for (i = 0; i < 3; i++) {
     if (denorm && i === 2 && point.z === undefined) {

package/lib/common/toPoint.js

@@ -1,3 +1,7 @@
+/**
+ * @param {Array<number>} array
+ * @returns {import("../core").InterfaceCoordinates}
+ */
 export default function (array) {
   var out = {
     x: array[0],

package/lib/common/vincenty.js

@@ -0,0 +1,123 @@
+/**
+ * Calculates the inverse geodesic problem using Vincenty's formulae.
+ * Computes the forward azimuth and ellipsoidal distance between two points
+ * specified by latitude and longitude on the surface of an ellipsoid.
+ *
+ * @param {number} lat1 Latitude of the first point in radians.
+ * @param {number} lon1 Longitude of the first point in radians.
+ * @param {number} lat2 Latitude of the second point in radians.
+ * @param {number} lon2 Longitude of the second point in radians.
+ * @param {number} a Semi-major axis of the ellipsoid (meters).
+ * @param {number} f Flattening of the ellipsoid.
+ * @returns {{ azi1: number, s12: number }} An object containing:
+ *   - azi1: Forward azimuth from the first point to the second point (radians).
+ *   - s12: Ellipsoidal distance between the two points (meters).
+ */
+export function vincentyInverse(lat1, lon1, lat2, lon2, a, f) {
+  const L = lon2 - lon1;
+  const U1 = Math.atan((1 - f) * Math.tan(lat1));
+  const U2 = Math.atan((1 - f) * Math.tan(lat2));
+  const sinU1 = Math.sin(U1), cosU1 = Math.cos(U1);
+  const sinU2 = Math.sin(U2), cosU2 = Math.cos(U2);
+
+  let lambda = L, lambdaP, iterLimit = 100;
+  let sinLambda, cosLambda, sinSigma, cosSigma, sigma, sinAlpha, cos2Alpha, cos2SigmaM, C;
+  let uSq, A, B, deltaSigma, s;
+
+  do {
+    sinLambda = Math.sin(lambda);
+    cosLambda = Math.cos(lambda);
+    sinSigma = Math.sqrt(
+      (cosU2 * sinLambda) * (cosU2 * sinLambda)
+      + (cosU1 * sinU2 - sinU1 * cosU2 * cosLambda)
+      * (cosU1 * sinU2 - sinU1 * cosU2 * cosLambda)
+    );
+    if (sinSigma === 0) {
+      return { azi1: 0, s12: 0 }; // coincident points
+    }
+    cosSigma = sinU1 * sinU2 + cosU1 * cosU2 * cosLambda;
+    sigma = Math.atan2(sinSigma, cosSigma);
+    sinAlpha = cosU1 * cosU2 * sinLambda / sinSigma;
+    cos2Alpha = 1 - sinAlpha * sinAlpha;
+    cos2SigmaM = (cos2Alpha !== 0) ? (cosSigma - 2 * sinU1 * sinU2 / cos2Alpha) : 0;
+    C = f / 16 * cos2Alpha * (4 + f * (4 - 3 * cos2Alpha));
+    lambdaP = lambda;
+    lambda = L + (1 - C) * f * sinAlpha
+    * (sigma + C * sinSigma * (cos2SigmaM + C * cosSigma * (-1 + 2 * cos2SigmaM * cos2SigmaM)));
+  } while (Math.abs(lambda - lambdaP) > 1e-12 && --iterLimit > 0);
+
+  if (iterLimit === 0) {
+    return { azi1: NaN, s12: NaN }; // formula failed to converge
+  }
+
+  uSq = cos2Alpha * (a * a - (a * (1 - f)) * (a * (1 - f))) / ((a * (1 - f)) * (a * (1 - f)));
+  A = 1 + uSq / 16384 * (4096 + uSq * (-768 + uSq * (320 - 175 * uSq)));
+  B = uSq / 1024 * (256 + uSq * (-128 + uSq * (74 - 47 * uSq)));
+  deltaSigma = B * sinSigma * (cos2SigmaM + B / 4 * (cosSigma * (-1 + 2 * cos2SigmaM * cos2SigmaM)
+    - B / 6 * cos2SigmaM * (-3 + 4 * sinSigma * sinSigma) * (-3 + 4 * cos2SigmaM * cos2SigmaM)));
+
+  s = (a * (1 - f)) * A * (sigma - deltaSigma);
+
+  // Forward azimuth
+  const azi1 = Math.atan2(cosU2 * sinLambda, cosU1 * sinU2 - sinU1 * cosU2 * cosLambda);
+
+  return { azi1, s12: s };
+}
+
+/**
+ * Solves the direct geodetic problem using Vincenty's formulae.
+ * Given a starting point, initial azimuth, and distance, computes the destination point on the ellipsoid.
+ *
+ * @param {number} lat1 Latitude of the starting point in radians.
+ * @param {number} lon1 Longitude of the starting point in radians.
+ * @param {number} azi1 Initial azimuth (forward azimuth) in radians.
+ * @param {number} s12 Distance to travel from the starting point in meters.
+ * @param {number} a Semi-major axis of the ellipsoid in meters.
+ * @param {number} f Flattening of the ellipsoid.
+ * @returns {{lat2: number, lon2: number}} The latitude and longitude (in radians) of the destination point.
+ */
+export function vincentyDirect(lat1, lon1, azi1, s12, a, f) {
+  const U1 = Math.atan((1 - f) * Math.tan(lat1));
+  const sinU1 = Math.sin(U1), cosU1 = Math.cos(U1);
+  const sinAlpha1 = Math.sin(azi1), cosAlpha1 = Math.cos(azi1);
+
+  const sigma1 = Math.atan2(sinU1, cosU1 * cosAlpha1);
+  const sinAlpha = cosU1 * sinAlpha1;
+  const cos2Alpha = 1 - sinAlpha * sinAlpha;
+  const uSq = cos2Alpha * (a * a - (a * (1 - f)) * (a * (1 - f))) / ((a * (1 - f)) * (a * (1 - f)));
+  const A = 1 + uSq / 16384 * (4096 + uSq * (-768 + uSq * (320 - 175 * uSq)));
+  const B = uSq / 1024 * (256 + uSq * (-128 + uSq * (74 - 47 * uSq)));
+
+  let sigma = s12 / ((a * (1 - f)) * A), sigmaP, iterLimit = 100;
+  let cos2SigmaM, sinSigma, cosSigma, deltaSigma;
+
+  do {
+    cos2SigmaM = Math.cos(2 * sigma1 + sigma);
+    sinSigma = Math.sin(sigma);
+    cosSigma = Math.cos(sigma);
+    deltaSigma = B * sinSigma * (cos2SigmaM + B / 4 * (cosSigma * (-1 + 2 * cos2SigmaM * cos2SigmaM)
+      - B / 6 * cos2SigmaM * (-3 + 4 * sinSigma * sinSigma) * (-3 + 4 * cos2SigmaM * cos2SigmaM)));
+    sigmaP = sigma;
+    sigma = s12 / ((a * (1 - f)) * A) + deltaSigma;
+  } while (Math.abs(sigma - sigmaP) > 1e-12 && --iterLimit > 0);
+
+  if (iterLimit === 0) {
+    return { lat2: NaN, lon2: NaN };
+  }
+
+  const tmp = sinU1 * sinSigma - cosU1 * cosSigma * cosAlpha1;
+  const lat2 = Math.atan2(
+    sinU1 * cosSigma + cosU1 * sinSigma * cosAlpha1,
+    (1 - f) * Math.sqrt(sinAlpha * sinAlpha + tmp * tmp)
+  );
+  const lambda = Math.atan2(
+    sinSigma * sinAlpha1,
+    cosU1 * cosSigma - sinU1 * sinSigma * cosAlpha1
+  );
+  const C = f / 16 * cos2Alpha * (4 + f * (4 - 3 * cos2Alpha));
+  const L = lambda - (1 - C) * f * sinAlpha
+    * (sigma + C * sinSigma * (cos2SigmaM + C * cosSigma * (-1 + 2 * cos2SigmaM * cos2SigmaM)));
+  const lon2 = lon1 + L;
+
+  return { lat2, lon2 };
+}

package/lib/constants/PrimeMeridian.js

@@ -1,16 +1,17 @@
-var exports = {};
-export { exports as default };
+var primeMeridian = {};
 
-exports.greenwich = 0.0; // "0dE",
-exports.lisbon = -9.131906111111; // "9d07'54.862\"W",
-exports.paris = 2.337229166667; // "2d20'14.025\"E",
-exports.bogota = -74.080916666667; // "74d04'51.3\"W",
-exports.madrid = -3.687938888889; // "3d41'16.58\"W",
-exports.rome = 12.452333333333; // "12d27'8.4\"E",
-exports.bern = 7.439583333333; // "7d26'22.5\"E",
-exports.jakarta = 106.807719444444; // "106d48'27.79\"E",
-exports.ferro = -17.666666666667; // "17d40'W",
-exports.brussels = 4.367975; // "4d22'4.71\"E",
-exports.stockholm = 18.058277777778; // "18d3'29.8\"E",
-exports.athens = 23.7163375; // "23d42'58.815\"E",
-exports.oslo = 10.722916666667; // "10d43'22.5\"E"
+primeMeridian.greenwich = 0.0; // "0dE",
+primeMeridian.lisbon = -9.131906111111; // "9d07'54.862\"W",
+primeMeridian.paris = 2.337229166667; // "2d20'14.025\"E",
+primeMeridian.bogota = -74.080916666667; // "74d04'51.3\"W",
+primeMeridian.madrid = -3.687938888889; // "3d41'16.58\"W",
+primeMeridian.rome = 12.452333333333; // "12d27'8.4\"E",
+primeMeridian.bern = 7.439583333333; // "7d26'22.5\"E",
+primeMeridian.jakarta = 106.807719444444; // "106d48'27.79\"E",
+primeMeridian.ferro = -17.666666666667; // "17d40'W",
+primeMeridian.brussels = 4.367975; // "4d22'4.71\"E",
+primeMeridian.stockholm = 18.058277777778; // "18d3'29.8\"E",
+primeMeridian.athens = 23.7163375; // "23d42'58.815\"E",
+primeMeridian.oslo = 10.722916666667; // "10d43'22.5\"E"
+
+export default primeMeridian;

package/lib/core.js

@@ -2,6 +2,85 @@ import proj from './Proj';
 import transform from './transform';
 var wgs84 = proj('WGS84');
 
+/**
+ * @typedef {{x: number, y: number, z?: number, m?: number}} InterfaceCoordinates
+ */
+
+/**
+ * @typedef {Array<number> | InterfaceCoordinates} TemplateCoordinates
+ */
+
+/**
+ * @typedef {Object} Converter
+ * @property {<T extends TemplateCoordinates>(coordinates: T, enforceAxis?: boolean) => T} forward
+ * @property {<T extends TemplateCoordinates>(coordinates: T, enforceAxis?: boolean) => T} inverse
+ * @property {proj} [oProj]
+ */
+
+/**
+ * @typedef {Object} PROJJSONDefinition
+ * @property {string} [$schema]
+ * @property {string} type
+ * @property {string} [name]
+ * @property {{authority: string, code: number}} [id]
+ * @property {string} [scope]
+ * @property {string} [area]
+ * @property {{south_latitude: number, west_longitude: number, north_latitude: number, east_longitude: number}} [bbox]
+ * @property {PROJJSONDefinition[]} [components]
+ * @property {{type: string, name: string}} [datum]
+ * @property {{
+ *   name: string,
+ *   members: Array<{
+ *     name: string,
+ *     id?: {authority: string, code: number}
+ *   }>,
+ *   ellipsoid?: {
+ *     name: string,
+ *     semi_major_axis: number,
+ *     inverse_flattening?: number
+ *   },
+ *   accuracy?: string,
+ *   id?: {authority: string, code: number}
+ * }} [datum_ensemble]
+ * @property {{
+ *   subtype: string,
+ *   axis: Array<{
+ *     name: string,
+ *     abbreviation?: string,
+ *     direction: string,
+ *     unit: string
+ *   }>
+ * }} [coordinate_system]
+ * @property {{
+ *   name: string,
+ *   method: {name: string},
+ *   parameters: Array<{
+ *     name: string,
+ *     value: number,
+ *     unit?: string
+ *   }>
+ * }} [conversion]
+ * @property {{
+ *   name: string,
+ *   method: {name: string},
+ *   parameters: Array<{
+ *     name: string,
+ *     value: number,
+ *     unit?: string,
+ *     type?: string,
+ *     file_name?: string
+ *   }>
+ * }} [transformation]
+ */
+
+/**
+ * @template {TemplateCoordinates} T
+ * @param {proj} from
+ * @param {proj} to
+ * @param {T} coords
+ * @param {boolean} [enforceAxis]
+ * @returns {T}
+ */
 function transformer(from, to, coords, enforceAxis) {
   var transformedArray, out, keys;
   if (Array.isArray(coords)) {
@@ -9,21 +88,21 @@ function transformer(from, to, coords, enforceAxis) {
     if (coords.length > 2) {
       if ((typeof from.name !== 'undefined' && from.name === 'geocent') || (typeof to.name !== 'undefined' && to.name === 'geocent')) {
         if (typeof transformedArray.z === 'number') {
-          return [transformedArray.x, transformedArray.y, transformedArray.z].concat(coords.slice(3));
+          return /** @type {T} */ ([transformedArray.x, transformedArray.y, transformedArray.z].concat(coords.slice(3)));
         } else {
-          return [transformedArray.x, transformedArray.y, coords[2]].concat(coords.slice(3));
+          return /** @type {T} */ ([transformedArray.x, transformedArray.y, coords[2]].concat(coords.slice(3)));
         }
       } else {
-        return [transformedArray.x, transformedArray.y].concat(coords.slice(2));
+        return /** @type {T} */ ([transformedArray.x, transformedArray.y].concat(coords.slice(2)));
       }
     } else {
-      return [transformedArray.x, transformedArray.y];
+      return /** @type {T} */ ([transformedArray.x, transformedArray.y]);
     }
   } else {
     out = transform(from, to, coords, enforceAxis);
     keys = Object.keys(coords);
     if (keys.length === 2) {
-      return out;
+      return /** @type {T} */ (out);
     }
     keys.forEach(function (key) {
       if ((typeof from.name !== 'undefined' && from.name === 'geocent') || (typeof to.name !== 'undefined' && to.name === 'geocent')) {
@@ -37,42 +116,98 @@ function transformer(from, to, coords, enforceAxis) {
       }
       out[key] = coords[key];
     });
-    return out;
+    return /** @type {T} */ (out);
   }
 }
 
+/**
+ * @param {proj | string | PROJJSONDefinition | Converter} item
+ * @returns {import('./Proj').default}
+ */
 function checkProj(item) {
   if (item instanceof proj) {
     return item;
   }
-  if (item.oProj) {
+  if (typeof item === 'object' && 'oProj' in item) {
     return item.oProj;
   }
-  return proj(item);
+  return proj(/** @type {string | PROJJSONDefinition} */ (item));
 }
 
-function proj4(fromProj, toProj, coord) {
-  fromProj = checkProj(fromProj);
+/**
+ * @overload
+ * @param {string | PROJJSONDefinition | proj} toProj
+ * @returns {Converter}
+ */
+/**
+ * @overload
+ * @param {string | PROJJSONDefinition | proj} fromProj
+ * @param {string | PROJJSONDefinition | proj} toProj
+ * @returns {Converter}
+ */
+/**
+ * @overload
+ * @param {string | PROJJSONDefinition | proj} toProj
+ * @param {T} coord
+ * @returns {T}
+ */
+/**
+ * @overload
+ * @param {string | PROJJSONDefinition | proj} fromProj
+ * @param {string | PROJJSONDefinition | proj} toProj
+ * @param {T} coord
+ * @returns {T}
+ */
+/**
+ * @template {TemplateCoordinates} T
+ * @param {string | PROJJSONDefinition | proj} fromProjOrToProj
+ * @param {string | PROJJSONDefinition | proj | TemplateCoordinates} [toProjOrCoord]
+ * @param {T} [coord]
+ * @returns {T|Converter}
+ */
+function proj4(fromProjOrToProj, toProjOrCoord, coord) {
+  /** @type {proj} */
+  var fromProj;
+  /** @type {proj} */
+  var toProj;
   var single = false;
+  /** @type {Converter} */
   var obj;
-  if (typeof toProj === 'undefined') {
-    toProj = fromProj;
+  if (typeof toProjOrCoord === 'undefined') {
+    toProj = checkProj(fromProjOrToProj);
     fromProj = wgs84;
     single = true;
-  } else if (typeof toProj.x !== 'undefined' || Array.isArray(toProj)) {
-    coord = toProj;
-    toProj = fromProj;
+  } else if (typeof /** @type {?} */ (toProjOrCoord).x !== 'undefined' || Array.isArray(toProjOrCoord)) {
+    coord = /** @type {T} */ (/** @type {?} */ (toProjOrCoord));
+    toProj = checkProj(fromProjOrToProj);
     fromProj = wgs84;
     single = true;
   }
-  toProj = checkProj(toProj);
+  if (!fromProj) {
+    fromProj = checkProj(fromProjOrToProj);
+  }
+  if (!toProj) {
+    toProj = checkProj(/** @type {string | PROJJSONDefinition | proj } */ (toProjOrCoord));
+  }
   if (coord) {
     return transformer(fromProj, toProj, coord);
   } else {
     obj = {
+      /**
+       * @template {TemplateCoordinates} T
+       * @param {T} coords
+       * @param {boolean=} enforceAxis
+       * @returns {T}
+       */
       forward: function (coords, enforceAxis) {
         return transformer(fromProj, toProj, coords, enforceAxis);
       },
+      /**
+       * @template {TemplateCoordinates} T
+       * @param {T} coords
+       * @param {boolean=} enforceAxis
+       * @returns {T}
+       */
       inverse: function (coords, enforceAxis) {
         return transformer(toProj, fromProj, coords, enforceAxis);
       }
@@ -83,4 +218,5 @@ function proj4(fromProj, toProj, coord) {
     return obj;
   }
 }
+
 export default proj4;

package/lib/defs.js

@@ -2,6 +2,66 @@ import globals from './global';
 import parseProj from './projString';
 import wkt from 'wkt-parser';
 
+/**
+ * @typedef {Object} ProjectionDefinition
+ * @property {string} title
+ * @property {string} [projName]
+ * @property {string} [ellps]
+ * @property {import('./Proj.js').DatumDefinition} [datum]
+ * @property {string} [datumName]
+ * @property {number} [rf]
+ * @property {number} [lat0]
+ * @property {number} [lat1]
+ * @property {number} [lat2]
+ * @property {number} [lat_ts]
+ * @property {number} [long0]
+ * @property {number} [long1]
+ * @property {number} [long2]
+ * @property {number} [alpha]
+ * @property {number} [longc]
+ * @property {number} [x0]
+ * @property {number} [y0]
+ * @property {number} [k0]
+ * @property {number} [a]
+ * @property {number} [b]
+ * @property {true} [R_A]
+ * @property {number} [zone]
+ * @property {true} [utmSouth]
+ * @property {string|Array<number>} [datum_params]
+ * @property {number} [to_meter]
+ * @property {string} [units]
+ * @property {number} [from_greenwich]
+ * @property {string} [datumCode]
+ * @property {string} [nadgrids]
+ * @property {string} [axis]
+ * @property {boolean} [sphere]
+ * @property {number} [rectified_grid_angle]
+ * @property {boolean} [approx]
+ * @property {<T extends import('./core').TemplateCoordinates>(coordinates: T, enforceAxis?: boolean) => T} inverse
+ * @property {<T extends import('./core').TemplateCoordinates>(coordinates: T, enforceAxis?: boolean) => T} forward
+ */
+
+/**
+ * @overload
+ * @param {string} name
+ * @param {string|ProjectionDefinition|import('./core.js').PROJJSONDefinition} projection
+ * @returns {void}
+ */
+/**
+ * @overload
+ * @param {Array<string, string>} name
+ * @returns {Array<ProjectionDefinition|undefined>}
+ */
+/**
+ * @overload
+ * @param {string} name
+ * @returns {ProjectionDefinition}
+ */
+
+/**
+ * @param {string | Array<Array<string>> | Partial<Record<'EPSG'|'ESRI'|'IAU2000', ProjectionDefinition>>} name
+ * @returns {ProjectionDefinition | Array<ProjectionDefinition|undefined> | void}
+ */
 function defs(name) {
   /* global console */
   var that = this;
@@ -9,20 +69,20 @@ function defs(name) {
     var def = arguments[1];
     if (typeof def === 'string') {
       if (def.charAt(0) === '+') {
-        defs[name] = parseProj(arguments[1]);
+        defs[/** @type {string} */ (name)] = parseProj(arguments[1]);
       } else {
-        defs[name] = wkt(arguments[1]);
+        defs[/** @type {string} */ (name)] = wkt(arguments[1]);
       }
     } else {
-      defs[name] = def;
+      defs[/** @type {string} */ (name)] = def;
     }
   } else if (arguments.length === 1) {
     if (Array.isArray(name)) {
       return name.map(function (v) {
         if (Array.isArray(v)) {
-          defs.apply(that, v);
+          return defs.apply(that, v);
         } else {
-          defs(v);
+          return defs(v);
         }
       });
     } else if (typeof name === 'string') {

package/lib/index.js

@@ -1,4 +1,4 @@
-import proj4 from './core';
+import core from './core';
 import Proj from './Proj';
 import Point from './Point';
 import common from './common/toPoint';
@@ -8,15 +8,21 @@ import transform from './transform';
 import mgrs from 'mgrs';
 import includedProjections from '../projs';
 
-proj4.defaultDatum = 'WGS84'; // default datum
-proj4.Proj = Proj;
-proj4.WGS84 = new proj4.Proj('WGS84');
-proj4.Point = Point;
-proj4.toPoint = common;
-proj4.defs = defs;
-proj4.nadgrid = nadgrid;
-proj4.transform = transform;
-proj4.mgrs = mgrs;
-proj4.version = '__VERSION__';
+/**
+ * @template {import('./core').TemplateCoordinates} T
+ * @type {core<T> & {defaultDatum: string, Proj: typeof Proj, WGS84: Proj, Point: typeof Point, toPoint: typeof common, defs: typeof defs, nadgrid: typeof nadgrid, transform: typeof transform, mgrs: typeof mgrs, version: string}}
+ */
+const proj4 = Object.assign(core, {
+  defaultDatum: 'WGS84',
+  Proj,
+  WGS84: new Proj('WGS84'),
+  Point,
+  toPoint: common,
+  defs,
+  nadgrid,
+  transform,
+  mgrs,
+  version: '__VERSION__'
+});
 includedProjections(proj4);
 export default proj4;