proj4 2.15.0 → 2.16.1

package/lib/projString.js

@@ -1,15 +1,15 @@
-import {D2R} from './constants/values';
+import { D2R } from './constants/values';
 import PrimeMeridian from './constants/PrimeMeridian';
 import units from './constants/units';
 import match from './match';
 
-export default function(defData) {
+export default function (defData) {
   var self = {};
-  var paramObj = defData.split('+').map(function(v) {
+  var paramObj = defData.split('+').map(function (v) {
     return v.trim();
-  }).filter(function(a) {
+  }).filter(function (a) {
     return a;
-  }).reduce(function(p, a) {
+  }).reduce(function (p, a) {
     var split = a.split('=');
     split.push(true);
     p[split[0].toLowerCase()] = split[1];
@@ -19,106 +19,105 @@ export default function(defData) {
   var params = {
     proj: 'projName',
     datum: 'datumCode',
-    rf: function(v) {
+    rf: function (v) {
       self.rf = parseFloat(v);
     },
-    lat_0: function(v) {
+    lat_0: function (v) {
       self.lat0 = v * D2R;
     },
-    lat_1: function(v) {
+    lat_1: function (v) {
       self.lat1 = v * D2R;
     },
-    lat_2: function(v) {
+    lat_2: function (v) {
       self.lat2 = v * D2R;
     },
-    lat_ts: function(v) {
+    lat_ts: function (v) {
       self.lat_ts = v * D2R;
     },
-    lon_0: function(v) {
+    lon_0: function (v) {
       self.long0 = v * D2R;
     },
-    lon_1: function(v) {
+    lon_1: function (v) {
       self.long1 = v * D2R;
     },
-    lon_2: function(v) {
+    lon_2: function (v) {
       self.long2 = v * D2R;
     },
-    alpha: function(v) {
+    alpha: function (v) {
       self.alpha = parseFloat(v) * D2R;
     },
-    gamma: function(v) {
-      self.rectified_grid_angle = parseFloat(v);
+    gamma: function (v) {
+      self.rectified_grid_angle = parseFloat(v) * D2R;
     },
-    lonc: function(v) {
+    lonc: function (v) {
       self.longc = v * D2R;
     },
-    x_0: function(v) {
+    x_0: function (v) {
       self.x0 = parseFloat(v);
     },
-    y_0: function(v) {
+    y_0: function (v) {
       self.y0 = parseFloat(v);
     },
-    k_0: function(v) {
+    k_0: function (v) {
       self.k0 = parseFloat(v);
     },
-    k: function(v) {
+    k: function (v) {
       self.k0 = parseFloat(v);
     },
-    a: function(v) {
+    a: function (v) {
       self.a = parseFloat(v);
     },
-    b: function(v) {
+    b: function (v) {
       self.b = parseFloat(v);
     },
-    r: function(v) {
+    r: function (v) {
       self.a = self.b = parseFloat(v);
     },
-    r_a: function() {
+    r_a: function () {
       self.R_A = true;
     },
-    zone: function(v) {
+    zone: function (v) {
       self.zone = parseInt(v, 10);
     },
-    south: function() {
+    south: function () {
       self.utmSouth = true;
     },
-    towgs84: function(v) {
-      self.datum_params = v.split(",").map(function(a) {
+    towgs84: function (v) {
+      self.datum_params = v.split(',').map(function (a) {
         return parseFloat(a);
       });
     },
-    to_meter: function(v) {
+    to_meter: function (v) {
       self.to_meter = parseFloat(v);
     },
-    units: function(v) {
+    units: function (v) {
       self.units = v;
       var unit = match(units, v);
       if (unit) {
         self.to_meter = unit.to_meter;
       }
     },
-    from_greenwich: function(v) {
+    from_greenwich: function (v) {
       self.from_greenwich = v * D2R;
     },
-    pm: function(v) {
+    pm: function (v) {
       var pm = match(PrimeMeridian, v);
       self.from_greenwich = (pm ? pm : parseFloat(v)) * D2R;
     },
-    nadgrids: function(v) {
+    nadgrids: function (v) {
       if (v === '@null') {
         self.datumCode = 'none';
-      }
-      else {
+      } else {
         self.nadgrids = v;
       }
     },
-    axis: function(v) {
-      var legalAxis = "ewnsud";
+    axis: function (v) {
+      var legalAxis = 'ewnsud';
       if (v.length === 3 && legalAxis.indexOf(v.substr(0, 1)) !== -1 && legalAxis.indexOf(v.substr(1, 1)) !== -1 && legalAxis.indexOf(v.substr(2, 1)) !== -1) {
         self.axis = v;
       }
     },
-    approx: function() {
+    approx: function () {
       self.approx = true;
     }
   };
@@ -128,16 +127,14 @@ export default function(defData) {
       paramOutname = params[paramName];
       if (typeof paramOutname === 'function') {
         paramOutname(paramVal);
-      }
-      else {
+      } else {
         self[paramOutname] = paramVal;
       }
-    }
-    else {
+    } else {
       self[paramName] = paramVal;
     }
   }
-  if(typeof self.datumCode === 'string' && self.datumCode !== "WGS84"){
+  if (typeof self.datumCode === 'string' && self.datumCode !== 'WGS84') {
     self.datumCode = self.datumCode.toLowerCase();
   }
   return self;

package/lib/projections/aea.js

@@ -2,10 +2,9 @@ import msfnz from '../common/msfnz';
 import qsfnz from '../common/qsfnz';
 import adjust_lon from '../common/adjust_lon';
 import asinz from '../common/asinz';
-import {EPSLN} from '../constants/values';
+import { EPSLN } from '../constants/values';
 
 export function init() {
-
   if (Math.abs(this.lat1 + this.lat2) < EPSLN) {
     return;
   }
@@ -33,8 +32,7 @@ export function init() {
 
   if (Math.abs(this.lat1 - this.lat2) > EPSLN) {
     this.ns0 = (this.ms1 * this.ms1 - this.ms2 * this.ms2) / (this.qs2 - this.qs1);
-  }
-  else {
+  } else {
     this.ns0 = this.con;
   }
   this.c = this.ms1 * this.ms1 + this.ns0 * this.qs1;
@@ -42,9 +40,8 @@ export function init() {
 }
 
 /* Albers Conical Equal Area forward equations--mapping lat,long to x,y
-  -------------------------------------------------------------------*/
+  ------------------------------------------------------------------- */
 export function forward(p) {
-
   var lon = p.x;
   var lat = p.y;
 
@@ -70,8 +67,7 @@ export function inverse(p) {
   if (this.ns0 >= 0) {
     rh1 = Math.sqrt(p.x * p.x + p.y * p.y);
     con = 1;
-  }
-  else {
+  } else {
     rh1 = -Math.sqrt(p.x * p.x + p.y * p.y);
     con = -1;
   }
@@ -82,8 +78,7 @@ export function inverse(p) {
   con = rh1 * this.ns0 / this.a;
   if (this.sphere) {
     lat = Math.asin((this.c - con * con) / (2 * this.ns0));
-  }
-  else {
+  } else {
     qs = (this.c - con * con) / this.ns0;
     lat = this.phi1z(this.e3, qs);
   }
@@ -96,7 +91,7 @@ export function inverse(p) {
 
 /* Function to compute phi1, the latitude for the inverse of the
    Albers Conical Equal-Area projection.
--------------------------------------------*/
+------------------------------------------- */
 export function phi1z(eccent, qs) {
   var sinphi, cosphi, con, com, dphi;
   var phi = asinz(0.5 * qs);
@@ -119,7 +114,7 @@ export function phi1z(eccent, qs) {
   return null;
 }
 
-export var names = ["Albers_Conic_Equal_Area", "Albers", "aea"];
+export var names = ['Albers_Conic_Equal_Area', 'Albers_Equal_Area', 'Albers', 'aea'];
 export default {
   init: init,
   forward: forward,

package/lib/projections/aeqd.js

@@ -1,20 +1,18 @@
 import adjust_lon from '../common/adjust_lon';
-import {HALF_PI, EPSLN} from '../constants/values';
-
+import { HALF_PI, EPSLN, D2R } from '../constants/values';
 import mlfn from '../common/mlfn';
 import e0fn from '../common/e0fn';
 import e1fn from '../common/e1fn';
 import e2fn from '../common/e2fn';
 import e3fn from '../common/e3fn';
-import gN from '../common/gN';
 import asinz from '../common/asinz';
 import imlfn from '../common/imlfn';
-
-
+import { Geodesic } from 'geographiclib-geodesic';
 
 export function init() {
   this.sin_p12 = Math.sin(this.lat0);
   this.cos_p12 = Math.cos(this.lat0);
+  this.g = new Geodesic.Geodesic(this.a, this.es / (1 + Math.sqrt(1 - this.es)));
 }
 
 export function forward(p) {
@@ -23,22 +21,20 @@ export function forward(p) {
   var sinphi = Math.sin(p.y);
   var cosphi = Math.cos(p.y);
   var dlon = adjust_lon(lon - this.long0);
-  var e0, e1, e2, e3, Mlp, Ml, tanphi, Nl1, Nl, psi, Az, G, H, GH, Hs, c, kp, cos_c, s, s2, s3, s4, s5;
+  var e0, e1, e2, e3, Mlp, Ml, c, kp, cos_c, lat1, lon1, lat2, lon2, vars, azi1;
   if (this.sphere) {
     if (Math.abs(this.sin_p12 - 1) <= EPSLN) {
-      //North Pole case
+      // North Pole case
       p.x = this.x0 + this.a * (HALF_PI - lat) * Math.sin(dlon);
       p.y = this.y0 - this.a * (HALF_PI - lat) * Math.cos(dlon);
       return p;
-    }
-    else if (Math.abs(this.sin_p12 + 1) <= EPSLN) {
-      //South Pole case
+    } else if (Math.abs(this.sin_p12 + 1) <= EPSLN) {
+      // South Pole case
       p.x = this.x0 + this.a * (HALF_PI + lat) * Math.sin(dlon);
       p.y = this.y0 + this.a * (HALF_PI + lat) * Math.cos(dlon);
       return p;
-    }
-    else {
-      //default case
+    } else {
+      // default case
       cos_c = this.sin_p12 * sinphi + this.cos_p12 * cosphi * Math.cos(dlon);
       c = Math.acos(cos_c);
       kp = c ? c / Math.sin(c) : 1;
@@ -46,66 +42,50 @@ export function forward(p) {
       p.y = this.y0 + this.a * kp * (this.cos_p12 * sinphi - this.sin_p12 * cosphi * Math.cos(dlon));
       return p;
     }
-  }
-  else {
+  } else {
     e0 = e0fn(this.es);
     e1 = e1fn(this.es);
     e2 = e2fn(this.es);
     e3 = e3fn(this.es);
     if (Math.abs(this.sin_p12 - 1) <= EPSLN) {
-      //North Pole case
+      // North Pole case
       Mlp = this.a * mlfn(e0, e1, e2, e3, HALF_PI);
       Ml = this.a * mlfn(e0, e1, e2, e3, lat);
       p.x = this.x0 + (Mlp - Ml) * Math.sin(dlon);
       p.y = this.y0 - (Mlp - Ml) * Math.cos(dlon);
       return p;
-    }
-    else if (Math.abs(this.sin_p12 + 1) <= EPSLN) {
-      //South Pole case
+    } else if (Math.abs(this.sin_p12 + 1) <= EPSLN) {
+      // South Pole case
       Mlp = this.a * mlfn(e0, e1, e2, e3, HALF_PI);
       Ml = this.a * mlfn(e0, e1, e2, e3, lat);
       p.x = this.x0 + (Mlp + Ml) * Math.sin(dlon);
       p.y = this.y0 + (Mlp + Ml) * Math.cos(dlon);
       return p;
-    }
-    else {
-      //Default case
-      tanphi = sinphi / cosphi;
-      Nl1 = gN(this.a, this.e, this.sin_p12);
-      Nl = gN(this.a, this.e, sinphi);
-      psi = Math.atan((1 - this.es) * tanphi + this.es * Nl1 * this.sin_p12 / (Nl * cosphi));
-      Az = Math.atan2(Math.sin(dlon), this.cos_p12 * Math.tan(psi) - this.sin_p12 * Math.cos(dlon));
-      if (Az === 0) {
-        s = Math.asin(this.cos_p12 * Math.sin(psi) - this.sin_p12 * Math.cos(psi));
-      }
-      else if (Math.abs(Math.abs(Az) - Math.PI) <= EPSLN) {
-        s = -Math.asin(this.cos_p12 * Math.sin(psi) - this.sin_p12 * Math.cos(psi));
-      }
-      else {
-        s = Math.asin(Math.sin(dlon) * Math.cos(psi) / Math.sin(Az));
+    } else {
+      // Default case
+      if (Math.abs(lon) < EPSLN && Math.abs(lat - this.lat0) < EPSLN) {
+        p.x = p.y = 0;
+        return p;
       }
-      G = this.e * this.sin_p12 / Math.sqrt(1 - this.es);
-      H = this.e * this.cos_p12 * Math.cos(Az) / Math.sqrt(1 - this.es);
-      GH = G * H;
-      Hs = H * H;
-      s2 = s * s;
-      s3 = s2 * s;
-      s4 = s3 * s;
-      s5 = s4 * s;
-      c = Nl1 * s * (1 - s2 * Hs * (1 - Hs) / 6 + s3 / 8 * GH * (1 - 2 * Hs) + s4 / 120 * (Hs * (4 - 7 * Hs) - 3 * G * G * (1 - 7 * Hs)) - s5 / 48 * GH);
-      p.x = this.x0 + c * Math.sin(Az);
-      p.y = this.y0 + c * Math.cos(Az);
+      lat1 = this.lat0 / D2R;
+      lon1 = this.long0 / D2R;
+      lat2 = lat / D2R;
+      lon2 = lon / D2R;
+
+      vars = this.g.Inverse(lat1, lon1, lat2, lon2, this.g.AZIMUTH);
+      azi1 = vars.azi1 * D2R;
+
+      p.x = vars.s12 * Math.sin(azi1);
+      p.y = vars.s12 * Math.cos(azi1);
       return p;
     }
   }
-
-
 }
 
 export function inverse(p) {
   p.x -= this.x0;
   p.y -= this.y0;
-  var rh, z, sinz, cosz, lon, lat, con, e0, e1, e2, e3, Mlp, M, N1, psi, Az, cosAz, tmp, A, B, D, Ee, F, sinpsi;
+  var rh, z, sinz, cosz, lon, lat, con, e0, e1, e2, e3, Mlp, M, lat1, lon1, azi1, s12, vars;
   if (this.sphere) {
     rh = Math.sqrt(p.x * p.x + p.y * p.y);
     if (rh > (2 * HALF_PI * this.a)) {
@@ -119,26 +99,23 @@ export function inverse(p) {
     lon = this.long0;
     if (Math.abs(rh) <= EPSLN) {
       lat = this.lat0;
-    }
-    else {
+    } else {
       lat = asinz(cosz * this.sin_p12 + (p.y * sinz * this.cos_p12) / rh);
       con = Math.abs(this.lat0) - HALF_PI;
       if (Math.abs(con) <= EPSLN) {
         if (this.lat0 >= 0) {
-          lon = adjust_lon(this.long0 + Math.atan2(p.x, - p.y));
-        }
-        else {
+          lon = adjust_lon(this.long0 + Math.atan2(p.x, -p.y));
+        } else {
           lon = adjust_lon(this.long0 - Math.atan2(-p.x, p.y));
         }
-      }
-      else {
-        /*con = cosz - this.sin_p12 * Math.sin(lat);
+      } else {
+        /* con = cosz - this.sin_p12 * Math.sin(lat);
         if ((Math.abs(con) < EPSLN) && (Math.abs(p.x) < EPSLN)) {
           //no-op, just keep the lon value as is
         } else {
           var temp = Math.atan2((p.x * sinz * this.cos_p12), (con * rh));
           lon = adjust_lon(this.long0 + Math.atan2((p.x * sinz * this.cos_p12), (con * rh)));
-        }*/
+        } */
         lon = adjust_lon(this.long0 + Math.atan2(p.x * sinz, rh * this.cos_p12 * cosz - p.y * this.sin_p12 * sinz));
       }
     }
@@ -146,25 +123,23 @@ export function inverse(p) {
     p.x = lon;
     p.y = lat;
     return p;
-  }
-  else {
+  } else {
     e0 = e0fn(this.es);
     e1 = e1fn(this.es);
     e2 = e2fn(this.es);
     e3 = e3fn(this.es);
     if (Math.abs(this.sin_p12 - 1) <= EPSLN) {
-      //North pole case
+      // North pole case
       Mlp = this.a * mlfn(e0, e1, e2, e3, HALF_PI);
       rh = Math.sqrt(p.x * p.x + p.y * p.y);
       M = Mlp - rh;
       lat = imlfn(M / this.a, e0, e1, e2, e3);
-      lon = adjust_lon(this.long0 + Math.atan2(p.x, - 1 * p.y));
+      lon = adjust_lon(this.long0 + Math.atan2(p.x, -1 * p.y));
       p.x = lon;
       p.y = lat;
       return p;
-    }
-    else if (Math.abs(this.sin_p12 + 1) <= EPSLN) {
-      //South pole case
+    } else if (Math.abs(this.sin_p12 + 1) <= EPSLN) {
+      // South pole case
       Mlp = this.a * mlfn(e0, e1, e2, e3, HALF_PI);
       rh = Math.sqrt(p.x * p.x + p.y * p.y);
       M = rh - Mlp;
@@ -174,32 +149,22 @@ export function inverse(p) {
       p.x = lon;
       p.y = lat;
       return p;
-    }
-    else {
-      //default case
-      rh = Math.sqrt(p.x * p.x + p.y * p.y);
-      Az = Math.atan2(p.x, p.y);
-      N1 = gN(this.a, this.e, this.sin_p12);
-      cosAz = Math.cos(Az);
-      tmp = this.e * this.cos_p12 * cosAz;
-      A = -tmp * tmp / (1 - this.es);
-      B = 3 * this.es * (1 - A) * this.sin_p12 * this.cos_p12 * cosAz / (1 - this.es);
-      D = rh / N1;
-      Ee = D - A * (1 + A) * Math.pow(D, 3) / 6 - B * (1 + 3 * A) * Math.pow(D, 4) / 24;
-      F = 1 - A * Ee * Ee / 2 - D * Ee * Ee * Ee / 6;
-      psi = Math.asin(this.sin_p12 * Math.cos(Ee) + this.cos_p12 * Math.sin(Ee) * cosAz);
-      lon = adjust_lon(this.long0 + Math.asin(Math.sin(Az) * Math.sin(Ee) / Math.cos(psi)));
-      sinpsi = Math.sin(psi);
-      lat = Math.atan2((sinpsi - this.es * F * this.sin_p12) * Math.tan(psi), sinpsi * (1 - this.es));
-      p.x = lon;
-      p.y = lat;
+    } else {
+      // default case
+      lat1 = this.lat0 / D2R;
+      lon1 = this.long0 / D2R;
+      azi1 = Math.atan2(p.x, p.y) / D2R;
+      s12 = Math.sqrt(p.x * p.x + p.y * p.y);
+      vars = this.g.Direct(lat1, lon1, azi1, s12, this.g.STANDARD);
+
+      p.x = vars.lon2 * D2R;
+      p.y = vars.lat2 * D2R;
       return p;
     }
   }
-
 }
 
-export var names = ["Azimuthal_Equidistant", "aeqd"];
+export var names = ['Azimuthal_Equidistant', 'aeqd'];
 export default {
   init: init,
   forward: forward,

package/lib/projections/bonne.js

@@ -1,10 +1,10 @@
-import adjust_lat from "../common/adjust_lat";
-import adjust_lon from "../common/adjust_lon";
-import hypot from "../common/hypot";
-import pj_enfn from "../common/pj_enfn";
-import pj_inv_mlfn from "../common/pj_inv_mlfn";
-import pj_mlfn from "../common/pj_mlfn";
-import { HALF_PI } from "../constants/values";
+import adjust_lat from '../common/adjust_lat';
+import adjust_lon from '../common/adjust_lon';
+import hypot from '../common/hypot';
+import pj_enfn from '../common/pj_enfn';
+import pj_inv_mlfn from '../common/pj_inv_mlfn';
+import pj_mlfn from '../common/pj_mlfn';
+import { HALF_PI } from '../constants/values';
 
 var EPS10 = 1e-10;
 
@@ -25,8 +25,7 @@ export function init() {
   } else {
     if (Math.abs(this.phi1) + EPS10 >= HALF_PI) {
       this.cphi1 = 0;
-    }
-    else {
+    } else {
       this.cphi1 = 1 / Math.tan(this.phi1);
     }
     this.inverse = s_inv;
@@ -60,8 +59,7 @@ function e_inv(p) {
     lam = rh * Math.atan2(p.x, p.y) * Math.sqrt(1 - this.es * s * s) / Math.cos(phi);
   } else if (Math.abs(s - HALF_PI) <= EPS10) {
     lam = 0;
-  }
-  else {
+  } else {
     throw new Error();
   }
   p.x = adjust_lon(lam + (this.long0 || 0));
@@ -106,8 +104,8 @@ function s_inv(p) {
   return p;
 }
 
-export var names = ["bonne", "Bonne (Werner lat_1=90)"];
+export var names = ['bonne', 'Bonne (Werner lat_1=90)'];
 export default {
   init: init,
   names: names
-};
+};

package/lib/projections/cass.js

@@ -7,7 +7,7 @@ import gN from '../common/gN';
 import adjust_lon from '../common/adjust_lon';
 import adjust_lat from '../common/adjust_lat';
 import imlfn from '../common/imlfn';
-import {HALF_PI, EPSLN} from '../constants/values';
+import { HALF_PI, EPSLN } from '../constants/values';
 
 export function init() {
   if (!this.sphere) {
@@ -20,11 +20,10 @@ export function init() {
 }
 
 /* Cassini forward equations--mapping lat,long to x,y
-  -----------------------------------------------------------------------*/
+  ----------------------------------------------------------------------- */
 export function forward(p) {
-
   /* Forward equations
-      -----------------*/
+      ----------------- */
   var x, y;
   var lam = p.x;
   var phi = p.y;
@@ -33,9 +32,8 @@ export function forward(p) {
   if (this.sphere) {
     x = this.a * Math.asin(Math.cos(phi) * Math.sin(lam));
     y = this.a * (Math.atan2(Math.tan(phi), Math.cos(lam)) - this.lat0);
-  }
-  else {
-    //ellipsoid
+  } else {
+    // ellipsoid
     var sinphi = Math.sin(phi);
     var cosphi = Math.cos(phi);
     var nl = gN(this.a, this.e, sinphi);
@@ -47,8 +45,6 @@ export function forward(p) {
 
     x = nl * al * (1 - asq * tl * (1 / 6 - (8 - tl + 8 * cl) * asq / 120));
     y = ml - this.ml0 + nl * sinphi / cosphi * asq * (0.5 + (5 - tl + 6 * cl) * asq / 24);
-
-
   }
 
   p.x = x + this.x0;
@@ -57,7 +53,7 @@ export function forward(p) {
 }
 
 /* Inverse equations
-  -----------------*/
+  ----------------- */
 export function inverse(p) {
   p.x -= this.x0;
   p.y -= this.y0;
@@ -69,8 +65,7 @@ export function inverse(p) {
     var dd = y + this.lat0;
     phi = Math.asin(Math.sin(dd) * Math.cos(x));
     lam = Math.atan2(Math.tan(x), Math.cos(dd));
-  }
-  else {
+  } else {
     /* ellipsoid */
     var ml1 = this.ml0 / this.a + y;
     var phi1 = imlfn(ml1, this.e0, this.e1, this.e2, this.e3);
@@ -90,16 +85,14 @@ export function inverse(p) {
     var dsq = dl * dl;
     phi = phi1 - nl1 * Math.tan(phi1) / rl1 * dl * dl * (0.5 - (1 + 3 * tl1) * dl * dl / 24);
     lam = dl * (1 - dsq * (tl1 / 3 + (1 + 3 * tl1) * tl1 * dsq / 15)) / Math.cos(phi1);
-
   }
 
   p.x = adjust_lon(lam + this.long0);
   p.y = adjust_lat(phi);
   return p;
-
 }
 
-export var names = ["Cassini", "Cassini_Soldner", "cass"];
+export var names = ['Cassini', 'Cassini_Soldner', 'cass'];
 export default {
   init: init,
   forward: forward,

package/lib/projections/cea.js

@@ -10,26 +10,25 @@ import iqsfnz from '../common/iqsfnz';
     USGS Open File Report 90-284and Release 4 Interim Reports (2003)
 */
 export function init() {
-  //no-op
+  // no-op
   if (!this.sphere) {
     this.k0 = msfnz(this.e, Math.sin(this.lat_ts), Math.cos(this.lat_ts));
   }
 }
 
 /* Cylindrical Equal Area forward equations--mapping lat,long to x,y
-    ------------------------------------------------------------*/
+    ------------------------------------------------------------ */
 export function forward(p) {
   var lon = p.x;
   var lat = p.y;
   var x, y;
   /* Forward equations
-      -----------------*/
+      ----------------- */
   var dlon = adjust_lon(lon - this.long0);
   if (this.sphere) {
     x = this.x0 + this.a * dlon * Math.cos(this.lat_ts);
     y = this.y0 + this.a * Math.sin(lat) / Math.cos(this.lat_ts);
-  }
-  else {
+  } else {
     var qs = qsfnz(this.e, Math.sin(lat));
     x = this.x0 + this.a * this.k0 * dlon;
     y = this.y0 + this.a * qs * 0.5 / this.k0;
@@ -41,7 +40,7 @@ export function forward(p) {
 }
 
 /* Cylindrical Equal Area inverse equations--mapping x,y to lat/long
-    ------------------------------------------------------------*/
+    ------------------------------------------------------------ */
 export function inverse(p) {
   p.x -= this.x0;
   p.y -= this.y0;
@@ -50,8 +49,7 @@ export function inverse(p) {
   if (this.sphere) {
     lon = adjust_lon(this.long0 + (p.x / this.a) / Math.cos(this.lat_ts));
     lat = Math.asin((p.y / this.a) * Math.cos(this.lat_ts));
-  }
-  else {
+  } else {
     lat = iqsfnz(this.e, 2 * p.y * this.k0 / this.a);
     lon = adjust_lon(this.long0 + p.x / (this.a * this.k0));
   }
@@ -61,7 +59,7 @@ export function inverse(p) {
   return p;
 }
 
-export var names = ["cea"];
+export var names = ['cea'];
 export default {
   init: init,
   forward: forward,