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

package/dist/dist.min.js

@@ -0,0 +1,1529 @@
+(() => {
+  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);
+  };
+
+  // ../../node_modules/@math.gl/polygon/dist/esm/polygon-utils.js
+  function getPolygonSignedArea(points, options = {}) {
+    const {
+      start = 0,
+      end = points.length
+    } = options;
+    const dim = options.size || 2;
+    let area2 = 0;
+    for (let i = start, j = end - dim; i < end; i += dim) {
+      area2 += (points[i] - points[j]) * (points[i + 1] + points[j + 1]);
+      j = i;
+    }
+    return area2 / 2;
+  }
+  var init_polygon_utils = __esm({
+    "../../node_modules/@math.gl/polygon/dist/esm/polygon-utils.js"() {
+    }
+  });
+
+  // ../../node_modules/@math.gl/polygon/dist/esm/polygon.js
+  var init_polygon = __esm({
+    "../../node_modules/@math.gl/polygon/dist/esm/polygon.js"() {
+      init_polygon_utils();
+    }
+  });
+
+  // ../../node_modules/@math.gl/polygon/dist/esm/earcut.js
+  function earcut(data, holeIndices, dim, areas) {
+    dim = dim || 2;
+    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 triangles = [];
+    if (!outerNode || outerNode.next === outerNode.prev)
+      return triangles;
+    let invSize;
+    let maxX;
+    let maxY;
+    let minX;
+    let minY;
+    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];
+      for (let i = dim; i < outerLen; i += dim) {
+        x = data[i];
+        y = data[i + 1];
+        if (x < minX)
+          minX = x;
+        if (y < minY)
+          minY = y;
+        if (x > maxX)
+          maxX = x;
+        if (y > maxY)
+          maxY = y;
+      }
+      invSize = Math.max(maxX - minX, maxY - minY);
+      invSize = invSize !== 0 ? 1 / invSize : 0;
+    }
+    earcutLinked(outerNode, triangles, dim, minX, minY, invSize);
+    return triangles;
+  }
+  function linkedList(data, start, end, dim, clockwise, area2) {
+    let i;
+    let last;
+    if (area2 === void 0) {
+      area2 = getPolygonSignedArea(data, {
+        start,
+        end,
+        size: dim
+      });
+    }
+    if (clockwise === area2 < 0) {
+      for (i = start; i < end; i += dim)
+        last = insertNode(i, data[i], data[i + 1], last);
+    } else {
+      for (i = end - dim; i >= start; i -= dim)
+        last = insertNode(i, data[i], data[i + 1], last);
+    }
+    if (last && equals(last, last.next)) {
+      removeNode(last);
+      last = last.next;
+    }
+    return last;
+  }
+  function filterPoints(start, end) {
+    if (!start)
+      return start;
+    if (!end)
+      end = start;
+    let p = start;
+    let again;
+    do {
+      again = false;
+      if (!p.steiner && (equals(p, p.next) || area(p.prev, p, p.next) === 0)) {
+        removeNode(p);
+        p = end = p.prev;
+        if (p === p.next)
+          break;
+        again = true;
+      } else {
+        p = p.next;
+      }
+    } while (again || p !== end);
+    return end;
+  }
+  function earcutLinked(ear, triangles, dim, minX, minY, invSize, pass) {
+    if (!ear)
+      return;
+    if (!pass && invSize)
+      indexCurve(ear, minX, minY, invSize);
+    let stop = ear;
+    let prev;
+    let next;
+    while (ear.prev !== ear.next) {
+      prev = ear.prev;
+      next = ear.next;
+      if (invSize ? isEarHashed(ear, minX, minY, invSize) : isEar(ear)) {
+        triangles.push(prev.i / dim);
+        triangles.push(ear.i / dim);
+        triangles.push(next.i / dim);
+        removeNode(ear);
+        ear = next.next;
+        stop = next.next;
+        continue;
+      }
+      ear = next;
+      if (ear === stop) {
+        if (!pass) {
+          earcutLinked(filterPoints(ear), triangles, dim, minX, minY, invSize, 1);
+        } else if (pass === 1) {
+          ear = cureLocalIntersections(filterPoints(ear), triangles, dim);
+          earcutLinked(ear, triangles, dim, minX, minY, invSize, 2);
+        } else if (pass === 2) {
+          splitEarcut(ear, triangles, dim, minX, minY, invSize);
+        }
+        break;
+      }
+    }
+  }
+  function isEar(ear) {
+    const a = ear.prev;
+    const b = ear;
+    const c = ear.next;
+    if (area(a, b, c) >= 0)
+      return false;
+    let p = ear.next.next;
+    while (p !== ear.prev) {
+      if (pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) && area(p.prev, p, p.next) >= 0)
+        return false;
+      p = p.next;
+    }
+    return true;
+  }
+  function isEarHashed(ear, minX, minY, invSize) {
+    const a = ear.prev;
+    const b = ear;
+    const c = ear.next;
+    if (area(a, b, c) >= 0)
+      return false;
+    const minTX = a.x < b.x ? a.x < c.x ? a.x : c.x : b.x < c.x ? b.x : c.x;
+    const minTY = a.y < b.y ? a.y < c.y ? a.y : c.y : b.y < c.y ? b.y : c.y;
+    const maxTX = a.x > b.x ? a.x > c.x ? a.x : c.x : b.x > c.x ? b.x : c.x;
+    const maxTY = a.y > b.y ? a.y > c.y ? a.y : c.y : b.y > c.y ? b.y : c.y;
+    const minZ = zOrder(minTX, minTY, minX, minY, invSize);
+    const maxZ = zOrder(maxTX, maxTY, minX, minY, invSize);
+    let p = ear.prevZ;
+    let n = ear.nextZ;
+    while (p && p.z >= minZ && n && n.z <= maxZ) {
+      if (p !== ear.prev && p !== ear.next && pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) && area(p.prev, p, p.next) >= 0)
+        return false;
+      p = p.prevZ;
+      if (n !== ear.prev && n !== ear.next && pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, n.x, n.y) && area(n.prev, n, n.next) >= 0)
+        return false;
+      n = n.nextZ;
+    }
+    while (p && p.z >= minZ) {
+      if (p !== ear.prev && p !== ear.next && pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) && area(p.prev, p, p.next) >= 0)
+        return false;
+      p = p.prevZ;
+    }
+    while (n && n.z <= maxZ) {
+      if (n !== ear.prev && n !== ear.next && pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, n.x, n.y) && area(n.prev, n, n.next) >= 0)
+        return false;
+      n = n.nextZ;
+    }
+    return true;
+  }
+  function cureLocalIntersections(start, triangles, dim) {
+    let p = start;
+    do {
+      const a = p.prev;
+      const b = p.next.next;
+      if (!equals(a, b) && intersects(a, p, p.next, b) && locallyInside(a, b) && locallyInside(b, a)) {
+        triangles.push(a.i / dim);
+        triangles.push(p.i / dim);
+        triangles.push(b.i / dim);
+        removeNode(p);
+        removeNode(p.next);
+        p = start = b;
+      }
+      p = p.next;
+    } while (p !== start);
+    return filterPoints(p);
+  }
+  function splitEarcut(start, triangles, dim, minX, minY, invSize) {
+    let a = start;
+    do {
+      let b = a.next.next;
+      while (b !== a.prev) {
+        if (a.i !== b.i && isValidDiagonal(a, b)) {
+          let c = splitPolygon(a, b);
+          a = filterPoints(a, a.next);
+          c = filterPoints(c, c.next);
+          earcutLinked(a, triangles, dim, minX, minY, invSize);
+          earcutLinked(c, triangles, dim, minX, minY, invSize);
+          return;
+        }
+        b = b.next;
+      }
+      a = a.next;
+    } while (a !== start);
+  }
+  function eliminateHoles(data, holeIndices, outerNode, dim, areas) {
+    const queue = [];
+    let i;
+    let len;
+    let start;
+    let end;
+    let list;
+    for (i = 0, len = holeIndices.length; i < len; i++) {
+      start = holeIndices[i] * dim;
+      end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;
+      list = linkedList(data, start, end, dim, false, areas && areas[i + 1]);
+      if (list === list.next)
+        list.steiner = true;
+      queue.push(getLeftmost(list));
+    }
+    queue.sort(compareX);
+    for (i = 0; i < queue.length; i++) {
+      eliminateHole(queue[i], outerNode);
+      outerNode = filterPoints(outerNode, outerNode.next);
+    }
+    return outerNode;
+  }
+  function compareX(a, b) {
+    return a.x - b.x;
+  }
+  function eliminateHole(hole, outerNode) {
+    outerNode = findHoleBridge(hole, outerNode);
+    if (outerNode) {
+      const b = splitPolygon(outerNode, hole);
+      filterPoints(outerNode, outerNode.next);
+      filterPoints(b, b.next);
+    }
+  }
+  function findHoleBridge(hole, outerNode) {
+    let p = outerNode;
+    const hx = hole.x;
+    const hy = hole.y;
+    let qx = -Infinity;
+    let m;
+    do {
+      if (hy <= p.y && hy >= p.next.y && p.next.y !== p.y) {
+        const x = p.x + (hy - p.y) * (p.next.x - p.x) / (p.next.y - p.y);
+        if (x <= hx && x > qx) {
+          qx = x;
+          if (x === hx) {
+            if (hy === p.y)
+              return p;
+            if (hy === p.next.y)
+              return p.next;
+          }
+          m = p.x < p.next.x ? p : p.next;
+        }
+      }
+      p = p.next;
+    } while (p !== outerNode);
+    if (!m)
+      return null;
+    if (hx === qx)
+      return m;
+    const stop = m;
+    const mx = m.x;
+    const my = m.y;
+    let tanMin = Infinity;
+    let tan;
+    p = m;
+    do {
+      if (hx >= p.x && p.x >= mx && hx !== p.x && pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.x, p.y)) {
+        tan = Math.abs(hy - p.y) / (hx - p.x);
+        if (locallyInside(p, hole) && (tan < tanMin || tan === tanMin && (p.x > m.x || p.x === m.x && sectorContainsSector(m, p)))) {
+          m = p;
+          tanMin = tan;
+        }
+      }
+      p = p.next;
+    } while (p !== stop);
+    return m;
+  }
+  function sectorContainsSector(m, p) {
+    return area(m.prev, m, p.prev) < 0 && area(p.next, m, m.next) < 0;
+  }
+  function indexCurve(start, minX, minY, invSize) {
+    let p = start;
+    do {
+      if (p.z === null)
+        p.z = zOrder(p.x, p.y, minX, minY, invSize);
+      p.prevZ = p.prev;
+      p.nextZ = p.next;
+      p = p.next;
+    } while (p !== start);
+    p.prevZ.nextZ = null;
+    p.prevZ = null;
+    sortLinked(p);
+  }
+  function sortLinked(list) {
+    let e;
+    let i;
+    let inSize = 1;
+    let numMerges;
+    let p;
+    let pSize;
+    let q;
+    let qSize;
+    let tail;
+    do {
+      p = list;
+      list = null;
+      tail = null;
+      numMerges = 0;
+      while (p) {
+        numMerges++;
+        q = p;
+        pSize = 0;
+        for (i = 0; i < inSize; i++) {
+          pSize++;
+          q = q.nextZ;
+          if (!q)
+            break;
+        }
+        qSize = inSize;
+        while (pSize > 0 || qSize > 0 && q) {
+          if (pSize !== 0 && (qSize === 0 || !q || p.z <= q.z)) {
+            e = p;
+            p = p.nextZ;
+            pSize--;
+          } else {
+            e = q;
+            q = q.nextZ;
+            qSize--;
+          }
+          if (tail)
+            tail.nextZ = e;
+          else
+            list = e;
+          e.prevZ = tail;
+          tail = e;
+        }
+        p = q;
+      }
+      tail.nextZ = null;
+      inSize *= 2;
+    } while (numMerges > 1);
+    return list;
+  }
+  function zOrder(x, y, minX, minY, invSize) {
+    x = 32767 * (x - minX) * invSize;
+    y = 32767 * (y - minY) * invSize;
+    x = (x | x << 8) & 16711935;
+    x = (x | x << 4) & 252645135;
+    x = (x | x << 2) & 858993459;
+    x = (x | x << 1) & 1431655765;
+    y = (y | y << 8) & 16711935;
+    y = (y | y << 4) & 252645135;
+    y = (y | y << 2) & 858993459;
+    y = (y | y << 1) & 1431655765;
+    return x | y << 1;
+  }
+  function getLeftmost(start) {
+    let p = start;
+    let leftmost = start;
+    do {
+      if (p.x < leftmost.x || p.x === leftmost.x && p.y < leftmost.y)
+        leftmost = p;
+      p = p.next;
+    } while (p !== start);
+    return leftmost;
+  }
+  function pointInTriangle(ax, ay, bx, by, cx, cy, px, py) {
+    return (cx - px) * (ay - py) - (ax - px) * (cy - py) >= 0 && (ax - px) * (by - py) - (bx - px) * (ay - py) >= 0 && (bx - px) * (cy - py) - (cx - px) * (by - py) >= 0;
+  }
+  function isValidDiagonal(a, b) {
+    return a.next.i !== b.i && a.prev.i !== b.i && !intersectsPolygon(a, b) && (locallyInside(a, b) && locallyInside(b, a) && middleInside(a, b) && (area(a.prev, a, b.prev) || area(a, b.prev, b)) || equals(a, b) && area(a.prev, a, a.next) > 0 && area(b.prev, b, b.next) > 0);
+  }
+  function area(p, q, r) {
+    return (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
+  }
+  function equals(p1, p2) {
+    return p1.x === p2.x && p1.y === p2.y;
+  }
+  function intersects(p1, q1, p2, q2) {
+    const o1 = sign(area(p1, q1, p2));
+    const o2 = sign(area(p1, q1, q2));
+    const o3 = sign(area(p2, q2, p1));
+    const o4 = sign(area(p2, q2, q1));
+    if (o1 !== o2 && o3 !== o4)
+      return true;
+    if (o1 === 0 && onSegment(p1, p2, q1))
+      return true;
+    if (o2 === 0 && onSegment(p1, q2, q1))
+      return true;
+    if (o3 === 0 && onSegment(p2, p1, q2))
+      return true;
+    if (o4 === 0 && onSegment(p2, q1, q2))
+      return true;
+    return false;
+  }
+  function onSegment(p, q, r) {
+    return q.x <= Math.max(p.x, r.x) && q.x >= Math.min(p.x, r.x) && q.y <= Math.max(p.y, r.y) && q.y >= Math.min(p.y, r.y);
+  }
+  function sign(num) {
+    return num > 0 ? 1 : num < 0 ? -1 : 0;
+  }
+  function intersectsPolygon(a, b) {
+    let p = a;
+    do {
+      if (p.i !== a.i && p.next.i !== a.i && p.i !== b.i && p.next.i !== b.i && intersects(p, p.next, a, b))
+        return true;
+      p = p.next;
+    } while (p !== a);
+    return false;
+  }
+  function locallyInside(a, b) {
+    return area(a.prev, a, a.next) < 0 ? area(a, b, a.next) >= 0 && area(a, a.prev, b) >= 0 : area(a, b, a.prev) < 0 || area(a, a.next, b) < 0;
+  }
+  function middleInside(a, b) {
+    let p = a;
+    let inside = false;
+    const px = (a.x + b.x) / 2;
+    const py = (a.y + b.y) / 2;
+    do {
+      if (p.y > py !== p.next.y > py && p.next.y !== p.y && px < (p.next.x - p.x) * (py - p.y) / (p.next.y - p.y) + p.x)
+        inside = !inside;
+      p = p.next;
+    } while (p !== a);
+    return inside;
+  }
+  function splitPolygon(a, b) {
+    const a2 = new Node(a.i, a.x, a.y);
+    const b2 = new Node(b.i, b.x, b.y);
+    const an = a.next;
+    const bp = b.prev;
+    a.next = b;
+    b.prev = a;
+    a2.next = an;
+    an.prev = a2;
+    b2.next = a2;
+    a2.prev = b2;
+    bp.next = b2;
+    b2.prev = bp;
+    return b2;
+  }
+  function insertNode(i, x, y, last) {
+    const p = new Node(i, x, y);
+    if (!last) {
+      p.prev = p;
+      p.next = p;
+    } else {
+      p.next = last.next;
+      p.prev = last;
+      last.next.prev = p;
+      last.next = p;
+    }
+    return p;
+  }
+  function removeNode(p) {
+    p.next.prev = p.prev;
+    p.prev.next = p.next;
+    if (p.prevZ)
+      p.prevZ.nextZ = p.nextZ;
+    if (p.nextZ)
+      p.nextZ.prevZ = p.prevZ;
+  }
+  function Node(i, x, y) {
+    this.i = i;
+    this.x = x;
+    this.y = y;
+    this.prev = null;
+    this.next = null;
+    this.z = null;
+    this.prevZ = null;
+    this.nextZ = null;
+    this.steiner = false;
+  }
+  var init_earcut = __esm({
+    "../../node_modules/@math.gl/polygon/dist/esm/earcut.js"() {
+      init_polygon_utils();
+    }
+  });
+
+  // ../../node_modules/@math.gl/polygon/dist/esm/utils.js
+  var init_utils = __esm({
+    "../../node_modules/@math.gl/polygon/dist/esm/utils.js"() {
+    }
+  });
+
+  // ../../node_modules/@math.gl/polygon/dist/esm/lineclip.js
+  var init_lineclip = __esm({
+    "../../node_modules/@math.gl/polygon/dist/esm/lineclip.js"() {
+      init_utils();
+    }
+  });
+
+  // ../../node_modules/@math.gl/polygon/dist/esm/cut-by-grid.js
+  var init_cut_by_grid = __esm({
+    "../../node_modules/@math.gl/polygon/dist/esm/cut-by-grid.js"() {
+      init_lineclip();
+      init_utils();
+    }
+  });
+
+  // ../../node_modules/@math.gl/polygon/dist/esm/cut-by-mercator-bounds.js
+  var init_cut_by_mercator_bounds = __esm({
+    "../../node_modules/@math.gl/polygon/dist/esm/cut-by-mercator-bounds.js"() {
+      init_cut_by_grid();
+      init_utils();
+    }
+  });
+
+  // ../../node_modules/@math.gl/polygon/dist/esm/index.js
+  var init_esm = __esm({
+    "../../node_modules/@math.gl/polygon/dist/esm/index.js"() {
+      init_polygon();
+      init_polygon_utils();
+      init_earcut();
+      init_lineclip();
+      init_cut_by_grid();
+      init_cut_by_mercator_bounds();
+      init_polygon();
+    }
+  });
+
+  // ../gis/src/lib/flat-geojson-to-binary.ts
+  function flatGeojsonToBinary(features, geometryInfo, options) {
+    const propArrayTypes = extractNumericPropTypes(features);
+    const numericPropKeys = Object.keys(propArrayTypes).filter((k) => propArrayTypes[k] !== Array);
+    return fillArrays(features, {
+      propArrayTypes,
+      ...geometryInfo
+    }, {
+      numericPropKeys: options && options.numericPropKeys || numericPropKeys,
+      PositionDataType: options ? options.PositionDataType : Float32Array
+    });
+  }
+  function extractNumericPropTypes(features) {
+    const propArrayTypes = {};
+    for (const feature of features) {
+      if (feature.properties) {
+        for (const key in feature.properties) {
+          const val = feature.properties[key];
+          propArrayTypes[key] = deduceArrayType(val, propArrayTypes[key]);
+        }
+      }
+    }
+    return propArrayTypes;
+  }
+  function fillArrays(features, geometryInfo, options) {
+    const {
+      pointPositionsCount,
+      pointFeaturesCount,
+      linePositionsCount,
+      linePathsCount,
+      lineFeaturesCount,
+      polygonPositionsCount,
+      polygonObjectsCount,
+      polygonRingsCount,
+      polygonFeaturesCount,
+      propArrayTypes,
+      coordLength
+    } = geometryInfo;
+    const { numericPropKeys = [], PositionDataType = Float32Array } = options;
+    const hasGlobalId = features[0] && "id" in features[0];
+    const GlobalFeatureIdsDataType = features.length > 65535 ? Uint32Array : Uint16Array;
+    const points = {
+      type: "Point",
+      positions: new PositionDataType(pointPositionsCount * coordLength),
+      globalFeatureIds: new GlobalFeatureIdsDataType(pointPositionsCount),
+      featureIds: pointFeaturesCount > 65535 ? new Uint32Array(pointPositionsCount) : new Uint16Array(pointPositionsCount),
+      numericProps: {},
+      properties: [],
+      fields: []
+    };
+    const lines = {
+      type: "LineString",
+      pathIndices: linePositionsCount > 65535 ? new Uint32Array(linePathsCount + 1) : new Uint16Array(linePathsCount + 1),
+      positions: new PositionDataType(linePositionsCount * coordLength),
+      globalFeatureIds: new GlobalFeatureIdsDataType(linePositionsCount),
+      featureIds: lineFeaturesCount > 65535 ? new Uint32Array(linePositionsCount) : new Uint16Array(linePositionsCount),
+      numericProps: {},
+      properties: [],
+      fields: []
+    };
+    const polygons = {
+      type: "Polygon",
+      polygonIndices: polygonPositionsCount > 65535 ? new Uint32Array(polygonObjectsCount + 1) : new Uint16Array(polygonObjectsCount + 1),
+      primitivePolygonIndices: polygonPositionsCount > 65535 ? new Uint32Array(polygonRingsCount + 1) : new Uint16Array(polygonRingsCount + 1),
+      positions: new PositionDataType(polygonPositionsCount * coordLength),
+      triangles: [],
+      globalFeatureIds: new GlobalFeatureIdsDataType(polygonPositionsCount),
+      featureIds: polygonFeaturesCount > 65535 ? new Uint32Array(polygonPositionsCount) : new Uint16Array(polygonPositionsCount),
+      numericProps: {},
+      properties: [],
+      fields: []
+    };
+    for (const object of [points, lines, polygons]) {
+      for (const propName of numericPropKeys) {
+        const T = propArrayTypes[propName];
+        object.numericProps[propName] = new T(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, points, indexMap, coordLength, properties);
+          points.properties.push(keepStringProperties(properties, numericPropKeys));
+          if (hasGlobalId) {
+            points.fields.push({ id: feature.id });
+          }
+          indexMap.pointFeature++;
+          break;
+        case "LineString":
+          handleLineString(geometry, lines, indexMap, coordLength, properties);
+          lines.properties.push(keepStringProperties(properties, numericPropKeys));
+          if (hasGlobalId) {
+            lines.fields.push({ id: feature.id });
+          }
+          indexMap.lineFeature++;
+          break;
+        case "Polygon":
+          handlePolygon(geometry, polygons, indexMap, coordLength, properties);
+          polygons.properties.push(keepStringProperties(properties, numericPropKeys));
+          if (hasGlobalId) {
+            polygons.fields.push({ id: feature.id });
+          }
+          indexMap.polygonFeature++;
+          break;
+        default:
+          throw new Error("Invalid geometry type");
+      }
+      indexMap.feature++;
+    }
+    return makeAccessorObjects(points, lines, polygons, coordLength);
+  }
+  function handlePoint(geometry, points, indexMap, coordLength, properties) {
+    points.positions.set(geometry.data, indexMap.pointPosition * coordLength);
+    const nPositions = geometry.data.length / coordLength;
+    fillNumericProperties(points, properties, indexMap.pointPosition, nPositions);
+    points.globalFeatureIds.fill(indexMap.feature, indexMap.pointPosition, indexMap.pointPosition + nPositions);
+    points.featureIds.fill(indexMap.pointFeature, indexMap.pointPosition, indexMap.pointPosition + nPositions);
+    indexMap.pointPosition += nPositions;
+  }
+  function handleLineString(geometry, lines, indexMap, coordLength, properties) {
+    lines.positions.set(geometry.data, indexMap.linePosition * coordLength);
+    const nPositions = geometry.data.length / coordLength;
+    fillNumericProperties(lines, properties, indexMap.linePosition, nPositions);
+    lines.globalFeatureIds.fill(indexMap.feature, indexMap.linePosition, indexMap.linePosition + nPositions);
+    lines.featureIds.fill(indexMap.lineFeature, indexMap.linePosition, indexMap.linePosition + nPositions);
+    for (let i = 0, il = geometry.indices.length; i < il; ++i) {
+      const start = geometry.indices[i];
+      const end = i === il - 1 ? geometry.data.length : geometry.indices[i + 1];
+      lines.pathIndices[indexMap.linePath++] = indexMap.linePosition;
+      indexMap.linePosition += (end - start) / coordLength;
+    }
+  }
+  function handlePolygon(geometry, polygons, indexMap, coordLength, properties) {
+    polygons.positions.set(geometry.data, indexMap.polygonPosition * coordLength);
+    const nPositions = geometry.data.length / coordLength;
+    fillNumericProperties(polygons, properties, indexMap.polygonPosition, nPositions);
+    polygons.globalFeatureIds.fill(indexMap.feature, indexMap.polygonPosition, indexMap.polygonPosition + nPositions);
+    polygons.featureIds.fill(indexMap.polygonFeature, indexMap.polygonPosition, indexMap.polygonPosition + nPositions);
+    for (let l = 0, ll = geometry.indices.length; l < ll; ++l) {
+      const startPosition = indexMap.polygonPosition;
+      polygons.polygonIndices[indexMap.polygonObject++] = startPosition;
+      const areas = geometry.areas[l];
+      const indices = geometry.indices[l];
+      const nextIndices = geometry.indices[l + 1];
+      for (let i = 0, il = indices.length; i < il; ++i) {
+        const start = indices[i];
+        const end = i === il - 1 ? nextIndices === void 0 ? geometry.data.length : nextIndices[0] : indices[i + 1];
+        polygons.primitivePolygonIndices[indexMap.polygonRing++] = indexMap.polygonPosition;
+        indexMap.polygonPosition += (end - start) / coordLength;
+      }
+      const endPosition = indexMap.polygonPosition;
+      triangulatePolygon(polygons, areas, indices, { startPosition, endPosition, coordLength });
+    }
+  }
+  function triangulatePolygon(polygons, areas, indices, {
+    startPosition,
+    endPosition,
+    coordLength
+  }) {
+    const start = startPosition * coordLength;
+    const end = endPosition * coordLength;
+    const polygonPositions = polygons.positions.subarray(start, end);
+    const offset = indices[0];
+    const holes = indices.slice(1).map((n) => (n - offset) / coordLength);
+    const triangles = earcut(polygonPositions, holes, coordLength, areas);
+    for (let t = 0, tl = triangles.length; t < tl; ++t) {
+      polygons.triangles.push(startPosition + triangles[t]);
+    }
+  }
+  function wrapProps(obj, size) {
+    const returnObj = {};
+    for (const key in obj) {
+      returnObj[key] = { value: obj[key], size };
+    }
+    return returnObj;
+  }
+  function makeAccessorObjects(points, lines, polygons, coordLength) {
+    return {
+      points: {
+        ...points,
+        positions: { value: points.positions, size: coordLength },
+        globalFeatureIds: { value: points.globalFeatureIds, size: 1 },
+        featureIds: { value: points.featureIds, size: 1 },
+        numericProps: wrapProps(points.numericProps, 1)
+      },
+      lines: {
+        ...lines,
+        positions: { value: lines.positions, size: coordLength },
+        pathIndices: { value: lines.pathIndices, size: 1 },
+        globalFeatureIds: { value: lines.globalFeatureIds, size: 1 },
+        featureIds: { value: lines.featureIds, size: 1 },
+        numericProps: wrapProps(lines.numericProps, 1)
+      },
+      polygons: {
+        ...polygons,
+        positions: { value: polygons.positions, size: coordLength },
+        polygonIndices: { value: polygons.polygonIndices, size: 1 },
+        primitivePolygonIndices: { value: polygons.primitivePolygonIndices, size: 1 },
+        triangles: { value: new Uint32Array(polygons.triangles), size: 1 },
+        globalFeatureIds: { value: polygons.globalFeatureIds, size: 1 },
+        featureIds: { value: polygons.featureIds, size: 1 },
+        numericProps: wrapProps(polygons.numericProps, 1)
+      }
+    };
+  }
+  function fillNumericProperties(object, properties, index, length) {
+    for (const numericPropName in object.numericProps) {
+      if (numericPropName in properties) {
+        const value = properties[numericPropName];
+        object.numericProps[numericPropName].fill(value, index, index + length);
+      }
+    }
+  }
+  function keepStringProperties(properties, numericKeys) {
+    const props = {};
+    for (const key in properties) {
+      if (!numericKeys.includes(key)) {
+        props[key] = properties[key];
+      }
+    }
+    return props;
+  }
+  function deduceArrayType(x, constructor) {
+    if (constructor === Array || !Number.isFinite(x)) {
+      return Array;
+    }
+    return constructor === Float64Array || Math.fround(x) !== x ? Float64Array : Float32Array;
+  }
+  var init_flat_geojson_to_binary = __esm({
+    "../gis/src/lib/flat-geojson-to-binary.ts"() {
+      init_esm();
+    }
+  });
+
+  // ../gis/src/lib/extract-geometry-info.ts
+  function extractGeometryInfo(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();
+    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;
+          const flattened = geometry.coordinates.flat();
+          polygonPositionsCount += flattened.length;
+          for (const coord of flattened) {
+            coordLengths.add(coord.length);
+          }
+          break;
+        case "MultiPolygon":
+          polygonFeaturesCount++;
+          for (const polygon of geometry.coordinates) {
+            polygonObjectsCount++;
+            polygonRingsCount += polygon.length;
+            const flattened2 = polygon.flat();
+            polygonPositionsCount += flattened2.length;
+            for (const coord of flattened2) {
+              coordLengths.add(coord.length);
+            }
+          }
+          break;
+        default:
+          throw new Error(`Unsupported geometry type: ${geometry.type}`);
+      }
+    }
+    return {
+      coordLength: coordLengths.size > 0 ? Math.max(...coordLengths) : 2,
+      pointPositionsCount,
+      pointFeaturesCount,
+      linePositionsCount,
+      linePathsCount,
+      lineFeaturesCount,
+      polygonPositionsCount,
+      polygonObjectsCount,
+      polygonRingsCount,
+      polygonFeaturesCount
+    };
+  }
+  var init_extract_geometry_info = __esm({
+    "../gis/src/lib/extract-geometry-info.ts"() {
+    }
+  });
+
+  // ../gis/src/lib/geojson-to-flat-geojson.ts
+  function geojsonToFlatGeojson(features, options = { coordLength: 2, fixRingWinding: true }) {
+    return features.map((feature) => flattenFeature(feature, options));
+  }
+  function flattenPoint(coordinates, data, indices, options) {
+    indices.push(data.length);
+    data.push(...coordinates);
+    for (let i = coordinates.length; i < options.coordLength; i++) {
+      data.push(0);
+    }
+  }
+  function flattenLineString(coordinates, data, indices, options) {
+    indices.push(data.length);
+    for (const c of coordinates) {
+      data.push(...c);
+      for (let i = c.length; i < options.coordLength; i++) {
+        data.push(0);
+      }
+    }
+  }
+  function flattenPolygon(coordinates, data, indices, areas, options) {
+    let count = 0;
+    const ringAreas = [];
+    const polygons = [];
+    for (const lineString of coordinates) {
+      const lineString2d = lineString.map((p) => p.slice(0, 2));
+      let area2 = getPolygonSignedArea(lineString2d.flat());
+      const ccw = area2 < 0;
+      if (options.fixRingWinding && (count === 0 && !ccw || count > 0 && ccw)) {
+        lineString.reverse();
+        area2 = -area2;
+      }
+      ringAreas.push(area2);
+      flattenLineString(lineString, data, polygons, options);
+      count++;
+    }
+    if (count > 0) {
+      areas.push(ringAreas);
+      indices.push(polygons);
+    }
+  }
+  function flattenFeature(feature, options) {
+    const { geometry } = feature;
+    if (geometry.type === "GeometryCollection") {
+      throw new Error("GeometryCollection type not supported");
+    }
+    const data = [];
+    const indices = [];
+    let areas;
+    let type;
+    switch (geometry.type) {
+      case "Point":
+        type = "Point";
+        flattenPoint(geometry.coordinates, data, indices, options);
+        break;
+      case "MultiPoint":
+        type = "Point";
+        geometry.coordinates.map((c) => flattenPoint(c, data, indices, options));
+        break;
+      case "LineString":
+        type = "LineString";
+        flattenLineString(geometry.coordinates, data, indices, options);
+        break;
+      case "MultiLineString":
+        type = "LineString";
+        geometry.coordinates.map((c) => flattenLineString(c, data, indices, options));
+        break;
+      case "Polygon":
+        type = "Polygon";
+        areas = [];
+        flattenPolygon(geometry.coordinates, data, indices, areas, options);
+        break;
+      case "MultiPolygon":
+        type = "Polygon";
+        areas = [];
+        geometry.coordinates.map((c) => flattenPolygon(c, data, indices, areas, options));
+        break;
+      default:
+        throw new Error(`Unknown type: ${type}`);
+    }
+    return { ...feature, geometry: { type, indices, data, areas } };
+  }
+  var init_geojson_to_flat_geojson = __esm({
+    "../gis/src/lib/geojson-to-flat-geojson.ts"() {
+      init_esm();
+    }
+  });
+
+  // ../gis/src/lib/geojson-to-binary.ts
+  function geojsonToBinary(features, options = { fixRingWinding: true }) {
+    const geometryInfo = extractGeometryInfo(features);
+    const coordLength = geometryInfo.coordLength;
+    const { fixRingWinding } = options;
+    const flatFeatures = geojsonToFlatGeojson(features, { coordLength, fixRingWinding });
+    return flatGeojsonToBinary(flatFeatures, geometryInfo, {
+      numericPropKeys: options.numericPropKeys,
+      PositionDataType: options.PositionDataType || Float32Array
+    });
+  }
+  var init_geojson_to_binary = __esm({
+    "../gis/src/lib/geojson-to-binary.ts"() {
+      init_extract_geometry_info();
+      init_geojson_to_flat_geojson();
+      init_flat_geojson_to_binary();
+    }
+  });
+
+  // ../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();
+})();