@loaders.gl/kml 4.0.0-alpha.5 → 4.0.0-alpha.7

package/dist/dist.min.js

@@ -29,6 +29,34 @@
     return __reExport(__markAsModule(__defProp(module != null ? __create(__getProtoOf(module)) : {}, "default", module && module.__esModule && "default" in module ? { get: () => module.default, enumerable: true } : { value: module, enumerable: true })), module);
   };
 
+  // ../../node_modules/@babel/runtime/helpers/esm/typeof.js
+  var init_typeof = __esm({
+    "../../node_modules/@babel/runtime/helpers/esm/typeof.js"() {
+    }
+  });
+
+  // ../../node_modules/@babel/runtime/helpers/esm/toPrimitive.js
+  var init_toPrimitive = __esm({
+    "../../node_modules/@babel/runtime/helpers/esm/toPrimitive.js"() {
+      init_typeof();
+    }
+  });
+
+  // ../../node_modules/@babel/runtime/helpers/esm/toPropertyKey.js
+  var init_toPropertyKey = __esm({
+    "../../node_modules/@babel/runtime/helpers/esm/toPropertyKey.js"() {
+      init_typeof();
+      init_toPrimitive();
+    }
+  });
+
+  // ../../node_modules/@babel/runtime/helpers/esm/defineProperty.js
+  var init_defineProperty = __esm({
+    "../../node_modules/@babel/runtime/helpers/esm/defineProperty.js"() {
+      init_toPropertyKey();
+    }
+  });
+
   // ../../node_modules/@math.gl/polygon/dist/esm/polygon-utils.js
   function getPolygonSignedArea(points, options = {}) {
     const {
@@ -51,16 +79,16 @@
   // ../../node_modules/@math.gl/polygon/dist/esm/polygon.js
   var init_polygon = __esm({
     "../../node_modules/@math.gl/polygon/dist/esm/polygon.js"() {
+      init_defineProperty();
       init_polygon_utils();
     }
   });
 
   // ../../node_modules/@math.gl/polygon/dist/esm/earcut.js
-  function earcut(data, holeIndices, dim, areas) {
-    dim = dim || 2;
+  function earcut(positions, holeIndices, dim = 2, areas) {
     const hasHoles = holeIndices && holeIndices.length;
-    const outerLen = hasHoles ? holeIndices[0] * dim : data.length;
-    let outerNode = linkedList(data, 0, outerLen, dim, true, areas && areas[0]);
+    const outerLen = hasHoles ? holeIndices[0] * dim : positions.length;
+    let outerNode = linkedList(positions, 0, outerLen, dim, true, areas && areas[0]);
     const triangles = [];
     if (!outerNode || outerNode.next === outerNode.prev)
       return triangles;
@@ -72,13 +100,13 @@
     let x;
     let y;
     if (hasHoles)
-      outerNode = eliminateHoles(data, holeIndices, outerNode, dim, areas);
-    if (data.length > 80 * dim) {
-      minX = maxX = data[0];
-      minY = maxY = data[1];
+      outerNode = eliminateHoles(positions, holeIndices, outerNode, dim, areas);
+    if (positions.length > 80 * dim) {
+      minX = maxX = positions[0];
+      minY = maxY = positions[1];
       for (let i = dim; i < outerLen; i += dim) {
-        x = data[i];
-        y = data[i + 1];
+        x = positions[i];
+        y = positions[i + 1];
         if (x < minX)
           minX = x;
         if (y < minY)
@@ -857,8 +885,8 @@
           lineFeaturesCount++;
           linePositionsCount += geometry.coordinates.length;
           linePathsCount++;
-          for (const coord of geometry.coordinates) {
-            coordLengths.add(coord.length);
+          for (const coord2 of geometry.coordinates) {
+            coordLengths.add(coord2.length);
           }
           break;
         case "MultiLineString":
@@ -866,8 +894,8 @@
           for (const line of geometry.coordinates) {
             linePositionsCount += line.length;
             linePathsCount++;
-            for (const coord of line) {
-              coordLengths.add(coord.length);
+            for (const coord2 of line) {
+              coordLengths.add(coord2.length);
             }
           }
           break;
@@ -877,8 +905,8 @@
           polygonRingsCount += geometry.coordinates.length;
           const flattened = geometry.coordinates.flat();
           polygonPositionsCount += flattened.length;
-          for (const coord of flattened) {
-            coordLengths.add(coord.length);
+          for (const coord2 of flattened) {
+            coordLengths.add(coord2.length);
           }
           break;
         case "MultiPolygon":
@@ -888,8 +916,8 @@
             polygonRingsCount += polygon.length;
             const flattened2 = polygon.flat();
             polygonPositionsCount += flattened2.length;
-            for (const coord of flattened2) {
-              coordLengths.add(coord.length);
+            for (const coord2 of flattened2) {
+              coordLengths.add(coord2.length);
             }
           }
           break;
@@ -1029,363 +1057,3061 @@
     }
   });
 
-  // ../../node_modules/@tmcw/togeojson/dist/togeojson.umd.js
-  var require_togeojson_umd = __commonJS({
-    "../../node_modules/@tmcw/togeojson/dist/togeojson.umd.js"(exports, module) {
-      !function(e, t) {
-        typeof exports == "object" && typeof module != "undefined" ? t(exports) : typeof define == "function" && define.amd ? define(["exports"], t) : t((e = typeof globalThis != "undefined" ? globalThis : e || self).toGeoJSON = {});
-      }(exports, function(e) {
-        "use strict";
-        function t(e2) {
-          return e2 && e2.normalize && e2.normalize(), e2 && e2.textContent || "";
-        }
-        function n(e2, t2) {
-          const n2 = e2.getElementsByTagName(t2);
-          return n2.length ? n2[0] : null;
-        }
-        function o(e2) {
-          const o2 = {};
-          if (e2) {
-            const s2 = n(e2, "line");
-            if (s2) {
-              const e3 = t(n(s2, "color")), r2 = parseFloat(t(n(s2, "opacity"))), i2 = parseFloat(t(n(s2, "width")));
-              e3 && (o2.stroke = e3), isNaN(r2) || (o2["stroke-opacity"] = r2), isNaN(i2) || (o2["stroke-width"] = 96 * i2 / 25.4);
+  // ../../node_modules/@tmcw/togeojson/dist/togeojson.es.js
+  function nodeVal(x) {
+    if (x && x.normalize) {
+      x.normalize();
+    }
+    return x && x.textContent || "";
+  }
+  function get1(x, y) {
+    const n = x.getElementsByTagName(y);
+    return n.length ? n[0] : null;
+  }
+  function getLineStyle(extensions) {
+    const style = {};
+    if (extensions) {
+      const lineStyle = get1(extensions, "line");
+      if (lineStyle) {
+        const color = nodeVal(get1(lineStyle, "color")), opacity = parseFloat(nodeVal(get1(lineStyle, "opacity"))), width = parseFloat(nodeVal(get1(lineStyle, "width")));
+        if (color)
+          style.stroke = color;
+        if (!isNaN(opacity))
+          style["stroke-opacity"] = opacity;
+        if (!isNaN(width))
+          style["stroke-width"] = width * 96 / 25.4;
+      }
+    }
+    return style;
+  }
+  function getExtensions(node) {
+    let values = [];
+    if (node !== null) {
+      for (let i = 0; i < node.childNodes.length; i++) {
+        const child = node.childNodes[i];
+        if (child.nodeType !== 1)
+          continue;
+        const name = ["heart", "gpxtpx:hr", "hr"].includes(child.nodeName) ? "heart" : child.nodeName;
+        if (name === "gpxtpx:TrackPointExtension") {
+          values = values.concat(getExtensions(child));
+        } else {
+          const val = nodeVal(child);
+          values.push([name, isNaN(val) ? val : parseFloat(val)]);
+        }
+      }
+    }
+    return values;
+  }
+  function getMulti(x, ys) {
+    const o = {};
+    let n;
+    let k;
+    for (k = 0; k < ys.length; k++) {
+      n = get1(x, ys[k]);
+      if (n)
+        o[ys[k]] = nodeVal(n);
+    }
+    return o;
+  }
+  function getProperties$1(node) {
+    const prop = getMulti(node, [
+      "name",
+      "cmt",
+      "desc",
+      "type",
+      "time",
+      "keywords"
+    ]);
+    const extensions = node.getElementsByTagNameNS("http://www.garmin.com/xmlschemas/GpxExtensions/v3", "*");
+    for (let i = 0; i < extensions.length; i++) {
+      const extension = extensions[i];
+      if (extension.parentNode.parentNode === node) {
+        prop[extension.tagName.replace(":", "_")] = nodeVal(extension);
+      }
+    }
+    const links = node.getElementsByTagName("link");
+    if (links.length)
+      prop.links = [];
+    for (let i = 0; i < links.length; i++) {
+      prop.links.push(Object.assign({ href: links[i].getAttribute("href") }, getMulti(links[i], ["text", "type"])));
+    }
+    return prop;
+  }
+  function coordPair$1(x) {
+    const ll = [
+      parseFloat(x.getAttribute("lon")),
+      parseFloat(x.getAttribute("lat"))
+    ];
+    const ele = get1(x, "ele");
+    const time = get1(x, "time");
+    if (ele) {
+      const e = parseFloat(nodeVal(ele));
+      if (!isNaN(e)) {
+        ll.push(e);
+      }
+    }
+    return {
+      coordinates: ll,
+      time: time ? nodeVal(time) : null,
+      extendedValues: getExtensions(get1(x, "extensions"))
+    };
+  }
+  function getRoute(node) {
+    const line = getPoints$1(node, "rtept");
+    if (!line)
+      return;
+    return {
+      type: "Feature",
+      properties: Object.assign(getProperties$1(node), getLineStyle(get1(node, "extensions")), { _gpxType: "rte" }),
+      geometry: {
+        type: "LineString",
+        coordinates: line.line
+      }
+    };
+  }
+  function getPoints$1(node, pointname) {
+    const pts = node.getElementsByTagName(pointname);
+    if (pts.length < 2)
+      return;
+    const line = [];
+    const times = [];
+    const extendedValues = {};
+    for (let i = 0; i < pts.length; i++) {
+      const c = coordPair$1(pts[i]);
+      line.push(c.coordinates);
+      if (c.time)
+        times.push(c.time);
+      for (let j = 0; j < c.extendedValues.length; j++) {
+        const [name, val] = c.extendedValues[j];
+        const plural = name === "heart" ? name : name.replace("gpxtpx:", "") + "s";
+        if (!extendedValues[plural]) {
+          extendedValues[plural] = Array(pts.length).fill(null);
+        }
+        extendedValues[plural][i] = val;
+      }
+    }
+    return {
+      line,
+      times,
+      extendedValues
+    };
+  }
+  function getTrack(node) {
+    const segments = node.getElementsByTagName("trkseg");
+    const track = [];
+    const times = [];
+    const extractedLines = [];
+    for (let i = 0; i < segments.length; i++) {
+      const line = getPoints$1(segments[i], "trkpt");
+      if (line) {
+        extractedLines.push(line);
+        if (line.times && line.times.length)
+          times.push(line.times);
+      }
+    }
+    if (extractedLines.length === 0)
+      return;
+    const multi = extractedLines.length > 1;
+    const properties = Object.assign(getProperties$1(node), getLineStyle(get1(node, "extensions")), { _gpxType: "trk" }, times.length ? {
+      coordinateProperties: {
+        times: multi ? times : times[0]
+      }
+    } : {});
+    for (let i = 0; i < extractedLines.length; i++) {
+      const line = extractedLines[i];
+      track.push(line.line);
+      for (const [name, val] of Object.entries(line.extendedValues)) {
+        if (!properties.coordinateProperties) {
+          properties.coordinateProperties = {};
+        }
+        const props = properties.coordinateProperties;
+        if (multi) {
+          if (!props[name])
+            props[name] = extractedLines.map((line2) => new Array(line2.line.length).fill(null));
+          props[name][i] = val;
+        } else {
+          props[name] = val;
+        }
+      }
+    }
+    return {
+      type: "Feature",
+      properties,
+      geometry: multi ? {
+        type: "MultiLineString",
+        coordinates: track
+      } : {
+        type: "LineString",
+        coordinates: track[0]
+      }
+    };
+  }
+  function getPoint(node) {
+    return {
+      type: "Feature",
+      properties: Object.assign(getProperties$1(node), getMulti(node, ["sym"])),
+      geometry: {
+        type: "Point",
+        coordinates: coordPair$1(node).coordinates
+      }
+    };
+  }
+  function* gpxGen(doc) {
+    const tracks = doc.getElementsByTagName("trk");
+    const routes = doc.getElementsByTagName("rte");
+    const waypoints = doc.getElementsByTagName("wpt");
+    for (let i = 0; i < tracks.length; i++) {
+      const feature = getTrack(tracks[i]);
+      if (feature)
+        yield feature;
+    }
+    for (let i = 0; i < routes.length; i++) {
+      const feature = getRoute(routes[i]);
+      if (feature)
+        yield feature;
+    }
+    for (let i = 0; i < waypoints.length; i++) {
+      yield getPoint(waypoints[i]);
+    }
+  }
+  function gpx(doc) {
+    return {
+      type: "FeatureCollection",
+      features: Array.from(gpxGen(doc))
+    };
+  }
+  function fromEntries(arr) {
+    const obj = {};
+    for (const [key, value] of arr) {
+      obj[key] = value;
+    }
+    return obj;
+  }
+  function getProperties(node, attributeNames) {
+    const properties = [];
+    for (const [tag, alias] of attributeNames) {
+      let elem = get1(node, tag);
+      if (!elem) {
+        const elements = node.getElementsByTagNameNS(EXTENSIONS_NS, tag);
+        if (elements.length) {
+          elem = elements[0];
+        }
+      }
+      const val = parseFloat(nodeVal(elem));
+      if (!isNaN(val)) {
+        properties.push([alias, val]);
+      }
+    }
+    return properties;
+  }
+  function coordPair(x) {
+    const lon = nodeVal(get1(x, "LongitudeDegrees"));
+    const lat = nodeVal(get1(x, "LatitudeDegrees"));
+    if (!lon.length || !lat.length) {
+      return null;
+    }
+    const ll = [parseFloat(lon), parseFloat(lat)];
+    const alt = get1(x, "AltitudeMeters");
+    const heartRate = get1(x, "HeartRateBpm");
+    const time = get1(x, "Time");
+    let a;
+    if (alt) {
+      a = parseFloat(nodeVal(alt));
+      if (!isNaN(a)) {
+        ll.push(a);
+      }
+    }
+    return {
+      coordinates: ll,
+      time: time ? nodeVal(time) : null,
+      heartRate: heartRate ? parseFloat(nodeVal(heartRate)) : null,
+      extensions: getProperties(x, TRACKPOINT_ATTRIBUTES)
+    };
+  }
+  function getPoints(node, pointname) {
+    const pts = node.getElementsByTagName(pointname);
+    const line = [];
+    const times = [];
+    const heartRates = [];
+    if (pts.length < 2)
+      return null;
+    const result = { extendedProperties: {} };
+    for (let i = 0; i < pts.length; i++) {
+      const c = coordPair(pts[i]);
+      if (c === null)
+        continue;
+      line.push(c.coordinates);
+      if (c.time)
+        times.push(c.time);
+      if (c.heartRate)
+        heartRates.push(c.heartRate);
+      for (const [alias, value] of c.extensions) {
+        if (!result.extendedProperties[alias]) {
+          result.extendedProperties[alias] = Array(pts.length).fill(null);
+        }
+        result.extendedProperties[alias][i] = value;
+      }
+    }
+    return Object.assign(result, {
+      line,
+      times,
+      heartRates
+    });
+  }
+  function getLap(node) {
+    const segments = node.getElementsByTagName("Track");
+    const track = [];
+    const times = [];
+    const heartRates = [];
+    const allExtendedProperties = [];
+    let line;
+    const properties = fromEntries(getProperties(node, LAP_ATTRIBUTES));
+    const nameElement = get1(node, "Name");
+    if (nameElement) {
+      properties.name = nodeVal(nameElement);
+    }
+    for (let i = 0; i < segments.length; i++) {
+      line = getPoints(segments[i], "Trackpoint");
+      if (line) {
+        track.push(line.line);
+        if (line.times.length)
+          times.push(line.times);
+        if (line.heartRates.length)
+          heartRates.push(line.heartRates);
+        allExtendedProperties.push(line.extendedProperties);
+      }
+    }
+    for (let i = 0; i < allExtendedProperties.length; i++) {
+      const extendedProperties = allExtendedProperties[i];
+      for (const property in extendedProperties) {
+        if (segments.length === 1) {
+          properties[property] = line.extendedProperties[property];
+        } else {
+          if (!properties[property]) {
+            properties[property] = track.map((track2) => Array(track2.length).fill(null));
+          }
+          properties[property][i] = extendedProperties[property];
+        }
+      }
+    }
+    if (track.length === 0)
+      return;
+    if (times.length || heartRates.length) {
+      properties.coordinateProperties = Object.assign(times.length ? {
+        times: track.length === 1 ? times[0] : times
+      } : {}, heartRates.length ? {
+        heart: track.length === 1 ? heartRates[0] : heartRates
+      } : {});
+    }
+    return {
+      type: "Feature",
+      properties,
+      geometry: {
+        type: track.length === 1 ? "LineString" : "MultiLineString",
+        coordinates: track.length === 1 ? track[0] : track
+      }
+    };
+  }
+  function* tcxGen(doc) {
+    const laps = doc.getElementsByTagName("Lap");
+    for (let i = 0; i < laps.length; i++) {
+      const feature = getLap(laps[i]);
+      if (feature)
+        yield feature;
+    }
+    const courses = doc.getElementsByTagName("Courses");
+    for (let i = 0; i < courses.length; i++) {
+      const feature = getLap(courses[i]);
+      if (feature)
+        yield feature;
+    }
+  }
+  function tcx(doc) {
+    return {
+      type: "FeatureCollection",
+      features: Array.from(tcxGen(doc))
+    };
+  }
+  function okhash(x) {
+    if (!x || !x.length)
+      return 0;
+    let h = 0;
+    for (let i = 0; i < x.length; i++) {
+      h = (h << 5) - h + x.charCodeAt(i) | 0;
+    }
+    return h;
+  }
+  function coord1(v) {
+    return v.replace(removeSpace, "").split(",").map(parseFloat);
+  }
+  function coord(v) {
+    return v.replace(trimSpace, "").split(splitSpace).map(coord1);
+  }
+  function xml2str(node) {
+    if (node.xml !== void 0)
+      return node.xml;
+    if (node.tagName) {
+      let output = node.tagName;
+      for (let i = 0; i < node.attributes.length; i++) {
+        output += node.attributes[i].name + node.attributes[i].value;
+      }
+      for (let i = 0; i < node.childNodes.length; i++) {
+        output += xml2str(node.childNodes[i]);
+      }
+      return output;
+    }
+    if (node.nodeName === "#text") {
+      return (node.nodeValue || node.value || "").trim();
+    }
+    if (node.nodeName === "#cdata-section") {
+      return node.nodeValue;
+    }
+    return "";
+  }
+  function kmlColor(properties, elem, prefix) {
+    let v = nodeVal(get1(elem, "color")) || "";
+    const colorProp = prefix == "stroke" || prefix === "fill" ? prefix : prefix + "-color";
+    if (v.substr(0, 1) === "#") {
+      v = v.substr(1);
+    }
+    if (v.length === 6 || v.length === 3) {
+      properties[colorProp] = v;
+    } else if (v.length === 8) {
+      properties[prefix + "-opacity"] = parseInt(v.substr(0, 2), 16) / 255;
+      properties[colorProp] = "#" + v.substr(6, 2) + v.substr(4, 2) + v.substr(2, 2);
+    }
+  }
+  function numericProperty(properties, elem, source, target) {
+    const val = parseFloat(nodeVal(get1(elem, source)));
+    if (!isNaN(val))
+      properties[target] = val;
+  }
+  function gxCoords(root) {
+    let elems = root.getElementsByTagName("coord");
+    const coords = [];
+    const times = [];
+    if (elems.length === 0)
+      elems = root.getElementsByTagName("gx:coord");
+    for (let i = 0; i < elems.length; i++) {
+      coords.push(nodeVal(elems[i]).split(" ").map(parseFloat));
+    }
+    const timeElems = root.getElementsByTagName("when");
+    for (let j = 0; j < timeElems.length; j++)
+      times.push(nodeVal(timeElems[j]));
+    return {
+      coords,
+      times
+    };
+  }
+  function getGeometry(root) {
+    let geomNode;
+    let geomNodes;
+    let i;
+    let j;
+    let k;
+    const geoms = [];
+    const coordTimes = [];
+    if (get1(root, "MultiGeometry")) {
+      return getGeometry(get1(root, "MultiGeometry"));
+    }
+    if (get1(root, "MultiTrack")) {
+      return getGeometry(get1(root, "MultiTrack"));
+    }
+    if (get1(root, "gx:MultiTrack")) {
+      return getGeometry(get1(root, "gx:MultiTrack"));
+    }
+    for (i = 0; i < geotypes.length; i++) {
+      geomNodes = root.getElementsByTagName(geotypes[i]);
+      if (geomNodes) {
+        for (j = 0; j < geomNodes.length; j++) {
+          geomNode = geomNodes[j];
+          if (geotypes[i] === "Point") {
+            geoms.push({
+              type: "Point",
+              coordinates: coord1(nodeVal(get1(geomNode, "coordinates")))
+            });
+          } else if (geotypes[i] === "LineString") {
+            geoms.push({
+              type: "LineString",
+              coordinates: coord(nodeVal(get1(geomNode, "coordinates")))
+            });
+          } else if (geotypes[i] === "Polygon") {
+            const rings = geomNode.getElementsByTagName("LinearRing"), coords = [];
+            for (k = 0; k < rings.length; k++) {
+              coords.push(coord(nodeVal(get1(rings[k], "coordinates"))));
             }
+            geoms.push({
+              type: "Polygon",
+              coordinates: coords
+            });
+          } else if (geotypes[i] === "Track" || geotypes[i] === "gx:Track") {
+            const track = gxCoords(geomNode);
+            geoms.push({
+              type: "LineString",
+              coordinates: track.coords
+            });
+            if (track.times.length)
+              coordTimes.push(track.times);
           }
-          return o2;
-        }
-        function s(e2, o2) {
-          const s2 = {};
-          let r2, i2;
-          for (i2 = 0; i2 < o2.length; i2++)
-            r2 = n(e2, o2[i2]), r2 && (s2[o2[i2]] = t(r2));
-          return s2;
-        }
-        function r(e2) {
-          const n2 = s(e2, ["name", "cmt", "desc", "type", "time", "keywords"]), o2 = e2.getElementsByTagNameNS("http://www.garmin.com/xmlschemas/GpxExtensions/v3", "*");
-          for (let s2 = 0; s2 < o2.length; s2++) {
-            const r3 = o2[s2];
-            r3.parentNode.parentNode === e2 && (n2[r3.tagName.replace(":", "_")] = t(r3));
-          }
-          const r2 = e2.getElementsByTagName("link");
-          r2.length && (n2.links = []);
-          for (let e3 = 0; e3 < r2.length; e3++)
-            n2.links.push(Object.assign({ href: r2[e3].getAttribute("href") }, s(r2[e3], ["text", "type"])));
-          return n2;
-        }
-        function i(e2) {
-          const o2 = [parseFloat(e2.getAttribute("lon")), parseFloat(e2.getAttribute("lat"))], s2 = n(e2, "ele"), r2 = n(e2, "gpxtpx:hr") || n(e2, "hr"), i2 = n(e2, "time");
-          let l2;
-          s2 && (l2 = parseFloat(t(s2)), isNaN(l2) || o2.push(l2));
-          const a2 = { coordinates: o2, time: i2 ? t(i2) : null, extendedValues: [] };
-          r2 && a2.extendedValues.push(["heart", parseFloat(t(r2))]);
-          const c2 = n(e2, "extensions");
-          if (c2 !== null)
-            for (const e3 of ["speed", "course", "hAcc", "vAcc"]) {
-              const o3 = parseFloat(t(n(c2, e3)));
-              isNaN(o3) || a2.extendedValues.push([e3, o3]);
+        }
+      }
+    }
+    return {
+      geoms,
+      coordTimes
+    };
+  }
+  function getPlacemark(root, styleIndex, styleMapIndex, styleByHash) {
+    const geomsAndTimes = getGeometry(root);
+    let i;
+    const properties = {};
+    const name = nodeVal(get1(root, "name"));
+    const address = nodeVal(get1(root, "address"));
+    let styleUrl = nodeVal(get1(root, "styleUrl"));
+    const description = nodeVal(get1(root, "description"));
+    const timeSpan = get1(root, "TimeSpan");
+    const timeStamp = get1(root, "TimeStamp");
+    const extendedData = get1(root, "ExtendedData");
+    let iconStyle = get1(root, "IconStyle");
+    let labelStyle = get1(root, "LabelStyle");
+    let lineStyle = get1(root, "LineStyle");
+    let polyStyle = get1(root, "PolyStyle");
+    const visibility = get1(root, "visibility");
+    if (name)
+      properties.name = name;
+    if (address)
+      properties.address = address;
+    if (styleUrl) {
+      if (styleUrl[0] !== "#") {
+        styleUrl = "#" + styleUrl;
+      }
+      properties.styleUrl = styleUrl;
+      if (styleIndex[styleUrl]) {
+        properties.styleHash = styleIndex[styleUrl];
+      }
+      if (styleMapIndex[styleUrl]) {
+        properties.styleMapHash = styleMapIndex[styleUrl];
+        properties.styleHash = styleIndex[styleMapIndex[styleUrl].normal];
+      }
+      const style = styleByHash[properties.styleHash];
+      if (style) {
+        if (!iconStyle)
+          iconStyle = get1(style, "IconStyle");
+        if (!labelStyle)
+          labelStyle = get1(style, "LabelStyle");
+        if (!lineStyle)
+          lineStyle = get1(style, "LineStyle");
+        if (!polyStyle)
+          polyStyle = get1(style, "PolyStyle");
+      }
+    }
+    if (description)
+      properties.description = description;
+    if (timeSpan) {
+      const begin = nodeVal(get1(timeSpan, "begin"));
+      const end = nodeVal(get1(timeSpan, "end"));
+      properties.timespan = { begin, end };
+    }
+    if (timeStamp) {
+      properties.timestamp = nodeVal(get1(timeStamp, "when"));
+    }
+    if (iconStyle) {
+      kmlColor(properties, iconStyle, "icon");
+      numericProperty(properties, iconStyle, "scale", "icon-scale");
+      numericProperty(properties, iconStyle, "heading", "icon-heading");
+      const hotspot = get1(iconStyle, "hotSpot");
+      if (hotspot) {
+        const left = parseFloat(hotspot.getAttribute("x"));
+        const top = parseFloat(hotspot.getAttribute("y"));
+        if (!isNaN(left) && !isNaN(top))
+          properties["icon-offset"] = [left, top];
+      }
+      const icon = get1(iconStyle, "Icon");
+      if (icon) {
+        const href = nodeVal(get1(icon, "href"));
+        if (href)
+          properties.icon = href;
+      }
+    }
+    if (labelStyle) {
+      kmlColor(properties, labelStyle, "label");
+      numericProperty(properties, labelStyle, "scale", "label-scale");
+    }
+    if (lineStyle) {
+      kmlColor(properties, lineStyle, "stroke");
+      numericProperty(properties, lineStyle, "width", "stroke-width");
+    }
+    if (polyStyle) {
+      kmlColor(properties, polyStyle, "fill");
+      const fill = nodeVal(get1(polyStyle, "fill"));
+      const outline = nodeVal(get1(polyStyle, "outline"));
+      if (fill)
+        properties["fill-opacity"] = fill === "1" ? properties["fill-opacity"] || 1 : 0;
+      if (outline)
+        properties["stroke-opacity"] = outline === "1" ? properties["stroke-opacity"] || 1 : 0;
+    }
+    if (extendedData) {
+      const datas = extendedData.getElementsByTagName("Data"), simpleDatas = extendedData.getElementsByTagName("SimpleData");
+      for (i = 0; i < datas.length; i++) {
+        properties[datas[i].getAttribute("name")] = nodeVal(get1(datas[i], "value"));
+      }
+      for (i = 0; i < simpleDatas.length; i++) {
+        properties[simpleDatas[i].getAttribute("name")] = nodeVal(simpleDatas[i]);
+      }
+    }
+    if (visibility) {
+      properties.visibility = nodeVal(visibility);
+    }
+    if (geomsAndTimes.coordTimes.length) {
+      properties.coordinateProperties = {
+        times: geomsAndTimes.coordTimes.length === 1 ? geomsAndTimes.coordTimes[0] : geomsAndTimes.coordTimes
+      };
+    }
+    const feature = {
+      type: "Feature",
+      geometry: geomsAndTimes.geoms.length === 0 ? null : geomsAndTimes.geoms.length === 1 ? geomsAndTimes.geoms[0] : {
+        type: "GeometryCollection",
+        geometries: geomsAndTimes.geoms
+      },
+      properties
+    };
+    if (root.getAttribute("id"))
+      feature.id = root.getAttribute("id");
+    return feature;
+  }
+  function* kmlGen(doc) {
+    const styleIndex = {};
+    const styleByHash = {};
+    const styleMapIndex = {};
+    const placemarks = doc.getElementsByTagName("Placemark");
+    const styles = doc.getElementsByTagName("Style");
+    const styleMaps = doc.getElementsByTagName("StyleMap");
+    for (let k = 0; k < styles.length; k++) {
+      const style = styles[k];
+      const hash = okhash(xml2str(style)).toString(16);
+      let id = style.getAttribute("id");
+      if (!id && style.parentNode.tagName.replace("gx:", "") === "CascadingStyle") {
+        id = style.parentNode.getAttribute("kml:id") || style.parentNode.getAttribute("id");
+      }
+      styleIndex["#" + id] = hash;
+      styleByHash[hash] = style;
+    }
+    for (let l = 0; l < styleMaps.length; l++) {
+      styleIndex["#" + styleMaps[l].getAttribute("id")] = okhash(xml2str(styleMaps[l])).toString(16);
+      const pairs = styleMaps[l].getElementsByTagName("Pair");
+      const pairsMap = {};
+      for (let m = 0; m < pairs.length; m++) {
+        pairsMap[nodeVal(get1(pairs[m], "key"))] = nodeVal(get1(pairs[m], "styleUrl"));
+      }
+      styleMapIndex["#" + styleMaps[l].getAttribute("id")] = pairsMap;
+    }
+    for (let j = 0; j < placemarks.length; j++) {
+      const feature = getPlacemark(placemarks[j], styleIndex, styleMapIndex, styleByHash);
+      if (feature)
+        yield feature;
+    }
+  }
+  function kml(doc) {
+    return {
+      type: "FeatureCollection",
+      features: Array.from(kmlGen(doc))
+    };
+  }
+  var EXTENSIONS_NS, TRACKPOINT_ATTRIBUTES, LAP_ATTRIBUTES, removeSpace, trimSpace, splitSpace, geotypes;
+  var init_togeojson_es = __esm({
+    "../../node_modules/@tmcw/togeojson/dist/togeojson.es.js"() {
+      EXTENSIONS_NS = "http://www.garmin.com/xmlschemas/ActivityExtension/v2";
+      TRACKPOINT_ATTRIBUTES = [
+        ["heartRate", "heartRates"],
+        ["Cadence", "cadences"],
+        ["Speed", "speeds"],
+        ["Watts", "watts"]
+      ];
+      LAP_ATTRIBUTES = [
+        ["TotalTimeSeconds", "totalTimeSeconds"],
+        ["DistanceMeters", "distanceMeters"],
+        ["MaximumSpeed", "maxSpeed"],
+        ["AverageHeartRateBpm", "avgHeartRate"],
+        ["MaximumHeartRateBpm", "maxHeartRate"],
+        ["AvgSpeed", "avgSpeed"],
+        ["AvgWatts", "avgWatts"],
+        ["MaxWatts", "maxWatts"]
+      ];
+      removeSpace = /\s*/g;
+      trimSpace = /^\s*|\s*$/g;
+      splitSpace = /\s+/;
+      geotypes = ["Polygon", "LineString", "Point", "Track", "gx:Track"];
+    }
+  });
+
+  // ../../node_modules/@xmldom/xmldom/lib/conventions.js
+  var require_conventions = __commonJS({
+    "../../node_modules/@xmldom/xmldom/lib/conventions.js"(exports) {
+      "use strict";
+      function find(list, predicate, ac) {
+        if (ac === void 0) {
+          ac = Array.prototype;
+        }
+        if (list && typeof ac.find === "function") {
+          return ac.find.call(list, predicate);
+        }
+        for (var i = 0; i < list.length; i++) {
+          if (Object.prototype.hasOwnProperty.call(list, i)) {
+            var item = list[i];
+            if (predicate.call(void 0, item, i, list)) {
+              return item;
             }
-          return a2;
+          }
         }
-        function l(e2) {
-          const t2 = a(e2, "rtept");
-          if (t2)
-            return { type: "Feature", properties: Object.assign(r(e2), o(n(e2, "extensions")), { _gpxType: "rte" }), geometry: { type: "LineString", coordinates: t2.line } };
+      }
+      function freeze(object, oc) {
+        if (oc === void 0) {
+          oc = Object;
         }
-        function a(e2, t2) {
-          const n2 = e2.getElementsByTagName(t2);
-          if (n2.length < 2)
-            return;
-          const o2 = [], s2 = [], r2 = {};
-          for (let e3 = 0; e3 < n2.length; e3++) {
-            const t3 = i(n2[e3]);
-            o2.push(t3.coordinates), t3.time && s2.push(t3.time);
-            for (let o3 = 0; o3 < t3.extendedValues.length; o3++) {
-              const [s3, i2] = t3.extendedValues[o3], l2 = s3 === "heart" ? s3 : s3 + "s";
-              r2[l2] || (r2[l2] = Array(n2.length).fill(null)), r2[l2][e3] = i2;
+        return oc && typeof oc.freeze === "function" ? oc.freeze(object) : object;
+      }
+      var MIME_TYPE = freeze({
+        HTML: "text/html",
+        isHTML: function(value) {
+          return value === MIME_TYPE.HTML;
+        },
+        XML_APPLICATION: "application/xml",
+        XML_TEXT: "text/xml",
+        XML_XHTML_APPLICATION: "application/xhtml+xml",
+        XML_SVG_IMAGE: "image/svg+xml"
+      });
+      var NAMESPACE = freeze({
+        HTML: "http://www.w3.org/1999/xhtml",
+        isHTML: function(uri) {
+          return uri === NAMESPACE.HTML;
+        },
+        SVG: "http://www.w3.org/2000/svg",
+        XML: "http://www.w3.org/XML/1998/namespace",
+        XMLNS: "http://www.w3.org/2000/xmlns/"
+      });
+      exports.find = find;
+      exports.freeze = freeze;
+      exports.MIME_TYPE = MIME_TYPE;
+      exports.NAMESPACE = NAMESPACE;
+    }
+  });
+
+  // ../../node_modules/@xmldom/xmldom/lib/dom.js
+  var require_dom = __commonJS({
+    "../../node_modules/@xmldom/xmldom/lib/dom.js"(exports) {
+      var conventions = require_conventions();
+      var find = conventions.find;
+      var NAMESPACE = conventions.NAMESPACE;
+      function notEmptyString(input) {
+        return input !== "";
+      }
+      function splitOnASCIIWhitespace(input) {
+        return input ? input.split(/[\t\n\f\r ]+/).filter(notEmptyString) : [];
+      }
+      function orderedSetReducer(current, element) {
+        if (!current.hasOwnProperty(element)) {
+          current[element] = true;
+        }
+        return current;
+      }
+      function toOrderedSet(input) {
+        if (!input)
+          return [];
+        var list = splitOnASCIIWhitespace(input);
+        return Object.keys(list.reduce(orderedSetReducer, {}));
+      }
+      function arrayIncludes(list) {
+        return function(element) {
+          return list && list.indexOf(element) !== -1;
+        };
+      }
+      function copy2(src, dest) {
+        for (var p in src) {
+          if (Object.prototype.hasOwnProperty.call(src, p)) {
+            dest[p] = src[p];
+          }
+        }
+      }
+      function _extends(Class, Super) {
+        var pt = Class.prototype;
+        if (!(pt instanceof Super)) {
+          let t2 = function() {
+          };
+          var t = t2;
+          ;
+          t2.prototype = Super.prototype;
+          t2 = new t2();
+          copy2(pt, t2);
+          Class.prototype = pt = t2;
+        }
+        if (pt.constructor != Class) {
+          if (typeof Class != "function") {
+            console.error("unknown Class:" + Class);
+          }
+          pt.constructor = Class;
+        }
+      }
+      var NodeType = {};
+      var ELEMENT_NODE = NodeType.ELEMENT_NODE = 1;
+      var ATTRIBUTE_NODE = NodeType.ATTRIBUTE_NODE = 2;
+      var TEXT_NODE = NodeType.TEXT_NODE = 3;
+      var CDATA_SECTION_NODE = NodeType.CDATA_SECTION_NODE = 4;
+      var ENTITY_REFERENCE_NODE = NodeType.ENTITY_REFERENCE_NODE = 5;
+      var ENTITY_NODE = NodeType.ENTITY_NODE = 6;
+      var PROCESSING_INSTRUCTION_NODE = NodeType.PROCESSING_INSTRUCTION_NODE = 7;
+      var COMMENT_NODE = NodeType.COMMENT_NODE = 8;
+      var DOCUMENT_NODE = NodeType.DOCUMENT_NODE = 9;
+      var DOCUMENT_TYPE_NODE = NodeType.DOCUMENT_TYPE_NODE = 10;
+      var DOCUMENT_FRAGMENT_NODE = NodeType.DOCUMENT_FRAGMENT_NODE = 11;
+      var NOTATION_NODE = NodeType.NOTATION_NODE = 12;
+      var ExceptionCode = {};
+      var ExceptionMessage = {};
+      var INDEX_SIZE_ERR = ExceptionCode.INDEX_SIZE_ERR = (ExceptionMessage[1] = "Index size error", 1);
+      var DOMSTRING_SIZE_ERR = ExceptionCode.DOMSTRING_SIZE_ERR = (ExceptionMessage[2] = "DOMString size error", 2);
+      var HIERARCHY_REQUEST_ERR = ExceptionCode.HIERARCHY_REQUEST_ERR = (ExceptionMessage[3] = "Hierarchy request error", 3);
+      var WRONG_DOCUMENT_ERR = ExceptionCode.WRONG_DOCUMENT_ERR = (ExceptionMessage[4] = "Wrong document", 4);
+      var INVALID_CHARACTER_ERR = ExceptionCode.INVALID_CHARACTER_ERR = (ExceptionMessage[5] = "Invalid character", 5);
+      var NO_DATA_ALLOWED_ERR = ExceptionCode.NO_DATA_ALLOWED_ERR = (ExceptionMessage[6] = "No data allowed", 6);
+      var NO_MODIFICATION_ALLOWED_ERR = ExceptionCode.NO_MODIFICATION_ALLOWED_ERR = (ExceptionMessage[7] = "No modification allowed", 7);
+      var NOT_FOUND_ERR = ExceptionCode.NOT_FOUND_ERR = (ExceptionMessage[8] = "Not found", 8);
+      var NOT_SUPPORTED_ERR = ExceptionCode.NOT_SUPPORTED_ERR = (ExceptionMessage[9] = "Not supported", 9);
+      var INUSE_ATTRIBUTE_ERR = ExceptionCode.INUSE_ATTRIBUTE_ERR = (ExceptionMessage[10] = "Attribute in use", 10);
+      var INVALID_STATE_ERR = ExceptionCode.INVALID_STATE_ERR = (ExceptionMessage[11] = "Invalid state", 11);
+      var SYNTAX_ERR = ExceptionCode.SYNTAX_ERR = (ExceptionMessage[12] = "Syntax error", 12);
+      var INVALID_MODIFICATION_ERR = ExceptionCode.INVALID_MODIFICATION_ERR = (ExceptionMessage[13] = "Invalid modification", 13);
+      var NAMESPACE_ERR = ExceptionCode.NAMESPACE_ERR = (ExceptionMessage[14] = "Invalid namespace", 14);
+      var INVALID_ACCESS_ERR = ExceptionCode.INVALID_ACCESS_ERR = (ExceptionMessage[15] = "Invalid access", 15);
+      function DOMException(code, message) {
+        if (message instanceof Error) {
+          var error = message;
+        } else {
+          error = this;
+          Error.call(this, ExceptionMessage[code]);
+          this.message = ExceptionMessage[code];
+          if (Error.captureStackTrace)
+            Error.captureStackTrace(this, DOMException);
+        }
+        error.code = code;
+        if (message)
+          this.message = this.message + ": " + message;
+        return error;
+      }
+      DOMException.prototype = Error.prototype;
+      copy2(ExceptionCode, DOMException);
+      function NodeList() {
+      }
+      NodeList.prototype = {
+        length: 0,
+        item: function(index) {
+          return this[index] || null;
+        },
+        toString: function(isHTML, nodeFilter) {
+          for (var buf = [], i = 0; i < this.length; i++) {
+            serializeToString(this[i], buf, isHTML, nodeFilter);
+          }
+          return buf.join("");
+        },
+        filter: function(predicate) {
+          return Array.prototype.filter.call(this, predicate);
+        },
+        indexOf: function(item) {
+          return Array.prototype.indexOf.call(this, item);
+        }
+      };
+      function LiveNodeList(node, refresh) {
+        this._node = node;
+        this._refresh = refresh;
+        _updateLiveList(this);
+      }
+      function _updateLiveList(list) {
+        var inc = list._node._inc || list._node.ownerDocument._inc;
+        if (list._inc != inc) {
+          var ls = list._refresh(list._node);
+          __set__(list, "length", ls.length);
+          copy2(ls, list);
+          list._inc = inc;
+        }
+      }
+      LiveNodeList.prototype.item = function(i) {
+        _updateLiveList(this);
+        return this[i];
+      };
+      _extends(LiveNodeList, NodeList);
+      function NamedNodeMap() {
+      }
+      function _findNodeIndex(list, node) {
+        var i = list.length;
+        while (i--) {
+          if (list[i] === node) {
+            return i;
+          }
+        }
+      }
+      function _addNamedNode(el, list, newAttr, oldAttr) {
+        if (oldAttr) {
+          list[_findNodeIndex(list, oldAttr)] = newAttr;
+        } else {
+          list[list.length++] = newAttr;
+        }
+        if (el) {
+          newAttr.ownerElement = el;
+          var doc = el.ownerDocument;
+          if (doc) {
+            oldAttr && _onRemoveAttribute(doc, el, oldAttr);
+            _onAddAttribute(doc, el, newAttr);
+          }
+        }
+      }
+      function _removeNamedNode(el, list, attr) {
+        var i = _findNodeIndex(list, attr);
+        if (i >= 0) {
+          var lastIndex = list.length - 1;
+          while (i < lastIndex) {
+            list[i] = list[++i];
+          }
+          list.length = lastIndex;
+          if (el) {
+            var doc = el.ownerDocument;
+            if (doc) {
+              _onRemoveAttribute(doc, el, attr);
+              attr.ownerElement = null;
             }
           }
-          return { line: o2, times: s2, extendedValues: r2 };
+        } else {
+          throw new DOMException(NOT_FOUND_ERR, new Error(el.tagName + "@" + attr));
         }
-        function c(e2) {
-          const t2 = e2.getElementsByTagName("trkseg"), s2 = [], i2 = [], l2 = [];
-          for (let e3 = 0; e3 < t2.length; e3++) {
-            const n2 = a(t2[e3], "trkpt");
-            n2 && (l2.push(n2), n2.times && n2.times.length && i2.push(n2.times));
+      }
+      NamedNodeMap.prototype = {
+        length: 0,
+        item: NodeList.prototype.item,
+        getNamedItem: function(key) {
+          var i = this.length;
+          while (i--) {
+            var attr = this[i];
+            if (attr.nodeName == key) {
+              return attr;
+            }
           }
-          if (l2.length === 0)
-            return;
-          const c2 = l2.length > 1, g2 = Object.assign(r(e2), o(n(e2, "extensions")), { _gpxType: "trk" }, i2.length ? { coordinateProperties: { times: c2 ? i2 : i2[0] } } : {});
-          for (let e3 = 0; e3 < l2.length; e3++) {
-            const t3 = l2[e3];
-            s2.push(t3.line);
-            for (const [n2, o2] of Object.entries(t3.extendedValues)) {
-              let t4 = g2;
-              n2 === "heart" && (g2.coordinateProperties || (g2.coordinateProperties = {}), t4 = g2.coordinateProperties), c2 ? (t4[n2] || (t4[n2] = l2.map((e4) => new Array(e4.line.length).fill(null))), t4[n2][e3] = o2) : t4[n2] = o2;
+        },
+        setNamedItem: function(attr) {
+          var el = attr.ownerElement;
+          if (el && el != this._ownerElement) {
+            throw new DOMException(INUSE_ATTRIBUTE_ERR);
+          }
+          var oldAttr = this.getNamedItem(attr.nodeName);
+          _addNamedNode(this._ownerElement, this, attr, oldAttr);
+          return oldAttr;
+        },
+        setNamedItemNS: function(attr) {
+          var el = attr.ownerElement, oldAttr;
+          if (el && el != this._ownerElement) {
+            throw new DOMException(INUSE_ATTRIBUTE_ERR);
+          }
+          oldAttr = this.getNamedItemNS(attr.namespaceURI, attr.localName);
+          _addNamedNode(this._ownerElement, this, attr, oldAttr);
+          return oldAttr;
+        },
+        removeNamedItem: function(key) {
+          var attr = this.getNamedItem(key);
+          _removeNamedNode(this._ownerElement, this, attr);
+          return attr;
+        },
+        removeNamedItemNS: function(namespaceURI, localName) {
+          var attr = this.getNamedItemNS(namespaceURI, localName);
+          _removeNamedNode(this._ownerElement, this, attr);
+          return attr;
+        },
+        getNamedItemNS: function(namespaceURI, localName) {
+          var i = this.length;
+          while (i--) {
+            var node = this[i];
+            if (node.localName == localName && node.namespaceURI == namespaceURI) {
+              return node;
             }
           }
-          return { type: "Feature", properties: g2, geometry: c2 ? { type: "MultiLineString", coordinates: s2 } : { type: "LineString", coordinates: s2[0] } };
-        }
-        function* g(e2) {
-          const t2 = e2.getElementsByTagName("trk"), n2 = e2.getElementsByTagName("rte"), o2 = e2.getElementsByTagName("wpt");
-          for (let e3 = 0; e3 < t2.length; e3++) {
-            const n3 = c(t2[e3]);
-            n3 && (yield n3);
-          }
-          for (let e3 = 0; e3 < n2.length; e3++) {
-            const t3 = l(n2[e3]);
-            t3 && (yield t3);
-          }
-          for (let e3 = 0; e3 < o2.length; e3++)
-            yield (a2 = o2[e3], { type: "Feature", properties: Object.assign(r(a2), s(a2, ["sym"])), geometry: { type: "Point", coordinates: i(a2).coordinates } });
-          var a2;
-        }
-        const u = [["heartRate", "heartRates"], ["Cadence", "cadences"], ["Speed", "speeds"], ["Watts", "watts"]], m = [["TotalTimeSeconds", "totalTimeSeconds"], ["DistanceMeters", "distanceMeters"], ["MaximumSpeed", "maxSpeed"], ["AverageHeartRateBpm", "avgHeartRate"], ["MaximumHeartRateBpm", "maxHeartRate"], ["AvgSpeed", "avgSpeed"], ["AvgWatts", "avgWatts"], ["MaxWatts", "maxWatts"]];
-        function p(e2, o2) {
-          const s2 = [];
-          for (const [r2, i2] of o2) {
-            let o3 = n(e2, r2);
-            if (!o3) {
-              const t2 = e2.getElementsByTagNameNS("http://www.garmin.com/xmlschemas/ActivityExtension/v2", r2);
-              t2.length && (o3 = t2[0]);
+          return null;
+        }
+      };
+      function DOMImplementation() {
+      }
+      DOMImplementation.prototype = {
+        hasFeature: function(feature, version) {
+          return true;
+        },
+        createDocument: function(namespaceURI, qualifiedName, doctype) {
+          var doc = new Document();
+          doc.implementation = this;
+          doc.childNodes = new NodeList();
+          doc.doctype = doctype || null;
+          if (doctype) {
+            doc.appendChild(doctype);
+          }
+          if (qualifiedName) {
+            var root = doc.createElementNS(namespaceURI, qualifiedName);
+            doc.appendChild(root);
+          }
+          return doc;
+        },
+        createDocumentType: function(qualifiedName, publicId, systemId) {
+          var node = new DocumentType();
+          node.name = qualifiedName;
+          node.nodeName = qualifiedName;
+          node.publicId = publicId || "";
+          node.systemId = systemId || "";
+          return node;
+        }
+      };
+      function Node2() {
+      }
+      Node2.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,
+        insertBefore: function(newChild, refChild) {
+          return _insertBefore(this, newChild, refChild);
+        },
+        replaceChild: function(newChild, oldChild) {
+          _insertBefore(this, newChild, oldChild, assertPreReplacementValidityInDocument);
+          if (oldChild) {
+            this.removeChild(oldChild);
+          }
+        },
+        removeChild: function(oldChild) {
+          return _removeChild(this, oldChild);
+        },
+        appendChild: function(newChild) {
+          return this.insertBefore(newChild, null);
+        },
+        hasChildNodes: function() {
+          return this.firstChild != null;
+        },
+        cloneNode: function(deep) {
+          return cloneNode(this.ownerDocument || this, this, deep);
+        },
+        normalize: function() {
+          var child = this.firstChild;
+          while (child) {
+            var next = child.nextSibling;
+            if (next && next.nodeType == TEXT_NODE && child.nodeType == TEXT_NODE) {
+              this.removeChild(next);
+              child.appendData(next.data);
+            } else {
+              child.normalize();
+              child = next;
             }
-            const l2 = parseFloat(t(o3));
-            isNaN(l2) || s2.push([i2, l2]);
-          }
-          return s2;
-        }
-        function h(e2) {
-          const o2 = t(n(e2, "LongitudeDegrees")), s2 = t(n(e2, "LatitudeDegrees"));
-          if (!o2.length || !s2.length)
-            return null;
-          const r2 = [parseFloat(o2), parseFloat(s2)], i2 = n(e2, "AltitudeMeters"), l2 = n(e2, "HeartRateBpm"), a2 = n(e2, "Time");
-          let c2;
-          return i2 && (c2 = parseFloat(t(i2)), isNaN(c2) || r2.push(c2)), { coordinates: r2, time: a2 ? t(a2) : null, heartRate: l2 ? parseFloat(t(l2)) : null, extensions: p(e2, u) };
-        }
-        function f(e2, t2) {
-          const n2 = e2.getElementsByTagName(t2), o2 = [], s2 = [], r2 = [];
-          if (n2.length < 2)
-            return null;
-          const i2 = { extendedProperties: {} };
-          for (let e3 = 0; e3 < n2.length; e3++) {
-            const t3 = h(n2[e3]);
-            if (t3 !== null) {
-              o2.push(t3.coordinates), t3.time && s2.push(t3.time), t3.heartRate && r2.push(t3.heartRate);
-              for (const [o3, s3] of t3.extensions)
-                i2.extendedProperties[o3] || (i2.extendedProperties[o3] = Array(n2.length).fill(null)), i2.extendedProperties[o3][e3] = s3;
+          }
+        },
+        isSupported: function(feature, version) {
+          return this.ownerDocument.implementation.hasFeature(feature, version);
+        },
+        hasAttributes: function() {
+          return this.attributes.length > 0;
+        },
+        lookupPrefix: function(namespaceURI) {
+          var el = this;
+          while (el) {
+            var map = el._nsMap;
+            if (map) {
+              for (var n in map) {
+                if (Object.prototype.hasOwnProperty.call(map, n) && map[n] === namespaceURI) {
+                  return n;
+                }
+              }
             }
+            el = el.nodeType == ATTRIBUTE_NODE ? el.ownerDocument : el.parentNode;
           }
-          return Object.assign(i2, { line: o2, times: s2, heartRates: r2 });
-        }
-        function d(e2) {
-          const o2 = e2.getElementsByTagName("Track"), s2 = [], r2 = [], i2 = [], l2 = [];
-          let a2;
-          const c2 = function(e3) {
-            const t2 = {};
-            for (const [n2, o3] of e3)
-              t2[n2] = o3;
-            return t2;
-          }(p(e2, m)), g2 = n(e2, "Name");
-          g2 && (c2.name = t(g2));
-          for (let e3 = 0; e3 < o2.length; e3++)
-            a2 = f(o2[e3], "Trackpoint"), a2 && (s2.push(a2.line), a2.times.length && r2.push(a2.times), a2.heartRates.length && i2.push(a2.heartRates), l2.push(a2.extendedProperties));
-          for (let e3 = 0; e3 < l2.length; e3++) {
-            const t2 = l2[e3];
-            for (const n2 in t2)
-              o2.length === 1 ? c2[n2] = a2.extendedProperties[n2] : (c2[n2] || (c2[n2] = s2.map((e4) => Array(e4.length).fill(null))), c2[n2][e3] = t2[n2]);
-          }
-          if (s2.length !== 0)
-            return (r2.length || i2.length) && (c2.coordinateProperties = Object.assign(r2.length ? { times: s2.length === 1 ? r2[0] : r2 } : {}, i2.length ? { heart: s2.length === 1 ? i2[0] : i2 } : {})), { type: "Feature", properties: c2, geometry: { type: s2.length === 1 ? "LineString" : "MultiLineString", coordinates: s2.length === 1 ? s2[0] : s2 } };
-        }
-        function* y(e2) {
-          const t2 = e2.getElementsByTagName("Lap");
-          for (let e3 = 0; e3 < t2.length; e3++) {
-            const n3 = d(t2[e3]);
-            n3 && (yield n3);
-          }
-          const n2 = e2.getElementsByTagName("Courses");
-          for (let e3 = 0; e3 < n2.length; e3++) {
-            const t3 = d(n2[e3]);
-            t3 && (yield t3);
-          }
-        }
-        const N = /\s*/g, x = /^\s*|\s*$/g, T = /\s+/;
-        function b(e2) {
-          if (!e2 || !e2.length)
-            return 0;
-          let t2 = 0;
-          for (let n2 = 0; n2 < e2.length; n2++)
-            t2 = (t2 << 5) - t2 + e2.charCodeAt(n2) | 0;
-          return t2;
-        }
-        function S(e2) {
-          return e2.replace(N, "").split(",").map(parseFloat);
-        }
-        function k(e2) {
-          return e2.replace(x, "").split(T).map(S);
-        }
-        function A(e2) {
-          if (e2.xml !== void 0)
-            return e2.xml;
-          if (e2.tagName) {
-            let t2 = e2.tagName;
-            for (let n2 = 0; n2 < e2.attributes.length; n2++)
-              t2 += e2.attributes[n2].name + e2.attributes[n2].value;
-            for (let n2 = 0; n2 < e2.childNodes.length; n2++)
-              t2 += A(e2.childNodes[n2]);
-            return t2;
-          }
-          return e2.nodeName === "#text" ? (e2.nodeValue || e2.value || "").trim() : e2.nodeName === "#cdata-section" ? e2.nodeValue : "";
-        }
-        const B = ["Polygon", "LineString", "Point", "Track", "gx:Track"];
-        function E(e2, o2, s2) {
-          let r2 = t(n(o2, "color")) || "";
-          const i2 = s2 == "stroke" || s2 === "fill" ? s2 : s2 + "-color";
-          r2.substr(0, 1) === "#" && (r2 = r2.substr(1)), r2.length === 6 || r2.length === 3 ? e2[i2] = r2 : r2.length === 8 && (e2[s2 + "-opacity"] = parseInt(r2.substr(0, 2), 16) / 255, e2[i2] = "#" + r2.substr(6, 2) + r2.substr(4, 2) + r2.substr(2, 2));
-        }
-        function F(e2, o2, s2, r2) {
-          const i2 = parseFloat(t(n(o2, s2)));
-          isNaN(i2) || (e2[r2] = i2);
-        }
-        function P(e2) {
-          let n2 = e2.getElementsByTagName("coord");
-          const o2 = [], s2 = [];
-          n2.length === 0 && (n2 = e2.getElementsByTagName("gx:coord"));
-          for (let e3 = 0; e3 < n2.length; e3++)
-            o2.push(t(n2[e3]).split(" ").map(parseFloat));
-          const r2 = e2.getElementsByTagName("when");
-          for (let e3 = 0; e3 < r2.length; e3++)
-            s2.push(t(r2[e3]));
-          return { coords: o2, times: s2 };
-        }
-        function v(e2) {
-          let o2, s2, r2, i2, l2;
-          const a2 = [], c2 = [];
-          if (n(e2, "MultiGeometry"))
-            return v(n(e2, "MultiGeometry"));
-          if (n(e2, "MultiTrack"))
-            return v(n(e2, "MultiTrack"));
-          if (n(e2, "gx:MultiTrack"))
-            return v(n(e2, "gx:MultiTrack"));
-          for (r2 = 0; r2 < B.length; r2++)
-            if (s2 = e2.getElementsByTagName(B[r2]), s2) {
-              for (i2 = 0; i2 < s2.length; i2++)
-                if (o2 = s2[i2], B[r2] === "Point")
-                  a2.push({ type: "Point", coordinates: S(t(n(o2, "coordinates"))) });
-                else if (B[r2] === "LineString")
-                  a2.push({ type: "LineString", coordinates: k(t(n(o2, "coordinates"))) });
-                else if (B[r2] === "Polygon") {
-                  const e3 = o2.getElementsByTagName("LinearRing"), s3 = [];
-                  for (l2 = 0; l2 < e3.length; l2++)
-                    s3.push(k(t(n(e3[l2], "coordinates"))));
-                  a2.push({ type: "Polygon", coordinates: s3 });
-                } else if (B[r2] === "Track" || B[r2] === "gx:Track") {
-                  const e3 = P(o2);
-                  a2.push({ type: "LineString", coordinates: e3.coords }), e3.times.length && c2.push(e3.times);
+          return null;
+        },
+        lookupNamespaceURI: function(prefix) {
+          var el = this;
+          while (el) {
+            var map = el._nsMap;
+            if (map) {
+              if (prefix in map) {
+                if (Object.prototype.hasOwnProperty.call(map, prefix)) {
+                  return map[prefix];
                 }
+              }
             }
-          return { geoms: a2, coordTimes: c2 };
-        }
-        function L(e2, o2, s2, r2) {
-          const i2 = v(e2);
-          let l2;
-          const a2 = {}, c2 = t(n(e2, "name")), g2 = t(n(e2, "address"));
-          let u2 = t(n(e2, "styleUrl"));
-          const m2 = t(n(e2, "description")), p2 = n(e2, "TimeSpan"), h2 = n(e2, "TimeStamp"), f2 = n(e2, "ExtendedData");
-          let d2 = n(e2, "IconStyle"), y2 = n(e2, "LabelStyle"), N2 = n(e2, "LineStyle"), x2 = n(e2, "PolyStyle");
-          const T2 = n(e2, "visibility");
-          if (c2 && (a2.name = c2), g2 && (a2.address = g2), u2) {
-            u2[0] !== "#" && (u2 = "#" + u2), a2.styleUrl = u2, o2[u2] && (a2.styleHash = o2[u2]), s2[u2] && (a2.styleMapHash = s2[u2], a2.styleHash = o2[s2[u2].normal]);
-            const e3 = r2[a2.styleHash];
-            e3 && (d2 || (d2 = n(e3, "IconStyle")), y2 || (y2 = n(e3, "LabelStyle")), N2 || (N2 = n(e3, "LineStyle")), x2 || (x2 = n(e3, "PolyStyle")));
-          }
-          if (m2 && (a2.description = m2), p2) {
-            const e3 = t(n(p2, "begin")), o3 = t(n(p2, "end"));
-            a2.timespan = { begin: e3, end: o3 };
-          }
-          if (h2 && (a2.timestamp = t(n(h2, "when"))), d2) {
-            E(a2, d2, "icon"), F(a2, d2, "scale", "icon-scale"), F(a2, d2, "heading", "icon-heading");
-            const e3 = n(d2, "hotSpot");
-            if (e3) {
-              const t2 = parseFloat(e3.getAttribute("x")), n2 = parseFloat(e3.getAttribute("y"));
-              isNaN(t2) || isNaN(n2) || (a2["icon-offset"] = [t2, n2]);
+            el = el.nodeType == ATTRIBUTE_NODE ? el.ownerDocument : el.parentNode;
+          }
+          return null;
+        },
+        isDefaultNamespace: function(namespaceURI) {
+          var prefix = this.lookupPrefix(namespaceURI);
+          return prefix == null;
+        }
+      };
+      function _xmlEncoder(c) {
+        return c == "<" && "&lt;" || c == ">" && "&gt;" || c == "&" && "&amp;" || c == '"' && "&quot;" || "&#" + c.charCodeAt() + ";";
+      }
+      copy2(NodeType, Node2);
+      copy2(NodeType, Node2.prototype);
+      function _visitNode(node, callback) {
+        if (callback(node)) {
+          return true;
+        }
+        if (node = node.firstChild) {
+          do {
+            if (_visitNode(node, callback)) {
+              return true;
             }
-            const o3 = n(d2, "Icon");
-            if (o3) {
-              const e4 = t(n(o3, "href"));
-              e4 && (a2.icon = e4);
+          } while (node = node.nextSibling);
+        }
+      }
+      function Document() {
+        this.ownerDocument = this;
+      }
+      function _onAddAttribute(doc, el, newAttr) {
+        doc && doc._inc++;
+        var ns = newAttr.namespaceURI;
+        if (ns === NAMESPACE.XMLNS) {
+          el._nsMap[newAttr.prefix ? newAttr.localName : ""] = newAttr.value;
+        }
+      }
+      function _onRemoveAttribute(doc, el, newAttr, remove) {
+        doc && doc._inc++;
+        var ns = newAttr.namespaceURI;
+        if (ns === NAMESPACE.XMLNS) {
+          delete el._nsMap[newAttr.prefix ? newAttr.localName : ""];
+        }
+      }
+      function _onUpdateChild(doc, el, newChild) {
+        if (doc && doc._inc) {
+          doc._inc++;
+          var cs = el.childNodes;
+          if (newChild) {
+            cs[cs.length++] = newChild;
+          } else {
+            var child = el.firstChild;
+            var i = 0;
+            while (child) {
+              cs[i++] = child;
+              child = child.nextSibling;
             }
+            cs.length = i;
+            delete cs[cs.length];
           }
-          if (y2 && (E(a2, y2, "label"), F(a2, y2, "scale", "label-scale")), N2 && (E(a2, N2, "stroke"), F(a2, N2, "width", "stroke-width")), x2) {
-            E(a2, x2, "fill");
-            const e3 = t(n(x2, "fill")), o3 = t(n(x2, "outline"));
-            e3 && (a2["fill-opacity"] = e3 === "1" ? a2["fill-opacity"] || 1 : 0), o3 && (a2["stroke-opacity"] = o3 === "1" ? a2["stroke-opacity"] || 1 : 0);
-          }
-          if (f2) {
-            const e3 = f2.getElementsByTagName("Data"), o3 = f2.getElementsByTagName("SimpleData");
-            for (l2 = 0; l2 < e3.length; l2++)
-              a2[e3[l2].getAttribute("name")] = t(n(e3[l2], "value"));
-            for (l2 = 0; l2 < o3.length; l2++)
-              a2[o3[l2].getAttribute("name")] = t(o3[l2]);
-          }
-          T2 && (a2.visibility = t(T2)), i2.coordTimes.length && (a2.coordinateProperties = { times: i2.coordTimes.length === 1 ? i2.coordTimes[0] : i2.coordTimes });
-          const b2 = { type: "Feature", geometry: i2.geoms.length === 0 ? null : i2.geoms.length === 1 ? i2.geoms[0] : { type: "GeometryCollection", geometries: i2.geoms }, properties: a2 };
-          return e2.getAttribute("id") && (b2.id = e2.getAttribute("id")), b2;
-        }
-        function* M(e2) {
-          const o2 = {}, s2 = {}, r2 = {}, i2 = e2.getElementsByTagName("Placemark"), l2 = e2.getElementsByTagName("Style"), a2 = e2.getElementsByTagName("StyleMap");
-          for (let e3 = 0; e3 < l2.length; e3++) {
-            const t2 = b(A(l2[e3])).toString(16);
-            o2["#" + l2[e3].getAttribute("id")] = t2, s2[t2] = l2[e3];
-          }
-          for (let e3 = 0; e3 < a2.length; e3++) {
-            o2["#" + a2[e3].getAttribute("id")] = b(A(a2[e3])).toString(16);
-            const s3 = a2[e3].getElementsByTagName("Pair"), i3 = {};
-            for (let e4 = 0; e4 < s3.length; e4++)
-              i3[t(n(s3[e4], "key"))] = t(n(s3[e4], "styleUrl"));
-            r2["#" + a2[e3].getAttribute("id")] = i3;
-          }
-          for (let e3 = 0; e3 < i2.length; e3++) {
-            const t2 = L(i2[e3], o2, r2, s2);
-            t2 && (yield t2);
-          }
-        }
-        e.gpx = function(e2) {
-          return { type: "FeatureCollection", features: Array.from(g(e2)) };
-        }, e.gpxGen = g, e.kml = function(e2) {
-          return { type: "FeatureCollection", features: Array.from(M(e2)) };
-        }, e.kmlGen = M, e.tcx = function(e2) {
-          return { type: "FeatureCollection", features: Array.from(y(e2)) };
-        }, e.tcxGen = y, Object.defineProperty(e, "__esModule", { value: true });
-      });
-    }
-  });
-
-  // src/gpx-loader.ts
-  function parseTextSync(text, options) {
-    const doc = new DOMParser().parseFromString(text, "text/xml");
-    const geojson = (0, import_togeojson.gpx)(doc);
-    switch (options?.gpx?.type) {
-      case "object-row-table":
-        return geojson.features;
-      default:
-    }
-    switch (options?.gis?.format) {
-      case "geojson":
-        return geojson;
-      case "binary":
-        return geojsonToBinary(geojson.features);
-      case "raw":
+        }
+      }
+      function _removeChild(parentNode, child) {
+        var previous = child.previousSibling;
+        var next = child.nextSibling;
+        if (previous) {
+          previous.nextSibling = next;
+        } else {
+          parentNode.firstChild = next;
+        }
+        if (next) {
+          next.previousSibling = previous;
+        } else {
+          parentNode.lastChild = previous;
+        }
+        child.parentNode = null;
+        child.previousSibling = null;
+        child.nextSibling = null;
+        _onUpdateChild(parentNode.ownerDocument, parentNode);
+        return child;
+      }
+      function hasValidParentNodeType(node) {
+        return node && (node.nodeType === Node2.DOCUMENT_NODE || node.nodeType === Node2.DOCUMENT_FRAGMENT_NODE || node.nodeType === Node2.ELEMENT_NODE);
+      }
+      function hasInsertableNodeType(node) {
+        return node && (isElementNode(node) || isTextNode(node) || isDocTypeNode(node) || node.nodeType === Node2.DOCUMENT_FRAGMENT_NODE || node.nodeType === Node2.COMMENT_NODE || node.nodeType === Node2.PROCESSING_INSTRUCTION_NODE);
+      }
+      function isDocTypeNode(node) {
+        return node && node.nodeType === Node2.DOCUMENT_TYPE_NODE;
+      }
+      function isElementNode(node) {
+        return node && node.nodeType === Node2.ELEMENT_NODE;
+      }
+      function isTextNode(node) {
+        return node && node.nodeType === Node2.TEXT_NODE;
+      }
+      function isElementInsertionPossible(doc, child) {
+        var parentChildNodes = doc.childNodes || [];
+        if (find(parentChildNodes, isElementNode) || isDocTypeNode(child)) {
+          return false;
+        }
+        var docTypeNode = find(parentChildNodes, isDocTypeNode);
+        return !(child && docTypeNode && parentChildNodes.indexOf(docTypeNode) > parentChildNodes.indexOf(child));
+      }
+      function isElementReplacementPossible(doc, child) {
+        var parentChildNodes = doc.childNodes || [];
+        function hasElementChildThatIsNotChild(node) {
+          return isElementNode(node) && node !== child;
+        }
+        if (find(parentChildNodes, hasElementChildThatIsNotChild)) {
+          return false;
+        }
+        var docTypeNode = find(parentChildNodes, isDocTypeNode);
+        return !(child && docTypeNode && parentChildNodes.indexOf(docTypeNode) > parentChildNodes.indexOf(child));
+      }
+      function assertPreInsertionValidity1to5(parent, node, child) {
+        if (!hasValidParentNodeType(parent)) {
+          throw new DOMException(HIERARCHY_REQUEST_ERR, "Unexpected parent node type " + parent.nodeType);
+        }
+        if (child && child.parentNode !== parent) {
+          throw new DOMException(NOT_FOUND_ERR, "child not in parent");
+        }
+        if (!hasInsertableNodeType(node) || isDocTypeNode(node) && parent.nodeType !== Node2.DOCUMENT_NODE) {
+          throw new DOMException(HIERARCHY_REQUEST_ERR, "Unexpected node type " + node.nodeType + " for parent node type " + parent.nodeType);
+        }
+      }
+      function assertPreInsertionValidityInDocument(parent, node, child) {
+        var parentChildNodes = parent.childNodes || [];
+        var nodeChildNodes = node.childNodes || [];
+        if (node.nodeType === Node2.DOCUMENT_FRAGMENT_NODE) {
+          var nodeChildElements = nodeChildNodes.filter(isElementNode);
+          if (nodeChildElements.length > 1 || find(nodeChildNodes, isTextNode)) {
+            throw new DOMException(HIERARCHY_REQUEST_ERR, "More than one element or text in fragment");
+          }
+          if (nodeChildElements.length === 1 && !isElementInsertionPossible(parent, child)) {
+            throw new DOMException(HIERARCHY_REQUEST_ERR, "Element in fragment can not be inserted before doctype");
+          }
+        }
+        if (isElementNode(node)) {
+          if (!isElementInsertionPossible(parent, child)) {
+            throw new DOMException(HIERARCHY_REQUEST_ERR, "Only one element can be added and only after doctype");
+          }
+        }
+        if (isDocTypeNode(node)) {
+          if (find(parentChildNodes, isDocTypeNode)) {
+            throw new DOMException(HIERARCHY_REQUEST_ERR, "Only one doctype is allowed");
+          }
+          var parentElementChild = find(parentChildNodes, isElementNode);
+          if (child && parentChildNodes.indexOf(parentElementChild) < parentChildNodes.indexOf(child)) {
+            throw new DOMException(HIERARCHY_REQUEST_ERR, "Doctype can only be inserted before an element");
+          }
+          if (!child && parentElementChild) {
+            throw new DOMException(HIERARCHY_REQUEST_ERR, "Doctype can not be appended since element is present");
+          }
+        }
+      }
+      function assertPreReplacementValidityInDocument(parent, node, child) {
+        var parentChildNodes = parent.childNodes || [];
+        var nodeChildNodes = node.childNodes || [];
+        if (node.nodeType === Node2.DOCUMENT_FRAGMENT_NODE) {
+          var nodeChildElements = nodeChildNodes.filter(isElementNode);
+          if (nodeChildElements.length > 1 || find(nodeChildNodes, isTextNode)) {
+            throw new DOMException(HIERARCHY_REQUEST_ERR, "More than one element or text in fragment");
+          }
+          if (nodeChildElements.length === 1 && !isElementReplacementPossible(parent, child)) {
+            throw new DOMException(HIERARCHY_REQUEST_ERR, "Element in fragment can not be inserted before doctype");
+          }
+        }
+        if (isElementNode(node)) {
+          if (!isElementReplacementPossible(parent, child)) {
+            throw new DOMException(HIERARCHY_REQUEST_ERR, "Only one element can be added and only after doctype");
+          }
+        }
+        if (isDocTypeNode(node)) {
+          let hasDoctypeChildThatIsNotChild2 = function(node2) {
+            return isDocTypeNode(node2) && node2 !== child;
+          };
+          var hasDoctypeChildThatIsNotChild = hasDoctypeChildThatIsNotChild2;
+          if (find(parentChildNodes, hasDoctypeChildThatIsNotChild2)) {
+            throw new DOMException(HIERARCHY_REQUEST_ERR, "Only one doctype is allowed");
+          }
+          var parentElementChild = find(parentChildNodes, isElementNode);
+          if (child && parentChildNodes.indexOf(parentElementChild) < parentChildNodes.indexOf(child)) {
+            throw new DOMException(HIERARCHY_REQUEST_ERR, "Doctype can only be inserted before an element");
+          }
+        }
+      }
+      function _insertBefore(parent, node, child, _inDocumentAssertion) {
+        assertPreInsertionValidity1to5(parent, node, child);
+        if (parent.nodeType === Node2.DOCUMENT_NODE) {
+          (_inDocumentAssertion || assertPreInsertionValidityInDocument)(parent, node, child);
+        }
+        var cp = node.parentNode;
+        if (cp) {
+          cp.removeChild(node);
+        }
+        if (node.nodeType === DOCUMENT_FRAGMENT_NODE) {
+          var newFirst = node.firstChild;
+          if (newFirst == null) {
+            return node;
+          }
+          var newLast = node.lastChild;
+        } else {
+          newFirst = newLast = node;
+        }
+        var pre = child ? child.previousSibling : parent.lastChild;
+        newFirst.previousSibling = pre;
+        newLast.nextSibling = child;
+        if (pre) {
+          pre.nextSibling = newFirst;
+        } else {
+          parent.firstChild = newFirst;
+        }
+        if (child == null) {
+          parent.lastChild = newLast;
+        } else {
+          child.previousSibling = newLast;
+        }
+        do {
+          newFirst.parentNode = parent;
+        } while (newFirst !== newLast && (newFirst = newFirst.nextSibling));
+        _onUpdateChild(parent.ownerDocument || parent, parent);
+        if (node.nodeType == DOCUMENT_FRAGMENT_NODE) {
+          node.firstChild = node.lastChild = null;
+        }
+        return node;
+      }
+      function _appendSingleChild(parentNode, newChild) {
+        if (newChild.parentNode) {
+          newChild.parentNode.removeChild(newChild);
+        }
+        newChild.parentNode = parentNode;
+        newChild.previousSibling = parentNode.lastChild;
+        newChild.nextSibling = null;
+        if (newChild.previousSibling) {
+          newChild.previousSibling.nextSibling = newChild;
+        } else {
+          parentNode.firstChild = newChild;
+        }
+        parentNode.lastChild = newChild;
+        _onUpdateChild(parentNode.ownerDocument, parentNode, newChild);
+        return newChild;
+      }
+      Document.prototype = {
+        nodeName: "#document",
+        nodeType: DOCUMENT_NODE,
+        doctype: null,
+        documentElement: null,
+        _inc: 1,
+        insertBefore: function(newChild, refChild) {
+          if (newChild.nodeType == DOCUMENT_FRAGMENT_NODE) {
+            var child = newChild.firstChild;
+            while (child) {
+              var next = child.nextSibling;
+              this.insertBefore(child, refChild);
+              child = next;
+            }
+            return newChild;
+          }
+          _insertBefore(this, newChild, refChild);
+          newChild.ownerDocument = this;
+          if (this.documentElement === null && newChild.nodeType === ELEMENT_NODE) {
+            this.documentElement = newChild;
+          }
+          return newChild;
+        },
+        removeChild: function(oldChild) {
+          if (this.documentElement == oldChild) {
+            this.documentElement = null;
+          }
+          return _removeChild(this, oldChild);
+        },
+        replaceChild: function(newChild, oldChild) {
+          _insertBefore(this, newChild, oldChild, assertPreReplacementValidityInDocument);
+          newChild.ownerDocument = this;
+          if (oldChild) {
+            this.removeChild(oldChild);
+          }
+          if (isElementNode(newChild)) {
+            this.documentElement = newChild;
+          }
+        },
+        importNode: function(importedNode, deep) {
+          return importNode(this, importedNode, deep);
+        },
+        getElementById: function(id) {
+          var rtv = null;
+          _visitNode(this.documentElement, function(node) {
+            if (node.nodeType == ELEMENT_NODE) {
+              if (node.getAttribute("id") == id) {
+                rtv = node;
+                return true;
+              }
+            }
+          });
+          return rtv;
+        },
+        getElementsByClassName: function(classNames) {
+          var classNamesSet = toOrderedSet(classNames);
+          return new LiveNodeList(this, function(base) {
+            var ls = [];
+            if (classNamesSet.length > 0) {
+              _visitNode(base.documentElement, function(node) {
+                if (node !== base && node.nodeType === ELEMENT_NODE) {
+                  var nodeClassNames = node.getAttribute("class");
+                  if (nodeClassNames) {
+                    var matches = classNames === nodeClassNames;
+                    if (!matches) {
+                      var nodeClassNamesSet = toOrderedSet(nodeClassNames);
+                      matches = classNamesSet.every(arrayIncludes(nodeClassNamesSet));
+                    }
+                    if (matches) {
+                      ls.push(node);
+                    }
+                  }
+                }
+              });
+            }
+            return ls;
+          });
+        },
+        createElement: function(tagName) {
+          var node = new Element();
+          node.ownerDocument = this;
+          node.nodeName = tagName;
+          node.tagName = tagName;
+          node.localName = tagName;
+          node.childNodes = new NodeList();
+          var attrs = node.attributes = new NamedNodeMap();
+          attrs._ownerElement = node;
+          return node;
+        },
+        createDocumentFragment: function() {
+          var node = new DocumentFragment();
+          node.ownerDocument = this;
+          node.childNodes = new NodeList();
+          return node;
+        },
+        createTextNode: function(data) {
+          var node = new Text();
+          node.ownerDocument = this;
+          node.appendData(data);
+          return node;
+        },
+        createComment: function(data) {
+          var node = new Comment();
+          node.ownerDocument = this;
+          node.appendData(data);
+          return node;
+        },
+        createCDATASection: function(data) {
+          var node = new CDATASection();
+          node.ownerDocument = this;
+          node.appendData(data);
+          return node;
+        },
+        createProcessingInstruction: function(target, data) {
+          var node = new ProcessingInstruction();
+          node.ownerDocument = this;
+          node.tagName = node.target = target;
+          node.nodeValue = node.data = data;
+          return node;
+        },
+        createAttribute: function(name) {
+          var node = new Attr();
+          node.ownerDocument = this;
+          node.name = name;
+          node.nodeName = name;
+          node.localName = name;
+          node.specified = true;
+          return node;
+        },
+        createEntityReference: function(name) {
+          var node = new EntityReference();
+          node.ownerDocument = this;
+          node.nodeName = name;
+          return node;
+        },
+        createElementNS: function(namespaceURI, qualifiedName) {
+          var node = new Element();
+          var pl = qualifiedName.split(":");
+          var attrs = node.attributes = new NamedNodeMap();
+          node.childNodes = new NodeList();
+          node.ownerDocument = this;
+          node.nodeName = qualifiedName;
+          node.tagName = qualifiedName;
+          node.namespaceURI = namespaceURI;
+          if (pl.length == 2) {
+            node.prefix = pl[0];
+            node.localName = pl[1];
+          } else {
+            node.localName = qualifiedName;
+          }
+          attrs._ownerElement = node;
+          return node;
+        },
+        createAttributeNS: function(namespaceURI, qualifiedName) {
+          var node = new Attr();
+          var pl = qualifiedName.split(":");
+          node.ownerDocument = this;
+          node.nodeName = qualifiedName;
+          node.name = qualifiedName;
+          node.namespaceURI = namespaceURI;
+          node.specified = true;
+          if (pl.length == 2) {
+            node.prefix = pl[0];
+            node.localName = pl[1];
+          } else {
+            node.localName = qualifiedName;
+          }
+          return node;
+        }
+      };
+      _extends(Document, Node2);
+      function Element() {
+        this._nsMap = {};
+      }
+      Element.prototype = {
+        nodeType: ELEMENT_NODE,
+        hasAttribute: function(name) {
+          return this.getAttributeNode(name) != null;
+        },
+        getAttribute: function(name) {
+          var attr = this.getAttributeNode(name);
+          return attr && attr.value || "";
+        },
+        getAttributeNode: function(name) {
+          return this.attributes.getNamedItem(name);
+        },
+        setAttribute: function(name, value) {
+          var attr = this.ownerDocument.createAttribute(name);
+          attr.value = attr.nodeValue = "" + value;
+          this.setAttributeNode(attr);
+        },
+        removeAttribute: function(name) {
+          var attr = this.getAttributeNode(name);
+          attr && this.removeAttributeNode(attr);
+        },
+        appendChild: function(newChild) {
+          if (newChild.nodeType === DOCUMENT_FRAGMENT_NODE) {
+            return this.insertBefore(newChild, null);
+          } else {
+            return _appendSingleChild(this, newChild);
+          }
+        },
+        setAttributeNode: function(newAttr) {
+          return this.attributes.setNamedItem(newAttr);
+        },
+        setAttributeNodeNS: function(newAttr) {
+          return this.attributes.setNamedItemNS(newAttr);
+        },
+        removeAttributeNode: function(oldAttr) {
+          return this.attributes.removeNamedItem(oldAttr.nodeName);
+        },
+        removeAttributeNS: function(namespaceURI, localName) {
+          var old = this.getAttributeNodeNS(namespaceURI, localName);
+          old && this.removeAttributeNode(old);
+        },
+        hasAttributeNS: function(namespaceURI, localName) {
+          return this.getAttributeNodeNS(namespaceURI, localName) != null;
+        },
+        getAttributeNS: function(namespaceURI, localName) {
+          var attr = this.getAttributeNodeNS(namespaceURI, localName);
+          return attr && attr.value || "";
+        },
+        setAttributeNS: function(namespaceURI, qualifiedName, value) {
+          var attr = this.ownerDocument.createAttributeNS(namespaceURI, qualifiedName);
+          attr.value = attr.nodeValue = "" + value;
+          this.setAttributeNode(attr);
+        },
+        getAttributeNodeNS: function(namespaceURI, localName) {
+          return this.attributes.getNamedItemNS(namespaceURI, localName);
+        },
+        getElementsByTagName: function(tagName) {
+          return new LiveNodeList(this, function(base) {
+            var ls = [];
+            _visitNode(base, function(node) {
+              if (node !== base && node.nodeType == ELEMENT_NODE && (tagName === "*" || node.tagName == tagName)) {
+                ls.push(node);
+              }
+            });
+            return ls;
+          });
+        },
+        getElementsByTagNameNS: function(namespaceURI, localName) {
+          return new LiveNodeList(this, function(base) {
+            var ls = [];
+            _visitNode(base, function(node) {
+              if (node !== base && node.nodeType === ELEMENT_NODE && (namespaceURI === "*" || node.namespaceURI === namespaceURI) && (localName === "*" || node.localName == localName)) {
+                ls.push(node);
+              }
+            });
+            return ls;
+          });
+        }
+      };
+      Document.prototype.getElementsByTagName = Element.prototype.getElementsByTagName;
+      Document.prototype.getElementsByTagNameNS = Element.prototype.getElementsByTagNameNS;
+      _extends(Element, Node2);
+      function Attr() {
+      }
+      Attr.prototype.nodeType = ATTRIBUTE_NODE;
+      _extends(Attr, Node2);
+      function CharacterData() {
+      }
+      CharacterData.prototype = {
+        data: "",
+        substringData: function(offset, count) {
+          return this.data.substring(offset, offset + count);
+        },
+        appendData: function(text) {
+          text = this.data + text;
+          this.nodeValue = this.data = text;
+          this.length = text.length;
+        },
+        insertData: function(offset, text) {
+          this.replaceData(offset, 0, text);
+        },
+        appendChild: function(newChild) {
+          throw new Error(ExceptionMessage[HIERARCHY_REQUEST_ERR]);
+        },
+        deleteData: function(offset, count) {
+          this.replaceData(offset, count, "");
+        },
+        replaceData: function(offset, count, text) {
+          var start = this.data.substring(0, offset);
+          var end = this.data.substring(offset + count);
+          text = start + text + end;
+          this.nodeValue = this.data = text;
+          this.length = text.length;
+        }
+      };
+      _extends(CharacterData, Node2);
+      function Text() {
+      }
+      Text.prototype = {
+        nodeName: "#text",
+        nodeType: TEXT_NODE,
+        splitText: function(offset) {
+          var text = this.data;
+          var newText = text.substring(offset);
+          text = text.substring(0, offset);
+          this.data = this.nodeValue = text;
+          this.length = text.length;
+          var newNode = this.ownerDocument.createTextNode(newText);
+          if (this.parentNode) {
+            this.parentNode.insertBefore(newNode, this.nextSibling);
+          }
+          return newNode;
+        }
+      };
+      _extends(Text, CharacterData);
+      function Comment() {
+      }
+      Comment.prototype = {
+        nodeName: "#comment",
+        nodeType: COMMENT_NODE
+      };
+      _extends(Comment, CharacterData);
+      function CDATASection() {
+      }
+      CDATASection.prototype = {
+        nodeName: "#cdata-section",
+        nodeType: CDATA_SECTION_NODE
+      };
+      _extends(CDATASection, CharacterData);
+      function DocumentType() {
+      }
+      DocumentType.prototype.nodeType = DOCUMENT_TYPE_NODE;
+      _extends(DocumentType, Node2);
+      function Notation() {
+      }
+      Notation.prototype.nodeType = NOTATION_NODE;
+      _extends(Notation, Node2);
+      function Entity() {
+      }
+      Entity.prototype.nodeType = ENTITY_NODE;
+      _extends(Entity, Node2);
+      function EntityReference() {
+      }
+      EntityReference.prototype.nodeType = ENTITY_REFERENCE_NODE;
+      _extends(EntityReference, Node2);
+      function DocumentFragment() {
+      }
+      DocumentFragment.prototype.nodeName = "#document-fragment";
+      DocumentFragment.prototype.nodeType = DOCUMENT_FRAGMENT_NODE;
+      _extends(DocumentFragment, Node2);
+      function ProcessingInstruction() {
+      }
+      ProcessingInstruction.prototype.nodeType = PROCESSING_INSTRUCTION_NODE;
+      _extends(ProcessingInstruction, Node2);
+      function XMLSerializer() {
+      }
+      XMLSerializer.prototype.serializeToString = function(node, isHtml, nodeFilter) {
+        return nodeSerializeToString.call(node, isHtml, nodeFilter);
+      };
+      Node2.prototype.toString = nodeSerializeToString;
+      function nodeSerializeToString(isHtml, nodeFilter) {
+        var buf = [];
+        var refNode = this.nodeType == 9 && this.documentElement || this;
+        var prefix = refNode.prefix;
+        var uri = refNode.namespaceURI;
+        if (uri && prefix == null) {
+          var prefix = refNode.lookupPrefix(uri);
+          if (prefix == null) {
+            var visibleNamespaces = [
+              { namespace: uri, prefix: null }
+            ];
+          }
+        }
+        serializeToString(this, buf, isHtml, nodeFilter, visibleNamespaces);
+        return buf.join("");
+      }
+      function needNamespaceDefine(node, isHTML, visibleNamespaces) {
+        var prefix = node.prefix || "";
+        var uri = node.namespaceURI;
+        if (!uri) {
+          return false;
+        }
+        if (prefix === "xml" && uri === NAMESPACE.XML || uri === NAMESPACE.XMLNS) {
+          return false;
+        }
+        var i = visibleNamespaces.length;
+        while (i--) {
+          var ns = visibleNamespaces[i];
+          if (ns.prefix === prefix) {
+            return ns.namespace !== uri;
+          }
+        }
+        return true;
+      }
+      function addSerializedAttribute(buf, qualifiedName, value) {
+        buf.push(" ", qualifiedName, '="', value.replace(/[<&"]/g, _xmlEncoder), '"');
+      }
+      function serializeToString(node, buf, isHTML, nodeFilter, visibleNamespaces) {
+        if (!visibleNamespaces) {
+          visibleNamespaces = [];
+        }
+        if (nodeFilter) {
+          node = nodeFilter(node);
+          if (node) {
+            if (typeof node == "string") {
+              buf.push(node);
+              return;
+            }
+          } else {
+            return;
+          }
+        }
+        switch (node.nodeType) {
+          case ELEMENT_NODE:
+            var attrs = node.attributes;
+            var len = attrs.length;
+            var child = node.firstChild;
+            var nodeName = node.tagName;
+            isHTML = NAMESPACE.isHTML(node.namespaceURI) || isHTML;
+            var prefixedNodeName = nodeName;
+            if (!isHTML && !node.prefix && node.namespaceURI) {
+              var defaultNS;
+              for (var ai = 0; ai < attrs.length; ai++) {
+                if (attrs.item(ai).name === "xmlns") {
+                  defaultNS = attrs.item(ai).value;
+                  break;
+                }
+              }
+              if (!defaultNS) {
+                for (var nsi = visibleNamespaces.length - 1; nsi >= 0; nsi--) {
+                  var namespace = visibleNamespaces[nsi];
+                  if (namespace.prefix === "" && namespace.namespace === node.namespaceURI) {
+                    defaultNS = namespace.namespace;
+                    break;
+                  }
+                }
+              }
+              if (defaultNS !== node.namespaceURI) {
+                for (var nsi = visibleNamespaces.length - 1; nsi >= 0; nsi--) {
+                  var namespace = visibleNamespaces[nsi];
+                  if (namespace.namespace === node.namespaceURI) {
+                    if (namespace.prefix) {
+                      prefixedNodeName = namespace.prefix + ":" + nodeName;
+                    }
+                    break;
+                  }
+                }
+              }
+            }
+            buf.push("<", prefixedNodeName);
+            for (var i = 0; i < len; i++) {
+              var attr = attrs.item(i);
+              if (attr.prefix == "xmlns") {
+                visibleNamespaces.push({ prefix: attr.localName, namespace: attr.value });
+              } else if (attr.nodeName == "xmlns") {
+                visibleNamespaces.push({ prefix: "", namespace: attr.value });
+              }
+            }
+            for (var i = 0; i < len; i++) {
+              var attr = attrs.item(i);
+              if (needNamespaceDefine(attr, isHTML, visibleNamespaces)) {
+                var prefix = attr.prefix || "";
+                var uri = attr.namespaceURI;
+                addSerializedAttribute(buf, prefix ? "xmlns:" + prefix : "xmlns", uri);
+                visibleNamespaces.push({ prefix, namespace: uri });
+              }
+              serializeToString(attr, buf, isHTML, nodeFilter, visibleNamespaces);
+            }
+            if (nodeName === prefixedNodeName && needNamespaceDefine(node, isHTML, visibleNamespaces)) {
+              var prefix = node.prefix || "";
+              var uri = node.namespaceURI;
+              addSerializedAttribute(buf, prefix ? "xmlns:" + prefix : "xmlns", uri);
+              visibleNamespaces.push({ prefix, namespace: uri });
+            }
+            if (child || isHTML && !/^(?:meta|link|img|br|hr|input)$/i.test(nodeName)) {
+              buf.push(">");
+              if (isHTML && /^script$/i.test(nodeName)) {
+                while (child) {
+                  if (child.data) {
+                    buf.push(child.data);
+                  } else {
+                    serializeToString(child, buf, isHTML, nodeFilter, visibleNamespaces.slice());
+                  }
+                  child = child.nextSibling;
+                }
+              } else {
+                while (child) {
+                  serializeToString(child, buf, isHTML, nodeFilter, visibleNamespaces.slice());
+                  child = child.nextSibling;
+                }
+              }
+              buf.push("</", prefixedNodeName, ">");
+            } else {
+              buf.push("/>");
+            }
+            return;
+          case DOCUMENT_NODE:
+          case DOCUMENT_FRAGMENT_NODE:
+            var child = node.firstChild;
+            while (child) {
+              serializeToString(child, buf, isHTML, nodeFilter, visibleNamespaces.slice());
+              child = child.nextSibling;
+            }
+            return;
+          case ATTRIBUTE_NODE:
+            return addSerializedAttribute(buf, node.name, node.value);
+          case TEXT_NODE:
+            return buf.push(node.data.replace(/[<&]/g, _xmlEncoder).replace(/]]>/g, "]]&gt;"));
+          case CDATA_SECTION_NODE:
+            return buf.push("<![CDATA[", node.data, "]]>");
+          case COMMENT_NODE:
+            return buf.push("<!--", node.data, "-->");
+          case DOCUMENT_TYPE_NODE:
+            var pubid = node.publicId;
+            var sysid = node.systemId;
+            buf.push("<!DOCTYPE ", node.name);
+            if (pubid) {
+              buf.push(" PUBLIC ", pubid);
+              if (sysid && sysid != ".") {
+                buf.push(" ", sysid);
+              }
+              buf.push(">");
+            } else if (sysid && sysid != ".") {
+              buf.push(" SYSTEM ", sysid, ">");
+            } else {
+              var sub = node.internalSubset;
+              if (sub) {
+                buf.push(" [", sub, "]");
+              }
+              buf.push(">");
+            }
+            return;
+          case PROCESSING_INSTRUCTION_NODE:
+            return buf.push("<?", node.target, " ", node.data, "?>");
+          case ENTITY_REFERENCE_NODE:
+            return buf.push("&", node.nodeName, ";");
+          default:
+            buf.push("??", node.nodeName);
+        }
+      }
+      function importNode(doc, node, deep) {
+        var node2;
+        switch (node.nodeType) {
+          case ELEMENT_NODE:
+            node2 = node.cloneNode(false);
+            node2.ownerDocument = doc;
+          case DOCUMENT_FRAGMENT_NODE:
+            break;
+          case ATTRIBUTE_NODE:
+            deep = true;
+            break;
+        }
+        if (!node2) {
+          node2 = node.cloneNode(false);
+        }
+        node2.ownerDocument = doc;
+        node2.parentNode = null;
+        if (deep) {
+          var child = node.firstChild;
+          while (child) {
+            node2.appendChild(importNode(doc, child, deep));
+            child = child.nextSibling;
+          }
+        }
+        return node2;
+      }
+      function cloneNode(doc, node, deep) {
+        var node2 = new node.constructor();
+        for (var n in node) {
+          if (Object.prototype.hasOwnProperty.call(node, n)) {
+            var v = node[n];
+            if (typeof v != "object") {
+              if (v != node2[n]) {
+                node2[n] = v;
+              }
+            }
+          }
+        }
+        if (node.childNodes) {
+          node2.childNodes = new NodeList();
+        }
+        node2.ownerDocument = doc;
+        switch (node2.nodeType) {
+          case ELEMENT_NODE:
+            var attrs = node.attributes;
+            var attrs2 = node2.attributes = new NamedNodeMap();
+            var len = attrs.length;
+            attrs2._ownerElement = node2;
+            for (var i = 0; i < len; i++) {
+              node2.setAttributeNode(cloneNode(doc, attrs.item(i), true));
+            }
+            break;
+            ;
+          case ATTRIBUTE_NODE:
+            deep = true;
+        }
+        if (deep) {
+          var child = node.firstChild;
+          while (child) {
+            node2.appendChild(cloneNode(doc, child, deep));
+            child = child.nextSibling;
+          }
+        }
+        return node2;
+      }
+      function __set__(object, key, value) {
+        object[key] = value;
+      }
+      try {
+        if (Object.defineProperty) {
+          let getTextContent2 = function(node) {
+            switch (node.nodeType) {
+              case ELEMENT_NODE:
+              case DOCUMENT_FRAGMENT_NODE:
+                var buf = [];
+                node = node.firstChild;
+                while (node) {
+                  if (node.nodeType !== 7 && node.nodeType !== 8) {
+                    buf.push(getTextContent2(node));
+                  }
+                  node = node.nextSibling;
+                }
+                return buf.join("");
+              default:
+                return node.nodeValue;
+            }
+          };
+          getTextContent = getTextContent2;
+          Object.defineProperty(LiveNodeList.prototype, "length", {
+            get: function() {
+              _updateLiveList(this);
+              return this.$$length;
+            }
+          });
+          Object.defineProperty(Node2.prototype, "textContent", {
+            get: function() {
+              return getTextContent2(this);
+            },
+            set: function(data) {
+              switch (this.nodeType) {
+                case ELEMENT_NODE:
+                case DOCUMENT_FRAGMENT_NODE:
+                  while (this.firstChild) {
+                    this.removeChild(this.firstChild);
+                  }
+                  if (data || String(data)) {
+                    this.appendChild(this.ownerDocument.createTextNode(data));
+                  }
+                  break;
+                default:
+                  this.data = data;
+                  this.value = data;
+                  this.nodeValue = data;
+              }
+            }
+          });
+          __set__ = function(object, key, value) {
+            object["$$" + key] = value;
+          };
+        }
+      } catch (e) {
+      }
+      var getTextContent;
+      exports.DocumentType = DocumentType;
+      exports.DOMException = DOMException;
+      exports.DOMImplementation = DOMImplementation;
+      exports.Element = Element;
+      exports.Node = Node2;
+      exports.NodeList = NodeList;
+      exports.XMLSerializer = XMLSerializer;
+    }
+  });
+
+  // ../../node_modules/@xmldom/xmldom/lib/entities.js
+  var require_entities = __commonJS({
+    "../../node_modules/@xmldom/xmldom/lib/entities.js"(exports) {
+      var freeze = require_conventions().freeze;
+      exports.XML_ENTITIES = freeze({ amp: "&", apos: "'", gt: ">", lt: "<", quot: '"' });
+      exports.HTML_ENTITIES = freeze({
+        lt: "<",
+        gt: ">",
+        amp: "&",
+        quot: '"',
+        apos: "'",
+        Agrave: "\xC0",
+        Aacute: "\xC1",
+        Acirc: "\xC2",
+        Atilde: "\xC3",
+        Auml: "\xC4",
+        Aring: "\xC5",
+        AElig: "\xC6",
+        Ccedil: "\xC7",
+        Egrave: "\xC8",
+        Eacute: "\xC9",
+        Ecirc: "\xCA",
+        Euml: "\xCB",
+        Igrave: "\xCC",
+        Iacute: "\xCD",
+        Icirc: "\xCE",
+        Iuml: "\xCF",
+        ETH: "\xD0",
+        Ntilde: "\xD1",
+        Ograve: "\xD2",
+        Oacute: "\xD3",
+        Ocirc: "\xD4",
+        Otilde: "\xD5",
+        Ouml: "\xD6",
+        Oslash: "\xD8",
+        Ugrave: "\xD9",
+        Uacute: "\xDA",
+        Ucirc: "\xDB",
+        Uuml: "\xDC",
+        Yacute: "\xDD",
+        THORN: "\xDE",
+        szlig: "\xDF",
+        agrave: "\xE0",
+        aacute: "\xE1",
+        acirc: "\xE2",
+        atilde: "\xE3",
+        auml: "\xE4",
+        aring: "\xE5",
+        aelig: "\xE6",
+        ccedil: "\xE7",
+        egrave: "\xE8",
+        eacute: "\xE9",
+        ecirc: "\xEA",
+        euml: "\xEB",
+        igrave: "\xEC",
+        iacute: "\xED",
+        icirc: "\xEE",
+        iuml: "\xEF",
+        eth: "\xF0",
+        ntilde: "\xF1",
+        ograve: "\xF2",
+        oacute: "\xF3",
+        ocirc: "\xF4",
+        otilde: "\xF5",
+        ouml: "\xF6",
+        oslash: "\xF8",
+        ugrave: "\xF9",
+        uacute: "\xFA",
+        ucirc: "\xFB",
+        uuml: "\xFC",
+        yacute: "\xFD",
+        thorn: "\xFE",
+        yuml: "\xFF",
+        nbsp: "\xA0",
+        iexcl: "\xA1",
+        cent: "\xA2",
+        pound: "\xA3",
+        curren: "\xA4",
+        yen: "\xA5",
+        brvbar: "\xA6",
+        sect: "\xA7",
+        uml: "\xA8",
+        copy: "\xA9",
+        ordf: "\xAA",
+        laquo: "\xAB",
+        not: "\xAC",
+        shy: "\xAD\xAD",
+        reg: "\xAE",
+        macr: "\xAF",
+        deg: "\xB0",
+        plusmn: "\xB1",
+        sup2: "\xB2",
+        sup3: "\xB3",
+        acute: "\xB4",
+        micro: "\xB5",
+        para: "\xB6",
+        middot: "\xB7",
+        cedil: "\xB8",
+        sup1: "\xB9",
+        ordm: "\xBA",
+        raquo: "\xBB",
+        frac14: "\xBC",
+        frac12: "\xBD",
+        frac34: "\xBE",
+        iquest: "\xBF",
+        times: "\xD7",
+        divide: "\xF7",
+        forall: "\u2200",
+        part: "\u2202",
+        exist: "\u2203",
+        empty: "\u2205",
+        nabla: "\u2207",
+        isin: "\u2208",
+        notin: "\u2209",
+        ni: "\u220B",
+        prod: "\u220F",
+        sum: "\u2211",
+        minus: "\u2212",
+        lowast: "\u2217",
+        radic: "\u221A",
+        prop: "\u221D",
+        infin: "\u221E",
+        ang: "\u2220",
+        and: "\u2227",
+        or: "\u2228",
+        cap: "\u2229",
+        cup: "\u222A",
+        "int": "\u222B",
+        there4: "\u2234",
+        sim: "\u223C",
+        cong: "\u2245",
+        asymp: "\u2248",
+        ne: "\u2260",
+        equiv: "\u2261",
+        le: "\u2264",
+        ge: "\u2265",
+        sub: "\u2282",
+        sup: "\u2283",
+        nsub: "\u2284",
+        sube: "\u2286",
+        supe: "\u2287",
+        oplus: "\u2295",
+        otimes: "\u2297",
+        perp: "\u22A5",
+        sdot: "\u22C5",
+        Alpha: "\u0391",
+        Beta: "\u0392",
+        Gamma: "\u0393",
+        Delta: "\u0394",
+        Epsilon: "\u0395",
+        Zeta: "\u0396",
+        Eta: "\u0397",
+        Theta: "\u0398",
+        Iota: "\u0399",
+        Kappa: "\u039A",
+        Lambda: "\u039B",
+        Mu: "\u039C",
+        Nu: "\u039D",
+        Xi: "\u039E",
+        Omicron: "\u039F",
+        Pi: "\u03A0",
+        Rho: "\u03A1",
+        Sigma: "\u03A3",
+        Tau: "\u03A4",
+        Upsilon: "\u03A5",
+        Phi: "\u03A6",
+        Chi: "\u03A7",
+        Psi: "\u03A8",
+        Omega: "\u03A9",
+        alpha: "\u03B1",
+        beta: "\u03B2",
+        gamma: "\u03B3",
+        delta: "\u03B4",
+        epsilon: "\u03B5",
+        zeta: "\u03B6",
+        eta: "\u03B7",
+        theta: "\u03B8",
+        iota: "\u03B9",
+        kappa: "\u03BA",
+        lambda: "\u03BB",
+        mu: "\u03BC",
+        nu: "\u03BD",
+        xi: "\u03BE",
+        omicron: "\u03BF",
+        pi: "\u03C0",
+        rho: "\u03C1",
+        sigmaf: "\u03C2",
+        sigma: "\u03C3",
+        tau: "\u03C4",
+        upsilon: "\u03C5",
+        phi: "\u03C6",
+        chi: "\u03C7",
+        psi: "\u03C8",
+        omega: "\u03C9",
+        thetasym: "\u03D1",
+        upsih: "\u03D2",
+        piv: "\u03D6",
+        OElig: "\u0152",
+        oelig: "\u0153",
+        Scaron: "\u0160",
+        scaron: "\u0161",
+        Yuml: "\u0178",
+        fnof: "\u0192",
+        circ: "\u02C6",
+        tilde: "\u02DC",
+        ensp: "\u2002",
+        emsp: "\u2003",
+        thinsp: "\u2009",
+        zwnj: "\u200C",
+        zwj: "\u200D",
+        lrm: "\u200E",
+        rlm: "\u200F",
+        ndash: "\u2013",
+        mdash: "\u2014",
+        lsquo: "\u2018",
+        rsquo: "\u2019",
+        sbquo: "\u201A",
+        ldquo: "\u201C",
+        rdquo: "\u201D",
+        bdquo: "\u201E",
+        dagger: "\u2020",
+        Dagger: "\u2021",
+        bull: "\u2022",
+        hellip: "\u2026",
+        permil: "\u2030",
+        prime: "\u2032",
+        Prime: "\u2033",
+        lsaquo: "\u2039",
+        rsaquo: "\u203A",
+        oline: "\u203E",
+        euro: "\u20AC",
+        trade: "\u2122",
+        larr: "\u2190",
+        uarr: "\u2191",
+        rarr: "\u2192",
+        darr: "\u2193",
+        harr: "\u2194",
+        crarr: "\u21B5",
+        lceil: "\u2308",
+        rceil: "\u2309",
+        lfloor: "\u230A",
+        rfloor: "\u230B",
+        loz: "\u25CA",
+        spades: "\u2660",
+        clubs: "\u2663",
+        hearts: "\u2665",
+        diams: "\u2666"
+      });
+      exports.entityMap = exports.HTML_ENTITIES;
+    }
+  });
+
+  // ../../node_modules/@xmldom/xmldom/lib/sax.js
+  var require_sax = __commonJS({
+    "../../node_modules/@xmldom/xmldom/lib/sax.js"(exports) {
+      var NAMESPACE = require_conventions().NAMESPACE;
+      var nameStartChar = /[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]/;
+      var nameChar = new RegExp("[\\-\\.0-9" + nameStartChar.source.slice(1, -1) + "\\u00B7\\u0300-\\u036F\\u203F-\\u2040]");
+      var tagNamePattern = new RegExp("^" + nameStartChar.source + nameChar.source + "*(?::" + nameStartChar.source + nameChar.source + "*)?$");
+      var S_TAG = 0;
+      var S_ATTR = 1;
+      var S_ATTR_SPACE = 2;
+      var S_EQ = 3;
+      var S_ATTR_NOQUOT_VALUE = 4;
+      var S_ATTR_END = 5;
+      var S_TAG_SPACE = 6;
+      var S_TAG_CLOSE = 7;
+      function ParseError(message, locator) {
+        this.message = message;
+        this.locator = locator;
+        if (Error.captureStackTrace)
+          Error.captureStackTrace(this, ParseError);
+      }
+      ParseError.prototype = new Error();
+      ParseError.prototype.name = ParseError.name;
+      function XMLReader() {
+      }
+      XMLReader.prototype = {
+        parse: function(source, defaultNSMap, entityMap) {
+          var domBuilder = this.domBuilder;
+          domBuilder.startDocument();
+          _copy(defaultNSMap, defaultNSMap = {});
+          parse(source, defaultNSMap, entityMap, domBuilder, this.errorHandler);
+          domBuilder.endDocument();
+        }
+      };
+      function parse(source, defaultNSMapCopy, entityMap, domBuilder, errorHandler) {
+        function fixedFromCharCode(code) {
+          if (code > 65535) {
+            code -= 65536;
+            var surrogate1 = 55296 + (code >> 10), surrogate2 = 56320 + (code & 1023);
+            return String.fromCharCode(surrogate1, surrogate2);
+          } else {
+            return String.fromCharCode(code);
+          }
+        }
+        function entityReplacer(a2) {
+          var k = a2.slice(1, -1);
+          if (k in entityMap) {
+            return entityMap[k];
+          } else if (k.charAt(0) === "#") {
+            return fixedFromCharCode(parseInt(k.substr(1).replace("x", "0x")));
+          } else {
+            errorHandler.error("entity not found:" + a2);
+            return a2;
+          }
+        }
+        function appendText(end2) {
+          if (end2 > start) {
+            var xt = source.substring(start, end2).replace(/&#?\w+;/g, entityReplacer);
+            locator && position(start);
+            domBuilder.characters(xt, 0, end2 - start);
+            start = end2;
+          }
+        }
+        function position(p, m) {
+          while (p >= lineEnd && (m = linePattern.exec(source))) {
+            lineStart = m.index;
+            lineEnd = lineStart + m[0].length;
+            locator.lineNumber++;
+          }
+          locator.columnNumber = p - lineStart + 1;
+        }
+        var lineStart = 0;
+        var lineEnd = 0;
+        var linePattern = /.*(?:\r\n?|\n)|.*$/g;
+        var locator = domBuilder.locator;
+        var parseStack = [{ currentNSMap: defaultNSMapCopy }];
+        var closeMap = {};
+        var start = 0;
+        while (true) {
+          try {
+            var tagStart = source.indexOf("<", start);
+            if (tagStart < 0) {
+              if (!source.substr(start).match(/^\s*$/)) {
+                var doc = domBuilder.doc;
+                var text = doc.createTextNode(source.substr(start));
+                doc.appendChild(text);
+                domBuilder.currentElement = text;
+              }
+              return;
+            }
+            if (tagStart > start) {
+              appendText(tagStart);
+            }
+            switch (source.charAt(tagStart + 1)) {
+              case "/":
+                var end = source.indexOf(">", tagStart + 3);
+                var tagName = source.substring(tagStart + 2, end).replace(/[ \t\n\r]+$/g, "");
+                var config = parseStack.pop();
+                if (end < 0) {
+                  tagName = source.substring(tagStart + 2).replace(/[\s<].*/, "");
+                  errorHandler.error("end tag name: " + tagName + " is not complete:" + config.tagName);
+                  end = tagStart + 1 + tagName.length;
+                } else if (tagName.match(/\s</)) {
+                  tagName = tagName.replace(/[\s<].*/, "");
+                  errorHandler.error("end tag name: " + tagName + " maybe not complete");
+                  end = tagStart + 1 + tagName.length;
+                }
+                var localNSMap = config.localNSMap;
+                var endMatch = config.tagName == tagName;
+                var endIgnoreCaseMach = endMatch || config.tagName && config.tagName.toLowerCase() == tagName.toLowerCase();
+                if (endIgnoreCaseMach) {
+                  domBuilder.endElement(config.uri, config.localName, tagName);
+                  if (localNSMap) {
+                    for (var prefix in localNSMap) {
+                      if (Object.prototype.hasOwnProperty.call(localNSMap, prefix)) {
+                        domBuilder.endPrefixMapping(prefix);
+                      }
+                    }
+                  }
+                  if (!endMatch) {
+                    errorHandler.fatalError("end tag name: " + tagName + " is not match the current start tagName:" + config.tagName);
+                  }
+                } else {
+                  parseStack.push(config);
+                }
+                end++;
+                break;
+              case "?":
+                locator && position(tagStart);
+                end = parseInstruction(source, tagStart, domBuilder);
+                break;
+              case "!":
+                locator && position(tagStart);
+                end = parseDCC(source, tagStart, domBuilder, errorHandler);
+                break;
+              default:
+                locator && position(tagStart);
+                var el = new ElementAttributes();
+                var currentNSMap = parseStack[parseStack.length - 1].currentNSMap;
+                var end = parseElementStartPart(source, tagStart, el, currentNSMap, entityReplacer, errorHandler);
+                var len = el.length;
+                if (!el.closed && fixSelfClosed(source, end, el.tagName, closeMap)) {
+                  el.closed = true;
+                  if (!entityMap.nbsp) {
+                    errorHandler.warning("unclosed xml attribute");
+                  }
+                }
+                if (locator && len) {
+                  var locator2 = copyLocator(locator, {});
+                  for (var i = 0; i < len; i++) {
+                    var a = el[i];
+                    position(a.offset);
+                    a.locator = copyLocator(locator, {});
+                  }
+                  domBuilder.locator = locator2;
+                  if (appendElement(el, domBuilder, currentNSMap)) {
+                    parseStack.push(el);
+                  }
+                  domBuilder.locator = locator;
+                } else {
+                  if (appendElement(el, domBuilder, currentNSMap)) {
+                    parseStack.push(el);
+                  }
+                }
+                if (NAMESPACE.isHTML(el.uri) && !el.closed) {
+                  end = parseHtmlSpecialContent(source, end, el.tagName, entityReplacer, domBuilder);
+                } else {
+                  end++;
+                }
+            }
+          } catch (e) {
+            if (e instanceof ParseError) {
+              throw e;
+            }
+            errorHandler.error("element parse error: " + e);
+            end = -1;
+          }
+          if (end > start) {
+            start = end;
+          } else {
+            appendText(Math.max(tagStart, start) + 1);
+          }
+        }
+      }
+      function copyLocator(f, t) {
+        t.lineNumber = f.lineNumber;
+        t.columnNumber = f.columnNumber;
+        return t;
+      }
+      function parseElementStartPart(source, start, el, currentNSMap, entityReplacer, errorHandler) {
+        function addAttribute(qname, value2, startIndex) {
+          if (el.attributeNames.hasOwnProperty(qname)) {
+            errorHandler.fatalError("Attribute " + qname + " redefined");
+          }
+          el.addValue(qname, value2, startIndex);
+        }
+        var attrName;
+        var value;
+        var p = ++start;
+        var s = S_TAG;
+        while (true) {
+          var c = source.charAt(p);
+          switch (c) {
+            case "=":
+              if (s === S_ATTR) {
+                attrName = source.slice(start, p);
+                s = S_EQ;
+              } else if (s === S_ATTR_SPACE) {
+                s = S_EQ;
+              } else {
+                throw new Error("attribute equal must after attrName");
+              }
+              break;
+            case "'":
+            case '"':
+              if (s === S_EQ || s === S_ATTR) {
+                if (s === S_ATTR) {
+                  errorHandler.warning('attribute value must after "="');
+                  attrName = source.slice(start, p);
+                }
+                start = p + 1;
+                p = source.indexOf(c, start);
+                if (p > 0) {
+                  value = source.slice(start, p).replace(/&#?\w+;/g, entityReplacer);
+                  addAttribute(attrName, value, start - 1);
+                  s = S_ATTR_END;
+                } else {
+                  throw new Error("attribute value no end '" + c + "' match");
+                }
+              } else if (s == S_ATTR_NOQUOT_VALUE) {
+                value = source.slice(start, p).replace(/&#?\w+;/g, entityReplacer);
+                addAttribute(attrName, value, start);
+                errorHandler.warning('attribute "' + attrName + '" missed start quot(' + c + ")!!");
+                start = p + 1;
+                s = S_ATTR_END;
+              } else {
+                throw new Error('attribute value must after "="');
+              }
+              break;
+            case "/":
+              switch (s) {
+                case S_TAG:
+                  el.setTagName(source.slice(start, p));
+                case S_ATTR_END:
+                case S_TAG_SPACE:
+                case S_TAG_CLOSE:
+                  s = S_TAG_CLOSE;
+                  el.closed = true;
+                case S_ATTR_NOQUOT_VALUE:
+                case S_ATTR:
+                  break;
+                case S_ATTR_SPACE:
+                  el.closed = true;
+                  break;
+                default:
+                  throw new Error("attribute invalid close char('/')");
+              }
+              break;
+            case "":
+              errorHandler.error("unexpected end of input");
+              if (s == S_TAG) {
+                el.setTagName(source.slice(start, p));
+              }
+              return p;
+            case ">":
+              switch (s) {
+                case S_TAG:
+                  el.setTagName(source.slice(start, p));
+                case S_ATTR_END:
+                case S_TAG_SPACE:
+                case S_TAG_CLOSE:
+                  break;
+                case S_ATTR_NOQUOT_VALUE:
+                case S_ATTR:
+                  value = source.slice(start, p);
+                  if (value.slice(-1) === "/") {
+                    el.closed = true;
+                    value = value.slice(0, -1);
+                  }
+                case S_ATTR_SPACE:
+                  if (s === S_ATTR_SPACE) {
+                    value = attrName;
+                  }
+                  if (s == S_ATTR_NOQUOT_VALUE) {
+                    errorHandler.warning('attribute "' + value + '" missed quot(")!');
+                    addAttribute(attrName, value.replace(/&#?\w+;/g, entityReplacer), start);
+                  } else {
+                    if (!NAMESPACE.isHTML(currentNSMap[""]) || !value.match(/^(?:disabled|checked|selected)$/i)) {
+                      errorHandler.warning('attribute "' + value + '" missed value!! "' + value + '" instead!!');
+                    }
+                    addAttribute(value, value, start);
+                  }
+                  break;
+                case S_EQ:
+                  throw new Error("attribute value missed!!");
+              }
+              return p;
+            case "\x80":
+              c = " ";
+            default:
+              if (c <= " ") {
+                switch (s) {
+                  case S_TAG:
+                    el.setTagName(source.slice(start, p));
+                    s = S_TAG_SPACE;
+                    break;
+                  case S_ATTR:
+                    attrName = source.slice(start, p);
+                    s = S_ATTR_SPACE;
+                    break;
+                  case S_ATTR_NOQUOT_VALUE:
+                    var value = source.slice(start, p).replace(/&#?\w+;/g, entityReplacer);
+                    errorHandler.warning('attribute "' + value + '" missed quot(")!!');
+                    addAttribute(attrName, value, start);
+                  case S_ATTR_END:
+                    s = S_TAG_SPACE;
+                    break;
+                }
+              } else {
+                switch (s) {
+                  case S_ATTR_SPACE:
+                    var tagName = el.tagName;
+                    if (!NAMESPACE.isHTML(currentNSMap[""]) || !attrName.match(/^(?:disabled|checked|selected)$/i)) {
+                      errorHandler.warning('attribute "' + attrName + '" missed value!! "' + attrName + '" instead2!!');
+                    }
+                    addAttribute(attrName, attrName, start);
+                    start = p;
+                    s = S_ATTR;
+                    break;
+                  case S_ATTR_END:
+                    errorHandler.warning('attribute space is required"' + attrName + '"!!');
+                  case S_TAG_SPACE:
+                    s = S_ATTR;
+                    start = p;
+                    break;
+                  case S_EQ:
+                    s = S_ATTR_NOQUOT_VALUE;
+                    start = p;
+                    break;
+                  case S_TAG_CLOSE:
+                    throw new Error("elements closed character '/' and '>' must be connected to");
+                }
+              }
+          }
+          p++;
+        }
+      }
+      function appendElement(el, domBuilder, currentNSMap) {
+        var tagName = el.tagName;
+        var localNSMap = null;
+        var i = el.length;
+        while (i--) {
+          var a = el[i];
+          var qName = a.qName;
+          var value = a.value;
+          var nsp = qName.indexOf(":");
+          if (nsp > 0) {
+            var prefix = a.prefix = qName.slice(0, nsp);
+            var localName = qName.slice(nsp + 1);
+            var nsPrefix = prefix === "xmlns" && localName;
+          } else {
+            localName = qName;
+            prefix = null;
+            nsPrefix = qName === "xmlns" && "";
+          }
+          a.localName = localName;
+          if (nsPrefix !== false) {
+            if (localNSMap == null) {
+              localNSMap = {};
+              _copy(currentNSMap, currentNSMap = {});
+            }
+            currentNSMap[nsPrefix] = localNSMap[nsPrefix] = value;
+            a.uri = NAMESPACE.XMLNS;
+            domBuilder.startPrefixMapping(nsPrefix, value);
+          }
+        }
+        var i = el.length;
+        while (i--) {
+          a = el[i];
+          var prefix = a.prefix;
+          if (prefix) {
+            if (prefix === "xml") {
+              a.uri = NAMESPACE.XML;
+            }
+            if (prefix !== "xmlns") {
+              a.uri = currentNSMap[prefix || ""];
+            }
+          }
+        }
+        var nsp = tagName.indexOf(":");
+        if (nsp > 0) {
+          prefix = el.prefix = tagName.slice(0, nsp);
+          localName = el.localName = tagName.slice(nsp + 1);
+        } else {
+          prefix = null;
+          localName = el.localName = tagName;
+        }
+        var ns = el.uri = currentNSMap[prefix || ""];
+        domBuilder.startElement(ns, localName, tagName, el);
+        if (el.closed) {
+          domBuilder.endElement(ns, localName, tagName);
+          if (localNSMap) {
+            for (prefix in localNSMap) {
+              if (Object.prototype.hasOwnProperty.call(localNSMap, prefix)) {
+                domBuilder.endPrefixMapping(prefix);
+              }
+            }
+          }
+        } else {
+          el.currentNSMap = currentNSMap;
+          el.localNSMap = localNSMap;
+          return true;
+        }
+      }
+      function parseHtmlSpecialContent(source, elStartEnd, tagName, entityReplacer, domBuilder) {
+        if (/^(?:script|textarea)$/i.test(tagName)) {
+          var elEndStart = source.indexOf("</" + tagName + ">", elStartEnd);
+          var text = source.substring(elStartEnd + 1, elEndStart);
+          if (/[&<]/.test(text)) {
+            if (/^script$/i.test(tagName)) {
+              domBuilder.characters(text, 0, text.length);
+              return elEndStart;
+            }
+            text = text.replace(/&#?\w+;/g, entityReplacer);
+            domBuilder.characters(text, 0, text.length);
+            return elEndStart;
+          }
+        }
+        return elStartEnd + 1;
+      }
+      function fixSelfClosed(source, elStartEnd, tagName, closeMap) {
+        var pos = closeMap[tagName];
+        if (pos == null) {
+          pos = source.lastIndexOf("</" + tagName + ">");
+          if (pos < elStartEnd) {
+            pos = source.lastIndexOf("</" + tagName);
+          }
+          closeMap[tagName] = pos;
+        }
+        return pos < elStartEnd;
+      }
+      function _copy(source, target) {
+        for (var n in source) {
+          if (Object.prototype.hasOwnProperty.call(source, n)) {
+            target[n] = source[n];
+          }
+        }
+      }
+      function parseDCC(source, start, domBuilder, errorHandler) {
+        var next = source.charAt(start + 2);
+        switch (next) {
+          case "-":
+            if (source.charAt(start + 3) === "-") {
+              var end = source.indexOf("-->", start + 4);
+              if (end > start) {
+                domBuilder.comment(source, start + 4, end - start - 4);
+                return end + 3;
+              } else {
+                errorHandler.error("Unclosed comment");
+                return -1;
+              }
+            } else {
+              return -1;
+            }
+          default:
+            if (source.substr(start + 3, 6) == "CDATA[") {
+              var end = source.indexOf("]]>", start + 9);
+              domBuilder.startCDATA();
+              domBuilder.characters(source, start + 9, end - start - 9);
+              domBuilder.endCDATA();
+              return end + 3;
+            }
+            var matchs = split(source, start);
+            var len = matchs.length;
+            if (len > 1 && /!doctype/i.test(matchs[0][0])) {
+              var name = matchs[1][0];
+              var pubid = false;
+              var sysid = false;
+              if (len > 3) {
+                if (/^public$/i.test(matchs[2][0])) {
+                  pubid = matchs[3][0];
+                  sysid = len > 4 && matchs[4][0];
+                } else if (/^system$/i.test(matchs[2][0])) {
+                  sysid = matchs[3][0];
+                }
+              }
+              var lastMatch = matchs[len - 1];
+              domBuilder.startDTD(name, pubid, sysid);
+              domBuilder.endDTD();
+              return lastMatch.index + lastMatch[0].length;
+            }
+        }
+        return -1;
+      }
+      function parseInstruction(source, start, domBuilder) {
+        var end = source.indexOf("?>", start);
+        if (end) {
+          var match = source.substring(start, end).match(/^<\?(\S*)\s*([\s\S]*?)\s*$/);
+          if (match) {
+            var len = match[0].length;
+            domBuilder.processingInstruction(match[1], match[2]);
+            return end + 2;
+          } else {
+            return -1;
+          }
+        }
+        return -1;
+      }
+      function ElementAttributes() {
+        this.attributeNames = {};
+      }
+      ElementAttributes.prototype = {
+        setTagName: function(tagName) {
+          if (!tagNamePattern.test(tagName)) {
+            throw new Error("invalid tagName:" + tagName);
+          }
+          this.tagName = tagName;
+        },
+        addValue: function(qName, value, offset) {
+          if (!tagNamePattern.test(qName)) {
+            throw new Error("invalid attribute:" + qName);
+          }
+          this.attributeNames[qName] = this.length;
+          this[this.length++] = { qName, value, offset };
+        },
+        length: 0,
+        getLocalName: function(i) {
+          return this[i].localName;
+        },
+        getLocator: function(i) {
+          return this[i].locator;
+        },
+        getQName: function(i) {
+          return this[i].qName;
+        },
+        getURI: function(i) {
+          return this[i].uri;
+        },
+        getValue: function(i) {
+          return this[i].value;
+        }
+      };
+      function split(source, start) {
+        var match;
+        var buf = [];
+        var reg = /'[^']+'|"[^"]+"|[^\s<>\/=]+=?|(\/?\s*>|<)/g;
+        reg.lastIndex = start;
+        reg.exec(source);
+        while (match = reg.exec(source)) {
+          buf.push(match);
+          if (match[1])
+            return buf;
+        }
+      }
+      exports.XMLReader = XMLReader;
+      exports.ParseError = ParseError;
+    }
+  });
+
+  // ../../node_modules/@xmldom/xmldom/lib/dom-parser.js
+  var require_dom_parser = __commonJS({
+    "../../node_modules/@xmldom/xmldom/lib/dom-parser.js"(exports) {
+      var conventions = require_conventions();
+      var dom = require_dom();
+      var entities = require_entities();
+      var sax = require_sax();
+      var DOMImplementation = dom.DOMImplementation;
+      var NAMESPACE = conventions.NAMESPACE;
+      var ParseError = sax.ParseError;
+      var XMLReader = sax.XMLReader;
+      function DOMParser4(options) {
+        this.options = options || { locator: {} };
+      }
+      DOMParser4.prototype.parseFromString = function(source, mimeType) {
+        var options = this.options;
+        var sax2 = new XMLReader();
+        var domBuilder = options.domBuilder || new DOMHandler();
+        var errorHandler = options.errorHandler;
+        var locator = options.locator;
+        var defaultNSMap = options.xmlns || {};
+        var isHTML = /\/x?html?$/.test(mimeType);
+        var entityMap = isHTML ? entities.HTML_ENTITIES : entities.XML_ENTITIES;
+        if (locator) {
+          domBuilder.setDocumentLocator(locator);
+        }
+        sax2.errorHandler = buildErrorHandler(errorHandler, domBuilder, locator);
+        sax2.domBuilder = options.domBuilder || domBuilder;
+        if (isHTML) {
+          defaultNSMap[""] = NAMESPACE.HTML;
+        }
+        defaultNSMap.xml = defaultNSMap.xml || NAMESPACE.XML;
+        if (source && typeof source === "string") {
+          sax2.parse(source, defaultNSMap, entityMap);
+        } else {
+          sax2.errorHandler.error("invalid doc source");
+        }
+        return domBuilder.doc;
+      };
+      function buildErrorHandler(errorImpl, domBuilder, locator) {
+        if (!errorImpl) {
+          if (domBuilder instanceof DOMHandler) {
+            return domBuilder;
+          }
+          errorImpl = domBuilder;
+        }
+        var errorHandler = {};
+        var isCallback = errorImpl instanceof Function;
+        locator = locator || {};
+        function build(key) {
+          var fn = errorImpl[key];
+          if (!fn && isCallback) {
+            fn = errorImpl.length == 2 ? function(msg) {
+              errorImpl(key, msg);
+            } : errorImpl;
+          }
+          errorHandler[key] = fn && function(msg) {
+            fn("[xmldom " + key + "]	" + msg + _locator(locator));
+          } || function() {
+          };
+        }
+        build("warning");
+        build("error");
+        build("fatalError");
+        return errorHandler;
+      }
+      function DOMHandler() {
+        this.cdata = false;
+      }
+      function position(locator, node) {
+        node.lineNumber = locator.lineNumber;
+        node.columnNumber = locator.columnNumber;
+      }
+      DOMHandler.prototype = {
+        startDocument: function() {
+          this.doc = new DOMImplementation().createDocument(null, null, null);
+          if (this.locator) {
+            this.doc.documentURI = this.locator.systemId;
+          }
+        },
+        startElement: function(namespaceURI, localName, qName, attrs) {
+          var doc = this.doc;
+          var el = doc.createElementNS(namespaceURI, qName || localName);
+          var len = attrs.length;
+          appendElement(this, el);
+          this.currentElement = el;
+          this.locator && position(this.locator, el);
+          for (var i = 0; i < len; i++) {
+            var namespaceURI = attrs.getURI(i);
+            var value = attrs.getValue(i);
+            var qName = attrs.getQName(i);
+            var attr = doc.createAttributeNS(namespaceURI, qName);
+            this.locator && position(attrs.getLocator(i), attr);
+            attr.value = attr.nodeValue = value;
+            el.setAttributeNode(attr);
+          }
+        },
+        endElement: function(namespaceURI, localName, qName) {
+          var current = this.currentElement;
+          var tagName = current.tagName;
+          this.currentElement = current.parentNode;
+        },
+        startPrefixMapping: function(prefix, uri) {
+        },
+        endPrefixMapping: function(prefix) {
+        },
+        processingInstruction: function(target, data) {
+          var ins = this.doc.createProcessingInstruction(target, data);
+          this.locator && position(this.locator, ins);
+          appendElement(this, ins);
+        },
+        ignorableWhitespace: function(ch, start, length) {
+        },
+        characters: function(chars, start, length) {
+          chars = _toString.apply(this, arguments);
+          if (chars) {
+            if (this.cdata) {
+              var charNode = this.doc.createCDATASection(chars);
+            } else {
+              var charNode = this.doc.createTextNode(chars);
+            }
+            if (this.currentElement) {
+              this.currentElement.appendChild(charNode);
+            } else if (/^\s*$/.test(chars)) {
+              this.doc.appendChild(charNode);
+            }
+            this.locator && position(this.locator, charNode);
+          }
+        },
+        skippedEntity: function(name) {
+        },
+        endDocument: function() {
+          this.doc.normalize();
+        },
+        setDocumentLocator: function(locator) {
+          if (this.locator = locator) {
+            locator.lineNumber = 0;
+          }
+        },
+        comment: function(chars, start, length) {
+          chars = _toString.apply(this, arguments);
+          var comm = this.doc.createComment(chars);
+          this.locator && position(this.locator, comm);
+          appendElement(this, comm);
+        },
+        startCDATA: function() {
+          this.cdata = true;
+        },
+        endCDATA: function() {
+          this.cdata = false;
+        },
+        startDTD: function(name, publicId, systemId) {
+          var impl = this.doc.implementation;
+          if (impl && impl.createDocumentType) {
+            var dt = impl.createDocumentType(name, publicId, systemId);
+            this.locator && position(this.locator, dt);
+            appendElement(this, dt);
+            this.doc.doctype = dt;
+          }
+        },
+        warning: function(error) {
+          console.warn("[xmldom warning]	" + error, _locator(this.locator));
+        },
+        error: function(error) {
+          console.error("[xmldom error]	" + error, _locator(this.locator));
+        },
+        fatalError: function(error) {
+          throw new ParseError(error, this.locator);
+        }
+      };
+      function _locator(l) {
+        if (l) {
+          return "\n@" + (l.systemId || "") + "#[line:" + l.lineNumber + ",col:" + l.columnNumber + "]";
+        }
+      }
+      function _toString(chars, start, length) {
+        if (typeof chars == "string") {
+          return chars.substr(start, length);
+        } else {
+          if (chars.length >= start + length || start) {
+            return new java.lang.String(chars, start, length) + "";
+          }
+          return chars;
+        }
+      }
+      "endDTD,startEntity,endEntity,attributeDecl,elementDecl,externalEntityDecl,internalEntityDecl,resolveEntity,getExternalSubset,notationDecl,unparsedEntityDecl".replace(/\w+/g, function(key) {
+        DOMHandler.prototype[key] = function() {
+          return null;
+        };
+      });
+      function appendElement(hander, node) {
+        if (!hander.currentElement) {
+          hander.doc.appendChild(node);
+        } else {
+          hander.currentElement.appendChild(node);
+        }
+      }
+      exports.__DOMHandler = DOMHandler;
+      exports.DOMParser = DOMParser4;
+      exports.DOMImplementation = dom.DOMImplementation;
+      exports.XMLSerializer = dom.XMLSerializer;
+    }
+  });
+
+  // ../../node_modules/@xmldom/xmldom/lib/index.js
+  var require_lib = __commonJS({
+    "../../node_modules/@xmldom/xmldom/lib/index.js"(exports) {
+      var dom = require_dom();
+      exports.DOMImplementation = dom.DOMImplementation;
+      exports.XMLSerializer = dom.XMLSerializer;
+      exports.DOMParser = require_dom_parser().DOMParser;
+    }
+  });
+
+  // src/gpx-loader.ts
+  function parseTextSync(text, options) {
+    const doc = new import_xmldom.DOMParser().parseFromString(text, "text/xml");
+    const geojson = gpx(doc);
+    const shape = options?.gis?.format || options?.gpx?.type || options?.gpx?.shape;
+    switch (shape) {
+      case "object-row-table": {
+        const table = {
+          shape: "object-row-table",
+          data: geojson.features
+        };
+        return table;
+      }
+      case "geojson-row-table": {
+        const table = {
+          shape: "geojson-row-table",
+          data: geojson.features
+        };
+        return table;
+      }
+      case "geojson":
+        return geojson;
+      case "binary":
+        return geojsonToBinary(geojson.features);
+      case "raw":
         return doc;
       default:
-        throw new Error();
+        return geojson;
     }
   }
-  var import_togeojson, VERSION, GPX_HEADER, GPXLoader;
+  var import_xmldom, VERSION, GPX_HEADER, GPXLoader;
   var init_gpx_loader = __esm({
     "src/gpx-loader.ts"() {
       init_src();
-      import_togeojson = __toModule(require_togeojson_umd());
+      init_togeojson_es();
+      import_xmldom = __toModule(require_lib());
       VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
       GPX_HEADER = `<?xml version="1.0" encoding="UTF-8"?>
 <gpx`;
@@ -1402,7 +4128,7 @@
         parseTextSync,
         options: {
           gpx: {},
-          gis: { format: "geojson" }
+          gis: {}
         }
       };
     }
@@ -1410,14 +4136,24 @@
 
   // src/kml-loader.ts
   function parseTextSync2(text, options) {
-    const doc = new DOMParser().parseFromString(text, "text/xml");
-    const geojson = (0, import_togeojson2.kml)(doc);
-    switch (options?.kml?.type) {
-      case "object-row-table":
-        return geojson.features;
-      default:
-    }
-    switch (options?.gis?.format) {
+    const doc = new import_xmldom2.DOMParser().parseFromString(text, "text/xml");
+    const geojson = kml(doc);
+    const shape = options?.gis?.format || options?.kml?.type || options?.kml?.shape;
+    switch (shape) {
+      case "object-row-table": {
+        const table = {
+          shape: "object-row-table",
+          data: geojson.features
+        };
+        return table;
+      }
+      case "geojson-row-table": {
+        const table = {
+          shape: "geojson-row-table",
+          data: geojson.features
+        };
+        return table;
+      }
       case "geojson":
         return geojson;
       case "binary":
@@ -1425,14 +4161,15 @@
       case "raw":
         return doc;
       default:
-        throw new Error();
+        return geojson;
     }
   }
-  var import_togeojson2, VERSION2, KML_HEADER, KMLLoader;
+  var import_xmldom2, VERSION2, KML_HEADER, KMLLoader;
   var init_kml_loader = __esm({
     "src/kml-loader.ts"() {
       init_src();
-      import_togeojson2 = __toModule(require_togeojson_umd());
+      init_togeojson_es();
+      import_xmldom2 = __toModule(require_lib());
       VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
       KML_HEADER = `<?xml version="1.0" encoding="UTF-8"?>
 <kml xmlns="http://www.opengis.net/kml/2.2">`;
@@ -1449,22 +4186,32 @@
         parseTextSync: parseTextSync2,
         options: {
           kml: {},
-          gis: { format: "geojson" }
+          gis: {}
         }
       };
     }
   });
 
   // src/tcx-loader.ts
-  function parseTextSync3(text, options = {}) {
-    const doc = new DOMParser().parseFromString(text, "text/xml");
-    const geojson = (0, import_togeojson3.tcx)(doc);
-    switch (options?.tcx?.type) {
-      case "object-row-table":
-        return geojson.features;
-      default:
-    }
-    switch (options?.gis?.format) {
+  function parseTextSync3(text, options) {
+    const doc = new import_xmldom3.DOMParser().parseFromString(text, "text/xml");
+    const geojson = tcx(doc);
+    const shape = options?.gis?.format || options?.tcx?.type || options?.tcx?.shape;
+    switch (shape) {
+      case "object-row-table": {
+        const table = {
+          shape: "object-row-table",
+          data: geojson.features
+        };
+        return table;
+      }
+      case "geojson-row-table": {
+        const table = {
+          shape: "geojson-row-table",
+          data: geojson.features
+        };
+        return table;
+      }
       case "geojson":
         return geojson;
       case "binary":
@@ -1472,14 +4219,15 @@
       case "raw":
         return doc;
       default:
-        throw new Error();
+        return geojson;
     }
   }
-  var import_togeojson3, VERSION3, TCX_HEADER, TCXLoader;
+  var import_xmldom3, VERSION3, TCX_HEADER, TCXLoader;
   var init_tcx_loader = __esm({
     "src/tcx-loader.ts"() {
       init_src();
-      import_togeojson3 = __toModule(require_togeojson_umd());
+      init_togeojson_es();
+      import_xmldom3 = __toModule(require_lib());
       VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
       TCX_HEADER = `<?xml version="1.0" encoding="UTF-8"?>
 <TrainingCenterDatabase`;
@@ -1496,7 +4244,7 @@
         parseTextSync: parseTextSync3,
         options: {
           tcx: {},
-          gis: { format: "geojson" }
+          gis: {}
         }
       };
     }