@loaders.gl/kml 3.1.0-beta.5 → 3.1.2

package/dist/bundle.js

@@ -1,853 +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;
-  };
-  var __commonJS = (cb, mod) => function __require() {
-    return mod || (0, cb[Object.keys(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-  };
-  var __export = (target, all) => {
-    __markAsModule(target);
-    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 });
-    }
-    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);
-  };
-
-  // ../gis/src/lib/geojson-to-binary.ts
-  function geojsonToBinary(features, options = {}) {
-    const firstPassData = firstPass(features);
-    return secondPass(features, firstPassData, {
-      coordLength: options.coordLength || firstPassData.coordLength,
-      numericPropKeys: options.numericPropKeys || firstPassData.numericPropKeys,
-      PositionDataType: options.PositionDataType || Float32Array
-    });
-  }
-  function firstPass(features) {
-    let pointPositionsCount = 0;
-    let pointFeaturesCount = 0;
-    let linePositionsCount = 0;
-    let linePathsCount = 0;
-    let lineFeaturesCount = 0;
-    let polygonPositionsCount = 0;
-    let polygonObjectsCount = 0;
-    let polygonRingsCount = 0;
-    let polygonFeaturesCount = 0;
-    const coordLengths = new Set();
-    const numericPropKeys = {};
-    for (const feature of features) {
-      const geometry = feature.geometry;
-      switch (geometry.type) {
-        case "Point":
-          pointFeaturesCount++;
-          pointPositionsCount++;
-          coordLengths.add(geometry.coordinates.length);
-          break;
-        case "MultiPoint":
-          pointFeaturesCount++;
-          pointPositionsCount += geometry.coordinates.length;
-          for (const point of geometry.coordinates) {
-            coordLengths.add(point.length);
-          }
-          break;
-        case "LineString":
-          lineFeaturesCount++;
-          linePositionsCount += geometry.coordinates.length;
-          linePathsCount++;
-          for (const coord of geometry.coordinates) {
-            coordLengths.add(coord.length);
-          }
-          break;
-        case "MultiLineString":
-          lineFeaturesCount++;
-          for (const line of geometry.coordinates) {
-            linePositionsCount += line.length;
-            linePathsCount++;
-            for (const coord of line) {
-              coordLengths.add(coord.length);
-            }
-          }
-          break;
-        case "Polygon":
-          polygonFeaturesCount++;
-          polygonObjectsCount++;
-          polygonRingsCount += geometry.coordinates.length;
-          polygonPositionsCount += flatten(geometry.coordinates).length;
-          for (const coord of flatten(geometry.coordinates)) {
-            coordLengths.add(coord.length);
-          }
-          break;
-        case "MultiPolygon":
-          polygonFeaturesCount++;
-          for (const polygon of geometry.coordinates) {
-            polygonObjectsCount++;
-            polygonRingsCount += polygon.length;
-            polygonPositionsCount += flatten(polygon).length;
-            for (const coord of flatten(polygon)) {
-              coordLengths.add(coord.length);
-            }
-          }
-          break;
-        default:
-          throw new Error(`Unsupported geometry type: ${geometry.type}`);
-      }
-      if (feature.properties) {
-        for (const key in feature.properties) {
-          const val = feature.properties[key];
-          numericPropKeys[key] = numericPropKeys[key] || numericPropKeys[key] === void 0 ? isNumeric(val) : numericPropKeys[key];
-        }
-      }
-    }
-    return {
-      coordLength: coordLengths.size > 0 ? Math.max(...coordLengths) : 2,
-      pointPositionsCount,
-      pointFeaturesCount,
-      linePositionsCount,
-      linePathsCount,
-      lineFeaturesCount,
-      polygonPositionsCount,
-      polygonObjectsCount,
-      polygonRingsCount,
-      polygonFeaturesCount,
-      numericPropKeys: Object.keys(numericPropKeys).filter((k) => numericPropKeys[k])
-    };
-  }
-  function secondPass(features, firstPassData, options) {
-    const {
-      pointPositionsCount,
-      pointFeaturesCount,
-      linePositionsCount,
-      linePathsCount,
-      lineFeaturesCount,
-      polygonPositionsCount,
-      polygonObjectsCount,
-      polygonRingsCount,
-      polygonFeaturesCount
-    } = firstPassData;
-    const { coordLength, numericPropKeys, PositionDataType = Float32Array } = options;
-    const GlobalFeatureIdsDataType = features.length > 65535 ? Uint32Array : Uint16Array;
-    const points = {
-      positions: new PositionDataType(pointPositionsCount * coordLength),
-      globalFeatureIds: new GlobalFeatureIdsDataType(pointPositionsCount),
-      featureIds: pointFeaturesCount > 65535 ? new Uint32Array(pointPositionsCount) : new Uint16Array(pointPositionsCount),
-      numericProps: {},
-      properties: Array(),
-      fields: Array()
-    };
-    const lines = {
-      positions: new PositionDataType(linePositionsCount * coordLength),
-      pathIndices: linePositionsCount > 65535 ? new Uint32Array(linePathsCount + 1) : new Uint16Array(linePathsCount + 1),
-      globalFeatureIds: new GlobalFeatureIdsDataType(linePositionsCount),
-      featureIds: lineFeaturesCount > 65535 ? new Uint32Array(linePositionsCount) : new Uint16Array(linePositionsCount),
-      numericProps: {},
-      properties: Array(),
-      fields: Array()
-    };
-    const polygons = {
-      positions: new PositionDataType(polygonPositionsCount * coordLength),
-      polygonIndices: polygonPositionsCount > 65535 ? new Uint32Array(polygonObjectsCount + 1) : new Uint16Array(polygonObjectsCount + 1),
-      primitivePolygonIndices: polygonPositionsCount > 65535 ? new Uint32Array(polygonRingsCount + 1) : new Uint16Array(polygonRingsCount + 1),
-      globalFeatureIds: new GlobalFeatureIdsDataType(polygonPositionsCount),
-      featureIds: polygonFeaturesCount > 65535 ? new Uint32Array(polygonPositionsCount) : new Uint16Array(polygonPositionsCount),
-      numericProps: {},
-      properties: Array(),
-      fields: Array()
-    };
-    for (const object of [points, lines, polygons]) {
-      for (const propName of numericPropKeys || []) {
-        object.numericProps[propName] = new Float32Array(object.positions.length / coordLength);
-      }
-    }
-    lines.pathIndices[linePathsCount] = linePositionsCount;
-    polygons.polygonIndices[polygonObjectsCount] = polygonPositionsCount;
-    polygons.primitivePolygonIndices[polygonRingsCount] = polygonPositionsCount;
-    const indexMap = {
-      pointPosition: 0,
-      pointFeature: 0,
-      linePosition: 0,
-      linePath: 0,
-      lineFeature: 0,
-      polygonPosition: 0,
-      polygonObject: 0,
-      polygonRing: 0,
-      polygonFeature: 0,
-      feature: 0
-    };
-    for (const feature of features) {
-      const geometry = feature.geometry;
-      const properties = feature.properties || {};
-      switch (geometry.type) {
-        case "Point":
-          handlePoint(geometry.coordinates, points, indexMap, coordLength, properties);
-          points.properties.push(keepStringProperties(properties, numericPropKeys));
-          indexMap.pointFeature++;
-          break;
-        case "MultiPoint":
-          handleMultiPoint(geometry.coordinates, points, indexMap, coordLength, properties);
-          points.properties.push(keepStringProperties(properties, numericPropKeys));
-          indexMap.pointFeature++;
-          break;
-        case "LineString":
-          handleLineString(geometry.coordinates, lines, indexMap, coordLength, properties);
-          lines.properties.push(keepStringProperties(properties, numericPropKeys));
-          indexMap.lineFeature++;
-          break;
-        case "MultiLineString":
-          handleMultiLineString(geometry.coordinates, lines, indexMap, coordLength, properties);
-          lines.properties.push(keepStringProperties(properties, numericPropKeys));
-          indexMap.lineFeature++;
-          break;
-        case "Polygon":
-          handlePolygon(geometry.coordinates, polygons, indexMap, coordLength, properties);
-          polygons.properties.push(keepStringProperties(properties, numericPropKeys));
-          indexMap.polygonFeature++;
-          break;
-        case "MultiPolygon":
-          handleMultiPolygon(geometry.coordinates, polygons, indexMap, coordLength, properties);
-          polygons.properties.push(keepStringProperties(properties, numericPropKeys));
-          indexMap.polygonFeature++;
-          break;
-        default:
-          throw new Error("Invalid geometry type");
-      }
-      indexMap.feature++;
-    }
-    return makeAccessorObjects(points, lines, polygons, coordLength);
-  }
-  function handlePoint(coords, points, indexMap, coordLength, properties) {
-    points.positions.set(coords, indexMap.pointPosition * coordLength);
-    points.globalFeatureIds[indexMap.pointPosition] = indexMap.feature;
-    points.featureIds[indexMap.pointPosition] = indexMap.pointFeature;
-    fillNumericProperties(points, properties, indexMap.pointPosition, 1);
-    indexMap.pointPosition++;
-  }
-  function handleMultiPoint(coords, points, indexMap, coordLength, properties) {
-    for (const point of coords) {
-      handlePoint(point, points, indexMap, coordLength, properties);
-    }
-  }
-  function handleLineString(coords, lines, indexMap, coordLength, properties) {
-    lines.pathIndices[indexMap.linePath] = indexMap.linePosition;
-    indexMap.linePath++;
-    fillCoords(lines.positions, coords, indexMap.linePosition, coordLength);
-    const nPositions = coords.length;
-    fillNumericProperties(lines, properties, indexMap.linePosition, nPositions);
-    lines.globalFeatureIds.set(new Uint32Array(nPositions).fill(indexMap.feature), indexMap.linePosition);
-    lines.featureIds.set(new Uint32Array(nPositions).fill(indexMap.lineFeature), indexMap.linePosition);
-    indexMap.linePosition += nPositions;
-  }
-  function handleMultiLineString(coords, lines, indexMap, coordLength, properties) {
-    for (const line of coords) {
-      handleLineString(line, lines, indexMap, coordLength, properties);
-    }
-  }
-  function handlePolygon(coords, polygons, indexMap, coordLength, properties) {
-    polygons.polygonIndices[indexMap.polygonObject] = indexMap.polygonPosition;
-    indexMap.polygonObject++;
-    for (const ring of coords) {
-      polygons.primitivePolygonIndices[indexMap.polygonRing] = indexMap.polygonPosition;
-      indexMap.polygonRing++;
-      fillCoords(polygons.positions, ring, indexMap.polygonPosition, coordLength);
-      const nPositions = ring.length;
-      fillNumericProperties(polygons, properties, indexMap.polygonPosition, nPositions);
-      polygons.globalFeatureIds.set(new Uint32Array(nPositions).fill(indexMap.feature), indexMap.polygonPosition);
-      polygons.featureIds.set(new Uint32Array(nPositions).fill(indexMap.polygonFeature), indexMap.polygonPosition);
-      indexMap.polygonPosition += nPositions;
-    }
-  }
-  function handleMultiPolygon(coords, polygons, indexMap, coordLength, properties) {
-    for (const polygon of coords) {
-      handlePolygon(polygon, polygons, indexMap, coordLength, properties);
-    }
-  }
-  function makeAccessorObjects(points, lines, polygons, coordLength) {
-    const returnObj = {
-      points: {
-        ...points,
-        positions: { value: points.positions, size: coordLength },
-        globalFeatureIds: { value: points.globalFeatureIds, size: 1 },
-        featureIds: { value: points.featureIds, size: 1 },
-        type: "Point"
-      },
-      lines: {
-        ...lines,
-        pathIndices: { value: lines.pathIndices, size: 1 },
-        positions: { value: lines.positions, size: coordLength },
-        globalFeatureIds: { value: lines.globalFeatureIds, size: 1 },
-        featureIds: { value: lines.featureIds, size: 1 },
-        type: "LineString"
-      },
-      polygons: {
-        ...polygons,
-        polygonIndices: { value: polygons.polygonIndices, size: 1 },
-        primitivePolygonIndices: { value: polygons.primitivePolygonIndices, size: 1 },
-        positions: { value: polygons.positions, size: coordLength },
-        globalFeatureIds: { value: polygons.globalFeatureIds, size: 1 },
-        featureIds: { value: polygons.featureIds, size: 1 },
-        type: "Polygon"
-      }
-    };
-    for (const geomType in returnObj) {
-      for (const numericProp in returnObj[geomType].numericProps) {
-        returnObj[geomType].numericProps[numericProp] = {
-          value: returnObj[geomType].numericProps[numericProp],
-          size: 1
-        };
-      }
-    }
-    return returnObj;
-  }
-  function fillNumericProperties(object, properties, index, length) {
-    for (const numericPropName in object.numericProps) {
-      if (numericPropName in properties) {
-        object.numericProps[numericPropName].set(new Array(length).fill(properties[numericPropName]), index);
-      }
-    }
-  }
-  function keepStringProperties(properties, numericKeys) {
-    const props = {};
-    for (const key in properties) {
-      if (!numericKeys.includes(key)) {
-        props[key] = properties[key];
-      }
-    }
-    return props;
-  }
-  function fillCoords(array, coords, startVertex, coordLength) {
-    let index = startVertex * coordLength;
-    for (const coord of coords) {
-      array.set(coord, index);
-      index += coordLength;
-    }
-  }
-  function flatten(arrays) {
-    return [].concat(...arrays);
-  }
-  function isNumeric(x) {
-    return Number.isFinite(x);
-  }
-  var init_geojson_to_binary = __esm({
-    "../gis/src/lib/geojson-to-binary.ts"() {
-    }
-  });
-
-  // ../gis/src/index.ts
-  var init_src = __esm({
-    "../gis/src/index.ts"() {
-      init_geojson_to_binary();
-    }
-  });
-
-  // ../../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 });
-        }
-        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 { 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 (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":
-        return doc;
-      default:
-        throw new Error();
-    }
-  }
-  var import_togeojson, VERSION, GPX_HEADER, GPXLoader;
-  var init_gpx_loader = __esm({
-    "src/gpx-loader.ts"() {
-      init_src();
-      import_togeojson = __toModule(require_togeojson_umd());
-      VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
-      GPX_HEADER = `<?xml version="1.0" encoding="UTF-8"?>
-<gpx`;
-      GPXLoader = {
-        name: "GPX (GPS exchange format)",
-        id: "gpx",
-        module: "kml",
-        version: VERSION,
-        extensions: ["gpx"],
-        mimeTypes: ["application/gpx+xml"],
-        text: true,
-        tests: [GPX_HEADER],
-        parse: async (arrayBuffer, options) => parseTextSync(new TextDecoder().decode(arrayBuffer), options),
-        parseTextSync,
-        options: {
-          gpx: {},
-          gis: { format: "geojson" }
-        }
-      };
-    }
-  });
-
-  // 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) {
-      case "geojson":
-        return geojson;
-      case "binary":
-        return geojsonToBinary(geojson.features);
-      case "raw":
-        return doc;
-      default:
-        throw new Error();
-    }
-  }
-  var import_togeojson2, VERSION2, KML_HEADER, KMLLoader;
-  var init_kml_loader = __esm({
-    "src/kml-loader.ts"() {
-      init_src();
-      import_togeojson2 = __toModule(require_togeojson_umd());
-      VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
-      KML_HEADER = `<?xml version="1.0" encoding="UTF-8"?>
-<kml xmlns="http://www.opengis.net/kml/2.2">`;
-      KMLLoader = {
-        name: "KML (Keyhole Markup Language)",
-        id: "kml",
-        module: "kml",
-        version: VERSION2,
-        extensions: ["kml"],
-        mimeTypes: ["application/vnd.google-earth.kml+xml"],
-        text: true,
-        tests: [KML_HEADER],
-        parse: async (arrayBuffer, options) => parseTextSync2(new TextDecoder().decode(arrayBuffer), options),
-        parseTextSync: parseTextSync2,
-        options: {
-          kml: {},
-          gis: { format: "geojson" }
-        }
-      };
-    }
-  });
-
-  // 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) {
-      case "geojson":
-        return geojson;
-      case "binary":
-        return geojsonToBinary(geojson.features);
-      case "raw":
-        return doc;
-      default:
-        throw new Error();
-    }
-  }
-  var import_togeojson3, VERSION3, TCX_HEADER, TCXLoader;
-  var init_tcx_loader = __esm({
-    "src/tcx-loader.ts"() {
-      init_src();
-      import_togeojson3 = __toModule(require_togeojson_umd());
-      VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
-      TCX_HEADER = `<?xml version="1.0" encoding="UTF-8"?>
-<TrainingCenterDatabase`;
-      TCXLoader = {
-        name: "TCX (Training Center XML)",
-        id: "tcx",
-        module: "kml",
-        version: VERSION3,
-        extensions: ["tcx"],
-        mimeTypes: ["application/vnd.garmin.tcx+xml"],
-        text: true,
-        tests: [TCX_HEADER],
-        parse: async (arrayBuffer, options) => parseTextSync3(new TextDecoder().decode(arrayBuffer), options),
-        parseTextSync: parseTextSync3,
-        options: {
-          tcx: {},
-          gis: { format: "geojson" }
-        }
-      };
-    }
-  });
-
-  // src/index.ts
-  var src_exports = {};
-  __export(src_exports, {
-    GPXLoader: () => GPXLoader,
-    KMLLoader: () => KMLLoader,
-    TCXLoader: () => TCXLoader
-  });
-  var init_src2 = __esm({
-    "src/index.ts"() {
-      init_gpx_loader();
-      init_kml_loader();
-      init_tcx_loader();
-    }
-  });
-
-  // src/bundle.ts
-  var require_bundle = __commonJS({
-    "src/bundle.ts"(exports, module) {
-      var moduleExports = (init_src2(), src_exports);
-      globalThis.loaders = globalThis.loaders || {};
-      module.exports = Object.assign(globalThis.loaders, moduleExports);
-    }
-  });
-  require_bundle();
-})();
+"use strict";
+// @ts-nocheck
+const moduleExports = require('./index');
+globalThis.loaders = globalThis.loaders || {};
+module.exports = Object.assign(globalThis.loaders, moduleExports);