UNPKG

covutils/covutils-lite.src.js

Version:
270 kBJavaScriptView Raw
1(function (exports) {
'use strict';
3
function minMax(arr) {
 var len = arr.length;
 var min = Infinity;
 var max = -Infinity;
 while (len--) {
   var el = arr[len];
   if (el == null) {
     // do nothing
   } else if (el < min) {
     min = el;
   } else if (el > max) {
     max = el;
   }
 }
 if (min === Infinity) {
   min = max;
 } else if (max === -Infinity) {
   max = min;
 }
 if (min === Infinity || min === -Infinity) {
   // all values were null
   min = null;
   max = null;
 }
 return [min, max];
}
30
/**
* Return the indices of the two neighbors in the sorted array closest to the given number.
*
* @example
* var a = [2,5,8,12,13]
* var i = CovUtils.indicesOfNearest(a, 6)
* // i == [1,2]
* var j = CovUtils.indicesOfNearest(a, 5)
* // j == [1,1]
* var k = CovUtils.indicesOfNearest(a, 50)
* // k == [4,4]
*
* @param {Array<number>} a The array to search through. Must be sorted, ascending or descending.
* @param {number} x The target number.
* @return {[lo,hi]} The indices of the two closest values, may be equal.
*   If `x` exists in the array, both neighbors point to `x`.
*   If `x` is lower (greater if descending) than the first value, both neighbors point to 0.
*   If `x` is greater (lower if descending) than the last value, both neighbors point to the last index.
*/
function indicesOfNearest(a, x) {
 if (a.length === 0) {
   throw new Error('Array must have at least one element');
 }
 var lo = -1;
 var hi = a.length;
 var ascending = a.length === 1 || a[0] < a[1];
 // we have two separate code paths to help the runtime optimize the loop
 if (ascending) {
   while (hi - lo > 1) {
     var mid = Math.round((lo + hi) / 2);
     if (a[mid] <= x) {
       lo = mid;
     } else {
       hi = mid;
     }
   }
 } else {
   while (hi - lo > 1) {
     var _mid = Math.round((lo + hi) / 2);
     if (a[_mid] >= x) {
       // here's the difference
       lo = _mid;
     } else {
       hi = _mid;
     }
   }
 }
 if (a[lo] === x) hi = lo;
 if (lo === -1) lo = hi;
 if (hi === a.length) hi = lo;
 return [lo, hi];
}
83
/**
* Return the index of the value closest to the given number in a sorted array.
*
* @example
* var a = [2,5,8,12,13]
* var i = CovUtils.indexOfNearest(a, 6)
* // i == 1
* var j = CovUtils.indexOfNearest(a, 7)
* // j == 2
* var k = CovUtils.indexOfNearest(a, 50)
* // k == 4
*
* @param {Array<number>} a The array to search through. Must be sorted, ascending or descending.
* @param {number} x The target number.
* @return {number} The array index whose value is closest to `x`.
*   If `x` happens to be exactly between two values, then the lower index is returned.
*/
function indexOfNearest(a, x) {
 var i = indicesOfNearest(a, x);
 var lo = i[0];
 var hi = i[1];
 if (Math.abs(x - a[lo]) <= Math.abs(x - a[hi])) {
   return lo;
 } else {
   return hi;
 }
}
111
var DOMAIN = 'Domain';
var COVERAGE = 'Coverage';
var COVERAGECOLLECTION = COVERAGE + 'Collection';
115
var COVJSON_NS = 'http://covjson.org/def/core#';
117
var COVJSON_DATATYPE_TUPLE = COVJSON_NS + 'tuple';
var COVJSON_DATATYPE_POLYGON = COVJSON_NS + 'polygon';
120
var DEFAULT_LANGUAGE = 'en';
122
/**
* @example
* var labels = {'en': 'Temperature', 'de': 'Temperatur'}
* var tag = CovUtils.getLanguageTag(labels, 'en-GB')
* // tag == 'en'
*
* @param {object} map An object that maps language tags to strings.
* @param {string} [preferredLanguage='en'] The preferred language as a language tag, e.g. 'de'.
* @return {string} The best matched language tag of the input map.
*   If no match was found then this is an arbitrary tag of the map.
*/
function getLanguageTag(map) {
 var preferredLanguage = arguments.length <= 1 || arguments[1] === undefined ? DEFAULT_LANGUAGE : arguments[1];
136
 if (preferredLanguage in map) {
   return preferredLanguage;
 }
140
 // cut off any subtags following the language subtag and try to find a match
 var prefTag = preferredLanguage.split('-')[0];
 var matches = Object.keys(map).filter(function (tag) {
   return prefTag === tag.split('-')[0];
 });
 if (matches.length) {
   return matches[0];
 }
149
 // no luck, return a random tag
 return Object.keys(map)[0];
}
153
/**
* @example
* var labels = {'en': 'Temperature', 'de': 'Temperatur'}
* var label = CovUtils.getLanguageString(labels, 'en-GB')
* // label == 'Temperature'
*
* @param {object} map An object that maps language tags to strings.
* @param {string} [preferredLanguage='en'] The preferred language as a language tag, e.g. 'de'.
* @return {string} The string within the input map whose language tag best matched.
*   If no match was found then this is an arbitrary string of the map.
*/
function getLanguageString(map) {
 var preferredLanguage = arguments.length <= 1 || arguments[1] === undefined ? DEFAULT_LANGUAGE : arguments[1];
167
 var tag = getLanguageTag(map, preferredLanguage);
 return map[tag];
}
171
/**
* Converts a unit object to a human-readable symbol or label, where symbols are preferred.
*
* @example
* var unit = {
*   symbol: '°C'
* }
* var str = CovUtils.stringifyUnit(unit) // str == '°C'
*
* @example
* var unit = {
*   symbol: {
*     value: 'Cel',
*     type: 'http://www.opengis.net/def/uom/UCUM/'
*   },
*   label: {
*     en: 'Degree Celsius'
*   }
* }
* var str = CovUtils.stringifyUnit(unit) // str == '°C'
*
* @example
* var unit = {
*   label: {
*     en: 'Degree Celsius',
*     de: 'Grad Celsius'
*   }
* }
* var str = CovUtils.stringifyUnit(unit, 'en') // str == 'Degree Celsius'
*/
function stringifyUnit(unit, language) {
 if (!unit) {
   return '';
 }
 if (unit.symbol) {
   var symbol = unit.symbol.value || unit.symbol;
   var scheme = unit.symbol.type;
   if (scheme === 'http://www.opengis.net/def/uom/UCUM/') {
     if (symbol === 'Cel') {
       symbol = '°C';
     } else if (symbol === '1') {
       symbol = '';
     }
   }
   return symbol;
 } else {
   return getLanguageString(unit.label, language);
 }
}
221
var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
 return typeof obj;
} : function (obj) {
 return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj;
};
227
var classCallCheck = function (instance, Constructor) {
 if (!(instance instanceof Constructor)) {
   throw new TypeError("Cannot call a class as a function");
 }
};
233
var createClass = function () {
 function defineProperties(target, props) {
   for (var i = 0; i < props.length; i++) {
     var descriptor = props[i];
     descriptor.enumerable = descriptor.enumerable || false;
     descriptor.configurable = true;
     if ("value" in descriptor) descriptor.writable = true;
     Object.defineProperty(target, descriptor.key, descriptor);
   }
 }
244
 return function (Constructor, protoProps, staticProps) {
   if (protoProps) defineProperties(Constructor.prototype, protoProps);
   if (staticProps) defineProperties(Constructor, staticProps);
   return Constructor;
 };
}();
251
var defineProperty = function (obj, key, value) {
 if (key in obj) {
   Object.defineProperty(obj, key, {
     value: value,
     enumerable: true,
     configurable: true,
     writable: true
   });
 } else {
   obj[key] = value;
 }
263
 return obj;
};
266
var slicedToArray = function () {
 function sliceIterator(arr, i) {
   var _arr = [];
   var _n = true;
   var _d = false;
   var _e = undefined;
273
   try {
     for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
       _arr.push(_s.value);
277
       if (i && _arr.length === i) break;
     }
   } catch (err) {
     _d = true;
     _e = err;
   } finally {
     try {
       if (!_n && _i["return"]) _i["return"]();
     } finally {
       if (_d) throw _e;
     }
   }
290
   return _arr;
 }
293
 return function (arr, i) {
   if (Array.isArray(arr)) {
     return arr;
   } else if (Symbol.iterator in Object(arr)) {
     return sliceIterator(arr, i);
   } else {
     throw new TypeError("Invalid attempt to destructure non-iterable instance");
   }
 };
}();
304
var toConsumableArray = function (arr) {
 if (Array.isArray(arr)) {
   for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];
308
   return arr2;
 } else {
   return Array.from(arr);
 }
};
314
/**
* @external {Range} https://github.com/Reading-eScience-Centre/coverage-jsapi/blob/master/Range.md
*/
318
/**
* Return the minimum/maximum across all range values, ignoring null's.
*
* @param {Range<number>} range The numeric coverage data range.
* @return {[min,max]} The minimum and maximum values of the range,
*   or [undefined, undefined] if the range contains only `null` values.
*/
function minMaxOfRange(range) {
 var min = Infinity;
 var max = -Infinity;
 var fn = function fn(val) {
   if (val === null) return;
   if (val < min) min = val;
   if (val > max) max = val;
 };
 iterateRange(range, fn);
 return min === Infinity ? [undefined, undefined] : [min, max];
}
337
/**
* Apply a reduce function over the range values.
*
* @param {Range} range The coverage data range.
* @param {function} callback Function to execute on each value in the array with arguments `(previousValue, currentValue)`.
* @param start Value to use as the first argument to the first call of the `callback`.
* @return The reduced value.
*/
function reduceRange(range, callback, start) {
 var v1 = start;
 var iterFn = function iterFn(v2) {
   v1 = callback(v1, v2);
 };
 iterateRange(range, iterFn);
 return v1;
}
354
/**
* Iterate over all range values and run a function for each value.
* No particular iteration order must be assumed.
*/
function iterateRange(range, fn) {
 // We use a precompiled function here for efficiency.
 // See below for a slower recursive version.
362
 // Benchmarks compared to recursive version:
 // Chrome 46: around 1.03x faster
 // Firefox 42: around 2x faster (and around 6x faster than Chrome 46!)
366
 // nest loops from smallest to biggest
 var shape = [].concat(toConsumableArray(range.shape));
 shape.sort(function (_ref, _ref2) {
   var _ref4 = slicedToArray(_ref, 2);
371
   var size1 = _ref4[1];
373
   var _ref3 = slicedToArray(_ref2, 2);
375
   var size2 = _ref3[1];
   return size1 - size2;
 });
379
 var begin = 'var obj = {}';
 var end = '';
 var _iteratorNormalCompletion = true;
 var _didIteratorError = false;
 var _iteratorError = undefined;
385
 try {
   for (var _iterator = shape[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
     var _step$value = slicedToArray(_step.value, 2);
389
     var axis = _step$value[0];
     var size = _step$value[1];
392
     begin += '\n      for (var i' + axis + '=0; i' + axis + ' < ' + size + '; ++i' + axis + ') {\n        obj[\'' + axis + '\'] = i' + axis + '\n    ';
     end += '}';
   }
 } catch (err) {
   _didIteratorError = true;
   _iteratorError = err;
 } finally {
   try {
     if (!_iteratorNormalCompletion && _iterator.return) {
       _iterator.return();
     }
   } finally {
     if (_didIteratorError) {
       throw _iteratorError;
     }
   }
 }
410
 begin += '\n    fn(get(obj))\n  ';
412
 var iterateLoop = new Function('return function iterRange (get, fn) { ' + begin + ' ' + end + ' }')(); // eslint-disable-line
 iterateLoop(range.get, fn);
}
416
/**
* Returns the category of the given parameter corresponding to the encoded integer value.
*
* @param {Parameter} parameter
* @param {number} val
* @return {Category}
*/
function getCategory(parameter, val) {
 var _iteratorNormalCompletion = true;
 var _didIteratorError = false;
 var _iteratorError = undefined;
428
 try {
   var _loop = function _loop() {
     var _step$value = slicedToArray(_step.value, 2);
432
     var catId = _step$value[0];
     var vals = _step$value[1];
435
     if (vals.indexOf(val) !== -1) {
       var cat = parameter.observedProperty.categories.filter(function (c) {
         return c.id === catId;
       })[0];
       return {
         v: cat
       };
     }
   };
445
   for (var _iterator = parameter.categoryEncoding[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
     var _ret = _loop();
448
     if ((typeof _ret === "undefined" ? "undefined" : _typeof(_ret)) === "object") return _ret.v;
   }
 } catch (err) {
   _didIteratorError = true;
   _iteratorError = err;
 } finally {
   try {
     if (!_iteratorNormalCompletion && _iterator.return) {
       _iterator.return();
     }
   } finally {
     if (_didIteratorError) {
       throw _iteratorError;
     }
   }
 }
}
466
function isCoverage(obj) {
 return obj.type === COVERAGE;
}
470
function checkCoverage(obj) {
 if (!isCoverage(obj)) {
   throw new Error('must be a Coverage');
 }
}
476
function isDomain(obj) {
 return obj.type === DOMAIN;
}
480
function checkDomain(obj) {
 if (!isDomain(obj)) {
   throw new Error('must be a Domain');
 }
}
486
function createCommonjsModule(fn, module) {
return module = { exports: {} }, fn(module, module.exports), module.exports;
}
490
var imlfn = createCommonjsModule(function (module) {
module.exports = function(ml, e0, e1, e2, e3) {
 var phi;
 var dphi;
495
 phi = ml / e0;
 for (var i = 0; i < 15; i++) {
   dphi = (ml - (e0 * phi - e1 * Math.sin(2 * phi) + e2 * Math.sin(4 * phi) - e3 * Math.sin(6 * phi))) / (e0 - 2 * e1 * Math.cos(2 * phi) + 4 * e2 * Math.cos(4 * phi) - 6 * e3 * Math.cos(6 * phi));
   phi += dphi;
   if (Math.abs(dphi) <= 0.0000000001) {
     return phi;
   }
 }
504
 //..reportError("IMLFN-CONV:Latitude failed to converge after 15 iterations");
 return NaN;
};
});
509
var require$$0$3 = (imlfn && typeof imlfn === 'object' && 'default' in imlfn ? imlfn['default'] : imlfn);
511
var asinz = createCommonjsModule(function (module) {
module.exports = function(x) {
 if (Math.abs(x) > 1) {
   x = (x > 1) ? 1 : -1;
 }
 return Math.asin(x);
};
});
520
var require$$0$4 = (asinz && typeof asinz === 'object' && 'default' in asinz ? asinz['default'] : asinz);
522
var gN = createCommonjsModule(function (module) {
module.exports = function(a, e, sinphi) {
 var temp = e * sinphi;
 return a / Math.sqrt(1 - temp * temp);
};
});
529
var require$$3 = (gN && typeof gN === 'object' && 'default' in gN ? gN['default'] : gN);
531
var e3fn = createCommonjsModule(function (module) {
module.exports = function(x) {
 return (x * x * x * (35 / 3072));
};
});
537
var require$$4 = (e3fn && typeof e3fn === 'object' && 'default' in e3fn ? e3fn['default'] : e3fn);
539
var e2fn = createCommonjsModule(function (module) {
module.exports = function(x) {
 return (0.05859375 * x * x * (1 + 0.75 * x));
};
});
545
var require$$5 = (e2fn && typeof e2fn === 'object' && 'default' in e2fn ? e2fn['default'] : e2fn);
547
var e1fn = createCommonjsModule(function (module) {
module.exports = function(x) {
 return (0.375 * x * (1 + 0.25 * x * (1 + 0.46875 * x)));
};
});
553
var require$$6 = (e1fn && typeof e1fn === 'object' && 'default' in e1fn ? e1fn['default'] : e1fn);
555
var e0fn = createCommonjsModule(function (module) {
module.exports = function(x) {
 return (1 - 0.25 * x * (1 + x / 16 * (3 + 1.25 * x)));
};
});
561
var require$$7 = (e0fn && typeof e0fn === 'object' && 'default' in e0fn ? e0fn['default'] : e0fn);
563
var mlfn = createCommonjsModule(function (module) {
module.exports = function(e0, e1, e2, e3, phi) {
 return (e0 * phi - e1 * Math.sin(2 * phi) + e2 * Math.sin(4 * phi) - e3 * Math.sin(6 * phi));
};
});
569
var require$$3$1 = (mlfn && typeof mlfn === 'object' && 'default' in mlfn ? mlfn['default'] : mlfn);
571
var sign = createCommonjsModule(function (module) {
module.exports = function(x) {
 return x<0 ? -1 : 1;
};
});
577
var require$$1 = (sign && typeof sign === 'object' && 'default' in sign ? sign['default'] : sign);
579
var adjust_lon = createCommonjsModule(function (module) {
var TWO_PI = Math.PI * 2;
// SPI is slightly greater than Math.PI, so values that exceed the -180..180
// degree range by a tiny amount don't get wrapped. This prevents points that
// have drifted from their original location along the 180th meridian (due to
// floating point error) from changing their sign.
var SPI = 3.14159265359;
var sign = require$$1;
588
module.exports = function(x) {
 return (Math.abs(x) <= SPI) ? x : (x - (sign(x) * TWO_PI));
};
});
593
var require$$2 = (adjust_lon && typeof adjust_lon === 'object' && 'default' in adjust_lon ? adjust_lon['default'] : adjust_lon);
595
var aeqd = createCommonjsModule(function (module, exports) {
var adjust_lon = require$$2;
var HALF_PI = Math.PI/2;
var EPSLN = 1.0e-10;
var mlfn = require$$3$1;
var e0fn = require$$7;
var e1fn = require$$6;
var e2fn = require$$5;
var e3fn = require$$4;
var gN = require$$3;
var asinz = require$$0$4;
var imlfn = require$$0$3;
exports.init = function() {
 this.sin_p12 = Math.sin(this.lat0);
 this.cos_p12 = Math.cos(this.lat0);
};
612
exports.forward = function(p) {
 var lon = p.x;
 var lat = p.y;
 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;
 if (this.sphere) {
   if (Math.abs(this.sin_p12 - 1) <= EPSLN) {
     //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
     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
     cos_c = this.sin_p12 * sinphi + this.cos_p12 * cosphi * Math.cos(dlon);
     c = Math.acos(cos_c);
     kp = c / Math.sin(c);
     p.x = this.x0 + this.a * kp * cosphi * Math.sin(dlon);
     p.y = this.y0 + this.a * kp * (this.cos_p12 * sinphi - this.sin_p12 * cosphi * Math.cos(dlon));
     return p;
   }
 }
 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
     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
     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));
     }
     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);
     return p;
   }
 }
694
695
};
697
exports.inverse = function(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;
 if (this.sphere) {
   rh = Math.sqrt(p.x * p.x + p.y * p.y);
   if (rh > (2 * HALF_PI * this.a)) {
     return;
   }
   z = rh / this.a;
708
   sinz = Math.sin(z);
   cosz = Math.cos(z);
711
   lon = this.long0;
   if (Math.abs(rh) <= EPSLN) {
     lat = this.lat0;
   }
   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 {
       /*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));
     }
   }
738
   p.x = lon;
   p.y = lat;
   return p;
 }
 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
     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));
     p.x = lon;
     p.y = lat;
     return p;
   }
   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;
764
     lat = imlfn(M / this.a, e0, e1, e2, e3);
     lon = adjust_lon(this.long0 + Math.atan2(p.x, p.y));
     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)));
     lat = Math.atan((1 - this.es * F * this.sin_p12 / Math.sin(psi)) * Math.tan(psi) / (1 - this.es));
     p.x = lon;
     p.y = lat;
     return p;
   }
 }
791
};
exports.names = ["Azimuthal_Equidistant", "aeqd"];
});
795
var require$$0$2 = (aeqd && typeof aeqd === 'object' && 'default' in aeqd ? aeqd['default'] : aeqd);
797
var vandg = createCommonjsModule(function (module, exports) {
var adjust_lon = require$$2;
var HALF_PI = Math.PI/2;
var EPSLN = 1.0e-10;
var asinz = require$$0$4;
/* Initialize the Van Der Grinten projection
 ----------------------------------------*/
exports.init = function() {
 //this.R = 6370997; //Radius of earth
 this.R = this.a;
};
809
exports.forward = function(p) {
811
 var lon = p.x;
 var lat = p.y;
814
 /* Forward equations
   -----------------*/
 var dlon = adjust_lon(lon - this.long0);
 var x, y;
819
 if (Math.abs(lat) <= EPSLN) {
   x = this.x0 + this.R * dlon;
   y = this.y0;
 }
 var theta = asinz(2 * Math.abs(lat / Math.PI));
 if ((Math.abs(dlon) <= EPSLN) || (Math.abs(Math.abs(lat) - HALF_PI) <= EPSLN)) {
   x = this.x0;
   if (lat >= 0) {
     y = this.y0 + Math.PI * this.R * Math.tan(0.5 * theta);
   }
   else {
     y = this.y0 + Math.PI * this.R * -Math.tan(0.5 * theta);
   }
   //  return(OK);
 }
 var al = 0.5 * Math.abs((Math.PI / dlon) - (dlon / Math.PI));
 var asq = al * al;
 var sinth = Math.sin(theta);
 var costh = Math.cos(theta);
839
 var g = costh / (sinth + costh - 1);
 var gsq = g * g;
 var m = g * (2 / sinth - 1);
 var msq = m * m;
 var con = Math.PI * this.R * (al * (g - msq) + Math.sqrt(asq * (g - msq) * (g - msq) - (msq + asq) * (gsq - msq))) / (msq + asq);
 if (dlon < 0) {
   con = -con;
 }
 x = this.x0 + con;
 //con = Math.abs(con / (Math.PI * this.R));
 var q = asq + g;
 con = Math.PI * this.R * (m * q - al * Math.sqrt((msq + asq) * (asq + 1) - q * q)) / (msq + asq);
 if (lat >= 0) {
   //y = this.y0 + Math.PI * this.R * Math.sqrt(1 - con * con - 2 * al * con);
   y = this.y0 + con;
 }
 else {
   //y = this.y0 - Math.PI * this.R * Math.sqrt(1 - con * con - 2 * al * con);
   y = this.y0 - con;
 }
 p.x = x;
 p.y = y;
 return p;
};
864
/* Van Der Grinten inverse equations--mapping x,y to lat/long
 ---------------------------------------------------------*/
exports.inverse = function(p) {
 var lon, lat;
 var xx, yy, xys, c1, c2, c3;
 var a1;
 var m1;
 var con;
 var th1;
 var d;
875
 /* inverse equations
   -----------------*/
 p.x -= this.x0;
 p.y -= this.y0;
 con = Math.PI * this.R;
 xx = p.x / con;
 yy = p.y / con;
 xys = xx * xx + yy * yy;
 c1 = -Math.abs(yy) * (1 + xys);
 c2 = c1 - 2 * yy * yy + xx * xx;
 c3 = -2 * c1 + 1 + 2 * yy * yy + xys * xys;
 d = yy * yy / c3 + (2 * c2 * c2 * c2 / c3 / c3 / c3 - 9 * c1 * c2 / c3 / c3) / 27;
 a1 = (c1 - c2 * c2 / 3 / c3) / c3;
 m1 = 2 * Math.sqrt(-a1 / 3);
 con = ((3 * d) / a1) / m1;
 if (Math.abs(con) > 1) {
   if (con >= 0) {
     con = 1;
   }
   else {
     con = -1;
   }
 }
 th1 = Math.acos(con) / 3;
 if (p.y >= 0) {
   lat = (-m1 * Math.cos(th1 + Math.PI / 3) - c2 / 3 / c3) * Math.PI;
 }
 else {
   lat = -(-m1 * Math.cos(th1 + Math.PI / 3) - c2 / 3 / c3) * Math.PI;
 }
906
 if (Math.abs(xx) < EPSLN) {
   lon = this.long0;
 }
 else {
   lon = adjust_lon(this.long0 + Math.PI * (xys - 1 + Math.sqrt(1 + 2 * (xx * xx - yy * yy) + xys * xys)) / 2 / xx);
 }
913
 p.x = lon;
 p.y = lat;
 return p;
};
exports.names = ["Van_der_Grinten_I", "VanDerGrinten", "vandg"];
});
920
var require$$1$1 = (vandg && typeof vandg === 'object' && 'default' in vandg ? vandg['default'] : vandg);
922
var adjust_lat = createCommonjsModule(function (module) {
var HALF_PI = Math.PI/2;
var sign = require$$1;
926
module.exports = function(x) {
 return (Math.abs(x) < HALF_PI) ? x : (x - (sign(x) * Math.PI));
};
});
931
var require$$1$2 = (adjust_lat && typeof adjust_lat === 'object' && 'default' in adjust_lat ? adjust_lat['default'] : adjust_lat);
933
var msfnz = createCommonjsModule(function (module) {
module.exports = function(eccent, sinphi, cosphi) {
 var con = eccent * sinphi;
 return cosphi / (Math.sqrt(1 - con * con));
};
});
940
var require$$3$2 = (msfnz && typeof msfnz === 'object' && 'default' in msfnz ? msfnz['default'] : msfnz);
942
var eqdc = createCommonjsModule(function (module, exports) {
var e0fn = require$$7;
var e1fn = require$$6;
var e2fn = require$$5;
var e3fn = require$$4;
var msfnz = require$$3$2;
var mlfn = require$$3$1;
var adjust_lon = require$$2;
var adjust_lat = require$$1$2;
var imlfn = require$$0$3;
var EPSLN = 1.0e-10;
exports.init = function() {
955
 /* Place parameters in static storage for common use
     -------------------------------------------------*/
 // Standard Parallels cannot be equal and on opposite sides of the equator
 if (Math.abs(this.lat1 + this.lat2) < EPSLN) {
   return;
 }
 this.lat2 = this.lat2 || this.lat1;
 this.temp = this.b / this.a;
 this.es = 1 - Math.pow(this.temp, 2);
 this.e = Math.sqrt(this.es);
 this.e0 = e0fn(this.es);
 this.e1 = e1fn(this.es);
 this.e2 = e2fn(this.es);
 this.e3 = e3fn(this.es);
970
 this.sinphi = Math.sin(this.lat1);
 this.cosphi = Math.cos(this.lat1);
973
 this.ms1 = msfnz(this.e, this.sinphi, this.cosphi);
 this.ml1 = mlfn(this.e0, this.e1, this.e2, this.e3, this.lat1);
976
 if (Math.abs(this.lat1 - this.lat2) < EPSLN) {
   this.ns = this.sinphi;
 }
 else {
   this.sinphi = Math.sin(this.lat2);
   this.cosphi = Math.cos(this.lat2);
   this.ms2 = msfnz(this.e, this.sinphi, this.cosphi);
   this.ml2 = mlfn(this.e0, this.e1, this.e2, this.e3, this.lat2);
   this.ns = (this.ms1 - this.ms2) / (this.ml2 - this.ml1);
 }
 this.g = this.ml1 + this.ms1 / this.ns;
 this.ml0 = mlfn(this.e0, this.e1, this.e2, this.e3, this.lat0);
 this.rh = this.a * (this.g - this.ml0);
};
991
992
/* Equidistant Conic forward equations--mapping lat,long to x,y
 -----------------------------------------------------------*/
exports.forward = function(p) {
 var lon = p.x;
 var lat = p.y;
 var rh1;
999
 /* Forward equations
     -----------------*/
 if (this.sphere) {
   rh1 = this.a * (this.g - lat);
 }
 else {
   var ml = mlfn(this.e0, this.e1, this.e2, this.e3, lat);
   rh1 = this.a * (this.g - ml);
 }
 var theta = this.ns * adjust_lon(lon - this.long0);
 var x = this.x0 + rh1 * Math.sin(theta);
 var y = this.y0 + this.rh - rh1 * Math.cos(theta);
 p.x = x;
 p.y = y;
 return p;
};
1016
/* Inverse equations
 -----------------*/
exports.inverse = function(p) {
 p.x -= this.x0;
 p.y = this.rh - p.y + this.y0;
 var con, rh1, lat, lon;
 if (this.ns >= 0) {
   rh1 = Math.sqrt(p.x * p.x + p.y * p.y);
   con = 1;
 }
 else {
   rh1 = -Math.sqrt(p.x * p.x + p.y * p.y);
   con = -1;
 }
 var theta = 0;
 if (rh1 !== 0) {
   theta = Math.atan2(con * p.x, con * p.y);
 }
1035
 if (this.sphere) {
   lon = adjust_lon(this.long0 + theta / this.ns);
   lat = adjust_lat(this.g - rh1 / this.a);
   p.x = lon;
   p.y = lat;
   return p;
 }
 else {
   var ml = this.g - rh1 / this.a;
   lat = imlfn(ml, this.e0, this.e1, this.e2, this.e3);
   lon = adjust_lon(this.long0 + theta / this.ns);
   p.x = lon;
   p.y = lat;
   return p;
 }
1051
};
exports.names = ["Equidistant_Conic", "eqdc"];
});
1055
var require$$2$1 = (eqdc && typeof eqdc === 'object' && 'default' in eqdc ? eqdc['default'] : eqdc);
1057
var moll = createCommonjsModule(function (module, exports) {
var adjust_lon = require$$2;
var EPSLN = 1.0e-10;
exports.init = function() {};
1062
/* Mollweide forward equations--mapping lat,long to x,y
   ----------------------------------------------------*/
exports.forward = function(p) {
1066
 /* Forward equations
     -----------------*/
 var lon = p.x;
 var lat = p.y;
1071
 var delta_lon = adjust_lon(lon - this.long0);
 var theta = lat;
 var con = Math.PI * Math.sin(lat);
1075
 /* Iterate using the Newton-Raphson method to find theta
     -----------------------------------------------------*/
 for (var i = 0; true; i++) {
   var delta_theta = -(theta + Math.sin(theta) - con) / (1 + Math.cos(theta));
   theta += delta_theta;
   if (Math.abs(delta_theta) < EPSLN) {
     break;
   }
 }
 theta /= 2;
1086
 /* If the latitude is 90 deg, force the x coordinate to be "0 + false easting"
      this is done here because of precision problems with "cos(theta)"
      --------------------------------------------------------------------------*/
 if (Math.PI / 2 - Math.abs(lat) < EPSLN) {
   delta_lon = 0;
 }
 var x = 0.900316316158 * this.a * delta_lon * Math.cos(theta) + this.x0;
 var y = 1.4142135623731 * this.a * Math.sin(theta) + this.y0;
1095
 p.x = x;
 p.y = y;
 return p;
};
1100
exports.inverse = function(p) {
 var theta;
 var arg;
1104
 /* Inverse equations
     -----------------*/
 p.x -= this.x0;
 p.y -= this.y0;
 arg = p.y / (1.4142135623731 * this.a);
1110
 /* Because of division by zero problems, 'arg' can not be 1.  Therefore
      a number very close to one is used instead.
      -------------------------------------------------------------------*/
 if (Math.abs(arg) > 0.999999999999) {
   arg = 0.999999999999;
 }
 theta = Math.asin(arg);
 var lon = adjust_lon(this.long0 + (p.x / (0.900316316158 * this.a * Math.cos(theta))));
 if (lon < (-Math.PI)) {
   lon = -Math.PI;
 }
 if (lon > Math.PI) {
   lon = Math.PI;
 }
 arg = (2 * theta + Math.sin(2 * theta)) / Math.PI;
 if (Math.abs(arg) > 1) {
   arg = 1;
 }
 var lat = Math.asin(arg);
1130
 p.x = lon;
 p.y = lat;
 return p;
};
exports.names = ["Mollweide", "moll"];
});
1137
var require$$3$3 = (moll && typeof moll === 'object' && 'default' in moll ? moll['default'] : moll);
1139
var pj_mlfn = createCommonjsModule(function (module) {
module.exports = function(phi, sphi, cphi, en) {
 cphi *= sphi;
 sphi *= sphi;
 return (en[0] * phi - cphi * (en[1] + sphi * (en[2] + sphi * (en[3] + sphi * en[4]))));
};
});
1147
var require$$0$5 = (pj_mlfn && typeof pj_mlfn === 'object' && 'default' in pj_mlfn ? pj_mlfn['default'] : pj_mlfn);
1149
var pj_inv_mlfn = createCommonjsModule(function (module) {
var pj_mlfn = require$$0$5;
var EPSLN = 1.0e-10;
var MAX_ITER = 20;
module.exports = function(arg, es, en) {
 var k = 1 / (1 - es);
 var phi = arg;
 for (var i = MAX_ITER; i; --i) { /* rarely goes over 2 iterations */
   var s = Math.sin(phi);
   var t = 1 - es * s * s;
   //t = this.pj_mlfn(phi, s, Math.cos(phi), en) - arg;
   //phi -= t * (t * Math.sqrt(t)) * k;
   t = (pj_mlfn(phi, s, Math.cos(phi), en) - arg) * (t * Math.sqrt(t)) * k;
   phi -= t;
   if (Math.abs(t) < EPSLN) {
     return phi;
   }
 }
 //..reportError("cass:pj_inv_mlfn: Convergence error");
 return phi;
};
});
1172
var require$$1$3 = (pj_inv_mlfn && typeof pj_inv_mlfn === 'object' && 'default' in pj_inv_mlfn ? pj_inv_mlfn['default'] : pj_inv_mlfn);
1174
var pj_enfn = createCommonjsModule(function (module) {
var C00 = 1;
var C02 = 0.25;
var C04 = 0.046875;
var C06 = 0.01953125;
var C08 = 0.01068115234375;
var C22 = 0.75;
var C44 = 0.46875;
var C46 = 0.01302083333333333333;
var C48 = 0.00712076822916666666;
var C66 = 0.36458333333333333333;
var C68 = 0.00569661458333333333;
var C88 = 0.3076171875;
1188
module.exports = function(es) {
 var en = [];
 en[0] = C00 - es * (C02 + es * (C04 + es * (C06 + es * C08)));
 en[1] = es * (C22 - es * (C04 + es * (C06 + es * C08)));
 var t = es * es;
 en[2] = t * (C44 - es * (C46 + es * C48));
 t *= es;
 en[3] = t * (C66 - es * C68);
 en[4] = t * es * C88;
 return en;
};
});
1201
var require$$3$4 = (pj_enfn && typeof pj_enfn === 'object' && 'default' in pj_enfn ? pj_enfn['default'] : pj_enfn);
1203
var sinu = createCommonjsModule(function (module, exports) {
var adjust_lon = require$$2;
var adjust_lat = require$$1$2;
var pj_enfn = require$$3$4;
var MAX_ITER = 20;
var pj_mlfn = require$$0$5;
var pj_inv_mlfn = require$$1$3;
var HALF_PI = Math.PI/2;
var EPSLN = 1.0e-10;
var asinz = require$$0$4;
exports.init = function() {
 /* Place parameters in static storage for common use
   -------------------------------------------------*/
1217
1218
 if (!this.sphere) {
   this.en = pj_enfn(this.es);
 }
 else {
   this.n = 1;
   this.m = 0;
   this.es = 0;
   this.C_y = Math.sqrt((this.m + 1) / this.n);
   this.C_x = this.C_y / (this.m + 1);
 }
1229
};
1231
/* Sinusoidal forward equations--mapping lat,long to x,y
 -----------------------------------------------------*/
exports.forward = function(p) {
 var x, y;
 var lon = p.x;
 var lat = p.y;
 /* Forward equations
   -----------------*/
 lon = adjust_lon(lon - this.long0);
1241
 if (this.sphere) {
   if (!this.m) {
     lat = this.n !== 1 ? Math.asin(this.n * Math.sin(lat)) : lat;
   }
   else {
     var k = this.n * Math.sin(lat);
     for (var i = MAX_ITER; i; --i) {
       var V = (this.m * lat + Math.sin(lat) - k) / (this.m + Math.cos(lat));
       lat -= V;
       if (Math.abs(V) < EPSLN) {
         break;
       }
     }
   }
   x = this.a * this.C_x * lon * (this.m + Math.cos(lat));
   y = this.a * this.C_y * lat;
1258
 }
 else {
1261
   var s = Math.sin(lat);
   var c = Math.cos(lat);
   y = this.a * pj_mlfn(lat, s, c, this.en);
   x = this.a * lon * c / Math.sqrt(1 - this.es * s * s);
 }
1267
 p.x = x;
 p.y = y;
 return p;
};
1272
exports.inverse = function(p) {
 var lat, temp, lon, s;
1275
 p.x -= this.x0;
 lon = p.x / this.a;
 p.y -= this.y0;
 lat = p.y / this.a;
1280
 if (this.sphere) {
   lat /= this.C_y;
   lon = lon / (this.C_x * (this.m + Math.cos(lat)));
   if (this.m) {
     lat = asinz((this.m * lat + Math.sin(lat)) / this.n);
   }
   else if (this.n !== 1) {
     lat = asinz(Math.sin(lat) / this.n);
   }
   lon = adjust_lon(lon + this.long0);
   lat = adjust_lat(lat);
 }
 else {
   lat = pj_inv_mlfn(p.y / this.a, this.es, this.en);
   s = Math.abs(lat);
   if (s < HALF_PI) {
     s = Math.sin(lat);
     temp = this.long0 + p.x * Math.sqrt(1 - this.es * s * s) / (this.a * Math.cos(lat));
     //temp = this.long0 + p.x / (this.a * Math.cos(lat));
     lon = adjust_lon(temp);
   }
   else if ((s - EPSLN) < HALF_PI) {
     lon = this.long0;
   }
 }
 p.x = lon;
 p.y = lat;
 return p;
};
exports.names = ["Sinusoidal", "sinu"];
});
1312
var require$$4$1 = (sinu && typeof sinu === 'object' && 'default' in sinu ? sinu['default'] : sinu);
1314
var mill = createCommonjsModule(function (module, exports) {
var adjust_lon = require$$2;
/*
 reference
   "New Equal-Area Map Projections for Noncircular Regions", John P. Snyder,
   The American Cartographer, Vol 15, No. 4, October 1988, pp. 341-355.
 */
1322
1323
/* Initialize the Miller Cylindrical projection
 -------------------------------------------*/
exports.init = function() {
 //no-op
};
1329
1330
/* Miller Cylindrical forward equations--mapping lat,long to x,y
   ------------------------------------------------------------*/
exports.forward = function(p) {
 var lon = p.x;
 var lat = p.y;
 /* Forward equations
     -----------------*/
 var dlon = adjust_lon(lon - this.long0);
 var x = this.x0 + this.a * dlon;
 var y = this.y0 + this.a * Math.log(Math.tan((Math.PI / 4) + (lat / 2.5))) * 1.25;
1341
 p.x = x;
 p.y = y;
 return p;
};
1346
/* Miller Cylindrical inverse equations--mapping x,y to lat/long
   ------------------------------------------------------------*/
exports.inverse = function(p) {
 p.x -= this.x0;
 p.y -= this.y0;
1352
 var lon = adjust_lon(this.long0 + p.x / this.a);
 var lat = 2.5 * (Math.atan(Math.exp(0.8 * p.y / this.a)) - Math.PI / 4);
1355
 p.x = lon;
 p.y = lat;
 return p;
};
exports.names = ["Miller_Cylindrical", "mill"];
});
1362
var require$$5$1 = (mill && typeof mill === 'object' && 'default' in mill ? mill['default'] : mill);
1364
var nzmg = createCommonjsModule(function (module, exports) {
var SEC_TO_RAD = 4.84813681109535993589914102357e-6;
/*
 reference
   Department of Land and Survey Technical Circular 1973/32
     http://www.linz.govt.nz/docs/miscellaneous/nz-map-definition.pdf
   OSG Technical Report 4.1
     http://www.linz.govt.nz/docs/miscellaneous/nzmg.pdf
 */
1374
/**
* iterations: Number of iterations to refine inverse transform.
*     0 -> km accuracy
*     1 -> m accuracy -- suitable for most mapping applications
*     2 -> mm accuracy
*/
exports.iterations = 1;
1382
exports.init = function() {
 this.A = [];
 this.A[1] = 0.6399175073;
 this.A[2] = -0.1358797613;
 this.A[3] = 0.063294409;
 this.A[4] = -0.02526853;
 this.A[5] = 0.0117879;
 this.A[6] = -0.0055161;
 this.A[7] = 0.0026906;
 this.A[8] = -0.001333;
 this.A[9] = 0.00067;
 this.A[10] = -0.00034;
1395
 this.B_re = [];
 this.B_im = [];
 this.B_re[1] = 0.7557853228;
 this.B_im[1] = 0;
 this.B_re[2] = 0.249204646;
 this.B_im[2] = 0.003371507;
 this.B_re[3] = -0.001541739;
 this.B_im[3] = 0.041058560;
 this.B_re[4] = -0.10162907;
 this.B_im[4] = 0.01727609;
 this.B_re[5] = -0.26623489;
 this.B_im[5] = -0.36249218;
 this.B_re[6] = -0.6870983;
 this.B_im[6] = -1.1651967;
1410
 this.C_re = [];
 this.C_im = [];
 this.C_re[1] = 1.3231270439;
 this.C_im[1] = 0;
 this.C_re[2] = -0.577245789;
 this.C_im[2] = -0.007809598;
 this.C_re[3] = 0.508307513;
 this.C_im[3] = -0.112208952;
 this.C_re[4] = -0.15094762;
 this.C_im[4] = 0.18200602;
 this.C_re[5] = 1.01418179;
 this.C_im[5] = 1.64497696;
 this.C_re[6] = 1.9660549;
 this.C_im[6] = 2.5127645;
1425
 this.D = [];
 this.D[1] = 1.5627014243;
 this.D[2] = 0.5185406398;
 this.D[3] = -0.03333098;
 this.D[4] = -0.1052906;
 this.D[5] = -0.0368594;
 this.D[6] = 0.007317;
 this.D[7] = 0.01220;
 this.D[8] = 0.00394;
 this.D[9] = -0.0013;
};
1437
/**
   New Zealand Map Grid Forward  - long/lat to x/y
   long/lat in radians
 */
exports.forward = function(p) {
 var n;
 var lon = p.x;
 var lat = p.y;
1446
 var delta_lat = lat - this.lat0;
 var delta_lon = lon - this.long0;
1449
 // 1. Calculate d_phi and d_psi    ...                          // and d_lambda
 // For this algorithm, delta_latitude is in seconds of arc x 10-5, so we need to scale to those units. Longitude is radians.
 var d_phi = delta_lat / SEC_TO_RAD * 1E-5;
 var d_lambda = delta_lon;
 var d_phi_n = 1; // d_phi^0
1455
 var d_psi = 0;
 for (n = 1; n <= 10; n++) {
   d_phi_n = d_phi_n * d_phi;
   d_psi = d_psi + this.A[n] * d_phi_n;
 }
1461
 // 2. Calculate theta
 var th_re = d_psi;
 var th_im = d_lambda;
1465
 // 3. Calculate z
 var th_n_re = 1;
 var th_n_im = 0; // theta^0
 var th_n_re1;
 var th_n_im1;
1471
 var z_re = 0;
 var z_im = 0;
 for (n = 1; n <= 6; n++) {
   th_n_re1 = th_n_re * th_re - th_n_im * th_im;
   th_n_im1 = th_n_im * th_re + th_n_re * th_im;
   th_n_re = th_n_re1;
   th_n_im = th_n_im1;
   z_re = z_re + this.B_re[n] * th_n_re - this.B_im[n] * th_n_im;
   z_im = z_im + this.B_im[n] * th_n_re + this.B_re[n] * th_n_im;
 }
1482
 // 4. Calculate easting and northing
 p.x = (z_im * this.a) + this.x0;
 p.y = (z_re * this.a) + this.y0;
1486
 return p;
};
1489
1490
/**
   New Zealand Map Grid Inverse  -  x/y to long/lat
 */
exports.inverse = function(p) {
 var n;
 var x = p.x;
 var y = p.y;
1498
 var delta_x = x - this.x0;
 var delta_y = y - this.y0;
1501
 // 1. Calculate z
 var z_re = delta_y / this.a;
 var z_im = delta_x / this.a;
1505
 // 2a. Calculate theta - first approximation gives km accuracy
 var z_n_re = 1;
 var z_n_im = 0; // z^0
 var z_n_re1;
 var z_n_im1;
1511
 var th_re = 0;
 var th_im = 0;
 for (n = 1; n <= 6; n++) {
   z_n_re1 = z_n_re * z_re - z_n_im * z_im;
   z_n_im1 = z_n_im * z_re + z_n_re * z_im;
   z_n_re = z_n_re1;
   z_n_im = z_n_im1;
   th_re = th_re + this.C_re[n] * z_n_re - this.C_im[n] * z_n_im;
   th_im = th_im + this.C_im[n] * z_n_re + this.C_re[n] * z_n_im;
 }
1522
 // 2b. Iterate to refine the accuracy of the calculation
 //        0 iterations gives km accuracy
 //        1 iteration gives m accuracy -- good enough for most mapping applications
 //        2 iterations bives mm accuracy
 for (var i = 0; i < this.iterations; i++) {
   var th_n_re = th_re;
   var th_n_im = th_im;
   var th_n_re1;
   var th_n_im1;
1532
   var num_re = z_re;
   var num_im = z_im;
   for (n = 2; n <= 6; n++) {
     th_n_re1 = th_n_re * th_re - th_n_im * th_im;
     th_n_im1 = th_n_im * th_re + th_n_re * th_im;
     th_n_re = th_n_re1;
     th_n_im = th_n_im1;
     num_re = num_re + (n - 1) * (this.B_re[n] * th_n_re - this.B_im[n] * th_n_im);
     num_im = num_im + (n - 1) * (this.B_im[n] * th_n_re + this.B_re[n] * th_n_im);
   }
1543
   th_n_re = 1;
   th_n_im = 0;
   var den_re = this.B_re[1];
   var den_im = this.B_im[1];
   for (n = 2; n <= 6; n++) {
     th_n_re1 = th_n_re * th_re - th_n_im * th_im;
     th_n_im1 = th_n_im * th_re + th_n_re * th_im;
     th_n_re = th_n_re1;
     th_n_im = th_n_im1;
     den_re = den_re + n * (this.B_re[n] * th_n_re - this.B_im[n] * th_n_im);
     den_im = den_im + n * (this.B_im[n] * th_n_re + this.B_re[n] * th_n_im);
   }
1556
   // Complex division
   var den2 = den_re * den_re + den_im * den_im;
   th_re = (num_re * den_re + num_im * den_im) / den2;
   th_im = (num_im * den_re - num_re * den_im) / den2;
 }
1562
 // 3. Calculate d_phi              ...                                    // and d_lambda
 var d_psi = th_re;
 var d_lambda = th_im;
 var d_psi_n = 1; // d_psi^0
1567
 var d_phi = 0;
 for (n = 1; n <= 9; n++) {
   d_psi_n = d_psi_n * d_psi;
   d_phi = d_phi + this.D[n] * d_psi_n;
 }
1573
 // 4. Calculate latitude and longitude
 // d_phi is calcuated in second of arc * 10^-5, so we need to scale back to radians. d_lambda is in radians.
 var lat = this.lat0 + (d_phi * SEC_TO_RAD * 1E5);
 var lon = this.long0 + d_lambda;
1578
 p.x = lon;
 p.y = lat;
1581
 return p;
};
exports.names = ["New_Zealand_Map_Grid", "nzmg"];
});
1586
var require$$6$1 = (nzmg && typeof nzmg === 'object' && 'default' in nzmg ? nzmg['default'] : nzmg);
1588
var poly = createCommonjsModule(function (module, exports) {
var e0fn = require$$7;
var e1fn = require$$6;
var e2fn = require$$5;
var e3fn = require$$4;
var adjust_lon = require$$2;
var adjust_lat = require$$1$2;
var mlfn = require$$3$1;
var EPSLN = 1.0e-10;
var gN = require$$3;
var MAX_ITER = 20;
exports.init = function() {
 /* Place parameters in static storage for common use
     -------------------------------------------------*/
 this.temp = this.b / this.a;
 this.es = 1 - Math.pow(this.temp, 2); // devait etre dans tmerc.js mais n y est pas donc je commente sinon retour de valeurs nulles
 this.e = Math.sqrt(this.es);
 this.e0 = e0fn(this.es);
 this.e1 = e1fn(this.es);
 this.e2 = e2fn(this.es);
 this.e3 = e3fn(this.es);
 this.ml0 = this.a * mlfn(this.e0, this.e1, this.e2, this.e3, this.lat0); //si que des zeros le calcul ne se fait pas
};
1612
1613
/* Polyconic forward equations--mapping lat,long to x,y
   ---------------------------------------------------*/
exports.forward = function(p) {
 var lon = p.x;
 var lat = p.y;
 var x, y, el;
 var dlon = adjust_lon(lon - this.long0);
 el = dlon * Math.sin(lat);
 if (this.sphere) {
   if (Math.abs(lat) <= EPSLN) {
     x = this.a * dlon;
     y = -1 * this.a * this.lat0;
   }
   else {
     x = this.a * Math.sin(el) / Math.tan(lat);
     y = this.a * (adjust_lat(lat - this.lat0) + (1 - Math.cos(el)) / Math.tan(lat));
   }
 }
 else {
   if (Math.abs(lat) <= EPSLN) {
     x = this.a * dlon;
     y = -1 * this.ml0;
   }
   else {
     var nl = gN(this.a, this.e, Math.sin(lat)) / Math.tan(lat);
     x = nl * Math.sin(el);
     y = this.a * mlfn(this.e0, this.e1, this.e2, this.e3, lat) - this.ml0 + nl * (1 - Math.cos(el));
   }
1642
 }
 p.x = x + this.x0;
 p.y = y + this.y0;
 return p;
};
1648
1649
/* Inverse equations
 -----------------*/
exports.inverse = function(p) {
 var lon, lat, x, y, i;
 var al, bl;
 var phi, dphi;
 x = p.x - this.x0;
 y = p.y - this.y0;
1658
 if (this.sphere) {
   if (Math.abs(y + this.a * this.lat0) <= EPSLN) {
     lon = adjust_lon(x / this.a + this.long0);
     lat = 0;
   }
   else {
     al = this.lat0 + y / this.a;
     bl = x * x / this.a / this.a + al * al;
     phi = al;
     var tanphi;
     for (i = MAX_ITER; i; --i) {
       tanphi = Math.tan(phi);
       dphi = -1 * (al * (phi * tanphi + 1) - phi - 0.5 * (phi * phi + bl) * tanphi) / ((phi - al) / tanphi - 1);
       phi += dphi;
       if (Math.abs(dphi) <= EPSLN) {
         lat = phi;
         break;
       }
     }
     lon = adjust_lon(this.long0 + (Math.asin(x * Math.tan(phi) / this.a)) / Math.sin(lat));
   }
 }
 else {
   if (Math.abs(y + this.ml0) <= EPSLN) {
     lat = 0;
     lon = adjust_lon(this.long0 + x / this.a);
   }
   else {
1687
     al = (this.ml0 + y) / this.a;
     bl = x * x / this.a / this.a + al * al;
     phi = al;
     var cl, mln, mlnp, ma;
     var con;
     for (i = MAX_ITER; i; --i) {
       con = this.e * Math.sin(phi);
       cl = Math.sqrt(1 - con * con) * Math.tan(phi);
       mln = this.a * mlfn(this.e0, this.e1, this.e2, this.e3, phi);
       mlnp = this.e0 - 2 * this.e1 * Math.cos(2 * phi) + 4 * this.e2 * Math.cos(4 * phi) - 6 * this.e3 * Math.cos(6 * phi);
       ma = mln / this.a;
       dphi = (al * (cl * ma + 1) - ma - 0.5 * cl * (ma * ma + bl)) / (this.es * Math.sin(2 * phi) * (ma * ma + bl - 2 * al * ma) / (4 * cl) + (al - ma) * (cl * mlnp - 2 / Math.sin(2 * phi)) - mlnp);
       phi -= dphi;
       if (Math.abs(dphi) <= EPSLN) {
         lat = phi;
         break;
       }
     }
1706
     //lat=phi4z(this.e,this.e0,this.e1,this.e2,this.e3,al,bl,0,0);
     cl = Math.sqrt(1 - this.es * Math.pow(Math.sin(lat), 2)) * Math.tan(lat);
     lon = adjust_lon(this.long0 + Math.asin(x * cl / this.a) / Math.sin(lat));
   }
 }
1712
 p.x = lon;
 p.y = lat;
 return p;
};
exports.names = ["Polyconic", "poly"];
});
1719
var require$$7$1 = (poly && typeof poly === 'object' && 'default' in poly ? poly['default'] : poly);
1721
var eqc = createCommonjsModule(function (module, exports) {
var adjust_lon = require$$2;
var adjust_lat = require$$1$2;
exports.init = function() {
1726
 this.x0 = this.x0 || 0;
 this.y0 = this.y0 || 0;
 this.lat0 = this.lat0 || 0;
 this.long0 = this.long0 || 0;
 this.lat_ts = this.lat_ts || 0;
 this.title = this.title || "Equidistant Cylindrical (Plate Carre)";
1733
 this.rc = Math.cos(this.lat_ts);
};
1736
1737
// forward equations--mapping lat,long to x,y
// -----------------------------------------------------------------
exports.forward = function(p) {
1741
 var lon = p.x;
 var lat = p.y;
1744
 var dlon = adjust_lon(lon - this.long0);
 var dlat = adjust_lat(lat - this.lat0);
 p.x = this.x0 + (this.a * dlon * this.rc);
 p.y = this.y0 + (this.a * dlat);
 return p;
};
1751
// inverse equations--mapping x,y to lat/long
// -----------------------------------------------------------------
exports.inverse = function(p) {
1755
 var x = p.x;
 var y = p.y;
1758
 p.x = adjust_lon(this.long0 + ((x - this.x0) / (this.a * this.rc)));
 p.y = adjust_lat(this.lat0 + ((y - this.y0) / (this.a)));
 return p;
};
exports.names = ["Equirectangular", "Equidistant_Cylindrical", "eqc"];
});
1765
var require$$8 = (eqc && typeof eqc === 'object' && 'default' in eqc ? eqc['default'] : eqc);
1767
var iqsfnz = createCommonjsModule(function (module) {
var HALF_PI = Math.PI/2;
1770
module.exports = function(eccent, q) {
 var temp = 1 - (1 - eccent * eccent) / (2 * eccent) * Math.log((1 - eccent) / (1 + eccent));
 if (Math.abs(Math.abs(q) - temp) < 1.0E-6) {
   if (q < 0) {
     return (-1 * HALF_PI);
   }
   else {
     return HALF_PI;
   }
 }
 //var phi = 0.5* q/(1-eccent*eccent);
 var phi = Math.asin(0.5 * q);
 var dphi;
 var sin_phi;
 var cos_phi;
 var con;
 for (var i = 0; i < 30; i++) {
   sin_phi = Math.sin(phi);
   cos_phi = Math.cos(phi);
   con = eccent * sin_phi;
   dphi = Math.pow(1 - con * con, 2) / (2 * cos_phi) * (q / (1 - eccent * eccent) - sin_phi / (1 - con * con) + 0.5 / eccent * Math.log((1 - con) / (1 + con)));
   phi += dphi;
   if (Math.abs(dphi) <= 0.0000000001) {
     return phi;
   }
 }
1797
 //console.log("IQSFN-CONV:Latitude failed to converge after 30 iterations");
 return NaN;
};
});
1802
var require$$0$6 = (iqsfnz && typeof iqsfnz === 'object' && 'default' in iqsfnz ? iqsfnz['default'] : iqsfnz);
1804
var qsfnz = createCommonjsModule(function (module) {
module.exports = function(eccent, sinphi) {
 var con;
 if (eccent > 1.0e-7) {
   con = eccent * sinphi;
   return ((1 - eccent * eccent) * (sinphi / (1 - con * con) - (0.5 / eccent) * Math.log((1 - con) / (1 + con))));
 }
 else {
   return (2 * sinphi);
 }
};
});
1817
var require$$1$4 = (qsfnz && typeof qsfnz === 'object' && 'default' in qsfnz ? qsfnz['default'] : qsfnz);
1819
var cea = createCommonjsModule(function (module, exports) {
var adjust_lon = require$$2;
var qsfnz = require$$1$4;
var msfnz = require$$3$2;
var iqsfnz = require$$0$6;
/*
 reference:  
   "Cartographic Projection Procedures for the UNIX Environment-
   A User's Manual" by Gerald I. Evenden,
   USGS Open File Report 90-284and Release 4 Interim Reports (2003)
*/
exports.init = function() {
 //no-op
 if (!this.sphere) {
   this.k0 = msfnz(this.e, Math.sin(this.lat_ts), Math.cos(this.lat_ts));
 }
};
1837
1838
/* Cylindrical Equal Area forward equations--mapping lat,long to x,y
   ------------------------------------------------------------*/
exports.forward = function(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 {
   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;
 }
1857
 p.x = x;
 p.y = y;
 return p;
};
1862
/* Cylindrical Equal Area inverse equations--mapping x,y to lat/long
   ------------------------------------------------------------*/
exports.inverse = function(p) {
 p.x -= this.x0;
 p.y -= this.y0;
 var lon, lat;
1869
 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 {
   lat = iqsfnz(this.e, 2 * p.y * this.k0 / this.a);
   lon = adjust_lon(this.long0 + p.x / (this.a * this.k0));
 }
1878
 p.x = lon;
 p.y = lat;
 return p;
};
exports.names = ["cea"];
});
1885
var require$$9 = (cea && typeof cea === 'object' && 'default' in cea ? cea['default'] : cea);
1887
var gnom = createCommonjsModule(function (module, exports) {
var adjust_lon = require$$2;
var EPSLN = 1.0e-10;
var asinz = require$$0$4;
1892
/*
 reference:
   Wolfram Mathworld "Gnomonic Projection"
   http://mathworld.wolfram.com/GnomonicProjection.html
   Accessed: 12th November 2009
 */
exports.init = function() {
1900
 /* Place parameters in static storage for common use
     -------------------------------------------------*/
 this.sin_p14 = Math.sin(this.lat0);
 this.cos_p14 = Math.cos(this.lat0);
 // Approximation for projecting points to the horizon (infinity)
 this.infinity_dist = 1000 * this.a;
 this.rc = 1;
};
1909
1910
/* Gnomonic forward equations--mapping lat,long to x,y
   ---------------------------------------------------*/
exports.forward = function(p) {
 var sinphi, cosphi; /* sin and cos value        */
 var dlon; /* delta longitude value      */
 var coslon; /* cos of longitude        */
 var ksp; /* scale factor          */
 var g;
 var x, y;
 var lon = p.x;
 var lat = p.y;
 /* Forward equations
     -----------------*/
 dlon = adjust_lon(lon - this.long0);
1925
 sinphi = Math.sin(lat);
 cosphi = Math.cos(lat);
1928
 coslon = Math.cos(dlon);
 g = this.sin_p14 * sinphi + this.cos_p14 * cosphi * coslon;
 ksp = 1;
 if ((g > 0) || (Math.abs(g) <= EPSLN)) {
   x = this.x0 + this.a * ksp * cosphi * Math.sin(dlon) / g;
   y = this.y0 + this.a * ksp * (this.cos_p14 * sinphi - this.sin_p14 * cosphi * coslon) / g;
 }
 else {
1937
   // Point is in the opposing hemisphere and is unprojectable
   // We still need to return a reasonable point, so we project 
   // to infinity, on a bearing 
   // equivalent to the northern hemisphere equivalent
   // This is a reasonable approximation for short shapes and lines that 
   // straddle the horizon.
1944
   x = this.x0 + this.infinity_dist * cosphi * Math.sin(dlon);
   y = this.y0 + this.infinity_dist * (this.cos_p14 * sinphi - this.sin_p14 * cosphi * coslon);
1947
 }
 p.x = x;
 p.y = y;
 return p;
};
1953
1954
exports.inverse = function(p) {
 var rh; /* Rho */
 var sinc, cosc;
 var c;
 var lon, lat;
1960
 /* Inverse equations
     -----------------*/
 p.x = (p.x - this.x0) / this.a;
 p.y = (p.y - this.y0) / this.a;
1965
 p.x /= this.k0;
 p.y /= this.k0;
1968
 if ((rh = Math.sqrt(p.x * p.x + p.y * p.y))) {
   c = Math.atan2(rh, this.rc);
   sinc = Math.sin(c);
   cosc = Math.cos(c);
1973
   lat = asinz(cosc * this.sin_p14 + (p.y * sinc * this.cos_p14) / rh);
   lon = Math.atan2(p.x * sinc, rh * this.cos_p14 * cosc - p.y * this.sin_p14 * sinc);
   lon = adjust_lon(this.long0 + lon);
 }
 else {
   lat = this.phic0;
   lon = 0;
 }
1982
 p.x = lon;
 p.y = lat;
 return p;
};
exports.names = ["gnom"];
});
1989
var require$$10 = (gnom && typeof gnom === 'object' && 'default' in gnom ? gnom['default'] : gnom);
1991
var aea = createCommonjsModule(function (module, exports) {
var EPSLN = 1.0e-10;
var msfnz = require$$3$2;
var qsfnz = require$$1$4;
var adjust_lon = require$$2;
var asinz = require$$0$4;
exports.init = function() {
1999
 if (Math.abs(this.lat1 + this.lat2) < EPSLN) {
   return;
 }
 this.temp = this.b / this.a;
 this.es = 1 - Math.pow(this.temp, 2);
 this.e3 = Math.sqrt(this.es);
2006
 this.sin_po = Math.sin(this.lat1);
 this.cos_po = Math.cos(this.lat1);
 this.t1 = this.sin_po;
 this.con = this.sin_po;
 this.ms1 = msfnz(this.e3, this.sin_po, this.cos_po);
 this.qs1 = qsfnz(this.e3, this.sin_po, this.cos_po);
2013
 this.sin_po = Math.sin(this.lat2);
 this.cos_po = Math.cos(this.lat2);
 this.t2 = this.sin_po;
 this.ms2 = msfnz(this.e3, this.sin_po, this.cos_po);
 this.qs2 = qsfnz(this.e3, this.sin_po, this.cos_po);
2019
 this.sin_po = Math.sin(this.lat0);
 this.cos_po = Math.cos(this.lat0);
 this.t3 = this.sin_po;
 this.qs0 = qsfnz(this.e3, this.sin_po, this.cos_po);
2024
 if (Math.abs(this.lat1 - this.lat2) > EPSLN) {
   this.ns0 = (this.ms1 * this.ms1 - this.ms2 * this.ms2) / (this.qs2 - this.qs1);
 }
 else {
   this.ns0 = this.con;
 }
 this.c = this.ms1 * this.ms1 + this.ns0 * this.qs1;
 this.rh = this.a * Math.sqrt(this.c - this.ns0 * this.qs0) / this.ns0;
};
2034
/* Albers Conical Equal Area forward equations--mapping lat,long to x,y
 -------------------------------------------------------------------*/
exports.forward = function(p) {
2038
 var lon = p.x;
 var lat = p.y;
2041
 this.sin_phi = Math.sin(lat);
 this.cos_phi = Math.cos(lat);
2044
 var qs = qsfnz(this.e3, this.sin_phi, this.cos_phi);
 var rh1 = this.a * Math.sqrt(this.c - this.ns0 * qs) / this.ns0;
 var theta = this.ns0 * adjust_lon(lon - this.long0);
 var x = rh1 * Math.sin(theta) + this.x0;
 var y = this.rh - rh1 * Math.cos(theta) + this.y0;
2050
 p.x = x;
 p.y = y;
 return p;
};
2055
2056
exports.inverse = function(p) {
 var rh1, qs, con, theta, lon, lat;
2059
 p.x -= this.x0;
 p.y = this.rh - p.y + this.y0;
 if (this.ns0 >= 0) {
   rh1 = Math.sqrt(p.x * p.x + p.y * p.y);
   con = 1;
 }
 else {
   rh1 = -Math.sqrt(p.x * p.x + p.y * p.y);
   con = -1;
 }
 theta = 0;
 if (rh1 !== 0) {
   theta = Math.atan2(con * p.x, con * p.y);
 }
 con = rh1 * this.ns0 / this.a;
 if (this.sphere) {
   lat = Math.asin((this.c - con * con) / (2 * this.ns0));
 }
 else {
   qs = (this.c - con * con) / this.ns0;
   lat = this.phi1z(this.e3, qs);
 }
2082
 lon = adjust_lon(theta / this.ns0 + this.long0);
 p.x = lon;
 p.y = lat;
 return p;
};
2088
/* Function to compute phi1, the latitude for the inverse of the
  Albers Conical Equal-Area projection.
-------------------------------------------*/
exports.phi1z = function(eccent, qs) {
 var sinphi, cosphi, con, com, dphi;
 var phi = asinz(0.5 * qs);
 if (eccent < EPSLN) {
   return phi;
 }
2098
 var eccnts = eccent * eccent;
 for (var i = 1; i <= 25; i++) {
   sinphi = Math.sin(phi);
   cosphi = Math.cos(phi);
   con = eccent * sinphi;
   com = 1 - con * con;
   dphi = 0.5 * com * com / cosphi * (qs / (1 - eccnts) - sinphi / com + 0.5 / eccent * Math.log((1 - con) / (1 + con)));
   phi = phi + dphi;
   if (Math.abs(dphi) <= 1e-7) {
     return phi;
   }
 }
 return null;
};
exports.names = ["Albers_Conic_Equal_Area", "Albers", "aea"];
});
2115
var require$$11 = (aea && typeof aea === 'object' && 'default' in aea ? aea['default'] : aea);
2117
var laea = createCommonjsModule(function (module, exports) {
var HALF_PI = Math.PI/2;
var FORTPI = Math.PI/4;
var EPSLN = 1.0e-10;
var qsfnz = require$$1$4;
var adjust_lon = require$$2;
/*
 reference
   "New Equal-Area Map Projections for Noncircular Regions", John P. Snyder,
   The American Cartographer, Vol 15, No. 4, October 1988, pp. 341-355.
 */
2129
exports.S_POLE = 1;
exports.N_POLE = 2;
exports.EQUIT = 3;
exports.OBLIQ = 4;
2134
2135
/* Initialize the Lambert Azimuthal Equal Area projection
 ------------------------------------------------------*/
exports.init = function() {
 var t = Math.abs(this.lat0);
 if (Math.abs(t - HALF_PI) < EPSLN) {
   this.mode = this.lat0 < 0 ? this.S_POLE : this.N_POLE;
 }
 else if (Math.abs(t) < EPSLN) {
   this.mode = this.EQUIT;
 }
 else {
   this.mode = this.OBLIQ;
 }
 if (this.es > 0) {
   var sinphi;
2151
   this.qp = qsfnz(this.e, 1);
   this.mmf = 0.5 / (1 - this.es);
   this.apa = this.authset(this.es);
   switch (this.mode) {
   case this.N_POLE:
     this.dd = 1;
     break;
   case this.S_POLE:
     this.dd = 1;
     break;
   case this.EQUIT:
     this.rq = Math.sqrt(0.5 * this.qp);
     this.dd = 1 / this.rq;
     this.xmf = 1;
     this.ymf = 0.5 * this.qp;
     break;
   case this.OBLIQ:
     this.rq = Math.sqrt(0.5 * this.qp);
     sinphi = Math.sin(this.lat0);
     this.sinb1 = qsfnz(this.e, sinphi) / this.qp;
     this.cosb1 = Math.sqrt(1 - this.sinb1 * this.sinb1);
     this.dd = Math.cos(this.lat0) / (Math.sqrt(1 - this.es * sinphi * sinphi) * this.rq * this.cosb1);
     this.ymf = (this.xmf = this.rq) / this.dd;
     this.xmf *= this.dd;
     break;
   }
 }
 else {
   if (this.mode === this.OBLIQ) {
     this.sinph0 = Math.sin(this.lat0);
     this.cosph0 = Math.cos(this.lat0);
   }
 }
};
2186
/* Lambert Azimuthal Equal Area forward equations--mapping lat,long to x,y
 -----------------------------------------------------------------------*/
exports.forward = function(p) {
2190
 /* Forward equations
     -----------------*/
 var x, y, coslam, sinlam, sinphi, q, sinb, cosb, b, cosphi;
 var lam = p.x;
 var phi = p.y;
2196
 lam = adjust_lon(lam - this.long0);
2198
 if (this.sphere) {
   sinphi = Math.sin(phi);
   cosphi = Math.cos(phi);
   coslam = Math.cos(lam);
   if (this.mode === this.OBLIQ || this.mode === this.EQUIT) {
     y = (this.mode === this.EQUIT) ? 1 + cosphi * coslam : 1 + this.sinph0 * sinphi + this.cosph0 * cosphi * coslam;
     if (y <= EPSLN) {
       return null;
     }
     y = Math.sqrt(2 / y);
     x = y * cosphi * Math.sin(lam);
     y *= (this.mode === this.EQUIT) ? sinphi : this.cosph0 * sinphi - this.sinph0 * cosphi * coslam;
   }
   else if (this.mode === this.N_POLE || this.mode === this.S_POLE) {
     if (this.mode === this.N_POLE) {
       coslam = -coslam;
     }
     if (Math.abs(phi + this.phi0) < EPSLN) {
       return null;
     }
     y = FORTPI - phi * 0.5;
     y = 2 * ((this.mode === this.S_POLE) ? Math.cos(y) : Math.sin(y));
     x = y * Math.sin(lam);
     y *= coslam;
   }
 }
 else {
   sinb = 0;
   cosb = 0;
   b = 0;
   coslam = Math.cos(lam);
   sinlam = Math.sin(lam);
   sinphi = Math.sin(phi);
   q = qsfnz(this.e, sinphi);
   if (this.mode === this.OBLIQ || this.mode === this.EQUIT) {
     sinb = q / this.qp;
     cosb = Math.sqrt(1 - sinb * sinb);
   }
   switch (this.mode) {
   case this.OBLIQ:
     b = 1 + this.sinb1 * sinb + this.cosb1 * cosb * coslam;
     break;
   case this.EQUIT:
     b = 1 + cosb * coslam;
     break;
   case this.N_POLE:
     b = HALF_PI + phi;
     q = this.qp - q;
     break;
   case this.S_POLE:
     b = phi - HALF_PI;
     q = this.qp + q;
     break;
   }
   if (Math.abs(b) < EPSLN) {
     return null;
   }
   switch (this.mode) {
   case this.OBLIQ:
   case this.EQUIT:
     b = Math.sqrt(2 / b);
     if (this.mode === this.OBLIQ) {
       y = this.ymf * b * (this.cosb1 * sinb - this.sinb1 * cosb * coslam);
     }
     else {
       y = (b = Math.sqrt(2 / (1 + cosb * coslam))) * sinb * this.ymf;
     }
     x = this.xmf * b * cosb * sinlam;
     break;
   case this.N_POLE:
   case this.S_POLE:
     if (q >= 0) {
       x = (b = Math.sqrt(q)) * sinlam;
       y = coslam * ((this.mode === this.S_POLE) ? b : -b);
     }
     else {
       x = y = 0;
     }
     break;
   }
 }
2280
 p.x = this.a * x + this.x0;
 p.y = this.a * y + this.y0;
 return p;
};
2285
/* Inverse equations
 -----------------*/
exports.inverse = function(p) {
 p.x -= this.x0;
 p.y -= this.y0;
 var x = p.x / this.a;
 var y = p.y / this.a;
 var lam, phi, cCe, sCe, q, rho, ab;
2294
 if (this.sphere) {
   var cosz = 0,
     rh, sinz = 0;
2298
   rh = Math.sqrt(x * x + y * y);
   phi = rh * 0.5;
   if (phi > 1) {
     return null;
   }
   phi = 2 * Math.asin(phi);
   if (this.mode === this.OBLIQ || this.mode === this.EQUIT) {
     sinz = Math.sin(phi);
     cosz = Math.cos(phi);
   }
   switch (this.mode) {
   case this.EQUIT:
     phi = (Math.abs(rh) <= EPSLN) ? 0 : Math.asin(y * sinz / rh);
     x *= sinz;
     y = cosz * rh;
     break;
   case this.OBLIQ:
     phi = (Math.abs(rh) <= EPSLN) ? this.phi0 : Math.asin(cosz * this.sinph0 + y * sinz * this.cosph0 / rh);
     x *= sinz * this.cosph0;
     y = (cosz - Math.sin(phi) * this.sinph0) * rh;
     break;
   case this.N_POLE:
     y = -y;
     phi = HALF_PI - phi;
     break;
   case this.S_POLE:
     phi -= HALF_PI;
     break;
   }
   lam = (y === 0 && (this.mode === this.EQUIT || this.mode === this.OBLIQ)) ? 0 : Math.atan2(x, y);
 }
 else {
   ab = 0;
   if (this.mode === this.OBLIQ || this.mode === this.EQUIT) {
     x /= this.dd;
     y *= this.dd;
     rho = Math.sqrt(x * x + y * y);
     if (rho < EPSLN) {
       p.x = 0;
       p.y = this.phi0;
       return p;
     }
     sCe = 2 * Math.asin(0.5 * rho / this.rq);
     cCe = Math.cos(sCe);
     x *= (sCe = Math.sin(sCe));
     if (this.mode === this.OBLIQ) {
       ab = cCe * this.sinb1 + y * sCe * this.cosb1 / rho;
       q = this.qp * ab;
       y = rho * this.cosb1 * cCe - y * this.sinb1 * sCe;
     }
     else {
       ab = y * sCe / rho;
       q = this.qp * ab;
       y = rho * cCe;
     }
   }
   else if (this.mode === this.N_POLE || this.mode === this.S_POLE) {
     if (this.mode === this.N_POLE) {
       y = -y;
     }
     q = (x * x + y * y);
     if (!q) {
       p.x = 0;
       p.y = this.phi0;
       return p;
     }
     ab = 1 - q / this.qp;
     if (this.mode === this.S_POLE) {
       ab = -ab;
     }
   }
   lam = Math.atan2(x, y);
   phi = this.authlat(Math.asin(ab), this.apa);
 }
2373
2374
 p.x = adjust_lon(this.long0 + lam);
 p.y = phi;
 return p;
};
2379
/* determine latitude from authalic latitude */
exports.P00 = 0.33333333333333333333;
exports.P01 = 0.17222222222222222222;
exports.P02 = 0.10257936507936507936;
exports.P10 = 0.06388888888888888888;
exports.P11 = 0.06640211640211640211;
exports.P20 = 0.01641501294219154443;
2387
exports.authset = function(es) {
 var t;
 var APA = [];
 APA[0] = es * this.P00;
 t = es * es;
 APA[0] += t * this.P01;
 APA[1] = t * this.P10;
 t *= es;
 APA[0] += t * this.P02;
 APA[1] += t * this.P11;
 APA[2] = t * this.P20;
 return APA;
};
2401
exports.authlat = function(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));
};
exports.names = ["Lambert Azimuthal Equal Area", "Lambert_Azimuthal_Equal_Area", "laea"];
});
2408
var require$$12 = (laea && typeof laea === 'object' && 'default' in laea ? laea['default'] : laea);
2410
var cass = createCommonjsModule(function (module, exports) {
var mlfn = require$$3$1;
var e0fn = require$$7;
var e1fn = require$$6;
var e2fn = require$$5;
var e3fn = require$$4;
var gN = require$$3;
var adjust_lon = require$$2;
var adjust_lat = require$$1$2;
var imlfn = require$$0$3;
var HALF_PI = Math.PI/2;
var EPSLN = 1.0e-10;
exports.init = function() {
 if (!this.sphere) {
   this.e0 = e0fn(this.es);
   this.e1 = e1fn(this.es);
   this.e2 = e2fn(this.es);
   this.e3 = e3fn(this.es);
   this.ml0 = this.a * mlfn(this.e0, this.e1, this.e2, this.e3, this.lat0);
 }
};
2432
2433
2434
/* Cassini forward equations--mapping lat,long to x,y
 -----------------------------------------------------------------------*/
exports.forward = function(p) {
2438
 /* Forward equations
     -----------------*/
 var x, y;
 var lam = p.x;
 var phi = p.y;
 lam = adjust_lon(lam - this.long0);
2445
 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
   var sinphi = Math.sin(phi);
   var cosphi = Math.cos(phi);
   var nl = gN(this.a, this.e, sinphi);
   var tl = Math.tan(phi) * Math.tan(phi);
   var al = lam * Math.cos(phi);
   var asq = al * al;
   var cl = this.es * cosphi * cosphi / (1 - this.es);
   var ml = this.a * mlfn(this.e0, this.e1, this.e2, this.e3, phi);
2460
   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);
2463
2464
 }
2466
 p.x = x + this.x0;
 p.y = y + this.y0;
 return p;
};
2471
/* Inverse equations
 -----------------*/
exports.inverse = function(p) {
 p.x -= this.x0;
 p.y -= this.y0;
 var x = p.x / this.a;
 var y = p.y / this.a;
 var phi, lam;
2480
 if (this.sphere) {
   var dd = y + this.lat0;
   phi = Math.asin(Math.sin(dd) * Math.cos(x));
   lam = Math.atan2(Math.tan(x), Math.cos(dd));
 }
 else {
   /* ellipsoid */
   var ml1 = this.ml0 / this.a + y;
   var phi1 = imlfn(ml1, this.e0, this.e1, this.e2, this.e3);
   if (Math.abs(Math.abs(phi1) - HALF_PI) <= EPSLN) {
     p.x = this.long0;
     p.y = HALF_PI;
     if (y < 0) {
       p.y *= -1;
     }
     return p;
   }
   var nl1 = gN(this.a, this.e, Math.sin(phi1));
2499
   var rl1 = nl1 * nl1 * nl1 / this.a / this.a * (1 - this.es);
   var tl1 = Math.pow(Math.tan(phi1), 2);
   var dl = x * this.a / nl1;
   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);
2506
 }
2508
 p.x = adjust_lon(lam + this.long0);
 p.y = adjust_lat(phi);
 return p;
2512
};
exports.names = ["Cassini", "Cassini_Soldner", "cass"];
});
2516
var require$$13 = (cass && typeof cass === 'object' && 'default' in cass ? cass['default'] : cass);
2518
var krovak = createCommonjsModule(function (module, exports) {
var adjust_lon = require$$2;
exports.init = function() {
 this.a = 6377397.155;
 this.es = 0.006674372230614;
 this.e = Math.sqrt(this.es);
 if (!this.lat0) {
   this.lat0 = 0.863937979737193;
 }
 if (!this.long0) {
   this.long0 = 0.7417649320975901 - 0.308341501185665;
 }
 /* if scale not set default to 0.9999 */
 if (!this.k0) {
   this.k0 = 0.9999;
 }
 this.s45 = 0.785398163397448; /* 45 */
 this.s90 = 2 * this.s45;
 this.fi0 = this.lat0;
 this.e2 = this.es;
 this.e = Math.sqrt(this.e2);
 this.alfa = Math.sqrt(1 + (this.e2 * Math.pow(Math.cos(this.fi0), 4)) / (1 - this.e2));
 this.uq = 1.04216856380474;
 this.u0 = Math.asin(Math.sin(this.fi0) / this.alfa);
 this.g = Math.pow((1 + this.e * Math.sin(this.fi0)) / (1 - this.e * Math.sin(this.fi0)), this.alfa * this.e / 2);
 this.k = Math.tan(this.u0 / 2 + this.s45) / Math.pow(Math.tan(this.fi0 / 2 + this.s45), this.alfa) * this.g;
 this.k1 = this.k0;
 this.n0 = this.a * Math.sqrt(1 - this.e2) / (1 - this.e2 * Math.pow(Math.sin(this.fi0), 2));
 this.s0 = 1.37008346281555;
 this.n = Math.sin(this.s0);
 this.ro0 = this.k1 * this.n0 / Math.tan(this.s0);
 this.ad = this.s90 - this.uq;
};
2552
/* ellipsoid */
/* calculate xy from lat/lon */
/* Constants, identical to inverse transform function */
exports.forward = function(p) {
 var gfi, u, deltav, s, d, eps, ro;
 var lon = p.x;
 var lat = p.y;
 var delta_lon = adjust_lon(lon - this.long0);
 /* Transformation */
 gfi = Math.pow(((1 + this.e * Math.sin(lat)) / (1 - this.e * Math.sin(lat))), (this.alfa * this.e / 2));
 u = 2 * (Math.atan(this.k * Math.pow(Math.tan(lat / 2 + this.s45), this.alfa) / gfi) - this.s45);
 deltav = -delta_lon * this.alfa;
 s = Math.asin(Math.cos(this.ad) * Math.sin(u) + Math.sin(this.ad) * Math.cos(u) * Math.cos(deltav));
 d = Math.asin(Math.cos(u) * Math.sin(deltav) / Math.cos(s));
 eps = this.n * d;
 ro = this.ro0 * Math.pow(Math.tan(this.s0 / 2 + this.s45), this.n) / Math.pow(Math.tan(s / 2 + this.s45), this.n);
 p.y = ro * Math.cos(eps) / 1;
 p.x = ro * Math.sin(eps) / 1;
2571
 if (!this.czech) {
   p.y *= -1;
   p.x *= -1;
 }
 return (p);
};
2578
/* calculate lat/lon from xy */
exports.inverse = function(p) {
 var u, deltav, s, d, eps, ro, fi1;
 var ok;
2583
 /* Transformation */
 /* revert y, x*/
 var tmp = p.x;
 p.x = p.y;
 p.y = tmp;
 if (!this.czech) {
   p.y *= -1;
   p.x *= -1;
 }
 ro = Math.sqrt(p.x * p.x + p.y * p.y);
 eps = Math.atan2(p.y, p.x);
 d = eps / Math.sin(this.s0);
 s = 2 * (Math.atan(Math.pow(this.ro0 / ro, 1 / this.n) * Math.tan(this.s0 / 2 + this.s45)) - this.s45);
 u = Math.asin(Math.cos(this.ad) * Math.sin(s) - Math.sin(this.ad) * Math.cos(s) * Math.cos(d));
 deltav = Math.asin(Math.cos(s) * Math.sin(d) / Math.cos(u));
 p.x = this.long0 - deltav / this.alfa;
 fi1 = u;
 ok = 0;
 var iter = 0;
 do {
   p.y = 2 * (Math.atan(Math.pow(this.k, - 1 / this.alfa) * Math.pow(Math.tan(u / 2 + this.s45), 1 / this.alfa) * Math.pow((1 + this.e * Math.sin(fi1)) / (1 - this.e * Math.sin(fi1)), this.e / 2)) - this.s45);
   if (Math.abs(fi1 - p.y) < 0.0000000001) {
     ok = 1;
   }
   fi1 = p.y;
   iter += 1;
 } while (ok === 0 && iter < 15);
 if (iter >= 15) {
   return null;
 }
2614
 return (p);
};
exports.names = ["Krovak", "krovak"];
});
2619
var require$$14 = (krovak && typeof krovak === 'object' && 'default' in krovak ? krovak['default'] : krovak);
2621
var phi2z = createCommonjsModule(function (module) {
var HALF_PI = Math.PI/2;
module.exports = function(eccent, ts) {
 var eccnth = 0.5 * eccent;
 var con, dphi;
 var phi = HALF_PI - 2 * Math.atan(ts);
 for (var i = 0; i <= 15; i++) {
   con = eccent * Math.sin(phi);
   dphi = HALF_PI - 2 * Math.atan(ts * (Math.pow(((1 - con) / (1 + con)), eccnth))) - phi;
   phi += dphi;
   if (Math.abs(dphi) <= 0.0000000001) {
     return phi;
   }
 }
 //console.log("phi2z has NoConvergence");
 return -9999;
};
});
2640
var require$$0$7 = (phi2z && typeof phi2z === 'object' && 'default' in phi2z ? phi2z['default'] : phi2z);
2642
var tsfnz = createCommonjsModule(function (module) {
var HALF_PI = Math.PI/2;
2645
module.exports = function(eccent, phi, sinphi) {
 var con = eccent * sinphi;
 var com = 0.5 * eccent;
 con = Math.pow(((1 - con) / (1 + con)), com);
 return (Math.tan(0.5 * (HALF_PI - phi)) / con);
};
});
2653
var require$$1$5 = (tsfnz && typeof tsfnz === 'object' && 'default' in tsfnz ? tsfnz['default'] : tsfnz);
2655
var lcc = createCommonjsModule(function (module, exports) {
var EPSLN = 1.0e-10;
var msfnz = require$$3$2;
var tsfnz = require$$1$5;
var HALF_PI = Math.PI/2;
var sign = require$$1;
var adjust_lon = require$$2;
var phi2z = require$$0$7;
exports.init = function() {
2665
 // array of:  r_maj,r_min,lat1,lat2,c_lon,c_lat,false_east,false_north
 //double c_lat;                   /* center latitude                      */
 //double c_lon;                   /* center longitude                     */
 //double lat1;                    /* first standard parallel              */
 //double lat2;                    /* second standard parallel             */
 //double r_maj;                   /* major axis                           */
 //double r_min;                   /* minor axis                           */
 //double false_east;              /* x offset in meters                   */
 //double false_north;             /* y offset in meters                   */
2675
 if (!this.lat2) {
   this.lat2 = this.lat1;
 } //if lat2 is not defined
 if (!this.k0) {
   this.k0 = 1;
 }
 this.x0 = this.x0 || 0;
 this.y0 = this.y0 || 0;
 // Standard Parallels cannot be equal and on opposite sides of the equator
 if (Math.abs(this.lat1 + this.lat2) < EPSLN) {
   return;
 }
2688
 var temp = this.b / this.a;
 this.e = Math.sqrt(1 - temp * temp);
2691
 var sin1 = Math.sin(this.lat1);
 var cos1 = Math.cos(this.lat1);
 var ms1 = msfnz(this.e, sin1, cos1);
 var ts1 = tsfnz(this.e, this.lat1, sin1);
2696
 var sin2 = Math.sin(this.lat2);
 var cos2 = Math.cos(this.lat2);
 var ms2 = msfnz(this.e, sin2, cos2);
 var ts2 = tsfnz(this.e, this.lat2, sin2);
2701
 var ts0 = tsfnz(this.e, this.lat0, Math.sin(this.lat0));
2703
 if (Math.abs(this.lat1 - this.lat2) > EPSLN) {
   this.ns = Math.log(ms1 / ms2) / Math.log(ts1 / ts2);
 }
 else {
   this.ns = sin1;
 }
 if (isNaN(this.ns)) {
   this.ns = sin1;
 }
 this.f0 = ms1 / (this.ns * Math.pow(ts1, this.ns));
 this.rh = this.a * this.f0 * Math.pow(ts0, this.ns);
 if (!this.title) {
   this.title = "Lambert Conformal Conic";
 }
};
2719
2720
// Lambert Conformal conic forward equations--mapping lat,long to x,y
// -----------------------------------------------------------------
exports.forward = function(p) {
2724
 var lon = p.x;
 var lat = p.y;
2727
 // singular cases :
 if (Math.abs(2 * Math.abs(lat) - Math.PI) <= EPSLN) {
   lat = sign(lat) * (HALF_PI - 2 * EPSLN);
 }
2732
 var con = Math.abs(Math.abs(lat) - HALF_PI);
 var ts, rh1;
 if (con > EPSLN) {
   ts = tsfnz(this.e, lat, Math.sin(lat));
   rh1 = this.a * this.f0 * Math.pow(ts, this.ns);
 }
 else {
   con = lat * this.ns;
   if (con <= 0) {
     return null;
   }
   rh1 = 0;
 }
 var theta = this.ns * adjust_lon(lon - this.long0);
 p.x = this.k0 * (rh1 * Math.sin(theta)) + this.x0;
 p.y = this.k0 * (this.rh - rh1 * Math.cos(theta)) + this.y0;
2749
 return p;
};
2752
// Lambert Conformal Conic inverse equations--mapping x,y to lat/long
// -----------------------------------------------------------------
exports.inverse = function(p) {
2756
 var rh1, con, ts;
 var lat, lon;
 var x = (p.x - this.x0) / this.k0;
 var y = (this.rh - (p.y - this.y0) / this.k0);
 if (this.ns > 0) {
   rh1 = Math.sqrt(x * x + y * y);
   con = 1;
 }
 else {
   rh1 = -Math.sqrt(x * x + y * y);
   con = -1;
 }
 var theta = 0;
 if (rh1 !== 0) {
   theta = Math.atan2((con * x), (con * y));
 }
 if ((rh1 !== 0) || (this.ns > 0)) {
   con = 1 / this.ns;
   ts = Math.pow((rh1 / (this.a * this.f0)), con);
   lat = phi2z(this.e, ts);
   if (lat === -9999) {
     return null;
   }
 }
 else {
   lat = -HALF_PI;
 }
 lon = adjust_lon(theta / this.ns + this.long0);
2785
 p.x = lon;
 p.y = lat;
 return p;
};
2790
exports.names = ["Lambert Tangential Conformal Conic Projection", "Lambert_Conformal_Conic", "Lambert_Conformal_Conic_2SP", "lcc"];
});
2793
var require$$15 = (lcc && typeof lcc === 'object' && 'default' in lcc ? lcc['default'] : lcc);
2795
var omerc = createCommonjsModule(function (module, exports) {
var tsfnz = require$$1$5;
var adjust_lon = require$$2;
var phi2z = require$$0$7;
var HALF_PI = Math.PI/2;
var FORTPI = Math.PI/4;
var EPSLN = 1.0e-10;
2803
/* Initialize the Oblique Mercator  projection
   ------------------------------------------*/
exports.init = function() {
 this.no_off = this.no_off || false;
 this.no_rot = this.no_rot || false;
2809
 if (isNaN(this.k0)) {
   this.k0 = 1;
 }
 var sinlat = Math.sin(this.lat0);
 var coslat = Math.cos(this.lat0);
 var con = this.e * sinlat;
2816
 this.bl = Math.sqrt(1 + this.es / (1 - this.es) * Math.pow(coslat, 4));
 this.al = this.a * this.bl * this.k0 * Math.sqrt(1 - this.es) / (1 - con * con);
 var t0 = tsfnz(this.e, this.lat0, sinlat);
 var dl = this.bl / coslat * Math.sqrt((1 - this.es) / (1 - con * con));
 if (dl * dl < 1) {
   dl = 1;
 }
 var fl;
 var gl;
 if (!isNaN(this.longc)) {
   //Central point and azimuth method
2828
   if (this.lat0 >= 0) {
     fl = dl + Math.sqrt(dl * dl - 1);
   }
   else {
     fl = dl - Math.sqrt(dl * dl - 1);
   }
   this.el = fl * Math.pow(t0, this.bl);
   gl = 0.5 * (fl - 1 / fl);
   this.gamma0 = Math.asin(Math.sin(this.alpha) / dl);
   this.long0 = this.longc - Math.asin(gl * Math.tan(this.gamma0)) / this.bl;
2839
 }
 else {
   //2 points method
   var t1 = tsfnz(this.e, this.lat1, Math.sin(this.lat1));
   var t2 = tsfnz(this.e, this.lat2, Math.sin(this.lat2));
   if (this.lat0 >= 0) {
     this.el = (dl + Math.sqrt(dl * dl - 1)) * Math.pow(t0, this.bl);
   }
   else {
     this.el = (dl - Math.sqrt(dl * dl - 1)) * Math.pow(t0, this.bl);
   }
   var hl = Math.pow(t1, this.bl);
   var ll = Math.pow(t2, this.bl);
   fl = this.el / hl;
   gl = 0.5 * (fl - 1 / fl);
   var jl = (this.el * this.el - ll * hl) / (this.el * this.el + ll * hl);
   var pl = (ll - hl) / (ll + hl);
   var dlon12 = adjust_lon(this.long1 - this.long2);
   this.long0 = 0.5 * (this.long1 + this.long2) - Math.atan(jl * Math.tan(0.5 * this.bl * (dlon12)) / pl) / this.bl;
   this.long0 = adjust_lon(this.long0);
   var dlon10 = adjust_lon(this.long1 - this.long0);
   this.gamma0 = Math.atan(Math.sin(this.bl * (dlon10)) / gl);
   this.alpha = Math.asin(dl * Math.sin(this.gamma0));
 }
2864
 if (this.no_off) {
   this.uc = 0;
 }
 else {
   if (this.lat0 >= 0) {
     this.uc = this.al / this.bl * Math.atan2(Math.sqrt(dl * dl - 1), Math.cos(this.alpha));
   }
   else {
     this.uc = -1 * this.al / this.bl * Math.atan2(Math.sqrt(dl * dl - 1), Math.cos(this.alpha));
   }
 }
2876
};
2878
2879
/* Oblique Mercator forward equations--mapping lat,long to x,y
   ----------------------------------------------------------*/
exports.forward = function(p) {
 var lon = p.x;
 var lat = p.y;
 var dlon = adjust_lon(lon - this.long0);
 var us, vs;
 var con;
 if (Math.abs(Math.abs(lat) - HALF_PI) <= EPSLN) {
   if (lat > 0) {
     con = -1;
   }
   else {
     con = 1;
   }
   vs = this.al / this.bl * Math.log(Math.tan(FORTPI + con * this.gamma0 * 0.5));
   us = -1 * con * HALF_PI * this.al / this.bl;
 }
 else {
   var t = tsfnz(this.e, lat, Math.sin(lat));
   var ql = this.el / Math.pow(t, this.bl);
   var sl = 0.5 * (ql - 1 / ql);
   var tl = 0.5 * (ql + 1 / ql);
   var vl = Math.sin(this.bl * (dlon));
   var ul = (sl * Math.sin(this.gamma0) - vl * Math.cos(this.gamma0)) / tl;
   if (Math.abs(Math.abs(ul) - 1) <= EPSLN) {
     vs = Number.POSITIVE_INFINITY;
   }
   else {
     vs = 0.5 * this.al * Math.log((1 - ul) / (1 + ul)) / this.bl;
   }
   if (Math.abs(Math.cos(this.bl * (dlon))) <= EPSLN) {
     us = this.al * this.bl * (dlon);
   }
   else {
     us = this.al * Math.atan2(sl * Math.cos(this.gamma0) + vl * Math.sin(this.gamma0), Math.cos(this.bl * dlon)) / this.bl;
   }
 }
2918
 if (this.no_rot) {
   p.x = this.x0 + us;
   p.y = this.y0 + vs;
 }
 else {
2924
   us -= this.uc;
   p.x = this.x0 + vs * Math.cos(this.alpha) + us * Math.sin(this.alpha);
   p.y = this.y0 + us * Math.cos(this.alpha) - vs * Math.sin(this.alpha);
 }
 return p;
};
2931
exports.inverse = function(p) {
 var us, vs;
 if (this.no_rot) {
   vs = p.y - this.y0;
   us = p.x - this.x0;
 }
 else {
   vs = (p.x - this.x0) * Math.cos(this.alpha) - (p.y - this.y0) * Math.sin(this.alpha);
   us = (p.y - this.y0) * Math.cos(this.alpha) + (p.x - this.x0) * Math.sin(this.alpha);
   us += this.uc;
 }
 var qp = Math.exp(-1 * this.bl * vs / this.al);
 var sp = 0.5 * (qp - 1 / qp);
 var tp = 0.5 * (qp + 1 / qp);
 var vp = Math.sin(this.bl * us / this.al);
 var up = (vp * Math.cos(this.gamma0) + sp * Math.sin(this.gamma0)) / tp;
 var ts = Math.pow(this.el / Math.sqrt((1 + up) / (1 - up)), 1 / this.bl);
 if (Math.abs(up - 1) < EPSLN) {
   p.x = this.long0;
   p.y = HALF_PI;
 }
 else if (Math.abs(up + 1) < EPSLN) {
   p.x = this.long0;
   p.y = -1 * HALF_PI;
 }
 else {
   p.y = phi2z(this.e, ts);
   p.x = adjust_lon(this.long0 - Math.atan2(sp * Math.cos(this.gamma0) - vp * Math.sin(this.gamma0), Math.cos(this.bl * us / this.al)) / this.bl);
 }
 return p;
};
2963
exports.names = ["Hotine_Oblique_Mercator", "Hotine Oblique Mercator", "Hotine_Oblique_Mercator_Azimuth_Natural_Origin", "Hotine_Oblique_Mercator_Azimuth_Center", "omerc"];
});
2966
var require$$16 = (omerc && typeof omerc === 'object' && 'default' in omerc ? omerc['default'] : omerc);
2968
var somerc = createCommonjsModule(function (module, exports) {
/*
 references:
   Formules et constantes pour le Calcul pour la
   projection cylindrique conforme à axe oblique et pour la transformation entre
   des systèmes de référence.
   http://www.swisstopo.admin.ch/internet/swisstopo/fr/home/topics/survey/sys/refsys/switzerland.parsysrelated1.31216.downloadList.77004.DownloadFile.tmp/swissprojectionfr.pdf
 */
exports.init = function() {
 var phy0 = this.lat0;
 this.lambda0 = this.long0;
 var sinPhy0 = Math.sin(phy0);
 var semiMajorAxis = this.a;
 var invF = this.rf;
 var flattening = 1 / invF;
 var e2 = 2 * flattening - Math.pow(flattening, 2);
 var e = this.e = Math.sqrt(e2);
 this.R = this.k0 * semiMajorAxis * Math.sqrt(1 - e2) / (1 - e2 * Math.pow(sinPhy0, 2));
 this.alpha = Math.sqrt(1 + e2 / (1 - e2) * Math.pow(Math.cos(phy0), 4));
 this.b0 = Math.asin(sinPhy0 / this.alpha);
 var k1 = Math.log(Math.tan(Math.PI / 4 + this.b0 / 2));
 var k2 = Math.log(Math.tan(Math.PI / 4 + phy0 / 2));
 var k3 = Math.log((1 + e * sinPhy0) / (1 - e * sinPhy0));
 this.K = k1 - this.alpha * k2 + this.alpha * e / 2 * k3;
};
2994
2995
exports.forward = function(p) {
 var Sa1 = Math.log(Math.tan(Math.PI / 4 - p.y / 2));
 var Sa2 = this.e / 2 * Math.log((1 + this.e * Math.sin(p.y)) / (1 - this.e * Math.sin(p.y)));
 var S = -this.alpha * (Sa1 + Sa2) + this.K;
3000
 // spheric latitude
 var b = 2 * (Math.atan(Math.exp(S)) - Math.PI / 4);
3003
 // spheric longitude
 var I = this.alpha * (p.x - this.lambda0);
3006
 // psoeudo equatorial rotation
 var rotI = Math.atan(Math.sin(I) / (Math.sin(this.b0) * Math.tan(b) + Math.cos(this.b0) * Math.cos(I)));
3009
 var rotB = Math.asin(Math.cos(this.b0) * Math.sin(b) - Math.sin(this.b0) * Math.cos(b) * Math.cos(I));
3011
 p.y = this.R / 2 * Math.log((1 + Math.sin(rotB)) / (1 - Math.sin(rotB))) + this.y0;
 p.x = this.R * rotI + this.x0;
 return p;
};
3016
exports.inverse = function(p) {
 var Y = p.x - this.x0;
 var X = p.y - this.y0;
3020
 var rotI = Y / this.R;
 var rotB = 2 * (Math.atan(Math.exp(X / this.R)) - Math.PI / 4);
3023
 var b = Math.asin(Math.cos(this.b0) * Math.sin(rotB) + Math.sin(this.b0) * Math.cos(rotB) * Math.cos(rotI));
 var I = Math.atan(Math.sin(rotI) / (Math.cos(this.b0) * Math.cos(rotI) - Math.sin(this.b0) * Math.tan(rotB)));
3026
 var lambda = this.lambda0 + I / this.alpha;
3028
 var S = 0;
 var phy = b;
 var prevPhy = -1000;
 var iteration = 0;
 while (Math.abs(phy - prevPhy) > 0.0000001) {
   if (++iteration > 20) {
     //...reportError("omercFwdInfinity");
     return;
   }
   //S = Math.log(Math.tan(Math.PI / 4 + phy / 2));
   S = 1 / this.alpha * (Math.log(Math.tan(Math.PI / 4 + b / 2)) - this.K) + this.e * Math.log(Math.tan(Math.PI / 4 + Math.asin(this.e * Math.sin(phy)) / 2));
   prevPhy = phy;
   phy = 2 * Math.atan(Math.exp(S)) - Math.PI / 2;
 }
3043
 p.x = lambda;
 p.y = phy;
 return p;
};
3048
exports.names = ["somerc"];
});
3051
var require$$17 = (somerc && typeof somerc === 'object' && 'default' in somerc ? somerc['default'] : somerc);
3053
var stere = createCommonjsModule(function (module, exports) {
var HALF_PI = Math.PI/2;
var EPSLN = 1.0e-10;
var sign = require$$1;
var msfnz = require$$3$2;
var tsfnz = require$$1$5;
var phi2z = require$$0$7;
var adjust_lon = require$$2;
exports.ssfn_ = function(phit, sinphi, eccen) {
 sinphi *= eccen;
 return (Math.tan(0.5 * (HALF_PI + phit)) * Math.pow((1 - sinphi) / (1 + sinphi), 0.5 * eccen));
};
3066
exports.init = function() {
 this.coslat0 = Math.cos(this.lat0);
 this.sinlat0 = Math.sin(this.lat0);
 if (this.sphere) {
   if (this.k0 === 1 && !isNaN(this.lat_ts) && Math.abs(this.coslat0) <= EPSLN) {
     this.k0 = 0.5 * (1 + sign(this.lat0) * Math.sin(this.lat_ts));
   }
 }
 else {
   if (Math.abs(this.coslat0) <= EPSLN) {
     if (this.lat0 > 0) {
       //North pole
       //trace('stere:north pole');
       this.con = 1;
     }
     else {
       //South pole
       //trace('stere:south pole');
       this.con = -1;
     }
   }
   this.cons = Math.sqrt(Math.pow(1 + this.e, 1 + this.e) * Math.pow(1 - this.e, 1 - this.e));
   if (this.k0 === 1 && !isNaN(this.lat_ts) && Math.abs(this.coslat0) <= EPSLN) {
     this.k0 = 0.5 * this.cons * msfnz(this.e, Math.sin(this.lat_ts), Math.cos(this.lat_ts)) / tsfnz(this.e, this.con * this.lat_ts, this.con * Math.sin(this.lat_ts));
   }
   this.ms1 = msfnz(this.e, this.sinlat0, this.coslat0);
   this.X0 = 2 * Math.atan(this.ssfn_(this.lat0, this.sinlat0, this.e)) - HALF_PI;
   this.cosX0 = Math.cos(this.X0);
   this.sinX0 = Math.sin(this.X0);
 }
};
3098
// Stereographic forward equations--mapping lat,long to x,y
exports.forward = function(p) {
 var lon = p.x;
 var lat = p.y;
 var sinlat = Math.sin(lat);
 var coslat = Math.cos(lat);
 var A, X, sinX, cosX, ts, rh;
 var dlon = adjust_lon(lon - this.long0);
3107
 if (Math.abs(Math.abs(lon - this.long0) - Math.PI) <= EPSLN && Math.abs(lat + this.lat0) <= EPSLN) {
   //case of the origine point
   //trace('stere:this is the origin point');
   p.x = NaN;
   p.y = NaN;
   return p;
 }
 if (this.sphere) {
   //trace('stere:sphere case');
   A = 2 * this.k0 / (1 + this.sinlat0 * sinlat + this.coslat0 * coslat * Math.cos(dlon));
   p.x = this.a * A * coslat * Math.sin(dlon) + this.x0;
   p.y = this.a * A * (this.coslat0 * sinlat - this.sinlat0 * coslat * Math.cos(dlon)) + this.y0;
   return p;
 }
 else {
   X = 2 * Math.atan(this.ssfn_(lat, sinlat, this.e)) - HALF_PI;
   cosX = Math.cos(X);
   sinX = Math.sin(X);
   if (Math.abs(this.coslat0) <= EPSLN) {
     ts = tsfnz(this.e, lat * this.con, this.con * sinlat);
     rh = 2 * this.a * this.k0 * ts / this.cons;
     p.x = this.x0 + rh * Math.sin(lon - this.long0);
     p.y = this.y0 - this.con * rh * Math.cos(lon - this.long0);
     //trace(p.toString());
     return p;
   }
   else if (Math.abs(this.sinlat0) < EPSLN) {
     //Eq
     //trace('stere:equateur');
     A = 2 * this.a * this.k0 / (1 + cosX * Math.cos(dlon));
     p.y = A * sinX;
   }
   else {
     //other case
     //trace('stere:normal case');
     A = 2 * this.a * this.k0 * this.ms1 / (this.cosX0 * (1 + this.sinX0 * sinX + this.cosX0 * cosX * Math.cos(dlon)));
     p.y = A * (this.cosX0 * sinX - this.sinX0 * cosX * Math.cos(dlon)) + this.y0;
   }
   p.x = A * cosX * Math.sin(dlon) + this.x0;
 }
 //trace(p.toString());
 return p;
};
3151
3152
//* Stereographic inverse equations--mapping x,y to lat/long
exports.inverse = function(p) {
 p.x -= this.x0;
 p.y -= this.y0;
 var lon, lat, ts, ce, Chi;
 var rh = Math.sqrt(p.x * p.x + p.y * p.y);
 if (this.sphere) {
   var c = 2 * Math.atan(rh / (0.5 * this.a * this.k0));
   lon = this.long0;
   lat = this.lat0;
   if (rh <= EPSLN) {
     p.x = lon;
     p.y = lat;
     return p;
   }
   lat = Math.asin(Math.cos(c) * this.sinlat0 + p.y * Math.sin(c) * this.coslat0 / rh);
   if (Math.abs(this.coslat0) < EPSLN) {
     if (this.lat0 > 0) {
       lon = adjust_lon(this.long0 + Math.atan2(p.x, - 1 * p.y));
     }
     else {
       lon = adjust_lon(this.long0 + Math.atan2(p.x, p.y));
     }
   }
   else {
     lon = adjust_lon(this.long0 + Math.atan2(p.x * Math.sin(c), rh * this.coslat0 * Math.cos(c) - p.y * this.sinlat0 * Math.sin(c)));
   }
   p.x = lon;
   p.y = lat;
   return p;
 }
 else {
   if (Math.abs(this.coslat0) <= EPSLN) {
     if (rh <= EPSLN) {
       lat = this.lat0;
       lon = this.long0;
       p.x = lon;
       p.y = lat;
       //trace(p.toString());
       return p;
     }
     p.x *= this.con;
     p.y *= this.con;
     ts = rh * this.cons / (2 * this.a * this.k0);
     lat = this.con * phi2z(this.e, ts);
     lon = this.con * adjust_lon(this.con * this.long0 + Math.atan2(p.x, - 1 * p.y));
   }
   else {
     ce = 2 * Math.atan(rh * this.cosX0 / (2 * this.a * this.k0 * this.ms1));
     lon = this.long0;
     if (rh <= EPSLN) {
       Chi = this.X0;
     }
     else {
       Chi = Math.asin(Math.cos(ce) * this.sinX0 + p.y * Math.sin(ce) * this.cosX0 / rh);
       lon = adjust_lon(this.long0 + Math.atan2(p.x * Math.sin(ce), rh * this.cosX0 * Math.cos(ce) - p.y * this.sinX0 * Math.sin(ce)));
     }
     lat = -1 * phi2z(this.e, Math.tan(0.5 * (HALF_PI + Chi)));
   }
 }
 p.x = lon;
 p.y = lat;
3215
 //trace(p.toString());
 return p;
3218
};
exports.names = ["stere", "Stereographic_South_Pole", "Polar Stereographic (variant B)"];
});
3222
var require$$18 = (stere && typeof stere === 'object' && 'default' in stere ? stere['default'] : stere);
3224
var srat = createCommonjsModule(function (module) {
module.exports = function(esinp, exp) {
 return (Math.pow((1 - esinp) / (1 + esinp), exp));
};
});
3230
var require$$0$8 = (srat && typeof srat === 'object' && 'default' in srat ? srat['default'] : srat);
3232
var gauss = createCommonjsModule(function (module, exports) {
var FORTPI = Math.PI/4;
var srat = require$$0$8;
var HALF_PI = Math.PI/2;
var MAX_ITER = 20;
exports.init = function() {
 var sphi = Math.sin(this.lat0);
 var cphi = Math.cos(this.lat0);
 cphi *= cphi;
 this.rc = Math.sqrt(1 - this.es) / (1 - this.es * sphi * sphi);
 this.C = Math.sqrt(1 + this.es * cphi * cphi / (1 - this.es));
 this.phic0 = Math.asin(sphi / this.C);
 this.ratexp = 0.5 * this.C * this.e;
 this.K = Math.tan(0.5 * this.phic0 + FORTPI) / (Math.pow(Math.tan(0.5 * this.lat0 + FORTPI), this.C) * srat(this.e * sphi, this.ratexp));
};
3248
exports.forward = function(p) {
 var lon = p.x;
 var lat = p.y;
3252
 p.y = 2 * Math.atan(this.K * Math.pow(Math.tan(0.5 * lat + FORTPI), this.C) * srat(this.e * Math.sin(lat), this.ratexp)) - HALF_PI;
 p.x = this.C * lon;
 return p;
};
3257
exports.inverse = function(p) {
 var DEL_TOL = 1e-14;
 var lon = p.x / this.C;
 var lat = p.y;
 var num = Math.pow(Math.tan(0.5 * lat + FORTPI) / this.K, 1 / this.C);
 for (var i = MAX_ITER; i > 0; --i) {
   lat = 2 * Math.atan(num * srat(this.e * Math.sin(p.y), - 0.5 * this.e)) - HALF_PI;
   if (Math.abs(lat - p.y) < DEL_TOL) {
     break;
   }
   p.y = lat;
 }
 /* convergence failed */
 if (!i) {
   return null;
 }
 p.x = lon;
 p.y = lat;
 return p;
};
exports.names = ["gauss"];
});
3280
var require$$1$6 = (gauss && typeof gauss === 'object' && 'default' in gauss ? gauss['default'] : gauss);
3282
var sterea = createCommonjsModule(function (module, exports) {
var gauss = require$$1$6;
var adjust_lon = require$$2;
exports.init = function() {
 gauss.init.apply(this);
 if (!this.rc) {
   return;
 }
 this.sinc0 = Math.sin(this.phic0);
 this.cosc0 = Math.cos(this.phic0);
 this.R2 = 2 * this.rc;
 if (!this.title) {
   this.title = "Oblique Stereographic Alternative";
 }
};
3298
exports.forward = function(p) {
 var sinc, cosc, cosl, k;
 p.x = adjust_lon(p.x - this.long0);
 gauss.forward.apply(this, [p]);
 sinc = Math.sin(p.y);
 cosc = Math.cos(p.y);
 cosl = Math.cos(p.x);
 k = this.k0 * this.R2 / (1 + this.sinc0 * sinc + this.cosc0 * cosc * cosl);
 p.x = k * cosc * Math.sin(p.x);
 p.y = k * (this.cosc0 * sinc - this.sinc0 * cosc * cosl);
 p.x = this.a * p.x + this.x0;
 p.y = this.a * p.y + this.y0;
 return p;
};
3313
exports.inverse = function(p) {
 var sinc, cosc, lon, lat, rho;
 p.x = (p.x - this.x0) / this.a;
 p.y = (p.y - this.y0) / this.a;
3318
 p.x /= this.k0;
 p.y /= this.k0;
 if ((rho = Math.sqrt(p.x * p.x + p.y * p.y))) {
   var c = 2 * Math.atan2(rho, this.R2);
   sinc = Math.sin(c);
   cosc = Math.cos(c);
   lat = Math.asin(cosc * this.sinc0 + p.y * sinc * this.cosc0 / rho);
   lon = Math.atan2(p.x * sinc, rho * this.cosc0 * cosc - p.y * this.sinc0 * sinc);
 }
 else {
   lat = this.phic0;
   lon = 0;
 }
3332
 p.x = lon;
 p.y = lat;
 gauss.inverse.apply(this, [p]);
 p.x = adjust_lon(p.x + this.long0);
 return p;
};
3339
exports.names = ["Stereographic_North_Pole", "Oblique_Stereographic", "Polar_Stereographic", "sterea","Oblique Stereographic Alternative"];
});
3342
var require$$19 = (sterea && typeof sterea === 'object' && 'default' in sterea ? sterea['default'] : sterea);
3344
var tmerc = createCommonjsModule(function (module, exports) {
var e0fn = require$$7;
var e1fn = require$$6;
var e2fn = require$$5;
var e3fn = require$$4;
var mlfn = require$$3$1;
var adjust_lon = require$$2;
var HALF_PI = Math.PI/2;
var EPSLN = 1.0e-10;
var sign = require$$1;
var asinz = require$$0$4;
3356
exports.init = function() {
 this.e0 = e0fn(this.es);
 this.e1 = e1fn(this.es);
 this.e2 = e2fn(this.es);
 this.e3 = e3fn(this.es);
 this.ml0 = this.a * mlfn(this.e0, this.e1, this.e2, this.e3, this.lat0);
};
3364
/**
   Transverse Mercator Forward  - long/lat to x/y
   long/lat in radians
 */
exports.forward = function(p) {
 var lon = p.x;
 var lat = p.y;
3372
 var delta_lon = adjust_lon(lon - this.long0);
 var con;
 var x, y;
 var sin_phi = Math.sin(lat);
 var cos_phi = Math.cos(lat);
3378
 if (this.sphere) {
   var b = cos_phi * Math.sin(delta_lon);
   if ((Math.abs(Math.abs(b) - 1)) < 0.0000000001) {
     return (93);
   }
   else {
     x = 0.5 * this.a * this.k0 * Math.log((1 + b) / (1 - b));
     con = Math.acos(cos_phi * Math.cos(delta_lon) / Math.sqrt(1 - b * b));
     if (lat < 0) {
       con = -con;
     }
     y = this.a * this.k0 * (con - this.lat0);
   }
 }
 else {
   var al = cos_phi * delta_lon;
   var als = Math.pow(al, 2);
   var c = this.ep2 * Math.pow(cos_phi, 2);
   var tq = Math.tan(lat);
   var t = Math.pow(tq, 2);
   con = 1 - this.es * Math.pow(sin_phi, 2);
   var n = this.a / Math.sqrt(con);
   var ml = this.a * mlfn(this.e0, this.e1, this.e2, this.e3, lat);
3402
   x = this.k0 * n * al * (1 + als / 6 * (1 - t + c + als / 20 * (5 - 18 * t + Math.pow(t, 2) + 72 * c - 58 * this.ep2))) + this.x0;
   y = this.k0 * (ml - this.ml0 + n * tq * (als * (0.5 + als / 24 * (5 - t + 9 * c + 4 * Math.pow(c, 2) + als / 30 * (61 - 58 * t + Math.pow(t, 2) + 600 * c - 330 * this.ep2))))) + this.y0;
3405
 }
 p.x = x;
 p.y = y;
 return p;
};
3411
/**
   Transverse Mercator Inverse  -  x/y to long/lat
 */
exports.inverse = function(p) {
 var con, phi;
 var delta_phi;
 var i;
 var max_iter = 6;
 var lat, lon;
3421
 if (this.sphere) {
   var f = Math.exp(p.x / (this.a * this.k0));
   var g = 0.5 * (f - 1 / f);
   var temp = this.lat0 + p.y / (this.a * this.k0);
   var h = Math.cos(temp);
   con = Math.sqrt((1 - h * h) / (1 + g * g));
   lat = asinz(con);
   if (temp < 0) {
     lat = -lat;
   }
   if ((g === 0) && (h === 0)) {
     lon = this.long0;
   }
   else {
     lon = adjust_lon(Math.atan2(g, h) + this.long0);
   }
 }
 else { // ellipsoidal form
   var x = p.x - this.x0;
   var y = p.y - this.y0;
3442
   con = (this.ml0 + y / this.k0) / this.a;
   phi = con;
   for (i = 0; true; i++) {
     delta_phi = ((con + this.e1 * Math.sin(2 * phi) - this.e2 * Math.sin(4 * phi) + this.e3 * Math.sin(6 * phi)) / this.e0) - phi;
     phi += delta_phi;
     if (Math.abs(delta_phi) <= EPSLN) {
       break;
     }
     if (i >= max_iter) {
       return (95);
     }
   } // for()
   if (Math.abs(phi) < HALF_PI) {
     var sin_phi = Math.sin(phi);
     var cos_phi = Math.cos(phi);
     var tan_phi = Math.tan(phi);
     var c = this.ep2 * Math.pow(cos_phi, 2);
     var cs = Math.pow(c, 2);
     var t = Math.pow(tan_phi, 2);
     var ts = Math.pow(t, 2);
     con = 1 - this.es * Math.pow(sin_phi, 2);
     var n = this.a / Math.sqrt(con);
     var r = n * (1 - this.es) / con;
     var d = x / (n * this.k0);
     var ds = Math.pow(d, 2);
     lat = phi - (n * tan_phi * ds / r) * (0.5 - ds / 24 * (5 + 3 * t + 10 * c - 4 * cs - 9 * this.ep2 - ds / 30 * (61 + 90 * t + 298 * c + 45 * ts - 252 * this.ep2 - 3 * cs)));
     lon = adjust_lon(this.long0 + (d * (1 - ds / 6 * (1 + 2 * t + c - ds / 20 * (5 - 2 * c + 28 * t - 3 * cs + 8 * this.ep2 + 24 * ts))) / cos_phi));
   }
   else {
     lat = HALF_PI * sign(y);
     lon = this.long0;
   }
 }
 p.x = lon;
 p.y = lat;
 return p;
};
exports.names = ["Transverse_Mercator", "Transverse Mercator", "tmerc"];
});
3482
var require$$0$9 = (tmerc && typeof tmerc === 'object' && 'default' in tmerc ? tmerc['default'] : tmerc);
3484
var utm = createCommonjsModule(function (module, exports) {
var D2R = 0.01745329251994329577;
var tmerc = require$$0$9;
exports.dependsOn = 'tmerc';
exports.init = function() {
 if (!this.zone) {
   return;
 }
 this.lat0 = 0;
 this.long0 = ((6 * Math.abs(this.zone)) - 183) * D2R;
 this.x0 = 500000;
 this.y0 = this.utmSouth ? 10000000 : 0;
 this.k0 = 0.9996;
3498
 tmerc.init.apply(this);
 this.forward = tmerc.forward;
 this.inverse = tmerc.inverse;
};
exports.names = ["Universal Transverse Mercator System", "utm"];
});
3505
var require$$20 = (utm && typeof utm === 'object' && 'default' in utm ? utm['default'] : utm);
3507
var includedProjections = createCommonjsModule(function (module) {
var projs = [
 require$$0$9,
 require$$20,
 require$$19,
 require$$18,
 require$$17,
 require$$16,
 require$$15,
 require$$14,
 require$$13,
 require$$12,
 require$$11,
 require$$10,
 require$$9,
 require$$8,
 require$$7$1,
 require$$6$1,
 require$$5$1,
 require$$4$1,
 require$$3$3,
 require$$2$1,
 require$$1$1,
 require$$0$2
];
module.exports = function(proj4){
 projs.forEach(function(proj){
   proj4.Proj.projections.add(proj);
 });
};
});
3539
var require$$0$1 = (includedProjections && typeof includedProjections === 'object' && 'default' in includedProjections ? includedProjections['default'] : includedProjections);
3541
var name = "proj4";
var version = "2.3.14";
var description = "Proj4js is a JavaScript library to transform point coordinates from one coordinate system to another, including datum transformations.";
var main = "lib/index.js";
var directories = {"test":"test","doc":"docs"};
var scripts = {"test":"./node_modules/istanbul/lib/cli.js test ./node_modules/mocha/bin/_mocha test/test.js"};
var repository = {"type":"git","url":"git://github.com/proj4js/proj4js.git"};
var author = "";
var license = "MIT";
var jam = {"main":"dist/proj4.js","include":["dist/proj4.js","README.md","AUTHORS","LICENSE.md"]};
var devDependencies = {"grunt-cli":"~0.1.13","grunt":"~0.4.2","grunt-contrib-connect":"~0.6.0","grunt-contrib-jshint":"~0.8.0","chai":"~1.8.1","mocha":"~1.17.1","grunt-mocha-phantomjs":"~0.4.0","browserify":"~12.0.1","grunt-browserify":"~4.0.1","grunt-contrib-uglify":"~0.11.1","curl":"git://github.com/cujojs/curl.git","istanbul":"~0.2.4","tin":"~0.4.0"};
var dependencies = {"mgrs":"~0.0.2"};
var contributors = [{"name":"Mike Adair","email":"madair@dmsolutions.ca"},{"name":"Richard Greenwood","email":"rich@greenwoodmap.com"},{"name":"Calvin Metcalf","email":"calvin.metcalf@gmail.com"},{"name":"Richard Marsden","url":"http://www.winwaed.com"},{"name":"T. Mittan"},{"name":"D. Steinwand"},{"name":"S. Nelson"}];
var gitHead = "7619c8a63df1eae5bad0b9ad31ca1d87b0549243";
var bugs = {"url":"https://github.com/proj4js/proj4js/issues"};
var homepage = "https://github.com/proj4js/proj4js#readme";
var _id = "proj4@2.3.14";
var _shasum = "928906144388980c914c5a357fc493aba59a747a";
var _from = "proj4@>=2.3.14 <3.0.0";
var _npmVersion = "2.14.12";
var _nodeVersion = "4.2.6";
var _npmUser = {"name":"ahocevar","email":"andreas.hocevar@gmail.com"};
var dist = {"shasum":"928906144388980c914c5a357fc493aba59a747a","tarball":"https://registry.npmjs.org/proj4/-/proj4-2.3.14.tgz"};
var maintainers = [{"name":"cwmma","email":"calvin.metcalf@gmail.com"},{"name":"ahocevar","email":"andreas.hocevar@gmail.com"}];
var _npmOperationalInternal = {"host":"packages-13-west.internal.npmjs.com","tmp":"tmp/proj4-2.3.14.tgz_1457689264880_0.9409773757215589"};
var _resolved = "https://registry.npmjs.org/proj4/-/proj4-2.3.14.tgz";
var readme = "ERROR: No README data found!";
var require$$1$7 = {
name: name,
version: version,
description: description,
main: main,
directories: directories,
scripts: scripts,
repository: repository,
author: author,
license: license,
jam: jam,
devDependencies: devDependencies,
dependencies: dependencies,
contributors: contributors,
gitHead: gitHead,
bugs: bugs,
homepage: homepage,
_id: _id,
_shasum: _shasum,
_from: _from,
_npmVersion: _npmVersion,
_nodeVersion: _nodeVersion,
_npmUser: _npmUser,
dist: dist,
maintainers: maintainers,
_npmOperationalInternal: _npmOperationalInternal,
_resolved: _resolved,
readme: readme
};
3598
var mgrs = createCommonjsModule(function (module, exports) {
/**
* UTM zones are grouped, and assigned to one of a group of 6
* sets.
*
* {int} @private
*/
var NUM_100K_SETS = 6;
3607
/**
* The column letters (for easting) of the lower left value, per
* set.
*
* {string} @private
*/
var SET_ORIGIN_COLUMN_LETTERS = 'AJSAJS';
3615
/**
* The row letters (for northing) of the lower left value, per
* set.
*
* {string} @private
*/
var SET_ORIGIN_ROW_LETTERS = 'AFAFAF';
3623
var A = 65; // A
var I = 73; // I
var O = 79; // O
var V = 86; // V
var Z = 90; // Z
3629
/**
* Conversion of lat/lon to MGRS.
*
* @param {object} ll Object literal with lat and lon properties on a
*     WGS84 ellipsoid.
* @param {int} accuracy Accuracy in digits (5 for 1 m, 4 for 10 m, 3 for
*      100 m, 2 for 1000 m or 1 for 10000 m). Optional, default is 5.
* @return {string} the MGRS string for the given location and accuracy.
*/
exports.forward = function(ll, accuracy) {
 accuracy = accuracy || 5; // default accuracy 1m
 return encode(LLtoUTM({
   lat: ll[1],
   lon: ll[0]
 }), accuracy);
};
3646
/**
* Conversion of MGRS to lat/lon.
*
* @param {string} mgrs MGRS string.
* @return {array} An array with left (longitude), bottom (latitude), right
*     (longitude) and top (latitude) values in WGS84, representing the
*     bounding box for the provided MGRS reference.
*/
exports.inverse = function(mgrs) {
 var bbox = UTMtoLL(decode(mgrs.toUpperCase()));
 if (bbox.lat && bbox.lon) {
   return [bbox.lon, bbox.lat, bbox.lon, bbox.lat];
 }
 return [bbox.left, bbox.bottom, bbox.right, bbox.top];
};
3662
exports.toPoint = function(mgrs) {
 var bbox = UTMtoLL(decode(mgrs.toUpperCase()));
 if (bbox.lat && bbox.lon) {
   return [bbox.lon, bbox.lat];
 }
 return [(bbox.left + bbox.right) / 2, (bbox.top + bbox.bottom) / 2];
};
/**
* Conversion from degrees to radians.
*
* @private
* @param {number} deg the angle in degrees.
* @return {number} the angle in radians.
*/
function degToRad(deg) {
 return (deg * (Math.PI / 180.0));
}
3680
/**
* Conversion from radians to degrees.
*
* @private
* @param {number} rad the angle in radians.
* @return {number} the angle in degrees.
*/
function radToDeg(rad) {
 return (180.0 * (rad / Math.PI));
}
3691
/**
* Converts a set of Longitude and Latitude co-ordinates to UTM
* using the WGS84 ellipsoid.
*
* @private
* @param {object} ll Object literal with lat and lon properties
*     representing the WGS84 coordinate to be converted.
* @return {object} Object literal containing the UTM value with easting,
*     northing, zoneNumber and zoneLetter properties, and an optional
*     accuracy property in digits. Returns null if the conversion failed.
*/
function LLtoUTM(ll) {
 var Lat = ll.lat;
 var Long = ll.lon;
 var a = 6378137.0; //ellip.radius;
 var eccSquared = 0.00669438; //ellip.eccsq;
 var k0 = 0.9996;
 var LongOrigin;
 var eccPrimeSquared;
 var N, T, C, A, M;
 var LatRad = degToRad(Lat);
 var LongRad = degToRad(Long);
 var LongOriginRad;
 var ZoneNumber;
 // (int)
 ZoneNumber = Math.floor((Long + 180) / 6) + 1;
3718
 //Make sure the longitude 180.00 is in Zone 60
 if (Long === 180) {
   ZoneNumber = 60;
 }
3723
 // Special zone for Norway
 if (Lat >= 56.0 && Lat < 64.0 && Long >= 3.0 && Long < 12.0) {
   ZoneNumber = 32;
 }
3728
 // Special zones for Svalbard
 if (Lat >= 72.0 && Lat < 84.0) {
   if (Long >= 0.0 && Long < 9.0) {
     ZoneNumber = 31;
   }
   else if (Long >= 9.0 && Long < 21.0) {
     ZoneNumber = 33;
   }
   else if (Long >= 21.0 && Long < 33.0) {
     ZoneNumber = 35;
   }
   else if (Long >= 33.0 && Long < 42.0) {
     ZoneNumber = 37;
   }
 }
3744
 LongOrigin = (ZoneNumber - 1) * 6 - 180 + 3; //+3 puts origin
 // in middle of
 // zone
 LongOriginRad = degToRad(LongOrigin);
3749
 eccPrimeSquared = (eccSquared) / (1 - eccSquared);
3751
 N = a / Math.sqrt(1 - eccSquared * Math.sin(LatRad) * Math.sin(LatRad));
 T = Math.tan(LatRad) * Math.tan(LatRad);
 C = eccPrimeSquared * Math.cos(LatRad) * Math.cos(LatRad);
 A = Math.cos(LatRad) * (LongRad - LongOriginRad);
3756
 M = a * ((1 - eccSquared / 4 - 3 * eccSquared * eccSquared / 64 - 5 * eccSquared * eccSquared * eccSquared / 256) * LatRad - (3 * eccSquared / 8 + 3 * eccSquared * eccSquared / 32 + 45 * eccSquared * eccSquared * eccSquared / 1024) * Math.sin(2 * LatRad) + (15 * eccSquared * eccSquared / 256 + 45 * eccSquared * eccSquared * eccSquared / 1024) * Math.sin(4 * LatRad) - (35 * eccSquared * eccSquared * eccSquared / 3072) * Math.sin(6 * LatRad));
3758
 var UTMEasting = (k0 * N * (A + (1 - T + C) * A * A * A / 6.0 + (5 - 18 * T + T * T + 72 * C - 58 * eccPrimeSquared) * A * A * A * A * A / 120.0) + 500000.0);
3760
 var UTMNorthing = (k0 * (M + N * Math.tan(LatRad) * (A * A / 2 + (5 - T + 9 * C + 4 * C * C) * A * A * A * A / 24.0 + (61 - 58 * T + T * T + 600 * C - 330 * eccPrimeSquared) * A * A * A * A * A * A / 720.0)));
 if (Lat < 0.0) {
   UTMNorthing += 10000000.0; //10000000 meter offset for
   // southern hemisphere
 }
3766
 return {
   northing: Math.round(UTMNorthing),
   easting: Math.round(UTMEasting),
   zoneNumber: ZoneNumber,
   zoneLetter: getLetterDesignator(Lat)
 };
}
3774
/**
* Converts UTM coords to lat/long, using the WGS84 ellipsoid. This is a convenience
* class where the Zone can be specified as a single string eg."60N" which
* is then broken down into the ZoneNumber and ZoneLetter.
*
* @private
* @param {object} utm An object literal with northing, easting, zoneNumber
*     and zoneLetter properties. If an optional accuracy property is
*     provided (in meters), a bounding box will be returned instead of
*     latitude and longitude.
* @return {object} An object literal containing either lat and lon values
*     (if no accuracy was provided), or top, right, bottom and left values
*     for the bounding box calculated according to the provided accuracy.
*     Returns null if the conversion failed.
*/
function UTMtoLL(utm) {
3791
 var UTMNorthing = utm.northing;
 var UTMEasting = utm.easting;
 var zoneLetter = utm.zoneLetter;
 var zoneNumber = utm.zoneNumber;
 // check the ZoneNummber is valid
 if (zoneNumber < 0 || zoneNumber > 60) {
   return null;
 }
3800
 var k0 = 0.9996;
 var a = 6378137.0; //ellip.radius;
 var eccSquared = 0.00669438; //ellip.eccsq;
 var eccPrimeSquared;
 var e1 = (1 - Math.sqrt(1 - eccSquared)) / (1 + Math.sqrt(1 - eccSquared));
 var N1, T1, C1, R1, D, M;
 var LongOrigin;
 var mu, phi1Rad;
3809
 // remove 500,000 meter offset for longitude
 var x = UTMEasting - 500000.0;
 var y = UTMNorthing;
3813
 // We must know somehow if we are in the Northern or Southern
 // hemisphere, this is the only time we use the letter So even
 // if the Zone letter isn't exactly correct it should indicate
 // the hemisphere correctly
 if (zoneLetter < 'N') {
   y -= 10000000.0; // remove 10,000,000 meter offset used
   // for southern hemisphere
 }
3822
 // There are 60 zones with zone 1 being at West -180 to -174
 LongOrigin = (zoneNumber - 1) * 6 - 180 + 3; // +3 puts origin
 // in middle of
 // zone
3827
 eccPrimeSquared = (eccSquared) / (1 - eccSquared);
3829
 M = y / k0;
 mu = M / (a * (1 - eccSquared / 4 - 3 * eccSquared * eccSquared / 64 - 5 * eccSquared * eccSquared * eccSquared / 256));
3832
 phi1Rad = mu + (3 * e1 / 2 - 27 * e1 * e1 * e1 / 32) * Math.sin(2 * mu) + (21 * e1 * e1 / 16 - 55 * e1 * e1 * e1 * e1 / 32) * Math.sin(4 * mu) + (151 * e1 * e1 * e1 / 96) * Math.sin(6 * mu);
 // double phi1 = ProjMath.radToDeg(phi1Rad);
3835
 N1 = a / Math.sqrt(1 - eccSquared * Math.sin(phi1Rad) * Math.sin(phi1Rad));
 T1 = Math.tan(phi1Rad) * Math.tan(phi1Rad);
 C1 = eccPrimeSquared * Math.cos(phi1Rad) * Math.cos(phi1Rad);
 R1 = a * (1 - eccSquared) / Math.pow(1 - eccSquared * Math.sin(phi1Rad) * Math.sin(phi1Rad), 1.5);
 D = x / (N1 * k0);
3841
 var lat = phi1Rad - (N1 * Math.tan(phi1Rad) / R1) * (D * D / 2 - (5 + 3 * T1 + 10 * C1 - 4 * C1 * C1 - 9 * eccPrimeSquared) * D * D * D * D / 24 + (61 + 90 * T1 + 298 * C1 + 45 * T1 * T1 - 252 * eccPrimeSquared - 3 * C1 * C1) * D * D * D * D * D * D / 720);
 lat = radToDeg(lat);
3844
 var lon = (D - (1 + 2 * T1 + C1) * D * D * D / 6 + (5 - 2 * C1 + 28 * T1 - 3 * C1 * C1 + 8 * eccPrimeSquared + 24 * T1 * T1) * D * D * D * D * D / 120) / Math.cos(phi1Rad);
 lon = LongOrigin + radToDeg(lon);
3847
 var result;
 if (utm.accuracy) {
   var topRight = UTMtoLL({
     northing: utm.northing + utm.accuracy,
     easting: utm.easting + utm.accuracy,
     zoneLetter: utm.zoneLetter,
     zoneNumber: utm.zoneNumber
   });
   result = {
     top: topRight.lat,
     right: topRight.lon,
     bottom: lat,
     left: lon
   };
 }
 else {
   result = {
     lat: lat,
     lon: lon
   };
 }
 return result;
}
3871
/**
* Calculates the MGRS letter designator for the given latitude.
*
* @private
* @param {number} lat The latitude in WGS84 to get the letter designator
*     for.
* @return {char} The letter designator.
*/
function getLetterDesignator(lat) {
 //This is here as an error flag to show that the Latitude is
 //outside MGRS limits
 var LetterDesignator = 'Z';
3884
 if ((84 >= lat) && (lat >= 72)) {
   LetterDesignator = 'X';
 }
 else if ((72 > lat) && (lat >= 64)) {
   LetterDesignator = 'W';
 }
 else if ((64 > lat) && (lat >= 56)) {
   LetterDesignator = 'V';
 }
 else if ((56 > lat) && (lat >= 48)) {
   LetterDesignator = 'U';
 }
 else if ((48 > lat) && (lat >= 40)) {
   LetterDesignator = 'T';
 }
 else if ((40 > lat) && (lat >= 32)) {
   LetterDesignator = 'S';
 }
 else if ((32 > lat) && (lat >= 24)) {
   LetterDesignator = 'R';
 }
 else if ((24 > lat) && (lat >= 16)) {
   LetterDesignator = 'Q';
 }
 else if ((16 > lat) && (lat >= 8)) {
   LetterDesignator = 'P';
 }
 else if ((8 > lat) && (lat >= 0)) {
   LetterDesignator = 'N';
 }
 else if ((0 > lat) && (lat >= -8)) {
   LetterDesignator = 'M';
 }
 else if ((-8 > lat) && (lat >= -16)) {
   LetterDesignator = 'L';
 }
 else if ((-16 > lat) && (lat >= -24)) {
   LetterDesignator = 'K';
 }
 else if ((-24 > lat) && (lat >= -32)) {
   LetterDesignator = 'J';
 }
 else if ((-32 > lat) && (lat >= -40)) {
   LetterDesignator = 'H';
 }
 else if ((-40 > lat) && (lat >= -48)) {
   LetterDesignator = 'G';
 }
 else if ((-48 > lat) && (lat >= -56)) {
   LetterDesignator = 'F';
 }
 else if ((-56 > lat) && (lat >= -64)) {
   LetterDesignator = 'E';
 }
 else if ((-64 > lat) && (lat >= -72)) {
   LetterDesignator = 'D';
 }
 else if ((-72 > lat) && (lat >= -80)) {
   LetterDesignator = 'C';
 }
 return LetterDesignator;
}
3947
/**
* Encodes a UTM location as MGRS string.
*
* @private
* @param {object} utm An object literal with easting, northing,
*     zoneLetter, zoneNumber
* @param {number} accuracy Accuracy in digits (1-5).
* @return {string} MGRS string for the given UTM location.
*/
function encode(utm, accuracy) {
 // prepend with leading zeroes
 var seasting = "00000" + utm.easting,
   snorthing = "00000" + utm.northing;
3961
 return utm.zoneNumber + utm.zoneLetter + get100kID(utm.easting, utm.northing, utm.zoneNumber) + seasting.substr(seasting.length - 5, accuracy) + snorthing.substr(snorthing.length - 5, accuracy);
}
3964
/**
* Get the two letter 100k designator for a given UTM easting,
* northing and zone number value.
*
* @private
* @param {number} easting
* @param {number} northing
* @param {number} zoneNumber
* @return the two letter 100k designator for the given UTM location.
*/
function get100kID(easting, northing, zoneNumber) {
 var setParm = get100kSetForZone(zoneNumber);
 var setColumn = Math.floor(easting / 100000);
 var setRow = Math.floor(northing / 100000) % 20;
 return getLetter100kID(setColumn, setRow, setParm);
}
3981
/**
* Given a UTM zone number, figure out the MGRS 100K set it is in.
*
* @private
* @param {number} i An UTM zone number.
* @return {number} the 100k set the UTM zone is in.
*/
function get100kSetForZone(i) {
 var setParm = i % NUM_100K_SETS;
 if (setParm === 0) {
   setParm = NUM_100K_SETS;
 }
3994
 return setParm;
}
3997
/**
* Get the two-letter MGRS 100k designator given information
* translated from the UTM northing, easting and zone number.
*
* @private
* @param {number} column the column index as it relates to the MGRS
*        100k set spreadsheet, created from the UTM easting.
*        Values are 1-8.
* @param {number} row the row index as it relates to the MGRS 100k set
*        spreadsheet, created from the UTM northing value. Values
*        are from 0-19.
* @param {number} parm the set block, as it relates to the MGRS 100k set
*        spreadsheet, created from the UTM zone. Values are from
*        1-60.
* @return two letter MGRS 100k code.
*/
function getLetter100kID(column, row, parm) {
 // colOrigin and rowOrigin are the letters at the origin of the set
 var index = parm - 1;
 var colOrigin = SET_ORIGIN_COLUMN_LETTERS.charCodeAt(index);
 var rowOrigin = SET_ORIGIN_ROW_LETTERS.charCodeAt(index);
4019
 // colInt and rowInt are the letters to build to return
 var colInt = colOrigin + column - 1;
 var rowInt = rowOrigin + row;
 var rollover = false;
4024
 if (colInt > Z) {
   colInt = colInt - Z + A - 1;
   rollover = true;
 }
4029
 if (colInt === I || (colOrigin < I && colInt > I) || ((colInt > I || colOrigin < I) && rollover)) {
   colInt++;
 }
4033
 if (colInt === O || (colOrigin < O && colInt > O) || ((colInt > O || colOrigin < O) && rollover)) {
   colInt++;
4036
   if (colInt === I) {
     colInt++;
   }
 }
4041
 if (colInt > Z) {
   colInt = colInt - Z + A - 1;
 }
4045
 if (rowInt > V) {
   rowInt = rowInt - V + A - 1;
   rollover = true;
 }
 else {
   rollover = false;
 }
4053
 if (((rowInt === I) || ((rowOrigin < I) && (rowInt > I))) || (((rowInt > I) || (rowOrigin < I)) && rollover)) {
   rowInt++;
 }
4057
 if (((rowInt === O) || ((rowOrigin < O) && (rowInt > O))) || (((rowInt > O) || (rowOrigin < O)) && rollover)) {
   rowInt++;
4060
   if (rowInt === I) {
     rowInt++;
   }
 }
4065
 if (rowInt > V) {
   rowInt = rowInt - V + A - 1;
 }
4069
 var twoLetter = String.fromCharCode(colInt) + String.fromCharCode(rowInt);
 return twoLetter;
}
4073
/**
* Decode the UTM parameters from a MGRS string.
*
* @private
* @param {string} mgrsString an UPPERCASE coordinate string is expected.
* @return {object} An object literal with easting, northing, zoneLetter,
*     zoneNumber and accuracy (in meters) properties.
*/
function decode(mgrsString) {
4083
 if (mgrsString && mgrsString.length === 0) {
   throw ("MGRSPoint coverting from nothing");
 }
4087
 var length = mgrsString.length;
4089
 var hunK = null;
 var sb = "";
 var testChar;
 var i = 0;
4094
 // get Zone number
 while (!(/[A-Z]/).test(testChar = mgrsString.charAt(i))) {
   if (i >= 2) {
     throw ("MGRSPoint bad conversion from: " + mgrsString);
   }
   sb += testChar;
   i++;
 }
4103
 var zoneNumber = parseInt(sb, 10);
4105
 if (i === 0 || i + 3 > length) {
   // A good MGRS string has to be 4-5 digits long,
   // ##AAA/#AAA at least.
   throw ("MGRSPoint bad conversion from: " + mgrsString);
 }
4111
 var zoneLetter = mgrsString.charAt(i++);
4113
 // Should we check the zone letter here? Why not.
 if (zoneLetter <= 'A' || zoneLetter === 'B' || zoneLetter === 'Y' || zoneLetter >= 'Z' || zoneLetter === 'I' || zoneLetter === 'O') {
   throw ("MGRSPoint zone letter " + zoneLetter + " not handled: " + mgrsString);
 }
4118
 hunK = mgrsString.substring(i, i += 2);
4120
 var set = get100kSetForZone(zoneNumber);
4122
 var east100k = getEastingFromChar(hunK.charAt(0), set);
 var north100k = getNorthingFromChar(hunK.charAt(1), set);
4125
 // We have a bug where the northing may be 2000000 too low.
 // How
 // do we know when to roll over?
4129
 while (north100k < getMinNorthing(zoneLetter)) {
   north100k += 2000000;
 }
4133
 // calculate the char index for easting/northing separator
 var remainder = length - i;
4136
 if (remainder % 2 !== 0) {
   throw ("MGRSPoint has to have an even number \nof digits after the zone letter and two 100km letters - front \nhalf for easting meters, second half for \nnorthing meters" + mgrsString);
 }
4140
 var sep = remainder / 2;
4142
 var sepEasting = 0.0;
 var sepNorthing = 0.0;
 var accuracyBonus, sepEastingString, sepNorthingString, easting, northing;
 if (sep > 0) {
   accuracyBonus = 100000.0 / Math.pow(10, sep);
   sepEastingString = mgrsString.substring(i, i + sep);
   sepEasting = parseFloat(sepEastingString) * accuracyBonus;
   sepNorthingString = mgrsString.substring(i + sep);
   sepNorthing = parseFloat(sepNorthingString) * accuracyBonus;
 }
4153
 easting = sepEasting + east100k;
 northing = sepNorthing + north100k;
4156
 return {
   easting: easting,
   northing: northing,
   zoneLetter: zoneLetter,
   zoneNumber: zoneNumber,
   accuracy: accuracyBonus
 };
}
4165
/**
* Given the first letter from a two-letter MGRS 100k zone, and given the
* MGRS table set for the zone number, figure out the easting value that
* should be added to the other, secondary easting value.
*
* @private
* @param {char} e The first letter from a two-letter MGRS 100´k zone.
* @param {number} set The MGRS table set for the zone number.
* @return {number} The easting value for the given letter and set.
*/
function getEastingFromChar(e, set) {
 // colOrigin is the letter at the origin of the set for the
 // column
 var curCol = SET_ORIGIN_COLUMN_LETTERS.charCodeAt(set - 1);
 var eastingValue = 100000.0;
 var rewindMarker = false;
4182
 while (curCol !== e.charCodeAt(0)) {
   curCol++;
   if (curCol === I) {
     curCol++;
   }
   if (curCol === O) {
     curCol++;
   }
   if (curCol > Z) {
     if (rewindMarker) {
       throw ("Bad character: " + e);
     }
     curCol = A;
     rewindMarker = true;
   }
   eastingValue += 100000.0;
 }
4200
 return eastingValue;
}
4203
/**
* Given the second letter from a two-letter MGRS 100k zone, and given the
* MGRS table set for the zone number, figure out the northing value that
* should be added to the other, secondary northing value. You have to
* remember that Northings are determined from the equator, and the vertical
* cycle of letters mean a 2000000 additional northing meters. This happens
* approx. every 18 degrees of latitude. This method does *NOT* count any
* additional northings. You have to figure out how many 2000000 meters need
* to be added for the zone letter of the MGRS coordinate.
*
* @private
* @param {char} n Second letter of the MGRS 100k zone
* @param {number} set The MGRS table set number, which is dependent on the
*     UTM zone number.
* @return {number} The northing value for the given letter and set.
*/
function getNorthingFromChar(n, set) {
4221
 if (n > 'V') {
   throw ("MGRSPoint given invalid Northing " + n);
 }
4225
 // rowOrigin is the letter at the origin of the set for the
 // column
 var curRow = SET_ORIGIN_ROW_LETTERS.charCodeAt(set - 1);
 var northingValue = 0.0;
 var rewindMarker = false;
4231
 while (curRow !== n.charCodeAt(0)) {
   curRow++;
   if (curRow === I) {
     curRow++;
   }
   if (curRow === O) {
     curRow++;
   }
   // fixing a bug making whole application hang in this loop
   // when 'n' is a wrong character
   if (curRow > V) {
     if (rewindMarker) { // making sure that this loop ends
       throw ("Bad character: " + n);
     }
     curRow = A;
     rewindMarker = true;
   }
   northingValue += 100000.0;
 }
4251
 return northingValue;
}
4254
/**
* The function getMinNorthing returns the minimum northing value of a MGRS
* zone.
*
* Ported from Geotrans' c Lattitude_Band_Value structure table.
*
* @private
* @param {char} zoneLetter The MGRS zone to get the min northing for.
* @return {number}
*/
function getMinNorthing(zoneLetter) {
 var northing;
 switch (zoneLetter) {
 case 'C':
   northing = 1100000.0;
   break;
 case 'D':
   northing = 2000000.0;
   break;
 case 'E':
   northing = 2800000.0;
   break;
 case 'F':
   northing = 3700000.0;
   break;
 case 'G':
   northing = 4600000.0;
   break;
 case 'H':
   northing = 5500000.0;
   break;
 case 'J':
   northing = 6400000.0;
   break;
 case 'K':
   northing = 7300000.0;
   break;
 case 'L':
   northing = 8200000.0;
   break;
 case 'M':
   northing = 9100000.0;
   break;
 case 'N':
   northing = 0.0;
   break;
 case 'P':
   northing = 800000.0;
   break;
 case 'Q':
   northing = 1700000.0;
   break;
 case 'R':
   northing = 2600000.0;
   break;
 case 'S':
   northing = 3500000.0;
   break;
 case 'T':
   northing = 4400000.0;
   break;
 case 'U':
   northing = 5300000.0;
   break;
 case 'V':
   northing = 6200000.0;
   break;
 case 'W':
   northing = 7000000.0;
   break;
 case 'X':
   northing = 7900000.0;
   break;
 default:
   northing = -1.0;
 }
 if (northing >= 0.0) {
   return northing;
 }
 else {
   throw ("Invalid zone letter: " + zoneLetter);
 }
4337
}
});
4340
var require$$0$10 = (mgrs && typeof mgrs === 'object' && 'default' in mgrs ? mgrs['default'] : mgrs);
4342
var toPoint$1 = createCommonjsModule(function (module) {
module.exports = function (array){
 var out = {
   x: array[0],
   y: array[1]
 };
 if (array.length>2) {
   out.z = array[2];
 }
 if (array.length>3) {
   out.m = array[3];
 }
 return out;
};
});
4358
var require$$0$12 = (toPoint$1 && typeof toPoint$1 === 'object' && 'default' in toPoint$1 ? toPoint$1['default'] : toPoint$1);
4360
var datum = createCommonjsModule(function (module) {
var HALF_PI = Math.PI/2;
var PJD_3PARAM = 1;
var PJD_7PARAM = 2;
var PJD_GRIDSHIFT = 3;
var PJD_WGS84 = 4; // WGS84 or equivalent
var PJD_NODATUM = 5; // WGS84 or equivalent
var SEC_TO_RAD = 4.84813681109535993589914102357e-6;
var AD_C = 1.0026000;
var COS_67P5 = 0.38268343236508977;
var datum = function(proj) {
 if (!(this instanceof datum)) {
   return new datum(proj);
 }
 this.datum_type = PJD_WGS84; //default setting
 if (!proj) {
   return;
 }
 if (proj.datumCode && proj.datumCode === 'none') {
   this.datum_type = PJD_NODATUM;
 }
4382
 if (proj.datum_params) {
   this.datum_params = proj.datum_params.map(parseFloat);
   if (this.datum_params[0] !== 0 || this.datum_params[1] !== 0 || this.datum_params[2] !== 0) {
     this.datum_type = PJD_3PARAM;
   }
   if (this.datum_params.length > 3) {
     if (this.datum_params[3] !== 0 || this.datum_params[4] !== 0 || this.datum_params[5] !== 0 || this.datum_params[6] !== 0) {
       this.datum_type = PJD_7PARAM;
       this.datum_params[3] *= SEC_TO_RAD;
       this.datum_params[4] *= SEC_TO_RAD;
       this.datum_params[5] *= SEC_TO_RAD;
       this.datum_params[6] = (this.datum_params[6] / 1000000.0) + 1.0;
     }
   }
 }
4398
 // DGR 2011-03-21 : nadgrids support
 this.datum_type = proj.grids ? PJD_GRIDSHIFT : this.datum_type;
4401
 this.a = proj.a; //datum object also uses these values
 this.b = proj.b;
 this.es = proj.es;
 this.ep2 = proj.ep2;
 if (this.datum_type === PJD_GRIDSHIFT) {
   this.grids = proj.grids;
 }
};
datum.prototype = {
4411
4412
 /****************************************************************/
 // cs_compare_datums()
 //   Returns TRUE if the two datums match, otherwise FALSE.
 compare_datums: function(dest) {
   if (this.datum_type !== dest.datum_type) {
     return false; // false, datums are not equal
   }
   else if (this.a !== dest.a || Math.abs(this.es - dest.es) > 0.000000000050) {
     // the tolerence for es is to ensure that GRS80 and WGS84
     // are considered identical
     return false;
   }
   else if (this.datum_type === PJD_3PARAM) {
     return (this.datum_params[0] === dest.datum_params[0] && this.datum_params[1] === dest.datum_params[1] && this.datum_params[2] === dest.datum_params[2]);
   }
   else if (this.datum_type === PJD_7PARAM) {
     return (this.datum_params[0] === dest.datum_params[0] && this.datum_params[1] === dest.datum_params[1] && this.datum_params[2] === dest.datum_params[2] && this.datum_params[3] === dest.datum_params[3] && this.datum_params[4] === dest.datum_params[4] && this.datum_params[5] === dest.datum_params[5] && this.datum_params[6] === dest.datum_params[6]);
   }
   else if (this.datum_type === PJD_GRIDSHIFT || dest.datum_type === PJD_GRIDSHIFT) {
     //alert("ERROR: Grid shift transformations are not implemented.");
     //return false
     //DGR 2012-07-29 lazy ...
     return this.nadgrids === dest.nadgrids;
   }
   else {
     return true; // datums are equal
   }
 }, // cs_compare_datums()
4441
 /*
  * The function Convert_Geodetic_To_Geocentric converts geodetic coordinates
  * (latitude, longitude, and height) to geocentric coordinates (X, Y, Z),
  * according to the current ellipsoid parameters.
  *
  *    Latitude  : Geodetic latitude in radians                     (input)
  *    Longitude : Geodetic longitude in radians                    (input)
  *    Height    : Geodetic height, in meters                       (input)
  *    X         : Calculated Geocentric X coordinate, in meters    (output)
  *    Y         : Calculated Geocentric Y coordinate, in meters    (output)
  *    Z         : Calculated Geocentric Z coordinate, in meters    (output)
  *
  */
 geodetic_to_geocentric: function(p) {
   var Longitude = p.x;
   var Latitude = p.y;
   var Height = p.z ? p.z : 0; //Z value not always supplied
   var X; // output
   var Y;
   var Z;
4462
   var Error_Code = 0; //  GEOCENT_NO_ERROR;
   var Rn; /*  Earth radius at location  */
   var Sin_Lat; /*  Math.sin(Latitude)  */
   var Sin2_Lat; /*  Square of Math.sin(Latitude)  */
   var Cos_Lat; /*  Math.cos(Latitude)  */
4468
   /*
    ** Don't blow up if Latitude is just a little out of the value
    ** range as it may just be a rounding issue.  Also removed longitude
    ** test, it should be wrapped by Math.cos() and Math.sin().  NFW for PROJ.4, Sep/2001.
    */
   if (Latitude < -HALF_PI && Latitude > -1.001 * HALF_PI) {
     Latitude = -HALF_PI;
   }
   else if (Latitude > HALF_PI && Latitude < 1.001 * HALF_PI) {
     Latitude = HALF_PI;
   }
   else if ((Latitude < -HALF_PI) || (Latitude > HALF_PI)) {
     /* Latitude out of range */
     //..reportError('geocent:lat out of range:' + Latitude);
     return null;
   }
4485
   if (Longitude > Math.PI) {
     Longitude -= (2 * Math.PI);
   }
   Sin_Lat = Math.sin(Latitude);
   Cos_Lat = Math.cos(Latitude);
   Sin2_Lat = Sin_Lat * Sin_Lat;
   Rn = this.a / (Math.sqrt(1.0e0 - this.es * Sin2_Lat));
   X = (Rn + Height) * Cos_Lat * Math.cos(Longitude);
   Y = (Rn + Height) * Cos_Lat * Math.sin(Longitude);
   Z = ((Rn * (1 - this.es)) + Height) * Sin_Lat;
4496
   p.x = X;
   p.y = Y;
   p.z = Z;
   return Error_Code;
 }, // cs_geodetic_to_geocentric()
4502
4503
 geocentric_to_geodetic: function(p) {
   /* local defintions and variables */
   /* end-criterium of loop, accuracy of sin(Latitude) */
   var genau = 1e-12;
   var genau2 = (genau * genau);
   var maxiter = 30;
4510
   var P; /* distance between semi-minor axis and location */
   var RR; /* distance between center and location */
   var CT; /* sin of geocentric latitude */
   var ST; /* cos of geocentric latitude */
   var RX;
   var RK;
   var RN; /* Earth radius at location */
   var CPHI0; /* cos of start or old geodetic latitude in iterations */
   var SPHI0; /* sin of start or old geodetic latitude in iterations */
   var CPHI; /* cos of searched geodetic latitude */
   var SPHI; /* sin of searched geodetic latitude */
   var SDPHI; /* end-criterium: addition-theorem of sin(Latitude(iter)-Latitude(iter-1)) */
   var At_Pole; /* indicates location is in polar region */
   var iter; /* # of continous iteration, max. 30 is always enough (s.a.) */
4525
   var X = p.x;
   var Y = p.y;
   var Z = p.z ? p.z : 0.0; //Z value not always supplied
   var Longitude;
   var Latitude;
   var Height;
4532
   At_Pole = false;
   P = Math.sqrt(X * X + Y * Y);
   RR = Math.sqrt(X * X + Y * Y + Z * Z);
4536
   /*      special cases for latitude and longitude */
   if (P / this.a < genau) {
4539
     /*  special case, if P=0. (X=0., Y=0.) */
     At_Pole = true;
     Longitude = 0.0;
4543
     /*  if (X,Y,Z)=(0.,0.,0.) then Height becomes semi-minor axis
      *  of ellipsoid (=center of mass), Latitude becomes PI/2 */
     if (RR / this.a < genau) {
       Latitude = HALF_PI;
       Height = -this.b;
       return;
     }
   }
   else {
     /*  ellipsoidal (geodetic) longitude
      *  interval: -PI < Longitude <= +PI */
     Longitude = Math.atan2(Y, X);
   }
4557
   /* --------------------------------------------------------------
    * Following iterative algorithm was developped by
    * "Institut for Erdmessung", University of Hannover, July 1988.
    * Internet: www.ife.uni-hannover.de
    * Iterative computation of CPHI,SPHI and Height.
    * Iteration of CPHI and SPHI to 10**-12 radian resp.
    * 2*10**-7 arcsec.
    * --------------------------------------------------------------
    */
   CT = Z / RR;
   ST = P / RR;
   RX = 1.0 / Math.sqrt(1.0 - this.es * (2.0 - this.es) * ST * ST);
   CPHI0 = ST * (1.0 - this.es) * RX;
   SPHI0 = CT * RX;
   iter = 0;
4573
   /* loop to find sin(Latitude) resp. Latitude
    * until |sin(Latitude(iter)-Latitude(iter-1))| < genau */
   do {
     iter++;
     RN = this.a / Math.sqrt(1.0 - this.es * SPHI0 * SPHI0);
4579
     /*  ellipsoidal (geodetic) height */
     Height = P * CPHI0 + Z * SPHI0 - RN * (1.0 - this.es * SPHI0 * SPHI0);
4582
     RK = this.es * RN / (RN + Height);
     RX = 1.0 / Math.sqrt(1.0 - RK * (2.0 - RK) * ST * ST);
     CPHI = ST * (1.0 - RK) * RX;
     SPHI = CT * RX;
     SDPHI = SPHI * CPHI0 - CPHI * SPHI0;
     CPHI0 = CPHI;
     SPHI0 = SPHI;
   }
   while (SDPHI * SDPHI > genau2 && iter < maxiter);
4592
   /*      ellipsoidal (geodetic) latitude */
   Latitude = Math.atan(SPHI / Math.abs(CPHI));
4595
   p.x = Longitude;
   p.y = Latitude;
   p.z = Height;
   return p;
 }, // cs_geocentric_to_geodetic()
4601
 /** Convert_Geocentric_To_Geodetic
  * The method used here is derived from 'An Improved Algorithm for
  * Geocentric to Geodetic Coordinate Conversion', by Ralph Toms, Feb 1996
  */
 geocentric_to_geodetic_noniter: function(p) {
   var X = p.x;
   var Y = p.y;
   var Z = p.z ? p.z : 0; //Z value not always supplied
   var Longitude;
   var Latitude;
   var Height;
4613
   var W; /* distance from Z axis */
   var W2; /* square of distance from Z axis */
   var T0; /* initial estimate of vertical component */
   var T1; /* corrected estimate of vertical component */
   var S0; /* initial estimate of horizontal component */
   var S1; /* corrected estimate of horizontal component */
   var Sin_B0; /* Math.sin(B0), B0 is estimate of Bowring aux variable */
   var Sin3_B0; /* cube of Math.sin(B0) */
   var Cos_B0; /* Math.cos(B0) */
   var Sin_p1; /* Math.sin(phi1), phi1 is estimated latitude */
   var Cos_p1; /* Math.cos(phi1) */
   var Rn; /* Earth radius at location */
   var Sum; /* numerator of Math.cos(phi1) */
   var At_Pole; /* indicates location is in polar region */
4628
   X = parseFloat(X); // cast from string to float
   Y = parseFloat(Y);
   Z = parseFloat(Z);
4632
   At_Pole = false;
   if (X !== 0.0) {
     Longitude = Math.atan2(Y, X);
   }
   else {
     if (Y > 0) {
       Longitude = HALF_PI;
     }
     else if (Y < 0) {
       Longitude = -HALF_PI;
     }
     else {
       At_Pole = true;
       Longitude = 0.0;
       if (Z > 0.0) { /* north pole */
         Latitude = HALF_PI;
       }
       else if (Z < 0.0) { /* south pole */
         Latitude = -HALF_PI;
       }
       else { /* center of earth */
         Latitude = HALF_PI;
         Height = -this.b;
         return;
       }
     }
   }
   W2 = X * X + Y * Y;
   W = Math.sqrt(W2);
   T0 = Z * AD_C;
   S0 = Math.sqrt(T0 * T0 + W2);
   Sin_B0 = T0 / S0;
   Cos_B0 = W / S0;
   Sin3_B0 = Sin_B0 * Sin_B0 * Sin_B0;
   T1 = Z + this.b * this.ep2 * Sin3_B0;
   Sum = W - this.a * this.es * Cos_B0 * Cos_B0 * Cos_B0;
   S1 = Math.sqrt(T1 * T1 + Sum * Sum);
   Sin_p1 = T1 / S1;
   Cos_p1 = Sum / S1;
   Rn = this.a / Math.sqrt(1.0 - this.es * Sin_p1 * Sin_p1);
   if (Cos_p1 >= COS_67P5) {
     Height = W / Cos_p1 - Rn;
   }
   else if (Cos_p1 <= -COS_67P5) {
     Height = W / -Cos_p1 - Rn;
   }
   else {
     Height = Z / Sin_p1 + Rn * (this.es - 1.0);
   }
   if (At_Pole === false) {
     Latitude = Math.atan(Sin_p1 / Cos_p1);
   }
4685
   p.x = Longitude;
   p.y = Latitude;
   p.z = Height;
   return p;
 }, // geocentric_to_geodetic_noniter()
4691
 /****************************************************************/
 // pj_geocentic_to_wgs84( p )
 //  p = point to transform in geocentric coordinates (x,y,z)
 geocentric_to_wgs84: function(p) {
4696
   if (this.datum_type === PJD_3PARAM) {
     // if( x[io] === HUGE_VAL )
     //    continue;
     p.x += this.datum_params[0];
     p.y += this.datum_params[1];
     p.z += this.datum_params[2];
4703
   }
   else if (this.datum_type === PJD_7PARAM) {
     var Dx_BF = this.datum_params[0];
     var Dy_BF = this.datum_params[1];
     var Dz_BF = this.datum_params[2];
     var Rx_BF = this.datum_params[3];
     var Ry_BF = this.datum_params[4];
     var Rz_BF = this.datum_params[5];
     var M_BF = this.datum_params[6];
     // if( x[io] === HUGE_VAL )
     //    continue;
     var x_out = M_BF * (p.x - Rz_BF * p.y + Ry_BF * p.z) + Dx_BF;
     var y_out = M_BF * (Rz_BF * p.x + p.y - Rx_BF * p.z) + Dy_BF;
     var z_out = M_BF * (-Ry_BF * p.x + Rx_BF * p.y + p.z) + Dz_BF;
     p.x = x_out;
     p.y = y_out;
     p.z = z_out;
   }
 }, // cs_geocentric_to_wgs84
4723
 /****************************************************************/
 // pj_geocentic_from_wgs84()
 //  coordinate system definition,
 //  point to transform in geocentric coordinates (x,y,z)
 geocentric_from_wgs84: function(p) {
4729
   if (this.datum_type === PJD_3PARAM) {
     //if( x[io] === HUGE_VAL )
     //    continue;
     p.x -= this.datum_params[0];
     p.y -= this.datum_params[1];
     p.z -= this.datum_params[2];
4736
   }
   else if (this.datum_type === PJD_7PARAM) {
     var Dx_BF = this.datum_params[0];
     var Dy_BF = this.datum_params[1];
     var Dz_BF = this.datum_params[2];
     var Rx_BF = this.datum_params[3];
     var Ry_BF = this.datum_params[4];
     var Rz_BF = this.datum_params[5];
     var M_BF = this.datum_params[6];
     var x_tmp = (p.x - Dx_BF) / M_BF;
     var y_tmp = (p.y - Dy_BF) / M_BF;
     var z_tmp = (p.z - Dz_BF) / M_BF;
     //if( x[io] === HUGE_VAL )
     //    continue;
4751
     p.x = x_tmp + Rz_BF * y_tmp - Ry_BF * z_tmp;
     p.y = -Rz_BF * x_tmp + y_tmp + Rx_BF * z_tmp;
     p.z = Ry_BF * x_tmp - Rx_BF * y_tmp + z_tmp;
   } //cs_geocentric_from_wgs84()
 }
};
4758
/** point object, nothing fancy, just allows values to be
   passed back and forth by reference rather than by value.
   Other point classes may be used as long as they have
   x and y properties, which will get modified in the transform method.
*/
module.exports = datum;
});
4766
var require$$0$14 = (datum && typeof datum === 'object' && 'default' in datum ? datum['default'] : datum);
4768
var extend = createCommonjsModule(function (module) {
module.exports = function(destination, source) {
 destination = destination || {};
 var value, property;
 if (!source) {
   return destination;
 }
 for (property in source) {
   value = source[property];
   if (value !== undefined) {
     destination[property] = value;
   }
 }
 return destination;
};
});
4785
var require$$0$15 = (extend && typeof extend === 'object' && 'default' in extend ? extend['default'] : extend);
4787
var Ellipsoid = createCommonjsModule(function (module, exports) {
exports.MERIT = {
 a: 6378137.0,
 rf: 298.257,
 ellipseName: "MERIT 1983"
};
exports.SGS85 = {
 a: 6378136.0,
 rf: 298.257,
 ellipseName: "Soviet Geodetic System 85"
};
exports.GRS80 = {
 a: 6378137.0,
 rf: 298.257222101,
 ellipseName: "GRS 1980(IUGG, 1980)"
};
exports.IAU76 = {
 a: 6378140.0,
 rf: 298.257,
 ellipseName: "IAU 1976"
};
exports.airy = {
 a: 6377563.396,
 b: 6356256.910,
 ellipseName: "Airy 1830"
};
exports.APL4 = {
 a: 6378137,
 rf: 298.25,
 ellipseName: "Appl. Physics. 1965"
};
exports.NWL9D = {
 a: 6378145.0,
 rf: 298.25,
 ellipseName: "Naval Weapons Lab., 1965"
};
exports.mod_airy = {
 a: 6377340.189,
 b: 6356034.446,
 ellipseName: "Modified Airy"
};
exports.andrae = {
 a: 6377104.43,
 rf: 300.0,
 ellipseName: "Andrae 1876 (Den., Iclnd.)"
};
exports.aust_SA = {
 a: 6378160.0,
 rf: 298.25,
 ellipseName: "Australian Natl & S. Amer. 1969"
};
exports.GRS67 = {
 a: 6378160.0,
 rf: 298.2471674270,
 ellipseName: "GRS 67(IUGG 1967)"
};
exports.bessel = {
 a: 6377397.155,
 rf: 299.1528128,
 ellipseName: "Bessel 1841"
};
exports.bess_nam = {
 a: 6377483.865,
 rf: 299.1528128,
 ellipseName: "Bessel 1841 (Namibia)"
};
exports.clrk66 = {
 a: 6378206.4,
 b: 6356583.8,
 ellipseName: "Clarke 1866"
};
exports.clrk80 = {
 a: 6378249.145,
 rf: 293.4663,
 ellipseName: "Clarke 1880 mod."
};
exports.clrk58 = {
 a: 6378293.645208759,
 rf: 294.2606763692654,
 ellipseName: "Clarke 1858"
};
exports.CPM = {
 a: 6375738.7,
 rf: 334.29,
 ellipseName: "Comm. des Poids et Mesures 1799"
};
exports.delmbr = {
 a: 6376428.0,
 rf: 311.5,
 ellipseName: "Delambre 1810 (Belgium)"
};
exports.engelis = {
 a: 6378136.05,
 rf: 298.2566,
 ellipseName: "Engelis 1985"
};
exports.evrst30 = {
 a: 6377276.345,
 rf: 300.8017,
 ellipseName: "Everest 1830"
};
exports.evrst48 = {
 a: 6377304.063,
 rf: 300.8017,
 ellipseName: "Everest 1948"
};
exports.evrst56 = {
 a: 6377301.243,
 rf: 300.8017,
 ellipseName: "Everest 1956"
};
exports.evrst69 = {
 a: 6377295.664,
 rf: 300.8017,
 ellipseName: "Everest 1969"
};
exports.evrstSS = {
 a: 6377298.556,
 rf: 300.8017,
 ellipseName: "Everest (Sabah & Sarawak)"
};
exports.fschr60 = {
 a: 6378166.0,
 rf: 298.3,
 ellipseName: "Fischer (Mercury Datum) 1960"
};
exports.fschr60m = {
 a: 6378155.0,
 rf: 298.3,
 ellipseName: "Fischer 1960"
};
exports.fschr68 = {
 a: 6378150.0,
 rf: 298.3,
 ellipseName: "Fischer 1968"
};
exports.helmert = {
 a: 6378200.0,
 rf: 298.3,
 ellipseName: "Helmert 1906"
};
exports.hough = {
 a: 6378270.0,
 rf: 297.0,
 ellipseName: "Hough"
};
exports.intl = {
 a: 6378388.0,
 rf: 297.0,
 ellipseName: "International 1909 (Hayford)"
};
exports.kaula = {
 a: 6378163.0,
 rf: 298.24,
 ellipseName: "Kaula 1961"
};
exports.lerch = {
 a: 6378139.0,
 rf: 298.257,
 ellipseName: "Lerch 1979"
};
exports.mprts = {
 a: 6397300.0,
 rf: 191.0,
 ellipseName: "Maupertius 1738"
};
exports.new_intl = {
 a: 6378157.5,
 b: 6356772.2,
 ellipseName: "New International 1967"
};
exports.plessis = {
 a: 6376523.0,
 rf: 6355863.0,
 ellipseName: "Plessis 1817 (France)"
};
exports.krass = {
 a: 6378245.0,
 rf: 298.3,
 ellipseName: "Krassovsky, 1942"
};
exports.SEasia = {
 a: 6378155.0,
 b: 6356773.3205,
 ellipseName: "Southeast Asia"
};
exports.walbeck = {
 a: 6376896.0,
 b: 6355834.8467,
 ellipseName: "Walbeck"
};
exports.WGS60 = {
 a: 6378165.0,
 rf: 298.3,
 ellipseName: "WGS 60"
};
exports.WGS66 = {
 a: 6378145.0,
 rf: 298.25,
 ellipseName: "WGS 66"
};
exports.WGS7 = {
 a: 6378135.0,
 rf: 298.26,
 ellipseName: "WGS 72"
};
exports.WGS84 = {
 a: 6378137.0,
 rf: 298.257223563,
 ellipseName: "WGS 84"
};
exports.sphere = {
 a: 6370997.0,
 b: 6370997.0,
 ellipseName: "Normal Sphere (r=6370997)"
};
});
5005
var require$$2$2 = (Ellipsoid && typeof Ellipsoid === 'object' && 'default' in Ellipsoid ? Ellipsoid['default'] : Ellipsoid);
5007
var Datum = createCommonjsModule(function (module, exports) {
exports.wgs84 = {
 towgs84: "0,0,0",
 ellipse: "WGS84",
 datumName: "WGS84"
};
exports.ch1903 = {
 towgs84: "674.374,15.056,405.346",
 ellipse: "bessel",
 datumName: "swiss"
};
exports.ggrs87 = {
 towgs84: "-199.87,74.79,246.62",
 ellipse: "GRS80",
 datumName: "Greek_Geodetic_Reference_System_1987"
};
exports.nad83 = {
 towgs84: "0,0,0",
 ellipse: "GRS80",
 datumName: "North_American_Datum_1983"
};
exports.nad27 = {
 nadgrids: "@conus,@alaska,@ntv2_0.gsb,@ntv1_can.dat",
 ellipse: "clrk66",
 datumName: "North_American_Datum_1927"
};
exports.potsdam = {
 towgs84: "606.0,23.0,413.0",
 ellipse: "bessel",
 datumName: "Potsdam Rauenberg 1950 DHDN"
};
exports.carthage = {
 towgs84: "-263.0,6.0,431.0",
 ellipse: "clark80",
 datumName: "Carthage 1934 Tunisia"
};
exports.hermannskogel = {
 towgs84: "653.0,-212.0,449.0",
 ellipse: "bessel",
 datumName: "Hermannskogel"
};
exports.ire65 = {
 towgs84: "482.530,-130.596,564.557,-1.042,-0.214,-0.631,8.15",
 ellipse: "mod_airy",
 datumName: "Ireland 1965"
};
exports.rassadiran = {
 towgs84: "-133.63,-157.5,-158.62",
 ellipse: "intl",
 datumName: "Rassadiran"
};
exports.nzgd49 = {
 towgs84: "59.47,-5.04,187.44,0.47,-0.1,1.024,-4.5993",
 ellipse: "intl",
 datumName: "New Zealand Geodetic Datum 1949"
};
exports.osgb36 = {
 towgs84: "446.448,-125.157,542.060,0.1502,0.2470,0.8421,-20.4894",
 ellipse: "airy",
 datumName: "Airy 1830"
};
exports.s_jtsk = {
 towgs84: "589,76,480",
 ellipse: 'bessel',
 datumName: 'S-JTSK (Ferro)'
};
exports.beduaram = {
 towgs84: '-106,-87,188',
 ellipse: 'clrk80',
 datumName: 'Beduaram'
};
exports.gunung_segara = {
 towgs84: '-403,684,41',
 ellipse: 'bessel',
 datumName: 'Gunung Segara Jakarta'
};
exports.rnb72 = {
 towgs84: "106.869,-52.2978,103.724,-0.33657,0.456955,-1.84218,1",
 ellipse: "intl",
 datumName: "Reseau National Belge 1972"
};
});
5090
var require$$3$5 = (Datum && typeof Datum === 'object' && 'default' in Datum ? Datum['default'] : Datum);
5092
var deriveConstants = createCommonjsModule(function (module) {
var Datum = require$$3$5;
var Ellipsoid = require$$2$2;
var extend = require$$0$15;
var datum = require$$0$14;
var EPSLN = 1.0e-10;
// ellipoid pj_set_ell.c
var SIXTH = 0.1666666666666666667;
/* 1/6 */
var RA4 = 0.04722222222222222222;
/* 17/360 */
var RA6 = 0.02215608465608465608;
module.exports = function(json) {
 // DGR 2011-03-20 : nagrids -> nadgrids
 if (json.datumCode && json.datumCode !== 'none') {
   var datumDef = Datum[json.datumCode];
   if (datumDef) {
     json.datum_params = datumDef.towgs84 ? datumDef.towgs84.split(',') : null;
     json.ellps = datumDef.ellipse;
     json.datumName = datumDef.datumName ? datumDef.datumName : json.datumCode;
   }
 }
 if (!json.a) { // do we have an ellipsoid?
   var ellipse = Ellipsoid[json.ellps] ? Ellipsoid[json.ellps] : Ellipsoid.WGS84;
   extend(json, ellipse);
 }
 if (json.rf && !json.b) {
   json.b = (1.0 - 1.0 / json.rf) * json.a;
 }
 if (json.rf === 0 || Math.abs(json.a - json.b) < EPSLN) {
   json.sphere = true;
   json.b = json.a;
 }
 json.a2 = json.a * json.a; // used in geocentric
 json.b2 = json.b * json.b; // used in geocentric
 json.es = (json.a2 - json.b2) / json.a2; // e ^ 2
 json.e = Math.sqrt(json.es); // eccentricity
 if (json.R_A) {
   json.a *= 1 - json.es * (SIXTH + json.es * (RA4 + json.es * RA6));
   json.a2 = json.a * json.a;
   json.b2 = json.b * json.b;
   json.es = 0;
 }
 json.ep2 = (json.a2 - json.b2) / json.b2; // used in geocentric
 if (!json.k0) {
   json.k0 = 1.0; //default value
 }
 //DGR 2010-11-12: axis
 if (!json.axis) {
   json.axis = "enu";
 }
5144
 if (!json.datum) {
   json.datum = datum(json);
 }
 return json;
};
});
5151
var require$$0$13 = (deriveConstants && typeof deriveConstants === 'object' && 'default' in deriveConstants ? deriveConstants['default'] : deriveConstants);
5153
var longlat = createCommonjsModule(function (module, exports) {
exports.init = function() {
 //no-op for longlat
};
5158
function identity(pt) {
 return pt;
}
exports.forward = identity;
exports.inverse = identity;
exports.names = ["longlat", "identity"];
});
5166
var require$$0$16 = (longlat && typeof longlat === 'object' && 'default' in longlat ? longlat['default'] : longlat);
5168
var merc = createCommonjsModule(function (module, exports) {
var msfnz = require$$3$2;
var HALF_PI = Math.PI/2;
var EPSLN = 1.0e-10;
var R2D = 57.29577951308232088;
var adjust_lon = require$$2;
var FORTPI = Math.PI/4;
var tsfnz = require$$1$5;
var phi2z = require$$0$7;
exports.init = function() {
 var con = this.b / this.a;
 this.es = 1 - con * con;
 if(!('x0' in this)){
   this.x0 = 0;
 }
 if(!('y0' in this)){
   this.y0 = 0;
 }
 this.e = Math.sqrt(this.es);
 if (this.lat_ts) {
   if (this.sphere) {
     this.k0 = Math.cos(this.lat_ts);
   }
   else {
     this.k0 = msfnz(this.e, Math.sin(this.lat_ts), Math.cos(this.lat_ts));
   }
 }
 else {
   if (!this.k0) {
     if (this.k) {
       this.k0 = this.k;
     }
     else {
       this.k0 = 1;
     }
   }
 }
};
5207
/* Mercator forward equations--mapping lat,long to x,y
 --------------------------------------------------*/
5210
exports.forward = function(p) {
 var lon = p.x;
 var lat = p.y;
 // convert to radians
 if (lat * R2D > 90 && lat * R2D < -90 && lon * R2D > 180 && lon * R2D < -180) {
   return null;
 }
5218
 var x, y;
 if (Math.abs(Math.abs(lat) - HALF_PI) <= EPSLN) {
   return null;
 }
 else {
   if (this.sphere) {
     x = this.x0 + this.a * this.k0 * adjust_lon(lon - this.long0);
     y = this.y0 + this.a * this.k0 * Math.log(Math.tan(FORTPI + 0.5 * lat));
   }
   else {
     var sinphi = Math.sin(lat);
     var ts = tsfnz(this.e, lat, sinphi);
     x = this.x0 + this.a * this.k0 * adjust_lon(lon - this.long0);
     y = this.y0 - this.a * this.k0 * Math.log(ts);
   }
   p.x = x;
   p.y = y;
   return p;
 }
};
5239
5240
/* Mercator inverse equations--mapping x,y to lat/long
 --------------------------------------------------*/
exports.inverse = function(p) {
5244
 var x = p.x - this.x0;
 var y = p.y - this.y0;
 var lon, lat;
5248
 if (this.sphere) {
   lat = HALF_PI - 2 * Math.atan(Math.exp(-y / (this.a * this.k0)));
 }
 else {
   var ts = Math.exp(-y / (this.a * this.k0));
   lat = phi2z(this.e, ts);
   if (lat === -9999) {
     return null;
   }
 }
 lon = adjust_lon(this.long0 + x / (this.a * this.k0));
5260
 p.x = lon;
 p.y = lat;
 return p;
};
5265
exports.names = ["Mercator", "Popular Visualisation Pseudo Mercator", "Mercator_1SP", "Mercator_Auxiliary_Sphere", "merc"];
});
5268
var require$$1$10 = (merc && typeof merc === 'object' && 'default' in merc ? merc['default'] : merc);
5270
var projections = createCommonjsModule(function (module, exports) {
var projs = [
 require$$1$10,
 require$$0$16
];
var names = {};
var projStore = [];
5278
function add(proj, i) {
 var len = projStore.length;
 if (!proj.names) {
   console.log(i);
   return true;
 }
 projStore[len] = proj;
 proj.names.forEach(function(n) {
   names[n.toLowerCase()] = len;
 });
 return this;
}
5291
exports.add = add;
5293
exports.get = function(name) {
 if (!name) {
   return false;
 }
 var n = name.toLowerCase();
 if (typeof names[n] !== 'undefined' && projStore[names[n]]) {
   return projStore[names[n]];
 }
};
exports.start = function() {
 projs.forEach(add);
};
});
5307
var require$$1$9 = (projections && typeof projections === 'object' && 'default' in projections ? projections['default'] : projections);
5309
var units = createCommonjsModule(function (module, exports) {
exports.ft = {to_meter: 0.3048};
exports['us-ft'] = {to_meter: 1200 / 3937};
});
5314
var require$$0$17 = (units && typeof units === 'object' && 'default' in units ? units['default'] : units);
5316
var PrimeMeridian = createCommonjsModule(function (module, exports) {
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"
});
5332
var require$$1$12 = (PrimeMeridian && typeof PrimeMeridian === 'object' && 'default' in PrimeMeridian ? PrimeMeridian['default'] : PrimeMeridian);
5334
var projString = createCommonjsModule(function (module) {
var D2R = 0.01745329251994329577;
var PrimeMeridian = require$$1$12;
var units = require$$0$17;
5339
module.exports = function(defData) {
 var self = {};
 var paramObj = {};
 defData.split("+").map(function(v) {
   return v.trim();
 }).filter(function(a) {
   return a;
 }).forEach(function(a) {
   var split = a.split("=");
   split.push(true);
   paramObj[split[0].toLowerCase()] = split[1];
 });
 var paramName, paramVal, paramOutname;
 var params = {
   proj: 'projName',
   datum: 'datumCode',
   rf: function(v) {
     self.rf = parseFloat(v);
   },
   lat_0: function(v) {
     self.lat0 = v * D2R;
   },
   lat_1: function(v) {
     self.lat1 = v * D2R;
   },
   lat_2: function(v) {
     self.lat2 = v * D2R;
   },
   lat_ts: function(v) {
     self.lat_ts = v * D2R;
   },
   lon_0: function(v) {
     self.long0 = v * D2R;
   },
   lon_1: function(v) {
     self.long1 = v * D2R;
   },
   lon_2: function(v) {
     self.long2 = v * D2R;
   },
   alpha: function(v) {
     self.alpha = parseFloat(v) * D2R;
   },
   lonc: function(v) {
     self.longc = v * D2R;
   },
   x_0: function(v) {
     self.x0 = parseFloat(v);
   },
   y_0: function(v) {
     self.y0 = parseFloat(v);
   },
   k_0: function(v) {
     self.k0 = parseFloat(v);
   },
   k: function(v) {
     self.k0 = parseFloat(v);
   },
   a: function(v) {
     self.a = parseFloat(v);
   },
   b: function(v) {
     self.b = parseFloat(v);
   },
   r_a: function() {
     self.R_A = true;
   },
   zone: function(v) {
     self.zone = parseInt(v, 10);
   },
   south: function() {
     self.utmSouth = true;
   },
   towgs84: function(v) {
     self.datum_params = v.split(",").map(function(a) {
       return parseFloat(a);
     });
   },
   to_meter: function(v) {
     self.to_meter = parseFloat(v);
   },
   units: function(v) {
     self.units = v;
     if (units[v]) {
       self.to_meter = units[v].to_meter;
     }
   },
   from_greenwich: function(v) {
     self.from_greenwich = v * D2R;
   },
   pm: function(v) {
     self.from_greenwich = (PrimeMeridian[v] ? PrimeMeridian[v] : parseFloat(v)) * D2R;
   },
   nadgrids: function(v) {
     if (v === '@null') {
       self.datumCode = 'none';
     }
     else {
       self.nadgrids = v;
     }
   },
   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;
     }
   }
 };
 for (paramName in paramObj) {
   paramVal = paramObj[paramName];
   if (paramName in params) {
     paramOutname = params[paramName];
     if (typeof paramOutname === 'function') {
       paramOutname(paramVal);
     }
     else {
       self[paramOutname] = paramVal;
     }
   }
   else {
     self[paramName] = paramVal;
   }
 }
 if(typeof self.datumCode === 'string' && self.datumCode !== "WGS84"){
   self.datumCode = self.datumCode.toLowerCase();
 }
 return self;
};
});
5469
var require$$1$11 = (projString && typeof projString === 'object' && 'default' in projString ? projString['default'] : projString);
5471
var wkt = createCommonjsModule(function (module) {
var D2R = 0.01745329251994329577;
var extend = require$$0$15;
5475
function mapit(obj, key, v) {
 obj[key] = v.map(function(aa) {
   var o = {};
   sExpr(aa, o);
   return o;
 }).reduce(function(a, b) {
   return extend(a, b);
 }, {});
}
5485
function sExpr(v, obj) {
 var key;
 if (!Array.isArray(v)) {
   obj[v] = true;
   return;
 }
 else {
   key = v.shift();
   if (key === 'PARAMETER') {
     key = v.shift();
   }
   if (v.length === 1) {
     if (Array.isArray(v[0])) {
       obj[key] = {};
       sExpr(v[0], obj[key]);
     }
     else {
       obj[key] = v[0];
     }
   }
   else if (!v.length) {
     obj[key] = true;
   }
   else if (key === 'TOWGS84') {
     obj[key] = v;
   }
   else {
     obj[key] = {};
     if (['UNIT', 'PRIMEM', 'VERT_DATUM'].indexOf(key) > -1) {
       obj[key] = {
         name: v[0].toLowerCase(),
         convert: v[1]
       };
       if (v.length === 3) {
         obj[key].auth = v[2];
       }
     }
     else if (key === 'SPHEROID') {
       obj[key] = {
         name: v[0],
         a: v[1],
         rf: v[2]
       };
       if (v.length === 4) {
         obj[key].auth = v[3];
       }
     }
     else if (['GEOGCS', 'GEOCCS', 'DATUM', 'VERT_CS', 'COMPD_CS', 'LOCAL_CS', 'FITTED_CS', 'LOCAL_DATUM'].indexOf(key) > -1) {
       v[0] = ['name', v[0]];
       mapit(obj, key, v);
     }
     else if (v.every(function(aa) {
       return Array.isArray(aa);
     })) {
       mapit(obj, key, v);
     }
     else {
       sExpr(v, obj[key]);
     }
   }
 }
}
5548
function rename(obj, params) {
 var outName = params[0];
 var inName = params[1];
 if (!(outName in obj) && (inName in obj)) {
   obj[outName] = obj[inName];
   if (params.length === 3) {
     obj[outName] = params[2](obj[outName]);
   }
 }
}
5559
function d2r(input) {
 return input * D2R;
}
5563
function cleanWKT(wkt) {
 if (wkt.type === 'GEOGCS') {
   wkt.projName = 'longlat';
 }
 else if (wkt.type === 'LOCAL_CS') {
   wkt.projName = 'identity';
   wkt.local = true;
 }
 else {
   if (typeof wkt.PROJECTION === "object") {
     wkt.projName = Object.keys(wkt.PROJECTION)[0];
   }
   else {
     wkt.projName = wkt.PROJECTION;
   }
 }
 if (wkt.UNIT) {
   wkt.units = wkt.UNIT.name.toLowerCase();
   if (wkt.units === 'metre') {
     wkt.units = 'meter';
   }
   if (wkt.UNIT.convert) {
     if (wkt.type === 'GEOGCS') {
       if (wkt.DATUM && wkt.DATUM.SPHEROID) {
         wkt.to_meter = parseFloat(wkt.UNIT.convert, 10)*wkt.DATUM.SPHEROID.a;
       }
     } else {
       wkt.to_meter = parseFloat(wkt.UNIT.convert, 10);
     }
   }
 }
5595
 if (wkt.GEOGCS) {
   //if(wkt.GEOGCS.PRIMEM&&wkt.GEOGCS.PRIMEM.convert){
   //  wkt.from_greenwich=wkt.GEOGCS.PRIMEM.convert*D2R;
   //}
   if (wkt.GEOGCS.DATUM) {
     wkt.datumCode = wkt.GEOGCS.DATUM.name.toLowerCase();
   }
   else {
     wkt.datumCode = wkt.GEOGCS.name.toLowerCase();
   }
   if (wkt.datumCode.slice(0, 2) === 'd_') {
     wkt.datumCode = wkt.datumCode.slice(2);
   }
   if (wkt.datumCode === 'new_zealand_geodetic_datum_1949' || wkt.datumCode === 'new_zealand_1949') {
     wkt.datumCode = 'nzgd49';
   }
   if (wkt.datumCode === "wgs_1984") {
     if (wkt.PROJECTION === 'Mercator_Auxiliary_Sphere') {
       wkt.sphere = true;
     }
     wkt.datumCode = 'wgs84';
   }
   if (wkt.datumCode.slice(-6) === '_ferro') {
     wkt.datumCode = wkt.datumCode.slice(0, - 6);
   }
   if (wkt.datumCode.slice(-8) === '_jakarta') {
     wkt.datumCode = wkt.datumCode.slice(0, - 8);
   }
   if (~wkt.datumCode.indexOf('belge')) {
     wkt.datumCode = "rnb72";
   }
   if (wkt.GEOGCS.DATUM && wkt.GEOGCS.DATUM.SPHEROID) {
     wkt.ellps = wkt.GEOGCS.DATUM.SPHEROID.name.replace('_19', '').replace(/[Cc]larke\_18/, 'clrk');
     if (wkt.ellps.toLowerCase().slice(0, 13) === "international") {
       wkt.ellps = 'intl';
     }
5632
     wkt.a = wkt.GEOGCS.DATUM.SPHEROID.a;
     wkt.rf = parseFloat(wkt.GEOGCS.DATUM.SPHEROID.rf, 10);
   }
   if (~wkt.datumCode.indexOf('osgb_1936')) {
     wkt.datumCode = "osgb36";
   }
 }
 if (wkt.b && !isFinite(wkt.b)) {
   wkt.b = wkt.a;
 }
5643
 function toMeter(input) {
   var ratio = wkt.to_meter || 1;
   return parseFloat(input, 10) * ratio;
 }
 var renamer = function(a) {
   return rename(wkt, a);
 };
 var list = [
   ['standard_parallel_1', 'Standard_Parallel_1'],
   ['standard_parallel_2', 'Standard_Parallel_2'],
   ['false_easting', 'False_Easting'],
   ['false_northing', 'False_Northing'],
   ['central_meridian', 'Central_Meridian'],
   ['latitude_of_origin', 'Latitude_Of_Origin'],
   ['latitude_of_origin', 'Central_Parallel'],
   ['scale_factor', 'Scale_Factor'],
   ['k0', 'scale_factor'],
   ['latitude_of_center', 'Latitude_of_center'],
   ['lat0', 'latitude_of_center', d2r],
   ['longitude_of_center', 'Longitude_Of_Center'],
   ['longc', 'longitude_of_center', d2r],
   ['x0', 'false_easting', toMeter],
   ['y0', 'false_northing', toMeter],
   ['long0', 'central_meridian', d2r],
   ['lat0', 'latitude_of_origin', d2r],
   ['lat0', 'standard_parallel_1', d2r],
   ['lat1', 'standard_parallel_1', d2r],
   ['lat2', 'standard_parallel_2', d2r],
   ['alpha', 'azimuth', d2r],
   ['srsCode', 'name']
 ];
 list.forEach(renamer);
 if (!wkt.long0 && wkt.longc && (wkt.projName === 'Albers_Conic_Equal_Area' || wkt.projName === "Lambert_Azimuthal_Equal_Area")) {
   wkt.long0 = wkt.longc;
 }
 if (!wkt.lat_ts && wkt.lat1 && (wkt.projName === 'Stereographic_South_Pole' || wkt.projName === 'Polar Stereographic (variant B)')) {
   wkt.lat0 = d2r(wkt.lat1 > 0 ? 90 : -90);
   wkt.lat_ts = wkt.lat1;
 }
}
module.exports = function(wkt, self) {
 var lisp = JSON.parse(("," + wkt).replace(/\s*\,\s*([A-Z_0-9]+?)(\[)/g, ',["$1",').slice(1).replace(/\s*\,\s*([A-Z_0-9]+?)\]/g, ',"$1"]').replace(/,\["VERTCS".+/,''));
 var type = lisp.shift();
 var name = lisp.shift();
 lisp.unshift(['name', name]);
 lisp.unshift(['type', type]);
 lisp.unshift('output');
 var obj = {};
 sExpr(lisp, obj);
 cleanWKT(obj.output);
 return extend(self, obj.output);
};
});
5697
var require$$0$18 = (wkt && typeof wkt === 'object' && 'default' in wkt ? wkt['default'] : wkt);
5699
var global$1 = createCommonjsModule(function (module) {
module.exports = function(defs) {
 defs('EPSG:4326', "+title=WGS 84 (long/lat) +proj=longlat +ellps=WGS84 +datum=WGS84 +units=degrees");
 defs('EPSG:4269', "+title=NAD83 (long/lat) +proj=longlat +a=6378137.0 +b=6356752.31414036 +ellps=GRS80 +datum=NAD83 +units=degrees");
 defs('EPSG:3857', "+title=WGS 84 / Pseudo-Mercator +proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m +nadgrids=@null +no_defs");
5705
 defs.WGS84 = defs['EPSG:4326'];
 defs['EPSG:3785'] = defs['EPSG:3857']; // maintain backward compat, official code is 3857
 defs.GOOGLE = defs['EPSG:3857'];
 defs['EPSG:900913'] = defs['EPSG:3857'];
 defs['EPSG:102113'] = defs['EPSG:3857'];
};
});
5713
var require$$2$4 = (global$1 && typeof global$1 === 'object' && 'default' in global$1 ? global$1['default'] : global$1);
5715
var defs = createCommonjsModule(function (module) {
var globals = require$$2$4;
var parseProj = require$$1$11;
var wkt = require$$0$18;
5720
function defs(name) {
 /*global console*/
 var that = this;
 if (arguments.length === 2) {
   var def = arguments[1];
   if (typeof def === 'string') {
     if (def.charAt(0) === '+') {
       defs[name] = parseProj(arguments[1]);
     }
     else {
       defs[name] = wkt(arguments[1]);
     }
   } else {
     defs[name] = def;
   }
 }
 else if (arguments.length === 1) {
   if (Array.isArray(name)) {
     return name.map(function(v) {
       if (Array.isArray(v)) {
         defs.apply(that, v);
       }
       else {
         defs(v);
       }
     });
   }
   else if (typeof name === 'string') {
     if (name in defs) {
       return defs[name];
     }
   }
   else if ('EPSG' in name) {
     defs['EPSG:' + name.EPSG] = name;
   }
   else if ('ESRI' in name) {
     defs['ESRI:' + name.ESRI] = name;
   }
   else if ('IAU2000' in name) {
     defs['IAU2000:' + name.IAU2000] = name;
   }
   else {
     console.log(name);
   }
   return;
 }
5767
5768
}
globals(defs);
module.exports = defs;
});
5773
var require$$2$3 = (defs && typeof defs === 'object' && 'default' in defs ? defs['default'] : defs);
5775
var parseCode = createCommonjsModule(function (module) {
var defs = require$$2$3;
var wkt = require$$0$18;
var projStr = require$$1$11;
function testObj(code){
 return typeof code === 'string';
}
function testDef(code){
 return code in defs;
}
function testWKT(code){
 var codeWords = ['GEOGCS','GEOCCS','PROJCS','LOCAL_CS'];
 return codeWords.reduce(function(a,b){
   return a+1+code.indexOf(b);
 },0);
}
function testProj(code){
 return code[0] === '+';
}
function parse(code){
 if (testObj(code)) {
   //check to see if this is a WKT string
   if (testDef(code)) {
     return defs[code];
   }
   else if (testWKT(code)) {
     return wkt(code);
   }
   else if (testProj(code)) {
     return projStr(code);
   }
 }else{
   return code;
 }
}
5811
module.exports = parse;
});
5814
var require$$3$6 = (parseCode && typeof parseCode === 'object' && 'default' in parseCode ? parseCode['default'] : parseCode);
5816
var Proj = createCommonjsModule(function (module) {
var parseCode = require$$3$6;
var extend = require$$0$15;
var projections = require$$1$9;
var deriveConstants = require$$0$13;
5822
function Projection(srsCode,callback) {
 if (!(this instanceof Projection)) {
   return new Projection(srsCode);
 }
 callback = callback || function(error){
   if(error){
     throw error;
   }
 };
 var json = parseCode(srsCode);
 if(typeof json !== 'object'){
   callback(srsCode);
   return;
 }
 var modifiedJSON = deriveConstants(json);
 var ourProj = Projection.projections.get(modifiedJSON.projName);
 if(ourProj){
   extend(this, modifiedJSON);
   extend(this, ourProj);
   this.init();
   callback(null, this);
 }else{
   callback(srsCode);
 }
}
Projection.projections = projections;
Projection.projections.start();
module.exports = Projection;
});
5852
var require$$1$8 = (Proj && typeof Proj === 'object' && 'default' in Proj ? Proj['default'] : Proj);
5854
var adjust_axis = createCommonjsModule(function (module) {
module.exports = function(crs, denorm, point) {
 var xin = point.x,
   yin = point.y,
   zin = point.z || 0.0;
 var v, t, i;
 for (i = 0; i < 3; i++) {
   if (denorm && i === 2 && point.z === undefined) {
     continue;
   }
   if (i === 0) {
     v = xin;
     t = 'x';
   }
   else if (i === 1) {
     v = yin;
     t = 'y';
   }
   else {
     v = zin;
     t = 'z';
   }
   switch (crs.axis[i]) {
   case 'e':
     point[t] = v;
     break;
   case 'w':
     point[t] = -v;
     break;
   case 'n':
     point[t] = v;
     break;
   case 's':
     point[t] = -v;
     break;
   case 'u':
     if (point[t] !== undefined) {
       point.z = v;
     }
     break;
   case 'd':
     if (point[t] !== undefined) {
       point.z = -v;
     }
     break;
   default:
     //console.log("ERROR: unknow axis ("+crs.axis[i]+") - check definition of "+crs.projName);
     return null;
   }
 }
 return point;
};
});
5908
var require$$2$5 = (adjust_axis && typeof adjust_axis === 'object' && 'default' in adjust_axis ? adjust_axis['default'] : adjust_axis);
5910
var datum_transform = createCommonjsModule(function (module) {
var PJD_3PARAM = 1;
var PJD_7PARAM = 2;
var PJD_GRIDSHIFT = 3;
var PJD_NODATUM = 5; // WGS84 or equivalent
var SRS_WGS84_SEMIMAJOR = 6378137; // only used in grid shift transforms
var SRS_WGS84_ESQUARED = 0.006694379990141316; //DGR: 2012-07-29
module.exports = function(source, dest, point) {
 var wp, i, l;
5920
 function checkParams(fallback) {
   return (fallback === PJD_3PARAM || fallback === PJD_7PARAM);
 }
 // Short cut if the datums are identical.
 if (source.compare_datums(dest)) {
   return point; // in this case, zero is sucess,
   // whereas cs_compare_datums returns 1 to indicate TRUE
   // confusing, should fix this
 }
5930
 // Explicitly skip datum transform by setting 'datum=none' as parameter for either source or dest
 if (source.datum_type === PJD_NODATUM || dest.datum_type === PJD_NODATUM) {
   return point;
 }
5935
 //DGR: 2012-07-29 : add nadgrids support (begin)
 var src_a = source.a;
 var src_es = source.es;
5939
 var dst_a = dest.a;
 var dst_es = dest.es;
5942
 var fallback = source.datum_type;
 // If this datum requires grid shifts, then apply it to geodetic coordinates.
 if (fallback === PJD_GRIDSHIFT) {
   if (this.apply_gridshift(source, 0, point) === 0) {
     source.a = SRS_WGS84_SEMIMAJOR;
     source.es = SRS_WGS84_ESQUARED;
   }
   else {
     // try 3 or 7 params transformation or nothing ?
     if (!source.datum_params) {
       source.a = src_a;
       source.es = source.es;
       return point;
     }
     wp = 1;
     for (i = 0, l = source.datum_params.length; i < l; i++) {
       wp *= source.datum_params[i];
     }
     if (wp === 0) {
       source.a = src_a;
       source.es = source.es;
       return point;
     }
     if (source.datum_params.length > 3) {
       fallback = PJD_7PARAM;
     }
     else {
       fallback = PJD_3PARAM;
     }
   }
 }
 if (dest.datum_type === PJD_GRIDSHIFT) {
   dest.a = SRS_WGS84_SEMIMAJOR;
   dest.es = SRS_WGS84_ESQUARED;
 }
 // Do we need to go through geocentric coordinates?
 if (source.es !== dest.es || source.a !== dest.a || checkParams(fallback) || checkParams(dest.datum_type)) {
   //DGR: 2012-07-29 : add nadgrids support (end)
   // Convert to geocentric coordinates.
   source.geodetic_to_geocentric(point);
   // CHECK_RETURN;
   // Convert between datums
   if (checkParams(source.datum_type)) {
     source.geocentric_to_wgs84(point);
     // CHECK_RETURN;
   }
   if (checkParams(dest.datum_type)) {
     dest.geocentric_from_wgs84(point);
     // CHECK_RETURN;
   }
   // Convert back to geodetic coordinates
   dest.geocentric_to_geodetic(point);
   // CHECK_RETURN;
 }
 // Apply grid shift to destination if required
 if (dest.datum_type === PJD_GRIDSHIFT) {
   this.apply_gridshift(dest, 1, point);
   // CHECK_RETURN;
 }
6002
 source.a = src_a;
 source.es = src_es;
 dest.a = dst_a;
 dest.es = dst_es;
6007
 return point;
};
});
6011
var require$$3$7 = (datum_transform && typeof datum_transform === 'object' && 'default' in datum_transform ? datum_transform['default'] : datum_transform);
6013
var transform = createCommonjsModule(function (module) {
var D2R = 0.01745329251994329577;
var R2D = 57.29577951308232088;
var PJD_3PARAM = 1;
var PJD_7PARAM = 2;
var datum_transform = require$$3$7;
var adjust_axis = require$$2$5;
var proj = require$$1$8;
var toPoint = require$$0$12;
module.exports = function transform(source, dest, point) {
 var wgs84;
 if (Array.isArray(point)) {
   point = toPoint(point);
 }
 function checkNotWGS(source, dest) {
   return ((source.datum.datum_type === PJD_3PARAM || source.datum.datum_type === PJD_7PARAM) && dest.datumCode !== "WGS84");
 }
6031
 // Workaround for datum shifts towgs84, if either source or destination projection is not wgs84
 if (source.datum && dest.datum && (checkNotWGS(source, dest) || checkNotWGS(dest, source))) {
   wgs84 = new proj('WGS84');
   transform(source, wgs84, point);
   source = wgs84;
 }
 // DGR, 2010/11/12
 if (source.axis !== "enu") {
   adjust_axis(source, false, point);
 }
 // Transform source points to long/lat, if they aren't already.
 if (source.projName === "longlat") {
   point.x *= D2R; // convert degrees to radians
   point.y *= D2R;
 }
 else {
   if (source.to_meter) {
     point.x *= source.to_meter;
     point.y *= source.to_meter;
   }
   source.inverse(point); // Convert Cartesian to longlat
 }
 // Adjust for the prime meridian if necessary
 if (source.from_greenwich) {
   point.x += source.from_greenwich;
 }
6058
 // Convert datums if needed, and if possible.
 point = datum_transform(source.datum, dest.datum, point);
6061
 // Adjust for the prime meridian if necessary
 if (dest.from_greenwich) {
   point.x -= dest.from_greenwich;
 }
6066
 if (dest.projName === "longlat") {
   // convert radians to decimal degrees
   point.x *= R2D;
   point.y *= R2D;
 }
 else { // else project
   dest.forward(point);
   if (dest.to_meter) {
     point.x /= dest.to_meter;
     point.y /= dest.to_meter;
   }
 }
6079
 // DGR, 2010/11/12
 if (dest.axis !== "enu") {
   adjust_axis(dest, true, point);
 }
6084
 return point;
};
});
6088
var require$$0$11 = (transform && typeof transform === 'object' && 'default' in transform ? transform['default'] : transform);
6090
var Point = createCommonjsModule(function (module) {
var mgrs = require$$0$10;
6093
function Point(x, y, z) {
 if (!(this instanceof Point)) {
   return new Point(x, y, z);
 }
 if (Array.isArray(x)) {
   this.x = x[0];
   this.y = x[1];
   this.z = x[2] || 0.0;
 } else if(typeof x === 'object') {
   this.x = x.x;
   this.y = x.y;
   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;
 } else {
   this.x = x;
   this.y = y;
   this.z = z || 0.0;
 }
 console.warn('proj4.Point will be removed in version 3, use proj4.toPoint');
}
6118
Point.fromMGRS = function(mgrsStr) {
 return new Point(mgrs.toPoint(mgrsStr));
};
Point.prototype.toMGRS = function(accuracy) {
 return mgrs.forward([this.x, this.y], accuracy);
};
module.exports = Point;
});
6127
var require$$6$2 = (Point && typeof Point === 'object' && 'default' in Point ? Point['default'] : Point);
6129
var core = createCommonjsModule(function (module) {
var proj = require$$1$8;
var transform = require$$0$11;
var wgs84 = proj('WGS84');
6134
function transformer(from, to, coords) {
 var transformedArray;
 if (Array.isArray(coords)) {
   transformedArray = transform(from, to, coords);
   if (coords.length === 3) {
     return [transformedArray.x, transformedArray.y, transformedArray.z];
   }
   else {
     return [transformedArray.x, transformedArray.y];
   }
 }
 else {
   return transform(from, to, coords);
 }
}
6150
function checkProj(item) {
 if (item instanceof proj) {
   return item;
 }
 if (item.oProj) {
   return item.oProj;
 }
 return proj(item);
}
function proj4(fromProj, toProj, coord) {
 fromProj = checkProj(fromProj);
 var single = false;
 var obj;
 if (typeof toProj === 'undefined') {
   toProj = fromProj;
   fromProj = wgs84;
   single = true;
 }
 else if (typeof toProj.x !== 'undefined' || Array.isArray(toProj)) {
   coord = toProj;
   toProj = fromProj;
   fromProj = wgs84;
   single = true;
 }
 toProj = checkProj(toProj);
 if (coord) {
   return transformer(fromProj, toProj, coord);
 }
 else {
   obj = {
     forward: function(coords) {
       return transformer(fromProj, toProj, coords);
     },
     inverse: function(coords) {
       return transformer(toProj, fromProj, coords);
     }
   };
   if (single) {
     obj.oProj = toProj;
   }
   return obj;
 }
}
module.exports = proj4;
});
6196
var require$$8$1 = (core && typeof core === 'object' && 'default' in core ? core['default'] : core);
6198
var index$2 = createCommonjsModule(function (module) {
var proj4 = require$$8$1;
proj4.defaultDatum = 'WGS84'; //default datum
proj4.Proj = require$$1$8;
proj4.WGS84 = new proj4.Proj('WGS84');
proj4.Point = require$$6$2;
proj4.toPoint = require$$0$12;
proj4.defs = require$$2$3;
proj4.transform = require$$0$11;
proj4.mgrs = require$$0$10;
proj4.version = require$$1$7.version;
require$$0$1(proj4);
module.exports = proj4;
});
6213
var require$$0 = (index$2 && typeof index$2 === 'object' && 'default' in index$2 ? index$2['default'] : index$2);
6215
(function(self) {
 'use strict';
6218
 if (self.fetch) {
   return
 }
6222
 var support = {
   searchParams: 'URLSearchParams' in self,
   iterable: 'Symbol' in self && 'iterator' in Symbol,
   blob: 'FileReader' in self && 'Blob' in self && (function() {
     try {
       new Blob()
       return true
     } catch(e) {
       return false
     }
   })(),
   formData: 'FormData' in self,
   arrayBuffer: 'ArrayBuffer' in self
 }
6237
 function normalizeName(name) {
   if (typeof name !== 'string') {
     name = String(name)
   }
   if (/[^a-z0-9\-#$%&'*+.\^_`|~]/i.test(name)) {
     throw new TypeError('Invalid character in header field name')
   }
   return name.toLowerCase()
 }
6247
 function normalizeValue(value) {
   if (typeof value !== 'string') {
     value = String(value)
   }
   return value
 }
6254
 // Build a destructive iterator for the value list
 function iteratorFor(items) {
   var iterator = {
     next: function() {
       var value = items.shift()
       return {done: value === undefined, value: value}
     }
   }
6263
   if (support.iterable) {
     iterator[Symbol.iterator] = function() {
       return iterator
     }
   }
6269
   return iterator
 }
6272
 function Headers(headers) {
   this.map = {}
6275
   if (headers instanceof Headers) {
     headers.forEach(function(value, name) {
       this.append(name, value)
     }, this)
6280
   } else if (headers) {
     Object.getOwnPropertyNames(headers).forEach(function(name) {
       this.append(name, headers[name])
     }, this)
   }
 }
6287
 Headers.prototype.append = function(name, value) {
   name = normalizeName(name)
   value = normalizeValue(value)
   var list = this.map[name]
   if (!list) {
     list = []
     this.map[name] = list
   }
   list.push(value)
 }
6298
 Headers.prototype['delete'] = function(name) {
   delete this.map[normalizeName(name)]
 }
6302
 Headers.prototype.get = function(name) {
   var values = this.map[normalizeName(name)]
   return values ? values[0] : null
 }
6307
 Headers.prototype.getAll = function(name) {
   return this.map[normalizeName(name)] || []
 }
6311
 Headers.prototype.has = function(name) {
   return this.map.hasOwnProperty(normalizeName(name))
 }
6315
 Headers.prototype.set = function(name, value) {
   this.map[normalizeName(name)] = [normalizeValue(value)]
 }
6319
 Headers.prototype.forEach = function(callback, thisArg) {
   Object.getOwnPropertyNames(this.map).forEach(function(name) {
     this.map[name].forEach(function(value) {
       callback.call(thisArg, value, name, this)
     }, this)
   }, this)
 }
6327
 Headers.prototype.keys = function() {
   var items = []
   this.forEach(function(value, name) { items.push(name) })
   return iteratorFor(items)
 }
6333
 Headers.prototype.values = function() {
   var items = []
   this.forEach(function(value) { items.push(value) })
   return iteratorFor(items)
 }
6339
 Headers.prototype.entries = function() {
   var items = []
   this.forEach(function(value, name) { items.push([name, value]) })
   return iteratorFor(items)
 }
6345
 if (support.iterable) {
   Headers.prototype[Symbol.iterator] = Headers.prototype.entries
 }
6349
 function consumed(body) {
   if (body.bodyUsed) {
     return Promise.reject(new TypeError('Already read'))
   }
   body.bodyUsed = true
 }
6356
 function fileReaderReady(reader) {
   return new Promise(function(resolve, reject) {
     reader.onload = function() {
       resolve(reader.result)
     }
     reader.onerror = function() {
       reject(reader.error)
     }
   })
 }
6367
 function readBlobAsArrayBuffer(blob) {
   var reader = new FileReader()
   reader.readAsArrayBuffer(blob)
   return fileReaderReady(reader)
 }
6373
 function readBlobAsText(blob) {
   var reader = new FileReader()
   reader.readAsText(blob)
   return fileReaderReady(reader)
 }
6379
 function Body() {
   this.bodyUsed = false
6382
   this._initBody = function(body) {
     this._bodyInit = body
     if (typeof body === 'string') {
       this._bodyText = body
     } else if (support.blob && Blob.prototype.isPrototypeOf(body)) {
       this._bodyBlob = body
     } else if (support.formData && FormData.prototype.isPrototypeOf(body)) {
       this._bodyFormData = body
     } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
       this._bodyText = body.toString()
     } else if (!body) {
       this._bodyText = ''
     } else if (support.arrayBuffer && ArrayBuffer.prototype.isPrototypeOf(body)) {
       // Only support ArrayBuffers for POST method.
       // Receiving ArrayBuffers happens via Blobs, instead.
     } else {
       throw new Error('unsupported BodyInit type')
     }
6401
     if (!this.headers.get('content-type')) {
       if (typeof body === 'string') {
         this.headers.set('content-type', 'text/plain;charset=UTF-8')
       } else if (this._bodyBlob && this._bodyBlob.type) {
         this.headers.set('content-type', this._bodyBlob.type)
       } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
         this.headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8')
       }
     }
   }
6412
   if (support.blob) {
     this.blob = function() {
       var rejected = consumed(this)
       if (rejected) {
         return rejected
       }
6419
       if (this._bodyBlob) {
         return Promise.resolve(this._bodyBlob)
       } else if (this._bodyFormData) {
         throw new Error('could not read FormData body as blob')
       } else {
         return Promise.resolve(new Blob([this._bodyText]))
       }
     }
6428
     this.arrayBuffer = function() {
       return this.blob().then(readBlobAsArrayBuffer)
     }
6432
     this.text = function() {
       var rejected = consumed(this)
       if (rejected) {
         return rejected
       }
6438
       if (this._bodyBlob) {
         return readBlobAsText(this._bodyBlob)
       } else if (this._bodyFormData) {
         throw new Error('could not read FormData body as text')
       } else {
         return Promise.resolve(this._bodyText)
       }
     }
   } else {
     this.text = function() {
       var rejected = consumed(this)
       return rejected ? rejected : Promise.resolve(this._bodyText)
     }
   }
6453
   if (support.formData) {
     this.formData = function() {
       return this.text().then(decode)
     }
   }
6459
   this.json = function() {
     return this.text().then(JSON.parse)
   }
6463
   return this
 }
6466
 // HTTP methods whose capitalization should be normalized
 var methods = ['DELETE', 'GET', 'HEAD', 'OPTIONS', 'POST', 'PUT']
6469
 function normalizeMethod(method) {
   var upcased = method.toUpperCase()
   return (methods.indexOf(upcased) > -1) ? upcased : method
 }
6474
 function Request(input, options) {
   options = options || {}
   var body = options.body
   if (Request.prototype.isPrototypeOf(input)) {
     if (input.bodyUsed) {
       throw new TypeError('Already read')
     }
     this.url = input.url
     this.credentials = input.credentials
     if (!options.headers) {
       this.headers = new Headers(input.headers)
     }
     this.method = input.method
     this.mode = input.mode
     if (!body) {
       body = input._bodyInit
       input.bodyUsed = true
     }
   } else {
     this.url = input
   }
6496
   this.credentials = options.credentials || this.credentials || 'omit'
   if (options.headers || !this.headers) {
     this.headers = new Headers(options.headers)
   }
   this.method = normalizeMethod(options.method || this.method || 'GET')
   this.mode = options.mode || this.mode || null
   this.referrer = null
6504
   if ((this.method === 'GET' || this.method === 'HEAD') && body) {
     throw new TypeError('Body not allowed for GET or HEAD requests')
   }
   this._initBody(body)
 }
6510
 Request.prototype.clone = function() {
   return new Request(this)
 }
6514
 function decode(body) {
   var form = new FormData()
   body.trim().split('&').forEach(function(bytes) {
     if (bytes) {
       var split = bytes.split('=')
       var name = split.shift().replace(/\+/g, ' ')
       var value = split.join('=').replace(/\+/g, ' ')
       form.append(decodeURIComponent(name), decodeURIComponent(value))
     }
   })
   return form
 }
6527
 function headers(xhr) {
   var head = new Headers()
   var pairs = (xhr.getAllResponseHeaders() || '').trim().split('\n')
   pairs.forEach(function(header) {
     var split = header.trim().split(':')
     var key = split.shift().trim()
     var value = split.join(':').trim()
     head.append(key, value)
   })
   return head
 }
6539
 Body.call(Request.prototype)
6541
 function Response(bodyInit, options) {
   if (!options) {
     options = {}
   }
6546
   this.type = 'default'
   this.status = options.status
   this.ok = this.status >= 200 && this.status < 300
   this.statusText = options.statusText
   this.headers = options.headers instanceof Headers ? options.headers : new Headers(options.headers)
   this.url = options.url || ''
   this._initBody(bodyInit)
 }
6555
 Body.call(Response.prototype)
6557
 Response.prototype.clone = function() {
   return new Response(this._bodyInit, {
     status: this.status,
     statusText: this.statusText,
     headers: new Headers(this.headers),
     url: this.url
   })
 }
6566
 Response.error = function() {
   var response = new Response(null, {status: 0, statusText: ''})
   response.type = 'error'
   return response
 }
6572
 var redirectStatuses = [301, 302, 303, 307, 308]
6574
 Response.redirect = function(url, status) {
   if (redirectStatuses.indexOf(status) === -1) {
     throw new RangeError('Invalid status code')
   }
6579
   return new Response(null, {status: status, headers: {location: url}})
 }
6582
 self.Headers = Headers
 self.Request = Request
 self.Response = Response
6586
 self.fetch = function(input, init) {
   return new Promise(function(resolve, reject) {
     var request
     if (Request.prototype.isPrototypeOf(input) && !init) {
       request = input
     } else {
       request = new Request(input, init)
     }
6595
     var xhr = new XMLHttpRequest()
6597
     function responseURL() {
       if ('responseURL' in xhr) {
         return xhr.responseURL
       }
6602
       // Avoid security warnings on getResponseHeader when not allowed by CORS
       if (/^X-Request-URL:/m.test(xhr.getAllResponseHeaders())) {
         return xhr.getResponseHeader('X-Request-URL')
       }
6607
       return
     }
6610
     xhr.onload = function() {
       var options = {
         status: xhr.status,
         statusText: xhr.statusText,
         headers: headers(xhr),
         url: responseURL()
       }
       var body = 'response' in xhr ? xhr.response : xhr.responseText
       resolve(new Response(body, options))
     }
6621
     xhr.onerror = function() {
       reject(new TypeError('Network request failed'))
     }
6625
     xhr.ontimeout = function() {
       reject(new TypeError('Network request failed'))
     }
6629
     xhr.open(request.method, request.url, true)
6631
     if (request.credentials === 'include') {
       xhr.withCredentials = true
     }
6635
     if ('responseType' in xhr && support.blob) {
       xhr.responseType = 'blob'
     }
6639
     request.headers.forEach(function(value, name) {
       xhr.setRequestHeader(name, value)
     })
6643
     xhr.send(typeof request._bodyInit === 'undefined' ? null : request._bodyInit)
   })
 }
 self.fetch.polyfill = true
})(typeof self !== 'undefined' ? self : this);
6649
var index = createCommonjsModule(function (module, exports) {
'use strict';
6652
Object.defineProperty(exports, "__esModule", {
 value: true
});
exports.get = get;
exports.load = load;
exports.set = set;
6659
6660
6661
var _proj = require$$0;
6663
var _proj2 = _interopRequireDefault(_proj);
6665
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
6667
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
6669
var ROOT_PREFIX = 'http://www.opengis.net/def/crs/';
var OGC_PREFIX = ROOT_PREFIX + 'OGC/';
var EPSG_PREFIX = ROOT_PREFIX + 'EPSG/0/';
6673
/**
* @typedef {Object} Projection
* @property {function(lonlat: Array<number>): Array<number>} forward
*   Transforms a geographic WGS84 [longitude, latitude] coordinate to an [x, y] projection coordinate.
* @property {function(xy: Array<number>): Array<number>} inverse
*   Transforms an [x, y] projection coordinate to a geographic WGS84 [longitude, latitude] coordinate.
*/
6681
// a cache of URI string -> Projection object mappings
var projCache = {};
6684
// work-arounds for incorrect epsg.io / proj4 behaviour
var needsAxesReordering = _defineProperty({}, EPSG_PREFIX + 4326, true);
6687
// store some built-in projections which are not available on epsg.io
var LONLAT = (0, _proj2.default)('+proj=longlat +datum=WGS84 +no_defs');
set(OGC_PREFIX + '1.3/CRS84', LONLAT);
set(EPSG_PREFIX + 4979, reverseAxes(LONLAT));
6692
/**
* Returns a stored {@link Projection} for a given URI, or {@link undefined} if no {@link Projection} is stored for that URI.
* 
* @param {string} crsUri The CRS URI for which to return a {@link Projection}.
* @return {Projection|undefined} A {@link Projection} object, or {@link undefined} if not stored by {@link load} or {@link set}.
* 
* @example
* // has to be stored previously via load() or set()
* var proj = uriproj.get('http://www.opengis.net/def/crs/EPSG/0/27700')
* var [longitude, latitude] = [-1.54, 55.5]
* var [easting,northing] = proj.forward([longitude, latitude])
*/
function get(crsUri) {
 return projCache[crsUri];
}
6708
/**
* Returns a {@link Promise} that succeeds with an already stored {@link Projection} or, if not stored,
* that remotely loads the {@link Projection} (currently using https://epsg.io), stores it, and then succeeds with it.
* 
* @param {string} crsUri The CRS URI for which to return a projection.
* @return {Promise<Projection,Error>} A {@link Promise} object succeeding with a {@link Projection} object,
*   and failing with an {@link Error} object in case of network or PROJ.4 parsing problems.
* 
* @example <caption>Loading a single projection</caption>
* uriproj.load('http://www.opengis.net/def/crs/EPSG/0/27700').then(proj => {
*   var [longitude, latitude] = [-1.54, 55.5]
*   var [easting,northing] = proj.forward([longitude, latitude])
* })
* 
* @example <caption>Loading multiple projections</caption>
* var uris = [
*   'http://www.opengis.net/def/crs/EPSG/0/27700',
*   'http://www.opengis.net/def/crs/EPSG/0/7376',
*   'http://www.opengis.net/def/crs/EPSG/0/7375']
* Promise.all(uris.map(uriproj.load)).then(projs => {
*   // all projections are loaded and stored now
*   
*   // get the first projection
*   var proj1 = projs[0]
*   // or:
*   var proj1 = uriproj.get(uris[0])
* })
* 
*/
function load(crsUri) {
 if (crsUri in projCache) {
   return Promise.resolve(projCache[crsUri]);
 }
6742
 var epsg = crsUriToEPSG(crsUri);
 var url = 'https://epsg.io/' + epsg + '.proj4';
6745
 return fetch(url).then(function (response) {
   if (!response.ok) {
     throw new Error('HTTP response code: ' + response.status);
   }
   return response.text();
 }).then(function (proj4string) {
   return set(crsUri, proj4string, { reverseAxes: crsUri in needsAxesReordering });
 });
}
6755
/**
* Stores a given projection for a given URI that can then be accessed via {@link get} and {@link load}.
* 
* @param {string} crsUri The CRS URI for which to store the projection.
* @param {string|Projection} proj A proj4 string or a {@link Projection} object.
* @param {Object} [options] Options object.
* @param {boolean} [options.reverseAxes=false] If proj is a proj4 string, whether to reverse the projection axes.
* @return {Projection} The newly stored projection.
* @throws {Error} If crsUri or proj is missing, or if a PROJ.4 string cannot be parsed by proj4js. 
* 
* @example <caption>Storing a projection using a PROJ.4 string</caption>
* var uri = 'http://www.opengis.net/def/crs/EPSG/0/27700'
* var proj4 = '+proj=tmerc +lat_0=49 +lon_0=-2 +k=0.9996012717 +x_0=400000 +y_0=-100000 ' +
*   '+ellps=airy +towgs84=446.448,-125.157,542.06,0.15,0.247,0.842,-20.489 +units=m +no_defs'
* uriproj.set(uri, proj4)
* 
* @example <caption>Storing a projection using a Projection object</caption>
* var uri = 'http://www.opengis.net/def/crs/EPSG/0/27700'
* var proj = {
*   forward: ([lon,lat]) => [..., ...],
*   inverse: ([x,y]) => [..., ...]
* }
* uriproj.set(uri, proj)
*/
function set(crsUri, proj) {
 var options = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];
6782
 if (!crsUri || !proj) {
   throw new Error('crsUri and proj cannot be empty');
 }
 var projobj = void 0;
 if (typeof proj === 'string') {
   projobj = (0, _proj2.default)(proj);
   if (!projobj) {
     throw new Error('Unsupported proj4 string: ' + proj);
   }
   if (options.reverseAxes) {
     projobj = reverseAxes(projobj);
   }
 } else {
   projobj = proj;
 }
 projCache[crsUri] = projobj;
 return projobj;
}
6801
/**
* Return the EPSG code of an OGC CRS URI of the form
* http://www.opengis.net/def/crs/EPSG/0/1234 (would return 1234).
* 
* @param {string} crsUri The CRS URI for which to return the EPSG code.
* @return {string} The EPSG code.
*/
function crsUriToEPSG(uri) {
 var epsg = void 0;
 if (uri.indexOf(EPSG_PREFIX) === 0) {
   epsg = uri.substr(EPSG_PREFIX.length);
 } else {
   throw new Error('Unsupported CRS URI: ' + uri);
 }
6816
 return epsg;
}
6819
/**
* Reverses projection axis order.
* 
* For example, a projection with lon, lat axis order is turned into one with lat, lon order.
* This is necessary since geographic projections in proj4 can only be defined with
* lon,lat order, however some CRSs have lat,lon order (like EPSG4326).
* Incorrectly, epsg.io returns a proj4 string (with lon,lat order) even if the CRS
* has lat,lon order. This function manually flips the axis order of a given projection.
* See also `needsAxesReordering` above.
* 
* @param {Projection} proj The projection whose axis order to revert.
* @return {Projection} The projection with reversed axis order.
*/
function reverseAxes(proj) {
 return {
   forward: function forward(pos) {
     return proj.forward(pos).reverse();
   },
   inverse: function inverse(pos) {
     return proj.inverse([pos[1], pos[0]]);
   }
 };
}
});
6844
var load = index.load;
var get$1 = index.get;
6847
var _LongitudeAxisIndex;
6849
var OPENGIS_CRS_PREFIX = 'http://www.opengis.net/def/crs/';
6851
/** 3D WGS84 in lat-lon-height order */
var EPSG4979 = OPENGIS_CRS_PREFIX + 'EPSG/0/4979';
6854
/** 2D WGS84 in lat-lon order */
var EPSG4326 = OPENGIS_CRS_PREFIX + 'EPSG/0/4326';
6857
/** 2D WGS84 in lon-lat order */
var CRS84 = OPENGIS_CRS_PREFIX + 'OGC/1.3/CRS84';
6860
/** CRSs in which position is specified by geodetic latitude and longitude */
var GeographicCRSs = [EPSG4979, EPSG4326, CRS84];
6863
/** Position of longitude axis */
var LongitudeAxisIndex = (_LongitudeAxisIndex = {}, defineProperty(_LongitudeAxisIndex, EPSG4979, 1), defineProperty(_LongitudeAxisIndex, EPSG4326, 1), defineProperty(_LongitudeAxisIndex, CRS84, 0), _LongitudeAxisIndex);
6866
/**
* Return the reference system connection object for the given domain coordinate ID,
* or undefined if none exists.
*/
function getReferenceObject(domain, coordinateId) {
 var ref = domain.referencing.find(function (ref) {
   return ref.coordinates.indexOf(coordinateId) !== -1;
 });
 return ref;
}
6877
/**
* Return the reference system connection object of the horizontal CRS of the domain,
* or ``undefined`` if none found.
* A horizontal CRS is either geodetic (typically ellipsoidal, meaning lat/lon)
* or projected, and may be 2D or 3D (including height).
*/
function getHorizontalCRSReferenceObject(domain) {
 var isHorizontal = function isHorizontal(ref) {
   return ['GeodeticCRS', 'GeographicCRS', 'GeocentricCRS', 'ProjectedCRS'].indexOf(ref.system.type) !== -1;
 };
 var ref = domain.referencing.find(isHorizontal);
 return ref;
}
6891
/**
* Return whether the reference system is a CRS in which
* horizontal position is specified by geodetic latitude and longitude.
*/
function isEllipsoidalCRS(rs) {
 return rs.type === 'GeographicCRS' || GeographicCRSs.indexOf(rs.id) !== -1;
}
6899
/**
* Return a projection object based on the CRS found in the coverage domain.
* If no CRS is found or it is unsupported, then ``undefined`` is returned.
* For non-built-in projections, this function returns already-cached projections
* that were loaded via {@link loadProjection}.
*
* A projection converts between geodetic lat/lon and projected x/y values.
*
* For lat/lon CRSs the projection is defined such that an input lat/lon
* position gets projected/wrapped to the longitude range used in the domain, for example
* [0,360]. The purpose of this is to make intercomparison between different coverages easier.
*
* The following limitations currently apply:
* - only primitive axes and Tuple/Polygon composite axes are supported for lat/lon CRSs
*
* @param {Domain} domain A coverage domain object.
* @return {IProjection} A stripped-down Leaflet IProjection object.
*/
function getProjection(domain) {
 var isEllipsoidal = domain.referencing.some(function (ref) {
   return isEllipsoidalCRS(ref.system);
 });
 if (isEllipsoidal) {
   return getLonLatProjection(domain);
 }
6925
 // try to get projection via uriproj library
 var ref = getHorizontalCRSReferenceObject(domain);
 if (!ref) {
   throw new Error('No horizontal CRS found in coverage domain');
 }
6931
 var uri = ref.system.id;
 var proj = get$1(uri);
 if (!proj) {
   throw new Error('Projection ' + uri + ' not cached in uriproj, use loadProjection() instead');
 }
 return wrapProj4(proj);
}
6939
/**
* Like {@link getProjection} but will also try to remotely load a projection definition via the uriproj library.
* On success, the loaded projection is automatically cached for later use and can be directly requested
* with {@link getProjection}.
*
* @param {Domain} domain A coverage domain object.
* @return {Promise<IProjection>} A Promise succeeding with a stripped-down Leaflet IProjection object.
*/
function loadProjection(domain) {
 try {
   // we try the local one first so that we get our special lon/lat projection (which doesn't exist in uriproj)
   return getProjection(domain);
 } catch (e) {}
6953
 // try to load projection remotely via uriproj library
 var ref = getHorizontalCRSReferenceObject(domain);
 if (!ref) {
   throw new Error('No horizontal CRS found in coverage domain');
 }
6959
 var uri = ref.system.id;
 return load(uri).then(function (proj) {
   return wrapProj4(proj);
 });
}
6965
/**
* Return the coordinate IDs of the horizontal CRS of the domain.
*
* @deprecated use getHorizontalCRSCoordinateIDs
* @example
* var [xComp,yComp] = getHorizontalCRSComponents(domain)
*/
function getHorizontalCRSComponents(domain) {
 return getHorizontalCRSCoordinateIDs(domain);
}
6976
/**
* Return the coordinate IDs of the horizontal CRS of the domain.
*
* @example
* var [xComp,yComp] = getHorizontalCRSCoordinateIDs(domain)
*/
function getHorizontalCRSCoordinateIDs(domain) {
 var ref = getHorizontalCRSReferenceObject(domain);
 return ref.coordinates;
}
6987
/**
* Wraps a proj4 Projection object into an IProjection object.
*/
function wrapProj4(proj) {
 return {
   project: function project(_ref) {
     var lon = _ref.lon;
     var lat = _ref.lat;
6996
     var _proj$forward = proj.forward([lon, lat]);
6998
     var _proj$forward2 = slicedToArray(_proj$forward, 2);
7000
     var x = _proj$forward2[0];
     var y = _proj$forward2[1];
7003
     return { x: x, y: y };
   },
   unproject: function unproject(_ref2) {
     var x = _ref2.x;
     var y = _ref2.y;
7009
     var _proj$inverse = proj.inverse([x, y]);
7011
     var _proj$inverse2 = slicedToArray(_proj$inverse, 2);
7013
     var lon = _proj$inverse2[0];
     var lat = _proj$inverse2[1];
7016
     return { lon: lon, lat: lat };
   }
 };
}
7021
function getLonLatProjection(domain) {
 var ref = domain.referencing.find(function (ref) {
   return isEllipsoidalCRS(ref.system);
 });
 var lonIdx = LongitudeAxisIndex[ref.system.id];
 if (lonIdx > 1) {
   // this should never happen as longitude is always the first or second axis
   throw new Error();
 }
7031
 var lonComponent = ref.coordinates[lonIdx];
7033
 // we find the min and max longitude occuring in the domain by inspecting the axis values
 // Note: this is inefficient for big composite axes.
 //       In that case, something like a domain extent might help which has the min/max values for each component.
 // TODO handle bounds
 var lonMin = void 0,
     lonMax = void 0;
 if (domain.axes.has(lonComponent)) {
   // longitude is a grid axis
   var lonAxisName = lonComponent;
   var lonAxisVals = domain.axes.get(lonAxisName).values;
   lonMin = lonAxisVals[0];
   lonMax = lonAxisVals[lonAxisVals.length - 1];
   if (lonMin > lonMax) {
     var _ref3 = [lonMax, lonMin];
     lonMin = _ref3[0];
     lonMax = _ref3[1];
   }
 } else {
   // TODO there should be no dependency to CovJSON
7053
   // longitude is not a primitive grid axis but a component of a composite axis
7055
   // find the composite axis containing the longitude component
   var axes = [].concat(toConsumableArray(domain.axes.values()));
   var axis = axes.find(function (axis) {
     return axis.coordinates.indexOf(lonComponent) !== -1;
   });
   var lonCompIdx = axis.coordinates.indexOf(lonComponent);
7062
   // scan the composite axis for min/max longitude values
   lonMin = Infinity;
   lonMax = -Infinity;
   if (axis.dataType === COVJSON_DATATYPE_TUPLE) {
     var _iteratorNormalCompletion = true;
     var _didIteratorError = false;
     var _iteratorError = undefined;
7070
     try {
       for (var _iterator = axis.values[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
         var tuple = _step.value;
7074
         var lon = tuple[lonCompIdx];
         lonMin = Math.min(lon, lonMin);
         lonMax = Math.max(lon, lonMax);
       }
     } catch (err) {
       _didIteratorError = true;
       _iteratorError = err;
     } finally {
       try {
         if (!_iteratorNormalCompletion && _iterator.return) {
           _iterator.return();
         }
       } finally {
         if (_didIteratorError) {
           throw _iteratorError;
         }
       }
     }
   } else if (axis.dataType === COVJSON_DATATYPE_POLYGON) {
     var _iteratorNormalCompletion2 = true;
     var _didIteratorError2 = false;
     var _iteratorError2 = undefined;
7097
     try {
       for (var _iterator2 = axis.values[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
         var poly = _step2.value;
         var _iteratorNormalCompletion3 = true;
         var _didIteratorError3 = false;
         var _iteratorError3 = undefined;
7104
         try {
           for (var _iterator3 = poly[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
             var ring = _step3.value;
             var _iteratorNormalCompletion4 = true;
             var _didIteratorError4 = false;
             var _iteratorError4 = undefined;
7111
             try {
               for (var _iterator4 = ring[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
                 var point = _step4.value;
7115
                 var _lon = point[lonCompIdx];
                 lonMin = Math.min(_lon, lonMin);
                 lonMax = Math.max(_lon, lonMax);
               }
             } catch (err) {
               _didIteratorError4 = true;
               _iteratorError4 = err;
             } finally {
               try {
                 if (!_iteratorNormalCompletion4 && _iterator4.return) {
                   _iterator4.return();
                 }
               } finally {
                 if (_didIteratorError4) {
                   throw _iteratorError4;
                 }
               }
             }
           }
         } catch (err) {
           _didIteratorError3 = true;
           _iteratorError3 = err;
         } finally {
           try {
             if (!_iteratorNormalCompletion3 && _iterator3.return) {
               _iterator3.return();
             }
           } finally {
             if (_didIteratorError3) {
               throw _iteratorError3;
             }
           }
         }
       }
     } catch (err) {
       _didIteratorError2 = true;
       _iteratorError2 = err;
     } finally {
       try {
         if (!_iteratorNormalCompletion2 && _iterator2.return) {
           _iterator2.return();
         }
       } finally {
         if (_didIteratorError2) {
           throw _iteratorError2;
         }
       }
     }
   } else {
     throw new Error('Unsupported data type: ' + axis.dataType);
   }
 }
7168
 var lonMid = (lonMax + lonMin) / 2;
 var lonMinExtended = lonMid - 180;
 var lonMaxExtended = lonMid + 180;
7172
 return {
   project: function project(_ref4) {
     var lon = _ref4.lon;
     var lat = _ref4.lat;
7177
     var lonProjected = void 0;
     if (lonMinExtended <= lon && lon <= lonMaxExtended) {
       // use unchanged to avoid introducing rounding errors
       lonProjected = lon;
     } else {
       lonProjected = ((lon - lonMinExtended) % 360 + 360) % 360 + lonMinExtended;
     }
7185
     var _ref5 = lonIdx === 0 ? [lonProjected, lat] : [lat, lonProjected];
7187
     var _ref6 = slicedToArray(_ref5, 2);
7189
     var x = _ref6[0];
     var y = _ref6[1];
7192
     return { x: x, y: y };
   },
   unproject: function unproject(_ref7) {
     var x = _ref7.x;
     var y = _ref7.y;
7198
     var _ref8 = lonIdx === 0 ? [x, y] : [y, x];
7200
     var _ref9 = slicedToArray(_ref8, 2);
7202
     var lon = _ref9[0];
     var lat = _ref9[1];
7205
     return { lon: lon, lat: lat };
   }
 };
}
7210
/**
* Reprojects coordinates from one projection to another.
*/
function reprojectCoords(pos, fromProjection, toProjection) {
 return toProjection.project(fromProjection.unproject(pos));
}
7217
/**
* Returns a function which converts an arbitrary longitude to the
* longitude extent used in the coverage domain.
* This only supports primitive axes since this is what subsetByValue supports.
* The longitude extent is extended to 360 degrees if the actual extent is smaller.
* The extension is done equally on both sides of the extent.
*
* For example, the domain may have longitudes within [0,360].
* An input longitude of -70 is converted to 290.
* All longitudes within [0,360] are returned unchanged.
*
* If the domain has longitudes within [10,50] then the
* extended longitude range is [-150,210] (-+180 from the middle point).
* An input longitude of -170 is converted to 190.
* All longitudes within [-150,210] are returned unchanged.
*
* @ignore
*/
function getLongitudeWrapper(domain, axisName) {
 // TODO deprecate this in favour of getProjection, check leaflet-coverage
7238
 // for primitive axes, the axis identifier = component identifier
 if (!isLongitudeAxis(domain, axisName)) {
   throw new Error('\'' + axisName + '\' is not a longitude axis');
 }
7243
 var vals = domain.axes.get(axisName).values;
 var lon_min = vals[0];
 var lon_max = vals[vals.length - 1];
 if (lon_min > lon_max) {
   var _ref10 = [lon_max, lon_min];
   lon_min = _ref10[0];
   lon_max = _ref10[1];
 }
7252
 var x_mid = (lon_max + lon_min) / 2;
 var x_min = x_mid - 180;
 var x_max = x_mid + 180;
7256
 return function (lon) {
   if (x_min <= lon && lon <= x_max) {
     // directly return to avoid introducing rounding errors
     return lon;
   } else {
     return ((lon - x_min) % 360 + 360) % 360 + x_min;
   }
 };
}
7266
/**
* Return whether the given domain axis represents longitudes.
*
* @ignore
*/
function isLongitudeAxis(domain, axisName) {
 var ref = getReferenceObject(domain, axisName);
 if (!ref) {
   return false;
 }
7277
 var crsId = ref.system.id;
 // TODO should support unknown CRSs with embedded axis information
 if (GeographicCRSs.indexOf(crsId) === -1) {
   // this also covers the case when there is no ID property
   return false;
 }
7284
 var compIdx = ref.coordinates.indexOf(axisName);
 var isLongitude = LongitudeAxisIndex[crsId] === compIdx;
 return isLongitude;
}
7289
/**
* Returns true if the given axis has ISO8601 date strings
* as axis values.
*/
function isISODateAxis(domain, axisName) {
 var val = domain.axes.get(axisName).values[0];
 if (typeof val !== 'string') {
   return false;
 }
 return !isNaN(new Date(val).getTime());
}
7301
function asTime(inp) {
 var res = void 0;
 var err = false;
 if (typeof inp === 'string') {
   res = new Date(inp).getTime();
 } else if (inp instanceof Date) {
   res = inp.getTime();
 } else {
   err = true;
 }
 if (isNaN(res)) {
   err = true;
 }
 if (err) {
   throw new Error('Invalid date: ' + inp);
 }
 return res;
}
7320
/**
* After normalization, all constraints are start,stop,step objects.
* It holds that stop > start, step > 0, start >= 0, stop >= 1.
* For each axis, a constraint exists.
*/
function normalizeIndexSubsetConstraints(domain, constraints) {
 // check and normalize constraints to simplify code
 var normalizedConstraints = {};
 for (var axisName in constraints) {
   if (!domain.axes.has(axisName)) {
     // TODO clarify cov behaviour in the JS API spec
     continue;
   }
   if (constraints[axisName] === undefined || constraints[axisName] === null) {
     continue;
   }
   if (typeof constraints[axisName] === 'number') {
     var constraint = constraints[axisName];
     normalizedConstraints[axisName] = { start: constraint, stop: constraint + 1 };
   } else {
     normalizedConstraints[axisName] = constraints[axisName];
   }
7343
   var _normalizedConstraint = normalizedConstraints[axisName];
   var _normalizedConstraint2 = _normalizedConstraint.start;
   var start = _normalizedConstraint2 === undefined ? 0 : _normalizedConstraint2;
   var _normalizedConstraint3 = _normalizedConstraint.stop;
   var stop = _normalizedConstraint3 === undefined ? domain.axes.get(axisName).values.length : _normalizedConstraint3;
   var _normalizedConstraint4 = _normalizedConstraint.step;
   var step = _normalizedConstraint4 === undefined ? 1 : _normalizedConstraint4;
7351
   if (step <= 0) {
     throw new Error('Invalid constraint for ' + axisName + ': step=' + step + ' must be > 0');
   }
   if (start >= stop || start < 0) {
     throw new Error('Invalid constraint for ' + axisName + ': stop=' + stop + ' must be > start=' + start + ' and both >= 0');
   }
   normalizedConstraints[axisName] = { start: start, stop: stop, step: step };
 }
 var _iteratorNormalCompletion = true;
 var _didIteratorError = false;
 var _iteratorError = undefined;
7363
 try {
   for (var _iterator = domain.axes.keys()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
     var _axisName = _step.value;
7367
     if (!(_axisName in normalizedConstraints)) {
       var len = domain.axes.get(_axisName).values.length;
       normalizedConstraints[_axisName] = { start: 0, stop: len, step: 1 };
     }
   }
 } catch (err) {
   _didIteratorError = true;
   _iteratorError = err;
 } finally {
   try {
     if (!_iteratorNormalCompletion && _iterator.return) {
       _iterator.return();
     }
   } finally {
     if (_didIteratorError) {
       throw _iteratorError;
     }
   }
 }
7387
 return normalizedConstraints;
}
7390
function subsetDomainByIndex(domain, constraints) {
 constraints = normalizeIndexSubsetConstraints(domain, constraints);
7393
 // subset the axis arrays of the domain (immediately + cached)
 var newdomain = {
   type: DOMAIN,
   domainType: domain.domainType,
   axes: new Map(domain.axes),
   referencing: domain.referencing
 };
7401
 var _iteratorNormalCompletion2 = true;
 var _didIteratorError2 = false;
 var _iteratorError2 = undefined;
7405
 try {
   var _loop = function _loop() {
     var axisName = _step2.value;
7409
     var axis = domain.axes.get(axisName);
     var coords = axis.values;
     var bounds = axis.bounds;
     var constraint = constraints[axisName];
     var newcoords = void 0;
     var newbounds = void 0;
7416
     var start = constraint.start;
     var stop = constraint.stop;
     var step = constraint.step;
7420
     if (start === 0 && stop === coords.length && step === 1) {
       newcoords = coords;
       newbounds = bounds;
     } else if (step === 1) {
       // TypedArray has subarray which creates a view, while Array has slice which makes a copy
       if (coords.subarray) {
         newcoords = coords.subarray(start, stop);
       } else {
         newcoords = coords.slice(start, stop);
       }
       if (bounds) {
         newbounds = {
           get: function get(i) {
             return bounds.get(start + i);
           }
         };
       }
     } else {
       var q = Math.trunc((stop - start) / step);
       var r = (stop - start) % step;
       var len = q + r;
       newcoords = new coords.constructor(len); // array or typed array
       for (var i = start, j = 0; i < stop; i += step, j++) {
         newcoords[j] = coords[i];
       }
       if (bounds) {
         newbounds = {
           get: function get(i) {
             return bounds.get(start + i * step);
           }
         };
       }
     }
7454
     var newaxis = {
       dataType: axis.dataType,
       coordinates: axis.coordinates,
       values: newcoords,
       bounds: newbounds
     };
     newdomain.axes.set(axisName, newaxis);
   };
7463
   for (var _iterator2 = Object.keys(constraints)[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
     _loop();
   }
 } catch (err) {
   _didIteratorError2 = true;
   _iteratorError2 = err;
 } finally {
   try {
     if (!_iteratorNormalCompletion2 && _iterator2.return) {
       _iterator2.return();
     }
   } finally {
     if (_didIteratorError2) {
       throw _iteratorError2;
     }
   }
 }
7481
 return newdomain;
}
7484
/**
* Returns a copy of the grid coverage subsetted to the given bounding box.
*
* Any grid cell is included which intersects with the bounding box.
*
* @param {Coverage} cov A Coverage object with domain Grid.
* @param {array} bbox [xmin,ymin,xmax,ymax] in native CRS coordinates.
* @param {array} [axes=['x','y']] Axis names [x,y].
* @returns {Promise<Coverage>} A promise with a Coverage object as result.
*/
function subsetByBbox(cov, bbox) {
 var _cov$subsetByValue;
7497
 var axes = arguments.length <= 2 || arguments[2] === undefined ? ['x', 'y'] : arguments[2];
7499
 var _bbox = slicedToArray(bbox, 4);
7501
 var xmin = _bbox[0];
 var ymin = _bbox[1];
 var xmax = _bbox[2];
 var ymax = _bbox[3];
7506
 return cov.subsetByValue((_cov$subsetByValue = {}, defineProperty(_cov$subsetByValue, axes[0], { start: xmin, stop: xmax }), defineProperty(_cov$subsetByValue, axes[1], { start: ymin, stop: ymax }), _cov$subsetByValue));
}
7509
/**
* Generic subsetByIndex function that can be used when building new Coverage objects.
*
* @example
* var cov = {
*   type: 'Coverage',
*   ...
*   subsetByIndex: constraints => CovUtils.subsetByIndex(cov, constraints)
* }
*/
function subsetByIndex(cov, constraints) {
 return cov.loadDomain().then(function (domain) {
   constraints = normalizeIndexSubsetConstraints(domain, constraints);
   var newdomain = subsetDomainByIndex(domain, constraints);
7524
   // subset ranges (on request)
   var rangeWrapper = function rangeWrapper(range) {
     var newrange = {
       dataType: range.dataType,
       get: function get(obj) {
         // translate subsetted to original indices
         var newobj = {};
         var _iteratorNormalCompletion = true;
         var _didIteratorError = false;
         var _iteratorError = undefined;
7535
         try {
           for (var _iterator = Object.keys(obj)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
             var axisName = _step.value;
             var _constraints$axisName = constraints[axisName];
             var start = _constraints$axisName.start;
             var step = _constraints$axisName.step;
7542
             newobj[axisName] = start + obj[axisName] * step;
           }
         } catch (err) {
           _didIteratorError = true;
           _iteratorError = err;
         } finally {
           try {
             if (!_iteratorNormalCompletion && _iterator.return) {
               _iterator.return();
             }
           } finally {
             if (_didIteratorError) {
               throw _iteratorError;
             }
           }
         }
7559
         return range.get(newobj);
       }
     };
     newrange.shape = new Map();
     var _iteratorNormalCompletion2 = true;
     var _didIteratorError2 = false;
     var _iteratorError2 = undefined;
7567
     try {
       for (var _iterator2 = domain.axes.keys()[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
         var axisName = _step2.value;
7571
         var size = newdomain.axes.get(axisName).values.length;
         newrange.shape.set(axisName, size);
       }
     } catch (err) {
       _didIteratorError2 = true;
       _iteratorError2 = err;
     } finally {
       try {
         if (!_iteratorNormalCompletion2 && _iterator2.return) {
           _iterator2.return();
         }
       } finally {
         if (_didIteratorError2) {
           throw _iteratorError2;
         }
       }
     }
7589
     return newrange;
   };
7592
   var loadRange = function loadRange(key) {
     return cov.loadRange(key).then(rangeWrapper);
   };
7596
   var loadRanges = function loadRanges(keys) {
     return cov.loadRanges(keys).then(function (ranges) {
       return new Map([].concat(toConsumableArray(ranges)).map(function (_ref) {
         var _ref2 = slicedToArray(_ref, 2);
7601
         var key = _ref2[0];
         var range = _ref2[1];
         return [key, rangeWrapper(range)];
       }));
     });
   };
7608
   // assemble everything to a new coverage
   var newcov = {
     type: COVERAGE,
     domainType: cov.domainType,
     parameters: cov.parameters,
     loadDomain: function loadDomain() {
       return Promise.resolve(newdomain);
     },
     loadRange: loadRange,
     loadRanges: loadRanges
   };
   newcov.subsetByIndex = subsetByIndex.bind(null, newcov);
   newcov.subsetByValue = subsetByValue.bind(null, newcov);
   return newcov;
 });
}
7625
/**
* Generic subsetByValue function that can be used when building new Coverage objects.
* Requires cov.subsetByIndex function.
*
* @example
* var cov = {
*   type: 'Coverage',
*   ...
*   subsetByValue: constraints => CovUtils.subsetByValue(cov, constraints)
* }
*/
function subsetByValue(cov, constraints) {
 return cov.loadDomain().then(function (domain) {
   // calculate indices and use subsetByIndex
   var indexConstraints = {};
7641
   var _iteratorNormalCompletion3 = true;
   var _didIteratorError3 = false;
   var _iteratorError3 = undefined;
7645
   try {
     for (var _iterator3 = Object.keys(constraints)[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
       var axisName = _step3.value;
7649
       var spec = constraints[axisName];
       if (spec === undefined || spec === null || !domain.axes.has(axisName)) {
         continue;
       }
       var axis = domain.axes.get(axisName);
       var vals = axis.values;
7656
       // special-case handling
       var isISODate = isISODateAxis(domain, axisName);
       var isLongitude = isLongitudeAxis(domain, axisName);
7660
       // wrap input longitudes into longitude range of domain axis
       var lonWrapper = isLongitude ? getLongitudeWrapper(domain, axisName) : undefined;
7663
       if (typeof spec === 'number' || typeof spec === 'string' || spec instanceof Date) {
         var match = spec;
         if (isISODate) {
           // convert times to numbers before searching
           match = asTime(match);
           vals = vals.map(function (v) {
             return new Date(v).getTime();
           });
         } else if (isLongitude) {
           match = lonWrapper(match);
         }
         var i = void 0;
         // older browsers don't have TypedArray.prototype.indexOf
         if (vals.indexOf) {
           i = vals.indexOf(match);
         } else {
           i = Array.prototype.indexOf.call(vals, match);
         }
         if (i === -1) {
           throw new Error('Domain value not found: ' + spec);
         }
         indexConstraints[axisName] = i;
       } else if ('target' in spec) {
         // find index of value closest to target
         var target = spec.target;
         if (isISODate) {
           // convert times to numbers before searching
           target = asTime(target);
           vals = vals.map(function (v) {
             return new Date(v).getTime();
           });
         } else if (isLongitude) {
           target = lonWrapper(target);
         } else if (typeof vals[0] !== 'number' || typeof target !== 'number') {
           throw new Error('Invalid axis or constraint value type');
         }
         var _i = indexOfNearest(vals, target);
         indexConstraints[axisName] = _i;
       } else if ('start' in spec && 'stop' in spec) {
         // TODO what about bounds?
7704
         var start = spec.start;
         var stop = spec.stop;
7707
         if (isISODate) {
           var _ref3 = [asTime(start), asTime(stop)];
           // convert times to numbers before searching
7711
           start = _ref3[0];
           stop = _ref3[1];
7714
           vals = vals.map(function (v) {
             return new Date(v).getTime();
           });
         } else if (isLongitude) {
           var _ref4 = [lonWrapper(start), lonWrapper(stop)];
           start = _ref4[0];
           stop = _ref4[1];
         } else if (typeof vals[0] !== 'number' || typeof start !== 'number') {
           throw new Error('Invalid axis or constraint value type');
         }
7725
         var _indicesOfNearest = indicesOfNearest(vals, start);
7727
         var _indicesOfNearest2 = slicedToArray(_indicesOfNearest, 2);
7729
         var lo1 = _indicesOfNearest2[0];
         var hi1 = _indicesOfNearest2[1];
7732
         var _indicesOfNearest3 = indicesOfNearest(vals, stop);
7734
         var _indicesOfNearest4 = slicedToArray(_indicesOfNearest3, 2);
7736
         var lo2 = _indicesOfNearest4[0];
         var hi2 = _indicesOfNearest4[1];
7739
         // cov is a bit arbitrary and may include one or two indices too much
         // (but since we don't handle bounds it doesn't matter that much)
7742
         var imin = Math.min(lo1, hi1, lo2, hi2);
         var imax = Math.max(lo1, hi1, lo2, hi2) + 1; // subsetByIndex is exclusive
7745
         indexConstraints[axisName] = { start: imin, stop: imax };
       } else {
         throw new Error('Invalid subset constraints');
       }
     }
   } catch (err) {
     _didIteratorError3 = true;
     _iteratorError3 = err;
   } finally {
     try {
       if (!_iteratorNormalCompletion3 && _iterator3.return) {
         _iterator3.return();
       }
     } finally {
       if (_didIteratorError3) {
         throw _iteratorError3;
       }
     }
   }
7765
   return cov.subsetByIndex(indexConstraints);
 });
}
7769
/**
* Wraps a Domain into a Coverage object by adding dummy parameter and range data.
*
* @param {Domain} domain the Domain object
* @param {array} [options.gridAxes] The horizontal grid axis names, used for checkerboard pattern.
* @return {Coverage}
*/
function fromDomain(domain) {
 var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
7779
 checkDomain(domain);
7781
 var _options$gridAxes = options.gridAxes;
 _options$gridAxes = _options$gridAxes === undefined ? ['x', 'y'] : _options$gridAxes;
7784
 var _options$gridAxes2 = slicedToArray(_options$gridAxes, 2);
7786
 var x = _options$gridAxes2[0];
 var y = _options$gridAxes2[1];
7789
7790
 var dummyKey = 'domain';
 var dummyLabel = 'Domain';
7793
 var assumeGrid = domain.axes.has(x) && domain.axes.has(y) && (domain.axes.get(x).values.length > 1 || domain.axes.get(y).values.length > 1);
 var categories = void 0;
 var categoryEncoding = void 0;
 var a = 'a';
 var av = 0;
 var b = 'b';
 var bv = 1;
 if (assumeGrid) {
   categories = [{
     id: a,
     label: { en: 'A' }
   }, {
     id: b,
     label: { en: 'B' }
   }];
   categoryEncoding = new Map([[a, [av]], [b, [bv]]]);
 } else {
   categories = [{
     id: a,
     label: { en: 'X' }
   }];
   categoryEncoding = new Map([[a, [av]]]);
 }
7817
 var parameters = new Map();
 parameters.set(dummyKey, {
   key: dummyKey,
   observedProperty: {
     label: { en: dummyLabel },
     categories: categories
   },
   categoryEncoding: categoryEncoding
 });
7827
 var shape = new Map([].concat(toConsumableArray(domain.axes)).map(function (_ref) {
   var _ref2 = slicedToArray(_ref, 2);
7830
   var name = _ref2[0];
   var axis = _ref2[1];
   return [name, axis.values.length];
 }));
7835
 var get = void 0;
 if (assumeGrid) {
   (function () {
     // checkerboard pattern to see grid cells
     var isOdd = function isOdd(n) {
       return n % 2;
     };
     get = function get(_ref3) {
       var _ref3$x = _ref3.x;
       var x = _ref3$x === undefined ? 0 : _ref3$x;
       var _ref3$y = _ref3.y;
       var y = _ref3$y === undefined ? 0 : _ref3$y;
       return isOdd(x + y) ? av : bv;
     };
   })();
 } else {
   get = function get() {
     return av;
   };
 }
7856
 var loadRange = function loadRange() {
   return Promise.resolve({
     shape: shape,
     dataType: 'integer',
     get: get
   });
 };
7864
 var cov = {
   type: COVERAGE,
   domainType: domain.domainType,
   parameters: parameters,
   loadDomain: function loadDomain() {
     return Promise.resolve(domain);
   },
   loadRange: loadRange
 };
 addLoadRangesFunction(cov);
 addSubsetFunctions(cov);
 return cov;
}
7878
/**
* Creates a Coverage with a single parameter from an xndarray object.
*
* @example
* var arr = xndarray(new Float64Array(
*   [ 1,2,3,
*     4,5,6 ]), {
*   shape: [2,3],
*   names: ['y','x'],
*   coords: {
*     y: [10,12,14],
*     x: [100,101,102],
*     t: [new Date('2001-01-01')]
*   }
* })
* var cov = CovUtils.fromXndarray(arr, {
*   parameter: {
*     key: 'temperature',
*     observedProperty: {
*       label: {en: 'Air temperature'}
*     },
*     unit: { symbol: '°C' }
*   }
* })
* let param = cov.parameters.get('temperature')
* let unit = param.unit.symbol // °C
* cov.loadRange('temperature').then(temps => {
*   let val = temps.get({x:0, y:1}) // val == 4
* })
*
* @param {xndarray} xndarr - Coordinates must be primitive, not tuples etc.
* @param {object} [options] Options object.
* @param {Parameter} [options.parameter] Specifies the parameter, default parameter has a key of 'p1'.
* @param {string} [options.domainType] A domain type URI.
* @param {Array<object>} [options.referencing] Optional referencing system info,
*   defaults to longitude/latitude in WGS84 for x/y axes and ISO8601 time strings for t axis.
* @return {Coverage}
*/
function fromXndarray(xndarr) {
 var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
 var _options$parameter = options.parameter;
 var parameter = _options$parameter === undefined ? {
   key: 'p1',
   observedProperty: {
     label: { en: 'Parameter 1' }
   }
 } : _options$parameter;
 var referencing = options.referencing;
 var domainType = options.domainType;
7928
7929
 var parameters = new Map();
 parameters.set(parameter.key, parameter);
7932
 // assume lon/lat/ISO time for x/y/t by default, for convenience
 if (!referencing) {
   referencing = [];
   if (xndarr.coords.has('x') && xndarr.coords.has('y')) {
     referencing.push({
       coordinates: ['x', 'y'],
       system: {
         type: 'GeographicCRS',
         id: 'http://www.opengis.net/def/crs/OGC/1.3/CRS84'
       }
     });
   }
   if (xndarr.coords.has('t')) {
     referencing.push({
       coordinates: ['t'],
       system: {
         type: 'TemporalRS',
         calendar: 'Gregorian'
       }
     });
   }
 }
7955
 var axes = new Map();
 var _iteratorNormalCompletion = true;
 var _didIteratorError = false;
 var _iteratorError = undefined;
7960
 try {
   for (var _iterator = xndarr.coords[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
     var _step$value = slicedToArray(_step.value, 2);
7964
     var axisName = _step$value[0];
     var vals1Dnd = _step$value[1];
7967
     var values = new Array(vals1Dnd.size);
     for (var i = 0; i < vals1Dnd.size; i++) {
       values[i] = vals1Dnd.get(i);
     }
     axes.set(axisName, {
       key: axisName,
       coordinates: [axisName],
       values: values
     });
   }
 } catch (err) {
   _didIteratorError = true;
   _iteratorError = err;
 } finally {
   try {
     if (!_iteratorNormalCompletion && _iterator.return) {
       _iterator.return();
     }
   } finally {
     if (_didIteratorError) {
       throw _iteratorError;
     }
   }
 }
7992
 var domain = {
   type: DOMAIN,
   domainType: domainType,
   referencing: referencing,
   axes: axes
 };
7999
 var shape = new Map([].concat(toConsumableArray(domain.axes)).map(function (_ref4) {
   var _ref5 = slicedToArray(_ref4, 2);
8002
   var name = _ref5[0];
   var axis = _ref5[1];
   return [name, axis.values.length];
 }));
 var dataType = xndarr.dtype.indexOf('int') !== -1 ? 'integer' : 'float';
8008
 var loadRange = function loadRange() {
   return Promise.resolve({
     shape: shape,
     dataType: dataType,
     get: xndarr.xget.bind(xndarr)
   });
 };
8016
 var cov = {
   type: COVERAGE,
   domainType: domainType,
   parameters: parameters,
   loadDomain: function loadDomain() {
     return Promise.resolve(domain);
   },
   loadRange: loadRange
 };
 addLoadRangesFunction(cov);
 addSubsetFunctions(cov);
 return cov;
}
8030
function addSubsetFunctions(cov) {
 checkCoverage(cov);
 cov.subsetByIndex = subsetByIndex.bind(null, cov);
 cov.subsetByValue = subsetByValue.bind(null, cov);
}
8036
function addLoadRangesFunction(cov) {
 checkCoverage(cov);
 function loadRanges(keys) {
   if (!keys) {
     keys = cov.parameters.keys();
   }
   return Promise.all([].concat(toConsumableArray(keys)).map(cov.loadRange)).then(function (ranges) {
     return new Map(keys.map(function (key, i) {
       return [key, ranges[i]];
     }));
   });
 }
 cov.loadRanges = loadRanges;
}
8051
/**
* Shallow clone a given object.
*
* Note: This does *not* handle all kinds of objects!
*
* @ignore
*/
function shallowcopy(obj) {
 var copy = void 0;
 if (obj instanceof Map) {
   copy = new Map(obj);
 } else {
   copy = Object.create(Object.getPrototypeOf(obj));
   for (var prop in obj) {
     copy[prop] = obj[prop];
   }
 }
 return copy;
}
8071
/**
* Reproject a coverage.
*
* Reprojecting means returning a new coverage where the horizontal CRS is replaced
* and the horizontal domain coordinates are reprojected.
*
* Current limitations:
* - only point-type coverage domains are supported (Tuple only)
* - only horizontal CRSs (2-dimensional) are supported
* - non-lat/lon CRSs have to be pre-cached with loadProjection()
*
* @param {Coverage} cov The Coverage object to reproject.
* @param {Domain} refDomain The reference domain from which the horizontal CRS is used.
* @returns {Promise<Coverage>} A promise with the reprojected Coverage object as result.
*/
function reproject(cov, refDomain) {
 return cov.loadDomain().then(function (sourceDomain) {
   var sourceRef = getHorizontalCRSReferenceObject(sourceDomain);
   if (sourceRef.coordinates.length > 2) {
     throw new Error('Reprojection not supported for >2D CRSs');
   }
   // check that the CRS coordinate IDs don't refer to grid axes
   if (sourceRef.coordinates.some(sourceDomain.axes.has)) {
     throw new Error('Grid reprojection not supported yet');
   }
8097
   var _sourceRef$coordinate = slicedToArray(sourceRef.coordinates, 2);
8099
   var xComp = _sourceRef$coordinate[0];
   var yComp = _sourceRef$coordinate[1];
8102
   // TODO reproject bounds
8104
   // find the composite axis that contains the horizontal coordinates
8106
   var axes = [].concat(toConsumableArray(sourceDomain.axes.values()));
   var axis = axes.find(function (axis) {
     return sourceRef.coordinates.every(function (comp) {
       return axis.coordinates.indexOf(comp) !== -1;
     });
   });
   var xCompIdx = axis.coordinates.indexOf(xComp);
   var yCompIdx = axis.coordinates.indexOf(yComp);
8115
   // find the target CRS and get the projection
8117
   var sourceProjection = getProjection(sourceDomain);
   var targetProjection = getProjection(refDomain);
8120
   // reproject the x/y part of every axis value
   // this is done by unprojecting to lon/lat, followed by projecting to the target x/y
   var values = void 0;
   if (axis.dataType === COVJSON_DATATYPE_TUPLE) {
     // make a deep copy of the axis values and replace x,y values by the reprojected ones
     values = axis.values.map(function (tuple) {
       return tuple.slice();
     });
     var _iteratorNormalCompletion = true;
     var _didIteratorError = false;
     var _iteratorError = undefined;
8132
     try {
       for (var _iterator = values[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
         var tuple = _step.value;
         var sourceX = tuple[xCompIdx];
         var sourceY = tuple[yCompIdx];
8138
         var latlon = sourceProjection.unproject({ x: sourceX, y: sourceY });
8140
         var _targetProjection$pro = targetProjection.project(latlon);
8142
         var x = _targetProjection$pro.x;
         var y = _targetProjection$pro.y;
8145
         tuple[xCompIdx] = x;
         tuple[yCompIdx] = y;
       }
     } catch (err) {
       _didIteratorError = true;
       _iteratorError = err;
     } finally {
       try {
         if (!_iteratorNormalCompletion && _iterator.return) {
           _iterator.return();
         }
       } finally {
         if (_didIteratorError) {
           throw _iteratorError;
         }
       }
     }
   } else {
     throw new Error('Unsupported data type: ' + axis.dataType);
   }
8166
   // assemble reprojected coverage
   var newAxes = new Map(sourceDomain.axes);
   var newAxis = shallowcopy(axis);
   delete newAxis.bounds;
   newAxis.values = values;
   newAxes.set(axis.key, newAxis);
8173
   var targetRef = getHorizontalCRSReferenceObject(refDomain);
   if (targetRef.coordinates.length > 2) {
     throw new Error('Reprojection not supported for >2D CRSs');
   }
   var newReferencing = sourceDomain.referencing.map(function (ref) {
     if (ref === sourceRef) {
       return {
         coordinates: sourceRef.coordinates,
         system: targetRef.system
       };
     } else {
       return ref;
     }
   });
8188
   var newDomain = {
     type: DOMAIN,
     domainType: sourceDomain.domainType,
     axes: newAxes,
     referencing: newReferencing
   };
8195
   var newCoverage = {
     type: COVERAGE,
     domainType: cov.domainType,
     parameters: cov.parameters,
     loadDomain: function loadDomain() {
       return Promise.resolve(newDomain);
     },
     loadRange: function loadRange(paramKey) {
       return cov.loadRange(paramKey);
     },
     loadRanges: function loadRanges(paramKeys) {
       return cov.loadRanges(paramKeys);
     },
     subsetByIndex: function subsetByIndex(constraints) {
       return cov.subsetByIndex(constraints).then(function (sub) {
         return reproject(sub, refDomain);
       });
     },
     subsetByValue: function subsetByValue(constraints) {
       return cov.subsetByValue(constraints).then(function (sub) {
         return reproject(sub, refDomain);
       });
     }
   };
   return newCoverage;
 });
}
8223
/**
* Returns a copy of the given Coverage object with the parameters
* replaced by the supplied ones.
*
* Note that this is a low-level function and no checks are done on the supplied parameters.
*/
function withParameters(cov, params) {
 var newcov = {
   type: COVERAGE,
   domainType: cov.domainType,
   parameters: params,
   loadDomain: function loadDomain() {
     return cov.loadDomain();
   },
   loadRange: function loadRange(key) {
     return cov.loadRange(key);
   },
   loadRanges: function loadRanges(keys) {
     return cov.loadRanges(keys);
   },
   subsetByIndex: function subsetByIndex(constraints) {
     return cov.subsetByIndex(constraints).then(function (sub) {
       return withParameters(sub, params);
     });
   },
   subsetByValue: function subsetByValue(constraints) {
     return cov.subsetByValue(constraints).then(function (sub) {
       return withParameters(sub, params);
     });
   }
 };
 return newcov;
}
8257
/**
* Returns a copy of the given Coverage object with the categories
* of a given parameter replaced by the supplied ones and the encoding
* adapted to the given mapping from old to new.
*
* @param {Coverage} cov The Coverage object.
* @param {String} key The key of the parameter to work with.
* @param {object} observedProperty The new observed property including the new array of category objects
*                           that will be part of the returned coverage.
* @param {Map<String,String>} mapping A mapping from source category id to destination category id.
* @returns {Coverage}
*/
function withCategories(cov, key, observedProperty, mapping) {
 /* check breaks with Babel, see https://github.com/jspm/jspm-cli/issues/1348
 if (!(mapping instanceof Map)) {
   throw new Error('mapping parameter must be a Map from/to category ID')
 }
 */
 checkCoverage(cov);
 if (observedProperty.categories.some(function (c) {
   return !c.id;
 })) {
   throw new Error('At least one category object is missing the "id" property');
 }
 var newparams = shallowcopy(cov.parameters);
 var newparam = shallowcopy(newparams.get(key));
 newparams.set(key, newparam);
 newparams.get(key).observedProperty = observedProperty;
8286
 var fromCatEnc = cov.parameters.get(key).categoryEncoding;
 var catEncoding = new Map();
 var categories = observedProperty.categories;
 var _iteratorNormalCompletion = true;
 var _didIteratorError = false;
 var _iteratorError = undefined;
8293
 try {
   for (var _iterator = categories[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
     var category = _step.value;
8297
     var vals = [];
     var _iteratorNormalCompletion2 = true;
     var _didIteratorError2 = false;
     var _iteratorError2 = undefined;
8302
     try {
       for (var _iterator2 = mapping[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
         var _step2$value = slicedToArray(_step2.value, 2);
8306
         var fromCatId = _step2$value[0];
         var toCatId = _step2$value[1];
8309
         if (toCatId === category.id && fromCatEnc.has(fromCatId)) {
           vals.push.apply(vals, toConsumableArray(fromCatEnc.get(fromCatId)));
         }
       }
     } catch (err) {
       _didIteratorError2 = true;
       _iteratorError2 = err;
     } finally {
       try {
         if (!_iteratorNormalCompletion2 && _iterator2.return) {
           _iterator2.return();
         }
       } finally {
         if (_didIteratorError2) {
           throw _iteratorError2;
         }
       }
     }
8328
     if (vals.length > 0) {
       catEncoding.set(category.id, vals);
     }
   }
 } catch (err) {
   _didIteratorError = true;
   _iteratorError = err;
 } finally {
   try {
     if (!_iteratorNormalCompletion && _iterator.return) {
       _iterator.return();
     }
   } finally {
     if (_didIteratorError) {
       throw _iteratorError;
     }
   }
 }
8347
 newparams.get(key).categoryEncoding = catEncoding;
8349
 var newcov = withParameters(cov, newparams);
 return newcov;
}
8353
/**
* Returns a new coverage where the domainType field of the coverage and the domain
* is set to the given one.
*
* @param {Coverage} cov The Coverage object.
* @param {String} domainType The new domain type.
* @returns {Coverage}
*/
function withDomainType(cov, domainType) {
 checkCoverage(cov);
8364
 var domainWrapper = function domainWrapper(domain) {
   var newdomain = {
     type: DOMAIN,
     domainType: domainType,
     axes: domain.axes,
     referencing: domain.referencing
   };
   return newdomain;
 };
8374
 var newcov = {
   type: COVERAGE,
   domainType: domainType,
   parameters: cov.parameters,
   loadDomain: function loadDomain() {
     return cov.loadDomain().then(domainWrapper);
   },
   loadRange: function loadRange(key) {
     return cov.loadRange(key);
   },
   loadRanges: function loadRanges(keys) {
     return cov.loadRanges(keys);
   },
   subsetByIndex: function subsetByIndex(constraints) {
     return cov.subsetByIndex(constraints).then(function (sub) {
       return withDomainType(sub, domainType);
     });
   },
   subsetByValue: function subsetByValue(constraints) {
     return cov.subsetByValue(constraints).then(function (sub) {
       return withDomainType(sub, domainType);
     });
   }
 };
 return newcov;
}
8401
/**
* Tries to transform the given Coverage object into a new one that
* conforms to one of the CovJSON domain types.
* If multiple domain types match, then the "smaller" one is preferred,
* for example, Point instead of Grid.
*
* The transformation consists of:
* - Setting domainType in coverage and domain object
* - Renaming domain axes
*
* @see https://github.com/Reading-eScience-Centre/coveragejson/blob/master/domain-types.md
*
* @param {Coverage} cov The Coverage object.
* @returns {Promise<Coverage>}
*   A Promise succeeding with the transformed coverage,
*   or failing if no CovJSON domain type matched the input coverage.
*/
function asCovJSONDomainType(cov) {
 return cov.loadDomain().then(function (domain) {
8421
   // TODO implement me
8423
 });
}
8426
/**
* @example
* var cov = ...
* var mapping = new Map()
* mapping.set('lat', 'y').set('lon', 'x')
* var newcov = CovUtils.renameAxes(cov, mapping)
*
* @param {Coverage} cov The coverage.
* @param {Map<String,String>} mapping
* @returns {Coverage}
*/
function renameAxes(cov, mapping) {
 checkCoverage(cov);
 mapping = new Map(mapping);
 var _iteratorNormalCompletion3 = true;
 var _didIteratorError3 = false;
 var _iteratorError3 = undefined;
8444
 try {
   for (var _iterator3 = cov.axes.keys()[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
     var axisName = _step3.value;
8448
     if (!mapping.has(axisName)) {
       mapping.set(axisName, axisName);
     }
   }
 } catch (err) {
   _didIteratorError3 = true;
   _iteratorError3 = err;
 } finally {
   try {
     if (!_iteratorNormalCompletion3 && _iterator3.return) {
       _iterator3.return();
     }
   } finally {
     if (_didIteratorError3) {
       throw _iteratorError3;
     }
   }
 }
8467
 var domainWrapper = function domainWrapper(domain) {
   var newaxes = new Map();
   var _iteratorNormalCompletion4 = true;
   var _didIteratorError4 = false;
   var _iteratorError4 = undefined;
8473
   try {
     for (var _iterator4 = mapping[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
       var _step4$value = slicedToArray(_step4.value, 2);
8477
       var from = _step4$value[0];
       var to = _step4$value[1];
8480
       var _domain$axes$get = domain.axes.get(from);
8482
       var dataType = _domain$axes$get.dataType;
       var coordinates = _domain$axes$get.coordinates;
       var values = _domain$axes$get.values;
       var bounds = _domain$axes$get.bounds;
8487
       var newaxis = {
         key: to,
         dataType: dataType,
         coordinates: coordinates.map(function (c) {
           return mapping.has(c) ? mapping.get(c) : c;
         }),
         values: values,
         bounds: bounds
       };
       newaxes.set(to, newaxis);
     }
   } catch (err) {
     _didIteratorError4 = true;
     _iteratorError4 = err;
   } finally {
     try {
       if (!_iteratorNormalCompletion4 && _iterator4.return) {
         _iterator4.return();
       }
     } finally {
       if (_didIteratorError4) {
         throw _iteratorError4;
       }
     }
   }
8513
   var newreferencing = domain.referencing.map(function (_ref) {
     var coordinates = _ref.coordinates;
     var system = _ref.system;
     return {
       coordinates: coordinates.map(function (c) {
         return mapping.has(c) ? mapping.get(c) : c;
       }),
       system: system
     };
   });
8524
   var newdomain = {
     type: DOMAIN,
     domainType: domain.domainType,
     axes: newaxes,
     referencing: newreferencing
   };
   return newdomain;
 };
8533
 // pre-compile for efficiency
 // get({['lat']: obj['y'], ['lon']: obj['x']})
 var getObjStr = [].concat(toConsumableArray(mapping)).map(function (_ref2) {
   var _ref3 = slicedToArray(_ref2, 2);
8538
   var from = _ref3[0];
   var to = _ref3[1];
   return '[\'' + from + '\']:obj[\'' + to + '\']';
 }).join(',');
8543
 var rangeWrapper = function rangeWrapper(range) {
   var get = new Function('range', 'return function get (obj){return range.get({' + getObjStr + '})}')(range); // eslint-disable-line
   var newrange = {
     shape: new Map([].concat(toConsumableArray(range.shape)).map(function (_ref4) {
       var _ref5 = slicedToArray(_ref4, 2);
8549
       var name = _ref5[0];
       var len = _ref5[1];
       return [mapping.get(name), len];
     })),
     dataType: range.dataType,
     get: get
   };
   return newrange;
 };
8559
 var loadRange = function loadRange(paramKey) {
   return cov.loadRange(paramKey).then(rangeWrapper);
 };
8563
 var loadRanges = function loadRanges(paramKeys) {
   return cov.loadRanges(paramKeys).then(function (ranges) {
     return new Map([].concat(toConsumableArray(ranges)).map(function (_ref6) {
       var _ref7 = slicedToArray(_ref6, 2);
8568
       var paramKey = _ref7[0];
       var range = _ref7[1];
       return [paramKey, rangeWrapper(range)];
     }));
   });
 };
8575
 var newcov = {
   type: COVERAGE,
   domainType: cov.domainType,
   parameters: cov.parameters,
   loadDomain: function loadDomain() {
     return cov.loadDomain().then(domainWrapper);
   },
   loadRange: loadRange,
   loadRanges: loadRanges,
   subsetByIndex: function subsetByIndex(constraints) {
     return cov.subsetByIndex(constraints).then(function (sub) {
       return renameAxes(sub, mapping);
     });
   },
   subsetByValue: function subsetByValue(constraints) {
     return cov.subsetByValue(constraints).then(function (sub) {
       return renameAxes(sub, mapping);
     });
   }
 };
8596
 return newcov;
}
8599
/**
* @param {Coverage} cov The coverage.
* @param {String} key The key of the parameter for which the mapping should be applied.
* @param {Function} fn A function getting called as fn(obj, range) where obj is the axis indices object
*   and range is the original range object.
* @param {String} [dataType] The new data type to use for the range. If omitted, the original type is used.
* @returns {Coverage}
*/
function mapRange(cov, key, fn, dataType) {
 checkCoverage(cov);
8610
 var rangeWrapper = function rangeWrapper(range) {
   var newrange = {
     shape: range.shape,
     dataType: dataType || range.dataType,
     get: function get(obj) {
       return fn(obj, range);
     }
   };
   return newrange;
 };
8621
 var loadRange = function loadRange(paramKey) {
   return key === paramKey ? cov.loadRange(paramKey).then(rangeWrapper) : cov.loadRange(paramKey);
 };
8625
 var loadRanges = function loadRanges(paramKeys) {
   return cov.loadRanges(paramKeys).then(function (ranges) {
     return new Map([].concat(toConsumableArray(ranges)).map(function (_ref8) {
       var _ref9 = slicedToArray(_ref8, 2);
8630
       var paramKey = _ref9[0];
       var range = _ref9[1];
       return [paramKey, key === paramKey ? rangeWrapper(range) : range];
     }));
   });
 };
8637
 var newcov = {
   type: COVERAGE,
   domainType: cov.domainType,
   parameters: cov.parameters,
   loadDomain: function loadDomain() {
     return cov.loadDomain();
   },
   loadRange: loadRange,
   loadRanges: loadRanges,
   subsetByIndex: function subsetByIndex(constraints) {
     return cov.subsetByIndex(constraints).then(function (sub) {
       return mapRange(sub, key, fn, dataType);
     });
   },
   subsetByValue: function subsetByValue(constraints) {
     return cov.subsetByValue(constraints).then(function (sub) {
       return mapRange(sub, key, fn, dataType);
     });
   }
 };
8658
 return newcov;
}
8661
/**
*
* @example
* var cov = ... // has parameters 'NIR', 'red', 'green', 'blue'
* var newcov = CovUtils.withDerivedParameter(cov, {
*   parameter: {
*     key: 'NDVI',
*     observedProperty: {
*       label: { en: 'Normalized Differenced Vegetation Index' }
*     }
*   },
*   inputParameters: ['NIR','red'],
*   dataType: 'float',
*   fn: function (obj, nirRange, redRange) {
*     var nir = nirRange.get(obj)
*     var red = redRange.get(obj)
*     if (nir === null || red === null) return null
*     return (nir - red) / (nir + red)
*   }
* })
*/
function withDerivedParameter(cov, options) {
 checkCoverage(cov);
 var parameter = options.parameter;
 var inputParameters = options.inputParameters;
 var _options$dataType = options.dataType;
 var dataType = _options$dataType === undefined ? 'float' : _options$dataType;
 var fn = options.fn;
8690
8691
 var parameters = new Map(cov.parameters);
 parameters.set(parameter.key, parameter);
8694
 var loadDerivedRange = function loadDerivedRange() {
   return cov.loadRanges(inputParameters).then(function (inputRanges) {
     var inputRangesArr = inputParameters.map(function (key) {
       return inputRanges.get(key);
     });
     var shape = inputRangesArr[0].shape;
     var range = {
       shape: shape,
       dataType: dataType,
       get: function get(obj) {
         return fn.apply(undefined, [obj].concat(toConsumableArray(inputRangesArr)));
       }
     };
     return range;
   });
 };
8711
 var loadRange = function loadRange(paramKey) {
   return parameter.key === paramKey ? loadDerivedRange() : cov.loadRange(paramKey);
 };
8715
 var newcov = {
   type: COVERAGE,
   domainType: cov.domainType,
   parameters: parameters,
   loadDomain: function loadDomain() {
     return cov.loadDomain();
   },
   loadRange: loadRange,
   subsetByIndex: function subsetByIndex(constraints) {
     return cov.subsetByIndex(constraints).then(function (sub) {
       return withDerivedParameter(sub, options);
     });
   },
   subsetByValue: function subsetByValue(constraints) {
     return cov.subsetByValue(constraints).then(function (sub) {
       return withDerivedParameter(sub, options);
     });
   }
 };
 addLoadRangesFunction(newcov);
8736
 return newcov;
}
8739
/**
*
* @example
* var cov = ... // has parameters 'NIR', 'red', 'green', 'blue'
* var newcov = CovUtils.withSimpleDerivedParameter(cov, {
*   parameter: {
*     key: 'NDVI',
*     observedProperty: {
*       label: { en: 'Normalized Differenced Vegetation Index' }
*     }
*   },
*   inputParameters: ['NIR','red'],
*   dataType: 'float',
*   fn: function (nir, red) {
*     return (nir - red) / (nir + red)
*   }
* })
*/
function withSimpleDerivedParameter(cov, options) {
 var parameter = options.parameter;
 var inputParameters = options.inputParameters;
 var dataType = options.dataType;
 var _fn = options.fn;
8763
 var options_ = {
   parameter: parameter,
   inputParameters: inputParameters,
   dataType: dataType,
   // TODO pre-compile if too slow
   fn: function fn(obj) {
     for (var _len = arguments.length, ranges = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
       ranges[_key - 1] = arguments[_key];
     }
8773
     var vals = inputParameters.map(function (_, i) {
       return ranges[i].get(obj);
     });
     if (vals.some(function (val) {
       return val === null;
     })) {
       return null;
     }
     return _fn.apply(undefined, toConsumableArray(vals));
   }
 };
 return withDerivedParameter(cov, options_);
}
8787
/**
* Adds a basic query() function to the coverage collection object.
* Note that this does not support paging.
*/
function addCollectionQueryFunction(collection) {
 if (collection.paging) {
   throw new Error('Paged collections not supported');
 }
 collection.query = function () {
   return new CollectionQuery(collection);
 };
}
8800
var CollectionQuery = function () {
 /**
  * @param {CoverageCollection} collection
  */
8805
 function CollectionQuery(collection) {
   classCallCheck(this, CollectionQuery);
8808
   this._collection = collection;
   this._filter = {};
   this._subset = {};
 }
8813
 /**
  * Matching mode: intersect
  *
  * Supports ISO8601 date string axes.
  * All other string-type axes are compared alphabetically.
  *
  * @example
  * collection.query().filter({
  *   't': {start: '2015-01-01T01:00:00', stop: '2015-01-01T02:00:00'}
  * }).execute().then(filteredCollection => {
  *   console.log(filteredCollection.coverages.length)
  * })
  * @param {Object} spec
  * @return {CollectionQuery}
  */
8829
8830
 createClass(CollectionQuery, [{
   key: 'filter',
   value: function filter(spec) {
     mergeInto(spec, this._filter);
     return this;
   }
8837
   /**
    * Subset coverages by domain values.
    *
    * Equivalent to calling {@link Coverage.subsetByValue}(spec) on each
    * coverage in the collection.
    *
    * @param {Object} spec
    * @return {CollectionQuery}
    */
8847
 }, {
   key: 'subset',
   value: function subset(spec) {
     mergeInto(spec, this._subset);
     return this;
   }
8854
   /**
    * Applies the query operators and returns
    * a Promise that succeeds with a new CoverageCollection.
    *
    * @return {Promise<CoverageCollection>}
    */
8861
 }, {
   key: 'execute',
   value: function execute() {
     var _this = this;
8866
     var coll = this._collection;
     var newcoll = {
       type: COVERAGECOLLECTION,
       coverages: [],
       parameters: coll.parameters,
       domainType: coll.domainType
     };
8874
     var promises = [];
     var _iteratorNormalCompletion = true;
     var _didIteratorError = false;
     var _iteratorError = undefined;
8879
     try {
       var _loop = function _loop() {
         var cov = _step.value;
8883
         promises.push(cov.loadDomain().then(function (domain) {
           if (!matchesFilter(domain, _this._filter)) {
             return;
           }
8888
           if (Object.keys(_this._subset).length === 0) {
             newcoll.coverages.push(cov);
           } else {
             return cov.subsetByValue(_this._subset).then(function (subsetted) {
               newcoll.coverages.push(subsetted);
             });
           }
         }));
       };
8898
       for (var _iterator = coll.coverages[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
         _loop();
       }
     } catch (err) {
       _didIteratorError = true;
       _iteratorError = err;
     } finally {
       try {
         if (!_iteratorNormalCompletion && _iterator.return) {
           _iterator.return();
         }
       } finally {
         if (_didIteratorError) {
           throw _iteratorError;
         }
       }
     }
8916
     return Promise.all(promises).then(function () {
       newcoll.query = function () {
         return new CollectionQuery(newcoll);
       };
       return newcoll;
     });
   }
 }]);
 return CollectionQuery;
}();
8927
function matchesFilter(domain, filter) {
 var _iteratorNormalCompletion2 = true;
 var _didIteratorError2 = false;
 var _iteratorError2 = undefined;
8932
 try {
   for (var _iterator2 = Object.keys(filter)[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
     var axisName = _step2.value;
8936
     var condition = filter[axisName];
     if (!domain.axes.has(axisName)) {
       throw new Error('Axis "' + axisName + '" does not exist');
     }
     var axis = domain.axes.get(axisName);
     var vals = axis.values;
8943
     var min = vals[0];
     var max = vals[vals.length - 1];
8946
     if (typeof min !== 'number' && typeof min !== 'string') {
       throw new Error('Can only filter primitive axis values');
     }
     var start = condition.start;
     var stop = condition.stop;
8952
     // special handling
8954
     if (isISODateAxis(domain, axisName)) {
       var _ref = [asTime(min), asTime(max)];
       min = _ref[0];
       max = _ref[1];
       var _ref2 = [asTime(start), asTime(stop)];
       start = _ref2[0];
       stop = _ref2[1];
     } else if (isLongitudeAxis(domain, axisName)) {
       var lonWrapper = getLongitudeWrapper(domain, axisName);var _ref3 = [lonWrapper(start), lonWrapper(stop)];
       start = _ref3[0];
       stop = _ref3[1];
     }
8967
     if (min > max) {
       var _ref4 = [max, min];
       min = _ref4[0];
       max = _ref4[1];
     }
     if (max < start || stop < min) {
       return false;
     }
   }
 } catch (err) {
   _didIteratorError2 = true;
   _iteratorError2 = err;
 } finally {
   try {
     if (!_iteratorNormalCompletion2 && _iterator2.return) {
       _iterator2.return();
     }
   } finally {
     if (_didIteratorError2) {
       throw _iteratorError2;
     }
   }
 }
8991
 return true;
}
8994
function mergeInto(inputObj, targetObj) {
 var _iteratorNormalCompletion3 = true;
 var _didIteratorError3 = false;
 var _iteratorError3 = undefined;
8999
 try {
   for (var _iterator3 = Object.keys(inputObj)[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
     var k = _step3.value;
9003
     targetObj[k] = inputObj[k];
   }
 } catch (err) {
   _didIteratorError3 = true;
   _iteratorError3 = err;
 } finally {
   try {
     if (!_iteratorNormalCompletion3 && _iterator3.return) {
       _iterator3.return();
     }
   } finally {
     if (_didIteratorError3) {
       throw _iteratorError3;
     }
   }
 }
}
9021
exports.minMax = minMax;
exports.indicesOfNearest = indicesOfNearest;
exports.indexOfNearest = indexOfNearest;
exports.DOMAIN = DOMAIN;
exports.COVERAGE = COVERAGE;
exports.COVERAGECOLLECTION = COVERAGECOLLECTION;
exports.COVJSON_DATATYPE_TUPLE = COVJSON_DATATYPE_TUPLE;
exports.COVJSON_DATATYPE_POLYGON = COVJSON_DATATYPE_POLYGON;
exports.getLanguageTag = getLanguageTag;
exports.getLanguageString = getLanguageString;
exports.stringifyUnit = stringifyUnit;
exports.minMaxOfRange = minMaxOfRange;
exports.reduceRange = reduceRange;
exports.iterateRange = iterateRange;
exports.getCategory = getCategory;
exports.isCoverage = isCoverage;
exports.checkCoverage = checkCoverage;
exports.isDomain = isDomain;
exports.checkDomain = checkDomain;
exports.getReferenceObject = getReferenceObject;
exports.getHorizontalCRSReferenceObject = getHorizontalCRSReferenceObject;
exports.isEllipsoidalCRS = isEllipsoidalCRS;
exports.getProjection = getProjection;
exports.loadProjection = loadProjection;
exports.getHorizontalCRSComponents = getHorizontalCRSComponents;
exports.getHorizontalCRSCoordinateIDs = getHorizontalCRSCoordinateIDs;
exports.reprojectCoords = reprojectCoords;
exports.getLongitudeWrapper = getLongitudeWrapper;
exports.isLongitudeAxis = isLongitudeAxis;
exports.isISODateAxis = isISODateAxis;
exports.asTime = asTime;
exports.normalizeIndexSubsetConstraints = normalizeIndexSubsetConstraints;
exports.subsetDomainByIndex = subsetDomainByIndex;
exports.fromDomain = fromDomain;
exports.fromXndarray = fromXndarray;
exports.addSubsetFunctions = addSubsetFunctions;
exports.addLoadRangesFunction = addLoadRangesFunction;
exports.reproject = reproject;
exports.subsetByBbox = subsetByBbox;
exports.subsetByIndex = subsetByIndex;
exports.subsetByValue = subsetByValue;
exports.withSimpleDerivedParameter = withSimpleDerivedParameter;
exports.withParameters = withParameters;
exports.withCategories = withCategories;
exports.withDomainType = withDomainType;
exports.asCovJSONDomainType = asCovJSONDomainType;
exports.renameAxes = renameAxes;
exports.mapRange = mapRange;
exports.withDerivedParameter = withDerivedParameter;
exports.addCollectionQueryFunction = addCollectionQueryFunction;
exports.CollectionQuery = CollectionQuery;
9073
9074}((this.CovUtils = this.CovUtils || {})));
9075//# sourceMappingURL=covutils-lite.src.js.map
\No newline at end of file
1	`(function (exports) {`
2	`'use strict';`
3
4	`function minMax(arr) {`
5	`var len = arr.length;`
6	`var min = Infinity;`
7	`var max = -Infinity;`
8	`while (len--) {`
9	`var el = arr[len];`
10	`if (el == null) {`
11	`// do nothing`
12	`} else if (el < min) {`
13	`min = el;`
14	`} else if (el > max) {`
15	`max = el;`
16	`}`
17	`}`
18	`if (min === Infinity) {`
19	`min = max;`
20	`} else if (max === -Infinity) {`
21	`max = min;`
22	`}`
23	`if (min === Infinity \|\| min === -Infinity) {`
24	`// all values were null`
25	`min = null;`
26	`max = null;`
27	`}`
28	`return [min, max];`
29	`}`
30
31	`/**`
32	`* Return the indices of the two neighbors in the sorted array closest to the given number.`
33	`*`
34	`* @example`
35	`* var a = [2,5,8,12,13]`
36	`* var i = CovUtils.indicesOfNearest(a, 6)`
37	`* // i == [1,2]`
38	`* var j = CovUtils.indicesOfNearest(a, 5)`
39	`* // j == [1,1]`
40	`* var k = CovUtils.indicesOfNearest(a, 50)`