@fuzzle/opencode-accountant 0.0.6 → 0.0.7

package/dist/index.js

@@ -1,5 +1,21 @@
 // @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
@@ -9,9 +25,1323 @@ var __export = (target, all) => {
       set: (newValue) => all[name] = () => newValue
     });
 };
+var __require = import.meta.require;
+
+// node_modules/papaparse/papaparse.js
+var require_papaparse = __commonJS((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 (global.jQuery) {
+      var $2 = global.jQuery;
+      $2.fn.parse = function(options) {
+        var config2 = options.config || {};
+        var queue = [];
+        this.each(function(idx) {
+          var supported = $2(this).prop("tagName").toUpperCase() === "INPUT" && $2(this).attr("type").toLowerCase() === "file" && global.FileReader;
+          if (!supported || !this.files || this.files.length === 0)
+            return true;
+          for (var i2 = 0;i2 < this.files.length; i2++) {
+            queue.push({
+              file: this.files[i2],
+              inputElem: this,
+              instanceConfig: $2.extend({}, config2)
+            });
+          }
+        });
+        parseNextFile();
+        return this;
+        function parseNextFile() {
+          if (queue.length === 0) {
+            if (isFunction(options.complete))
+              options.complete();
+            return;
+          }
+          var f = queue[0];
+          if (isFunction(options.before)) {
+            var returned = options.before(f.file, f.inputElem);
+            if (typeof returned === "object") {
+              if (returned.action === "abort") {
+                error45("AbortError", f.file, f.inputElem, returned.reason);
+                return;
+              } else if (returned.action === "skip") {
+                fileComplete();
+                return;
+              } else if (typeof returned.config === "object")
+                f.instanceConfig = $2.extend(f.instanceConfig, returned.config);
+            } else if (returned === "skip") {
+              fileComplete();
+              return;
+            }
+          }
+          var userCompleteFunc = f.instanceConfig.complete;
+          f.instanceConfig.complete = function(results) {
+            if (isFunction(userCompleteFunc))
+              userCompleteFunc(results, f.file, f.inputElem);
+            fileComplete();
+          };
+          Papa.parse(f.file, f.instanceConfig);
+        }
+        function error45(name, file2, elem, reason) {
+          if (isFunction(options.error))
+            options.error({ name }, file2, elem, reason);
+        }
+        function fileComplete() {
+          queue.splice(0, 1);
+          parseNextFile();
+        }
+      };
+    }
+    if (IS_PAPA_WORKER) {
+      global.onmessage = workerThreadReceivedMessage;
+    }
+    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.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 stripBom(string4) {
+        if (string4.charCodeAt(0) === 65279) {
+          return string4.slice(1);
+        }
+        return string4;
+      }
+    }
+    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;
+        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 i2 = 0;i2 < fields.length; i2++) {
+            if (i2 > 0)
+              csv += _delimiter;
+            csv += safe(fields[i2], i2);
+          }
+          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(str2, col) {
+        if (typeof str2 === "undefined" || str2 === null)
+          return "";
+        if (str2.constructor === Date)
+          return JSON.stringify(str2).slice(1, 25);
+        var needsQuotes = false;
+        if (_escapeFormulae && typeof str2 === "string" && _escapeFormulae.test(str2)) {
+          str2 = "'" + str2;
+          needsQuotes = true;
+        }
+        var escapedQuoteStr = str2.toString().replace(quoteCharRegex, _escapedQuote);
+        needsQuotes = needsQuotes || _quotes === true || typeof _quotes === "function" && _quotes(str2, col) || Array.isArray(_quotes) && _quotes[col] || hasAny(escapedQuoteStr, Papa.BAD_DELIMITERS) || escapedQuoteStr.indexOf(_delimiter) > -1 || escapedQuoteStr.charAt(0) === " " || escapedQuoteStr.charAt(escapedQuoteStr.length - 1) === " ";
+        return needsQuotes ? _quoteChar + escapedQuoteStr + _quoteChar : escapedQuoteStr;
+      }
+      function hasAny(str2, substrings) {
+        for (var i2 = 0;i2 < substrings.length; i2++)
+          if (str2.indexOf(substrings[i2]) > -1)
+            return true;
+        return false;
+      }
+    }
+    function ChunkStreamer(config2) {
+      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, config2);
+      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(error45) {
+        if (isFunction(this._config.error))
+          this._config.error(error45);
+        else if (IS_PAPA_WORKER && this._config.error) {
+          global.postMessage({
+            workerId: Papa.WORKER_ID,
+            error: error45,
+            finished: false
+          });
+        }
+      };
+      function replaceConfig(config3) {
+        var configCopy = copy(config3);
+        configCopy.chunkSize = parseInt(configCopy.chunkSize);
+        if (!config3.step && !config3.chunk)
+          configCopy.chunkSize = null;
+        this._handle = new ParserHandle(configCopy);
+        this._handle.streamer = this;
+        this._config = configCopy;
+      }
+    }
+    function NetworkStreamer(config2) {
+      config2 = config2 || {};
+      if (!config2.chunkSize)
+        config2.chunkSize = Papa.RemoteChunkSize;
+      ChunkStreamer.call(this, config2);
+      var xhr;
+      if (IS_WORKER) {
+        this._nextChunk = function() {
+          this._readChunk();
+          this._chunkLoaded();
+        };
+      } else {
+        this._nextChunk = function() {
+          this._readChunk();
+        };
+      }
+      this.stream = function(url2) {
+        this._input = url2;
+        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.open(this._config.downloadRequestBody ? "POST" : "GET", this._input, !IS_WORKER);
+        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));
+      };
+      function getFileSize(xhr2) {
+        var contentRange = xhr2.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(config2) {
+      config2 = config2 || {};
+      if (!config2.chunkSize)
+        config2.chunkSize = Papa.LocalChunkSize;
+      ChunkStreamer.call(this, config2);
+      var reader, slice;
+      var usingAsyncReader = typeof FileReader !== "undefined";
+      this.stream = function(file2) {
+        this._input = file2;
+        slice = file2.slice || file2.webkitSlice || file2.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(config2) {
+      config2 = config2 || {};
+      ChunkStreamer.call(this, config2);
+      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(config2) {
+      config2 = config2 || {};
+      ChunkStreamer.call(this, config2);
+      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 (error45) {
+          this._streamError(error45);
+        }
+      }, this);
+      this._streamError = bindFunction(function(error45) {
+        this._streamCleanUp();
+        this._sendError(error45);
+      }, 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 config2 = 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);
+      };
+      config2.step = bindFunction(this._onCsvData, this);
+      config2.complete = bindFunction(this._onCsvComplete, this);
+      ChunkStreamer.call(this, config2);
+      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(config2.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);
+        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 i2 = 0;i2 < r.length; i2++) {
+          if (r[i2][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, i3) {
+          if (isFunction(_config.transformHeader))
+            header = _config.transformHeader(header, i3);
+          _fields.push(header);
+        }
+        if (Array.isArray(_results.data[0])) {
+          for (var i2 = 0;needsHeaderRow() && i2 < _results.data.length; i2++)
+            _results.data[i2].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, i2) {
+          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 + i2);
+            else if (j < _fields.length)
+              addError("FieldMismatch", "TooFewFields", "Too few fields: expected " + _fields.length + " fields but parsed " + j, _rowCounter + i2);
+          }
+          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 i2 = 0;i2 < delimitersToGuess.length; i2++) {
+          var delim = delimitersToGuess[i2];
+          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 ((typeof bestDelta === "undefined" || delta <= bestDelta) && (typeof maxFieldCount === "undefined" || avgFieldCount > maxFieldCount) && avgFieldCount > 1.99) {
+            bestDelta = delta;
+            bestDelim = delim;
+            maxFieldCount = avgFieldCount;
+          }
+        }
+        _config.delimiter = bestDelim;
+        return {
+          successful: !!bestDelim,
+          bestDelimiter: bestDelim
+        };
+      }
+      function addError(type2, code, msg, row) {
+        var error45 = {
+          type: type2,
+          code,
+          message: msg
+        };
+        if (row !== undefined) {
+          error45.row = row;
+        }
+        _results.errors.push(error45);
+      }
+    }
+    function escapeRegExp(string4) {
+      return string4.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }
+    function Parser(config2) {
+      config2 = config2 || {};
+      var delim = config2.delimiter;
+      var newline = config2.newline;
+      var comments = config2.comments;
+      var step = config2.step;
+      var preview = config2.preview;
+      var fastMode = config2.fastMode;
+      var quoteChar;
+      var renamedHeaders = null;
+      var headerParsed = false;
+      if (config2.quoteChar === undefined || config2.quoteChar === null) {
+        quoteChar = '"';
+      } else {
+        quoteChar = config2.quoteChar;
+      }
+      var escapeChar = quoteChar;
+      if (config2.escapeChar !== undefined) {
+        escapeChar = config2.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 aborted2 = 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 = [], errors3 = [], row = [], lastCursor = 0;
+        if (!input)
+          return returnable();
+        if (fastMode || fastMode !== false && input.indexOf(quoteChar) === -1) {
+          var rows = input.split(newline);
+          for (var i2 = 0;i2 < rows.length; i2++) {
+            row = rows[i2];
+            cursor += row.length;
+            if (i2 !== 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 (aborted2)
+                return returnable();
+            } else
+              pushRow(row.split(delim));
+            if (preview && i2 >= 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) {
+                  errors3.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 (aborted2)
+                    return returnable();
+                }
+                if (preview && data.length >= preview)
+                  return returnable(true);
+                break;
+              }
+              errors3.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 (aborted2)
+                return returnable();
+            }
+            if (preview && data.length >= preview)
+              return returnable(true);
+            continue;
+          }
+          break;
+        }
+        return finish();
+        function pushRow(row2) {
+          data.push(row2);
+          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(value2) {
+          if (ignoreLastRow)
+            return returnable();
+          if (typeof value2 === "undefined")
+            value2 = input.substring(cursor);
+          row.push(value2);
+          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 (config2.header && !baseIndex && data.length && !headerParsed) {
+            const result = data[0];
+            const headerCount = Object.create(null);
+            const usedHeaders = new Set(result);
+            let duplicateHeaders = false;
+            for (let i3 = 0;i3 < result.length; i3++) {
+              let header = result[i3];
+              if (isFunction(config2.transformHeader))
+                header = config2.transformHeader(header, i3);
+              if (!headerCount[header]) {
+                headerCount[header] = 1;
+                result[i3] = header;
+              } else {
+                let newHeader;
+                let suffixCount = headerCount[header];
+                do {
+                  newHeader = `${header}_${suffixCount}`;
+                  suffixCount++;
+                } while (usedHeaders.has(newHeader));
+                usedHeaders.add(newHeader);
+                result[i3] = 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: errors3,
+            meta: {
+              delimiter: delim,
+              linebreak: newline,
+              aborted: aborted2,
+              truncated: !!stopped,
+              cursor: lastCursor + (baseIndex || 0),
+              renamedHeaders
+            }
+          };
+        }
+        function doStep() {
+          step(returnable());
+          data = [];
+          errors3 = [];
+        }
+      };
+      this.abort = function() {
+        aborted2 = 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 aborted2 = false;
+      if (msg.error)
+        worker.userError(msg.error, msg.file);
+      else if (msg.results && msg.results.data) {
+        var abort = function() {
+          aborted2 = true;
+          completeWorker(msg.workerId, { data: [], errors: [], meta: { aborted: true } });
+        };
+        var handle = {
+          abort,
+          pause: notImplemented,
+          resume: notImplemented
+        };
+        if (isFunction(worker.userStep)) {
+          for (var i2 = 0;i2 < msg.results.data.length; i2++) {
+            worker.userStep({
+              data: msg.results.data[i2],
+              errors: msg.results.errors,
+              meta: msg.results.meta
+            }, handle);
+            if (aborted2)
+              break;
+          }
+          delete msg.results;
+        } else if (isFunction(worker.userChunk)) {
+          worker.userChunk(msg.results, handle, msg.file);
+          delete msg.results;
+        }
+      }
+      if (msg.finished && !aborted2)
+        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;
+  });
+});
 
 // src/index.ts
-import { dirname, join as join3 } from "path";
+import { dirname, join as join5 } from "path";
 import { fileURLToPath } from "url";
 
 // src/utils/agentLoader.ts
@@ -15246,14 +16576,322 @@ var update_prices_default = tool({
     return updatePricesCore(directory, agent, backfill || false);
   }
 });
+// src/tools/classify-statements.ts
+import * as path4 from "path";
+import * as fs4 from "fs";
+
+// src/utils/importConfig.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+var CONFIG_FILE2 = "config/import/providers.yaml";
+var REQUIRED_PATH_FIELDS = ["imports", "pending", "done", "unrecognized"];
+var REQUIRED_DETECTION_FIELDS = [
+  "filenamePattern",
+  "header",
+  "currencyField"
+];
+function validatePaths(paths) {
+  if (typeof paths !== "object" || paths === null) {
+    throw new Error("Invalid config: 'paths' must be an object");
+  }
+  const pathsObj = paths;
+  for (const field of REQUIRED_PATH_FIELDS) {
+    if (typeof pathsObj[field] !== "string" || pathsObj[field] === "") {
+      throw new Error(`Invalid config: 'paths.${field}' is required`);
+    }
+  }
+  return {
+    imports: pathsObj.imports,
+    pending: pathsObj.pending,
+    done: pathsObj.done,
+    unrecognized: pathsObj.unrecognized
+  };
+}
+function validateDetectionRule(providerName, index, rule) {
+  if (typeof rule !== "object" || rule === null) {
+    throw new Error(`Invalid config: provider '${providerName}' detect[${index}] must be an object`);
+  }
+  const ruleObj = rule;
+  for (const field of REQUIRED_DETECTION_FIELDS) {
+    if (typeof ruleObj[field] !== "string" || ruleObj[field] === "") {
+      throw new Error(`Invalid config: provider '${providerName}' detect[${index}].${field} is required`);
+    }
+  }
+  try {
+    new RegExp(ruleObj.filenamePattern);
+  } catch {
+    throw new Error(`Invalid config: provider '${providerName}' detect[${index}].filenamePattern is not a valid regex`);
+  }
+  return {
+    filenamePattern: ruleObj.filenamePattern,
+    header: ruleObj.header,
+    currencyField: ruleObj.currencyField
+  };
+}
+function validateProviderConfig(name, config2) {
+  if (typeof config2 !== "object" || config2 === null) {
+    throw new Error(`Invalid config for provider '${name}': expected an object`);
+  }
+  const configObj = config2;
+  if (!Array.isArray(configObj.detect) || configObj.detect.length === 0) {
+    throw new Error(`Invalid config for provider '${name}': 'detect' must be a non-empty array`);
+  }
+  const detect = [];
+  for (let i2 = 0;i2 < configObj.detect.length; i2++) {
+    detect.push(validateDetectionRule(name, i2, configObj.detect[i2]));
+  }
+  if (typeof configObj.currencies !== "object" || configObj.currencies === null) {
+    throw new Error(`Invalid config for provider '${name}': 'currencies' must be an object`);
+  }
+  const currenciesObj = configObj.currencies;
+  const currencies = {};
+  for (const [key, value] of Object.entries(currenciesObj)) {
+    if (typeof value !== "string") {
+      throw new Error(`Invalid config for provider '${name}': currencies.${key} must be a string`);
+    }
+    currencies[key] = value;
+  }
+  if (Object.keys(currencies).length === 0) {
+    throw new Error(`Invalid config for provider '${name}': 'currencies' must contain at least one mapping`);
+  }
+  return { detect, currencies };
+}
+function loadImportConfig(directory) {
+  const configPath = path3.join(directory, CONFIG_FILE2);
+  if (!fs3.existsSync(configPath)) {
+    throw new Error(`Configuration file not found: ${CONFIG_FILE2}. Please create this file to configure statement imports.`);
+  }
+  let parsed;
+  try {
+    const content = fs3.readFileSync(configPath, "utf-8");
+    parsed = jsYaml.load(content);
+  } catch (err) {
+    if (err instanceof jsYaml.YAMLException) {
+      throw new Error(`Failed to parse ${CONFIG_FILE2}: ${err.message}`);
+    }
+    throw err;
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    throw new Error(`Invalid config: ${CONFIG_FILE2} must contain a YAML object`);
+  }
+  const parsedObj = parsed;
+  if (!parsedObj.paths) {
+    throw new Error("Invalid config: 'paths' section is required");
+  }
+  const paths = validatePaths(parsedObj.paths);
+  if (!parsedObj.providers || typeof parsedObj.providers !== "object") {
+    throw new Error("Invalid config: 'providers' section is required");
+  }
+  const providersObj = parsedObj.providers;
+  if (Object.keys(providersObj).length === 0) {
+    throw new Error("Invalid config: 'providers' section must contain at least one provider");
+  }
+  const providers = {};
+  for (const [name, config2] of Object.entries(providersObj)) {
+    providers[name] = validateProviderConfig(name, config2);
+  }
+  return { paths, providers };
+}
+
+// src/utils/providerDetector.ts
+var import_papaparse = __toESM(require_papaparse(), 1);
+function parseCSVPreview(content) {
+  const result = import_papaparse.default.parse(content, {
+    header: true,
+    preview: 1,
+    skipEmptyLines: true
+  });
+  return {
+    fields: result.meta.fields,
+    firstRow: result.data[0]
+  };
+}
+function normalizeHeader(fields) {
+  return fields.map((f) => f.trim()).join(",");
+}
+function detectProvider(filename, content, config2) {
+  const { fields, firstRow } = parseCSVPreview(content);
+  if (!fields || fields.length === 0) {
+    return null;
+  }
+  const actualHeader = normalizeHeader(fields);
+  for (const [providerName, providerConfig] of Object.entries(config2.providers)) {
+    for (const rule of providerConfig.detect) {
+      const filenameRegex = new RegExp(rule.filenamePattern);
+      if (!filenameRegex.test(filename)) {
+        continue;
+      }
+      if (actualHeader !== rule.header) {
+        continue;
+      }
+      if (!firstRow) {
+        continue;
+      }
+      const rawCurrency = firstRow[rule.currencyField];
+      if (!rawCurrency) {
+        continue;
+      }
+      const normalizedCurrency = providerConfig.currencies[rawCurrency];
+      if (!normalizedCurrency) {
+        return {
+          provider: providerName,
+          currency: rawCurrency.toLowerCase(),
+          rule
+        };
+      }
+      return {
+        provider: providerName,
+        currency: normalizedCurrency,
+        rule
+      };
+    }
+  }
+  return null;
+}
+
+// src/tools/classify-statements.ts
+function findCSVFiles(importsDir) {
+  if (!fs4.existsSync(importsDir)) {
+    return [];
+  }
+  return fs4.readdirSync(importsDir).filter((file2) => file2.toLowerCase().endsWith(".csv")).filter((file2) => {
+    const fullPath = path4.join(importsDir, file2);
+    return fs4.statSync(fullPath).isFile();
+  });
+}
+function checkPendingFiles(directory, pendingBasePath) {
+  const pendingDir = path4.join(directory, pendingBasePath);
+  const pendingFiles = [];
+  if (!fs4.existsSync(pendingDir)) {
+    return [];
+  }
+  const providers = fs4.readdirSync(pendingDir);
+  for (const provider of providers) {
+    const providerPath = path4.join(pendingDir, provider);
+    if (!fs4.statSync(providerPath).isDirectory())
+      continue;
+    const currencies = fs4.readdirSync(providerPath);
+    for (const currency of currencies) {
+      const currencyPath = path4.join(providerPath, currency);
+      if (!fs4.statSync(currencyPath).isDirectory())
+        continue;
+      const files = fs4.readdirSync(currencyPath).filter((f) => f.toLowerCase().endsWith(".csv"));
+      for (const file2 of files) {
+        pendingFiles.push({
+          provider,
+          currency,
+          filename: file2,
+          path: path4.join(currencyPath, file2)
+        });
+      }
+    }
+  }
+  return pendingFiles;
+}
+function ensureDirectory(dirPath) {
+  if (!fs4.existsSync(dirPath)) {
+    fs4.mkdirSync(dirPath, { recursive: true });
+  }
+}
+async function classifyStatementsCore(directory, agent, configLoader = loadImportConfig) {
+  if (agent !== "accountant") {
+    return JSON.stringify({
+      success: false,
+      error: "This tool is restricted to the accountant agent only.",
+      hint: "Use: Task(subagent_type='accountant', prompt='classify statements')",
+      caller: agent || "main assistant",
+      classified: [],
+      unrecognized: []
+    });
+  }
+  let config2;
+  try {
+    config2 = configLoader(directory);
+  } catch (err) {
+    return JSON.stringify({
+      success: false,
+      error: err instanceof Error ? err.message : String(err),
+      classified: [],
+      unrecognized: []
+    });
+  }
+  const importsDir = path4.join(directory, config2.paths.imports);
+  const pendingDir = path4.join(directory, config2.paths.pending);
+  const unrecognizedDir = path4.join(directory, config2.paths.unrecognized);
+  const pendingFiles = checkPendingFiles(directory, config2.paths.pending);
+  if (pendingFiles.length > 0) {
+    return JSON.stringify({
+      success: false,
+      error: `Found ${pendingFiles.length} pending file(s) that must be processed before classifying new statements.`,
+      pendingFiles,
+      classified: [],
+      unrecognized: []
+    });
+  }
+  const csvFiles = findCSVFiles(importsDir);
+  if (csvFiles.length === 0) {
+    return JSON.stringify({
+      success: true,
+      classified: [],
+      unrecognized: [],
+      message: `No CSV files found in ${config2.paths.imports}`
+    });
+  }
+  const classified = [];
+  const unrecognized = [];
+  for (const filename of csvFiles) {
+    const sourcePath = path4.join(importsDir, filename);
+    const content = fs4.readFileSync(sourcePath, "utf-8");
+    const detection = detectProvider(filename, content, config2);
+    if (detection) {
+      const targetDir = path4.join(pendingDir, detection.provider, detection.currency);
+      ensureDirectory(targetDir);
+      const targetPath = path4.join(targetDir, filename);
+      fs4.renameSync(sourcePath, targetPath);
+      classified.push({
+        filename,
+        provider: detection.provider,
+        currency: detection.currency,
+        targetPath: path4.join(config2.paths.pending, detection.provider, detection.currency, filename)
+      });
+    } else {
+      ensureDirectory(unrecognizedDir);
+      const targetPath = path4.join(unrecognizedDir, filename);
+      fs4.renameSync(sourcePath, targetPath);
+      unrecognized.push({
+        filename,
+        targetPath: path4.join(config2.paths.unrecognized, filename)
+      });
+    }
+  }
+  return JSON.stringify({
+    success: true,
+    classified,
+    unrecognized,
+    summary: {
+      total: csvFiles.length,
+      classified: classified.length,
+      unrecognized: unrecognized.length
+    }
+  });
+}
+var classify_statements_default = tool({
+  description: "ACCOUNTANT AGENT ONLY: Classifies bank statement CSV files from the imports directory by detecting their provider and currency, then moves them to the appropriate pending import directories.",
+  args: {},
+  async execute(_params, context) {
+    const { directory, agent } = context;
+    return classifyStatementsCore(directory, agent);
+  }
+});
 // src/index.ts
 var __dirname2 = dirname(fileURLToPath(import.meta.url));
-var AGENT_FILE = join3(__dirname2, "..", "agent", "accountant.md");
+var AGENT_FILE = join5(__dirname2, "..", "agent", "accountant.md");
 var AccountantPlugin = async () => {
   const agent = loadAgent(AGENT_FILE);
   return {
     tool: {
-      "update-prices": update_prices_default
+      "update-prices": update_prices_default,
+      "classify-statements": classify_statements_default
     },
     config: async (config2) => {
       if (agent) {