@basemaps/landing 6.30.0 → 6.31.0

package/dist/{index-6.30.0-3328a19b1b63f913.js → index-6.31.0-a46fbc728fb71e99.js}

@@ -20814,8 +20814,12 @@ init_preact_shim();
 init_preact_shim();
 var PJD_3PARAM = 1;
 var PJD_7PARAM = 2;
+var PJD_GRIDSHIFT = 3;
 var PJD_WGS84 = 4;
 var PJD_NODATUM = 5;
+var SRS_WGS84_SEMIMAJOR = 6378137;
+var SRS_WGS84_SEMIMINOR = 6356752314e-3;
+var SRS_WGS84_ESQUARED = 0.0066943799901413165;
 var SEC_TO_RAD = 484813681109536e-20;
 var HALF_PI = Math.PI / 2;
 var SIXTH = 0.16666666666666666;
@@ -20916,6 +20920,9 @@ function projString_default(defData) {
     alpha: function(v2) {
       self2.alpha = parseFloat(v2) * D2R;
     },
+    gamma: function(v2) {
+      self2.rectified_grid_angle = parseFloat(v2);
+    },
     lonc: function(v2) {
       self2.longc = v2 * D2R;
     },
@@ -20980,6 +20987,9 @@ function projString_default(defData) {
       if (v2.length === 3 && legalAxis.indexOf(v2.substr(0, 1)) !== -1 && legalAxis.indexOf(v2.substr(1, 1)) !== -1 && legalAxis.indexOf(v2.substr(2, 1)) !== -1) {
         self2.axis = v2;
       }
+    },
+    approx: function() {
+      self2.approx = true;
     }
   };
   for (paramName in paramObj) {
@@ -21015,7 +21025,7 @@ var AFTERQUOTE = 5;
 var ENDED = -1;
 var whitespace = /\s/;
 var latin = /[A-Za-z]/;
-var keyword = /[A-Za-z84]/;
+var keyword = /[A-Za-z84_]/;
 var endThings = /[,\]]/;
 var digets = /[\d\.E\-\+]/;
 function Parser(text) {
@@ -21314,15 +21324,14 @@ function cleanWKT(wkt) {
   if (wkt.AXIS) {
     var axisOrder = "";
     for (var i2 = 0, ii = wkt.AXIS.length; i2 < ii; ++i2) {
-      var axis = wkt.AXIS[i2];
-      var descriptor = axis[0].toLowerCase();
-      if (descriptor.indexOf("north") !== -1) {
+      var axis = [wkt.AXIS[i2][0].toLowerCase(), wkt.AXIS[i2][1].toLowerCase()];
+      if (axis[0].indexOf("north") !== -1 || (axis[0] === "y" || axis[0] === "lat") && axis[1] === "north") {
         axisOrder += "n";
-      } else if (descriptor.indexOf("south") !== -1) {
+      } else if (axis[0].indexOf("south") !== -1 || (axis[0] === "y" || axis[0] === "lat") && axis[1] === "south") {
         axisOrder += "s";
-      } else if (descriptor.indexOf("east") !== -1) {
+      } else if (axis[0].indexOf("east") !== -1 || (axis[0] === "x" || axis[0] === "lon") && axis[1] === "east") {
         axisOrder += "e";
-      } else if (descriptor.indexOf("west") !== -1) {
+      } else if (axis[0].indexOf("west") !== -1 || (axis[0] === "x" || axis[0] === "lon") && axis[1] === "west") {
         axisOrder += "w";
       }
     }
@@ -21418,12 +21427,22 @@ function cleanWKT(wkt) {
   };
   var list = [
     ["standard_parallel_1", "Standard_Parallel_1"],
+    ["standard_parallel_1", "Latitude of 1st standard parallel"],
     ["standard_parallel_2", "Standard_Parallel_2"],
+    ["standard_parallel_2", "Latitude of 2nd standard parallel"],
     ["false_easting", "False_Easting"],
+    ["false_easting", "False easting"],
+    ["false-easting", "Easting at false origin"],
     ["false_northing", "False_Northing"],
+    ["false_northing", "False northing"],
+    ["false_northing", "Northing at false origin"],
     ["central_meridian", "Central_Meridian"],
+    ["central_meridian", "Longitude of natural origin"],
+    ["central_meridian", "Longitude of false origin"],
     ["latitude_of_origin", "Latitude_Of_Origin"],
     ["latitude_of_origin", "Central_Parallel"],
+    ["latitude_of_origin", "Latitude of natural origin"],
+    ["latitude_of_origin", "Latitude of false origin"],
     ["scale_factor", "Scale_Factor"],
     ["k0", "scale_factor"],
     ["latitude_of_center", "Latitude_Of_Center"],
@@ -22055,7 +22074,7 @@ exports3.nad27 = {
   datumName: "North_American_Datum_1927"
 };
 exports3.potsdam = {
-  towgs84: "606.0,23.0,413.0",
+  towgs84: "598.1,73.7,418.2,0.202,0.045,-2.455,6.7",
   ellipse: "bessel",
   datumName: "Potsdam Rauenberg 1950 DHDN"
 };
@@ -22065,7 +22084,7 @@ exports3.carthage = {
   datumName: "Carthage 1934 Tunisia"
 };
 exports3.hermannskogel = {
-  towgs84: "653.0,-212.0,449.0",
+  towgs84: "577.326,90.129,463.919,5.137,1.474,5.297,2.4232",
   ellipse: "bessel",
   datumName: "Hermannskogel"
 };
@@ -22117,7 +22136,7 @@ exports3.rnb72 = {
 
 // ../../node_modules/proj4/lib/datum.js
 init_preact_shim();
-function datum(datumCode, datum_params, a2, b2, es, ep2) {
+function datum(datumCode, datum_params, a2, b2, es, ep2, nadgrids) {
   var out = {};
   if (datumCode === void 0 || datumCode === "none") {
     out.datum_type = PJD_NODATUM;
@@ -22139,6 +22158,10 @@ function datum(datumCode, datum_params, a2, b2, es, ep2) {
       }
     }
   }
+  if (nadgrids) {
+    out.datum_type = PJD_GRIDSHIFT;
+    out.grids = nadgrids;
+  }
   out.a = a2;
   out.b = b2;
   out.es = es;
@@ -22147,6 +22170,127 @@ function datum(datumCode, datum_params, a2, b2, es, ep2) {
 }
 var datum_default = datum;
 
+// ../../node_modules/proj4/lib/nadgrid.js
+init_preact_shim();
+var loadedNadgrids = {};
+function nadgrid(key, data) {
+  var view = new DataView(data);
+  var isLittleEndian = detectLittleEndian(view);
+  var header = readHeader(view, isLittleEndian);
+  if (header.nSubgrids > 1) {
+    console.log("Only single NTv2 subgrids are currently supported, subsequent sub grids are ignored");
+  }
+  var subgrids = readSubgrids(view, header, isLittleEndian);
+  var nadgrid2 = { header, subgrids };
+  loadedNadgrids[key] = nadgrid2;
+  return nadgrid2;
+}
+function getNadgrids(nadgrids) {
+  if (nadgrids === void 0) {
+    return null;
+  }
+  var grids = nadgrids.split(",");
+  return grids.map(parseNadgridString);
+}
+function parseNadgridString(value) {
+  if (value.length === 0) {
+    return null;
+  }
+  var optional = value[0] === "@";
+  if (optional) {
+    value = value.slice(1);
+  }
+  if (value === "null") {
+    return { name: "null", mandatory: !optional, grid: null, isNull: true };
+  }
+  return {
+    name: value,
+    mandatory: !optional,
+    grid: loadedNadgrids[value] || null,
+    isNull: false
+  };
+}
+function secondsToRadians(seconds) {
+  return seconds / 3600 * Math.PI / 180;
+}
+function detectLittleEndian(view) {
+  var nFields = view.getInt32(8, false);
+  if (nFields === 11) {
+    return false;
+  }
+  nFields = view.getInt32(8, true);
+  if (nFields !== 11) {
+    console.warn("Failed to detect nadgrid endian-ness, defaulting to little-endian");
+  }
+  return true;
+}
+function readHeader(view, isLittleEndian) {
+  return {
+    nFields: view.getInt32(8, isLittleEndian),
+    nSubgridFields: view.getInt32(24, isLittleEndian),
+    nSubgrids: view.getInt32(40, isLittleEndian),
+    shiftType: decodeString(view, 56, 56 + 8).trim(),
+    fromSemiMajorAxis: view.getFloat64(120, isLittleEndian),
+    fromSemiMinorAxis: view.getFloat64(136, isLittleEndian),
+    toSemiMajorAxis: view.getFloat64(152, isLittleEndian),
+    toSemiMinorAxis: view.getFloat64(168, isLittleEndian)
+  };
+}
+function decodeString(view, start2, end) {
+  return String.fromCharCode.apply(null, new Uint8Array(view.buffer.slice(start2, end)));
+}
+function readSubgrids(view, header, isLittleEndian) {
+  var gridOffset = 176;
+  var grids = [];
+  for (var i2 = 0; i2 < header.nSubgrids; i2++) {
+    var subHeader = readGridHeader(view, gridOffset, isLittleEndian);
+    var nodes = readGridNodes(view, gridOffset, subHeader, isLittleEndian);
+    var lngColumnCount = Math.round(1 + (subHeader.upperLongitude - subHeader.lowerLongitude) / subHeader.longitudeInterval);
+    var latColumnCount = Math.round(1 + (subHeader.upperLatitude - subHeader.lowerLatitude) / subHeader.latitudeInterval);
+    grids.push({
+      ll: [secondsToRadians(subHeader.lowerLongitude), secondsToRadians(subHeader.lowerLatitude)],
+      del: [secondsToRadians(subHeader.longitudeInterval), secondsToRadians(subHeader.latitudeInterval)],
+      lim: [lngColumnCount, latColumnCount],
+      count: subHeader.gridNodeCount,
+      cvs: mapNodes(nodes)
+    });
+  }
+  return grids;
+}
+function mapNodes(nodes) {
+  return nodes.map(function(r2) {
+    return [secondsToRadians(r2.longitudeShift), secondsToRadians(r2.latitudeShift)];
+  });
+}
+function readGridHeader(view, offset, isLittleEndian) {
+  return {
+    name: decodeString(view, offset + 8, offset + 16).trim(),
+    parent: decodeString(view, offset + 24, offset + 24 + 8).trim(),
+    lowerLatitude: view.getFloat64(offset + 72, isLittleEndian),
+    upperLatitude: view.getFloat64(offset + 88, isLittleEndian),
+    lowerLongitude: view.getFloat64(offset + 104, isLittleEndian),
+    upperLongitude: view.getFloat64(offset + 120, isLittleEndian),
+    latitudeInterval: view.getFloat64(offset + 136, isLittleEndian),
+    longitudeInterval: view.getFloat64(offset + 152, isLittleEndian),
+    gridNodeCount: view.getInt32(offset + 168, isLittleEndian)
+  };
+}
+function readGridNodes(view, offset, gridHeader, isLittleEndian) {
+  var nodesOffset = offset + 176;
+  var gridRecordLength = 16;
+  var gridShiftRecords = [];
+  for (var i2 = 0; i2 < gridHeader.gridNodeCount; i2++) {
+    var record = {
+      latitudeShift: view.getFloat32(nodesOffset + i2 * gridRecordLength, isLittleEndian),
+      longitudeShift: view.getFloat32(nodesOffset + i2 * gridRecordLength + 4, isLittleEndian),
+      latitudeAccuracy: view.getFloat32(nodesOffset + i2 * gridRecordLength + 8, isLittleEndian),
+      longitudeAccuracy: view.getFloat32(nodesOffset + i2 * gridRecordLength + 12, isLittleEndian)
+    };
+    gridShiftRecords.push(record);
+  }
+  return gridShiftRecords;
+}
+
 // ../../node_modules/proj4/lib/Proj.js
 function Projection(srsCode, callback) {
   if (!(this instanceof Projection)) {
@@ -22170,7 +22314,7 @@ function Projection(srsCode, callback) {
   if (json.datumCode && json.datumCode !== "none") {
     var datumDef = match(exports3, json.datumCode);
     if (datumDef) {
-      json.datum_params = datumDef.towgs84 ? datumDef.towgs84.split(",") : null;
+      json.datum_params = json.datum_params || (datumDef.towgs84 ? datumDef.towgs84.split(",") : null);
       json.ellps = datumDef.ellipse;
       json.datumName = datumDef.datumName ? datumDef.datumName : json.datumCode;
     }
@@ -22178,9 +22322,11 @@ function Projection(srsCode, callback) {
   json.k0 = json.k0 || 1;
   json.axis = json.axis || "enu";
   json.ellps = json.ellps || "wgs84";
+  json.lat1 = json.lat1 || json.lat0;
   var sphere_ = sphere(json.a, json.b, json.rf, json.ellps, json.sphere);
   var ecc = eccentricity(sphere_.a, sphere_.b, sphere_.rf, json.R_A);
-  var datumObj = json.datum || datum_default(json.datumCode, json.datum_params, sphere_.a, sphere_.b, ecc.es, ecc.ep2);
+  var nadgrids = getNadgrids(json.nadgrids);
+  var datumObj = json.datum || datum_default(json.datumCode, json.datum_params, sphere_.a, sphere_.b, ecc.es, ecc.ep2, nadgrids);
   extend_default(this, json);
   extend_default(this, ourProj);
   this.a = sphere_.a;
@@ -22372,17 +22518,155 @@ function datum_transform_default(source, dest, point) {
   if (source.datum_type === PJD_NODATUM || dest.datum_type === PJD_NODATUM) {
     return point;
   }
-  if (source.es === dest.es && source.a === dest.a && !checkParams(source.datum_type) && !checkParams(dest.datum_type)) {
+  var source_a = source.a;
+  var source_es = source.es;
+  if (source.datum_type === PJD_GRIDSHIFT) {
+    var gridShiftCode = applyGridShift(source, false, point);
+    if (gridShiftCode !== 0) {
+      return void 0;
+    }
+    source_a = SRS_WGS84_SEMIMAJOR;
+    source_es = SRS_WGS84_ESQUARED;
+  }
+  var dest_a = dest.a;
+  var dest_b = dest.b;
+  var dest_es = dest.es;
+  if (dest.datum_type === PJD_GRIDSHIFT) {
+    dest_a = SRS_WGS84_SEMIMAJOR;
+    dest_b = SRS_WGS84_SEMIMINOR;
+    dest_es = SRS_WGS84_ESQUARED;
+  }
+  if (source_es === dest_es && source_a === dest_a && !checkParams(source.datum_type) && !checkParams(dest.datum_type)) {
     return point;
   }
-  point = geodeticToGeocentric(point, source.es, source.a);
+  point = geodeticToGeocentric(point, source_es, source_a);
   if (checkParams(source.datum_type)) {
     point = geocentricToWgs84(point, source.datum_type, source.datum_params);
   }
   if (checkParams(dest.datum_type)) {
     point = geocentricFromWgs84(point, dest.datum_type, dest.datum_params);
   }
-  return geocentricToGeodetic(point, dest.es, dest.a, dest.b);
+  point = geocentricToGeodetic(point, dest_es, dest_a, dest_b);
+  if (dest.datum_type === PJD_GRIDSHIFT) {
+    var destGridShiftResult = applyGridShift(dest, true, point);
+    if (destGridShiftResult !== 0) {
+      return void 0;
+    }
+  }
+  return point;
+}
+function applyGridShift(source, inverse32, point) {
+  if (source.grids === null || source.grids.length === 0) {
+    console.log("Grid shift grids not found");
+    return -1;
+  }
+  var input = { x: -point.x, y: point.y };
+  var output = { x: Number.NaN, y: Number.NaN };
+  var onlyMandatoryGrids = false;
+  var attemptedGrids = [];
+  for (var i2 = 0; i2 < source.grids.length; i2++) {
+    var grid = source.grids[i2];
+    attemptedGrids.push(grid.name);
+    if (grid.isNull) {
+      output = input;
+      break;
+    }
+    onlyMandatoryGrids = grid.mandatory;
+    if (grid.grid === null) {
+      if (grid.mandatory) {
+        console.log("Unable to find mandatory grid '" + grid.name + "'");
+        return -1;
+      }
+      continue;
+    }
+    var subgrid = grid.grid.subgrids[0];
+    var epsilon = (Math.abs(subgrid.del[1]) + Math.abs(subgrid.del[0])) / 1e4;
+    var minX = subgrid.ll[0] - epsilon;
+    var minY = subgrid.ll[1] - epsilon;
+    var maxX = subgrid.ll[0] + (subgrid.lim[0] - 1) * subgrid.del[0] + epsilon;
+    var maxY = subgrid.ll[1] + (subgrid.lim[1] - 1) * subgrid.del[1] + epsilon;
+    if (minY > input.y || minX > input.x || maxY < input.y || maxX < input.x) {
+      continue;
+    }
+    output = applySubgridShift(input, inverse32, subgrid);
+    if (!isNaN(output.x)) {
+      break;
+    }
+  }
+  if (isNaN(output.x)) {
+    console.log("Failed to find a grid shift table for location '" + -input.x * R2D + " " + input.y * R2D + " tried: '" + attemptedGrids + "'");
+    return -1;
+  }
+  point.x = -output.x;
+  point.y = output.y;
+  return 0;
+}
+function applySubgridShift(pin, inverse32, ct) {
+  var val = { x: Number.NaN, y: Number.NaN };
+  if (isNaN(pin.x)) {
+    return val;
+  }
+  var tb = { x: pin.x, y: pin.y };
+  tb.x -= ct.ll[0];
+  tb.y -= ct.ll[1];
+  tb.x = adjust_lon_default(tb.x - Math.PI) + Math.PI;
+  var t2 = nadInterpolate(tb, ct);
+  if (inverse32) {
+    if (isNaN(t2.x)) {
+      return val;
+    }
+    t2.x = tb.x - t2.x;
+    t2.y = tb.y - t2.y;
+    var i2 = 9, tol = 1e-12;
+    var dif, del;
+    do {
+      del = nadInterpolate(t2, ct);
+      if (isNaN(del.x)) {
+        console.log("Inverse grid shift iteration failed, presumably at grid edge.  Using first approximation.");
+        break;
+      }
+      dif = { x: tb.x - (del.x + t2.x), y: tb.y - (del.y + t2.y) };
+      t2.x += dif.x;
+      t2.y += dif.y;
+    } while (i2-- && Math.abs(dif.x) > tol && Math.abs(dif.y) > tol);
+    if (i2 < 0) {
+      console.log("Inverse grid shift iterator failed to converge.");
+      return val;
+    }
+    val.x = adjust_lon_default(t2.x + ct.ll[0]);
+    val.y = t2.y + ct.ll[1];
+  } else {
+    if (!isNaN(t2.x)) {
+      val.x = pin.x + t2.x;
+      val.y = pin.y + t2.y;
+    }
+  }
+  return val;
+}
+function nadInterpolate(pin, ct) {
+  var t2 = { x: pin.x / ct.del[0], y: pin.y / ct.del[1] };
+  var indx = { x: Math.floor(t2.x), y: Math.floor(t2.y) };
+  var frct = { x: t2.x - 1 * indx.x, y: t2.y - 1 * indx.y };
+  var val = { x: Number.NaN, y: Number.NaN };
+  var inx;
+  if (indx.x < 0 || indx.x >= ct.lim[0]) {
+    return val;
+  }
+  if (indx.y < 0 || indx.y >= ct.lim[1]) {
+    return val;
+  }
+  inx = indx.y * ct.lim[0] + indx.x;
+  var f00 = { x: ct.cvs[inx][0], y: ct.cvs[inx][1] };
+  inx++;
+  var f10 = { x: ct.cvs[inx][0], y: ct.cvs[inx][1] };
+  inx += ct.lim[0];
+  var f11 = { x: ct.cvs[inx][0], y: ct.cvs[inx][1] };
+  inx--;
+  var f01 = { x: ct.cvs[inx][0], y: ct.cvs[inx][1] };
+  var m11 = frct.x * frct.y, m10 = frct.x * (1 - frct.y), m00 = (1 - frct.x) * (1 - frct.y), m01 = (1 - frct.x) * frct.y;
+  val.x = m00 * f00.x + m10 * f10.x + m01 * f01.x + m11 * f11.x;
+  val.y = m00 * f00.y + m10 * f10.y + m01 * f01.y + m11 * f11.y;
+  return val;
 }
 
 // ../../node_modules/proj4/lib/adjust_axis.js
@@ -22481,7 +22765,7 @@ function checkCoord(num) {
 function checkNotWGS(source, dest) {
   return (source.datum.datum_type === PJD_3PARAM || source.datum.datum_type === PJD_7PARAM) && dest.datumCode !== "WGS84" || (dest.datum.datum_type === PJD_3PARAM || dest.datum.datum_type === PJD_7PARAM) && source.datumCode !== "WGS84";
 }
-function transform(source, dest, point) {
+function transform(source, dest, point, enforceAxis) {
   var wgs842;
   if (Array.isArray(point)) {
     point = toPoint_default(point);
@@ -22489,10 +22773,10 @@ function transform(source, dest, point) {
   checkSanity_default(point);
   if (source.datum && dest.datum && checkNotWGS(source, dest)) {
     wgs842 = new Proj_default("WGS84");
-    point = transform(source, wgs842, point);
+    point = transform(source, wgs842, point, enforceAxis);
     source = wgs842;
   }
-  if (source.axis !== "enu") {
+  if (enforceAxis && source.axis !== "enu") {
     point = adjust_axis_default(source, false, point);
   }
   if (source.projName === "longlat") {
@@ -22518,6 +22802,9 @@ function transform(source, dest, point) {
     point.x += source.from_greenwich;
   }
   point = datum_transform_default(source.datum, dest.datum, point);
+  if (!point) {
+    return;
+  }
   if (dest.from_greenwich) {
     point = {
       x: point.x - dest.from_greenwich,
@@ -22541,7 +22828,7 @@ function transform(source, dest, point) {
       };
     }
   }
-  if (dest.axis !== "enu") {
+  if (enforceAxis && dest.axis !== "enu") {
     return adjust_axis_default(dest, true, point);
   }
   return point;
@@ -22549,10 +22836,10 @@ function transform(source, dest, point) {
 
 // ../../node_modules/proj4/lib/core.js
 var wgs84 = Proj_default("WGS84");
-function transformer(from, to, coords) {
+function transformer(from, to, coords, enforceAxis) {
   var transformedArray, out, keys;
   if (Array.isArray(coords)) {
-    transformedArray = transform(from, to, coords) || { x: NaN, y: NaN };
+    transformedArray = transform(from, to, coords, enforceAxis) || { x: NaN, y: NaN };
     if (coords.length > 2) {
       if (typeof from.name !== "undefined" && from.name === "geocent" || typeof to.name !== "undefined" && to.name === "geocent") {
         if (typeof transformedArray.z === "number") {
@@ -22567,7 +22854,7 @@ function transformer(from, to, coords) {
       return [transformedArray.x, transformedArray.y];
     }
   } else {
-    out = transform(from, to, coords);
+    out = transform(from, to, coords, enforceAxis);
     keys = Object.keys(coords);
     if (keys.length === 2) {
       return out;
@@ -22615,11 +22902,11 @@ function proj4(fromProj, toProj, coord) {
     return transformer(fromProj, toProj, coord);
   } else {
     obj = {
-      forward: function(coords) {
-        return transformer(fromProj, toProj, coords);
+      forward: function(coords, enforceAxis) {
+        return transformer(fromProj, toProj, coords, enforceAxis);
       },
-      inverse: function(coords) {
-        return transformer(toProj, fromProj, coords);
+      inverse: function(coords, enforceAxis) {
+        return transformer(toProj, fromProj, coords, enforceAxis);
       }
     };
     if (single) {
@@ -23263,7 +23550,7 @@ function inverse3(p) {
   p.y = lat;
   return p;
 }
-var names4 = ["Transverse_Mercator", "Transverse Mercator", "tmerc"];
+var names4 = ["Fast_Transverse_Mercator", "Fast Transverse Mercator"];
 var tmerc_default = {
   init: init3,
   forward: forward3,
@@ -23383,8 +23670,13 @@ function clens_cmplx_default(pp, arg_r, arg_i) {
 
 // ../../node_modules/proj4/lib/projections/etmerc.js
 function init4() {
-  if (this.es === void 0 || this.es <= 0) {
-    throw new Error("incorrect elliptical usage");
+  if (!this.approx && (isNaN(this.es) || this.es <= 0)) {
+    throw new Error('Incorrect elliptical usage. Try using the +approx option in the proj string, or PROJECTION["Fast_Transverse_Mercator"] in the WKT.');
+  }
+  if (this.approx) {
+    tmerc_default.init.apply(this);
+    this.forward = tmerc_default.forward;
+    this.inverse = tmerc_default.inverse;
   }
   this.x0 = this.x0 !== void 0 ? this.x0 : 0;
   this.y0 = this.y0 !== void 0 ? this.y0 : 0;
@@ -23490,7 +23782,7 @@ function inverse4(p) {
   p.y = lat;
   return p;
 }
-var names5 = ["Extended_Transverse_Mercator", "Extended Transverse Mercator", "etmerc"];
+var names5 = ["Extended_Transverse_Mercator", "Extended Transverse Mercator", "etmerc", "Transverse_Mercator", "Transverse Mercator", "tmerc"];
 var etmerc_default = {
   init: init4,
   forward: forward4,
@@ -23853,136 +24145,184 @@ var somerc_default = {
 
 // ../../node_modules/proj4/lib/projections/omerc.js
 init_preact_shim();
+var TOL = 1e-7;
+function isTypeA(P2) {
+  var typeAProjections = ["Hotine_Oblique_Mercator", "Hotine_Oblique_Mercator_Azimuth_Natural_Origin"];
+  var projectionName = typeof P2.PROJECTION === "object" ? Object.keys(P2.PROJECTION)[0] : P2.PROJECTION;
+  return "no_uoff" in P2 || "no_off" in P2 || typeAProjections.indexOf(projectionName) !== -1;
+}
 function init10() {
-  this.no_off = this.no_off || false;
-  this.no_rot = this.no_rot || false;
-  if (isNaN(this.k0)) {
-    this.k0 = 1;
+  var con, com, cosph0, D, F, H2, L2, sinph0, p, J, gamma = 0, gamma0, lamc = 0, lam1 = 0, lam2 = 0, phi1 = 0, phi2 = 0, alpha_c = 0, AB;
+  this.no_off = isTypeA(this);
+  this.no_rot = "no_rot" in this;
+  var alp = false;
+  if ("alpha" in this) {
+    alp = true;
   }
-  var sinlat = Math.sin(this.lat0);
-  var coslat = Math.cos(this.lat0);
-  var con = this.e * sinlat;
-  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_default(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)) {
-    if (this.lat0 >= 0) {
-      fl = dl + Math.sqrt(dl * dl - 1);
+  var gam = false;
+  if ("rectified_grid_angle" in this) {
+    gam = true;
+  }
+  if (alp) {
+    alpha_c = this.alpha;
+  }
+  if (gam) {
+    gamma = this.rectified_grid_angle * D2R;
+  }
+  if (alp || gam) {
+    lamc = this.longc;
+  } else {
+    lam1 = this.long1;
+    phi1 = this.lat1;
+    lam2 = this.long2;
+    phi2 = this.lat2;
+    if (Math.abs(phi1 - phi2) <= TOL || (con = Math.abs(phi1)) <= TOL || Math.abs(con - HALF_PI) <= TOL || Math.abs(Math.abs(this.lat0) - HALF_PI) <= TOL || Math.abs(Math.abs(phi2) - HALF_PI) <= TOL) {
+      throw new Error();
+    }
+  }
+  var one_es = 1 - this.es;
+  com = Math.sqrt(one_es);
+  if (Math.abs(this.lat0) > EPSLN) {
+    sinph0 = Math.sin(this.lat0);
+    cosph0 = Math.cos(this.lat0);
+    con = 1 - this.es * sinph0 * sinph0;
+    this.B = cosph0 * cosph0;
+    this.B = Math.sqrt(1 + this.es * this.B * this.B / one_es);
+    this.A = this.B * this.k0 * com / con;
+    D = this.B * com / (cosph0 * Math.sqrt(con));
+    F = D * D - 1;
+    if (F <= 0) {
+      F = 0;
     } else {
-      fl = dl - Math.sqrt(dl * dl - 1);
+      F = Math.sqrt(F);
+      if (this.lat0 < 0) {
+        F = -F;
+      }
     }
-    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;
+    this.E = F += D;
+    this.E *= Math.pow(tsfnz_default(this.e, this.lat0, sinph0), this.B);
   } else {
-    var t1 = tsfnz_default(this.e, this.lat1, Math.sin(this.lat1));
-    var t2 = tsfnz_default(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);
+    this.B = 1 / com;
+    this.A = this.k0;
+    this.E = D = F = 1;
+  }
+  if (alp || gam) {
+    if (alp) {
+      gamma0 = Math.asin(Math.sin(alpha_c) / D);
+      if (!gam) {
+        gamma = alpha_c;
+      }
     } else {
-      this.el = (dl - Math.sqrt(dl * dl - 1)) * Math.pow(t0, this.bl);
+      gamma0 = gamma;
+      alpha_c = Math.asin(D * Math.sin(gamma0));
     }
-    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_default(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_default(this.long0);
-    var dlon10 = adjust_lon_default(this.long1 - this.long0);
-    this.gamma0 = Math.atan(Math.sin(this.bl * dlon10) / gl);
-    this.alpha = Math.asin(dl * Math.sin(this.gamma0));
-  }
+    this.lam0 = lamc - Math.asin(0.5 * (F - 1 / F) * Math.tan(gamma0)) / this.B;
+  } else {
+    H2 = Math.pow(tsfnz_default(this.e, phi1, Math.sin(phi1)), this.B);
+    L2 = Math.pow(tsfnz_default(this.e, phi2, Math.sin(phi2)), this.B);
+    F = this.E / H2;
+    p = (L2 - H2) / (L2 + H2);
+    J = this.E * this.E;
+    J = (J - L2 * H2) / (J + L2 * H2);
+    con = lam1 - lam2;
+    if (con < -Math.pi) {
+      lam2 -= TWO_PI;
+    } else if (con > Math.pi) {
+      lam2 += TWO_PI;
+    }
+    this.lam0 = adjust_lon_default(0.5 * (lam1 + lam2) - Math.atan(J * Math.tan(0.5 * this.B * (lam1 - lam2)) / p) / this.B);
+    gamma0 = Math.atan(2 * Math.sin(this.B * adjust_lon_default(lam1 - this.lam0)) / (F - 1 / F));
+    gamma = alpha_c = Math.asin(D * Math.sin(gamma0));
+  }
+  this.singam = Math.sin(gamma0);
+  this.cosgam = Math.cos(gamma0);
+  this.sinrot = Math.sin(gamma);
+  this.cosrot = Math.cos(gamma);
+  this.rB = 1 / this.B;
+  this.ArB = this.A * this.rB;
+  this.BrA = 1 / this.ArB;
+  AB = this.A * this.B;
   if (this.no_off) {
-    this.uc = 0;
+    this.u_0 = 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));
+    this.u_0 = Math.abs(this.ArB * Math.atan(Math.sqrt(D * D - 1) / Math.cos(alpha_c)));
+    if (this.lat0 < 0) {
+      this.u_0 = -this.u_0;
     }
   }
+  F = 0.5 * gamma0;
+  this.v_pole_n = this.ArB * Math.log(Math.tan(FORTPI - F));
+  this.v_pole_s = this.ArB * Math.log(Math.tan(FORTPI + F));
 }
 function forward9(p) {
-  var lon = p.x;
-  var lat = p.y;
-  var dlon = adjust_lon_default(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;
+  var coords = {};
+  var S2, T2, U, V2, W, temp, u2, v2;
+  p.x = p.x - this.lam0;
+  if (Math.abs(Math.abs(p.y) - HALF_PI) > EPSLN) {
+    W = this.E / Math.pow(tsfnz_default(this.e, p.y, Math.sin(p.y)), this.B);
+    temp = 1 / W;
+    S2 = 0.5 * (W - temp);
+    T2 = 0.5 * (W + temp);
+    V2 = Math.sin(this.B * p.x);
+    U = (S2 * this.singam - V2 * this.cosgam) / T2;
+    if (Math.abs(Math.abs(U) - 1) < EPSLN) {
+      throw new Error();
     }
-    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 t2 = tsfnz_default(this.e, lat, Math.sin(lat));
-    var ql = this.el / Math.pow(t2, 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;
+    v2 = 0.5 * this.ArB * Math.log((1 - U) / (1 + U));
+    temp = Math.cos(this.B * p.x);
+    if (Math.abs(temp) < TOL) {
+      u2 = this.A * p.x;
     } else {
-      us = this.al * Math.atan2(sl * Math.cos(this.gamma0) + vl * Math.sin(this.gamma0), Math.cos(this.bl * dlon)) / this.bl;
+      u2 = this.ArB * Math.atan2(S2 * this.cosgam + V2 * this.singam, temp);
     }
+  } else {
+    v2 = p.y > 0 ? this.v_pole_n : this.v_pole_s;
+    u2 = this.ArB * p.y;
   }
   if (this.no_rot) {
-    p.x = this.x0 + us;
-    p.y = this.y0 + vs;
+    coords.x = u2;
+    coords.y = v2;
   } else {
-    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);
+    u2 -= this.u_0;
+    coords.x = v2 * this.cosrot + u2 * this.sinrot;
+    coords.y = u2 * this.cosrot - v2 * this.sinrot;
   }
-  return p;
+  coords.x = this.a * coords.x + this.x0;
+  coords.y = this.a * coords.y + this.y0;
+  return coords;
 }
 function inverse9(p) {
-  var us, vs;
+  var u2, v2, Qp, Sp, Tp, Vp, Up;
+  var coords = {};
+  p.x = (p.x - this.x0) * (1 / this.a);
+  p.y = (p.y - this.y0) * (1 / this.a);
   if (this.no_rot) {
-    vs = p.y - this.y0;
-    us = p.x - this.x0;
+    v2 = p.y;
+    u2 = p.x;
   } 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;
+    v2 = p.x * this.cosrot - p.y * this.sinrot;
+    u2 = p.y * this.cosrot + p.x * this.sinrot + this.u_0;
+  }
+  Qp = Math.exp(-this.BrA * v2);
+  Sp = 0.5 * (Qp - 1 / Qp);
+  Tp = 0.5 * (Qp + 1 / Qp);
+  Vp = Math.sin(this.BrA * u2);
+  Up = (Vp * this.cosgam + Sp * this.singam) / Tp;
+  if (Math.abs(Math.abs(Up) - 1) < EPSLN) {
+    coords.x = 0;
+    coords.y = Up < 0 ? -HALF_PI : HALF_PI;
   } else {
-    p.y = phi2z_default(this.e, ts);
-    p.x = adjust_lon_default(this.long0 - Math.atan2(sp * Math.cos(this.gamma0) - vp * Math.sin(this.gamma0), Math.cos(this.bl * us / this.al)) / this.bl);
+    coords.y = this.E / Math.sqrt((1 + Up) / (1 - Up));
+    coords.y = phi2z_default(this.e, Math.pow(coords.y, 1 / this.B));
+    if (coords.y === Infinity) {
+      throw new Error();
+    }
+    coords.x = -this.rB * Math.atan2(Sp * this.cosgam - Vp * this.singam, Math.cos(this.BrA * u2));
   }
-  return p;
+  coords.x += this.lam0;
+  return coords;
 }
-var names11 = ["Hotine_Oblique_Mercator", "Hotine Oblique Mercator", "Hotine_Oblique_Mercator_Azimuth_Natural_Origin", "Hotine_Oblique_Mercator_Azimuth_Center", "omerc"];
+var names11 = ["Hotine_Oblique_Mercator", "Hotine Oblique Mercator", "Hotine_Oblique_Mercator_Azimuth_Natural_Origin", "Hotine_Oblique_Mercator_Two_Point_Natural_Origin", "Hotine_Oblique_Mercator_Azimuth_Center", "Oblique_Mercator", "omerc"];
 var omerc_default = {
   init: init10,
   forward: forward9,
@@ -24083,7 +24423,15 @@ function inverse10(p) {
   p.y = lat;
   return p;
 }
-var names12 = ["Lambert Tangential Conformal Conic Projection", "Lambert_Conformal_Conic", "Lambert_Conformal_Conic_2SP", "lcc"];
+var names12 = [
+  "Lambert Tangential Conformal Conic Projection",
+  "Lambert_Conformal_Conic",
+  "Lambert_Conformal_Conic_1SP",
+  "Lambert_Conformal_Conic_2SP",
+  "lcc",
+  "Lambert Conic Conformal (1SP)",
+  "Lambert Conic Conformal (2SP)"
+];
 var lcc_default = {
   init: init11,
   forward: forward10,
@@ -26344,6 +26692,141 @@ var tpers_default = {
   names: names32
 };
 
+// ../../node_modules/proj4/lib/projections/geos.js
+init_preact_shim();
+function init32() {
+  this.flip_axis = this.sweep === "x" ? 1 : 0;
+  this.h = Number(this.h);
+  this.radius_g_1 = this.h / this.a;
+  if (this.radius_g_1 <= 0 || this.radius_g_1 > 1e10) {
+    throw new Error();
+  }
+  this.radius_g = 1 + this.radius_g_1;
+  this.C = this.radius_g * this.radius_g - 1;
+  if (this.es !== 0) {
+    var one_es = 1 - this.es;
+    var rone_es = 1 / one_es;
+    this.radius_p = Math.sqrt(one_es);
+    this.radius_p2 = one_es;
+    this.radius_p_inv2 = rone_es;
+    this.shape = "ellipse";
+  } else {
+    this.radius_p = 1;
+    this.radius_p2 = 1;
+    this.radius_p_inv2 = 1;
+    this.shape = "sphere";
+  }
+  if (!this.title) {
+    this.title = "Geostationary Satellite View";
+  }
+}
+function forward31(p) {
+  var lon = p.x;
+  var lat = p.y;
+  var tmp, v_x, v_y, v_z;
+  lon = lon - this.long0;
+  if (this.shape === "ellipse") {
+    lat = Math.atan(this.radius_p2 * Math.tan(lat));
+    var r2 = this.radius_p / hypot_default(this.radius_p * Math.cos(lat), Math.sin(lat));
+    v_x = r2 * Math.cos(lon) * Math.cos(lat);
+    v_y = r2 * Math.sin(lon) * Math.cos(lat);
+    v_z = r2 * Math.sin(lat);
+    if ((this.radius_g - v_x) * v_x - v_y * v_y - v_z * v_z * this.radius_p_inv2 < 0) {
+      p.x = Number.NaN;
+      p.y = Number.NaN;
+      return p;
+    }
+    tmp = this.radius_g - v_x;
+    if (this.flip_axis) {
+      p.x = this.radius_g_1 * Math.atan(v_y / hypot_default(v_z, tmp));
+      p.y = this.radius_g_1 * Math.atan(v_z / tmp);
+    } else {
+      p.x = this.radius_g_1 * Math.atan(v_y / tmp);
+      p.y = this.radius_g_1 * Math.atan(v_z / hypot_default(v_y, tmp));
+    }
+  } else if (this.shape === "sphere") {
+    tmp = Math.cos(lat);
+    v_x = Math.cos(lon) * tmp;
+    v_y = Math.sin(lon) * tmp;
+    v_z = Math.sin(lat);
+    tmp = this.radius_g - v_x;
+    if (this.flip_axis) {
+      p.x = this.radius_g_1 * Math.atan(v_y / hypot_default(v_z, tmp));
+      p.y = this.radius_g_1 * Math.atan(v_z / tmp);
+    } else {
+      p.x = this.radius_g_1 * Math.atan(v_y / tmp);
+      p.y = this.radius_g_1 * Math.atan(v_z / hypot_default(v_y, tmp));
+    }
+  }
+  p.x = p.x * this.a;
+  p.y = p.y * this.a;
+  return p;
+}
+function inverse31(p) {
+  var v_x = -1;
+  var v_y = 0;
+  var v_z = 0;
+  var a2, b2, det, k2;
+  p.x = p.x / this.a;
+  p.y = p.y / this.a;
+  if (this.shape === "ellipse") {
+    if (this.flip_axis) {
+      v_z = Math.tan(p.y / this.radius_g_1);
+      v_y = Math.tan(p.x / this.radius_g_1) * hypot_default(1, v_z);
+    } else {
+      v_y = Math.tan(p.x / this.radius_g_1);
+      v_z = Math.tan(p.y / this.radius_g_1) * hypot_default(1, v_y);
+    }
+    var v_zp = v_z / this.radius_p;
+    a2 = v_y * v_y + v_zp * v_zp + v_x * v_x;
+    b2 = 2 * this.radius_g * v_x;
+    det = b2 * b2 - 4 * a2 * this.C;
+    if (det < 0) {
+      p.x = Number.NaN;
+      p.y = Number.NaN;
+      return p;
+    }
+    k2 = (-b2 - Math.sqrt(det)) / (2 * a2);
+    v_x = this.radius_g + k2 * v_x;
+    v_y *= k2;
+    v_z *= k2;
+    p.x = Math.atan2(v_y, v_x);
+    p.y = Math.atan(v_z * Math.cos(p.x) / v_x);
+    p.y = Math.atan(this.radius_p_inv2 * Math.tan(p.y));
+  } else if (this.shape === "sphere") {
+    if (this.flip_axis) {
+      v_z = Math.tan(p.y / this.radius_g_1);
+      v_y = Math.tan(p.x / this.radius_g_1) * Math.sqrt(1 + v_z * v_z);
+    } else {
+      v_y = Math.tan(p.x / this.radius_g_1);
+      v_z = Math.tan(p.y / this.radius_g_1) * Math.sqrt(1 + v_y * v_y);
+    }
+    a2 = v_y * v_y + v_z * v_z + v_x * v_x;
+    b2 = 2 * this.radius_g * v_x;
+    det = b2 * b2 - 4 * a2 * this.C;
+    if (det < 0) {
+      p.x = Number.NaN;
+      p.y = Number.NaN;
+      return p;
+    }
+    k2 = (-b2 - Math.sqrt(det)) / (2 * a2);
+    v_x = this.radius_g + k2 * v_x;
+    v_y *= k2;
+    v_z *= k2;
+    p.x = Math.atan2(v_y, v_x);
+    p.y = Math.atan(v_z * Math.cos(p.x) / v_x);
+  }
+  p.x = p.x + this.long0;
+  return p;
+}
+var names33 = ["Geostationary Satellite View", "Geostationary_Satellite", "geos"];
+var geos_default = {
+  init: init32,
+  forward: forward31,
+  inverse: inverse31,
+  names: names33
+};
+
 // ../../node_modules/proj4/projs.js
 function projs_default(proj42) {
   proj42.Proj.projections.add(tmerc_default);
@@ -26374,6 +26857,7 @@ function projs_default(proj42) {
   proj42.Proj.projections.add(robin_default);
   proj42.Proj.projections.add(geocent_default);
   proj42.Proj.projections.add(tpers_default);
+  proj42.Proj.projections.add(geos_default);
 }
 
 // ../../node_modules/proj4/lib/index.js
@@ -26383,6 +26867,7 @@ core_default.WGS84 = new core_default.Proj("WGS84");
 core_default.Point = Point_default;
 core_default.toPoint = toPoint_default;
 core_default.defs = defs_default;
+core_default.nadgrid = nadgrid;
 core_default.transform = transform;
 core_default.mgrs = mgrs_default;
 core_default.version = "__VERSION__";
@@ -27227,7 +27712,7 @@ var Config = {
     return "UA-23232486-4";
   },
   get Version() {
-    return "v6.30.0";
+    return "v6.31.0";
   },
   map: new MapConfig()
 };
@@ -27797,7 +28282,8 @@ var MapAttribution = class {
       this.scheduleRender();
     };
     this.isIgnored = (attr) => {
-      return attr.collection.title.toLowerCase().startsWith("geographx");
+      const title = attr.collection.title.toLowerCase();
+      return title.startsWith("geographx") || title.includes(" dem ");
     };
     this.renderAttribution = () => {
       this._raf = 0;
@@ -28432,7 +28918,8 @@ var Basemaps = class extends _ {
     if (Config.map.debug["debug.screenshot"] !== true) {
       const nav = new import_maplibre_gl3.default.NavigationControl({ visualizePitch: true });
       this.map.addControl(nav, "top-left");
-      this.map.addControl(new import_maplibre_gl3.default.FullscreenControl({ container: this.el }));
+      if (!Config.map.isDebug)
+        this.map.addControl(new import_maplibre_gl3.default.FullscreenControl({ container: this.el }));
     }
     this.map.on("render", this.onRender);
     onMapLoaded(this.map, () => {