@wemap/geo 13.2.3 → 14.2.0

package/dist/index.mjs

@@ -1,1348 +0,0 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-import { wrap, deg2rad, rad2deg, Quaternion, Vector3, positiveMod, Rotations } from "@wemap/maths";
-import booleanPointInPolygon from "@turf/boolean-point-in-polygon";
-const R_MAJOR = 6378137;
-const R_MINOR = 63567523142e-4;
-const EARTH_GRAVITY = 9.80665;
-const EPS_DEG_MM = 1e-8;
-const EPS_MM = 1e-3;
-const ELLIPSOID_FLATNESS = (R_MAJOR - R_MINOR) / R_MAJOR;
-const ECCENTRICITY = Math.sqrt(ELLIPSOID_FLATNESS * (2 - ELLIPSOID_FLATNESS));
-const ECCENTRICITY_2 = ECCENTRICITY * ECCENTRICITY;
-const R_MAJOR_2 = R_MAJOR * R_MAJOR;
-const R_MAJOR_4 = R_MAJOR_2 * R_MAJOR_2;
-const R_MINOR_2 = R_MINOR * R_MINOR;
-const R_MINOR_4 = R_MINOR_2 * R_MINOR_2;
-const CIRCUMFERENCE = R_MAJOR * 2 * Math.PI;
-const Constants = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  CIRCUMFERENCE,
-  EARTH_GRAVITY,
-  ECCENTRICITY,
-  ECCENTRICITY_2,
-  ELLIPSOID_FLATNESS,
-  EPS_DEG_MM,
-  EPS_MM,
-  R_MAJOR,
-  R_MAJOR_2,
-  R_MAJOR_4,
-  R_MINOR,
-  R_MINOR_2,
-  R_MINOR_4
-}, Symbol.toStringTag, { value: "Module" }));
-const _Level = class _Level {
-  static checkType(level) {
-    if (level === null) {
-      return;
-    }
-    if (typeof level === "number" && !isNaN(level)) {
-      return;
-    }
-    if (Array.isArray(level) && level.length === 2) {
-      const [low, up] = level;
-      if (typeof low === "number" && !isNaN(low) && typeof up === "number" && !isNaN(up)) {
-        if (low > up || low === up) {
-          throw Error(`Invalid level range: [${low}, ${up}]`);
-        }
-        return;
-      }
-    }
-    throw Error(`Unknown level format: ${level}`);
-  }
-  /**
-   * Return true if the level is a range, false otherwise
-   */
-  static isRange(level) {
-    if (_Level.VERIFY_TYPING) {
-      _Level.checkType(level);
-    }
-    return Array.isArray(level);
-  }
-  static clone(level) {
-    if (_Level.VERIFY_TYPING) {
-      _Level.checkType(level);
-    }
-    if (level === null) {
-      return null;
-    }
-    if (typeof level === "number") {
-      return level;
-    }
-    return [level[0], level[1]];
-  }
-  /**
-   * Create a level from a string (eg. 1, -2, 1;2, -2;3, 2;-1, 0.5;1 ...)
-   */
-  static fromString(str) {
-    if (str === null) {
-      return null;
-    }
-    if (typeof str !== "string" || !str.length) {
-      throw Error(`argument must be a non empty string, got ${typeof str}`);
-    }
-    if (!isNaN(Number(str))) {
-      return parseFloat(str);
-    }
-    const splited = str.split(";");
-    if (splited.length > 1) {
-      const levels = splited.map((str2) => Number(str2));
-      const low = Math.min(...levels);
-      const up = Math.max(...levels);
-      _Level.checkType([low, up]);
-      return [low, up];
-    } else {
-      const rangeSeparator = str.substring(1).indexOf("-") + 1;
-      if (rangeSeparator > 0) {
-        const low = Number(str.substring(0, rangeSeparator));
-        const up = Number(str.substring(rangeSeparator + 1));
-        _Level.checkType([low, up]);
-        return [low, up];
-      }
-    }
-    throw Error(`Cannot parse following level: ${str}`);
-  }
-  /**
-   * Returns if a level is contained in another
-   * @param {null|number|[number, number]} container The container level
-   * @param {null|number|[number, number]} targeted The targeted level
-   */
-  static contains(container, targeted) {
-    if (_Level.VERIFY_TYPING) {
-      _Level.checkType(container);
-      _Level.checkType(targeted);
-    }
-    if (container === targeted) {
-      return true;
-    }
-    if (Array.isArray(container)) {
-      if (Array.isArray(targeted)) {
-        return container[0] <= targeted[0] && container[1] >= targeted[1];
-      }
-      if (targeted === null) {
-        return false;
-      }
-      return container[0] <= targeted && container[1] >= targeted;
-    }
-    if (container === null || targeted === null) {
-      return false;
-    }
-    return container <= targeted[0] && container >= targeted[1];
-  }
-  /**
-   * Retrieve the intersection of two levels
-   * null n null => null
-   * null n 1 => null // Conception choice
-   * null n [1,2] => null // Conception choice
-   * 1 n 1 => 1
-   * 1 n 2 => null
-   * 1 n [1,2] => 1
-   * 1 n [0,2] => 1
-   * 1 n [2,3] => null
-   * [1,2] n [1,2] => [1,2]
-   * [1,2] n [2,3] => 2
-   * [1,2] n [3,4] => null
-   */
-  static intersection(first, second) {
-    if (_Level.VERIFY_TYPING) {
-      _Level.checkType(first);
-      _Level.checkType(second);
-    }
-    if (first === null || second === null) {
-      return null;
-    }
-    if (_Level.equals(first, second)) {
-      return _Level.clone(first);
-    }
-    if (typeof first === "number" && typeof second === "number") {
-      return first === second ? first : null;
-    }
-    if (Array.isArray(first) && !Array.isArray(second)) {
-      if (_Level.contains(first, second)) {
-        return second;
-      }
-      return null;
-    }
-    if (!Array.isArray(first) && Array.isArray(second)) {
-      if (_Level.contains(second, first)) {
-        return first;
-      }
-      return null;
-    }
-    const low = Math.max(first[0], second[0]);
-    const up = Math.min(first[1], second[1]);
-    if (up === low) {
-      return up;
-    }
-    return up < low ? null : [low, up];
-  }
-  /**
-  * Retrieve the intersection of two levels
-  * @param {null|number|[number, number]} first The first level
-  * @param {null|number|[number, number]} second The second level
-  * @returns {boolean}
-  */
-  static intersect(first, second) {
-    if (_Level.VERIFY_TYPING) {
-      _Level.checkType(first);
-      _Level.checkType(second);
-    }
-    if (first === null && second === null) {
-      return true;
-    }
-    return _Level.intersection(first, second) !== null;
-  }
-  /**
-   * Retrieve the union of two levels
-   * null u null => null
-   * null u 1 => null // Conception choice
-   * null u [1,2] => null // Conception choice
-   * 1 u 1 => 1
-   * 1 u 2 => [1,2]
-   * 1 u [1,2] => [1,2]
-   * 1 u [0,2] => [0,2]
-   * 1 u [2,3] => [1,3]
-   * [1,2] u [1,2] => [1,2]
-   * [1,2] u [2,3] => [1,3]
-   * [1,2] u [3,4] => [1,4]
-   */
-  static union(first, second) {
-    if (_Level.VERIFY_TYPING) {
-      _Level.checkType(first);
-      _Level.checkType(second);
-    }
-    if (first === second) {
-      return _Level.clone(first);
-    }
-    if (second === null) {
-      return null;
-    }
-    if (first === null) {
-      return null;
-    }
-    let low, up;
-    if (!Array.isArray(first) && !Array.isArray(second)) {
-      low = Math.min(first, second);
-      up = Math.max(first, second);
-    } else if (Array.isArray(first) && !Array.isArray(second)) {
-      low = Math.min(first[0], second);
-      up = Math.max(first[1], second);
-    } else if (!Array.isArray(first) && Array.isArray(second)) {
-      low = Math.min(second[0], first);
-      up = Math.max(second[1], first);
-    } else {
-      low = Math.min(first[0], second[0]);
-      up = Math.max(first[1], second[1]);
-    }
-    if (low === up) {
-      return low;
-    }
-    return [low, up];
-  }
-  /**
-   * Multiply a level by a factor
-   * @param {null|number|[number, number]} level the level to multiply
-   * @param {number} factor
-   * @returns {null|number|[number, number]}
-   */
-  static multiplyBy(level, factor) {
-    if (_Level.VERIFY_TYPING) {
-      _Level.checkType(level);
-    }
-    if (level === null) {
-      return null;
-    }
-    return Array.isArray(level) ? [level[0] * factor, level[1] * factor] : level * factor;
-  }
-  static toString(level) {
-    if (_Level.VERIFY_TYPING) {
-      _Level.checkType(level);
-    }
-    if (level === null) {
-      return null;
-    }
-    return Array.isArray(level) ? level[0] + ";" + level[1] : String(level);
-  }
-  static equals(first, second) {
-    if (_Level.VERIFY_TYPING) {
-      _Level.checkType(first);
-      _Level.checkType(second);
-    }
-    if (first === second) {
-      return true;
-    }
-    if (Array.isArray(first) && Array.isArray(second)) {
-      return first[0] === second[0] && first[1] === second[1];
-    }
-    return false;
-  }
-  static diff(first, second) {
-    if (_Level.VERIFY_TYPING) {
-      _Level.checkType(first);
-      _Level.checkType(second);
-    }
-    if (first === null || second === null) {
-      return null;
-    }
-    if (!Array.isArray(first) && !Array.isArray(second)) {
-      return second - first;
-    }
-    if (Array.isArray(first) && !Array.isArray(second)) {
-      if (first[0] === second) {
-        return second - first[1];
-      }
-      if (first[1] === second) {
-        return second - first[0];
-      }
-      return null;
-    }
-    if (Array.isArray(second) && !Array.isArray(first)) {
-      if (first === second[0]) {
-        return second[1] - first;
-      }
-      if (first === second[1]) {
-        return second[0] - first;
-      }
-      return null;
-    }
-    if (_Level.equals(first, second)) {
-      return 0;
-    }
-    return null;
-  }
-};
-__publicField(_Level, "VERIFY_TYPING", false);
-let Level = _Level;
-class Coordinates {
-  constructor(lat, lng, alt = null, level = null) {
-    __publicField(this, "_lat");
-    __publicField(this, "_lng");
-    __publicField(this, "_alt", null);
-    __publicField(this, "_level", null);
-    __publicField(this, "_heightFromFloor", null);
-    __publicField(this, "_heightFromGround", null);
-    __publicField(this, "_ecef");
-    __publicField(this, "autoWrap", true);
-    this.lat = lat;
-    this.lng = lng;
-    this.alt = alt;
-    this.level = level;
-    this._ecef = null;
-  }
-  get lat() {
-    return this._lat;
-  }
-  set lat(lat) {
-    if (Math.abs(lat) <= 90) {
-      this._lat = lat;
-    } else {
-      throw new Error(`lat argument is not in [-90; 90], value is ${lat}`);
-    }
-    this._ecef = null;
-  }
-  get latitude() {
-    return this._lat;
-  }
-  set latitude(_) {
-    throw new Error("Please use Coordinates#lat setter instead of Coordinate#latitude");
-  }
-  get lng() {
-    return this._lng;
-  }
-  set lng(lng) {
-    this._lng = lng;
-    if (this.autoWrap) {
-      this.wrap();
-    }
-    this._ecef = null;
-  }
-  get longitude() {
-    return this._lng;
-  }
-  set longitude(_) {
-    throw new Error("Please use Coordinates#lng setter instead of Coordinate#longitude");
-  }
-  /**
-   * alt does not denote the altitude of a point but its height from
-   *  the "level" field (if defined) or from the ground
-   */
-  get alt() {
-    return this._alt;
-  }
-  set alt(alt) {
-    this._alt = alt;
-    this._ecef = null;
-  }
-  get level() {
-    return this._level;
-  }
-  set level(level) {
-    Level.checkType(level);
-    this._level = level;
-  }
-  get heightFromFloor() {
-    return this._heightFromFloor;
-  }
-  set heightFromFloor(heightFromFloor) {
-    this._heightFromFloor = heightFromFloor;
-  }
-  get heightFromGround() {
-    return this._heightFromGround;
-  }
-  set heightFromGround(heightFromGround) {
-    this._heightFromGround = heightFromGround;
-  }
-  /**
-   * Deep clone coordinates
-   */
-  clone() {
-    const output = new Coordinates(this.lat, this.lng, this.alt);
-    if (this.level !== null) {
-      output.level = Level.clone(this.level);
-    }
-    return output;
-  }
-  wrap() {
-    if (this._lng <= -180 || this._lng > 180) {
-      this._lng = wrap(this._lng, -180, 180);
-    }
-  }
-  static equals(pos1, pos2, eps = EPS_DEG_MM, epsAlt = EPS_MM) {
-    if (!this.equalsWithoutLevel(pos1, pos2, eps, epsAlt)) {
-      return false;
-    }
-    if (pos1 === null || pos2 === null) {
-      return true;
-    }
-    return Level.equals(pos1.level, pos2.level);
-  }
-  equals(other) {
-    return Coordinates.equals(this, other);
-  }
-  static equalsWithoutLevel(pos1, pos2, eps = EPS_DEG_MM, epsAlt = EPS_MM) {
-    if (pos1 === null && pos1 === pos2) {
-      return true;
-    }
-    if (!(pos1 instanceof Coordinates) || !(pos2 instanceof Coordinates)) {
-      return false;
-    }
-    return Math.abs(pos2.lat - pos1.lat) < eps && Math.abs(pos2.lng - pos1.lng) < eps && (pos1.alt === pos2.alt || pos1.alt !== null && pos2.alt !== null && Math.abs(pos2.alt - pos1.alt) < epsAlt);
-  }
-  equalsWithoutLevel(other, eps = EPS_DEG_MM, epsAlt = EPS_MM) {
-    return Coordinates.equalsWithoutLevel(this, other, eps, epsAlt);
-  }
-  /**
-   * @throws {Error} if elevation is defined and point altitude is not defined
-   */
-  destinationPoint(distance, bearing, elevation = null) {
-    const newPoint = this.clone();
-    newPoint.move(distance, bearing, elevation);
-    return newPoint;
-  }
-  /**
-   * Source: http://www.movable-type.co.uk/scripts/latlong.html#destPoint
-   * @throws {Error} if elevation is defined and point altitude is not defined
-   */
-  move(distance, bearing, elevation = null) {
-    const dR = distance / R_MAJOR;
-    const cosDr = Math.cos(dR);
-    const sinDr = Math.sin(dR);
-    const phi1 = deg2rad(this.lat);
-    const lambda1 = deg2rad(this.lng);
-    const phi2 = Math.asin(
-      Math.sin(phi1) * cosDr + Math.cos(phi1) * sinDr * Math.cos(bearing)
-    );
-    const lambda2 = lambda1 + Math.atan2(
-      Math.sin(bearing) * sinDr * Math.cos(phi1),
-      cosDr - Math.sin(phi1) * Math.sin(phi2)
-    );
-    this.lat = rad2deg(phi2);
-    this.lng = rad2deg(lambda2);
-    if (elevation !== null) {
-      if (this.alt === null) {
-        throw new Error("Point altitude is not defined");
-      }
-      this.alt += elevation;
-    }
-    return this;
-  }
-  /**
-   * Returns a distance between two points in meters
-   */
-  distanceTo(location2) {
-    const lat1 = this.lat;
-    const lng1 = this.lng;
-    const lat2 = location2.lat;
-    const lng2 = location2.lng;
-    const dlat = deg2rad(lat2 - lat1);
-    const dlng = deg2rad(lng2 - lng1);
-    const dlngsin = Math.sin(dlng / 2);
-    const dlatsin = Math.sin(dlat / 2);
-    const lat1rad = deg2rad(lat1);
-    const lat1cos = Math.cos(lat1rad);
-    const lat2rad = deg2rad(lat2);
-    const lat2cos = Math.cos(lat2rad);
-    const angle = dlatsin * dlatsin + lat1cos * lat2cos * dlngsin * dlngsin;
-    const tangy = Math.sqrt(angle);
-    const tangx = Math.sqrt(1 - angle);
-    const cosn = 2 * Math.atan2(tangy, tangx);
-    return R_MAJOR * cosn;
-  }
-  static distanceBetween(point1, point2) {
-    return point1.distanceTo(point2);
-  }
-  bearingTo(location2) {
-    const lat1 = deg2rad(this.lat);
-    const lat2 = deg2rad(location2.lat);
-    const diffLng = deg2rad(location2.lng - this.lng);
-    return Math.atan2(
-      Math.sin(diffLng) * Math.cos(lat2),
-      Math.cos(lat1) * Math.sin(lat2) - Math.sin(lat1) * Math.cos(lat2) * Math.cos(diffLng)
-    );
-  }
-  static bearingTo(point1, point2) {
-    return point1.bearingTo(point2);
-  }
-  /**
-   * ECEF Transformations
-   * Here we used a light version of ECEF considering earth
-   * as a sphere instead of an ellipse
-   */
-  get enuToEcefRotation() {
-    const rot1 = Quaternion.fromAxisAngle([0, 0, 1], Math.PI / 2 + deg2rad(this.lng));
-    const rot2 = Quaternion.fromAxisAngle([1, 0, 0], Math.PI / 2 - deg2rad(this.lat));
-    return Quaternion.multiply(rot1, rot2);
-  }
-  get ecefToEnuRotation() {
-    const rot1 = Quaternion.fromAxisAngle([1, 0, 0], deg2rad(this.lat) - Math.PI / 2);
-    const rot2 = Quaternion.fromAxisAngle([0, 0, 1], -deg2rad(this.lng) - Math.PI / 2);
-    return Quaternion.multiply(rot1, rot2);
-  }
-  /**
-   * https://gist.github.com/klucar/1536194
-   * Adapted for spherical formula
-   */
-  get ecef() {
-    if (!this._ecef) {
-      const lat = deg2rad(this.lat);
-      const lng = deg2rad(this.lng);
-      const alt = this.alt || 0;
-      const x = (R_MAJOR + alt) * Math.cos(lat) * Math.cos(lng);
-      const y = (R_MAJOR + alt) * Math.cos(lat) * Math.sin(lng);
-      const z = (R_MAJOR + alt) * Math.sin(lat);
-      this._ecef = [x, y, z];
-    }
-    return this._ecef;
-  }
-  static fromECEF(ecef) {
-    const x = ecef[0];
-    const y = ecef[1];
-    const z = ecef[2];
-    const p = Math.sqrt(x ** 2 + y ** 2);
-    let lng = Math.atan2(y, x);
-    const lat = Math.atan2(z, p);
-    const alt = p / Math.cos(lat) - R_MAJOR;
-    lng = lng % (2 * Math.PI);
-    const newPoint = new Coordinates(rad2deg(lat), rad2deg(lng), alt);
-    newPoint._ecef = ecef;
-    return newPoint;
-  }
-  /**
-   * https://stackoverflow.com/questions/1299567/how-to-calculate-distance-from-a-point-to-a-line-segment-on-a-sphere
-   * Adapted to ECEF
-   */
-  getSegmentProjection(p1, p2) {
-    const a = Vector3.normalize(p1.ecef);
-    const b = Vector3.normalize(p2.ecef);
-    const c = Vector3.normalize(this.ecef);
-    const G = Vector3.cross(a, b);
-    if (Vector3.norm(G) === 0) {
-      return null;
-    }
-    const F = Vector3.cross(c, G);
-    const t = Vector3.normalize(Vector3.cross(G, F));
-    const posECEF = Vector3.multiplyScalar(t, R_MAJOR);
-    const poseCoordinates = Coordinates.fromECEF(posECEF);
-    let alt;
-    if (p1.alt !== null && p2.alt !== null) {
-      alt = (p1.alt + p2.alt) / 2;
-    }
-    const projection = new Coordinates(
-      poseCoordinates.lat,
-      poseCoordinates.lng,
-      alt,
-      Level.union(p1.level, p2.level)
-    );
-    if (Math.abs(p1.distanceTo(p2) - p1.distanceTo(projection) - p2.distanceTo(projection)) > EPS_MM) {
-      return null;
-    }
-    return projection;
-  }
-  /**
-   * Input / Output
-   */
-  toString() {
-    let str = "[" + this._lat.toFixed(7) + ", " + this._lng.toFixed(7);
-    if (this._alt !== null) {
-      str += ", " + this._alt.toFixed(2);
-    }
-    if (this._level !== null) {
-      str += ", [" + Level.toString(this._level) + "]";
-    }
-    str += "]";
-    return str;
-  }
-  toJson() {
-    return {
-      lat: Number(this.lat.toFixed(8)),
-      lng: Number(this.lng.toFixed(8)),
-      ...this.alt !== null && { alt: Number(this.alt.toFixed(3)) },
-      ...this.level !== null && { level: this.level }
-    };
-  }
-  static fromJson(json) {
-    return new Coordinates(json.lat, json.lng, json.alt, json.level);
-  }
-  toCompressedJson() {
-    if (this.level !== null) {
-      return [
-        Number(this.lat.toFixed(8)),
-        Number(this.lng.toFixed(8)),
-        this.level
-      ];
-    }
-    return [Number(this.lat.toFixed(8)), Number(this.lng.toFixed(8))];
-  }
-  static fromCompressedJson(json) {
-    const coords = new Coordinates(json[0], json[1]);
-    if (json.length > 2) {
-      coords.level = json[2];
-    }
-    return coords;
-  }
-}
-class UserPosition extends Coordinates {
-  constructor(lat, lng, alt = null, level = null, time = null, accuracy = null, bearing = null) {
-    super(lat, lng, alt, level);
-    __publicField(this, "_time", null);
-    __publicField(this, "_accuracy", null);
-    __publicField(this, "_bearing", null);
-    this.time = time;
-    this.accuracy = accuracy;
-    this.bearing = bearing;
-  }
-  get time() {
-    return this._time;
-  }
-  set time(time) {
-    this._time = time;
-  }
-  get accuracy() {
-    return this._accuracy;
-  }
-  set accuracy(accuracy) {
-    if (accuracy !== null && accuracy < 0) {
-      throw new Error("accuracy argument is not a positive number");
-    }
-    this._accuracy = accuracy;
-  }
-  get bearing() {
-    return this._bearing;
-  }
-  set bearing(bearing) {
-    this._bearing = bearing !== null ? bearing % (2 * Math.PI) : null;
-  }
-  move(distance, bearing, elevation = null) {
-    super.move(distance, bearing, elevation);
-    return this;
-  }
-  destinationPoint(distance, bearing, elevation = null) {
-    const newPoint = this.clone();
-    newPoint.move(distance, bearing, elevation);
-    return newPoint;
-  }
-  // Create a UserPosition with lat, lng, alt from Coordinates coordinates and
-  //   other fields from another UserPosition
-  static fromCoordinates(coordinates) {
-    return new UserPosition(
-      coordinates.lat,
-      coordinates.lng,
-      coordinates.alt,
-      coordinates.level
-    );
-  }
-  clone() {
-    const cloned = UserPosition.fromCoordinates(super.clone());
-    cloned.time = this.time;
-    cloned.accuracy = this.accuracy;
-    cloned.bearing = this.bearing;
-    return cloned;
-  }
-  static equals(pos1, pos2, eps = EPS_DEG_MM, epsAlt = EPS_MM) {
-    if (pos1 === null && pos1 === pos2) {
-      return true;
-    }
-    if (!(pos1 instanceof UserPosition) || !(pos2 instanceof UserPosition)) {
-      return false;
-    }
-    if (!super.equals(pos1, pos2, eps, epsAlt)) {
-      return false;
-    }
-    return pos1.time === pos2.time && pos1.accuracy === pos2.accuracy && pos1.bearing === pos2.bearing;
-  }
-  equals(other, eps = EPS_DEG_MM, epsAlt = EPS_MM) {
-    return UserPosition.equals(this, other, eps, epsAlt);
-  }
-  toJson() {
-    return {
-      ...super.toJson(),
-      ...this.time !== null && { time: this.time },
-      ...this.accuracy !== null && { accuracy: this.accuracy },
-      ...this.bearing !== null && { bearing: this.bearing }
-    };
-  }
-  static fromJson(json) {
-    const position = UserPosition.fromCoordinates(Coordinates.fromJson(json));
-    if (typeof json.time !== "undefined") {
-      position.time = json.time;
-    }
-    if (typeof json.accuracy !== "undefined") {
-      position.accuracy = json.accuracy;
-    }
-    if (typeof json.bearing !== "undefined") {
-      position.bearing = json.bearing;
-    }
-    return position;
-  }
-}
-function sampleRoute(route, stepSize = 0.7, startSampling = 0, length = Number.MAX_VALUE) {
-  const endSampling = startSampling + length;
-  const sampledRoute = [];
-  let lastSample;
-  let totalDistanceTraveled = 0;
-  let distanceToNextSample = 0;
-  let startFound = false;
-  for (let segmentIndex = 0; segmentIndex < route.length - 1; segmentIndex++) {
-    const p1 = route[segmentIndex];
-    const p2 = route[segmentIndex + 1];
-    const segmentSize = p1.distanceTo(p2);
-    const segmentBearing = p1.bearingTo(p2);
-    let distanceTraveledOnSegment = 0;
-    if (!startFound) {
-      if (startSampling < totalDistanceTraveled + segmentSize) {
-        startFound = true;
-        distanceToNextSample = startSampling - totalDistanceTraveled;
-      } else {
-        totalDistanceTraveled += segmentSize;
-        continue;
-      }
-    }
-    lastSample = Object.assign(p1.clone(), { bearing: segmentBearing });
-    while (distanceTraveledOnSegment + distanceToNextSample < segmentSize && totalDistanceTraveled + distanceToNextSample <= endSampling) {
-      const newPoint = lastSample.destinationPoint(distanceToNextSample, segmentBearing);
-      newPoint.bearing = segmentBearing;
-      sampledRoute.push(newPoint);
-      lastSample = newPoint;
-      distanceTraveledOnSegment += distanceToNextSample;
-      totalDistanceTraveled += distanceToNextSample;
-      distanceToNextSample = stepSize;
-    }
-    if (totalDistanceTraveled + distanceToNextSample > endSampling) {
-      break;
-    }
-    const rest = segmentSize - distanceTraveledOnSegment;
-    totalDistanceTraveled += rest;
-    distanceToNextSample -= rest;
-  }
-  return sampledRoute;
-}
-function trimRoute(route, startPosition = route[0], length = Number.MAX_VALUE) {
-  const newRoute = [];
-  let previousPoint = null;
-  let currentPointIndex;
-  let cumulativeDistance = 0;
-  if (route.length <= 1) {
-    throw new Error("Route must have at least 2 points");
-  }
-  for (currentPointIndex = 1; currentPointIndex < route.length; currentPointIndex++) {
-    const p1 = route[currentPointIndex - 1];
-    const p2 = route[currentPointIndex];
-    if (Coordinates.equals(startPosition, p1)) {
-      newRoute.push(p1);
-      previousPoint = p1;
-      break;
-    }
-    const proj = startPosition.getSegmentProjection(p1, p2);
-    if (proj && Coordinates.equals(startPosition, proj) && !proj.equals(p2)) {
-      newRoute.push(proj);
-      previousPoint = proj;
-      break;
-    }
-  }
-  if (!newRoute.length) {
-    throw new Error("startPosition is not on the route");
-  }
-  while (previousPoint && currentPointIndex < route.length) {
-    const currentPoint = route[currentPointIndex];
-    const dist = previousPoint.distanceTo(currentPoint);
-    if (cumulativeDistance + dist >= length || Math.abs(cumulativeDistance + dist - length) <= EPS_MM) {
-      const bearing = previousPoint.bearingTo(currentPoint);
-      const remainingLength = length - cumulativeDistance;
-      const end = previousPoint.destinationPoint(remainingLength, bearing);
-      newRoute.push(end);
-      break;
-    }
-    newRoute.push(currentPoint);
-    previousPoint = currentPoint;
-    cumulativeDistance += dist;
-    currentPointIndex++;
-  }
-  return newRoute;
-}
-function simplifyRoute(coords, precisionAngle = deg2rad(5)) {
-  const isClosed = coords[0].equals(coords[coords.length - 1]);
-  let newRoute = coords.slice(0, coords.length - (isClosed ? 1 : 0));
-  const len = newRoute.length;
-  for (let i = isClosed ? 0 : 1; i < len; i++) {
-    const p0 = coords[positiveMod(i - 1, len)];
-    const p1 = coords[i];
-    const p2 = coords[positiveMod(i + 1, len)];
-    const seg1Dir = p0.bearingTo(p1);
-    const seg2Dir = p1.bearingTo(p2);
-    if (Math.abs(seg2Dir - seg1Dir) < precisionAngle) {
-      newRoute = newRoute.filter((coord) => coord !== p1);
-    }
-  }
-  if (isClosed) {
-    newRoute.push(newRoute[0]);
-  }
-  return newRoute;
-}
-function geolocationPositionToUserPosition(geolocationPosition) {
-  if (geolocationPosition === null) {
-    return null;
-  }
-  const { latitude, longitude, accuracy, heading } = geolocationPosition.coords;
-  const userPosition = new UserPosition(latitude, longitude);
-  userPosition.time = geolocationPosition.timestamp;
-  userPosition.accuracy = accuracy;
-  userPosition.bearing = heading ? deg2rad(heading) : null;
-  return userPosition;
-}
-function calcDistance(coords) {
-  return coords.reduce((acc, coords2, idx, arr) => acc + (idx ? arr[idx - 1].distanceTo(coords2) : 0), 0);
-}
-function createSegmentsAtLevel(itineraryCoords, segmentsLevel, useMultiLevelSegments = true) {
-  const itineraryCoordsLength = itineraryCoords.length;
-  let previousLevelCorrespond = false;
-  const segments = [];
-  let coordinates = [];
-  for (let i = 0; i < itineraryCoordsLength; i++) {
-    const coords = itineraryCoords[i];
-    const levelCorrespond = Level.intersect(segmentsLevel, coords.level);
-    if (useMultiLevelSegments && !levelCorrespond && previousLevelCorrespond) {
-      coordinates.push(coords);
-    } else if (levelCorrespond) {
-      if (!previousLevelCorrespond) {
-        coordinates = [];
-        segments.push(coordinates);
-        if (useMultiLevelSegments && i !== 0) {
-          coordinates.push(itineraryCoords[i - 1]);
-        }
-      }
-      coordinates.push(coords);
-    }
-    previousLevelCorrespond = levelCorrespond;
-  }
-  return segments;
-}
-const Utils = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  calcDistance,
-  createSegmentsAtLevel,
-  geolocationPositionToUserPosition,
-  sampleRoute,
-  simplifyRoute,
-  trimRoute
-}, Symbol.toStringTag, { value: "Module" }));
-class BoundingBox {
-  constructor(northEast, southWest) {
-    __publicField(this, "northEast");
-    __publicField(this, "southWest");
-    this.northEast = northEast;
-    this.southWest = southWest;
-    if (this.northEast && this.southWest && this.getNorth() < this.getSouth()) {
-      throw new Error("Incorrect bounding box");
-    }
-  }
-  /**
-   * Returns the geographical coordinate equidistant from the bounding box's corners.
-   */
-  get center() {
-    const latCenter = (this.southWest.lat + this.northEast.lat) / 2;
-    const lngCenter = (this.northEast.lng + this.southWest.lng) / 2;
-    return new Coordinates(latCenter, lngCenter);
-  }
-  /**
-   * Check if a point is contained in the bounding box.
-   */
-  contains(point) {
-    return point.lat <= this.northEast.lat && point.lat >= this.southWest.lat && point.lng <= this.northEast.lng && point.lng >= this.southWest.lng;
-  }
-  /**
-   * Extend the bounds to include a given LngLat or LngLatBounds.
-   */
-  extend(obj) {
-    const sw = this.southWest, ne = this.northEast;
-    let sw2, ne2;
-    if (obj instanceof Coordinates) {
-      sw2 = obj;
-      ne2 = obj;
-    } else if (obj instanceof BoundingBox) {
-      sw2 = obj.southWest;
-      ne2 = obj.northEast;
-    } else {
-      throw new Error("Unknown parameter");
-    }
-    this.southWest = new Coordinates(
-      Math.min(sw2.lat, sw.lat),
-      Math.min(sw2.lng, sw.lng)
-    );
-    this.northEast = new Coordinates(
-      Math.max(ne2.lat, ne.lat),
-      Math.max(ne2.lng, ne.lng)
-    );
-    return this;
-  }
-  /**
-   * This method extends the bounding box with a value in meters
-   * /*\ This method is not precise as distance differs in function of latitude
-   */
-  extendsWithMeasure(measure) {
-    if (typeof measure !== "number") {
-      throw new Error("measure is not a number");
-    }
-    this.northEast = this.northEast.destinationPoint(measure, 0).move(measure, Math.PI / 2);
-    this.southWest = this.southWest.clone().destinationPoint(measure, -Math.PI / 2).destinationPoint(measure, Math.PI);
-    return this;
-  }
-  /**
-   * Returns bounds created by extending or retracting the current bounds by a given ratio in each direction.
-   * For example, a ratio of 0.5 extends the bounds by 50% in each direction.
-   * Negative values will retract the bounds.
-   */
-  pad(bufferRatio) {
-    const sw = this.southWest;
-    const ne = this.northEast;
-    const heightBuffer = Math.abs(sw.lat - ne.lat) * bufferRatio;
-    const widthBuffer = Math.abs(sw.lng - ne.lng) * bufferRatio;
-    this.southWest = new Coordinates(sw.lat - heightBuffer, sw.lng - widthBuffer);
-    this.northEast = new Coordinates(ne.lat + heightBuffer, ne.lng + widthBuffer);
-    return this;
-  }
-  /**
-   * Returns the southwest corner of the bounding box.
-   */
-  getSouthWest() {
-    return this.southWest;
-  }
-  /**
-  * Returns the northeast corner of the bounding box.
-  */
-  getNorthEast() {
-    return this.northEast;
-  }
-  /**
-  * Returns the northwest corner of the bounding box.
-  */
-  getNorthWest() {
-    return new Coordinates(this.getNorth(), this.getWest());
-  }
-  /**
-  * Returns the southeast corner of the bounding box.
-  */
-  getSouthEast() {
-    return new Coordinates(this.getSouth(), this.getEast());
-  }
-  /**
-  * Returns the west edge of the bounding box.
-  */
-  getWest() {
-    return this.southWest.lng;
-  }
-  /**
-  * Returns the south edge of the bounding box.
-  */
-  getSouth() {
-    return this.southWest.lat;
-  }
-  /**
-  * Returns the east edge of the bounding box.
-  */
-  getEast() {
-    return this.northEast.lng;
-  }
-  /**
-  * Returns the north edge of the bounding box.
-  */
-  getNorth() {
-    return this.northEast.lat;
-  }
-  static equals(bb1, bb2) {
-    return Coordinates.equals(bb1.northEast, bb2.northEast) && Coordinates.equals(bb1.southWest, bb2.southWest);
-  }
-  equals(other) {
-    return BoundingBox.equals(this, other);
-  }
-  /**
-   * Create a BoundingBox from a WSEN array
-   */
-  static fromArray(bounds) {
-    return new BoundingBox(
-      new Coordinates(bounds[3], bounds[2]),
-      new Coordinates(bounds[1], bounds[0])
-    );
-  }
-  static fromCoordinates(coords) {
-    if (coords.length === 0) {
-      return null;
-    }
-    return coords.reduce(
-      (acc, _coords) => acc.extend(_coords),
-      new BoundingBox(coords[0], coords[0])
-    );
-  }
-  /**
-   * Returns the WSEN array
-   */
-  toArray() {
-    return [this.getWest(), this.getSouth(), this.getEast(), this.getNorth()];
-  }
-}
-class RelativePosition {
-  constructor(x, y, z, time = null, accuracy = null, bearing = null) {
-    __publicField(this, "x");
-    __publicField(this, "y");
-    __publicField(this, "z");
-    __publicField(this, "time", null);
-    __publicField(this, "_accuracy", null);
-    __publicField(this, "_bearing", null);
-    this.x = x;
-    this.y = y;
-    this.z = z;
-    this.time = time;
-    this.accuracy = accuracy;
-    this.bearing = bearing;
-  }
-  get accuracy() {
-    return this._accuracy;
-  }
-  set accuracy(accuracy) {
-    if (accuracy !== null && accuracy < 0) {
-      throw new Error("accuracy argument is not a positive number");
-    }
-    this._accuracy = accuracy;
-  }
-  get bearing() {
-    return this._bearing;
-  }
-  set bearing(bearing) {
-    this._bearing = bearing !== null ? bearing % (2 * Math.PI) : null;
-  }
-  clone() {
-    return new RelativePosition(this.x, this.y, this.z, this.time, this.accuracy, this.bearing);
-  }
-  /**
-   * Compares two RelativePosition
-   * @param {RelativePosition} pos1 position 1
-   * @param {RelativePosition} pos2 position 2
-   * @param {Number} eps x, y, z epsilon in meters (default: 1e-3 [= 1mm])
-   */
-  static equals(pos1, pos2, eps = EPS_MM) {
-    if (pos1 === null && pos1 === pos2) {
-      return true;
-    }
-    if (!(pos1 instanceof RelativePosition) || !(pos2 instanceof RelativePosition)) {
-      return false;
-    }
-    return Math.abs(pos2.x - pos1.x) < eps && Math.abs(pos2.y - pos1.y) < eps && Math.abs(pos2.z - pos1.z) < eps && pos1.time === pos2.time && pos1.accuracy === pos2.accuracy && pos1.bearing === pos2.bearing;
-  }
-  equals(other) {
-    return RelativePosition.equals(this, other);
-  }
-  toJson() {
-    return {
-      x: this.x,
-      y: this.y,
-      z: this.z,
-      ...this.time !== null && { time: this.time },
-      ...this.accuracy !== null && { accuracy: this.accuracy },
-      ...this.bearing !== null && { bearing: this.bearing }
-    };
-  }
-  static fromJson(json) {
-    return new RelativePosition(json.x, json.y, json.z, json.time, json.accuracy, json.bearing);
-  }
-}
-class GeoRelativePosition extends RelativePosition {
-}
-class GeoRef {
-  constructor(origin, buildingLevels = []) {
-    __publicField(this, "scale", 1);
-    __publicField(this, "heading", 0);
-    this.origin = origin;
-    this.buildingLevels = buildingLevels;
-  }
-  /**
-   * LocalPosition in ENU frame
-   */
-  localToWorld(localPosition) {
-    const enuTranslationScaled = Vector3.multiplyScalar(localPosition, this.scale);
-    const rotationOffset = Quaternion.fromAxisAngle([0, 0, 1], this.heading);
-    const enuToEcefRotationOrigin = Quaternion.multiply(rotationOffset, this.origin.enuToEcefRotation);
-    const ecefTranslation = Quaternion.rotate(enuToEcefRotationOrigin, enuTranslationScaled);
-    const ecef = Vector3.sum(this.origin.ecef, ecefTranslation);
-    const coordinates = Coordinates.fromECEF(ecef);
-    const alt = coordinates.alt;
-    coordinates.heightFromGround = coordinates.alt - this.origin.alt;
-    const updateLevelAndHeightFromFloor = (buildingLevel) => {
-      coordinates.level = buildingLevel.id;
-      coordinates.heightFromFloor = alt - buildingLevel.floorAltitude;
-    };
-    if (!this.buildingLevels.length) {
-      return coordinates;
-    }
-    const correspondedLevelsByAltitude = this.buildingLevels.filter(
-      (buildingLevel) => alt >= buildingLevel.floorAltitude && alt <= buildingLevel.ceilingAltitude
-    );
-    if (!correspondedLevelsByAltitude.length) {
-      return coordinates;
-    }
-    const levelByAltitude = correspondedLevelsByAltitude[0];
-    const geojsonPt = [coordinates.lng, coordinates.lat];
-    const levelsWithCoverage = correspondedLevelsByAltitude.filter((l) => l.geometries.length);
-    if (!levelsWithCoverage.length) {
-      updateLevelAndHeightFromFloor(levelByAltitude);
-      return coordinates;
-    }
-    const correspondedLevelsByCoverage = levelsWithCoverage.filter((l) => l.geometries.some((geom) => booleanPointInPolygon(geojsonPt, geom)));
-    const levelByCoverage = correspondedLevelsByCoverage[0];
-    if (!levelByCoverage) {
-      return coordinates;
-    }
-    updateLevelAndHeightFromFloor(levelByCoverage);
-    return coordinates;
-  }
-  /**
-   * LocalPosition in ENU frame
-   */
-  worldToLocal(coords) {
-    const rotationOffset = Quaternion.fromAxisAngle([0, 0, 1], -this.heading);
-    const ecefToEnuRotationOrigin = Quaternion.multiply(this.origin.ecefToEnuRotation, rotationOffset);
-    const ecefTranslation = Vector3.subtract(coords.ecef, this.origin.ecef);
-    const ecefTranslationScaled = Vector3.multiplyScalar(ecefTranslation, 1 / this.scale);
-    return Quaternion.rotate(ecefToEnuRotationOrigin, ecefTranslationScaled);
-  }
-  toJson() {
-    return {
-      origin: this.origin.toJson(),
-      ...this.scale !== 1 && { scale: this.scale },
-      ...this.heading !== 0 && { heading: this.heading }
-    };
-  }
-  static fromJson(json) {
-    const geoRef = new GeoRef(Coordinates.fromJson(json.origin));
-    geoRef.scale = typeof json.scale !== "undefined" ? json.scale : 1;
-    geoRef.heading = typeof json.heading !== "undefined" ? json.heading : 0;
-    return geoRef;
-  }
-}
-class Attitude {
-  constructor(quaternion, time = null, accuracy = null) {
-    __publicField(this, "_quaternion", [1, 0, 0, 0]);
-    __publicField(this, "_heading", null);
-    __publicField(this, "_eulerAngles", null);
-    __publicField(this, "_time", null);
-    __publicField(this, "_accuracy", null);
-    this.quaternion = quaternion;
-    this.time = time;
-    this.accuracy = accuracy;
-  }
-  static unitary() {
-    return new Attitude([1, 0, 0, 0]);
-  }
-  get quaternion() {
-    return this._quaternion;
-  }
-  set quaternion(quaternion) {
-    if (Math.abs(1 - Quaternion.norm(quaternion)) > 1e-4) {
-      throw new Error("quaternion is not a unit quaternion");
-    }
-    this._quaternion = quaternion;
-    this._heading = null;
-    this._eulerAngles = null;
-  }
-  get time() {
-    return this._time;
-  }
-  set time(time) {
-    this._time = time;
-  }
-  get accuracy() {
-    return this._accuracy;
-  }
-  set accuracy(accuracy) {
-    if (accuracy !== null && (accuracy < 0 || accuracy > Math.PI)) {
-      throw new Error("accuracy argument (" + accuracy + ") is not in range [0; PI]");
-    }
-    this._accuracy = accuracy;
-  }
-  get eulerAngles() {
-    if (this._eulerAngles === null) {
-      this._eulerAngles = Rotations.quaternionToEulerZXY(this.quaternion);
-    }
-    return this._eulerAngles;
-  }
-  get eulerAnglesDegrees() {
-    return this.eulerAngles.map((x) => rad2deg(x));
-  }
-  get heading() {
-    if (this._heading === null) {
-      let offset = 0;
-      if (typeof window !== "undefined" && window && window.orientation) {
-        offset = deg2rad(window.orientation);
-      }
-      this._heading = Rotations.getHeadingFromQuaternion(this.quaternion) + offset;
-    }
-    return this._heading;
-  }
-  get headingDegrees() {
-    return rad2deg(this.heading);
-  }
-  static equals(att1, att2) {
-    if (att1 === null && att1 === att2) {
-      return true;
-    }
-    if (!(att1 instanceof Attitude) || !(att2 instanceof Attitude)) {
-      return false;
-    }
-    if (att1 === att2) {
-      return true;
-    }
-    return Quaternion.equals(att1.quaternion, att2.quaternion);
-  }
-  equals(other) {
-    return Attitude.equals(this, other);
-  }
-  toJson() {
-    if (this.time === null && this.accuracy === null) {
-      return this.quaternion;
-    }
-    return {
-      q: this.quaternion,
-      ...this.time !== null && { time: this.time },
-      ...this.accuracy !== null && { accuracy: this.accuracy }
-    };
-  }
-  static fromJson(json) {
-    if (Array.isArray(json)) {
-      return new Attitude(json, null, null);
-    }
-    return new Attitude(json.q, json.time, json.accuracy);
-  }
-  clone() {
-    return new Attitude(this.quaternion.slice(0), this.time, this.accuracy);
-  }
-  /**
-   * Calculate the relative attitude between two given attitudes
-   */
-  static diff(attitudeStart, attitudeEnd) {
-    const quaternionDiff = Quaternion.multiply(
-      Quaternion.inverse(attitudeStart.quaternion),
-      attitudeEnd.quaternion
-    );
-    let timeDiff = null;
-    if (attitudeEnd.time !== null && attitudeStart.time !== null) {
-      timeDiff = attitudeEnd.time - attitudeStart.time;
-    }
-    let accuracyDiff = null;
-    if (attitudeStart.accuracy !== null && attitudeEnd.accuracy !== null) {
-      accuracyDiff = Math.max(attitudeEnd.accuracy - attitudeStart.accuracy);
-    }
-    return new Attitude(quaternionDiff, timeDiff, accuracyDiff);
-  }
-}
-class AbsoluteHeading {
-  constructor(heading, time = null, accuracy = null) {
-    __publicField(this, "heading");
-    __publicField(this, "time", null);
-    __publicField(this, "_accuracy", null);
-    this.heading = heading;
-    this.time = time;
-    this.accuracy = accuracy;
-  }
-  get accuracy() {
-    return this._accuracy;
-  }
-  set accuracy(accuracy) {
-    if (accuracy !== null && (accuracy < 0 || accuracy > Math.PI)) {
-      throw new Error("accuracy argument (" + accuracy + ") is not in range [0; PI]");
-    }
-    this._accuracy = accuracy;
-  }
-  toAttitude() {
-    return new Attitude(
-      Quaternion.fromAxisAngle([0, 0, 1], -this.heading),
-      this.time,
-      this.accuracy
-    );
-  }
-  /**
-   * Compares two AbsoluteHeading
-   * @param {AbsoluteHeading} heading1 heading 1
-   * @param {AbsoluteHeading} heading2 heading 2
-   */
-  static equals(heading1, heading2) {
-    if (heading1 === null && heading1 === heading2) {
-      return true;
-    }
-    if (!(heading1 instanceof AbsoluteHeading) || !(heading2 instanceof AbsoluteHeading)) {
-      return false;
-    }
-    return Math.abs(heading1.heading - heading2.heading) < 1e-8;
-  }
-  equals(other) {
-    return AbsoluteHeading.equals(this, other);
-  }
-  toJson() {
-    return {
-      heading: this.heading,
-      ...this.time !== null && { time: this.time },
-      ...this.accuracy !== null && { accuracy: this.accuracy }
-    };
-  }
-  static fromJson(json) {
-    return new AbsoluteHeading(json.heading, json.time, json.accuracy);
-  }
-  clone() {
-    return new AbsoluteHeading(this.heading, this.time, this.accuracy);
-  }
-}
-export {
-  AbsoluteHeading,
-  Attitude,
-  BoundingBox,
-  Constants,
-  Coordinates,
-  GeoRef,
-  GeoRelativePosition,
-  Level,
-  RelativePosition,
-  UserPosition,
-  Utils
-};
-//# sourceMappingURL=index.mjs.map