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

package/dist/dist.min.js

@@ -1,10 +1,5 @@
 (() => {
-  var __create = Object.create;
   var __defProp = Object.defineProperty;
-  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-  var __getOwnPropNames = Object.getOwnPropertyNames;
-  var __getProtoOf = Object.getPrototypeOf;
-  var __hasOwnProp = Object.prototype.hasOwnProperty;
   var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
   var __esm = (fn, res) => function __init() {
     return fn && (res = (0, fn[Object.keys(fn)[0]])(fn = 0)), res;
@@ -17,17 +12,34 @@
     for (var name in all)
       __defProp(target, name, { get: all[name], enumerable: true });
   };
-  var __reExport = (target, module, desc) => {
-    if (module && typeof module === "object" || typeof module === "function") {
-      for (let key of __getOwnPropNames(module))
-        if (!__hasOwnProp.call(target, key) && key !== "default")
-          __defProp(target, key, { get: () => module[key], enumerable: !(desc = __getOwnPropDesc(module, key)) || desc.enumerable });
+
+  // ../../node_modules/@babel/runtime/helpers/esm/typeof.js
+  var init_typeof = __esm({
+    "../../node_modules/@babel/runtime/helpers/esm/typeof.js"() {
     }
-    return target;
-  };
-  var __toModule = (module) => {
-    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/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 = {}) {
@@ -51,16 +63,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 +84,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 +869,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 +878,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 +889,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 +900,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,348 +1041,713 @@
     }
   });
 
-  // ../../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);
-            }
-          }
-          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 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 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 { line: o2, times: s2, extendedValues: r2 };
-        }
-        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));
-          }
-          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;
-            }
-          }
-          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]);
-            }
-            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;
-            }
-          }
-          return Object.assign(i2, { line: o2, times: s2, heartRates: r2 });
+  // ../../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)]);
         }
-        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 } };
+      }
+    }
+    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);
         }
-        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);
-          }
+        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 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;
+        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;
         }
-        function S(e2) {
-          return e2.replace(N, "").split(",").map(parseFloat);
+      }
+    }
+    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];
         }
-        function k(e2) {
-          return e2.replace(x, "").split(T).map(S);
+      }
+      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);
         }
-        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;
+        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));
           }
-          return e2.nodeName === "#text" ? (e2.nodeValue || e2.value || "").trim() : e2.nodeName === "#cdata-section" ? e2.nodeValue : "";
+          properties[property][i] = extendedProperties[property];
         }
-        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 { 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]);
-            }
-            const o3 = n(d2, "Icon");
-            if (o3) {
-              const e4 = t(n(o3, "href"));
-              e4 && (a2.icon = e4);
+      }
+    }
+    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"))));
             }
-          }
-          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);
+            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);
           }
         }
-        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 });
-      });
+      }
+    }
+    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"];
     }
   });
 
   // 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) {
+    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":
@@ -1378,14 +1755,14 @@
       case "raw":
         return doc;
       default:
-        throw new Error();
+        return geojson;
     }
   }
-  var import_togeojson, VERSION, GPX_HEADER, GPXLoader;
+  var VERSION, GPX_HEADER, GPXLoader;
   var init_gpx_loader = __esm({
     "src/gpx-loader.ts"() {
       init_src();
-      import_togeojson = __toModule(require_togeojson_umd());
+      init_togeojson_es();
       VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
       GPX_HEADER = `<?xml version="1.0" encoding="UTF-8"?>
 <gpx`;
@@ -1402,7 +1779,7 @@
         parseTextSync,
         options: {
           gpx: {},
-          gis: { format: "geojson" }
+          gis: {}
         }
       };
     }
@@ -1411,13 +1788,23 @@
   // 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 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 +1812,14 @@
       case "raw":
         return doc;
       default:
-        throw new Error();
+        return geojson;
     }
   }
-  var import_togeojson2, VERSION2, KML_HEADER, KMLLoader;
+  var VERSION2, KML_HEADER, KMLLoader;
   var init_kml_loader = __esm({
     "src/kml-loader.ts"() {
       init_src();
-      import_togeojson2 = __toModule(require_togeojson_umd());
+      init_togeojson_es();
       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 +1836,32 @@
         parseTextSync: parseTextSync2,
         options: {
           kml: {},
-          gis: { format: "geojson" }
+          gis: {}
         }
       };
     }
   });
 
   // src/tcx-loader.ts
-  function parseTextSync3(text, options = {}) {
+  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) {
+    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 +1869,14 @@
       case "raw":
         return doc;
       default:
-        throw new Error();
+        return geojson;
     }
   }
-  var import_togeojson3, VERSION3, TCX_HEADER, TCXLoader;
+  var VERSION3, TCX_HEADER, TCXLoader;
   var init_tcx_loader = __esm({
     "src/tcx-loader.ts"() {
       init_src();
-      import_togeojson3 = __toModule(require_togeojson_umd());
+      init_togeojson_es();
       VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
       TCX_HEADER = `<?xml version="1.0" encoding="UTF-8"?>
 <TrainingCenterDatabase`;
@@ -1496,7 +1893,7 @@
         parseTextSync: parseTextSync3,
         options: {
           tcx: {},
-          gis: { format: "geojson" }
+          gis: {}
         }
       };
     }