diff --git a/package.json b/package.json
index 751a5c44..62e407af 100644
--- a/package.json
+++ b/package.json
@@ -28,7 +28,7 @@
 		"lint": "eslint --ext mjs src/",
 		"prepublishOnly": "npm lint; npm test; ./pre-publish",
 		"postpublish": "./release_web_ui; ./release_github_version",
-		"browserify": "browserify -r sync-request -r mproj -r buffer -r iconv-lite -r fs -r flatbush -r rw -r path -r kdbush -r @tmcw/togeojson -o www/modules.js",
+		"browserify": "browserify -r sync-request -r mproj -r buffer -r iconv-lite -r fs -r flatbush -r rw -r path -r kdbush -r @tmcw/togeojson -r @placemarkio/tokml -o www/modules.js",
 		"dev": "rollup --config --watch"
 	},
 	"main": "./mapshaper.js",
diff --git a/src/cli/mapshaper-cli-utils.mjs b/src/cli/mapshaper-cli-utils.mjs
index 01d996c7..66992429 100644
--- a/src/cli/mapshaper-cli-utils.mjs
+++ b/src/cli/mapshaper-cli-utils.mjs
@@ -19,6 +19,13 @@ cli.isFile = function(path, cache) {
   return ss && ss.isFile() || false;
 };
 
+cli.checkCommandEnv = function(cname) {
+  var blocked = ['i', 'include', 'require', 'external'];
+  if (runningInBrowser() && blocked.includes(cname)) {
+    stop('The -' + cname + ' command cannot be run in the browser');
+  }
+};
+
 // cli.fileSize = function(path) {
 //   var ss = cli.statSync(path);
 //   return ss && ss.size || 0;
diff --git a/src/cli/mapshaper-parse-commands.mjs b/src/cli/mapshaper-parse-commands.mjs
index 653e5836..9a654f69 100644
--- a/src/cli/mapshaper-parse-commands.mjs
+++ b/src/cli/mapshaper-parse-commands.mjs
@@ -2,6 +2,7 @@ import { getOptionParser } from '../cli/mapshaper-options';
 import { splitShellTokens } from '../cli/mapshaper-option-parsing-utils';
 import { stop } from '../utils/mapshaper-logging';
 import utils from '../utils/mapshaper-utils';
+import cli from './mapshaper-cli-utils';
 
 // Parse an array or a string of command line tokens into an array of
 // command objects.
@@ -23,12 +24,12 @@ export function standardizeConsoleCommands(raw) {
   var parser = getOptionParser();
   // support multiline string of commands pasted into console
   str = str.split(/\n+/g).map(function(str) {
-    var match = /^[a-z][\w-]*/.exec(str = str.trim());
+    var match = /^[a-z][\w-]*/i.exec(str = str.trim());
     //if (match && parser.isCommandName(match[0])) {
     if (match) {
       // add hyphen prefix to bare command
-       // also add hyphen to non-command strings, for a better error message
-       // ("unsupported command" instead of "The -i command cannot be run in the browser")
+      // also add hyphen to non-command strings, for a better error message
+      // ("unsupported command" instead of "The -i command cannot be run in the browser")
       str = '-' + str;
     }
     return str;
@@ -38,15 +39,10 @@ export function standardizeConsoleCommands(raw) {
 
 // Parse a command line string for the browser console
 export function parseConsoleCommands(raw) {
-  var blocked = ['i', 'include', 'require', 'external'];
   var str = standardizeConsoleCommands(raw);
-  var parsed;
-  parsed = parseCommands(str);
+  var parsed = parseCommands(str);
   parsed.forEach(function(cmd) {
-    var i = blocked.indexOf(cmd.name);
-    if (i > -1) {
-      stop("The -" + blocked[i] + " command cannot be run in the browser");
-    }
+    cli.checkCommandEnv(cmd.name);
   });
   return parsed;
 }
diff --git a/src/gui/gui-export-control.mjs b/src/gui/gui-export-control.mjs
index da1ddf40..e2f5f795 100644
--- a/src/gui/gui-export-control.mjs
+++ b/src/gui/gui-export-control.mjs
@@ -214,7 +214,7 @@ export var ExportControl = function(gui) {
   }
 
   function initFormatMenu() {
-    var defaults = ['shapefile', 'geojson', 'topojson', 'json', 'dsv', 'svg'];
+    var defaults = ['shapefile', 'geojson', 'topojson', 'json', 'dsv', 'kml', 'svg'];
     var formats = utils.uniq(defaults.concat(getInputFormats()));
     var items = formats.map(function(fmt) {
       return utils.format('<div><label><input type="radio" name="format" value="%s"' +
diff --git a/src/gui/gui-import-control.mjs b/src/gui/gui-import-control.mjs
index 68977401..c7db75ea 100644
--- a/src/gui/gui-import-control.mjs
+++ b/src/gui/gui-import-control.mjs
@@ -268,12 +268,14 @@ export function ImportControl(gui, opts) {
   async function expandFiles(files) {
     var files2 = [], expanded;
     for (var f of files) {
-      if (internal.isZipFile(f.name) || /\.kmz$/.test(f.name)) {
+      if (internal.isZipFile(f.name)) {
         expanded = await readZipFile(f);
-        files2 = files2.concat(expanded);
+      } else if (internal.isKmzFile(f.name)) {
+        expanded = await readKmzFile(f);
       } else {
-        files2.push(f);
+        expanded = [f];
       }
+      files2 = files2.concat(expanded);
     }
     return files2;
   }
@@ -430,6 +432,15 @@ export function ImportControl(gui, opts) {
     });
   }
 
+  async function readKmzFile(file) {
+    var files = await readZipFile(file);
+    var name = files[0] && files[0].name;
+    if (name == 'doc.kml') {
+      files[0].name = internal.replaceFileExtension(file.name, 'kml');
+    }
+    return files;
+  }
+
   async function readZipFile(file) {
     var files = [];
     await wait(35); // pause a beat so status message can display
diff --git a/src/io/mapshaper-export.mjs b/src/io/mapshaper-export.mjs
index 174fc80a..c7de0dd8 100644
--- a/src/io/mapshaper-export.mjs
+++ b/src/io/mapshaper-export.mjs
@@ -1,5 +1,6 @@
 import { getLayerBounds } from '../dataset/mapshaper-layer-utils';
 import { exportSVG } from '../svg/mapshaper-svg';
+import { exportKML } from '../kml/kml-export';
 import { exportDbf } from '../shapefile/dbf-export';
 import { exportDelim } from '../text/mapshaper-delim-export';
 import { exportShapefile } from '../shapefile/shp-export';
@@ -31,7 +32,7 @@ export function exportTargetLayers(targets, opts) {
 function exportDatasets(datasets, opts) {
   var format = getOutputFormat(datasets[0], opts);
   var files;
-  if (format == 'svg' || format == 'topojson' || format == 'geojson' && opts.combine_layers) {
+  if (format == 'kml' || format == 'svg' || format == 'topojson' || format == 'geojson' && opts.combine_layers) {
     // multi-layer formats: combine multiple datasets into one
     if (datasets.length > 1) {
       datasets = [mergeDatasetsForExport(datasets)];
@@ -85,8 +86,8 @@ export function exportFileContent(dataset, opts) {
   }, dataset);
 
   // Adjust layer names, so they can be used as output file names
-  // (except for multi-layer formats TopoJSON and SVG)
-  if (opts.file && outFmt != 'topojson' && outFmt != 'svg') {
+  // (except for multi-layer formats TopoJSON, SVG, KML)
+  if (opts.file && outFmt != 'topojson' && outFmt != 'svg'&& outFmt != 'kml') {
     dataset.layers.forEach(function(lyr) {
       lyr.name = getFileBase(opts.file);
     });
@@ -131,7 +132,8 @@ var exporters = {
   dsv: exportDelim,
   dbf: exportDbf,
   json: exportJSON,
-  svg: exportSVG
+  svg: exportSVG,
+  kml: exportKML
 };
 
 
diff --git a/src/io/mapshaper-file-import.mjs b/src/io/mapshaper-file-import.mjs
index f58db5dc..11d470ea 100644
--- a/src/io/mapshaper-file-import.mjs
+++ b/src/io/mapshaper-file-import.mjs
@@ -1,10 +1,15 @@
 import { importContent } from '../io/mapshaper-import';
-import { isSupportedBinaryInputType, guessInputContentType, guessInputFileType } from '../io/mapshaper-file-types';
+import {
+  isSupportedBinaryInputType,
+  guessInputContentType,
+  guessInputFileType,
+  isZipFile,
+  isKmzFile } from '../io/mapshaper-file-types';
 import cmd from '../mapshaper-cmd';
 import cli from '../cli/mapshaper-cli-utils';
 import utils from '../utils/mapshaper-utils';
 import { message, verbose, stop } from '../utils/mapshaper-logging';
-import { getFileExtension, replaceFileExtension } from '../utils/mapshaper-filename-utils';
+import { parseLocalPath, getFileExtension, replaceFileExtension } from '../utils/mapshaper-filename-utils';
 import { trimBOM, decodeString } from '../text/mapshaper-encodings';
 import { extractFiles } from './mapshaper-zip';
 import { buildTopology } from '../topology/mapshaper-topology';
@@ -12,32 +17,81 @@ import { cleanPathsAfterImport } from '../paths/mapshaper-path-import';
 import { mergeDatasets } from '../dataset/mapshaper-merging';
 
 cmd.importFiles = function(opts) {
-  var files = opts.files || [],
-      dataset;
+  var files = opts.files || [];
+  var dataset;
 
+  cli.checkCommandEnv('i');
   if (opts.stdin) {
     return importFile('/dev/stdin', opts);
   }
 
+
   if (files.length > 0 === false) {
     stop('Missing input file(s)');
   }
 
   verbose("Importing: " + files.join(' '));
-  if (files.length == 1 && /\.zip/i.test(files[0])) {
-    dataset = importZipFile(files[0], opts);
-  } else if (files.length == 1) {
+
+  // copy opts, so parameters can be modified within this command
+  opts = Object.assign({}, opts);
+  opts.input = Object.assign({}, opts.input); // make sure we have a cache
+
+  files = expandFiles(files, opts.input);
+
+  if (files.length === 0) {
+    stop('Missing importable files');
+  }
+
+  if (files.length == 1) {
     dataset = importFile(files[0], opts);
-  } else if (opts.merge_files) {
-    // TODO: deprecate and remove this option (use -merge-layers cmd instead)
-    dataset = importFilesTogether(files, opts);
-    dataset.layers = cmd.mergeLayers(dataset.layers);
   } else {
     dataset = importFilesTogether(files, opts);
   }
+
+  if (opts.merge_files && files.length > 1) {
+    // TODO: deprecate and remove this option (use -merge-layers cmd instead)
+    dataset.layers = cmd.mergeLayers(dataset.layers);
+  }
   return dataset;
 };
 
+function expandFiles(files, cache) {
+  var files2 = [];
+  files.forEach(function(file) {
+    var expanded;
+    if (isZipFile(file)) {
+      expanded = expandZipFile(file, cache);
+    } else if (isKmzFile(file)) {
+      expanded = expandKmzFile(file, cache);
+    } else {
+      expanded = [file]; // ordinary file, no change
+    }
+    files2 = files2.concat(expanded);
+  });
+  return files2;
+}
+
+function expandKmzFile(file, cache) {
+  var files = expandZipFile(file, cache);
+  var name = replaceFileExtension(parseLocalPath(file).filename, 'kml');
+  if (files[0] == 'doc.kml') {
+    files[0] = name;
+    cache[name] = cache['doc.kml'];
+  }
+  return files;
+}
+
+function expandZipFile(file, cache) {
+  var input;
+  if (file in cache) {
+    input = cache[file];
+  } else {
+    input = file;
+    cli.checkFileExists(file);
+  }
+  return extractFiles(input, cache);
+}
+
 // Let the web UI replace importFile() with a browser-friendly version
 export function replaceImportFile(func) {
   _importFile = func;
@@ -56,6 +110,7 @@ var _importFile = function(path, opts) {
       content;
 
   cli.checkFileExists(path, cache);
+
   if ((fileType == 'shp' || fileType == 'json' || fileType == 'text' || fileType == 'dbf') && !cached) {
     // these file types are read incrementally
     content = null;
@@ -78,6 +133,7 @@ var _importFile = function(path, opts) {
       stop('Unrecognized file type:', path);
     }
     // TODO: consider using a temp file, to support incremental reading
+    // read to buffer, even for string-based types (to support larger input files)
     content = require('zlib').gunzipSync(cli.readFile(pathgz));
 
   } else { // type can't be inferred from filename -- try reading as text
@@ -116,8 +172,8 @@ function importZipFile(path, opts) {
     input = path;
   }
   var files = extractFiles(input, cache);
-  var zipOpts = Object.assign({}, opts, {input: cache});
-  return importFilesTogether(files, zipOpts);
+  var zipOpts = Object.assign({}, opts, {input: cache, files: files});
+  return cmd.importFiles(zipOpts);
 }
 
 // Import multiple files to a single dataset
diff --git a/src/io/mapshaper-file-types.mjs b/src/io/mapshaper-file-types.mjs
index 102feb1c..92e0bc58 100644
--- a/src/io/mapshaper-file-types.mjs
+++ b/src/io/mapshaper-file-types.mjs
@@ -49,8 +49,12 @@ export function isZipFile(file) {
   return /\.zip$/i.test(file);
 }
 
+export function isKmzFile(file) {
+  return /\.kmz$/i.test(file);
+}
+
 export function isSupportedOutputFormat(fmt) {
-  var types = ['geojson', 'topojson', 'json', 'dsv', 'dbf', 'shapefile', 'svg'];
+  var types = ['geojson', 'topojson', 'json', 'dsv', 'dbf', 'shapefile', 'svg', 'kml'];
   return types.indexOf(fmt) > -1;
 }
 
@@ -61,6 +65,8 @@ export function getFormatName(fmt) {
     json: 'JSON records',
     dsv: 'CSV',
     dbf: 'DBF',
+    kml: 'KML',
+    kmz: 'KMZ',
     shapefile: 'Shapefile',
     svg: 'SVG'
   }[fmt] || '';
@@ -74,6 +80,6 @@ export function isSupportedBinaryInputType(path) {
 
 // Detect extensions of some unsupported file types, for cmd line validation
 export function filenameIsUnsupportedOutputType(file) {
-  var rxp = /\.(shx|prj|xls|xlsx|gdb|sbn|sbx|xml|kml)$/i;
+  var rxp = /\.(shx|prj|xls|xlsx|gdb|sbn|sbx|xml)$/i;
   return rxp.test(file);
 }
diff --git a/src/kml/kml-export.mjs b/src/kml/kml-export.mjs
new file mode 100644
index 00000000..755a7f09
--- /dev/null
+++ b/src/kml/kml-export.mjs
@@ -0,0 +1,17 @@
+import { exportDatasetAsGeoJSON } from '../geojson/geojson-export';
+import { getOutputFileBase } from '../utils/mapshaper-filename-utils';
+// import { isKmzFile } from '../io/mapshaper-file-types';
+
+export function exportKML(dataset, opts) {
+  var toKML = require("@placemarkio/tokml").toKML;
+  var geojsonOpts = Object.assign({combine_layers: true, geojson_type: 'FeatureCollection'}, opts);
+  var geojson = exportDatasetAsGeoJSON(dataset, geojsonOpts);
+  var kml = toKML(geojson);
+  // TODO: add KMZ output
+  // var useKmz = opts.file && isKmzFile(opts.file);
+  var ofile = opts.file || getOutputFileBase(dataset) + '.kml';
+  return [{
+    content: kml,
+    filename: ofile
+  }];
+}
\ No newline at end of file
diff --git a/test/data/kml/Albania.kmz b/test/data/kml/Albania.kmz
new file mode 100644
index 00000000..01ec35b8
Binary files /dev/null and b/test/data/kml/Albania.kmz differ
diff --git a/test/kml-test.mjs b/test/kml-test.mjs
new file mode 100644
index 00000000..a729d9fa
--- /dev/null
+++ b/test/kml-test.mjs
@@ -0,0 +1,24 @@
+import api from '../';
+import assert from 'assert';
+import fs from 'fs';
+
+describe('kml i/o', function () {
+
+  it('kmz -> kml -> .geojson', async function() {
+    var file = 'test/data/kml/Albania.kmz';
+    var cmd = `-i ${file} -o points.kml`;
+    var out = await api.applyCommands(cmd);
+    var cmd2 = '-i points.kml -o format=geojson';
+    var out2 = await api.applyCommands(cmd2, {'points.kml': out['points.kml']});
+    var geojson = JSON.parse(out2['points.json']);
+    assert.equal(geojson.features[0].geometry.type, 'Point');
+  })
+
+  it('-o format=kml syntax', async function() {
+    var file = 'test/data/kml/Albania.kmz';
+    var cmd = `-i ${file} -filter-fields -o format=kml`;
+    var out = await api.applyCommands(cmd);
+    assert(/^<kml/.test(out['Albania.kml']));
+  })
+
+});
diff --git a/test/option-parsing-utils-test.mjs b/test/option-parsing-utils-test.mjs
index 3adbce7e..c3f91de9 100644
--- a/test/option-parsing-utils-test.mjs
+++ b/test/option-parsing-utils-test.mjs
@@ -90,7 +90,6 @@ describe('mapshaper-option-parsing-utils.js', function () {
   describe('splitShellTokens()', function () {
     var split = api.internal.splitShellTokens;
     function test(src, dest) {
-      // assert.deepEqual(await import('shell-quote').parse(src), split(src));
      assert.deepEqual(split(src), dest);
     }
 
diff --git a/test/parse-commands-test.mjs b/test/parse-commands-test.mjs
index 33efd0f9..04c4899e 100644
--- a/test/parse-commands-test.mjs
+++ b/test/parse-commands-test.mjs
@@ -6,17 +6,17 @@ var internal = api.internal;
 describe('mapshaper-parse-commands.js', function () {
 
   describe('parseConsoleCommands()', function () {
-    it('should block input commands', function () {
-
-      function bad(cmd) {
-        assert.throws(function() {
-          internal.parseConsoleCommands(cmd);
-        });
-      }
-
-      bad("mapshaper foo.shp")
-      bad("-i foo");
-    })
+    // // Removed this test (now, -i command is blocked in browser by
+    // // checking the execution environment).
+    // it('should block input commands', function () {
+    //   function bad(cmd) {
+    //     assert.throws(function() {
+    //       internal.parseConsoleCommands(cmd);
+    //     });
+    //   }
+    //   bad("mapshaper foo.shp")
+    //   bad("-i foo");
+    // })
 
     it('mapshaper -filter true', function () {
       var commands = internal.parseConsoleCommands('mapshaper -filter true');
diff --git a/www/modules.js b/www/modules.js
index efc03926..da489e0c 100644
--- a/www/modules.js
+++ b/www/modules.js
@@ -5866,7 +5866,909 @@ function handleQs(url, query) {
 }
 exports["default"] = handleQs;
 
-},{"qs":27}],"@tmcw/togeojson":[function(require,module,exports){
+},{"qs":27}],"@placemarkio/tokml":[function(require,module,exports){
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * @typedef {import('unist').Node} Node
+ * @typedef {import('unist').Parent} Parent
+ * @typedef {import('unist').Literal} Literal
+ * @typedef {Object.<string, unknown>} Props
+ * @typedef {Array.<Node>|string} ChildrenOrValue
+ *
+ * @typedef {(<T extends string, P extends Record<string, unknown>, C extends Node[]>(type: T, props: P, children: C) => {type: T, children: C} & P)} BuildParentWithProps
+ * @typedef {(<T extends string, P extends Record<string, unknown>>(type: T, props: P, value: string) => {type: T, value: string} & P)} BuildLiteralWithProps
+ * @typedef {(<T extends string, P extends Record<string, unknown>>(type: T, props: P) => {type: T} & P)} BuildVoidWithProps
+ * @typedef {(<T extends string, C extends Node[]>(type: T, children: C) => {type: T, children: C})} BuildParent
+ * @typedef {(<T extends string>(type: T, value: string) => {type: T, value: string})} BuildLiteral
+ * @typedef {(<T extends string>(type: T) => {type: T})} BuildVoid
+ */
+
+var u = /**
+ * @type {BuildVoid & BuildVoidWithProps & BuildLiteral & BuildLiteralWithProps & BuildParent & BuildParentWithProps}
+ */ (
+  /**
+   * @param {string} type Type of node
+   * @param {Props|ChildrenOrValue} [props] Additional properties for node (or `children` or `value`)
+   * @param {ChildrenOrValue} [value] `children` or `value` of node
+   * @returns {Node}
+   */
+  function (type, props, value) {
+    /** @type {Node} */
+    var node = {type: String(type)};
+
+    if (
+      (value === undefined || value === null) &&
+      (typeof props === 'string' || Array.isArray(props))
+    ) {
+      value = props;
+    } else {
+      Object.assign(node, props);
+    }
+
+    if (Array.isArray(value)) {
+      node.children = value;
+    } else if (value !== undefined && value !== null) {
+      node.value = String(value);
+    }
+
+    return node
+  }
+);
+
+/**
+ * @typedef {import('xast').Root} Root
+ * @typedef {import('xast').Element} Element
+ * @typedef {Root['children'][number]} Child
+ * @typedef {Child|Root} Node
+ * @typedef {Root|Element} XResult
+ * @typedef {string|number|boolean|null|undefined} XValue
+ * @typedef {{[attribute: string]: XValue}} XAttributes Attributes to support JS primitive types
+ *
+ * @typedef {string|number|null|undefined} XPrimitiveChild
+ * @typedef {Array.<Node|XPrimitiveChild>} XArrayChild
+ * @typedef {Node|XPrimitiveChild|XArrayChild} XChild
+ * @typedef {import('./jsx-classic').Element} x.JSX.Element
+ * @typedef {import('./jsx-classic').IntrinsicAttributes} x.JSX.IntrinsicAttributes
+ * @typedef {import('./jsx-classic').IntrinsicElements} x.JSX.IntrinsicElements
+ * @typedef {import('./jsx-classic').ElementChildrenAttribute} x.JSX.ElementChildrenAttribute
+ */
+
+/**
+ * Create XML trees in xast.
+ *
+ * @param name Qualified name. Case sensitive and can contain a namespace prefix (such as `rdf:RDF`). Pass `null|undefined` to build a root.
+ * @param attributes Map of attributes. Nullish (null or undefined) or NaN values are ignored, other values (strings, booleans) are cast to strings.
+ * @param children (Lists of) child nodes. When strings are encountered, they are mapped to Text nodes.
+ */
+const x =
+  /**
+   * @type {{
+   *   (): Root
+   *   (name: null|undefined, ...children: XChild[]): Root
+   *   (name: string, attributes: XAttributes, ...children: XChild[]): Element
+   *   (name: string, ...children: XChild[]): Element
+   * }}
+   */
+  (
+    /**
+     * Hyperscript compatible DSL for creating virtual xast trees.
+     *
+     * @param {string|null} [name]
+     * @param {XAttributes|XChild} [attributes]
+     * @param {XChild[]} children
+     * @returns {XResult}
+     */
+    function (name, attributes, ...children) {
+      var index = -1;
+      /** @type {XResult} */
+      var node;
+      /** @type {string} */
+      var key;
+
+      if (name === undefined || name === null) {
+        node = {type: 'root', children: []};
+        // @ts-ignore Root builder doesn’t accept attributes.
+        children.unshift(attributes);
+      } else if (typeof name === 'string') {
+        node = {type: 'element', name, attributes: {}, children: []};
+
+        if (isAttributes(attributes)) {
+          for (key in attributes) {
+            // Ignore nullish and NaN values.
+            if (
+              attributes[key] !== undefined &&
+              attributes[key] !== null &&
+              (typeof attributes[key] !== 'number' ||
+                !Number.isNaN(attributes[key]))
+            ) {
+              // @ts-ignore Pretty sure we just set it.
+              node.attributes[key] = String(attributes[key]);
+            }
+          }
+        } else {
+          children.unshift(attributes);
+        }
+      } else {
+        throw new TypeError('Expected element name, got `' + name + '`')
+      }
+
+      // Handle children.
+      while (++index < children.length) {
+        addChild(node.children, children[index]);
+      }
+
+      return node
+    }
+  );
+
+/**
+ * @param {Array.<Child>} nodes
+ * @param {XChild} value
+ */
+function addChild(nodes, value) {
+  var index = -1;
+
+  if (value === undefined || value === null) ; else if (typeof value === 'string' || typeof value === 'number') {
+    nodes.push({type: 'text', value: String(value)});
+  } else if (Array.isArray(value)) {
+    while (++index < value.length) {
+      addChild(nodes, value[index]);
+    }
+  } else if (typeof value === 'object' && 'type' in value) {
+    if (value.type === 'root') {
+      addChild(nodes, value.children);
+    } else {
+      nodes.push(value);
+    }
+  } else {
+    throw new TypeError('Expected node, nodes, string, got `' + value + '`')
+  }
+}
+
+/**
+ * @param {XAttributes|XChild} value
+ * @returns {value is XAttributes}
+ */
+function isAttributes(value) {
+  if (
+    value === null ||
+    value === undefined ||
+    typeof value !== 'object' ||
+    Array.isArray(value)
+  ) {
+    return false
+  }
+
+  return true
+}
+
+/**
+ * @typedef {import('./index.js').Parent} Parent
+ * @typedef {import('./index.js').Context} Context
+ * @typedef {import('./index.js').Child} Child
+ */
+
+/**
+ * Serialize all children of `parent`.
+ *
+ * @param {Parent} parent
+ * @param {Context} ctx
+ * @returns {string}
+ *
+ */
+function all(parent, ctx) {
+  /** @type {Array.<Child>} */
+  var children = (parent && parent.children) || [];
+  var index = -1;
+  /** @type {Array.<string>} */
+  var results = [];
+
+  while (++index < children.length) {
+    results[index] = one(children[index], ctx);
+  }
+
+  return results.join('')
+}
+
+/**
+ * @typedef {Object} CoreOptions
+ * @property {string[]} [subset=[]]
+ *   Whether to only escape the given subset of characters.
+ * @property {boolean} [escapeOnly=false]
+ *   Whether to only escape possibly dangerous characters.
+ *   Those characters are `"`, `&`, `'`, `<`, `>`, and `` ` ``.
+ *
+ * @typedef {Object} FormatOptions
+ * @property {(code: number, next: number, options: CoreWithFormatOptions) => string} format
+ *   Format strategy.
+ *
+ * @typedef {CoreOptions & FormatOptions & import('./util/format-smart.js').FormatSmartOptions} CoreWithFormatOptions
+ */
+
+/**
+ * Encode certain characters in `value`.
+ *
+ * @param {string} value
+ * @param {CoreWithFormatOptions} options
+ * @returns {string}
+ */
+function core(value, options) {
+  value = value.replace(
+    options.subset ? charactersToExpression(options.subset) : /["&'<>`]/g,
+    basic
+  );
+
+  if (options.subset || options.escapeOnly) {
+    return value
+  }
+
+  return (
+    value
+      // Surrogate pairs.
+      .replace(/[\uD800-\uDBFF][\uDC00-\uDFFF]/g, surrogate)
+      // BMP control characters (C0 except for LF, CR, SP; DEL; and some more
+      // non-ASCII ones).
+      .replace(
+        // eslint-disable-next-line no-control-regex, unicorn/no-hex-escape
+        /[\x01-\t\v\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g,
+        basic
+      )
+  )
+
+  /**
+   * @param {string} pair
+   * @param {number} index
+   * @param {string} all
+   */
+  function surrogate(pair, index, all) {
+    return options.format(
+      (pair.charCodeAt(0) - 0xd800) * 0x400 +
+        pair.charCodeAt(1) -
+        0xdc00 +
+        0x10000,
+      all.charCodeAt(index + 2),
+      options
+    )
+  }
+
+  /**
+   * @param {string} character
+   * @param {number} index
+   * @param {string} all
+   */
+  function basic(character, index, all) {
+    return options.format(
+      character.charCodeAt(0),
+      all.charCodeAt(index + 1),
+      options
+    )
+  }
+}
+
+/**
+ * @param {string[]} subset
+ * @returns {RegExp}
+ */
+function charactersToExpression(subset) {
+  /** @type {string[]} */
+  const groups = [];
+  let index = -1;
+
+  while (++index < subset.length) {
+    groups.push(subset[index].replace(/[|\\{}()[\]^$+*?.]/g, '\\$&'));
+  }
+
+  return new RegExp('(?:' + groups.join('|') + ')', 'g')
+}
+
+/**
+ * The smallest way to encode a character.
+ *
+ * @param {number} code
+ * @returns {string}
+ */
+function formatBasic(code) {
+  return '&#x' + code.toString(16).toUpperCase() + ';'
+}
+
+/**
+ * @typedef {import('./core.js').CoreOptions & import('./util/format-smart.js').FormatSmartOptions} Options
+ * @typedef {import('./core.js').CoreOptions} LightOptions
+ */
+
+/**
+ * Encode special characters in `value` as hexadecimals.
+ *
+ * @param {string} value
+ *   Value to encode.
+ * @param {LightOptions} [options]
+ *   Configuration.
+ * @returns {string}
+ *   Encoded value.
+ */
+function stringifyEntitiesLight(value, options) {
+  return core(value, Object.assign({format: formatBasic}, options))
+}
+
+var noncharacter = /[\u0000-\u0008\u000B\u000C\u000E-\u001F]/g;
+
+/**
+ * Escape a string.
+ *
+ * @param {string} value
+ * @param {Array.<string>} subset
+ * @param {RegExp} [unsafe]
+ * @returns {string}
+ */
+function escape(value, subset, unsafe) {
+  var result = clean(value);
+
+  return unsafe ? result.replace(unsafe, encode) : encode(result)
+
+  /**
+   * @param {string} $0
+   * @returns {string}
+   */
+  function encode($0) {
+    return stringifyEntitiesLight($0, {subset})
+  }
+}
+
+/**
+ * @param {string} value
+ * @returns {string}
+ */
+function clean(value) {
+  return String(value || '').replace(noncharacter, '')
+}
+
+var subset$3 = ['\t', '\n', ' ', '"', '&', "'", '/', '<', '=', '>'];
+
+/**
+ * Serialize a node name.
+ *
+ * @param {string} value
+ * @returns {string}
+ */
+function name(value) {
+  return escape(value, subset$3)
+}
+
+/**
+ * Count how often a character (or substring) is used in a string.
+ *
+ * @param {string} value
+ *   Value to search in.
+ * @param {string} character
+ *   Character (or substring) to look for.
+ * @return {number}
+ *   Number of times `character` occurred in `value`.
+ */
+function ccount(value, character) {
+  const source = String(value);
+
+  if (typeof character !== 'string') {
+    throw new TypeError('Expected character')
+  }
+
+  let count = 0;
+  let index = source.indexOf(character);
+
+  while (index !== -1) {
+    count++;
+    index = source.indexOf(character, index + character.length);
+  }
+
+  return count
+}
+
+/**
+ * @typedef {import('./index.js').Context} Context
+ */
+
+/**
+ * Serialize an attribute value.
+ *
+ * @param {string} value
+ * @param {Context} ctx
+ * @returns {string}
+ */
+function value(value, ctx) {
+  var primary = ctx.quote;
+  var secondary = ctx.alternative;
+  var result = String(value);
+  var quote =
+    secondary && ccount(result, primary) > ccount(result, secondary)
+      ? secondary
+      : primary;
+
+  return quote + escape(result, ['<', '&', quote]) + quote
+}
+
+/**
+ * @typedef {import('./index.js').Handle} Handle
+ * @typedef {import('./index.js').Element} Element
+ * @typedef {import('./index.js').Attributes} Attributes
+ */
+
+var own$1 = {}.hasOwnProperty;
+
+/**
+ * Serialize an element.
+ *
+ * @type {Handle}
+ * @param {Element} node
+ */
+function element(node, ctx) {
+  var nodeName = name(node.name);
+  var content = all(node, ctx);
+  /** @type {Attributes} */
+  var attributes = node.attributes || {};
+  var close = content ? false : ctx.close;
+  /** @type {Array.<string>} */
+  var attrs = [];
+  /** @type {string} */
+  var key;
+  /** @type {Attributes[keyof Attributes]} */
+  var result;
+
+  for (key in attributes) {
+    if (own$1.call(attributes, key)) {
+      result = attributes[key];
+
+      if (result !== null && result !== undefined) {
+        attrs.push(name(key) + '=' + value(result, ctx));
+      }
+    }
+  }
+
+  return (
+    '<' +
+    nodeName +
+    (attrs.length === 0 ? '' : ' ' + attrs.join(' ')) +
+    (close ? (ctx.tight ? '' : ' ') + '/' : '') +
+    '>' +
+    content +
+    (close ? '' : '</' + nodeName + '>')
+  )
+}
+
+/**
+ * @typedef {import('./index.js').Handle} Handle
+ * @typedef {import('./index.js').Text} Text
+ */
+
+var subset$2 = ['&', '<'];
+
+/**
+ * Serialize a text.
+ *
+ * @type {Handle}
+ * @param {Text} node
+ */
+function text(node) {
+  return escape(node.value, subset$2)
+}
+
+/**
+ * @typedef {import('./index.js').Handle} Handle
+ * @typedef {import('./index.js').Comment} Comment
+ */
+
+/**
+ * Serialize a comment.
+ *
+ * @type {Handle}
+ * @param {Comment} node
+ */
+function comment(node) {
+  return '<!--' + escape(node.value, ['-']) + '-->'
+}
+
+/**
+ * @typedef {import('./index.js').Handle} Handle
+ * @typedef {import('./index.js').Doctype} Doctype
+ */
+
+/**
+ * Serialize a doctype.
+ *
+ * @type {Handle}
+ * @param {Doctype} node
+ */
+function doctype(node, ctx) {
+  var nodeName = name(node.name);
+  var pub = node.public;
+  var sys = node.system;
+  var result = '<!DOCTYPE';
+
+  if (nodeName !== '') {
+    result += ' ' + nodeName;
+  }
+
+  if (pub !== null && pub !== undefined && pub !== '') {
+    result += ' PUBLIC ' + value(pub, ctx);
+  } else if (sys !== null && sys !== undefined && sys !== '') {
+    result += ' SYSTEM';
+  }
+
+  if (sys !== null && sys !== undefined && sys !== '') {
+    result += ' ' + value(sys, ctx);
+  }
+
+  return result + '>'
+}
+
+/**
+ * @typedef {import('./index.js').Handle} Handle
+ * @typedef {import('./index.js').Instruction} Instruction
+ */
+
+var unsafe$1 = /\?>/g;
+var subset$1 = ['>'];
+
+/**
+ * Serialize an instruction.
+ *
+ * @type {Handle}
+ * @param {Instruction} node
+ */
+function instruction(node) {
+  var nodeName = name(node.name) || 'x';
+  var result = escape(node.value, subset$1, unsafe$1);
+  return '<?' + nodeName + (result ? ' ' + result : '') + '?>'
+}
+
+/**
+ * @typedef {import('./index.js').Handle} Handle
+ * @typedef {import('./index.js').Cdata} Cdata
+ */
+
+var unsafe = /]]>/g;
+var subset = ['>'];
+
+/**
+ * Serialize a CDATA section.
+ *
+ * @type {Handle}
+ * @param {Cdata} node
+ */
+function cdata(node) {
+  return '<![CDATA[' + escape(node.value, subset, unsafe) + ']]>'
+}
+
+/**
+ * @typedef {import('./index.js').Handle} Handle
+ * @typedef {import('./index.js').Raw} Raw
+ */
+
+/**
+ * Serialize a (non-standard) raw.
+ *
+ * @type {Handle}
+ * @param {Raw} node
+ */
+function raw(node, ctx) {
+  // @ts-ignore Looks like a text.
+  return ctx.dangerous ? node.value : text(node)
+}
+
+/**
+ * @typedef {import('./index.js').Handle} Handle
+ */
+
+var own = {}.hasOwnProperty;
+
+var handlers = {
+  root: all,
+  element,
+  text,
+  comment,
+  doctype,
+  instruction,
+  cdata,
+  raw
+};
+
+/**
+ * Serialize a node.
+ *
+ * @type {Handle}
+ */
+function one(node, ctx) {
+  var type = node && node.type;
+
+  if (!type) {
+    throw new Error('Expected node, not `' + node + '`')
+  }
+
+  if (!own.call(handlers, type)) {
+    throw new Error('Cannot compile unknown node `' + type + '`')
+  }
+
+  // @ts-ignore Hush, it works.
+  return handlers[type](node, ctx)
+}
+
+/**
+ * @typedef {import('xast').Root} Root
+ * @typedef {import('xast').Element} Element
+ * @typedef {import('xast').Cdata} Cdata
+ * @typedef {import('xast').Comment} Comment
+ * @typedef {import('xast').Doctype} Doctype
+ * @typedef {import('xast').Instruction} Instruction
+ * @typedef {import('xast').Text} Text
+ * @typedef {import('xast').Literal & {type: 'raw'}} Raw
+ * @typedef {Root|Element} Parent
+ * @typedef {import('xast').Attributes} Attributes
+ * @typedef {Root['children'][number]} Child
+ * @typedef {Child|Root} Node
+ *
+ * @typedef {'"'|"'"} Quote
+ *
+ * @typedef Options
+ * @property {Quote} [quote='"'] Preferred quote to use
+ * @property {boolean} [quoteSmart=false] Use the other quote if that results in
+ *   less bytes
+ * @property {boolean} [closeEmptyElements=false] Close elements without any
+ *   content with slash (/) on the opening tag instead of an end tag:
+ *   `<circle />` instead of `<circle></circle>`.
+ *   See `tightClose` to control whether a space is used before the slash.
+ * @property {boolean} [tightClose=false] Do not use an extra space when closing
+ *    self-closing elements: `<circle/>` instead of `<circle />`.
+ * @property {boolean} [allowDangerousXml=false] Allow `raw` nodes and insert
+ *   them as raw XML. When falsey, encodes `raw` nodes.
+ *   Only set this if you completely trust the content!
+ *
+ * @typedef Context
+ * @property {Quote} quote
+ * @property {Quote} alternative
+ * @property {boolean} close
+ * @property {boolean} tight
+ * @property {boolean} dangerous
+ *
+ * @callback Handle
+ * @param {Node} node
+ * @param {Context} context
+ * @returns {string}
+ */
+
+/**
+ * Serialize the given xast tree (or list of nodes).
+ *
+ * @param {Node|Array.<Node>} node
+ * @param {Options} [options]
+ * @returns {string}
+ */
+function toXml(node, options = {}) {
+  var quote = options.quote || '"';
+  /** @type {Quote} */
+  var alternative = quote === '"' ? "'" : '"';
+  var smart = options.quoteSmart;
+  /** @type {Node} */
+  // @ts-ignore Assume no `root` in `node`.
+  var value = Array.isArray(node) ? {type: 'root', children: node} : node;
+
+  if (quote !== '"' && quote !== "'") {
+    throw new Error('Invalid quote `' + quote + '`, expected `\'` or `"`')
+  }
+
+  return one(value, {
+    dangerous: options.allowDangerousXml,
+    close: options.closeEmptyElements,
+    tight: options.tightClose,
+    quote,
+    alternative: smart ? alternative : null
+  })
+}
+
+const BR = u('text', '\n');
+const TAB = u('text', '  ');
+/**
+ * Convert nested folder structure to KML. This expects
+ * input that follows the same patterns as [toGeoJSON](https://github.com/placemark/togeojson)'s
+ * kmlWithFolders method: a tree of folders and features,
+ * starting with a root element.
+ */
+function foldersToKML(root) {
+    return toXml(u('root', [
+        x('kml', { xmlns: 'http://www.opengis.net/kml/2.2' }, x('Document', root.children.flatMap((child) => convertChild(child)))),
+    ]));
+}
+/**
+ * Convert a GeoJSON FeatureCollection to a string of
+ * KML data.
+ */
+function toKML(featureCollection) {
+    return toXml(u('root', [
+        x('kml', { xmlns: 'http://www.opengis.net/kml/2.2' }, x('Document', featureCollection.features.flatMap((feature) => convertFeature(feature)))),
+    ]));
+}
+function convertChild(child) {
+    switch (child.type) {
+        case 'Feature':
+            return convertFeature(child);
+        case 'folder':
+            return convertFolder(child);
+    }
+}
+function convertFolder(folder) {
+    const id = ['string', 'number'].includes(typeof folder.meta.id)
+        ? {
+            id: String(folder.meta.id),
+        }
+        : {};
+    return [
+        BR,
+        x('Folder', id, [
+            BR,
+            ...folderMeta(folder.meta),
+            BR,
+            TAB,
+            ...folder.children.flatMap((child) => convertChild(child)),
+        ]),
+    ];
+}
+const META_PROPERTIES = [
+    'address',
+    'description',
+    'name',
+    'open',
+    'visibility',
+    'phoneNumber',
+];
+function folderMeta(meta) {
+    return META_PROPERTIES.filter((p) => meta[p] !== undefined).map((p) => {
+        return x(p, [u('text', String(meta[p]))]);
+    });
+}
+function convertFeature(feature) {
+    const { id } = feature;
+    const idMember = ['string', 'number'].includes(typeof id)
+        ? {
+            id: id,
+        }
+        : {};
+    return [
+        BR,
+        x('Placemark', idMember, [
+            BR,
+            ...propertiesToTags(feature.properties),
+            BR,
+            TAB,
+            ...(feature.geometry ? [convertGeometry(feature.geometry)] : []),
+        ]),
+    ];
+}
+function join(position) {
+    return `${position[0]},${position[1]}`;
+}
+function coord1(coordinates) {
+    return x('coordinates', [u('text', join(coordinates))]);
+}
+function coord2(coordinates) {
+    return x('coordinates', [u('text', coordinates.map(join).join('\n'))]);
+}
+function toString(value) {
+    switch (typeof value) {
+        case 'string': {
+            return value;
+        }
+        case 'boolean':
+        case 'number': {
+            return String(value);
+        }
+        case 'object': {
+            try {
+                return JSON.stringify(value);
+            }
+            catch (e) {
+                return '';
+            }
+        }
+    }
+    return '';
+}
+function maybeCData(value) {
+    if (value &&
+        typeof value === 'object' &&
+        '@type' in value &&
+        value['@type'] === 'html' &&
+        'value' in value &&
+        typeof value.value === 'string') {
+        return u('cdata', value.value);
+    }
+    return toString(value);
+}
+function propertiesToTags(properties) {
+    if (!properties)
+        return [];
+    const { name, description, visibility, ...otherProperties } = properties;
+    return [
+        name && x('name', [u('text', toString(name))]),
+        description && x('description', [u('text', maybeCData(description))]),
+        visibility !== undefined &&
+            x('visibility', [u('text', visibility ? '1' : '0')]),
+        x('ExtendedData', Object.entries(otherProperties).flatMap(([name, value]) => [
+            BR,
+            TAB,
+            x('Data', { name: name }, [
+                x('value', [
+                    u('text', typeof value === 'string' ? value : JSON.stringify(value)),
+                ]),
+            ]),
+        ])),
+    ].filter(Boolean);
+}
+const linearRing = (ring) => x('LinearRing', [coord2(ring)]);
+function convertMultiPoint(geometry) {
+    return x('MultiGeometry', geometry.coordinates.flatMap((coordinates) => [
+        BR,
+        convertGeometry({
+            type: 'Point',
+            coordinates,
+        }),
+    ]));
+}
+function convertMultiLineString(geometry) {
+    return x('MultiGeometry', geometry.coordinates.flatMap((coordinates) => [
+        BR,
+        convertGeometry({
+            type: 'LineString',
+            coordinates,
+        }),
+    ]));
+}
+function convertMultiPolygon(geometry) {
+    return x('MultiGeometry', geometry.coordinates.flatMap((coordinates) => [
+        BR,
+        convertGeometry({
+            type: 'Polygon',
+            coordinates,
+        }),
+    ]));
+}
+function convertPolygon(geometry) {
+    const [outerBoundary, ...innerRings] = geometry.coordinates;
+    return x('Polygon', [
+        BR,
+        x('outerBoundaryIs', [BR, TAB, linearRing(outerBoundary)]),
+        ...innerRings.flatMap((innerRing) => [
+            BR,
+            x('innerBoundaryIs', [BR, TAB, linearRing(innerRing)]),
+        ]),
+    ]);
+}
+function convertGeometry(geometry) {
+    switch (geometry.type) {
+        case 'Point':
+            return x('Point', [coord1(geometry.coordinates)]);
+        case 'MultiPoint':
+            return convertMultiPoint(geometry);
+        case 'LineString':
+            return x('LineString', [coord2(geometry.coordinates)]);
+        case 'MultiLineString':
+            return convertMultiLineString(geometry);
+        case 'Polygon':
+            return convertPolygon(geometry);
+        case 'MultiPolygon':
+            return convertMultiPolygon(geometry);
+        case 'GeometryCollection':
+            return x('MultiGeometry', geometry.geometries.flatMap((geometry) => [
+                BR,
+                convertGeometry(geometry),
+            ]));
+    }
+}
+
+exports.foldersToKML = foldersToKML;
+exports.toKML = toKML;
+
+
+},{}],"@tmcw/togeojson":[function(require,module,exports){
 !function(t,e){"object"==typeof exports&&"undefined"!=typeof module?e(exports):"function"==typeof define&&define.amd?define(["exports"],e):e((t="undefined"!=typeof globalThis?globalThis:t||self).toGeoJSON={})}(this,(function(t){"use strict";function e(t,e){return Array.from(t.getElementsByTagName(e))}function n(t){return"#"===t[0]?t:`#${t}`}function o(t){return t?.normalize(),t&&t.textContent||""}function r(t,e,n){const o=t.getElementsByTagName(e),r=o.length?o[0]:null;return r&&n&&n(r),r}function i(t,e,n){const o={};if(!t)return o;const r=t.getElementsByTagName(e),i=r.length?r[0]:null;return i&&n?n(i,o):o}function s(t,e,n){const i=o(r(t,e));return i&&n&&n(i)||{}}function c(t,e,n){const i=parseFloat(o(r(t,e)));if(!isNaN(i))return i&&n&&n(i)||{}}function a(t,e,n){const i=parseFloat(o(r(t,e)));if(!isNaN(i))return i&&n&&n(i),i}function l(t,e){const n={};for(const o of e)s(t,o,(t=>{n[o]=t}));return n}function u(t){return 1===t?.nodeType}function f(t){return i(t,"line",(t=>Object.assign({},s(t,"color",(t=>({stroke:`#${t}`}))),c(t,"opacity",(t=>({"stroke-opacity":t}))),c(t,"width",(t=>({"stroke-width":96*t/25.4}))))))}function p(t){let e=[];if(null===t)return e;for(const n of Array.from(t.childNodes)){if(!u(n))continue;const t=g(n.nodeName);if("gpxtpx:TrackPointExtension"===t)e=e.concat(p(n));else{const r=o(n);e.push([t,d(r)])}}return e}function g(t){return["heart","gpxtpx:hr","hr"].includes(t)?"heart":t}function d(t){const e=parseFloat(t);return isNaN(e)?t:e}function h(t){const e=[parseFloat(t.getAttribute("lon")||""),parseFloat(t.getAttribute("lat")||"")];if(isNaN(e[0])||isNaN(e[1]))return null;a(t,"ele",(t=>{e.push(t)}));const n=r(t,"time");return{coordinates:e,time:n?o(n):null,extendedValues:p(r(t,"extensions"))}}function m(t){const n=l(t,["name","cmt","desc","type","time","keywords"]),r=Array.from(t.getElementsByTagNameNS("http://www.garmin.com/xmlschemas/GpxExtensions/v3","*"));for(const e of r)e.parentNode?.parentNode===t&&(n[e.tagName.replace(":","_")]=o(e));const i=e(t,"link");return i.length&&(n.links=i.map((t=>Object.assign({href:t.getAttribute("href")},l(t,["text","type"]))))),n}function y(t,n){const o=e(t,n),r=[],i=[],s={};for(let t=0;t<o.length;t++){const e=h(o[t]);if(e){r.push(e.coordinates),e.time&&i.push(e.time);for(const[n,r]of e.extendedValues){const e="heart"===n?n:n.replace("gpxtpx:","")+"s";s[e]||(s[e]=Array(o.length).fill(null)),s[e][t]=r}}}if(!(r.length<2))return{line:r,times:i,extendedValues:s}}function b(t){const e=y(t,"rtept");if(e)return{type:"Feature",properties:Object.assign({_gpxType:"rte"},m(t),f(r(t,"extensions"))),geometry:{type:"LineString",coordinates:e.line}}}function N(t){const n=e(t,"trkseg"),o=[],i=[],s=[];for(const t of n){const e=y(t,"trkpt");e&&(s.push(e),e.times&&e.times.length&&i.push(e.times))}if(0===s.length)return null;const c=s.length>1,a=Object.assign({_gpxType:"trk"},m(t),f(r(t,"extensions")),i.length?{coordinateProperties:{times:c?i:i[0]}}:{});for(const t of s){o.push(t.line),a.coordinateProperties||(a.coordinateProperties={});const e=a.coordinateProperties,n=Object.entries(t.extendedValues);for(let t=0;t<n.length;t++){const[o,r]=n[t];c?(e[o]||(e[o]=s.map((t=>new Array(t.line.length).fill(null)))),e[o][t]=r):e[o]=r}}return{type:"Feature",properties:a,geometry:c?{type:"MultiLineString",coordinates:o}:{type:"LineString",coordinates:o[0]}}}function x(t){const e=Object.assign(m(t),l(t,["sym"])),n=h(t);return n?{type:"Feature",properties:e,geometry:{type:"Point",coordinates:n.coordinates}}:null}function*k(t){for(const n of e(t,"trk")){const t=N(n);t&&(yield t)}for(const n of e(t,"rte")){const t=b(n);t&&(yield t)}for(const n of e(t,"wpt")){const t=x(n);t&&(yield t)}}const A=[["heartRate","heartRates"],["Cadence","cadences"],["Speed","speeds"],["Watts","watts"]],S=[["TotalTimeSeconds","totalTimeSeconds"],["DistanceMeters","distanceMeters"],["MaximumSpeed","maxSpeed"],["AverageHeartRateBpm","avgHeartRate"],["MaximumHeartRateBpm","maxHeartRate"],["AvgSpeed","avgSpeed"],["AvgWatts","avgWatts"],["MaxWatts","maxWatts"]];function v(t,e){const n=[];for(const[i,s]of e){let e=r(t,i);if(!e){const n=t.getElementsByTagNameNS("http://www.garmin.com/xmlschemas/ActivityExtension/v2",i);n.length&&(e=n[0])}const c=parseFloat(o(e));isNaN(c)||n.push([s,c])}return n}function T(t){const e=[a(t,"LongitudeDegrees"),a(t,"LatitudeDegrees")];if(void 0===e[0]||isNaN(e[0])||void 0===e[1]||isNaN(e[1]))return null;const n=r(t,"HeartRateBpm"),i=o(r(t,"Time"));return r(t,"AltitudeMeters",(t=>{const n=parseFloat(o(t));isNaN(n)||e.push(n)})),{coordinates:e,time:i||null,heartRate:n?parseFloat(o(n)):null,extensions:v(t,A)}}function F(t){const n=e(t,"Trackpoint"),o=[],r=[],i=[];if(n.length<2)return null;const s={},c={extendedProperties:s};for(let t=0;t<n.length;t++){const e=T(n[t]);if(null===e)continue;o.push(e.coordinates);const{time:c,heartRate:a,extensions:l}=e;c&&r.push(c),a&&i.push(a);for(const[e,o]of l)s[e]||(s[e]=Array(n.length).fill(null)),s[e][t]=o}return o.length<2?null:Object.assign(c,{line:o,times:r,heartRates:i})}function P(t){const n=e(t,"Track"),r=[],s=[],c=[],a=[];let l;const u=Object.assign(Object.fromEntries(v(t,S)),i(t,"Name",(t=>({name:o(t)}))));for(const t of n)l=F(t),l&&(r.push(l.line),l.times.length&&s.push(l.times),l.heartRates.length&&c.push(l.heartRates),a.push(l.extendedProperties));for(let t=0;t<a.length;t++){const e=a[t];for(const o in e)1===n.length?l&&(u[o]=l.extendedProperties[o]):(u[o]||(u[o]=r.map((t=>Array(t.length).fill(null)))),u[o][t]=e[o])}return 0===r.length?null:((s.length||c.length)&&(u.coordinateProperties=Object.assign(s.length?{times:1===r.length?s[0]:s}:{},c.length?{heart:1===r.length?c[0]:c}:{})),{type:"Feature",properties:u,geometry:1===r.length?{type:"LineString",coordinates:r[0]}:{type:"MultiLineString",coordinates:r}})}function*O(t){for(const n of e(t,"Lap")){const t=P(n);t&&(yield t)}for(const n of e(t,"Courses")){const t=P(n);t&&(yield t)}}function w(t,e){const n={},o="stroke"==e||"fill"===e?e:e+"-color";return"#"===t[0]&&(t=t.substring(1)),6===t.length||3===t.length?n[o]="#"+t:8===t.length&&(n[e+"-opacity"]=parseInt(t.substring(0,2),16)/255,n[o]="#"+t.substring(6,8)+t.substring(4,6)+t.substring(2,4)),n}function M(t,e,n){const o={};return a(t,e,(t=>{o[n]=t})),o}function j(t,e){return i(t,"color",(t=>w(o(t),e)))}function L(t){return i(t,"Icon",((t,e)=>(s(t,"href",(t=>{e.icon=t})),e)))}function R(t){return Object.assign({},function(t){return i(t,"PolyStyle",((t,e)=>Object.assign(e,i(t,"color",(t=>w(o(t),"fill"))),s(t,"fill",(t=>{if("0"===t)return{"fill-opacity":0}})),s(t,"outline",(t=>{if("0"===t)return{"stroke-opacity":0}})))))}(t),function(t){return i(t,"LineStyle",(t=>Object.assign(j(t,"stroke"),M(t,"width","stroke-width"))))}(t),function(t){return i(t,"LabelStyle",(t=>Object.assign(j(t,"label"),M(t,"scale","label-scale"))))}(t),function(t){return i(t,"IconStyle",(t=>Object.assign(j(t,"icon"),M(t,"scale","icon-scale"),M(t,"heading","icon-heading"),i(t,"hotSpot",(t=>{const e=parseFloat(t.getAttribute("x")||""),n=parseFloat(t.getAttribute("y")||""),o=t.getAttribute("xunits")||"",r=t.getAttribute("yunits")||"";return isNaN(e)||isNaN(n)?{}:{"icon-offset":[e,n],"icon-offset-units":[o,r]}})),L(t))))}(t))}const B=t=>Number(t),E={string:t=>t,int:B,uint:B,short:B,ushort:B,float:B,double:B,bool:t=>Boolean(t)};function G(t,n){return i(t,"ExtendedData",((t,i)=>{for(const n of e(t,"Data"))i[n.getAttribute("name")||""]=o(r(n,"value"));for(const r of e(t,"SimpleData")){const t=r.getAttribute("name")||"",e=n[t]||E.string;i[t]=e(o(r))}return i}))}function C(t){const e=r(t,"description");for(const t of Array.from(e?.childNodes||[]))if(4===t.nodeType)return{description:{"@type":"html",value:o(t)}};return{}}function D(t){return i(t,"TimeSpan",(t=>({timespan:{begin:o(r(t,"begin")),end:o(r(t,"end"))}})))}function W(t){return i(t,"TimeStamp",(t=>({timestamp:o(r(t,"when"))})))}function H(t,e){return s(t,"styleUrl",(t=>(t=n(t),e[t]?Object.assign({styleUrl:t},e[t]):{styleUrl:t})))}const _=/\s*/g,I=/^\s*|\s*$/g,U=/\s+/;function V(t){return t.replace(_,"").split(",").map(parseFloat).filter((t=>!isNaN(t))).slice(0,3)}function $(t){return t.replace(I,"").split(U).map(V).filter((t=>t.length>=2))}function q(t){let n=e(t,"coord");var r,i,s;0===n.length&&(r=t,i="coord",s="*",n=Array.from(r.getElementsByTagNameNS(s,i)));const c=n.map((t=>o(t).split(" ").map(parseFloat)));return 0===c.length?null:{geometry:c.length>2?{type:"LineString",coordinates:c}:{type:"Point",coordinates:c[0]},times:e(t,"when").map((t=>o(t)))}}function z(t){if(0===t.length)return t;const e=t[0],n=t[t.length-1];let o=!0;for(let t=0;t<Math.max(e.length,n.length);t++)if(e[t]!==n[t]){o=!1;break}return o?t:t.concat([t[0]])}function J(t){return o(r(t,"coordinates"))}function Q(t){let n=[],o=[];for(let r=0;r<t.childNodes.length;r++){const i=t.childNodes.item(r);if(u(i))switch(i.tagName){case"MultiGeometry":case"MultiTrack":case"gx:MultiTrack":{const t=Q(i);n=n.concat(t.geometries),o=o.concat(t.coordTimes);break}case"Point":{const t=V(J(i));t.length>=2&&n.push({type:"Point",coordinates:t});break}case"LineString":{const t=$(J(i));t.length>=2&&n.push({type:"LineString",coordinates:t});break}case"Polygon":{const t=[];for(const n of e(i,"LinearRing")){const e=z($(J(n)));e.length>=4&&t.push(e)}t.length&&n.push({type:"Polygon",coordinates:t});break}case"Track":case"gx:Track":{const t=q(i);if(!t)break;const{times:e,geometry:r}=t;n.push(r),e.length&&o.push(e);break}}}return{geometries:n,coordTimes:o}}function K(t){return 0===t.length?null:1===t.length?t[0]:{type:"GeometryCollection",geometries:t}}function X(t,e,n){const{coordTimes:o,geometries:r}=Q(t),i={type:"Feature",geometry:K(r),properties:Object.assign(l(t,["name","address","visibility","open","phoneNumber","description"]),C(t),H(t,e),R(t),G(t,n),D(t),W(t),o.length?{coordinateProperties:{times:1===o.length?o[0]:o}}:{})};void 0!==i.properties?.visibility&&(i.properties.visibility="0"!==i.properties.visibility);const s=t.getAttribute("id");return null!==s&&""!==s&&(i.id=s),i}function Y(t){if(r(t,"gx:LatLonQuad")){return{type:"Polygon",coordinates:[z($(J(t)))]}}return function(t){const e=r(t,"LatLonBox");if(e){const t=a(e,"north"),n=a(e,"west"),o=a(e,"east"),r=a(e,"south"),i=a(e,"rotation");if("number"==typeof t&&"number"==typeof r&&"number"==typeof n&&"number"==typeof o){const e=[n,r,o,t];let s=[[[n,t],[o,t],[o,r],[n,r],[n,t]]];return"number"==typeof i&&(s=function(t,e,n){const o=[(t[0]+t[2])/2,(t[1]+t[3])/2];return[e[0].map((t=>{const e=t[1]-o[1],r=t[0]-o[0],i=Math.sqrt(Math.pow(e,2)+Math.pow(r,2)),s=Math.atan2(e,r)-n*Z;return[o[0]+Math.cos(s)*i,o[1]+Math.sin(s)*i]}))]}(e,s,i)),{type:"Polygon",coordinates:s}}}return null}(t)}const Z=Math.PI/180;function tt(t,e,n){const o={type:"Feature",geometry:Y(t),properties:Object.assign({"@geometry-type":"groundoverlay"},l(t,["name","address","visibility","open","phoneNumber","description"]),C(t),H(t,e),R(t),L(t),G(t,n),D(t),W(t))};void 0!==o.properties?.visibility&&(o.properties.visibility="0"!==o.properties.visibility);const r=t.getAttribute("id");return null!==r&&""!==r&&(o.id=r),o}function et(t){let e=t.getAttribute("id");const o=t.parentNode;return!e&&u(o)&&"CascadingStyle"===o.localName&&(e=o.getAttribute("kml:id")||o.getAttribute("id")),n(e||"")}function nt(t){const o={};for(const n of e(t,"Style"))o[et(n)]=R(n);for(const r of e(t,"StyleMap")){const t=n(r.getAttribute("id")||"");s(r,"styleUrl",(e=>{e=n(e),o[e]&&(o[t]=o[e])}))}return o}function ot(t){const n={};for(const o of e(t,"SimpleField"))n[o.getAttribute("name")||""]=E[o.getAttribute("type")||""]||E.string;return n}const rt=["name","visibility","open","address","description","phoneNumber","visibility"];function*it(t){const n=nt(t),o=ot(t);for(const r of e(t,"Placemark")){const t=X(r,n,o);t&&(yield t)}for(const r of e(t,"GroundOverlay")){const t=tt(r,n,o);t&&(yield t)}}t.gpx=function(t){return{type:"FeatureCollection",features:Array.from(k(t))}},t.gpxGen=k,t.kml=function(t){return{type:"FeatureCollection",features:Array.from(it(t))}},t.kmlGen=it,t.kmlWithFolders=function(t){const e=nt(t),n=ot(t),r={type:"root",children:[]};return function t(r,i){if(u(r))switch(r.tagName){case"GroundOverlay":{const t=tt(r,e,n);t&&i.children.push(t);break}case"Placemark":{const t=X(r,e,n);t&&i.children.push(t);break}case"Folder":{const t=function(t){const e={};for(const n of Array.from(t.childNodes))u(n)&&rt.includes(n.tagName)&&(e[n.tagName]=o(n));return{type:"folder",meta:e,children:[]}}(r);i.children.push(t),i=t;break}}if(r.childNodes)for(let e=0;e<r.childNodes.length;e++)t(r.childNodes[e],i)}(t,r),r},t.tcx=function(t){return{type:"FeatureCollection",features:Array.from(O(t))}},t.tcxGen=O,Object.defineProperty(t,"__esModule",{value:!0})}));