proj4 2.20.8 → 2.20.9

package/lib/Proj.js

@@ -32,6 +32,8 @@ function Projection(srsCode, callback) {
   this.init = null;
   /** @type {string} */
   this.name;
+  /** @type {string} */
+  this.axis;
   /** @type {Array<string>} */
   this.names = null;
   /** @type {string} */

package/lib/adjust_axis.js

@@ -1,57 +1,79 @@
-export default function (crs, denorm, point) {
-  var xin = point.x,
-    yin = point.y,
-    zin = point.z || 0.0;
-  var v, t, i;
+var order = ['x', 'y', 'z'];
+
+/**
+ * Convert a point in a given CRS axis order to ENU (east/north/up) order
+ * @param {import('./defs').ProjectionDefinition} crs
+ * @param {import('./core').InterfaceCoordinates} point
+ * @returns {import('./core').InterfaceCoordinates | null}
+ */
+export function adjustAxisToEnu(crs, point) {
   /** @type {import("./core").InterfaceCoordinates} */
-  var out = {};
-  for (i = 0; i < 3; i++) {
-    if (denorm && i === 2 && point.z === undefined) {
+  const out = {};
+  for (let i = 0, ii = crs.axis.length; i < ii; i++) {
+    if (i === 2 && point.z === undefined) {
       continue;
     }
-    if (i === 0) {
-      v = xin;
-      if ('ew'.indexOf(crs.axis[i]) !== -1) {
-        t = 'x';
-      } else {
-        t = 'y';
-      }
-    } else if (i === 1) {
-      v = yin;
-      if ('ns'.indexOf(crs.axis[i]) !== -1) {
-        t = 'y';
-      } else {
-        t = 'x';
-      }
-    } else {
-      v = zin;
-      t = 'z';
+    let v = point[order[i]];
+    switch (crs.axis[i]) {
+      case 'e':
+        out.x = v;
+        break;
+      case 'w':
+        out.x = -v;
+        break;
+      case 'n':
+        out.y = v;
+        break;
+      case 's':
+        out.y = -v;
+        break;
+      case 'u':
+        out.z = v;
+        break;
+      case 'd':
+        out.z = -v;
+        break;
+      default:
+        // console.log("ERROR: unknown axis ("+crs.axis[i]+") - check definition of "+crs.projName);
+        return null;
+    }
+  }
+  return out;
+}
+
+/**
+ * Convert a point in ENU (east/north/up) order to the given CRS axis order.
+ * @param {import('./defs').ProjectionDefinition} crs
+ * @param {import('./core').InterfaceCoordinates} point
+ * @returns {import('./core').InterfaceCoordinates | null}
+ */
+export function adjustAxisFromEnu(crs, point) {
+  const out = /** @type {import("./core").InterfaceCoordinates} */ ({});
+  for (let i = 0, ii = crs.axis.length; i < ii; i++) {
+    if (i === 2 && point.z === undefined) {
+      continue;
     }
     switch (crs.axis[i]) {
       case 'e':
-        out[t] = v;
+        out[order[i]] = point.x;
         break;
       case 'w':
-        out[t] = -v;
+        out[order[i]] = -point.x;
         break;
       case 'n':
-        out[t] = v;
+        out[order[i]] = point.y;
         break;
       case 's':
-        out[t] = -v;
+        out[order[i]] = -point.y;
         break;
       case 'u':
-        if (point[t] !== undefined) {
-          out.z = v;
-        }
+        out[order[i]] = point.z;
         break;
       case 'd':
-        if (point[t] !== undefined) {
-          out.z = -v;
-        }
+        out[order[i]] = -point.z;
         break;
       default:
-      // console.log("ERROR: unknow axis ("+crs.axis[i]+") - check definition of "+crs.projName);
+        // console.log("ERROR: unknown axis ("+crs.axis[i]+") - check definition of "+crs.projName);
         return null;
     }
   }

package/lib/common/authlat.js

@@ -0,0 +1,4 @@
+export default function authlat(beta, APA) {
+  var t = beta + beta;
+  return (beta + APA[0] * Math.sin(t) + APA[1] * Math.sin(t + t) + APA[2] * Math.sin(t + t + t));
+}

package/lib/common/authset.js

@@ -0,0 +1,20 @@
+var P00 = 0.33333333333333333333;
+var P01 = 0.17222222222222222222;
+var P02 = 0.10257936507936507936;
+var P10 = 0.06388888888888888888;
+var P11 = 0.06640211640211640211;
+var P20 = 0.01641501294219154443;
+
+export default function authset(es) {
+  var t;
+  var APA = [];
+  APA[0] = es * P00;
+  t = es * es;
+  APA[0] += t * P01;
+  APA[1] = t * P10;
+  t *= es;
+  APA[0] += t * P02;
+  APA[1] += t * P11;
+  APA[2] = t * P20;
+  return APA;
+}

package/lib/core.js

@@ -1,5 +1,6 @@
 import proj from './Proj';
-import transform from './transform';
+import { transformInternal } from './transform';
+import toPoint from './common/toPoint';
 var wgs84 = proj('WGS84');
 
 /**
@@ -82,37 +83,36 @@ var wgs84 = proj('WGS84');
  * @returns {T}
  */
 function transformer(from, to, coords, enforceAxis) {
-  var transformedArray, out, keys;
+  var out, geocent, keys;
   if (Array.isArray(coords)) {
-    transformedArray = transform(from, to, coords, enforceAxis) || { x: NaN, y: NaN };
+    out = transformInternal(from, to, toPoint(coords), enforceAxis) || { x: NaN, y: NaN };
     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 /** @type {T} */ ([transformedArray.x, transformedArray.y, transformedArray.z].concat(coords.slice(3)));
-        } else {
-          return /** @type {T} */ ([transformedArray.x, transformedArray.y, coords[2]].concat(coords.slice(3)));
+      geocent = (typeof from.name !== 'undefined' && from.name === 'geocent') || (typeof to.name !== 'undefined' && to.name === 'geocent');
+      if (geocent) {
+        if (typeof out.z === 'number') {
+          return /** @type {T} */ ([out.x, out.y, out.z].concat(coords.slice(3)));
         }
-      } else {
-        return /** @type {T} */ ([transformedArray.x, transformedArray.y].concat(coords.slice(2)));
+        return /** @type {T} */ ([out.x, out.y, coords[2]].concat(coords.slice(3)));
       }
-    } else {
-      return /** @type {T} */ ([transformedArray.x, transformedArray.y]);
+      if (enforceAxis && typeof out.z === 'number') {
+        return /** @type {T} */ ([out.x, out.y, out.z].concat(coords.slice(3)));
+      }
+      return /** @type {T} */ ([out.x, out.y].concat(coords.slice(2)));
     }
+    return /** @type {T} */ ([out.x, out.y]);
   } else {
-    out = transform(from, to, coords, enforceAxis);
+    out = transformInternal(from, to, { x: coords.x, y: coords.y, z: coords.z, m: coords.m }, enforceAxis) || { x: NaN, y: NaN };
     keys = Object.keys(coords);
     if (keys.length === 2) {
       return /** @type {T} */ (out);
     }
+    geocent = (typeof from.name !== 'undefined' && from.name === 'geocent') || (typeof to.name !== 'undefined' && to.name === 'geocent');
     keys.forEach(function (key) {
-      if ((typeof from.name !== 'undefined' && from.name === 'geocent') || (typeof to.name !== 'undefined' && to.name === 'geocent')) {
-        if (key === 'x' || key === 'y' || key === 'z') {
-          return;
-        }
-      } else {
-        if (key === 'x' || key === 'y') {
-          return;
-        }
+      if (key === 'x' || key === 'y') {
+        return;
+      }
+      if (key === 'z' && (geocent || enforceAxis)) {
+        return;
       }
       out[key] = coords[key];
     });

package/lib/datum.js

@@ -2,14 +2,10 @@ import { PJD_3PARAM, PJD_7PARAM, PJD_GRIDSHIFT, PJD_WGS84, PJD_NODATUM, SEC_TO_R
 
 function datum(datumCode, datum_params, a, b, es, ep2, nadgrids) {
   var out = {};
-
-  if (datumCode === undefined || datumCode === 'none') {
-    out.datum_type = PJD_NODATUM;
-  } else {
-    out.datum_type = PJD_WGS84;
-  }
+  out.datum_type = PJD_NODATUM;
 
   if (datum_params) {
+    out.datum_type = PJD_WGS84;
     out.datum_params = datum_params.map(parseFloat);
     if (out.datum_params[0] !== 0 || out.datum_params[1] !== 0 || out.datum_params[2] !== 0) {
       out.datum_type = PJD_3PARAM;

package/lib/includedProjections.js

@@ -16,6 +16,7 @@ import poly from './projections/poly';
 import nzmg from './projections/nzmg';
 import mill from './projections/mill';
 import sinu from './projections/sinu';
+import eck6 from './projections/eck6';
 import moll from './projections/moll';
 import eqdc from './projections/eqdc';
 import vandg from './projections/vandg';
@@ -49,6 +50,7 @@ var projs = [
   nzmg,
   mill,
   sinu,
+  eck6,
   moll,
   eqdc,
   vandg,

package/lib/nadgrid.js

@@ -40,22 +40,6 @@
 
 /** @typedef {{header: NadgridHeader, subgrids: Array<Subgrid>}} NADGrid */
 
-/**
- * @typedef {Object} GeoTIFF
- * @property {() => Promise<number>} getImageCount - Returns the number of images in the GeoTIFF.
- * @property {(index: number) => Promise<GeoTIFFImage>} getImage - Returns a GeoTIFFImage for the given index.
- */
-
-/**
- * @typedef {Object} GeoTIFFImage
- * @property {() => number} getWidth - Returns the width of the image.
- * @property {() => number} getHeight - Returns the height of the image.
- * @property {() => number[]} getBoundingBox - Returns the bounding box as [minX, minY, maxX, maxY] in degrees.
- * @property {() => Promise<ArrayLike<ArrayLike<number>>>} readRasters - Returns the raster data as an array of bands.
- * @property {Object} fileDirectory - The file directory object containing metadata.
- * @property {Object} fileDirectory.ModelPixelScale - The pixel scale array [scaleX, scaleY, scaleZ] in degrees.
- */
-
 var loadedNadgrids = {};
 
 /**
@@ -68,14 +52,14 @@ var loadedNadgrids = {};
 /**
  * @overload
  * @param {string} key - The key to associate with the loaded grid.
- * @param {GeoTIFF} data - The GeoTIFF instance to read the grid from.
+ * @param {import('geotiff').GeoTIFF} data - The GeoTIFF instance to read the grid from.
  * @returns {{ready: Promise<NADGrid>}} - A promise that resolves to the loaded grid information.
  */
 /**
  * Load either a NTv2 file (.gsb) or a Geotiff (.tif) to a key that can be used in a proj string like +nadgrids=<key>. Pass the NTv2 file
  * as an ArrayBuffer. Pass Geotiff as a GeoTIFF instance from the geotiff.js library.
  * @param {string} key - The key to associate with the loaded grid.
- * @param {ArrayBuffer|GeoTIFF} data The data to load, either an ArrayBuffer for NTv2 or a GeoTIFF instance.
+ * @param {ArrayBuffer|import('geotiff').GeoTIFF} data The data to load, either an ArrayBuffer for NTv2 or a GeoTIFF instance.
  * @param {NTV2GridOptions} [options] Optional parameters.
  * @returns {{ready: Promise<NADGrid>}|NADGrid} - A promise that resolves to the loaded grid information.
  */
@@ -108,7 +92,7 @@ function readNTV2Grid(key, data, options) {
 
 /**
  * @param {string} key The key to associate with the loaded grid.
- * @param {GeoTIFF} tiff The GeoTIFF instance to read the grid from.
+ * @param {import('geotiff').GeoTIFF} tiff The GeoTIFF instance to read the grid from.
  * @returns {Promise<NADGrid>} A promise that resolves to the loaded NAD grid information.
  */
 async function readGeotiffGrid(key, tiff) {
@@ -122,7 +106,12 @@ async function readGeotiffGrid(key, tiff) {
     var data = rasters;
     var lim = [image.getWidth(), image.getHeight()];
     var imageBBoxRadians = image.getBoundingBox().map(degreesToRadians);
-    var del = [image.fileDirectory.ModelPixelScale[0], image.fileDirectory.ModelPixelScale[1]].map(degreesToRadians);
+    var modelPixelScale = typeof image.fileDirectory.getValue === 'function'
+      // geotiff v3
+      ? image.fileDirectory.getValue('ModelPixelScale')
+      // geotiff v2
+      : /** @type {any} */ (image.fileDirectory).ModelPixelScale;
+    var del = [modelPixelScale[0], modelPixelScale[1]].map(degreesToRadians);
 
     var maxX = imageBBoxRadians[0] + (lim[0] - 1) * del[0];
     var minY = imageBBoxRadians[3] - (lim[1] - 1) * del[1];

package/lib/projections/eck6.js

@@ -0,0 +1,38 @@
+import { forward as sinuForward, inverse as sinuInverse } from './sinu';
+
+/**
+ * Eckert VI projection — spherical sinusoidal variant with m=1, n=1+π/2.
+ * Always forces spherical computation regardless of the ellipsoid.
+ *
+ * @typedef {Object} LocalThis
+ * @property {number} m
+ * @property {number} n
+ * @property {number} C_y
+ * @property {number} C_x
+ * @property {number} es
+ */
+
+/** @this {import('../defs.js').ProjectionDefinition & LocalThis} */
+export function init() {
+  /* Force spherical handling */
+  this.sphere = true;
+  this.b = this.a;
+
+  this.m = 1.0;
+  this.n = 2.570796326794896619231321691; /* 1 + π/2 */
+  this.es = 0;
+
+  this.C_y = Math.sqrt((this.m + 1.0) / this.n);
+  this.C_x = this.C_y / (this.m + 1.0);
+}
+
+export var forward = sinuForward;
+export var inverse = sinuInverse;
+
+export var names = ['Eckert_VI', 'eck6'];
+export default {
+  init: init,
+  forward: forward,
+  inverse: inverse,
+  names: names
+};

package/lib/projections/eqearth.js

@@ -28,6 +28,9 @@
  */
 
 import adjust_lon from '../common/adjust_lon';
+import qsfnz from '../common/qsfnz';
+import authset from '../common/authset';
+import authlat from '../common/authlat';
 
 var A1 = 1.340264,
   A2 = -0.081106,
@@ -35,32 +38,62 @@ var A1 = 1.340264,
   A4 = 0.003796,
   M = Math.sqrt(3) / 2.0;
 
+/**
+ * @typedef {Object} LocalThis
+ * @property {number} es
+ * @property {number} e
+ * @property {Array<number>} apa
+ * @property {number} qp
+ * @property {number} rqda
+ */
+
+/** @this {import('../defs.js').ProjectionDefinition & LocalThis} */
 export function init() {
-  this.es = 0;
   this.long0 = this.long0 !== undefined ? this.long0 : 0;
   this.x0 = this.x0 !== undefined ? this.x0 : 0;
   this.y0 = this.y0 !== undefined ? this.y0 : 0;
+  if (this.es !== 0) {
+    this.apa = authset(this.es);
+    this.qp = qsfnz(this.e, 1);
+    this.rqda = Math.sqrt(0.5 * this.qp);
+  }
 }
 
+/** @this {import('../defs.js').ProjectionDefinition & LocalThis} */
 export function forward(p) {
   var lam = adjust_lon(p.x - this.long0, this.over);
   var phi = p.y;
-  var paramLat = Math.asin(M * Math.sin(phi)),
+  var sinphi = Math.sin(phi);
+  if (this.es !== 0) {
+    sinphi = qsfnz(this.e, sinphi) / this.qp;
+  }
+  var paramLat = Math.asin(M * sinphi),
     paramLatSq = paramLat * paramLat,
     paramLatPow6 = paramLatSq * paramLatSq * paramLatSq;
   p.x = lam * Math.cos(paramLat)
     / (M * (A1 + 3 * A2 * paramLatSq + paramLatPow6 * (7 * A3 + 9 * A4 * paramLatSq)));
   p.y = paramLat * (A1 + A2 * paramLatSq + paramLatPow6 * (A3 + A4 * paramLatSq));
 
+  if (this.es !== 0) {
+    p.x *= this.rqda;
+    p.y *= this.rqda;
+  }
+
   p.x = this.a * p.x + this.x0;
   p.y = this.a * p.y + this.y0;
   return p;
 }
 
+/** @this {import('../defs.js').ProjectionDefinition & LocalThis} */
 export function inverse(p) {
   p.x = (p.x - this.x0) / this.a;
   p.y = (p.y - this.y0) / this.a;
 
+  if (this.es !== 0) {
+    p.x /= this.rqda;
+    p.y /= this.rqda;
+  }
+
   var EPS = 1e-9,
     NITER = 12,
     paramLat = p.y,
@@ -82,6 +115,10 @@ export function inverse(p) {
     / Math.cos(paramLat);
   p.y = Math.asin(Math.sin(paramLat) / M);
 
+  if (this.es !== 0) {
+    p.y = authlat(p.y, this.apa);
+  }
+
   p.x = adjust_lon(p.x + this.long0, this.over);
   return p;
 }

package/lib/projections/laea.js

@@ -2,6 +2,8 @@ import { HALF_PI, EPSLN, FORTPI } from '../constants/values';
 
 import qsfnz from '../common/qsfnz';
 import adjust_lon from '../common/adjust_lon';
+import authset from '../common/authset';
+import authlat from '../common/authlat';
 
 /**
  * @typedef {Object} LocalThis
@@ -264,34 +266,6 @@ export function inverse(p) {
   return p;
 }
 
-/* determine latitude from authalic latitude */
-var P00 = 0.33333333333333333333;
-
-var P01 = 0.17222222222222222222;
-var P02 = 0.10257936507936507936;
-var P10 = 0.06388888888888888888;
-var P11 = 0.06640211640211640211;
-var P20 = 0.01641501294219154443;
-
-function authset(es) {
-  var t;
-  var APA = [];
-  APA[0] = es * P00;
-  t = es * es;
-  APA[0] += t * P01;
-  APA[1] = t * P10;
-  t *= es;
-  APA[0] += t * P02;
-  APA[1] += t * P11;
-  APA[2] = t * P20;
-  return APA;
-}
-
-function authlat(beta, APA) {
-  var t = beta + beta;
-  return (beta + APA[0] * Math.sin(t) + APA[1] * Math.sin(t + t) + APA[2] * Math.sin(t + t + t));
-}
-
 export var names = ['Lambert Azimuthal Equal Area', 'Lambert_Azimuthal_Equal_Area', 'laea'];
 export default {
   init: init,

package/lib/projections/ob_tran.js

@@ -250,7 +250,7 @@ function createRotation(params, how) {
  */
 function forwardOblique(self, lp) {
   let { x: lam, y: phi } = lp;
-  lam += self.long0;
+  lam = adjust_lon(lam - self.long0, self.over);
   const coslam = Math.cos(lam);
   const sinphi = Math.sin(phi);
   const cosphi = Math.cos(phi);
@@ -280,7 +280,7 @@ function forwardOblique(self, lp) {
  */
 function forwardTransverse(self, lp) {
   let { x: lam, y: phi } = lp;
-  lam += self.long0;
+  lam = adjust_lon(lam - self.long0, self.over);
   const cosphi = Math.cos(phi);
   const coslam = Math.cos(lam);
   lp.x = adjust_lon(

package/lib/projections/omerc.js

@@ -65,6 +65,10 @@ export function init() {
 
   if (gam) {
     gamma = this.rectified_grid_angle;
+    if (!alp) {
+      alpha_c = 0;
+      alp = true;
+    }
   }
 
   if (alp || gam) {

package/lib/transform.js

@@ -1,6 +1,6 @@
 import { D2R, R2D, PJD_3PARAM, PJD_7PARAM, PJD_GRIDSHIFT } from './constants/values';
 import datum_transform from './datum_transform';
-import adjust_axis from './adjust_axis';
+import { adjustAxisToEnu, adjustAxisFromEnu } from './adjust_axis';
 import proj from './Proj';
 import toPoint from './common/toPoint';
 import checkSanity from './checkSanity';
@@ -12,36 +12,26 @@ function checkNotWGS(source, dest) {
 }
 
 /**
+ * Internal transform: accepts an already-cloned point object, returns transformed point object.
  * @param {import('./defs').ProjectionDefinition} source
  * @param {import('./defs').ProjectionDefinition} dest
- * @param {import('./core').TemplateCoordinates} point
- * @param {boolean} enforceAxis
+ * @param {import('./core').InterfaceCoordinates} point
+ * @param {boolean} [enforceAxis]
  * @returns {import('./core').InterfaceCoordinates | undefined}
  */
-export default function transform(source, dest, point, enforceAxis) {
+export function transformInternal(source, dest, point, enforceAxis) {
   var wgs84;
-  if (Array.isArray(point)) {
-    point = toPoint(point);
-  } else {
-    // Clone the point object so inputs don't get modified
-    point = {
-      x: point.x,
-      y: point.y,
-      z: point.z,
-      m: point.m
-    };
-  }
   var hasZ = point.z !== undefined;
   checkSanity(point);
   // Workaround for datum shifts towgs84, if either source or destination projection is not wgs84
   if (source.datum && dest.datum && checkNotWGS(source, dest)) {
     wgs84 = new proj('WGS84');
-    point = transform(source, wgs84, point, enforceAxis);
+    point = transformInternal(source, wgs84, point, enforceAxis);
     source = wgs84;
   }
   // DGR, 2010/11/12
   if (enforceAxis && source.axis !== 'enu') {
-    point = adjust_axis(source, false, point);
+    point = adjustAxisToEnu(source, point);
   }
   // Transform source points to long/lat, if they aren't already.
   if (source.projName === 'longlat') {
@@ -105,7 +95,7 @@ export default function transform(source, dest, point, enforceAxis) {
 
   // DGR, 2010/11/12
   if (enforceAxis && dest.axis !== 'enu') {
-    return adjust_axis(dest, true, point);
+    return adjustAxisFromEnu(dest, point);
   }
 
   if (point && !hasZ && dest.projName !== 'geocent') {
@@ -113,3 +103,21 @@ export default function transform(source, dest, point, enforceAxis) {
   }
   return point;
 }
+
+/**
+ * @param {import('./defs').ProjectionDefinition} source
+ * @param {import('./defs').ProjectionDefinition} dest
+ * @param {import('./core').TemplateCoordinates} point
+ * @param {boolean} [enforceAxis]
+ * @returns {import('./core').InterfaceCoordinates | undefined}
+ */
+export default function transform(source, dest, point, enforceAxis) {
+  var pt;
+  if (Array.isArray(point)) {
+    pt = toPoint(point);
+  } else {
+    // Clone the point object so inputs don't get modified
+    pt = { x: point.x, y: point.y, z: point.z, m: point.m };
+  }
+  return transformInternal(source, dest, pt, enforceAxis);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "proj4",
-  "version": "2.20.8",
+  "version": "2.20.9",
   "description": "Proj4js is a JavaScript library to transform point coordinates from one coordinate system to another, including datum transformations.",
   "homepage": "https://proj4js.github.io/proj4js/",
   "main": "dist/proj4-src.js",
@@ -13,8 +13,9 @@
     "build:custom": "node scripts/build.mjs",
     "prerollup": "npm run types",
     "rollup": "rollup -c",
-    "pretest": "npm run lint",
+    "pretest": "npm run lint && npm run typecheck",
     "lint": "eslint *.js *.mjs scripts lib test",
+    "typecheck": "tsc --noEmit",
     "format": "npm run lint -- --fix",
     "test": "npm run build && npm run test:all",
     "test:coverage": "vitest run --coverage",
@@ -40,11 +41,19 @@
     "@vitest/browser-playwright": "^4.1.2",
     "@vitest/coverage-v8": "^4.1.2",
     "eslint": "^9.25.1",
-    "geotiff": "^2.1.4-beta.0",
+    "geotiff": "^3.0.5",
     "rollup": "^4.9.6",
     "typescript": "^5.8.3",
     "vitest": "^4.1.2"
   },
+  "peerDependencies": {
+    "geotiff": "*"
+  },
+  "peerDependenciesMeta": {
+    "geotiff": {
+      "optional": true
+    }
+  },
   "dependencies": {
     "mgrs": "1.0.0",
     "wkt-parser": "^1.5.5"

package/projs.js

@@ -17,6 +17,7 @@ import poly from './lib/projections/poly';
 import nzmg from './lib/projections/nzmg';
 import mill from './lib/projections/mill';
 import sinu from './lib/projections/sinu';
+import eck6 from './lib/projections/eck6';
 import moll from './lib/projections/moll';
 import eqdc from './lib/projections/eqdc';
 import vandg from './lib/projections/vandg';
@@ -50,6 +51,7 @@ export default function (proj4) {
   proj4.Proj.projections.add(nzmg);
   proj4.Proj.projections.add(mill);
   proj4.Proj.projections.add(sinu);
+  proj4.Proj.projections.add(eck6);
   proj4.Proj.projections.add(moll);
   proj4.Proj.projections.add(eqdc);
   proj4.Proj.projections.add(vandg);

package/tsconfig.json

@@ -2,6 +2,7 @@
   "compilerOptions": {
     "allowJs": true,
     "checkJs": true,
+    "noImplicitAny": false,
     "skipLibCheck": true,
     "emitDeclarationOnly": true,
     "declaration": true,