@wemap/geo 11.0.0-alpha.2 → 11.0.0-alpha.20

package/dist/index.js

@@ -1,11 +1,15 @@
+"use strict";
 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, diffAngleLines } from "@wemap/maths";
-import Logger from "@wemap/logger";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const maths = require("@wemap/maths");
+const Logger = require("@wemap/logger");
+const _interopDefaultLegacy = (e) => e && typeof e === "object" && "default" in e ? e : { default: e };
+const Logger__default = /* @__PURE__ */ _interopDefaultLegacy(Logger);
 const R_MAJOR = 6378137;
 const R_MINOR = 63567523142e-4;
 const EARTH_GRAVITY = 9.80665;
@@ -327,7 +331,7 @@ class Coordinates {
   }
   wrap() {
     if (this._lng <= -180 || this._lng > 180) {
-      this._lng = wrap(this._lng, -180, 180);
+      this._lng = maths.wrap(this._lng, -180, 180);
     }
   }
   static equals(pos1, pos2, eps = EPS_DEG_MM, epsAlt = EPS_MM) {
@@ -351,8 +355,8 @@ class Coordinates {
     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 phi1 = maths.deg2rad(this.lat);
+    const lambda1 = maths.deg2rad(this.lng);
     const phi2 = Math.asin(
       Math.sin(phi1) * cosDr + Math.cos(phi1) * sinDr * Math.cos(bearing)
     );
@@ -360,8 +364,8 @@ class Coordinates {
       Math.sin(bearing) * sinDr * Math.cos(phi1),
       cosDr - Math.sin(phi1) * Math.sin(phi2)
     );
-    this.lat = rad2deg(phi2);
-    this.lng = rad2deg(lambda2);
+    this.lat = maths.rad2deg(phi2);
+    this.lng = maths.rad2deg(lambda2);
     if (elevation !== null) {
       if (this.alt === null) {
         throw new Error("Point altitude is not defined");
@@ -375,13 +379,13 @@ class Coordinates {
     const lng1 = this.lng;
     const lat2 = location2.lat;
     const lng2 = location2.lng;
-    const dlat = deg2rad(lat2 - lat1);
-    const dlng = deg2rad(lng2 - lng1);
+    const dlat = maths.deg2rad(lat2 - lat1);
+    const dlng = maths.deg2rad(lng2 - lng1);
     const dlngsin = Math.sin(dlng / 2);
     const dlatsin = Math.sin(dlat / 2);
-    const lat1rad = deg2rad(lat1);
+    const lat1rad = maths.deg2rad(lat1);
     const lat1cos = Math.cos(lat1rad);
-    const lat2rad = deg2rad(lat2);
+    const lat2rad = maths.deg2rad(lat2);
     const lat2cos = Math.cos(lat2rad);
     const angle = dlatsin * dlatsin + lat1cos * lat2cos * dlngsin * dlngsin;
     const tangy = Math.sqrt(angle);
@@ -393,9 +397,9 @@ class Coordinates {
     return point1.distanceTo(point2);
   }
   bearingTo(location2) {
-    const lat1 = deg2rad(this.lat);
-    const lat2 = deg2rad(location2.lat);
-    const diffLng = deg2rad(location2.lng - this.lng);
+    const lat1 = maths.deg2rad(this.lat);
+    const lat2 = maths.deg2rad(location2.lat);
+    const diffLng = maths.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)
@@ -405,19 +409,19 @@ class Coordinates {
     return point1.bearingTo(point2);
   }
   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);
+    const rot1 = maths.Quaternion.fromAxisAngle([0, 0, 1], Math.PI / 2 + maths.deg2rad(this.lng));
+    const rot2 = maths.Quaternion.fromAxisAngle([1, 0, 0], Math.PI / 2 - maths.deg2rad(this.lat));
+    return maths.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);
+    const rot1 = maths.Quaternion.fromAxisAngle([1, 0, 0], maths.deg2rad(this.lat) - Math.PI / 2);
+    const rot2 = maths.Quaternion.fromAxisAngle([0, 0, 1], -maths.deg2rad(this.lng) - Math.PI / 2);
+    return maths.Quaternion.multiply(rot1, rot2);
   }
   get ecef() {
     if (!this._ecef) {
-      const lat = deg2rad(this.lat);
-      const lng = deg2rad(this.lng);
+      const lat = maths.deg2rad(this.lat);
+      const lng = maths.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);
@@ -435,21 +439,21 @@ class Coordinates {
     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);
+    const newPoint = new Coordinates(maths.rad2deg(lat), maths.rad2deg(lng), alt);
     newPoint._ecef = ecef;
     return newPoint;
   }
   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) {
+    const a = maths.Vector3.normalize(p1.ecef);
+    const b = maths.Vector3.normalize(p2.ecef);
+    const c = maths.Vector3.normalize(this.ecef);
+    const G = maths.Vector3.cross(a, b);
+    if (maths.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 F = maths.Vector3.cross(c, G);
+    const t = maths.Vector3.normalize(maths.Vector3.cross(G, F));
+    const posECEF = maths.Vector3.multiplyScalar(t, R_MAJOR);
     const poseCoordinates = Coordinates.fromECEF(posECEF);
     let alt;
     if (p1.alt !== null && p2.alt !== null) {
@@ -479,9 +483,9 @@ class Coordinates {
   }
   toJson() {
     return {
-      lat: this.lat,
-      lng: this.lng,
-      ...this.alt !== null && { alt: this.alt },
+      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 }
     };
   }
@@ -490,12 +494,21 @@ class Coordinates {
   }
   toCompressedJson() {
     if (this.level !== null) {
-      return [this.lat, this.lng, this.alt, this.level];
+      return [
+        Number(this.lat.toFixed(8)),
+        Number(this.lng.toFixed(8)),
+        this.alt === null ? null : Number(this.alt.toFixed(3)),
+        this.level
+      ];
     }
     if (this.alt !== null) {
-      return [this.lat, this.lng, this.alt];
+      return [
+        Number(this.lat.toFixed(8)),
+        Number(this.lng.toFixed(8)),
+        Number(this.alt.toFixed(3))
+      ];
     }
-    return [this.lat, this.lng];
+    return [Number(this.lat.toFixed(8)), Number(this.lng.toFixed(8))];
   }
   static fromCompressedJson(json) {
     const coords = new Coordinates(json[0], json[1]);
@@ -684,14 +697,14 @@ function trimRoute(route, startPosition = route[0], length = Number.MAX_VALUE) {
   }
   return newRoute;
 }
-function simplifyRoute(coords, precisionAngle = deg2rad(5)) {
+function simplifyRoute(coords, precisionAngle = maths.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 p0 = coords[maths.positiveMod(i - 1, len)];
     const p1 = coords[i];
-    const p2 = coords[positiveMod(i + 1, len)];
+    const p2 = coords[maths.positiveMod(i + 1, len)];
     const seg1Dir = p0.bearingTo(p1);
     const seg2Dir = p1.bearingTo(p2);
     if (Math.abs(seg2Dir - seg1Dir) < precisionAngle) {
@@ -711,7 +724,7 @@ function geolocationPositionToUserPosition(geolocationPosition) {
   const userPosition = new UserPosition(latitude, longitude);
   userPosition.time = geolocationPosition.timestamp;
   userPosition.accuracy = accuracy;
-  userPosition.bearing = heading ? deg2rad(heading) : null;
+  userPosition.bearing = heading ? maths.deg2rad(heading) : null;
   return userPosition;
 }
 function calcDistance(coords) {
@@ -900,19 +913,19 @@ class GeoRef {
     this.origin = origin;
   }
   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 enuTranslationScaled = maths.Vector3.multiplyScalar(localPosition, this.scale);
+    const rotationOffset = maths.Quaternion.fromAxisAngle([0, 0, 1], this.heading);
+    const enuToEcefRotationOrigin = maths.Quaternion.multiply(rotationOffset, this.origin.enuToEcefRotation);
+    const ecefTranslation = maths.Quaternion.rotate(enuToEcefRotationOrigin, enuTranslationScaled);
+    const ecef = maths.Vector3.sum(this.origin.ecef, ecefTranslation);
     return Coordinates.fromECEF(ecef);
   }
   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);
+    const rotationOffset = maths.Quaternion.fromAxisAngle([0, 0, 1], -this.heading);
+    const ecefToEnuRotationOrigin = maths.Quaternion.multiply(this.origin.ecefToEnuRotation, rotationOffset);
+    const ecefTranslation = maths.Vector3.subtract(coords.ecef, this.origin.ecef);
+    const ecefTranslationScaled = maths.Vector3.multiplyScalar(ecefTranslation, 1 / this.scale);
+    return maths.Quaternion.rotate(ecefToEnuRotationOrigin, ecefTranslationScaled);
   }
   toJson() {
     return {
@@ -946,7 +959,7 @@ class Attitude {
     return this._quaternion;
   }
   set quaternion(quaternion) {
-    if (Math.abs(1 - Quaternion.norm(quaternion)) > 1e-4) {
+    if (Math.abs(1 - maths.Quaternion.norm(quaternion)) > 1e-4) {
       throw new Error("quaternion is not a unit quaternion");
     }
     this._quaternion = quaternion;
@@ -970,25 +983,25 @@ class Attitude {
   }
   get eulerAngles() {
     if (this._eulerAngles === null) {
-      this._eulerAngles = Rotations.quaternionToEulerZXY(this.quaternion);
+      this._eulerAngles = maths.Rotations.quaternionToEulerZXY(this.quaternion);
     }
     return this._eulerAngles;
   }
   get eulerAnglesDegrees() {
-    return this.eulerAngles.map((x) => rad2deg(x));
+    return this.eulerAngles.map((x) => maths.rad2deg(x));
   }
   get heading() {
     if (this._heading === null) {
       let offset = 0;
       if (typeof window !== "undefined" && window && window.orientation) {
-        offset = deg2rad(window.orientation);
+        offset = maths.deg2rad(window.orientation);
       }
-      this._heading = Rotations.getHeadingFromQuaternion(this.quaternion) + offset;
+      this._heading = maths.Rotations.getHeadingFromQuaternion(this.quaternion) + offset;
     }
     return this._heading;
   }
   get headingDegrees() {
-    return rad2deg(this.heading);
+    return maths.rad2deg(this.heading);
   }
   static equals(att1, att2) {
     if (att1 === null && att1 === att2) {
@@ -1000,7 +1013,7 @@ class Attitude {
     if (att1 === att2) {
       return true;
     }
-    return Quaternion.equals(att1.quaternion, att2.quaternion);
+    return maths.Quaternion.equals(att1.quaternion, att2.quaternion);
   }
   equals(other) {
     return Attitude.equals(this, other);
@@ -1025,8 +1038,8 @@ class Attitude {
     return new Attitude(this.quaternion.slice(0), this.time, this.accuracy);
   }
   static diff(attitudeStart, attitudeEnd) {
-    const quaternionDiff = Quaternion.multiply(
-      Quaternion.inverse(attitudeStart.quaternion),
+    const quaternionDiff = maths.Quaternion.multiply(
+      maths.Quaternion.inverse(attitudeStart.quaternion),
       attitudeEnd.quaternion
     );
     let timeDiff = null;
@@ -1060,7 +1073,7 @@ class AbsoluteHeading {
   }
   toAttitude() {
     return new Attitude(
-      Quaternion.fromAxisAngle([0, 0, 1], -this.heading),
+      maths.Quaternion.fromAxisAngle([0, 0, 1], -this.heading),
       this.time,
       this.accuracy
     );
@@ -1091,158 +1104,1118 @@ class AbsoluteHeading {
     return new AbsoluteHeading(this.heading, this.time, this.accuracy);
   }
 }
-class GraphNode {
-  constructor(coords, builtFrom = null) {
-    __publicField(this, "coords");
-    __publicField(this, "edges", []);
-    __publicField(this, "builtFrom");
-    __publicField(this, "io", false);
-    this.coords = coords;
-    this.builtFrom = builtFrom;
-  }
-  distanceTo(other) {
-    return this.coords.distanceTo(other.coords);
-  }
-  bearingTo(other) {
-    return this.coords.bearingTo(other.coords);
-  }
-  equals(other) {
-    return this.coords.equals(other.coords) && this.builtFrom === other.builtFrom;
-  }
-  clone() {
-    const node = new GraphNode(this.coords, this.builtFrom);
-    node.edges = this.edges.slice(0);
-    node.io = this.io;
-    return node;
-  }
-  toJson() {
-    return this.coords.toCompressedJson();
-  }
-  static fromJson(json, builtFrom = null) {
-    return new GraphNode(Coordinates.fromCompressedJson(json), builtFrom);
-  }
-  _generateLevelFromEdges() {
-    let tmpLevel = null;
-    for (let i = 0; i < this.edges.length; i++) {
-      const edge = this.edges[i];
-      if (edge.level !== null) {
-        if (tmpLevel === null) {
-          tmpLevel = Level.clone(edge.level);
+var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
+var uaParser = { exports: {} };
+(function(module2, exports2) {
+  (function(window2, undefined$1) {
+    var LIBVERSION = "1.0.33", EMPTY = "", UNKNOWN = "?", FUNC_TYPE = "function", UNDEF_TYPE = "undefined", OBJ_TYPE = "object", STR_TYPE = "string", MAJOR = "major", MODEL = "model", NAME = "name", TYPE = "type", VENDOR = "vendor", VERSION = "version", ARCHITECTURE = "architecture", CONSOLE = "console", MOBILE = "mobile", TABLET = "tablet", SMARTTV = "smarttv", WEARABLE = "wearable", EMBEDDED = "embedded", UA_MAX_LENGTH = 350;
+    var AMAZON = "Amazon", APPLE = "Apple", ASUS = "ASUS", BLACKBERRY = "BlackBerry", BROWSER = "Browser", CHROME = "Chrome", EDGE = "Edge", FIREFOX = "Firefox", GOOGLE = "Google", HUAWEI = "Huawei", LG = "LG", MICROSOFT = "Microsoft", MOTOROLA = "Motorola", OPERA = "Opera", SAMSUNG = "Samsung", SHARP = "Sharp", SONY = "Sony", XIAOMI = "Xiaomi", ZEBRA = "Zebra", FACEBOOK = "Facebook";
+    var extend = function(regexes2, extensions) {
+      var mergedRegexes = {};
+      for (var i in regexes2) {
+        if (extensions[i] && extensions[i].length % 2 === 0) {
+          mergedRegexes[i] = extensions[i].concat(regexes2[i]);
         } else {
-          tmpLevel = Level.intersection(tmpLevel, edge.level);
-          if (tmpLevel === null) {
-            throw Error("Something bad happend during parsing: We cannot retrieve node level from adjacent ways: " + this.coords);
-          }
+          mergedRegexes[i] = regexes2[i];
         }
       }
-    }
-    this.coords.level = tmpLevel;
-  }
-  _inferNodeLevelByRecursion() {
-    const { level } = this.coords;
-    if (level === null || !Level.isRange(level)) {
-      return;
-    }
-    if (this.edges.length > 1) {
-      return;
-    }
-    const lookForLevel = (node, visitedNodes) => {
-      visitedNodes.push(node);
-      if (node.coords.level === null) {
-        return null;
+      return mergedRegexes;
+    }, enumerize = function(arr) {
+      var enums = {};
+      for (var i = 0; i < arr.length; i++) {
+        enums[arr[i].toUpperCase()] = arr[i];
       }
-      if (!Level.isRange(node.coords.level)) {
-        return node.coords.level;
+      return enums;
+    }, has = function(str1, str2) {
+      return typeof str1 === STR_TYPE ? lowerize(str2).indexOf(lowerize(str1)) !== -1 : false;
+    }, lowerize = function(str) {
+      return str.toLowerCase();
+    }, majorize = function(version) {
+      return typeof version === STR_TYPE ? version.replace(/[^\d\.]/g, EMPTY).split(".")[0] : undefined$1;
+    }, trim = function(str, len) {
+      if (typeof str === STR_TYPE) {
+        str = str.replace(/^\s\s*/, EMPTY);
+        return typeof len === UNDEF_TYPE ? str : str.substring(0, UA_MAX_LENGTH);
       }
-      let tmpLevel = null;
-      for (let i = 0; i < node.edges.length; i++) {
-        const edge = node.edges[i];
-        const otherNode = edge.node1 === node ? edge.node2 : edge.node1;
-        if (!visitedNodes.includes(otherNode)) {
-          tmpLevel = Level.union(lookForLevel(otherNode, visitedNodes), tmpLevel);
+    };
+    var rgxMapper = function(ua, arrays) {
+      var i = 0, j, k, p, q, matches, match;
+      while (i < arrays.length && !matches) {
+        var regex = arrays[i], props = arrays[i + 1];
+        j = k = 0;
+        while (j < regex.length && !matches) {
+          matches = regex[j++].exec(ua);
+          if (!!matches) {
+            for (p = 0; p < props.length; p++) {
+              match = matches[++k];
+              q = props[p];
+              if (typeof q === OBJ_TYPE && q.length > 0) {
+                if (q.length === 2) {
+                  if (typeof q[1] == FUNC_TYPE) {
+                    this[q[0]] = q[1].call(this, match);
+                  } else {
+                    this[q[0]] = q[1];
+                  }
+                } else if (q.length === 3) {
+                  if (typeof q[1] === FUNC_TYPE && !(q[1].exec && q[1].test)) {
+                    this[q[0]] = match ? q[1].call(this, match, q[2]) : undefined$1;
+                  } else {
+                    this[q[0]] = match ? match.replace(q[1], q[2]) : undefined$1;
+                  }
+                } else if (q.length === 4) {
+                  this[q[0]] = match ? q[3].call(this, match.replace(q[1], q[2])) : undefined$1;
+                }
+              } else {
+                this[q] = match ? match : undefined$1;
+              }
+            }
+          }
         }
+        i += 2;
       }
-      return tmpLevel;
+    }, strMapper = function(str, map) {
+      for (var i in map) {
+        if (typeof map[i] === OBJ_TYPE && map[i].length > 0) {
+          for (var j = 0; j < map[i].length; j++) {
+            if (has(map[i][j], str)) {
+              return i === UNKNOWN ? undefined$1 : i;
+            }
+          }
+        } else if (has(map[i], str)) {
+          return i === UNKNOWN ? undefined$1 : i;
+        }
+      }
+      return str;
     };
-    const othersLevels = lookForLevel(this, []);
-    if (othersLevels !== null) {
-      if (!Level.isRange(othersLevels)) {
-        this.coords.level = othersLevels === level[0] ? level[1] : level[0];
-        return;
+    var oldSafariMap = {
+      "1.0": "/8",
+      "1.2": "/1",
+      "1.3": "/3",
+      "2.0": "/412",
+      "2.0.2": "/416",
+      "2.0.3": "/417",
+      "2.0.4": "/419",
+      "?": "/"
+    }, windowsVersionMap = {
+      "ME": "4.90",
+      "NT 3.11": "NT3.51",
+      "NT 4.0": "NT4.0",
+      "2000": "NT 5.0",
+      "XP": ["NT 5.1", "NT 5.2"],
+      "Vista": "NT 6.0",
+      "7": "NT 6.1",
+      "8": "NT 6.2",
+      "8.1": "NT 6.3",
+      "10": ["NT 6.4", "NT 10.0"],
+      "RT": "ARM"
+    };
+    var regexes = {
+      browser: [
+        [
+          /\b(?:crmo|crios)\/([\w\.]+)/i
+        ],
+        [VERSION, [NAME, "Chrome"]],
+        [
+          /edg(?:e|ios|a)?\/([\w\.]+)/i
+        ],
+        [VERSION, [NAME, "Edge"]],
+        [
+          /(opera mini)\/([-\w\.]+)/i,
+          /(opera [mobiletab]{3,6})\b.+version\/([-\w\.]+)/i,
+          /(opera)(?:.+version\/|[\/ ]+)([\w\.]+)/i
+        ],
+        [NAME, VERSION],
+        [
+          /opios[\/ ]+([\w\.]+)/i
+        ],
+        [VERSION, [NAME, OPERA + " Mini"]],
+        [
+          /\bopr\/([\w\.]+)/i
+        ],
+        [VERSION, [NAME, OPERA]],
+        [
+          /(kindle)\/([\w\.]+)/i,
+          /(lunascape|maxthon|netfront|jasmine|blazer)[\/ ]?([\w\.]*)/i,
+          /(avant |iemobile|slim)(?:browser)?[\/ ]?([\w\.]*)/i,
+          /(ba?idubrowser)[\/ ]?([\w\.]+)/i,
+          /(?:ms|\()(ie) ([\w\.]+)/i,
+          /(flock|rockmelt|midori|epiphany|silk|skyfire|ovibrowser|bolt|iron|vivaldi|iridium|phantomjs|bowser|quark|qupzilla|falkon|rekonq|puffin|brave|whale|qqbrowserlite|qq|duckduckgo)\/([-\w\.]+)/i,
+          /(weibo)__([\d\.]+)/i
+        ],
+        [NAME, VERSION],
+        [
+          /(?:\buc? ?browser|(?:juc.+)ucweb)[\/ ]?([\w\.]+)/i
+        ],
+        [VERSION, [NAME, "UC" + BROWSER]],
+        [
+          /microm.+\bqbcore\/([\w\.]+)/i,
+          /\bqbcore\/([\w\.]+).+microm/i
+        ],
+        [VERSION, [NAME, "WeChat(Win) Desktop"]],
+        [
+          /micromessenger\/([\w\.]+)/i
+        ],
+        [VERSION, [NAME, "WeChat"]],
+        [
+          /konqueror\/([\w\.]+)/i
+        ],
+        [VERSION, [NAME, "Konqueror"]],
+        [
+          /trident.+rv[: ]([\w\.]{1,9})\b.+like gecko/i
+        ],
+        [VERSION, [NAME, "IE"]],
+        [
+          /yabrowser\/([\w\.]+)/i
+        ],
+        [VERSION, [NAME, "Yandex"]],
+        [
+          /(avast|avg)\/([\w\.]+)/i
+        ],
+        [[NAME, /(.+)/, "$1 Secure " + BROWSER], VERSION],
+        [
+          /\bfocus\/([\w\.]+)/i
+        ],
+        [VERSION, [NAME, FIREFOX + " Focus"]],
+        [
+          /\bopt\/([\w\.]+)/i
+        ],
+        [VERSION, [NAME, OPERA + " Touch"]],
+        [
+          /coc_coc\w+\/([\w\.]+)/i
+        ],
+        [VERSION, [NAME, "Coc Coc"]],
+        [
+          /dolfin\/([\w\.]+)/i
+        ],
+        [VERSION, [NAME, "Dolphin"]],
+        [
+          /coast\/([\w\.]+)/i
+        ],
+        [VERSION, [NAME, OPERA + " Coast"]],
+        [
+          /miuibrowser\/([\w\.]+)/i
+        ],
+        [VERSION, [NAME, "MIUI " + BROWSER]],
+        [
+          /fxios\/([-\w\.]+)/i
+        ],
+        [VERSION, [NAME, FIREFOX]],
+        [
+          /\bqihu|(qi?ho?o?|360)browser/i
+        ],
+        [[NAME, "360 " + BROWSER]],
+        [
+          /(oculus|samsung|sailfish|huawei)browser\/([\w\.]+)/i
+        ],
+        [[NAME, /(.+)/, "$1 " + BROWSER], VERSION],
+        [
+          /(comodo_dragon)\/([\w\.]+)/i
+        ],
+        [[NAME, /_/g, " "], VERSION],
+        [
+          /(electron)\/([\w\.]+) safari/i,
+          /(tesla)(?: qtcarbrowser|\/(20\d\d\.[-\w\.]+))/i,
+          /m?(qqbrowser|baiduboxapp|2345Explorer)[\/ ]?([\w\.]+)/i
+        ],
+        [NAME, VERSION],
+        [
+          /(metasr)[\/ ]?([\w\.]+)/i,
+          /(lbbrowser)/i,
+          /\[(linkedin)app\]/i
+        ],
+        [NAME],
+        [
+          /((?:fban\/fbios|fb_iab\/fb4a)(?!.+fbav)|;fbav\/([\w\.]+);)/i
+        ],
+        [[NAME, FACEBOOK], VERSION],
+        [
+          /safari (line)\/([\w\.]+)/i,
+          /\b(line)\/([\w\.]+)\/iab/i,
+          /(chromium|instagram)[\/ ]([-\w\.]+)/i
+        ],
+        [NAME, VERSION],
+        [
+          /\bgsa\/([\w\.]+) .*safari\//i
+        ],
+        [VERSION, [NAME, "GSA"]],
+        [
+          /headlesschrome(?:\/([\w\.]+)| )/i
+        ],
+        [VERSION, [NAME, CHROME + " Headless"]],
+        [
+          / wv\).+(chrome)\/([\w\.]+)/i
+        ],
+        [[NAME, CHROME + " WebView"], VERSION],
+        [
+          /droid.+ version\/([\w\.]+)\b.+(?:mobile safari|safari)/i
+        ],
+        [VERSION, [NAME, "Android " + BROWSER]],
+        [
+          /(chrome|omniweb|arora|[tizenoka]{5} ?browser)\/v?([\w\.]+)/i
+        ],
+        [NAME, VERSION],
+        [
+          /version\/([\w\.\,]+) .*mobile\/\w+ (safari)/i
+        ],
+        [VERSION, [NAME, "Mobile Safari"]],
+        [
+          /version\/([\w(\.|\,)]+) .*(mobile ?safari|safari)/i
+        ],
+        [VERSION, NAME],
+        [
+          /webkit.+?(mobile ?safari|safari)(\/[\w\.]+)/i
+        ],
+        [NAME, [VERSION, strMapper, oldSafariMap]],
+        [
+          /(webkit|khtml)\/([\w\.]+)/i
+        ],
+        [NAME, VERSION],
+        [
+          /(navigator|netscape\d?)\/([-\w\.]+)/i
+        ],
+        [[NAME, "Netscape"], VERSION],
+        [
+          /mobile vr; rv:([\w\.]+)\).+firefox/i
+        ],
+        [VERSION, [NAME, FIREFOX + " Reality"]],
+        [
+          /ekiohf.+(flow)\/([\w\.]+)/i,
+          /(swiftfox)/i,
+          /(icedragon|iceweasel|camino|chimera|fennec|maemo browser|minimo|conkeror|klar)[\/ ]?([\w\.\+]+)/i,
+          /(seamonkey|k-meleon|icecat|iceape|firebird|phoenix|palemoon|basilisk|waterfox)\/([-\w\.]+)$/i,
+          /(firefox)\/([\w\.]+)/i,
+          /(mozilla)\/([\w\.]+) .+rv\:.+gecko\/\d+/i,
+          /(polaris|lynx|dillo|icab|doris|amaya|w3m|netsurf|sleipnir|obigo|mosaic|(?:go|ice|up)[\. ]?browser)[-\/ ]?v?([\w\.]+)/i,
+          /(links) \(([\w\.]+)/i
+        ],
+        [NAME, VERSION],
+        [
+          /(cobalt)\/([\w\.]+)/i
+        ],
+        [NAME, [VERSION, /master.|lts./, ""]]
+      ],
+      cpu: [
+        [
+          /(?:(amd|x(?:(?:86|64)[-_])?|wow|win)64)[;\)]/i
+        ],
+        [[ARCHITECTURE, "amd64"]],
+        [
+          /(ia32(?=;))/i
+        ],
+        [[ARCHITECTURE, lowerize]],
+        [
+          /((?:i[346]|x)86)[;\)]/i
+        ],
+        [[ARCHITECTURE, "ia32"]],
+        [
+          /\b(aarch64|arm(v?8e?l?|_?64))\b/i
+        ],
+        [[ARCHITECTURE, "arm64"]],
+        [
+          /\b(arm(?:v[67])?ht?n?[fl]p?)\b/i
+        ],
+        [[ARCHITECTURE, "armhf"]],
+        [
+          /windows (ce|mobile); ppc;/i
+        ],
+        [[ARCHITECTURE, "arm"]],
+        [
+          /((?:ppc|powerpc)(?:64)?)(?: mac|;|\))/i
+        ],
+        [[ARCHITECTURE, /ower/, EMPTY, lowerize]],
+        [
+          /(sun4\w)[;\)]/i
+        ],
+        [[ARCHITECTURE, "sparc"]],
+        [
+          /((?:avr32|ia64(?=;))|68k(?=\))|\barm(?=v(?:[1-7]|[5-7]1)l?|;|eabi)|(?=atmel )avr|(?:irix|mips|sparc)(?:64)?\b|pa-risc)/i
+        ],
+        [[ARCHITECTURE, lowerize]]
+      ],
+      device: [
+        [
+          /\b(sch-i[89]0\d|shw-m380s|sm-[ptx]\w{2,4}|gt-[pn]\d{2,4}|sgh-t8[56]9|nexus 10)/i
+        ],
+        [MODEL, [VENDOR, SAMSUNG], [TYPE, TABLET]],
+        [
+          /\b((?:s[cgp]h|gt|sm)-\w+|galaxy nexus)/i,
+          /samsung[- ]([-\w]+)/i,
+          /sec-(sgh\w+)/i
+        ],
+        [MODEL, [VENDOR, SAMSUNG], [TYPE, MOBILE]],
+        [
+          /\((ip(?:hone|od)[\w ]*);/i
+        ],
+        [MODEL, [VENDOR, APPLE], [TYPE, MOBILE]],
+        [
+          /\((ipad);[-\w\),; ]+apple/i,
+          /applecoremedia\/[\w\.]+ \((ipad)/i,
+          /\b(ipad)\d\d?,\d\d?[;\]].+ios/i
+        ],
+        [MODEL, [VENDOR, APPLE], [TYPE, TABLET]],
+        [
+          /(macintosh);/i
+        ],
+        [MODEL, [VENDOR, APPLE]],
+        [
+          /\b((?:ag[rs][23]?|bah2?|sht?|btv)-a?[lw]\d{2})\b(?!.+d\/s)/i
+        ],
+        [MODEL, [VENDOR, HUAWEI], [TYPE, TABLET]],
+        [
+          /(?:huawei|honor)([-\w ]+)[;\)]/i,
+          /\b(nexus 6p|\w{2,4}e?-[atu]?[ln][\dx][012359c][adn]?)\b(?!.+d\/s)/i
+        ],
+        [MODEL, [VENDOR, HUAWEI], [TYPE, MOBILE]],
+        [
+          /\b(poco[\w ]+)(?: bui|\))/i,
+          /\b; (\w+) build\/hm\1/i,
+          /\b(hm[-_ ]?note?[_ ]?(?:\d\w)?) bui/i,
+          /\b(redmi[\-_ ]?(?:note|k)?[\w_ ]+)(?: bui|\))/i,
+          /\b(mi[-_ ]?(?:a\d|one|one[_ ]plus|note lte|max|cc)?[_ ]?(?:\d?\w?)[_ ]?(?:plus|se|lite)?)(?: bui|\))/i
+        ],
+        [[MODEL, /_/g, " "], [VENDOR, XIAOMI], [TYPE, MOBILE]],
+        [
+          /\b(mi[-_ ]?(?:pad)(?:[\w_ ]+))(?: bui|\))/i
+        ],
+        [[MODEL, /_/g, " "], [VENDOR, XIAOMI], [TYPE, TABLET]],
+        [
+          /; (\w+) bui.+ oppo/i,
+          /\b(cph[12]\d{3}|p(?:af|c[al]|d\w|e[ar])[mt]\d0|x9007|a101op)\b/i
+        ],
+        [MODEL, [VENDOR, "OPPO"], [TYPE, MOBILE]],
+        [
+          /vivo (\w+)(?: bui|\))/i,
+          /\b(v[12]\d{3}\w?[at])(?: bui|;)/i
+        ],
+        [MODEL, [VENDOR, "Vivo"], [TYPE, MOBILE]],
+        [
+          /\b(rmx[12]\d{3})(?: bui|;|\))/i
+        ],
+        [MODEL, [VENDOR, "Realme"], [TYPE, MOBILE]],
+        [
+          /\b(milestone|droid(?:[2-4x]| (?:bionic|x2|pro|razr))?:?( 4g)?)\b[\w ]+build\//i,
+          /\bmot(?:orola)?[- ](\w*)/i,
+          /((?:moto[\w\(\) ]+|xt\d{3,4}|nexus 6)(?= bui|\)))/i
+        ],
+        [MODEL, [VENDOR, MOTOROLA], [TYPE, MOBILE]],
+        [
+          /\b(mz60\d|xoom[2 ]{0,2}) build\//i
+        ],
+        [MODEL, [VENDOR, MOTOROLA], [TYPE, TABLET]],
+        [
+          /((?=lg)?[vl]k\-?\d{3}) bui| 3\.[-\w; ]{10}lg?-([06cv9]{3,4})/i
+        ],
+        [MODEL, [VENDOR, LG], [TYPE, TABLET]],
+        [
+          /(lm(?:-?f100[nv]?|-[\w\.]+)(?= bui|\))|nexus [45])/i,
+          /\blg[-e;\/ ]+((?!browser|netcast|android tv)\w+)/i,
+          /\blg-?([\d\w]+) bui/i
+        ],
+        [MODEL, [VENDOR, LG], [TYPE, MOBILE]],
+        [
+          /(ideatab[-\w ]+)/i,
+          /lenovo ?(s[56]000[-\w]+|tab(?:[\w ]+)|yt[-\d\w]{6}|tb[-\d\w]{6})/i
+        ],
+        [MODEL, [VENDOR, "Lenovo"], [TYPE, TABLET]],
+        [
+          /(?:maemo|nokia).*(n900|lumia \d+)/i,
+          /nokia[-_ ]?([-\w\.]*)/i
+        ],
+        [[MODEL, /_/g, " "], [VENDOR, "Nokia"], [TYPE, MOBILE]],
+        [
+          /(pixel c)\b/i
+        ],
+        [MODEL, [VENDOR, GOOGLE], [TYPE, TABLET]],
+        [
+          /droid.+; (pixel[\daxl ]{0,6})(?: bui|\))/i
+        ],
+        [MODEL, [VENDOR, GOOGLE], [TYPE, MOBILE]],
+        [
+          /droid.+ (a?\d[0-2]{2}so|[c-g]\d{4}|so[-gl]\w+|xq-a\w[4-7][12])(?= bui|\).+chrome\/(?![1-6]{0,1}\d\.))/i
+        ],
+        [MODEL, [VENDOR, SONY], [TYPE, MOBILE]],
+        [
+          /sony tablet [ps]/i,
+          /\b(?:sony)?sgp\w+(?: bui|\))/i
+        ],
+        [[MODEL, "Xperia Tablet"], [VENDOR, SONY], [TYPE, TABLET]],
+        [
+          / (kb2005|in20[12]5|be20[12][59])\b/i,
+          /(?:one)?(?:plus)? (a\d0\d\d)(?: b|\))/i
+        ],
+        [MODEL, [VENDOR, "OnePlus"], [TYPE, MOBILE]],
+        [
+          /(alexa)webm/i,
+          /(kf[a-z]{2}wi)( bui|\))/i,
+          /(kf[a-z]+)( bui|\)).+silk\//i
+        ],
+        [MODEL, [VENDOR, AMAZON], [TYPE, TABLET]],
+        [
+          /((?:sd|kf)[0349hijorstuw]+)( bui|\)).+silk\//i
+        ],
+        [[MODEL, /(.+)/g, "Fire Phone $1"], [VENDOR, AMAZON], [TYPE, MOBILE]],
+        [
+          /(playbook);[-\w\),; ]+(rim)/i
+        ],
+        [MODEL, VENDOR, [TYPE, TABLET]],
+        [
+          /\b((?:bb[a-f]|st[hv])100-\d)/i,
+          /\(bb10; (\w+)/i
+        ],
+        [MODEL, [VENDOR, BLACKBERRY], [TYPE, MOBILE]],
+        [
+          /(?:\b|asus_)(transfo[prime ]{4,10} \w+|eeepc|slider \w+|nexus 7|padfone|p00[cj])/i
+        ],
+        [MODEL, [VENDOR, ASUS], [TYPE, TABLET]],
+        [
+          / (z[bes]6[027][012][km][ls]|zenfone \d\w?)\b/i
+        ],
+        [MODEL, [VENDOR, ASUS], [TYPE, MOBILE]],
+        [
+          /(nexus 9)/i
+        ],
+        [MODEL, [VENDOR, "HTC"], [TYPE, TABLET]],
+        [
+          /(htc)[-;_ ]{1,2}([\w ]+(?=\)| bui)|\w+)/i,
+          /(zte)[- ]([\w ]+?)(?: bui|\/|\))/i,
+          /(alcatel|geeksphone|nexian|panasonic|sony(?!-bra))[-_ ]?([-\w]*)/i
+        ],
+        [VENDOR, [MODEL, /_/g, " "], [TYPE, MOBILE]],
+        [
+          /droid.+; ([ab][1-7]-?[0178a]\d\d?)/i
+        ],
+        [MODEL, [VENDOR, "Acer"], [TYPE, TABLET]],
+        [
+          /droid.+; (m[1-5] note) bui/i,
+          /\bmz-([-\w]{2,})/i
+        ],
+        [MODEL, [VENDOR, "Meizu"], [TYPE, MOBILE]],
+        [
+          /\b(sh-?[altvz]?\d\d[a-ekm]?)/i
+        ],
+        [MODEL, [VENDOR, SHARP], [TYPE, MOBILE]],
+        [
+          /(blackberry|benq|palm(?=\-)|sonyericsson|acer|asus|dell|meizu|motorola|polytron)[-_ ]?([-\w]*)/i,
+          /(hp) ([\w ]+\w)/i,
+          /(asus)-?(\w+)/i,
+          /(microsoft); (lumia[\w ]+)/i,
+          /(lenovo)[-_ ]?([-\w]+)/i,
+          /(jolla)/i,
+          /(oppo) ?([\w ]+) bui/i
+        ],
+        [VENDOR, MODEL, [TYPE, MOBILE]],
+        [
+          /(archos) (gamepad2?)/i,
+          /(hp).+(touchpad(?!.+tablet)|tablet)/i,
+          /(kindle)\/([\w\.]+)/i,
+          /(nook)[\w ]+build\/(\w+)/i,
+          /(dell) (strea[kpr\d ]*[\dko])/i,
+          /(le[- ]+pan)[- ]+(\w{1,9}) bui/i,
+          /(trinity)[- ]*(t\d{3}) bui/i,
+          /(gigaset)[- ]+(q\w{1,9}) bui/i,
+          /(vodafone) ([\w ]+)(?:\)| bui)/i
+        ],
+        [VENDOR, MODEL, [TYPE, TABLET]],
+        [
+          /(surface duo)/i
+        ],
+        [MODEL, [VENDOR, MICROSOFT], [TYPE, TABLET]],
+        [
+          /droid [\d\.]+; (fp\du?)(?: b|\))/i
+        ],
+        [MODEL, [VENDOR, "Fairphone"], [TYPE, MOBILE]],
+        [
+          /(u304aa)/i
+        ],
+        [MODEL, [VENDOR, "AT&T"], [TYPE, MOBILE]],
+        [
+          /\bsie-(\w*)/i
+        ],
+        [MODEL, [VENDOR, "Siemens"], [TYPE, MOBILE]],
+        [
+          /\b(rct\w+) b/i
+        ],
+        [MODEL, [VENDOR, "RCA"], [TYPE, TABLET]],
+        [
+          /\b(venue[\d ]{2,7}) b/i
+        ],
+        [MODEL, [VENDOR, "Dell"], [TYPE, TABLET]],
+        [
+          /\b(q(?:mv|ta)\w+) b/i
+        ],
+        [MODEL, [VENDOR, "Verizon"], [TYPE, TABLET]],
+        [
+          /\b(?:barnes[& ]+noble |bn[rt])([\w\+ ]*) b/i
+        ],
+        [MODEL, [VENDOR, "Barnes & Noble"], [TYPE, TABLET]],
+        [
+          /\b(tm\d{3}\w+) b/i
+        ],
+        [MODEL, [VENDOR, "NuVision"], [TYPE, TABLET]],
+        [
+          /\b(k88) b/i
+        ],
+        [MODEL, [VENDOR, "ZTE"], [TYPE, TABLET]],
+        [
+          /\b(nx\d{3}j) b/i
+        ],
+        [MODEL, [VENDOR, "ZTE"], [TYPE, MOBILE]],
+        [
+          /\b(gen\d{3}) b.+49h/i
+        ],
+        [MODEL, [VENDOR, "Swiss"], [TYPE, MOBILE]],
+        [
+          /\b(zur\d{3}) b/i
+        ],
+        [MODEL, [VENDOR, "Swiss"], [TYPE, TABLET]],
+        [
+          /\b((zeki)?tb.*\b) b/i
+        ],
+        [MODEL, [VENDOR, "Zeki"], [TYPE, TABLET]],
+        [
+          /\b([yr]\d{2}) b/i,
+          /\b(dragon[- ]+touch |dt)(\w{5}) b/i
+        ],
+        [[VENDOR, "Dragon Touch"], MODEL, [TYPE, TABLET]],
+        [
+          /\b(ns-?\w{0,9}) b/i
+        ],
+        [MODEL, [VENDOR, "Insignia"], [TYPE, TABLET]],
+        [
+          /\b((nxa|next)-?\w{0,9}) b/i
+        ],
+        [MODEL, [VENDOR, "NextBook"], [TYPE, TABLET]],
+        [
+          /\b(xtreme\_)?(v(1[045]|2[015]|[3469]0|7[05])) b/i
+        ],
+        [[VENDOR, "Voice"], MODEL, [TYPE, MOBILE]],
+        [
+          /\b(lvtel\-)?(v1[12]) b/i
+        ],
+        [[VENDOR, "LvTel"], MODEL, [TYPE, MOBILE]],
+        [
+          /\b(ph-1) /i
+        ],
+        [MODEL, [VENDOR, "Essential"], [TYPE, MOBILE]],
+        [
+          /\b(v(100md|700na|7011|917g).*\b) b/i
+        ],
+        [MODEL, [VENDOR, "Envizen"], [TYPE, TABLET]],
+        [
+          /\b(trio[-\w\. ]+) b/i
+        ],
+        [MODEL, [VENDOR, "MachSpeed"], [TYPE, TABLET]],
+        [
+          /\btu_(1491) b/i
+        ],
+        [MODEL, [VENDOR, "Rotor"], [TYPE, TABLET]],
+        [
+          /(shield[\w ]+) b/i
+        ],
+        [MODEL, [VENDOR, "Nvidia"], [TYPE, TABLET]],
+        [
+          /(sprint) (\w+)/i
+        ],
+        [VENDOR, MODEL, [TYPE, MOBILE]],
+        [
+          /(kin\.[onetw]{3})/i
+        ],
+        [[MODEL, /\./g, " "], [VENDOR, MICROSOFT], [TYPE, MOBILE]],
+        [
+          /droid.+; (cc6666?|et5[16]|mc[239][23]x?|vc8[03]x?)\)/i
+        ],
+        [MODEL, [VENDOR, ZEBRA], [TYPE, TABLET]],
+        [
+          /droid.+; (ec30|ps20|tc[2-8]\d[kx])\)/i
+        ],
+        [MODEL, [VENDOR, ZEBRA], [TYPE, MOBILE]],
+        [
+          /(ouya)/i,
+          /(nintendo) ([wids3utch]+)/i
+        ],
+        [VENDOR, MODEL, [TYPE, CONSOLE]],
+        [
+          /droid.+; (shield) bui/i
+        ],
+        [MODEL, [VENDOR, "Nvidia"], [TYPE, CONSOLE]],
+        [
+          /(playstation [345portablevi]+)/i
+        ],
+        [MODEL, [VENDOR, SONY], [TYPE, CONSOLE]],
+        [
+          /\b(xbox(?: one)?(?!; xbox))[\); ]/i
+        ],
+        [MODEL, [VENDOR, MICROSOFT], [TYPE, CONSOLE]],
+        [
+          /smart-tv.+(samsung)/i
+        ],
+        [VENDOR, [TYPE, SMARTTV]],
+        [
+          /hbbtv.+maple;(\d+)/i
+        ],
+        [[MODEL, /^/, "SmartTV"], [VENDOR, SAMSUNG], [TYPE, SMARTTV]],
+        [
+          /(nux; netcast.+smarttv|lg (netcast\.tv-201\d|android tv))/i
+        ],
+        [[VENDOR, LG], [TYPE, SMARTTV]],
+        [
+          /(apple) ?tv/i
+        ],
+        [VENDOR, [MODEL, APPLE + " TV"], [TYPE, SMARTTV]],
+        [
+          /crkey/i
+        ],
+        [[MODEL, CHROME + "cast"], [VENDOR, GOOGLE], [TYPE, SMARTTV]],
+        [
+          /droid.+aft(\w)( bui|\))/i
+        ],
+        [MODEL, [VENDOR, AMAZON], [TYPE, SMARTTV]],
+        [
+          /\(dtv[\);].+(aquos)/i,
+          /(aquos-tv[\w ]+)\)/i
+        ],
+        [MODEL, [VENDOR, SHARP], [TYPE, SMARTTV]],
+        [
+          /(bravia[\w ]+)( bui|\))/i
+        ],
+        [MODEL, [VENDOR, SONY], [TYPE, SMARTTV]],
+        [
+          /(mitv-\w{5}) bui/i
+        ],
+        [MODEL, [VENDOR, XIAOMI], [TYPE, SMARTTV]],
+        [
+          /\b(roku)[\dx]*[\)\/]((?:dvp-)?[\d\.]*)/i,
+          /hbbtv\/\d+\.\d+\.\d+ +\([\w ]*; *(\w[^;]*);([^;]*)/i
+        ],
+        [[VENDOR, trim], [MODEL, trim], [TYPE, SMARTTV]],
+        [
+          /\b(android tv|smart[- ]?tv|opera tv|tv; rv:)\b/i
+        ],
+        [[TYPE, SMARTTV]],
+        [
+          /((pebble))app/i
+        ],
+        [VENDOR, MODEL, [TYPE, WEARABLE]],
+        [
+          /droid.+; (glass) \d/i
+        ],
+        [MODEL, [VENDOR, GOOGLE], [TYPE, WEARABLE]],
+        [
+          /droid.+; (wt63?0{2,3})\)/i
+        ],
+        [MODEL, [VENDOR, ZEBRA], [TYPE, WEARABLE]],
+        [
+          /(quest( 2)?)/i
+        ],
+        [MODEL, [VENDOR, FACEBOOK], [TYPE, WEARABLE]],
+        [
+          /(tesla)(?: qtcarbrowser|\/[-\w\.]+)/i
+        ],
+        [VENDOR, [TYPE, EMBEDDED]],
+        [
+          /droid .+?; ([^;]+?)(?: bui|\) applew).+? mobile safari/i
+        ],
+        [MODEL, [TYPE, MOBILE]],
+        [
+          /droid .+?; ([^;]+?)(?: bui|\) applew).+?(?! mobile) safari/i
+        ],
+        [MODEL, [TYPE, TABLET]],
+        [
+          /\b((tablet|tab)[;\/]|focus\/\d(?!.+mobile))/i
+        ],
+        [[TYPE, TABLET]],
+        [
+          /(phone|mobile(?:[;\/]| [ \w\/\.]*safari)|pda(?=.+windows ce))/i
+        ],
+        [[TYPE, MOBILE]],
+        [
+          /(android[-\w\. ]{0,9});.+buil/i
+        ],
+        [MODEL, [VENDOR, "Generic"]]
+      ],
+      engine: [
+        [
+          /windows.+ edge\/([\w\.]+)/i
+        ],
+        [VERSION, [NAME, EDGE + "HTML"]],
+        [
+          /webkit\/537\.36.+chrome\/(?!27)([\w\.]+)/i
+        ],
+        [VERSION, [NAME, "Blink"]],
+        [
+          /(presto)\/([\w\.]+)/i,
+          /(webkit|trident|netfront|netsurf|amaya|lynx|w3m|goanna)\/([\w\.]+)/i,
+          /ekioh(flow)\/([\w\.]+)/i,
+          /(khtml|tasman|links)[\/ ]\(?([\w\.]+)/i,
+          /(icab)[\/ ]([23]\.[\d\.]+)/i
+        ],
+        [NAME, VERSION],
+        [
+          /rv\:([\w\.]{1,9})\b.+(gecko)/i
+        ],
+        [VERSION, NAME]
+      ],
+      os: [
+        [
+          /microsoft (windows) (vista|xp)/i
+        ],
+        [NAME, VERSION],
+        [
+          /(windows) nt 6\.2; (arm)/i,
+          /(windows (?:phone(?: os)?|mobile))[\/ ]?([\d\.\w ]*)/i,
+          /(windows)[\/ ]?([ntce\d\. ]+\w)(?!.+xbox)/i
+        ],
+        [NAME, [VERSION, strMapper, windowsVersionMap]],
+        [
+          /(win(?=3|9|n)|win 9x )([nt\d\.]+)/i
+        ],
+        [[NAME, "Windows"], [VERSION, strMapper, windowsVersionMap]],
+        [
+          /ip[honead]{2,4}\b(?:.*os ([\w]+) like mac|; opera)/i,
+          /cfnetwork\/.+darwin/i
+        ],
+        [[VERSION, /_/g, "."], [NAME, "iOS"]],
+        [
+          /(mac os x) ?([\w\. ]*)/i,
+          /(macintosh|mac_powerpc\b)(?!.+haiku)/i
+        ],
+        [[NAME, "Mac OS"], [VERSION, /_/g, "."]],
+        [
+          /droid ([\w\.]+)\b.+(android[- ]x86|harmonyos)/i
+        ],
+        [VERSION, NAME],
+        [
+          /(android|webos|qnx|bada|rim tablet os|maemo|meego|sailfish)[-\/ ]?([\w\.]*)/i,
+          /(blackberry)\w*\/([\w\.]*)/i,
+          /(tizen|kaios)[\/ ]([\w\.]+)/i,
+          /\((series40);/i
+        ],
+        [NAME, VERSION],
+        [
+          /\(bb(10);/i
+        ],
+        [VERSION, [NAME, BLACKBERRY]],
+        [
+          /(?:symbian ?os|symbos|s60(?=;)|series60)[-\/ ]?([\w\.]*)/i
+        ],
+        [VERSION, [NAME, "Symbian"]],
+        [
+          /mozilla\/[\d\.]+ \((?:mobile|tablet|tv|mobile; [\w ]+); rv:.+ gecko\/([\w\.]+)/i
+        ],
+        [VERSION, [NAME, FIREFOX + " OS"]],
+        [
+          /web0s;.+rt(tv)/i,
+          /\b(?:hp)?wos(?:browser)?\/([\w\.]+)/i
+        ],
+        [VERSION, [NAME, "webOS"]],
+        [
+          /crkey\/([\d\.]+)/i
+        ],
+        [VERSION, [NAME, CHROME + "cast"]],
+        [
+          /(cros) [\w]+ ([\w\.]+\w)/i
+        ],
+        [[NAME, "Chromium OS"], VERSION],
+        [
+          /(nintendo|playstation) ([wids345portablevuch]+)/i,
+          /(xbox); +xbox ([^\);]+)/i,
+          /\b(joli|palm)\b ?(?:os)?\/?([\w\.]*)/i,
+          /(mint)[\/\(\) ]?(\w*)/i,
+          /(mageia|vectorlinux)[; ]/i,
+          /([kxln]?ubuntu|debian|suse|opensuse|gentoo|arch(?= linux)|slackware|fedora|mandriva|centos|pclinuxos|red ?hat|zenwalk|linpus|raspbian|plan 9|minix|risc os|contiki|deepin|manjaro|elementary os|sabayon|linspire)(?: gnu\/linux)?(?: enterprise)?(?:[- ]linux)?(?:-gnu)?[-\/ ]?(?!chrom|package)([-\w\.]*)/i,
+          /(hurd|linux) ?([\w\.]*)/i,
+          /(gnu) ?([\w\.]*)/i,
+          /\b([-frentopcghs]{0,5}bsd|dragonfly)[\/ ]?(?!amd|[ix346]{1,2}86)([\w\.]*)/i,
+          /(haiku) (\w+)/i
+        ],
+        [NAME, VERSION],
+        [
+          /(sunos) ?([\w\.\d]*)/i
+        ],
+        [[NAME, "Solaris"], VERSION],
+        [
+          /((?:open)?solaris)[-\/ ]?([\w\.]*)/i,
+          /(aix) ((\d)(?=\.|\)| )[\w\.])*/i,
+          /\b(beos|os\/2|amigaos|morphos|openvms|fuchsia|hp-ux)/i,
+          /(unix) ?([\w\.]*)/i
+        ],
+        [NAME, VERSION]
+      ]
+    };
+    var UAParser = function(ua, extensions) {
+      if (typeof ua === OBJ_TYPE) {
+        extensions = ua;
+        ua = undefined$1;
+      }
+      if (!(this instanceof UAParser)) {
+        return new UAParser(ua, extensions).getResult();
+      }
+      var _ua = ua || (typeof window2 !== UNDEF_TYPE && window2.navigator && window2.navigator.userAgent ? window2.navigator.userAgent : EMPTY);
+      var _rgxmap = extensions ? extend(regexes, extensions) : regexes;
+      this.getBrowser = function() {
+        var _browser = {};
+        _browser[NAME] = undefined$1;
+        _browser[VERSION] = undefined$1;
+        rgxMapper.call(_browser, _ua, _rgxmap.browser);
+        _browser.major = majorize(_browser.version);
+        return _browser;
+      };
+      this.getCPU = function() {
+        var _cpu = {};
+        _cpu[ARCHITECTURE] = undefined$1;
+        rgxMapper.call(_cpu, _ua, _rgxmap.cpu);
+        return _cpu;
+      };
+      this.getDevice = function() {
+        var _device = {};
+        _device[VENDOR] = undefined$1;
+        _device[MODEL] = undefined$1;
+        _device[TYPE] = undefined$1;
+        rgxMapper.call(_device, _ua, _rgxmap.device);
+        return _device;
+      };
+      this.getEngine = function() {
+        var _engine = {};
+        _engine[NAME] = undefined$1;
+        _engine[VERSION] = undefined$1;
+        rgxMapper.call(_engine, _ua, _rgxmap.engine);
+        return _engine;
+      };
+      this.getOS = function() {
+        var _os = {};
+        _os[NAME] = undefined$1;
+        _os[VERSION] = undefined$1;
+        rgxMapper.call(_os, _ua, _rgxmap.os);
+        return _os;
+      };
+      this.getResult = function() {
+        return {
+          ua: this.getUA(),
+          browser: this.getBrowser(),
+          engine: this.getEngine(),
+          os: this.getOS(),
+          device: this.getDevice(),
+          cpu: this.getCPU()
+        };
+      };
+      this.getUA = function() {
+        return _ua;
+      };
+      this.setUA = function(ua2) {
+        _ua = typeof ua2 === STR_TYPE && ua2.length > UA_MAX_LENGTH ? trim(ua2, UA_MAX_LENGTH) : ua2;
+        return this;
+      };
+      this.setUA(_ua);
+      return this;
+    };
+    UAParser.VERSION = LIBVERSION;
+    UAParser.BROWSER = enumerize([NAME, VERSION, MAJOR]);
+    UAParser.CPU = enumerize([ARCHITECTURE]);
+    UAParser.DEVICE = enumerize([MODEL, VENDOR, TYPE, CONSOLE, MOBILE, SMARTTV, TABLET, WEARABLE, EMBEDDED]);
+    UAParser.ENGINE = UAParser.OS = enumerize([NAME, VERSION]);
+    {
+      if (module2.exports) {
+        exports2 = module2.exports = UAParser;
+      }
+      exports2.UAParser = UAParser;
+    }
+    var $ = typeof window2 !== UNDEF_TYPE && (window2.jQuery || window2.Zepto);
+    if ($ && !$.ua) {
+      var parser = new UAParser();
+      $.ua = parser.getResult();
+      $.ua.get = function() {
+        return parser.getUA();
+      };
+      $.ua.set = function(ua) {
+        parser.setUA(ua);
+        var result = parser.getResult();
+        for (var prop in result) {
+          $.ua[prop] = result[prop];
+        }
+      };
+    }
+  })(typeof window === "object" ? window : commonjsGlobal);
+})(uaParser, uaParser.exports);
+var __defProp2 = Object.defineProperty;
+var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField2 = (obj, key, value) => {
+  __defNormalProp2(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+const Browser = {
+  UNKNOWN: "Unknown",
+  SAFARI: "Safari",
+  FIREFOX: "Firefox",
+  OPERA: "Opera",
+  CHROME: "Chrome",
+  IOS_WEBVIEW: "iOS-webview"
+};
+class BrowserUtils {
+  static getName() {
+    if (!this._name) {
+      if (typeof navigator === "undefined" || !navigator) {
+        this._name = Browser.UNKNOWN;
+      } else {
+        const { userAgent } = navigator;
+        if (userAgent.match(/Firefox/i)) {
+          this._name = Browser.FIREFOX;
+        } else if (userAgent.match(/(Opera|OPR)/i)) {
+          this._name = Browser.OPERA;
+        } else if (userAgent.match(/Chrome/i)) {
+          this._name = Browser.CHROME;
+        } else if (userAgent.match(/Safari/i)) {
+          this._name = Browser.SAFARI;
+        } else if (userAgent.match(/(iPhone|iPod|iPad).*AppleWebKit(?!.*Version)/i)) {
+          this._name = Browser.IOS_WEBVIEW;
+        } else {
+          this._name = Browser.UNKNOWN;
+        }
       }
-      throw Error("Level of: " + this.coords.toString() + " cannot be decided");
     }
+    return this._name;
   }
-  _inferNodeLevelByNeighboors() {
-    const { level } = this.coords;
-    if (level === null || !Level.isRange(level)) {
-      return true;
+  static get isMobile() {
+    if (this._isMobile === null) {
+      this._isMobile = false;
+      if (typeof navigator !== "undefined" && navigator) {
+        const userAgent = navigator.userAgent || navigator.vendor;
+        if (userAgent && (/(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino|android|ipad|playbook|silk/i.test(userAgent) || /1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc\-s|devi|dica|dmob|do(c|p)o|ds(12|\-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(\-|_)|g1 u|g560|gene|gf\-5|g\-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd\-(m|p|t)|hei\-|hi(pt|ta)|hp( i|ip)|hs\-c|ht(c(\-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i\-(20|go|ma)|i230|iac( |\-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc\-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|\-[a-w])|libw|lynx|m1\-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m\-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(\-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)\-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|\-([1-8]|c))|phil|pire|pl(ay|uc)|pn\-2|po(ck|rt|se)|prox|psio|pt\-g|qa\-a|qc(07|12|21|32|60|\-[2-7]|i\-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h\-|oo|p\-)|sdk\/|se(c(\-|0|1)|47|mc|nd|ri)|sgh\-|shar|sie(\-|m)|sk\-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h\-|v\-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl\-|tdg\-|tel(i|m)|tim\-|t\-mo|to(pl|sh)|ts(70|m\-|m3|m5)|tx\-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|\-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(\-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas\-|your|zeto|zte\-/i.test(userAgent.substr(0, 4)))) {
+          this._isMobile = true;
+        }
+      }
     }
-    let tmpLevel = null;
-    for (let i = 0; i < this.edges.length; i++) {
-      const edge = this.edges[i];
-      const otherNode = edge.node1 === this ? edge.node2 : edge.node1;
-      tmpLevel = Level.union(otherNode.coords.level, tmpLevel);
+    return this._isMobile;
+  }
+  static clearCache() {
+    this._name = null;
+    this._isMobile = null;
+  }
+}
+__publicField2(BrowserUtils, "_name", null);
+__publicField2(BrowserUtils, "_isMobile", null);
+const _GraphVertex = class {
+  constructor(params = {}) {
+    __publicField2(this, "name", null);
+    __publicField2(this, "data", null);
+    __publicField2(this, "id");
+    __publicField2(this, "edges", []);
+    Object.assign(this, params);
+    if (typeof params.id === "number") {
+      this.id = params.id;
+      GraphEdge.currentUniqueId = Math.max(GraphEdge.currentUniqueId, params.id + 1);
+    } else {
+      this.id = _GraphVertex.currentUniqueId++;
     }
-    if (tmpLevel === null || !Level.isRange(tmpLevel)) {
-      this.coords.level = tmpLevel === level[0] ? level[1] : level[0];
+  }
+};
+let GraphVertex = _GraphVertex;
+__publicField2(GraphVertex, "currentUniqueId", 0);
+const _GraphEdge = class {
+  constructor(vertex1, vertex2, params = {}) {
+    __publicField2(this, "name", null);
+    __publicField2(this, "data", null);
+    __publicField2(this, "id");
+    __publicField2(this, "_vertex1");
+    __publicField2(this, "_vertex2");
+    Object.assign(this, params);
+    this.vertex1 = vertex1;
+    this.vertex2 = vertex2;
+    if (typeof params.id === "number") {
+      this.id = params.id;
+      _GraphEdge.currentUniqueId = Math.max(_GraphEdge.currentUniqueId, params.id + 1);
+    } else {
+      this.id = GraphVertex.currentUniqueId++;
     }
-    return true;
   }
-  _checkIO() {
-    this.io = this.coords.level !== null && this.edges.some((edge) => edge.level === null);
-    return true;
+  get vertex1() {
+    return this._vertex1;
   }
-  static generateNodesLevels(nodes) {
-    nodes.forEach((node) => node._generateLevelFromEdges());
-    nodes.forEach((node) => node._inferNodeLevelByNeighboors());
-    nodes.forEach((node) => node._inferNodeLevelByRecursion());
-    nodes.forEach((node) => node._checkIO());
+  set vertex1(vertex) {
+    if (this._vertex1 && this._vertex2 !== this._vertex1) {
+      this._vertex1.edges = this._vertex1.edges.filter((edge) => edge !== this);
+    }
+    vertex.edges.push(this);
+    this._vertex1 = vertex;
+  }
+  get vertex2() {
+    return this._vertex2;
+  }
+  set vertex2(vertex) {
+    if (this._vertex2 && this._vertex2 !== this._vertex1) {
+      this._vertex2.edges = this._vertex2.edges.filter((edge) => edge !== this);
+    }
+    vertex.edges.push(this);
+    this._vertex2 = vertex;
+  }
+  static getEdgeByVertices(edges, vertex1, vertex2) {
+    return edges.find(
+      (edge) => vertex1 === edge.vertex1 && vertex2 === edge.vertex2 || vertex2 === edge.vertex1 && vertex1 === edge.vertex2
+    );
+  }
+};
+let GraphEdge = _GraphEdge;
+__publicField2(GraphEdge, "currentUniqueId", 0);
+class Graph {
+  constructor(vertices, edges) {
+    __publicField2(this, "vertices");
+    __publicField2(this, "edges");
+    this.vertices = Array.isArray(vertices) ? vertices : [];
+    this.edges = Array.isArray(edges) ? edges : [];
+  }
+  getEdgeByVertices(vertex1, vertex2) {
+    return GraphEdge.getEdgeByVertices(this.edges, vertex1, vertex2);
+  }
+  getVertexByName(name) {
+    return this.vertices.find((vertex) => vertex.name === name);
+  }
+  getEdgeByName(name) {
+    return this.edges.find((edge) => edge.name === name);
+  }
+  toDetailedString() {
+    let output = `--- Network ---
+Vertices: ${this.vertices.length}
+Edges: ${this.edges.length}
+---
+Vertices
+`;
+    this.vertices.forEach((vertex) => {
+      output += `${vertex.id} [edges: ${vertex.edges.length}]
+`;
+    });
+    output += "---\nEdges\n";
+    this.edges.forEach((edge) => {
+      output += `${edge.id} `;
+      output += `[${edge.vertex1.id} -- ${edge.vertex2.id}]
+`;
+    });
+    output += "---";
+    return output;
   }
 }
-class GraphEdge {
-  constructor(node1, node2, level = null, builtFrom = null) {
-    __publicField(this, "_node1");
-    __publicField(this, "_node2");
+class GeoGraphEdge extends GraphEdge {
+  constructor(vertex1, vertex2, params) {
+    super(vertex1, vertex2, params);
     __publicField(this, "_level", null);
     __publicField(this, "_bearing", null);
     __publicField(this, "_length", null);
     __publicField(this, "_computedSizeAndBearing", false);
-    __publicField(this, "builtFrom");
     __publicField(this, "isOneway", false);
-    this.node1 = node1;
-    this.node2 = node2;
-    this.level = level;
-    this.builtFrom = builtFrom;
-  }
-  get node1() {
-    return this._node1;
+    Object.assign(this, params);
   }
-  set node1(node) {
-    if (!(node instanceof GraphNode)) {
-      throw new TypeError("node1 is not a GraphNode");
-    }
-    if (this._node1 instanceof GraphNode && this._node2 !== this._node1) {
-      this._node1.edges = this._node1.edges.filter((edge) => edge !== this);
-    }
-    node.edges.push(this);
-    this._node1 = node;
+  set vertex1(vertex) {
+    super.vertex1 = vertex;
     this._computedSizeAndBearing = false;
   }
-  get node2() {
-    return this._node2;
+  get vertex1() {
+    return this._vertex1;
   }
-  set node2(node) {
-    if (!(node instanceof GraphNode)) {
-      throw new TypeError("node2 is not a GraphNode");
-    }
-    if (this._node2 instanceof GraphNode && this._node2 !== this._node1) {
-      this._node2.edges = this._node2.edges.filter((edge) => edge !== this);
-    }
-    node.edges.push(this);
-    this._node2 = node;
+  set vertex2(vertex) {
+    super.vertex2 = vertex;
     this._computedSizeAndBearing = false;
   }
+  get vertex2() {
+    return this._vertex2;
+  }
   get level() {
     return this._level;
   }
@@ -1263,154 +2236,206 @@ class GraphEdge {
     return this._length;
   }
   _computeSizeAndBearing() {
-    this._length = this.node1.distanceTo(this.node2);
-    this._bearing = this.node1.bearingTo(this.node2);
+    this._length = this.vertex1.distanceTo(this.vertex2);
+    this._bearing = this.vertex1.bearingTo(this.vertex2);
     this._computedSizeAndBearing = true;
   }
-  equals(other) {
-    if (this === other) {
+  static getEdgeByVertices(edges, vertex1, vertex2) {
+    return super.getEdgeByVertices(edges, vertex1, vertex2);
+  }
+}
+class GeoGraphVertex extends GraphVertex {
+  constructor(coords, params) {
+    super(params);
+    __publicField(this, "coords");
+    __publicField(this, "io", false);
+    this.coords = coords;
+  }
+  distanceTo(other) {
+    return this.coords.distanceTo(other.coords);
+  }
+  bearingTo(other) {
+    return this.coords.bearingTo(other.coords);
+  }
+  toJson() {
+    return this.coords.toCompressedJson();
+  }
+  static fromJson(json) {
+    return new GeoGraphVertex(Coordinates.fromCompressedJson(json));
+  }
+  inferVertexLevelFromEdges() {
+    let tmpLevel = null;
+    for (let i = 0; i < this.edges.length; i++) {
+      const edge = this.edges[i];
+      if (edge.level !== null) {
+        if (tmpLevel === null) {
+          tmpLevel = Level.clone(edge.level);
+        } else {
+          tmpLevel = Level.intersection(tmpLevel, edge.level);
+          if (tmpLevel === null) {
+            throw Error("Something bad happend during parsing: We cannot retrieve vertex level from adjacent ways: " + this.coords);
+          }
+        }
+      }
+    }
+    this.coords.level = tmpLevel;
+  }
+  inferVertexLevelByNeighboors() {
+    const { level } = this.coords;
+    if (level === null || !Level.isRange(level)) {
       return true;
     }
-    if (!(other instanceof GraphEdge)) {
-      return false;
+    let tmpLevel = null;
+    for (let i = 0; i < this.edges.length; i++) {
+      const edge = this.edges[i];
+      const otherVertex = edge.vertex1 === this ? edge.vertex2 : edge.vertex1;
+      tmpLevel = Level.union(otherVertex.coords.level, tmpLevel);
     }
-    return other.node1.equals(this.node1) && other.node2.equals(this.node2) && Level.equals(other.level, this.level) && other.isOneway === this.isOneway && other.builtFrom === this.builtFrom;
+    if (tmpLevel === null || !Level.isRange(tmpLevel)) {
+      this.coords.level = tmpLevel === level[0] ? level[1] : level[0];
+    }
+    return true;
   }
-  clone() {
-    const edge = new GraphEdge(this.node1, this.node2, this.level, this.builtFrom);
-    edge.isOneway = this.isOneway;
-    return edge;
+  inferVertexLevelByRecursion() {
+    const { level } = this.coords;
+    if (level === null || !Level.isRange(level)) {
+      return;
+    }
+    if (this.edges.length > 1) {
+      return;
+    }
+    const lookForLevel = (vertex, visitedVertices) => {
+      visitedVertices.push(vertex);
+      if (vertex.coords.level === null) {
+        return null;
+      }
+      if (!Level.isRange(vertex.coords.level)) {
+        return vertex.coords.level;
+      }
+      let tmpLevel = null;
+      for (let i = 0; i < vertex.edges.length; i++) {
+        const edge = vertex.edges[i];
+        const otherVertex = edge.vertex1 === vertex ? edge.vertex2 : edge.vertex1;
+        if (!visitedVertices.includes(otherVertex)) {
+          tmpLevel = Level.union(lookForLevel(otherVertex, visitedVertices), tmpLevel);
+        }
+      }
+      return tmpLevel;
+    };
+    const othersLevels = lookForLevel(this, []);
+    if (othersLevels !== null) {
+      if (!Level.isRange(othersLevels)) {
+        this.coords.level = othersLevels === level[0] ? level[1] : level[0];
+        return;
+      }
+      throw Error("Level of: " + this.coords.toString() + " cannot be decided");
+    }
   }
 }
-function getEdgeByNodes(edges, node1, node2) {
-  return edges.find(
-    (edge) => node1 === edge.node1 && node2 === edge.node2 || node2 === edge.node1 && node1 === edge.node2
-  );
-}
-function getNodeByCoords(nodes, coords) {
-  return nodes.find((node) => node.coords.equals(coords));
-}
-const GraphUtils = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  getEdgeByNodes,
-  getNodeByCoords
-}, Symbol.toStringTag, { value: "Module" }));
-class Network {
-  constructor(nodes, edges) {
-    __publicField(this, "nodes");
-    __publicField(this, "edges");
-    this.nodes = Array.isArray(nodes) ? nodes : [];
-    this.edges = Array.isArray(edges) ? edges : [];
+class GeoGraph extends Graph {
+  constructor(vertices, edges, generateVerticesLevels = false) {
+    super(vertices, edges);
+    generateVerticesLevels && this.generateVerticesLevels();
+  }
+  getVertexByCoords(coords) {
+    return GeoGraph.getVertexByCoords(this.vertices, coords);
+  }
+  static getVertexByCoords(vertices, coords) {
+    return vertices.find((vertex) => vertex.coords.equals(coords));
   }
-  getNodeByCoords(coords) {
-    return this.nodes.find((node) => node.coords.equals(coords));
+  getVertexByName(name) {
+    return super.getVertexByName(name);
   }
-  getEdgeByNodes(node1, node2) {
-    return getEdgeByNodes(this.edges, node1, node2);
+  getEdgeByName(name) {
+    return super.getEdgeByName(name);
   }
   getBoundingBox(extendedMeasure) {
-    if (!this.nodes.length) {
+    if (!this.vertices.length) {
       return null;
     }
-    const boundingBox = BoundingBox.fromCoordinates(this.nodes.map((node) => node.coords));
+    const boundingBox = BoundingBox.fromCoordinates(this.vertices.map((vertex) => vertex.coords));
     if (extendedMeasure) {
       boundingBox.extendsWithMeasure(extendedMeasure);
     }
     return boundingBox;
   }
-  toDetailedString(_nodeToStringFn, _edgeToStringFn) {
-    let nodeToStringFn = _nodeToStringFn;
-    if (!nodeToStringFn) {
-      nodeToStringFn = (node) => `${node.builtFrom}`;
-    }
-    let edgeToStringFn = _edgeToStringFn;
-    if (!_edgeToStringFn) {
-      edgeToStringFn = (edge) => `${edge.builtFrom}`;
-    }
-    let output = `--- Network ---
-Nodes: ${this.nodes.length}
-Edges: ${this.edges.length}
----
-Nodes
-`;
-    this.nodes.forEach((node) => {
-      output += `${nodeToStringFn(node)} [edges: ${node.edges.length}]
-`;
-    });
-    output += "---\nEdges\n";
-    this.edges.forEach((edge) => {
-      output += `${edgeToStringFn(edge)} `;
-      output += `[${nodeToStringFn(edge.node1)} -- ${nodeToStringFn(edge.node2)}]
-`;
-    });
-    output += "---";
-    return output;
-  }
   toCompressedJson() {
     return {
-      nodes: this.nodes.map((node) => node.toJson()),
+      vertices: this.vertices.map((vertex) => vertex.toJson()),
       edges: this.edges.map((edge) => {
-        const node1Idx = this.nodes.indexOf(edge.node1);
-        const node2Idx = this.nodes.indexOf(edge.node2);
+        const vertex1Idx = this.vertices.indexOf(edge.vertex1);
+        const vertex2Idx = this.vertices.indexOf(edge.vertex2);
         if (edge.isOneway) {
-          return [node1Idx, node2Idx, edge.level, true];
+          return [vertex1Idx, vertex2Idx, edge.level, true];
         }
-        if (edge.level) {
-          return [node1Idx, node2Idx, edge.level];
+        if (edge.level !== null) {
+          return [vertex1Idx, vertex2Idx, edge.level];
         }
-        return [node1Idx, node2Idx];
+        return [vertex1Idx, vertex2Idx];
       })
     };
   }
   static fromCompressedJson(json) {
-    const network = new Network();
-    network.nodes = json.nodes.map((node) => GraphNode.fromJson(node, null));
-    network.edges = json.edges.map((jsonEdge) => {
-      const edge = new GraphEdge(
-        network.nodes[jsonEdge[0]],
-        network.nodes[jsonEdge[1]],
-        jsonEdge[2],
-        null
+    const geograph = new GeoGraph();
+    geograph.vertices = json.vertices.map((vertex) => GeoGraphVertex.fromJson(vertex));
+    geograph.edges = json.edges.map((jsonEdge) => {
+      const edge = new GeoGraphEdge(
+        geograph.vertices[jsonEdge[0]],
+        geograph.vertices[jsonEdge[1]],
+        { level: jsonEdge.length > 2 ? jsonEdge[2] : null }
       );
       if (jsonEdge.length > 3 && jsonEdge[3]) {
         edge.isOneway = true;
       }
       return edge;
     });
-    return network;
+    return geograph;
   }
   static fromCoordinates(segments) {
-    const network = new Network();
-    const getOrCreateNode = (coords) => {
-      const node = network.nodes.find((otherNode) => otherNode.coords.equals(coords));
-      if (node) {
-        return node;
+    const geograph = new GeoGraph();
+    const getOrCreateVertex = (coords) => {
+      const vertex = geograph.vertices.find((otherVertex) => otherVertex.coords.equals(coords));
+      if (vertex) {
+        return vertex;
       }
-      const newNode = new GraphNode(coords, null);
-      network.nodes.push(newNode);
-      return newNode;
+      const newVertex = new GeoGraphVertex(coords);
+      geograph.vertices.push(newVertex);
+      return newVertex;
     };
-    const createEdgeFromNodes = (node1, node2) => new GraphEdge(node1, node2, Level.union(node1.coords.level, node2.coords.level), null);
+    const createEdgeFromVertices = (vertex1, vertex2) => new GeoGraphEdge(
+      vertex1,
+      vertex2,
+      { level: Level.union(vertex1.coords.level, vertex2.coords.level) }
+    );
     for (const segment of segments) {
-      let previousNode = null;
+      let previousVertex = null;
       for (const coords of segment) {
-        const currentNode = getOrCreateNode(coords);
-        if (previousNode) {
-          const edge = createEdgeFromNodes(currentNode, previousNode);
-          network.edges.push(edge);
+        const currentVertex = getOrCreateVertex(coords);
+        if (previousVertex) {
+          const edge = createEdgeFromVertices(currentVertex, previousVertex);
+          geograph.edges.push(edge);
         }
-        previousNode = currentNode;
+        previousVertex = currentVertex;
       }
     }
-    return network;
+    return geograph;
   }
   getEdgesAtLevel(targetLevel, useMultiLevelEdges = true) {
     return this.edges.filter(
       ({ level }) => useMultiLevelEdges ? Level.intersect(targetLevel, level) : Level.contains(targetLevel, level)
     );
   }
+  generateVerticesLevels() {
+    const { vertices } = this;
+    vertices.forEach((vertex) => vertex.inferVertexLevelFromEdges());
+    vertices.forEach((vertex) => vertex.inferVertexLevelByNeighboors());
+    vertices.forEach((vertex) => vertex.inferVertexLevelByRecursion());
+    vertices.forEach((vertex) => {
+      vertex.io = vertex.coords.level !== null && vertex.edges.some((edge) => edge.level === null);
+    });
+  }
 }
-class GraphProjection {
+class GeoGraphProjection {
   constructor(origin, distanceFromNearestElement, coords, nearestElement) {
     __publicField(this, "origin");
     __publicField(this, "distanceFromNearestElement");
@@ -1422,12 +2447,12 @@ class GraphProjection {
     this.nearestElement = nearestElement;
   }
 }
-const _MapMatching = class {
-  constructor(network = null) {
-    __publicField(this, "network", null);
+const _GeoGraphProjectionHandler = class {
+  constructor(graph = null) {
+    __publicField(this, "graph", null);
     __publicField(this, "_maxDistance", Number.MAX_VALUE);
     __publicField(this, "_maxAngleBearing", Math.PI);
-    this.network = network;
+    this.graph = graph;
   }
   set maxAngleBearing(maxAngleBearing) {
     this._maxAngleBearing = maxAngleBearing;
@@ -1446,18 +2471,18 @@ const _MapMatching = class {
       return [false, false, false];
     }
     let checkEdge = Level.intersect(location.level, edge.level);
-    let checkNode1 = Level.intersect(location.level, edge.node1.coords.level);
-    let checkNode2 = Level.intersect(location.level, edge.node2.coords.level);
-    checkNode1 = checkNode1 || edge.node1.io && location.level === null;
-    checkNode2 = checkNode2 || edge.node2.io && location.level === null;
+    let checkNode1 = Level.intersect(location.level, edge.vertex1.coords.level);
+    let checkNode2 = Level.intersect(location.level, edge.vertex2.coords.level);
+    checkNode1 = checkNode1 || edge.vertex1.io && location.level === null;
+    checkNode2 = checkNode2 || edge.vertex2.io && location.level === null;
     if (!useMultiLevelSegments) {
       checkEdge = checkEdge && !Level.isRange(edge.level);
-      checkNode1 = checkNode1 && !Level.isRange(edge.node1.coords.level);
-      checkNode2 = checkNode2 && !Level.isRange(edge.node2.coords.level);
+      checkNode1 = checkNode1 && !Level.isRange(edge.vertex1.coords.level);
+      checkNode2 = checkNode2 && !Level.isRange(edge.vertex2.coords.level);
     }
     if (useBearing) {
       if (checkEdge) {
-        const diffAngle = diffAngleLines(edge.bearing, location.bearing);
+        const diffAngle = maths.diffAngleLines(edge.bearing, location.bearing);
         if (diffAngle > this._maxAngleBearing) {
           checkEdge = false;
         }
@@ -1478,11 +2503,8 @@ const _MapMatching = class {
     }
   }
   getProjection(location, useDistance = false, useBearing = false, useMultiLevelSegments = true, acceptEdgeFn = () => true) {
-    if (this.network === null) {
-      throw new Error("Network has not been set yet");
-    }
-    if (!(location instanceof Coordinates)) {
-      throw new TypeError("location is not an instance of Coordinates");
+    if (this.graph === null) {
+      throw new Error("Graph has not been set yet");
     }
     if (useBearing && (!("bearing" in location && location.bearing !== null) || !this._maxAngleBearing)) {
       return null;
@@ -1493,7 +2515,7 @@ const _MapMatching = class {
     const isProjectionBetter = (distanceOfNewProjection) => {
       return distanceOfNewProjection < distanceFromNearestElement && (!useDistance || distanceOfNewProjection <= this._maxDistance);
     };
-    for (const edge of this.network.edges) {
+    for (const edge of this.graph.edges) {
       const [checkEdge, checkNode1, checkNode2] = this._shouldProjectOnEdgeAndNodes(
         edge,
         location,
@@ -1502,38 +2524,38 @@ const _MapMatching = class {
         acceptEdgeFn
       );
       if (checkNode1) {
-        const distNode1 = location.distanceTo(edge.node1.coords);
+        const distNode1 = location.distanceTo(edge.vertex1.coords);
         if (isProjectionBetter(distNode1) || distNode1 <= EPS_MM) {
           distanceFromNearestElement = distNode1;
-          nearestElement = edge.node1;
-          _MapMatching._assignLatLngLevel(edge.node1.coords, projection);
-          _MapMatching._handleLevelsWithIONodes(projection, location, edge.node1);
+          nearestElement = edge.vertex1;
+          _GeoGraphProjectionHandler._assignLatLngLevel(edge.vertex1.coords, projection);
+          _GeoGraphProjectionHandler._handleLevelsWithIONodes(projection, location, edge.vertex1);
           if (distNode1 <= EPS_MM) {
             break;
           }
         }
       }
       if (checkNode2) {
-        const distNode2 = location.distanceTo(edge.node2.coords);
+        const distNode2 = location.distanceTo(edge.vertex2.coords);
         if (isProjectionBetter(distNode2) || distNode2 <= EPS_MM) {
           distanceFromNearestElement = distNode2;
-          nearestElement = edge.node2;
-          _MapMatching._assignLatLngLevel(edge.node2.coords, projection);
-          _MapMatching._handleLevelsWithIONodes(projection, location, edge.node2);
+          nearestElement = edge.vertex2;
+          _GeoGraphProjectionHandler._assignLatLngLevel(edge.vertex2.coords, projection);
+          _GeoGraphProjectionHandler._handleLevelsWithIONodes(projection, location, edge.vertex2);
           if (distNode2 <= EPS_MM) {
             break;
           }
         }
       }
       if (checkEdge) {
-        const segmentProjection = location.getSegmentProjection(edge.node1.coords, edge.node2.coords);
+        const segmentProjection = location.getSegmentProjection(edge.vertex1.coords, edge.vertex2.coords);
         if (segmentProjection) {
           const distEdge = location.distanceTo(segmentProjection);
           if (isProjectionBetter(distEdge)) {
             distanceFromNearestElement = distEdge;
             nearestElement = edge;
-            _MapMatching._assignLatLngLevel(segmentProjection, projection);
-            _MapMatching._updateProjectionLevelFromEdge(edge, projection);
+            _GeoGraphProjectionHandler._assignLatLngLevel(segmentProjection, projection);
+            _GeoGraphProjectionHandler._updateProjectionLevelFromEdge(edge, projection);
           }
         }
       }
@@ -1544,7 +2566,7 @@ const _MapMatching = class {
     if (projection instanceof UserPosition && projection.accuracy !== null) {
       projection.accuracy += distanceFromNearestElement;
     }
-    return new GraphProjection(
+    return new GeoGraphProjection(
       location,
       distanceFromNearestElement,
       projection,
@@ -1552,74 +2574,59 @@ const _MapMatching = class {
     );
   }
 };
-let MapMatching = _MapMatching;
-__publicField(MapMatching, "_updateProjectionLevelFromEdge", (_edge, _projection) => {
+let GeoGraphProjectionHandler = _GeoGraphProjectionHandler;
+__publicField(GeoGraphProjectionHandler, "_updateProjectionLevelFromEdge", (_edge, _projection) => {
   _projection.level = Level.clone(_edge.level);
 });
-class GraphItinerary {
-  constructor(start, end, nodes, edges, edgesWeights) {
-    __publicField(this, "start");
-    __publicField(this, "end");
-    __publicField(this, "nodes");
-    __publicField(this, "edges");
-    __publicField(this, "edgesWeights");
+class GeoGraphItinerary extends GeoGraph {
+  constructor(start, end, vertices, edges, edgesWeights) {
+    super(vertices, edges);
     this.start = start;
     this.end = end;
-    this.nodes = nodes;
-    this.edges = edges;
     this.edgesWeights = edgesWeights;
   }
-  static fromNetworkNodes(start, end, networkNodes, edgesWeights) {
-    const nodes = networkNodes.map((node) => {
-      const newNode = node.clone();
-      newNode.edges = [];
-      if (newNode.io) {
-        newNode.coords = newNode.coords.clone();
-        newNode.coords.level = null;
-      }
-      return newNode;
+  static fromGraphVertices(start, end, networkVertices, edgesWeights) {
+    const vertices = networkVertices.map((vertex) => {
+      return new GeoGraphVertex(
+        vertex.coords.clone(),
+        { name: vertex.name, id: vertex.id, data: vertex.data, io: vertex.io }
+      );
     });
     const edges = [];
-    networkNodes.forEach((node, idx, arr) => {
+    networkVertices.forEach((vertex, idx, arr) => {
       if (idx === 0) {
         return;
       }
-      const prevNode = arr[idx - 1];
-      const edge = getEdgeByNodes(prevNode.edges, prevNode, node);
+      const prevVertex = arr[idx - 1];
+      const edge = GeoGraphEdge.getEdgeByVertices(prevVertex.edges, prevVertex, vertex);
       if (!edge) {
-        Logger.error("Cannot retrieve edge to create itinerary");
+        Logger__default.default.error("Cannot retrieve edge to create itinerary");
         return;
       }
-      const newEdge = new GraphEdge(
-        nodes[idx - 1],
-        nodes[idx],
-        edge.level,
-        edge.builtFrom
-      );
-      newEdge.isOneway = edge.isOneway;
-      edges.push(newEdge);
+      edges.push(new GeoGraphEdge(
+        vertices[idx - 1],
+        vertices[idx],
+        { name: edge.name, id: edge.id, data: edge.data, level: edge.level, isOneway: edge.isOneway }
+      ));
     });
-    return new GraphItinerary(start, end, nodes, edges, edgesWeights);
+    return new GeoGraphItinerary(start, end, vertices, edges, edgesWeights);
   }
 }
 class NoRouteFoundError extends Error {
-  constructor(start, end, details) {
+  constructor(start, end, details = null) {
     super();
-    __publicField(this, "details");
-    __publicField(this, "end");
-    __publicField(this, "start");
     this.start = start;
     this.end = end;
     this.details = details;
   }
   get startStr() {
-    if (this.start instanceof GraphNode) {
+    if (this.start instanceof GeoGraphVertex) {
       return `GraphNode ${this.start.coords.toString()}`;
     }
     return this.start.toString();
   }
   get endStr() {
-    if (this.end instanceof GraphNode) {
+    if (this.end instanceof GeoGraphVertex) {
       return `GraphNode ${this.end.coords.toString()}`;
     }
     return this.end.toString();
@@ -1632,159 +2639,142 @@ class NoRouteFoundError extends Error {
     return message;
   }
 }
-class GraphRouterOptions {
-  constructor() {
-    __publicField(this, "projectionMaxDistance", 50);
-    __publicField(this, "weightEdgeFn", (edge) => edge.length);
-    __publicField(this, "acceptEdgeFn", () => true);
-  }
-}
-class GraphRouter {
-  constructor(network) {
+const DEFAULT_OPTIONS = {
+  projectionMaxDistance: 50,
+  weightEdgeFn: (edge) => edge.length,
+  acceptEdgeFn: () => true
+};
+class GeoGraphRouter {
+  constructor(graph) {
     __publicField(this, "_mapMatching");
-    __publicField(this, "_network");
+    __publicField(this, "_graph");
     __publicField(this, "disabledEdges", /* @__PURE__ */ new Set());
-    this._network = network;
-    this._mapMatching = new MapMatching(network);
+    this._graph = graph;
+    this._mapMatching = new GeoGraphProjectionHandler(graph);
   }
-  getShortestPath(start, end, options = new GraphRouterOptions()) {
-    if (!(start instanceof GraphNode) && !(start instanceof Coordinates)) {
-      throw new Error("Unknown start type");
-    }
-    if (!(end instanceof GraphNode) && !(end instanceof Coordinates)) {
-      throw new Error("Unknown end type");
-    }
+  getShortestPath(start, end, options = DEFAULT_OPTIONS) {
     const { acceptEdgeFn, weightEdgeFn, projectionMaxDistance } = options;
     this._mapMatching.maxDistance = projectionMaxDistance;
-    const createdNodes = [];
-    const retrieveOrCreateNearestNode = (point) => {
-      if (point instanceof GraphNode) {
+    const createdVertices = [];
+    const retrieveOrCreateNearestVertex = (point) => {
+      if (point instanceof GeoGraphVertex) {
         return point;
       }
-      const closeNode = this._network.getNodeByCoords(point);
-      if (closeNode) {
-        return closeNode;
+      const closeVertex = this._graph.getVertexByCoords(point);
+      if (closeVertex) {
+        return closeVertex;
       }
       const proj = this._mapMatching.getProjection(point, true, false, false, acceptEdgeFn);
       if (!proj) {
-        let message = `Point ${point.toString()} is too far from the network > ${this._mapMatching.maxDistance.toFixed(0)} meters.`;
+        let message = `Point ${point.toString()} is too far from the graph > ${this._mapMatching.maxDistance.toFixed(0)} meters.`;
         if (point.level !== null) {
-          message += ` If it is a multi-level map, please verify if you have a network at level ${Level.toString(point.level)}.`;
+          message += ` If it is a multi-level map, please verify if you have a graph at level ${Level.toString(point.level)}.`;
         }
         throw new NoRouteFoundError(start, end, message);
       }
-      if (proj.nearestElement instanceof GraphNode) {
+      if (proj.nearestElement instanceof GeoGraphVertex) {
         return proj.nearestElement;
       }
-      const nodeCreated = this.createNodeInsideEdge(
+      const vertexCreated = this.createVertexInsideEdge(
         proj.nearestElement,
         proj.coords
       );
-      createdNodes.push(nodeCreated);
-      return nodeCreated;
+      createdVertices.push(vertexCreated);
+      return vertexCreated;
     };
-    const removeCreatedNodes = () => {
-      while (createdNodes.length) {
-        this.removeNodeFromPreviouslyCreatedEdge(createdNodes.pop());
+    const removeCreatedVertices = () => {
+      while (createdVertices.length) {
+        this.removeVertexFromPreviouslyCreatedEdge(createdVertices.pop());
       }
     };
-    const startNode = retrieveOrCreateNearestNode(start);
-    const endNode = retrieveOrCreateNearestNode(end);
-    const startCoords = start instanceof GraphNode ? start.coords : start;
-    const endCoords = end instanceof GraphNode ? end.coords : end;
+    const startVertex = retrieveOrCreateNearestVertex(start);
+    const endVertex = retrieveOrCreateNearestVertex(end);
+    const startCoords = start instanceof GeoGraphVertex ? start.coords : start;
+    const endCoords = end instanceof GeoGraphVertex ? end.coords : end;
     let graphItinerary;
-    if (startNode === endNode) {
-      graphItinerary = GraphItinerary.fromNetworkNodes(
+    if (startVertex === endVertex) {
+      graphItinerary = GeoGraphItinerary.fromGraphVertices(
         startCoords,
         endCoords,
-        [startNode],
+        [startVertex],
         []
       );
     } else {
-      graphItinerary = this.getShortestPathBetweenGraphNodes(
-        startNode,
-        endNode,
-        acceptEdgeFn,
-        weightEdgeFn
+      graphItinerary = this.getShortestPathBetweenGeoGraphVertices(
+        startVertex,
+        endVertex,
+        weightEdgeFn,
+        acceptEdgeFn
       );
     }
     graphItinerary.start = startCoords;
     graphItinerary.end = endCoords;
-    removeCreatedNodes();
-    if (!graphItinerary.nodes.length) {
+    removeCreatedVertices();
+    if (!graphItinerary.vertices.length) {
       throw new NoRouteFoundError(start, end);
     }
     return graphItinerary;
   }
-  createNodeInsideEdge(edge, point) {
-    const a = edge.node1;
-    const b = edge.node2;
-    const m = new GraphNode(point, edge.builtFrom);
-    m.coords.level = edge.level;
-    const u = edge.clone();
-    u.node1 = a;
-    u.node2 = m;
-    const v = edge.clone();
-    v.node1 = m;
-    v.node2 = b;
+  createVertexInsideEdge(edge, point) {
+    const a = edge.vertex1;
+    const b = edge.vertex2;
+    const m = new GeoGraphVertex(point, { name: `proj on ${edge.name || null} (tmp)` });
+    const newEdgesParams = { name: `splitted ${edge.name || null} (tmp)`, data: edge.data, isOneway: edge.isOneway, level: edge.level };
+    const u = new GeoGraphEdge(a, m, newEdgesParams);
+    const v = new GeoGraphEdge(m, b, newEdgesParams);
     a.edges = a.edges.filter((_edge) => _edge !== edge);
     b.edges = b.edges.filter((_edge) => _edge !== edge);
-    this._network.nodes.push(m);
-    this._network.edges.push(u, v);
-    this._network.edges = this._network.edges.filter(
+    this._graph.vertices.push(m);
+    this._graph.edges.push(u, v);
+    this._graph.edges = this._graph.edges.filter(
       (_edge) => _edge !== edge
     );
     return m;
   }
-  removeNodeFromPreviouslyCreatedEdge(_node) {
-    const u = _node.edges[0];
-    const v = _node.edges[1];
-    u.node1.edges = u.node1.edges.filter((edge) => edge !== u);
-    v.node1.edges = v.node1.edges.filter((edge) => edge !== v);
-    const oldEdge = u.clone();
-    oldEdge.node1 = u.node1;
-    oldEdge.node2 = v.node2;
-    this._network.edges.push(oldEdge);
-    this._network.nodes = this._network.nodes.filter((node) => node !== _node);
-    this._network.edges = this._network.edges.filter(
+  removeVertexFromPreviouslyCreatedEdge(_vertex) {
+    const u = _vertex.edges[0];
+    const v = _vertex.edges[1];
+    u.vertex1.edges = u.vertex1.edges.filter((edge) => edge !== u);
+    v.vertex1.edges = v.vertex1.edges.filter((edge) => edge !== v);
+    const oldEdgeName = u.name.substring("splitted ".length, u.name.length - " (tmp)".length);
+    const oldEdgeParams = { name: oldEdgeName, data: u.data, isOneway: u.isOneway, level: u.level };
+    const oldEdge = new GeoGraphEdge(u.vertex1, v.vertex2, oldEdgeParams);
+    this._graph.edges.push(oldEdge);
+    this._graph.vertices = this._graph.vertices.filter((vertex) => vertex !== _vertex);
+    this._graph.edges = this._graph.edges.filter(
       (edge) => edge !== u && edge !== v
     );
   }
-  getShortestPathBetweenGraphNodes(start, end, acceptEdgeFn, weightFn) {
-    const distanceMap = {}, checking = {}, vertexList = {}, vertexNodes = {}, parentVertices = {}, path = [];
-    let vertexId = 1;
-    this._network.nodes.forEach((vertex) => {
-      vertex.uniqueRouterId = vertexId;
-      vertexNodes[vertexId] = vertex;
-      distanceMap[vertexId] = Infinity;
-      checking[vertexId] = null;
-      vertexList[vertexId] = true;
-      vertexId++;
+  getShortestPathBetweenGeoGraphVertices(start, end, weightFn, acceptEdgeFn) {
+    const distanceMap = {}, checking = {}, vertexList = {}, vertices = {}, parentVertices = {}, path = [];
+    this._graph.vertices.forEach((vertex) => {
+      vertices[vertex.id] = vertex;
+      distanceMap[vertex.id] = Infinity;
+      checking[vertex.id] = null;
+      vertexList[vertex.id] = true;
     });
-    const startVertex = Object.values(vertexNodes).find((vertex) => start.equals(vertex));
-    const endVertex = Object.values(vertexNodes).find((vertex) => end.equals(vertex));
-    distanceMap[startVertex.uniqueRouterId] = 0;
+    distanceMap[start.id] = 0;
     while (Object.keys(vertexList).length > 0) {
       const keys = Object.keys(vertexList).map(Number);
       const current = Number(
-        keys.reduce((_checking, vertexId2) => {
-          return distanceMap[_checking] > distanceMap[vertexId2] ? vertexId2 : _checking;
+        keys.reduce((_checking, vertexId) => {
+          return distanceMap[_checking] > distanceMap[vertexId] ? vertexId : _checking;
         }, keys[0])
       );
-      this._network.edges.filter((edge) => {
-        if (!acceptEdgeFn(edge) || this.disabledEdges.has(edge)) {
+      this._graph.edges.filter((edge) => {
+        if (acceptEdgeFn && !acceptEdgeFn(edge) || this.disabledEdges.has(edge)) {
           return false;
         }
-        const from = edge.node1.uniqueRouterId, to = edge.node2.uniqueRouterId;
+        const from = edge.vertex1.id, to = edge.vertex2.id;
         return from === current || to === current;
       }).forEach((edge) => {
         let to, from, reversed = false;
-        if (edge.node1.uniqueRouterId === current) {
-          to = edge.node2.uniqueRouterId;
-          from = edge.node1.uniqueRouterId;
+        if (edge.vertex1.id === current) {
+          to = edge.vertex2.id;
+          from = edge.vertex1.id;
         } else {
-          to = edge.node1.uniqueRouterId;
-          from = edge.node2.uniqueRouterId;
+          to = edge.vertex1.id;
+          from = edge.vertex2.id;
           reversed = true;
         }
         if (edge.isOneway && reversed) {
@@ -1800,42 +2790,36 @@ class GraphRouter {
       delete vertexList[current];
     }
     const edgesWeights = [];
-    let endId = endVertex.uniqueRouterId;
-    while (parentVertices[endId]) {
-      path.unshift(vertexNodes[endId]);
+    let endId = end.id;
+    while (typeof parentVertices[endId] !== "undefined") {
+      path.unshift(vertices[endId]);
       edgesWeights.unshift(distanceMap[endId] - distanceMap[parentVertices[endId]]);
       endId = parentVertices[endId];
     }
     if (path.length !== 0) {
       path.unshift(start);
     }
-    this._network.nodes.forEach((vertex) => {
-      delete vertex.uniqueRouterId;
-    });
-    return GraphItinerary.fromNetworkNodes(start.coords, end.coords, path, edgesWeights);
+    return GeoGraphItinerary.fromGraphVertices(start.coords, end.coords, path, edgesWeights);
   }
 }
-export {
-  AbsoluteHeading,
-  Attitude,
-  BoundingBox,
-  Constants,
-  Coordinates,
-  GeoRef,
-  GeoRelativePosition,
-  GraphEdge,
-  GraphItinerary,
-  GraphNode,
-  GraphProjection,
-  GraphRouter,
-  GraphRouterOptions,
-  GraphUtils,
-  Level,
-  MapMatching,
-  Network,
-  NoRouteFoundError,
-  RelativePosition,
-  UserPosition,
-  Utils
-};
+__publicField(GeoGraphRouter, "DEFAULT_OPTIONS", DEFAULT_OPTIONS);
+exports.AbsoluteHeading = AbsoluteHeading;
+exports.Attitude = Attitude;
+exports.BoundingBox = BoundingBox;
+exports.Constants = Constants;
+exports.Coordinates = Coordinates;
+exports.GeoGraph = GeoGraph;
+exports.GeoGraphEdge = GeoGraphEdge;
+exports.GeoGraphItinerary = GeoGraphItinerary;
+exports.GeoGraphProjection = GeoGraphProjection;
+exports.GeoGraphProjectionHandler = GeoGraphProjectionHandler;
+exports.GeoGraphRouter = GeoGraphRouter;
+exports.GeoGraphVertex = GeoGraphVertex;
+exports.GeoRef = GeoRef;
+exports.GeoRelativePosition = GeoRelativePosition;
+exports.Level = Level;
+exports.NoRouteFoundError = NoRouteFoundError;
+exports.RelativePosition = RelativePosition;
+exports.UserPosition = UserPosition;
+exports.Utils = Utils;
 //# sourceMappingURL=index.js.map