@wemap/osm 10.11.2 → 11.0.0-alpha.0

package/dist/index.js

@@ -1,47 +1,38 @@
-"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;
-};
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const saxes = require("saxes");
-const geo = require("@wemap/geo");
-class OsmElement {
-  constructor(id, tags) {
-    __publicField(this, "id");
-    __publicField(this, "tags");
-    this.id = id;
-    this.tags = tags || {};
+var Jt = Object.defineProperty;
+var Kt = (s, t, e) => t in s ? Jt(s, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : s[t] = e;
+var M = (s, t, e) => (Kt(s, typeof t != "symbol" ? t + "" : t, e), e);
+class $t {
+  constructor(t, e) {
+    M(this, "id");
+    M(this, "tags");
+    this.id = t, this.tags = e || {};
   }
 }
-class OsmModel {
-  constructor(nodes, ways) {
-    __publicField(this, "nodes");
-    __publicField(this, "ways");
-    this.nodes = nodes || [];
-    this.ways = ways || [];
+class Zt {
+  constructor(t, e) {
+    M(this, "nodes");
+    M(this, "ways");
+    this.nodes = t || [], this.ways = e || [];
   }
-  getNodeById(id) {
-    return this.nodes.find((node) => node.id === id) || null;
+  getNodeById(t) {
+    return this.nodes.find((e) => e.id === t) || null;
   }
-  getNodeByName(name) {
-    return this.nodes.find((node) => node.tags.name === name) || null;
+  getNodeByName(t) {
+    return this.nodes.find((e) => e.tags.name === t) || null;
   }
-  getWayById(id) {
-    return this.ways.find((way) => way.id === id) || null;
+  getWayById(t) {
+    return this.ways.find((e) => e.id === t) || null;
   }
-  getWayByName(name) {
-    return this.ways.find((way) => way.tags.name === name) || null;
+  getWayByName(t) {
+    return this.ways.find((e) => e.tags.name === t) || null;
   }
 }
-class OsmNode extends OsmElement {
-  constructor(id, coords, tags) {
-    super(id, tags);
-    __publicField(this, "coords");
-    __publicField(this, "ways", []);
-    this.coords = coords;
+class te extends $t {
+  constructor(e, i, n) {
+    super(e, n);
+    M(this, "coords");
+    M(this, "ways", []);
+    this.coords = i;
   }
   get isElevator() {
     return this.tags.highway === "elevator";
@@ -50,12 +41,1945 @@ class OsmNode extends OsmElement {
     return this.isElevator;
   }
 }
-class OsmWay extends OsmElement {
-  constructor(id, tags, level = null) {
-    super(id, tags);
-    __publicField(this, "nodes", []);
-    __publicField(this, "level", null);
-    this.level = level;
+var Ct = {}, Wt = {};
+(function(s) {
+  /**
+   * Character classes and associated utilities for the 5th edition of XML 1.0.
+   *
+   * @author Louis-Dominique Dubeau
+   * @license MIT
+   * @copyright Louis-Dominique Dubeau
+   */
+  Object.defineProperty(s, "__esModule", { value: !0 }), s.CHAR = `	
+\r -\uD7FF\uE000-\uFFFD\u{10000}-\u{10FFFF}`, s.S = ` 	\r
+`, s.NAME_START_CHAR = ":A-Z_a-z\xC0-\xD6\xD8-\xF6\xF8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u{10000}-\u{EFFFF}", s.NAME_CHAR = "-" + s.NAME_START_CHAR + ".0-9\xB7\u0300-\u036F\u203F-\u2040", s.CHAR_RE = new RegExp("^[" + s.CHAR + "]$", "u"), s.S_RE = new RegExp("^[" + s.S + "]+$", "u"), s.NAME_START_CHAR_RE = new RegExp("^[" + s.NAME_START_CHAR + "]$", "u"), s.NAME_CHAR_RE = new RegExp("^[" + s.NAME_CHAR + "]$", "u"), s.NAME_RE = new RegExp("^[" + s.NAME_START_CHAR + "][" + s.NAME_CHAR + "]*$", "u"), s.NMTOKEN_RE = new RegExp("^[" + s.NAME_CHAR + "]+$", "u");
+  var t = 9, e = 10, i = 13, n = 32;
+  s.S_LIST = [n, e, i, t];
+  function r(o) {
+    return o >= n && o <= 55295 || o === e || o === i || o === t || o >= 57344 && o <= 65533 || o >= 65536 && o <= 1114111;
+  }
+  s.isChar = r;
+  function a(o) {
+    return o === n || o === e || o === i || o === t;
+  }
+  s.isS = a;
+  function l(o) {
+    return o >= 65 && o <= 90 || o >= 97 && o <= 122 || o === 58 || o === 95 || o === 8204 || o === 8205 || o >= 192 && o <= 214 || o >= 216 && o <= 246 || o >= 248 && o <= 767 || o >= 880 && o <= 893 || o >= 895 && o <= 8191 || o >= 8304 && o <= 8591 || o >= 11264 && o <= 12271 || o >= 12289 && o <= 55295 || o >= 63744 && o <= 64975 || o >= 65008 && o <= 65533 || o >= 65536 && o <= 983039;
+  }
+  s.isNameStartChar = l;
+  function c(o) {
+    return l(o) || o >= 48 && o <= 57 || o === 45 || o === 46 || o === 183 || o >= 768 && o <= 879 || o >= 8255 && o <= 8256;
+  }
+  s.isNameChar = c;
+})(Wt);
+var Xt = {};
+(function(s) {
+  /**
+   * Character classes and associated utilities for the 2nd edition of XML 1.1.
+   *
+   * @author Louis-Dominique Dubeau
+   * @license MIT
+   * @copyright Louis-Dominique Dubeau
+   */
+  Object.defineProperty(s, "__esModule", { value: !0 }), s.CHAR = "
-\uD7FF\uE000-\uFFFD\u{10000}-\u{10FFFF}", s.RESTRICTED_CHAR = "
-\b\v\f-\x7F-\x84\x86-\x9F", s.S = ` 	\r
+`, s.NAME_START_CHAR = ":A-Z_a-z\xC0-\xD6\xD8-\xF6\xF8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u{10000}-\u{EFFFF}", s.NAME_CHAR = "-" + s.NAME_START_CHAR + ".0-9\xB7\u0300-\u036F\u203F-\u2040", s.CHAR_RE = new RegExp("^[" + s.CHAR + "]$", "u"), s.RESTRICTED_CHAR_RE = new RegExp("^[" + s.RESTRICTED_CHAR + "]$", "u"), s.S_RE = new RegExp("^[" + s.S + "]+$", "u"), s.NAME_START_CHAR_RE = new RegExp("^[" + s.NAME_START_CHAR + "]$", "u"), s.NAME_CHAR_RE = new RegExp("^[" + s.NAME_CHAR + "]$", "u"), s.NAME_RE = new RegExp("^[" + s.NAME_START_CHAR + "][" + s.NAME_CHAR + "]*$", "u"), s.NMTOKEN_RE = new RegExp("^[" + s.NAME_CHAR + "]+$", "u");
+  var t = 9, e = 10, i = 13, n = 32;
+  s.S_LIST = [n, e, i, t];
+  function r(h) {
+    return h >= 1 && h <= 55295 || h >= 57344 && h <= 65533 || h >= 65536 && h <= 1114111;
+  }
+  s.isChar = r;
+  function a(h) {
+    return h >= 1 && h <= 8 || h === 11 || h === 12 || h >= 14 && h <= 31 || h >= 127 && h <= 132 || h >= 134 && h <= 159;
+  }
+  s.isRestrictedChar = a;
+  function l(h) {
+    return h === 9 || h === 10 || h === 13 || h > 31 && h < 127 || h === 133 || h > 159 && h <= 55295 || h >= 57344 && h <= 65533 || h >= 65536 && h <= 1114111;
+  }
+  s.isCharAndNotRestricted = l;
+  function c(h) {
+    return h === n || h === e || h === i || h === t;
+  }
+  s.isS = c;
+  function o(h) {
+    return h >= 65 && h <= 90 || h >= 97 && h <= 122 || h === 58 || h === 95 || h === 8204 || h === 8205 || h >= 192 && h <= 214 || h >= 216 && h <= 246 || h >= 248 && h <= 767 || h >= 880 && h <= 893 || h >= 895 && h <= 8191 || h >= 8304 && h <= 8591 || h >= 11264 && h <= 12271 || h >= 12289 && h <= 55295 || h >= 63744 && h <= 64975 || h >= 65008 && h <= 65533 || h >= 65536 && h <= 983039;
+  }
+  s.isNameStartChar = o;
+  function u(h) {
+    return o(h) || h >= 48 && h <= 57 || h === 45 || h === 46 || h === 183 || h >= 768 && h <= 879 || h >= 8255 && h <= 8256;
+  }
+  s.isNameChar = u;
+})(Xt);
+var qt = {};
+(function(s) {
+  /**
+   * Character class utilities for XML NS 1.0 edition 3.
+   *
+   * @author Louis-Dominique Dubeau
+   * @license MIT
+   * @copyright Louis-Dominique Dubeau
+   */
+  Object.defineProperty(s, "__esModule", { value: !0 }), s.NC_NAME_START_CHAR = "A-Z_a-z\xC0-\xD6\xD8-\xF6\xF8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u{10000}-\u{EFFFF}", s.NC_NAME_CHAR = "-" + s.NC_NAME_START_CHAR + ".0-9\xB7\u0300-\u036F\u203F-\u2040", s.NC_NAME_START_CHAR_RE = new RegExp("^[" + s.NC_NAME_START_CHAR + "]$", "u"), s.NC_NAME_CHAR_RE = new RegExp("^[" + s.NC_NAME_CHAR + "]$", "u"), s.NC_NAME_RE = new RegExp("^[" + s.NC_NAME_START_CHAR + "][" + s.NC_NAME_CHAR + "]*$", "u");
+  function t(i) {
+    return i >= 65 && i <= 90 || i === 95 || i >= 97 && i <= 122 || i >= 192 && i <= 214 || i >= 216 && i <= 246 || i >= 248 && i <= 767 || i >= 880 && i <= 893 || i >= 895 && i <= 8191 || i >= 8204 && i <= 8205 || i >= 8304 && i <= 8591 || i >= 11264 && i <= 12271 || i >= 12289 && i <= 55295 || i >= 63744 && i <= 64975 || i >= 65008 && i <= 65533 || i >= 65536 && i <= 983039;
+  }
+  s.isNCNameStartChar = t;
+  function e(i) {
+    return t(i) || i === 45 || i === 46 || i >= 48 && i <= 57 || i === 183 || i >= 768 && i <= 879 || i >= 8255 && i <= 8256;
+  }
+  s.isNCNameChar = e;
+})(qt);
+Object.defineProperty(Ct, "__esModule", { value: !0 });
+const z = Wt, ee = Xt, Tt = qt;
+var v = z.isS, se = z.isChar, Q = z.isNameStartChar, bt = z.isNameChar, Vt = z.S_LIST, ie = z.NAME_RE, ne = ee.isChar, ae = Tt.isNCNameStartChar, re = Tt.isNCNameChar, oe = Tt.NC_NAME_RE;
+const ot = "http://www.w3.org/XML/1998/namespace", G = "http://www.w3.org/2000/xmlns/", le = {
+  __proto__: null,
+  xml: ot,
+  xmlns: G
+}, he = {
+  __proto__: null,
+  amp: "&",
+  gt: ">",
+  lt: "<",
+  quot: '"',
+  apos: "'"
+}, E = -1, S = -2, vt = 0, ce = 1, ht = 2, ue = 3, W = 4, de = 5, fe = 6, ge = 7, ct = 8, me = 9, _e = 10, xe = 11, Ee = 12, T = 13, tt = 14, ut = 15, pe = 16, dt = 17, Ae = 18, Fe = 19, ft = 20, Ce = 21, Te = 22, Ne = 23, wt = 24, gt = 25, et = 26, Dt = 27, be = 28, ve = 29, yt = 30, we = 31, De = 32, O = 33, ye = 34, mt = 35, J = 36, _t = 37, Se = 38, St = 39, Mt = 40, Me = 41, Rt = 42, Re = 43, Ie = 44, xt = 9, y = 10, Et = 13, It = 32, kt = 33, Yt = 34, K = 38, Gt = 39, st = 45, it = 47, ke = 59, k = 60, V = 61, A = 62, F = 63, zt = 91, Y = 93, Pt = 133, Lt = 8232, nt = (s) => s === Yt || s === Gt, Ut = [Yt, Gt], Pe = [...Ut, zt, A], Le = [...Ut, k, Y], Oe = [V, F, ...Vt], Be = [...Vt, A, K, k];
+function At(s, t, e) {
+  switch (t) {
+    case "xml":
+      e !== ot && s.fail(`xml prefix must be bound to ${ot}.`);
+      break;
+    case "xmlns":
+      e !== G && s.fail(`xmlns prefix must be bound to ${G}.`);
+      break;
+  }
+  switch (e) {
+    case G:
+      s.fail(t === "" ? `the default namespace may not be set to ${e}.` : `may not assign a prefix (even "xmlns") to the URI ${G}.`);
+      break;
+    case ot:
+      switch (t) {
+        case "xml":
+          break;
+        case "":
+          s.fail(`the default namespace may not be set to ${e}.`);
+          break;
+        default:
+          s.fail("may not assign the xml namespace to another prefix.");
+      }
+      break;
+  }
+}
+function He(s, t) {
+  for (const e of Object.keys(t))
+    At(s, e, t[e]);
+}
+const $e = (s) => oe.test(s), We = (s) => ie.test(s), B = 0, Ot = 1, pt = 2;
+Ct.EVENTS = [
+  "xmldecl",
+  "text",
+  "processinginstruction",
+  "doctype",
+  "comment",
+  "opentagstart",
+  "attribute",
+  "opentag",
+  "closetag",
+  "cdata",
+  "error",
+  "end",
+  "ready"
+];
+const Bt = {
+  xmldecl: "xmldeclHandler",
+  text: "textHandler",
+  processinginstruction: "piHandler",
+  doctype: "doctypeHandler",
+  comment: "commentHandler",
+  opentagstart: "openTagStartHandler",
+  attribute: "attributeHandler",
+  opentag: "openTagHandler",
+  closetag: "closeTagHandler",
+  cdata: "cdataHandler",
+  error: "errorHandler",
+  end: "endHandler",
+  ready: "readyHandler"
+};
+class Xe {
+  constructor(t) {
+    this.opt = t != null ? t : {}, this.fragmentOpt = !!this.opt.fragment;
+    const e = this.xmlnsOpt = !!this.opt.xmlns;
+    if (this.trackPosition = this.opt.position !== !1, this.fileName = this.opt.fileName, e) {
+      this.nameStartCheck = ae, this.nameCheck = re, this.isName = $e, this.processAttribs = this.processAttribsNS, this.pushAttrib = this.pushAttribNS, this.ns = Object.assign({ __proto__: null }, le);
+      const i = this.opt.additionalNamespaces;
+      i != null && (He(this, i), Object.assign(this.ns, i));
+    } else
+      this.nameStartCheck = Q, this.nameCheck = bt, this.isName = We, this.processAttribs = this.processAttribsPlain, this.pushAttrib = this.pushAttribPlain;
+    this.stateTable = [
+      this.sBegin,
+      this.sBeginWhitespace,
+      this.sDoctype,
+      this.sDoctypeQuote,
+      this.sDTD,
+      this.sDTDQuoted,
+      this.sDTDOpenWaka,
+      this.sDTDOpenWakaBang,
+      this.sDTDComment,
+      this.sDTDCommentEnding,
+      this.sDTDCommentEnded,
+      this.sDTDPI,
+      this.sDTDPIEnding,
+      this.sText,
+      this.sEntity,
+      this.sOpenWaka,
+      this.sOpenWakaBang,
+      this.sComment,
+      this.sCommentEnding,
+      this.sCommentEnded,
+      this.sCData,
+      this.sCDataEnding,
+      this.sCDataEnding2,
+      this.sPIFirstChar,
+      this.sPIRest,
+      this.sPIBody,
+      this.sPIEnding,
+      this.sXMLDeclNameStart,
+      this.sXMLDeclName,
+      this.sXMLDeclEq,
+      this.sXMLDeclValueStart,
+      this.sXMLDeclValue,
+      this.sXMLDeclSeparator,
+      this.sXMLDeclEnding,
+      this.sOpenTag,
+      this.sOpenTagSlash,
+      this.sAttrib,
+      this.sAttribName,
+      this.sAttribNameSawWhite,
+      this.sAttribValue,
+      this.sAttribValueQuoted,
+      this.sAttribValueClosed,
+      this.sAttribValueUnquoted,
+      this.sCloseTag,
+      this.sCloseTagSawWhite
+    ], this._init();
+  }
+  get closed() {
+    return this._closed;
+  }
+  _init() {
+    var t;
+    this.openWakaBang = "", this.text = "", this.name = "", this.piTarget = "", this.entity = "", this.q = null, this.tags = [], this.tag = null, this.topNS = null, this.chunk = "", this.chunkPosition = 0, this.i = 0, this.prevI = 0, this.carriedFromPrevious = void 0, this.forbiddenState = B, this.attribList = [];
+    const { fragmentOpt: e } = this;
+    this.state = e ? T : vt, this.reportedTextBeforeRoot = this.reportedTextAfterRoot = this.closedRoot = this.sawRoot = e, this.xmlDeclPossible = !e, this.xmlDeclExpects = ["version"], this.entityReturnState = void 0;
+    let { defaultXMLVersion: i } = this.opt;
+    if (i === void 0) {
+      if (this.opt.forceXMLVersion === !0)
+        throw new Error("forceXMLVersion set but defaultXMLVersion is not set");
+      i = "1.0";
+    }
+    this.setXMLVersion(i), this.positionAtNewLine = 0, this.doctype = !1, this._closed = !1, this.xmlDecl = {
+      version: void 0,
+      encoding: void 0,
+      standalone: void 0
+    }, this.line = 1, this.column = 0, this.ENTITIES = Object.create(he), (t = this.readyHandler) === null || t === void 0 || t.call(this);
+  }
+  get position() {
+    return this.chunkPosition + this.i;
+  }
+  get columnIndex() {
+    return this.position - this.positionAtNewLine;
+  }
+  on(t, e) {
+    this[Bt[t]] = e;
+  }
+  off(t) {
+    this[Bt[t]] = void 0;
+  }
+  makeError(t) {
+    var e;
+    let i = (e = this.fileName) !== null && e !== void 0 ? e : "";
+    return this.trackPosition && (i.length > 0 && (i += ":"), i += `${this.line}:${this.column}`), i.length > 0 && (i += ": "), new Error(i + t);
+  }
+  fail(t) {
+    const e = this.makeError(t), i = this.errorHandler;
+    if (i === void 0)
+      throw e;
+    return i(e), this;
+  }
+  write(t) {
+    if (this.closed)
+      return this.fail("cannot write after close; assign an onready handler.");
+    let e = !1;
+    t === null ? (e = !0, t = "") : typeof t == "object" && (t = t.toString()), this.carriedFromPrevious !== void 0 && (t = `${this.carriedFromPrevious}${t}`, this.carriedFromPrevious = void 0);
+    let i = t.length;
+    const n = t.charCodeAt(i - 1);
+    !e && (n === Et || n >= 55296 && n <= 56319) && (this.carriedFromPrevious = t[i - 1], i--, t = t.slice(0, i));
+    const { stateTable: r } = this;
+    for (this.chunk = t, this.i = 0; this.i < i; )
+      r[this.state].call(this);
+    return this.chunkPosition += i, e ? this.end() : this;
+  }
+  close() {
+    return this.write(null);
+  }
+  getCode10() {
+    const { chunk: t, i: e } = this;
+    if (this.prevI = e, this.i = e + 1, e >= t.length)
+      return E;
+    const i = t.charCodeAt(e);
+    if (this.column++, i < 55296) {
+      if (i >= It || i === xt)
+        return i;
+      switch (i) {
+        case y:
+          return this.line++, this.column = 0, this.positionAtNewLine = this.position, y;
+        case Et:
+          return t.charCodeAt(e + 1) === y && (this.i = e + 2), this.line++, this.column = 0, this.positionAtNewLine = this.position, S;
+        default:
+          return this.fail("disallowed character."), i;
+      }
+    }
+    if (i > 56319)
+      return i >= 57344 && i <= 65533 || this.fail("disallowed character."), i;
+    const n = 65536 + (i - 55296) * 1024 + (t.charCodeAt(e + 1) - 56320);
+    return this.i = e + 2, n > 1114111 && this.fail("disallowed character."), n;
+  }
+  getCode11() {
+    const { chunk: t, i: e } = this;
+    if (this.prevI = e, this.i = e + 1, e >= t.length)
+      return E;
+    const i = t.charCodeAt(e);
+    if (this.column++, i < 55296) {
+      if (i > 31 && i < 127 || i > 159 && i !== Lt || i === xt)
+        return i;
+      switch (i) {
+        case y:
+          return this.line++, this.column = 0, this.positionAtNewLine = this.position, y;
+        case Et: {
+          const r = t.charCodeAt(e + 1);
+          (r === y || r === Pt) && (this.i = e + 2);
+        }
+        case Pt:
+        case Lt:
+          return this.line++, this.column = 0, this.positionAtNewLine = this.position, S;
+        default:
+          return this.fail("disallowed character."), i;
+      }
+    }
+    if (i > 56319)
+      return i >= 57344 && i <= 65533 || this.fail("disallowed character."), i;
+    const n = 65536 + (i - 55296) * 1024 + (t.charCodeAt(e + 1) - 56320);
+    return this.i = e + 2, n > 1114111 && this.fail("disallowed character."), n;
+  }
+  getCodeNorm() {
+    const t = this.getCode();
+    return t === S ? y : t;
+  }
+  unget() {
+    this.i = this.prevI, this.column--;
+  }
+  captureTo(t) {
+    let { i: e } = this;
+    const { chunk: i } = this;
+    for (; ; ) {
+      const n = this.getCode(), r = n === S, a = r ? y : n;
+      if (a === E || t.includes(a))
+        return this.text += i.slice(e, this.prevI), a;
+      r && (this.text += `${i.slice(e, this.prevI)}
+`, e = this.i);
+    }
+  }
+  captureToChar(t) {
+    let { i: e } = this;
+    const { chunk: i } = this;
+    for (; ; ) {
+      let n = this.getCode();
+      switch (n) {
+        case S:
+          this.text += `${i.slice(e, this.prevI)}
+`, e = this.i, n = y;
+          break;
+        case E:
+          return this.text += i.slice(e), !1;
+      }
+      if (n === t)
+        return this.text += i.slice(e, this.prevI), !0;
+    }
+  }
+  captureNameChars() {
+    const { chunk: t, i: e } = this;
+    for (; ; ) {
+      const i = this.getCode();
+      if (i === E)
+        return this.name += t.slice(e), E;
+      if (!bt(i))
+        return this.name += t.slice(e, this.prevI), i === S ? y : i;
+    }
+  }
+  skipSpaces() {
+    for (; ; ) {
+      const t = this.getCodeNorm();
+      if (t === E || !v(t))
+        return t;
+    }
+  }
+  setXMLVersion(t) {
+    this.currentXMLVersion = t, t === "1.0" ? (this.isChar = se, this.getCode = this.getCode10) : (this.isChar = ne, this.getCode = this.getCode11);
+  }
+  sBegin() {
+    this.chunk.charCodeAt(0) === 65279 && (this.i++, this.column++), this.state = ce;
+  }
+  sBeginWhitespace() {
+    const t = this.i, e = this.skipSpaces();
+    switch (this.prevI !== t && (this.xmlDeclPossible = !1), e) {
+      case k:
+        if (this.state = ut, this.text.length !== 0)
+          throw new Error("no-empty text at start");
+        break;
+      case E:
+        break;
+      default:
+        this.unget(), this.state = T, this.xmlDeclPossible = !1;
+    }
+  }
+  sDoctype() {
+    var t;
+    const e = this.captureTo(Pe);
+    switch (e) {
+      case A: {
+        (t = this.doctypeHandler) === null || t === void 0 || t.call(this, this.text), this.text = "", this.state = T, this.doctype = !0;
+        break;
+      }
+      case E:
+        break;
+      default:
+        this.text += String.fromCodePoint(e), e === zt ? this.state = W : nt(e) && (this.state = ue, this.q = e);
+    }
+  }
+  sDoctypeQuote() {
+    const t = this.q;
+    this.captureToChar(t) && (this.text += String.fromCodePoint(t), this.q = null, this.state = ht);
+  }
+  sDTD() {
+    const t = this.captureTo(Le);
+    t !== E && (this.text += String.fromCodePoint(t), t === Y ? this.state = ht : t === k ? this.state = fe : nt(t) && (this.state = de, this.q = t));
+  }
+  sDTDQuoted() {
+    const t = this.q;
+    this.captureToChar(t) && (this.text += String.fromCodePoint(t), this.state = W, this.q = null);
+  }
+  sDTDOpenWaka() {
+    const t = this.getCodeNorm();
+    switch (this.text += String.fromCodePoint(t), t) {
+      case kt:
+        this.state = ge, this.openWakaBang = "";
+        break;
+      case F:
+        this.state = xe;
+        break;
+      default:
+        this.state = W;
+    }
+  }
+  sDTDOpenWakaBang() {
+    const t = String.fromCodePoint(this.getCodeNorm()), e = this.openWakaBang += t;
+    this.text += t, e !== "-" && (this.state = e === "--" ? ct : W, this.openWakaBang = "");
+  }
+  sDTDComment() {
+    this.captureToChar(st) && (this.text += "-", this.state = me);
+  }
+  sDTDCommentEnding() {
+    const t = this.getCodeNorm();
+    this.text += String.fromCodePoint(t), this.state = t === st ? _e : ct;
+  }
+  sDTDCommentEnded() {
+    const t = this.getCodeNorm();
+    this.text += String.fromCodePoint(t), t === A ? this.state = W : (this.fail("malformed comment."), this.state = ct);
+  }
+  sDTDPI() {
+    this.captureToChar(F) && (this.text += "?", this.state = Ee);
+  }
+  sDTDPIEnding() {
+    const t = this.getCodeNorm();
+    this.text += String.fromCodePoint(t), t === A && (this.state = W);
+  }
+  sText() {
+    this.tags.length !== 0 ? this.handleTextInRoot() : this.handleTextOutsideRoot();
+  }
+  sEntity() {
+    let { i: t } = this;
+    const { chunk: e } = this;
+    t:
+      for (; ; )
+        switch (this.getCode()) {
+          case S:
+            this.entity += `${e.slice(t, this.prevI)}
+`, t = this.i;
+            break;
+          case ke: {
+            const { entityReturnState: i } = this, n = this.entity + e.slice(t, this.prevI);
+            this.state = i;
+            let r;
+            n === "" ? (this.fail("empty entity name."), r = "&;") : (r = this.parseEntity(n), this.entity = ""), (i !== T || this.textHandler !== void 0) && (this.text += r);
+            break t;
+          }
+          case E:
+            this.entity += e.slice(t);
+            break t;
+        }
+  }
+  sOpenWaka() {
+    const t = this.getCode();
+    if (Q(t))
+      this.state = ye, this.unget(), this.xmlDeclPossible = !1;
+    else
+      switch (t) {
+        case it:
+          this.state = Re, this.xmlDeclPossible = !1;
+          break;
+        case kt:
+          this.state = pe, this.openWakaBang = "", this.xmlDeclPossible = !1;
+          break;
+        case F:
+          this.state = Ne;
+          break;
+        default:
+          this.fail("disallowed character in tag name"), this.state = T, this.xmlDeclPossible = !1;
+      }
+  }
+  sOpenWakaBang() {
+    switch (this.openWakaBang += String.fromCodePoint(this.getCodeNorm()), this.openWakaBang) {
+      case "[CDATA[":
+        !this.sawRoot && !this.reportedTextBeforeRoot && (this.fail("text data outside of root node."), this.reportedTextBeforeRoot = !0), this.closedRoot && !this.reportedTextAfterRoot && (this.fail("text data outside of root node."), this.reportedTextAfterRoot = !0), this.state = ft, this.openWakaBang = "";
+        break;
+      case "--":
+        this.state = dt, this.openWakaBang = "";
+        break;
+      case "DOCTYPE":
+        this.state = ht, (this.doctype || this.sawRoot) && this.fail("inappropriately located doctype declaration."), this.openWakaBang = "";
+        break;
+      default:
+        this.openWakaBang.length >= 7 && this.fail("incorrect syntax.");
+    }
+  }
+  sComment() {
+    this.captureToChar(st) && (this.state = Ae);
+  }
+  sCommentEnding() {
+    var t;
+    const e = this.getCodeNorm();
+    e === st ? (this.state = Fe, (t = this.commentHandler) === null || t === void 0 || t.call(this, this.text), this.text = "") : (this.text += `-${String.fromCodePoint(e)}`, this.state = dt);
+  }
+  sCommentEnded() {
+    const t = this.getCodeNorm();
+    t !== A ? (this.fail("malformed comment."), this.text += `--${String.fromCodePoint(t)}`, this.state = dt) : this.state = T;
+  }
+  sCData() {
+    this.captureToChar(Y) && (this.state = Ce);
+  }
+  sCDataEnding() {
+    const t = this.getCodeNorm();
+    t === Y ? this.state = Te : (this.text += `]${String.fromCodePoint(t)}`, this.state = ft);
+  }
+  sCDataEnding2() {
+    var t;
+    const e = this.getCodeNorm();
+    switch (e) {
+      case A: {
+        (t = this.cdataHandler) === null || t === void 0 || t.call(this, this.text), this.text = "", this.state = T;
+        break;
+      }
+      case Y:
+        this.text += "]";
+        break;
+      default:
+        this.text += `]]${String.fromCodePoint(e)}`, this.state = ft;
+    }
+  }
+  sPIFirstChar() {
+    const t = this.getCodeNorm();
+    this.nameStartCheck(t) ? (this.piTarget += String.fromCodePoint(t), this.state = wt) : t === F || v(t) ? (this.fail("processing instruction without a target."), this.state = t === F ? et : gt) : (this.fail("disallowed character in processing instruction name."), this.piTarget += String.fromCodePoint(t), this.state = wt);
+  }
+  sPIRest() {
+    const { chunk: t, i: e } = this;
+    for (; ; ) {
+      const i = this.getCodeNorm();
+      if (i === E) {
+        this.piTarget += t.slice(e);
+        return;
+      }
+      if (!this.nameCheck(i)) {
+        this.piTarget += t.slice(e, this.prevI);
+        const n = i === F;
+        n || v(i) ? this.piTarget === "xml" ? (this.xmlDeclPossible || this.fail("an XML declaration must be at the start of the document."), this.state = n ? O : Dt) : this.state = n ? et : gt : (this.fail("disallowed character in processing instruction name."), this.piTarget += String.fromCodePoint(i));
+        break;
+      }
+    }
+  }
+  sPIBody() {
+    if (this.text.length === 0) {
+      const t = this.getCodeNorm();
+      t === F ? this.state = et : v(t) || (this.text = String.fromCodePoint(t));
+    } else
+      this.captureToChar(F) && (this.state = et);
+  }
+  sPIEnding() {
+    var t;
+    const e = this.getCodeNorm();
+    if (e === A) {
+      const { piTarget: i } = this;
+      i.toLowerCase() === "xml" && this.fail("the XML declaration must appear at the start of the document."), (t = this.piHandler) === null || t === void 0 || t.call(this, {
+        target: i,
+        body: this.text
+      }), this.piTarget = this.text = "", this.state = T;
+    } else
+      e === F ? this.text += "?" : (this.text += `?${String.fromCodePoint(e)}`, this.state = gt);
+    this.xmlDeclPossible = !1;
+  }
+  sXMLDeclNameStart() {
+    const t = this.skipSpaces();
+    if (t === F) {
+      this.state = O;
+      return;
+    }
+    t !== E && (this.state = be, this.name = String.fromCodePoint(t));
+  }
+  sXMLDeclName() {
+    const t = this.captureTo(Oe);
+    if (t === F) {
+      this.state = O, this.name += this.text, this.text = "", this.fail("XML declaration is incomplete.");
+      return;
+    }
+    if (!!(v(t) || t === V)) {
+      if (this.name += this.text, this.text = "", !this.xmlDeclExpects.includes(this.name))
+        switch (this.name.length) {
+          case 0:
+            this.fail("did not expect any more name/value pairs.");
+            break;
+          case 1:
+            this.fail(`expected the name ${this.xmlDeclExpects[0]}.`);
+            break;
+          default:
+            this.fail(`expected one of ${this.xmlDeclExpects.join(", ")}`);
+        }
+      this.state = t === V ? yt : ve;
+    }
+  }
+  sXMLDeclEq() {
+    const t = this.getCodeNorm();
+    if (t === F) {
+      this.state = O, this.fail("XML declaration is incomplete.");
+      return;
+    }
+    v(t) || (t !== V && this.fail("value required."), this.state = yt);
+  }
+  sXMLDeclValueStart() {
+    const t = this.getCodeNorm();
+    if (t === F) {
+      this.state = O, this.fail("XML declaration is incomplete.");
+      return;
+    }
+    v(t) || (nt(t) ? this.q = t : (this.fail("value must be quoted."), this.q = It), this.state = we);
+  }
+  sXMLDeclValue() {
+    const t = this.captureTo([this.q, F]);
+    if (t === F) {
+      this.state = O, this.text = "", this.fail("XML declaration is incomplete.");
+      return;
+    }
+    if (t === E)
+      return;
+    const e = this.text;
+    switch (this.text = "", this.name) {
+      case "version": {
+        this.xmlDeclExpects = ["encoding", "standalone"];
+        const i = e;
+        this.xmlDecl.version = i, /^1\.[0-9]+$/.test(i) ? this.opt.forceXMLVersion || this.setXMLVersion(i) : this.fail("version number must match /^1\\.[0-9]+$/.");
+        break;
+      }
+      case "encoding":
+        /^[A-Za-z][A-Za-z0-9._-]*$/.test(e) || this.fail("encoding value must match /^[A-Za-z0-9][A-Za-z0-9._-]*$/."), this.xmlDeclExpects = ["standalone"], this.xmlDecl.encoding = e;
+        break;
+      case "standalone":
+        e !== "yes" && e !== "no" && this.fail('standalone value must match "yes" or "no".'), this.xmlDeclExpects = [], this.xmlDecl.standalone = e;
+        break;
+    }
+    this.name = "", this.state = De;
+  }
+  sXMLDeclSeparator() {
+    const t = this.getCodeNorm();
+    if (t === F) {
+      this.state = O;
+      return;
+    }
+    v(t) || (this.fail("whitespace required."), this.unget()), this.state = Dt;
+  }
+  sXMLDeclEnding() {
+    var t;
+    this.getCodeNorm() === A ? (this.piTarget !== "xml" ? this.fail("processing instructions are not allowed before root.") : this.name !== "version" && this.xmlDeclExpects.includes("version") && this.fail("XML declaration must contain a version."), (t = this.xmldeclHandler) === null || t === void 0 || t.call(this, this.xmlDecl), this.name = "", this.piTarget = this.text = "", this.state = T) : this.fail("The character ? is disallowed anywhere in XML declarations."), this.xmlDeclPossible = !1;
+  }
+  sOpenTag() {
+    var t;
+    const e = this.captureNameChars();
+    if (e === E)
+      return;
+    const i = this.tag = {
+      name: this.name,
+      attributes: /* @__PURE__ */ Object.create(null)
+    };
+    switch (this.name = "", this.xmlnsOpt && (this.topNS = i.ns = /* @__PURE__ */ Object.create(null)), (t = this.openTagStartHandler) === null || t === void 0 || t.call(this, i), this.sawRoot = !0, !this.fragmentOpt && this.closedRoot && this.fail("documents may contain only one root."), e) {
+      case A:
+        this.openTag();
+        break;
+      case it:
+        this.state = mt;
+        break;
+      default:
+        v(e) || this.fail("disallowed character in tag name."), this.state = J;
+    }
+  }
+  sOpenTagSlash() {
+    this.getCode() === A ? this.openSelfClosingTag() : (this.fail("forward-slash in opening tag not followed by >."), this.state = J);
+  }
+  sAttrib() {
+    const t = this.skipSpaces();
+    t !== E && (Q(t) ? (this.unget(), this.state = _t) : t === A ? this.openTag() : t === it ? this.state = mt : this.fail("disallowed character in attribute name."));
+  }
+  sAttribName() {
+    const t = this.captureNameChars();
+    t === V ? this.state = St : v(t) ? this.state = Se : t === A ? (this.fail("attribute without value."), this.pushAttrib(this.name, this.name), this.name = this.text = "", this.openTag()) : t !== E && this.fail("disallowed character in attribute name.");
+  }
+  sAttribNameSawWhite() {
+    const t = this.skipSpaces();
+    switch (t) {
+      case E:
+        return;
+      case V:
+        this.state = St;
+        break;
+      default:
+        this.fail("attribute without value."), this.text = "", this.name = "", t === A ? this.openTag() : Q(t) ? (this.unget(), this.state = _t) : (this.fail("disallowed character in attribute name."), this.state = J);
+    }
+  }
+  sAttribValue() {
+    const t = this.getCodeNorm();
+    nt(t) ? (this.q = t, this.state = Mt) : v(t) || (this.fail("unquoted attribute value."), this.state = Rt, this.unget());
+  }
+  sAttribValueQuoted() {
+    const { q: t, chunk: e } = this;
+    let { i } = this;
+    for (; ; )
+      switch (this.getCode()) {
+        case t:
+          this.pushAttrib(this.name, this.text + e.slice(i, this.prevI)), this.name = this.text = "", this.q = null, this.state = Me;
+          return;
+        case K:
+          this.text += e.slice(i, this.prevI), this.state = tt, this.entityReturnState = Mt;
+          return;
+        case y:
+        case S:
+        case xt:
+          this.text += `${e.slice(i, this.prevI)} `, i = this.i;
+          break;
+        case k:
+          this.text += e.slice(i, this.prevI), this.fail("disallowed character.");
+          return;
+        case E:
+          this.text += e.slice(i);
+          return;
+      }
+  }
+  sAttribValueClosed() {
+    const t = this.getCodeNorm();
+    v(t) ? this.state = J : t === A ? this.openTag() : t === it ? this.state = mt : Q(t) ? (this.fail("no whitespace between attributes."), this.unget(), this.state = _t) : this.fail("disallowed character in attribute name.");
+  }
+  sAttribValueUnquoted() {
+    const t = this.captureTo(Be);
+    switch (t) {
+      case K:
+        this.state = tt, this.entityReturnState = Rt;
+        break;
+      case k:
+        this.fail("disallowed character.");
+        break;
+      case E:
+        break;
+      default:
+        this.text.includes("]]>") && this.fail('the string "]]>" is disallowed in char data.'), this.pushAttrib(this.name, this.text), this.name = this.text = "", t === A ? this.openTag() : this.state = J;
+    }
+  }
+  sCloseTag() {
+    const t = this.captureNameChars();
+    t === A ? this.closeTag() : v(t) ? this.state = Ie : t !== E && this.fail("disallowed character in closing tag.");
+  }
+  sCloseTagSawWhite() {
+    switch (this.skipSpaces()) {
+      case A:
+        this.closeTag();
+        break;
+      case E:
+        break;
+      default:
+        this.fail("disallowed character in closing tag.");
+    }
+  }
+  handleTextInRoot() {
+    let { i: t, forbiddenState: e } = this;
+    const { chunk: i, textHandler: n } = this;
+    t:
+      for (; ; )
+        switch (this.getCode()) {
+          case k: {
+            if (this.state = ut, n !== void 0) {
+              const { text: r } = this, a = i.slice(t, this.prevI);
+              r.length !== 0 ? (n(r + a), this.text = "") : a.length !== 0 && n(a);
+            }
+            e = B;
+            break t;
+          }
+          case K:
+            this.state = tt, this.entityReturnState = T, n !== void 0 && (this.text += i.slice(t, this.prevI)), e = B;
+            break t;
+          case Y:
+            switch (e) {
+              case B:
+                e = Ot;
+                break;
+              case Ot:
+                e = pt;
+                break;
+              case pt:
+                break;
+              default:
+                throw new Error("impossible state");
+            }
+            break;
+          case A:
+            e === pt && this.fail('the string "]]>" is disallowed in char data.'), e = B;
+            break;
+          case S:
+            n !== void 0 && (this.text += `${i.slice(t, this.prevI)}
+`), t = this.i, e = B;
+            break;
+          case E:
+            n !== void 0 && (this.text += i.slice(t));
+            break t;
+          default:
+            e = B;
+        }
+    this.forbiddenState = e;
+  }
+  handleTextOutsideRoot() {
+    let { i: t } = this;
+    const { chunk: e, textHandler: i } = this;
+    let n = !1;
+    t:
+      for (; ; ) {
+        const r = this.getCode();
+        switch (r) {
+          case k: {
+            if (this.state = ut, i !== void 0) {
+              const { text: a } = this, l = e.slice(t, this.prevI);
+              a.length !== 0 ? (i(a + l), this.text = "") : l.length !== 0 && i(l);
+            }
+            break t;
+          }
+          case K:
+            this.state = tt, this.entityReturnState = T, i !== void 0 && (this.text += e.slice(t, this.prevI)), n = !0;
+            break t;
+          case S:
+            i !== void 0 && (this.text += `${e.slice(t, this.prevI)}
+`), t = this.i;
+            break;
+          case E:
+            i !== void 0 && (this.text += e.slice(t));
+            break t;
+          default:
+            v(r) || (n = !0);
+        }
+      }
+    !n || (!this.sawRoot && !this.reportedTextBeforeRoot && (this.fail("text data outside of root node."), this.reportedTextBeforeRoot = !0), this.closedRoot && !this.reportedTextAfterRoot && (this.fail("text data outside of root node."), this.reportedTextAfterRoot = !0));
+  }
+  pushAttribNS(t, e) {
+    var i;
+    const { prefix: n, local: r } = this.qname(t), a = { name: t, prefix: n, local: r, value: e };
+    if (this.attribList.push(a), (i = this.attributeHandler) === null || i === void 0 || i.call(this, a), n === "xmlns") {
+      const l = e.trim();
+      this.currentXMLVersion === "1.0" && l === "" && this.fail("invalid attempt to undefine prefix in XML 1.0"), this.topNS[r] = l, At(this, r, l);
+    } else if (t === "xmlns") {
+      const l = e.trim();
+      this.topNS[""] = l, At(this, "", l);
+    }
+  }
+  pushAttribPlain(t, e) {
+    var i;
+    const n = { name: t, value: e };
+    this.attribList.push(n), (i = this.attributeHandler) === null || i === void 0 || i.call(this, n);
+  }
+  end() {
+    var t, e;
+    this.sawRoot || this.fail("document must contain a root element.");
+    const { tags: i } = this;
+    for (; i.length > 0; ) {
+      const r = i.pop();
+      this.fail(`unclosed tag: ${r.name}`);
+    }
+    this.state !== vt && this.state !== T && this.fail("unexpected end.");
+    const { text: n } = this;
+    return n.length !== 0 && ((t = this.textHandler) === null || t === void 0 || t.call(this, n), this.text = ""), this._closed = !0, (e = this.endHandler) === null || e === void 0 || e.call(this), this._init(), this;
+  }
+  resolve(t) {
+    var e, i;
+    let n = this.topNS[t];
+    if (n !== void 0)
+      return n;
+    const { tags: r } = this;
+    for (let a = r.length - 1; a >= 0; a--)
+      if (n = r[a].ns[t], n !== void 0)
+        return n;
+    return n = this.ns[t], n !== void 0 ? n : (i = (e = this.opt).resolvePrefix) === null || i === void 0 ? void 0 : i.call(e, t);
+  }
+  qname(t) {
+    const e = t.indexOf(":");
+    if (e === -1)
+      return { prefix: "", local: t };
+    const i = t.slice(e + 1), n = t.slice(0, e);
+    return (n === "" || i === "" || i.includes(":")) && this.fail(`malformed name: ${t}.`), { prefix: n, local: i };
+  }
+  processAttribsNS() {
+    var t;
+    const { attribList: e } = this, i = this.tag;
+    {
+      const { prefix: a, local: l } = this.qname(i.name);
+      i.prefix = a, i.local = l;
+      const c = i.uri = (t = this.resolve(a)) !== null && t !== void 0 ? t : "";
+      a !== "" && (a === "xmlns" && this.fail('tags may not have "xmlns" as prefix.'), c === "" && (this.fail(`unbound namespace prefix: ${JSON.stringify(a)}.`), i.uri = a));
+    }
+    if (e.length === 0)
+      return;
+    const { attributes: n } = i, r = /* @__PURE__ */ new Set();
+    for (const a of e) {
+      const { name: l, prefix: c, local: o } = a;
+      let u, h;
+      c === "" ? (u = l === "xmlns" ? G : "", h = l) : (u = this.resolve(c), u === void 0 && (this.fail(`unbound namespace prefix: ${JSON.stringify(c)}.`), u = c), h = `{${u}}${o}`), r.has(h) && this.fail(`duplicate attribute: ${h}.`), r.add(h), a.uri = u, n[l] = a;
+    }
+    this.attribList = [];
+  }
+  processAttribsPlain() {
+    const { attribList: t } = this, e = this.tag.attributes;
+    for (const { name: i, value: n } of t)
+      e[i] !== void 0 && this.fail(`duplicate attribute: ${i}.`), e[i] = n;
+    this.attribList = [];
+  }
+  openTag() {
+    var t;
+    this.processAttribs();
+    const { tags: e } = this, i = this.tag;
+    i.isSelfClosing = !1, (t = this.openTagHandler) === null || t === void 0 || t.call(this, i), e.push(i), this.state = T, this.name = "";
+  }
+  openSelfClosingTag() {
+    var t, e, i;
+    this.processAttribs();
+    const { tags: n } = this, r = this.tag;
+    r.isSelfClosing = !0, (t = this.openTagHandler) === null || t === void 0 || t.call(this, r), (e = this.closeTagHandler) === null || e === void 0 || e.call(this, r), (this.tag = (i = n[n.length - 1]) !== null && i !== void 0 ? i : null) === null && (this.closedRoot = !0), this.state = T, this.name = "";
+  }
+  closeTag() {
+    const { tags: t, name: e } = this;
+    if (this.state = T, this.name = "", e === "") {
+      this.fail("weird empty close tag."), this.text += "</>";
+      return;
+    }
+    const i = this.closeTagHandler;
+    let n = t.length;
+    for (; n-- > 0; ) {
+      const r = this.tag = t.pop();
+      if (this.topNS = r.ns, i == null || i(r), r.name === e)
+        break;
+      this.fail("unexpected close tag.");
+    }
+    n === 0 ? this.closedRoot = !0 : n < 0 && (this.fail(`unmatched closing tag: ${e}.`), this.text += `</${e}>`);
+  }
+  parseEntity(t) {
+    if (t[0] !== "#") {
+      const i = this.ENTITIES[t];
+      return i !== void 0 ? i : (this.fail(this.isName(t) ? "undefined entity." : "disallowed character in entity name."), `&${t};`);
+    }
+    let e = NaN;
+    return t[1] === "x" && /^#x[0-9a-f]+$/i.test(t) ? e = parseInt(t.slice(2), 16) : /^#[0-9]+$/.test(t) && (e = parseInt(t.slice(1), 10)), this.isChar(e) ? String.fromCodePoint(e) : (this.fail("malformed character entity."), `&${t};`);
+  }
+}
+var qe = Ct.SaxesParser = Xe, Ve = Object.defineProperty, Ye = (s, t, e) => t in s ? Ve(s, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : s[t] = e, d = (s, t, e) => (Ye(s, typeof t != "symbol" ? t + "" : t, e), e);
+const Ft = 1e-8, L = 1e-3;
+var Ge = Object.defineProperty, ze = (s, t, e) => t in s ? Ge(s, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : s[t] = e, R = (s, t, e) => (ze(s, typeof t != "symbol" ? t + "" : t, e), e);
+class Ue {
+  static concat(t, e) {
+    return t.concat(e);
+  }
+}
+class m extends Ue {
+  static norm(t) {
+    return Math.sqrt(t[0] * t[0] + t[1] * t[1] + t[2] * t[2]);
+  }
+  static normalize(t) {
+    const e = this.norm(t), i = new Array(3);
+    for (let n = 0; n < 3; n++)
+      i[n] = t[n] / e;
+    return i;
+  }
+  static sum(t, e) {
+    return [t[0] + e[0], t[1] + e[1], t[2] + e[2]];
+  }
+  static subtract(t, e) {
+    return [t[0] - e[0], t[1] - e[1], t[2] - e[2]];
+  }
+  static distance(t, e) {
+    return m.norm(m.subtract(t, e));
+  }
+  static cross(t, e) {
+    return [
+      t[1] * e[2] - t[2] * e[1],
+      t[2] * e[0] - t[0] * e[2],
+      t[0] * e[1] - t[1] * e[0]
+    ];
+  }
+  static dot(t, e) {
+    return t[0] * e[0] + t[1] * e[1] + t[2] * e[2];
+  }
+  static multiplyScalar(t, e) {
+    const i = new Array(3);
+    for (let n = 0; n < 3; n++)
+      i[n] = t[n] * e;
+    return i;
+  }
+}
+const C = class {
+  static get identity() {
+    return [1, 0, 0, 0];
+  }
+  static sum(s, t) {
+    return [s[0] + t[0], s[1] + t[1], s[2] + t[2], s[3] + t[3]];
+  }
+  static rotateMatlab(s, t) {
+    const [e, i, n, r] = s, [a, l, c] = t;
+    return [
+      e * (e * a - n * c + r * l) - n * (e * c - i * l + n * a) + i * (i * a + n * l + r * c) + r * (e * l + i * c - r * a),
+      e * (e * l + i * c - r * a) + i * (e * c - i * l + n * a) + n * (i * a + n * l + r * c) - r * (e * a - n * c + r * l),
+      e * (e * c - i * l + n * a) - i * (e * l + i * c - r * a) + n * (e * a - n * c + r * l) + r * (i * a + n * l + r * c)
+    ];
+  }
+  static rotate(s, t) {
+    const [e, i, n, r] = s, a = [i, n, r];
+    let l = m.cross(a, t);
+    l = m.sum(l, l);
+    const c = m.sum(t, m.multiplyScalar(l, e));
+    return m.sum(c, m.cross(a, l));
+  }
+  static inverse(s) {
+    return [-s[0], s[1], s[2], s[3]];
+  }
+  static multiply(...s) {
+    if (s.length === 2) {
+      const [t, e, i, n] = s[0], [r, a, l, c] = s[1];
+      return [
+        t * r - e * a - i * l - n * c,
+        t * a + r * e + i * c - n * l,
+        t * l + r * i + n * a - e * c,
+        t * c + r * n + e * l - i * a
+      ];
+    }
+    return s.reduce((t, e) => this.multiply(t, e), C.identity);
+  }
+  static fromAxisAngle(s, t) {
+    const e = Math.sin(t / 2);
+    return [Math.cos(t / 2), s[0] * e, s[1] * e, s[2] * e];
+  }
+  static rotX(s) {
+    return this.fromAxisAngle([1, 0, 0], s);
+  }
+  static rotY(s) {
+    return this.fromAxisAngle([0, 1, 0], s);
+  }
+  static rotZ(s) {
+    return this.fromAxisAngle([0, 0, 1], s);
+  }
+  static fromMatrix3(s) {
+    const t = Math.sqrt(1 + s[0][0] + s[1][1] + s[2][2]) / 2, e = (s[2][1] - s[1][2]) / (4 * t), i = (s[0][2] - s[2][0]) / (4 * t), n = (s[1][0] - s[0][1]) / (4 * t);
+    return [t, e, i, n];
+  }
+  static fromMatrix3Matlab(s) {
+    const t = Math.sqrt(1 + s[0][0] + s[1][1] + s[2][2]) / 2, e = (s[1][2] - s[2][1]) / (4 * t), i = (s[2][0] - s[0][2]) / (4 * t), n = (s[0][1] - s[1][0]) / (4 * t);
+    return [t, e, i, n];
+  }
+  static toMatrix3(s) {
+    const [t, e, i, n] = s, r = t * e, a = t * i, l = t * n, c = e * e, o = e * i, u = e * n, h = i * i, x = i * n, _ = n * n;
+    return [
+      [1 - 2 * (h + _), 2 * (o - l), 2 * (u + a)],
+      [2 * (o + l), 1 - 2 * (c + _), 2 * (x - r)],
+      [2 * (u - a), 2 * (x + r), 1 - 2 * (c + h)]
+    ];
+  }
+  static wxyz2xyzw(s) {
+    return [s[1], s[2], s[3], s[0]];
+  }
+  static xyzw2wxyz(s) {
+    return [s[3], s[0], s[1], s[2]];
+  }
+  static distance(s, t) {
+    return Math.acos(Math.min(2 * C.dot(s, t) ** 2 - 1, 1));
+  }
+  static equals(s, t) {
+    return C.distance(s, t) < 1e-8;
+  }
+  static normalize(s) {
+    const t = this.norm(s), e = new Array(4);
+    for (let i = 0; i < 4; i++)
+      e[i] = s[i] / t;
+    return e;
+  }
+  static norm(s) {
+    return Math.sqrt(s[0] ** 2 + s[1] ** 2 + s[2] ** 2 + s[3] ** 2);
+  }
+  static dot(s, t) {
+    return s[0] * t[0] + s[1] * t[1] + s[2] * t[2] + s[3] * t[3];
+  }
+  static getRotationBetweenTwoVectors(s, t) {
+    const e = m.normalize(s), i = m.normalize(t), n = m.dot(e, i);
+    let r;
+    if (n < -0.999999)
+      return r = m.cross([1, 0, 0], e), m.norm(r) < 1e-6 && (r = m.cross([0, 1, 0], e)), r = m.normalize(r), C.fromAxisAngle(r, Math.PI);
+    if (n > 0.999999)
+      return C.identity;
+    r = m.cross(e, i);
+    const a = [1 + n, r[0], r[1], r[2]];
+    return C.normalize(a);
+  }
+  static slerp(s, t, e) {
+    const i = s[1], n = s[2], r = s[3], a = s[0];
+    let l = t[1], c = t[2], o = t[3], u = t[0], h, x, _;
+    h = i * l + n * c + r * o + a * u, h < 0 && (h = -h, u = -u, l = -l, c = -c, o = -o);
+    const I = 1 - h < 1e-6;
+    if (I)
+      x = 1 - e, _ = e;
+    else {
+      const j = Math.acos(h), Nt = Math.sin(j);
+      x = Math.sin((1 - e) * j) / Nt, _ = Math.sin(e * j) / Nt;
+    }
+    let U = [
+      x * a + _ * u,
+      x * i + _ * l,
+      x * n + _ * c,
+      x * r + _ * o
+    ];
+    return I && (U = C.normalize(U)), U;
+  }
+  static toString(s) {
+    return `[${s[0].toFixed(2)}, ${s[1].toFixed(2)}, ${s[2].toFixed(2)}, ${s[3].toFixed(2)}]`;
+  }
+};
+let b = C;
+R(b, "ROTX_PI2", C.rotX(Math.PI / 2)), R(b, "ROTX_PI", C.rotX(Math.PI)), R(b, "ROTX_MPI2", C.rotX(-Math.PI / 2)), R(b, "ROTY_PI2", C.rotY(Math.PI / 2)), R(b, "ROTY_PI", C.rotY(Math.PI)), R(b, "ROTY_MPI2", C.rotY(-Math.PI / 2)), R(b, "ROTZ_PI2", C.rotZ(Math.PI / 2)), R(b, "ROTZ_PI", C.rotZ(Math.PI)), R(b, "ROTZ_MPI2", C.rotZ(-Math.PI / 2));
+function N(s) {
+  return s * (Math.PI / 180);
+}
+function at(s) {
+  return s * 180 / Math.PI;
+}
+function je(s, t) {
+  return Math.atan2(Math.sin(s - t), Math.cos(s - t));
+}
+function Qe(s, t) {
+  let e = Math.abs(je(s, t));
+  return e > Math.PI / 2 && (e = Math.PI - e), e;
+}
+function Je(s, t, e) {
+  const i = e - t, n = ((s - t) % i + i) % i + t;
+  return n === t ? e : n;
+}
+const w = class {
+  static checkType(s) {
+    if (s !== null && !(typeof s == "number" && !isNaN(s))) {
+      if (Array.isArray(s) && s.length === 2) {
+        const [t, e] = s;
+        if (typeof t == "number" && !isNaN(t) && typeof e == "number" && !isNaN(e)) {
+          if (t > e || t === e)
+            throw Error(`Invalid level range: [${t}, ${e}]`);
+          return;
+        }
+      }
+      throw Error(`Unknown level format: ${s}`);
+    }
+  }
+  static isRange(s) {
+    return w.VERIFY_TYPING && this.checkType(s), Array.isArray(s);
+  }
+  static clone(s) {
+    return w.VERIFY_TYPING && this.checkType(s), s === null ? null : typeof s == "number" ? s : [s[0], s[1]];
+  }
+  static fromString(s) {
+    if (s === null)
+      return null;
+    if (typeof s != "string")
+      throw Error(`argument must be a string, got ${typeof s}`);
+    if (!isNaN(Number(s)))
+      return parseFloat(s);
+    const t = s.split(";");
+    if (t.length === 2) {
+      const e = Number(t[0]), i = Number(t[1]);
+      return this.checkType([e, i]), [parseFloat(t[0]), parseFloat(t[1])];
+    }
+    throw Error(`Cannot parse following level: ${s}`);
+  }
+  static contains(s, t) {
+    return w.VERIFY_TYPING && (this.checkType(s), this.checkType(t)), s === t ? !0 : Array.isArray(s) ? Array.isArray(t) ? s[0] <= t[0] && s[1] >= t[1] : t === null ? !1 : s[0] <= t && s[1] >= t : s === null || t === null ? !1 : s <= t[0] && s >= t[1];
+  }
+  static intersection(s, t) {
+    if (w.VERIFY_TYPING && (this.checkType(s), this.checkType(t)), s === null || t === null)
+      return null;
+    if (this.equals(s, t))
+      return this.clone(s);
+    if (typeof s == "number" && typeof t == "number")
+      return s === t ? s : null;
+    if (Array.isArray(s) && !Array.isArray(t))
+      return this.contains(s, t) ? t : null;
+    if (!Array.isArray(s) && Array.isArray(t))
+      return this.contains(t, s) ? s : null;
+    const e = Math.max(s[0], t[0]), i = Math.min(s[1], t[1]);
+    return i === e ? i : i < e ? null : [e, i];
+  }
+  static intersect(s, t) {
+    return w.VERIFY_TYPING && (this.checkType(s), this.checkType(t)), s === null && t === null ? !0 : this.intersection(s, t) !== null;
+  }
+  static union(s, t) {
+    if (w.VERIFY_TYPING && (this.checkType(s), this.checkType(t)), s === t)
+      return this.clone(s);
+    if (t === null)
+      return this.clone(s);
+    if (s === null)
+      return this.clone(t);
+    let e, i;
+    return !Array.isArray(s) && !Array.isArray(t) ? (e = Math.min(s, t), i = Math.max(s, t)) : Array.isArray(s) && !Array.isArray(t) ? (e = Math.min(s[0], t), i = Math.max(s[1], t)) : !Array.isArray(s) && Array.isArray(t) ? (e = Math.min(t[0], s), i = Math.max(t[1], s)) : (e = Math.min(s[0], t[0]), i = Math.max(s[1], t[1])), e === i ? e : [e, i];
+  }
+  static multiplyBy(s, t) {
+    return w.VERIFY_TYPING && this.checkType(s), s === null ? null : Array.isArray(s) ? [s[0] * t, s[1] * t] : s * t;
+  }
+  static toString(s) {
+    return w.VERIFY_TYPING && this.checkType(s), s === null ? null : Array.isArray(s) ? s[0] + ";" + s[1] : String(s);
+  }
+  static equals(s, t) {
+    return w.VERIFY_TYPING && (this.checkType(s), this.checkType(t)), s === t ? !0 : Array.isArray(s) && Array.isArray(t) ? s[0] === t[0] && s[1] === t[1] : !1;
+  }
+  static diff(s, t) {
+    return w.VERIFY_TYPING && (this.checkType(s), this.checkType(t)), s === null || t === null ? null : !Array.isArray(s) && !Array.isArray(t) ? t - s : Array.isArray(s) && !Array.isArray(t) ? s[0] === t ? t - s[1] : s[1] === t ? t - s[0] : null : Array.isArray(t) && !Array.isArray(s) ? s === t[0] ? t[1] - s : s === t[1] ? t[0] - s : null : w.equals(s, t) ? 0 : null;
+  }
+};
+let f = w;
+d(f, "VERIFY_TYPING", !1);
+class g {
+  constructor(t, e, i = null, n = null) {
+    d(this, "_lat"), d(this, "_lng"), d(this, "_alt", null), d(this, "_level", null), d(this, "_ecef"), d(this, "autoWrap", !0), this.lat = t, this.lng = e, this.alt = i, this.level = n, this._ecef = null;
+  }
+  get lat() {
+    return this._lat;
+  }
+  set lat(t) {
+    if (Math.abs(t) <= 90)
+      this._lat = t;
+    else
+      throw new Error("lat argument is not in [-90; 90]");
+    this._ecef = null;
+  }
+  get latitude() {
+    return this._lat;
+  }
+  set latitude(t) {
+    throw new Error("Please use Coordinates#lat setter instead of Coordinate#latitude");
+  }
+  get lng() {
+    return this._lng;
+  }
+  set lng(t) {
+    this._lng = t, this.autoWrap && this.wrap(), this._ecef = null;
+  }
+  get longitude() {
+    return this._lng;
+  }
+  set longitude(t) {
+    throw new Error("Please use Coordinates#lng setter instead of Coordinate#longitude");
+  }
+  get alt() {
+    return this._alt;
+  }
+  set alt(t) {
+    this._alt = t, this._ecef = null;
+  }
+  get level() {
+    return this._level;
+  }
+  set level(t) {
+    f.checkType(t), this._level = t;
+  }
+  clone() {
+    const t = new g(this.lat, this.lng, this.alt);
+    return this.level !== null && (t.level = f.clone(this.level)), t;
+  }
+  wrap() {
+    (this._lng <= -180 || this._lng > 180) && (this._lng = Je(this._lng, -180, 180));
+  }
+  static equals(t, e, i = Ft, n = L) {
+    return t === null && t === e ? !0 : !(t instanceof g) || !(e instanceof g) ? !1 : Math.abs(e.lat - t.lat) < i && Math.abs(e.lng - t.lng) < i && (t.alt === e.alt || t.alt !== null && e.alt !== null && Math.abs(e.alt - t.alt) < n) && f.equals(t.level, e.level);
+  }
+  equals(t) {
+    return g.equals(this, t);
+  }
+  destinationPoint(t, e, i = null) {
+    const n = this.clone();
+    return n.move(t, e, i), n;
+  }
+  move(t, e, i = null) {
+    const n = t / 6378137, r = Math.cos(n), a = Math.sin(n), l = N(this.lat), c = N(this.lng), o = Math.asin(
+      Math.sin(l) * r + Math.cos(l) * a * Math.cos(e)
+    ), u = c + Math.atan2(
+      Math.sin(e) * a * Math.cos(l),
+      r - Math.sin(l) * Math.sin(o)
+    );
+    if (this.lat = at(o), this.lng = at(u), i !== null) {
+      if (this.alt === null)
+        throw new Error("Point altitude is not defined");
+      this.alt += i;
+    }
+    return this;
+  }
+  distanceTo(t) {
+    const e = this.lat, i = this.lng, n = t.lat, r = t.lng, a = N(n - e), l = N(r - i), c = Math.sin(l / 2), o = Math.sin(a / 2), u = N(e), h = Math.cos(u), x = N(n), _ = Math.cos(x), I = o * o + h * _ * c * c, U = Math.sqrt(I), j = Math.sqrt(1 - I);
+    return 6378137 * (2 * Math.atan2(U, j));
+  }
+  static distanceBetween(t, e) {
+    return t.distanceTo(e);
+  }
+  bearingTo(t) {
+    const e = N(this.lat), i = N(t.lat), n = N(t.lng - this.lng);
+    return Math.atan2(
+      Math.sin(n) * Math.cos(i),
+      Math.cos(e) * Math.sin(i) - Math.sin(e) * Math.cos(i) * Math.cos(n)
+    );
+  }
+  static bearingTo(t, e) {
+    return t.bearingTo(e);
+  }
+  get enuToEcefRotation() {
+    const t = b.fromAxisAngle([0, 0, 1], Math.PI / 2 + N(this.lng)), e = b.fromAxisAngle([1, 0, 0], Math.PI / 2 - N(this.lat));
+    return b.multiply(t, e);
+  }
+  get ecefToEnuRotation() {
+    const t = b.fromAxisAngle([1, 0, 0], N(this.lat) - Math.PI / 2), e = b.fromAxisAngle([0, 0, 1], -N(this.lng) - Math.PI / 2);
+    return b.multiply(t, e);
+  }
+  get ecef() {
+    if (!this._ecef) {
+      const t = N(this.lat), e = N(this.lng), i = this.alt || 0, n = (6378137 + i) * Math.cos(t) * Math.cos(e), r = (6378137 + i) * Math.cos(t) * Math.sin(e), a = (6378137 + i) * Math.sin(t);
+      this._ecef = [n, r, a];
+    }
+    return this._ecef;
+  }
+  static fromECEF(t) {
+    const e = t[0], i = t[1], n = t[2], r = Math.sqrt(e ** 2 + i ** 2);
+    let a = Math.atan2(i, e);
+    const l = Math.atan2(n, r), c = r / Math.cos(l) - 6378137;
+    a = a % (2 * Math.PI);
+    const o = new g(at(l), at(a), c);
+    return o._ecef = t, o;
+  }
+  getSegmentProjection(t, e) {
+    const i = m.normalize(t.ecef), n = m.normalize(e.ecef), r = m.normalize(this.ecef), a = m.cross(i, n);
+    if (m.norm(a) === 0)
+      return null;
+    const l = m.cross(r, a), c = m.normalize(m.cross(a, l)), o = m.multiplyScalar(c, 6378137), u = g.fromECEF(o);
+    let h;
+    t.alt !== null && e.alt !== null && (h = (t.alt + e.alt) / 2);
+    const x = new g(
+      u.lat,
+      u.lng,
+      h,
+      f.intersection(t.level, e.level)
+    );
+    return Math.abs(t.distanceTo(e) - t.distanceTo(x) - e.distanceTo(x)) > L ? null : x;
+  }
+  toString() {
+    let t = "[" + this._lat.toFixed(7) + ", " + this._lng.toFixed(7);
+    return this._alt !== null && (t += ", " + this._alt.toFixed(2)), this._level !== null && (t += ", [" + f.toString(this._level) + "]"), t += "]", t;
+  }
+  toJson() {
+    return {
+      lat: this.lat,
+      lng: this.lng,
+      ...this.alt !== null && { alt: this.alt },
+      ...this.level !== null && { level: this.level }
+    };
+  }
+  static fromJson(t) {
+    return new g(t.lat, t.lng, t.alt, t.level);
+  }
+  toCompressedJson() {
+    return this.level !== null ? [this.lat, this.lng, this.alt, this.level] : this.alt !== null ? [this.lat, this.lng, this.alt] : [this.lat, this.lng];
+  }
+  static fromCompressedJson(t) {
+    const e = new g(t[0], t[1]);
+    return t.length > 2 && (e.alt = t[2]), t.length > 3 && (e.level = t[3]), e;
+  }
+}
+class P extends g {
+  constructor(t, e, i = null, n = null, r = null, a = null, l = null) {
+    super(t, e, i, n), d(this, "_time", null), d(this, "_accuracy", null), d(this, "_bearing", null), this.time = r, this.accuracy = a, this.bearing = l;
+  }
+  get time() {
+    return this._time;
+  }
+  set time(t) {
+    this._time = t;
+  }
+  get accuracy() {
+    return this._accuracy;
+  }
+  set accuracy(t) {
+    if (t !== null && t < 0)
+      throw new Error("accuracy argument is not a positive number");
+    this._accuracy = t;
+  }
+  get bearing() {
+    return this._bearing;
+  }
+  set bearing(t) {
+    this._bearing = t !== null ? t % (2 * Math.PI) : null;
+  }
+  move(t, e, i = null) {
+    return super.move(t, e, i), this;
+  }
+  destinationPoint(t, e, i = null) {
+    const n = this.clone();
+    return n.move(t, e, i), n;
+  }
+  static fromCoordinates(t) {
+    return new P(
+      t.lat,
+      t.lng,
+      t.alt,
+      t.level
+    );
+  }
+  clone() {
+    const t = P.fromCoordinates(super.clone());
+    return t.time = this.time, t.accuracy = this.accuracy, t.bearing = this.bearing, t;
+  }
+  static equals(t, e, i = Ft, n = L) {
+    return t === null && t === e ? !0 : !(t instanceof P) || !(e instanceof P) || !super.equals(t, e, i, n) ? !1 : t.time === e.time && t.accuracy === e.accuracy && t.bearing === e.bearing;
+  }
+  equals(t, e = Ft, i = L) {
+    return P.equals(this, t, e, i);
+  }
+  toJson() {
+    return {
+      ...super.toJson(),
+      ...this.time !== null && { time: this.time },
+      ...this.accuracy !== null && { accuracy: this.accuracy },
+      ...this.bearing !== null && { bearing: this.bearing }
+    };
+  }
+  static fromJson(t) {
+    const e = P.fromCoordinates(g.fromJson(t));
+    return typeof t.time < "u" && (e.time = t.time), typeof t.accuracy < "u" && (e.accuracy = t.accuracy), typeof t.bearing < "u" && (e.bearing = t.bearing), e;
+  }
+}
+class Z {
+  constructor(t, e) {
+    if (d(this, "northEast"), d(this, "southWest"), this.northEast = t, this.southWest = e, this.northEast && this.southWest && this.getNorth() < this.getSouth())
+      throw new Error("Incorrect bounding box");
+  }
+  get center() {
+    const t = (this.southWest.lat + this.northEast.lat) / 2, e = (this.northEast.lng + this.southWest.lng) / 2;
+    return new g(t, e);
+  }
+  contains(t) {
+    return t.lat <= this.northEast.lat && t.lat >= this.southWest.lat && t.lng <= this.northEast.lng && t.lng >= this.southWest.lng;
+  }
+  extend(t) {
+    const e = this.southWest, i = this.northEast;
+    let n, r;
+    if (t instanceof g)
+      n = t, r = t;
+    else if (t instanceof Z)
+      n = t.southWest, r = t.northEast;
+    else
+      throw new Error("Unknown parameter");
+    return this.southWest = new g(
+      Math.min(n.lat, e.lat),
+      Math.min(n.lng, e.lng)
+    ), this.northEast = new g(
+      Math.max(r.lat, i.lat),
+      Math.max(r.lng, i.lng)
+    ), this;
+  }
+  extendsWithMeasure(t) {
+    if (typeof t != "number")
+      throw new Error("measure is not a number");
+    return this.northEast = this.northEast.destinationPoint(t, 0).move(t, Math.PI / 2), this.southWest = this.southWest.clone().destinationPoint(t, -Math.PI / 2).destinationPoint(t, Math.PI), this;
+  }
+  pad(t) {
+    const e = this.southWest, i = this.northEast, n = Math.abs(e.lat - i.lat) * t, r = Math.abs(e.lng - i.lng) * t;
+    return this.southWest = new g(e.lat - n, e.lng - r), this.northEast = new g(i.lat + n, i.lng + r), this;
+  }
+  getSouthWest() {
+    return this.southWest;
+  }
+  getNorthEast() {
+    return this.northEast;
+  }
+  getNorthWest() {
+    return new g(this.getNorth(), this.getWest());
+  }
+  getSouthEast() {
+    return new g(this.getSouth(), this.getEast());
+  }
+  getWest() {
+    return this.southWest.lng;
+  }
+  getSouth() {
+    return this.southWest.lat;
+  }
+  getEast() {
+    return this.northEast.lng;
+  }
+  getNorth() {
+    return this.northEast.lat;
+  }
+  static equals(t, e) {
+    return g.equals(t.northEast, e.northEast) && g.equals(t.southWest, e.southWest);
+  }
+  equals(t) {
+    return Z.equals(this, t);
+  }
+  static fromArray(t) {
+    return new Z(
+      new g(t[3], t[2]),
+      new g(t[1], t[0])
+    );
+  }
+  toArray() {
+    return [this.getWest(), this.getSouth(), this.getEast(), this.getNorth()];
+  }
+}
+class D {
+  constructor(t, e = null) {
+    d(this, "coords"), d(this, "edges", []), d(this, "builtFrom"), d(this, "io", !1), this.coords = t, this.builtFrom = e;
+  }
+  distanceTo(t) {
+    return this.coords.distanceTo(t.coords);
+  }
+  bearingTo(t) {
+    return this.coords.bearingTo(t.coords);
+  }
+  equals(t) {
+    return this.coords.equals(t.coords) && this.builtFrom === t.builtFrom;
+  }
+  clone() {
+    const t = new D(this.coords, this.builtFrom);
+    return t.edges = this.edges.slice(0), t.io = this.io, t;
+  }
+  toJson() {
+    return this.coords.toCompressedJson();
+  }
+  static fromJson(t, e = null) {
+    return new D(g.fromCompressedJson(t), e);
+  }
+  _generateLevelFromEdges() {
+    let t = null;
+    for (let e = 0; e < this.edges.length; e++) {
+      const i = this.edges[e];
+      if (i.level !== null) {
+        if (t === null)
+          t = f.clone(i.level);
+        else if (t = f.intersection(t, i.level), t === null)
+          throw Error("Something bad happend during parsing: We cannot retrieve node level from adjacent ways: " + this.coords);
+      }
+    }
+    this.coords.level = t;
+  }
+  _inferNodeLevelByRecursion() {
+    const { level: t } = this.coords;
+    if (t === null || !f.isRange(t) || this.edges.length > 1)
+      return;
+    const e = (n, r) => {
+      if (r.push(n), n.coords.level === null)
+        return null;
+      if (!f.isRange(n.coords.level))
+        return n.coords.level;
+      let a = null;
+      for (let l = 0; l < n.edges.length; l++) {
+        const c = n.edges[l], o = c.node1 === n ? c.node2 : c.node1;
+        r.includes(o) || (a = f.union(e(o, r), a));
+      }
+      return a;
+    }, i = e(this, []);
+    if (i !== null) {
+      if (!f.isRange(i)) {
+        this.coords.level = i === t[0] ? t[1] : t[0];
+        return;
+      }
+      throw Error("Level of: " + this.coords.toString() + " cannot be decided");
+    }
+  }
+  _inferNodeLevelByNeighboors() {
+    const { level: t } = this.coords;
+    if (t === null || !f.isRange(t))
+      return !0;
+    let e = null;
+    for (let i = 0; i < this.edges.length; i++) {
+      const n = this.edges[i], r = n.node1 === this ? n.node2 : n.node1;
+      e = f.union(r.coords.level, e);
+    }
+    return (e === null || !f.isRange(e)) && (this.coords.level = e === t[0] ? t[1] : t[0]), !0;
+  }
+  _checkIO() {
+    return this.io = this.coords.level !== null && this.edges.some((t) => t.level === null), !0;
+  }
+  static generateNodesLevels(t) {
+    t.forEach((e) => e._generateLevelFromEdges()), t.forEach((e) => e._inferNodeLevelByNeighboors()), t.forEach((e) => e._inferNodeLevelByRecursion()), t.forEach((e) => e._checkIO());
+  }
+}
+class $ {
+  constructor(t, e, i = null, n = null) {
+    d(this, "_node1"), d(this, "_node2"), d(this, "_level", null), d(this, "_bearing", null), d(this, "_length", null), d(this, "_computedSizeAndBearing", !1), d(this, "builtFrom"), d(this, "isOneway", !1), this.node1 = t, this.node2 = e, this.level = i, this.builtFrom = n;
+  }
+  get node1() {
+    return this._node1;
+  }
+  set node1(t) {
+    if (!(t instanceof D))
+      throw new TypeError("node1 is not a GraphNode");
+    this._node1 instanceof D && this._node2 !== this._node1 && (this._node1.edges = this._node1.edges.filter((e) => e !== this)), t.edges.push(this), this._node1 = t, this._computedSizeAndBearing = !1;
+  }
+  get node2() {
+    return this._node2;
+  }
+  set node2(t) {
+    if (!(t instanceof D))
+      throw new TypeError("node2 is not a GraphNode");
+    this._node2 instanceof D && this._node2 !== this._node1 && (this._node2.edges = this._node2.edges.filter((e) => e !== this)), t.edges.push(this), this._node2 = t, this._computedSizeAndBearing = !1;
+  }
+  get level() {
+    return this._level;
+  }
+  set level(t) {
+    f.checkType(t), this._level = t;
+  }
+  get bearing() {
+    return this._computedSizeAndBearing || this._computeSizeAndBearing(), this._bearing;
+  }
+  get length() {
+    return this._computedSizeAndBearing || this._computeSizeAndBearing(), this._length;
+  }
+  _computeSizeAndBearing() {
+    this._length = this.node1.distanceTo(this.node2), this._bearing = this.node1.bearingTo(this.node2), this._computedSizeAndBearing = !0;
+  }
+  equals(t) {
+    return this === t ? !0 : t instanceof $ ? t.node1.equals(this.node1) && t.node2.equals(this.node2) && f.equals(t.level, this.level) && t.isOneway === this.isOneway && t.builtFrom === this.builtFrom : !1;
+  }
+  clone() {
+    const t = new $(this.node1, this.node2, this.level, this.builtFrom);
+    return t.isOneway = this.isOneway, t;
+  }
+}
+function Ke(s, t, e) {
+  return s.find(
+    (i) => t === i.node1 && e === i.node2 || e === i.node1 && t === i.node2
+  );
+}
+class lt {
+  constructor(t, e) {
+    d(this, "nodes"), d(this, "edges"), this.nodes = Array.isArray(t) ? t : [], this.edges = Array.isArray(e) ? e : [];
+  }
+  getNodeByCoords(t) {
+    return this.nodes.find((e) => e.coords.equals(t));
+  }
+  getEdgeByNodes(t, e) {
+    return Ke(this.edges, t, e);
+  }
+  getBoundingBox(t) {
+    if (!this.nodes.length)
+      return null;
+    const e = this.nodes.reduce(
+      (i, n) => i.extend(n.coords),
+      new Z(this.nodes[0].coords, this.nodes[0].coords)
+    );
+    return t && e.extendsWithMeasure(t), e;
+  }
+  toDetailedString(t, e) {
+    let i = t;
+    i || (i = (a) => `${a.builtFrom}`);
+    let n = e;
+    e || (n = (a) => `${a.builtFrom}`);
+    let r = `--- Network ---
+Nodes: ${this.nodes.length}
+Edges: ${this.edges.length}
+---
+Nodes
+`;
+    return this.nodes.forEach((a) => {
+      r += `${i(a)} [edges: ${a.edges.length}]
+`;
+    }), r += `---
+Edges
+`, this.edges.forEach((a) => {
+      r += `${n(a)} `, r += `[${i(a.node1)} -- ${i(a.node2)}]
+`;
+    }), r += "---", r;
+  }
+  toCompressedJson() {
+    return {
+      nodes: this.nodes.map((t) => t.toJson()),
+      edges: this.edges.map((t) => {
+        const e = this.nodes.indexOf(t.node1), i = this.nodes.indexOf(t.node2);
+        return t.isOneway ? [e, i, t.level, !0] : t.level ? [e, i, t.level] : [e, i];
+      })
+    };
+  }
+  static fromCompressedJson(t) {
+    const e = new lt();
+    return e.nodes = t.nodes.map((i) => D.fromJson(i, null)), e.edges = t.edges.map((i) => {
+      const n = new $(
+        e.nodes[i[0]],
+        e.nodes[i[1]],
+        i[2],
+        null
+      );
+      return i.length > 3 && i[3] && (n.isOneway = !0), n;
+    }), e;
+  }
+  static fromCoordinates(t) {
+    const e = new lt(), i = (r) => {
+      const a = e.nodes.find((c) => c.coords.equals(r));
+      if (a)
+        return a;
+      const l = new D(r, null);
+      return e.nodes.push(l), l;
+    }, n = (r, a) => new $(r, a, f.union(r.coords.level, a.coords.level), null);
+    for (const r of t) {
+      let a = null;
+      for (const l of r) {
+        const c = i(l);
+        if (a) {
+          const o = n(c, a);
+          e.edges.push(o);
+        }
+        a = c;
+      }
+    }
+    return e;
+  }
+  getEdgesAtLevel(t, e = !0) {
+    return this.edges.filter(
+      ({ level: i }) => e ? f.intersect(t, i) : f.contains(t, i)
+    );
+  }
+}
+class Ze {
+  constructor(t, e, i, n) {
+    d(this, "origin"), d(this, "distanceFromNearestElement"), d(this, "coords"), d(this, "nearestElement"), this.origin = t, this.distanceFromNearestElement = e, this.coords = i, this.nearestElement = n;
+  }
+}
+const H = class {
+  constructor(s = null) {
+    d(this, "network", null), d(this, "_maxDistance", Number.MAX_VALUE), d(this, "_maxAngleBearing", Math.PI), this.network = s;
+  }
+  set maxAngleBearing(s) {
+    this._maxAngleBearing = s;
+  }
+  get maxAngleBearing() {
+    return this._maxAngleBearing;
+  }
+  set maxDistance(s) {
+    this._maxDistance = s;
+  }
+  get maxDistance() {
+    return this._maxDistance;
+  }
+  _shouldProjectOnEdgeAndNodes(s, t, e, i, n) {
+    if (!n(s))
+      return [!1, !1, !1];
+    let r = f.intersect(t.level, s.level), a = f.intersect(t.level, s.node1.coords.level), l = f.intersect(t.level, s.node2.coords.level);
+    return a = a || s.node1.io && t.level === null, l = l || s.node2.io && t.level === null, i || (r = r && !f.isRange(s.level), a = a && !f.isRange(s.node1.coords.level), l = l && !f.isRange(s.node2.coords.level)), e && (r && Qe(s.bearing, t.bearing) > this._maxAngleBearing && (r = !1), a = !1, l = !1), [r, a, l];
+  }
+  static _assignLatLngLevel(s, t) {
+    t.lat = s.lat, t.lng = s.lng, t.level = f.clone(s.level);
+  }
+  static _handleLevelsWithIONodes(s, t, e) {
+    t.level === null && e.io && (s.level = null);
+  }
+  getProjection(s, t = !1, e = !1, i = !0, n = () => !0) {
+    if (this.network === null)
+      throw new Error("Network has not been set yet");
+    if (!(s instanceof g))
+      throw new TypeError("location is not an instance of Coordinates");
+    if (e && (!("bearing" in s && s.bearing !== null) || !this._maxAngleBearing))
+      return null;
+    let r = Number.MAX_VALUE;
+    const a = s.clone();
+    let l = null;
+    const c = (o) => o < r && (!t || o <= this._maxDistance);
+    for (const o of this.network.edges) {
+      const [u, h, x] = this._shouldProjectOnEdgeAndNodes(
+        o,
+        s,
+        e,
+        i,
+        n
+      );
+      if (h) {
+        const _ = s.distanceTo(o.node1.coords);
+        if ((c(_) || _ <= L) && (r = _, l = o.node1, H._assignLatLngLevel(o.node1.coords, a), H._handleLevelsWithIONodes(a, s, o.node1), _ <= L))
+          break;
+      }
+      if (x) {
+        const _ = s.distanceTo(o.node2.coords);
+        if ((c(_) || _ <= L) && (r = _, l = o.node2, H._assignLatLngLevel(o.node2.coords, a), H._handleLevelsWithIONodes(a, s, o.node2), _ <= L))
+          break;
+      }
+      if (u) {
+        const _ = s.getSegmentProjection(o.node1.coords, o.node2.coords);
+        if (_) {
+          const I = s.distanceTo(_);
+          c(I) && (r = I, l = o, H._assignLatLngLevel(_, a), H._updateProjectionLevelFromEdge(o, a));
+        }
+      }
+    }
+    return l ? (a instanceof P && a.accuracy !== null && (a.accuracy += r), new Ze(
+      s,
+      r,
+      a,
+      l
+    )) : null;
+  }
+};
+let ts = H;
+d(ts, "_updateProjectionLevelFromEdge", (s, t) => {
+  t.level = f.clone(s.level);
+});
+var es = Object.defineProperty, ss = (s, t, e) => t in s ? es(s, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : s[t] = e, X = (s, t, e) => (ss(s, typeof t != "symbol" ? t + "" : t, e), e);
+const rt = [
+  "error",
+  "ok",
+  "warn",
+  "flux",
+  "deprecated",
+  "info",
+  "log",
+  "debug"
+];
+function is(s) {
+  return "wemap" in s;
+}
+const p = class {
+  static enable(s) {
+    p.ENABLED = Boolean(s);
+  }
+  static level(s) {
+    return arguments.length && (p.LOG_LEVEL = s), p.LOG_LEVEL;
+  }
+  static clearHistory() {
+    p.HISTORY = [];
+  }
+  static _canUseLog(s) {
+    const t = rt.indexOf(s), e = rt.indexOf(p.LOG_LEVEL);
+    return e === -1 ? !1 : t <= e;
+  }
+  static _getColorByType(s) {
+    let t = null;
+    switch (s) {
+      case "flux":
+        t = "background: #0083E0; color: #FFFFFF;";
+        break;
+      case "ok":
+        t = "background: #00FF22; color: #272727;";
+        break;
+      case "deprecated":
+        t = "background: #CA0AFA; color: #FFFFFF;";
+        break;
+      case "error":
+        t = "background: #CC0000; color: #FFFFFF;";
+        break;
+      case "warn":
+        t = "background: #DD7908; color: #FFFFFF;";
+        break;
+      case "debug":
+        t = "background: #999999; color: #FFFFFF;";
+        break;
+      case "info":
+        t = "background: #DCFF4E; color: #000000;";
+        break;
+      default:
+        t = "background: #F4F4F4; color: #999999;";
+        break;
+    }
+    return t;
+  }
+  static _getOriginByType(s, t) {
+    let e = null, i = null, n = t;
+    if (arguments.length < 2)
+      return "";
+    try {
+      for (e = "", i = s.stack && s.stack.length ? s.stack.split(`
+`).splice(3) : [], (n < 0 || n >= i.length) && (n = i.length); n; )
+        e += `\r
+	` + i[0].trim(), i = i.splice(1), n--;
+      return e;
+    } catch {
+      return "";
+    }
+  }
+  static _log(s, t, e) {
+    const i = "color: auto;", n = "color: #6A6A6A;";
+    let r, a = null, l = null, c = null, o = null, u = "", h = !1;
+    if (a = s, o = new Error(t), l = p._getColorByType(s), c = p._getOriginByType(o, e), a === "deprecated" && (a = "warn", h = "deprecated"), c = p._COLOR_TOKEN + c, r = p._COLOR_TOKEN + " " + o.message, u = p._COLOR_TOKEN, u += p._TYPE_PREFIX, u += h || s, u += p._TYPE_SUFFIX, typeof window < "u" && is(window)) {
+      const x = performance && performance.now ? performance.now() : new Date().getTime();
+      u += "[" + Math.round(x - window.wemap.startTime) + "ms]";
+    }
+    return r = u + r + c, p.HISTORY.push(r), !this._canUseLog(s) || arguments.length < 2 || !p.ENABLED ? !1 : (console && s !== "ok" && s !== "flux" && s !== "deprecated" && console[s] && rt.indexOf(s) <= rt.indexOf("info") ? console[s](r, l, i, n) : console.log(r, l, i, n), !0);
+  }
+  static external(s) {
+    return console.log("LIVEMAP :: " + s);
+  }
+  static flux(s) {
+    return p._log("flux", s, 0);
+  }
+  static ok(s) {
+    return p._log("ok", s, 1);
+  }
+  static error(s, t = -1) {
+    return p._log("error", s, t);
+  }
+  static warn(s, t = 2) {
+    return p._log("warn", s, t);
+  }
+  static deprecated(s, t = 2) {
+    return p._log("deprecated", s, t);
+  }
+  static debug(s, t = -1) {
+    return p._log("debug", s, t);
+  }
+  static info(s, t = 0) {
+    return p._log("info", s, t);
+  }
+  static log(s, t = 1) {
+    return p._log("log", s, t);
+  }
+};
+let q = p;
+X(q, "LOG_LEVEL", "debug"), X(q, "ENABLED", !0), X(q, "HISTORY", []), X(q, "_COLOR_TOKEN", "%c"), X(q, "_TYPE_PREFIX", "<<<< "), X(q, "_TYPE_SUFFIX", " >>>>");
+class Ht extends $t {
+  constructor(e, i, n = null) {
+    super(e, i);
+    M(this, "nodes", []);
+    M(this, "level", null);
+    this.level = n;
   }
   get areStairs() {
     return this.tags.highway === "steps";
@@ -73,224 +1997,142 @@ class OsmWay extends OsmElement {
     return this.nodes[0] === this.nodes[this.nodes.length - 1];
   }
 }
-class OsmParser {
-  static parseOsmXmlString(osmXmlString) {
-    const model = new OsmModel();
-    const parser = new saxes.SaxesParser();
-    let buffer;
-    const isDeleted = (element) => element.attributes.action && element.attributes.action === "delete";
-    parser.on("opentag", (node) => {
-      switch (node.name) {
+class cs {
+  static parseOsmXmlString(t) {
+    const e = new Zt(), i = new qe();
+    let n;
+    const r = (a) => a.attributes.action && a.attributes.action === "delete";
+    i.on("opentag", (a) => {
+      switch (a.name) {
         case "node": {
-          if (isDeleted(node)) {
-            buffer = null;
+          if (r(a)) {
+            n = null;
             break;
           }
-          const osmNode = this._parseNode(node.attributes);
-          buffer = osmNode;
-          model.nodes.push(osmNode);
+          const l = this._parseNode(a.attributes);
+          n = l, e.nodes.push(l);
           break;
         }
         case "way": {
-          if (isDeleted(node)) {
-            buffer = null;
+          if (r(a)) {
+            n = null;
             break;
           }
-          const osmWay = this._parseWay(node.attributes);
-          buffer = osmWay;
-          model.ways.push(osmWay);
+          const l = this._parseWay(a.attributes);
+          n = l, e.ways.push(l);
           break;
         }
         case "tag": {
-          if (!buffer) {
+          if (!n)
             return;
-          }
           const {
-            k,
-            v
-          } = node.attributes;
-          buffer.tags[k] = v;
+            k: l,
+            v: c
+          } = a.attributes;
+          n.tags[l] = c;
           break;
         }
         case "nd": {
-          if (!buffer || !(buffer instanceof OsmWay)) {
+          if (!n || !(n instanceof Ht))
             return;
-          }
-          const nodeId = Number(node.attributes.ref);
-          const refNode = model.getNodeById(nodeId);
-          if (!refNode) {
-            throw Error("Node: " + nodeId + " in way " + buffer.id + " not found");
-          }
-          buffer.nodes.push(refNode);
-          refNode.ways.push(buffer);
+          const l = Number(a.attributes.ref), c = e.getNodeById(l);
+          if (!c)
+            throw Error("Node: " + l + " in way " + n.id + " not found");
+          n.nodes.push(c), c.ways.push(n);
           break;
         }
       }
-    });
-    parser.write(osmXmlString);
-    for (let i = 0; i < model.ways.length; i++) {
-      const way = model.ways[i];
-      if (way.tags.level) {
-        way.level = geo.Level.fromString(way.tags.level);
-      }
+    }), i.write(t);
+    for (let a = 0; a < e.ways.length; a++) {
+      const l = e.ways[a];
+      l.tags.level && (l.level = f.fromString(l.tags.level));
     }
-    return model;
+    return e;
   }
-  static _parseNode(attr) {
-    return new OsmNode(
-      Number(attr.id),
-      new geo.Coordinates(Number(attr.lat), Number(attr.lon))
+  static _parseNode(t) {
+    return new te(
+      Number(t.id),
+      new g(Number(t.lat), Number(t.lon))
     );
   }
-  static _parseWay(attr) {
-    return new OsmWay(Number(attr.id));
+  static _parseWay(t) {
+    return new Ht(Number(t.id));
   }
 }
-class OsmGraphNode$1 extends geo.GraphNode {
-}
-class OsmGraphNode extends geo.GraphEdge {
-}
-class OsmGraphItinerary extends geo.GraphItinerary {
-  static fromNetworkNodes(start, end, networkNodes, edgesWeights) {
-    return super.fromNetworkNodes(start, end, networkNodes, edgesWeights);
-  }
-}
-class OsmNetwork extends geo.Network {
-  static fromCoordinates(segments) {
-    return super.fromCoordinates(segments);
-  }
-}
-class OsmGraphProjection extends geo.GraphProjection {
-}
-class OsmGraphRouter extends geo.GraphRouter {
-}
-class OsmGraphRouterOptions extends geo.GraphRouterOptions {
+const jt = ["footway", "steps", "pedestrian", "living_street", "path", "track", "sidewalk"], Qt = (s) => jt.includes(s.tags.highway) || s.tags.footway === "sidewalk" || s.tags.public_transport === "platform" || s.tags.railway === "platform";
+function ns(s, t) {
+  return s.nodes.find(({ builtFrom: e }) => (e == null ? void 0 : e.tags.name) === t);
 }
-class OsmMapMatching extends geo.MapMatching {
+function as(s, t) {
+  return s.edges.find(({ builtFrom: e }) => (e == null ? void 0 : e.tags.name) === t);
 }
-const HIGHWAYS_PEDESTRIANS = ["footway", "steps", "pedestrian", "living_street", "path", "track", "sidewalk"];
-const DEFAULT_WAY_SELECTOR = (way) => {
-  return HIGHWAYS_PEDESTRIANS.includes(way.tags.highway) || way.tags.footway === "sidewalk" || way.tags.public_transport === "platform" || way.tags.railway === "platform";
-};
-function getNodeByName(network, name) {
-  return network.nodes.find(({ builtFrom }) => (builtFrom == null ? void 0 : builtFrom.tags.name) === name);
-}
-function getEdgeByName(network, name) {
-  return network.edges.find(({ builtFrom }) => (builtFrom == null ? void 0 : builtFrom.tags.name) === name);
-}
-function manageOneWay(edge, way) {
-  const { highway, oneway, conveying } = way.tags;
-  edge.isOneway = Boolean(oneway === "yes" || oneway === "true" || oneway === "1" || conveying && highway && ["forward", "backward"].includes(conveying));
-  if (edge.isOneway && conveying === "backward") {
-    const tmpNode = edge.node1;
-    edge.node1 = edge.node2;
-    edge.node2 = tmpNode;
+function rs(s, t) {
+  const { highway: e, oneway: i, conveying: n } = t.tags;
+  if (s.isOneway = Boolean(i === "yes" || i === "true" || i === "1" || n && e && ["forward", "backward"].includes(n)), s.isOneway && n === "backward") {
+    const r = s.node1;
+    s.node1 = s.node2, s.node2 = r;
   }
 }
-function createNodesAndEdgesFromElevator(nodes, edges, elevatorNode) {
-  const createdNodes = [];
-  const getOrCreateLevelNode = (level, builtFrom) => {
-    let levelNode = createdNodes.find(({ coords }) => geo.Level.equals(level, coords.level));
-    if (!levelNode) {
-      levelNode = new OsmGraphNode$1(elevatorNode.coords.clone(), builtFrom);
-      levelNode.coords.level = level;
-      createdNodes.push(levelNode);
-      nodes.push(levelNode);
-    }
-    return levelNode;
+function os(s, t, e) {
+  const i = [], n = (a, l) => {
+    let c = i.find(({ coords: o }) => f.equals(a, o.level));
+    return c || (c = new D(e.coords.clone(), l), c.coords.level = a, i.push(c), s.push(c)), c;
   };
-  elevatorNode.edges.forEach((edge) => {
-    if (geo.Level.isRange(edge.level)) {
+  e.edges.forEach((a) => {
+    if (f.isRange(a.level))
       throw new Error("Cannot handle this elevator edge due to ambiguity");
-    }
-    const levelNode = getOrCreateLevelNode(edge.level, elevatorNode.builtFrom);
-    if (edge.node1 === elevatorNode) {
-      edge.node1 = levelNode;
-    } else {
-      edge.node2 = levelNode;
-    }
-    levelNode.edges.push(edge);
+    const l = n(a.level, e.builtFrom);
+    a.node1 === e ? a.node1 = l : a.node2 = l, l.edges.push(a);
   });
-  for (let i = 0; i < createdNodes.length; i++) {
-    for (let j = i + 1; j < createdNodes.length; j++) {
-      const createdNode1 = createdNodes[i];
-      const createdNode2 = createdNodes[j];
-      if (createdNode1.coords.level === null || createdNode2.coords.level === null) {
+  for (let a = 0; a < i.length; a++)
+    for (let l = a + 1; l < i.length; l++) {
+      const c = i[a], o = i[l];
+      if (c.coords.level === null || o.coords.level === null)
         continue;
-      }
-      const minLevel = Math.min(createdNode1.coords.level, createdNode2.coords.level);
-      const maxLevel = Math.max(createdNode1.coords.level, createdNode2.coords.level);
-      const newEdge = new OsmGraphNode(
-        createdNode1,
-        createdNode2,
-        [minLevel, maxLevel],
-        elevatorNode.builtFrom
+      const u = Math.min(c.coords.level, o.coords.level), h = Math.max(c.coords.level, o.coords.level), x = new $(
+        c,
+        o,
+        [u, h],
+        e.builtFrom
       );
-      edges.push(newEdge);
+      t.push(x);
     }
-  }
-  const elevatorNodeIndex = nodes.indexOf(elevatorNode);
-  if (elevatorNodeIndex > -1) {
-    nodes.splice(elevatorNodeIndex, 1);
-  }
+  const r = s.indexOf(e);
+  r > -1 && s.splice(r, 1);
 }
-function createNetworkFromOsmModel(osmModel, waySelectionFilter = DEFAULT_WAY_SELECTOR) {
-  const nodes = [];
-  const edges = [];
-  const nodesCreated = {};
-  const elevatorNodes = [];
-  const getOrCreateNode = (osmNode) => {
-    let node = nodesCreated[osmNode.id];
-    if (!node) {
-      node = new OsmGraphNode$1(osmNode.coords, osmNode);
-      nodesCreated[osmNode.id] = node;
-      nodes.push(node);
-      if (osmNode.tags.highway === "elevator") {
-        elevatorNodes.push(node);
-      }
-    }
-    return node;
+function ls(s, t = Qt) {
+  const e = [], i = [], n = {}, r = [], a = (c) => {
+    let o = n[c.id];
+    return o || (o = new D(c.coords, c), n[c.id] = o, e.push(o), c.tags.highway === "elevator" && r.push(o)), o;
   };
-  osmModel.ways.forEach((way) => {
-    if (!waySelectionFilter(way)) {
+  s.ways.forEach((c) => {
+    if (!t(c))
       return;
+    let o = a(c.nodes[0]);
+    for (let u = 1; u < c.nodes.length; u++) {
+      const h = a(c.nodes[u]), x = new $(o, h, c.level, c);
+      rs(x, c), i.push(x), o = h;
     }
-    let firstNode = getOrCreateNode(way.nodes[0]);
-    for (let i = 1; i < way.nodes.length; i++) {
-      const secondNode = getOrCreateNode(way.nodes[i]);
-      const edge = new OsmGraphNode(firstNode, secondNode, way.level, way);
-      manageOneWay(edge, way);
-      edges.push(edge);
-      firstNode = secondNode;
-    }
-  });
-  elevatorNodes.forEach((node) => {
-    createNodesAndEdgesFromElevator(nodes, edges, node);
+  }), r.forEach((c) => {
+    os(e, i, c);
   });
-  const networkModel = new OsmNetwork(nodes, edges);
-  OsmGraphNode$1.generateNodesLevels(networkModel.nodes);
-  return networkModel;
+  const l = new lt(e, i);
+  return D.generateNodesLevels(l.nodes), l;
 }
-const OsmNetworkUtils = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const us = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  HIGHWAYS_PEDESTRIANS,
-  DEFAULT_WAY_SELECTOR,
-  getNodeByName,
-  getEdgeByName,
-  createNetworkFromOsmModel
+  HIGHWAYS_PEDESTRIANS: jt,
+  DEFAULT_WAY_SELECTOR: Qt,
+  getNodeByName: ns,
+  getEdgeByName: as,
+  createNetworkFromOsmModel: ls
 }, Symbol.toStringTag, { value: "Module" }));
-exports.OsmElement = OsmElement;
-exports.OsmGraphEdge = OsmGraphNode;
-exports.OsmGraphItinerary = OsmGraphItinerary;
-exports.OsmGraphNode = OsmGraphNode$1;
-exports.OsmGraphProjection = OsmGraphProjection;
-exports.OsmGraphRouter = OsmGraphRouter;
-exports.OsmGraphRouterOptions = OsmGraphRouterOptions;
-exports.OsmMapMatching = OsmMapMatching;
-exports.OsmModel = OsmModel;
-exports.OsmNetwork = OsmNetwork;
-exports.OsmNetworkUtils = OsmNetworkUtils;
-exports.OsmNode = OsmNode;
-exports.OsmParser = OsmParser;
-exports.OsmWay = OsmWay;
+export {
+  $t as OsmElement,
+  Zt as OsmModel,
+  us as OsmNetworkUtils,
+  te as OsmNode,
+  cs as OsmParser,
+  Ht as OsmWay
+};
 //# sourceMappingURL=index.js.map