@loaders.gl/json 4.0.0-beta.2 → 4.0.0-beta.4

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

@@ -1,77 +1,97 @@
-(() => {
+(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, {
+    JSONLoader: () => JSONLoader,
+    JSONWriter: () => JSONWriter,
+    NDJSONLoader: () => NDJSONLoader,
+    _ClarinetParser: () => ClarinetParser,
+    _GeoJSONLoader: () => GeoJSONLoader,
+    _GeoJSONWorkerLoader: () => GeoJSONWorkerLoader,
+    _GeoJSONWriter: () => GeoJSONWriter,
+    _JSONPath: () => JSONPath,
+    _rebuildJsonObject: () => rebuildJsonObject
+  });
 
   // ../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 +120,286 @@
     }
     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;
     }
-  });
+    _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;
+    }
+    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;
         }
-        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;
     }
-  });
+    _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) {
@@ -568,10 +568,6 @@
       yield getTableRowAsObject(table, rowIndex, target);
     }
   }
-  var init_table_accessors = __esm({
-    "../schema/src/lib/table/simple-table/table-accessors.ts"() {
-    }
-  });
 
   // ../schema/src/lib/table/simple-table/data-type.ts
   function getDataTypeFromValue(value, defaultNumberType = "float32") {
@@ -592,13 +588,22 @@
   function getDataTypeFromArray(array) {
     let type = getDataTypeFromTypedArray(array);
     if (type !== "null") {
-      return { type, nullable: false };
+      return {
+        type,
+        nullable: false
+      };
     }
     if (array.length > 0) {
       type = getDataTypeFromValue(array[0]);
-      return { type, nullable: true };
+      return {
+        type,
+        nullable: true
+      };
     }
-    return { type: "null", nullable: true };
+    return {
+      type: "null",
+      nullable: true
+    };
   }
   function getDataTypeFromTypedArray(array) {
     switch (array.constructor) {
@@ -623,10 +628,6 @@
         return "null";
     }
   }
-  var init_data_type = __esm({
-    "../schema/src/lib/table/simple-table/data-type.ts"() {
-    }
-  });
 
   // ../schema/src/lib/table/simple-table/table-schema.ts
   function deduceTableSchema(table) {
@@ -647,7 +648,10 @@
       const field = deduceFieldFromColumn(column, columnName);
       fields.push(field);
     }
-    return { fields, metadata: {} };
+    return {
+      fields,
+      metadata: {}
+    };
   }
   function deduceSchemaFromRows(rowTable) {
     if (!rowTable.length) {
@@ -658,7 +662,10 @@
     for (const [columnName, value] of Object.entries(row0)) {
       fields.push(deduceFieldFromValue(value, columnName));
     }
-    return { fields, metadata: {} };
+    return {
+      fields,
+      metadata: {}
+    };
   }
   function deduceFieldFromColumn(column, name) {
     if (ArrayBuffer.isView(column)) {
@@ -688,30 +695,37 @@
       nullable: true
     };
   }
-  var init_table_schema = __esm({
-    "../schema/src/lib/table/simple-table/table-schema.ts"() {
-      init_data_type();
-    }
-  });
 
   // ../schema/src/lib/table/simple-table/make-table.ts
   function makeTableFromData(data) {
     let table;
     switch (getTableShapeFromData(data)) {
       case "array-row-table":
-        table = { shape: "array-row-table", data };
+        table = {
+          shape: "array-row-table",
+          data
+        };
         break;
       case "object-row-table":
-        table = { shape: "object-row-table", data };
+        table = {
+          shape: "object-row-table",
+          data
+        };
         break;
       case "columnar-table":
-        table = { shape: "columnar-table", data };
+        table = {
+          shape: "columnar-table",
+          data
+        };
         break;
       default:
         throw new Error("table");
     }
     const schema = deduceTableSchema(table);
-    return { ...table, schema };
+    return {
+      ...table,
+      schema
+    };
   }
   function getTableShapeFromData(data) {
     if (Array.isArray(data)) {
@@ -731,20 +745,6 @@
     }
     throw new Error("invalid table");
   }
-  var init_make_table = __esm({
-    "../schema/src/lib/table/simple-table/make-table.ts"() {
-      init_table_schema();
-    }
-  });
-
-  // ../schema/src/index.ts
-  var init_src = __esm({
-    "../schema/src/index.ts"() {
-      init_table_batch_builder();
-      init_table_accessors();
-      init_make_table();
-    }
-  });
 
   // src/lib/parsers/parse-json.ts
   function parseJSONSync(jsonText, options) {
@@ -773,11 +773,6 @@
     }
     return null;
   }
-  var init_parse_json = __esm({
-    "src/lib/parsers/parse-json.ts"() {
-      init_src();
-    }
-  });
 
   // ../loader-utils/src/lib/env-utils/assert.ts
   function assert(condition, message) {
@@ -785,16 +780,14 @@
       throw new Error(message || "loader assertion failed.");
     }
   }
-  var init_assert = __esm({
-    "../loader-utils/src/lib/env-utils/assert.ts"() {
-    }
-  });
 
   // ../loader-utils/src/lib/iterators/text-iterators.ts
   async function* makeTextDecoderIterator(arrayBufferIterator, options = {}) {
     const textDecoder = new TextDecoder(void 0, options);
     for await (const arrayBuffer of arrayBufferIterator) {
-      yield typeof arrayBuffer === "string" ? arrayBuffer : textDecoder.decode(arrayBuffer, { stream: true });
+      yield typeof arrayBuffer === "string" ? arrayBuffer : textDecoder.decode(arrayBuffer, {
+        stream: true
+      });
     }
   }
   async function* makeLineIterator(textIterator) {
@@ -815,791 +808,801 @@
   async function* makeNumberedLineIterator(lineIterator) {
     let counter = 1;
     for await (const line of lineIterator) {
-      yield { counter, line };
+      yield {
+        counter,
+        line
+      };
       counter++;
     }
   }
-  var init_text_iterators = __esm({
-    "../loader-utils/src/lib/iterators/text-iterators.ts"() {
-    }
-  });
 
   // ../../node_modules/@babel/runtime/helpers/esm/typeof.js
-  var init_typeof = __esm({
-    "../../node_modules/@babel/runtime/helpers/esm/typeof.js"() {
-    }
-  });
+  function _typeof(obj) {
+    "@babel/helpers - typeof";
+    return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
+      return typeof obj2;
+    } : function(obj2) {
+      return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+    }, _typeof(obj);
+  }
 
   // ../../node_modules/@babel/runtime/helpers/esm/toPrimitive.js
-  var init_toPrimitive = __esm({
-    "../../node_modules/@babel/runtime/helpers/esm/toPrimitive.js"() {
-      init_typeof();
-    }
-  });
+  function _toPrimitive(input, hint) {
+    if (_typeof(input) !== "object" || input === null)
+      return input;
+    var prim = input[Symbol.toPrimitive];
+    if (prim !== void 0) {
+      var res = prim.call(input, hint || "default");
+      if (_typeof(res) !== "object")
+        return res;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return (hint === "string" ? String : Number)(input);
+  }
 
   // ../../node_modules/@babel/runtime/helpers/esm/toPropertyKey.js
-  var init_toPropertyKey = __esm({
-    "../../node_modules/@babel/runtime/helpers/esm/toPropertyKey.js"() {
-      init_typeof();
-      init_toPrimitive();
-    }
-  });
+  function _toPropertyKey(arg) {
+    var key = _toPrimitive(arg, "string");
+    return _typeof(key) === "symbol" ? key : String(key);
+  }
 
   // ../../node_modules/@babel/runtime/helpers/esm/defineProperty.js
-  var init_defineProperty = __esm({
-    "../../node_modules/@babel/runtime/helpers/esm/defineProperty.js"() {
-      init_toPropertyKey();
-    }
-  });
-
-  // ../loader-utils/src/index.ts
-  var init_src2 = __esm({
-    "../loader-utils/src/index.ts"() {
-      init_assert();
-      init_text_iterators();
+  function _defineProperty(obj, key, value) {
+    key = _toPropertyKey(key);
+    if (key in obj) {
+      Object.defineProperty(obj, key, {
+        value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    } else {
+      obj[key] = value;
     }
-  });
+    return obj;
+  }
 
   // src/lib/clarinet/clarinet.ts
-  function isWhitespace(c) {
-    return c === Char.carriageReturn || c === Char.lineFeed || c === Char.space || c === Char.tab;
-  }
-  function checkBufferLength(parser) {
-    const maxAllowed = Math.max(MAX_BUFFER_LENGTH, 10);
-    let maxActual = 0;
-    for (const buffer of ["textNode", "numberNode"]) {
-      const len = parser[buffer] === void 0 ? 0 : parser[buffer].length;
-      if (len > maxAllowed) {
-        switch (buffer) {
-          case "text":
-            break;
-          default:
-            parser._error(`Max buffer length exceeded: ${buffer}`);
-        }
-      }
-      maxActual = Math.max(maxActual, len);
+  var MAX_BUFFER_LENGTH = Number.MAX_SAFE_INTEGER;
+  var STATE = function(STATE2) {
+    STATE2[STATE2["BEGIN"] = 0] = "BEGIN";
+    STATE2[STATE2["VALUE"] = 1] = "VALUE";
+    STATE2[STATE2["OPEN_OBJECT"] = 2] = "OPEN_OBJECT";
+    STATE2[STATE2["CLOSE_OBJECT"] = 3] = "CLOSE_OBJECT";
+    STATE2[STATE2["OPEN_ARRAY"] = 4] = "OPEN_ARRAY";
+    STATE2[STATE2["CLOSE_ARRAY"] = 5] = "CLOSE_ARRAY";
+    STATE2[STATE2["TEXT_ESCAPE"] = 6] = "TEXT_ESCAPE";
+    STATE2[STATE2["STRING"] = 7] = "STRING";
+    STATE2[STATE2["BACKSLASH"] = 8] = "BACKSLASH";
+    STATE2[STATE2["END"] = 9] = "END";
+    STATE2[STATE2["OPEN_KEY"] = 10] = "OPEN_KEY";
+    STATE2[STATE2["CLOSE_KEY"] = 11] = "CLOSE_KEY";
+    STATE2[STATE2["TRUE"] = 12] = "TRUE";
+    STATE2[STATE2["TRUE2"] = 13] = "TRUE2";
+    STATE2[STATE2["TRUE3"] = 14] = "TRUE3";
+    STATE2[STATE2["FALSE"] = 15] = "FALSE";
+    STATE2[STATE2["FALSE2"] = 16] = "FALSE2";
+    STATE2[STATE2["FALSE3"] = 17] = "FALSE3";
+    STATE2[STATE2["FALSE4"] = 18] = "FALSE4";
+    STATE2[STATE2["NULL"] = 19] = "NULL";
+    STATE2[STATE2["NULL2"] = 20] = "NULL2";
+    STATE2[STATE2["NULL3"] = 21] = "NULL3";
+    STATE2[STATE2["NUMBER_DECIMAL_POINT"] = 22] = "NUMBER_DECIMAL_POINT";
+    STATE2[STATE2["NUMBER_DIGIT"] = 23] = "NUMBER_DIGIT";
+    return STATE2;
+  }(STATE || {});
+  var Char = {
+    tab: 9,
+    lineFeed: 10,
+    carriageReturn: 13,
+    space: 32,
+    doubleQuote: 34,
+    plus: 43,
+    comma: 44,
+    minus: 45,
+    period: 46,
+    _0: 48,
+    _9: 57,
+    colon: 58,
+    E: 69,
+    openBracket: 91,
+    backslash: 92,
+    closeBracket: 93,
+    a: 97,
+    b: 98,
+    e: 101,
+    f: 102,
+    l: 108,
+    n: 110,
+    r: 114,
+    s: 115,
+    t: 116,
+    u: 117,
+    openBrace: 123,
+    closeBrace: 125
+  };
+  var stringTokenPattern = /[\\"\n]/g;
+  var DEFAULT_OPTIONS2 = {
+    onready: () => {
+    },
+    onopenobject: () => {
+    },
+    onkey: () => {
+    },
+    oncloseobject: () => {
+    },
+    onopenarray: () => {
+    },
+    onclosearray: () => {
+    },
+    onvalue: () => {
+    },
+    onerror: () => {
+    },
+    onend: () => {
+    },
+    onchunkparsed: () => {
     }
-    parser.bufferCheckPosition = MAX_BUFFER_LENGTH - maxActual + parser.position;
-  }
-  var MAX_BUFFER_LENGTH, STATE, Char, stringTokenPattern, DEFAULT_OPTIONS2, ClarinetParser;
-  var init_clarinet = __esm({
-    "src/lib/clarinet/clarinet.ts"() {
-      MAX_BUFFER_LENGTH = Number.MAX_SAFE_INTEGER;
-      (function(STATE2) {
-        STATE2[STATE2["BEGIN"] = 0] = "BEGIN";
-        STATE2[STATE2["VALUE"] = 1] = "VALUE";
-        STATE2[STATE2["OPEN_OBJECT"] = 2] = "OPEN_OBJECT";
-        STATE2[STATE2["CLOSE_OBJECT"] = 3] = "CLOSE_OBJECT";
-        STATE2[STATE2["OPEN_ARRAY"] = 4] = "OPEN_ARRAY";
-        STATE2[STATE2["CLOSE_ARRAY"] = 5] = "CLOSE_ARRAY";
-        STATE2[STATE2["TEXT_ESCAPE"] = 6] = "TEXT_ESCAPE";
-        STATE2[STATE2["STRING"] = 7] = "STRING";
-        STATE2[STATE2["BACKSLASH"] = 8] = "BACKSLASH";
-        STATE2[STATE2["END"] = 9] = "END";
-        STATE2[STATE2["OPEN_KEY"] = 10] = "OPEN_KEY";
-        STATE2[STATE2["CLOSE_KEY"] = 11] = "CLOSE_KEY";
-        STATE2[STATE2["TRUE"] = 12] = "TRUE";
-        STATE2[STATE2["TRUE2"] = 13] = "TRUE2";
-        STATE2[STATE2["TRUE3"] = 14] = "TRUE3";
-        STATE2[STATE2["FALSE"] = 15] = "FALSE";
-        STATE2[STATE2["FALSE2"] = 16] = "FALSE2";
-        STATE2[STATE2["FALSE3"] = 17] = "FALSE3";
-        STATE2[STATE2["FALSE4"] = 18] = "FALSE4";
-        STATE2[STATE2["NULL"] = 19] = "NULL";
-        STATE2[STATE2["NULL2"] = 20] = "NULL2";
-        STATE2[STATE2["NULL3"] = 21] = "NULL3";
-        STATE2[STATE2["NUMBER_DECIMAL_POINT"] = 22] = "NUMBER_DECIMAL_POINT";
-        STATE2[STATE2["NUMBER_DIGIT"] = 23] = "NUMBER_DIGIT";
-      })(STATE || (STATE = {}));
-      Char = {
-        tab: 9,
-        lineFeed: 10,
-        carriageReturn: 13,
-        space: 32,
-        doubleQuote: 34,
-        plus: 43,
-        comma: 44,
-        minus: 45,
-        period: 46,
-        _0: 48,
-        _9: 57,
-        colon: 58,
-        E: 69,
-        openBracket: 91,
-        backslash: 92,
-        closeBracket: 93,
-        a: 97,
-        b: 98,
-        e: 101,
-        f: 102,
-        l: 108,
-        n: 110,
-        r: 114,
-        s: 115,
-        t: 116,
-        u: 117,
-        openBrace: 123,
-        closeBrace: 125
+  };
+  var ClarinetParser = class {
+    options = DEFAULT_OPTIONS2;
+    bufferCheckPosition = MAX_BUFFER_LENGTH;
+    q = "";
+    c = "";
+    p = "";
+    closed = false;
+    closedRoot = false;
+    sawRoot = false;
+    error = null;
+    state = STATE.BEGIN;
+    stack = [];
+    position = 0;
+    column = 0;
+    line = 1;
+    slashed = false;
+    unicodeI = 0;
+    unicodeS = null;
+    depth = 0;
+    constructor(options = {}) {
+      this.options = {
+        ...DEFAULT_OPTIONS2,
+        ...options
       };
-      stringTokenPattern = /[\\"\n]/g;
-      DEFAULT_OPTIONS2 = {
-        onready: () => {
-        },
-        onopenobject: () => {
-        },
-        onkey: () => {
-        },
-        oncloseobject: () => {
-        },
-        onopenarray: () => {
-        },
-        onclosearray: () => {
-        },
-        onvalue: () => {
-        },
-        onerror: () => {
-        },
-        onend: () => {
-        },
-        onchunkparsed: () => {
+      this.textNode = void 0;
+      this.numberNode = "";
+      this.emit("onready");
+    }
+    end() {
+      if (this.state !== STATE.VALUE || this.depth !== 0)
+        this._error("Unexpected end");
+      this._closeValue();
+      this.c = "";
+      this.closed = true;
+      this.emit("onend");
+      return this;
+    }
+    resume() {
+      this.error = null;
+      return this;
+    }
+    close() {
+      return this.write(null);
+    }
+    emit(event, data) {
+      this.options[event]?.(data, this);
+    }
+    emitNode(event, data) {
+      this._closeValue();
+      this.emit(event, data);
+    }
+    write(chunk) {
+      if (this.error) {
+        throw this.error;
+      }
+      if (this.closed) {
+        return this._error("Cannot write after close. Assign an onready handler.");
+      }
+      if (chunk === null) {
+        return this.end();
+      }
+      let i = 0;
+      let c = chunk.charCodeAt(0);
+      let p = this.p;
+      while (c) {
+        p = c;
+        this.c = c = chunk.charCodeAt(i++);
+        if (p !== c) {
+          this.p = p;
+        } else {
+          p = this.p;
         }
-      };
-      ClarinetParser = class {
-        constructor(options = {}) {
-          this.options = DEFAULT_OPTIONS2;
-          this.bufferCheckPosition = MAX_BUFFER_LENGTH;
-          this.q = "";
-          this.c = "";
-          this.p = "";
-          this.closed = false;
-          this.closedRoot = false;
-          this.sawRoot = false;
-          this.error = null;
-          this.state = 0;
-          this.stack = [];
-          this.position = 0;
+        if (!c)
+          break;
+        this.position++;
+        if (c === Char.lineFeed) {
+          this.line++;
           this.column = 0;
-          this.line = 1;
-          this.slashed = false;
-          this.unicodeI = 0;
-          this.unicodeS = null;
-          this.depth = 0;
-          this.options = { ...DEFAULT_OPTIONS2, ...options };
-          this.textNode = void 0;
-          this.numberNode = "";
-          this.emit("onready");
-        }
-        end() {
-          if (this.state !== 1 || this.depth !== 0)
-            this._error("Unexpected end");
-          this._closeValue();
-          this.c = "";
-          this.closed = true;
-          this.emit("onend");
-          return this;
-        }
-        resume() {
-          this.error = null;
-          return this;
-        }
-        close() {
-          return this.write(null);
-        }
-        emit(event, data) {
-          this.options[event]?.(data, this);
-        }
-        emitNode(event, data) {
-          this._closeValue();
-          this.emit(event, data);
-        }
-        write(chunk) {
-          if (this.error) {
-            throw this.error;
-          }
-          if (this.closed) {
-            return this._error("Cannot write after close. Assign an onready handler.");
-          }
-          if (chunk === null) {
-            return this.end();
-          }
-          let i = 0;
-          let c = chunk.charCodeAt(0);
-          let p = this.p;
-          while (c) {
-            p = c;
-            this.c = c = chunk.charCodeAt(i++);
-            if (p !== c) {
-              this.p = p;
-            } else {
-              p = this.p;
+        } else
+          this.column++;
+        switch (this.state) {
+          case STATE.BEGIN:
+            if (c === Char.openBrace)
+              this.state = STATE.OPEN_OBJECT;
+            else if (c === Char.openBracket)
+              this.state = STATE.OPEN_ARRAY;
+            else if (!isWhitespace(c)) {
+              this._error("Non-whitespace before {[.");
             }
-            if (!c)
-              break;
-            this.position++;
-            if (c === Char.lineFeed) {
-              this.line++;
-              this.column = 0;
+            continue;
+          case STATE.OPEN_KEY:
+          case STATE.OPEN_OBJECT:
+            if (isWhitespace(c))
+              continue;
+            if (this.state === STATE.OPEN_KEY)
+              this.stack.push(STATE.CLOSE_KEY);
+            else if (c === Char.closeBrace) {
+              this.emit("onopenobject");
+              this.depth++;
+              this.emit("oncloseobject");
+              this.depth--;
+              this.state = this.stack.pop() || STATE.VALUE;
+              continue;
             } else
-              this.column++;
-            switch (this.state) {
-              case 0:
-                if (c === Char.openBrace)
-                  this.state = 2;
-                else if (c === Char.openBracket)
-                  this.state = 4;
-                else if (!isWhitespace(c)) {
-                  this._error("Non-whitespace before {[.");
-                }
-                continue;
-              case 10:
-              case 2:
-                if (isWhitespace(c))
-                  continue;
-                if (this.state === 10)
-                  this.stack.push(11);
-                else if (c === Char.closeBrace) {
-                  this.emit("onopenobject");
-                  this.depth++;
-                  this.emit("oncloseobject");
-                  this.depth--;
-                  this.state = this.stack.pop() || 1;
-                  continue;
-                } else
-                  this.stack.push(3);
-                if (c === Char.doubleQuote)
-                  this.state = 7;
-                else
-                  this._error('Malformed object key should start with "');
-                continue;
-              case 11:
-              case 3:
-                if (isWhitespace(c))
-                  continue;
-                if (c === Char.colon) {
-                  if (this.state === 3) {
-                    this.stack.push(3);
-                    this._closeValue("onopenobject");
-                    this.depth++;
-                  } else
-                    this._closeValue("onkey");
-                  this.state = 1;
-                } else if (c === Char.closeBrace) {
-                  this.emitNode("oncloseobject");
-                  this.depth--;
-                  this.state = this.stack.pop() || 1;
-                } else if (c === Char.comma) {
-                  if (this.state === 3)
-                    this.stack.push(3);
-                  this._closeValue();
-                  this.state = 10;
-                } else
-                  this._error("Bad object");
+              this.stack.push(STATE.CLOSE_OBJECT);
+            if (c === Char.doubleQuote)
+              this.state = STATE.STRING;
+            else
+              this._error('Malformed object key should start with "');
+            continue;
+          case STATE.CLOSE_KEY:
+          case STATE.CLOSE_OBJECT:
+            if (isWhitespace(c))
+              continue;
+            if (c === Char.colon) {
+              if (this.state === STATE.CLOSE_OBJECT) {
+                this.stack.push(STATE.CLOSE_OBJECT);
+                this._closeValue("onopenobject");
+                this.depth++;
+              } else
+                this._closeValue("onkey");
+              this.state = STATE.VALUE;
+            } else if (c === Char.closeBrace) {
+              this.emitNode("oncloseobject");
+              this.depth--;
+              this.state = this.stack.pop() || STATE.VALUE;
+            } else if (c === Char.comma) {
+              if (this.state === STATE.CLOSE_OBJECT)
+                this.stack.push(STATE.CLOSE_OBJECT);
+              this._closeValue();
+              this.state = STATE.OPEN_KEY;
+            } else
+              this._error("Bad object");
+            continue;
+          case STATE.OPEN_ARRAY:
+          case STATE.VALUE:
+            if (isWhitespace(c))
+              continue;
+            if (this.state === STATE.OPEN_ARRAY) {
+              this.emit("onopenarray");
+              this.depth++;
+              this.state = STATE.VALUE;
+              if (c === Char.closeBracket) {
+                this.emit("onclosearray");
+                this.depth--;
+                this.state = this.stack.pop() || STATE.VALUE;
                 continue;
-              case 4:
-              case 1:
-                if (isWhitespace(c))
-                  continue;
-                if (this.state === 4) {
-                  this.emit("onopenarray");
-                  this.depth++;
-                  this.state = 1;
-                  if (c === Char.closeBracket) {
-                    this.emit("onclosearray");
-                    this.depth--;
-                    this.state = this.stack.pop() || 1;
-                    continue;
+              } else {
+                this.stack.push(STATE.CLOSE_ARRAY);
+              }
+            }
+            if (c === Char.doubleQuote)
+              this.state = STATE.STRING;
+            else if (c === Char.openBrace)
+              this.state = STATE.OPEN_OBJECT;
+            else if (c === Char.openBracket)
+              this.state = STATE.OPEN_ARRAY;
+            else if (c === Char.t)
+              this.state = STATE.TRUE;
+            else if (c === Char.f)
+              this.state = STATE.FALSE;
+            else if (c === Char.n)
+              this.state = STATE.NULL;
+            else if (c === Char.minus) {
+              this.numberNode += "-";
+            } else if (Char._0 <= c && c <= Char._9) {
+              this.numberNode += String.fromCharCode(c);
+              this.state = STATE.NUMBER_DIGIT;
+            } else
+              this._error("Bad value");
+            continue;
+          case STATE.CLOSE_ARRAY:
+            if (c === Char.comma) {
+              this.stack.push(STATE.CLOSE_ARRAY);
+              this._closeValue("onvalue");
+              this.state = STATE.VALUE;
+            } else if (c === Char.closeBracket) {
+              this.emitNode("onclosearray");
+              this.depth--;
+              this.state = this.stack.pop() || STATE.VALUE;
+            } else if (isWhitespace(c))
+              continue;
+            else
+              this._error("Bad array");
+            continue;
+          case STATE.STRING:
+            if (this.textNode === void 0) {
+              this.textNode = "";
+            }
+            let starti = i - 1;
+            let slashed = this.slashed;
+            let unicodeI = this.unicodeI;
+            STRING_BIGLOOP:
+              while (true) {
+                while (unicodeI > 0) {
+                  this.unicodeS += String.fromCharCode(c);
+                  c = chunk.charCodeAt(i++);
+                  this.position++;
+                  if (unicodeI === 4) {
+                    this.textNode += String.fromCharCode(parseInt(this.unicodeS, 16));
+                    unicodeI = 0;
+                    starti = i - 1;
                   } else {
-                    this.stack.push(5);
+                    unicodeI++;
                   }
+                  if (!c)
+                    break STRING_BIGLOOP;
                 }
-                if (c === Char.doubleQuote)
-                  this.state = 7;
-                else if (c === Char.openBrace)
-                  this.state = 2;
-                else if (c === Char.openBracket)
-                  this.state = 4;
-                else if (c === Char.t)
-                  this.state = 12;
-                else if (c === Char.f)
-                  this.state = 15;
-                else if (c === Char.n)
-                  this.state = 19;
-                else if (c === Char.minus) {
-                  this.numberNode += "-";
-                } else if (Char._0 <= c && c <= Char._9) {
-                  this.numberNode += String.fromCharCode(c);
-                  this.state = 23;
-                } else
-                  this._error("Bad value");
-                continue;
-              case 5:
-                if (c === Char.comma) {
-                  this.stack.push(5);
-                  this._closeValue("onvalue");
-                  this.state = 1;
-                } else if (c === Char.closeBracket) {
-                  this.emitNode("onclosearray");
-                  this.depth--;
-                  this.state = this.stack.pop() || 1;
-                } else if (isWhitespace(c))
-                  continue;
-                else
-                  this._error("Bad array");
-                continue;
-              case 7:
-                if (this.textNode === void 0) {
-                  this.textNode = "";
+                if (c === Char.doubleQuote && !slashed) {
+                  this.state = this.stack.pop() || STATE.VALUE;
+                  this.textNode += chunk.substring(starti, i - 1);
+                  this.position += i - 1 - starti;
+                  break;
+                }
+                if (c === Char.backslash && !slashed) {
+                  slashed = true;
+                  this.textNode += chunk.substring(starti, i - 1);
+                  this.position += i - 1 - starti;
+                  c = chunk.charCodeAt(i++);
+                  this.position++;
+                  if (!c)
+                    break;
                 }
-                let starti = i - 1;
-                let slashed = this.slashed;
-                let unicodeI = this.unicodeI;
-                STRING_BIGLOOP:
-                  while (true) {
-                    while (unicodeI > 0) {
-                      this.unicodeS += String.fromCharCode(c);
-                      c = chunk.charCodeAt(i++);
-                      this.position++;
-                      if (unicodeI === 4) {
-                        this.textNode += String.fromCharCode(parseInt(this.unicodeS, 16));
-                        unicodeI = 0;
-                        starti = i - 1;
-                      } else {
-                        unicodeI++;
-                      }
-                      if (!c)
-                        break STRING_BIGLOOP;
-                    }
-                    if (c === Char.doubleQuote && !slashed) {
-                      this.state = this.stack.pop() || 1;
-                      this.textNode += chunk.substring(starti, i - 1);
-                      this.position += i - 1 - starti;
-                      break;
-                    }
-                    if (c === Char.backslash && !slashed) {
-                      slashed = true;
-                      this.textNode += chunk.substring(starti, i - 1);
-                      this.position += i - 1 - starti;
-                      c = chunk.charCodeAt(i++);
-                      this.position++;
-                      if (!c)
-                        break;
-                    }
-                    if (slashed) {
-                      slashed = false;
-                      if (c === Char.n) {
-                        this.textNode += "\n";
-                      } else if (c === Char.r) {
-                        this.textNode += "\r";
-                      } else if (c === Char.t) {
-                        this.textNode += "	";
-                      } else if (c === Char.f) {
-                        this.textNode += "\f";
-                      } else if (c === Char.b) {
-                        this.textNode += "\b";
-                      } else if (c === Char.u) {
-                        unicodeI = 1;
-                        this.unicodeS = "";
-                      } else {
-                        this.textNode += String.fromCharCode(c);
-                      }
-                      c = chunk.charCodeAt(i++);
-                      this.position++;
-                      starti = i - 1;
-                      if (!c)
-                        break;
-                      else
-                        continue;
-                    }
-                    stringTokenPattern.lastIndex = i;
-                    const reResult = stringTokenPattern.exec(chunk);
-                    if (reResult === null) {
-                      i = chunk.length + 1;
-                      this.textNode += chunk.substring(starti, i - 1);
-                      this.position += i - 1 - starti;
-                      break;
-                    }
-                    i = reResult.index + 1;
-                    c = chunk.charCodeAt(reResult.index);
-                    if (!c) {
-                      this.textNode += chunk.substring(starti, i - 1);
-                      this.position += i - 1 - starti;
-                      break;
-                    }
+                if (slashed) {
+                  slashed = false;
+                  if (c === Char.n) {
+                    this.textNode += "\n";
+                  } else if (c === Char.r) {
+                    this.textNode += "\r";
+                  } else if (c === Char.t) {
+                    this.textNode += "	";
+                  } else if (c === Char.f) {
+                    this.textNode += "\f";
+                  } else if (c === Char.b) {
+                    this.textNode += "\b";
+                  } else if (c === Char.u) {
+                    unicodeI = 1;
+                    this.unicodeS = "";
+                  } else {
+                    this.textNode += String.fromCharCode(c);
                   }
-                this.slashed = slashed;
-                this.unicodeI = unicodeI;
-                continue;
-              case 12:
-                if (c === Char.r)
-                  this.state = 13;
-                else
-                  this._error(`Invalid true started with t${c}`);
-                continue;
-              case 13:
-                if (c === Char.u)
-                  this.state = 14;
-                else
-                  this._error(`Invalid true started with tr${c}`);
-                continue;
-              case 14:
-                if (c === Char.e) {
-                  this.emit("onvalue", true);
-                  this.state = this.stack.pop() || 1;
-                } else
-                  this._error(`Invalid true started with tru${c}`);
-                continue;
-              case 15:
-                if (c === Char.a)
-                  this.state = 16;
-                else
-                  this._error(`Invalid false started with f${c}`);
-                continue;
-              case 16:
-                if (c === Char.l)
-                  this.state = 17;
-                else
-                  this._error(`Invalid false started with fa${c}`);
-                continue;
-              case 17:
-                if (c === Char.s)
-                  this.state = 18;
-                else
-                  this._error(`Invalid false started with fal${c}`);
-                continue;
-              case 18:
-                if (c === Char.e) {
-                  this.emit("onvalue", false);
-                  this.state = this.stack.pop() || 1;
-                } else
-                  this._error(`Invalid false started with fals${c}`);
-                continue;
-              case 19:
-                if (c === Char.u)
-                  this.state = 20;
-                else
-                  this._error(`Invalid null started with n${c}`);
-                continue;
-              case 20:
-                if (c === Char.l)
-                  this.state = 21;
-                else
-                  this._error(`Invalid null started with nu${c}`);
-                continue;
-              case 21:
-                if (c === Char.l) {
-                  this.emit("onvalue", null);
-                  this.state = this.stack.pop() || 1;
-                } else
-                  this._error(`Invalid null started with nul${c}`);
-                continue;
-              case 22:
-                if (c === Char.period) {
-                  this.numberNode += ".";
-                  this.state = 23;
-                } else
-                  this._error("Leading zero not followed by .");
-                continue;
-              case 23:
-                if (Char._0 <= c && c <= Char._9)
-                  this.numberNode += String.fromCharCode(c);
-                else if (c === Char.period) {
-                  if (this.numberNode.indexOf(".") !== -1)
-                    this._error("Invalid number has two dots");
-                  this.numberNode += ".";
-                } else if (c === Char.e || c === Char.E) {
-                  if (this.numberNode.indexOf("e") !== -1 || this.numberNode.indexOf("E") !== -1)
-                    this._error("Invalid number has two exponential");
-                  this.numberNode += "e";
-                } else if (c === Char.plus || c === Char.minus) {
-                  if (!(p === Char.e || p === Char.E))
-                    this._error("Invalid symbol in number");
-                  this.numberNode += String.fromCharCode(c);
-                } else {
-                  this._closeNumber();
-                  i--;
-                  this.state = this.stack.pop() || 1;
+                  c = chunk.charCodeAt(i++);
+                  this.position++;
+                  starti = i - 1;
+                  if (!c)
+                    break;
+                  else
+                    continue;
                 }
-                continue;
-              default:
-                this._error(`Unknown state: ${this.state}`);
+                stringTokenPattern.lastIndex = i;
+                const reResult = stringTokenPattern.exec(chunk);
+                if (reResult === null) {
+                  i = chunk.length + 1;
+                  this.textNode += chunk.substring(starti, i - 1);
+                  this.position += i - 1 - starti;
+                  break;
+                }
+                i = reResult.index + 1;
+                c = chunk.charCodeAt(reResult.index);
+                if (!c) {
+                  this.textNode += chunk.substring(starti, i - 1);
+                  this.position += i - 1 - starti;
+                  break;
+                }
+              }
+            this.slashed = slashed;
+            this.unicodeI = unicodeI;
+            continue;
+          case STATE.TRUE:
+            if (c === Char.r)
+              this.state = STATE.TRUE2;
+            else
+              this._error(`Invalid true started with t${c}`);
+            continue;
+          case STATE.TRUE2:
+            if (c === Char.u)
+              this.state = STATE.TRUE3;
+            else
+              this._error(`Invalid true started with tr${c}`);
+            continue;
+          case STATE.TRUE3:
+            if (c === Char.e) {
+              this.emit("onvalue", true);
+              this.state = this.stack.pop() || STATE.VALUE;
+            } else
+              this._error(`Invalid true started with tru${c}`);
+            continue;
+          case STATE.FALSE:
+            if (c === Char.a)
+              this.state = STATE.FALSE2;
+            else
+              this._error(`Invalid false started with f${c}`);
+            continue;
+          case STATE.FALSE2:
+            if (c === Char.l)
+              this.state = STATE.FALSE3;
+            else
+              this._error(`Invalid false started with fa${c}`);
+            continue;
+          case STATE.FALSE3:
+            if (c === Char.s)
+              this.state = STATE.FALSE4;
+            else
+              this._error(`Invalid false started with fal${c}`);
+            continue;
+          case STATE.FALSE4:
+            if (c === Char.e) {
+              this.emit("onvalue", false);
+              this.state = this.stack.pop() || STATE.VALUE;
+            } else
+              this._error(`Invalid false started with fals${c}`);
+            continue;
+          case STATE.NULL:
+            if (c === Char.u)
+              this.state = STATE.NULL2;
+            else
+              this._error(`Invalid null started with n${c}`);
+            continue;
+          case STATE.NULL2:
+            if (c === Char.l)
+              this.state = STATE.NULL3;
+            else
+              this._error(`Invalid null started with nu${c}`);
+            continue;
+          case STATE.NULL3:
+            if (c === Char.l) {
+              this.emit("onvalue", null);
+              this.state = this.stack.pop() || STATE.VALUE;
+            } else
+              this._error(`Invalid null started with nul${c}`);
+            continue;
+          case STATE.NUMBER_DECIMAL_POINT:
+            if (c === Char.period) {
+              this.numberNode += ".";
+              this.state = STATE.NUMBER_DIGIT;
+            } else
+              this._error("Leading zero not followed by .");
+            continue;
+          case STATE.NUMBER_DIGIT:
+            if (Char._0 <= c && c <= Char._9)
+              this.numberNode += String.fromCharCode(c);
+            else if (c === Char.period) {
+              if (this.numberNode.indexOf(".") !== -1)
+                this._error("Invalid number has two dots");
+              this.numberNode += ".";
+            } else if (c === Char.e || c === Char.E) {
+              if (this.numberNode.indexOf("e") !== -1 || this.numberNode.indexOf("E") !== -1)
+                this._error("Invalid number has two exponential");
+              this.numberNode += "e";
+            } else if (c === Char.plus || c === Char.minus) {
+              if (!(p === Char.e || p === Char.E))
+                this._error("Invalid symbol in number");
+              this.numberNode += String.fromCharCode(c);
+            } else {
+              this._closeNumber();
+              i--;
+              this.state = this.stack.pop() || STATE.VALUE;
             }
-          }
-          if (this.position >= this.bufferCheckPosition) {
-            checkBufferLength(this);
-          }
-          this.emit("onchunkparsed");
-          return this;
-        }
-        _closeValue(event = "onvalue") {
-          if (this.textNode !== void 0) {
-            this.emit(event, this.textNode);
-          }
-          this.textNode = void 0;
-        }
-        _closeNumber() {
-          if (this.numberNode)
-            this.emit("onvalue", parseFloat(this.numberNode));
-          this.numberNode = "";
+            continue;
+          default:
+            this._error(`Unknown state: ${this.state}`);
         }
-        _error(message = "") {
-          this._closeValue();
-          message += `
+      }
+      if (this.position >= this.bufferCheckPosition) {
+        checkBufferLength(this);
+      }
+      this.emit("onchunkparsed");
+      return this;
+    }
+    _closeValue(event = "onvalue") {
+      if (this.textNode !== void 0) {
+        this.emit(event, this.textNode);
+      }
+      this.textNode = void 0;
+    }
+    _closeNumber() {
+      if (this.numberNode)
+        this.emit("onvalue", parseFloat(this.numberNode));
+      this.numberNode = "";
+    }
+    _error(message = "") {
+      this._closeValue();
+      message += `
 Line: ${this.line}
 Column: ${this.column}
 Char: ${this.c}`;
-          const error = new Error(message);
-          this.error = error;
-          this.emit("onerror", error);
+      const error = new Error(message);
+      this.error = error;
+      this.emit("onerror", error);
+    }
+  };
+  function isWhitespace(c) {
+    return c === Char.carriageReturn || c === Char.lineFeed || c === Char.space || c === Char.tab;
+  }
+  function checkBufferLength(parser) {
+    const maxAllowed = Math.max(MAX_BUFFER_LENGTH, 10);
+    let maxActual = 0;
+    for (const buffer of ["textNode", "numberNode"]) {
+      const len = parser[buffer] === void 0 ? 0 : parser[buffer].length;
+      if (len > maxAllowed) {
+        switch (buffer) {
+          case "text":
+            break;
+          default:
+            parser._error(`Max buffer length exceeded: ${buffer}`);
         }
-      };
+      }
+      maxActual = Math.max(maxActual, len);
     }
-  });
+    parser.bufferCheckPosition = MAX_BUFFER_LENGTH - maxActual + parser.position;
+  }
 
   // src/lib/jsonpath/jsonpath.ts
-  var JSONPath;
-  var init_jsonpath = __esm({
-    "src/lib/jsonpath/jsonpath.ts"() {
-      JSONPath = class {
-        constructor(path = null) {
-          this.path = ["$"];
-          if (path instanceof JSONPath) {
-            this.path = [...path.path];
-            return;
-          }
-          if (Array.isArray(path)) {
-            this.path.push(...path);
-            return;
-          }
-          if (typeof path === "string") {
-            this.path = path.split(".");
-            if (this.path[0] !== "$") {
-              throw new Error("JSONPaths must start with $");
-            }
-          }
-        }
-        clone() {
-          return new JSONPath(this);
-        }
-        toString() {
-          return this.path.join(".");
-        }
-        push(name) {
-          this.path.push(name);
-        }
-        pop() {
-          return this.path.pop();
-        }
-        set(name) {
-          this.path[this.path.length - 1] = name;
-        }
-        equals(other) {
-          if (!this || !other || this.path.length !== other.path.length) {
-            return false;
-          }
-          for (let i = 0; i < this.path.length; ++i) {
-            if (this.path[i] !== other.path[i]) {
-              return false;
-            }
-          }
-          return true;
-        }
-        setFieldAtPath(object, value) {
-          const path = [...this.path];
-          path.shift();
-          const field = path.pop();
-          for (const component of path) {
-            object = object[component];
-          }
-          object[field] = value;
+  var JSONPath = class {
+    constructor(path = null) {
+      this.path = ["$"];
+      if (path instanceof JSONPath) {
+        this.path = [...path.path];
+        return;
+      }
+      if (Array.isArray(path)) {
+        this.path.push(...path);
+        return;
+      }
+      if (typeof path === "string") {
+        this.path = path.split(".");
+        if (this.path[0] !== "$") {
+          throw new Error("JSONPaths must start with $");
         }
-        getFieldAtPath(object) {
-          const path = [...this.path];
-          path.shift();
-          const field = path.pop();
-          for (const component of path) {
-            object = object[component];
-          }
-          return object[field];
+      }
+    }
+    clone() {
+      return new JSONPath(this);
+    }
+    toString() {
+      return this.path.join(".");
+    }
+    push(name) {
+      this.path.push(name);
+    }
+    pop() {
+      return this.path.pop();
+    }
+    set(name) {
+      this.path[this.path.length - 1] = name;
+    }
+    equals(other) {
+      if (!this || !other || this.path.length !== other.path.length) {
+        return false;
+      }
+      for (let i = 0; i < this.path.length; ++i) {
+        if (this.path[i] !== other.path[i]) {
+          return false;
         }
-      };
+      }
+      return true;
     }
-  });
+    setFieldAtPath(object, value) {
+      const path = [...this.path];
+      path.shift();
+      const field = path.pop();
+      for (const component of path) {
+        object = object[component];
+      }
+      object[field] = value;
+    }
+    getFieldAtPath(object) {
+      const path = [...this.path];
+      path.shift();
+      const field = path.pop();
+      for (const component of path) {
+        object = object[component];
+      }
+      return object[field];
+    }
+  };
 
   // src/lib/json-parser/json-parser.ts
-  var JSONParser;
-  var init_json_parser = __esm({
-    "src/lib/json-parser/json-parser.ts"() {
-      init_clarinet();
-      init_jsonpath();
-      JSONParser = class {
-        constructor(options) {
-          this.result = void 0;
-          this.previousStates = [];
-          this.currentState = Object.freeze({ container: [], key: null });
-          this.jsonpath = new JSONPath();
-          this.reset();
-          this.parser = new ClarinetParser({
-            onready: () => {
-              this.jsonpath = new JSONPath();
-              this.previousStates.length = 0;
-              this.currentState.container.length = 0;
-            },
-            onopenobject: (name) => {
-              this._openObject({});
-              if (typeof name !== "undefined") {
-                this.parser.emit("onkey", name);
-              }
-            },
-            onkey: (name) => {
-              this.jsonpath.set(name);
-              this.currentState.key = name;
-            },
-            oncloseobject: () => {
-              this._closeObject();
-            },
-            onopenarray: () => {
-              this._openArray();
-            },
-            onclosearray: () => {
-              this._closeArray();
-            },
-            onvalue: (value) => {
-              this._pushOrSet(value);
-            },
-            onerror: (error) => {
-              throw error;
-            },
-            onend: () => {
-              this.result = this.currentState.container.pop();
-            },
-            ...options
-          });
-        }
-        reset() {
-          this.result = void 0;
-          this.previousStates = [];
-          this.currentState = Object.freeze({ container: [], key: null });
+  var JSONParser = class {
+    result = void 0;
+    previousStates = [];
+    currentState = Object.freeze({
+      container: [],
+      key: null
+    });
+    jsonpath = new JSONPath();
+    constructor(options) {
+      this.reset();
+      this.parser = new ClarinetParser({
+        onready: () => {
           this.jsonpath = new JSONPath();
-        }
-        write(chunk) {
-          this.parser.write(chunk);
-        }
-        close() {
-          this.parser.close();
-        }
-        _pushOrSet(value) {
-          const { container, key } = this.currentState;
-          if (key !== null) {
-            container[key] = value;
-            this.currentState.key = null;
-          } else {
-            container.push(value);
+          this.previousStates.length = 0;
+          this.currentState.container.length = 0;
+        },
+        onopenobject: (name) => {
+          this._openObject({});
+          if (typeof name !== "undefined") {
+            this.parser.emit("onkey", name);
           }
-        }
-        _openArray(newContainer = []) {
-          this.jsonpath.push(null);
-          this._pushOrSet(newContainer);
-          this.previousStates.push(this.currentState);
-          this.currentState = { container: newContainer, isArray: true, key: null };
-        }
-        _closeArray() {
-          this.jsonpath.pop();
-          this.currentState = this.previousStates.pop();
-        }
-        _openObject(newContainer = {}) {
-          this.jsonpath.push(null);
-          this._pushOrSet(newContainer);
-          this.previousStates.push(this.currentState);
-          this.currentState = { container: newContainer, isArray: false, key: null };
-        }
-        _closeObject() {
-          this.jsonpath.pop();
-          this.currentState = this.previousStates.pop();
-        }
+        },
+        onkey: (name) => {
+          this.jsonpath.set(name);
+          this.currentState.key = name;
+        },
+        oncloseobject: () => {
+          this._closeObject();
+        },
+        onopenarray: () => {
+          this._openArray();
+        },
+        onclosearray: () => {
+          this._closeArray();
+        },
+        onvalue: (value) => {
+          this._pushOrSet(value);
+        },
+        onerror: (error) => {
+          throw error;
+        },
+        onend: () => {
+          this.result = this.currentState.container.pop();
+        },
+        ...options
+      });
+    }
+    reset() {
+      this.result = void 0;
+      this.previousStates = [];
+      this.currentState = Object.freeze({
+        container: [],
+        key: null
+      });
+      this.jsonpath = new JSONPath();
+    }
+    write(chunk) {
+      this.parser.write(chunk);
+    }
+    close() {
+      this.parser.close();
+    }
+    _pushOrSet(value) {
+      const {
+        container,
+        key
+      } = this.currentState;
+      if (key !== null) {
+        container[key] = value;
+        this.currentState.key = null;
+      } else {
+        container.push(value);
+      }
+    }
+    _openArray(newContainer = []) {
+      this.jsonpath.push(null);
+      this._pushOrSet(newContainer);
+      this.previousStates.push(this.currentState);
+      this.currentState = {
+        container: newContainer,
+        isArray: true,
+        key: null
       };
     }
-  });
+    _closeArray() {
+      this.jsonpath.pop();
+      this.currentState = this.previousStates.pop();
+    }
+    _openObject(newContainer = {}) {
+      this.jsonpath.push(null);
+      this._pushOrSet(newContainer);
+      this.previousStates.push(this.currentState);
+      this.currentState = {
+        container: newContainer,
+        isArray: false,
+        key: null
+      };
+    }
+    _closeObject() {
+      this.jsonpath.pop();
+      this.currentState = this.previousStates.pop();
+    }
+  };
 
   // src/lib/json-parser/streaming-json-parser.ts
-  var StreamingJSONParser;
-  var init_streaming_json_parser = __esm({
-    "src/lib/json-parser/streaming-json-parser.ts"() {
-      init_json_parser();
-      init_jsonpath();
-      StreamingJSONParser = class extends JSONParser {
-        constructor(options = {}) {
-          super({
-            onopenarray: () => {
-              if (!this.streamingArray) {
-                if (this._matchJSONPath()) {
-                  this.streamingJsonPath = this.getJsonPath().clone();
-                  this.streamingArray = [];
-                  this._openArray(this.streamingArray);
-                  return;
-                }
-              }
-              this._openArray();
-            },
-            onopenobject: (name) => {
-              if (!this.topLevelObject) {
-                this.topLevelObject = {};
-                this._openObject(this.topLevelObject);
-              } else {
-                this._openObject({});
-              }
-              if (typeof name !== "undefined") {
-                this.parser.emit("onkey", name);
-              }
+  var StreamingJSONParser = class extends JSONParser {
+    streamingJsonPath = null;
+    streamingArray = null;
+    topLevelObject = null;
+    constructor(options = {}) {
+      super({
+        onopenarray: () => {
+          if (!this.streamingArray) {
+            if (this._matchJSONPath()) {
+              this.streamingJsonPath = this.getJsonPath().clone();
+              this.streamingArray = [];
+              this._openArray(this.streamingArray);
+              return;
             }
-          });
-          this.streamingJsonPath = null;
-          this.streamingArray = null;
-          this.topLevelObject = null;
-          const jsonpaths = options.jsonpaths || [];
-          this.jsonPaths = jsonpaths.map((jsonpath) => new JSONPath(jsonpath));
-        }
-        write(chunk) {
-          super.write(chunk);
-          let array = [];
-          if (this.streamingArray) {
-            array = [...this.streamingArray];
-            this.streamingArray.length = 0;
           }
-          return array;
-        }
-        getPartialResult() {
-          return this.topLevelObject;
-        }
-        getStreamingJsonPath() {
-          return this.streamingJsonPath;
-        }
-        getStreamingJsonPathAsString() {
-          return this.streamingJsonPath && this.streamingJsonPath.toString();
-        }
-        getJsonPath() {
-          return this.jsonpath;
-        }
-        _matchJSONPath() {
-          const currentPath = this.getJsonPath();
-          if (this.jsonPaths.length === 0) {
-            return true;
+          this._openArray();
+        },
+        onopenobject: (name) => {
+          if (!this.topLevelObject) {
+            this.topLevelObject = {};
+            this._openObject(this.topLevelObject);
+          } else {
+            this._openObject({});
           }
-          for (const jsonPath of this.jsonPaths) {
-            if (jsonPath.equals(currentPath)) {
-              return true;
-            }
+          if (typeof name !== "undefined") {
+            this.parser.emit("onkey", name);
           }
-          return false;
         }
-      };
+      });
+      const jsonpaths = options.jsonpaths || [];
+      this.jsonPaths = jsonpaths.map((jsonpath) => new JSONPath(jsonpath));
+    }
+    write(chunk) {
+      super.write(chunk);
+      let array = [];
+      if (this.streamingArray) {
+        array = [...this.streamingArray];
+        this.streamingArray.length = 0;
+      }
+      return array;
     }
-  });
+    getPartialResult() {
+      return this.topLevelObject;
+    }
+    getStreamingJsonPath() {
+      return this.streamingJsonPath;
+    }
+    getStreamingJsonPathAsString() {
+      return this.streamingJsonPath && this.streamingJsonPath.toString();
+    }
+    getJsonPath() {
+      return this.jsonpath;
+    }
+    _matchJSONPath() {
+      const currentPath = this.getJsonPath();
+      if (this.jsonPaths.length === 0) {
+        return true;
+      }
+      for (const jsonPath of this.jsonPaths) {
+        if (jsonPath.equals(currentPath)) {
+          return true;
+        }
+      }
+      return false;
+    }
+  };
 
   // src/lib/parsers/parse-json-in-batches.ts
   async function* parseJSONInBatches(binaryAsyncIterator, options) {
     const asyncIterator = makeTextDecoderIterator(binaryAsyncIterator);
-    const { metadata } = options;
-    const { jsonpaths } = options.json || {};
+    const {
+      metadata
+    } = options;
+    const {
+      jsonpaths
+    } = options.json || {};
     let isFirstChunk = true;
     const schema = null;
     const shape = options?.json?.shape || "object-row-table";
@@ -1607,7 +1610,9 @@ Char: ${this.c}`;
       ...options,
       shape
     });
-    const parser = new StreamingJSONParser({ jsonpaths });
+    const parser = new StreamingJSONParser({
+      jsonpaths
+    });
     for await (const chunk of asyncIterator) {
       const rows = parser.write(chunk);
       const jsonpath2 = rows.length > 0 && parser.getStreamingJsonPathAsString();
@@ -1628,19 +1633,25 @@ Char: ${this.c}`;
       }
       for (const row of rows) {
         tableBatchBuilder.addRow(row);
-        const batch3 = tableBatchBuilder.getFullBatch({ jsonpath: jsonpath2 });
+        const batch3 = tableBatchBuilder.getFullBatch({
+          jsonpath: jsonpath2
+        });
         if (batch3) {
           yield batch3;
         }
       }
       tableBatchBuilder.chunkComplete(chunk);
-      const batch2 = tableBatchBuilder.getFullBatch({ jsonpath: jsonpath2 });
+      const batch2 = tableBatchBuilder.getFullBatch({
+        jsonpath: jsonpath2
+      });
       if (batch2) {
         yield batch2;
       }
     }
     const jsonpath = parser.getStreamingJsonPathAsString();
-    const batch = tableBatchBuilder.getFinalBatch({ jsonpath });
+    const batch = tableBatchBuilder.getFinalBatch({
+      jsonpath
+    });
     if (batch) {
       yield batch;
     }
@@ -1669,56 +1680,53 @@ Char: ${this.c}`;
     }
     return batch.container;
   }
-  var init_parse_json_in_batches = __esm({
-    "src/lib/parsers/parse-json-in-batches.ts"() {
-      init_src();
-      init_src2();
-      init_streaming_json_parser();
-      init_jsonpath();
-    }
-  });
 
   // src/json-loader.ts
+  var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var DEFAULT_JSON_LOADER_OPTIONS = {
+    json: {
+      shape: "object-row-table",
+      table: false,
+      jsonpaths: []
+    }
+  };
+  var JSONLoader = {
+    name: "JSON",
+    id: "json",
+    module: "json",
+    version: VERSION,
+    extensions: ["json", "geojson"],
+    mimeTypes: ["application/json"],
+    category: "table",
+    text: true,
+    parse,
+    parseTextSync,
+    parseInBatches,
+    options: DEFAULT_JSON_LOADER_OPTIONS
+  };
   async function parse(arrayBuffer, options) {
     return parseTextSync(new TextDecoder().decode(arrayBuffer), options);
   }
   function parseTextSync(text, options) {
-    const jsonOptions = { ...options, json: { ...DEFAULT_JSON_LOADER_OPTIONS.json, ...options?.json } };
+    const jsonOptions = {
+      ...options,
+      json: {
+        ...DEFAULT_JSON_LOADER_OPTIONS.json,
+        ...options?.json
+      }
+    };
     return parseJSONSync(text, jsonOptions);
   }
   function parseInBatches(asyncIterator, options) {
-    const jsonOptions = { ...options, json: { ...DEFAULT_JSON_LOADER_OPTIONS.json, ...options?.json } };
+    const jsonOptions = {
+      ...options,
+      json: {
+        ...DEFAULT_JSON_LOADER_OPTIONS.json,
+        ...options?.json
+      }
+    };
     return parseJSONInBatches(asyncIterator, jsonOptions);
   }
-  var VERSION, DEFAULT_JSON_LOADER_OPTIONS, JSONLoader;
-  var init_json_loader = __esm({
-    "src/json-loader.ts"() {
-      init_parse_json();
-      init_parse_json_in_batches();
-      VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
-      DEFAULT_JSON_LOADER_OPTIONS = {
-        json: {
-          shape: "object-row-table",
-          table: false,
-          jsonpaths: []
-        }
-      };
-      JSONLoader = {
-        name: "JSON",
-        id: "json",
-        module: "json",
-        version: VERSION,
-        extensions: ["json", "geojson"],
-        mimeTypes: ["application/json"],
-        category: "table",
-        text: true,
-        parse,
-        parseTextSync,
-        parseInBatches,
-        options: DEFAULT_JSON_LOADER_OPTIONS
-      };
-    }
-  });
 
   // src/lib/parsers/parse-ndjson.ts
   function parseNDJSONSync(ndjsonText) {
@@ -1732,11 +1740,6 @@ Char: ${this.c}`;
     });
     return makeTableFromData(parsedLines);
   }
-  var init_parse_ndjson = __esm({
-    "src/lib/parsers/parse-ndjson.ts"() {
-      init_src();
-    }
-  });
 
   // src/lib/parsers/parse-ndjson-in-batches.ts
   async function* parseNDJSONInBatches(binaryAsyncIterator, options) {
@@ -1749,7 +1752,10 @@ Char: ${this.c}`;
       ...options,
       shape
     });
-    for await (const { counter, line } of numberedLineIterator) {
+    for await (const {
+      counter,
+      line
+    } of numberedLineIterator) {
       try {
         const row = JSON.parse(line);
         tableBatchBuilder.addRow(row);
@@ -1767,40 +1773,23 @@ Char: ${this.c}`;
       yield batch;
     }
   }
-  var init_parse_ndjson_in_batches = __esm({
-    "src/lib/parsers/parse-ndjson-in-batches.ts"() {
-      init_src();
-      init_src2();
-    }
-  });
 
   // src/ndjson-loader.ts
-  var VERSION2, NDJSONLoader;
-  var init_ndjson_loader = __esm({
-    "src/ndjson-loader.ts"() {
-      init_parse_ndjson();
-      init_parse_ndjson_in_batches();
-      VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
-      NDJSONLoader = {
-        name: "NDJSON",
-        id: "ndjson",
-        module: "json",
-        version: VERSION2,
-        extensions: ["ndjson", "jsonl"],
-        mimeTypes: [
-          "application/x-ndjson",
-          "application/jsonlines",
-          "application/json-seq"
-        ],
-        category: "table",
-        text: true,
-        parse: async (arrayBuffer) => parseNDJSONSync(new TextDecoder().decode(arrayBuffer)),
-        parseTextSync: parseNDJSONSync,
-        parseInBatches: parseNDJSONInBatches,
-        options: {}
-      };
-    }
-  });
+  var VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var NDJSONLoader = {
+    name: "NDJSON",
+    id: "ndjson",
+    module: "json",
+    version: VERSION2,
+    extensions: ["ndjson", "jsonl"],
+    mimeTypes: ["application/x-ndjson", "application/jsonlines", "application/json-seq"],
+    category: "table",
+    text: true,
+    parse: async (arrayBuffer) => parseNDJSONSync(new TextDecoder().decode(arrayBuffer)),
+    parseTextSync: parseNDJSONSync,
+    parseInBatches: parseNDJSONInBatches,
+    options: {}
+  };
 
   // src/lib/encoders/json-encoder.ts
   function encodeTableAsJSON(table, options) {
@@ -1812,64 +1801,49 @@ Char: ${this.c}`;
     }
     return `[${strings.join(",")}]`;
   }
-  var init_json_encoder = __esm({
-    "src/lib/encoders/json-encoder.ts"() {
-      init_src();
-    }
-  });
 
   // src/json-writer.ts
-  var JSONWriter;
-  var init_json_writer = __esm({
-    "src/json-writer.ts"() {
-      init_json_encoder();
-      JSONWriter = {
-        id: "json",
-        version: "latest",
-        module: "json",
-        name: "JSON",
-        extensions: ["json"],
-        mimeTypes: ["application/json"],
-        options: {},
-        text: true,
-        encode: async (table, options) => new TextEncoder().encode(encodeTableAsJSON(table, options)).buffer,
-        encodeTextSync: (table, options) => encodeTableAsJSON(table, options)
-      };
-    }
-  });
+  var JSONWriter = {
+    id: "json",
+    version: "latest",
+    module: "json",
+    name: "JSON",
+    extensions: ["json"],
+    mimeTypes: ["application/json"],
+    options: {},
+    text: true,
+    encode: async (table, options) => new TextEncoder().encode(encodeTableAsJSON(table, options)).buffer,
+    encodeTextSync: (table, options) => encodeTableAsJSON(table, options)
+  };
 
-  // ../../node_modules/@math.gl/polygon/dist/esm/polygon-utils.js
+  // ../../node_modules/@math.gl/polygon/dist/polygon-utils.js
+  var DimIndex = {
+    x: 0,
+    y: 1,
+    z: 2
+  };
   function getPolygonSignedArea(points, options = {}) {
     const {
       start = 0,
-      end = points.length
+      end = points.length,
+      plane = "xy"
     } = options;
     const dim = options.size || 2;
     let area2 = 0;
+    const i0 = DimIndex[plane[0]];
+    const i1 = DimIndex[plane[1]];
     for (let i = start, j = end - dim; i < end; i += dim) {
-      area2 += (points[i] - points[j]) * (points[i + 1] + points[j + 1]);
+      area2 += (points[i + i0] - points[j + i0]) * (points[i + i1] + points[j + i1]);
       j = i;
     }
     return area2 / 2;
   }
-  var init_polygon_utils = __esm({
-    "../../node_modules/@math.gl/polygon/dist/esm/polygon-utils.js"() {
-    }
-  });
 
-  // ../../node_modules/@math.gl/polygon/dist/esm/polygon.js
-  var init_polygon = __esm({
-    "../../node_modules/@math.gl/polygon/dist/esm/polygon.js"() {
-      init_defineProperty();
-      init_polygon_utils();
-    }
-  });
-
-  // ../../node_modules/@math.gl/polygon/dist/esm/earcut.js
-  function earcut(positions, holeIndices, dim = 2, areas) {
+  // ../../node_modules/@math.gl/polygon/dist/earcut.js
+  function earcut(positions, holeIndices, dim = 2, areas, plane = "xy") {
     const hasHoles = holeIndices && holeIndices.length;
     const outerLen = hasHoles ? holeIndices[0] * dim : positions.length;
-    let outerNode = linkedList(positions, 0, outerLen, dim, true, areas && areas[0]);
+    let outerNode = linkedList(positions, 0, outerLen, dim, true, areas && areas[0], plane);
     const triangles = [];
     if (!outerNode || outerNode.next === outerNode.prev)
       return triangles;
@@ -1881,7 +1855,7 @@ Char: ${this.c}`;
     let x;
     let y;
     if (hasHoles)
-      outerNode = eliminateHoles(positions, holeIndices, outerNode, dim, areas);
+      outerNode = eliminateHoles(positions, holeIndices, outerNode, dim, areas, plane);
     if (positions.length > 80 * dim) {
       minX = maxX = positions[0];
       minY = maxY = positions[1];
@@ -1898,27 +1872,30 @@ Char: ${this.c}`;
           maxY = y;
       }
       invSize = Math.max(maxX - minX, maxY - minY);
-      invSize = invSize !== 0 ? 1 / invSize : 0;
+      invSize = invSize !== 0 ? 32767 / invSize : 0;
     }
-    earcutLinked(outerNode, triangles, dim, minX, minY, invSize);
+    earcutLinked(outerNode, triangles, dim, minX, minY, invSize, 0);
     return triangles;
   }
-  function linkedList(data, start, end, dim, clockwise, area2) {
+  function linkedList(data, start, end, dim, clockwise, area2, plane) {
     let i;
     let last;
     if (area2 === void 0) {
       area2 = getPolygonSignedArea(data, {
         start,
         end,
-        size: dim
+        size: dim,
+        plane
       });
     }
+    let i0 = DimIndex[plane[0]];
+    let i1 = DimIndex[plane[1]];
     if (clockwise === area2 < 0) {
       for (i = start; i < end; i += dim)
-        last = insertNode(i, data[i], data[i + 1], last);
+        last = insertNode(i, data[i + i0], data[i + i1], last);
     } else {
       for (i = end - dim; i >= start; i -= dim)
-        last = insertNode(i, data[i], data[i + 1], last);
+        last = insertNode(i, data[i + i0], data[i + i1], last);
     }
     if (last && equals(last, last.next)) {
       removeNode(last);
@@ -1959,9 +1936,9 @@ Char: ${this.c}`;
       prev = ear.prev;
       next = ear.next;
       if (invSize ? isEarHashed(ear, minX, minY, invSize) : isEar(ear)) {
-        triangles.push(prev.i / dim);
-        triangles.push(ear.i / dim);
-        triangles.push(next.i / dim);
+        triangles.push(prev.i / dim | 0);
+        triangles.push(ear.i / dim | 0);
+        triangles.push(next.i / dim | 0);
         removeNode(ear);
         ear = next.next;
         stop = next.next;
@@ -1987,9 +1964,19 @@ Char: ${this.c}`;
     const c = ear.next;
     if (area(a, b, c) >= 0)
       return false;
-    let p = ear.next.next;
-    while (p !== ear.prev) {
-      if (pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) && area(p.prev, p, p.next) >= 0)
+    const ax = a.x;
+    const bx = b.x;
+    const cx = c.x;
+    const ay = a.y;
+    const by = b.y;
+    const cy = c.y;
+    const x0 = ax < bx ? ax < cx ? ax : cx : bx < cx ? bx : cx;
+    const y0 = ay < by ? ay < cy ? ay : cy : by < cy ? by : cy;
+    const x1 = ax > bx ? ax > cx ? ax : cx : bx > cx ? bx : cx;
+    const y1 = ay > by ? ay > cy ? ay : cy : by > cy ? by : cy;
+    let p = c.next;
+    while (p !== a) {
+      if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0)
         return false;
       p = p.next;
     }
@@ -2001,29 +1988,35 @@ Char: ${this.c}`;
     const c = ear.next;
     if (area(a, b, c) >= 0)
       return false;
-    const minTX = a.x < b.x ? a.x < c.x ? a.x : c.x : b.x < c.x ? b.x : c.x;
-    const minTY = a.y < b.y ? a.y < c.y ? a.y : c.y : b.y < c.y ? b.y : c.y;
-    const maxTX = a.x > b.x ? a.x > c.x ? a.x : c.x : b.x > c.x ? b.x : c.x;
-    const maxTY = a.y > b.y ? a.y > c.y ? a.y : c.y : b.y > c.y ? b.y : c.y;
-    const minZ = zOrder(minTX, minTY, minX, minY, invSize);
-    const maxZ = zOrder(maxTX, maxTY, minX, minY, invSize);
+    const ax = a.x;
+    const bx = b.x;
+    const cx = c.x;
+    const ay = a.y;
+    const by = b.y;
+    const cy = c.y;
+    const x0 = ax < bx ? ax < cx ? ax : cx : bx < cx ? bx : cx;
+    const y0 = ay < by ? ay < cy ? ay : cy : by < cy ? by : cy;
+    const x1 = ax > bx ? ax > cx ? ax : cx : bx > cx ? bx : cx;
+    const y1 = ay > by ? ay > cy ? ay : cy : by > cy ? by : cy;
+    const minZ = zOrder(x0, y0, minX, minY, invSize);
+    const maxZ = zOrder(x1, y1, minX, minY, invSize);
     let p = ear.prevZ;
     let n = ear.nextZ;
     while (p && p.z >= minZ && n && n.z <= maxZ) {
-      if (p !== ear.prev && p !== ear.next && pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) && area(p.prev, p, p.next) >= 0)
+      if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0)
         return false;
       p = p.prevZ;
-      if (n !== ear.prev && n !== ear.next && pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, n.x, n.y) && area(n.prev, n, n.next) >= 0)
+      if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c && pointInTriangle(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0)
         return false;
       n = n.nextZ;
     }
     while (p && p.z >= minZ) {
-      if (p !== ear.prev && p !== ear.next && pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) && area(p.prev, p, p.next) >= 0)
+      if (p.x >= x0 && p.x <= x1 && p.y >= y0 && p.y <= y1 && p !== a && p !== c && pointInTriangle(ax, ay, bx, by, cx, cy, p.x, p.y) && area(p.prev, p, p.next) >= 0)
         return false;
       p = p.prevZ;
     }
     while (n && n.z <= maxZ) {
-      if (n !== ear.prev && n !== ear.next && pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, n.x, n.y) && area(n.prev, n, n.next) >= 0)
+      if (n.x >= x0 && n.x <= x1 && n.y >= y0 && n.y <= y1 && n !== a && n !== c && pointInTriangle(ax, ay, bx, by, cx, cy, n.x, n.y) && area(n.prev, n, n.next) >= 0)
         return false;
       n = n.nextZ;
     }
@@ -2035,9 +2028,9 @@ Char: ${this.c}`;
       const a = p.prev;
       const b = p.next.next;
       if (!equals(a, b) && intersects(a, p, p.next, b) && locallyInside(a, b) && locallyInside(b, a)) {
-        triangles.push(a.i / dim);
-        triangles.push(p.i / dim);
-        triangles.push(b.i / dim);
+        triangles.push(a.i / dim | 0);
+        triangles.push(p.i / dim | 0);
+        triangles.push(b.i / dim | 0);
         removeNode(p);
         removeNode(p.next);
         p = start = b;
@@ -2055,8 +2048,8 @@ Char: ${this.c}`;
           let c = splitPolygon(a, b);
           a = filterPoints(a, a.next);
           c = filterPoints(c, c.next);
-          earcutLinked(a, triangles, dim, minX, minY, invSize);
-          earcutLinked(c, triangles, dim, minX, minY, invSize);
+          earcutLinked(a, triangles, dim, minX, minY, invSize, 0);
+          earcutLinked(c, triangles, dim, minX, minY, invSize, 0);
           return;
         }
         b = b.next;
@@ -2064,7 +2057,7 @@ Char: ${this.c}`;
       a = a.next;
     } while (a !== start);
   }
-  function eliminateHoles(data, holeIndices, outerNode, dim, areas) {
+  function eliminateHoles(data, holeIndices, outerNode, dim, areas, plane) {
     const queue = [];
     let i;
     let len;
@@ -2074,15 +2067,14 @@ Char: ${this.c}`;
     for (i = 0, len = holeIndices.length; i < len; i++) {
       start = holeIndices[i] * dim;
       end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;
-      list = linkedList(data, start, end, dim, false, areas && areas[i + 1]);
+      list = linkedList(data, start, end, dim, false, areas && areas[i + 1], plane);
       if (list === list.next)
         list.steiner = true;
       queue.push(getLeftmost(list));
     }
     queue.sort(compareX);
     for (i = 0; i < queue.length; i++) {
-      eliminateHole(queue[i], outerNode);
-      outerNode = filterPoints(outerNode, outerNode.next);
+      outerNode = eliminateHole(queue[i], outerNode);
     }
     return outerNode;
   }
@@ -2090,12 +2082,13 @@ Char: ${this.c}`;
     return a.x - b.x;
   }
   function eliminateHole(hole, outerNode) {
-    outerNode = findHoleBridge(hole, outerNode);
-    if (outerNode) {
-      const b = splitPolygon(outerNode, hole);
-      filterPoints(outerNode, outerNode.next);
-      filterPoints(b, b.next);
+    const bridge = findHoleBridge(hole, outerNode);
+    if (!bridge) {
+      return outerNode;
     }
+    const bridgeReverse = splitPolygon(bridge, hole);
+    filterPoints(bridgeReverse, bridgeReverse.next);
+    return filterPoints(bridge, bridge.next);
   }
   function findHoleBridge(hole, outerNode) {
     let p = outerNode;
@@ -2108,21 +2101,15 @@ Char: ${this.c}`;
         const x = p.x + (hy - p.y) * (p.next.x - p.x) / (p.next.y - p.y);
         if (x <= hx && x > qx) {
           qx = x;
-          if (x === hx) {
-            if (hy === p.y)
-              return p;
-            if (hy === p.next.y)
-              return p.next;
-          }
           m = p.x < p.next.x ? p : p.next;
+          if (x === hx)
+            return m;
         }
       }
       p = p.next;
     } while (p !== outerNode);
     if (!m)
       return null;
-    if (hx === qx)
-      return m;
     const stop = m;
     const mx = m.x;
     const my = m.y;
@@ -2147,7 +2134,7 @@ Char: ${this.c}`;
   function indexCurve(start, minX, minY, invSize) {
     let p = start;
     do {
-      if (p.z === null)
+      if (p.z === 0)
         p.z = zOrder(p.x, p.y, minX, minY, invSize);
       p.prevZ = p.prev;
       p.nextZ = p.next;
@@ -2208,8 +2195,8 @@ Char: ${this.c}`;
     return list;
   }
   function zOrder(x, y, minX, minY, invSize) {
-    x = 32767 * (x - minX) * invSize;
-    y = 32767 * (y - minY) * invSize;
+    x = (x - minX) * invSize | 0;
+    y = (y - minY) * invSize | 0;
     x = (x | x << 8) & 16711935;
     x = (x | x << 4) & 252645135;
     x = (x | x << 2) & 858993459;
@@ -2231,7 +2218,7 @@ Char: ${this.c}`;
     return leftmost;
   }
   function pointInTriangle(ax, ay, bx, by, cx, cy, px, py) {
-    return (cx - px) * (ay - py) - (ax - px) * (cy - py) >= 0 && (ax - px) * (by - py) - (bx - px) * (ay - py) >= 0 && (bx - px) * (cy - py) - (cx - px) * (by - py) >= 0;
+    return (cx - px) * (ay - py) >= (ax - px) * (cy - py) && (ax - px) * (by - py) >= (bx - px) * (ay - py) && (bx - px) * (cy - py) >= (cx - px) * (by - py);
   }
   function isValidDiagonal(a, b) {
     return a.next.i !== b.i && a.prev.i !== b.i && !intersectsPolygon(a, b) && (locallyInside(a, b) && locallyInside(b, a) && middleInside(a, b) && (area(a.prev, a, b.prev) || area(a, b.prev, b)) || equals(a, b) && area(a.prev, a, a.next) > 0 && area(b.prev, b, b.next) > 0);
@@ -2290,8 +2277,8 @@ Char: ${this.c}`;
     return inside;
   }
   function splitPolygon(a, b) {
-    const a2 = new Node(a.i, a.x, a.y);
-    const b2 = new Node(b.i, b.x, b.y);
+    const a2 = new Vertex(a.i, a.x, a.y);
+    const b2 = new Vertex(b.i, b.x, b.y);
     const an = a.next;
     const bp = b.prev;
     a.next = b;
@@ -2305,7 +2292,7 @@ Char: ${this.c}`;
     return b2;
   }
   function insertNode(i, x, y, last) {
-    const p = new Node(i, x, y);
+    const p = new Vertex(i, x, y);
     if (!last) {
       p.prev = p;
       p.next = p;
@@ -2325,64 +2312,22 @@ Char: ${this.c}`;
     if (p.nextZ)
       p.nextZ.prevZ = p.prevZ;
   }
-  function Node(i, x, y) {
-    this.i = i;
-    this.x = x;
-    this.y = y;
-    this.prev = null;
-    this.next = null;
-    this.z = null;
-    this.prevZ = null;
-    this.nextZ = null;
-    this.steiner = false;
-  }
-  var init_earcut = __esm({
-    "../../node_modules/@math.gl/polygon/dist/esm/earcut.js"() {
-      init_polygon_utils();
-    }
-  });
-
-  // ../../node_modules/@math.gl/polygon/dist/esm/utils.js
-  var init_utils = __esm({
-    "../../node_modules/@math.gl/polygon/dist/esm/utils.js"() {
-    }
-  });
-
-  // ../../node_modules/@math.gl/polygon/dist/esm/lineclip.js
-  var init_lineclip = __esm({
-    "../../node_modules/@math.gl/polygon/dist/esm/lineclip.js"() {
-      init_utils();
-    }
-  });
-
-  // ../../node_modules/@math.gl/polygon/dist/esm/cut-by-grid.js
-  var init_cut_by_grid = __esm({
-    "../../node_modules/@math.gl/polygon/dist/esm/cut-by-grid.js"() {
-      init_lineclip();
-      init_utils();
-    }
-  });
-
-  // ../../node_modules/@math.gl/polygon/dist/esm/cut-by-mercator-bounds.js
-  var init_cut_by_mercator_bounds = __esm({
-    "../../node_modules/@math.gl/polygon/dist/esm/cut-by-mercator-bounds.js"() {
-      init_cut_by_grid();
-      init_utils();
+  var Vertex = class {
+    constructor(i, x, y) {
+      _defineProperty(this, "i", void 0);
+      _defineProperty(this, "x", void 0);
+      _defineProperty(this, "y", void 0);
+      _defineProperty(this, "prev", null);
+      _defineProperty(this, "next", null);
+      _defineProperty(this, "z", 0);
+      _defineProperty(this, "prevZ", null);
+      _defineProperty(this, "nextZ", null);
+      _defineProperty(this, "steiner", false);
+      this.i = i;
+      this.x = x;
+      this.y = y;
     }
-  });
-
-  // ../../node_modules/@math.gl/polygon/dist/esm/index.js
-  var init_esm = __esm({
-    "../../node_modules/@math.gl/polygon/dist/esm/index.js"() {
-      init_polygon();
-      init_polygon_utils();
-      init_earcut();
-      init_lineclip();
-      init_cut_by_grid();
-      init_cut_by_mercator_bounds();
-      init_polygon();
-    }
-  });
+  };
 
   // ../gis/src/lib/flat-geojson-to-binary.ts
   function flatGeojsonToBinary(features, geometryInfo, options) {
@@ -2423,7 +2368,11 @@ Char: ${this.c}`;
       propArrayTypes,
       coordLength
     } = geometryInfo;
-    const { numericPropKeys = [], PositionDataType = Float32Array, triangulate = true } = options;
+    const {
+      numericPropKeys = [],
+      PositionDataType = Float32Array,
+      triangulate = true
+    } = options;
     const hasGlobalId = features[0] && "id" in features[0];
     const GlobalFeatureIdsDataType = features.length > 65535 ? Uint32Array : Uint16Array;
     const points = {
@@ -2488,7 +2437,9 @@ Char: ${this.c}`;
           handlePoint(geometry, points, indexMap, coordLength, properties);
           points.properties.push(keepStringProperties(properties, numericPropKeys));
           if (hasGlobalId) {
-            points.fields.push({ id: feature.id });
+            points.fields.push({
+              id: feature.id
+            });
           }
           indexMap.pointFeature++;
           break;
@@ -2496,7 +2447,9 @@ Char: ${this.c}`;
           handleLineString(geometry, lines, indexMap, coordLength, properties);
           lines.properties.push(keepStringProperties(properties, numericPropKeys));
           if (hasGlobalId) {
-            lines.fields.push({ id: feature.id });
+            lines.fields.push({
+              id: feature.id
+            });
           }
           indexMap.lineFeature++;
           break;
@@ -2504,7 +2457,9 @@ Char: ${this.c}`;
           handlePolygon(geometry, polygons, indexMap, coordLength, properties);
           polygons.properties.push(keepStringProperties(properties, numericPropKeys));
           if (hasGlobalId) {
-            polygons.fields.push({ id: feature.id });
+            polygons.fields.push({
+              id: feature.id
+            });
           }
           indexMap.polygonFeature++;
           break;
@@ -2555,7 +2510,11 @@ Char: ${this.c}`;
         indexMap.polygonPosition += (end - start) / coordLength;
       }
       const endPosition = indexMap.polygonPosition;
-      triangulatePolygon(polygons, areas, indices, { startPosition, endPosition, coordLength });
+      triangulatePolygon(polygons, areas, indices, {
+        startPosition,
+        endPosition,
+        coordLength
+      });
     }
   }
   function triangulatePolygon(polygons, areas, indices, {
@@ -2579,7 +2538,10 @@ Char: ${this.c}`;
   function wrapProps(obj, size) {
     const returnObj = {};
     for (const key in obj) {
-      returnObj[key] = { value: obj[key], size };
+      returnObj[key] = {
+        value: obj[key],
+        size
+      };
     }
     return returnObj;
   }
@@ -2587,31 +2549,70 @@ Char: ${this.c}`;
     const binaryFeatures = {
       points: {
         ...points,
-        positions: { value: points.positions, size: coordLength },
-        globalFeatureIds: { value: points.globalFeatureIds, size: 1 },
-        featureIds: { value: points.featureIds, size: 1 },
+        positions: {
+          value: points.positions,
+          size: coordLength
+        },
+        globalFeatureIds: {
+          value: points.globalFeatureIds,
+          size: 1
+        },
+        featureIds: {
+          value: points.featureIds,
+          size: 1
+        },
         numericProps: wrapProps(points.numericProps, 1)
       },
       lines: {
         ...lines,
-        positions: { value: lines.positions, size: coordLength },
-        pathIndices: { value: lines.pathIndices, size: 1 },
-        globalFeatureIds: { value: lines.globalFeatureIds, size: 1 },
-        featureIds: { value: lines.featureIds, size: 1 },
+        positions: {
+          value: lines.positions,
+          size: coordLength
+        },
+        pathIndices: {
+          value: lines.pathIndices,
+          size: 1
+        },
+        globalFeatureIds: {
+          value: lines.globalFeatureIds,
+          size: 1
+        },
+        featureIds: {
+          value: lines.featureIds,
+          size: 1
+        },
         numericProps: wrapProps(lines.numericProps, 1)
       },
       polygons: {
         ...polygons,
-        positions: { value: polygons.positions, size: coordLength },
-        polygonIndices: { value: polygons.polygonIndices, size: 1 },
-        primitivePolygonIndices: { value: polygons.primitivePolygonIndices, size: 1 },
-        globalFeatureIds: { value: polygons.globalFeatureIds, size: 1 },
-        featureIds: { value: polygons.featureIds, size: 1 },
+        positions: {
+          value: polygons.positions,
+          size: coordLength
+        },
+        polygonIndices: {
+          value: polygons.polygonIndices,
+          size: 1
+        },
+        primitivePolygonIndices: {
+          value: polygons.primitivePolygonIndices,
+          size: 1
+        },
+        globalFeatureIds: {
+          value: polygons.globalFeatureIds,
+          size: 1
+        },
+        featureIds: {
+          value: polygons.featureIds,
+          size: 1
+        },
         numericProps: wrapProps(polygons.numericProps, 1)
       }
     };
     if (binaryFeatures.polygons && polygons.triangles) {
-      binaryFeatures.polygons.triangles = { value: new Uint32Array(polygons.triangles), size: 1 };
+      binaryFeatures.polygons.triangles = {
+        value: new Uint32Array(polygons.triangles),
+        size: 1
+      };
     }
     return binaryFeatures;
   }
@@ -2638,11 +2639,6 @@ Char: ${this.c}`;
     }
     return constructor === Float64Array || Math.fround(x) !== x ? Float64Array : Float32Array;
   }
-  var init_flat_geojson_to_binary = __esm({
-    "../gis/src/lib/flat-geojson-to-binary.ts"() {
-      init_esm();
-    }
-  });
 
   // ../gis/src/lib/extract-geometry-info.ts
   function extractGeometryInfo(features) {
@@ -2655,7 +2651,7 @@ Char: ${this.c}`;
     let polygonObjectsCount = 0;
     let polygonRingsCount = 0;
     let polygonFeaturesCount = 0;
-    const coordLengths = new Set();
+    const coordLengths = /* @__PURE__ */ new Set();
     for (const feature of features) {
       const geometry = feature.geometry;
       switch (geometry.type) {
@@ -2728,13 +2724,12 @@ Char: ${this.c}`;
       polygonFeaturesCount
     };
   }
-  var init_extract_geometry_info = __esm({
-    "../gis/src/lib/extract-geometry-info.ts"() {
-    }
-  });
 
   // ../gis/src/lib/geojson-to-flat-geojson.ts
-  function geojsonToFlatGeojson(features, options = { coordLength: 2, fixRingWinding: true }) {
+  function geojsonToFlatGeojson(features, options = {
+    coordLength: 2,
+    fixRingWinding: true
+  }) {
     return features.map((feature) => flattenFeature(feature, options));
   }
   function flattenPoint(coordinates, data, indices, options) {
@@ -2775,7 +2770,9 @@ Char: ${this.c}`;
     }
   }
   function flattenFeature(feature, options) {
-    const { geometry } = feature;
+    const {
+      geometry
+    } = feature;
     if (geometry.type === "GeometryCollection") {
       throw new Error("GeometryCollection type not supported");
     }
@@ -2813,48 +2810,81 @@ Char: ${this.c}`;
       default:
         throw new Error(`Unknown type: ${type}`);
     }
-    return { ...feature, geometry: { type, indices, data, areas } };
+    return {
+      ...feature,
+      geometry: {
+        type,
+        indices,
+        data,
+        areas
+      }
+    };
   }
-  var init_geojson_to_flat_geojson = __esm({
-    "../gis/src/lib/geojson-to-flat-geojson.ts"() {
-      init_esm();
-    }
-  });
 
   // ../gis/src/lib/geojson-to-binary.ts
-  function geojsonToBinary(features, options = { fixRingWinding: true, triangulate: true }) {
+  function geojsonToBinary(features, options = {
+    fixRingWinding: true,
+    triangulate: true
+  }) {
     const geometryInfo = extractGeometryInfo(features);
     const coordLength = geometryInfo.coordLength;
-    const { fixRingWinding } = options;
-    const flatFeatures = geojsonToFlatGeojson(features, { coordLength, fixRingWinding });
+    const {
+      fixRingWinding
+    } = options;
+    const flatFeatures = geojsonToFlatGeojson(features, {
+      coordLength,
+      fixRingWinding
+    });
     return flatGeojsonToBinary(flatFeatures, geometryInfo, {
       numericPropKeys: options.numericPropKeys,
       PositionDataType: options.PositionDataType || Float32Array,
       triangulate: options.triangulate
     });
   }
-  var init_geojson_to_binary = __esm({
-    "../gis/src/lib/geojson-to-binary.ts"() {
-      init_extract_geometry_info();
-      init_geojson_to_flat_geojson();
-      init_flat_geojson_to_binary();
-    }
-  });
-
-  // ../gis/src/index.ts
-  var init_src3 = __esm({
-    "../gis/src/index.ts"() {
-      init_geojson_to_binary();
-    }
-  });
 
   // src/geojson-loader.ts
+  var VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var GeoJSONWorkerLoader = {
+    name: "GeoJSON",
+    id: "geojson",
+    module: "geojson",
+    version: VERSION3,
+    worker: true,
+    extensions: ["geojson"],
+    mimeTypes: ["application/geo+json"],
+    category: "geometry",
+    text: true,
+    options: {
+      geojson: {
+        shape: "object-row-table"
+      },
+      json: {
+        shape: "object-row-table",
+        jsonpaths: ["$", "$.features"]
+      },
+      gis: {
+        format: "geojson"
+      }
+    }
+  };
+  var GeoJSONLoader = {
+    ...GeoJSONWorkerLoader,
+    parse: parse2,
+    parseTextSync: parseTextSync2,
+    parseInBatches: parseInBatches2
+  };
   async function parse2(arrayBuffer, options) {
     return parseTextSync2(new TextDecoder().decode(arrayBuffer), options);
   }
   function parseTextSync2(text, options) {
-    options = { ...GeoJSONLoader.options, ...options };
-    options.geojson = { ...GeoJSONLoader.options.geojson, ...options.geojson };
+    options = {
+      ...GeoJSONLoader.options,
+      ...options
+    };
+    options.geojson = {
+      ...GeoJSONLoader.options.geojson,
+      ...options.geojson
+    };
     options.gis = options.gis || {};
     let geojson;
     try {
@@ -2875,8 +2905,14 @@ Char: ${this.c}`;
     }
   }
   function parseInBatches2(asyncIterator, options) {
-    options = { ...GeoJSONLoader.options, ...options };
-    options.json = { ...GeoJSONLoader.options.geojson, ...options.geojson };
+    options = {
+      ...GeoJSONLoader.options,
+      ...options
+    };
+    options.json = {
+      ...GeoJSONLoader.options.geojson,
+      ...options.geojson
+    };
     const geojsonIterator = parseJSONInBatches(asyncIterator, options);
     switch (options.gis.format) {
       case "binary":
@@ -2891,43 +2927,6 @@ Char: ${this.c}`;
       yield batch;
     }
   }
-  var VERSION3, GeoJSONWorkerLoader, GeoJSONLoader;
-  var init_geojson_loader = __esm({
-    "src/geojson-loader.ts"() {
-      init_src3();
-      init_parse_json_in_batches();
-      VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
-      GeoJSONWorkerLoader = {
-        name: "GeoJSON",
-        id: "geojson",
-        module: "geojson",
-        version: VERSION3,
-        worker: true,
-        extensions: ["geojson"],
-        mimeTypes: ["application/geo+json"],
-        category: "geometry",
-        text: true,
-        options: {
-          geojson: {
-            shape: "object-row-table"
-          },
-          json: {
-            shape: "object-row-table",
-            jsonpaths: ["$", "$.features"]
-          },
-          gis: {
-            format: "geojson"
-          }
-        }
-      };
-      GeoJSONLoader = {
-        ...GeoJSONWorkerLoader,
-        parse: parse2,
-        parseTextSync: parseTextSync2,
-        parseInBatches: parseInBatches2
-      };
-    }
-  });
 
   // src/lib/encoder-utils/encode-utils.ts
   function detectGeometryColumnIndex(table) {
@@ -2956,11 +2955,6 @@ Char: ${this.c}`;
     }
     return properties;
   }
-  var init_encode_utils = __esm({
-    "src/lib/encoder-utils/encode-utils.ts"() {
-      init_src();
-    }
-  });
 
   // src/lib/encoder-utils/encode-table-row.ts
   function encodeTableRow(table, rowIndex, geometryColumnIndex, utf8Encoder) {
@@ -2976,7 +2970,11 @@ Char: ${this.c}`;
     const columnName = table.schema?.fields[geometryColumnIndex].name;
     let featureOrGeometry = columnName && row[columnName];
     if (!featureOrGeometry) {
-      return { type: "Feature", geometry: null, properties };
+      return {
+        type: "Feature",
+        geometry: null,
+        properties
+      };
     }
     if (typeof featureOrGeometry === "string") {
       try {
@@ -2989,53 +2987,53 @@ Char: ${this.c}`;
       throw new Error("invalid geometry column value");
     }
     if (featureOrGeometry?.type === "Feature") {
-      return { ...featureOrGeometry, properties };
+      return {
+        ...featureOrGeometry,
+        properties
+      };
     }
-    return { type: "Feature", geometry: featureOrGeometry, properties };
+    return {
+      type: "Feature",
+      geometry: featureOrGeometry,
+      properties
+    };
   }
-  var init_encode_table_row = __esm({
-    "src/lib/encoder-utils/encode-table-row.ts"() {
-      init_src();
-      init_encode_utils();
-    }
-  });
 
   // src/lib/encoder-utils/utf8-encoder.ts
-  var Utf8ArrayBufferEncoder;
-  var init_utf8_encoder = __esm({
-    "src/lib/encoder-utils/utf8-encoder.ts"() {
-      Utf8ArrayBufferEncoder = class {
-        constructor(chunkSize) {
-          this.strings = [];
-          this.totalLength = 0;
-          this.textEncoder = new TextEncoder();
-          this.chunkSize = chunkSize;
-        }
-        push(...strings) {
-          for (const string of strings) {
-            this.strings.push(string);
-            this.totalLength += string.length;
-          }
-        }
-        isFull() {
-          return this.totalLength >= this.chunkSize;
-        }
-        getArrayBufferBatch() {
-          return this.textEncoder.encode(this.getStringBatch()).buffer;
-        }
-        getStringBatch() {
-          const stringChunk = this.strings.join("");
-          this.strings = [];
-          this.totalLength = 0;
-          return stringChunk;
-        }
-      };
+  var Utf8ArrayBufferEncoder = class {
+    strings = [];
+    totalLength = 0;
+    textEncoder = new TextEncoder();
+    constructor(chunkSize) {
+      this.chunkSize = chunkSize;
+    }
+    push(...strings) {
+      for (const string of strings) {
+        this.strings.push(string);
+        this.totalLength += string.length;
+      }
     }
-  });
+    isFull() {
+      return this.totalLength >= this.chunkSize;
+    }
+    getArrayBufferBatch() {
+      return this.textEncoder.encode(this.getStringBatch()).buffer;
+    }
+    getStringBatch() {
+      const stringChunk = this.strings.join("");
+      this.strings = [];
+      this.totalLength = 0;
+      return stringChunk;
+    }
+  };
 
   // src/lib/encoders/geojson-encoder.ts
   async function* encodeTableAsGeojsonInBatches(batchIterator, inputOpts = {}) {
-    const options = { geojson: {}, chunkSize: 1e4, ...inputOpts };
+    const options = {
+      geojson: {},
+      chunkSize: 1e4,
+      ...inputOpts
+    };
     const utf8Encoder = new Utf8ArrayBufferEncoder(options.chunkSize);
     if (!options.geojson.featureArray) {
       utf8Encoder.push("{\n", '"type": "FeatureCollection",\n', '"features":\n');
@@ -3073,72 +3071,25 @@ Char: ${this.c}`;
     }
     yield utf8Encoder.getArrayBufferBatch();
   }
-  var init_geojson_encoder = __esm({
-    "src/lib/encoders/geojson-encoder.ts"() {
-      init_src();
-      init_encode_utils();
-      init_encode_table_row();
-      init_utf8_encoder();
-    }
-  });
 
   // src/geojson-writer.ts
-  var GeoJSONWriter;
-  var init_geojson_writer = __esm({
-    "src/geojson-writer.ts"() {
-      init_geojson_encoder();
-      GeoJSONWriter = {
-        id: "geojson",
-        version: "latest",
-        module: "geojson",
-        name: "GeoJSON",
-        extensions: ["geojson"],
-        mimeTypes: ["application/geo+json"],
-        options: {
-          geojson: {
-            featureArray: false,
-            geometryColumn: null
-          }
-        },
-        text: true,
-        encodeInBatches: (tableIterator, options) => encodeTableAsGeojsonInBatches(tableIterator, options)
-      };
-    }
-  });
-
-  // src/index.ts
-  var src_exports = {};
-  __export(src_exports, {
-    JSONLoader: () => JSONLoader,
-    JSONWriter: () => JSONWriter,
-    NDJSONLoader: () => NDJSONLoader,
-    _ClarinetParser: () => ClarinetParser,
-    _GeoJSONLoader: () => GeoJSONLoader,
-    _GeoJSONWorkerLoader: () => GeoJSONWorkerLoader,
-    _GeoJSONWriter: () => GeoJSONWriter,
-    _JSONPath: () => JSONPath,
-    _rebuildJsonObject: () => rebuildJsonObject
-  });
-  var init_src4 = __esm({
-    "src/index.ts"() {
-      init_json_loader();
-      init_ndjson_loader();
-      init_json_writer();
-      init_geojson_loader();
-      init_geojson_writer();
-      init_jsonpath();
-      init_clarinet();
-      init_parse_json_in_batches();
-    }
-  });
-
-  // src/bundle.ts
-  var require_bundle = __commonJS({
-    "src/bundle.ts"(exports, module) {
-      var moduleExports = (init_src4(), src_exports);
-      globalThis.loaders = globalThis.loaders || {};
-      module.exports = Object.assign(globalThis.loaders, moduleExports);
-    }
-  });
-  require_bundle();
+  var GeoJSONWriter = {
+    id: "geojson",
+    version: "latest",
+    module: "geojson",
+    name: "GeoJSON",
+    extensions: ["geojson"],
+    mimeTypes: ["application/geo+json"],
+    options: {
+      geojson: {
+        featureArray: false,
+        geometryColumn: null
+      }
+    },
+    text: true,
+    encodeInBatches: (tableIterator, options) => encodeTableAsGeojsonInBatches(tableIterator, options)
+  };
+  return __toCommonJS(src_exports);
 })();
+      return __exports__;
+      });