@loaders.gl/json 4.2.0-alpha.4 → 4.2.0-alpha.5

package/dist/dist.dev.js

@@ -2,14 +2,19 @@
   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 () {
+        else if (typeof exports === 'object') exports['loaders'] = factory();
+  else root['loaders'] = factory();})(globalThis, function () {
 "use strict";
 var __exports__ = (() => {
+  var __create = Object.create;
   var __defProp = Object.defineProperty;
   var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
   var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
   var __export = (target, all) => {
     for (var name in all)
       __defProp(target, name, { get: all[name], enumerable: true });
@@ -22,11 +27,27 @@ var __exports__ = (() => {
     }
     return to;
   };
+  var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-  // src/index.ts
-  var src_exports = {};
-  __export(src_exports, {
+  // external-global-plugin:@loaders.gl/core
+  var require_core = __commonJS({
+    "external-global-plugin:@loaders.gl/core"(exports, module) {
+      module.exports = globalThis.loaders;
+    }
+  });
+
+  // bundle.ts
+  var bundle_exports = {};
+  __export(bundle_exports, {
     JSONLoader: () => JSONLoader,
     JSONWriter: () => JSONWriter,
     NDJSONLoader: () => NDJSONLoader,
@@ -37,15 +58,16 @@ var __exports__ = (() => {
     _JSONPath: () => JSONPath,
     _rebuildJsonObject: () => rebuildJsonObject
   });
+  __reExport(bundle_exports, __toESM(require_core(), 1));
 
   // ../schema/src/lib/table/batches/base-table-batch-aggregator.ts
   var DEFAULT_ROW_COUNT = 100;
   var BaseTableBatchAggregator = class {
-    length = 0;
-    rows = null;
-    cursor = 0;
-    _headers = [];
     constructor(schema, options) {
+      this.length = 0;
+      this.rows = null;
+      this.cursor = 0;
+      this._headers = [];
       this.options = options;
       this.schema = schema;
       if (!Array.isArray(schema)) {
@@ -141,12 +163,12 @@ var __exports__ = (() => {
   // ../schema/src/lib/table/batches/row-table-batch-aggregator.ts
   var DEFAULT_ROW_COUNT2 = 100;
   var RowTableBatchAggregator = class {
-    length = 0;
-    objectRows = null;
-    arrayRows = null;
-    cursor = 0;
-    _headers = null;
     constructor(schema, options) {
+      this.length = 0;
+      this.objectRows = null;
+      this.arrayRows = null;
+      this.cursor = 0;
+      this._headers = null;
       this.options = options;
       this.schema = schema;
       if (schema) {
@@ -206,6 +228,7 @@ var __exports__ = (() => {
         batchType: "data",
         data: rows,
         length: this.length,
+        // @ts-expect-error we should infer a schema
         schema: this.schema,
         cursor: this.cursor
       };
@@ -215,10 +238,10 @@ var __exports__ = (() => {
   // ../schema/src/lib/table/batches/columnar-table-batch-aggregator.ts
   var DEFAULT_ROW_COUNT3 = 100;
   var ColumnarTableBatchAggregator = class {
-    length = 0;
-    allocated = 0;
-    columns = {};
     constructor(schema, options) {
+      this.length = 0;
+      this.allocated = 0;
+      this.columns = {};
       this.schema = schema;
       this._reallocateColumns();
     }
@@ -259,6 +282,7 @@ var __exports__ = (() => {
       };
       return batch;
     }
+    // HELPERS
     _reallocateColumns() {
       if (this.length < this.allocated) {
         return;
@@ -298,20 +322,17 @@ var __exports__ = (() => {
   };
   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.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
-      };
+      this.options = { ...DEFAULT_OPTIONS, ...options };
     }
     limitReached() {
       if (Boolean(this.options?.limit) && this.totalLength >= this.options.limit) {
@@ -322,6 +343,7 @@ var __exports__ = (() => {
       }
       return false;
     }
+    /** @deprecated Use addArrayRow or addObjectRow */
     addRow(row) {
       if (this.limitReached()) {
         return;
@@ -335,6 +357,7 @@ var __exports__ = (() => {
         this.addObjectRow(row);
       }
     }
+    /** Add one row to the batch */
     addArrayRow(row) {
       if (!this.aggregator) {
         const TableBatchType = this._getTableBatchType();
@@ -342,6 +365,7 @@ var __exports__ = (() => {
       }
       this.aggregator.addArrayRow(row);
     }
+    /** Add one row to the batch */
     addObjectRow(row) {
       if (!this.aggregator) {
         const TableBatchType = this._getTableBatchType();
@@ -349,6 +373,7 @@ var __exports__ = (() => {
       }
       this.aggregator.addObjectRow(row);
     }
+    /** Mark an incoming raw memory chunk has completed */
     chunkComplete(chunk) {
       if (chunk instanceof ArrayBuffer) {
         this.bytesUsed += chunk.byteLength;
@@ -364,6 +389,7 @@ var __exports__ = (() => {
     getFinalBatch(options) {
       return this._getBatch(options);
     }
+    // INTERNAL
     _estimateRowMB(row) {
       return Array.isArray(row) ? row.length * 8 : Object.keys(row).length * 8;
     }
@@ -385,6 +411,9 @@ var __exports__ = (() => {
       this.lastBatchEmittedMs = Date.now();
       return true;
     }
+    /**
+     * bytesUsed can be set via chunkComplete or via getBatch*
+     */
     _getBatch(options) {
       if (!this.aggregator) {
         return null;
@@ -605,22 +634,13 @@ var __exports__ = (() => {
   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) {
@@ -665,10 +685,7 @@ var __exports__ = (() => {
       const field = deduceFieldFromColumn(column, columnName);
       fields.push(field);
     }
-    return {
-      fields,
-      metadata: {}
-    };
+    return { fields, metadata: {} };
   }
   function deduceSchemaFromRows(rowTable) {
     if (!rowTable.length) {
@@ -679,10 +696,7 @@ var __exports__ = (() => {
     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)) {
@@ -691,6 +705,7 @@ var __exports__ = (() => {
         name,
         type: type.type || "null",
         nullable: type.nullable
+        // metadata: {}
       };
     }
     if (Array.isArray(column) && column.length > 0) {
@@ -700,6 +715,7 @@ var __exports__ = (() => {
         name,
         type,
         nullable: true
+        // metadata: {},
       };
     }
     throw new Error("empty table");
@@ -710,6 +726,7 @@ var __exports__ = (() => {
       name,
       type,
       nullable: true
+      // metadata: {}
     };
   }
 
@@ -718,31 +735,19 @@ var __exports__ = (() => {
     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)) {
@@ -803,7 +808,9 @@ var __exports__ = (() => {
     return concatenateArrayBuffersFromArray(sources);
   }
   function concatenateArrayBuffersFromArray(sources) {
-    const sourceArrays = sources.map((source2) => source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2);
+    const sourceArrays = sources.map(
+      (source2) => source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2
+    );
     const byteLength = sourceArrays.reduce((length, typedArray) => length + typedArray.byteLength, 0);
     const result = new Uint8Array(byteLength);
     let offset = 0;
@@ -818,9 +825,7 @@ var __exports__ = (() => {
   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) {
@@ -841,10 +846,7 @@ var __exports__ = (() => {
   async function* makeNumberedLineIterator(lineIterator) {
     let counter = 1;
     for await (const line of lineIterator) {
-      yield {
-        counter,
-        line
-      };
+      yield { counter, line };
       counter++;
     }
   }
@@ -906,62 +908,63 @@ var __exports__ = (() => {
 
   // src/lib/clarinet/clarinet.ts
   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,
+    // \t
     lineFeed: 10,
+    // \n
     carriageReturn: 13,
+    // \r
     space: 32,
+    // " "
     doubleQuote: 34,
+    // "
     plus: 43,
+    // +
     comma: 44,
+    // ,
     minus: 45,
+    // -
     period: 46,
+    // .
     _0: 48,
+    // 0
     _9: 57,
+    // 9
     colon: 58,
+    // :
     E: 69,
+    // E
     openBracket: 91,
+    // [
     backslash: 92,
+    // \
     closeBracket: 93,
+    // ]
     a: 97,
+    // a
     b: 98,
+    // b
     e: 101,
+    // e
     f: 102,
+    // f
     l: 108,
+    // l
     n: 110,
+    // n
     r: 114,
+    // r
     s: 115,
+    // s
     t: 116,
+    // t
     u: 117,
+    // u
     openBrace: 123,
+    // {
     closeBrace: 125
+    // }
   };
   var stringTokenPattern = /[\\"\n]/g;
   var DEFAULT_OPTIONS2 = {
@@ -987,35 +990,34 @@ var __exports__ = (() => {
     }
   };
   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
-      };
+      this.options = DEFAULT_OPTIONS2;
+      this.bufferCheckPosition = MAX_BUFFER_LENGTH;
+      this.q = "";
+      this.c = "";
+      this.p = "";
+      this.closed = false;
+      this.closedRoot = false;
+      this.sawRoot = false;
+      // tag = null;
+      this.error = null;
+      this.state = 0 /* BEGIN */;
+      this.stack = [];
+      // mostly just for error reporting
+      this.position = 0;
+      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 !== STATE.VALUE || this.depth !== 0)
+      if (this.state !== 1 /* VALUE */ || this.depth !== 0)
         this._error("Unexpected end");
       this._closeValue();
       this.c = "";
@@ -1030,6 +1032,7 @@ var __exports__ = (() => {
     close() {
       return this.write(null);
     }
+    // protected
     emit(event, data) {
       this.options[event]?.(data, this);
     }
@@ -1037,6 +1040,8 @@ var __exports__ = (() => {
       this._closeValue();
       this.emit(event, data);
     }
+    /* eslint-disable no-continue */
+    // eslint-disable-next-line complexity, max-statements
     write(chunk) {
       if (this.error) {
         throw this.error;
@@ -1067,111 +1072,111 @@ var __exports__ = (() => {
         } else
           this.column++;
         switch (this.state) {
-          case STATE.BEGIN:
+          case 0 /* BEGIN */:
             if (c === Char.openBrace)
-              this.state = STATE.OPEN_OBJECT;
+              this.state = 2 /* OPEN_OBJECT */;
             else if (c === Char.openBracket)
-              this.state = STATE.OPEN_ARRAY;
+              this.state = 4 /* OPEN_ARRAY */;
             else if (!isWhitespace(c)) {
               this._error("Non-whitespace before {[.");
             }
             continue;
-          case STATE.OPEN_KEY:
-          case STATE.OPEN_OBJECT:
+          case 10 /* OPEN_KEY */:
+          case 2 /* OPEN_OBJECT */:
             if (isWhitespace(c))
               continue;
-            if (this.state === STATE.OPEN_KEY)
-              this.stack.push(STATE.CLOSE_KEY);
+            if (this.state === 10 /* OPEN_KEY */)
+              this.stack.push(11 /* CLOSE_KEY */);
             else if (c === Char.closeBrace) {
               this.emit("onopenobject");
               this.depth++;
               this.emit("oncloseobject");
               this.depth--;
-              this.state = this.stack.pop() || STATE.VALUE;
+              this.state = this.stack.pop() || 1 /* VALUE */;
               continue;
             } else
-              this.stack.push(STATE.CLOSE_OBJECT);
+              this.stack.push(3 /* CLOSE_OBJECT */);
             if (c === Char.doubleQuote)
-              this.state = STATE.STRING;
+              this.state = 7 /* STRING */;
             else
               this._error('Malformed object key should start with "');
             continue;
-          case STATE.CLOSE_KEY:
-          case STATE.CLOSE_OBJECT:
+          case 11 /* CLOSE_KEY */:
+          case 3 /* CLOSE_OBJECT */:
             if (isWhitespace(c))
               continue;
             if (c === Char.colon) {
-              if (this.state === STATE.CLOSE_OBJECT) {
-                this.stack.push(STATE.CLOSE_OBJECT);
+              if (this.state === 3 /* CLOSE_OBJECT */) {
+                this.stack.push(3 /* CLOSE_OBJECT */);
                 this._closeValue("onopenobject");
                 this.depth++;
               } else
                 this._closeValue("onkey");
-              this.state = STATE.VALUE;
+              this.state = 1 /* VALUE */;
             } else if (c === Char.closeBrace) {
               this.emitNode("oncloseobject");
               this.depth--;
-              this.state = this.stack.pop() || STATE.VALUE;
+              this.state = this.stack.pop() || 1 /* VALUE */;
             } else if (c === Char.comma) {
-              if (this.state === STATE.CLOSE_OBJECT)
-                this.stack.push(STATE.CLOSE_OBJECT);
+              if (this.state === 3 /* CLOSE_OBJECT */)
+                this.stack.push(3 /* CLOSE_OBJECT */);
               this._closeValue();
-              this.state = STATE.OPEN_KEY;
+              this.state = 10 /* OPEN_KEY */;
             } else
               this._error("Bad object");
             continue;
-          case STATE.OPEN_ARRAY:
-          case STATE.VALUE:
+          case 4 /* OPEN_ARRAY */:
+          case 1 /* VALUE */:
             if (isWhitespace(c))
               continue;
-            if (this.state === STATE.OPEN_ARRAY) {
+            if (this.state === 4 /* OPEN_ARRAY */) {
               this.emit("onopenarray");
               this.depth++;
-              this.state = STATE.VALUE;
+              this.state = 1 /* VALUE */;
               if (c === Char.closeBracket) {
                 this.emit("onclosearray");
                 this.depth--;
-                this.state = this.stack.pop() || STATE.VALUE;
+                this.state = this.stack.pop() || 1 /* VALUE */;
                 continue;
               } else {
-                this.stack.push(STATE.CLOSE_ARRAY);
+                this.stack.push(5 /* CLOSE_ARRAY */);
               }
             }
             if (c === Char.doubleQuote)
-              this.state = STATE.STRING;
+              this.state = 7 /* STRING */;
             else if (c === Char.openBrace)
-              this.state = STATE.OPEN_OBJECT;
+              this.state = 2 /* OPEN_OBJECT */;
             else if (c === Char.openBracket)
-              this.state = STATE.OPEN_ARRAY;
+              this.state = 4 /* OPEN_ARRAY */;
             else if (c === Char.t)
-              this.state = STATE.TRUE;
+              this.state = 12 /* TRUE */;
             else if (c === Char.f)
-              this.state = STATE.FALSE;
+              this.state = 15 /* FALSE */;
             else if (c === Char.n)
-              this.state = STATE.NULL;
+              this.state = 19 /* 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;
+              this.state = 23 /* NUMBER_DIGIT */;
             } else
               this._error("Bad value");
             continue;
-          case STATE.CLOSE_ARRAY:
+          case 5 /* CLOSE_ARRAY */:
             if (c === Char.comma) {
-              this.stack.push(STATE.CLOSE_ARRAY);
+              this.stack.push(5 /* CLOSE_ARRAY */);
               this._closeValue("onvalue");
-              this.state = STATE.VALUE;
+              this.state = 1 /* VALUE */;
             } else if (c === Char.closeBracket) {
               this.emitNode("onclosearray");
               this.depth--;
-              this.state = this.stack.pop() || STATE.VALUE;
+              this.state = this.stack.pop() || 1 /* VALUE */;
             } else if (isWhitespace(c))
               continue;
             else
               this._error("Bad array");
             continue;
-          case STATE.STRING:
+          case 7 /* STRING */:
             if (this.textNode === void 0) {
               this.textNode = "";
             }
@@ -1195,7 +1200,7 @@ var __exports__ = (() => {
                     break STRING_BIGLOOP;
                 }
                 if (c === Char.doubleQuote && !slashed) {
-                  this.state = this.stack.pop() || STATE.VALUE;
+                  this.state = this.stack.pop() || 1 /* VALUE */;
                   this.textNode += chunk.substring(starti, i - 1);
                   this.position += i - 1 - starti;
                   break;
@@ -1254,77 +1259,77 @@ var __exports__ = (() => {
             this.slashed = slashed;
             this.unicodeI = unicodeI;
             continue;
-          case STATE.TRUE:
+          case 12 /* TRUE */:
             if (c === Char.r)
-              this.state = STATE.TRUE2;
+              this.state = 13 /* TRUE2 */;
             else
               this._error(`Invalid true started with t${c}`);
             continue;
-          case STATE.TRUE2:
+          case 13 /* TRUE2 */:
             if (c === Char.u)
-              this.state = STATE.TRUE3;
+              this.state = 14 /* TRUE3 */;
             else
               this._error(`Invalid true started with tr${c}`);
             continue;
-          case STATE.TRUE3:
+          case 14 /* TRUE3 */:
             if (c === Char.e) {
               this.emit("onvalue", true);
-              this.state = this.stack.pop() || STATE.VALUE;
+              this.state = this.stack.pop() || 1 /* VALUE */;
             } else
               this._error(`Invalid true started with tru${c}`);
             continue;
-          case STATE.FALSE:
+          case 15 /* FALSE */:
             if (c === Char.a)
-              this.state = STATE.FALSE2;
+              this.state = 16 /* FALSE2 */;
             else
               this._error(`Invalid false started with f${c}`);
             continue;
-          case STATE.FALSE2:
+          case 16 /* FALSE2 */:
             if (c === Char.l)
-              this.state = STATE.FALSE3;
+              this.state = 17 /* FALSE3 */;
             else
               this._error(`Invalid false started with fa${c}`);
             continue;
-          case STATE.FALSE3:
+          case 17 /* FALSE3 */:
             if (c === Char.s)
-              this.state = STATE.FALSE4;
+              this.state = 18 /* FALSE4 */;
             else
               this._error(`Invalid false started with fal${c}`);
             continue;
-          case STATE.FALSE4:
+          case 18 /* FALSE4 */:
             if (c === Char.e) {
               this.emit("onvalue", false);
-              this.state = this.stack.pop() || STATE.VALUE;
+              this.state = this.stack.pop() || 1 /* VALUE */;
             } else
               this._error(`Invalid false started with fals${c}`);
             continue;
-          case STATE.NULL:
+          case 19 /* NULL */:
             if (c === Char.u)
-              this.state = STATE.NULL2;
+              this.state = 20 /* NULL2 */;
             else
               this._error(`Invalid null started with n${c}`);
             continue;
-          case STATE.NULL2:
+          case 20 /* NULL2 */:
             if (c === Char.l)
-              this.state = STATE.NULL3;
+              this.state = 21 /* NULL3 */;
             else
               this._error(`Invalid null started with nu${c}`);
             continue;
-          case STATE.NULL3:
+          case 21 /* NULL3 */:
             if (c === Char.l) {
               this.emit("onvalue", null);
-              this.state = this.stack.pop() || STATE.VALUE;
+              this.state = this.stack.pop() || 1 /* VALUE */;
             } else
               this._error(`Invalid null started with nul${c}`);
             continue;
-          case STATE.NUMBER_DECIMAL_POINT:
+          case 22 /* NUMBER_DECIMAL_POINT */:
             if (c === Char.period) {
               this.numberNode += ".";
-              this.state = STATE.NUMBER_DIGIT;
+              this.state = 23 /* NUMBER_DIGIT */;
             } else
               this._error("Leading zero not followed by .");
             continue;
-          case STATE.NUMBER_DIGIT:
+          case 23 /* NUMBER_DIGIT */:
             if (Char._0 <= c && c <= Char._9)
               this.numberNode += String.fromCharCode(c);
             else if (c === Char.period) {
@@ -1342,7 +1347,7 @@ var __exports__ = (() => {
             } else {
               this._closeNumber();
               i--;
-              this.state = this.stack.pop() || STATE.VALUE;
+              this.state = this.stack.pop() || 1 /* VALUE */;
             }
             continue;
           default:
@@ -1443,6 +1448,12 @@ Char: ${this.c}`;
       }
       return true;
     }
+    /**
+     * Sets the value pointed at by path
+     * TODO - handle root path
+     * @param object
+     * @param value
+     */
     setFieldAtPath(object, value) {
       const path = [...this.path];
       path.shift();
@@ -1452,6 +1463,11 @@ Char: ${this.c}`;
       }
       object[field] = value;
     }
+    /**
+     * Gets the value pointed at by path
+     * TODO - handle root path
+     * @param object
+     */
     getFieldAtPath(object) {
       const path = [...this.path];
       path.shift();
@@ -1465,14 +1481,11 @@ Char: ${this.c}`;
 
   // src/lib/json-parser/json-parser.ts
   var JSONParser = class {
-    result = void 0;
-    previousStates = [];
-    currentState = Object.freeze({
-      container: [],
-      key: null
-    });
-    jsonpath = new JSONPath();
     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: () => {
@@ -1514,10 +1527,7 @@ Char: ${this.c}`;
     reset() {
       this.result = void 0;
       this.previousStates = [];
-      this.currentState = Object.freeze({
-        container: [],
-        key: null
-      });
+      this.currentState = Object.freeze({ container: [], key: null });
       this.jsonpath = new JSONPath();
     }
     write(chunk) {
@@ -1526,11 +1536,9 @@ Char: ${this.c}`;
     close() {
       this.parser.close();
     }
+    // PRIVATE METHODS
     _pushOrSet(value) {
-      const {
-        container,
-        key
-      } = this.currentState;
+      const { container, key } = this.currentState;
       if (key !== null) {
         container[key] = value;
         this.currentState.key = null;
@@ -1542,11 +1550,7 @@ Char: ${this.c}`;
       this.jsonpath.push(null);
       this._pushOrSet(newContainer);
       this.previousStates.push(this.currentState);
-      this.currentState = {
-        container: newContainer,
-        isArray: true,
-        key: null
-      };
+      this.currentState = { container: newContainer, isArray: true, key: null };
     }
     _closeArray() {
       this.jsonpath.pop();
@@ -1556,11 +1560,7 @@ Char: ${this.c}`;
       this.jsonpath.push(null);
       this._pushOrSet(newContainer);
       this.previousStates.push(this.currentState);
-      this.currentState = {
-        container: newContainer,
-        isArray: false,
-        key: null
-      };
+      this.currentState = { container: newContainer, isArray: false, key: null };
     }
     _closeObject() {
       this.jsonpath.pop();
@@ -1570,9 +1570,6 @@ Char: ${this.c}`;
 
   // src/lib/json-parser/streaming-json-parser.ts
   var StreamingJSONParser = class extends JSONParser {
-    streamingJsonPath = null;
-    streamingArray = null;
-    topLevelObject = null;
     constructor(options = {}) {
       super({
         onopenarray: () => {
@@ -1586,6 +1583,7 @@ Char: ${this.c}`;
           }
           this._openArray();
         },
+        // Redefine onopenarray to inject value for top-level object
         onopenobject: (name) => {
           if (!this.topLevelObject) {
             this.topLevelObject = {};
@@ -1598,9 +1596,19 @@ Char: ${this.c}`;
           }
         }
       });
+      this.streamingJsonPath = null;
+      this.streamingArray = null;
+      this.topLevelObject = null;
       const jsonpaths = options.jsonpaths || [];
       this.jsonPaths = jsonpaths.map((jsonpath) => new JSONPath(jsonpath));
     }
+    /**
+     * write REDEFINITION
+     * - super.write() chunk to parser
+     * - get the contents (so far) of "topmost-level" array as batch of rows
+     * - clear top-level array
+     * - return the batch of rows\
+     */
     write(chunk) {
       super.write(chunk);
       let array = [];
@@ -1610,6 +1618,11 @@ Char: ${this.c}`;
       }
       return array;
     }
+    /**
+     * Returns a partially formed result object
+     * Useful for returning the "wrapper" object when array is not top level
+     * e.g. GeoJSON
+     */
     getPartialResult() {
       return this.topLevelObject;
     }
@@ -1622,6 +1635,10 @@ Char: ${this.c}`;
     getJsonPath() {
       return this.jsonpath;
     }
+    // PRIVATE METHODS
+    /**
+     * Checks is this.getJsonPath matches the jsonpaths provided in options
+     */
     _matchJSONPath() {
       const currentPath = this.getJsonPath();
       if (this.jsonPaths.length === 0) {
@@ -1639,29 +1656,25 @@ Char: ${this.c}`;
   // 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 tableBatchBuilder = new TableBatchBuilder(schema, options);
-    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();
       if (rows.length > 0 && isFirstChunk) {
         if (metadata) {
           const initialBatch = {
+            // Common fields
             shape: options?.json?.shape || "array-row-table",
             batchType: "partial-result",
             data: [],
             length: 0,
             bytesUsed: 0,
+            // JSON additions
             container: parser.getPartialResult(),
             jsonpath: jsonpath2
           };
@@ -1671,25 +1684,19 @@ 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;
     }
@@ -1699,8 +1706,10 @@ Char: ${this.c}`;
         batchType: "final-result",
         container: parser.getPartialResult(),
         jsonpath: parser.getStreamingJsonPathAsString(),
+        /** Data Just to avoid crashing? */
         data: [],
         length: 0
+        // schema: null
       };
       yield finalBatch;
     }
@@ -1720,7 +1729,7 @@ Char: ${this.c}`;
   }
 
   // src/json-loader.ts
-  var VERSION = true ? "4.2.0-alpha.4" : "latest";
+  var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
   var JSONLoader = {
     name: "JSON",
     id: "json",
@@ -1735,6 +1744,7 @@ Char: ${this.c}`;
         shape: void 0,
         table: false,
         jsonpaths: []
+        // batchSize: 'auto'
       }
     },
     parse,
@@ -1745,23 +1755,11 @@ Char: ${this.c}`;
     return parseTextSync(new TextDecoder().decode(arrayBuffer), options);
   }
   function parseTextSync(text, options) {
-    const jsonOptions = {
-      ...options,
-      json: {
-        ...JSONLoader.options.json,
-        ...options?.json
-      }
-    };
+    const jsonOptions = { ...options, json: { ...JSONLoader.options.json, ...options?.json } };
     return parseJSONSync(text, jsonOptions);
   }
   function parseInBatches(asyncIterator, options) {
-    const jsonOptions = {
-      ...options,
-      json: {
-        ...JSONLoader.options.json,
-        ...options?.json
-      }
-    };
+    const jsonOptions = { ...options, json: { ...JSONLoader.options.json, ...options?.json } };
     return parseJSONInBatches(asyncIterator, jsonOptions);
   }
 
@@ -1789,10 +1787,7 @@ 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);
@@ -1812,14 +1807,19 @@ Char: ${this.c}`;
   }
 
   // src/ndjson-loader.ts
-  var VERSION2 = true ? "4.2.0-alpha.4" : "latest";
+  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"],
+    mimeTypes: [
+      "application/x-ndjson",
+      "application/jsonlines",
+      // https://docs.aws.amazon.com/sagemaker/latest/dg/cdf-inference.html#cm-batch
+      "application/json-seq"
+    ],
     category: "table",
     text: true,
     parse: async (arrayBuffer) => parseNDJSONSync(new TextDecoder().decode(arrayBuffer)),
@@ -2370,14 +2370,18 @@ Char: ${this.c}`;
   function flatGeojsonToBinary(features, geometryInfo, options) {
     const propArrayTypes = extractNumericPropTypes(features);
     const numericPropKeys = Object.keys(propArrayTypes).filter((k) => propArrayTypes[k] !== Array);
-    return fillArrays(features, {
-      propArrayTypes,
-      ...geometryInfo
-    }, {
-      numericPropKeys: options && options.numericPropKeys || numericPropKeys,
-      PositionDataType: options ? options.PositionDataType : Float32Array,
-      triangulate: options ? options.triangulate : true
-    });
+    return fillArrays(
+      features,
+      {
+        propArrayTypes,
+        ...geometryInfo
+      },
+      {
+        numericPropKeys: options && options.numericPropKeys || numericPropKeys,
+        PositionDataType: options ? options.PositionDataType : Float32Array,
+        triangulate: options ? options.triangulate : true
+      }
+    );
   }
   function extractNumericPropTypes(features) {
     const propArrayTypes = {};
@@ -2405,11 +2409,7 @@ 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 = {
@@ -2474,9 +2474,7 @@ 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;
@@ -2484,9 +2482,7 @@ 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;
@@ -2494,9 +2490,7 @@ 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;
@@ -2511,16 +2505,32 @@ Char: ${this.c}`;
     points.positions.set(geometry.data, indexMap.pointPosition * coordLength);
     const nPositions = geometry.data.length / coordLength;
     fillNumericProperties(points, properties, indexMap.pointPosition, nPositions);
-    points.globalFeatureIds.fill(indexMap.feature, indexMap.pointPosition, indexMap.pointPosition + nPositions);
-    points.featureIds.fill(indexMap.pointFeature, indexMap.pointPosition, indexMap.pointPosition + nPositions);
+    points.globalFeatureIds.fill(
+      indexMap.feature,
+      indexMap.pointPosition,
+      indexMap.pointPosition + nPositions
+    );
+    points.featureIds.fill(
+      indexMap.pointFeature,
+      indexMap.pointPosition,
+      indexMap.pointPosition + nPositions
+    );
     indexMap.pointPosition += nPositions;
   }
   function handleLineString(geometry, lines, indexMap, coordLength, properties) {
     lines.positions.set(geometry.data, indexMap.linePosition * coordLength);
     const nPositions = geometry.data.length / coordLength;
     fillNumericProperties(lines, properties, indexMap.linePosition, nPositions);
-    lines.globalFeatureIds.fill(indexMap.feature, indexMap.linePosition, indexMap.linePosition + nPositions);
-    lines.featureIds.fill(indexMap.lineFeature, indexMap.linePosition, indexMap.linePosition + nPositions);
+    lines.globalFeatureIds.fill(
+      indexMap.feature,
+      indexMap.linePosition,
+      indexMap.linePosition + nPositions
+    );
+    lines.featureIds.fill(
+      indexMap.lineFeature,
+      indexMap.linePosition,
+      indexMap.linePosition + nPositions
+    );
     for (let i = 0, il = geometry.indices.length; i < il; ++i) {
       const start = geometry.indices[i];
       const end = i === il - 1 ? geometry.data.length : geometry.indices[i + 1];
@@ -2532,8 +2542,16 @@ Char: ${this.c}`;
     polygons.positions.set(geometry.data, indexMap.polygonPosition * coordLength);
     const nPositions = geometry.data.length / coordLength;
     fillNumericProperties(polygons, properties, indexMap.polygonPosition, nPositions);
-    polygons.globalFeatureIds.fill(indexMap.feature, indexMap.polygonPosition, indexMap.polygonPosition + nPositions);
-    polygons.featureIds.fill(indexMap.polygonFeature, indexMap.polygonPosition, indexMap.polygonPosition + nPositions);
+    polygons.globalFeatureIds.fill(
+      indexMap.feature,
+      indexMap.polygonPosition,
+      indexMap.polygonPosition + nPositions
+    );
+    polygons.featureIds.fill(
+      indexMap.polygonFeature,
+      indexMap.polygonPosition,
+      indexMap.polygonPosition + nPositions
+    );
     for (let l = 0, ll = geometry.indices.length; l < ll; ++l) {
       const startPosition = indexMap.polygonPosition;
       polygons.polygonIndices[indexMap.polygonObject++] = startPosition;
@@ -2542,16 +2560,15 @@ Char: ${this.c}`;
       const nextIndices = geometry.indices[l + 1];
       for (let i = 0, il = indices.length; i < il; ++i) {
         const start = indices[i];
-        const end = i === il - 1 ? nextIndices === void 0 ? geometry.data.length : nextIndices[0] : indices[i + 1];
+        const end = i === il - 1 ? (
+          // last line, so either read to:
+          nextIndices === void 0 ? geometry.data.length : nextIndices[0]
+        ) : indices[i + 1];
         polygons.primitivePolygonIndices[indexMap.polygonRing++] = indexMap.polygonPosition;
         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, {
@@ -2575,10 +2592,7 @@ 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,70 +2601,32 @@ Char: ${this.c}`;
       shape: "binary-feature-collection",
       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)
       }
+      // triangles not expected
     };
     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;
   }
@@ -2764,10 +2740,7 @@ Char: ${this.c}`;
   }
 
   // ../gis/src/lib/binary-features/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) {
@@ -2808,9 +2781,7 @@ Char: ${this.c}`;
     }
   }
   function flattenFeature(feature, options) {
-    const {
-      geometry
-    } = feature;
+    const { geometry } = feature;
     if (geometry.type === "GeometryCollection") {
       throw new Error("GeometryCollection type not supported");
     }
@@ -2848,31 +2819,15 @@ Char: ${this.c}`;
       default:
         throw new Error(`Unknown type: ${type}`);
     }
-    return {
-      ...feature,
-      geometry: {
-        type,
-        indices,
-        data,
-        areas
-      }
-    };
+    return { ...feature, geometry: { type, indices, data, areas } };
   }
 
   // ../gis/src/lib/binary-features/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,
@@ -2881,7 +2836,7 @@ Char: ${this.c}`;
   }
 
   // src/geojson-loader.ts
-  var VERSION3 = true ? "4.2.0-alpha.4" : "latest";
+  var VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
   var GeoJSONWorkerLoader = {
     name: "GeoJSON",
     id: "geojson",
@@ -2907,7 +2862,9 @@ Char: ${this.c}`;
   };
   var GeoJSONLoader = {
     ...GeoJSONWorkerLoader,
+    // @ts-expect-error
     parse: parse2,
+    // @ts-expect-error
     parseTextSync: parseTextSync2,
     parseInBatches: parseInBatches2
   };
@@ -2915,14 +2872,8 @@ Char: ${this.c}`;
     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 {
@@ -2932,6 +2883,8 @@ Char: ${this.c}`;
     }
     const table = {
       shape: "geojson-table",
+      // TODO - deduce schema from geojson
+      // TODO check that parsed data is of type FeatureCollection
       type: "FeatureCollection",
       features: geojson?.features || []
     };
@@ -2943,14 +2896,8 @@ 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":
@@ -3008,11 +2955,7 @@ 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 {
@@ -3025,24 +2968,17 @@ 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 };
   }
 
   // src/lib/encoder-utils/utf8-encoder.ts
   var Utf8ArrayBufferEncoder = class {
-    strings = [];
-    totalLength = 0;
-    textEncoder = new TextEncoder();
     constructor(chunkSize) {
+      this.strings = [];
+      this.totalLength = 0;
+      this.textEncoder = new TextEncoder();
       this.chunkSize = chunkSize;
     }
     push(...strings) {
@@ -3067,11 +3003,7 @@ Char: ${this.c}`;
 
   // 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');
@@ -3132,7 +3064,7 @@ Char: ${this.c}`;
     },
     encodeInBatches: (tableIterator, options) => encodeTableAsGeojsonInBatches(tableIterator, options)
   };
-  return __toCommonJS(src_exports);
+  return __toCommonJS(bundle_exports);
 })();
       return __exports__;
       });