@nika-js/onlymap 0.1.0

package/dist/index-C9w78NS9.js

@@ -0,0 +1,4883 @@
+import { a2 as _t, a3 as Ct } from "./index-CU-iOTdr.js";
+function Yt(e, r, t = 2, i, o = "xy") {
+  const s = r && r.length, l = s ? r[0] * t : e.length;
+  let c = Ut(e, 0, l, t, !0, i && i[0], o);
+  const p = [];
+  if (!c || c.next === c.prev)
+    return p;
+  let g, D, d, E, S, C, m;
+  if (s && (c = tu(e, r, c, t, i, o)), e.length > 80 * t) {
+    E = D = e[0], S = d = e[1];
+    for (let N = t; N < l; N += t)
+      C = e[N], m = e[N + 1], C < E && (E = C), m < S && (S = m), C > D && (D = C), m > d && (d = m);
+    g = Math.max(D - E, d - S), g = g !== 0 ? 32767 / g : 0;
+  }
+  return Ie(c, p, t, E, S, g, 0), p;
+}
+function Ut(e, r, t, i, o, s, l) {
+  let c, p;
+  s === void 0 && (s = _t(e, { start: r, end: t, size: i, plane: l }));
+  let g = Ct[l[0]], D = Ct[l[1]];
+  if (o === s < 0)
+    for (c = r; c < t; c += i)
+      p = bt(c, e[c + g], e[c + D], p);
+  else
+    for (c = t - i; c >= r; c -= i)
+      p = bt(c, e[c + g], e[c + D], p);
+  return p && Xe(p, p.next) && (qe(p), p = p.next), p;
+}
+function ye(e, r) {
+  if (!e)
+    return e;
+  r || (r = e);
+  let t = e, i;
+  do
+    if (i = !1, !t.steiner && (Xe(t, t.next) || X(t.prev, t, t.next) === 0)) {
+      if (qe(t), t = r = t.prev, t === t.next)
+        break;
+      i = !0;
+    } else
+      t = t.next;
+  while (i || t !== r);
+  return r;
+}
+function Ie(e, r, t, i, o, s, l) {
+  if (!e)
+    return;
+  !l && s && ou(e, i, o, s);
+  let c = e, p, g;
+  for (; e.prev !== e.next; ) {
+    if (p = e.prev, g = e.next, s ? Qt(e, i, o, s) : Kt(e)) {
+      r.push(p.i / t | 0), r.push(e.i / t | 0), r.push(g.i / t | 0), qe(e), e = g.next, c = g.next;
+      continue;
+    }
+    if (e = g, e === c) {
+      l ? l === 1 ? (e = Jt(ye(e), r, t), Ie(e, r, t, i, o, s, 2)) : l === 2 && eu(e, r, t, i, o, s) : Ie(ye(e), r, t, i, o, s, 1);
+      break;
+    }
+  }
+}
+function Kt(e) {
+  const r = e.prev, t = e, i = e.next;
+  if (X(r, t, i) >= 0)
+    return !1;
+  const o = r.x, s = t.x, l = i.x, c = r.y, p = t.y, g = i.y, D = o < s ? o < l ? o : l : s < l ? s : l, d = c < p ? c < g ? c : g : p < g ? p : g, E = o > s ? o > l ? o : l : s > l ? s : l, S = c > p ? c > g ? c : g : p > g ? p : g;
+  let C = i.next;
+  for (; C !== r; ) {
+    if (C.x >= D && C.x <= E && C.y >= d && C.y <= S && Be(o, c, s, p, l, g, C.x, C.y) && X(C.prev, C, C.next) >= 0)
+      return !1;
+    C = C.next;
+  }
+  return !0;
+}
+function Qt(e, r, t, i) {
+  const o = e.prev, s = e, l = e.next;
+  if (X(o, s, l) >= 0)
+    return !1;
+  const c = o.x, p = s.x, g = l.x, D = o.y, d = s.y, E = l.y, S = c < p ? c < g ? c : g : p < g ? p : g, C = D < d ? D < E ? D : E : d < E ? d : E, m = c > p ? c > g ? c : g : p > g ? p : g, N = D > d ? D > E ? D : E : d > E ? d : E, P = it(S, C, r, t, i), R = it(m, N, r, t, i);
+  let w = e.prevZ, y = e.nextZ;
+  for (; w && w.z >= P && y && y.z <= R; ) {
+    if (w.x >= S && w.x <= m && w.y >= C && w.y <= N && w !== o && w !== l && Be(c, D, p, d, g, E, w.x, w.y) && X(w.prev, w, w.next) >= 0 || (w = w.prevZ, y.x >= S && y.x <= m && y.y >= C && y.y <= N && y !== o && y !== l && Be(c, D, p, d, g, E, y.x, y.y) && X(y.prev, y, y.next) >= 0))
+      return !1;
+    y = y.nextZ;
+  }
+  for (; w && w.z >= P; ) {
+    if (w.x >= S && w.x <= m && w.y >= C && w.y <= N && w !== o && w !== l && Be(c, D, p, d, g, E, w.x, w.y) && X(w.prev, w, w.next) >= 0)
+      return !1;
+    w = w.prevZ;
+  }
+  for (; y && y.z <= R; ) {
+    if (y.x >= S && y.x <= m && y.y >= C && y.y <= N && y !== o && y !== l && Be(c, D, p, d, g, E, y.x, y.y) && X(y.prev, y, y.next) >= 0)
+      return !1;
+    y = y.nextZ;
+  }
+  return !0;
+}
+function Jt(e, r, t) {
+  let i = e;
+  do {
+    const o = i.prev, s = i.next.next;
+    !Xe(o, s) && Mt(o, i, i.next, s) && Re(o, s) && Re(s, o) && (r.push(o.i / t | 0), r.push(i.i / t | 0), r.push(s.i / t | 0), qe(i), qe(i.next), i = e = s), i = i.next;
+  } while (i !== e);
+  return ye(i);
+}
+function eu(e, r, t, i, o, s) {
+  let l = e;
+  do {
+    let c = l.next.next;
+    for (; c !== l.prev; ) {
+      if (l.i !== c.i && lu(l, c)) {
+        let p = Vt(l, c);
+        l = ye(l, l.next), p = ye(p, p.next), Ie(l, r, t, i, o, s, 0), Ie(p, r, t, i, o, s, 0);
+        return;
+      }
+      c = c.next;
+    }
+    l = l.next;
+  } while (l !== e);
+}
+function tu(e, r, t, i, o, s) {
+  const l = [];
+  let c, p, g, D, d;
+  for (c = 0, p = r.length; c < p; c++)
+    g = r[c] * i, D = c < p - 1 ? r[c + 1] * i : e.length, d = Ut(e, g, D, i, !1, o && o[c + 1], s), d === d.next && (d.steiner = !0), l.push(su(d));
+  for (l.sort(uu), c = 0; c < l.length; c++)
+    t = ru(l[c], t);
+  return t;
+}
+function uu(e, r) {
+  return e.x - r.x;
+}
+function ru(e, r) {
+  const t = nu(e, r);
+  if (!t)
+    return r;
+  const i = Vt(t, e);
+  return ye(i, i.next), ye(t, t.next);
+}
+function nu(e, r) {
+  let t = r;
+  const i = e.x, o = e.y;
+  let s = -1 / 0, l;
+  do {
+    if (o <= t.y && o >= t.next.y && t.next.y !== t.y) {
+      const E = t.x + (o - t.y) * (t.next.x - t.x) / (t.next.y - t.y);
+      if (E <= i && E > s && (s = E, l = t.x < t.next.x ? t : t.next, E === i))
+        return l;
+    }
+    t = t.next;
+  } while (t !== r);
+  if (!l)
+    return null;
+  const c = l, p = l.x, g = l.y;
+  let D = 1 / 0, d;
+  t = l;
+  do
+    i >= t.x && t.x >= p && i !== t.x && Be(o < g ? i : s, o, p, g, o < g ? s : i, o, t.x, t.y) && (d = Math.abs(o - t.y) / (i - t.x), Re(t, e) && (d < D || d === D && (t.x > l.x || t.x === l.x && iu(l, t))) && (l = t, D = d)), t = t.next;
+  while (t !== c);
+  return l;
+}
+function iu(e, r) {
+  return X(e.prev, e, r.prev) < 0 && X(r.next, e, e.next) < 0;
+}
+function ou(e, r, t, i) {
+  let o = e;
+  do
+    o.z === 0 && (o.z = it(o.x, o.y, r, t, i)), o.prevZ = o.prev, o.nextZ = o.next, o = o.next;
+  while (o !== e);
+  o.prevZ.nextZ = null, o.prevZ = null, au(o);
+}
+function au(e) {
+  let r, t, i = 1, o, s, l, c, p, g;
+  do {
+    for (s = e, e = null, g = null, o = 0; s; ) {
+      for (o++, c = s, l = 0, t = 0; t < i && (l++, c = c.nextZ, !!c); t++)
+        ;
+      for (p = i; l > 0 || p > 0 && c; )
+        l !== 0 && (p === 0 || !c || s.z <= c.z) ? (r = s, s = s.nextZ, l--) : (r = c, c = c.nextZ, p--), g ? g.nextZ = r : e = r, r.prevZ = g, g = r;
+      s = c;
+    }
+    g.nextZ = null, i *= 2;
+  } while (o > 1);
+  return e;
+}
+function it(e, r, t, i, o) {
+  return e = (e - t) * o | 0, r = (r - i) * o | 0, e = (e | e << 8) & 16711935, e = (e | e << 4) & 252645135, e = (e | e << 2) & 858993459, e = (e | e << 1) & 1431655765, r = (r | r << 8) & 16711935, r = (r | r << 4) & 252645135, r = (r | r << 2) & 858993459, r = (r | r << 1) & 1431655765, e | r << 1;
+}
+function su(e) {
+  let r = e, t = e;
+  do
+    (r.x < t.x || r.x === t.x && r.y < t.y) && (t = r), r = r.next;
+  while (r !== e);
+  return t;
+}
+function Be(e, r, t, i, o, s, l, c) {
+  return (o - l) * (r - c) >= (e - l) * (s - c) && (e - l) * (i - c) >= (t - l) * (r - c) && (t - l) * (s - c) >= (o - l) * (i - c);
+}
+function lu(e, r) {
+  return e.next.i !== r.i && e.prev.i !== r.i && !cu(e, r) && // dones't intersect other edges
+  (Re(e, r) && Re(r, e) && pu(e, r) && // locally visible
+  (X(e.prev, e, r.prev) || X(e, r.prev, r)) || // does not create opposite-facing sectors
+  Xe(e, r) && X(e.prev, e, e.next) > 0 && X(r.prev, r, r.next) > 0);
+}
+function X(e, r, t) {
+  return (r.y - e.y) * (t.x - r.x) - (r.x - e.x) * (t.y - r.y);
+}
+function Xe(e, r) {
+  return e.x === r.x && e.y === r.y;
+}
+function Mt(e, r, t, i) {
+  const o = Ge(X(e, r, t)), s = Ge(X(e, r, i)), l = Ge(X(t, i, e)), c = Ge(X(t, i, r));
+  return !!(o !== s && l !== c || o === 0 && Ve(e, t, r) || s === 0 && Ve(e, i, r) || l === 0 && Ve(t, e, i) || c === 0 && Ve(t, r, i));
+}
+function Ve(e, r, t) {
+  return r.x <= Math.max(e.x, t.x) && r.x >= Math.min(e.x, t.x) && r.y <= Math.max(e.y, t.y) && r.y >= Math.min(e.y, t.y);
+}
+function Ge(e) {
+  return e > 0 ? 1 : e < 0 ? -1 : 0;
+}
+function cu(e, r) {
+  let t = e;
+  do {
+    if (t.i !== e.i && t.next.i !== e.i && t.i !== r.i && t.next.i !== r.i && Mt(t, t.next, e, r))
+      return !0;
+    t = t.next;
+  } while (t !== e);
+  return !1;
+}
+function Re(e, r) {
+  return X(e.prev, e, e.next) < 0 ? X(e, r, e.next) >= 0 && X(e, e.prev, r) >= 0 : X(e, r, e.prev) < 0 || X(e, e.next, r) < 0;
+}
+function pu(e, r) {
+  let t = e, i = !1;
+  const o = (e.x + r.x) / 2, s = (e.y + r.y) / 2;
+  do
+    t.y > s != t.next.y > s && t.next.y !== t.y && o < (t.next.x - t.x) * (s - t.y) / (t.next.y - t.y) + t.x && (i = !i), t = t.next;
+  while (t !== e);
+  return i;
+}
+function Vt(e, r) {
+  const t = new ot(e.i, e.x, e.y), i = new ot(r.i, r.x, r.y), o = e.next, s = r.prev;
+  return e.next = r, r.prev = e, t.next = o, o.prev = t, i.next = t, t.prev = i, s.next = i, i.prev = s, i;
+}
+function bt(e, r, t, i) {
+  const o = new ot(e, r, t);
+  return i ? (o.next = i.next, o.prev = i, i.next.prev = o, i.next = o) : (o.prev = o, o.next = o), o;
+}
+function qe(e) {
+  e.next.prev = e.prev, e.prev.next = e.next, e.prevZ && (e.prevZ.nextZ = e.nextZ), e.nextZ && (e.nextZ.prevZ = e.prevZ);
+}
+class ot {
+  constructor(r, t, i) {
+    this.prev = null, this.next = null, this.z = 0, this.prevZ = null, this.nextZ = null, this.steiner = !1, this.i = r, this.x = t, this.y = i;
+  }
+}
+function fu(e) {
+  let r = 0, t = 0, i = 0, o = 0, s = 0, l = 0, c = 0, p = 0, g = 0;
+  const D = /* @__PURE__ */ new Set();
+  for (const d of e) {
+    const E = d.geometry;
+    switch (E.type) {
+      case "Point":
+        t++, r++, D.add(E.coordinates.length);
+        break;
+      case "MultiPoint":
+        t++, r += E.coordinates.length;
+        for (const C of E.coordinates)
+          D.add(C.length);
+        break;
+      case "LineString":
+        s++, i += E.coordinates.length, o++;
+        for (const C of E.coordinates)
+          D.add(C.length);
+        break;
+      case "MultiLineString":
+        s++;
+        for (const C of E.coordinates) {
+          i += C.length, o++;
+          for (const m of C)
+            D.add(m.length);
+        }
+        break;
+      case "Polygon":
+        g++, c++, p += E.coordinates.length;
+        const S = E.coordinates.flat();
+        l += S.length;
+        for (const C of S)
+          D.add(C.length);
+        break;
+      case "MultiPolygon":
+        g++;
+        for (const C of E.coordinates) {
+          c++, p += C.length;
+          const m = C.flat();
+          l += m.length;
+          for (const N of m)
+            D.add(N.length);
+        }
+        break;
+      default:
+        throw new Error(`Unsupported geometry type: ${E.type}`);
+    }
+  }
+  return {
+    coordLength: D.size > 0 ? Math.max(...D) : 2,
+    pointPositionsCount: r,
+    pointFeaturesCount: t,
+    linePositionsCount: i,
+    linePathsCount: o,
+    lineFeaturesCount: s,
+    polygonPositionsCount: l,
+    polygonObjectsCount: c,
+    polygonRingsCount: p,
+    polygonFeaturesCount: g
+  };
+}
+function gu(e, r, t) {
+  const i = hu(e), o = Object.keys(i).filter((s) => i[s] !== Array);
+  return Du(e, {
+    propArrayTypes: i,
+    ...r
+  }, {
+    numericPropKeys: t && t.numericPropKeys || o,
+    PositionDataType: t ? t.PositionDataType : Float32Array,
+    triangulate: t ? t.triangulate : !0
+  });
+}
+function hu(e) {
+  const r = {};
+  for (const t of e)
+    if (t.properties)
+      for (const i in t.properties) {
+        const o = t.properties[i];
+        r[i] = vu(o, r[i]);
+      }
+  return r;
+}
+function Du(e, r, t) {
+  const { pointPositionsCount: i, pointFeaturesCount: o, linePositionsCount: s, linePathsCount: l, lineFeaturesCount: c, polygonPositionsCount: p, polygonObjectsCount: g, polygonRingsCount: D, polygonFeaturesCount: d, propArrayTypes: E, coordLength: S } = r, { numericPropKeys: C = [], PositionDataType: m = Float32Array, triangulate: N = !0 } = t, P = e[0] && "id" in e[0], R = e.length > 65535 ? Uint32Array : Uint16Array, w = {
+    type: "Point",
+    positions: new m(i * S),
+    globalFeatureIds: new R(i),
+    featureIds: o > 65535 ? new Uint32Array(i) : new Uint16Array(i),
+    numericProps: {},
+    properties: [],
+    fields: []
+  }, y = {
+    type: "LineString",
+    pathIndices: s > 65535 ? new Uint32Array(l + 1) : new Uint16Array(l + 1),
+    positions: new m(s * S),
+    globalFeatureIds: new R(s),
+    featureIds: c > 65535 ? new Uint32Array(s) : new Uint16Array(s),
+    numericProps: {},
+    properties: [],
+    fields: []
+  }, q = {
+    type: "Polygon",
+    polygonIndices: p > 65535 ? new Uint32Array(g + 1) : new Uint16Array(g + 1),
+    primitivePolygonIndices: p > 65535 ? new Uint32Array(D + 1) : new Uint16Array(D + 1),
+    positions: new m(p * S),
+    globalFeatureIds: new R(p),
+    featureIds: d > 65535 ? new Uint32Array(p) : new Uint16Array(p),
+    numericProps: {},
+    properties: [],
+    fields: []
+  };
+  N && (q.triangles = []);
+  for (const L of [w, y, q])
+    for (const G of C) {
+      const h = E[G];
+      L.numericProps[G] = new h(L.positions.length / S);
+    }
+  y.pathIndices[l] = s, q.polygonIndices[g] = p, q.primitivePolygonIndices[D] = p;
+  const j = {
+    pointPosition: 0,
+    pointFeature: 0,
+    linePosition: 0,
+    linePath: 0,
+    lineFeature: 0,
+    polygonPosition: 0,
+    polygonObject: 0,
+    polygonRing: 0,
+    polygonFeature: 0,
+    feature: 0
+  };
+  for (const L of e) {
+    const G = L.geometry, h = L.properties || {};
+    switch (G.type) {
+      case "Point":
+        mu(G, w, j, S, h), w.properties.push(rt(h, C)), P && w.fields.push({ id: L.id }), j.pointFeature++;
+        break;
+      case "LineString":
+        du(G, y, j, S, h), y.properties.push(rt(h, C)), P && y.fields.push({ id: L.id }), j.lineFeature++;
+        break;
+      case "Polygon":
+        Au(G, q, j, S, h), q.properties.push(rt(h, C)), P && q.fields.push({ id: L.id }), j.polygonFeature++;
+        break;
+      default:
+        throw new Error("Invalid geometry type");
+    }
+    j.feature++;
+  }
+  return yu(w, y, q, S);
+}
+function mu(e, r, t, i, o) {
+  r.positions.set(e.data, t.pointPosition * i);
+  const s = e.data.length / i;
+  ct(r, o, t.pointPosition, s), r.globalFeatureIds.fill(t.feature, t.pointPosition, t.pointPosition + s), r.featureIds.fill(t.pointFeature, t.pointPosition, t.pointPosition + s), t.pointPosition += s;
+}
+function du(e, r, t, i, o) {
+  r.positions.set(e.data, t.linePosition * i);
+  const s = e.data.length / i;
+  ct(r, o, t.linePosition, s), r.globalFeatureIds.fill(t.feature, t.linePosition, t.linePosition + s), r.featureIds.fill(t.lineFeature, t.linePosition, t.linePosition + s);
+  for (let l = 0, c = e.indices.length; l < c; ++l) {
+    const p = e.indices[l], g = l === c - 1 ? e.data.length : e.indices[l + 1];
+    r.pathIndices[t.linePath++] = t.linePosition, t.linePosition += (g - p) / i;
+  }
+}
+function Au(e, r, t, i, o) {
+  r.positions.set(e.data, t.polygonPosition * i);
+  const s = e.data.length / i;
+  ct(r, o, t.polygonPosition, s), r.globalFeatureIds.fill(t.feature, t.polygonPosition, t.polygonPosition + s), r.featureIds.fill(t.polygonFeature, t.polygonPosition, t.polygonPosition + s);
+  for (let l = 0, c = e.indices.length; l < c; ++l) {
+    const p = t.polygonPosition;
+    r.polygonIndices[t.polygonObject++] = p;
+    const g = e.areas[l], D = e.indices[l], d = e.indices[l + 1];
+    for (let S = 0, C = D.length; S < C; ++S) {
+      const m = D[S], N = S === C - 1 ? (
+        // last line, so either read to:
+        d === void 0 ? e.data.length : d[0]
+      ) : D[S + 1];
+      r.primitivePolygonIndices[t.polygonRing++] = t.polygonPosition, t.polygonPosition += (N - m) / i;
+    }
+    const E = t.polygonPosition;
+    Eu(r, g, D, { startPosition: p, endPosition: E, coordLength: i });
+  }
+}
+function Eu(e, r, t, { startPosition: i, endPosition: o, coordLength: s }) {
+  if (!e.triangles)
+    return;
+  const l = i * s, c = o * s, p = e.positions.subarray(l, c), g = t[0], D = t.slice(1).map((E) => (E - g) / s), d = Yt(p, D, s, r);
+  for (let E = 0, S = d.length; E < S; ++E)
+    e.triangles.push(i + d[E]);
+}
+function ut(e, r) {
+  const t = {};
+  for (const i in e)
+    t[i] = { value: e[i], size: r };
+  return t;
+}
+function yu(e, r, t, i) {
+  const o = {
+    shape: "binary-feature-collection",
+    points: {
+      ...e,
+      positions: { value: e.positions, size: i },
+      globalFeatureIds: { value: e.globalFeatureIds, size: 1 },
+      featureIds: { value: e.featureIds, size: 1 },
+      numericProps: ut(e.numericProps, 1)
+    },
+    lines: {
+      ...r,
+      positions: { value: r.positions, size: i },
+      pathIndices: { value: r.pathIndices, size: 1 },
+      globalFeatureIds: { value: r.globalFeatureIds, size: 1 },
+      featureIds: { value: r.featureIds, size: 1 },
+      numericProps: ut(r.numericProps, 1)
+    },
+    polygons: {
+      ...t,
+      positions: { value: t.positions, size: i },
+      polygonIndices: { value: t.polygonIndices, size: 1 },
+      primitivePolygonIndices: { value: t.primitivePolygonIndices, size: 1 },
+      globalFeatureIds: { value: t.globalFeatureIds, size: 1 },
+      featureIds: { value: t.featureIds, size: 1 },
+      numericProps: ut(t.numericProps, 1)
+    }
+    // triangles not expected
+  };
+  return o.polygons && t.triangles && (o.polygons.triangles = { value: new Uint32Array(t.triangles), size: 1 }), o;
+}
+function ct(e, r, t, i) {
+  for (const o in e.numericProps)
+    if (o in r) {
+      const s = r[o];
+      e.numericProps[o].fill(s, t, t + i);
+    }
+}
+function rt(e, r) {
+  const t = {};
+  for (const i in e)
+    r.includes(i) || (t[i] = e[i]);
+  return t;
+}
+function vu(e, r) {
+  return r === Array || !Number.isFinite(e) ? Array : r === Float64Array || Math.fround(e) !== e ? Float64Array : Float32Array;
+}
+function Cu(e, r = { coordLength: 2, fixRingWinding: !0 }) {
+  return e.map((t) => bu(t, r));
+}
+function wt(e, r, t, i) {
+  t.push(r.length), r.push(...e);
+  for (let o = e.length; o < i.coordLength; o++)
+    r.push(0);
+}
+function at(e, r, t, i) {
+  t.push(r.length);
+  for (const o of e) {
+    r.push(...o);
+    for (let s = o.length; s < i.coordLength; s++)
+      r.push(0);
+  }
+}
+function xt(e, r, t, i, o) {
+  let s = 0;
+  const l = [], c = [];
+  for (const p of e) {
+    const g = p.map((E) => E.slice(0, 2));
+    let D = _t(g.flat());
+    const d = D < 0;
+    o.fixRingWinding && (s === 0 && !d || s > 0 && d) && (p.reverse(), D = -D), l.push(D), at(p, r, c, o), s++;
+  }
+  s > 0 && (i.push(l), t.push(c));
+}
+function bu(e, r) {
+  const { geometry: t } = e;
+  if (t.type === "GeometryCollection")
+    throw new Error("GeometryCollection type not supported");
+  const i = [], o = [];
+  let s, l;
+  switch (t.type) {
+    case "Point":
+      l = "Point", wt(t.coordinates, i, o, r);
+      break;
+    case "MultiPoint":
+      l = "Point", t.coordinates.map((c) => wt(c, i, o, r));
+      break;
+    case "LineString":
+      l = "LineString", at(t.coordinates, i, o, r);
+      break;
+    case "MultiLineString":
+      l = "LineString", t.coordinates.map((c) => at(c, i, o, r));
+      break;
+    case "Polygon":
+      l = "Polygon", s = [], xt(t.coordinates, i, o, s, r);
+      break;
+    case "MultiPolygon":
+      l = "Polygon", s = [], t.coordinates.map((c) => xt(c, i, o, s, r));
+      break;
+    default:
+      throw new Error(`Unknown type: ${l}`);
+  }
+  return { ...e, geometry: { type: l, indices: o, data: i, areas: s } };
+}
+function Gt(e, r = { fixRingWinding: !0, triangulate: !0 }) {
+  const t = fu(e), i = t.coordLength, { fixRingWinding: o } = r, s = Cu(e, { coordLength: i, fixRingWinding: o });
+  return gu(s, t, {
+    numericPropKeys: r.numericPropKeys,
+    PositionDataType: r.PositionDataType || Float32Array,
+    triangulate: r.triangulate
+  });
+}
+function V(e) {
+  return e && e.normalize && e.normalize(), e && e.textContent || "";
+}
+function x(e, r) {
+  const t = e.getElementsByTagName(r);
+  return t.length ? t[0] : null;
+}
+function jt(e) {
+  const r = {};
+  if (e) {
+    const t = x(e, "line");
+    if (t) {
+      const i = V(x(t, "color")), o = parseFloat(V(x(t, "opacity"))), s = parseFloat(V(x(t, "width")));
+      i && (r.stroke = i), isNaN(o) || (r["stroke-opacity"] = o), isNaN(s) || (r["stroke-width"] = s * 96 / 25.4);
+    }
+  }
+  return r;
+}
+function zt(e) {
+  let r = [];
+  if (e !== null)
+    for (let t = 0; t < e.childNodes.length; t++) {
+      const i = e.childNodes[t];
+      if (i.nodeType !== 1) continue;
+      const o = ["heart", "gpxtpx:hr", "hr"].includes(i.nodeName) ? "heart" : i.nodeName;
+      if (o === "gpxtpx:TrackPointExtension")
+        r = r.concat(zt(i));
+      else {
+        const s = V(i);
+        r.push([o, isNaN(s) ? s : parseFloat(s)]);
+      }
+    }
+  return r;
+}
+function st(e, r) {
+  const t = {};
+  let i, o;
+  for (o = 0; o < r.length; o++)
+    i = x(e, r[o]), i && (t[r[o]] = V(i));
+  return t;
+}
+function pt(e) {
+  const r = st(e, [
+    "name",
+    "cmt",
+    "desc",
+    "type",
+    "time",
+    "keywords"
+  ]), t = e.getElementsByTagNameNS(
+    "http://www.garmin.com/xmlschemas/GpxExtensions/v3",
+    "*"
+  );
+  for (let o = 0; o < t.length; o++) {
+    const s = t[o];
+    s.parentNode.parentNode === e && (r[s.tagName.replace(":", "_")] = V(s));
+  }
+  const i = e.getElementsByTagName("link");
+  i.length && (r.links = []);
+  for (let o = 0; o < i.length; o++)
+    r.links.push(
+      Object.assign(
+        { href: i[o].getAttribute("href") },
+        st(i[o], ["text", "type"])
+      )
+    );
+  return r;
+}
+function Ht(e) {
+  const r = [
+    parseFloat(e.getAttribute("lon")),
+    parseFloat(e.getAttribute("lat"))
+  ], t = x(e, "ele"), i = x(e, "time");
+  if (t) {
+    const o = parseFloat(V(t));
+    isNaN(o) || r.push(o);
+  }
+  return {
+    coordinates: r,
+    time: i ? V(i) : null,
+    extendedValues: zt(x(e, "extensions"))
+  };
+}
+function wu(e) {
+  const r = Zt(e, "rtept");
+  if (r)
+    return {
+      type: "Feature",
+      properties: Object.assign(
+        pt(e),
+        jt(x(e, "extensions")),
+        { _gpxType: "rte" }
+      ),
+      geometry: {
+        type: "LineString",
+        coordinates: r.line
+      }
+    };
+}
+function Zt(e, r) {
+  const t = e.getElementsByTagName(r);
+  if (t.length < 2) return;
+  const i = [], o = [], s = {};
+  for (let l = 0; l < t.length; l++) {
+    const c = Ht(t[l]);
+    i.push(c.coordinates), c.time && o.push(c.time);
+    for (let p = 0; p < c.extendedValues.length; p++) {
+      const [g, D] = c.extendedValues[p], d = g === "heart" ? g : g.replace("gpxtpx:", "") + "s";
+      s[d] || (s[d] = Array(t.length).fill(null)), s[d][l] = D;
+    }
+  }
+  return {
+    line: i,
+    times: o,
+    extendedValues: s
+  };
+}
+function xu(e) {
+  const r = e.getElementsByTagName("trkseg"), t = [], i = [], o = [];
+  for (let c = 0; c < r.length; c++) {
+    const p = Zt(r[c], "trkpt");
+    p && (o.push(p), p.times && p.times.length && i.push(p.times));
+  }
+  if (o.length === 0) return;
+  const s = o.length > 1, l = Object.assign(
+    pt(e),
+    jt(x(e, "extensions")),
+    { _gpxType: "trk" },
+    i.length ? {
+      coordinateProperties: {
+        times: s ? i : i[0]
+      }
+    } : {}
+  );
+  for (let c = 0; c < o.length; c++) {
+    const p = o[c];
+    t.push(p.line);
+    for (const [g, D] of Object.entries(p.extendedValues)) {
+      l.coordinateProperties || (l.coordinateProperties = {});
+      const d = l.coordinateProperties;
+      s ? (d[g] || (d[g] = o.map(
+        (E) => new Array(E.line.length).fill(null)
+      )), d[g][c] = D) : d[g] = D;
+    }
+  }
+  return {
+    type: "Feature",
+    properties: l,
+    geometry: s ? {
+      type: "MultiLineString",
+      coordinates: t
+    } : {
+      type: "LineString",
+      coordinates: t[0]
+    }
+  };
+}
+function Nu(e) {
+  return {
+    type: "Feature",
+    properties: Object.assign(pt(e), st(e, ["sym"])),
+    geometry: {
+      type: "Point",
+      coordinates: Ht(e).coordinates
+    }
+  };
+}
+function* Tu(e) {
+  const r = e.getElementsByTagName("trk"), t = e.getElementsByTagName("rte"), i = e.getElementsByTagName("wpt");
+  for (let o = 0; o < r.length; o++) {
+    const s = xu(r[o]);
+    s && (yield s);
+  }
+  for (let o = 0; o < t.length; o++) {
+    const s = wu(t[o]);
+    s && (yield s);
+  }
+  for (let o = 0; o < i.length; o++)
+    yield Nu(i[o]);
+}
+function Bu(e) {
+  return {
+    type: "FeatureCollection",
+    features: Array.from(Tu(e))
+  };
+}
+const Fu = "http://www.garmin.com/xmlschemas/ActivityExtension/v2", Su = [
+  ["heartRate", "heartRates"],
+  ["Cadence", "cadences"],
+  // Extended Trackpoint attributes
+  ["Speed", "speeds"],
+  ["Watts", "watts"]
+], Pu = [
+  ["TotalTimeSeconds", "totalTimeSeconds"],
+  ["DistanceMeters", "distanceMeters"],
+  ["MaximumSpeed", "maxSpeed"],
+  ["AverageHeartRateBpm", "avgHeartRate"],
+  ["MaximumHeartRateBpm", "maxHeartRate"],
+  // Extended Lap attributes
+  ["AvgSpeed", "avgSpeed"],
+  ["AvgWatts", "avgWatts"],
+  ["MaxWatts", "maxWatts"]
+];
+function ku(e) {
+  const r = {};
+  for (const [t, i] of e)
+    r[t] = i;
+  return r;
+}
+function Xt(e, r) {
+  const t = [];
+  for (const [i, o] of r) {
+    let s = x(e, i);
+    if (!s) {
+      const c = e.getElementsByTagNameNS(Fu, i);
+      c.length && (s = c[0]);
+    }
+    const l = parseFloat(V(s));
+    isNaN(l) || t.push([o, l]);
+  }
+  return t;
+}
+function Iu(e) {
+  const r = V(x(e, "LongitudeDegrees")), t = V(x(e, "LatitudeDegrees"));
+  if (!r.length || !t.length)
+    return null;
+  const i = [parseFloat(r), parseFloat(t)], o = x(e, "AltitudeMeters"), s = x(e, "HeartRateBpm"), l = x(e, "Time");
+  let c;
+  return o && (c = parseFloat(V(o)), isNaN(c) || i.push(c)), {
+    coordinates: i,
+    time: l ? V(l) : null,
+    heartRate: s ? parseFloat(V(s)) : null,
+    extensions: Xt(e, Su)
+  };
+}
+function Ru(e, r) {
+  const t = e.getElementsByTagName(r), i = [], o = [], s = [];
+  if (t.length < 2) return null;
+  const l = { extendedProperties: {} };
+  for (let c = 0; c < t.length; c++) {
+    const p = Iu(t[c]);
+    if (p !== null) {
+      i.push(p.coordinates), p.time && o.push(p.time), p.heartRate && s.push(p.heartRate);
+      for (const [g, D] of p.extensions)
+        l.extendedProperties[g] || (l.extendedProperties[g] = Array(t.length).fill(null)), l.extendedProperties[g][c] = D;
+    }
+  }
+  return Object.assign(l, {
+    line: i,
+    times: o,
+    heartRates: s
+  });
+}
+function Nt(e) {
+  const r = e.getElementsByTagName("Track"), t = [], i = [], o = [], s = [];
+  let l;
+  const c = ku(Xt(e, Pu)), p = x(e, "Name");
+  p && (c.name = V(p));
+  for (let g = 0; g < r.length; g++)
+    l = Ru(r[g], "Trackpoint"), l && (t.push(l.line), l.times.length && i.push(l.times), l.heartRates.length && o.push(l.heartRates), s.push(l.extendedProperties));
+  for (let g = 0; g < s.length; g++) {
+    const D = s[g];
+    for (const d in D)
+      r.length === 1 ? c[d] = l.extendedProperties[d] : (c[d] || (c[d] = t.map(
+        (E) => Array(E.length).fill(null)
+      )), c[d][g] = D[d]);
+  }
+  if (t.length !== 0)
+    return (i.length || o.length) && (c.coordinateProperties = Object.assign(
+      i.length ? {
+        times: t.length === 1 ? i[0] : i
+      } : {},
+      o.length ? {
+        heart: t.length === 1 ? o[0] : o
+      } : {}
+    )), {
+      type: "Feature",
+      properties: c,
+      geometry: {
+        type: t.length === 1 ? "LineString" : "MultiLineString",
+        coordinates: t.length === 1 ? t[0] : t
+      }
+    };
+}
+function* qu(e) {
+  const r = e.getElementsByTagName("Lap");
+  for (let i = 0; i < r.length; i++) {
+    const o = Nt(r[i]);
+    o && (yield o);
+  }
+  const t = e.getElementsByTagName("Courses");
+  for (let i = 0; i < t.length; i++) {
+    const o = Nt(t[i]);
+    o && (yield o);
+  }
+}
+function Lu(e) {
+  return {
+    type: "FeatureCollection",
+    features: Array.from(qu(e))
+  };
+}
+const Ou = /\s*/g, _u = /^\s*|\s*$/g, Uu = /\s+/;
+function Tt(e) {
+  if (!e || !e.length) return 0;
+  let r = 0;
+  for (let t = 0; t < e.length; t++)
+    r = (r << 5) - r + e.charCodeAt(t) | 0;
+  return r;
+}
+function $t(e) {
+  return e.replace(Ou, "").split(",").map(parseFloat);
+}
+function Bt(e) {
+  return e.replace(_u, "").split(Uu).map($t);
+}
+function lt(e) {
+  if (e.xml !== void 0) return e.xml;
+  if (e.tagName) {
+    let r = e.tagName;
+    for (let t = 0; t < e.attributes.length; t++)
+      r += e.attributes[t].name + e.attributes[t].value;
+    for (let t = 0; t < e.childNodes.length; t++)
+      r += lt(e.childNodes[t]);
+    return r;
+  }
+  return e.nodeName === "#text" ? (e.nodeValue || e.value || "").trim() : e.nodeName === "#cdata-section" ? e.nodeValue : "";
+}
+const Ee = ["Polygon", "LineString", "Point", "Track", "gx:Track"];
+function je(e, r, t) {
+  let i = V(x(r, "color")) || "";
+  const o = t == "stroke" || t === "fill" ? t : t + "-color";
+  i.substr(0, 1) === "#" && (i = i.substr(1)), i.length === 6 || i.length === 3 ? e[o] = i : i.length === 8 && (e[t + "-opacity"] = parseInt(i.substr(0, 2), 16) / 255, e[o] = "#" + i.substr(6, 2) + i.substr(4, 2) + i.substr(2, 2));
+}
+function ze(e, r, t, i) {
+  const o = parseFloat(V(x(r, t)));
+  isNaN(o) || (e[i] = o);
+}
+function Mu(e) {
+  let r = e.getElementsByTagName("coord");
+  const t = [], i = [];
+  r.length === 0 && (r = e.getElementsByTagName("gx:coord"));
+  for (let s = 0; s < r.length; s++)
+    t.push(V(r[s]).split(" ").map(parseFloat));
+  const o = e.getElementsByTagName("when");
+  for (let s = 0; s < o.length; s++) i.push(V(o[s]));
+  return {
+    coords: t,
+    times: i
+  };
+}
+function Ze(e) {
+  let r, t, i, o, s;
+  const l = [], c = [];
+  if (x(e, "MultiGeometry"))
+    return Ze(x(e, "MultiGeometry"));
+  if (x(e, "MultiTrack"))
+    return Ze(x(e, "MultiTrack"));
+  if (x(e, "gx:MultiTrack"))
+    return Ze(x(e, "gx:MultiTrack"));
+  for (i = 0; i < Ee.length; i++)
+    if (t = e.getElementsByTagName(Ee[i]), t) {
+      for (o = 0; o < t.length; o++)
+        if (r = t[o], Ee[i] === "Point")
+          l.push({
+            type: "Point",
+            coordinates: $t(V(x(r, "coordinates")))
+          });
+        else if (Ee[i] === "LineString")
+          l.push({
+            type: "LineString",
+            coordinates: Bt(V(x(r, "coordinates")))
+          });
+        else if (Ee[i] === "Polygon") {
+          const p = r.getElementsByTagName("LinearRing"), g = [];
+          for (s = 0; s < p.length; s++)
+            g.push(Bt(V(x(p[s], "coordinates"))));
+          l.push({
+            type: "Polygon",
+            coordinates: g
+          });
+        } else if (Ee[i] === "Track" || Ee[i] === "gx:Track") {
+          const p = Mu(r);
+          l.push({
+            type: "LineString",
+            coordinates: p.coords
+          }), p.times.length && c.push(p.times);
+        }
+    }
+  return {
+    geoms: l,
+    coordTimes: c
+  };
+}
+function Vu(e, r, t, i) {
+  const o = Ze(e);
+  let s;
+  const l = {}, c = V(x(e, "name")), p = V(x(e, "address"));
+  let g = V(x(e, "styleUrl"));
+  const D = V(x(e, "description")), d = x(e, "TimeSpan"), E = x(e, "TimeStamp"), S = x(e, "ExtendedData");
+  let C = x(e, "IconStyle"), m = x(e, "LabelStyle"), N = x(e, "LineStyle"), P = x(e, "PolyStyle");
+  const R = x(e, "visibility");
+  if (c && (l.name = c), p && (l.address = p), g) {
+    g[0] !== "#" && (g = "#" + g), l.styleUrl = g, r[g] && (l.styleHash = r[g]), t[g] && (l.styleMapHash = t[g], l.styleHash = r[t[g].normal]);
+    const y = i[l.styleHash];
+    y && (C || (C = x(y, "IconStyle")), m || (m = x(y, "LabelStyle")), N || (N = x(y, "LineStyle")), P || (P = x(y, "PolyStyle")));
+  }
+  if (D && (l.description = D), d) {
+    const y = V(x(d, "begin")), q = V(x(d, "end"));
+    l.timespan = { begin: y, end: q };
+  }
+  if (E && (l.timestamp = V(x(E, "when"))), C) {
+    je(l, C, "icon"), ze(l, C, "scale", "icon-scale"), ze(l, C, "heading", "icon-heading");
+    const y = x(C, "hotSpot");
+    if (y) {
+      const j = parseFloat(y.getAttribute("x")), L = parseFloat(y.getAttribute("y"));
+      !isNaN(j) && !isNaN(L) && (l["icon-offset"] = [j, L]);
+    }
+    const q = x(C, "Icon");
+    if (q) {
+      const j = V(x(q, "href"));
+      j && (l.icon = j);
+    }
+  }
+  if (m && (je(l, m, "label"), ze(l, m, "scale", "label-scale")), N && (je(l, N, "stroke"), ze(l, N, "width", "stroke-width")), P) {
+    je(l, P, "fill");
+    const y = V(x(P, "fill")), q = V(x(P, "outline"));
+    y && (l["fill-opacity"] = y === "1" ? l["fill-opacity"] || 1 : 0), q && (l["stroke-opacity"] = q === "1" ? l["stroke-opacity"] || 1 : 0);
+  }
+  if (S) {
+    const y = S.getElementsByTagName("Data"), q = S.getElementsByTagName("SimpleData");
+    for (s = 0; s < y.length; s++)
+      l[y[s].getAttribute("name")] = V(
+        x(y[s], "value")
+      );
+    for (s = 0; s < q.length; s++)
+      l[q[s].getAttribute("name")] = V(q[s]);
+  }
+  R && (l.visibility = V(R)), o.coordTimes.length && (l.coordinateProperties = {
+    times: o.coordTimes.length === 1 ? o.coordTimes[0] : o.coordTimes
+  });
+  const w = {
+    type: "Feature",
+    geometry: o.geoms.length === 0 ? null : o.geoms.length === 1 ? o.geoms[0] : {
+      type: "GeometryCollection",
+      geometries: o.geoms
+    },
+    properties: l
+  };
+  return e.getAttribute("id") && (w.id = e.getAttribute("id")), w;
+}
+function* Gu(e) {
+  const r = {}, t = {}, i = {}, o = e.getElementsByTagName("Placemark"), s = e.getElementsByTagName("Style"), l = e.getElementsByTagName("StyleMap");
+  for (let c = 0; c < s.length; c++) {
+    const p = s[c], g = Tt(lt(p)).toString(16);
+    let D = p.getAttribute("id");
+    !D && p.parentNode.tagName.replace("gx:", "") === "CascadingStyle" && (D = p.parentNode.getAttribute("kml:id") || p.parentNode.getAttribute("id")), r["#" + D] = g, t[g] = p;
+  }
+  for (let c = 0; c < l.length; c++) {
+    r["#" + l[c].getAttribute("id")] = Tt(
+      lt(l[c])
+    ).toString(16);
+    const p = l[c].getElementsByTagName("Pair"), g = {};
+    for (let D = 0; D < p.length; D++)
+      g[V(x(p[D], "key"))] = V(
+        x(p[D], "styleUrl")
+      );
+    i["#" + l[c].getAttribute("id")] = g;
+  }
+  for (let c = 0; c < o.length; c++) {
+    const p = Vu(
+      o[c],
+      r,
+      i,
+      t
+    );
+    p && (yield p);
+  }
+}
+function ju(e) {
+  return {
+    type: "FeatureCollection",
+    features: Array.from(Gu(e))
+  };
+}
+var ke = {}, pe = {}, Ne = {}, Ft;
+function $e() {
+  if (Ft) return Ne;
+  Ft = 1;
+  function e(o, s, l) {
+    if (l === void 0 && (l = Array.prototype), o && typeof l.find == "function")
+      return l.find.call(o, s);
+    for (var c = 0; c < o.length; c++)
+      if (Object.prototype.hasOwnProperty.call(o, c)) {
+        var p = o[c];
+        if (s.call(void 0, p, c, o))
+          return p;
+      }
+  }
+  function r(o, s) {
+    return s === void 0 && (s = Object), s && typeof s.freeze == "function" ? s.freeze(o) : o;
+  }
+  var t = r({
+    /**
+     * `text/html`, the only mime type that triggers treating an XML document as HTML.
+     *
+     * @see DOMParser.SupportedType.isHTML
+     * @see https://www.iana.org/assignments/media-types/text/html IANA MimeType registration
+     * @see https://en.wikipedia.org/wiki/HTML Wikipedia
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMParser/parseFromString MDN
+     * @see https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#dom-domparser-parsefromstring WHATWG HTML Spec
+     */
+    HTML: "text/html",
+    /**
+     * Helper method to check a mime type if it indicates an HTML document
+     *
+     * @param {string} [value]
+     * @returns {boolean}
+     *
+     * @see https://www.iana.org/assignments/media-types/text/html IANA MimeType registration
+     * @see https://en.wikipedia.org/wiki/HTML Wikipedia
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMParser/parseFromString MDN
+     * @see https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#dom-domparser-parsefromstring 	 */
+    isHTML: function(o) {
+      return o === t.HTML;
+    },
+    /**
+     * `application/xml`, the standard mime type for XML documents.
+     *
+     * @see https://www.iana.org/assignments/media-types/application/xml IANA MimeType registration
+     * @see https://tools.ietf.org/html/rfc7303#section-9.1 RFC 7303
+     * @see https://en.wikipedia.org/wiki/XML_and_MIME Wikipedia
+     */
+    XML_APPLICATION: "application/xml",
+    /**
+     * `text/html`, an alias for `application/xml`.
+     *
+     * @see https://tools.ietf.org/html/rfc7303#section-9.2 RFC 7303
+     * @see https://www.iana.org/assignments/media-types/text/xml IANA MimeType registration
+     * @see https://en.wikipedia.org/wiki/XML_and_MIME Wikipedia
+     */
+    XML_TEXT: "text/xml",
+    /**
+     * `application/xhtml+xml`, indicates an XML document that has the default HTML namespace,
+     * but is parsed as an XML document.
+     *
+     * @see https://www.iana.org/assignments/media-types/application/xhtml+xml IANA MimeType registration
+     * @see https://dom.spec.whatwg.org/#dom-domimplementation-createdocument WHATWG DOM Spec
+     * @see https://en.wikipedia.org/wiki/XHTML Wikipedia
+     */
+    XML_XHTML_APPLICATION: "application/xhtml+xml",
+    /**
+     * `image/svg+xml`,
+     *
+     * @see https://www.iana.org/assignments/media-types/image/svg+xml IANA MimeType registration
+     * @see https://www.w3.org/TR/SVG11/ W3C SVG 1.1
+     * @see https://en.wikipedia.org/wiki/Scalable_Vector_Graphics Wikipedia
+     */
+    XML_SVG_IMAGE: "image/svg+xml"
+  }), i = r({
+    /**
+     * The XHTML namespace.
+     *
+     * @see http://www.w3.org/1999/xhtml
+     */
+    HTML: "http://www.w3.org/1999/xhtml",
+    /**
+     * Checks if `uri` equals `NAMESPACE.HTML`.
+     *
+     * @param {string} [uri]
+     *
+     * @see NAMESPACE.HTML
+     */
+    isHTML: function(o) {
+      return o === i.HTML;
+    },
+    /**
+     * The SVG namespace.
+     *
+     * @see http://www.w3.org/2000/svg
+     */
+    SVG: "http://www.w3.org/2000/svg",
+    /**
+     * The `xml:` namespace.
+     *
+     * @see http://www.w3.org/XML/1998/namespace
+     */
+    XML: "http://www.w3.org/XML/1998/namespace",
+    /**
+     * The `xmlns:` namespace
+     *
+     * @see https://www.w3.org/2000/xmlns/
+     */
+    XMLNS: "http://www.w3.org/2000/xmlns/"
+  });
+  return Ne.find = e, Ne.freeze = r, Ne.MIME_TYPE = t, Ne.NAMESPACE = i, Ne;
+}
+var St;
+function Wt() {
+  if (St) return pe;
+  St = 1;
+  var e = $e(), r = e.find, t = e.NAMESPACE;
+  function i(u) {
+    return u !== "";
+  }
+  function o(u) {
+    return u ? u.split(/[\t\n\f\r ]+/).filter(i) : [];
+  }
+  function s(u, n) {
+    return u.hasOwnProperty(n) || (u[n] = !0), u;
+  }
+  function l(u) {
+    if (!u) return [];
+    var n = o(u);
+    return Object.keys(n.reduce(s, {}));
+  }
+  function c(u) {
+    return function(n) {
+      return u && u.indexOf(n) !== -1;
+    };
+  }
+  function p(u, n) {
+    for (var a in u)
+      Object.prototype.hasOwnProperty.call(u, a) && (n[a] = u[a]);
+  }
+  function g(u, n) {
+    var a = u.prototype;
+    if (!(a instanceof n)) {
+      let f = function() {
+      };
+      f.prototype = n.prototype, f = new f(), p(a, f), u.prototype = a = f;
+    }
+    a.constructor != u && (typeof u != "function" && console.error("unknown Class:" + u), a.constructor = u);
+  }
+  var D = {}, d = D.ELEMENT_NODE = 1, E = D.ATTRIBUTE_NODE = 2, S = D.TEXT_NODE = 3, C = D.CDATA_SECTION_NODE = 4, m = D.ENTITY_REFERENCE_NODE = 5, N = D.ENTITY_NODE = 6, P = D.PROCESSING_INSTRUCTION_NODE = 7, R = D.COMMENT_NODE = 8, w = D.DOCUMENT_NODE = 9, y = D.DOCUMENT_TYPE_NODE = 10, q = D.DOCUMENT_FRAGMENT_NODE = 11, j = D.NOTATION_NODE = 12, L = {}, G = {};
+  L.INDEX_SIZE_ERR = (G[1] = "Index size error", 1), L.DOMSTRING_SIZE_ERR = (G[2] = "DOMString size error", 2);
+  var h = L.HIERARCHY_REQUEST_ERR = (G[3] = "Hierarchy request error", 3);
+  L.WRONG_DOCUMENT_ERR = (G[4] = "Wrong document", 4), L.INVALID_CHARACTER_ERR = (G[5] = "Invalid character", 5), L.NO_DATA_ALLOWED_ERR = (G[6] = "No data allowed", 6), L.NO_MODIFICATION_ALLOWED_ERR = (G[7] = "No modification allowed", 7);
+  var v = L.NOT_FOUND_ERR = (G[8] = "Not found", 8);
+  L.NOT_SUPPORTED_ERR = (G[9] = "Not supported", 9);
+  var T = L.INUSE_ATTRIBUTE_ERR = (G[10] = "Attribute in use", 10);
+  L.INVALID_STATE_ERR = (G[11] = "Invalid state", 11), L.SYNTAX_ERR = (G[12] = "Syntax error", 12), L.INVALID_MODIFICATION_ERR = (G[13] = "Invalid modification", 13), L.NAMESPACE_ERR = (G[14] = "Invalid namespace", 14), L.INVALID_ACCESS_ERR = (G[15] = "Invalid access", 15);
+  function b(u, n) {
+    if (n instanceof Error)
+      var a = n;
+    else
+      a = this, Error.call(this, G[u]), this.message = G[u], Error.captureStackTrace && Error.captureStackTrace(this, b);
+    return a.code = u, n && (this.message = this.message + ": " + n), a;
+  }
+  b.prototype = Error.prototype, p(L, b);
+  function B() {
+  }
+  B.prototype = {
+    /**
+     * The number of nodes in the list. The range of valid child node indices is 0 to length-1 inclusive.
+     * @standard level1
+     */
+    length: 0,
+    /**
+     * Returns the indexth item in the collection. If index is greater than or equal to the number of nodes in the list, this returns null.
+     * @standard level1
+     * @param index  unsigned long
+     *   Index into the collection.
+     * @return Node
+     * 	The node at the indexth position in the NodeList, or null if that is not a valid index.
+     */
+    item: function(u) {
+      return u >= 0 && u < this.length ? this[u] : null;
+    },
+    toString: function(u, n) {
+      for (var a = [], f = 0; f < this.length; f++)
+        we(this[f], a, u, n);
+      return a.join("");
+    },
+    /**
+     * @private
+     * @param {function (Node):boolean} predicate
+     * @returns {Node[]}
+     */
+    filter: function(u) {
+      return Array.prototype.filter.call(this, u);
+    },
+    /**
+     * @private
+     * @param {Node} item
+     * @returns {number}
+     */
+    indexOf: function(u) {
+      return Array.prototype.indexOf.call(this, u);
+    }
+  };
+  function U(u, n) {
+    this._node = u, this._refresh = n, M(this);
+  }
+  function M(u) {
+    var n = u._node._inc || u._node.ownerDocument._inc;
+    if (u._inc !== n) {
+      var a = u._refresh(u._node);
+      if (Et(u, "length", a.length), !u.$$length || a.length < u.$$length)
+        for (var f = a.length; f in u; f++)
+          Object.prototype.hasOwnProperty.call(u, f) && delete u[f];
+      p(a, u), u._inc = n;
+    }
+  }
+  U.prototype.item = function(u) {
+    return M(this), this[u] || null;
+  }, g(U, B);
+  function z() {
+  }
+  function I(u, n) {
+    for (var a = u.length; a--; )
+      if (u[a] === n)
+        return a;
+  }
+  function O(u, n, a, f) {
+    if (f ? n[I(n, f)] = a : n[n.length++] = a, u) {
+      a.ownerElement = u;
+      var A = u.ownerDocument;
+      A && (f && Fe(A, u, f), Y(A, u, a));
+    }
+  }
+  function _(u, n, a) {
+    var f = I(n, a);
+    if (f >= 0) {
+      for (var A = n.length - 1; f < A; )
+        n[f] = n[++f];
+      if (n.length = A, u) {
+        var k = u.ownerDocument;
+        k && (Fe(k, u, a), a.ownerElement = null);
+      }
+    } else
+      throw new b(v, new Error(u.tagName + "@" + a));
+  }
+  z.prototype = {
+    length: 0,
+    item: B.prototype.item,
+    getNamedItem: function(u) {
+      for (var n = this.length; n--; ) {
+        var a = this[n];
+        if (a.nodeName == u)
+          return a;
+      }
+    },
+    setNamedItem: function(u) {
+      var n = u.ownerElement;
+      if (n && n != this._ownerElement)
+        throw new b(T);
+      var a = this.getNamedItem(u.nodeName);
+      return O(this._ownerElement, this, u, a), a;
+    },
+    /* returns Node */
+    setNamedItemNS: function(u) {
+      var n = u.ownerElement, a;
+      if (n && n != this._ownerElement)
+        throw new b(T);
+      return a = this.getNamedItemNS(u.namespaceURI, u.localName), O(this._ownerElement, this, u, a), a;
+    },
+    /* returns Node */
+    removeNamedItem: function(u) {
+      var n = this.getNamedItem(u);
+      return _(this._ownerElement, this, n), n;
+    },
+    // raises: NOT_FOUND_ERR,NO_MODIFICATION_ALLOWED_ERR
+    //for level2
+    removeNamedItemNS: function(u, n) {
+      var a = this.getNamedItemNS(u, n);
+      return _(this._ownerElement, this, a), a;
+    },
+    getNamedItemNS: function(u, n) {
+      for (var a = this.length; a--; ) {
+        var f = this[a];
+        if (f.localName == n && f.namespaceURI == u)
+          return f;
+      }
+      return null;
+    }
+  };
+  function $() {
+  }
+  $.prototype = {
+    /**
+     * The DOMImplementation.hasFeature() method returns a Boolean flag indicating if a given feature is supported.
+     * The different implementations fairly diverged in what kind of features were reported.
+     * The latest version of the spec settled to force this method to always return true, where the functionality was accurate and in use.
+     *
+     * @deprecated It is deprecated and modern browsers return true in all cases.
+     *
+     * @param {string} feature
+     * @param {string} [version]
+     * @returns {boolean} always true
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation/hasFeature MDN
+     * @see https://www.w3.org/TR/REC-DOM-Level-1/level-one-core.html#ID-5CED94D7 DOM Level 1 Core
+     * @see https://dom.spec.whatwg.org/#dom-domimplementation-hasfeature DOM Living Standard
+     */
+    hasFeature: function(u, n) {
+      return !0;
+    },
+    /**
+     * Creates an XML Document object of the specified type with its document element.
+     *
+     * __It behaves slightly different from the description in the living standard__:
+     * - There is no interface/class `XMLDocument`, it returns a `Document` instance.
+     * - `contentType`, `encoding`, `mode`, `origin`, `url` fields are currently not declared.
+     * - this implementation is not validating names or qualified names
+     *   (when parsing XML strings, the SAX parser takes care of that)
+     *
+     * @param {string|null} namespaceURI
+     * @param {string} qualifiedName
+     * @param {DocumentType=null} doctype
+     * @returns {Document}
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation/createDocument MDN
+     * @see https://www.w3.org/TR/DOM-Level-2-Core/core.html#Level-2-Core-DOM-createDocument DOM Level 2 Core (initial)
+     * @see https://dom.spec.whatwg.org/#dom-domimplementation-createdocument  DOM Level 2 Core
+     *
+     * @see https://dom.spec.whatwg.org/#validate-and-extract DOM: Validate and extract
+     * @see https://www.w3.org/TR/xml/#NT-NameStartChar XML Spec: Names
+     * @see https://www.w3.org/TR/xml-names/#ns-qualnames XML Namespaces: Qualified names
+     */
+    createDocument: function(u, n, a) {
+      var f = new W();
+      if (f.implementation = this, f.childNodes = new B(), f.doctype = a || null, a && f.appendChild(a), n) {
+        var A = f.createElementNS(u, n);
+        f.appendChild(A);
+      }
+      return f;
+    },
+    /**
+     * Returns a doctype, with the given `qualifiedName`, `publicId`, and `systemId`.
+     *
+     * __This behavior is slightly different from the in the specs__:
+     * - this implementation is not validating names or qualified names
+     *   (when parsing XML strings, the SAX parser takes care of that)
+     *
+     * @param {string} qualifiedName
+     * @param {string} [publicId]
+     * @param {string} [systemId]
+     * @returns {DocumentType} which can either be used with `DOMImplementation.createDocument` upon document creation
+     * 				  or can be put into the document via methods like `Node.insertBefore()` or `Node.replaceChild()`
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation/createDocumentType MDN
+     * @see https://www.w3.org/TR/DOM-Level-2-Core/core.html#Level-2-Core-DOM-createDocType DOM Level 2 Core
+     * @see https://dom.spec.whatwg.org/#dom-domimplementation-createdocumenttype DOM Living Standard
+     *
+     * @see https://dom.spec.whatwg.org/#validate-and-extract DOM: Validate and extract
+     * @see https://www.w3.org/TR/xml/#NT-NameStartChar XML Spec: Names
+     * @see https://www.w3.org/TR/xml-names/#ns-qualnames XML Namespaces: Qualified names
+     */
+    createDocumentType: function(u, n, a) {
+      var f = new Ue();
+      return f.name = u, f.nodeName = u, f.publicId = n || "", f.systemId = a || "", f;
+    }
+  };
+  function F() {
+  }
+  F.prototype = {
+    firstChild: null,
+    lastChild: null,
+    previousSibling: null,
+    nextSibling: null,
+    attributes: null,
+    parentNode: null,
+    childNodes: null,
+    ownerDocument: null,
+    nodeValue: null,
+    namespaceURI: null,
+    prefix: null,
+    localName: null,
+    // Modified in DOM Level 2:
+    insertBefore: function(u, n) {
+      return fe(this, u, n);
+    },
+    replaceChild: function(u, n) {
+      fe(this, u, n, Oe), n && this.removeChild(n);
+    },
+    removeChild: function(u) {
+      return te(this, u);
+    },
+    appendChild: function(u) {
+      return this.insertBefore(u, null);
+    },
+    hasChildNodes: function() {
+      return this.firstChild != null;
+    },
+    cloneNode: function(u) {
+      return tt(this.ownerDocument || this, this, u);
+    },
+    // Modified in DOM Level 2:
+    normalize: function() {
+      for (var u = this.firstChild; u; ) {
+        var n = u.nextSibling;
+        n && n.nodeType == S && u.nodeType == S ? (this.removeChild(n), u.appendData(n.data)) : (u.normalize(), u = n);
+      }
+    },
+    // Introduced in DOM Level 2:
+    isSupported: function(u, n) {
+      return this.ownerDocument.implementation.hasFeature(u, n);
+    },
+    // Introduced in DOM Level 2:
+    hasAttributes: function() {
+      return this.attributes.length > 0;
+    },
+    /**
+     * Look up the prefix associated to the given namespace URI, starting from this node.
+     * **The default namespace declarations are ignored by this method.**
+     * See Namespace Prefix Lookup for details on the algorithm used by this method.
+     *
+     * _Note: The implementation seems to be incomplete when compared to the algorithm described in the specs._
+     *
+     * @param {string | null} namespaceURI
+     * @returns {string | null}
+     * @see https://www.w3.org/TR/DOM-Level-3-Core/core.html#Node3-lookupNamespacePrefix
+     * @see https://www.w3.org/TR/DOM-Level-3-Core/namespaces-algorithms.html#lookupNamespacePrefixAlgo
+     * @see https://dom.spec.whatwg.org/#dom-node-lookupprefix
+     * @see https://github.com/xmldom/xmldom/issues/322
+     */
+    lookupPrefix: function(u) {
+      for (var n = this; n; ) {
+        var a = n._nsMap;
+        if (a) {
+          for (var f in a)
+            if (Object.prototype.hasOwnProperty.call(a, f) && a[f] === u)
+              return f;
+        }
+        n = n.nodeType == E ? n.ownerDocument : n.parentNode;
+      }
+      return null;
+    },
+    // Introduced in DOM Level 3:
+    lookupNamespaceURI: function(u) {
+      for (var n = this; n; ) {
+        var a = n._nsMap;
+        if (a && u in a && Object.prototype.hasOwnProperty.call(a, u))
+          return a[u];
+        n = n.nodeType == E ? n.ownerDocument : n.parentNode;
+      }
+      return null;
+    },
+    // Introduced in DOM Level 3:
+    isDefaultNamespace: function(u) {
+      var n = this.lookupPrefix(u);
+      return n == null;
+    }
+  };
+  function ue(u) {
+    return u == "<" && "&lt;" || u == ">" && "&gt;" || u == "&" && "&amp;" || u == '"' && "&quot;" || "&#" + u.charCodeAt() + ";";
+  }
+  p(D, F), p(D, F.prototype);
+  function se(u, n) {
+    if (n(u))
+      return !0;
+    if (u = u.firstChild)
+      do
+        if (se(u, n))
+          return !0;
+      while (u = u.nextSibling);
+  }
+  function W() {
+    this.ownerDocument = this;
+  }
+  function Y(u, n, a) {
+    u && u._inc++;
+    var f = a.namespaceURI;
+    f === t.XMLNS && (n._nsMap[a.prefix ? a.localName : ""] = a.value);
+  }
+  function Fe(u, n, a, f) {
+    u && u._inc++;
+    var A = a.namespaceURI;
+    A === t.XMLNS && delete n._nsMap[a.prefix ? a.localName : ""];
+  }
+  function ve(u, n, a) {
+    if (u && u._inc) {
+      u._inc++;
+      var f = n.childNodes;
+      if (a)
+        f[f.length++] = a;
+      else {
+        for (var A = n.firstChild, k = 0; A; )
+          f[k++] = A, A = A.nextSibling;
+        f.length = k, delete f[f.length];
+      }
+    }
+  }
+  function te(u, n) {
+    var a = n.previousSibling, f = n.nextSibling;
+    return a ? a.nextSibling = f : u.firstChild = f, f ? f.previousSibling = a : u.lastChild = a, n.parentNode = null, n.previousSibling = null, n.nextSibling = null, ve(u.ownerDocument, u), n;
+  }
+  function oe(u) {
+    return u && (u.nodeType === F.DOCUMENT_NODE || u.nodeType === F.DOCUMENT_FRAGMENT_NODE || u.nodeType === F.ELEMENT_NODE);
+  }
+  function Se(u) {
+    return u && (ie(u) || Ce(u) || ne(u) || u.nodeType === F.DOCUMENT_FRAGMENT_NODE || u.nodeType === F.COMMENT_NODE || u.nodeType === F.PROCESSING_INSTRUCTION_NODE);
+  }
+  function ne(u) {
+    return u && u.nodeType === F.DOCUMENT_TYPE_NODE;
+  }
+  function ie(u) {
+    return u && u.nodeType === F.ELEMENT_NODE;
+  }
+  function Ce(u) {
+    return u && u.nodeType === F.TEXT_NODE;
+  }
+  function J(u, n) {
+    var a = u.childNodes || [];
+    if (r(a, ie) || ne(n))
+      return !1;
+    var f = r(a, ne);
+    return !(n && f && a.indexOf(f) > a.indexOf(n));
+  }
+  function be(u, n) {
+    var a = u.childNodes || [];
+    function f(k) {
+      return ie(k) && k !== n;
+    }
+    if (r(a, f))
+      return !1;
+    var A = r(a, ne);
+    return !(n && A && a.indexOf(A) > a.indexOf(n));
+  }
+  function K(u, n, a) {
+    if (!oe(u))
+      throw new b(h, "Unexpected parent node type " + u.nodeType);
+    if (a && a.parentNode !== u)
+      throw new b(v, "child not in parent");
+    if (
+      // 4. If `node` is not a DocumentFragment, DocumentType, Element, or CharacterData node, then throw a "HierarchyRequestError" DOMException.
+      !Se(n) || // 5. If either `node` is a Text node and `parent` is a document,
+      // the sax parser currently adds top level text nodes, this will be fixed in 0.9.0
+      // || (node.nodeType === Node.TEXT_NODE && parent.nodeType === Node.DOCUMENT_NODE)
+      // or `node` is a doctype and `parent` is not a document, then throw a "HierarchyRequestError" DOMException.
+      ne(n) && u.nodeType !== F.DOCUMENT_NODE
+    )
+      throw new b(
+        h,
+        "Unexpected node type " + n.nodeType + " for parent node type " + u.nodeType
+      );
+  }
+  function Le(u, n, a) {
+    var f = u.childNodes || [], A = n.childNodes || [];
+    if (n.nodeType === F.DOCUMENT_FRAGMENT_NODE) {
+      var k = A.filter(ie);
+      if (k.length > 1 || r(A, Ce))
+        throw new b(h, "More than one element or text in fragment");
+      if (k.length === 1 && !J(u, a))
+        throw new b(h, "Element in fragment can not be inserted before doctype");
+    }
+    if (ie(n) && !J(u, a))
+      throw new b(h, "Only one element can be added and only after doctype");
+    if (ne(n)) {
+      if (r(f, ne))
+        throw new b(h, "Only one doctype is allowed");
+      var Z = r(f, ie);
+      if (a && f.indexOf(Z) < f.indexOf(a))
+        throw new b(h, "Doctype can only be inserted before an element");
+      if (!a && Z)
+        throw new b(h, "Doctype can not be appended since element is present");
+    }
+  }
+  function Oe(u, n, a) {
+    var f = u.childNodes || [], A = n.childNodes || [];
+    if (n.nodeType === F.DOCUMENT_FRAGMENT_NODE) {
+      var k = A.filter(ie);
+      if (k.length > 1 || r(A, Ce))
+        throw new b(h, "More than one element or text in fragment");
+      if (k.length === 1 && !be(u, a))
+        throw new b(h, "Element in fragment can not be inserted before doctype");
+    }
+    if (ie(n) && !be(u, a))
+      throw new b(h, "Only one element can be added and only after doctype");
+    if (ne(n)) {
+      if (r(f, function(le) {
+        return ne(le) && le !== a;
+      }))
+        throw new b(h, "Only one doctype is allowed");
+      var Z = r(f, ie);
+      if (a && f.indexOf(Z) < f.indexOf(a))
+        throw new b(h, "Doctype can only be inserted before an element");
+    }
+  }
+  function fe(u, n, a, f) {
+    K(u, n, a), u.nodeType === F.DOCUMENT_NODE && (f || Le)(u, n, a);
+    var A = n.parentNode;
+    if (A && A.removeChild(n), n.nodeType === q) {
+      var k = n.firstChild;
+      if (k == null)
+        return n;
+      var Z = n.lastChild;
+    } else
+      k = Z = n;
+    var re = a ? a.previousSibling : u.lastChild;
+    k.previousSibling = re, Z.nextSibling = a, re ? re.nextSibling = k : u.firstChild = k, a == null ? u.lastChild = Z : a.previousSibling = Z;
+    do
+      k.parentNode = u;
+    while (k !== Z && (k = k.nextSibling));
+    return ve(u.ownerDocument || u, u), n.nodeType == q && (n.firstChild = n.lastChild = null), n;
+  }
+  function _e(u, n) {
+    return n.parentNode && n.parentNode.removeChild(n), n.parentNode = u, n.previousSibling = u.lastChild, n.nextSibling = null, n.previousSibling ? n.previousSibling.nextSibling = n : u.firstChild = n, u.lastChild = n, ve(u.ownerDocument, u, n), n;
+  }
+  W.prototype = {
+    //implementation : null,
+    nodeName: "#document",
+    nodeType: w,
+    /**
+     * The DocumentType node of the document.
+     *
+     * @readonly
+     * @type DocumentType
+     */
+    doctype: null,
+    documentElement: null,
+    _inc: 1,
+    insertBefore: function(u, n) {
+      if (u.nodeType == q) {
+        for (var a = u.firstChild; a; ) {
+          var f = a.nextSibling;
+          this.insertBefore(a, n), a = f;
+        }
+        return u;
+      }
+      return fe(this, u, n), u.ownerDocument = this, this.documentElement === null && u.nodeType === d && (this.documentElement = u), u;
+    },
+    removeChild: function(u) {
+      return this.documentElement == u && (this.documentElement = null), te(this, u);
+    },
+    replaceChild: function(u, n) {
+      fe(this, u, n, Oe), u.ownerDocument = this, n && this.removeChild(n), ie(u) && (this.documentElement = u);
+    },
+    // Introduced in DOM Level 2:
+    importNode: function(u, n) {
+      return At(this, u, n);
+    },
+    // Introduced in DOM Level 2:
+    getElementById: function(u) {
+      var n = null;
+      return se(this.documentElement, function(a) {
+        if (a.nodeType == d && a.getAttribute("id") == u)
+          return n = a, !0;
+      }), n;
+    },
+    /**
+     * The `getElementsByClassName` method of `Document` interface returns an array-like object
+     * of all child elements which have **all** of the given class name(s).
+     *
+     * Returns an empty list if `classeNames` is an empty string or only contains HTML white space characters.
+     *
+     *
+     * Warning: This is a live LiveNodeList.
+     * Changes in the DOM will reflect in the array as the changes occur.
+     * If an element selected by this array no longer qualifies for the selector,
+     * it will automatically be removed. Be aware of this for iteration purposes.
+     *
+     * @param {string} classNames is a string representing the class name(s) to match; multiple class names are separated by (ASCII-)whitespace
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/Document/getElementsByClassName
+     * @see https://dom.spec.whatwg.org/#concept-getelementsbyclassname
+     */
+    getElementsByClassName: function(u) {
+      var n = l(u);
+      return new U(this, function(a) {
+        var f = [];
+        return n.length > 0 && se(a.documentElement, function(A) {
+          if (A !== a && A.nodeType === d) {
+            var k = A.getAttribute("class");
+            if (k) {
+              var Z = u === k;
+              if (!Z) {
+                var re = l(k);
+                Z = n.every(c(re));
+              }
+              Z && f.push(A);
+            }
+          }
+        }), f;
+      });
+    },
+    //document factory method:
+    createElement: function(u) {
+      var n = new H();
+      n.ownerDocument = this, n.nodeName = u, n.tagName = u, n.localName = u, n.childNodes = new B();
+      var a = n.attributes = new z();
+      return a._ownerElement = n, n;
+    },
+    createDocumentFragment: function() {
+      var u = new Me();
+      return u.ownerDocument = this, u.childNodes = new B(), u;
+    },
+    createTextNode: function(u) {
+      var n = new We();
+      return n.ownerDocument = this, n.appendData(u), n;
+    },
+    createComment: function(u) {
+      var n = new Ye();
+      return n.ownerDocument = this, n.appendData(u), n;
+    },
+    createCDATASection: function(u) {
+      var n = new Ke();
+      return n.ownerDocument = this, n.appendData(u), n;
+    },
+    createProcessingInstruction: function(u, n) {
+      var a = new Je();
+      return a.ownerDocument = this, a.tagName = a.nodeName = a.target = u, a.nodeValue = a.data = n, a;
+    },
+    createAttribute: function(u) {
+      var n = new Q();
+      return n.ownerDocument = this, n.name = u, n.nodeName = u, n.localName = u, n.specified = !0, n;
+    },
+    createEntityReference: function(u) {
+      var n = new Qe();
+      return n.ownerDocument = this, n.nodeName = u, n;
+    },
+    // Introduced in DOM Level 2:
+    createElementNS: function(u, n) {
+      var a = new H(), f = n.split(":"), A = a.attributes = new z();
+      return a.childNodes = new B(), a.ownerDocument = this, a.nodeName = n, a.tagName = n, a.namespaceURI = u, f.length == 2 ? (a.prefix = f[0], a.localName = f[1]) : a.localName = n, A._ownerElement = a, a;
+    },
+    // Introduced in DOM Level 2:
+    createAttributeNS: function(u, n) {
+      var a = new Q(), f = n.split(":");
+      return a.ownerDocument = this, a.nodeName = n, a.name = n, a.namespaceURI = u, a.specified = !0, f.length == 2 ? (a.prefix = f[0], a.localName = f[1]) : a.localName = n, a;
+    }
+  }, g(W, F);
+  function H() {
+    this._nsMap = {};
+  }
+  H.prototype = {
+    nodeType: d,
+    hasAttribute: function(u) {
+      return this.getAttributeNode(u) != null;
+    },
+    getAttribute: function(u) {
+      var n = this.getAttributeNode(u);
+      return n && n.value || "";
+    },
+    getAttributeNode: function(u) {
+      return this.attributes.getNamedItem(u);
+    },
+    setAttribute: function(u, n) {
+      var a = this.ownerDocument.createAttribute(u);
+      a.value = a.nodeValue = "" + n, this.setAttributeNode(a);
+    },
+    removeAttribute: function(u) {
+      var n = this.getAttributeNode(u);
+      n && this.removeAttributeNode(n);
+    },
+    //four real opeartion method
+    appendChild: function(u) {
+      return u.nodeType === q ? this.insertBefore(u, null) : _e(this, u);
+    },
+    setAttributeNode: function(u) {
+      return this.attributes.setNamedItem(u);
+    },
+    setAttributeNodeNS: function(u) {
+      return this.attributes.setNamedItemNS(u);
+    },
+    removeAttributeNode: function(u) {
+      return this.attributes.removeNamedItem(u.nodeName);
+    },
+    //get real attribute name,and remove it by removeAttributeNode
+    removeAttributeNS: function(u, n) {
+      var a = this.getAttributeNodeNS(u, n);
+      a && this.removeAttributeNode(a);
+    },
+    hasAttributeNS: function(u, n) {
+      return this.getAttributeNodeNS(u, n) != null;
+    },
+    getAttributeNS: function(u, n) {
+      var a = this.getAttributeNodeNS(u, n);
+      return a && a.value || "";
+    },
+    setAttributeNS: function(u, n, a) {
+      var f = this.ownerDocument.createAttributeNS(u, n);
+      f.value = f.nodeValue = "" + a, this.setAttributeNode(f);
+    },
+    getAttributeNodeNS: function(u, n) {
+      return this.attributes.getNamedItemNS(u, n);
+    },
+    getElementsByTagName: function(u) {
+      return new U(this, function(n) {
+        var a = [];
+        return se(n, function(f) {
+          f !== n && f.nodeType == d && (u === "*" || f.tagName == u) && a.push(f);
+        }), a;
+      });
+    },
+    getElementsByTagNameNS: function(u, n) {
+      return new U(this, function(a) {
+        var f = [];
+        return se(a, function(A) {
+          A !== a && A.nodeType === d && (u === "*" || A.namespaceURI === u) && (n === "*" || A.localName == n) && f.push(A);
+        }), f;
+      });
+    }
+  }, W.prototype.getElementsByTagName = H.prototype.getElementsByTagName, W.prototype.getElementsByTagNameNS = H.prototype.getElementsByTagNameNS, g(H, F);
+  function Q() {
+  }
+  Q.prototype.nodeType = E, g(Q, F);
+  function he() {
+  }
+  he.prototype = {
+    data: "",
+    substringData: function(u, n) {
+      return this.data.substring(u, u + n);
+    },
+    appendData: function(u) {
+      u = this.data + u, this.nodeValue = this.data = u, this.length = u.length;
+    },
+    insertData: function(u, n) {
+      this.replaceData(u, 0, n);
+    },
+    appendChild: function(u) {
+      throw new Error(G[h]);
+    },
+    deleteData: function(u, n) {
+      this.replaceData(u, n, "");
+    },
+    replaceData: function(u, n, a) {
+      var f = this.data.substring(0, u), A = this.data.substring(u + n);
+      a = f + a + A, this.nodeValue = this.data = a, this.length = a.length;
+    }
+  }, g(he, F);
+  function We() {
+  }
+  We.prototype = {
+    nodeName: "#text",
+    nodeType: S,
+    splitText: function(u) {
+      var n = this.data, a = n.substring(u);
+      n = n.substring(0, u), this.data = this.nodeValue = n, this.length = n.length;
+      var f = this.ownerDocument.createTextNode(a);
+      return this.parentNode && this.parentNode.insertBefore(f, this.nextSibling), f;
+    }
+  }, g(We, he);
+  function Ye() {
+  }
+  Ye.prototype = {
+    nodeName: "#comment",
+    nodeType: R
+  }, g(Ye, he);
+  function Ke() {
+  }
+  Ke.prototype = {
+    nodeName: "#cdata-section",
+    nodeType: C
+  }, g(Ke, he);
+  function Ue() {
+  }
+  Ue.prototype.nodeType = y, g(Ue, F);
+  function gt() {
+  }
+  gt.prototype.nodeType = j, g(gt, F);
+  function ht() {
+  }
+  ht.prototype.nodeType = N, g(ht, F);
+  function Qe() {
+  }
+  Qe.prototype.nodeType = m, g(Qe, F);
+  function Me() {
+  }
+  Me.prototype.nodeName = "#document-fragment", Me.prototype.nodeType = q, g(Me, F);
+  function Je() {
+  }
+  Je.prototype.nodeType = P, g(Je, F);
+  function Dt() {
+  }
+  Dt.prototype.serializeToString = function(u, n, a) {
+    return mt.call(u, n, a);
+  }, F.prototype.toString = mt;
+  function mt(u, n) {
+    var a = [], f = this.nodeType == 9 && this.documentElement || this, A = f.prefix, k = f.namespaceURI;
+    if (k && A == null) {
+      var A = f.lookupPrefix(k);
+      if (A == null)
+        var Z = [
+          { namespace: k, prefix: null }
+          //{namespace:uri,prefix:''}
+        ];
+    }
+    return we(this, a, u, n, Z), a.join("");
+  }
+  function dt(u, n, a) {
+    var f = u.prefix || "", A = u.namespaceURI;
+    if (!A || f === "xml" && A === t.XML || A === t.XMLNS)
+      return !1;
+    for (var k = a.length; k--; ) {
+      var Z = a[k];
+      if (Z.prefix === f)
+        return Z.namespace !== A;
+    }
+    return !0;
+  }
+  function et(u, n, a) {
+    u.push(" ", n, '="', a.replace(/[<&"]/g, ue), '"');
+  }
+  function we(u, n, a, f, A) {
+    if (A || (A = []), f)
+      if (u = f(u), u) {
+        if (typeof u == "string") {
+          n.push(u);
+          return;
+        }
+      } else
+        return;
+    switch (u.nodeType) {
+      case d:
+        var k = u.attributes, Z = k.length, ee = u.firstChild, re = u.tagName;
+        a = t.isHTML(u.namespaceURI) || a;
+        var le = re;
+        if (!a && !u.prefix && u.namespaceURI) {
+          for (var ge, ce = 0; ce < k.length; ce++)
+            if (k.item(ce).name === "xmlns") {
+              ge = k.item(ce).value;
+              break;
+            }
+          if (!ge)
+            for (var De = A.length - 1; De >= 0; De--) {
+              var me = A[De];
+              if (me.prefix === "" && me.namespace === u.namespaceURI) {
+                ge = me.namespace;
+                break;
+              }
+            }
+          if (ge !== u.namespaceURI)
+            for (var De = A.length - 1; De >= 0; De--) {
+              var me = A[De];
+              if (me.namespace === u.namespaceURI) {
+                me.prefix && (le = me.prefix + ":" + re);
+                break;
+              }
+            }
+        }
+        n.push("<", le);
+        for (var de = 0; de < Z; de++) {
+          var ae = k.item(de);
+          ae.prefix == "xmlns" ? A.push({ prefix: ae.localName, namespace: ae.value }) : ae.nodeName == "xmlns" && A.push({ prefix: "", namespace: ae.value });
+        }
+        for (var de = 0; de < Z; de++) {
+          var ae = k.item(de);
+          if (dt(ae, a, A)) {
+            var Ae = ae.prefix || "", Pe = ae.namespaceURI;
+            et(n, Ae ? "xmlns:" + Ae : "xmlns", Pe), A.push({ prefix: Ae, namespace: Pe });
+          }
+          we(ae, n, a, f, A);
+        }
+        if (re === le && dt(u, a, A)) {
+          var Ae = u.prefix || "", Pe = u.namespaceURI;
+          et(n, Ae ? "xmlns:" + Ae : "xmlns", Pe), A.push({ prefix: Ae, namespace: Pe });
+        }
+        if (ee || a && !/^(?:meta|link|img|br|hr|input)$/i.test(re)) {
+          if (n.push(">"), a && /^script$/i.test(re))
+            for (; ee; )
+              ee.data ? n.push(ee.data) : we(ee, n, a, f, A.slice()), ee = ee.nextSibling;
+          else
+            for (; ee; )
+              we(ee, n, a, f, A.slice()), ee = ee.nextSibling;
+          n.push("</", le, ">");
+        } else
+          n.push("/>");
+        return;
+      case w:
+      case q:
+        for (var ee = u.firstChild; ee; )
+          we(ee, n, a, f, A.slice()), ee = ee.nextSibling;
+        return;
+      case E:
+        return et(n, u.name, u.value);
+      case S:
+        return n.push(
+          u.data.replace(/[<&]/g, ue).replace(/]]>/g, "]]&gt;")
+        );
+      case C:
+        return n.push("<![CDATA[", u.data, "]]>");
+      case R:
+        return n.push("<!--", u.data, "-->");
+      case y:
+        var yt = u.publicId, xe = u.systemId;
+        if (n.push("<!DOCTYPE ", u.name), yt)
+          n.push(" PUBLIC ", yt), xe && xe != "." && n.push(" ", xe), n.push(">");
+        else if (xe && xe != ".")
+          n.push(" SYSTEM ", xe, ">");
+        else {
+          var vt = u.internalSubset;
+          vt && n.push(" [", vt, "]"), n.push(">");
+        }
+        return;
+      case P:
+        return n.push("<?", u.target, " ", u.data, "?>");
+      case m:
+        return n.push("&", u.nodeName, ";");
+      //case ENTITY_NODE:
+      //case NOTATION_NODE:
+      default:
+        n.push("??", u.nodeName);
+    }
+  }
+  function At(u, n, a) {
+    var f;
+    switch (n.nodeType) {
+      case d:
+        f = n.cloneNode(!1), f.ownerDocument = u;
+      //var attrs = node2.attributes;
+      //var len = attrs.length;
+      //for(var i=0;i<len;i++){
+      //node2.setAttributeNodeNS(importNode(doc,attrs.item(i),deep));
+      //}
+      case q:
+        break;
+      case E:
+        a = !0;
+        break;
+    }
+    if (f || (f = n.cloneNode(!1)), f.ownerDocument = u, f.parentNode = null, a)
+      for (var A = n.firstChild; A; )
+        f.appendChild(At(u, A, a)), A = A.nextSibling;
+    return f;
+  }
+  function tt(u, n, a) {
+    var f = new n.constructor();
+    for (var A in n)
+      if (Object.prototype.hasOwnProperty.call(n, A)) {
+        var k = n[A];
+        typeof k != "object" && k != f[A] && (f[A] = k);
+      }
+    switch (n.childNodes && (f.childNodes = new B()), f.ownerDocument = u, f.nodeType) {
+      case d:
+        var Z = n.attributes, re = f.attributes = new z(), le = Z.length;
+        re._ownerElement = f;
+        for (var ge = 0; ge < le; ge++)
+          f.setAttributeNode(tt(u, Z.item(ge), !0));
+        break;
+      case E:
+        a = !0;
+    }
+    if (a)
+      for (var ce = n.firstChild; ce; )
+        f.appendChild(tt(u, ce, a)), ce = ce.nextSibling;
+    return f;
+  }
+  function Et(u, n, a) {
+    u[n] = a;
+  }
+  try {
+    if (Object.defineProperty) {
+      let u = function(n) {
+        switch (n.nodeType) {
+          case d:
+          case q:
+            var a = [];
+            for (n = n.firstChild; n; )
+              n.nodeType !== 7 && n.nodeType !== 8 && a.push(u(n)), n = n.nextSibling;
+            return a.join("");
+          default:
+            return n.nodeValue;
+        }
+      };
+      Object.defineProperty(U.prototype, "length", {
+        get: function() {
+          return M(this), this.$$length;
+        }
+      }), Object.defineProperty(F.prototype, "textContent", {
+        get: function() {
+          return u(this);
+        },
+        set: function(n) {
+          switch (this.nodeType) {
+            case d:
+            case q:
+              for (; this.firstChild; )
+                this.removeChild(this.firstChild);
+              (n || String(n)) && this.appendChild(this.ownerDocument.createTextNode(n));
+              break;
+            default:
+              this.data = n, this.value = n, this.nodeValue = n;
+          }
+        }
+      }), Et = function(n, a, f) {
+        n["$$" + a] = f;
+      };
+    }
+  } catch {
+  }
+  return pe.DocumentType = Ue, pe.DOMException = b, pe.DOMImplementation = $, pe.Element = H, pe.Node = F, pe.NodeList = B, pe.XMLSerializer = Dt, pe;
+}
+var Te = {}, nt = {}, Pt;
+function zu() {
+  return Pt || (Pt = 1, (function(e) {
+    var r = $e().freeze;
+    e.XML_ENTITIES = r({
+      amp: "&",
+      apos: "'",
+      gt: ">",
+      lt: "<",
+      quot: '"'
+    }), e.HTML_ENTITIES = r({
+      Aacute: "Á",
+      aacute: "á",
+      Abreve: "Ă",
+      abreve: "ă",
+      ac: "∾",
+      acd: "∿",
+      acE: "∾̳",
+      Acirc: "Â",
+      acirc: "â",
+      acute: "´",
+      Acy: "А",
+      acy: "а",
+      AElig: "Æ",
+      aelig: "æ",
+      af: "⁡",
+      Afr: "𝔄",
+      afr: "𝔞",
+      Agrave: "À",
+      agrave: "à",
+      alefsym: "ℵ",
+      aleph: "ℵ",
+      Alpha: "Α",
+      alpha: "α",
+      Amacr: "Ā",
+      amacr: "ā",
+      amalg: "⨿",
+      AMP: "&",
+      amp: "&",
+      And: "⩓",
+      and: "∧",
+      andand: "⩕",
+      andd: "⩜",
+      andslope: "⩘",
+      andv: "⩚",
+      ang: "∠",
+      ange: "⦤",
+      angle: "∠",
+      angmsd: "∡",
+      angmsdaa: "⦨",
+      angmsdab: "⦩",
+      angmsdac: "⦪",
+      angmsdad: "⦫",
+      angmsdae: "⦬",
+      angmsdaf: "⦭",
+      angmsdag: "⦮",
+      angmsdah: "⦯",
+      angrt: "∟",
+      angrtvb: "⊾",
+      angrtvbd: "⦝",
+      angsph: "∢",
+      angst: "Å",
+      angzarr: "⍼",
+      Aogon: "Ą",
+      aogon: "ą",
+      Aopf: "𝔸",
+      aopf: "𝕒",
+      ap: "≈",
+      apacir: "⩯",
+      apE: "⩰",
+      ape: "≊",
+      apid: "≋",
+      apos: "'",
+      ApplyFunction: "⁡",
+      approx: "≈",
+      approxeq: "≊",
+      Aring: "Å",
+      aring: "å",
+      Ascr: "𝒜",
+      ascr: "𝒶",
+      Assign: "≔",
+      ast: "*",
+      asymp: "≈",
+      asympeq: "≍",
+      Atilde: "Ã",
+      atilde: "ã",
+      Auml: "Ä",
+      auml: "ä",
+      awconint: "∳",
+      awint: "⨑",
+      backcong: "≌",
+      backepsilon: "϶",
+      backprime: "‵",
+      backsim: "∽",
+      backsimeq: "⋍",
+      Backslash: "∖",
+      Barv: "⫧",
+      barvee: "⊽",
+      Barwed: "⌆",
+      barwed: "⌅",
+      barwedge: "⌅",
+      bbrk: "⎵",
+      bbrktbrk: "⎶",
+      bcong: "≌",
+      Bcy: "Б",
+      bcy: "б",
+      bdquo: "„",
+      becaus: "∵",
+      Because: "∵",
+      because: "∵",
+      bemptyv: "⦰",
+      bepsi: "϶",
+      bernou: "ℬ",
+      Bernoullis: "ℬ",
+      Beta: "Β",
+      beta: "β",
+      beth: "ℶ",
+      between: "≬",
+      Bfr: "𝔅",
+      bfr: "𝔟",
+      bigcap: "⋂",
+      bigcirc: "◯",
+      bigcup: "⋃",
+      bigodot: "⨀",
+      bigoplus: "⨁",
+      bigotimes: "⨂",
+      bigsqcup: "⨆",
+      bigstar: "★",
+      bigtriangledown: "▽",
+      bigtriangleup: "△",
+      biguplus: "⨄",
+      bigvee: "⋁",
+      bigwedge: "⋀",
+      bkarow: "⤍",
+      blacklozenge: "⧫",
+      blacksquare: "▪",
+      blacktriangle: "▴",
+      blacktriangledown: "▾",
+      blacktriangleleft: "◂",
+      blacktriangleright: "▸",
+      blank: "␣",
+      blk12: "▒",
+      blk14: "░",
+      blk34: "▓",
+      block: "█",
+      bne: "=⃥",
+      bnequiv: "≡⃥",
+      bNot: "⫭",
+      bnot: "⌐",
+      Bopf: "𝔹",
+      bopf: "𝕓",
+      bot: "⊥",
+      bottom: "⊥",
+      bowtie: "⋈",
+      boxbox: "⧉",
+      boxDL: "╗",
+      boxDl: "╖",
+      boxdL: "╕",
+      boxdl: "┐",
+      boxDR: "╔",
+      boxDr: "╓",
+      boxdR: "╒",
+      boxdr: "┌",
+      boxH: "═",
+      boxh: "─",
+      boxHD: "╦",
+      boxHd: "╤",
+      boxhD: "╥",
+      boxhd: "┬",
+      boxHU: "╩",
+      boxHu: "╧",
+      boxhU: "╨",
+      boxhu: "┴",
+      boxminus: "⊟",
+      boxplus: "⊞",
+      boxtimes: "⊠",
+      boxUL: "╝",
+      boxUl: "╜",
+      boxuL: "╛",
+      boxul: "┘",
+      boxUR: "╚",
+      boxUr: "╙",
+      boxuR: "╘",
+      boxur: "└",
+      boxV: "║",
+      boxv: "│",
+      boxVH: "╬",
+      boxVh: "╫",
+      boxvH: "╪",
+      boxvh: "┼",
+      boxVL: "╣",
+      boxVl: "╢",
+      boxvL: "╡",
+      boxvl: "┤",
+      boxVR: "╠",
+      boxVr: "╟",
+      boxvR: "╞",
+      boxvr: "├",
+      bprime: "‵",
+      Breve: "˘",
+      breve: "˘",
+      brvbar: "¦",
+      Bscr: "ℬ",
+      bscr: "𝒷",
+      bsemi: "⁏",
+      bsim: "∽",
+      bsime: "⋍",
+      bsol: "\\",
+      bsolb: "⧅",
+      bsolhsub: "⟈",
+      bull: "•",
+      bullet: "•",
+      bump: "≎",
+      bumpE: "⪮",
+      bumpe: "≏",
+      Bumpeq: "≎",
+      bumpeq: "≏",
+      Cacute: "Ć",
+      cacute: "ć",
+      Cap: "⋒",
+      cap: "∩",
+      capand: "⩄",
+      capbrcup: "⩉",
+      capcap: "⩋",
+      capcup: "⩇",
+      capdot: "⩀",
+      CapitalDifferentialD: "ⅅ",
+      caps: "∩︀",
+      caret: "⁁",
+      caron: "ˇ",
+      Cayleys: "ℭ",
+      ccaps: "⩍",
+      Ccaron: "Č",
+      ccaron: "č",
+      Ccedil: "Ç",
+      ccedil: "ç",
+      Ccirc: "Ĉ",
+      ccirc: "ĉ",
+      Cconint: "∰",
+      ccups: "⩌",
+      ccupssm: "⩐",
+      Cdot: "Ċ",
+      cdot: "ċ",
+      cedil: "¸",
+      Cedilla: "¸",
+      cemptyv: "⦲",
+      cent: "¢",
+      CenterDot: "·",
+      centerdot: "·",
+      Cfr: "ℭ",
+      cfr: "𝔠",
+      CHcy: "Ч",
+      chcy: "ч",
+      check: "✓",
+      checkmark: "✓",
+      Chi: "Χ",
+      chi: "χ",
+      cir: "○",
+      circ: "ˆ",
+      circeq: "≗",
+      circlearrowleft: "↺",
+      circlearrowright: "↻",
+      circledast: "⊛",
+      circledcirc: "⊚",
+      circleddash: "⊝",
+      CircleDot: "⊙",
+      circledR: "®",
+      circledS: "Ⓢ",
+      CircleMinus: "⊖",
+      CirclePlus: "⊕",
+      CircleTimes: "⊗",
+      cirE: "⧃",
+      cire: "≗",
+      cirfnint: "⨐",
+      cirmid: "⫯",
+      cirscir: "⧂",
+      ClockwiseContourIntegral: "∲",
+      CloseCurlyDoubleQuote: "”",
+      CloseCurlyQuote: "’",
+      clubs: "♣",
+      clubsuit: "♣",
+      Colon: "∷",
+      colon: ":",
+      Colone: "⩴",
+      colone: "≔",
+      coloneq: "≔",
+      comma: ",",
+      commat: "@",
+      comp: "∁",
+      compfn: "∘",
+      complement: "∁",
+      complexes: "ℂ",
+      cong: "≅",
+      congdot: "⩭",
+      Congruent: "≡",
+      Conint: "∯",
+      conint: "∮",
+      ContourIntegral: "∮",
+      Copf: "ℂ",
+      copf: "𝕔",
+      coprod: "∐",
+      Coproduct: "∐",
+      COPY: "©",
+      copy: "©",
+      copysr: "℗",
+      CounterClockwiseContourIntegral: "∳",
+      crarr: "↵",
+      Cross: "⨯",
+      cross: "✗",
+      Cscr: "𝒞",
+      cscr: "𝒸",
+      csub: "⫏",
+      csube: "⫑",
+      csup: "⫐",
+      csupe: "⫒",
+      ctdot: "⋯",
+      cudarrl: "⤸",
+      cudarrr: "⤵",
+      cuepr: "⋞",
+      cuesc: "⋟",
+      cularr: "↶",
+      cularrp: "⤽",
+      Cup: "⋓",
+      cup: "∪",
+      cupbrcap: "⩈",
+      CupCap: "≍",
+      cupcap: "⩆",
+      cupcup: "⩊",
+      cupdot: "⊍",
+      cupor: "⩅",
+      cups: "∪︀",
+      curarr: "↷",
+      curarrm: "⤼",
+      curlyeqprec: "⋞",
+      curlyeqsucc: "⋟",
+      curlyvee: "⋎",
+      curlywedge: "⋏",
+      curren: "¤",
+      curvearrowleft: "↶",
+      curvearrowright: "↷",
+      cuvee: "⋎",
+      cuwed: "⋏",
+      cwconint: "∲",
+      cwint: "∱",
+      cylcty: "⌭",
+      Dagger: "‡",
+      dagger: "†",
+      daleth: "ℸ",
+      Darr: "↡",
+      dArr: "⇓",
+      darr: "↓",
+      dash: "‐",
+      Dashv: "⫤",
+      dashv: "⊣",
+      dbkarow: "⤏",
+      dblac: "˝",
+      Dcaron: "Ď",
+      dcaron: "ď",
+      Dcy: "Д",
+      dcy: "д",
+      DD: "ⅅ",
+      dd: "ⅆ",
+      ddagger: "‡",
+      ddarr: "⇊",
+      DDotrahd: "⤑",
+      ddotseq: "⩷",
+      deg: "°",
+      Del: "∇",
+      Delta: "Δ",
+      delta: "δ",
+      demptyv: "⦱",
+      dfisht: "⥿",
+      Dfr: "𝔇",
+      dfr: "𝔡",
+      dHar: "⥥",
+      dharl: "⇃",
+      dharr: "⇂",
+      DiacriticalAcute: "´",
+      DiacriticalDot: "˙",
+      DiacriticalDoubleAcute: "˝",
+      DiacriticalGrave: "`",
+      DiacriticalTilde: "˜",
+      diam: "⋄",
+      Diamond: "⋄",
+      diamond: "⋄",
+      diamondsuit: "♦",
+      diams: "♦",
+      die: "¨",
+      DifferentialD: "ⅆ",
+      digamma: "ϝ",
+      disin: "⋲",
+      div: "÷",
+      divide: "÷",
+      divideontimes: "⋇",
+      divonx: "⋇",
+      DJcy: "Ђ",
+      djcy: "ђ",
+      dlcorn: "⌞",
+      dlcrop: "⌍",
+      dollar: "$",
+      Dopf: "𝔻",
+      dopf: "𝕕",
+      Dot: "¨",
+      dot: "˙",
+      DotDot: "⃜",
+      doteq: "≐",
+      doteqdot: "≑",
+      DotEqual: "≐",
+      dotminus: "∸",
+      dotplus: "∔",
+      dotsquare: "⊡",
+      doublebarwedge: "⌆",
+      DoubleContourIntegral: "∯",
+      DoubleDot: "¨",
+      DoubleDownArrow: "⇓",
+      DoubleLeftArrow: "⇐",
+      DoubleLeftRightArrow: "⇔",
+      DoubleLeftTee: "⫤",
+      DoubleLongLeftArrow: "⟸",
+      DoubleLongLeftRightArrow: "⟺",
+      DoubleLongRightArrow: "⟹",
+      DoubleRightArrow: "⇒",
+      DoubleRightTee: "⊨",
+      DoubleUpArrow: "⇑",
+      DoubleUpDownArrow: "⇕",
+      DoubleVerticalBar: "∥",
+      DownArrow: "↓",
+      Downarrow: "⇓",
+      downarrow: "↓",
+      DownArrowBar: "⤓",
+      DownArrowUpArrow: "⇵",
+      DownBreve: "̑",
+      downdownarrows: "⇊",
+      downharpoonleft: "⇃",
+      downharpoonright: "⇂",
+      DownLeftRightVector: "⥐",
+      DownLeftTeeVector: "⥞",
+      DownLeftVector: "↽",
+      DownLeftVectorBar: "⥖",
+      DownRightTeeVector: "⥟",
+      DownRightVector: "⇁",
+      DownRightVectorBar: "⥗",
+      DownTee: "⊤",
+      DownTeeArrow: "↧",
+      drbkarow: "⤐",
+      drcorn: "⌟",
+      drcrop: "⌌",
+      Dscr: "𝒟",
+      dscr: "𝒹",
+      DScy: "Ѕ",
+      dscy: "ѕ",
+      dsol: "⧶",
+      Dstrok: "Đ",
+      dstrok: "đ",
+      dtdot: "⋱",
+      dtri: "▿",
+      dtrif: "▾",
+      duarr: "⇵",
+      duhar: "⥯",
+      dwangle: "⦦",
+      DZcy: "Џ",
+      dzcy: "џ",
+      dzigrarr: "⟿",
+      Eacute: "É",
+      eacute: "é",
+      easter: "⩮",
+      Ecaron: "Ě",
+      ecaron: "ě",
+      ecir: "≖",
+      Ecirc: "Ê",
+      ecirc: "ê",
+      ecolon: "≕",
+      Ecy: "Э",
+      ecy: "э",
+      eDDot: "⩷",
+      Edot: "Ė",
+      eDot: "≑",
+      edot: "ė",
+      ee: "ⅇ",
+      efDot: "≒",
+      Efr: "𝔈",
+      efr: "𝔢",
+      eg: "⪚",
+      Egrave: "È",
+      egrave: "è",
+      egs: "⪖",
+      egsdot: "⪘",
+      el: "⪙",
+      Element: "∈",
+      elinters: "⏧",
+      ell: "ℓ",
+      els: "⪕",
+      elsdot: "⪗",
+      Emacr: "Ē",
+      emacr: "ē",
+      empty: "∅",
+      emptyset: "∅",
+      EmptySmallSquare: "◻",
+      emptyv: "∅",
+      EmptyVerySmallSquare: "▫",
+      emsp: " ",
+      emsp13: " ",
+      emsp14: " ",
+      ENG: "Ŋ",
+      eng: "ŋ",
+      ensp: " ",
+      Eogon: "Ę",
+      eogon: "ę",
+      Eopf: "𝔼",
+      eopf: "𝕖",
+      epar: "⋕",
+      eparsl: "⧣",
+      eplus: "⩱",
+      epsi: "ε",
+      Epsilon: "Ε",
+      epsilon: "ε",
+      epsiv: "ϵ",
+      eqcirc: "≖",
+      eqcolon: "≕",
+      eqsim: "≂",
+      eqslantgtr: "⪖",
+      eqslantless: "⪕",
+      Equal: "⩵",
+      equals: "=",
+      EqualTilde: "≂",
+      equest: "≟",
+      Equilibrium: "⇌",
+      equiv: "≡",
+      equivDD: "⩸",
+      eqvparsl: "⧥",
+      erarr: "⥱",
+      erDot: "≓",
+      Escr: "ℰ",
+      escr: "ℯ",
+      esdot: "≐",
+      Esim: "⩳",
+      esim: "≂",
+      Eta: "Η",
+      eta: "η",
+      ETH: "Ð",
+      eth: "ð",
+      Euml: "Ë",
+      euml: "ë",
+      euro: "€",
+      excl: "!",
+      exist: "∃",
+      Exists: "∃",
+      expectation: "ℰ",
+      ExponentialE: "ⅇ",
+      exponentiale: "ⅇ",
+      fallingdotseq: "≒",
+      Fcy: "Ф",
+      fcy: "ф",
+      female: "♀",
+      ffilig: "ffi",
+      fflig: "ff",
+      ffllig: "ffl",
+      Ffr: "𝔉",
+      ffr: "𝔣",
+      filig: "fi",
+      FilledSmallSquare: "◼",
+      FilledVerySmallSquare: "▪",
+      fjlig: "fj",
+      flat: "♭",
+      fllig: "fl",
+      fltns: "▱",
+      fnof: "ƒ",
+      Fopf: "𝔽",
+      fopf: "𝕗",
+      ForAll: "∀",
+      forall: "∀",
+      fork: "⋔",
+      forkv: "⫙",
+      Fouriertrf: "ℱ",
+      fpartint: "⨍",
+      frac12: "½",
+      frac13: "⅓",
+      frac14: "¼",
+      frac15: "⅕",
+      frac16: "⅙",
+      frac18: "⅛",
+      frac23: "⅔",
+      frac25: "⅖",
+      frac34: "¾",
+      frac35: "⅗",
+      frac38: "⅜",
+      frac45: "⅘",
+      frac56: "⅚",
+      frac58: "⅝",
+      frac78: "⅞",
+      frasl: "⁄",
+      frown: "⌢",
+      Fscr: "ℱ",
+      fscr: "𝒻",
+      gacute: "ǵ",
+      Gamma: "Γ",
+      gamma: "γ",
+      Gammad: "Ϝ",
+      gammad: "ϝ",
+      gap: "⪆",
+      Gbreve: "Ğ",
+      gbreve: "ğ",
+      Gcedil: "Ģ",
+      Gcirc: "Ĝ",
+      gcirc: "ĝ",
+      Gcy: "Г",
+      gcy: "г",
+      Gdot: "Ġ",
+      gdot: "ġ",
+      gE: "≧",
+      ge: "≥",
+      gEl: "⪌",
+      gel: "⋛",
+      geq: "≥",
+      geqq: "≧",
+      geqslant: "⩾",
+      ges: "⩾",
+      gescc: "⪩",
+      gesdot: "⪀",
+      gesdoto: "⪂",
+      gesdotol: "⪄",
+      gesl: "⋛︀",
+      gesles: "⪔",
+      Gfr: "𝔊",
+      gfr: "𝔤",
+      Gg: "⋙",
+      gg: "≫",
+      ggg: "⋙",
+      gimel: "ℷ",
+      GJcy: "Ѓ",
+      gjcy: "ѓ",
+      gl: "≷",
+      gla: "⪥",
+      glE: "⪒",
+      glj: "⪤",
+      gnap: "⪊",
+      gnapprox: "⪊",
+      gnE: "≩",
+      gne: "⪈",
+      gneq: "⪈",
+      gneqq: "≩",
+      gnsim: "⋧",
+      Gopf: "𝔾",
+      gopf: "𝕘",
+      grave: "`",
+      GreaterEqual: "≥",
+      GreaterEqualLess: "⋛",
+      GreaterFullEqual: "≧",
+      GreaterGreater: "⪢",
+      GreaterLess: "≷",
+      GreaterSlantEqual: "⩾",
+      GreaterTilde: "≳",
+      Gscr: "𝒢",
+      gscr: "ℊ",
+      gsim: "≳",
+      gsime: "⪎",
+      gsiml: "⪐",
+      Gt: "≫",
+      GT: ">",
+      gt: ">",
+      gtcc: "⪧",
+      gtcir: "⩺",
+      gtdot: "⋗",
+      gtlPar: "⦕",
+      gtquest: "⩼",
+      gtrapprox: "⪆",
+      gtrarr: "⥸",
+      gtrdot: "⋗",
+      gtreqless: "⋛",
+      gtreqqless: "⪌",
+      gtrless: "≷",
+      gtrsim: "≳",
+      gvertneqq: "≩︀",
+      gvnE: "≩︀",
+      Hacek: "ˇ",
+      hairsp: " ",
+      half: "½",
+      hamilt: "ℋ",
+      HARDcy: "Ъ",
+      hardcy: "ъ",
+      hArr: "⇔",
+      harr: "↔",
+      harrcir: "⥈",
+      harrw: "↭",
+      Hat: "^",
+      hbar: "ℏ",
+      Hcirc: "Ĥ",
+      hcirc: "ĥ",
+      hearts: "♥",
+      heartsuit: "♥",
+      hellip: "…",
+      hercon: "⊹",
+      Hfr: "ℌ",
+      hfr: "𝔥",
+      HilbertSpace: "ℋ",
+      hksearow: "⤥",
+      hkswarow: "⤦",
+      hoarr: "⇿",
+      homtht: "∻",
+      hookleftarrow: "↩",
+      hookrightarrow: "↪",
+      Hopf: "ℍ",
+      hopf: "𝕙",
+      horbar: "―",
+      HorizontalLine: "─",
+      Hscr: "ℋ",
+      hscr: "𝒽",
+      hslash: "ℏ",
+      Hstrok: "Ħ",
+      hstrok: "ħ",
+      HumpDownHump: "≎",
+      HumpEqual: "≏",
+      hybull: "⁃",
+      hyphen: "‐",
+      Iacute: "Í",
+      iacute: "í",
+      ic: "⁣",
+      Icirc: "Î",
+      icirc: "î",
+      Icy: "И",
+      icy: "и",
+      Idot: "İ",
+      IEcy: "Е",
+      iecy: "е",
+      iexcl: "¡",
+      iff: "⇔",
+      Ifr: "ℑ",
+      ifr: "𝔦",
+      Igrave: "Ì",
+      igrave: "ì",
+      ii: "ⅈ",
+      iiiint: "⨌",
+      iiint: "∭",
+      iinfin: "⧜",
+      iiota: "℩",
+      IJlig: "IJ",
+      ijlig: "ij",
+      Im: "ℑ",
+      Imacr: "Ī",
+      imacr: "ī",
+      image: "ℑ",
+      ImaginaryI: "ⅈ",
+      imagline: "ℐ",
+      imagpart: "ℑ",
+      imath: "ı",
+      imof: "⊷",
+      imped: "Ƶ",
+      Implies: "⇒",
+      in: "∈",
+      incare: "℅",
+      infin: "∞",
+      infintie: "⧝",
+      inodot: "ı",
+      Int: "∬",
+      int: "∫",
+      intcal: "⊺",
+      integers: "ℤ",
+      Integral: "∫",
+      intercal: "⊺",
+      Intersection: "⋂",
+      intlarhk: "⨗",
+      intprod: "⨼",
+      InvisibleComma: "⁣",
+      InvisibleTimes: "⁢",
+      IOcy: "Ё",
+      iocy: "ё",
+      Iogon: "Į",
+      iogon: "į",
+      Iopf: "𝕀",
+      iopf: "𝕚",
+      Iota: "Ι",
+      iota: "ι",
+      iprod: "⨼",
+      iquest: "¿",
+      Iscr: "ℐ",
+      iscr: "𝒾",
+      isin: "∈",
+      isindot: "⋵",
+      isinE: "⋹",
+      isins: "⋴",
+      isinsv: "⋳",
+      isinv: "∈",
+      it: "⁢",
+      Itilde: "Ĩ",
+      itilde: "ĩ",
+      Iukcy: "І",
+      iukcy: "і",
+      Iuml: "Ï",
+      iuml: "ï",
+      Jcirc: "Ĵ",
+      jcirc: "ĵ",
+      Jcy: "Й",
+      jcy: "й",
+      Jfr: "𝔍",
+      jfr: "𝔧",
+      jmath: "ȷ",
+      Jopf: "𝕁",
+      jopf: "𝕛",
+      Jscr: "𝒥",
+      jscr: "𝒿",
+      Jsercy: "Ј",
+      jsercy: "ј",
+      Jukcy: "Є",
+      jukcy: "є",
+      Kappa: "Κ",
+      kappa: "κ",
+      kappav: "ϰ",
+      Kcedil: "Ķ",
+      kcedil: "ķ",
+      Kcy: "К",
+      kcy: "к",
+      Kfr: "𝔎",
+      kfr: "𝔨",
+      kgreen: "ĸ",
+      KHcy: "Х",
+      khcy: "х",
+      KJcy: "Ќ",
+      kjcy: "ќ",
+      Kopf: "𝕂",
+      kopf: "𝕜",
+      Kscr: "𝒦",
+      kscr: "𝓀",
+      lAarr: "⇚",
+      Lacute: "Ĺ",
+      lacute: "ĺ",
+      laemptyv: "⦴",
+      lagran: "ℒ",
+      Lambda: "Λ",
+      lambda: "λ",
+      Lang: "⟪",
+      lang: "⟨",
+      langd: "⦑",
+      langle: "⟨",
+      lap: "⪅",
+      Laplacetrf: "ℒ",
+      laquo: "«",
+      Larr: "↞",
+      lArr: "⇐",
+      larr: "←",
+      larrb: "⇤",
+      larrbfs: "⤟",
+      larrfs: "⤝",
+      larrhk: "↩",
+      larrlp: "↫",
+      larrpl: "⤹",
+      larrsim: "⥳",
+      larrtl: "↢",
+      lat: "⪫",
+      lAtail: "⤛",
+      latail: "⤙",
+      late: "⪭",
+      lates: "⪭︀",
+      lBarr: "⤎",
+      lbarr: "⤌",
+      lbbrk: "❲",
+      lbrace: "{",
+      lbrack: "[",
+      lbrke: "⦋",
+      lbrksld: "⦏",
+      lbrkslu: "⦍",
+      Lcaron: "Ľ",
+      lcaron: "ľ",
+      Lcedil: "Ļ",
+      lcedil: "ļ",
+      lceil: "⌈",
+      lcub: "{",
+      Lcy: "Л",
+      lcy: "л",
+      ldca: "⤶",
+      ldquo: "“",
+      ldquor: "„",
+      ldrdhar: "⥧",
+      ldrushar: "⥋",
+      ldsh: "↲",
+      lE: "≦",
+      le: "≤",
+      LeftAngleBracket: "⟨",
+      LeftArrow: "←",
+      Leftarrow: "⇐",
+      leftarrow: "←",
+      LeftArrowBar: "⇤",
+      LeftArrowRightArrow: "⇆",
+      leftarrowtail: "↢",
+      LeftCeiling: "⌈",
+      LeftDoubleBracket: "⟦",
+      LeftDownTeeVector: "⥡",
+      LeftDownVector: "⇃",
+      LeftDownVectorBar: "⥙",
+      LeftFloor: "⌊",
+      leftharpoondown: "↽",
+      leftharpoonup: "↼",
+      leftleftarrows: "⇇",
+      LeftRightArrow: "↔",
+      Leftrightarrow: "⇔",
+      leftrightarrow: "↔",
+      leftrightarrows: "⇆",
+      leftrightharpoons: "⇋",
+      leftrightsquigarrow: "↭",
+      LeftRightVector: "⥎",
+      LeftTee: "⊣",
+      LeftTeeArrow: "↤",
+      LeftTeeVector: "⥚",
+      leftthreetimes: "⋋",
+      LeftTriangle: "⊲",
+      LeftTriangleBar: "⧏",
+      LeftTriangleEqual: "⊴",
+      LeftUpDownVector: "⥑",
+      LeftUpTeeVector: "⥠",
+      LeftUpVector: "↿",
+      LeftUpVectorBar: "⥘",
+      LeftVector: "↼",
+      LeftVectorBar: "⥒",
+      lEg: "⪋",
+      leg: "⋚",
+      leq: "≤",
+      leqq: "≦",
+      leqslant: "⩽",
+      les: "⩽",
+      lescc: "⪨",
+      lesdot: "⩿",
+      lesdoto: "⪁",
+      lesdotor: "⪃",
+      lesg: "⋚︀",
+      lesges: "⪓",
+      lessapprox: "⪅",
+      lessdot: "⋖",
+      lesseqgtr: "⋚",
+      lesseqqgtr: "⪋",
+      LessEqualGreater: "⋚",
+      LessFullEqual: "≦",
+      LessGreater: "≶",
+      lessgtr: "≶",
+      LessLess: "⪡",
+      lesssim: "≲",
+      LessSlantEqual: "⩽",
+      LessTilde: "≲",
+      lfisht: "⥼",
+      lfloor: "⌊",
+      Lfr: "𝔏",
+      lfr: "𝔩",
+      lg: "≶",
+      lgE: "⪑",
+      lHar: "⥢",
+      lhard: "↽",
+      lharu: "↼",
+      lharul: "⥪",
+      lhblk: "▄",
+      LJcy: "Љ",
+      ljcy: "љ",
+      Ll: "⋘",
+      ll: "≪",
+      llarr: "⇇",
+      llcorner: "⌞",
+      Lleftarrow: "⇚",
+      llhard: "⥫",
+      lltri: "◺",
+      Lmidot: "Ŀ",
+      lmidot: "ŀ",
+      lmoust: "⎰",
+      lmoustache: "⎰",
+      lnap: "⪉",
+      lnapprox: "⪉",
+      lnE: "≨",
+      lne: "⪇",
+      lneq: "⪇",
+      lneqq: "≨",
+      lnsim: "⋦",
+      loang: "⟬",
+      loarr: "⇽",
+      lobrk: "⟦",
+      LongLeftArrow: "⟵",
+      Longleftarrow: "⟸",
+      longleftarrow: "⟵",
+      LongLeftRightArrow: "⟷",
+      Longleftrightarrow: "⟺",
+      longleftrightarrow: "⟷",
+      longmapsto: "⟼",
+      LongRightArrow: "⟶",
+      Longrightarrow: "⟹",
+      longrightarrow: "⟶",
+      looparrowleft: "↫",
+      looparrowright: "↬",
+      lopar: "⦅",
+      Lopf: "𝕃",
+      lopf: "𝕝",
+      loplus: "⨭",
+      lotimes: "⨴",
+      lowast: "∗",
+      lowbar: "_",
+      LowerLeftArrow: "↙",
+      LowerRightArrow: "↘",
+      loz: "◊",
+      lozenge: "◊",
+      lozf: "⧫",
+      lpar: "(",
+      lparlt: "⦓",
+      lrarr: "⇆",
+      lrcorner: "⌟",
+      lrhar: "⇋",
+      lrhard: "⥭",
+      lrm: "‎",
+      lrtri: "⊿",
+      lsaquo: "‹",
+      Lscr: "ℒ",
+      lscr: "𝓁",
+      Lsh: "↰",
+      lsh: "↰",
+      lsim: "≲",
+      lsime: "⪍",
+      lsimg: "⪏",
+      lsqb: "[",
+      lsquo: "‘",
+      lsquor: "‚",
+      Lstrok: "Ł",
+      lstrok: "ł",
+      Lt: "≪",
+      LT: "<",
+      lt: "<",
+      ltcc: "⪦",
+      ltcir: "⩹",
+      ltdot: "⋖",
+      lthree: "⋋",
+      ltimes: "⋉",
+      ltlarr: "⥶",
+      ltquest: "⩻",
+      ltri: "◃",
+      ltrie: "⊴",
+      ltrif: "◂",
+      ltrPar: "⦖",
+      lurdshar: "⥊",
+      luruhar: "⥦",
+      lvertneqq: "≨︀",
+      lvnE: "≨︀",
+      macr: "¯",
+      male: "♂",
+      malt: "✠",
+      maltese: "✠",
+      Map: "⤅",
+      map: "↦",
+      mapsto: "↦",
+      mapstodown: "↧",
+      mapstoleft: "↤",
+      mapstoup: "↥",
+      marker: "▮",
+      mcomma: "⨩",
+      Mcy: "М",
+      mcy: "м",
+      mdash: "—",
+      mDDot: "∺",
+      measuredangle: "∡",
+      MediumSpace: " ",
+      Mellintrf: "ℳ",
+      Mfr: "𝔐",
+      mfr: "𝔪",
+      mho: "℧",
+      micro: "µ",
+      mid: "∣",
+      midast: "*",
+      midcir: "⫰",
+      middot: "·",
+      minus: "−",
+      minusb: "⊟",
+      minusd: "∸",
+      minusdu: "⨪",
+      MinusPlus: "∓",
+      mlcp: "⫛",
+      mldr: "…",
+      mnplus: "∓",
+      models: "⊧",
+      Mopf: "𝕄",
+      mopf: "𝕞",
+      mp: "∓",
+      Mscr: "ℳ",
+      mscr: "𝓂",
+      mstpos: "∾",
+      Mu: "Μ",
+      mu: "μ",
+      multimap: "⊸",
+      mumap: "⊸",
+      nabla: "∇",
+      Nacute: "Ń",
+      nacute: "ń",
+      nang: "∠⃒",
+      nap: "≉",
+      napE: "⩰̸",
+      napid: "≋̸",
+      napos: "ʼn",
+      napprox: "≉",
+      natur: "♮",
+      natural: "♮",
+      naturals: "ℕ",
+      nbsp: " ",
+      nbump: "≎̸",
+      nbumpe: "≏̸",
+      ncap: "⩃",
+      Ncaron: "Ň",
+      ncaron: "ň",
+      Ncedil: "Ņ",
+      ncedil: "ņ",
+      ncong: "≇",
+      ncongdot: "⩭̸",
+      ncup: "⩂",
+      Ncy: "Н",
+      ncy: "н",
+      ndash: "–",
+      ne: "≠",
+      nearhk: "⤤",
+      neArr: "⇗",
+      nearr: "↗",
+      nearrow: "↗",
+      nedot: "≐̸",
+      NegativeMediumSpace: "​",
+      NegativeThickSpace: "​",
+      NegativeThinSpace: "​",
+      NegativeVeryThinSpace: "​",
+      nequiv: "≢",
+      nesear: "⤨",
+      nesim: "≂̸",
+      NestedGreaterGreater: "≫",
+      NestedLessLess: "≪",
+      NewLine: `
+`,
+      nexist: "∄",
+      nexists: "∄",
+      Nfr: "𝔑",
+      nfr: "𝔫",
+      ngE: "≧̸",
+      nge: "≱",
+      ngeq: "≱",
+      ngeqq: "≧̸",
+      ngeqslant: "⩾̸",
+      nges: "⩾̸",
+      nGg: "⋙̸",
+      ngsim: "≵",
+      nGt: "≫⃒",
+      ngt: "≯",
+      ngtr: "≯",
+      nGtv: "≫̸",
+      nhArr: "⇎",
+      nharr: "↮",
+      nhpar: "⫲",
+      ni: "∋",
+      nis: "⋼",
+      nisd: "⋺",
+      niv: "∋",
+      NJcy: "Њ",
+      njcy: "њ",
+      nlArr: "⇍",
+      nlarr: "↚",
+      nldr: "‥",
+      nlE: "≦̸",
+      nle: "≰",
+      nLeftarrow: "⇍",
+      nleftarrow: "↚",
+      nLeftrightarrow: "⇎",
+      nleftrightarrow: "↮",
+      nleq: "≰",
+      nleqq: "≦̸",
+      nleqslant: "⩽̸",
+      nles: "⩽̸",
+      nless: "≮",
+      nLl: "⋘̸",
+      nlsim: "≴",
+      nLt: "≪⃒",
+      nlt: "≮",
+      nltri: "⋪",
+      nltrie: "⋬",
+      nLtv: "≪̸",
+      nmid: "∤",
+      NoBreak: "⁠",
+      NonBreakingSpace: " ",
+      Nopf: "ℕ",
+      nopf: "𝕟",
+      Not: "⫬",
+      not: "¬",
+      NotCongruent: "≢",
+      NotCupCap: "≭",
+      NotDoubleVerticalBar: "∦",
+      NotElement: "∉",
+      NotEqual: "≠",
+      NotEqualTilde: "≂̸",
+      NotExists: "∄",
+      NotGreater: "≯",
+      NotGreaterEqual: "≱",
+      NotGreaterFullEqual: "≧̸",
+      NotGreaterGreater: "≫̸",
+      NotGreaterLess: "≹",
+      NotGreaterSlantEqual: "⩾̸",
+      NotGreaterTilde: "≵",
+      NotHumpDownHump: "≎̸",
+      NotHumpEqual: "≏̸",
+      notin: "∉",
+      notindot: "⋵̸",
+      notinE: "⋹̸",
+      notinva: "∉",
+      notinvb: "⋷",
+      notinvc: "⋶",
+      NotLeftTriangle: "⋪",
+      NotLeftTriangleBar: "⧏̸",
+      NotLeftTriangleEqual: "⋬",
+      NotLess: "≮",
+      NotLessEqual: "≰",
+      NotLessGreater: "≸",
+      NotLessLess: "≪̸",
+      NotLessSlantEqual: "⩽̸",
+      NotLessTilde: "≴",
+      NotNestedGreaterGreater: "⪢̸",
+      NotNestedLessLess: "⪡̸",
+      notni: "∌",
+      notniva: "∌",
+      notnivb: "⋾",
+      notnivc: "⋽",
+      NotPrecedes: "⊀",
+      NotPrecedesEqual: "⪯̸",
+      NotPrecedesSlantEqual: "⋠",
+      NotReverseElement: "∌",
+      NotRightTriangle: "⋫",
+      NotRightTriangleBar: "⧐̸",
+      NotRightTriangleEqual: "⋭",
+      NotSquareSubset: "⊏̸",
+      NotSquareSubsetEqual: "⋢",
+      NotSquareSuperset: "⊐̸",
+      NotSquareSupersetEqual: "⋣",
+      NotSubset: "⊂⃒",
+      NotSubsetEqual: "⊈",
+      NotSucceeds: "⊁",
+      NotSucceedsEqual: "⪰̸",
+      NotSucceedsSlantEqual: "⋡",
+      NotSucceedsTilde: "≿̸",
+      NotSuperset: "⊃⃒",
+      NotSupersetEqual: "⊉",
+      NotTilde: "≁",
+      NotTildeEqual: "≄",
+      NotTildeFullEqual: "≇",
+      NotTildeTilde: "≉",
+      NotVerticalBar: "∤",
+      npar: "∦",
+      nparallel: "∦",
+      nparsl: "⫽⃥",
+      npart: "∂̸",
+      npolint: "⨔",
+      npr: "⊀",
+      nprcue: "⋠",
+      npre: "⪯̸",
+      nprec: "⊀",
+      npreceq: "⪯̸",
+      nrArr: "⇏",
+      nrarr: "↛",
+      nrarrc: "⤳̸",
+      nrarrw: "↝̸",
+      nRightarrow: "⇏",
+      nrightarrow: "↛",
+      nrtri: "⋫",
+      nrtrie: "⋭",
+      nsc: "⊁",
+      nsccue: "⋡",
+      nsce: "⪰̸",
+      Nscr: "𝒩",
+      nscr: "𝓃",
+      nshortmid: "∤",
+      nshortparallel: "∦",
+      nsim: "≁",
+      nsime: "≄",
+      nsimeq: "≄",
+      nsmid: "∤",
+      nspar: "∦",
+      nsqsube: "⋢",
+      nsqsupe: "⋣",
+      nsub: "⊄",
+      nsubE: "⫅̸",
+      nsube: "⊈",
+      nsubset: "⊂⃒",
+      nsubseteq: "⊈",
+      nsubseteqq: "⫅̸",
+      nsucc: "⊁",
+      nsucceq: "⪰̸",
+      nsup: "⊅",
+      nsupE: "⫆̸",
+      nsupe: "⊉",
+      nsupset: "⊃⃒",
+      nsupseteq: "⊉",
+      nsupseteqq: "⫆̸",
+      ntgl: "≹",
+      Ntilde: "Ñ",
+      ntilde: "ñ",
+      ntlg: "≸",
+      ntriangleleft: "⋪",
+      ntrianglelefteq: "⋬",
+      ntriangleright: "⋫",
+      ntrianglerighteq: "⋭",
+      Nu: "Ν",
+      nu: "ν",
+      num: "#",
+      numero: "№",
+      numsp: " ",
+      nvap: "≍⃒",
+      nVDash: "⊯",
+      nVdash: "⊮",
+      nvDash: "⊭",
+      nvdash: "⊬",
+      nvge: "≥⃒",
+      nvgt: ">⃒",
+      nvHarr: "⤄",
+      nvinfin: "⧞",
+      nvlArr: "⤂",
+      nvle: "≤⃒",
+      nvlt: "<⃒",
+      nvltrie: "⊴⃒",
+      nvrArr: "⤃",
+      nvrtrie: "⊵⃒",
+      nvsim: "∼⃒",
+      nwarhk: "⤣",
+      nwArr: "⇖",
+      nwarr: "↖",
+      nwarrow: "↖",
+      nwnear: "⤧",
+      Oacute: "Ó",
+      oacute: "ó",
+      oast: "⊛",
+      ocir: "⊚",
+      Ocirc: "Ô",
+      ocirc: "ô",
+      Ocy: "О",
+      ocy: "о",
+      odash: "⊝",
+      Odblac: "Ő",
+      odblac: "ő",
+      odiv: "⨸",
+      odot: "⊙",
+      odsold: "⦼",
+      OElig: "Œ",
+      oelig: "œ",
+      ofcir: "⦿",
+      Ofr: "𝔒",
+      ofr: "𝔬",
+      ogon: "˛",
+      Ograve: "Ò",
+      ograve: "ò",
+      ogt: "⧁",
+      ohbar: "⦵",
+      ohm: "Ω",
+      oint: "∮",
+      olarr: "↺",
+      olcir: "⦾",
+      olcross: "⦻",
+      oline: "‾",
+      olt: "⧀",
+      Omacr: "Ō",
+      omacr: "ō",
+      Omega: "Ω",
+      omega: "ω",
+      Omicron: "Ο",
+      omicron: "ο",
+      omid: "⦶",
+      ominus: "⊖",
+      Oopf: "𝕆",
+      oopf: "𝕠",
+      opar: "⦷",
+      OpenCurlyDoubleQuote: "“",
+      OpenCurlyQuote: "‘",
+      operp: "⦹",
+      oplus: "⊕",
+      Or: "⩔",
+      or: "∨",
+      orarr: "↻",
+      ord: "⩝",
+      order: "ℴ",
+      orderof: "ℴ",
+      ordf: "ª",
+      ordm: "º",
+      origof: "⊶",
+      oror: "⩖",
+      orslope: "⩗",
+      orv: "⩛",
+      oS: "Ⓢ",
+      Oscr: "𝒪",
+      oscr: "ℴ",
+      Oslash: "Ø",
+      oslash: "ø",
+      osol: "⊘",
+      Otilde: "Õ",
+      otilde: "õ",
+      Otimes: "⨷",
+      otimes: "⊗",
+      otimesas: "⨶",
+      Ouml: "Ö",
+      ouml: "ö",
+      ovbar: "⌽",
+      OverBar: "‾",
+      OverBrace: "⏞",
+      OverBracket: "⎴",
+      OverParenthesis: "⏜",
+      par: "∥",
+      para: "¶",
+      parallel: "∥",
+      parsim: "⫳",
+      parsl: "⫽",
+      part: "∂",
+      PartialD: "∂",
+      Pcy: "П",
+      pcy: "п",
+      percnt: "%",
+      period: ".",
+      permil: "‰",
+      perp: "⊥",
+      pertenk: "‱",
+      Pfr: "𝔓",
+      pfr: "𝔭",
+      Phi: "Φ",
+      phi: "φ",
+      phiv: "ϕ",
+      phmmat: "ℳ",
+      phone: "☎",
+      Pi: "Π",
+      pi: "π",
+      pitchfork: "⋔",
+      piv: "ϖ",
+      planck: "ℏ",
+      planckh: "ℎ",
+      plankv: "ℏ",
+      plus: "+",
+      plusacir: "⨣",
+      plusb: "⊞",
+      pluscir: "⨢",
+      plusdo: "∔",
+      plusdu: "⨥",
+      pluse: "⩲",
+      PlusMinus: "±",
+      plusmn: "±",
+      plussim: "⨦",
+      plustwo: "⨧",
+      pm: "±",
+      Poincareplane: "ℌ",
+      pointint: "⨕",
+      Popf: "ℙ",
+      popf: "𝕡",
+      pound: "£",
+      Pr: "⪻",
+      pr: "≺",
+      prap: "⪷",
+      prcue: "≼",
+      prE: "⪳",
+      pre: "⪯",
+      prec: "≺",
+      precapprox: "⪷",
+      preccurlyeq: "≼",
+      Precedes: "≺",
+      PrecedesEqual: "⪯",
+      PrecedesSlantEqual: "≼",
+      PrecedesTilde: "≾",
+      preceq: "⪯",
+      precnapprox: "⪹",
+      precneqq: "⪵",
+      precnsim: "⋨",
+      precsim: "≾",
+      Prime: "″",
+      prime: "′",
+      primes: "ℙ",
+      prnap: "⪹",
+      prnE: "⪵",
+      prnsim: "⋨",
+      prod: "∏",
+      Product: "∏",
+      profalar: "⌮",
+      profline: "⌒",
+      profsurf: "⌓",
+      prop: "∝",
+      Proportion: "∷",
+      Proportional: "∝",
+      propto: "∝",
+      prsim: "≾",
+      prurel: "⊰",
+      Pscr: "𝒫",
+      pscr: "𝓅",
+      Psi: "Ψ",
+      psi: "ψ",
+      puncsp: " ",
+      Qfr: "𝔔",
+      qfr: "𝔮",
+      qint: "⨌",
+      Qopf: "ℚ",
+      qopf: "𝕢",
+      qprime: "⁗",
+      Qscr: "𝒬",
+      qscr: "𝓆",
+      quaternions: "ℍ",
+      quatint: "⨖",
+      quest: "?",
+      questeq: "≟",
+      QUOT: '"',
+      quot: '"',
+      rAarr: "⇛",
+      race: "∽̱",
+      Racute: "Ŕ",
+      racute: "ŕ",
+      radic: "√",
+      raemptyv: "⦳",
+      Rang: "⟫",
+      rang: "⟩",
+      rangd: "⦒",
+      range: "⦥",
+      rangle: "⟩",
+      raquo: "»",
+      Rarr: "↠",
+      rArr: "⇒",
+      rarr: "→",
+      rarrap: "⥵",
+      rarrb: "⇥",
+      rarrbfs: "⤠",
+      rarrc: "⤳",
+      rarrfs: "⤞",
+      rarrhk: "↪",
+      rarrlp: "↬",
+      rarrpl: "⥅",
+      rarrsim: "⥴",
+      Rarrtl: "⤖",
+      rarrtl: "↣",
+      rarrw: "↝",
+      rAtail: "⤜",
+      ratail: "⤚",
+      ratio: "∶",
+      rationals: "ℚ",
+      RBarr: "⤐",
+      rBarr: "⤏",
+      rbarr: "⤍",
+      rbbrk: "❳",
+      rbrace: "}",
+      rbrack: "]",
+      rbrke: "⦌",
+      rbrksld: "⦎",
+      rbrkslu: "⦐",
+      Rcaron: "Ř",
+      rcaron: "ř",
+      Rcedil: "Ŗ",
+      rcedil: "ŗ",
+      rceil: "⌉",
+      rcub: "}",
+      Rcy: "Р",
+      rcy: "р",
+      rdca: "⤷",
+      rdldhar: "⥩",
+      rdquo: "”",
+      rdquor: "”",
+      rdsh: "↳",
+      Re: "ℜ",
+      real: "ℜ",
+      realine: "ℛ",
+      realpart: "ℜ",
+      reals: "ℝ",
+      rect: "▭",
+      REG: "®",
+      reg: "®",
+      ReverseElement: "∋",
+      ReverseEquilibrium: "⇋",
+      ReverseUpEquilibrium: "⥯",
+      rfisht: "⥽",
+      rfloor: "⌋",
+      Rfr: "ℜ",
+      rfr: "𝔯",
+      rHar: "⥤",
+      rhard: "⇁",
+      rharu: "⇀",
+      rharul: "⥬",
+      Rho: "Ρ",
+      rho: "ρ",
+      rhov: "ϱ",
+      RightAngleBracket: "⟩",
+      RightArrow: "→",
+      Rightarrow: "⇒",
+      rightarrow: "→",
+      RightArrowBar: "⇥",
+      RightArrowLeftArrow: "⇄",
+      rightarrowtail: "↣",
+      RightCeiling: "⌉",
+      RightDoubleBracket: "⟧",
+      RightDownTeeVector: "⥝",
+      RightDownVector: "⇂",
+      RightDownVectorBar: "⥕",
+      RightFloor: "⌋",
+      rightharpoondown: "⇁",
+      rightharpoonup: "⇀",
+      rightleftarrows: "⇄",
+      rightleftharpoons: "⇌",
+      rightrightarrows: "⇉",
+      rightsquigarrow: "↝",
+      RightTee: "⊢",
+      RightTeeArrow: "↦",
+      RightTeeVector: "⥛",
+      rightthreetimes: "⋌",
+      RightTriangle: "⊳",
+      RightTriangleBar: "⧐",
+      RightTriangleEqual: "⊵",
+      RightUpDownVector: "⥏",
+      RightUpTeeVector: "⥜",
+      RightUpVector: "↾",
+      RightUpVectorBar: "⥔",
+      RightVector: "⇀",
+      RightVectorBar: "⥓",
+      ring: "˚",
+      risingdotseq: "≓",
+      rlarr: "⇄",
+      rlhar: "⇌",
+      rlm: "‏",
+      rmoust: "⎱",
+      rmoustache: "⎱",
+      rnmid: "⫮",
+      roang: "⟭",
+      roarr: "⇾",
+      robrk: "⟧",
+      ropar: "⦆",
+      Ropf: "ℝ",
+      ropf: "𝕣",
+      roplus: "⨮",
+      rotimes: "⨵",
+      RoundImplies: "⥰",
+      rpar: ")",
+      rpargt: "⦔",
+      rppolint: "⨒",
+      rrarr: "⇉",
+      Rrightarrow: "⇛",
+      rsaquo: "›",
+      Rscr: "ℛ",
+      rscr: "𝓇",
+      Rsh: "↱",
+      rsh: "↱",
+      rsqb: "]",
+      rsquo: "’",
+      rsquor: "’",
+      rthree: "⋌",
+      rtimes: "⋊",
+      rtri: "▹",
+      rtrie: "⊵",
+      rtrif: "▸",
+      rtriltri: "⧎",
+      RuleDelayed: "⧴",
+      ruluhar: "⥨",
+      rx: "℞",
+      Sacute: "Ś",
+      sacute: "ś",
+      sbquo: "‚",
+      Sc: "⪼",
+      sc: "≻",
+      scap: "⪸",
+      Scaron: "Š",
+      scaron: "š",
+      sccue: "≽",
+      scE: "⪴",
+      sce: "⪰",
+      Scedil: "Ş",
+      scedil: "ş",
+      Scirc: "Ŝ",
+      scirc: "ŝ",
+      scnap: "⪺",
+      scnE: "⪶",
+      scnsim: "⋩",
+      scpolint: "⨓",
+      scsim: "≿",
+      Scy: "С",
+      scy: "с",
+      sdot: "⋅",
+      sdotb: "⊡",
+      sdote: "⩦",
+      searhk: "⤥",
+      seArr: "⇘",
+      searr: "↘",
+      searrow: "↘",
+      sect: "§",
+      semi: ";",
+      seswar: "⤩",
+      setminus: "∖",
+      setmn: "∖",
+      sext: "✶",
+      Sfr: "𝔖",
+      sfr: "𝔰",
+      sfrown: "⌢",
+      sharp: "♯",
+      SHCHcy: "Щ",
+      shchcy: "щ",
+      SHcy: "Ш",
+      shcy: "ш",
+      ShortDownArrow: "↓",
+      ShortLeftArrow: "←",
+      shortmid: "∣",
+      shortparallel: "∥",
+      ShortRightArrow: "→",
+      ShortUpArrow: "↑",
+      shy: "­",
+      Sigma: "Σ",
+      sigma: "σ",
+      sigmaf: "ς",
+      sigmav: "ς",
+      sim: "∼",
+      simdot: "⩪",
+      sime: "≃",
+      simeq: "≃",
+      simg: "⪞",
+      simgE: "⪠",
+      siml: "⪝",
+      simlE: "⪟",
+      simne: "≆",
+      simplus: "⨤",
+      simrarr: "⥲",
+      slarr: "←",
+      SmallCircle: "∘",
+      smallsetminus: "∖",
+      smashp: "⨳",
+      smeparsl: "⧤",
+      smid: "∣",
+      smile: "⌣",
+      smt: "⪪",
+      smte: "⪬",
+      smtes: "⪬︀",
+      SOFTcy: "Ь",
+      softcy: "ь",
+      sol: "/",
+      solb: "⧄",
+      solbar: "⌿",
+      Sopf: "𝕊",
+      sopf: "𝕤",
+      spades: "♠",
+      spadesuit: "♠",
+      spar: "∥",
+      sqcap: "⊓",
+      sqcaps: "⊓︀",
+      sqcup: "⊔",
+      sqcups: "⊔︀",
+      Sqrt: "√",
+      sqsub: "⊏",
+      sqsube: "⊑",
+      sqsubset: "⊏",
+      sqsubseteq: "⊑",
+      sqsup: "⊐",
+      sqsupe: "⊒",
+      sqsupset: "⊐",
+      sqsupseteq: "⊒",
+      squ: "□",
+      Square: "□",
+      square: "□",
+      SquareIntersection: "⊓",
+      SquareSubset: "⊏",
+      SquareSubsetEqual: "⊑",
+      SquareSuperset: "⊐",
+      SquareSupersetEqual: "⊒",
+      SquareUnion: "⊔",
+      squarf: "▪",
+      squf: "▪",
+      srarr: "→",
+      Sscr: "𝒮",
+      sscr: "𝓈",
+      ssetmn: "∖",
+      ssmile: "⌣",
+      sstarf: "⋆",
+      Star: "⋆",
+      star: "☆",
+      starf: "★",
+      straightepsilon: "ϵ",
+      straightphi: "ϕ",
+      strns: "¯",
+      Sub: "⋐",
+      sub: "⊂",
+      subdot: "⪽",
+      subE: "⫅",
+      sube: "⊆",
+      subedot: "⫃",
+      submult: "⫁",
+      subnE: "⫋",
+      subne: "⊊",
+      subplus: "⪿",
+      subrarr: "⥹",
+      Subset: "⋐",
+      subset: "⊂",
+      subseteq: "⊆",
+      subseteqq: "⫅",
+      SubsetEqual: "⊆",
+      subsetneq: "⊊",
+      subsetneqq: "⫋",
+      subsim: "⫇",
+      subsub: "⫕",
+      subsup: "⫓",
+      succ: "≻",
+      succapprox: "⪸",
+      succcurlyeq: "≽",
+      Succeeds: "≻",
+      SucceedsEqual: "⪰",
+      SucceedsSlantEqual: "≽",
+      SucceedsTilde: "≿",
+      succeq: "⪰",
+      succnapprox: "⪺",
+      succneqq: "⪶",
+      succnsim: "⋩",
+      succsim: "≿",
+      SuchThat: "∋",
+      Sum: "∑",
+      sum: "∑",
+      sung: "♪",
+      Sup: "⋑",
+      sup: "⊃",
+      sup1: "¹",
+      sup2: "²",
+      sup3: "³",
+      supdot: "⪾",
+      supdsub: "⫘",
+      supE: "⫆",
+      supe: "⊇",
+      supedot: "⫄",
+      Superset: "⊃",
+      SupersetEqual: "⊇",
+      suphsol: "⟉",
+      suphsub: "⫗",
+      suplarr: "⥻",
+      supmult: "⫂",
+      supnE: "⫌",
+      supne: "⊋",
+      supplus: "⫀",
+      Supset: "⋑",
+      supset: "⊃",
+      supseteq: "⊇",
+      supseteqq: "⫆",
+      supsetneq: "⊋",
+      supsetneqq: "⫌",
+      supsim: "⫈",
+      supsub: "⫔",
+      supsup: "⫖",
+      swarhk: "⤦",
+      swArr: "⇙",
+      swarr: "↙",
+      swarrow: "↙",
+      swnwar: "⤪",
+      szlig: "ß",
+      Tab: "	",
+      target: "⌖",
+      Tau: "Τ",
+      tau: "τ",
+      tbrk: "⎴",
+      Tcaron: "Ť",
+      tcaron: "ť",
+      Tcedil: "Ţ",
+      tcedil: "ţ",
+      Tcy: "Т",
+      tcy: "т",
+      tdot: "⃛",
+      telrec: "⌕",
+      Tfr: "𝔗",
+      tfr: "𝔱",
+      there4: "∴",
+      Therefore: "∴",
+      therefore: "∴",
+      Theta: "Θ",
+      theta: "θ",
+      thetasym: "ϑ",
+      thetav: "ϑ",
+      thickapprox: "≈",
+      thicksim: "∼",
+      ThickSpace: "  ",
+      thinsp: " ",
+      ThinSpace: " ",
+      thkap: "≈",
+      thksim: "∼",
+      THORN: "Þ",
+      thorn: "þ",
+      Tilde: "∼",
+      tilde: "˜",
+      TildeEqual: "≃",
+      TildeFullEqual: "≅",
+      TildeTilde: "≈",
+      times: "×",
+      timesb: "⊠",
+      timesbar: "⨱",
+      timesd: "⨰",
+      tint: "∭",
+      toea: "⤨",
+      top: "⊤",
+      topbot: "⌶",
+      topcir: "⫱",
+      Topf: "𝕋",
+      topf: "𝕥",
+      topfork: "⫚",
+      tosa: "⤩",
+      tprime: "‴",
+      TRADE: "™",
+      trade: "™",
+      triangle: "▵",
+      triangledown: "▿",
+      triangleleft: "◃",
+      trianglelefteq: "⊴",
+      triangleq: "≜",
+      triangleright: "▹",
+      trianglerighteq: "⊵",
+      tridot: "◬",
+      trie: "≜",
+      triminus: "⨺",
+      TripleDot: "⃛",
+      triplus: "⨹",
+      trisb: "⧍",
+      tritime: "⨻",
+      trpezium: "⏢",
+      Tscr: "𝒯",
+      tscr: "𝓉",
+      TScy: "Ц",
+      tscy: "ц",
+      TSHcy: "Ћ",
+      tshcy: "ћ",
+      Tstrok: "Ŧ",
+      tstrok: "ŧ",
+      twixt: "≬",
+      twoheadleftarrow: "↞",
+      twoheadrightarrow: "↠",
+      Uacute: "Ú",
+      uacute: "ú",
+      Uarr: "↟",
+      uArr: "⇑",
+      uarr: "↑",
+      Uarrocir: "⥉",
+      Ubrcy: "Ў",
+      ubrcy: "ў",
+      Ubreve: "Ŭ",
+      ubreve: "ŭ",
+      Ucirc: "Û",
+      ucirc: "û",
+      Ucy: "У",
+      ucy: "у",
+      udarr: "⇅",
+      Udblac: "Ű",
+      udblac: "ű",
+      udhar: "⥮",
+      ufisht: "⥾",
+      Ufr: "𝔘",
+      ufr: "𝔲",
+      Ugrave: "Ù",
+      ugrave: "ù",
+      uHar: "⥣",
+      uharl: "↿",
+      uharr: "↾",
+      uhblk: "▀",
+      ulcorn: "⌜",
+      ulcorner: "⌜",
+      ulcrop: "⌏",
+      ultri: "◸",
+      Umacr: "Ū",
+      umacr: "ū",
+      uml: "¨",
+      UnderBar: "_",
+      UnderBrace: "⏟",
+      UnderBracket: "⎵",
+      UnderParenthesis: "⏝",
+      Union: "⋃",
+      UnionPlus: "⊎",
+      Uogon: "Ų",
+      uogon: "ų",
+      Uopf: "𝕌",
+      uopf: "𝕦",
+      UpArrow: "↑",
+      Uparrow: "⇑",
+      uparrow: "↑",
+      UpArrowBar: "⤒",
+      UpArrowDownArrow: "⇅",
+      UpDownArrow: "↕",
+      Updownarrow: "⇕",
+      updownarrow: "↕",
+      UpEquilibrium: "⥮",
+      upharpoonleft: "↿",
+      upharpoonright: "↾",
+      uplus: "⊎",
+      UpperLeftArrow: "↖",
+      UpperRightArrow: "↗",
+      Upsi: "ϒ",
+      upsi: "υ",
+      upsih: "ϒ",
+      Upsilon: "Υ",
+      upsilon: "υ",
+      UpTee: "⊥",
+      UpTeeArrow: "↥",
+      upuparrows: "⇈",
+      urcorn: "⌝",
+      urcorner: "⌝",
+      urcrop: "⌎",
+      Uring: "Ů",
+      uring: "ů",
+      urtri: "◹",
+      Uscr: "𝒰",
+      uscr: "𝓊",
+      utdot: "⋰",
+      Utilde: "Ũ",
+      utilde: "ũ",
+      utri: "▵",
+      utrif: "▴",
+      uuarr: "⇈",
+      Uuml: "Ü",
+      uuml: "ü",
+      uwangle: "⦧",
+      vangrt: "⦜",
+      varepsilon: "ϵ",
+      varkappa: "ϰ",
+      varnothing: "∅",
+      varphi: "ϕ",
+      varpi: "ϖ",
+      varpropto: "∝",
+      vArr: "⇕",
+      varr: "↕",
+      varrho: "ϱ",
+      varsigma: "ς",
+      varsubsetneq: "⊊︀",
+      varsubsetneqq: "⫋︀",
+      varsupsetneq: "⊋︀",
+      varsupsetneqq: "⫌︀",
+      vartheta: "ϑ",
+      vartriangleleft: "⊲",
+      vartriangleright: "⊳",
+      Vbar: "⫫",
+      vBar: "⫨",
+      vBarv: "⫩",
+      Vcy: "В",
+      vcy: "в",
+      VDash: "⊫",
+      Vdash: "⊩",
+      vDash: "⊨",
+      vdash: "⊢",
+      Vdashl: "⫦",
+      Vee: "⋁",
+      vee: "∨",
+      veebar: "⊻",
+      veeeq: "≚",
+      vellip: "⋮",
+      Verbar: "‖",
+      verbar: "|",
+      Vert: "‖",
+      vert: "|",
+      VerticalBar: "∣",
+      VerticalLine: "|",
+      VerticalSeparator: "❘",
+      VerticalTilde: "≀",
+      VeryThinSpace: " ",
+      Vfr: "𝔙",
+      vfr: "𝔳",
+      vltri: "⊲",
+      vnsub: "⊂⃒",
+      vnsup: "⊃⃒",
+      Vopf: "𝕍",
+      vopf: "𝕧",
+      vprop: "∝",
+      vrtri: "⊳",
+      Vscr: "𝒱",
+      vscr: "𝓋",
+      vsubnE: "⫋︀",
+      vsubne: "⊊︀",
+      vsupnE: "⫌︀",
+      vsupne: "⊋︀",
+      Vvdash: "⊪",
+      vzigzag: "⦚",
+      Wcirc: "Ŵ",
+      wcirc: "ŵ",
+      wedbar: "⩟",
+      Wedge: "⋀",
+      wedge: "∧",
+      wedgeq: "≙",
+      weierp: "℘",
+      Wfr: "𝔚",
+      wfr: "𝔴",
+      Wopf: "𝕎",
+      wopf: "𝕨",
+      wp: "℘",
+      wr: "≀",
+      wreath: "≀",
+      Wscr: "𝒲",
+      wscr: "𝓌",
+      xcap: "⋂",
+      xcirc: "◯",
+      xcup: "⋃",
+      xdtri: "▽",
+      Xfr: "𝔛",
+      xfr: "𝔵",
+      xhArr: "⟺",
+      xharr: "⟷",
+      Xi: "Ξ",
+      xi: "ξ",
+      xlArr: "⟸",
+      xlarr: "⟵",
+      xmap: "⟼",
+      xnis: "⋻",
+      xodot: "⨀",
+      Xopf: "𝕏",
+      xopf: "𝕩",
+      xoplus: "⨁",
+      xotime: "⨂",
+      xrArr: "⟹",
+      xrarr: "⟶",
+      Xscr: "𝒳",
+      xscr: "𝓍",
+      xsqcup: "⨆",
+      xuplus: "⨄",
+      xutri: "△",
+      xvee: "⋁",
+      xwedge: "⋀",
+      Yacute: "Ý",
+      yacute: "ý",
+      YAcy: "Я",
+      yacy: "я",
+      Ycirc: "Ŷ",
+      ycirc: "ŷ",
+      Ycy: "Ы",
+      ycy: "ы",
+      yen: "¥",
+      Yfr: "𝔜",
+      yfr: "𝔶",
+      YIcy: "Ї",
+      yicy: "ї",
+      Yopf: "𝕐",
+      yopf: "𝕪",
+      Yscr: "𝒴",
+      yscr: "𝓎",
+      YUcy: "Ю",
+      yucy: "ю",
+      Yuml: "Ÿ",
+      yuml: "ÿ",
+      Zacute: "Ź",
+      zacute: "ź",
+      Zcaron: "Ž",
+      zcaron: "ž",
+      Zcy: "З",
+      zcy: "з",
+      Zdot: "Ż",
+      zdot: "ż",
+      zeetrf: "ℨ",
+      ZeroWidthSpace: "​",
+      Zeta: "Ζ",
+      zeta: "ζ",
+      Zfr: "ℨ",
+      zfr: "𝔷",
+      ZHcy: "Ж",
+      zhcy: "ж",
+      zigrarr: "⇝",
+      Zopf: "ℤ",
+      zopf: "𝕫",
+      Zscr: "𝒵",
+      zscr: "𝓏",
+      zwj: "‍",
+      zwnj: "‌"
+    }), e.entityMap = e.HTML_ENTITIES;
+  })(nt)), nt;
+}
+var He = {}, kt;
+function Hu() {
+  if (kt) return He;
+  kt = 1;
+  var e = $e().NAMESPACE, r = /[A-Z_a-z\xC0-\xD6\xD8-\xF6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/, t = new RegExp("[\\-\\.0-9" + r.source.slice(1, -1) + "\\u00B7\\u0300-\\u036F\\u203F-\\u2040]"), i = new RegExp("^" + r.source + t.source + "*(?::" + r.source + t.source + "*)?$"), o = 0, s = 1, l = 2, c = 3, p = 4, g = 5, D = 6, d = 7;
+  function E(h, v) {
+    this.message = h, this.locator = v, Error.captureStackTrace && Error.captureStackTrace(this, E);
+  }
+  E.prototype = new Error(), E.prototype.name = E.name;
+  function S() {
+  }
+  S.prototype = {
+    parse: function(h, v, T) {
+      var b = this.domBuilder;
+      b.startDocument(), y(v, v = {}), C(
+        h,
+        v,
+        T,
+        b,
+        this.errorHandler
+      ), b.endDocument();
+    }
+  };
+  function C(h, v, T, b, B) {
+    function U(H) {
+      if (H > 65535) {
+        H -= 65536;
+        var Q = 55296 + (H >> 10), he = 56320 + (H & 1023);
+        return String.fromCharCode(Q, he);
+      } else
+        return String.fromCharCode(H);
+    }
+    function M(H) {
+      var Q = H.slice(1, -1);
+      return Q in T ? T[Q] : Q.charAt(0) === "#" ? U(parseInt(Q.substr(1).replace("x", "0x"))) : (B.error("entity not found:" + H), H);
+    }
+    function z(H) {
+      if (H > W) {
+        var Q = h.substring(W, H).replace(/&#?\w+;/g, M);
+        F && I(W), b.characters(Q, 0, H - W), W = H;
+      }
+    }
+    function I(H, Q) {
+      for (; H >= _ && (Q = $.exec(h)); )
+        O = Q.index, _ = O + Q[0].length, F.lineNumber++;
+      F.columnNumber = H - O + 1;
+    }
+    for (var O = 0, _ = 0, $ = /.*(?:\r\n?|\n)|.*$/g, F = b.locator, ue = [{ currentNSMap: v }], se = {}, W = 0; ; ) {
+      try {
+        var Y = h.indexOf("<", W);
+        if (Y < 0) {
+          if (!h.substr(W).match(/^\s*$/)) {
+            var Fe = b.doc, ve = Fe.createTextNode(h.substr(W));
+            Fe.appendChild(ve), b.currentElement = ve;
+          }
+          return;
+        }
+        switch (Y > W && z(Y), h.charAt(Y + 1)) {
+          case "/":
+            var K = h.indexOf(">", Y + 3), te = h.substring(Y + 2, K).replace(/[ \t\n\r]+$/g, ""), oe = ue.pop();
+            K < 0 ? (te = h.substring(Y + 2).replace(/[\s<].*/, ""), B.error("end tag name: " + te + " is not complete:" + oe.tagName), K = Y + 1 + te.length) : te.match(/\s</) && (te = te.replace(/[\s<].*/, ""), B.error("end tag name: " + te + " maybe not complete"), K = Y + 1 + te.length);
+            var Se = oe.localNSMap, ne = oe.tagName == te, ie = ne || oe.tagName && oe.tagName.toLowerCase() == te.toLowerCase();
+            if (ie) {
+              if (b.endElement(oe.uri, oe.localName, te), Se)
+                for (var Ce in Se)
+                  Object.prototype.hasOwnProperty.call(Se, Ce) && b.endPrefixMapping(Ce);
+              ne || B.fatalError("end tag name: " + te + " is not match the current start tagName:" + oe.tagName);
+            } else
+              ue.push(oe);
+            K++;
+            break;
+          // end elment
+          case "?":
+            F && I(Y), K = j(h, Y, b);
+            break;
+          case "!":
+            F && I(Y), K = q(h, Y, b, B);
+            break;
+          default:
+            F && I(Y);
+            var J = new L(), be = ue[ue.length - 1].currentNSMap, K = N(h, Y, J, be, M, B), Le = J.length;
+            if (!J.closed && w(h, K, J.tagName, se) && (J.closed = !0, T.nbsp || B.warning("unclosed xml attribute")), F && Le) {
+              for (var Oe = m(F, {}), fe = 0; fe < Le; fe++) {
+                var _e = J[fe];
+                I(_e.offset), _e.locator = m(F, {});
+              }
+              b.locator = Oe, P(J, b, be) && ue.push(J), b.locator = F;
+            } else
+              P(J, b, be) && ue.push(J);
+            e.isHTML(J.uri) && !J.closed ? K = R(h, K, J.tagName, M, b) : K++;
+        }
+      } catch (H) {
+        if (H instanceof E)
+          throw H;
+        B.error("element parse error: " + H), K = -1;
+      }
+      K > W ? W = K : z(Math.max(Y, W) + 1);
+    }
+  }
+  function m(h, v) {
+    return v.lineNumber = h.lineNumber, v.columnNumber = h.columnNumber, v;
+  }
+  function N(h, v, T, b, B, U) {
+    function M(F, ue, se) {
+      T.attributeNames.hasOwnProperty(F) && U.fatalError("Attribute " + F + " redefined"), T.addValue(F, ue, se);
+    }
+    for (var z, I, O = ++v, _ = o; ; ) {
+      var $ = h.charAt(O);
+      switch ($) {
+        case "=":
+          if (_ === s)
+            z = h.slice(v, O), _ = c;
+          else if (_ === l)
+            _ = c;
+          else
+            throw new Error("attribute equal must after attrName");
+          break;
+        case "'":
+        case '"':
+          if (_ === c || _ === s)
+            if (_ === s && (U.warning('attribute value must after "="'), z = h.slice(v, O)), v = O + 1, O = h.indexOf($, v), O > 0)
+              I = h.slice(v, O).replace(/&#?\w+;/g, B), M(z, I, v - 1), _ = g;
+            else
+              throw new Error("attribute value no end '" + $ + "' match");
+          else if (_ == p)
+            I = h.slice(v, O).replace(/&#?\w+;/g, B), M(z, I, v), U.warning('attribute "' + z + '" missed start quot(' + $ + ")!!"), v = O + 1, _ = g;
+          else
+            throw new Error('attribute value must after "="');
+          break;
+        case "/":
+          switch (_) {
+            case o:
+              T.setTagName(h.slice(v, O));
+            case g:
+            case D:
+            case d:
+              _ = d, T.closed = !0;
+            case p:
+            case s:
+              break;
+            case l:
+              T.closed = !0;
+              break;
+            //case S_EQ:
+            default:
+              throw new Error("attribute invalid close char('/')");
+          }
+          break;
+        case "":
+          return U.error("unexpected end of input"), _ == o && T.setTagName(h.slice(v, O)), O;
+        case ">":
+          switch (_) {
+            case o:
+              T.setTagName(h.slice(v, O));
+            case g:
+            case D:
+            case d:
+              break;
+            //normal
+            case p:
+            //Compatible state
+            case s:
+              I = h.slice(v, O), I.slice(-1) === "/" && (T.closed = !0, I = I.slice(0, -1));
+            case l:
+              _ === l && (I = z), _ == p ? (U.warning('attribute "' + I + '" missed quot(")!'), M(z, I.replace(/&#?\w+;/g, B), v)) : ((!e.isHTML(b[""]) || !I.match(/^(?:disabled|checked|selected)$/i)) && U.warning('attribute "' + I + '" missed value!! "' + I + '" instead!!'), M(I, I, v));
+              break;
+            case c:
+              throw new Error("attribute value missed!!");
+          }
+          return O;
+        /*xml space '\x20' | #x9 | #xD | #xA; */
+        case "€":
+          $ = " ";
+        default:
+          if ($ <= " ")
+            switch (_) {
+              case o:
+                T.setTagName(h.slice(v, O)), _ = D;
+                break;
+              case s:
+                z = h.slice(v, O), _ = l;
+                break;
+              case p:
+                var I = h.slice(v, O).replace(/&#?\w+;/g, B);
+                U.warning('attribute "' + I + '" missed quot(")!!'), M(z, I, v);
+              case g:
+                _ = D;
+                break;
+            }
+          else
+            switch (_) {
+              //case S_TAG:void();break;
+              //case S_ATTR:void();break;
+              //case S_ATTR_NOQUOT_VALUE:void();break;
+              case l:
+                T.tagName, (!e.isHTML(b[""]) || !z.match(/^(?:disabled|checked|selected)$/i)) && U.warning('attribute "' + z + '" missed value!! "' + z + '" instead2!!'), M(z, z, v), v = O, _ = s;
+                break;
+              case g:
+                U.warning('attribute space is required"' + z + '"!!');
+              case D:
+                _ = s, v = O;
+                break;
+              case c:
+                _ = p, v = O;
+                break;
+              case d:
+                throw new Error("elements closed character '/' and '>' must be connected to");
+            }
+      }
+      O++;
+    }
+  }
+  function P(h, v, T) {
+    for (var b = h.tagName, B = null, $ = h.length; $--; ) {
+      var U = h[$], M = U.qName, z = U.value, F = M.indexOf(":");
+      if (F > 0)
+        var I = U.prefix = M.slice(0, F), O = M.slice(F + 1), _ = I === "xmlns" && O;
+      else
+        O = M, I = null, _ = M === "xmlns" && "";
+      U.localName = O, _ !== !1 && (B == null && (B = {}, y(T, T = {})), T[_] = B[_] = z, U.uri = e.XMLNS, v.startPrefixMapping(_, z));
+    }
+    for (var $ = h.length; $--; ) {
+      U = h[$];
+      var I = U.prefix;
+      I && (I === "xml" && (U.uri = e.XML), I !== "xmlns" && (U.uri = T[I || ""]));
+    }
+    var F = b.indexOf(":");
+    F > 0 ? (I = h.prefix = b.slice(0, F), O = h.localName = b.slice(F + 1)) : (I = null, O = h.localName = b);
+    var ue = h.uri = T[I || ""];
+    if (v.startElement(ue, O, b, h), h.closed) {
+      if (v.endElement(ue, O, b), B)
+        for (I in B)
+          Object.prototype.hasOwnProperty.call(B, I) && v.endPrefixMapping(I);
+    } else
+      return h.currentNSMap = T, h.localNSMap = B, !0;
+  }
+  function R(h, v, T, b, B) {
+    if (/^(?:script|textarea)$/i.test(T)) {
+      var U = h.indexOf("</" + T + ">", v), M = h.substring(v + 1, U);
+      if (/[&<]/.test(M))
+        return /^script$/i.test(T) ? (B.characters(M, 0, M.length), U) : (M = M.replace(/&#?\w+;/g, b), B.characters(M, 0, M.length), U);
+    }
+    return v + 1;
+  }
+  function w(h, v, T, b) {
+    var B = b[T];
+    return B == null && (B = h.lastIndexOf("</" + T + ">"), B < v && (B = h.lastIndexOf("</" + T)), b[T] = B), B < v;
+  }
+  function y(h, v) {
+    for (var T in h)
+      Object.prototype.hasOwnProperty.call(h, T) && (v[T] = h[T]);
+  }
+  function q(h, v, T, b) {
+    var B = h.charAt(v + 2);
+    switch (B) {
+      case "-":
+        if (h.charAt(v + 3) === "-") {
+          var U = h.indexOf("-->", v + 4);
+          return U > v ? (T.comment(h, v + 4, U - v - 4), U + 3) : (b.error("Unclosed comment"), -1);
+        } else
+          return -1;
+      default:
+        if (h.substr(v + 3, 6) == "CDATA[") {
+          var U = h.indexOf("]]>", v + 9);
+          return T.startCDATA(), T.characters(h, v + 9, U - v - 9), T.endCDATA(), U + 3;
+        }
+        var M = G(h, v), z = M.length;
+        if (z > 1 && /!doctype/i.test(M[0][0])) {
+          var I = M[1][0], O = !1, _ = !1;
+          z > 3 && (/^public$/i.test(M[2][0]) ? (O = M[3][0], _ = z > 4 && M[4][0]) : /^system$/i.test(M[2][0]) && (_ = M[3][0]));
+          var $ = M[z - 1];
+          return T.startDTD(I, O, _), T.endDTD(), $.index + $[0].length;
+        }
+    }
+    return -1;
+  }
+  function j(h, v, T) {
+    var b = h.indexOf("?>", v);
+    if (b) {
+      var B = h.substring(v, b).match(/^<\?(\S*)\s*([\s\S]*?)\s*$/);
+      return B ? (B[0].length, T.processingInstruction(B[1], B[2]), b + 2) : -1;
+    }
+    return -1;
+  }
+  function L() {
+    this.attributeNames = {};
+  }
+  L.prototype = {
+    setTagName: function(h) {
+      if (!i.test(h))
+        throw new Error("invalid tagName:" + h);
+      this.tagName = h;
+    },
+    addValue: function(h, v, T) {
+      if (!i.test(h))
+        throw new Error("invalid attribute:" + h);
+      this.attributeNames[h] = this.length, this[this.length++] = { qName: h, value: v, offset: T };
+    },
+    length: 0,
+    getLocalName: function(h) {
+      return this[h].localName;
+    },
+    getLocator: function(h) {
+      return this[h].locator;
+    },
+    getQName: function(h) {
+      return this[h].qName;
+    },
+    getURI: function(h) {
+      return this[h].uri;
+    },
+    getValue: function(h) {
+      return this[h].value;
+    }
+    //	,getIndex:function(uri, localName)){
+    //		if(localName){
+    //
+    //		}else{
+    //			var qName = uri
+    //		}
+    //	},
+    //	getValue:function(){return this.getValue(this.getIndex.apply(this,arguments))},
+    //	getType:function(uri,localName){}
+    //	getType:function(i){},
+  };
+  function G(h, v) {
+    var T, b = [], B = /'[^']+'|"[^"]+"|[^\s<>\/=]+=?|(\/?\s*>|<)/g;
+    for (B.lastIndex = v, B.exec(h); T = B.exec(h); )
+      if (b.push(T), T[1]) return b;
+  }
+  return He.XMLReader = S, He.ParseError = E, He;
+}
+var It;
+function Zu() {
+  if (It) return Te;
+  It = 1;
+  var e = $e(), r = Wt(), t = zu(), i = Hu(), o = r.DOMImplementation, s = e.NAMESPACE, l = i.ParseError, c = i.XMLReader;
+  function p(m) {
+    this.options = m || { locator: {} };
+  }
+  p.prototype.parseFromString = function(m, N) {
+    var P = this.options, R = new c(), w = P.domBuilder || new D(), y = P.errorHandler, q = P.locator, j = P.xmlns || {}, L = /\/x?html?$/.test(N), G = L ? t.HTML_ENTITIES : t.XML_ENTITIES;
+    return q && w.setDocumentLocator(q), R.errorHandler = g(y, w, q), R.domBuilder = P.domBuilder || w, L && (j[""] = s.HTML), j.xml = j.xml || s.XML, m && typeof m == "string" ? R.parse(m, j, G) : R.errorHandler.error("invalid doc source"), w.doc;
+  };
+  function g(m, N, P) {
+    if (!m) {
+      if (N instanceof D)
+        return N;
+      m = N;
+    }
+    var R = {}, w = m instanceof Function;
+    P = P || {};
+    function y(q) {
+      var j = m[q];
+      !j && w && (j = m.length == 2 ? function(L) {
+        m(q, L);
+      } : m), R[q] = j && function(L) {
+        j("[xmldom " + q + "]	" + L + E(P));
+      } || function() {
+      };
+    }
+    return y("warning"), y("error"), y("fatalError"), R;
+  }
+  function D() {
+    this.cdata = !1;
+  }
+  function d(m, N) {
+    N.lineNumber = m.lineNumber, N.columnNumber = m.columnNumber;
+  }
+  D.prototype = {
+    startDocument: function() {
+      this.doc = new o().createDocument(null, null, null), this.locator && (this.doc.documentURI = this.locator.systemId);
+    },
+    startElement: function(m, N, P, R) {
+      var w = this.doc, y = w.createElementNS(m, P || N), q = R.length;
+      C(this, y), this.currentElement = y, this.locator && d(this.locator, y);
+      for (var j = 0; j < q; j++) {
+        var m = R.getURI(j), L = R.getValue(j), P = R.getQName(j), G = w.createAttributeNS(m, P);
+        this.locator && d(R.getLocator(j), G), G.value = G.nodeValue = L, y.setAttributeNode(G);
+      }
+    },
+    endElement: function(m, N, P) {
+      var R = this.currentElement;
+      R.tagName, this.currentElement = R.parentNode;
+    },
+    startPrefixMapping: function(m, N) {
+    },
+    endPrefixMapping: function(m) {
+    },
+    processingInstruction: function(m, N) {
+      var P = this.doc.createProcessingInstruction(m, N);
+      this.locator && d(this.locator, P), C(this, P);
+    },
+    ignorableWhitespace: function(m, N, P) {
+    },
+    characters: function(m, N, P) {
+      if (m = S.apply(this, arguments), m) {
+        if (this.cdata)
+          var R = this.doc.createCDATASection(m);
+        else
+          var R = this.doc.createTextNode(m);
+        this.currentElement ? this.currentElement.appendChild(R) : /^\s*$/.test(m) && this.doc.appendChild(R), this.locator && d(this.locator, R);
+      }
+    },
+    skippedEntity: function(m) {
+    },
+    endDocument: function() {
+      this.doc.normalize();
+    },
+    setDocumentLocator: function(m) {
+      (this.locator = m) && (m.lineNumber = 0);
+    },
+    //LexicalHandler
+    comment: function(m, N, P) {
+      m = S.apply(this, arguments);
+      var R = this.doc.createComment(m);
+      this.locator && d(this.locator, R), C(this, R);
+    },
+    startCDATA: function() {
+      this.cdata = !0;
+    },
+    endCDATA: function() {
+      this.cdata = !1;
+    },
+    startDTD: function(m, N, P) {
+      var R = this.doc.implementation;
+      if (R && R.createDocumentType) {
+        var w = R.createDocumentType(m, N, P);
+        this.locator && d(this.locator, w), C(this, w), this.doc.doctype = w;
+      }
+    },
+    /**
+     * @see org.xml.sax.ErrorHandler
+     * @link http://www.saxproject.org/apidoc/org/xml/sax/ErrorHandler.html
+     */
+    warning: function(m) {
+      console.warn("[xmldom warning]	" + m, E(this.locator));
+    },
+    error: function(m) {
+      console.error("[xmldom error]	" + m, E(this.locator));
+    },
+    fatalError: function(m) {
+      throw new l(m, this.locator);
+    }
+  };
+  function E(m) {
+    if (m)
+      return `
+@` + (m.systemId || "") + "#[line:" + m.lineNumber + ",col:" + m.columnNumber + "]";
+  }
+  function S(m, N, P) {
+    return typeof m == "string" ? m.substr(N, P) : m.length >= N + P || N ? new java.lang.String(m, N, P) + "" : m;
+  }
+  "endDTD,startEntity,endEntity,attributeDecl,elementDecl,externalEntityDecl,internalEntityDecl,resolveEntity,getExternalSubset,notationDecl,unparsedEntityDecl".replace(/\w+/g, function(m) {
+    D.prototype[m] = function() {
+      return null;
+    };
+  });
+  function C(m, N) {
+    m.currentElement ? m.currentElement.appendChild(N) : m.doc.appendChild(N);
+  }
+  return Te.__DOMHandler = D, Te.DOMParser = p, Te.DOMImplementation = r.DOMImplementation, Te.XMLSerializer = r.XMLSerializer, Te;
+}
+var Rt;
+function Xu() {
+  if (Rt) return ke;
+  Rt = 1;
+  var e = Wt();
+  return ke.DOMImplementation = e.DOMImplementation, ke.XMLSerializer = e.XMLSerializer, ke.DOMParser = Zu().DOMParser, ke;
+}
+var ft = Xu();
+const $u = "4.4.3", Wu = `<?xml version="1.0" encoding="UTF-8"?>
+<gpx`, Yu = {
+  dataType: null,
+  batchType: null,
+  name: "GPX (GPS exchange format)",
+  id: "gpx",
+  module: "kml",
+  version: $u,
+  extensions: ["gpx"],
+  mimeTypes: ["application/gpx+xml"],
+  text: !0,
+  tests: [Wu],
+  parse: async (e, r) => qt(new TextDecoder().decode(e), r),
+  parseTextSync: qt,
+  options: {
+    gpx: { shape: "geojson-table" },
+    gis: {}
+  }
+};
+function qt(e, r) {
+  const t = new ft.DOMParser().parseFromString(e, "text/xml"), i = Bu(t), o = { ...Yu.options.gpx, ...r == null ? void 0 : r.gpx };
+  switch (o.shape) {
+    case "object-row-table":
+      return {
+        shape: "object-row-table",
+        data: i.features
+      };
+    case "geojson-table":
+      return {
+        shape: "geojson-table",
+        type: "FeatureCollection",
+        features: i.features
+      };
+    case "binary":
+      return Gt(i.features);
+    default:
+      throw new Error(o.shape);
+  }
+}
+const Ku = "4.4.3", Qu = `<?xml version="1.0" encoding="UTF-8"?>
+<kml xmlns="http://www.opengis.net/kml/2.2">`, Ju = {
+  dataType: null,
+  batchType: null,
+  name: "KML (Keyhole Markup Language)",
+  id: "kml",
+  module: "kml",
+  version: Ku,
+  extensions: ["kml"],
+  mimeTypes: ["application/vnd.google-earth.kml+xml"],
+  text: !0,
+  tests: [Qu],
+  parse: async (e, r) => Lt(new TextDecoder().decode(e), r),
+  parseTextSync: Lt,
+  options: {
+    kml: { shape: "geojson-table" },
+    gis: {}
+  }
+};
+function Lt(e, r) {
+  const t = new ft.DOMParser().parseFromString(e, "text/xml"), i = ju(t), o = { ...Ju.options.kml, ...r == null ? void 0 : r.kml };
+  switch (o.shape) {
+    case "geojson-table":
+      return {
+        shape: "geojson-table",
+        type: "FeatureCollection",
+        features: i.features
+      };
+    // case 'geojson':
+    //   return geojson;
+    // case 'binary':
+    //   return geojsonToBinary(geojson.features);
+    // case 'raw':
+    //   return doc;
+    case "object-row-table":
+      return {
+        shape: "object-row-table",
+        data: i.features
+      };
+    default:
+      throw new Error(o.shape);
+  }
+}
+const er = "4.4.3", tr = `<?xml version="1.0" encoding="UTF-8"?>
+<TrainingCenterDatabase`, ur = {
+  dataType: null,
+  batchType: null,
+  name: "TCX (Training Center XML)",
+  id: "tcx",
+  module: "kml",
+  version: er,
+  extensions: ["tcx"],
+  mimeTypes: ["application/vnd.garmin.tcx+xml"],
+  text: !0,
+  tests: [tr],
+  parse: async (e, r) => Ot(new TextDecoder().decode(e), r),
+  parseTextSync: Ot,
+  options: {
+    tcx: { shape: "geojson-table" },
+    gis: {}
+  }
+};
+function Ot(e, r) {
+  const t = new ft.DOMParser().parseFromString(e, "text/xml"), i = Lu(t), o = { ...ur.options.tcx, ...r == null ? void 0 : r.tcx };
+  switch (o.shape) {
+    case "object-row-table":
+      return {
+        shape: "object-row-table",
+        data: i.features
+      };
+    case "geojson-table":
+      return {
+        shape: "geojson-table",
+        type: "FeatureCollection",
+        schema: { metadata: {}, fields: [] },
+        features: i.features
+      };
+    case "binary":
+      return Gt(i.features);
+    default:
+      throw new Error(o.shape);
+  }
+}
+export {
+  Yu as GPXLoader,
+  Ju as KMLLoader,
+  ur as TCXLoader
+};