@tailglow/cli 0.7.1 → 0.8.1

package/src/import.generated.js

@@ -0,0 +1,4731 @@
+// @ts-nocheck
+// Generated by scripts/build/import.build.js. Do not edit directly.
+/*! Bundled Papa Parse
+The MIT License (MIT)
+
+Copyright (c) 2015 Matthew Holt
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  if (mod && typeof mod === "object" || typeof mod === "function") {
+    for (let key of __getOwnPropNames(mod))
+      if (!__hasOwnProp.call(to, key))
+        __defProp(to, key, {
+          get: __accessProp.bind(mod, key),
+          enumerable: true
+        });
+  }
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// node_modules/.bun/papaparse@5.7.0/node_modules/papaparse/papaparse.js
+var require_papaparse = __commonJS(function(exports, module) {
+  (function(root, factory) {
+    if (typeof define === "function" && define.amd) {
+      define([], factory);
+    } else if (typeof module === "object" && typeof exports !== "undefined") {
+      module.exports = factory();
+    } else {
+      root.Papa = factory();
+    }
+  })(exports, function moduleFactory() {
+    var global = function() {
+      if (typeof self !== "undefined") {
+        return self;
+      }
+      if (typeof window !== "undefined") {
+        return window;
+      }
+      if (typeof global !== "undefined") {
+        return global;
+      }
+      return {};
+    }();
+    function getWorkerBlob() {
+      var URL2 = global.URL || global.webkitURL || null;
+      var code = moduleFactory.toString();
+      return Papa.BLOB_URL || (Papa.BLOB_URL = URL2.createObjectURL(new Blob(["var global = (function() { if (typeof self !== 'undefined') { return self; } if (typeof window !== 'undefined') { return window; } if (typeof global !== 'undefined') { return global; } return {}; })(); global.IS_PAPA_WORKER=true; ", "(", code, ")();"], { type: "text/javascript" })));
+    }
+    var IS_WORKER = !global.document && !!global.postMessage, IS_PAPA_WORKER = global.IS_PAPA_WORKER || false;
+    var workers = {}, workerIdCounter = 0;
+    var Papa = {};
+    Papa.parse = CsvToJson;
+    Papa.unparse = JsonToCsv;
+    Papa.RECORD_SEP = String.fromCharCode(30);
+    Papa.UNIT_SEP = String.fromCharCode(31);
+    Papa.BYTE_ORDER_MARK = "\uFEFF";
+    Papa.BAD_DELIMITERS = ["\r", `
+`, '"', Papa.BYTE_ORDER_MARK];
+    Papa.WORKERS_SUPPORTED = !IS_WORKER && !!global.Worker;
+    Papa.NODE_STREAM_INPUT = 1;
+    Papa.LocalChunkSize = 1024 * 1024 * 10;
+    Papa.RemoteChunkSize = 1024 * 1024 * 5;
+    Papa.DefaultDelimiter = ",";
+    Papa.Parser = Parser;
+    Papa.ParserHandle = ParserHandle;
+    Papa.NetworkStreamer = NetworkStreamer;
+    Papa.FileStreamer = FileStreamer;
+    Papa.StringStreamer = StringStreamer;
+    Papa.ReadableStreamStreamer = ReadableStreamStreamer;
+    if (typeof PAPA_BROWSER_CONTEXT === "undefined") {
+      Papa.DuplexStreamStreamer = DuplexStreamStreamer;
+    }
+    if (IS_PAPA_WORKER) {
+      global.onmessage = workerThreadReceivedMessage;
+    }
+    function stripBom(string) {
+      if (string.charCodeAt(0) === 65279) {
+        return string.slice(1);
+      }
+      return string;
+    }
+    function CsvToJson(_input, _config) {
+      _config = _config || {};
+      var dynamicTyping = _config.dynamicTyping || false;
+      if (isFunction(dynamicTyping)) {
+        _config.dynamicTypingFunction = dynamicTyping;
+        dynamicTyping = {};
+      }
+      _config.dynamicTyping = dynamicTyping;
+      _config.transform = isFunction(_config.transform) ? _config.transform : false;
+      if (_config.downloadTimeout !== undefined) {
+        var downloadTimeout = parseInt(_config.downloadTimeout);
+        if (isNaN(downloadTimeout)) {
+          throw new Error("Config downloadTimeout value (" + _config.downloadTimeout + ") not parsable by parseInt(val).");
+        }
+        _config.downloadTimeout = downloadTimeout;
+      }
+      if (_config.worker && Papa.WORKERS_SUPPORTED) {
+        var w = newWorker();
+        w.userStep = _config.step;
+        w.userChunk = _config.chunk;
+        w.userComplete = _config.complete;
+        w.userError = _config.error;
+        _config.step = isFunction(_config.step);
+        _config.chunk = isFunction(_config.chunk);
+        _config.complete = isFunction(_config.complete);
+        _config.error = isFunction(_config.error);
+        delete _config.worker;
+        w.postMessage({
+          input: _input,
+          config: _config,
+          workerId: w.id
+        });
+        return;
+      }
+      var streamer = null;
+      if (_input === Papa.NODE_STREAM_INPUT && typeof PAPA_BROWSER_CONTEXT === "undefined") {
+        streamer = new DuplexStreamStreamer(_config);
+        return streamer.getStream();
+      } else if (typeof _input === "string") {
+        _input = stripBom(_input);
+        if (_config.download)
+          streamer = new NetworkStreamer(_config);
+        else
+          streamer = new StringStreamer(_config);
+      } else if (_input.readable === true && isFunction(_input.read) && isFunction(_input.on)) {
+        streamer = new ReadableStreamStreamer(_config);
+      } else if (global.File && _input instanceof File || _input instanceof Object)
+        streamer = new FileStreamer(_config);
+      return streamer.stream(_input);
+    }
+    function JsonToCsv(_input, _config) {
+      var _quotes = false;
+      var _writeHeader = true;
+      var _delimiter = ",";
+      var _newline = `\r
+`;
+      var _quoteChar = '"';
+      var _escapedQuote = _quoteChar + _quoteChar;
+      var _skipEmptyLines = false;
+      var _columns = null;
+      var _escapeFormulae = false;
+      unpackConfig();
+      var quoteCharRegex = new RegExp(escapeRegExp(_quoteChar), "g");
+      if (typeof _input === "string")
+        _input = JSON.parse(_input);
+      if (Array.isArray(_input)) {
+        if (!_input.length || Array.isArray(_input[0]))
+          return serialize(null, _input, _skipEmptyLines);
+        else if (typeof _input[0] === "object")
+          return serialize(_columns || Object.keys(_input[0]), _input, _skipEmptyLines);
+      } else if (typeof _input === "object") {
+        if (typeof _input.data === "string")
+          _input.data = JSON.parse(_input.data);
+        if (Array.isArray(_input.data)) {
+          if (!_input.fields)
+            _input.fields = _input.meta && _input.meta.fields || _columns;
+          if (!_input.fields)
+            _input.fields = Array.isArray(_input.data[0]) ? _input.fields : typeof _input.data[0] === "object" ? Object.keys(_input.data[0]) : [];
+          if (!Array.isArray(_input.data[0]) && typeof _input.data[0] !== "object")
+            _input.data = [_input.data];
+        }
+        return serialize(_input.fields || [], _input.data || [], _skipEmptyLines);
+      }
+      throw new Error("Unable to serialize unrecognized input");
+      function unpackConfig() {
+        if (typeof _config !== "object")
+          return;
+        if (typeof _config.delimiter === "string" && !Papa.BAD_DELIMITERS.filter(function(value) {
+          return _config.delimiter.indexOf(value) !== -1;
+        }).length) {
+          _delimiter = _config.delimiter;
+        }
+        if (typeof _config.quotes === "boolean" || typeof _config.quotes === "function" || Array.isArray(_config.quotes))
+          _quotes = _config.quotes;
+        if (typeof _config.skipEmptyLines === "boolean" || typeof _config.skipEmptyLines === "string")
+          _skipEmptyLines = _config.skipEmptyLines;
+        if (typeof _config.newline === "string")
+          _newline = _config.newline;
+        if (typeof _config.quoteChar === "string") {
+          _quoteChar = _config.quoteChar;
+          _escapedQuote = _quoteChar + _quoteChar;
+        }
+        if (typeof _config.header === "boolean")
+          _writeHeader = _config.header;
+        if (Array.isArray(_config.columns)) {
+          if (_config.columns.length === 0)
+            throw new Error("Option columns is empty");
+          _columns = _config.columns;
+        }
+        if (_config.escapeChar !== undefined) {
+          _escapedQuote = _config.escapeChar + _quoteChar;
+        }
+        if (_config.escapeFormulae instanceof RegExp) {
+          _escapeFormulae = _config.escapeFormulae;
+        } else if (typeof _config.escapeFormulae === "boolean" && _config.escapeFormulae) {
+          _escapeFormulae = /^[=+\-@\t\r].*$/;
+        }
+      }
+      function serialize(fields, data, skipEmptyLines) {
+        var csv = "";
+        if (typeof fields === "string")
+          fields = JSON.parse(fields);
+        if (typeof data === "string")
+          data = JSON.parse(data);
+        var hasHeader = Array.isArray(fields) && fields.length > 0;
+        var dataKeyedByField = !Array.isArray(data[0]);
+        if (hasHeader && _writeHeader) {
+          for (var i = 0;i < fields.length; i++) {
+            if (i > 0)
+              csv += _delimiter;
+            csv += safe(fields[i], i);
+          }
+          if (data.length > 0)
+            csv += _newline;
+        }
+        for (var row = 0;row < data.length; row++) {
+          var maxCol = hasHeader ? fields.length : data[row].length;
+          var emptyLine = false;
+          var nullLine = hasHeader ? Object.keys(data[row]).length === 0 : data[row].length === 0;
+          if (skipEmptyLines && !hasHeader) {
+            emptyLine = skipEmptyLines === "greedy" ? data[row].join("").trim() === "" : data[row].length === 1 && data[row][0].length === 0;
+          }
+          if (skipEmptyLines === "greedy" && hasHeader) {
+            var line = [];
+            for (var c = 0;c < maxCol; c++) {
+              var cx = dataKeyedByField ? fields[c] : c;
+              line.push(data[row][cx]);
+            }
+            emptyLine = line.join("").trim() === "";
+          }
+          if (!emptyLine) {
+            for (var col = 0;col < maxCol; col++) {
+              if (col > 0 && !nullLine)
+                csv += _delimiter;
+              var colIdx = hasHeader && dataKeyedByField ? fields[col] : col;
+              csv += safe(data[row][colIdx], col);
+            }
+            if (row < data.length - 1 && (!skipEmptyLines || maxCol > 0 && !nullLine)) {
+              csv += _newline;
+            }
+          }
+        }
+        return csv;
+      }
+      function safe(str, col) {
+        if (typeof str === "undefined" || str === null)
+          return "";
+        if (str.constructor === Date) {
+          if (isNaN(str.getTime()))
+            return "";
+          return str.toISOString();
+        }
+        var needsQuotes = false;
+        if (_escapeFormulae && typeof str === "string" && _escapeFormulae.test(str)) {
+          str = "'" + str;
+          needsQuotes = true;
+        }
+        var strValue = str.toString();
+        var escapedQuoteStr = strValue.replace(quoteCharRegex, _escapedQuote);
+        needsQuotes = needsQuotes || _quotes === true || typeof _quotes === "function" && _quotes(str, col) || Array.isArray(_quotes) && _quotes[col] || hasAny(escapedQuoteStr, Papa.BAD_DELIMITERS) || escapedQuoteStr.indexOf(_delimiter) > -1 || strValue.indexOf(_quoteChar) > -1 || escapedQuoteStr.charAt(0) === " " || escapedQuoteStr.charAt(escapedQuoteStr.length - 1) === " ";
+        return needsQuotes ? _quoteChar + escapedQuoteStr + _quoteChar : escapedQuoteStr;
+      }
+      function hasAny(str, substrings) {
+        for (var i = 0;i < substrings.length; i++)
+          if (str.indexOf(substrings[i]) > -1)
+            return true;
+        return false;
+      }
+    }
+    function ChunkStreamer(config) {
+      this._handle = null;
+      this._finished = false;
+      this._completed = false;
+      this._halted = false;
+      this._input = null;
+      this._baseIndex = 0;
+      this._partialLine = "";
+      this._rowCount = 0;
+      this._start = 0;
+      this._nextChunk = null;
+      this.isFirstChunk = true;
+      this._completeResults = {
+        data: [],
+        errors: [],
+        meta: {}
+      };
+      replaceConfig.call(this, config);
+      this.parseChunk = function(chunk, isFakeChunk) {
+        const skipFirstNLines = parseInt(this._config.skipFirstNLines) || 0;
+        if (this.isFirstChunk && skipFirstNLines > 0) {
+          let _newline = this._config.newline;
+          if (!_newline) {
+            const quoteChar = this._config.quoteChar || '"';
+            _newline = this._handle.guessLineEndings(chunk, quoteChar);
+          }
+          const splitChunk = chunk.split(_newline);
+          chunk = [...splitChunk.slice(skipFirstNLines)].join(_newline);
+        }
+        if (this.isFirstChunk && isFunction(this._config.beforeFirstChunk)) {
+          var modifiedChunk = this._config.beforeFirstChunk(chunk);
+          if (modifiedChunk !== undefined)
+            chunk = modifiedChunk;
+        }
+        this.isFirstChunk = false;
+        this._halted = false;
+        var aggregate = this._partialLine + chunk;
+        this._partialLine = "";
+        var results = this._handle.parse(aggregate, this._baseIndex, !this._finished);
+        if (this._handle.paused() || this._handle.aborted()) {
+          this._halted = true;
+          return;
+        }
+        var lastIndex = results.meta.cursor;
+        if (!this._finished) {
+          this._partialLine = aggregate.substring(lastIndex - this._baseIndex);
+          this._baseIndex = lastIndex;
+        }
+        if (results && results.data)
+          this._rowCount += results.data.length;
+        var finishedIncludingPreview = this._finished || this._config.preview && this._rowCount >= this._config.preview;
+        if (IS_PAPA_WORKER) {
+          global.postMessage({
+            results,
+            workerId: Papa.WORKER_ID,
+            finished: finishedIncludingPreview
+          });
+        } else if (isFunction(this._config.chunk) && !isFakeChunk) {
+          this._config.chunk(results, this._handle);
+          if (this._handle.paused() || this._handle.aborted()) {
+            this._halted = true;
+            return;
+          }
+          results = undefined;
+          this._completeResults = undefined;
+        }
+        if (!this._config.step && !this._config.chunk) {
+          this._completeResults.data = this._completeResults.data.concat(results.data);
+          this._completeResults.errors = this._completeResults.errors.concat(results.errors);
+          this._completeResults.meta = results.meta;
+        }
+        if (!this._completed && finishedIncludingPreview && isFunction(this._config.complete) && (!results || !results.meta.aborted)) {
+          this._config.complete(this._completeResults, this._input);
+          this._completed = true;
+        }
+        if (!finishedIncludingPreview && (!results || !results.meta.paused))
+          this._nextChunk();
+        return results;
+      };
+      this._sendError = function(error) {
+        if (isFunction(this._config.error))
+          this._config.error(error);
+        else if (IS_PAPA_WORKER && this._config.error) {
+          global.postMessage({
+            workerId: Papa.WORKER_ID,
+            error,
+            finished: false
+          });
+        }
+      };
+      function replaceConfig(config) {
+        var configCopy = copy(config);
+        configCopy.chunkSize = parseInt(configCopy.chunkSize);
+        if (!config.step && !config.chunk)
+          configCopy.chunkSize = null;
+        this._handle = new ParserHandle(configCopy);
+        this._handle.streamer = this;
+        this._config = configCopy;
+      }
+    }
+    function NetworkStreamer(config) {
+      config = config || {};
+      if (!config.chunkSize)
+        config.chunkSize = Papa.RemoteChunkSize;
+      ChunkStreamer.call(this, config);
+      var xhr;
+      if (IS_WORKER) {
+        this._nextChunk = function() {
+          this._readChunk();
+          this._chunkLoaded();
+        };
+      } else {
+        this._nextChunk = function() {
+          this._readChunk();
+        };
+      }
+      this.stream = function(url) {
+        this._input = url;
+        this._nextChunk();
+      };
+      this._readChunk = function() {
+        if (this._finished) {
+          this._chunkLoaded();
+          return;
+        }
+        xhr = new XMLHttpRequest;
+        if (this._config.withCredentials) {
+          xhr.withCredentials = this._config.withCredentials;
+        }
+        if (!IS_WORKER) {
+          xhr.onload = bindFunction(this._chunkLoaded, this);
+          xhr.onerror = bindFunction(this._chunkError, this);
+        }
+        xhr.ontimeout = bindFunction(this._chunkTimeout, this);
+        xhr.open(this._config.downloadRequestBody ? "POST" : "GET", this._input, !IS_WORKER);
+        if (this._config.downloadTimeout && !IS_WORKER) {
+          xhr.timeout = this._config.downloadTimeout;
+        }
+        if (this._config.downloadRequestHeaders) {
+          var headers = this._config.downloadRequestHeaders;
+          for (var headerName in headers) {
+            xhr.setRequestHeader(headerName, headers[headerName]);
+          }
+        }
+        if (this._config.chunkSize) {
+          var end = this._start + this._config.chunkSize - 1;
+          xhr.setRequestHeader("Range", "bytes=" + this._start + "-" + end);
+        }
+        try {
+          xhr.send(this._config.downloadRequestBody);
+        } catch (err) {
+          this._chunkError(err.message);
+        }
+        if (IS_WORKER && xhr.status === 0)
+          this._chunkError();
+      };
+      this._chunkLoaded = function() {
+        if (xhr.readyState !== 4)
+          return;
+        if (xhr.status < 200 || xhr.status >= 400) {
+          this._chunkError();
+          return;
+        }
+        this._start += this._config.chunkSize ? this._config.chunkSize : xhr.responseText.length;
+        this._finished = !this._config.chunkSize || this._start >= getFileSize(xhr);
+        this.parseChunk(xhr.responseText);
+      };
+      this._chunkError = function(errorMessage) {
+        var errorText = xhr.statusText || errorMessage;
+        this._sendError(new Error(errorText));
+      };
+      this._chunkTimeout = function() {
+        this._chunkError("Request timed out after " + this._config.downloadTimeout + "ms");
+      };
+      function getFileSize(xhr) {
+        var contentRange = xhr.getResponseHeader("Content-Range");
+        if (contentRange === null) {
+          return -1;
+        }
+        return parseInt(contentRange.substring(contentRange.lastIndexOf("/") + 1));
+      }
+    }
+    NetworkStreamer.prototype = Object.create(ChunkStreamer.prototype);
+    NetworkStreamer.prototype.constructor = NetworkStreamer;
+    function FileStreamer(config) {
+      config = config || {};
+      if (!config.chunkSize)
+        config.chunkSize = Papa.LocalChunkSize;
+      ChunkStreamer.call(this, config);
+      var reader, slice;
+      var usingAsyncReader = typeof FileReader !== "undefined";
+      this.stream = function(file) {
+        this._input = file;
+        slice = file.slice || file.webkitSlice || file.mozSlice;
+        if (usingAsyncReader) {
+          reader = new FileReader;
+          reader.onload = bindFunction(this._chunkLoaded, this);
+          reader.onerror = bindFunction(this._chunkError, this);
+        } else
+          reader = new FileReaderSync;
+        this._nextChunk();
+      };
+      this._nextChunk = function() {
+        if (!this._finished && (!this._config.preview || this._rowCount < this._config.preview))
+          this._readChunk();
+      };
+      this._readChunk = function() {
+        var input = this._input;
+        if (this._config.chunkSize) {
+          var end = Math.min(this._start + this._config.chunkSize, this._input.size);
+          input = slice.call(input, this._start, end);
+        }
+        var txt = reader.readAsText(input, this._config.encoding);
+        if (!usingAsyncReader)
+          this._chunkLoaded({ target: { result: txt } });
+      };
+      this._chunkLoaded = function(event) {
+        this._start += this._config.chunkSize;
+        this._finished = !this._config.chunkSize || this._start >= this._input.size;
+        this.parseChunk(event.target.result);
+      };
+      this._chunkError = function() {
+        this._sendError(reader.error);
+      };
+    }
+    FileStreamer.prototype = Object.create(ChunkStreamer.prototype);
+    FileStreamer.prototype.constructor = FileStreamer;
+    function StringStreamer(config) {
+      config = config || {};
+      ChunkStreamer.call(this, config);
+      var remaining;
+      this.stream = function(s) {
+        remaining = s;
+        return this._nextChunk();
+      };
+      this._nextChunk = function() {
+        if (this._finished)
+          return;
+        var size = this._config.chunkSize;
+        var chunk;
+        if (size) {
+          chunk = remaining.substring(0, size);
+          remaining = remaining.substring(size);
+        } else {
+          chunk = remaining;
+          remaining = "";
+        }
+        this._finished = !remaining;
+        return this.parseChunk(chunk);
+      };
+    }
+    StringStreamer.prototype = Object.create(StringStreamer.prototype);
+    StringStreamer.prototype.constructor = StringStreamer;
+    function ReadableStreamStreamer(config) {
+      config = config || {};
+      ChunkStreamer.call(this, config);
+      var queue = [];
+      var parseOnData = true;
+      var streamHasEnded = false;
+      this.pause = function() {
+        ChunkStreamer.prototype.pause.apply(this, arguments);
+        this._input.pause();
+      };
+      this.resume = function() {
+        ChunkStreamer.prototype.resume.apply(this, arguments);
+        this._input.resume();
+      };
+      this.stream = function(stream) {
+        this._input = stream;
+        this._input.on("data", this._streamData);
+        this._input.on("end", this._streamEnd);
+        this._input.on("error", this._streamError);
+      };
+      this._checkIsFinished = function() {
+        if (streamHasEnded && queue.length === 1) {
+          this._finished = true;
+        }
+      };
+      this._nextChunk = function() {
+        this._checkIsFinished();
+        if (queue.length) {
+          this.parseChunk(queue.shift());
+        } else {
+          parseOnData = true;
+        }
+      };
+      this._streamData = bindFunction(function(chunk) {
+        try {
+          queue.push(typeof chunk === "string" ? chunk : chunk.toString(this._config.encoding));
+          if (parseOnData) {
+            parseOnData = false;
+            this._checkIsFinished();
+            this.parseChunk(queue.shift());
+          }
+        } catch (error) {
+          this._streamError(error);
+        }
+      }, this);
+      this._streamError = bindFunction(function(error) {
+        this._streamCleanUp();
+        this._sendError(error);
+      }, this);
+      this._streamEnd = bindFunction(function() {
+        this._streamCleanUp();
+        streamHasEnded = true;
+        this._streamData("");
+      }, this);
+      this._streamCleanUp = bindFunction(function() {
+        this._input.removeListener("data", this._streamData);
+        this._input.removeListener("end", this._streamEnd);
+        this._input.removeListener("error", this._streamError);
+      }, this);
+    }
+    ReadableStreamStreamer.prototype = Object.create(ChunkStreamer.prototype);
+    ReadableStreamStreamer.prototype.constructor = ReadableStreamStreamer;
+    function DuplexStreamStreamer(_config) {
+      var Duplex = __require("stream").Duplex;
+      var config = copy(_config);
+      var parseOnWrite = true;
+      var writeStreamHasFinished = false;
+      var parseCallbackQueue = [];
+      var stream = null;
+      this._onCsvData = function(results) {
+        var data = results.data;
+        if (!stream.push(data) && !this._handle.paused()) {
+          this._handle.pause();
+        }
+      };
+      this._onCsvComplete = function() {
+        stream.push(null);
+      };
+      config.step = bindFunction(this._onCsvData, this);
+      config.complete = bindFunction(this._onCsvComplete, this);
+      ChunkStreamer.call(this, config);
+      this._nextChunk = function() {
+        if (writeStreamHasFinished && parseCallbackQueue.length === 1) {
+          this._finished = true;
+        }
+        if (parseCallbackQueue.length) {
+          parseCallbackQueue.shift()();
+        } else {
+          parseOnWrite = true;
+        }
+      };
+      this._addToParseQueue = function(chunk, callback) {
+        parseCallbackQueue.push(bindFunction(function() {
+          this.parseChunk(typeof chunk === "string" ? chunk : chunk.toString(config.encoding));
+          if (isFunction(callback)) {
+            return callback();
+          }
+        }, this));
+        if (parseOnWrite) {
+          parseOnWrite = false;
+          this._nextChunk();
+        }
+      };
+      this._onRead = function() {
+        if (this._handle.paused()) {
+          this._handle.resume();
+        }
+      };
+      this._onWrite = function(chunk, encoding, callback) {
+        this._addToParseQueue(chunk, callback);
+      };
+      this._onWriteComplete = function() {
+        writeStreamHasFinished = true;
+        this._addToParseQueue("");
+      };
+      this.getStream = function() {
+        return stream;
+      };
+      stream = new Duplex({
+        readableObjectMode: true,
+        decodeStrings: false,
+        read: bindFunction(this._onRead, this),
+        write: bindFunction(this._onWrite, this)
+      });
+      stream.once("finish", bindFunction(this._onWriteComplete, this));
+    }
+    if (typeof PAPA_BROWSER_CONTEXT === "undefined") {
+      DuplexStreamStreamer.prototype = Object.create(ChunkStreamer.prototype);
+      DuplexStreamStreamer.prototype.constructor = DuplexStreamStreamer;
+    }
+    function ParserHandle(_config) {
+      var MAX_FLOAT = Math.pow(2, 53);
+      var MIN_FLOAT = -MAX_FLOAT;
+      var FLOAT = /^\s*-?(\d+\.?|\.\d+|\d+\.\d+)([eE][-+]?\d+)?\s*$/;
+      var ISO_DATE = /^((\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d+([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z)))$/;
+      var self2 = this;
+      var _stepCounter = 0;
+      var _rowCounter = 0;
+      var _input;
+      var _parser;
+      var _paused = false;
+      var _aborted = false;
+      var _delimiterError;
+      var _fields = [];
+      var _results = {
+        data: [],
+        errors: [],
+        meta: {}
+      };
+      if (isFunction(_config.step)) {
+        var userStep = _config.step;
+        _config.step = function(results) {
+          _results = results;
+          if (needsHeaderRow())
+            processResults();
+          else {
+            processResults();
+            if (_results.data.length === 0)
+              return;
+            _stepCounter += results.data.length;
+            if (_config.preview && _stepCounter > _config.preview)
+              _parser.abort();
+            else {
+              _results.data = _results.data[0];
+              userStep(_results, self2);
+            }
+          }
+        };
+      }
+      this.parse = function(input, baseIndex, ignoreLastRow) {
+        var quoteChar = _config.quoteChar || '"';
+        if (!_config.newline)
+          _config.newline = this.guessLineEndings(input, quoteChar);
+        _delimiterError = false;
+        if (!_config.delimiter) {
+          var delimGuess = guessDelimiter(input, _config.newline, _config.skipEmptyLines, _config.comments, _config.delimitersToGuess);
+          if (delimGuess.successful)
+            _config.delimiter = delimGuess.bestDelimiter;
+          else {
+            _delimiterError = true;
+            _config.delimiter = Papa.DefaultDelimiter;
+          }
+          _results.meta.delimiter = _config.delimiter;
+        } else if (isFunction(_config.delimiter)) {
+          _config.delimiter = _config.delimiter(input);
+          _results.meta.delimiter = _config.delimiter;
+        }
+        var parserConfig = copy(_config);
+        parserConfig.header = needsHeaderRow();
+        if (_config.preview && _config.header)
+          parserConfig.preview++;
+        _input = input;
+        _parser = new Parser(parserConfig);
+        _results = _parser.parse(_input, baseIndex, ignoreLastRow);
+        processResults();
+        return _paused ? { meta: { paused: true } } : _results || { meta: { paused: false } };
+      };
+      this.paused = function() {
+        return _paused;
+      };
+      this.pause = function() {
+        _paused = true;
+        _parser.abort();
+        _input = isFunction(_config.chunk) ? "" : _input.substring(_parser.getCharIndex());
+      };
+      this.resume = function() {
+        if (self2.streamer._halted) {
+          _paused = false;
+          self2.streamer.parseChunk(_input, true);
+        } else {
+          setTimeout(self2.resume, 3);
+        }
+      };
+      this.aborted = function() {
+        return _aborted;
+      };
+      this.abort = function() {
+        _aborted = true;
+        _parser.abort();
+        _results.meta.aborted = true;
+        if (isFunction(_config.complete))
+          _config.complete(_results);
+        _input = "";
+      };
+      this.guessLineEndings = function(input, quoteChar) {
+        input = input.substring(0, 1024 * 1024);
+        var re = new RegExp(escapeRegExp(quoteChar) + "([^]*?)" + escapeRegExp(quoteChar), "gm");
+        input = input.replace(re, "");
+        var r = input.split("\r");
+        var n = input.split(`
+`);
+        var nAppearsFirst = n.length > 1 && n[0].length < r[0].length;
+        if (r.length === 1 || nAppearsFirst)
+          return `
+`;
+        var numWithN = 0;
+        for (var i = 0;i < r.length; i++) {
+          if (r[i][0] === `
+`)
+            numWithN++;
+        }
+        return numWithN >= r.length / 2 ? `\r
+` : "\r";
+      };
+      function testEmptyLine(s) {
+        return _config.skipEmptyLines === "greedy" ? s.join("").trim() === "" : s.length === 1 && s[0].length === 0;
+      }
+      function testFloat(s) {
+        if (FLOAT.test(s)) {
+          var floatValue = parseFloat(s);
+          if (floatValue > MIN_FLOAT && floatValue < MAX_FLOAT) {
+            return true;
+          }
+        }
+        return false;
+      }
+      function processResults() {
+        if (_results && _delimiterError) {
+          addError("Delimiter", "UndetectableDelimiter", "Unable to auto-detect delimiting character; defaulted to '" + Papa.DefaultDelimiter + "'");
+          _delimiterError = false;
+        }
+        if (_config.skipEmptyLines) {
+          _results.data = _results.data.filter(function(d) {
+            return !testEmptyLine(d);
+          });
+        }
+        if (needsHeaderRow())
+          fillHeaderFields();
+        return applyHeaderAndDynamicTypingAndTransformation();
+      }
+      function needsHeaderRow() {
+        return _config.header && _fields.length === 0;
+      }
+      function fillHeaderFields() {
+        if (!_results)
+          return;
+        function addHeader(header) {
+          _fields.push(header);
+        }
+        if (Array.isArray(_results.data[0])) {
+          for (var i = 0;needsHeaderRow() && i < _results.data.length; i++)
+            _results.data[i].forEach(addHeader);
+          _results.data.splice(0, 1);
+        } else
+          _results.data.forEach(addHeader);
+      }
+      function shouldApplyDynamicTyping(field) {
+        if (_config.dynamicTypingFunction && _config.dynamicTyping[field] === undefined) {
+          _config.dynamicTyping[field] = _config.dynamicTypingFunction(field);
+        }
+        return (_config.dynamicTyping[field] || _config.dynamicTyping) === true;
+      }
+      function parseDynamic(field, value) {
+        if (shouldApplyDynamicTyping(field)) {
+          if (value === "true" || value === "TRUE")
+            return true;
+          else if (value === "false" || value === "FALSE")
+            return false;
+          else if (testFloat(value))
+            return parseFloat(value);
+          else if (ISO_DATE.test(value))
+            return new Date(value);
+          else
+            return value === "" ? null : value;
+        }
+        return value;
+      }
+      function applyHeaderAndDynamicTypingAndTransformation() {
+        if (!_results || !_config.header && !_config.dynamicTyping && !_config.transform)
+          return _results;
+        function processRow(rowSource, i) {
+          var row = _config.header ? {} : [];
+          var j;
+          for (j = 0;j < rowSource.length; j++) {
+            var field = j;
+            var value = rowSource[j];
+            if (_config.header)
+              field = j >= _fields.length ? "__parsed_extra" : _fields[j];
+            if (_config.transform)
+              value = _config.transform(value, field);
+            value = parseDynamic(field, value);
+            if (field === "__parsed_extra") {
+              row[field] = row[field] || [];
+              row[field].push(value);
+            } else
+              row[field] = value;
+          }
+          if (_config.header) {
+            if (j > _fields.length)
+              addError("FieldMismatch", "TooManyFields", "Too many fields: expected " + _fields.length + " fields but parsed " + j, _rowCounter + i);
+            else if (j < _fields.length)
+              addError("FieldMismatch", "TooFewFields", "Too few fields: expected " + _fields.length + " fields but parsed " + j, _rowCounter + i);
+          }
+          return row;
+        }
+        var incrementBy = 1;
+        if (!_results.data.length || Array.isArray(_results.data[0])) {
+          _results.data = _results.data.map(processRow);
+          incrementBy = _results.data.length;
+        } else
+          _results.data = processRow(_results.data, 0);
+        if (_config.header && _results.meta)
+          _results.meta.fields = _fields;
+        _rowCounter += incrementBy;
+        return _results;
+      }
+      function guessDelimiter(input, newline, skipEmptyLines, comments, delimitersToGuess) {
+        var bestDelim, bestDelta, fieldCountPrevRow, maxFieldCount;
+        delimitersToGuess = delimitersToGuess || [",", "\t", "|", ";", Papa.RECORD_SEP, Papa.UNIT_SEP];
+        for (var i = 0;i < delimitersToGuess.length; i++) {
+          var delim = delimitersToGuess[i];
+          var delta = 0, avgFieldCount = 0, emptyLinesCount = 0;
+          fieldCountPrevRow = undefined;
+          var preview = new Parser({
+            comments,
+            delimiter: delim,
+            newline,
+            preview: 10
+          }).parse(input);
+          for (var j = 0;j < preview.data.length; j++) {
+            if (skipEmptyLines && testEmptyLine(preview.data[j])) {
+              emptyLinesCount++;
+              continue;
+            }
+            var fieldCount = preview.data[j].length;
+            avgFieldCount += fieldCount;
+            if (typeof fieldCountPrevRow === "undefined") {
+              fieldCountPrevRow = fieldCount;
+              continue;
+            } else if (fieldCount > 0) {
+              delta += Math.abs(fieldCount - fieldCountPrevRow);
+              fieldCountPrevRow = fieldCount;
+            }
+          }
+          if (preview.data.length > 0)
+            avgFieldCount /= preview.data.length - emptyLinesCount;
+          if (avgFieldCount > 1.99 && (typeof bestDelta === "undefined" || delta < bestDelta || delta === bestDelta && avgFieldCount > maxFieldCount)) {
+            bestDelta = delta;
+            bestDelim = delim;
+            maxFieldCount = avgFieldCount;
+          }
+        }
+        _config.delimiter = bestDelim;
+        return {
+          successful: !!bestDelim,
+          bestDelimiter: bestDelim
+        };
+      }
+      function addError(type, code, msg, row) {
+        var error = {
+          type,
+          code,
+          message: msg
+        };
+        if (row !== undefined) {
+          error.row = row;
+        }
+        _results.errors.push(error);
+      }
+    }
+    function escapeRegExp(string) {
+      return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }
+    function Parser(config) {
+      config = config || {};
+      var delim = config.delimiter;
+      var newline = config.newline;
+      var comments = config.comments;
+      var step = config.step;
+      var preview = config.preview;
+      var fastMode = config.fastMode;
+      var quoteChar;
+      var renamedHeaders = null;
+      var headerParsed = false;
+      if (config.quoteChar === undefined || config.quoteChar === null) {
+        quoteChar = '"';
+      } else {
+        quoteChar = config.quoteChar;
+      }
+      var escapeChar = quoteChar;
+      if (config.escapeChar !== undefined) {
+        escapeChar = config.escapeChar;
+      }
+      if (typeof delim !== "string" || Papa.BAD_DELIMITERS.indexOf(delim) > -1)
+        delim = ",";
+      if (comments === delim)
+        throw new Error("Comment character same as delimiter");
+      else if (comments === true)
+        comments = "#";
+      else if (typeof comments !== "string" || Papa.BAD_DELIMITERS.indexOf(comments) > -1)
+        comments = false;
+      if (newline !== `
+` && newline !== "\r" && newline !== `\r
+`)
+        newline = `
+`;
+      var cursor = 0;
+      var aborted = false;
+      this.parse = function(input, baseIndex, ignoreLastRow) {
+        if (typeof input !== "string")
+          throw new Error("Input must be a string");
+        var inputLen = input.length, delimLen = delim.length, newlineLen = newline.length, commentsLen = comments.length;
+        var stepIsFunction = isFunction(step);
+        cursor = 0;
+        var data = [], errors = [], row = [], lastCursor = 0;
+        if (!input)
+          return returnable();
+        if (fastMode || fastMode !== false && input.indexOf(quoteChar) === -1) {
+          var rows = input.split(newline);
+          for (var i = 0;i < rows.length; i++) {
+            row = rows[i];
+            cursor += row.length;
+            if (i !== rows.length - 1)
+              cursor += newline.length;
+            else if (ignoreLastRow)
+              return returnable();
+            if (comments && row.substring(0, commentsLen) === comments)
+              continue;
+            if (stepIsFunction) {
+              data = [];
+              pushRow(row.split(delim));
+              doStep();
+              if (aborted)
+                return returnable();
+            } else
+              pushRow(row.split(delim));
+            if (preview && i >= preview) {
+              data = data.slice(0, preview);
+              return returnable(true);
+            }
+          }
+          return returnable();
+        }
+        var nextDelim = input.indexOf(delim, cursor);
+        var nextNewline = input.indexOf(newline, cursor);
+        var quoteCharRegex = new RegExp(escapeRegExp(escapeChar) + escapeRegExp(quoteChar), "g");
+        var quoteSearch = input.indexOf(quoteChar, cursor);
+        for (;; ) {
+          if (input[cursor] === quoteChar) {
+            quoteSearch = cursor;
+            cursor++;
+            for (;; ) {
+              quoteSearch = input.indexOf(quoteChar, quoteSearch + 1);
+              if (quoteSearch === -1) {
+                if (!ignoreLastRow) {
+                  errors.push({
+                    type: "Quotes",
+                    code: "MissingQuotes",
+                    message: "Quoted field unterminated",
+                    row: data.length,
+                    index: cursor
+                  });
+                }
+                return finish();
+              }
+              if (quoteSearch === inputLen - 1) {
+                var value = input.substring(cursor, quoteSearch).replace(quoteCharRegex, quoteChar);
+                return finish(value);
+              }
+              if (quoteChar === escapeChar && input[quoteSearch + 1] === escapeChar) {
+                quoteSearch++;
+                continue;
+              }
+              if (quoteChar !== escapeChar && quoteSearch !== 0 && input[quoteSearch - 1] === escapeChar) {
+                continue;
+              }
+              if (nextDelim !== -1 && nextDelim < quoteSearch + 1) {
+                nextDelim = input.indexOf(delim, quoteSearch + 1);
+              }
+              if (nextNewline !== -1 && nextNewline < quoteSearch + 1) {
+                nextNewline = input.indexOf(newline, quoteSearch + 1);
+              }
+              var checkUpTo = nextNewline === -1 ? nextDelim : Math.min(nextDelim, nextNewline);
+              var spacesBetweenQuoteAndDelimiter = extraSpaces(checkUpTo);
+              if (input.substr(quoteSearch + 1 + spacesBetweenQuoteAndDelimiter, delimLen) === delim) {
+                row.push(input.substring(cursor, quoteSearch).replace(quoteCharRegex, quoteChar));
+                cursor = quoteSearch + 1 + spacesBetweenQuoteAndDelimiter + delimLen;
+                if (input[quoteSearch + 1 + spacesBetweenQuoteAndDelimiter + delimLen] !== quoteChar) {
+                  quoteSearch = input.indexOf(quoteChar, cursor);
+                }
+                nextDelim = input.indexOf(delim, cursor);
+                nextNewline = input.indexOf(newline, cursor);
+                break;
+              }
+              var spacesBetweenQuoteAndNewLine = extraSpaces(nextNewline);
+              if (input.substring(quoteSearch + 1 + spacesBetweenQuoteAndNewLine, quoteSearch + 1 + spacesBetweenQuoteAndNewLine + newlineLen) === newline) {
+                row.push(input.substring(cursor, quoteSearch).replace(quoteCharRegex, quoteChar));
+                saveRow(quoteSearch + 1 + spacesBetweenQuoteAndNewLine + newlineLen);
+                nextDelim = input.indexOf(delim, cursor);
+                quoteSearch = input.indexOf(quoteChar, cursor);
+                if (stepIsFunction) {
+                  doStep();
+                  if (aborted)
+                    return returnable();
+                }
+                if (preview && data.length >= preview)
+                  return returnable(true);
+                break;
+              }
+              errors.push({
+                type: "Quotes",
+                code: "InvalidQuotes",
+                message: "Trailing quote on quoted field is malformed",
+                row: data.length,
+                index: cursor
+              });
+              quoteSearch++;
+              continue;
+            }
+            continue;
+          }
+          if (comments && row.length === 0 && input.substring(cursor, cursor + commentsLen) === comments) {
+            if (nextNewline === -1)
+              return returnable();
+            cursor = nextNewline + newlineLen;
+            nextNewline = input.indexOf(newline, cursor);
+            nextDelim = input.indexOf(delim, cursor);
+            continue;
+          }
+          if (nextDelim !== -1 && (nextDelim < nextNewline || nextNewline === -1)) {
+            row.push(input.substring(cursor, nextDelim));
+            cursor = nextDelim + delimLen;
+            nextDelim = input.indexOf(delim, cursor);
+            continue;
+          }
+          if (nextNewline !== -1) {
+            row.push(input.substring(cursor, nextNewline));
+            saveRow(nextNewline + newlineLen);
+            if (stepIsFunction) {
+              doStep();
+              if (aborted)
+                return returnable();
+            }
+            if (preview && data.length >= preview)
+              return returnable(true);
+            continue;
+          }
+          break;
+        }
+        return finish();
+        function pushRow(row) {
+          data.push(row);
+          lastCursor = cursor;
+        }
+        function extraSpaces(index) {
+          var spaceLength = 0;
+          if (index !== -1) {
+            var textBetweenClosingQuoteAndIndex = input.substring(quoteSearch + 1, index);
+            if (textBetweenClosingQuoteAndIndex && textBetweenClosingQuoteAndIndex.trim() === "") {
+              spaceLength = textBetweenClosingQuoteAndIndex.length;
+            }
+          }
+          return spaceLength;
+        }
+        function finish(value) {
+          if (ignoreLastRow)
+            return returnable();
+          if (typeof value === "undefined")
+            value = input.substring(cursor);
+          row.push(value);
+          cursor = inputLen;
+          pushRow(row);
+          if (stepIsFunction)
+            doStep();
+          return returnable();
+        }
+        function saveRow(newCursor) {
+          cursor = newCursor;
+          pushRow(row);
+          row = [];
+          nextNewline = input.indexOf(newline, cursor);
+        }
+        function returnable(stopped) {
+          if (config.header && !baseIndex && data.length && !headerParsed) {
+            const result = data[0];
+            const headerCount = Object.create(null);
+            const usedHeaders = new Set(result);
+            let duplicateHeaders = false;
+            for (let i = 0;i < result.length; i++) {
+              let header = stripBom(result[i]);
+              if (isFunction(config.transformHeader))
+                header = config.transformHeader(header, i);
+              if (!headerCount[header]) {
+                headerCount[header] = 1;
+                result[i] = header;
+              } else {
+                let newHeader;
+                let suffixCount = headerCount[header];
+                do {
+                  newHeader = `${header}_${suffixCount}`;
+                  suffixCount++;
+                } while (usedHeaders.has(newHeader));
+                usedHeaders.add(newHeader);
+                result[i] = newHeader;
+                headerCount[header]++;
+                duplicateHeaders = true;
+                if (renamedHeaders === null) {
+                  renamedHeaders = {};
+                }
+                renamedHeaders[newHeader] = header;
+              }
+              usedHeaders.add(header);
+            }
+            if (duplicateHeaders) {
+              console.warn("Duplicate headers found and renamed.");
+            }
+            headerParsed = true;
+          }
+          return {
+            data,
+            errors,
+            meta: {
+              delimiter: delim,
+              linebreak: newline,
+              aborted,
+              truncated: !!stopped,
+              cursor: lastCursor + (baseIndex || 0),
+              renamedHeaders
+            }
+          };
+        }
+        function doStep() {
+          step(returnable());
+          data = [];
+          errors = [];
+        }
+      };
+      this.abort = function() {
+        aborted = true;
+      };
+      this.getCharIndex = function() {
+        return cursor;
+      };
+    }
+    function newWorker() {
+      if (!Papa.WORKERS_SUPPORTED)
+        return false;
+      var workerUrl = getWorkerBlob();
+      var w = new global.Worker(workerUrl);
+      w.onmessage = mainThreadReceivedMessage;
+      w.id = workerIdCounter++;
+      workers[w.id] = w;
+      return w;
+    }
+    function mainThreadReceivedMessage(e) {
+      var msg = e.data;
+      var worker = workers[msg.workerId];
+      var aborted = false;
+      if (msg.error)
+        worker.userError(msg.error, msg.file);
+      else if (msg.results && msg.results.data) {
+        var abort = function() {
+          aborted = true;
+          completeWorker(msg.workerId, { data: [], errors: [], meta: { aborted: true } });
+        };
+        var handle = {
+          abort,
+          pause: notImplemented,
+          resume: notImplemented
+        };
+        if (isFunction(worker.userStep)) {
+          for (var i = 0;i < msg.results.data.length; i++) {
+            worker.userStep({
+              data: msg.results.data[i],
+              errors: msg.results.errors,
+              meta: msg.results.meta
+            }, handle);
+            if (aborted)
+              break;
+          }
+          delete msg.results;
+        } else if (isFunction(worker.userChunk)) {
+          worker.userChunk(msg.results, handle, msg.file);
+          delete msg.results;
+        }
+      }
+      if (msg.finished && !aborted)
+        completeWorker(msg.workerId, msg.results);
+    }
+    function completeWorker(workerId, results) {
+      var worker = workers[workerId];
+      if (isFunction(worker.userComplete))
+        worker.userComplete(results);
+      worker.terminate();
+      delete workers[workerId];
+    }
+    function notImplemented() {
+      throw new Error("Not implemented.");
+    }
+    function workerThreadReceivedMessage(e) {
+      var msg = e.data;
+      if (typeof Papa.WORKER_ID === "undefined" && msg)
+        Papa.WORKER_ID = msg.workerId;
+      if (typeof msg.input === "string") {
+        global.postMessage({
+          workerId: Papa.WORKER_ID,
+          results: Papa.parse(msg.input, msg.config),
+          finished: true
+        });
+      } else if (global.File && msg.input instanceof File || msg.input instanceof Object) {
+        var results = Papa.parse(msg.input, msg.config);
+        if (results)
+          global.postMessage({
+            workerId: Papa.WORKER_ID,
+            results,
+            finished: true
+          });
+      }
+    }
+    function copy(obj) {
+      if (typeof obj !== "object" || obj === null)
+        return obj;
+      var cpy = Array.isArray(obj) ? [] : {};
+      for (var key in obj)
+        cpy[key] = copy(obj[key]);
+      return cpy;
+    }
+    function bindFunction(f, self2) {
+      return function() {
+        f.apply(self2, arguments);
+      };
+    }
+    function isFunction(func) {
+      return typeof func === "function";
+    }
+    return Papa;
+  });
+});
+
+// packages/xml-parser/node.js
+import { parentPort, Worker } from "node:worker_threads";
+function toTransferList(transfer) {
+  return transfer;
+}
+function createNodeXmlWorker(entry) {
+  const worker = new Worker(entry);
+  let is_terminated = false;
+  const error_listeners = [];
+  worker.on("exit", (code) => {
+    if (is_terminated)
+      return;
+    for (const listener of error_listeners)
+      listener({ message: `The worker exited with code ${code}.` });
+  });
+  return {
+    postMessage(message, transfer) {
+      worker.postMessage(message, toTransferList(transfer));
+    },
+    addEventListener(type, listener) {
+      if (type === "message")
+        worker.on("message", (data) => listener({ data }));
+      else if (type === "messageerror")
+        worker.on("messageerror", (error) => listener({ error }));
+      else if (type === "error") {
+        error_listeners.push(listener);
+        worker.on("error", (error) => listener({ message: error?.message, error }));
+      }
+    },
+    terminate() {
+      is_terminated = true;
+      return worker.terminate();
+    }
+  };
+}
+
+// packages/import/src/constants.js
+var IMPORT_BATCH_BYTES = 1024 * 1024;
+var IMPORT_BATCH_ROWS = 500;
+var IMPORT_JSON_BYTES = 50 * 1024 * 1024;
+var IMPORT_CHUNK_BYTES = 16 * 1024;
+var IMPORT_SNIFF_BYTES = 256 * 1024;
+var IMPORT_SAMPLE_BYTES = 2 * 1024 * 1024;
+var IMPORT_SAMPLE_ROWS = 1000;
+var IMPORT_MAX_WORKERS = 16;
+var IMPORT_AUTO_WORKERS = 2;
+var IMPORT_XML_SEGMENT_MAX_BYTES = 2 * IMPORT_BATCH_BYTES;
+var IMPORT_XML_READ_BYTES = 256 * 1024;
+var IMPORT_WORKER_MIN_BYTES = 32 * 1024 * 1024;
+var IMPORT_FORMATS = Object.freeze({
+  xml: "xml",
+  jsonl: "jsonl",
+  json: "json",
+  csv: "csv",
+  tsv: "tsv"
+});
+var IMPORT_REJECTED_STATUSES = Object.freeze([
+  400,
+  401,
+  403,
+  404,
+  405,
+  409,
+  410,
+  413,
+  415,
+  422,
+  429
+]);
+
+// packages/import/src/source.js
+function checkImportAbort(signal) {
+  if (signal?.aborted)
+    throw signal.reason ?? new DOMException("Import cancelled", "AbortError");
+}
+function createBlobSource(blob, name = "name" in blob ? String(blob.name) : "input") {
+  return {
+    name,
+    size: blob.size,
+    async* open() {
+      for (let offset = 0;offset < blob.size; offset += IMPORT_CHUNK_BYTES) {
+        yield new Uint8Array(await blob.slice(offset, offset + IMPORT_CHUNK_BYTES).arrayBuffer());
+      }
+    },
+    async read(start, end) {
+      return new Uint8Array(await blob.slice(start, end).arrayBuffer());
+    }
+  };
+}
+async function* readImportBytes(source, signal) {
+  checkImportAbort(signal);
+  const opened = source.open();
+  const reader = "getReader" in opened ? opened.getReader() : null;
+  const iterator = reader ? null : opened[Symbol.asyncIterator]();
+  let is_complete = false;
+  try {
+    while (true) {
+      checkImportAbort(signal);
+      const result = await awaitImportRead(reader ? reader.read() : iterator.next(), signal);
+      if (result.done) {
+        is_complete = true;
+        return;
+      }
+      if (!(result.value instanceof Uint8Array))
+        throw new TypeError("Import sources must yield Uint8Array chunks.");
+      for (let offset = 0;offset < result.value.length; offset += IMPORT_CHUNK_BYTES) {
+        checkImportAbort(signal);
+        yield result.value.subarray(offset, offset + IMPORT_CHUNK_BYTES);
+      }
+    }
+  } finally {
+    try {
+      if (!is_complete) {
+        const closing = reader ? reader.cancel() : iterator.return?.();
+        if (signal?.aborted)
+          Promise.resolve(closing).catch(() => {});
+        else
+          await closing;
+      }
+    } finally {
+      reader?.releaseLock();
+    }
+  }
+}
+async function* decodeImportBytes(chunks) {
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  try {
+    for await (const chunk of chunks)
+      yield decoder.decode(chunk, { stream: true });
+    const tail = decoder.decode();
+    if (tail)
+      yield tail;
+  } catch (error) {
+    if (error instanceof TypeError && /encoded data|encoding|utf-?8/i.test(error.message)) {
+      throw new Error("This file is not valid UTF-8.");
+    }
+    throw error;
+  }
+}
+function awaitImportRead(pending, signal) {
+  if (!signal)
+    return Promise.resolve(pending);
+  return new Promise((resolve, reject) => {
+    const onabort = () => reject(signal.reason ?? new DOMException("Import cancelled", "AbortError"));
+    signal.addEventListener("abort", onabort, { once: true });
+    Promise.resolve(pending).then((value) => {
+      signal.removeEventListener("abort", onabort);
+      resolve(value);
+    }, (error) => {
+      signal.removeEventListener("abort", onabort);
+      reject(error);
+    });
+    if (signal.aborted) {
+      signal.removeEventListener("abort", onabort);
+      onabort();
+    }
+  });
+}
+// packages/xml-parser/src/parser.js
+var NAME_START = ":A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\u{10000}-\\u{EFFFF}";
+var NAME = new RegExp(`^[${NAME_START}][${NAME_START}\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$`, "u");
+var ASCII_NAME = new Uint8Array(128);
+for (let code = 0;code < 128; code++) {
+  const char = String.fromCharCode(code);
+  if (/[:A-Z_a-z]/.test(char))
+    ASCII_NAME[code] = 3;
+  else if (/[-.0-9]/.test(char))
+    ASCII_NAME[code] = 2;
+}
+var SUSPECT_CHAR = new RegExp("[\\0-\\x08\\x0B\\x0C\\x0E-\\x1F\\uD800-\\uDFFF\\uFFFE\\uFFFF]");
+var INVALID_CHAR = new RegExp("[\\0-\\x08\\x0B\\x0C\\x0E-\\x1F\\uFFFE\\uFFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|" + "(?:^|[^\\uD800-\\uDBFF])[\\uDC00-\\uDFFF]");
+var SPACE = /^[ \t\r\n]*$/;
+var TAG_DELIMITER = /["'>]/g;
+var LINE_END = /\r\n?/g;
+var ATTRIBUTE_SPACE = /\r\n?|[\t\n]/g;
+var ENTITIES = Object.assign(Object.create(null), {
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  apos: "'",
+  quot: '"'
+});
+var NAME_CACHE_SIZE = 64;
+var DEFAULTS = {
+  maxDepth: 256,
+  maxTokenLength: 4 * 1024 * 1024,
+  maxNameLength: 1024,
+  maxAttributes: 4096
+};
+function normalizeLineEnds(value) {
+  return value.includes("\r") ? value.replace(LINE_END, `
+`) : value;
+}
+function isXmlChar(cp) {
+  if (cp < 32)
+    return cp === 9 || cp === 10 || cp === 13;
+  return cp <= 55295 || cp >= 57344 && cp <= 65533 || cp >= 65536 && cp <= 1114111;
+}
+function decodeReference(source, start, end) {
+  if (source.charCodeAt(start) !== 35)
+    return ENTITIES[source.slice(start, end)] ?? null;
+  let i = start + 1;
+  const is_hex = source.charCodeAt(i) === 120;
+  if (is_hex)
+    i++;
+  if (i >= end)
+    return null;
+  let cp = 0;
+  for (;i < end; i++) {
+    const code = source.charCodeAt(i);
+    let digit = code - 48;
+    if (digit < 0 || digit > 9) {
+      const lower = code | 32;
+      if (!is_hex || lower < 97 || lower > 102)
+        return null;
+      digit = lower - 87;
+    }
+    cp = cp * (is_hex ? 16 : 10) + digit;
+    if (cp > 1114111)
+      return null;
+  }
+  return isXmlChar(cp) ? String.fromCodePoint(cp) : null;
+}
+function decodeReferences(value) {
+  let result = "";
+  let cursor = 0;
+  for (let amp = value.indexOf("&");amp >= 0; amp = value.indexOf("&", cursor)) {
+    const semicolon = value.indexOf(";", amp + 1);
+    if (semicolon < 0)
+      return null;
+    const decoded = decodeReference(value, amp + 1, semicolon);
+    if (decoded === null)
+      return null;
+    result += value.slice(cursor, amp) + decoded;
+    cursor = semicolon + 1;
+  }
+  return result + value.slice(cursor);
+}
+function endsAttributeName(code) {
+  return code === 61 || code === 32 || code === 9 || code === 10 || code === 13;
+}
+function skipSpace(source, i, limit) {
+  while (i < limit) {
+    const code = source.charCodeAt(i);
+    if (code !== 32 && code !== 9 && code !== 10 && code !== 13)
+      break;
+    i++;
+  }
+  return i;
+}
+
+class XmlParseError extends Error {
+  constructor(message, code, offset) {
+    super(message);
+    this.name = "XmlParseError";
+    this.code = code;
+    this.offset = offset;
+  }
+}
+
+class XmlStreamParser {
+  constructor(handlers = {}, options = {}) {
+    this.handlers = handlers;
+    this.options = { ...DEFAULTS, ...options, doctype: options.doctype ?? "prohibit" };
+    for (const key of Object.keys(DEFAULTS)) {
+      const value = this.options[key];
+      if (!Number.isInteger(value) || value <= 0)
+        throw new TypeError(`${key} must be a positive finite integer`);
+    }
+    if (!["prohibit", "ignore"].includes(this.options.doctype))
+      throw new TypeError('doctype must be "prohibit" or "ignore"');
+    this._offset = 0;
+    this._mode = "";
+    this._decoder = null;
+    this._surrogate = "";
+    this._ended = false;
+    this._failed = false;
+    this._busy = false;
+    this._stack = [];
+    this._root = false;
+    this._is_declaration_allowed = true;
+    this._doctype = false;
+    this._kind = "";
+    this._parts = [];
+    this._length = 0;
+    this._head = "";
+    this._tail = "";
+    this._quote = "";
+    this._brackets = 0;
+    this._dtdContext = "";
+    this._entityParts = null;
+    this._entityLength = 0;
+    this._textBrackets = 0;
+    this._textCR = false;
+    this._scannedName = "";
+    this._scannedAttributes = null;
+    this._scannedEmpty = false;
+    this._attributeNames = [];
+  }
+  get offset() {
+    return this._offset;
+  }
+  write(chunk) {
+    this._guard();
+    this._busy = true;
+    try {
+      this._input(chunk);
+    } catch (error) {
+      this._failed = true;
+      throw error;
+    } finally {
+      this._busy = false;
+    }
+    return this;
+  }
+  end(chunk) {
+    this._guard();
+    this._busy = true;
+    try {
+      if (chunk !== undefined)
+        this._input(chunk);
+      if (this._decoder) {
+        let final;
+        try {
+          final = this._decoder.decode();
+        } catch {
+          this._error("Truncated UTF-8 input", "UTF8");
+        }
+        if (final)
+          this._decoded(final);
+      }
+      if (this._surrogate)
+        this._error("Unpaired UTF-16 surrogate", "CHARACTER");
+      if (this._kind || this._entityParts || this._stack.length || !this._root)
+        this._error("Incomplete XML document", "EOF");
+    } catch (error) {
+      this._failed = true;
+      throw error;
+    } finally {
+      this._ended = true;
+      this._busy = false;
+    }
+  }
+  _guard() {
+    if (this._ended || this._failed || this._busy) {
+      this._failed = true;
+      this._error("Parser is ended, failed, or already executing a callback", "STATE");
+    }
+  }
+  _error(message, code = "SYNTAX", offset = this._offset) {
+    throw new XmlParseError(message, code, offset);
+  }
+  _emit(name, ...args) {
+    this.handlers[name]?.(...args);
+    this._afterCallback();
+  }
+  _emitText(value, kind = "literal") {
+    this.handlers.text?.(value, kind);
+    this._afterCallback();
+  }
+  _afterCallback() {
+    if (this._failed)
+      this._error("Parser failed during callback", "STATE");
+  }
+  _input(chunk) {
+    const mode = typeof chunk === "string" ? "string" : chunk instanceof Uint8Array ? "bytes" : "";
+    if (!mode)
+      throw new TypeError("XML input must be a string or Uint8Array");
+    if (!chunk.length)
+      return;
+    if (this._mode && this._mode !== mode)
+      this._error("Cannot mix strings and UTF-8 bytes", "INPUT_MODE");
+    this._mode = mode;
+    if (mode === "bytes") {
+      this._decoder ??= new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+      try {
+        chunk = this._decoder.decode(chunk, { stream: true });
+      } catch {
+        this._error("Invalid UTF-8 input", "UTF8");
+      }
+    }
+    this._decoded(chunk);
+  }
+  _decoded(value) {
+    if (!value)
+      return;
+    if (this._surrogate) {
+      value = this._surrogate + value;
+      this._surrogate = "";
+    }
+    const last = value.charCodeAt(value.length - 1);
+    if (last >= 55296 && last <= 56319) {
+      this._surrogate = value.slice(-1);
+      value = value.slice(0, -1);
+    }
+    if (SUSPECT_CHAR.test(value)) {
+      const invalid = INVALID_CHAR.exec(value);
+      if (invalid)
+        this._error("Invalid XML character", "CHARACTER", this._offset + invalid.index + invalid[0].length - 1);
+    }
+    let i = 0;
+    if (this._offset === 0 && value.charCodeAt(0) === 65279) {
+      i++;
+      this._offset++;
+    }
+    while (i < value.length) {
+      if (this._kind) {
+        i = this._continueToken(value, i);
+        continue;
+      }
+      const open = value.indexOf("<", i);
+      const end = open < 0 ? value.length : open;
+      if (end > i) {
+        this._text(value.slice(i, end));
+        this._offset += end - i;
+        i = end;
+      }
+      if (i === value.length)
+        break;
+      if (this._entityParts)
+        this._error("Unterminated entity reference", "ENTITY");
+      this._textBrackets = 0;
+      this._textCR = false;
+      const next = this._markup(value, i);
+      if (next >= 0) {
+        i = next;
+        continue;
+      }
+      this._kind = "prefix";
+      this._tokenStart = this._offset;
+      this._parts = [];
+      this._length = 0;
+      this._head = "";
+      this._tail = "";
+      this._quote = "";
+    }
+  }
+  _markup(value, open) {
+    const limit = Math.min(value.length, open + this.options.maxTokenLength);
+    const next = value.charCodeAt(open + 1);
+    let end;
+    if (next === 33) {
+      if (value.startsWith("<!--", open)) {
+        const close = value.indexOf("--", open + 4);
+        end = close + 3;
+        if (close < 0 || end > limit || value.charCodeAt(close + 2) !== 62)
+          return -1;
+        this._offset += end - open;
+        this._is_declaration_allowed = false;
+        this._comment(value, open + 4, close);
+        return end;
+      }
+      if (!this._stack.length || !value.startsWith("<![CDATA[", open))
+        return -1;
+      const close = value.indexOf("]]>", open + 9);
+      end = close + 3;
+      if (close < 0 || end > limit)
+        return -1;
+      this._offset += end - open;
+      this._is_declaration_allowed = false;
+      this._cdata(value, open + 9, close);
+      return end;
+    }
+    if (next === 63) {
+      const close = value.indexOf("?>", open + 1);
+      end = close + 2;
+      if (close < 0 || end > limit)
+        return -1;
+      this._offset += end - open;
+      this._token(value.slice(open, end), "pi");
+      return end;
+    }
+    end = this._scanTag(value, open, limit);
+    if (end < 0)
+      return -1;
+    this._offset += end - open;
+    this._is_declaration_allowed = false;
+    this._applyTag();
+    return end;
+  }
+  _scanTag(source, start, limit) {
+    let i = start + 1;
+    if (source.charCodeAt(i) === 47) {
+      const name = this._stack[this._stack.length - 1];
+      if (name === undefined || !source.startsWith(name, ++i))
+        return -1;
+      i = skipSpace(source, i + name.length, limit);
+      if (i >= limit || source.charCodeAt(i) !== 62)
+        return -1;
+      this._scannedName = name;
+      this._scannedAttributes = null;
+      return i + 1;
+    }
+    const nameEnd = this._nameEnd(source, i, limit);
+    if (nameEnd < 0)
+      return -1;
+    const attributes = Object.create(null);
+    let count = 0;
+    let is_empty = false;
+    i = nameEnd;
+    for (;; ) {
+      const before = i;
+      i = skipSpace(source, i, limit);
+      if (i >= limit)
+        return -1;
+      const code = source.charCodeAt(i);
+      if (code === 62)
+        break;
+      if (code === 47) {
+        if (i + 1 >= limit || source.charCodeAt(i + 1) !== 62)
+          return -1;
+        is_empty = true;
+        i++;
+        break;
+      }
+      if (i === before)
+        return -1;
+      let attribute = count < NAME_CACHE_SIZE ? this._attributeNames[count] : undefined;
+      let attribute_end = attribute === undefined ? -1 : i + attribute.length;
+      if (attribute_end < 0 || !endsAttributeName(source.charCodeAt(attribute_end)) || !source.startsWith(attribute, i)) {
+        attribute_end = this._nameEnd(source, i, limit);
+        if (attribute_end < 0)
+          return -1;
+        attribute = source.slice(i, attribute_end);
+        if (count < NAME_CACHE_SIZE)
+          this._attributeNames[count] = attribute;
+      }
+      if (attributes[attribute] !== undefined || ++count > this.options.maxAttributes)
+        return -1;
+      i = skipSpace(source, attribute_end, limit);
+      if (i >= limit || source.charCodeAt(i) !== 61)
+        return -1;
+      i = skipSpace(source, i + 1, limit);
+      if (i >= limit)
+        return -1;
+      const quote = source.charCodeAt(i);
+      if (quote !== 34 && quote !== 39)
+        return -1;
+      const value_start = ++i;
+      let has_spaces = false;
+      let has_references = false;
+      for (;i < limit; i++) {
+        const unit = source.charCodeAt(i);
+        if (unit === quote)
+          break;
+        if (unit <= 38) {
+          if (unit === 38)
+            has_references = true;
+          else if (unit === 9 || unit === 10 || unit === 13)
+            has_spaces = true;
+        } else if (unit === 60)
+          return -1;
+      }
+      if (i >= limit)
+        return -1;
+      let value = source.slice(value_start, i);
+      if (has_spaces)
+        value = value.replace(ATTRIBUTE_SPACE, " ");
+      if (has_references) {
+        value = decodeReferences(value);
+        if (value === null)
+          return -1;
+      }
+      attributes[attribute] = value;
+      i++;
+    }
+    this._scannedName = source.slice(start + 1, nameEnd);
+    this._scannedAttributes = attributes;
+    this._scannedEmpty = is_empty;
+    return i + 1;
+  }
+  _nameEnd(source, start, limit) {
+    if (start >= limit)
+      return -1;
+    let code = source.charCodeAt(start);
+    let is_ascii = code < 128;
+    if (is_ascii && !(ASCII_NAME[code] & 1))
+      return -1;
+    let i = start + 1;
+    for (;i < limit; i++) {
+      code = source.charCodeAt(i);
+      if (code >= 128)
+        is_ascii = false;
+      else if (!(ASCII_NAME[code] & 2))
+        break;
+    }
+    if (i >= limit || i - start > this.options.maxNameLength)
+      return -1;
+    if (!is_ascii && !NAME.test(source.slice(start, i)))
+      return -1;
+    return i;
+  }
+  _applyTag() {
+    const attributes = this._scannedAttributes;
+    if (attributes === null) {
+      this._closeElement(this._scannedName);
+      return;
+    }
+    this._scannedAttributes = null;
+    this._openElement(this._scannedName, attributes, this._scannedEmpty);
+  }
+  _openElement(name, attributes, is_empty) {
+    if (!this._stack.length && this._root)
+      this._error("Multiple document elements");
+    if (this._stack.length + 1 > this.options.maxDepth)
+      this._error("Element exceeds maxDepth", "LIMIT");
+    this._root = true;
+    if (!is_empty)
+      this._stack.push(name);
+    this.handlers.startTag?.(name, attributes);
+    this._afterCallback();
+    if (is_empty) {
+      this.handlers.endTag?.(name);
+      this._afterCallback();
+    }
+  }
+  _closeElement(name) {
+    if (this._stack.pop() !== name)
+      this._error("Mismatched end tag");
+    this.handlers.endTag?.(name);
+    this._afterCallback();
+  }
+  _comment(source, start, end) {
+    const handler = this.handlers.comment;
+    if (handler != null)
+      Reflect.apply(handler, this.handlers, [normalizeLineEnds(source.slice(start, end))]);
+    this._afterCallback();
+  }
+  _cdata(source, start, end) {
+    if (end > start)
+      this._emitText(normalizeLineEnds(source.slice(start, end)), "cdata");
+  }
+  _continueToken(value, i) {
+    const start = i;
+    let is_done = false;
+    while (i < value.length && !is_done) {
+      const kind = this._kind;
+      if (kind === "comment" || kind === "cdata" || kind === "pi") {
+        const end = this._sectionEnd(value, i);
+        is_done = end >= 0;
+        const next = is_done ? end : value.length;
+        this._consumeSection(next - i);
+        i = next;
+        continue;
+      }
+      if (kind === "tag") {
+        let next;
+        if (this._quote) {
+          next = value.indexOf(this._quote, i);
+          if (next >= 0)
+            this._quote = "";
+        } else {
+          TAG_DELIMITER.lastIndex = i;
+          const delimiter = TAG_DELIMITER.exec(value);
+          next = delimiter ? delimiter.index : -1;
+          if (delimiter) {
+            if (delimiter[0] === ">")
+              is_done = true;
+            else
+              this._quote = delimiter[0];
+          }
+        }
+        next = next < 0 ? value.length : next + 1;
+        this._length += next - i;
+        this._offset += next - i;
+        i = next;
+        if (this._length > this.options.maxTokenLength)
+          this._error("XML token exceeds maxTokenLength", "LIMIT");
+        continue;
+      }
+      const c = value[i++];
+      this._offset++;
+      if (++this._length > this.options.maxTokenLength)
+        this._error("XML token exceeds maxTokenLength", "LIMIT");
+      is_done = this._frame(c);
+    }
+    this._parts.push(value.slice(start, i));
+    if (is_done) {
+      const token = this._parts.length === 1 ? this._parts[0] : this._parts.join("");
+      const kind = this._kind;
+      this._kind = "";
+      this._parts = [];
+      this._token(token, kind);
+    }
+    return i;
+  }
+  _sectionEnd(value, i) {
+    const tail = this._tail;
+    const text = tail ? tail + value.slice(i) : value;
+    const from = tail ? 0 : i;
+    const shift = tail ? i - tail.length : 0;
+    let end = -1;
+    if (this._kind === "comment") {
+      const hyphens = text.indexOf("--", from);
+      if (hyphens >= 0 && hyphens + 2 < text.length) {
+        end = hyphens + 3 + shift;
+        if (text.charCodeAt(hyphens + 2) !== 62) {
+          this._consumeSection(end - i);
+          this._error("Double hyphen in comment");
+        }
+      }
+    } else {
+      const terminator = this._kind === "cdata" ? "]]>" : "?>";
+      const found = text.indexOf(terminator, from);
+      if (found >= 0)
+        end = found + terminator.length + shift;
+    }
+    if (end < 0)
+      this._tail = text.slice(Math.max(from, text.length - 2));
+    return end;
+  }
+  _consumeSection(count) {
+    const allowed = this.options.maxTokenLength - this._length;
+    if (count > allowed)
+      this._error("XML token exceeds maxTokenLength", "LIMIT", this._offset + allowed + 1);
+    this._length += count;
+    this._offset += count;
+  }
+  _frame(c) {
+    const tail = this._tail;
+    this._tail = (tail + c).slice(-3);
+    if (this._kind === "prefix") {
+      this._head += c;
+      const h = this._head;
+      if (h.length === 2 && c !== "!") {
+        this._kind = c === "?" ? "pi" : "tag";
+        return c === ">";
+      }
+      if (h === "<!--") {
+        this._kind = "comment";
+        this._tail = "";
+      } else if (h === "<![CDATA[")
+        this._kind = "cdata";
+      else if (h === "<!DOCTYPE") {
+        if (this.options.doctype === "prohibit")
+          this._error("DOCTYPE is prohibited", "DOCTYPE");
+        this._kind = "doctype";
+        this._brackets = 0;
+        this._dtdContext = "";
+      } else if (!["<!--", "<![CDATA[", "<!DOCTYPE"].some((prefix) => prefix.startsWith(h)) && h.length > 1) {
+        this._error("Invalid markup declaration");
+      }
+      return false;
+    }
+    if (this._dtdContext === "comment") {
+      if (tail.endsWith("--") && c !== ">")
+        this._error("Double hyphen in DTD comment");
+      if (this._tail === "-->")
+        this._dtdContext = "";
+      return false;
+    }
+    if (this._dtdContext === "pi") {
+      if (this._tail.endsWith("?>"))
+        this._dtdContext = "";
+      return false;
+    }
+    if (!this._quote && tail === "<!-" && c === "-") {
+      this._dtdContext = "comment";
+      this._tail = "";
+      return false;
+    }
+    if (!this._quote && tail.endsWith("<") && c === "?") {
+      this._dtdContext = "pi";
+      return false;
+    }
+    if (this._quote) {
+      if (c === this._quote)
+        this._quote = "";
+      return false;
+    }
+    if (c === '"' || c === "'") {
+      this._quote = c;
+      return false;
+    }
+    if (c === "[")
+      this._brackets++;
+    if (c === "]" && --this._brackets < 0)
+      this._error("Unmatched DOCTYPE bracket");
+    return c === ">" && this._brackets === 0;
+  }
+  _text(value) {
+    this._is_declaration_allowed = false;
+    if (!this._stack.length) {
+      if (!SPACE.test(value))
+        this._error("Non-whitespace outside document element");
+      this._literal(value);
+      return;
+    }
+    let i = 0;
+    if (this._entityParts) {
+      const semicolon = value.indexOf(";");
+      const end = semicolon < 0 ? value.length : semicolon;
+      this._entityLength += end;
+      if (this._entityLength + 2 > this.options.maxTokenLength)
+        this._error("Entity exceeds maxTokenLength", "LIMIT");
+      this._entityParts.push(value.slice(0, end));
+      if (semicolon < 0)
+        return;
+      const name = this._entityParts.join("");
+      this._entityParts = null;
+      this._reference(this._entity(name));
+      i = semicolon + 1;
+    }
+    while (i < value.length) {
+      const amp = value.indexOf("&", i);
+      if (amp < 0) {
+        this._literal(i ? value.slice(i) : value);
+        return;
+      }
+      if (amp > i)
+        this._literal(value.slice(i, amp));
+      i = amp + 1;
+      if (i === value.length) {
+        this._entityParts = [];
+        this._entityLength = 0;
+        return;
+      }
+      const semicolon = value.indexOf(";", i);
+      const end = semicolon < 0 ? value.length : semicolon;
+      if (end - i + 2 > this.options.maxTokenLength)
+        this._error("Entity exceeds maxTokenLength", "LIMIT");
+      if (semicolon < 0) {
+        this._entityParts = [value.slice(i)];
+        this._entityLength = end - i;
+        return;
+      }
+      this._reference(decodeReference(value, i, semicolon) ?? this._entity(value.slice(i, semicolon)));
+      i = semicolon + 1;
+    }
+  }
+  _reference(value) {
+    this._textBrackets = 0;
+    this._textCR = false;
+    this._emitText(value, "reference");
+  }
+  _literal(value) {
+    const length = value.length;
+    const first = value.charCodeAt(0);
+    const brackets = this._textBrackets;
+    const is_straddling = brackets > 0 && (brackets === 2 && first === 62 || first === 93 && value.charCodeAt(1) === 62);
+    if (is_straddling || value.includes("]]>"))
+      this._error("CDATA close delimiter in text");
+    let trailing = 0;
+    while (trailing < 2 && trailing < length && value.charCodeAt(length - 1 - trailing) === 93)
+      trailing++;
+    this._textBrackets = trailing === length ? Math.min(2, brackets + trailing) : trailing;
+    const has_pending_cr = this._textCR;
+    this._textCR = value.charCodeAt(length - 1) === 13;
+    if (has_pending_cr && first === 10)
+      value = value.slice(1);
+    value = normalizeLineEnds(value);
+    if (value)
+      this._emitText(value);
+  }
+  _entity(name) {
+    const value = decodeReference(name, 0, name.length);
+    if (value !== null)
+      return value;
+    if (!/^#(?:[0-9]+|x[0-9a-fA-F]+)$/.test(name))
+      this._error("Unknown or malformed entity reference", "ENTITY");
+    const cp = name[1] === "x" ? Number.parseInt(name.slice(2), 16) : Number(name.slice(1));
+    if (!Number.isSafeInteger(cp) || cp > 1114111 || cp < 0)
+      this._error("Invalid character reference", "ENTITY");
+    this._error("Invalid XML character reference", "CHARACTER");
+  }
+  _name(name) {
+    if (name.length > this.options.maxNameLength)
+      this._error("Name exceeds maxNameLength", "LIMIT");
+    if (!NAME.test(name))
+      this._error("Invalid XML name");
+    return name;
+  }
+  _token(raw, kind) {
+    const is_declaration_allowed = this._is_declaration_allowed;
+    this._is_declaration_allowed = false;
+    if (kind === "tag") {
+      if (this._scanTag(raw, 0, raw.length) === raw.length)
+        this._applyTag();
+      else
+        this._tag(normalizeLineEnds(raw));
+      return;
+    }
+    if (kind === "comment") {
+      this._comment(raw, 4, raw.length - 3);
+      return;
+    }
+    if (kind === "cdata") {
+      if (!this._stack.length)
+        this._error("CDATA outside document element");
+      this._cdata(raw, 9, raw.length - 3);
+      return;
+    }
+    const token = normalizeLineEnds(raw);
+    if (kind === "pi") {
+      const match = /^<\?([^ \t\n?]+)(?:[ \t\n]+([\s\S]*))?\?>$/.exec(token);
+      if (!match)
+        this._error("Malformed processing instruction");
+      const target = this._name(match[1]);
+      if (target.toLowerCase() === "xml") {
+        if (target !== "xml" || !is_declaration_allowed)
+          this._error("Misplaced XML declaration");
+        const declaration = /^<\?xml[ \t\n]+version[ \t\n]*=[ \t\n]*(['"])1\.0\1(?:[ \t\n]+encoding[ \t\n]*=[ \t\n]*(['"])([A-Za-z][A-Za-z0-9._-]*)\2)?(?:[ \t\n]+standalone[ \t\n]*=[ \t\n]*(['"])(?:yes|no)\4)?[ \t\n]*\?>$/.exec(token);
+        if (!declaration)
+          this._error("Unsupported or malformed XML declaration", "DECLARATION");
+        if (this._mode === "bytes" && declaration[3] && declaration[3].toLowerCase() !== "utf-8")
+          this._error("Only UTF-8 byte encoding is supported", "ENCODING");
+      } else
+        this._emit("processingInstruction", target, match[2] ?? "");
+      return;
+    }
+    this._parseDoctype(token, raw);
+  }
+  _parseDoctype(token, raw) {
+    if (this._doctype || this._root)
+      this._error("Misplaced or duplicate DOCTYPE", "DOCTYPE");
+    const header = /^<!DOCTYPE[ \t\n]+([^ \t\n\[>]+)([\s\S]*)>$/.exec(token);
+    if (!header)
+      this._error("Malformed DOCTYPE", "DOCTYPE");
+    this._name(header[1]);
+    let rest = header[2];
+    const external = /^[ \t\n]+(?:SYSTEM[ \t\n]+(?:"[^"]*"|'[^']*')|PUBLIC[ \t\n]+(?:"[\r\na-zA-Z0-9 \-'()+,./:=?;!*#@$_%]*"|'[\r\na-zA-Z0-9 \-()+,./:=?;!*#@$_%]*')[ \t\n]+(?:"[^"]*"|'[^']*'))/.exec(rest);
+    if (external)
+      rest = rest.slice(external[0].length);
+    const start = skipSpace(rest, 0, rest.length);
+    let end = rest.length;
+    while (end > start) {
+      const code = rest.charCodeAt(end - 1);
+      if (code !== 32 && code !== 9 && code !== 10 && code !== 13)
+        break;
+      end--;
+    }
+    rest = rest.slice(start, end);
+    if (rest && !(rest.startsWith("[") && rest.endsWith("]")))
+      this._error("Malformed DOCTYPE framing", "DOCTYPE");
+    this._doctype = true;
+    this._emit("doctype", raw);
+  }
+  _tag(token) {
+    if (token.startsWith("</")) {
+      const match = /^<\/([^ \t\n>]+)[ \t\n]*>$/.exec(token);
+      if (!match)
+        this._error("Malformed end tag");
+      this._closeElement(this._name(match[1]));
+      return;
+    }
+    const is_empty = token.endsWith("/>");
+    const end = token.length - (is_empty ? 2 : 1);
+    let i = 1;
+    while (i < end && !/[ \t\n]/.test(token[i]))
+      i++;
+    const name = this._name(token.slice(1, i));
+    const attrs = Object.create(null);
+    let count = 0;
+    while (i < end) {
+      const before = i;
+      while (i < end && /[ \t\n]/.test(token[i]))
+        i++;
+      if (i === end)
+        break;
+      if (i === before)
+        this._error("Missing whitespace before attribute");
+      const start = i;
+      while (i < end && !/[ \t\n=]/.test(token[i]))
+        i++;
+      const attr = this._name(token.slice(start, i));
+      if (Object.hasOwn(attrs, attr))
+        this._error("Duplicate attribute");
+      if (++count > this.options.maxAttributes)
+        this._error("Too many attributes", "LIMIT");
+      while (i < end && /[ \t\n]/.test(token[i]))
+        i++;
+      if (token[i++] !== "=")
+        this._error("Expected attribute equals sign");
+      while (i < end && /[ \t\n]/.test(token[i]))
+        i++;
+      const quote = token[i++];
+      if (quote !== '"' && quote !== "'")
+        this._error("Expected quoted attribute value");
+      const close = token.indexOf(quote, i);
+      if (close < 0 || close >= end)
+        this._error("Unterminated attribute value");
+      let value = token.slice(i, close);
+      if (value.includes("<"))
+        this._error("Literal less-than in attribute");
+      value = value.replace(ATTRIBUTE_SPACE, " ");
+      if (value.includes("&")) {
+        let cursor = 0;
+        const pieces = [];
+        while (cursor < value.length) {
+          const amp = value.indexOf("&", cursor);
+          if (amp < 0) {
+            pieces.push(value.slice(cursor));
+            break;
+          }
+          pieces.push(value.slice(cursor, amp));
+          const semi = value.indexOf(";", amp + 1);
+          if (semi < 0)
+            this._error("Unterminated attribute entity", "ENTITY");
+          pieces.push(this._entity(value.slice(amp + 1, semi)));
+          cursor = semi + 1;
+        }
+        value = pieces.join("");
+      }
+      attrs[attr] = value;
+      i = close + 1;
+    }
+    this._openElement(name, attrs, is_empty);
+  }
+}
+// packages/xml-parser/src/whitespace.js
+function createWhitespaceFilter(mode = "preserve") {
+  if (mode === "preserve")
+    return;
+  if (mode !== "strip-indentation")
+    throw new TypeError("Unsupported XML whitespace mode");
+  const stack = [];
+  return {
+    enter(attributes) {
+      const space = attributes["xml:space"];
+      stack.push({
+        is_preserved: space === "preserve" || space !== "default" && Boolean(stack.at(-1)?.is_preserved),
+        has_content: false,
+        has_protected_text: false
+      });
+    },
+    text(value, kind) {
+      const frame = stack.at(-1);
+      if (!frame)
+        return;
+      frame.has_content ||= /[^ \t\r\n]/.test(value);
+      frame.has_protected_text ||= kind !== "literal";
+    },
+    leave(record) {
+      const frame = stack.pop();
+      if (!record || !frame || frame.is_preserved || frame.has_content || frame.has_protected_text)
+        return;
+      if (!record.children.some((child) => typeof child !== "string"))
+        return;
+      record.children = record.children.filter((child) => typeof child !== "string" || !/^[ \t\r\n]*[\r\n][ \t\r\n]*$/.test(child));
+    }
+  };
+}
+
+// packages/xml-parser/src/streams.js
+var SLICE_SIZE = 16 * 1024;
+function validatePositiveInteger(value, name) {
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new RangeError(`${name} must be a positive safe integer`);
+  }
+  return value;
+}
+async function* readSourceValues(source) {
+  if (source != null && typeof source === "object" && "getReader" in source && typeof source.getReader === "function") {
+    const reader = source.getReader();
+    let is_finished = false;
+    let has_failed = false;
+    try {
+      while (true) {
+        const result = await reader.read();
+        if (result.done) {
+          is_finished = true;
+          return;
+        }
+        yield result.value;
+      }
+    } catch (error) {
+      has_failed = true;
+      throw error;
+    } finally {
+      try {
+        if (!is_finished)
+          await reader.cancel();
+      } catch (error) {
+        if (!has_failed)
+          throw error;
+      } finally {
+        reader.releaseLock();
+      }
+    }
+  } else {
+    yield* source;
+  }
+}
+async function* xmlRecords(source, options = {}) {
+  const whitespace = createWhitespaceFilter(options.whitespace);
+  const record_depth = validatePositiveInteger(options.recordDepth ?? 2, "recordDepth");
+  const max_chars = validatePositiveInteger(options.maxRecordChars ?? 4 * 1024 * 1024, "maxRecordChars");
+  const max_nodes = validatePositiveInteger(options.maxRecordNodes ?? 1e5, "maxRecordNodes");
+  if (options.select !== undefined && typeof options.select !== "function") {
+    throw new TypeError("select must be a function");
+  }
+  const path = [];
+  const stack = [];
+  let ready = [];
+  let chars = 0;
+  let nodes = 0;
+  function account(added_chars, added_nodes) {
+    chars += added_chars;
+    nodes += added_nodes;
+    if (chars > max_chars)
+      throw new RangeError("maxRecordChars exceeded");
+    if (nodes > max_nodes)
+      throw new RangeError("maxRecordNodes exceeded");
+  }
+  const parser = new XmlStreamParser({
+    startTag(name, attributes) {
+      path.push(name);
+      whitespace?.enter(attributes);
+      if (!stack.length) {
+        const is_selected = options.select ? options.select(path.slice(), attributes) : path.length === record_depth;
+        if (typeof is_selected !== "boolean")
+          throw new TypeError("select must return a boolean");
+        if (!is_selected)
+          return;
+        chars = 0;
+        nodes = 0;
+      }
+      let length = name.length;
+      for (const key of Object.keys(attributes))
+        length += key.length + attributes[key].length;
+      account(length, 1);
+      const record = { name, attributes, children: [] };
+      if (stack.length)
+        stack[stack.length - 1].children.push(record);
+      stack.push(record);
+    },
+    endTag() {
+      if (stack.length) {
+        const record = stack.pop();
+        whitespace?.leave(record);
+        if (!stack.length)
+          ready.push(record);
+      } else
+        whitespace?.leave();
+      path.pop();
+    },
+    text(value, kind) {
+      whitespace?.text(value, kind);
+      if (!stack.length || !value.length)
+        return;
+      const children = stack[stack.length - 1].children;
+      const last = children.length - 1;
+      const is_merging = typeof children[last] === "string";
+      account(value.length, is_merging ? 0 : 1);
+      if (is_merging)
+        children[last] += value;
+      else
+        children.push(value);
+    }
+  }, options.parserOptions);
+  for await (const chunk of readSourceValues(source)) {
+    if (typeof chunk !== "string" && !(chunk instanceof Uint8Array)) {
+      throw new TypeError("XML source chunks must be strings or Uint8Array values");
+    }
+    for (let offset = 0;offset < chunk.length; offset += SLICE_SIZE) {
+      parser.write(typeof chunk === "string" ? chunk.slice(offset, offset + SLICE_SIZE) : chunk.subarray(offset, offset + SLICE_SIZE));
+      for (const record of ready)
+        yield record;
+      ready = [];
+    }
+  }
+  parser.end();
+  for (const record of ready)
+    yield record;
+}
+async function* xmlDocumentRecords(source, options = {}) {
+  const whitespace = createWhitespaceFilter(options.whitespace);
+  const max_chars = validatePositiveInteger(options.maxRecordChars ?? 4 * 1024 * 1024, "maxRecordChars");
+  const max_nodes = validatePositiveInteger(options.maxRecordNodes ?? 1e5, "maxRecordNodes");
+  if (options.onRoot !== undefined && typeof options.onRoot !== "function")
+    throw new TypeError("onRoot must be a function");
+  let root = null;
+  let root_chars = 0;
+  let root_nodes = 1;
+  let root_text = "";
+  let is_root_text_protected = false;
+  let has_element_children = false;
+  let has_root_attributes = false;
+  let depth = 0;
+  const stack = [];
+  let ready = [];
+  let chars = 0;
+  let nodes = 0;
+  function checkLimits(count, node_count) {
+    if (count > max_chars)
+      throw new RangeError("maxRecordChars exceeded");
+    if (node_count > max_nodes)
+      throw new RangeError("maxRecordNodes exceeded");
+  }
+  function finishRootText() {
+    if (root && root_text && (!has_element_children || is_root_text_protected || /[^ \t\r\n]/.test(root_text))) {
+      root.children.push(root_text);
+      root_chars += root_text.length;
+      root_nodes++;
+    }
+    root_text = "";
+    is_root_text_protected = false;
+  }
+  const parser = new XmlStreamParser({
+    startTag(name, attributes) {
+      depth++;
+      whitespace?.enter(attributes);
+      let length = name.length;
+      for (const key of Object.keys(attributes))
+        length += key.length + attributes[key].length;
+      if (depth === 1) {
+        options.onRoot?.(name, attributes);
+        root = { name, attributes, children: [] };
+        root_chars = length;
+        has_root_attributes = Object.keys(attributes).length > 0;
+        checkLimits(root_chars, root_nodes);
+        return;
+      }
+      if (depth === 2) {
+        has_element_children = true;
+        finishRootText();
+        chars = 0;
+        nodes = 0;
+      }
+      chars += length;
+      nodes++;
+      checkLimits(chars, nodes);
+      const record = { name, attributes, children: [] };
+      if (stack.length)
+        stack[stack.length - 1].children.push(record);
+      stack.push(record);
+    },
+    endTag() {
+      if (depth === 1) {
+        finishRootText();
+        whitespace?.leave();
+      } else {
+        const record = stack.pop();
+        whitespace?.leave(record);
+        if (!stack.length)
+          ready.push(record);
+      }
+      depth--;
+    },
+    text(value, kind) {
+      whitespace?.text(value, kind);
+      if (!value.length)
+        return;
+      if (depth === 1) {
+        checkLimits(root_chars + root_text.length + value.length, root_nodes + 1);
+        root_text += value;
+        is_root_text_protected ||= kind !== "literal";
+      } else if (stack.length) {
+        const children = stack[stack.length - 1].children;
+        const last = children.length - 1;
+        const is_merging = typeof children[last] === "string";
+        chars += value.length;
+        if (!is_merging)
+          nodes++;
+        checkLimits(chars, nodes);
+        if (is_merging)
+          children[last] += value;
+        else
+          children.push(value);
+      }
+    }
+  }, options.parserOptions);
+  for await (const chunk of readSourceValues(source)) {
+    if (typeof chunk !== "string" && !(chunk instanceof Uint8Array))
+      throw new TypeError("XML source chunks must be strings or Uint8Array values");
+    for (let offset = 0;offset < chunk.length; offset += SLICE_SIZE) {
+      parser.write(typeof chunk === "string" ? chunk.slice(offset, offset + SLICE_SIZE) : chunk.subarray(offset, offset + SLICE_SIZE));
+      for (const record of ready)
+        yield record;
+      ready = [];
+    }
+  }
+  parser.end();
+  for (const record of ready)
+    yield record;
+  const context = root;
+  if (context && (!has_element_children || has_root_attributes || context.children.length))
+    yield context;
+}
+// packages/xml-parser/src/parallel/reader.js
+function checkXmlAbort(signal) {
+  if (signal?.aborted)
+    throw signal.reason ?? new DOMException("XML read cancelled", "AbortError");
+}
+function awaitXmlSignal(pending, signal) {
+  if (!signal)
+    return Promise.resolve(pending);
+  return new Promise((resolve, reject) => {
+    const onabort = () => reject(signal.reason ?? new DOMException("XML read cancelled", "AbortError"));
+    signal.addEventListener("abort", onabort, { once: true });
+    Promise.resolve(pending).then((value) => {
+      signal.removeEventListener("abort", onabort);
+      resolve(value);
+    }, (error) => {
+      signal.removeEventListener("abort", onabort);
+      reject(error);
+    });
+    if (signal.aborted) {
+      signal.removeEventListener("abort", onabort);
+      onabort();
+    }
+  });
+}
+
+class XmlSourceReader {
+  constructor(source, start, read_bytes, signal) {
+    this.source = source;
+    this.position = start;
+    this.read_bytes = read_bytes;
+    this.signal = signal;
+    this.pending = null;
+  }
+  read() {
+    const start = this.position;
+    if (start >= this.source.size)
+      return Promise.resolve(null);
+    const end = Math.min(this.source.size, Math.floor((start + this.read_bytes) / SLICE_SIZE) * SLICE_SIZE);
+    this.position = end;
+    const reading = Promise.resolve(this.source.read(start, end)).then((bytes) => {
+      if (!(bytes instanceof Uint8Array) || bytes.length !== end - start)
+        throw new Error("The XML source returned a different number of bytes than requested.");
+      return bytes;
+    });
+    reading.catch(() => {});
+    return reading;
+  }
+  async next() {
+    checkXmlAbort(this.signal);
+    const current = this.pending ?? this.read();
+    this.pending = null;
+    const chunk = await awaitXmlSignal(current, this.signal);
+    if (chunk)
+      this.pending = this.read();
+    return chunk;
+  }
+}
+
+// packages/xml-parser/src/parallel/segment.js
+var encoder;
+function describeXmlError(error) {
+  const value = error ?? {};
+  const description = {
+    name: typeof value.name === "string" ? value.name : "Error",
+    message: typeof value.message === "string" ? value.message : String(error)
+  };
+  if (typeof value.code === "string")
+    description.code = value.code;
+  if (typeof value.offset === "number")
+    description.offset = value.offset;
+  return description;
+}
+function createXmlSegmentProcessor(config, state, sink, describeRecordError) {
+  const whitespace = createWhitespaceFilter(config.whitespace);
+  const max_chars = config.max_record_chars;
+  const max_nodes = config.max_record_nodes;
+  function checkLimits(count, node_count) {
+    if (count > max_chars)
+      throw new RangeError("maxRecordChars exceeded");
+    if (node_count > max_nodes)
+      throw new RangeError("maxRecordNodes exceeded");
+  }
+  let ready = [];
+  const stack = [];
+  let chars = 0;
+  let nodes = 0;
+  let root_text = "";
+  let is_root_text_protected = false;
+  let root_chars = state.root_chars;
+  let root_nodes = state.root_nodes;
+  let has_element_children = state.has_element_children;
+  const kept = [];
+  const root_check = { chars: -1, nodes: -1 };
+  let is_root_limit = false;
+  function checkRoot(count, node_count) {
+    root_check.chars = Math.max(root_check.chars, count - state.root_chars);
+    root_check.nodes = Math.max(root_check.nodes, node_count - state.root_nodes);
+    try {
+      checkLimits(count, node_count);
+    } catch (error) {
+      is_root_limit = true;
+      throw error;
+    }
+  }
+  function finishRootText() {
+    if (root_text && (!has_element_children || is_root_text_protected || /[^ \t\r\n]/.test(root_text))) {
+      kept.push(root_text);
+      root_chars += root_text.length;
+      root_nodes++;
+    }
+    root_text = "";
+    is_root_text_protected = false;
+  }
+  function addChildText(value) {
+    const children = stack[stack.length - 1].children;
+    const last = children.length - 1;
+    const is_merging = typeof children[last] === "string";
+    chars += value.length;
+    if (!is_merging)
+      nodes++;
+    checkLimits(chars, nodes);
+    if (is_merging)
+      children[last] += value;
+    else
+      children.push(value);
+  }
+  function openRecord(name, attributes) {
+    let length = name.length;
+    for (const key of Object.keys(attributes))
+      length += key.length + attributes[key].length;
+    chars += length;
+    nodes++;
+    checkLimits(chars, nodes);
+    const record = { name, attributes, children: [] };
+    if (stack.length)
+      stack[stack.length - 1].children.push(record);
+    stack.push(record);
+  }
+  function closeRecord() {
+    const record = stack.pop();
+    whitespace?.leave(record);
+    if (!stack.length)
+      ready.push(record);
+  }
+  let depth = 0;
+  const path = [];
+  const select_path = config.select_path;
+  let handlers;
+  if (!select_path) {
+    handlers = {
+      startTag(name, attributes) {
+        depth++;
+        whitespace?.enter(attributes);
+        if (depth === 1)
+          return;
+        if (depth === 2) {
+          has_element_children = true;
+          finishRootText();
+          chars = 0;
+          nodes = 0;
+        }
+        openRecord(name, attributes);
+      },
+      endTag() {
+        if (depth === 1) {
+          finishRootText();
+          whitespace?.leave();
+        } else
+          closeRecord();
+        depth--;
+      },
+      text(value, kind) {
+        whitespace?.text(value, kind);
+        if (!value.length)
+          return;
+        if (depth === 1) {
+          checkRoot(root_chars + root_text.length + value.length, root_nodes + 1);
+          root_text += value;
+          is_root_text_protected ||= kind !== "literal";
+        } else if (stack.length)
+          addChildText(value);
+      }
+    };
+  } else {
+    handlers = {
+      startTag(name, attributes) {
+        path.push(name);
+        whitespace?.enter(attributes);
+        if (!stack.length) {
+          if (path.length !== select_path.length)
+            return;
+          for (let index = 0;index < path.length; index++)
+            if (path[index] !== select_path[index])
+              return;
+          chars = 0;
+          nodes = 0;
+        }
+        openRecord(name, attributes);
+      },
+      endTag() {
+        if (stack.length)
+          closeRecord();
+        else
+          whitespace?.leave();
+        path.pop();
+      },
+      text(value, kind) {
+        whitespace?.text(value, kind);
+        if (stack.length && value.length)
+          addChildText(value);
+      }
+    };
+  }
+  const parser = new XmlStreamParser(handlers, config.parser_options);
+  parser.write(config.root_tag);
+  const base_offset = parser.offset;
+  let position = state.start;
+  let last_write_offset = 0;
+  let length = 0;
+  let count = 0;
+  let failure = null;
+  function drain(slice) {
+    const completed = ready;
+    ready = [];
+    for (const record of completed) {
+      try {
+        sink.add(record);
+      } catch (error) {
+        failure = { phase: "record", slice, error: describeRecordError(error) };
+        return false;
+      }
+      count++;
+    }
+    return true;
+  }
+  function failWrite(phase, slice, error) {
+    const description = describeXmlError(error);
+    if (description.offset !== undefined)
+      description.offset -= base_offset;
+    failure = { phase, slice, error: description };
+    if (is_root_limit)
+      failure.is_root_limit = true;
+  }
+  return {
+    push(bytes) {
+      let offset = 0;
+      while (offset < bytes.length && !failure) {
+        const slice = Math.floor(position / SLICE_SIZE);
+        const boundary = (slice + 1) * SLICE_SIZE;
+        const size = Math.min(bytes.length - offset, boundary - position);
+        last_write_offset = parser.offset - base_offset;
+        try {
+          parser.write(bytes.subarray(offset, offset + size));
+        } catch (error) {
+          failWrite("write", slice, error);
+          return false;
+        }
+        offset += size;
+        position += size;
+        if (position === boundary && !drain(slice))
+          return false;
+      }
+      return !failure;
+    },
+    close() {
+      if (failure)
+        return false;
+      length = parser.offset - base_offset;
+      const slice = Math.floor((position - 1) / SLICE_SIZE);
+      const is_drained = position % SLICE_SIZE === 0 || drain(slice);
+      try {
+        if (state.is_final) {
+          if (!is_drained)
+            return false;
+          parser.end();
+          return drain(slice);
+        }
+        if (root_text)
+          throw new Error("The segment ended inside root text.");
+        parser.end((encoder ??= new TextEncoder).encode(`</${config.root_name}>`));
+      } catch (error) {
+        failWrite(state.is_final ? "end" : "boundary", slice, error);
+        return false;
+      }
+      return is_drained;
+    },
+    get failure() {
+      return failure;
+    },
+    get length() {
+      return length;
+    },
+    get last_write_offset() {
+      return last_write_offset;
+    },
+    take() {
+      const output = { output: sink.take(), count };
+      count = 0;
+      return output;
+    },
+    summary() {
+      return {
+        kept,
+        has_element_children,
+        root_check: root_check.chars >= 0 ? root_check : null
+      };
+    }
+  };
+}
+
+// packages/xml-parser/src/parallel/split.js
+var LT = 60;
+var GT = 62;
+var SLASH = 47;
+var BANG = 33;
+var QUESTION = 63;
+var DOUBLE_QUOTE = 34;
+var SINGLE_QUOTE = 39;
+var DASH = 45;
+var OPEN_BRACKET = 91;
+var CLOSE_BRACKET = 93;
+var CDATA_NAME = [67, 68, 65, 84, 65, 91];
+var MAX_PROLOG_BYTES = 16 * 1024 * 1024;
+var SCAN_MORE = 0;
+var SCAN_CUT = 1;
+var SCAN_ROOT_END = 2;
+var SCAN_UNSUPPORTED = 3;
+async function readXmlProlog(reader, options) {
+  let root = null;
+  let is_root_closed = false;
+  const parser = new XmlStreamParser({
+    startTag(name, attributes) {
+      if (root)
+        return;
+      root = { name, attributes };
+      options.onRoot?.(name, attributes);
+    },
+    endTag() {
+      is_root_closed = true;
+    }
+  }, options.parserOptions);
+  const pieces = [];
+  let length = 0;
+  let rest = new Uint8Array(0);
+  while (!root) {
+    const chunk = await reader.next();
+    if (!chunk)
+      return { reason: "the input ends before the root element" };
+    let index = 0;
+    try {
+      while (index < chunk.length && !root) {
+        const gt = chunk.indexOf(GT, index);
+        const end = gt < 0 ? chunk.length : gt + 1;
+        parser.write(chunk.subarray(index, end));
+        index = end;
+      }
+    } catch {
+      return { reason: "the prolog or root start tag was rejected" };
+    }
+    pieces.push(chunk.subarray(0, index));
+    length += index;
+    if (root)
+      rest = chunk.subarray(index);
+    if (length > MAX_PROLOG_BYTES)
+      return { reason: "the prolog exceeds 16 MiB" };
+  }
+  if (is_root_closed)
+    return { reason: "the root element is empty" };
+  const prolog = new Uint8Array(length);
+  let offset = 0;
+  for (const piece of pieces) {
+    prolog.set(piece, offset);
+    offset += piece.length;
+  }
+  const accepted = root;
+  const slice_start = Math.floor(length / SLICE_SIZE) * SLICE_SIZE;
+  const slice_offset = new TextDecoder("utf-8", { ignoreBOM: true }).decode(prolog.subarray(0, slice_start), { stream: true }).length;
+  return {
+    prolog: {
+      root_name: accepted.name,
+      root_attributes: accepted.attributes,
+      root_tag: prolog.slice(prolog.lastIndexOf(LT)),
+      body_start: length,
+      body_offset: parser.offset,
+      slice_offset,
+      rest
+    }
+  };
+}
+function scanBody(bytes, index, cut_from, state) {
+  const end = bytes.length;
+  let depth = state.depth;
+  for (;; ) {
+    const lt = bytes.indexOf(LT, index);
+    if (lt < 0 || lt + 1 >= end) {
+      state.depth = depth;
+      state.result = SCAN_MORE;
+      return lt < 0 ? end : lt;
+    }
+    const next = bytes[lt + 1];
+    let close = -1;
+    if (next === SLASH) {
+      const gt = bytes.indexOf(GT, lt + 2);
+      if (gt >= 0) {
+        close = gt + 1;
+        if (--depth === 0) {
+          state.depth = 0;
+          state.result = SCAN_ROOT_END;
+          return lt;
+        }
+        if (depth === 1 && close >= cut_from) {
+          state.depth = depth;
+          state.result = SCAN_CUT;
+          return close;
+        }
+      }
+    } else if (next === BANG) {
+      if (lt + 3 >= end)
+        close = -1;
+      else if (bytes[lt + 2] === DASH) {
+        if (bytes[lt + 3] !== DASH)
+          return markUnsupported(state, depth, lt);
+        for (let position = lt + 4;; position++) {
+          position = bytes.indexOf(DASH, position);
+          if (position < 0 || position + 2 >= end)
+            break;
+          if (bytes[position + 1] === DASH) {
+            if (bytes[position + 2] !== GT)
+              return markUnsupported(state, depth, lt);
+            close = position + 3;
+            break;
+          }
+        }
+      } else if (bytes[lt + 2] === OPEN_BRACKET) {
+        if (lt + 9 > end)
+          close = -1;
+        else {
+          for (let offset = 0;offset < CDATA_NAME.length; offset++)
+            if (bytes[lt + 3 + offset] !== CDATA_NAME[offset])
+              return markUnsupported(state, depth, lt);
+          for (let position = lt + 11;; position++) {
+            position = bytes.indexOf(GT, position);
+            if (position < 0)
+              break;
+            if (bytes[position - 1] === CLOSE_BRACKET && bytes[position - 2] === CLOSE_BRACKET) {
+              close = position + 1;
+              break;
+            }
+          }
+        }
+      } else
+        return markUnsupported(state, depth, lt);
+    } else if (next === QUESTION) {
+      for (let position = lt + 2;; position++) {
+        position = bytes.indexOf(GT, position);
+        if (position < 0)
+          break;
+        if (bytes[position - 1] === QUESTION) {
+          close = position + 1;
+          break;
+        }
+      }
+    } else {
+      let position = lt + 1;
+      let quote = 0;
+      for (;position < end; position++) {
+        const unit = bytes[position];
+        if (quote !== 0) {
+          if (unit === quote)
+            quote = 0;
+        } else if (unit === GT)
+          break;
+        else if (unit === DOUBLE_QUOTE || unit === SINGLE_QUOTE)
+          quote = unit;
+      }
+      if (position < end) {
+        close = position + 1;
+        if (bytes[position - 1] !== SLASH)
+          depth++;
+        else if (depth === 1 && close >= cut_from) {
+          state.depth = depth;
+          state.result = SCAN_CUT;
+          return close;
+        }
+      }
+    }
+    if (close < 0) {
+      state.depth = depth;
+      state.result = SCAN_MORE;
+      return lt;
+    }
+    index = close;
+  }
+}
+function markUnsupported(state, depth, at) {
+  state.depth = depth;
+  state.result = SCAN_UNSUPPORTED;
+  return at;
+}
+async function* splitXmlBody(reader, first, body_start, options) {
+  const state = { depth: 1, result: SCAN_MORE };
+  let buffer = first;
+  let base = body_start;
+  let segment = 0;
+  let position = 0;
+  let is_eof = false;
+  for (;; ) {
+    position = scanBody(buffer, position, segment + options.segment_bytes, state);
+    if (state.result === SCAN_CUT) {
+      if (position - segment > options.max_segment_bytes) {
+        yield {
+          start: base + segment,
+          fallback: "a direct child of the root exceeds the segment limit"
+        };
+        return;
+      }
+      yield {
+        start: base + segment,
+        bytes: new Uint8Array(buffer.subarray(segment, position)),
+        is_final: false
+      };
+      segment = position;
+      continue;
+    }
+    if (state.result === SCAN_UNSUPPORTED) {
+      yield {
+        start: base + segment,
+        fallback: "the body contains markup the splitter does not frame"
+      };
+      return;
+    }
+    if (state.result === SCAN_MORE && !is_eof) {
+      if (buffer.length - segment > options.max_segment_bytes) {
+        yield {
+          start: base + segment,
+          fallback: "a direct child of the root exceeds the segment limit"
+        };
+        return;
+      }
+      const chunk = await reader.next();
+      if (!chunk) {
+        is_eof = true;
+        continue;
+      }
+      const kept = buffer.length - segment;
+      const next = new Uint8Array(kept + chunk.length);
+      next.set(buffer.subarray(segment));
+      next.set(chunk, kept);
+      base += segment;
+      position -= segment;
+      segment = 0;
+      buffer = next;
+      continue;
+    }
+    const parts = [buffer.subarray(segment)];
+    let length = parts[0].length;
+    if (length > options.max_segment_bytes) {
+      yield { start: base + segment, fallback: "the final segment exceeds the segment limit" };
+      return;
+    }
+    for (let chunk = await reader.next();chunk; chunk = await reader.next()) {
+      parts.push(chunk);
+      length += chunk.length;
+      if (length > options.max_segment_bytes) {
+        yield { start: base + segment, fallback: "the final segment exceeds the segment limit" };
+        return;
+      }
+    }
+    const bytes = new Uint8Array(length);
+    let offset = 0;
+    for (const part of parts) {
+      bytes.set(part, offset);
+      offset += part.length;
+    }
+    yield { start: base + segment, bytes, is_final: true };
+    return;
+  }
+}
+
+// packages/xml-parser/src/parallel/worker.js
+var XML_WORKER_PROTOCOL = 2;
+
+// packages/xml-parser/src/parallel/coordinator.js
+var MAX_WORKERS = 64;
+var MAX_DEFAULT_SEGMENT_BYTES = 1024 * 1024;
+var MIN_DEFAULT_SEGMENT_BYTES = 64 * 1024;
+var DEFAULT_READ_BYTES = 4 * 1024 * 1024;
+var DEFAULT_MAX_SEGMENT_BYTES = 64 * 1024 * 1024;
+var DEFAULT_STARTUP_TIMEOUT_MS = 1e4;
+var MAX_SEGMENTS_PER_WORKER = 2;
+function validateInteger(value, name, min, max = Number.MAX_SAFE_INTEGER) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < min || value > max)
+    throw new RangeError(`${name} must be an integer from ${min} to ${max}`);
+  return value;
+}
+function restoreXmlError(description, offset = 0) {
+  if (description.name === "XmlParseError")
+    return new XmlParseError(description.message, description.code ?? "SYNTAX", offset);
+  if (description.name === "RangeError")
+    return new RangeError(description.message);
+  if (description.name === "TypeError")
+    return new TypeError(description.message);
+  return new Error(description.message);
+}
+function describeReason(error) {
+  if (error && typeof error === "object" && "message" in error && error.message)
+    return String(error.message);
+  return "unknown error";
+}
+function startXmlWorkers({ count, createWorker, task_name, signal }) {
+  const slots = [];
+  const results = new Map;
+  const failures = [];
+  let fatal = null;
+  let is_terminated = false;
+  let wake = () => {};
+  let woken = new Promise((resolve) => wake = resolve);
+  function notify() {
+    const resolve = wake;
+    woken = new Promise((next) => wake = next);
+    resolve();
+  }
+  function terminate() {
+    if (is_terminated)
+      return;
+    is_terminated = true;
+    signal?.removeEventListener("abort", onAbort);
+    for (const slot of slots)
+      stop(slot.worker);
+    results.clear();
+  }
+  function onAbort() {
+    terminate();
+    notify();
+  }
+  signal?.addEventListener("abort", onAbort, { once: true });
+  function stop(worker) {
+    try {
+      Promise.resolve(worker.terminate()).catch(() => {});
+    } catch {}
+  }
+  for (let index = 0;index < count; index++) {
+    let worker;
+    try {
+      worker = createWorker();
+    } catch (error) {
+      failures.push(describeReason(error));
+      continue;
+    }
+    const slot = { worker, busy: 0, state: "starting" };
+    slots.push(slot);
+    const fail = (reason) => {
+      if (is_terminated)
+        return;
+      if (slot.state === "ready")
+        fatal ??= new Error(`An XML worker failed: ${reason}`);
+      else if (slot.state === "starting") {
+        slot.state = "failed";
+        failures.push(reason);
+        stop(worker);
+      }
+      notify();
+    };
+    try {
+      worker.addEventListener("message", (event) => {
+        if (is_terminated)
+          return;
+        const data = event?.data;
+        if (slot.state === "starting") {
+          if (data?.type === "ready" && data.protocol === XML_WORKER_PROTOCOL && data.task === task_name) {
+            slot.state = "ready";
+            notify();
+          } else if (data?.type === "refused")
+            fail("the worker entry serves another task or protocol version");
+          else
+            fail("the worker sent an unexpected message before it was ready");
+          return;
+        }
+        if (slot.state !== "ready")
+          return;
+        if (data?.type === "segment") {
+          slot.busy--;
+          results.set(data.seq, data.result);
+        } else if (data?.type === "error")
+          fatal ??= new Error(`An XML worker failed: ${data.error?.message}`);
+        else
+          fatal ??= new Error("An XML worker sent an unexpected message.");
+        notify();
+      });
+      worker.addEventListener("error", (event) => {
+        event?.preventDefault?.();
+        fail(event?.message || describeReason(event?.error));
+      });
+      worker.addEventListener("messageerror", () => fail("a worker message could not be read"));
+      worker.postMessage({ type: "hello", protocol: XML_WORKER_PROTOCOL, task: task_name }, []);
+    } catch (error) {
+      fail(describeReason(error));
+    }
+  }
+  return {
+    results,
+    get ready() {
+      return slots.filter((slot) => slot.state === "ready");
+    },
+    get reason() {
+      if (!failures.length)
+        return;
+      return `${failures.length} of ${count} XML workers did not start: ${failures[0]}`;
+    },
+    async whenStarted(timeout_ms) {
+      let is_timed_out = false;
+      const timer = setTimeout(() => {
+        is_timed_out = true;
+        notify();
+      }, timeout_ms);
+      try {
+        while (!is_timed_out && slots.some((slot) => slot.state === "starting")) {
+          checkXmlAbort(signal);
+          await woken;
+        }
+        checkXmlAbort(signal);
+      } finally {
+        clearTimeout(timer);
+      }
+      for (const slot of slots) {
+        if (slot.state !== "starting")
+          continue;
+        slot.state = "failed";
+        failures.push(`no ready reply within ${timeout_ms} ms`);
+        stop(slot.worker);
+      }
+    },
+    configure(config) {
+      for (const slot of slots)
+        if (slot.state === "ready")
+          slot.worker.postMessage({ type: "config", config }, []);
+    },
+    leastBusy() {
+      const ready = slots.filter((slot) => slot.state === "ready");
+      return ready.reduce((best, slot) => slot.busy < best.busy ? slot : best, ready[0]);
+    },
+    dispatch(slot, message, transfer) {
+      slot.busy++;
+      slot.worker.postMessage(message, transfer);
+    },
+    throwIfFailed() {
+      if (fatal)
+        throw fatal;
+    },
+    wait() {
+      return woken;
+    },
+    terminate
+  };
+}
+async function* readXmlSegments(source, options) {
+  const task = options.task;
+  if (!task || typeof task.name !== "string" || typeof task.createSink !== "function")
+    throw new TypeError("task must provide a name and createSink(options)");
+  if (typeof options.createWorker !== "function")
+    throw new TypeError("createWorker must be a function");
+  if (!source || !Number.isSafeInteger(source.size) || source.size < 0 || typeof source.read !== "function")
+    throw new TypeError("source must provide size and read(start, end)");
+  const requested = validateInteger(options.workers, "workers", 1, MAX_WORKERS);
+  const select_path = options.selectPath ? Array.from(options.selectPath) : null;
+  if (select_path && (!select_path.length || select_path.some((name) => typeof name !== "string" || !name)))
+    throw new TypeError("selectPath must list element names from the root");
+  if (options.onRoot !== undefined && typeof options.onRoot !== "function")
+    throw new TypeError("onRoot must be a function");
+  const max_record_chars = validateInteger(options.maxRecordChars ?? 4 * 1024 * 1024, "maxRecordChars", 1);
+  createWhitespaceFilter(options.whitespace);
+  const max_record_nodes = validateInteger(options.maxRecordNodes ?? 1e5, "maxRecordNodes", 1);
+  const read_bytes = validateInteger(options.readBytes ?? DEFAULT_READ_BYTES, "readBytes", SLICE_SIZE);
+  if (read_bytes % SLICE_SIZE)
+    throw new RangeError(`readBytes must be a multiple of ${SLICE_SIZE}`);
+  if (options.segmentBytes !== undefined)
+    validateInteger(options.segmentBytes, "segmentBytes", SLICE_SIZE);
+  if (options.maxSegmentBytes !== undefined)
+    validateInteger(options.maxSegmentBytes, "maxSegmentBytes", options.segmentBytes ?? SLICE_SIZE);
+  if (options.maxInFlight !== undefined)
+    validateInteger(options.maxInFlight, "maxInFlight", 1);
+  const startup_timeout = validateInteger(options.startupTimeout ?? DEFAULT_STARTUP_TIMEOUT_MS, "startupTimeout", 1);
+  const signal = options.signal;
+  const describeRecordError = task.describeError ?? describeXmlError;
+  function restoreRecordError(description, record_number) {
+    if (task.restoreError)
+      return task.restoreError(description, record_number);
+    return restoreXmlError(description);
+  }
+  checkXmlAbort(signal);
+  const pool = startXmlWorkers({
+    count: requested,
+    createWorker: options.createWorker,
+    task_name: task.name,
+    signal
+  });
+  function checkActive() {
+    checkXmlAbort(signal);
+    pool.throwIfFailed();
+  }
+  let segments = null;
+  try {
+    let captureState = function(start) {
+      return { start, doc_offset, has_element_children, root_chars, root_nodes };
+    }, restoreFailure = function(failure, base, slice_offset = null) {
+      if (failure.phase === "record")
+        return restoreRecordError(failure.error, emitted + 1);
+      const description = failure.error;
+      if (description.code === "UTF8" && slice_offset !== null)
+        return restoreXmlError(description, slice_offset);
+      return restoreXmlError(description, base + (description.offset ?? 0));
+    }, isRootContextStale = function(result) {
+      const dispatched = result.dispatched;
+      if (!is_document || !dispatched)
+        return false;
+      if (dispatched.root_chars === root_chars && dispatched.root_nodes === root_nodes)
+        return false;
+      const check = result.summary.root_check;
+      return Boolean(result.failure?.is_root_limit || check && (root_chars + check.chars > max_record_chars || root_nodes + check.nodes > max_record_nodes));
+    }, advance = function(result) {
+      doc_offset += result.length;
+      for (const text of result.summary.kept) {
+        kept.push(text);
+        root_chars += text.length;
+        root_nodes++;
+      }
+      has_element_children = result.summary.has_element_children;
+    }, createContinuation = function(state) {
+      const continuation_reader = new XmlSourceReader(source, state.start, read_bytes, signal);
+      const processor = createXmlSegmentProcessor(config, {
+        start: state.start,
+        is_final: true,
+        has_element_children: state.has_element_children,
+        root_chars: state.root_chars,
+        root_nodes: state.root_nodes
+      }, task.createSink(options.taskOptions), describeRecordError);
+      let position = state.start;
+      const empty = { output: undefined, count: 0 };
+      return {
+        async next() {
+          const start = position;
+          const chunk = await continuation_reader.next();
+          if (chunk) {
+            processor.push(chunk);
+            position += chunk.length;
+            return {
+              start,
+              end: position,
+              is_final: false,
+              has_shared_tail: false,
+              base: state.doc_offset,
+              body: processor.take(),
+              tail: empty,
+              failure: processor.failure,
+              length: 0,
+              last_write_offset: 0,
+              summary: {
+                kept: [],
+                has_element_children: processor.summary().has_element_children,
+                root_check: null
+              }
+            };
+          }
+          processor.close();
+          return {
+            start,
+            end: position,
+            is_final: true,
+            has_shared_tail: false,
+            base: state.doc_offset,
+            body: empty,
+            tail: processor.take(),
+            failure: processor.failure,
+            length: 0,
+            last_write_offset: 0,
+            summary: processor.summary()
+          };
+        }
+      };
+    };
+    const reader = new XmlSourceReader(source, 0, read_bytes, signal);
+    const framed = await readXmlProlog(reader, {
+      parserOptions: options.parserOptions,
+      onRoot: options.onRoot
+    });
+    const prolog = framed.prolog;
+    let reason = framed.reason;
+    let root_chars = 0;
+    let root_nodes = 1;
+    if (prolog) {
+      root_chars = prolog.root_name.length;
+      for (const key of Object.keys(prolog.root_attributes))
+        root_chars += key.length + prolog.root_attributes[key].length;
+      if (select_path && select_path.length < 2)
+        reason = "selectPath selects the root element";
+      else if (!select_path && root_chars > max_record_chars)
+        reason = "the root start tag exceeds maxRecordChars";
+    }
+    if (!prolog || reason) {
+      checkActive();
+      yield { type: "sequential", reason: `the document cannot be split: ${reason}` };
+      checkActive();
+      return;
+    }
+    await pool.whenStarted(startup_timeout);
+    const ready_count = pool.ready.length;
+    if (!ready_count) {
+      checkActive();
+      yield { type: "sequential", reason: pool.reason ?? "no XML worker started" };
+      checkActive();
+      return;
+    }
+    checkActive();
+    yield { type: "workers", actual: ready_count, ...pool.reason ? { reason: pool.reason } : {} };
+    checkActive();
+    const segment_bytes = options.segmentBytes ?? Math.min(MAX_DEFAULT_SEGMENT_BYTES, Math.max(MIN_DEFAULT_SEGMENT_BYTES, Math.ceil(source.size / (8 * ready_count))));
+    const max_segment_bytes = options.maxSegmentBytes ?? Math.max(DEFAULT_MAX_SEGMENT_BYTES, 4 * segment_bytes);
+    const max_in_flight = options.maxInFlight ?? 2 * ready_count;
+    const config = {
+      select_path,
+      whitespace: options.whitespace,
+      parser_options: options.parserOptions,
+      max_record_chars,
+      max_record_nodes,
+      root_tag: prolog.root_tag,
+      root_name: prolog.root_name,
+      task_options: options.taskOptions
+    };
+    pool.configure(config);
+    const is_document = !select_path;
+    let emitted = 0;
+    let doc_offset = prolog.body_offset;
+    let has_element_children = false;
+    const kept = [];
+    let held = {
+      slice: Math.floor(prolog.body_start / SLICE_SIZE),
+      offset: prolog.slice_offset,
+      outputs: [],
+      failure: null,
+      restart: null
+    };
+    function* release(outputs) {
+      for (const entry of outputs) {
+        checkActive();
+        if (!entry.count)
+          continue;
+        emitted += entry.count;
+        yield { type: "records", output: entry.output, count: entry.count, end: entry.end };
+        checkActive();
+      }
+    }
+    function* merge(result) {
+      if (result.failure?.phase === "boundary")
+        return {
+          ...captureState(result.start),
+          reason: "a segment did not end at a clean root-child boundary"
+        };
+      if (isRootContextStale(result))
+        return {
+          ...captureState(result.start),
+          reason: "root text limits depend on earlier segments"
+        };
+      const base = result.base ?? doc_offset;
+      const head_slice = Math.floor(result.start / SLICE_SIZE);
+      const head_failure = held && result.start % SLICE_SIZE !== 0 && held.slice === head_slice && result.failure?.phase === "write" && result.failure.slice === head_slice ? result.failure : null;
+      if (held) {
+        const previous = held;
+        held = null;
+        if (previous.failure) {
+          if (head_failure) {
+            if (previous.failure.failure.phase !== "record")
+              return {
+                ...previous.restart,
+                reason: "errors on both sides of a segment boundary"
+              };
+            throw restoreFailure(head_failure, base, previous.offset);
+          }
+          yield* release(previous.outputs);
+          throw restoreFailure(previous.failure.failure, previous.failure.base);
+        }
+        if (head_failure)
+          throw restoreFailure(head_failure, base, previous.offset);
+        yield* release(previous.outputs);
+      }
+      const tail_slice = Math.floor((result.end - 1) / SLICE_SIZE);
+      const body = {
+        ...result.body,
+        end: Math.max(result.start, Math.floor(result.end / SLICE_SIZE) * SLICE_SIZE)
+      };
+      const tail = { ...result.tail, end: result.end };
+      const failure = result.failure;
+      if (failure) {
+        const is_shared = result.has_shared_tail && failure.slice === tail_slice && !(failure.phase === "write" && failure.error.code === "UTF8");
+        if (!is_shared) {
+          yield* release([body, tail]);
+          throw restoreFailure(failure, base);
+        }
+        const offset = base + result.last_write_offset;
+        if (failure.phase === "record") {
+          yield* release([body]);
+          advance(result);
+          held = {
+            slice: tail_slice,
+            offset,
+            outputs: [tail],
+            failure: { failure, base },
+            restart: null
+          };
+        } else
+          held = {
+            slice: tail_slice,
+            offset,
+            outputs: [body, tail],
+            failure: { failure, base },
+            restart: captureState(result.start)
+          };
+        return null;
+      }
+      yield* release([body]);
+      advance(result);
+      held = {
+        slice: tail_slice,
+        offset: base + result.last_write_offset,
+        outputs: [tail],
+        failure: null,
+        restart: null
+      };
+      if (!result.is_final)
+        return null;
+      const last = held;
+      held = null;
+      yield* release(last.outputs);
+      return "final";
+    }
+    let next_seq = 0;
+    let dispatch_seq = 0;
+    const dispatched = new Map;
+    segments = splitXmlBody(reader, prolog.rest, prolog.body_start, {
+      segment_bytes,
+      max_segment_bytes
+    });
+    let is_split_done = false;
+    let split_fallback = null;
+    let fallback = null;
+    let continuation = null;
+    let is_complete = false;
+    while (!is_complete) {
+      checkActive();
+      if (fallback) {
+        pool.terminate();
+        dispatched.clear();
+        is_split_done = true;
+        await segments.return(undefined);
+        continuation = createContinuation(fallback);
+        checkActive();
+        yield { type: "fallback", start: fallback.start, reason: fallback.reason };
+        checkActive();
+        fallback = null;
+      }
+      if (continuation) {
+        const action = yield* merge(await continuation.next());
+        if (action === "final")
+          is_complete = true;
+        else if (action)
+          fallback = action;
+        continue;
+      }
+      pool.throwIfFailed();
+      while (!is_split_done && dispatch_seq - next_seq < max_in_flight && !(held?.failure && dispatch_seq > next_seq)) {
+        const slot = pool.leastBusy();
+        if (slot.busy >= MAX_SEGMENTS_PER_WORKER)
+          break;
+        const { value, done } = await segments.next();
+        checkActive();
+        if (done) {
+          is_split_done = true;
+          break;
+        }
+        if (value.fallback !== undefined) {
+          is_split_done = true;
+          split_fallback = { start: value.start, reason: value.fallback };
+          break;
+        }
+        const seq = dispatch_seq++;
+        const state = {
+          start: value.start,
+          is_final: value.is_final,
+          has_element_children: seq > 0,
+          root_chars,
+          root_nodes
+        };
+        dispatched.set(seq, { ...state, end: value.start + value.bytes.length });
+        pool.dispatch(slot, { type: "segment", seq, state, bytes: value.bytes }, [
+          value.bytes.buffer
+        ]);
+      }
+      let is_merged = false;
+      while (pool.results.has(next_seq)) {
+        const result = pool.results.get(next_seq);
+        const meta = dispatched.get(next_seq);
+        pool.results.delete(next_seq);
+        dispatched.delete(next_seq);
+        next_seq++;
+        is_merged = true;
+        const action = yield* merge({
+          ...result,
+          start: meta.start,
+          end: meta.end,
+          is_final: meta.is_final,
+          has_shared_tail: !meta.is_final && meta.end % SLICE_SIZE !== 0,
+          dispatched: meta
+        });
+        if (action === "final")
+          is_complete = true;
+        else if (action)
+          fallback = action;
+        if (action)
+          break;
+      }
+      if (is_complete || fallback)
+        continue;
+      if (is_split_done && next_seq === dispatch_seq) {
+        if (!split_fallback)
+          throw new Error("The XML splitter ended without a final segment.");
+        fallback = { ...captureState(split_fallback.start), reason: split_fallback.reason };
+        continue;
+      }
+      if (!is_merged) {
+        checkXmlAbort(signal);
+        pool.throwIfFailed();
+        await pool.wait();
+      }
+    }
+    checkActive();
+    if (is_document) {
+      const has_root_attributes = Object.keys(prolog.root_attributes).length > 0;
+      if (!has_element_children || has_root_attributes || kept.length) {
+        const sink = task.createSink(options.taskOptions);
+        try {
+          sink.add({ name: prolog.root_name, attributes: prolog.root_attributes, children: kept });
+        } catch (error) {
+          throw restoreRecordError(describeRecordError(error), emitted + 1);
+        }
+        emitted++;
+        checkActive();
+        yield { type: "records", output: sink.take(), count: 1, end: source.size };
+        checkActive();
+      }
+    }
+  } finally {
+    pool.terminate();
+    await segments?.return(undefined);
+  }
+}
+// packages/import/src/detect.js
+var import_papaparse = __toESM(require_papaparse(), 1);
+async function detectImport(source, options = {}) {
+  if (options.format && options.format !== "auto" && !Object.hasOwn(IMPORT_FORMATS, options.format))
+    throw new Error(`Unsupported import format: ${options.format}`);
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  let text = "";
+  let bytes_read = 0;
+  let is_sampled = false;
+  for await (const bytes of readImportBytes(source, options.signal)) {
+    const part = bytes.subarray(0, IMPORT_SNIFF_BYTES - bytes_read);
+    bytes_read += part.length;
+    text += decoder.decode(part, { stream: true });
+    if (bytes_read >= IMPORT_SNIFF_BYTES) {
+      is_sampled = true;
+      break;
+    }
+  }
+  if (!is_sampled)
+    text += decoder.decode();
+  const trimmed = text.trimStart();
+  if (!trimmed && (!is_sampled || !options.format || options.format === "auto"))
+    throw new Error("This file is empty or has no recognizable data in its first 256 KiB.");
+  let format = options.format === "auto" ? undefined : options.format;
+  const warnings = [];
+  if (!format) {
+    if (trimmed.startsWith("<"))
+      format = "xml";
+    else if (/^[\[{]/.test(trimmed)) {
+      if (trimmed.startsWith("["))
+        format = "json";
+      else {
+        const lines = trimmed.split(/\r?\n/).filter((line) => line.trim());
+        if (is_sampled)
+          lines.pop();
+        let has_json_lines = lines.length > 1;
+        try {
+          for (const line of lines) {
+            const value = JSON.parse(line);
+            if (!value || typeof value !== "object" || Array.isArray(value))
+              has_json_lines = false;
+          }
+        } catch {
+          has_json_lines = false;
+        }
+        const has_jsonl_hint = /\.(?:jsonl|ndjson)$/i.test(source.name) && (lines.length <= 1 || has_json_lines);
+        format = has_json_lines || has_jsonl_hint ? "jsonl" : "json";
+      }
+    } else {
+      const candidates = [IMPORT_FORMATS.csv, IMPORT_FORMATS.tsv].filter((candidate) => {
+        const result = import_papaparse.default.parse(text, {
+          delimiter: candidate === "tsv" ? "\t" : ",",
+          preview: 4,
+          skipEmptyLines: "greedy"
+        });
+        const rows = result.data;
+        return rows.length >= 1 && rows[0].length > 1 && !result.errors.some((error) => error.code !== "MissingQuotes" && error.code !== "InvalidQuotes") && rows.slice(1, is_sampled ? -1 : undefined).every((row) => row.length === rows[0].length);
+      });
+      if (candidates.length === 1)
+        format = candidates[0];
+      else if (candidates.length > 1) {
+        const extension = source.name.split(".").pop()?.toLowerCase();
+        if (extension === "csv" || extension === "tsv") {
+          format = extension;
+          warnings.push("Both delimiters occur in this sample; the filename selected the CSV/TSV dialect. Verify the preview.");
+        } else
+          throw new Error("The delimiter is ambiguous. Choose CSV or TSV explicitly.");
+      } else
+        throw new Error("Could not detect XML, JSONL, JSON, CSV or TSV from the content. Select a format explicitly for single-column CSV/TSV.");
+    }
+  }
+  const detection = { format, is_sampled, bytes_read, warnings };
+  if (format === "xml") {
+    const discovery = createXmlDiscovery();
+    discovery.parser.write(text);
+    if (!is_sampled)
+      discovery.parser.end();
+    const result = discovery.finish();
+    if (!result.xml.root_name) {
+      if (!is_sampled)
+        throw new Error("No XML root element was found in the input.");
+      warnings.push("No XML root element was found in the first 256 KiB; recognized XML content will be validated while reading the remaining input.");
+    }
+    detection.xml = result.xml;
+    warnings.push(...result.warnings);
+  }
+  if (is_sampled)
+    warnings.push("Detection used a bounded content sample; it does not validate the complete file.");
+  return detection;
+}
+function createXmlDiscovery() {
+  const path = [];
+  const paths = new Map;
+  let root_name = null;
+  let has_truncated_paths = false;
+  let has_doctype = false;
+  const parser = new XmlStreamParser({
+    startTag(name) {
+      path.push(name);
+      if (path.length === 1) {
+        root_name = name;
+        if (name.toLowerCase().split(":").pop() === "html")
+          throw new Error("HTML documents are not supported XML imports.");
+      } else {
+        const key = "/" + path.join("/");
+        if (paths.has(key))
+          paths.set(key, (paths.get(key) ?? 0) + 1);
+        else if (paths.size < 256 && key.length <= 4096)
+          paths.set(key, 1);
+        else
+          has_truncated_paths = true;
+      }
+    },
+    endTag() {
+      path.pop();
+    },
+    doctype() {
+      has_doctype = true;
+    }
+  }, { doctype: "ignore" });
+  function finish() {
+    const record_paths = Array.from(paths, ([path, count]) => ({ path, count }));
+    const repeated = record_paths.filter((entry) => entry.count > 1).sort((a, b) => b.count - a.count || a.path.split("/").length - b.path.split("/").length);
+    const direct = record_paths.filter((entry) => entry.path.split("/").length === 3);
+    let recommended_path = null;
+    if (repeated.length && (repeated.length === 1 || repeated[0].count > repeated[1].count || repeated[0].path.split("/").length < repeated[1].path.split("/").length))
+      recommended_path = repeated[0].path;
+    else if (direct.length === 1)
+      recommended_path = direct[0].path;
+    const warnings = [];
+    if (has_truncated_paths)
+      warnings.push("XML path discovery was truncated at 256 paths or 4096 characters per path.");
+    if (has_doctype)
+      warnings.push("The XML DOCTYPE is framed but not applied; external resources and declared entities are not loaded.");
+    return { xml: { root_name, record_paths, recommended_path }, warnings };
+  }
+  return { parser, finish };
+}
+// packages/import/src/read.js
+var import_papaparse2 = __toESM(require_papaparse(), 1);
+
+// packages/import/src/errors.js
+class ImportRowError extends Error {
+  constructor(index, detail) {
+    super(`Row ${index}${detail}`);
+    this.index = index;
+    this.detail = detail;
+  }
+}
+
+// packages/import/src/timestamp.js
+function getImportField(record, path) {
+  if (!path.startsWith("/"))
+    return Object.hasOwn(record, path) ? record[path] : undefined;
+  let value = record;
+  for (const raw of path.slice(1).split("/")) {
+    if (/~(?:[^01]|$)/.test(raw))
+      return;
+    const key = raw.replace(/~1/g, "/").replace(/~0/g, "~");
+    if (value === null || typeof value !== "object" || !Object.hasOwn(value, key))
+      return;
+    value = value[key];
+  }
+  return value;
+}
+function parseImportTimestamp(value) {
+  if (typeof value === "number" || typeof value === "string" && /^\d{10}(?:\d{3})?$/.test(value)) {
+    const number = Number(value);
+    if (!Number.isSafeInteger(number) || number < 1e9)
+      return null;
+    const digits = String(number).length;
+    if (digits !== 10 && digits !== 13)
+      return null;
+    const date = new Date(digits === 10 ? number * 1000 : number);
+    return Number.isNaN(date.valueOf()) ? null : date.toISOString();
+  }
+  if (typeof value !== "string")
+    return null;
+  const match = /^(\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2}):(\d{2})(?:\.(\d{1,3}))? ?(Z|[+-]\d{2}:?\d{2})$/.exec(value);
+  if (!match)
+    return null;
+  const [
+    ,
+    year_text,
+    month_text,
+    day_text,
+    hour_text,
+    minute_text,
+    second_text,
+    fraction = "",
+    zone
+  ] = match;
+  const [year, month, day, hour, minute, second] = [
+    year_text,
+    month_text,
+    day_text,
+    hour_text,
+    minute_text,
+    second_text
+  ].map(Number);
+  if (year < 1 || month < 1 || month > 12 || day < 1 || hour > 23 || minute > 59 || second > 59)
+    return null;
+  const date = new Date(0);
+  date.setUTCFullYear(year, month - 1, day);
+  date.setUTCHours(hour, minute, second, Number(fraction.padEnd(3, "0")));
+  if (date.getUTCFullYear() !== year || date.getUTCMonth() !== month - 1 || date.getUTCDate() !== day)
+    return null;
+  let offset = 0;
+  if (zone !== "Z") {
+    const digits = zone.slice(1).replace(":", "");
+    const hours = Number(digits.slice(0, 2));
+    const minutes = Number(digits.slice(2));
+    if (hours > 14 || minutes > 59 || hours === 14 && minutes !== 0 || /^-00:?00$/.test(zone))
+      return null;
+    offset = (hours * 60 + minutes) * (zone[0] === "-" ? -1 : 1);
+  }
+  return new Date(date.valueOf() - offset * 60000).toISOString();
+}
+function isAmbiguousTimestamp(value) {
+  return typeof value === "string" && (/^\d{4}-\d{2}-\d{2}(?:[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?)?$/.test(value) || /-00:?00$/.test(value));
+}
+function getRowTimestamp(row, timestamp_field) {
+  if (!timestamp_field)
+    return null;
+  const value = getImportField(row.record, timestamp_field);
+  const timestamp = parseImportTimestamp(value);
+  if (!timestamp)
+    throw new ImportRowError(row.index, `: timestamp field ${JSON.stringify(timestamp_field)} is missing, invalid or timezone-ambiguous. Choose an explicit timezone or a different field.`);
+  const milliseconds = Date.parse(timestamp);
+  if (milliseconds < 0)
+    throw new ImportRowError(row.index, `: timestamp field ${JSON.stringify(timestamp_field)} is before 1970-01-01T00:00:00Z and cannot be used as an import timestamp.`);
+  if (milliseconds > Date.now())
+    throw new ImportRowError(row.index, `: timestamp field ${JSON.stringify(timestamp_field)} is in the future and cannot be used as an import timestamp.`);
+  return timestamp;
+}
+
+// packages/import/src/batch.js
+var encoder2 = new TextEncoder;
+function serializeImportRow(row) {
+  const line = JSON.stringify(row.record);
+  if (line === undefined || line.length + 1 > IMPORT_BATCH_BYTES)
+    throw new ImportRowError(row.index, " exceeds the 1 MiB record limit.");
+  const bytes = encoder2.encode(line).byteLength + 1;
+  if (bytes > IMPORT_BATCH_BYTES)
+    throw new ImportRowError(row.index, " exceeds the 1 MiB record limit.");
+  return { row, line, bytes };
+}
+async function* createImportBatches(rows, options = {}) {
+  const max_bytes = options.max_bytes ?? IMPORT_BATCH_BYTES;
+  const max_rows = options.max_rows ?? IMPORT_BATCH_ROWS;
+  if (!Number.isSafeInteger(max_bytes) || max_bytes < 1 || max_bytes > IMPORT_BATCH_BYTES)
+    throw new RangeError("max_bytes must be between 1 and 1048576.");
+  if (!Number.isSafeInteger(max_rows) || max_rows < 1 || max_rows > IMPORT_BATCH_ROWS)
+    throw new RangeError("max_rows must be between 1 and 500.");
+  let batch_rows = [];
+  let body = "";
+  let bytes = 0;
+  let index = 0;
+  let timestamp = null;
+  function finish() {
+    const batch = { index: ++index, body, bytes, rows: batch_rows, timestamp };
+    batch_rows = [];
+    body = "";
+    bytes = 0;
+    return batch;
+  }
+  for await (const row of rows) {
+    const entry = serializeImportRow(row);
+    const next_timestamp = getRowTimestamp(row, options.timestamp_field);
+    if (entry.bytes > max_bytes)
+      throw new Error(`Row ${row.index} exceeds max_bytes (${max_bytes}).`);
+    if (batch_rows.length && (bytes + entry.bytes > max_bytes || timestamp !== next_timestamp))
+      yield finish();
+    timestamp = next_timestamp;
+    batch_rows.push(row);
+    body += entry.line + `
+`;
+    bytes += entry.bytes;
+    if (batch_rows.length === max_rows || bytes === max_bytes)
+      yield finish();
+  }
+  if (batch_rows.length)
+    yield finish();
+}
+
+// packages/import/src/row.js
+function createImportRow(record, index) {
+  if (!record || typeof record !== "object" || Array.isArray(record))
+    throw new ImportRowError(index, " must be a JSON object.");
+  const row = { index, record };
+  serializeImportRow(row);
+  return row;
+}
+
+// packages/import/src/scan-profile.js
+var IMPORT_PROFILE_FIELDS = 256;
+var MAX_DEPTH = 16;
+var MAX_PATH_CHARS = 4096;
+var MAX_VISITED_FIELDS = 2048;
+var PREVIEW_ROWS = 12;
+function createScanProfile({ timestamp_field, max_fields = IMPORT_PROFILE_FIELDS } = {}) {
+  const fields = new Map;
+  const preview = [];
+  let rows = 0;
+  let max_row_bytes = 0;
+  let has_row_limits = false;
+  let has_long_paths = false;
+  let has_field_limit = false;
+  function profile(record) {
+    let visited = 0;
+    function visit(object, prefix, depth) {
+      for (const key of Object.keys(object)) {
+        if (++visited > MAX_VISITED_FIELDS) {
+          has_row_limits = true;
+          return;
+        }
+        const path = prefix + "/" + key.replace(/~/g, "~0").replace(/\//g, "~1");
+        if (path.length > MAX_PATH_CHARS) {
+          has_long_paths = true;
+          continue;
+        }
+        const value = object[key];
+        let entry = fields.get(path);
+        if (!entry) {
+          if (fields.size >= max_fields) {
+            has_field_limit = true;
+            continue;
+          }
+          entry = {
+            field: {
+              path,
+              label: path.slice(1).replace(/~1/g, "/").replace(/~0/g, "~"),
+              types: [],
+              present: 0,
+              missing: 0
+            },
+            candidate: {
+              path,
+              label: key,
+              valid: 0,
+              invalid: 0,
+              missing: 0,
+              ambiguous: 0,
+              min: null,
+              max: null
+            },
+            has_evidence: /(?:date|time|(?:^|_)at$|timestamp)/i.test(key)
+          };
+          fields.set(path, entry);
+        }
+        if (value && typeof value === "object" && !Array.isArray(value)) {
+          if (depth >= MAX_DEPTH)
+            has_row_limits = true;
+          else
+            visit(value, path, depth + 1);
+        }
+      }
+    }
+    visit(record, "", 1);
+    for (const entry of fields.values()) {
+      const value = getImportField(record, entry.field.path);
+      if (value === undefined)
+        continue;
+      entry.field.present++;
+      let type = typeof value;
+      if (value === null)
+        type = "null";
+      else if (Array.isArray(value))
+        type = "array";
+      if (!entry.field.types.includes(type))
+        entry.field.types.push(type);
+      if (value !== undefined && value !== null && value !== "") {
+        const timestamp = parseImportTimestamp(value);
+        if (typeof value === "string" && /^\d{4}-\d{2}-\d{2}(?:[T ]|$)/.test(value))
+          entry.has_evidence = true;
+        if (timestamp) {
+          entry.candidate.valid++;
+          if (!entry.candidate.min || timestamp < entry.candidate.min)
+            entry.candidate.min = timestamp;
+          if (!entry.candidate.max || timestamp > entry.candidate.max)
+            entry.candidate.max = timestamp;
+        } else if (isAmbiguousTimestamp(value))
+          entry.candidate.ambiguous++;
+        else
+          entry.candidate.invalid++;
+      }
+    }
+  }
+  return {
+    get rows() {
+      return rows;
+    },
+    get max_row_bytes() {
+      return max_row_bytes;
+    },
+    get preview() {
+      return preview;
+    },
+    get is_truncated() {
+      return has_row_limits || has_long_paths || has_field_limit;
+    },
+    add(row) {
+      const entry = serializeImportRow(row);
+      getRowTimestamp(row, timestamp_field);
+      rows++;
+      max_row_bytes = Math.max(max_row_bytes, entry.bytes);
+      if (preview.length < PREVIEW_ROWS)
+        preview.push(row);
+      profile(row.record);
+    },
+    merge(partial) {
+      for (let index = 0;index < partial.preview.length && preview.length < PREVIEW_ROWS; index++)
+        preview.push({ index: rows + index + 1, record: partial.preview[index] });
+      rows += partial.rows;
+      max_row_bytes = Math.max(max_row_bytes, partial.max_row_bytes);
+      has_row_limits ||= partial.has_row_limits;
+      has_long_paths ||= partial.has_long_paths;
+      has_field_limit ||= partial.has_field_limit;
+      for (const local of partial.entries) {
+        const path = local.field.path;
+        let entry = fields.get(path);
+        if (!entry) {
+          if (fields.size >= max_fields) {
+            has_field_limit = true;
+            continue;
+          }
+          entry = {
+            field: { ...local.field, types: [], present: 0, missing: 0 },
+            candidate: {
+              ...local.candidate,
+              valid: 0,
+              invalid: 0,
+              ambiguous: 0,
+              min: null,
+              max: null
+            },
+            has_evidence: false
+          };
+          fields.set(path, entry);
+        }
+        entry.field.present += local.field.present;
+        for (const type of local.field.types)
+          if (!entry.field.types.includes(type))
+            entry.field.types.push(type);
+        const candidate = entry.candidate;
+        candidate.valid += local.candidate.valid;
+        candidate.invalid += local.candidate.invalid;
+        candidate.ambiguous += local.candidate.ambiguous;
+        if (local.candidate.min && (!candidate.min || local.candidate.min < candidate.min))
+          candidate.min = local.candidate.min;
+        if (local.candidate.max && (!candidate.max || local.candidate.max > candidate.max))
+          candidate.max = local.candidate.max;
+        entry.has_evidence ||= local.has_evidence;
+      }
+    },
+    partial() {
+      return {
+        rows,
+        max_row_bytes,
+        preview: preview.map((row) => row.record),
+        entries: Array.from(fields.values()),
+        has_row_limits,
+        has_long_paths,
+        has_field_limit
+      };
+    },
+    finish(report) {
+      report.row_count = rows;
+      report.max_row_bytes = max_row_bytes;
+      report.preview = preview;
+      for (const { field, candidate, has_evidence } of fields.values()) {
+        field.missing = rows - field.present;
+        report.fields.push(field);
+        if (has_evidence) {
+          candidate.missing = rows - candidate.valid - candidate.invalid - candidate.ambiguous;
+          report.timestamp_candidates.push(candidate);
+        }
+      }
+    }
+  };
+}
+
+// packages/import/src/xml-task.js
+var PARTIAL_PROFILE_FIELDS = 1024;
+var IMPORT_XML_OPTIONS = Object.freeze({
+  whitespace: "strip-indentation",
+  parserOptions: Object.freeze({ doctype: "ignore" }),
+  maxRecordChars: IMPORT_BATCH_BYTES,
+  maxRecordNodes: 1e5
+});
+function checkImportRecordPath(record_path) {
+  if (record_path && !/^\/[^/]+(?:\/[^/]+)*$/.test(record_path))
+    throw new Error("XML record_path must be an absolute element path such as /Export/Record.");
+}
+function checkImportXmlRoot(name) {
+  if (name.toLowerCase().split(":").pop() === "html")
+    throw new Error("HTML documents are not supported XML imports.");
+}
+function restoreXmlRecord(record) {
+  Object.setPrototypeOf(record.attributes, null);
+  for (const child of record.children)
+    if (typeof child !== "string")
+      restoreXmlRecord(child);
+  return record;
+}
+var IMPORT_XML_TASK = {
+  name: "tailglow-import-xml",
+  createSink(options) {
+    let index = 0;
+    if (options.kind === "rows") {
+      let records = [];
+      return {
+        add(record) {
+          createImportRow(record, ++index);
+          records.push(record);
+        },
+        take() {
+          const output = { records };
+          records = [];
+          return output;
+        }
+      };
+    }
+    const createProfile = () => createScanProfile({
+      timestamp_field: options.timestamp_field,
+      max_fields: PARTIAL_PROFILE_FIELDS
+    });
+    let profile = createProfile();
+    return {
+      add(record) {
+        profile.add(createImportRow(record, ++index));
+      },
+      take() {
+        const partial = profile.partial();
+        profile = createProfile();
+        return partial;
+      }
+    };
+  },
+  describeError(error) {
+    if (error instanceof ImportRowError)
+      return { detail: error.detail };
+    const value = error ?? {};
+    return {
+      name: typeof value.name === "string" ? value.name : "Error",
+      message: typeof value.message === "string" ? value.message : String(error)
+    };
+  },
+  restoreError(description, record_number) {
+    const value = description;
+    if (typeof value.detail === "string")
+      return new ImportRowError(record_number, value.detail);
+    if (value.name === "RangeError")
+      return new RangeError(value.message);
+    if (value.name === "TypeError")
+      return new TypeError(value.message);
+    return new Error(value.message);
+  }
+};
+
+// packages/import/src/xml-workers.js
+var AUTO_MIN_PROCESSORS = 4;
+function validateImportWorkers(value = "auto") {
+  if (value === "auto")
+    return value;
+  if (typeof value === "number" && Number.isSafeInteger(value) && value >= 0 && value <= IMPORT_MAX_WORKERS)
+    return value;
+  throw new RangeError(`workers must be "auto" or an integer from 0 to ${IMPORT_MAX_WORKERS}.`);
+}
+function planImportWorkers({ source, options, format, is_complete_read }) {
+  const workers = validateImportWorkers(options.workers);
+  if (workers === 0)
+    return { requested: 0, reason: "workers is 0" };
+  if (format !== "xml")
+    return { requested: 0, reason: "only XML is read with workers" };
+  if (!is_complete_read)
+    return { requested: 0, reason: "sampled scans read sequentially" };
+  if (typeof source.read !== "function")
+    return { requested: 0, reason: "the source has no random access" };
+  if (typeof options.create_worker !== "function")
+    return { requested: 0, reason: "no create_worker factory was given" };
+  if (workers !== "auto")
+    return { requested: workers };
+  if (source.size < IMPORT_WORKER_MIN_BYTES)
+    return { requested: 0, reason: "auto uses workers for files of 32 MiB or more" };
+  const processors = globalThis.navigator?.hardwareConcurrency;
+  if (!processors || processors < AUTO_MIN_PROCESSORS)
+    return {
+      requested: 0,
+      reason: `auto needs at least ${AUTO_MIN_PROCESSORS} logical processors`
+    };
+  return { requested: IMPORT_AUTO_WORKERS };
+}
+function readImportXmlSegments(source, options, requested, task_options) {
+  const read = source.read;
+  return readXmlSegments({ size: source.size, read: (start, end) => read.call(source, start, end) }, {
+    workers: requested,
+    maxSegmentBytes: IMPORT_XML_SEGMENT_MAX_BYTES,
+    readBytes: IMPORT_XML_READ_BYTES,
+    createWorker: options.create_worker,
+    task: IMPORT_XML_TASK,
+    taskOptions: task_options,
+    ...options.record_path ? { selectPath: options.record_path.slice(1).split("/") } : {},
+    ...IMPORT_XML_OPTIONS,
+    onRoot: checkImportXmlRoot,
+    signal: options.signal
+  });
+}
+function reportWorkerEvent(event, state, options) {
+  if (event.type === "sequential") {
+    options.onworkers?.({ ...state.status, reason: event.reason });
+    return false;
+  }
+  if (event.type === "workers") {
+    state.status = { requested: state.status.requested, actual: event.actual };
+    if (event.reason)
+      state.status.reason = event.reason;
+    options.onworkers?.(state.status);
+  } else if (event.type === "fallback")
+    options.onworkers?.({ ...state.status, fallback: event.reason });
+  return true;
+}
+async function* readXmlRowsWithWorkers(source, options, requested) {
+  const state = { status: { requested, actual: 0 } };
+  let rows = 0;
+  for await (const event of readImportXmlSegments(source, options, requested, { kind: "rows" })) {
+    if (!reportWorkerEvent(event, state, options))
+      return false;
+    if (event.type !== "records")
+      continue;
+    const output = event.output;
+    for (const record of output.records) {
+      checkImportAbort(options.signal);
+      const restored = restoreXmlRecord(record);
+      yield { index: ++rows, record: restored };
+    }
+    options.onprogress?.({ bytes_read: event.end, total_bytes: source.size, rows });
+  }
+  return true;
+}
+async function scanXmlWithWorkers(source, options, requested) {
+  const state = { status: { requested, actual: 0 } };
+  const profile = createScanProfile({ timestamp_field: options.timestamp_field });
+  for await (const event of readImportXmlSegments(source, options, requested, {
+    kind: "scan",
+    timestamp_field: options.timestamp_field
+  })) {
+    if (!reportWorkerEvent(event, state, options))
+      return null;
+    if (event.type !== "records")
+      continue;
+    const partial = event.output;
+    if (partial.has_row_limits || partial.has_field_limit) {
+      options.onworkers?.({
+        ...state.status,
+        fallback: "a part's schema profile cannot merge exactly; scanning sequentially"
+      });
+      return null;
+    }
+    for (const record of partial.preview)
+      restoreXmlRecord(record);
+    profile.merge(partial);
+    options.onprogress?.({ bytes_read: event.end, total_bytes: source.size, rows: profile.rows });
+  }
+  return profile;
+}
+
+// packages/import/src/read.js
+async function* readImportRows(source, options = {}) {
+  validateImportWorkers(options.workers);
+  const format = !options.format || options.format === "auto" ? (await detectImport(source, options)).format : options.format;
+  if (format === "xml")
+    checkImportRecordPath(options.record_path);
+  const plan = planImportWorkers({ source, options, format, is_complete_read: true });
+  if (!plan.requested)
+    options.onworkers?.({ requested: 0, actual: 0, reason: plan.reason });
+  else if (yield* readXmlRowsWithWorkers(source, options, plan.requested))
+    return;
+  let bytes_read = 0;
+  let rows = 0;
+  async function* bytes() {
+    for await (const chunk of readImportBytes(source, options.signal)) {
+      bytes_read += chunk.length;
+      options.onprogress?.({ bytes_read, total_bytes: source.size, rows });
+      yield chunk;
+    }
+  }
+  async function* records() {
+    if (format === "xml") {
+      const chunks = alignXmlChunks(bytes());
+      const record_path = options.record_path;
+      if (!record_path) {
+        yield* xmlDocumentRecords(chunks, { ...IMPORT_XML_OPTIONS, onRoot: checkImportXmlRoot });
+      } else {
+        let has_root = false;
+        yield* xmlRecords(chunks, {
+          ...IMPORT_XML_OPTIONS,
+          select(path) {
+            if (!has_root) {
+              has_root = true;
+              checkImportXmlRoot(path[0]);
+            }
+            return "/" + path.join("/") === record_path;
+          }
+        });
+      }
+      return;
+    }
+    if (format === "json") {
+      if (source.size > IMPORT_JSON_BYTES)
+        throw new Error("Whole-document JSON is limited to 50 MiB. Use JSONL for larger files.");
+      let text = "";
+      for await (const part of decodeImportBytes(bytes())) {
+        if (bytes_read > IMPORT_JSON_BYTES)
+          throw new Error("Whole-document JSON is limited to 50 MiB. Use JSONL for larger files.");
+        text += part;
+      }
+      let value;
+      try {
+        value = JSON.parse(text);
+      } catch {
+        throw new Error("This file is not valid JSON.");
+      }
+      if (Array.isArray(value))
+        yield* value;
+      else
+        yield value;
+      return;
+    }
+    if (format === "jsonl") {
+      let parseLine = function(line) {
+        line_number++;
+        if (!line.trim())
+          return;
+        if (line.length > IMPORT_BATCH_BYTES)
+          throw new Error(`JSONL line ${line_number} exceeds the 1 MiB record limit.`);
+        try {
+          return JSON.parse(line);
+        } catch {
+          throw new Error(`JSONL line ${line_number} is not valid JSON.`);
+        }
+      };
+      let partial = "";
+      let line_number = 0;
+      for await (const part of decodeImportBytes(bytes())) {
+        const input = partial + part;
+        let start = 0;
+        let end;
+        while ((end = input.indexOf(`
+`, start)) !== -1) {
+          const record = parseLine(input.slice(start, end));
+          if (record !== undefined)
+            yield record;
+          start = end + 1;
+        }
+        partial = input.slice(start);
+        if (partial.length > IMPORT_BATCH_BYTES)
+          throw new Error(`JSONL line ${line_number + 1} exceeds the 1 MiB record limit.`);
+      }
+      if (partial) {
+        const record = parseLine(partial);
+        if (record !== undefined)
+          yield record;
+      }
+      return;
+    }
+    if (format !== "csv" && format !== "tsv")
+      throw new Error(`Unsupported import format: ${format}`);
+    let headers = null;
+    for await (const result of readCsvResults(decodeImportBytes(bytes()), format === "tsv" ? "\t" : ",")) {
+      for (const values of result.data) {
+        if (!headers) {
+          headers = values.map((value) => value.trim().replace(/^\uFEFF/, ""));
+          if (headers.some((header) => !header))
+            throw new Error("Every CSV/TSV column needs a header.");
+          if (new Set(headers).size !== headers.length)
+            throw new Error("Two CSV/TSV columns have the same header.");
+        } else {
+          if (values.length !== headers.length)
+            throw new Error(`Row ${rows + 1} has ${values.length} cells; the header has ${headers.length}.`);
+          yield Object.fromEntries(headers.map((header, index) => [header, values[index]]));
+        }
+      }
+    }
+  }
+  for await (const record of records()) {
+    checkImportAbort(options.signal);
+    yield createImportRow(record, ++rows);
+  }
+  options.onprogress?.({ bytes_read, total_bytes: source.size, rows });
+}
+async function* readCsvResults(chunks, delimiter) {
+  let parser;
+  let partial = "";
+  let cursor = 0;
+  function parse(text, is_last) {
+    let input = partial + text;
+    const has_pending_cr = !is_last && input.endsWith("\r");
+    if (has_pending_cr)
+      input = input.slice(0, -1);
+    const candidate = parser ?? new import_papaparse2.default.ParserHandle({
+      delimiter,
+      skipEmptyLines: "greedy",
+      dynamicTyping: false
+    });
+    const results = candidate.parse(input, cursor, !is_last);
+    if (results.data.length || is_last)
+      parser = candidate;
+    const error = results.errors.find((item) => item.code !== "UndetectableDelimiter" && (is_last || !(item.index >= results.meta.cursor - cursor)));
+    if (error)
+      throw new Error(`CSV could not be read: ${error.message}`);
+    partial = input.slice(results.meta.cursor - cursor) + (has_pending_cr ? "\r" : "");
+    if (partial.length > 4 * IMPORT_BATCH_BYTES)
+      throw new Error("A CSV row is too large. Each record must fit within 1 MiB.");
+    cursor = results.meta.cursor;
+    return results;
+  }
+  for await (const text of chunks)
+    yield parse(text, false);
+  yield parse("", true);
+}
+async function* alignXmlChunks(chunks) {
+  let pending = new Uint8Array(IMPORT_CHUNK_BYTES);
+  let length = 0;
+  for await (const chunk of chunks) {
+    if (!length && chunk.length === IMPORT_CHUNK_BYTES) {
+      yield chunk;
+      continue;
+    }
+    let offset = 0;
+    while (offset < chunk.length) {
+      const count = Math.min(IMPORT_CHUNK_BYTES - length, chunk.length - offset);
+      pending.set(chunk.subarray(offset, offset + count), length);
+      length += count;
+      offset += count;
+      if (length === IMPORT_CHUNK_BYTES) {
+        yield pending;
+        pending = new Uint8Array(IMPORT_CHUNK_BYTES);
+        length = 0;
+      }
+    }
+  }
+  if (length)
+    yield pending.subarray(0, length);
+}
+// packages/import/src/scan.js
+async function scanImport(source, options = {}) {
+  validateImportWorkers(options.workers);
+  const detection = await detectImport(source, options);
+  const report = {
+    format: detection.format,
+    is_sampled: false,
+    is_complete: false,
+    bytes_read: 0,
+    total_bytes: source.size,
+    row_count: 0,
+    preview: [],
+    fields: [],
+    timestamp_candidates: [],
+    warnings: detection.warnings.filter((warning) => !warning.startsWith("Detection used")),
+    max_row_bytes: 0
+  };
+  if (detection.xml)
+    report.xml = {
+      ...detection.xml,
+      ...options.record_path ? { record_path: options.record_path } : {}
+    };
+  if (detection.xml && detection.is_sampled)
+    report.warnings.push("XML path discovery counts cover only the first 256 KiB; a complete selected-row scan does not make those path counts complete.");
+  if (detection.format === "xml" && !options.record_path)
+    report.warnings.push("Automatic XML import includes every direct root child; root attributes and meaningful direct text become a final context record. A root without child elements becomes one record.");
+  if (detection.format === "xml")
+    checkImportRecordPath(options.record_path);
+  const plan = planImportWorkers({
+    source,
+    options,
+    format: detection.format,
+    is_complete_read: Boolean(options.is_full)
+  });
+  if (!plan.requested)
+    options.onworkers?.({ requested: 0, actual: 0, reason: plan.reason });
+  let profile = plan.requested ? await scanXmlWithWorkers(source, options, plan.requested) : null;
+  if (profile)
+    report.bytes_read = source.size;
+  else
+    profile = await scanSequentially(source, options, detection.format, report);
+  report.is_complete = !report.is_sampled;
+  if (report.is_complete && !profile.rows)
+    throw new Error("This selection has no data rows. Check the XML record_path or file contents.");
+  profile.finish(report);
+  if (profile.is_truncated)
+    report.warnings.push("Schema discovery was truncated (256 fields, 16 levels, 4096 characters per path or 2048 visited fields per row). Counts cover scanned rows only.");
+  if (report.is_sampled)
+    report.warnings.push("This bounded sample does not certify full file validity or schema coverage. Records must be validated as they are imported.");
+  if (options.timestamp_field)
+    report.warnings.push("The selected timestamp is sent at request level. Changes between rows split batches and may produce many small requests.");
+  options.onprogress?.({
+    bytes_read: report.bytes_read,
+    total_bytes: source.size,
+    rows: report.row_count
+  });
+  return report;
+}
+async function scanSequentially(source, options, format, report) {
+  const sample_limit = new Error("Sample complete");
+  const has_byte_limit = !options.is_full && format !== "json";
+  const scanned_source = {
+    name: source.name,
+    size: source.size,
+    async* open() {
+      for await (const chunk of readImportBytes(source, options.signal)) {
+        const remaining = has_byte_limit ? IMPORT_SAMPLE_BYTES - report.bytes_read : chunk.length;
+        const part = chunk.subarray(0, remaining);
+        report.bytes_read += part.length;
+        if (part.length)
+          yield part;
+        if (has_byte_limit && report.bytes_read >= IMPORT_SAMPLE_BYTES)
+          throw sample_limit;
+      }
+    }
+  };
+  const profile = createScanProfile({ timestamp_field: options.timestamp_field });
+  report.bytes_read = 0;
+  try {
+    for await (const row of readImportRows(scanned_source, {
+      ...options,
+      format,
+      workers: 0,
+      onworkers: undefined,
+      onprogress(progress) {
+        options.onprogress?.({ ...progress, total_bytes: source.size });
+      }
+    })) {
+      profile.add(row);
+      if (!options.is_full && profile.rows >= IMPORT_SAMPLE_ROWS) {
+        report.is_sampled = true;
+        break;
+      }
+    }
+  } catch (error) {
+    if (error !== sample_limit)
+      throw error;
+    report.is_sampled = true;
+  }
+  return profile;
+}
+// packages/import/node.js
+function createNodeImportWorker(entry = new URL("./src/worker.node.js", import.meta.url)) {
+  return createNodeXmlWorker(entry);
+}
+export {
+  IMPORT_BATCH_BYTES,
+  IMPORT_BATCH_ROWS,
+  IMPORT_JSON_BYTES,
+  IMPORT_MAX_WORKERS,
+  IMPORT_REJECTED_STATUSES,
+  createBlobSource,
+  createImportBatches,
+  createNodeImportWorker,
+  detectImport,
+  getImportField,
+  parseImportTimestamp,
+  readImportRows,
+  scanImport,
+  serializeImportRow
+};