@loaders.gl/csv 4.0.0-beta.1 → 4.0.0-beta.3

package/dist/{dist.min.js → dist.dev.js}

@@ -1,77 +1,90 @@
-(() => {
+(function webpackUniversalModuleDefinition(root, factory) {
+  if (typeof exports === 'object' && typeof module === 'object')
+    module.exports = factory();
+  else if (typeof define === 'function' && define.amd) define([], factory);
+        else if (typeof exports === 'object') exports['loader'] = factory();
+  else root['loader'] = factory();})(globalThis, function () {
+"use strict";
+var __exports__ = (() => {
   var __defProp = Object.defineProperty;
-  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
-  var __esm = (fn, res) => function __init() {
-    return fn && (res = (0, fn[Object.keys(fn)[0]])(fn = 0)), res;
-  };
-  var __commonJS = (cb, mod) => function __require() {
-    return mod || (0, cb[Object.keys(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-  };
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
   var __export = (target, all) => {
-    __markAsModule(target);
     for (var name in all)
       __defProp(target, name, { get: all[name], enumerable: true });
   };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/index.ts
+  var src_exports = {};
+  __export(src_exports, {
+    CSVLoader: () => CSVLoader,
+    CSVWriter: () => CSVWriter
+  });
 
   // ../schema/src/lib/table/batches/base-table-batch-aggregator.ts
-  var DEFAULT_ROW_COUNT, BaseTableBatchAggregator;
-  var init_base_table_batch_aggregator = __esm({
-    "../schema/src/lib/table/batches/base-table-batch-aggregator.ts"() {
-      DEFAULT_ROW_COUNT = 100;
-      BaseTableBatchAggregator = class {
-        constructor(schema, options) {
-          this.length = 0;
-          this.rows = null;
-          this.cursor = 0;
-          this._headers = [];
-          this.options = options;
-          this.schema = schema;
-          if (!Array.isArray(schema)) {
-            this._headers = [];
-            for (const key in schema) {
-              this._headers[schema[key].index] = schema[key].name;
-            }
-          }
-        }
-        rowCount() {
-          return this.length;
-        }
-        addArrayRow(row, cursor) {
-          if (Number.isFinite(cursor)) {
-            this.cursor = cursor;
-          }
-          this.rows = this.rows || new Array(DEFAULT_ROW_COUNT);
-          this.rows[this.length] = row;
-          this.length++;
-        }
-        addObjectRow(row, cursor) {
-          if (Number.isFinite(cursor)) {
-            this.cursor = cursor;
-          }
-          this.rows = this.rows || new Array(DEFAULT_ROW_COUNT);
-          this.rows[this.length] = row;
-          this.length++;
-        }
-        getBatch() {
-          let rows = this.rows;
-          if (!rows) {
-            return null;
-          }
-          rows = rows.slice(0, this.length);
-          this.rows = null;
-          const batch = {
-            shape: this.options.shape,
-            batchType: "data",
-            data: rows,
-            length: this.length,
-            schema: this.schema,
-            cursor: this.cursor
-          };
-          return batch;
+  var DEFAULT_ROW_COUNT = 100;
+  var BaseTableBatchAggregator = class {
+    length = 0;
+    rows = null;
+    cursor = 0;
+    _headers = [];
+    constructor(schema, options) {
+      this.options = options;
+      this.schema = schema;
+      if (!Array.isArray(schema)) {
+        this._headers = [];
+        for (const key in schema) {
+          this._headers[schema[key].index] = schema[key].name;
         }
+      }
+    }
+    rowCount() {
+      return this.length;
+    }
+    addArrayRow(row, cursor) {
+      if (Number.isFinite(cursor)) {
+        this.cursor = cursor;
+      }
+      this.rows = this.rows || new Array(DEFAULT_ROW_COUNT);
+      this.rows[this.length] = row;
+      this.length++;
+    }
+    addObjectRow(row, cursor) {
+      if (Number.isFinite(cursor)) {
+        this.cursor = cursor;
+      }
+      this.rows = this.rows || new Array(DEFAULT_ROW_COUNT);
+      this.rows[this.length] = row;
+      this.length++;
+    }
+    getBatch() {
+      let rows = this.rows;
+      if (!rows) {
+        return null;
+      }
+      rows = rows.slice(0, this.length);
+      this.rows = null;
+      const batch = {
+        shape: this.options.shape,
+        batchType: "data",
+        data: rows,
+        length: this.length,
+        schema: this.schema,
+        cursor: this.cursor
       };
+      return batch;
     }
-  });
+  };
 
   // ../schema/src/lib/table/simple-table/row-utils.ts
   function convertToObjectRow(arrayRow, headers) {
@@ -100,306 +113,295 @@
     }
     return arrayRow;
   }
-  var init_row_utils = __esm({
-    "../schema/src/lib/table/simple-table/row-utils.ts"() {
-    }
-  });
 
   // ../schema/src/lib/table/batches/row-table-batch-aggregator.ts
-  var DEFAULT_ROW_COUNT2, RowTableBatchAggregator;
-  var init_row_table_batch_aggregator = __esm({
-    "../schema/src/lib/table/batches/row-table-batch-aggregator.ts"() {
-      init_row_utils();
-      DEFAULT_ROW_COUNT2 = 100;
-      RowTableBatchAggregator = class {
-        constructor(schema, options) {
-          this.length = 0;
-          this.objectRows = null;
-          this.arrayRows = null;
-          this.cursor = 0;
-          this._headers = [];
-          this.options = options;
-          this.schema = schema;
-          if (!Array.isArray(schema)) {
-            this._headers = [];
-            for (const key in schema) {
-              this._headers[schema[key].index] = schema[key].name;
-            }
-          }
-        }
-        rowCount() {
-          return this.length;
-        }
-        addArrayRow(row, cursor) {
-          if (Number.isFinite(cursor)) {
-            this.cursor = cursor;
-          }
-          switch (this.options.shape) {
-            case "object-row-table":
-              const rowObject = convertToObjectRow(row, this._headers);
-              this.addObjectRow(rowObject, cursor);
-              break;
-            case "array-row-table":
-              this.arrayRows = this.arrayRows || new Array(DEFAULT_ROW_COUNT2);
-              this.arrayRows[this.length] = row;
-              this.length++;
-              break;
-          }
-        }
-        addObjectRow(row, cursor) {
-          if (Number.isFinite(cursor)) {
-            this.cursor = cursor;
-          }
-          switch (this.options.shape) {
-            case "array-row-table":
-              const rowArray = convertToArrayRow(row, this._headers);
-              this.addArrayRow(rowArray, cursor);
-              break;
-            case "object-row-table":
-              this.objectRows = this.objectRows || new Array(DEFAULT_ROW_COUNT2);
-              this.objectRows[this.length] = row;
-              this.length++;
-              break;
-          }
-        }
-        getBatch() {
-          let rows = this.arrayRows || this.objectRows;
-          if (!rows) {
-            return null;
-          }
-          rows = rows.slice(0, this.length);
-          this.arrayRows = null;
-          this.objectRows = null;
-          return {
-            shape: this.options.shape,
-            batchType: "data",
-            data: rows,
-            length: this.length,
-            schema: this.schema,
-            cursor: this.cursor
-          };
+  var DEFAULT_ROW_COUNT2 = 100;
+  var RowTableBatchAggregator = class {
+    length = 0;
+    objectRows = null;
+    arrayRows = null;
+    cursor = 0;
+    _headers = [];
+    constructor(schema, options) {
+      this.options = options;
+      this.schema = schema;
+      if (!Array.isArray(schema)) {
+        this._headers = [];
+        for (const key in schema) {
+          this._headers[schema[key].index] = schema[key].name;
         }
+      }
+    }
+    rowCount() {
+      return this.length;
+    }
+    addArrayRow(row, cursor) {
+      if (Number.isFinite(cursor)) {
+        this.cursor = cursor;
+      }
+      switch (this.options.shape) {
+        case "object-row-table":
+          const rowObject = convertToObjectRow(row, this._headers);
+          this.addObjectRow(rowObject, cursor);
+          break;
+        case "array-row-table":
+          this.arrayRows = this.arrayRows || new Array(DEFAULT_ROW_COUNT2);
+          this.arrayRows[this.length] = row;
+          this.length++;
+          break;
+      }
+    }
+    addObjectRow(row, cursor) {
+      if (Number.isFinite(cursor)) {
+        this.cursor = cursor;
+      }
+      switch (this.options.shape) {
+        case "array-row-table":
+          const rowArray = convertToArrayRow(row, this._headers);
+          this.addArrayRow(rowArray, cursor);
+          break;
+        case "object-row-table":
+          this.objectRows = this.objectRows || new Array(DEFAULT_ROW_COUNT2);
+          this.objectRows[this.length] = row;
+          this.length++;
+          break;
+      }
+    }
+    getBatch() {
+      let rows = this.arrayRows || this.objectRows;
+      if (!rows) {
+        return null;
+      }
+      rows = rows.slice(0, this.length);
+      this.arrayRows = null;
+      this.objectRows = null;
+      return {
+        shape: this.options.shape,
+        batchType: "data",
+        data: rows,
+        length: this.length,
+        schema: this.schema,
+        cursor: this.cursor
       };
     }
-  });
+  };
 
   // ../schema/src/lib/table/batches/columnar-table-batch-aggregator.ts
-  var DEFAULT_ROW_COUNT3, ColumnarTableBatchAggregator;
-  var init_columnar_table_batch_aggregator = __esm({
-    "../schema/src/lib/table/batches/columnar-table-batch-aggregator.ts"() {
-      DEFAULT_ROW_COUNT3 = 100;
-      ColumnarTableBatchAggregator = class {
-        constructor(schema, options) {
-          this.length = 0;
-          this.allocated = 0;
-          this.columns = {};
-          this.schema = schema;
-          this._reallocateColumns();
-        }
-        rowCount() {
-          return this.length;
-        }
-        addArrayRow(row) {
-          this._reallocateColumns();
-          let i = 0;
-          for (const fieldName in this.columns) {
-            this.columns[fieldName][this.length] = row[i++];
-          }
-          this.length++;
-        }
-        addObjectRow(row) {
-          this._reallocateColumns();
-          for (const fieldName in row) {
-            this.columns[fieldName][this.length] = row[fieldName];
-          }
-          this.length++;
-        }
-        getBatch() {
-          this._pruneColumns();
-          const columns = Array.isArray(this.schema) ? this.columns : {};
-          if (!Array.isArray(this.schema)) {
-            for (const fieldName in this.schema) {
-              const field = this.schema[fieldName];
-              columns[field.name] = this.columns[field.index];
-            }
-          }
-          this.columns = {};
-          const batch = {
-            shape: "columnar-table",
-            batchType: "data",
-            data: columns,
-            schema: this.schema,
-            length: this.length
-          };
-          return batch;
-        }
-        _reallocateColumns() {
-          if (this.length < this.allocated) {
-            return;
-          }
-          this.allocated = this.allocated > 0 ? this.allocated *= 2 : DEFAULT_ROW_COUNT3;
-          this.columns = {};
-          for (const fieldName in this.schema) {
-            const field = this.schema[fieldName];
-            const ArrayType = field.type || Float32Array;
-            const oldColumn = this.columns[field.index];
-            if (oldColumn && ArrayBuffer.isView(oldColumn)) {
-              const typedArray = new ArrayType(this.allocated);
-              typedArray.set(oldColumn);
-              this.columns[field.index] = typedArray;
-            } else if (oldColumn) {
-              oldColumn.length = this.allocated;
-              this.columns[field.index] = oldColumn;
-            } else {
-              this.columns[field.index] = new ArrayType(this.allocated);
-            }
-          }
-        }
-        _pruneColumns() {
-          for (const [columnName, column] of Object.entries(this.columns)) {
-            this.columns[columnName] = column.slice(0, this.length);
-          }
+  var DEFAULT_ROW_COUNT3 = 100;
+  var ColumnarTableBatchAggregator = class {
+    length = 0;
+    allocated = 0;
+    columns = {};
+    constructor(schema, options) {
+      this.schema = schema;
+      this._reallocateColumns();
+    }
+    rowCount() {
+      return this.length;
+    }
+    addArrayRow(row) {
+      this._reallocateColumns();
+      let i = 0;
+      for (const fieldName in this.columns) {
+        this.columns[fieldName][this.length] = row[i++];
+      }
+      this.length++;
+    }
+    addObjectRow(row) {
+      this._reallocateColumns();
+      for (const fieldName in row) {
+        this.columns[fieldName][this.length] = row[fieldName];
+      }
+      this.length++;
+    }
+    getBatch() {
+      this._pruneColumns();
+      const columns = Array.isArray(this.schema) ? this.columns : {};
+      if (!Array.isArray(this.schema)) {
+        for (const fieldName in this.schema) {
+          const field = this.schema[fieldName];
+          columns[field.name] = this.columns[field.index];
         }
+      }
+      this.columns = {};
+      const batch = {
+        shape: "columnar-table",
+        batchType: "data",
+        data: columns,
+        schema: this.schema,
+        length: this.length
       };
+      return batch;
     }
-  });
+    // HELPERS
+    _reallocateColumns() {
+      if (this.length < this.allocated) {
+        return;
+      }
+      this.allocated = this.allocated > 0 ? this.allocated *= 2 : DEFAULT_ROW_COUNT3;
+      this.columns = {};
+      for (const fieldName in this.schema) {
+        const field = this.schema[fieldName];
+        const ArrayType = field.type || Float32Array;
+        const oldColumn = this.columns[field.index];
+        if (oldColumn && ArrayBuffer.isView(oldColumn)) {
+          const typedArray = new ArrayType(this.allocated);
+          typedArray.set(oldColumn);
+          this.columns[field.index] = typedArray;
+        } else if (oldColumn) {
+          oldColumn.length = this.allocated;
+          this.columns[field.index] = oldColumn;
+        } else {
+          this.columns[field.index] = new ArrayType(this.allocated);
+        }
+      }
+    }
+    _pruneColumns() {
+      for (const [columnName, column] of Object.entries(this.columns)) {
+        this.columns[columnName] = column.slice(0, this.length);
+      }
+    }
+  };
 
   // ../schema/src/lib/table/batches/table-batch-builder.ts
-  var DEFAULT_OPTIONS, ERR_MESSAGE, TableBatchBuilder;
-  var init_table_batch_builder = __esm({
-    "../schema/src/lib/table/batches/table-batch-builder.ts"() {
-      init_base_table_batch_aggregator();
-      init_row_table_batch_aggregator();
-      init_columnar_table_batch_aggregator();
-      DEFAULT_OPTIONS = {
-        shape: "array-row-table",
-        batchSize: "auto",
-        batchDebounceMs: 0,
-        limit: 0,
-        _limitMB: 0
+  var DEFAULT_OPTIONS = {
+    shape: "array-row-table",
+    batchSize: "auto",
+    batchDebounceMs: 0,
+    limit: 0,
+    _limitMB: 0
+  };
+  var ERR_MESSAGE = "TableBatchBuilder";
+  var TableBatchBuilder = class {
+    aggregator = null;
+    batchCount = 0;
+    bytesUsed = 0;
+    isChunkComplete = false;
+    lastBatchEmittedMs = Date.now();
+    totalLength = 0;
+    totalBytes = 0;
+    rowBytes = 0;
+    constructor(schema, options) {
+      this.schema = schema;
+      this.options = {
+        ...DEFAULT_OPTIONS,
+        ...options
       };
-      ERR_MESSAGE = "TableBatchBuilder";
-      TableBatchBuilder = class {
-        constructor(schema, options) {
-          this.aggregator = null;
-          this.batchCount = 0;
-          this.bytesUsed = 0;
-          this.isChunkComplete = false;
-          this.lastBatchEmittedMs = Date.now();
-          this.totalLength = 0;
-          this.totalBytes = 0;
-          this.rowBytes = 0;
-          this.schema = schema;
-          this.options = { ...DEFAULT_OPTIONS, ...options };
-        }
-        limitReached() {
-          if (Boolean(this.options?.limit) && this.totalLength >= this.options.limit) {
-            return true;
-          }
-          if (Boolean(this.options?._limitMB) && this.totalBytes / 1e6 >= this.options._limitMB) {
-            return true;
-          }
+    }
+    limitReached() {
+      if (Boolean(this.options?.limit) && this.totalLength >= this.options.limit) {
+        return true;
+      }
+      if (Boolean(this.options?._limitMB) && this.totalBytes / 1e6 >= this.options._limitMB) {
+        return true;
+      }
+      return false;
+    }
+    /** @deprecated Use addArrayRow or addObjectRow */
+    addRow(row) {
+      if (this.limitReached()) {
+        return;
+      }
+      this.totalLength++;
+      this.rowBytes = this.rowBytes || this._estimateRowMB(row);
+      this.totalBytes += this.rowBytes;
+      if (Array.isArray(row)) {
+        this.addArrayRow(row);
+      } else {
+        this.addObjectRow(row);
+      }
+    }
+    /** Add one row to the batch */
+    addArrayRow(row) {
+      if (!this.aggregator) {
+        const TableBatchType = this._getTableBatchType();
+        this.aggregator = new TableBatchType(this.schema, this.options);
+      }
+      this.aggregator.addArrayRow(row);
+    }
+    /** Add one row to the batch */
+    addObjectRow(row) {
+      if (!this.aggregator) {
+        const TableBatchType = this._getTableBatchType();
+        this.aggregator = new TableBatchType(this.schema, this.options);
+      }
+      this.aggregator.addObjectRow(row);
+    }
+    /** Mark an incoming raw memory chunk has completed */
+    chunkComplete(chunk) {
+      if (chunk instanceof ArrayBuffer) {
+        this.bytesUsed += chunk.byteLength;
+      }
+      if (typeof chunk === "string") {
+        this.bytesUsed += chunk.length;
+      }
+      this.isChunkComplete = true;
+    }
+    getFullBatch(options) {
+      return this._isFull() ? this._getBatch(options) : null;
+    }
+    getFinalBatch(options) {
+      return this._getBatch(options);
+    }
+    // INTERNAL
+    _estimateRowMB(row) {
+      return Array.isArray(row) ? row.length * 8 : Object.keys(row).length * 8;
+    }
+    _isFull() {
+      if (!this.aggregator || this.aggregator.rowCount() === 0) {
+        return false;
+      }
+      if (this.options.batchSize === "auto") {
+        if (!this.isChunkComplete) {
           return false;
         }
-        addRow(row) {
-          if (this.limitReached()) {
-            return;
-          }
-          this.totalLength++;
-          this.rowBytes = this.rowBytes || this._estimateRowMB(row);
-          this.totalBytes += this.rowBytes;
-          if (Array.isArray(row)) {
-            this.addArrayRow(row);
-          } else {
-            this.addObjectRow(row);
-          }
-        }
-        addArrayRow(row) {
-          if (!this.aggregator) {
-            const TableBatchType = this._getTableBatchType();
-            this.aggregator = new TableBatchType(this.schema, this.options);
-          }
-          this.aggregator.addArrayRow(row);
-        }
-        addObjectRow(row) {
-          if (!this.aggregator) {
-            const TableBatchType = this._getTableBatchType();
-            this.aggregator = new TableBatchType(this.schema, this.options);
-          }
-          this.aggregator.addObjectRow(row);
-        }
-        chunkComplete(chunk) {
-          if (chunk instanceof ArrayBuffer) {
-            this.bytesUsed += chunk.byteLength;
-          }
-          if (typeof chunk === "string") {
-            this.bytesUsed += chunk.length;
-          }
-          this.isChunkComplete = true;
-        }
-        getFullBatch(options) {
-          return this._isFull() ? this._getBatch(options) : null;
-        }
-        getFinalBatch(options) {
-          return this._getBatch(options);
-        }
-        _estimateRowMB(row) {
-          return Array.isArray(row) ? row.length * 8 : Object.keys(row).length * 8;
-        }
-        _isFull() {
-          if (!this.aggregator || this.aggregator.rowCount() === 0) {
-            return false;
-          }
-          if (this.options.batchSize === "auto") {
-            if (!this.isChunkComplete) {
-              return false;
-            }
-          } else if (this.options.batchSize > this.aggregator.rowCount()) {
-            return false;
-          }
-          if (this.options.batchDebounceMs > Date.now() - this.lastBatchEmittedMs) {
-            return false;
-          }
-          this.isChunkComplete = false;
-          this.lastBatchEmittedMs = Date.now();
-          return true;
-        }
-        _getBatch(options) {
-          if (!this.aggregator) {
-            return null;
-          }
-          if (options?.bytesUsed) {
-            this.bytesUsed = options.bytesUsed;
-          }
-          const normalizedBatch = this.aggregator.getBatch();
-          normalizedBatch.count = this.batchCount;
-          normalizedBatch.bytesUsed = this.bytesUsed;
-          Object.assign(normalizedBatch, options);
-          this.batchCount++;
-          this.aggregator = null;
-          return normalizedBatch;
-        }
-        _getTableBatchType() {
-          switch (this.options.shape) {
-            case "row-table":
-              return BaseTableBatchAggregator;
-            case "array-row-table":
-            case "object-row-table":
-              return RowTableBatchAggregator;
-            case "columnar-table":
-              return ColumnarTableBatchAggregator;
-            case "arrow-table":
-              if (!TableBatchBuilder.ArrowBatch) {
-                throw new Error(ERR_MESSAGE);
-              }
-              return TableBatchBuilder.ArrowBatch;
-            default:
-              throw new Error(ERR_MESSAGE);
+      } else if (this.options.batchSize > this.aggregator.rowCount()) {
+        return false;
+      }
+      if (this.options.batchDebounceMs > Date.now() - this.lastBatchEmittedMs) {
+        return false;
+      }
+      this.isChunkComplete = false;
+      this.lastBatchEmittedMs = Date.now();
+      return true;
+    }
+    /**
+     * bytesUsed can be set via chunkComplete or via getBatch*
+     */
+    _getBatch(options) {
+      if (!this.aggregator) {
+        return null;
+      }
+      if (options?.bytesUsed) {
+        this.bytesUsed = options.bytesUsed;
+      }
+      const normalizedBatch = this.aggregator.getBatch();
+      normalizedBatch.count = this.batchCount;
+      normalizedBatch.bytesUsed = this.bytesUsed;
+      Object.assign(normalizedBatch, options);
+      this.batchCount++;
+      this.aggregator = null;
+      return normalizedBatch;
+    }
+    _getTableBatchType() {
+      switch (this.options.shape) {
+        case "row-table":
+          return BaseTableBatchAggregator;
+        case "array-row-table":
+        case "object-row-table":
+          return RowTableBatchAggregator;
+        case "columnar-table":
+          return ColumnarTableBatchAggregator;
+        case "arrow-table":
+          if (!TableBatchBuilder.ArrowBatch) {
+            throw new Error(ERR_MESSAGE);
           }
-        }
-      };
+          return TableBatchBuilder.ArrowBatch;
+        default:
+          throw new Error(ERR_MESSAGE);
+      }
     }
-  });
+  };
 
   // ../schema/src/lib/table/simple-table/table-accessors.ts
   function getTableLength(table) {
@@ -501,89 +503,110 @@
       yield getTableRowAsArray(table, rowIndex, target);
     }
   }
-  var init_table_accessors = __esm({
-    "../schema/src/lib/table/simple-table/table-accessors.ts"() {
-    }
-  });
 
   // ../schema/src/lib/utils/async-queue.ts
-  var ArrayQueue, AsyncQueue;
-  var init_async_queue = __esm({
-    "../schema/src/lib/utils/async-queue.ts"() {
-      ArrayQueue = class extends Array {
-        enqueue(value) {
-          return this.push(value);
-        }
-        dequeue() {
-          return this.shift();
-        }
-      };
-      AsyncQueue = class {
-        constructor() {
-          this._values = new ArrayQueue();
-          this._settlers = new ArrayQueue();
-          this._closed = false;
-        }
-        close() {
-          while (this._settlers.length > 0) {
-            this._settlers.dequeue().resolve({ done: true });
-          }
-          this._closed = true;
-        }
-        [Symbol.asyncIterator]() {
-          return this;
-        }
-        enqueue(value) {
-          if (this._closed) {
-            throw new Error("Closed");
-          }
-          if (this._settlers.length > 0) {
-            if (this._values.length > 0) {
-              throw new Error("Illegal internal state");
-            }
-            const settler = this._settlers.dequeue();
-            if (value instanceof Error) {
-              settler.reject(value);
-            } else {
-              settler.resolve({ value });
-            }
-          } else {
-            this._values.enqueue(value);
-          }
+  var ArrayQueue = class extends Array {
+    enqueue(value) {
+      return this.push(value);
+    }
+    dequeue() {
+      return this.shift();
+    }
+  };
+  var AsyncQueue = class {
+    constructor() {
+      this._values = new ArrayQueue();
+      this._settlers = new ArrayQueue();
+      this._closed = false;
+    }
+    close() {
+      while (this._settlers.length > 0) {
+        this._settlers.dequeue().resolve({
+          done: true
+        });
+      }
+      this._closed = true;
+    }
+    [Symbol.asyncIterator]() {
+      return this;
+    }
+    enqueue(value) {
+      if (this._closed) {
+        throw new Error("Closed");
+      }
+      if (this._settlers.length > 0) {
+        if (this._values.length > 0) {
+          throw new Error("Illegal internal state");
         }
-        next() {
-          if (this._values.length > 0) {
-            const value = this._values.dequeue();
-            if (value instanceof Error) {
-              return Promise.reject(value);
-            }
-            return Promise.resolve({ value });
-          }
-          if (this._closed) {
-            if (this._settlers.length > 0) {
-              throw new Error("Illegal internal state");
-            }
-            return Promise.resolve({ done: true });
-          }
-          return new Promise((resolve, reject) => {
-            this._settlers.enqueue({ resolve, reject });
+        const settler = this._settlers.dequeue();
+        if (value instanceof Error) {
+          settler.reject(value);
+        } else {
+          settler.resolve({
+            value
           });
         }
-      };
+      } else {
+        this._values.enqueue(value);
+      }
     }
-  });
-
-  // ../schema/src/index.ts
-  var init_src = __esm({
-    "../schema/src/index.ts"() {
-      init_table_batch_builder();
-      init_table_accessors();
-      init_row_utils();
-      init_async_queue();
+    /**
+     * @returns a Promise for an IteratorResult
+     */
+    next() {
+      if (this._values.length > 0) {
+        const value = this._values.dequeue();
+        if (value instanceof Error) {
+          return Promise.reject(value);
+        }
+        return Promise.resolve({
+          value
+        });
+      }
+      if (this._closed) {
+        if (this._settlers.length > 0) {
+          throw new Error("Illegal internal state");
+        }
+        return Promise.resolve({
+          done: true
+        });
+      }
+      return new Promise((resolve, reject) => {
+        this._settlers.enqueue({
+          resolve,
+          reject
+        });
+      });
     }
-  });
+  };
 
   // src/papaparse/papaparse.ts
+  var BYTE_ORDER_MARK = "\uFEFF";
+  var Papa = {
+    parse: CsvToJson,
+    unparse: JsonToCsv,
+    RECORD_SEP: String.fromCharCode(30),
+    UNIT_SEP: String.fromCharCode(31),
+    BYTE_ORDER_MARK,
+    BAD_DELIMITERS: ["\r", "\n", '"', BYTE_ORDER_MARK],
+    WORKERS_SUPPORTED: false,
+    // !IS_WORKER && !!globalThis.Worker
+    NODE_STREAM_INPUT: 1,
+    // Configurable chunk sizes for local and remote files, respectively
+    LocalChunkSize: 1024 * 1024 * 10,
+    // 10 M,
+    RemoteChunkSize: 1024 * 1024 * 5,
+    // 5 M,
+    DefaultDelimiter: ",",
+    // Used if not specified and detection fail,
+    // Exposed for testing and development only
+    Parser,
+    ParserHandle,
+    // BEGIN FORK
+    ChunkStreamer,
+    StringStreamer
+  };
+  var papaparse_default = Papa;
   function CsvToJson(_input, _config, UserDefinedStreamer) {
     _config = _config || {};
     var dynamicTyping = _config.dynamicTyping || false;
@@ -838,6 +861,8 @@
       return this.parseChunk(chunk);
     };
   }
+  StringStreamer.prototype = Object.create(StringStreamer.prototype);
+  StringStreamer.prototype.constructor = StringStreamer;
   function ParserHandle(_config) {
     var FLOAT = /^\s*-?(\d*\.?\d+|\d+\.?\d*)(e[-+]?\d+)?\s*$/i;
     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))/;
@@ -851,6 +876,7 @@
     var _delimiterError;
     var _fields = [];
     var _results = {
+      // The last results returned from the parser
       data: [],
       errors: [],
       meta: {}
@@ -898,7 +924,15 @@
       _parser = new Parser(parserConfig);
       _results = _parser.parse(_input, baseIndex, ignoreLastRow);
       processResults();
-      return _paused ? { meta: { paused: true } } : _results || { meta: { paused: false } };
+      return _paused ? {
+        meta: {
+          paused: true
+        }
+      } : _results || {
+        meta: {
+          paused: false
+        }
+      };
     };
     this.paused = function() {
       return _paused;
@@ -1169,6 +1203,7 @@
                   code: "MissingQuotes",
                   message: "Quoted field unterminated",
                   row: data.length,
+                  // row has yet to be inserted
                   index: cursor
                 });
               }
@@ -1220,6 +1255,7 @@
               code: "InvalidQuotes",
               message: "Trailing quote on quoted field is malformed",
               row: data.length,
+              // row has yet to be inserted
               index: cursor
             });
             quoteSearch++;
@@ -1333,34 +1369,11 @@
   function isFunction(func) {
     return typeof func === "function";
   }
-  var BYTE_ORDER_MARK, Papa, papaparse_default;
-  var init_papaparse = __esm({
-    "src/papaparse/papaparse.ts"() {
-      BYTE_ORDER_MARK = "\uFEFF";
-      Papa = {
-        parse: CsvToJson,
-        unparse: JsonToCsv,
-        RECORD_SEP: String.fromCharCode(30),
-        UNIT_SEP: String.fromCharCode(31),
-        BYTE_ORDER_MARK,
-        BAD_DELIMITERS: ["\r", "\n", '"', BYTE_ORDER_MARK],
-        WORKERS_SUPPORTED: false,
-        NODE_STREAM_INPUT: 1,
-        LocalChunkSize: 1024 * 1024 * 10,
-        RemoteChunkSize: 1024 * 1024 * 5,
-        DefaultDelimiter: ",",
-        Parser,
-        ParserHandle,
-        ChunkStreamer,
-        StringStreamer
-      };
-      papaparse_default = Papa;
-      StringStreamer.prototype = Object.create(StringStreamer.prototype);
-      StringStreamer.prototype.constructor = StringStreamer;
-    }
-  });
 
   // src/papaparse/async-iterator-streamer.ts
+  var {
+    ChunkStreamer: ChunkStreamer2
+  } = papaparse_default;
   function AsyncIteratorStreamer(config) {
     config = config || {};
     ChunkStreamer2.call(this, config);
@@ -1380,29 +1393,65 @@
     this._nextChunk = function nextChunk() {
     };
     this.getStringChunk = function(chunk) {
-      return typeof chunk === "string" ? chunk : this.textDecoder.decode(chunk, { stream: true });
+      return typeof chunk === "string" ? chunk : this.textDecoder.decode(chunk, {
+        stream: true
+      });
     };
   }
-  var ChunkStreamer2;
-  var init_async_iterator_streamer = __esm({
-    "src/papaparse/async-iterator-streamer.ts"() {
-      init_papaparse();
-      ({ ChunkStreamer: ChunkStreamer2 } = papaparse_default);
-      AsyncIteratorStreamer.prototype = Object.create(ChunkStreamer2.prototype);
-      AsyncIteratorStreamer.prototype.constructor = AsyncIteratorStreamer;
-    }
-  });
+  AsyncIteratorStreamer.prototype = Object.create(ChunkStreamer2.prototype);
+  AsyncIteratorStreamer.prototype.constructor = AsyncIteratorStreamer;
 
   // src/csv-loader.ts
+  var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var DEFAULT_CSV_SHAPE = "object-row-table";
+  var CSVLoader = {
+    id: "csv",
+    module: "csv",
+    name: "CSV",
+    version: VERSION,
+    extensions: ["csv", "tsv", "dsv"],
+    mimeTypes: ["text/csv", "text/tab-separated-values", "text/dsv"],
+    category: "table",
+    parse: async (arrayBuffer, options) => parseCSV(new TextDecoder().decode(arrayBuffer), options),
+    parseText: (text, options) => parseCSV(text, options),
+    parseInBatches: parseCSVInBatches,
+    // @ts-ignore
+    // testText: null,
+    options: {
+      csv: {
+        shape: DEFAULT_CSV_SHAPE,
+        // 'object-row-table'
+        optimizeMemoryUsage: false,
+        // CSV options
+        header: "auto",
+        columnPrefix: "column",
+        // delimiter: auto
+        // newline: auto
+        quoteChar: '"',
+        escapeChar: '"',
+        dynamicTyping: true,
+        comments: false,
+        skipEmptyLines: true,
+        // transform: null?
+        delimitersToGuess: [",", "	", "|", ";"]
+        // fastMode: auto
+      }
+    }
+  };
   async function parseCSV(csvText, options) {
-    const csvOptions = { ...CSVLoader.options.csv, ...options?.csv };
+    const csvOptions = {
+      ...CSVLoader.options.csv,
+      ...options?.csv
+    };
     const firstRow = readFirstRow(csvText);
     const header = csvOptions.header === "auto" ? isHeaderRow(firstRow) : Boolean(csvOptions.header);
     const parseWithHeader = header;
     const papaparseConfig = {
+      // dynamicTyping: true,
       ...csvOptions,
       header: parseWithHeader,
       download: false,
+      // We handle loading, no need for papaparse to do it for us
       transformHeader: parseWithHeader ? duplicateColumnTransformer() : void 0,
       error: (e) => {
         throw new Error(e);
@@ -1428,22 +1477,40 @@
     }
   }
   function parseCSVInBatches(asyncIterator, options) {
-    options = { ...options };
+    options = {
+      ...options
+    };
     if (options.batchSize === "auto") {
       options.batchSize = 4e3;
     }
-    const csvOptions = { ...CSVLoader.options.csv, ...options?.csv };
+    const csvOptions = {
+      ...CSVLoader.options.csv,
+      ...options?.csv
+    };
     const asyncQueue = new AsyncQueue();
     let isFirstRow = true;
     let headerRow = null;
     let tableBatchBuilder = null;
     let schema = null;
     const config = {
+      // dynamicTyping: true, // Convert numbers and boolean values in rows from strings,
       ...csvOptions,
       header: false,
+      // Unfortunately, header detection is not automatic and does not infer shapes
       download: false,
+      // We handle loading, no need for papaparse to do it for us
+      // chunkSize is set to 5MB explicitly (same as Papaparse default) due to a bug where the
+      // streaming parser gets stuck if skipEmptyLines and a step callback are both supplied.
+      // See https://github.com/mholt/PapaParse/issues/465
       chunkSize: 1024 * 1024 * 5,
+      // skipEmptyLines is set to a boolean value if supplied. Greedy is set to true
+      // skipEmptyLines is handled manually given two bugs where the streaming parser gets stuck if
+      // both of the skipEmptyLines and step callback options are provided:
+      // - true doesn't work unless chunkSize is set: https://github.com/mholt/PapaParse/issues/465
+      // - greedy doesn't work: https://github.com/mholt/PapaParse/issues/825
       skipEmptyLines: false,
+      // step is called on every row
+      // eslint-disable-next-line complexity, max-statements
       step(results) {
         let row = results.data;
         if (csvOptions.skipEmptyLines) {
@@ -1471,13 +1538,19 @@
           row = JSON.parse(JSON.stringify(row));
         }
         const shape = csvOptions.shape || DEFAULT_CSV_SHAPE;
-        tableBatchBuilder = tableBatchBuilder || new TableBatchBuilder(schema, {
-          shape,
-          ...options
-        });
+        tableBatchBuilder = tableBatchBuilder || new TableBatchBuilder(
+          // @ts-expect-error TODO this is not a proper schema
+          schema,
+          {
+            shape,
+            ...options
+          }
+        );
         try {
           tableBatchBuilder.addRow(row);
-          const batch = tableBatchBuilder && tableBatchBuilder.getFullBatch({ bytesUsed });
+          const batch = tableBatchBuilder && tableBatchBuilder.getFullBatch({
+            bytesUsed
+          });
           if (batch) {
             asyncQueue.enqueue(batch);
           }
@@ -1485,10 +1558,13 @@
           asyncQueue.enqueue(error);
         }
       },
+      // complete is called when all rows have been read
       complete(results) {
         try {
           const bytesUsed = results.meta.cursor;
-          const batch = tableBatchBuilder && tableBatchBuilder.getFinalBatch({ bytesUsed });
+          const batch = tableBatchBuilder && tableBatchBuilder.getFinalBatch({
+            bytesUsed
+          });
           if (batch) {
             asyncQueue.enqueue(batch);
           }
@@ -1513,7 +1589,7 @@
     return result.data[0];
   }
   function duplicateColumnTransformer() {
-    const observedColumns = new Set();
+    const observedColumns = /* @__PURE__ */ new Set();
     return (col) => {
       let colName = col;
       let counter = 1;
@@ -1540,53 +1616,30 @@
       switch (typeof value) {
         case "number":
         case "boolean":
-          schema[columnName] = { name: String(columnName), index: i, type: Float32Array };
+          schema[columnName] = {
+            name: String(columnName),
+            index: i,
+            type: Float32Array
+          };
           break;
         case "string":
         default:
-          schema[columnName] = { name: String(columnName), index: i, type: Array };
+          schema[columnName] = {
+            name: String(columnName),
+            index: i,
+            type: Array
+          };
       }
     }
     return schema;
   }
-  var VERSION, DEFAULT_CSV_SHAPE, CSVLoader;
-  var init_csv_loader = __esm({
-    "src/csv-loader.ts"() {
-      init_src();
-      init_papaparse();
-      init_async_iterator_streamer();
-      VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
-      DEFAULT_CSV_SHAPE = "object-row-table";
-      CSVLoader = {
-        id: "csv",
-        module: "csv",
-        name: "CSV",
-        version: VERSION,
-        extensions: ["csv", "tsv", "dsv"],
-        mimeTypes: ["text/csv", "text/tab-separated-values", "text/dsv"],
-        category: "table",
-        parse: async (arrayBuffer, options) => parseCSV(new TextDecoder().decode(arrayBuffer), options),
-        parseText: (text, options) => parseCSV(text, options),
-        parseInBatches: parseCSVInBatches,
-        options: {
-          csv: {
-            shape: DEFAULT_CSV_SHAPE,
-            optimizeMemoryUsage: false,
-            header: "auto",
-            columnPrefix: "column",
-            quoteChar: '"',
-            escapeChar: '"',
-            dynamicTyping: true,
-            comments: false,
-            skipEmptyLines: true,
-            delimitersToGuess: [",", "	", "|", ";"]
-          }
-        }
-      };
-    }
-  });
 
   // ../../node_modules/d3-dsv/src/dsv.js
+  var EOL = {};
+  var EOF = {};
+  var QUOTE = 34;
+  var NEWLINE = 10;
+  var RETURN = 13;
   function objectConverter(columns) {
     return new Function("d", "return {" + columns.map(function(name, i) {
       return JSON.stringify(name) + ": d[" + i + '] || ""';
@@ -1599,7 +1652,7 @@
     };
   }
   function inferColumns(rows) {
-    var columnSet = Object.create(null), columns = [];
+    var columnSet = /* @__PURE__ */ Object.create(null), columns = [];
     rows.forEach(function(row) {
       for (var column in row) {
         if (!(column in columnSet)) {
@@ -1716,42 +1769,23 @@
       formatValue
     };
   }
-  var EOL, EOF, QUOTE, NEWLINE, RETURN;
-  var init_dsv = __esm({
-    "../../node_modules/d3-dsv/src/dsv.js"() {
-      EOL = {};
-      EOF = {};
-      QUOTE = 34;
-      NEWLINE = 10;
-      RETURN = 13;
-    }
-  });
 
   // ../../node_modules/d3-dsv/src/csv.js
-  var csv, csvParse, csvParseRows, csvFormat, csvFormatBody, csvFormatRows, csvFormatRow, csvFormatValue;
-  var init_csv = __esm({
-    "../../node_modules/d3-dsv/src/csv.js"() {
-      init_dsv();
-      csv = dsv_default(",");
-      csvParse = csv.parse;
-      csvParseRows = csv.parseRows;
-      csvFormat = csv.format;
-      csvFormatBody = csv.formatBody;
-      csvFormatRows = csv.formatRows;
-      csvFormatRow = csv.formatRow;
-      csvFormatValue = csv.formatValue;
-    }
-  });
-
-  // ../../node_modules/d3-dsv/src/index.js
-  var init_src2 = __esm({
-    "../../node_modules/d3-dsv/src/index.js"() {
-      init_csv();
-    }
-  });
+  var csv = dsv_default(",");
+  var csvParse = csv.parse;
+  var csvParseRows = csv.parseRows;
+  var csvFormat = csv.format;
+  var csvFormatBody = csv.formatBody;
+  var csvFormatRows = csv.formatRows;
+  var csvFormatRow = csv.formatRow;
+  var csvFormatValue = csv.formatValue;
 
   // src/lib/encoders/encode-csv.ts
-  function encodeTableAsCSV(table, options = { csv: { useDisplayNames: true } }) {
+  function encodeTableAsCSV(table, options = {
+    csv: {
+      useDisplayNames: true
+    }
+  }) {
     const useDisplayNames = options.useDisplayNames || options.csv?.useDisplayNames;
     const fields = table.schema?.fields || [];
     const columnNames = fields.map((f) => {
@@ -1769,73 +1803,39 @@
     }
     return csvFormatRows(formattedData);
   }
-  var preformatFieldValue;
-  var init_encode_csv = __esm({
-    "src/lib/encoders/encode-csv.ts"() {
-      init_src();
-      init_src2();
-      preformatFieldValue = (value) => {
-        if (value === null || value === void 0) {
-          return null;
-        }
-        if (value instanceof Date) {
-          return value.toISOString();
-        }
-        if (typeof value === "object") {
-          return JSON.stringify(value);
-        }
-        return String(value);
-      };
+  var preformatFieldValue = (value) => {
+    if (value === null || value === void 0) {
+      return null;
     }
-  });
-
-  // src/csv-writer.ts
-  var CSVWriter;
-  var init_csv_writer = __esm({
-    "src/csv-writer.ts"() {
-      init_encode_csv();
-      CSVWriter = {
-        id: "csv",
-        version: "latest",
-        module: "csv",
-        name: "CSV",
-        extensions: ["csv"],
-        mimeTypes: ["text/csv"],
-        options: {
-          csv: {
-            useDisplayNames: false
-          },
-          useDisplayNames: false
-        },
-        text: true,
-        encode: async (table, options) => new TextEncoder().encode(encodeTableAsCSV(table, options)).buffer,
-        encodeTextSync: (table, options) => encodeTableAsCSV(table, options)
-      };
+    if (value instanceof Date) {
+      return value.toISOString();
     }
-  });
-
-  // src/index.ts
-  var src_exports = {};
-  __export(src_exports, {
-    CSVLoader: () => CSVLoader,
-    CSVWriter: () => CSVWriter
-  });
-  var init_src3 = __esm({
-    "src/index.ts"() {
-      init_csv_loader();
-      init_csv_writer();
+    if (typeof value === "object") {
+      return JSON.stringify(value);
     }
-  });
+    return String(value);
+  };
 
-  // src/bundle.ts
-  var require_bundle = __commonJS({
-    "src/bundle.ts"(exports, module) {
-      var moduleExports = (init_src3(), src_exports);
-      globalThis.loaders = globalThis.loaders || {};
-      module.exports = Object.assign(globalThis.loaders, moduleExports);
-    }
-  });
-  require_bundle();
+  // src/csv-writer.ts
+  var CSVWriter = {
+    id: "csv",
+    version: "latest",
+    module: "csv",
+    name: "CSV",
+    extensions: ["csv"],
+    mimeTypes: ["text/csv"],
+    options: {
+      csv: {
+        useDisplayNames: false
+      },
+      /** @deprecated use csv.displayNames */
+      useDisplayNames: false
+    },
+    text: true,
+    encode: async (table, options) => new TextEncoder().encode(encodeTableAsCSV(table, options)).buffer,
+    encodeTextSync: (table, options) => encodeTableAsCSV(table, options)
+  };
+  return __toCommonJS(src_exports);
 })();
 /* @license
 Papa Parse
@@ -1843,3 +1843,5 @@ v5.0.0-beta.0
 https://github.com/mholt/PapaParse
 License: MIT
 */
+      return __exports__;
+      });