@hybridcore/ui 1.0.2 → 1.1.0

package/dist/components/geometry-picker/parser/coordinate-input/logic.js

@@ -0,0 +1,1305 @@
+import { useState as it, useEffect as ct } from "react";
+let ut = " ";
+class h {
+  // note Unicode Degree = U+00B0. Prime = U+2032, Double prime = U+2033
+  /**
+   * Separator character to be used to separate degrees, minutes, seconds, and cardinal directions.
+   *
+   * Default separator is U+202F ‘narrow no-break space’.
+   *
+   * To change this (e.g. to empty string or full space), set Dms.separator prior to invoking
+   * formatting.
+   *
+   * @example
+   *   import LatLon, { Dms } from '/js/geodesy/latlon-spherical.js';
+   *   const p = new LatLon(51.2, 0.33).toString('dms');  // 51° 12′ 00″ N, 000° 19′ 48″ E
+   *   Dms.separator = '';                                // no separator
+   *   const pʹ = new LatLon(51.2, 0.33).toString('dms'); // 51°12′00″N, 000°19′48″E
+   */
+  static get separator() {
+    return ut;
+  }
+  static set separator(t) {
+    ut = t;
+  }
+  /**
+   * Parses string representing degrees/minutes/seconds into numeric degrees.
+   *
+   * This is very flexible on formats, allowing signed decimal degrees, or deg-min-sec optionally
+   * suffixed by compass direction (NSEW); a variety of separators are accepted. Examples -3.62,
+   * '3 37 12W', '3°37′12″W'.
+   *
+   * Thousands/decimal separators must be comma/dot; use Dms.fromLocale to convert locale-specific
+   * thousands/decimal separators.
+   *
+   * @param   {string|number} dms - Degrees or deg/min/sec in variety of formats.
+   * @returns {number}        Degrees as decimal number.
+   *
+   * @example
+   *   const lat = Dms.parse('51° 28′ 40.37″ N');
+   *   const lon = Dms.parse('000° 00′ 05.29″ W');
+   *   const p1 = new LatLon(lat, lon); // 51.4779°N, 000.0015°W
+   */
+  static parse(t) {
+    if (!isNaN(parseFloat(t)) && isFinite(t)) return Number(t);
+    const n = String(t).trim().replace(/^-/, "").replace(/[NSEW]$/i, "").split(/[^0-9.,]+/);
+    if (n[n.length - 1] == "" && n.splice(n.length - 1), n == "") return NaN;
+    let s = null;
+    switch (n.length) {
+      case 3:
+        s = n[0] / 1 + n[1] / 60 + n[2] / 3600;
+        break;
+      case 2:
+        s = n[0] / 1 + n[1] / 60;
+        break;
+      case 1:
+        s = n[0];
+        break;
+      default:
+        return NaN;
+    }
+    return /^-|[WS]$/i.test(t.trim()) && (s = -s), Number(s);
+  }
+  /**
+   * Converts decimal degrees to deg/min/sec format
+   *  - degree, prime, double-prime symbols are added, but sign is discarded, though no compass
+   *    direction is added.
+   *  - degrees are zero-padded to 3 digits; for degrees latitude, use .slice(1) to remove leading
+   *    zero.
+   *
+   * @private
+   * @param   {number} deg - Degrees to be formatted as specified.
+   * @param   {string} [format=d] - Return value as 'd', 'dm', 'dms' for deg, deg+min, deg+min+sec.
+   * @param   {number} [dp=4|2|0] - Number of decimal places to use – default 4 for d, 2 for dm, 0 for dms.
+   * @returns {string} Degrees formatted as deg/min/secs according to specified format.
+   */
+  static toDms(t, n = "d", s = void 0) {
+    if (isNaN(t) || typeof t == "string" && t.trim() == "" || typeof t == "boolean" || t == 1 / 0 || t == null) return null;
+    if (s === void 0)
+      switch (n) {
+        case "d":
+        case "deg":
+          s = 4;
+          break;
+        case "dm":
+        case "deg+min":
+          s = 2;
+          break;
+        case "dms":
+        case "deg+min+sec":
+          s = 0;
+          break;
+        default:
+          n = "d", s = 4;
+          break;
+      }
+    t = Math.abs(t);
+    let e = null, i = null, r = null, a = null;
+    switch (n) {
+      default:
+      case "d":
+      case "deg":
+        i = t.toFixed(s), i < 100 && (i = "0" + i), i < 10 && (i = "0" + i), e = i + "°";
+        break;
+      case "dm":
+      case "deg+min":
+        i = Math.floor(t), r = (t * 60 % 60).toFixed(s), r == 60 && (r = 0 .toFixed(s), i++), i = ("000" + i).slice(-3), r < 10 && (r = "0" + r), e = i + "°" + h.separator + r + "′";
+        break;
+      case "dms":
+      case "deg+min+sec":
+        i = Math.floor(t), r = Math.floor(t * 3600 / 60) % 60, a = (t * 3600 % 60).toFixed(s), a == 60 && (a = 0 .toFixed(s), r++), r == 60 && (r = 0, i++), i = ("000" + i).slice(-3), r = ("00" + r).slice(-2), a < 10 && (a = "0" + a), e = i + "°" + h.separator + r + "′" + h.separator + a + "″";
+        break;
+    }
+    return e;
+  }
+  /**
+   * Converts numeric degrees to deg/min/sec latitude (2-digit degrees, suffixed with N/S).
+   *
+   * @param   {number} deg - Degrees to be formatted as specified.
+   * @param   {string} [format=d] - Return value as 'd', 'dm', 'dms' for deg, deg+min, deg+min+sec.
+   * @param   {number} [dp=4|2|0] - Number of decimal places to use – default 4 for d, 2 for dm, 0 for dms.
+   * @returns {string} Degrees formatted as deg/min/secs according to specified format.
+   *
+   * @example
+   *   const lat = Dms.toLat(-3.62, 'dms'); // 3°37′12″S
+   */
+  static toLat(t, n, s) {
+    const e = h.toDms(h.wrap90(t), n, s);
+    return e === null ? "–" : e.slice(1) + h.separator + (t < 0 ? "S" : "N");
+  }
+  /**
+   * Convert numeric degrees to deg/min/sec longitude (3-digit degrees, suffixed with E/W).
+   *
+   * @param   {number} deg - Degrees to be formatted as specified.
+   * @param   {string} [format=d] - Return value as 'd', 'dm', 'dms' for deg, deg+min, deg+min+sec.
+   * @param   {number} [dp=4|2|0] - Number of decimal places to use – default 4 for d, 2 for dm, 0 for dms.
+   * @returns {string} Degrees formatted as deg/min/secs according to specified format.
+   *
+   * @example
+   *   const lon = Dms.toLon(-3.62, 'dms'); // 3°37′12″W
+   */
+  static toLon(t, n, s) {
+    const e = h.toDms(h.wrap180(t), n, s);
+    return e === null ? "–" : e + h.separator + (t < 0 ? "W" : "E");
+  }
+  /**
+   * Converts numeric degrees to deg/min/sec as a bearing (0°..360°).
+   *
+   * @param   {number} deg - Degrees to be formatted as specified.
+   * @param   {string} [format=d] - Return value as 'd', 'dm', 'dms' for deg, deg+min, deg+min+sec.
+   * @param   {number} [dp=4|2|0] - Number of decimal places to use – default 4 for d, 2 for dm, 0 for dms.
+   * @returns {string} Degrees formatted as deg/min/secs according to specified format.
+   *
+   * @example
+   *   const lon = Dms.toBrng(-3.62, 'dms'); // 356°22′48″
+   */
+  static toBrng(t, n, s) {
+    const e = h.toDms(h.wrap360(t), n, s);
+    return e === null ? "–" : e.replace("360", "0");
+  }
+  /**
+   * Converts DMS string from locale thousands/decimal separators to JavaScript comma/dot separators
+   * for subsequent parsing.
+   *
+   * Both thousands and decimal separators must be followed by a numeric character, to facilitate
+   * parsing of single lat/long string (in which whitespace must be left after the comma separator).
+   *
+   * @param   {string} str - Degrees/minutes/seconds formatted with locale separators.
+   * @returns {string} Degrees/minutes/seconds formatted with standard Javascript separators.
+   *
+   * @example
+   *   const lat = Dms.fromLocale('51°28′40,12″N');                          // '51°28′40.12″N' in France
+   *   const p = new LatLon(Dms.fromLocale('51°28′40,37″N, 000°00′05,29″W'); // '51.4779°N, 000.0015°W' in France
+   */
+  static fromLocale(t) {
+    const n = 123456.789.toLocaleString(), s = { thousands: n.slice(3, 4), decimal: n.slice(7, 8) };
+    return t.replace(s.thousands, "⁜").replace(s.decimal, ".").replace("⁜", ",");
+  }
+  /**
+   * Converts DMS string from JavaScript comma/dot thousands/decimal separators to locale separators.
+   *
+   * Can also be used to format standard numbers such as distances.
+   *
+   * @param   {string} str - Degrees/minutes/seconds formatted with standard Javascript separators.
+   * @returns {string} Degrees/minutes/seconds formatted with locale separators.
+   *
+   * @example
+   *   const Dms.toLocale('123,456.789');                   // '123.456,789' in France
+   *   const Dms.toLocale('51°28′40.12″N, 000°00′05.31″W'); // '51°28′40,12″N, 000°00′05,31″W' in France
+   */
+  static toLocale(t) {
+    const n = 123456.789.toLocaleString(), s = { thousands: n.slice(3, 4), decimal: n.slice(7, 8) };
+    return t.replace(/,([0-9])/, "⁜$1").replace(".", s.decimal).replace("⁜", s.thousands);
+  }
+  /**
+   * Returns compass point (to given precision) for supplied bearing.
+   *
+   * @param   {number} bearing - Bearing in degrees from north.
+   * @param   {number} [precision=3] - Precision (1:cardinal / 2:intercardinal / 3:secondary-intercardinal).
+   * @returns {string} Compass point for supplied bearing.
+   *
+   * @example
+   *   const point = Dms.compassPoint(24);    // point = 'NNE'
+   *   const point = Dms.compassPoint(24, 1); // point = 'N'
+   */
+  static compassPoint(t, n = 3) {
+    if (![1, 2, 3].includes(Number(n))) throw new RangeError(`invalid precision ‘${n}’`);
+    t = h.wrap360(t);
+    const s = [
+      "N",
+      "NNE",
+      "NE",
+      "ENE",
+      "E",
+      "ESE",
+      "SE",
+      "SSE",
+      "S",
+      "SSW",
+      "SW",
+      "WSW",
+      "W",
+      "WNW",
+      "NW",
+      "NNW"
+    ], e = 4 * 2 ** (n - 1);
+    return s[Math.round(t * e / 360) % e * 16 / e];
+  }
+  /**
+   * Constrain degrees to range -90..+90 (for latitude); e.g. -91 => -89, 91 => 89.
+   *
+   * @private
+   * @param {number} degrees
+   * @returns degrees within range -90..+90.
+   */
+  static wrap90(t) {
+    if (-90 <= t && t <= 90) return t;
+    const n = t, s = 90, e = 360;
+    return 4 * s / e * Math.abs(((n - e / 4) % e + e) % e - e / 2) - s;
+  }
+  /**
+   * Constrain degrees to range -180..+180 (for longitude); e.g. -181 => 179, 181 => -179.
+   *
+   * @private
+   * @param {number} degrees
+   * @returns degrees within range -180..+180.
+   */
+  static wrap180(t) {
+    if (-180 <= t && t <= 180) return t;
+    const n = t, s = 180, e = 360;
+    return ((2 * s * n / e - e / 2) % e + e) % e - s;
+  }
+  /**
+   * Constrain degrees to range 0..360 (for bearings); e.g. -1 => 359, 361 => 1.
+   *
+   * @private
+   * @param {number} degrees
+   * @returns degrees within range 0..360.
+   */
+  static wrap360(t) {
+    if (0 <= t && t < 360) return t;
+    const n = t, s = 180, e = 360;
+    return (2 * s * n / e % e + e) % e;
+  }
+}
+Number.prototype.toRadians = function() {
+  return this * Math.PI / 180;
+};
+Number.prototype.toDegrees = function() {
+  return this * 180 / Math.PI;
+};
+class $ {
+  /**
+   * Creates a 3-d vector.
+   *
+   * @param {number} x - X component of vector.
+   * @param {number} y - Y component of vector.
+   * @param {number} z - Z component of vector.
+   *
+   * @example
+   *   import Vector3d from '/js/geodesy/vector3d.js';
+   *   const v = new Vector3d(0.267, 0.535, 0.802);
+   */
+  constructor(t, n, s) {
+    if (isNaN(t) || isNaN(n) || isNaN(s)) throw new TypeError(`invalid vector [${t},${n},${s}]`);
+    this.x = Number(t), this.y = Number(n), this.z = Number(s);
+  }
+  /**
+   * Length (magnitude or norm) of ‘this’ vector.
+   *
+   * @returns {number} Magnitude of this vector.
+   */
+  get length() {
+    return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
+  }
+  /**
+   * Adds supplied vector to ‘this’ vector.
+   *
+   * @param   {Vector3d} v - Vector to be added to this vector.
+   * @returns {Vector3d} Vector representing sum of this and v.
+   */
+  plus(t) {
+    if (!(t instanceof $)) throw new TypeError("v is not Vector3d object");
+    return new $(this.x + t.x, this.y + t.y, this.z + t.z);
+  }
+  /**
+   * Subtracts supplied vector from ‘this’ vector.
+   *
+   * @param   {Vector3d} v - Vector to be subtracted from this vector.
+   * @returns {Vector3d} Vector representing difference between this and v.
+   */
+  minus(t) {
+    if (!(t instanceof $)) throw new TypeError("v is not Vector3d object");
+    return new $(this.x - t.x, this.y - t.y, this.z - t.z);
+  }
+  /**
+   * Multiplies ‘this’ vector by a scalar value.
+   *
+   * @param   {number}   x - Factor to multiply this vector by.
+   * @returns {Vector3d} Vector scaled by x.
+   */
+  times(t) {
+    if (isNaN(t)) throw new TypeError(`invalid scalar value ‘${t}’`);
+    return new $(this.x * t, this.y * t, this.z * t);
+  }
+  /**
+   * Divides ‘this’ vector by a scalar value.
+   *
+   * @param   {number}   x - Factor to divide this vector by.
+   * @returns {Vector3d} Vector divided by x.
+   */
+  dividedBy(t) {
+    if (isNaN(t)) throw new TypeError(`invalid scalar value ‘${t}’`);
+    return new $(this.x / t, this.y / t, this.z / t);
+  }
+  /**
+   * Multiplies ‘this’ vector by the supplied vector using dot (scalar) product.
+   *
+   * @param   {Vector3d} v - Vector to be dotted with this vector.
+   * @returns {number}   Dot product of ‘this’ and v.
+   */
+  dot(t) {
+    if (!(t instanceof $)) throw new TypeError("v is not Vector3d object");
+    return this.x * t.x + this.y * t.y + this.z * t.z;
+  }
+  /**
+   * Multiplies ‘this’ vector by the supplied vector using cross (vector) product.
+   *
+   * @param   {Vector3d} v - Vector to be crossed with this vector.
+   * @returns {Vector3d} Cross product of ‘this’ and v.
+   */
+  cross(t) {
+    if (!(t instanceof $)) throw new TypeError("v is not Vector3d object");
+    const n = this.y * t.z - this.z * t.y, s = this.z * t.x - this.x * t.z, e = this.x * t.y - this.y * t.x;
+    return new $(n, s, e);
+  }
+  /**
+   * Negates a vector to point in the opposite direction.
+   *
+   * @returns {Vector3d} Negated vector.
+   */
+  negate() {
+    return new $(-this.x, -this.y, -this.z);
+  }
+  /**
+   * Normalizes a vector to its unit vector
+   * – if the vector is already unit or is zero magnitude, this is a no-op.
+   *
+   * @returns {Vector3d} Normalised version of this vector.
+   */
+  unit() {
+    const t = this.length;
+    if (t == 1) return this;
+    if (t == 0) return this;
+    const n = this.x / t, s = this.y / t, e = this.z / t;
+    return new $(n, s, e);
+  }
+  /**
+   * Calculates the angle between ‘this’ vector and supplied vector atan2(|p₁×p₂|, p₁·p₂) (or if
+   * (extra-planar) ‘n’ supplied then atan2(n·p₁×p₂, p₁·p₂).
+   *
+   * @param   {Vector3d} v - Vector whose angle is to be determined from ‘this’ vector.
+   * @param   {Vector3d} [n] - Plane normal: if supplied, angle is signed +ve if this->v is
+   *                     clockwise looking along n, -ve in opposite direction.
+   * @returns {number}   Angle (in radians) between this vector and supplied vector (in range 0..π
+   *                     if n not supplied, range -π..+π if n supplied).
+   */
+  angleTo(t, n = void 0) {
+    if (!(t instanceof $)) throw new TypeError("v is not Vector3d object");
+    if (!(n instanceof $ || n == null)) throw new TypeError("n is not Vector3d object");
+    const s = n == null || this.cross(t).dot(n) >= 0 ? 1 : -1, e = this.cross(t).length * s, i = this.dot(t);
+    return Math.atan2(e, i);
+  }
+  /**
+   * Rotates ‘this’ point around an axis by a specified angle.
+   *
+   * @param   {Vector3d} axis - The axis being rotated around.
+   * @param   {number}   angle - The angle of rotation (in degrees).
+   * @returns {Vector3d} The rotated point.
+   */
+  rotateAround(t, n) {
+    if (!(t instanceof $)) throw new TypeError("axis is not Vector3d object");
+    const s = n.toRadians(), e = this.unit(), i = t.unit(), r = Math.sin(s), a = Math.cos(s), o = 1 - a, f = i.x, c = i.y, u = i.z, w = [
+      // rotation matrix for rotation about supplied axis
+      [o * f * f + a, o * f * c - r * u, o * f * u + r * c],
+      [o * f * c + r * u, o * c * c + a, o * c * u - r * f],
+      [o * f * u - r * c, o * c * u + r * f, o * u * u + a]
+    ], N = [
+      w[0][0] * e.x + w[0][1] * e.y + w[0][2] * e.z,
+      w[1][0] * e.x + w[1][1] * e.y + w[1][2] * e.z,
+      w[2][0] * e.x + w[2][1] * e.y + w[2][2] * e.z
+    ];
+    return new $(N[0], N[1], N[2]);
+  }
+  /**
+   * String representation of vector.
+   *
+   * @param   {number} [dp=3] - Number of decimal places to be used.
+   * @returns {string} Vector represented as [x,y,z].
+   */
+  toString(t = 3) {
+    return `[${this.x.toFixed(t)},${this.y.toFixed(t)},${this.z.toFixed(t)}]`;
+  }
+}
+Number.prototype.toRadians = function() {
+  return this * Math.PI / 180;
+};
+Number.prototype.toDegrees = function() {
+  return this * 180 / Math.PI;
+};
+const B = {
+  WGS84: { a: 6378137, b: 6356752314245e-6, f: 1 / 298.257223563 }
+}, dt = {
+  WGS84: { ellipsoid: B.WGS84 }
+};
+Object.freeze(B.WGS84);
+Object.freeze(dt.WGS84);
+class Q {
+  /**
+   * Creates a geodetic latitude/longitude point on a (WGS84) ellipsoidal model earth.
+   *
+   * @param  {number} lat - Latitude (in degrees).
+   * @param  {number} lon - Longitude (in degrees).
+   * @param  {number} [height=0] - Height above ellipsoid in metres.
+   * @throws {TypeError} Invalid lat/lon/height.
+   *
+   * @example
+   *   import LatLon from '/js/geodesy/latlon-ellipsoidal.js';
+   *   const p = new LatLon(51.47788, -0.00147, 17);
+   */
+  constructor(t, n, s = 0) {
+    if (isNaN(t) || t == null) throw new TypeError(`invalid lat ‘${t}’`);
+    if (isNaN(n) || n == null) throw new TypeError(`invalid lon ‘${n}’`);
+    if (isNaN(s) || s == null) throw new TypeError(`invalid height ‘${s}’`);
+    this._lat = h.wrap90(Number(t)), this._lon = h.wrap180(Number(n)), this._height = Number(s);
+  }
+  /**
+   * Latitude in degrees north from equator (including aliases lat, latitude): can be set as
+   * numeric or hexagesimal (deg-min-sec); returned as numeric.
+   */
+  get lat() {
+    return this._lat;
+  }
+  get latitude() {
+    return this._lat;
+  }
+  set lat(t) {
+    if (this._lat = isNaN(t) ? h.wrap90(h.parse(t)) : h.wrap90(Number(t)), isNaN(this._lat)) throw new TypeError(`invalid lat ‘${t}’`);
+  }
+  set latitude(t) {
+    if (this._lat = isNaN(t) ? h.wrap90(h.parse(t)) : h.wrap90(Number(t)), isNaN(this._lat)) throw new TypeError(`invalid latitude ‘${t}’`);
+  }
+  /**
+   * Longitude in degrees east from international reference meridian (including aliases lon, lng,
+   * longitude): can be set as numeric or hexagesimal (deg-min-sec); returned as numeric.
+   */
+  get lon() {
+    return this._lon;
+  }
+  get lng() {
+    return this._lon;
+  }
+  get longitude() {
+    return this._lon;
+  }
+  set lon(t) {
+    if (this._lon = isNaN(t) ? h.wrap180(h.parse(t)) : h.wrap180(Number(t)), isNaN(this._lon)) throw new TypeError(`invalid lon ‘${t}’`);
+  }
+  set lng(t) {
+    if (this._lon = isNaN(t) ? h.wrap180(h.parse(t)) : h.wrap180(Number(t)), isNaN(this._lon)) throw new TypeError(`invalid lng ‘${t}’`);
+  }
+  set longitude(t) {
+    if (this._lon = isNaN(t) ? h.wrap180(h.parse(t)) : h.wrap180(Number(t)), isNaN(this._lon)) throw new TypeError(`invalid longitude ‘${t}’`);
+  }
+  /**
+   * Height in metres above ellipsoid.
+   */
+  get height() {
+    return this._height;
+  }
+  set height(t) {
+    if (this._height = Number(t), isNaN(this._height)) throw new TypeError(`invalid height ‘${t}’`);
+  }
+  /**
+   * Datum.
+   *
+   * Note this is replicated within LatLonEllipsoidal in order that a LatLonEllipsoidal object can
+   * be monkey-patched to look like a LatLonEllipsoidal_Datum, for Vincenty calculations on
+   * different ellipsoids.
+   *
+   * @private
+   */
+  get datum() {
+    return this._datum;
+  }
+  set datum(t) {
+    this._datum = t;
+  }
+  /**
+   * Ellipsoids with their parameters; this module only defines WGS84 parameters a = 6378137, b =
+   * 6356752.314245, f = 1/298.257223563.
+   *
+   * @example
+   *   const a = LatLon.ellipsoids.WGS84.a; // 6378137
+   */
+  static get ellipsoids() {
+    return B;
+  }
+  /**
+   * Datums; this module only defines WGS84 datum, hence no datum transformations.
+   *
+   * @example
+   *   const a = LatLon.datums.WGS84.ellipsoid.a; // 6377563.396
+   */
+  static get datums() {
+    return dt;
+  }
+  /**
+   * Parses a latitude/longitude point from a variety of formats.
+   *
+   * Latitude & longitude (in degrees) can be supplied as two separate parameters, as a single
+   * comma-separated lat/lon string, or as a single object with { lat, lon } or GeoJSON properties.
+   *
+   * The latitude/longitude values may be numeric or strings; they may be signed decimal or
+   * deg-min-sec (hexagesimal) suffixed by compass direction (NSEW); a variety of separators are
+   * accepted. Examples -3.62, '3 37 12W', '3°37′12″W'.
+   *
+   * Thousands/decimal separators must be comma/dot; use Dms.fromLocale to convert locale-specific
+   * thousands/decimal separators.
+   *
+   * @param   {number|string|Object} lat|latlon - Latitude (in degrees), or comma-separated lat/lon, or lat/lon object.
+   * @param   {number}               [lon]      - Longitude (in degrees).
+   * @param   {number}               [height=0] - Height above ellipsoid in metres.
+   * @returns {LatLon} Latitude/longitude point on WGS84 ellipsoidal model earth.
+   * @throws  {TypeError} Invalid coordinate.
+   *
+   * @example
+   *   const p1 = LatLon.parse(51.47788, -0.00147);              // numeric pair
+   *   const p2 = LatLon.parse('51°28′40″N, 000°00′05″W', 17);   // dms string + height
+   *   const p3 = LatLon.parse({ lat: 52.205, lon: 0.119 }, 17); // { lat, lon } object numeric + height
+   */
+  static parse(...t) {
+    if (t.length == 0) throw new TypeError("invalid (empty) point");
+    let n, s, e;
+    if (typeof t[0] == "object" && (t.length == 1 || !isNaN(parseFloat(t[1])))) {
+      const i = t[0];
+      if (i.type == "Point" && Array.isArray(i.coordinates) ? ([s, n, e] = i.coordinates, e = e || 0) : (i.latitude != null && (n = i.latitude), i.lat != null && (n = i.lat), i.longitude != null && (s = i.longitude), i.lng != null && (s = i.lng), i.lon != null && (s = i.lon), i.height != null && (e = i.height), n = h.wrap90(h.parse(n)), s = h.wrap180(h.parse(s))), t[1] != null && (e = t[1]), isNaN(n) || isNaN(s)) throw new TypeError(`invalid point ‘${JSON.stringify(t[0])}’`);
+    }
+    if (typeof t[0] == "string" && t[0].split(",").length == 2 && ([n, s] = t[0].split(","), n = h.wrap90(h.parse(n)), s = h.wrap180(h.parse(s)), e = t[1] || 0, isNaN(n) || isNaN(s)))
+      throw new TypeError(`invalid point ‘${t[0]}’`);
+    if (n == null && s == null && ([n, s] = t, n = h.wrap90(h.parse(n)), s = h.wrap180(h.parse(s)), e = t[2] || 0, isNaN(n) || isNaN(s)))
+      throw new TypeError(`invalid point ‘${t.toString()}’`);
+    return new this(n, s, e);
+  }
+  /**
+   * Converts ‘this’ point from (geodetic) latitude/longitude coordinates to (geocentric)
+   * cartesian (x/y/z) coordinates.
+   *
+   * @returns {Cartesian} Cartesian point equivalent to lat/lon point, with x, y, z in metres from
+   *   earth centre.
+   */
+  toCartesian() {
+    const t = this.datum ? this.datum.ellipsoid : this.referenceFrame ? this.referenceFrame.ellipsoid : B.WGS84, n = this.lat.toRadians(), s = this.lon.toRadians(), e = this.height, { a: i, f: r } = t, a = Math.sin(n), o = Math.cos(n), f = Math.sin(s), c = Math.cos(s), u = 2 * r - r * r, w = i / Math.sqrt(1 - u * a * a), N = (w + e) * o * c, g = (w + e) * o * f, d = (w * (1 - u) + e) * a;
+    return new ft(N, g, d);
+  }
+  /**
+   * Checks if another point is equal to ‘this’ point.
+   *
+   * @param   {LatLon} point - Point to be compared against this point.
+   * @returns {bool} True if points have identical latitude, longitude, height, and datum/referenceFrame.
+   * @throws  {TypeError} Invalid point.
+   *
+   * @example
+   *   const p1 = new LatLon(52.205, 0.119);
+   *   const p2 = new LatLon(52.205, 0.119);
+   *   const equal = p1.equals(p2); // true
+   */
+  equals(t) {
+    if (!(t instanceof Q)) throw new TypeError(`invalid point ‘${t}’`);
+    return !(Math.abs(this.lat - t.lat) > Number.EPSILON || Math.abs(this.lon - t.lon) > Number.EPSILON || Math.abs(this.height - t.height) > Number.EPSILON || this.datum != t.datum || this.referenceFrame != t.referenceFrame || this.epoch != t.epoch);
+  }
+  /**
+   * Returns a string representation of ‘this’ point, formatted as degrees, degrees+minutes, or
+   * degrees+minutes+seconds.
+   *
+   * @param   {string} [format=d] - Format point as 'd', 'dm', 'dms', or 'n' for signed numeric.
+   * @param   {number} [dp=4|2|0] - Number of decimal places to use: default 4 for d, 2 for dm, 0 for dms.
+   * @param   {number} [dpHeight=null] - Number of decimal places to use for height; default is no height display.
+   * @returns {string} Comma-separated formatted latitude/longitude.
+   * @throws  {RangeError} Invalid format.
+   *
+   * @example
+   *   const greenwich = new LatLon(51.47788, -0.00147, 46);
+   *   const d = greenwich.toString();                        // 51.4779°N, 000.0015°W
+   *   const dms = greenwich.toString('dms', 2);              // 51°28′40″N, 000°00′05″W
+   *   const [lat, lon] = greenwich.toString('n').split(','); // 51.4779, -0.0015
+   *   const dmsh = greenwich.toString('dms', 0, 0);          // 51°28′40″N, 000°00′06″W +46m
+   */
+  toString(t = "d", n = void 0, s = null) {
+    if (!["d", "dm", "dms", "n"].includes(t)) throw new RangeError(`invalid format ‘${t}’`);
+    const e = (this.height >= 0 ? " +" : " ") + this.height.toFixed(s) + "m";
+    if (t == "n") {
+      n == null && (n = 4);
+      const a = this.lat.toFixed(n), o = this.lon.toFixed(n);
+      return `${a}, ${o}${s == null ? "" : e}`;
+    }
+    const i = h.toLat(this.lat, t, n), r = h.toLon(this.lon, t, n);
+    return `${i}, ${r}${s == null ? "" : e}`;
+  }
+}
+class ft extends $ {
+  /**
+   * Creates cartesian coordinate representing ECEF (earth-centric earth-fixed) point.
+   *
+   * @param {number} x - X coordinate in metres (=> 0°N,0°E).
+   * @param {number} y - Y coordinate in metres (=> 0°N,90°E).
+   * @param {number} z - Z coordinate in metres (=> 90°N).
+   *
+   * @example
+   *   import { Cartesian } from '/js/geodesy/latlon-ellipsoidal.js';
+   *   const coord = new Cartesian(3980581.210, -111.159, 4966824.522);
+   */
+  constructor(t, n, s) {
+    super(t, n, s);
+  }
+  /**
+   * Converts ‘this’ (geocentric) cartesian (x/y/z) coordinate to (geodetic) latitude/longitude
+   * point on specified ellipsoid.
+   *
+   * Uses Bowring’s (1985) formulation for μm precision in concise form; ‘The accuracy of geodetic
+   * latitude and height equations’, B R Bowring, Survey Review vol 28, 218, Oct 1985.
+   *
+   * @param   {LatLon.ellipsoids} [ellipsoid=WGS84] - Ellipsoid to use when converting point.
+   * @returns {LatLon} Latitude/longitude point defined by cartesian coordinates, on given ellipsoid.
+   * @throws  {TypeError} Invalid ellipsoid.
+   *
+   * @example
+   *   const c = new Cartesian(4027893.924, 307041.993, 4919474.294);
+   *   const p = c.toLatLon(); // 50.7978°N, 004.3592°E
+   */
+  toLatLon(t = B.WGS84) {
+    if (!t || !t.a) throw new TypeError(`invalid ellipsoid ‘${t}’`);
+    const { x: n, y: s, z: e } = this, { a: i, b: r, f: a } = t, o = 2 * a - a * a, f = o / (1 - o), c = Math.sqrt(n * n + s * s), u = Math.sqrt(c * c + e * e), w = r * e / (i * c) * (1 + f * r / u), N = w / Math.sqrt(1 + w * w), g = N / w, d = isNaN(g) ? 0 : Math.atan2(e + f * r * N * N * N, c - o * i * g * g * g), p = Math.atan2(s, n), m = Math.sin(d), y = Math.cos(d), b = i / Math.sqrt(1 - o * m * m), S = c * y + e * m - i * i / b;
+    return new Q(d.toDegrees(), p.toDegrees(), S);
+  }
+  /**
+   * Returns a string representation of ‘this’ cartesian point.
+   *
+   * @param   {number} [dp=0] - Number of decimal places to use.
+   * @returns {string} Comma-separated latitude/longitude.
+   */
+  toString(t = 0) {
+    const n = this.x.toFixed(t), s = this.y.toFixed(t), e = this.z.toFixed(t);
+    return `[${n},${s},${e}]`;
+  }
+}
+const x = {
+  WGS84: { a: 6378137, b: 6356752314245e-6, f: 1 / 298.257223563 },
+  Airy1830: { a: 6377563396e-3, b: 6356256909e-3, f: 1 / 299.3249646 },
+  AiryModified: { a: 6377340189e-3, b: 6356034448e-3, f: 1 / 299.3249646 },
+  Bessel1841: { a: 6377397155e-3, b: 6356078962818e-6, f: 1 / 299.1528128 },
+  Clarke1866: { a: 63782064e-1, b: 63565838e-1, f: 1 / 294.978698214 },
+  Clarke1880IGN: { a: 63782492e-1, b: 6356515, f: 1 / 293.466021294 },
+  GRS80: { a: 6378137, b: 635675231414e-5, f: 1 / 298.257222101 },
+  Intl1924: { a: 6378388, b: 6356911946e-3, f: 1 / 297 },
+  // aka Hayford
+  WGS72: { a: 6378135, b: 63567505e-1, f: 1 / 298.26 }
+}, R = {
+  // transforms: t in metres, s in ppm, r in arcseconds              tx       ty        tz       s        rx        ry        rz
+  ED50: { ellipsoid: x.Intl1924, transform: [89.5, 93.8, 123.1, -1.2, 0, 0, 0.156] },
+  // epsg.io/1311
+  ETRS89: { ellipsoid: x.GRS80, transform: [0, 0, 0, 0, 0, 0, 0] },
+  // epsg.io/1149; @ 1-metre level
+  Irl1975: { ellipsoid: x.AiryModified, transform: [-482.53, 130.596, -564.557, -8.15, 1.042, 0.214, 0.631] },
+  // epsg.io/1954
+  NAD27: { ellipsoid: x.Clarke1866, transform: [8, -160, -176, 0, 0, 0, 0] },
+  NAD83: { ellipsoid: x.GRS80, transform: [0.9956, -1.9103, -0.5215, -62e-5, 0.025915, 9426e-6, 0.011599] },
+  NTF: { ellipsoid: x.Clarke1880IGN, transform: [168, 60, -320, 0, 0, 0, 0] },
+  OSGB36: { ellipsoid: x.Airy1830, transform: [-446.448, 125.157, -542.06, 20.4894, -0.1502, -0.247, -0.8421] },
+  // epsg.io/1314
+  Potsdam: { ellipsoid: x.Bessel1841, transform: [-582, -105, -414, -8.3, 1.04, 0.35, -3.08] },
+  TokyoJapan: { ellipsoid: x.Bessel1841, transform: [148, -507, -685, 0, 0, 0, 0] },
+  WGS72: { ellipsoid: x.WGS72, transform: [0, 0, -4.5, -0.22, 0, 0, 0.554] },
+  WGS84: { ellipsoid: x.WGS84, transform: [0, 0, 0, 0, 0, 0, 0] }
+};
+Object.keys(x).forEach((M) => Object.freeze(x[M]));
+Object.keys(R).forEach((M) => {
+  Object.freeze(R[M]), Object.freeze(R[M].transform);
+});
+class D extends Q {
+  /**
+   * Creates a geodetic latitude/longitude point on an ellipsoidal model earth using given datum.
+   *
+   * @param {number} lat - Latitude (in degrees).
+   * @param {number} lon - Longitude (in degrees).
+   * @param {number} [height=0] - Height above ellipsoid in metres.
+   * @param {LatLon.datums} datum - Datum this point is defined within.
+   *
+   * @example
+   *   import LatLon from '/js/geodesy/latlon-ellipsoidal-datum.js';
+   *   const p = new LatLon(53.3444, -6.2577, 17, LatLon.datums.Irl1975);
+   */
+  constructor(t, n, s = 0, e = R.WGS84) {
+    if (!e || e.ellipsoid == null) throw new TypeError(`unrecognised datum ‘${e}’`);
+    super(t, n, s), this._datum = e;
+  }
+  /**
+   * Datum this point is defined within.
+   */
+  get datum() {
+    return this._datum;
+  }
+  /**
+   * Ellipsoids with their parameters; semi-major axis (a), semi-minor axis (b), and flattening (f).
+   *
+   * Flattening f = (a−b)/a; at least one of these parameters is derived from defining constants.
+   *
+   * @example
+   *   const a = LatLon.ellipsoids.Airy1830.a; // 6377563.396
+   */
+  static get ellipsoids() {
+    return x;
+  }
+  /**
+   * Datums; with associated ellipsoid, and Helmert transform parameters to convert from WGS-84
+   * into given datum.
+   *
+   * Note that precision of various datums will vary, and WGS-84 (original) is not defined to be
+   * accurate to better than ±1 metre. No transformation should be assumed to be accurate to
+   * better than a metre, for many datums somewhat less.
+   *
+   * This is a small sample of commoner datums from a large set of historical datums. I will add
+   * new datums on request.
+   *
+   * @example
+   *   const a = LatLon.datums.OSGB36.ellipsoid.a;                    // 6377563.396
+   *   const tx = LatLon.datums.OSGB36.transform;                     // [ tx, ty, tz, s, rx, ry, rz ]
+   *   const availableDatums = Object.keys(LatLon.datums).join(', '); // ED50, Irl1975, NAD27, ...
+   */
+  static get datums() {
+    return R;
+  }
+  // note instance datum getter/setters are in LatLonEllipsoidal
+  /**
+   * Parses a latitude/longitude point from a variety of formats.
+   *
+   * Latitude & longitude (in degrees) can be supplied as two separate parameters, as a single
+   * comma-separated lat/lon string, or as a single object with { lat, lon } or GeoJSON properties.
+   *
+   * The latitude/longitude values may be numeric or strings; they may be signed decimal or
+   * deg-min-sec (hexagesimal) suffixed by compass direction (NSEW); a variety of separators are
+   * accepted. Examples -3.62, '3 37 12W', '3°37′12″W'.
+   *
+   * Thousands/decimal separators must be comma/dot; use Dms.fromLocale to convert locale-specific
+   * thousands/decimal separators.
+   *
+   * @param   {number|string|Object} lat|latlon - Geodetic Latitude (in degrees) or comma-separated lat/lon or lat/lon object.
+   * @param   {number}               [lon] - Longitude in degrees.
+   * @param   {number}               [height=0] - Height above ellipsoid in metres.
+   * @param   {LatLon.datums}        [datum=WGS84] - Datum this point is defined within.
+   * @returns {LatLon} Latitude/longitude point on ellipsoidal model earth using given datum.
+   * @throws  {TypeError} Unrecognised datum.
+   *
+   * @example
+   *   const p = LatLon.parse('51.47736, 0.0000', 0, LatLon.datums.OSGB36);
+   */
+  static parse(...t) {
+    let n = R.WGS84;
+    if ((t.length == 4 || t.length == 3 && typeof t[2] == "object") && (n = t.pop()), !n || n.ellipsoid == null) throw new TypeError(`unrecognised datum ‘${n}’`);
+    const s = super.parse(...t);
+    return s._datum = n, s;
+  }
+  /**
+   * Converts ‘this’ lat/lon coordinate to new coordinate system.
+   *
+   * @param   {LatLon.datums} toDatum - Datum this coordinate is to be converted to.
+   * @returns {LatLon} This point converted to new datum.
+   * @throws  {TypeError} Unrecognised datum.
+   *
+   * @example
+   *   const pWGS84 = new LatLon(51.47788, -0.00147, 0, LatLon.datums.WGS84);
+   *   const pOSGB = pWGS84.convertDatum(LatLon.datums.OSGB36); // 51.4773°N, 000.0001°E
+   */
+  convertDatum(t) {
+    if (!t || t.ellipsoid == null) throw new TypeError(`unrecognised datum ‘${t}’`);
+    return this.toCartesian().convertDatum(t).toLatLon();
+  }
+  /**
+   * Converts ‘this’ point from (geodetic) latitude/longitude coordinates to (geocentric) cartesian
+   * (x/y/z) coordinates, based on the same datum.
+   *
+   * Shadow of LatLonEllipsoidal.toCartesian(), returning Cartesian augmented with
+   * LatLonEllipsoidal_Datum methods/properties.
+   *
+   * @returns {Cartesian} Cartesian point equivalent to lat/lon point, with x, y, z in metres from
+   *   earth centre, augmented with reference frame conversion methods and properties.
+   */
+  toCartesian() {
+    const t = super.toCartesian();
+    return new lt(t.x, t.y, t.z, this.datum);
+  }
+}
+class lt extends ft {
+  /**
+   * Creates cartesian coordinate representing ECEF (earth-centric earth-fixed) point, on a given
+   * datum. The datum will identify the primary meridian (for the x-coordinate), and is also
+   * useful in transforming to/from geodetic (lat/lon) coordinates.
+   *
+   * @param  {number} x - X coordinate in metres (=> 0°N,0°E).
+   * @param  {number} y - Y coordinate in metres (=> 0°N,90°E).
+   * @param  {number} z - Z coordinate in metres (=> 90°N).
+   * @param  {LatLon.datums} [datum] - Datum this coordinate is defined within.
+   * @throws {TypeError} Unrecognised datum.
+   *
+   * @example
+   *   import { Cartesian } from '/js/geodesy/latlon-ellipsoidal-datum.js';
+   *   const coord = new Cartesian(3980581.210, -111.159, 4966824.522);
+   */
+  constructor(t, n, s, e = void 0) {
+    if (e && e.ellipsoid == null) throw new TypeError(`unrecognised datum ‘${e}’`);
+    super(t, n, s), e && (this._datum = e);
+  }
+  /**
+   * Datum this point is defined within.
+   */
+  get datum() {
+    return this._datum;
+  }
+  set datum(t) {
+    if (!t || t.ellipsoid == null) throw new TypeError(`unrecognised datum ‘${t}’`);
+    this._datum = t;
+  }
+  /**
+   * Converts ‘this’ (geocentric) cartesian (x/y/z) coordinate to (geodetic) latitude/longitude
+   * point (based on the same datum, or WGS84 if unset).
+   *
+   * Shadow of Cartesian.toLatLon(), returning LatLon augmented with LatLonEllipsoidal_Datum
+   * methods convertDatum, toCartesian, etc.
+   *
+   * @returns {LatLon} Latitude/longitude point defined by cartesian coordinates.
+   * @throws  {TypeError} Unrecognised datum
+   *
+   * @example
+   *   const c = new Cartesian(4027893.924, 307041.993, 4919474.294);
+   *   const p = c.toLatLon(); // 50.7978°N, 004.3592°E
+   */
+  toLatLon(t = void 0) {
+    t && (console.info("datum parameter to Cartesian_Datum.toLatLon is deprecated: set datum before calling toLatLon()"), this.datum = t);
+    const n = this.datum || R.WGS84;
+    if (!n || n.ellipsoid == null) throw new TypeError(`unrecognised datum ‘${n}’`);
+    const s = super.toLatLon(n.ellipsoid);
+    return new D(s.lat, s.lon, s.height, this.datum);
+  }
+  /**
+   * Converts ‘this’ cartesian coordinate to new datum using Helmert 7-parameter transformation.
+   *
+   * @param   {LatLon.datums} toDatum - Datum this coordinate is to be converted to.
+   * @returns {Cartesian} This point converted to new datum.
+   * @throws  {Error} Undefined datum.
+   *
+   * @example
+   *   const c = new Cartesian(3980574.247, -102.127, 4966830.065, LatLon.datums.OSGB36);
+   *   c.convertDatum(LatLon.datums.Irl1975); // [??,??,??]
+   */
+  convertDatum(t) {
+    if (!t || t.ellipsoid == null) throw new TypeError(`unrecognised datum ‘${t}’`);
+    if (!this.datum) throw new TypeError("cartesian coordinate has no datum");
+    let n = null, s = null;
+    (this.datum == null || this.datum == R.WGS84) && (n = this, s = t.transform), t == R.WGS84 && (n = this, s = this.datum.transform.map((i) => -i)), s == null && (n = this.convertDatum(R.WGS84), s = t.transform);
+    const e = n.applyTransform(s);
+    return e.datum = t, e;
+  }
+  /**
+   * Applies Helmert 7-parameter transformation to ‘this’ coordinate using transform parameters t.
+   *
+   * This is used in converting datums (geodetic->cartesian, apply transform, cartesian->geodetic).
+   *
+   * @private
+   * @param   {number[]} t - Transformation to apply to this coordinate.
+   * @returns {Cartesian} Transformed point.
+   */
+  applyTransform(t) {
+    const { x: n, y: s, z: e } = this, i = t[0], r = t[1], a = t[2], o = t[3] / 1e6 + 1, f = (t[4] / 3600).toRadians(), c = (t[5] / 3600).toRadians(), u = (t[6] / 3600).toRadians(), w = i + n * o - s * u + e * c, N = r + n * u + s * o - e * f, g = a - n * c + s * f + e * o;
+    return new lt(w, N, g);
+  }
+}
+class pt {
+  /**
+   * Creates a Utm coordinate object comprising zone, hemisphere, easting, northing on a given
+   * datum (normally WGS84).
+   *
+   * @param  {number}        zone - UTM 6° longitudinal zone (1..60 covering 180°W..180°E).
+   * @param  {string}        hemisphere - N for northern hemisphere, S for southern hemisphere.
+   * @param  {number}        easting - Easting in metres from false easting (-500km from central meridian).
+   * @param  {number}        northing - Northing in metres from equator (N) or from false northing -10,000km (S).
+   * @param  {LatLon.datums} [datum=WGS84] - Datum UTM coordinate is based on.
+   * @param  {number}        [convergence=null] - Meridian convergence (bearing of grid north
+   *                         clockwise from true north), in degrees.
+   * @param  {number}        [scale=null] - Grid scale factor.
+   * @params {boolean=true}  verifyEN - Check easting/northing is within 'normal' values (may be
+   *                         suppressed for extended coherent coordinates or alternative datums
+   *                         e.g. ED50 (epsg.io/23029).
+   * @throws {TypeError} Invalid UTM coordinate.
+   *
+   * @example
+   *   import Utm from '/js/geodesy/utm.js';
+   *   const utmCoord = new Utm(31, 'N', 448251, 5411932);
+   */
+  constructor(t, n, s, e, i = D.datums.WGS84, r = null, a = null, o = !0) {
+    if (!(1 <= t && t <= 60)) throw new RangeError(`invalid UTM zone ‘${t}’`);
+    if (t != parseInt(t)) throw new RangeError(`invalid UTM zone ‘${t}’`);
+    if (typeof n != "string" || !n.match(/[NS]/i)) throw new RangeError(`invalid UTM hemisphere ‘${n}’`);
+    if (o) {
+      if (!(0 <= s && s <= 1e6)) throw new RangeError(`invalid UTM easting ‘${s}’`);
+      if (n.toUpperCase() == "N" && !(0 <= e && e < 9328094)) throw new RangeError(`invalid UTM northing ‘${e}’`);
+      if (n.toUpperCase() == "S" && !(1118414 < e && e <= 1e7)) throw new RangeError(`invalid UTM northing ‘${e}’`);
+    }
+    if (!i || i.ellipsoid == null) throw new TypeError(`unrecognised datum ‘${i}’`);
+    this.zone = Number(t), this.hemisphere = n.toUpperCase(), this.easting = Number(s), this.northing = Number(e), this.datum = i, this.convergence = r === null ? null : Number(r), this.scale = a === null ? null : Number(a);
+  }
+  /**
+   * Converts UTM zone/easting/northing coordinate to latitude/longitude.
+   *
+   * Implements Karney’s method, using Krüger series to order n⁶, giving results accurate to 5nm
+   * for distances up to 3900km from the central meridian.
+   *
+   * @param   {Utm} utmCoord - UTM coordinate to be converted to latitude/longitude.
+   * @returns {LatLon} Latitude/longitude of supplied grid reference.
+   *
+   * @example
+   *   const grid = new Utm(31, 'N', 448251.795, 5411932.678);
+   *   const latlong = grid.toLatLon(); // 48°51′29.52″N, 002°17′40.20″E
+   */
+  toLatLon() {
+    const { zone: t, hemisphere: n } = this, s = 5e5, e = 1e7, { a: i, f: r } = this.datum.ellipsoid, a = 0.9996, o = this.easting - s, f = n == "S" ? this.northing - e : this.northing, c = Math.sqrt(r * (2 - r)), u = r / (2 - r), w = u * u, N = u * w, g = u * N, d = u * g, p = u * d, m = i / (1 + u) * (1 + 1 / 4 * w + 1 / 64 * g + 1 / 256 * p), y = o / (a * m), b = f / (a * m), S = [
+      null,
+      // note β is one-based array (6th order Krüger expressions)
+      1 / 2 * u - 2 / 3 * w + 37 / 96 * N - 1 / 360 * g - 81 / 512 * d + 96199 / 604800 * p,
+      1 / 48 * w + 1 / 15 * N - 437 / 1440 * g + 46 / 105 * d - 1118711 / 3870720 * p,
+      17 / 480 * N - 37 / 840 * g - 209 / 4480 * d + 5569 / 90720 * p,
+      4397 / 161280 * g - 11 / 504 * d - 830251 / 7257600 * p,
+      4583 / 161280 * d - 108847 / 3991680 * p,
+      20648693 / 638668800 * p
+    ];
+    let L = b;
+    for (let l = 1; l <= 6; l++) L -= S[l] * Math.sin(2 * l * b) * Math.cosh(2 * l * y);
+    let P = y;
+    for (let l = 1; l <= 6; l++) P -= S[l] * Math.cos(2 * l * b) * Math.sinh(2 * l * y);
+    const G = Math.sinh(P), v = Math.sin(L), F = Math.cos(L), T = v / Math.sqrt(G * G + F * F);
+    let W = null, E = T;
+    do {
+      const l = Math.sinh(c * Math.atanh(c * E / Math.sqrt(1 + E * E))), st = E * Math.sqrt(1 + l * l) - l * Math.sqrt(1 + E * E);
+      W = (T - st) / Math.sqrt(1 + st * st) * (1 + (1 - c * c) * E * E) / ((1 - c * c) * Math.sqrt(1 + E * E)), E += W;
+    } while (Math.abs(W) > 1e-12);
+    const q = E, U = Math.atan(q);
+    let O = Math.atan2(G, F), C = 1;
+    for (let l = 1; l <= 6; l++) C -= 2 * l * S[l] * Math.cos(2 * l * b) * Math.cosh(2 * l * y);
+    let z = 0;
+    for (let l = 1; l <= 6; l++) z += 2 * l * S[l] * Math.sin(2 * l * b) * Math.sinh(2 * l * y);
+    const k = Math.atan(Math.tan(L) * Math.tanh(P)), j = Math.atan2(z, C), A = k + j, X = Math.sin(U), H = Math.sqrt(1 - c * c * X * X) * Math.sqrt(1 + q * q) * Math.sqrt(G * G + F * F), Y = m / i / Math.sqrt(C * C + z * z), J = a * H * Y, Z = ((t - 1) * 6 - 180 + 3).toRadians();
+    O += Z;
+    const V = Number(U.toDegrees().toFixed(14)), tt = Number(O.toDegrees().toFixed(14)), nt = Number(A.toDegrees().toFixed(9)), et = Number(J.toFixed(12)), I = new K(V, tt, 0, this.datum);
+    return I.convergence = nt, I.scale = et, I;
+  }
+  /**
+   * Parses string representation of UTM coordinate.
+   *
+   * A UTM coordinate comprises (space-separated)
+   *  - zone
+   *  - hemisphere
+   *  - easting
+   *  - northing.
+   *
+   * @param   {string} utmCoord - UTM coordinate (WGS 84).
+   * @param   {Datum}  [datum=WGS84] - Datum coordinate is defined in (default WGS 84).
+   * @returns {Utm} Parsed UTM coordinate.
+   * @throws  {TypeError} Invalid UTM coordinate.
+   *
+   * @example
+   *   const utmCoord = Utm.parse('31 N 448251 5411932');
+   *   // utmCoord: {zone: 31, hemisphere: 'N', easting: 448251, northing: 5411932 }
+   */
+  static parse(t, n = D.datums.WGS84) {
+    if (t = t.trim().match(/\S+/g), t == null || t.length != 4) throw new Error(`invalid UTM coordinate ‘${t}’`);
+    const s = t[0], e = t[1], i = t[2], r = t[3];
+    return new this(s, e, i, r, n);
+  }
+  /**
+   * Returns a string representation of a UTM coordinate.
+   *
+   * To distinguish from MGRS grid zone designators, a space is left between the zone and the
+   * hemisphere.
+   *
+   * Note that UTM coordinates get rounded, not truncated (unlike MGRS grid references).
+   *
+   * @param   {number} [digits=0] - Number of digits to appear after the decimal point (3 ≡ mm).
+   * @returns {string} A string representation of the coordinate.
+   *
+   * @example
+   *   const utm = new Utm('31', 'N', 448251, 5411932).toString(4);  // 31 N 448251.0000 5411932.0000
+   */
+  toString(t = 0) {
+    const n = this.zone.toString().padStart(2, "0"), s = this.hemisphere, e = this.easting.toFixed(t), i = this.northing.toFixed(t);
+    return `${n} ${s} ${e} ${i}`;
+  }
+}
+class K extends D {
+  /**
+   * Converts latitude/longitude to UTM coordinate.
+   *
+   * Implements Karney’s method, using Krüger series to order n⁶, giving results accurate to 5nm
+   * for distances up to 3900km from the central meridian.
+   *
+   * @param   {number} [zoneOverride] - Use specified zone rather than zone within which point lies;
+   *          note overriding the UTM zone has the potential to result in negative eastings, and
+   *          perverse results within Norway/Svalbard exceptions.
+   * @returns {Utm} UTM coordinate.
+   * @throws  {TypeError} Latitude outside UTM limits.
+   *
+   * @example
+   *   const latlong = new LatLon(48.8582, 2.2945);
+   *   const utmCoord = latlong.toUtm(); // 31 N 448252 5411933
+   */
+  toUtm(t = void 0) {
+    if (!(-80 <= this.lat && this.lat <= 84)) throw new RangeError(`latitude ‘${this.lat}’ outside UTM limits`);
+    const n = 5e5, s = 1e7;
+    let e = t || Math.floor((this.lon + 180) / 6) + 1, i = ((e - 1) * 6 - 180 + 3).toRadians();
+    const a = "CDEFGHJKLMNPQRSTUVWXX".charAt(Math.floor(this.lat / 8 + 10));
+    e == 31 && a == "V" && this.lon >= 3 && (e++, i += 6 .toRadians()), e == 32 && a == "X" && this.lon < 9 && (e--, i -= 6 .toRadians()), e == 32 && a == "X" && this.lon >= 9 && (e++, i += 6 .toRadians()), e == 34 && a == "X" && this.lon < 21 && (e--, i -= 6 .toRadians()), e == 34 && a == "X" && this.lon >= 21 && (e++, i += 6 .toRadians()), e == 36 && a == "X" && this.lon < 33 && (e--, i -= 6 .toRadians()), e == 36 && a == "X" && this.lon >= 33 && (e++, i += 6 .toRadians());
+    const o = this.lat.toRadians(), f = this.lon.toRadians() - i, c = this.datum ? this.datum.ellipsoid : D.ellipsoids.WGS84, { a: u, f: w } = c, N = 0.9996, g = Math.sqrt(w * (2 - w)), d = w / (2 - w), p = d * d, m = d * p, y = d * m, b = d * y, S = d * b, L = Math.cos(f), P = Math.sin(f), G = Math.tan(f), v = Math.tan(o), F = Math.sinh(g * Math.atanh(g * v / Math.sqrt(1 + v * v))), T = v * Math.sqrt(1 + F * F) - F * Math.sqrt(1 + v * v), W = Math.atan2(T, L), E = Math.asinh(P / Math.sqrt(T * T + L * L)), q = u / (1 + d) * (1 + 1 / 4 * p + 1 / 64 * y + 1 / 256 * S), U = [
+      null,
+      // note α is one-based array (6th order Krüger expressions)
+      1 / 2 * d - 2 / 3 * p + 5 / 16 * m + 41 / 180 * y - 127 / 288 * b + 7891 / 37800 * S,
+      13 / 48 * p - 3 / 5 * m + 557 / 1440 * y + 281 / 630 * b - 1983433 / 1935360 * S,
+      61 / 240 * m - 103 / 140 * y + 15061 / 26880 * b + 167603 / 181440 * S,
+      49561 / 161280 * y - 179 / 168 * b + 6601661 / 7257600 * S,
+      34729 / 80640 * b - 3418889 / 1995840 * S,
+      212378941 / 319334400 * S
+    ];
+    let O = W;
+    for (let l = 1; l <= 6; l++) O += U[l] * Math.sin(2 * l * W) * Math.cosh(2 * l * E);
+    let C = E;
+    for (let l = 1; l <= 6; l++) C += U[l] * Math.cos(2 * l * W) * Math.sinh(2 * l * E);
+    let z = N * q * C, k = N * q * O, j = 1;
+    for (let l = 1; l <= 6; l++) j += 2 * l * U[l] * Math.cos(2 * l * W) * Math.cosh(2 * l * E);
+    let A = 0;
+    for (let l = 1; l <= 6; l++) A += 2 * l * U[l] * Math.sin(2 * l * W) * Math.sinh(2 * l * E);
+    const X = Math.atan(T / Math.sqrt(1 + T * T) * G), H = Math.atan2(A, j), Y = X + H, J = Math.sin(o), Z = Math.sqrt(1 - g * g * J * J) * Math.sqrt(1 + v * v) / Math.sqrt(T * T + L * L), V = q / u * Math.sqrt(j * j + A * A), tt = N * Z * V;
+    z = z + n, k < 0 && (k = k + s), z = Number(z.toFixed(9)), k = Number(k.toFixed(9));
+    const nt = Number(Y.toDegrees().toFixed(9)), et = Number(tt.toFixed(12)), I = this.lat >= 0 ? "N" : "S";
+    return new pt(e, I, z, k, this.datum, nt, et, !!t);
+  }
+}
+const rt = "CDEFGHJKLMNPQRSTUVWXX", ot = ["ABCDEFGH", "JKLMNPQR", "STUVWXYZ"], at = ["ABCDEFGHJKLMNPQRSTUV", "FGHJKLMNPQRSTUVABCDE"];
+class _ {
+  /**
+   * Creates an Mgrs grid reference object.
+   *
+   * @param  {number} zone - 6° longitudinal zone (1..60 covering 180°W..180°E).
+   * @param  {string} band - 8° latitudinal band (C..X covering 80°S..84°N).
+   * @param  {string} e100k - First letter (E) of 100km grid square.
+   * @param  {string} n100k - Second letter (N) of 100km grid square.
+   * @param  {number} easting - Easting in metres within 100km grid square.
+   * @param  {number} northing - Northing in metres within 100km grid square.
+   * @param  {LatLon.datums} [datum=WGS84] - Datum UTM coordinate is based on.
+   * @throws {RangeError}  Invalid MGRS grid reference.
+   *
+   * @example
+   *   import Mgrs from '/js/geodesy/mgrs.js';
+   *   const mgrsRef = new Mgrs(31, 'U', 'D', 'Q', 48251, 11932); // 31U DQ 48251 11932
+   */
+  constructor(t, n, s, e, i, r, a = K.datums.WGS84) {
+    if (!(1 <= t && t <= 60)) throw new RangeError(`invalid MGRS zone ‘${t}’`);
+    if (t != parseInt(t)) throw new RangeError(`invalid MGRS zone ‘${t}’`);
+    const o = [];
+    if ((n.length != 1 || rt.indexOf(n) == -1) && o.push(`invalid MGRS band ‘${n}’`), (s.length != 1 || ot[(t - 1) % 3].indexOf(s) == -1) && o.push(`invalid MGRS 100km grid square column ‘${s}’ for zone ${t}`), (e.length != 1 || at[0].indexOf(e) == -1) && o.push(`invalid MGRS 100km grid square row ‘${e}’`), isNaN(Number(i)) && o.push(`invalid MGRS easting ‘${i}’`), isNaN(Number(r)) && o.push(`invalid MGRS northing ‘${r}’`), (!a || a.ellipsoid == null) && o.push(`unrecognised datum ‘${a}’`), o.length > 0) throw new RangeError(o.join(", "));
+    this.zone = Number(t), this.band = n, this.e100k = s, this.n100k = e, this.easting = Number(i), this.northing = Number(r), this.datum = a;
+  }
+  /**
+   * Converts MGRS grid reference to UTM coordinate.
+   *
+   * Grid references refer to squares rather than points (with the size of the square indicated
+   * by the precision of the reference); this conversion will return the UTM coordinate of the SW
+   * corner of the grid reference square.
+   *
+   * @returns {Utm} UTM coordinate of SW corner of this MGRS grid reference.
+   *
+   * @example
+   *   const mgrsRef = Mgrs.parse('31U DQ 48251 11932');
+   *   const utmCoord = mgrsRef.toUtm(); // 31 N 448251 5411932
+   */
+  toUtm() {
+    const t = this.band >= "N" ? "N" : "S", s = (ot[(this.zone - 1) % 3].indexOf(this.e100k) + 1) * 1e5, i = at[(this.zone - 1) % 2].indexOf(this.n100k) * 1e5, r = (rt.indexOf(this.band) - 10) * 8, a = Math.floor(new K(r, 3).toUtm().northing / 1e5) * 1e5;
+    let o = 0;
+    for (; o + i + this.northing < a; ) o += 2e6;
+    return new ht(this.zone, t, s + this.easting, o + i + this.northing, this.datum);
+  }
+  /**
+   * Parses string representation of MGRS grid reference.
+   *
+   * An MGRS grid reference comprises (space-separated)
+   *  - grid zone designator (GZD)
+   *  - 100km grid square letter-pair
+   *  - easting
+   *  - northing.
+   *
+   * @param   {string} mgrsGridRef - String representation of MGRS grid reference.
+   * @returns {Mgrs}   Mgrs grid reference object.
+   * @throws  {Error}  Invalid MGRS grid reference.
+   *
+   * @example
+   *   const mgrsRef = Mgrs.parse('31U DQ 48251 11932');
+   *   const mgrsRef = Mgrs.parse('31UDQ4825111932');
+   *   //  mgrsRef: { zone:31, band:'U', e100k:'D', n100k:'Q', easting:48251, northing:11932 }
+   */
+  static parse(t) {
+    if (!t) throw new Error(`invalid MGRS grid reference ‘${t}’`);
+    if (!t.trim().match(/\s/)) {
+      if (!Number(t.slice(0, 2))) throw new Error(`invalid MGRS grid reference ‘${t}’`);
+      let u = t.trim().slice(5);
+      u = u.slice(0, u.length / 2) + " " + u.slice(-u.length / 2), t = t.slice(0, 3) + " " + t.slice(3, 5) + " " + u;
+    }
+    const n = t.match(/\S+/g);
+    if (n == null || n.length != 4) throw new Error(`invalid MGRS grid reference ‘${t}’`);
+    const s = n[0], e = s.slice(0, 2), i = s.slice(2, 3), r = n[1], a = r.slice(0, 1), o = r.slice(1, 2);
+    let f = n[2], c = n[3];
+    return f = f.length >= 5 ? f : (f + "00000").slice(0, 5), c = c.length >= 5 ? c : (c + "00000").slice(0, 5), new _(e, i, a, o, f, c);
+  }
+  /**
+   * Returns a string representation of an MGRS grid reference.
+   *
+   * To distinguish from civilian UTM coordinate representations, no space is included within the
+   * zone/band grid zone designator.
+   *
+   * Components are separated by spaces: for a military-style unseparated string, use
+   *   Mgrs.toString().replace(/ /g, '');
+   *
+   * Note that MGRS grid references get truncated, not rounded (unlike UTM coordinates); grid
+   * references indicate a bounding square, rather than a point, with the size of the square
+   * indicated by the precision - a precision of 10 indicates a 1-metre square, a precision of 4
+   * indicates a 1,000-metre square (hence 31U DQ 48 11 indicates a 1km square with SW corner at
+   * 31 N 448000 5411000, which would include the 1m square 31U DQ 48251 11932).
+   *
+   * @param   {number}     [digits=10] - Precision of returned grid reference (eg 4 = km, 10 = m).
+   * @returns {string}     This grid reference in standard format.
+   * @throws  {RangeError} Invalid precision.
+   *
+   * @example
+   *   const mgrsStr = new Mgrs(31, 'U', 'D', 'Q', 48251, 11932).toString(); // 31U DQ 48251 11932
+   */
+  toString(t = 10) {
+    if (![2, 4, 6, 8, 10].includes(Number(t))) throw new RangeError(`invalid precision ‘${t}’`);
+    const { zone: n, band: s, e100k: e, n100k: i, easting: r, northing: a } = this, o = Math.floor(r / Math.pow(10, 5 - t / 2)), f = Math.floor(a / Math.pow(10, 5 - t / 2)), c = n.toString().padStart(2, "0"), u = o.toString().padStart(t / 2, "0"), w = f.toString().padStart(t / 2, "0");
+    return `${c}${s} ${e}${i} ${u} ${w}`;
+  }
+}
+class ht extends pt {
+  /**
+   * Converts UTM coordinate to MGRS reference.
+   *
+   * @returns {Mgrs}
+   * @throws  {TypeError} Invalid UTM coordinate.
+   *
+   * @example
+   *   const utmCoord = new Utm(31, 'N', 448251, 5411932);
+   *   const mgrsRef = utmCoord.toMgrs(); // 31U DQ 48251 11932
+   */
+  toMgrs() {
+    const t = this.zone, n = this.toLatLon(), s = rt.charAt(Math.floor(n.lat / 8 + 10)), e = Math.floor(this.easting / 1e5), i = ot[(t - 1) % 3].charAt(e - 1), r = Math.floor(this.northing / 1e5) % 20, a = at[(t - 1) % 2].charAt(r);
+    let o = this.easting % 1e5, f = this.northing % 1e5;
+    return o = Number(o.toFixed(6)), f = Number(f.toFixed(6)), new _(t, s, i, a, o, f);
+  }
+}
+class wt extends K {
+  /**
+   * Converts latitude/longitude to UTM coordinate.
+   *
+   * Shadow of LatLon.toUtm, returning Utm augmented with toMgrs() method.
+   *
+   * @param   {number} [zoneOverride] - Use specified zone rather than zone within which point lies;
+   *          note overriding the UTM zone has the potential to result in negative eastings, and
+   *          perverse results within Norway/Svalbard exceptions (this is unlikely to be relevant
+   *          for MGRS, but is needed as Mgrs passes through the Utm class).
+   * @returns {Utm}   UTM coordinate.
+   * @throws  {Error} If point not valid, if point outside latitude range.
+   *
+   * @example
+   *   const latlong = new LatLon(48.8582, 2.2945);
+   *   const utmCoord = latlong.toUtm(); // 31 N 448252 5411933
+   */
+  toUtm(t = void 0) {
+    const n = super.toUtm(t);
+    return new ht(n.zone, n.hemisphere, n.easting, n.northing, n.datum, n.convergence, n.scale);
+  }
+}
+function Nt({
+  coordinate: M,
+  onChange: t
+}) {
+  const [n, s] = it("LATLON"), [e, i] = it({
+    latLon: {
+      latitude: M[1],
+      longitude: M[0]
+    },
+    utm: "",
+    mgrs: "",
+    dms: ""
+  }), [r, a] = it({
+    latitude: String(M[1]),
+    longitude: String(M[0])
+  });
+  ct(() => (o(M[1], M[0]), () => {
+  }), [M]), ct(() => {
+    const { latitude: d, longitude: p } = e.latLon;
+    return t && (d !== M[1] || p !== M[0]) && t({
+      latitude: d,
+      longitude: p
+    }), () => {
+    };
+  }, [e]);
+  const o = (d, p) => {
+    try {
+      const m = new wt(d, p), y = m.toUtm(), b = y.toMgrs(), S = m.toString("dms");
+      i({
+        latLon: {
+          latitude: m.latitude,
+          longitude: m.longitude
+        },
+        utm: y.toString(),
+        mgrs: b.toString(),
+        dms: S
+      });
+    } catch {
+    }
+  };
+  return {
+    state: {
+      format: n,
+      data: e,
+      latLonStr: r
+    },
+    action: {
+      onChangeFormat: (d) => {
+        s(d.target.value);
+      },
+      onChangeLat: (d) => {
+        let p = d.target.value;
+        p = p.replace(",", "."), a({
+          latitude: p,
+          longitude: r.longitude
+        }), o(Number(p), e.latLon.longitude);
+      },
+      onChangeLon: (d) => {
+        let p = d.target.value;
+        p = p.replace(",", "."), a({
+          latitude: r.latitude,
+          longitude: p
+        }), o(e.latLon.latitude, Number(p));
+      },
+      onChangeDms: (d) => {
+        try {
+          const p = d.target.value.split(","), m = p[0].trim(), y = p[1].trim(), b = h.parse(m), S = h.parse(y);
+          o(b, S);
+        } catch {
+        }
+      },
+      onChangeMgrs: (d) => {
+        try {
+          const m = _.parse(d.target.value).toUtm().toLatLon();
+          o(m.latitude, m.longitude);
+        } catch {
+        }
+      },
+      onChangeUtm: (d) => {
+        try {
+          const m = ht.parse(d.target.value).toLatLon();
+          o(m.latitude, m.longitude);
+        } catch {
+        }
+      }
+    }
+  };
+}
+export {
+  Nt as default
+};