@loaders.gl/json 4.0.0-alpha.5 → 4.0.0-alpha.7

package/dist/dist.min.js

@@ -13,43 +13,12 @@
       __defProp(target, name, { get: all[name], enumerable: true });
   };
 
-  // src/lib/parse-json.ts
-  function parseJSONSync(jsonText, options) {
-    try {
-      const json = JSON.parse(jsonText);
-      if (options.json?.table) {
-        return getFirstArray(json) || json;
-      }
-      return json;
-    } catch (error) {
-      throw new Error("JSONLoader: failed to parse JSON");
-    }
-  }
-  function getFirstArray(json) {
-    if (Array.isArray(json)) {
-      return json;
-    }
-    if (json && typeof json === "object") {
-      for (const value of Object.values(json)) {
-        const array = getFirstArray(value);
-        if (array) {
-          return array;
-        }
-      }
-    }
-    return null;
-  }
-  var init_parse_json = __esm({
-    "src/lib/parse-json.ts"() {
-    }
-  });
-
-  // ../schema/src/lib/batches/base-table-batch-aggregator.ts
-  var DEFAULT_ROW_COUNT, RowTableBatchAggregator;
+  // ../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/batches/base-table-batch-aggregator.ts"() {
+    "../schema/src/lib/table/batches/base-table-batch-aggregator.ts"() {
       DEFAULT_ROW_COUNT = 100;
-      RowTableBatchAggregator = class {
+      BaseTableBatchAggregator = class {
         constructor(schema, options) {
           this.length = 0;
           this.rows = null;
@@ -104,7 +73,7 @@
     }
   });
 
-  // ../schema/src/lib/utils/row-utils.ts
+  // ../schema/src/lib/table/simple-table/row-utils.ts
   function convertToObjectRow(arrayRow, headers) {
     if (!arrayRow) {
       throw new Error("null row");
@@ -132,17 +101,17 @@
     return arrayRow;
   }
   var init_row_utils = __esm({
-    "../schema/src/lib/utils/row-utils.ts"() {
+    "../schema/src/lib/table/simple-table/row-utils.ts"() {
     }
   });
 
-  // ../schema/src/lib/batches/row-table-batch-aggregator.ts
-  var DEFAULT_ROW_COUNT2, RowTableBatchAggregator2;
+  // ../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/batches/row-table-batch-aggregator.ts"() {
+    "../schema/src/lib/table/batches/row-table-batch-aggregator.ts"() {
       init_row_utils();
       DEFAULT_ROW_COUNT2 = 100;
-      RowTableBatchAggregator2 = class {
+      RowTableBatchAggregator = class {
         constructor(schema, options) {
           this.length = 0;
           this.objectRows = null;
@@ -214,10 +183,10 @@
     }
   });
 
-  // ../schema/src/lib/batches/columnar-table-batch-aggregator.ts
+  // ../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/batches/columnar-table-batch-aggregator.ts"() {
+    "../schema/src/lib/table/batches/columnar-table-batch-aggregator.ts"() {
       DEFAULT_ROW_COUNT3 = 100;
       ColumnarTableBatchAggregator = class {
         constructor(schema, options) {
@@ -295,10 +264,10 @@
     }
   });
 
-  // ../schema/src/lib/batches/table-batch-builder.ts
+  // ../schema/src/lib/table/batches/table-batch-builder.ts
   var DEFAULT_OPTIONS, ERR_MESSAGE, TableBatchBuilder;
   var init_table_batch_builder = __esm({
-    "../schema/src/lib/batches/table-batch-builder.ts"() {
+    "../schema/src/lib/table/batches/table-batch-builder.ts"() {
       init_base_table_batch_aggregator();
       init_row_table_batch_aggregator();
       init_columnar_table_batch_aggregator();
@@ -413,10 +382,10 @@
         _getTableBatchType() {
           switch (this.options.shape) {
             case "row-table":
-              return RowTableBatchAggregator;
+              return BaseTableBatchAggregator;
             case "array-row-table":
             case "object-row-table":
-              return RowTableBatchAggregator2;
+              return RowTableBatchAggregator;
             case "columnar-table":
               return ColumnarTableBatchAggregator;
             case "arrow-table":
@@ -432,10 +401,359 @@
     }
   });
 
+  // ../schema/src/lib/table/simple-table/table-accessors.ts
+  function getTableLength(table) {
+    switch (table.shape) {
+      case "array-row-table":
+      case "object-row-table":
+      case "geojson-row-table":
+        return table.data.length;
+      case "arrow-table":
+        return table.data.numRows;
+      case "columnar-table":
+        for (const column of Object.values(table.data)) {
+          return column.length || 0;
+        }
+        return 0;
+      default:
+        throw new Error("table");
+    }
+  }
+  function getTableNumCols(table) {
+    if (table.schema) {
+      return table.schema.fields.length;
+    }
+    if (getTableLength(table) === 0) {
+      throw new Error("empty table");
+    }
+    switch (table.shape) {
+      case "array-row-table":
+        return table.data[0].length;
+      case "object-row-table":
+      case "geojson-row-table":
+        return Object.keys(table.data[0]).length;
+      case "columnar-table":
+        return Object.keys(table.data).length;
+      case "arrow-table":
+        return table.data.numCols;
+      default:
+        throw new Error("table");
+    }
+  }
+  function getTableRowAsObject(table, rowIndex, target, copy2) {
+    switch (table.shape) {
+      case "object-row-table":
+        return copy2 ? Object.fromEntries(Object.entries(table.data[rowIndex])) : table.data[rowIndex];
+      case "array-row-table":
+      case "geojson-row-table":
+        if (table.schema) {
+          const objectRow2 = target || {};
+          for (let i = 0; i < table.schema.fields.length; i++) {
+            objectRow2[table.schema.fields[i].name] = table.data[rowIndex][i];
+          }
+          return objectRow2;
+        }
+        throw new Error("no schema");
+      case "columnar-table":
+        if (table.schema) {
+          const objectRow2 = target || {};
+          for (let i = 0; i < table.schema.fields.length; i++) {
+            objectRow2[table.schema.fields[i].name] = table.data[table.schema.fields[i].name][rowIndex];
+          }
+          return objectRow2;
+        } else {
+          const objectRow2 = target || {};
+          for (const [name, column] of Object.entries(table.data)) {
+            objectRow2[name] = column[rowIndex];
+          }
+          return objectRow2;
+        }
+      case "arrow-table":
+        const objectRow = target || {};
+        const row = table.data.get(rowIndex);
+        const schema = table.data.schema;
+        for (let i = 0; i < schema.fields.length; i++) {
+          objectRow[schema.fields[i].name] = row?.[schema.fields[i].name];
+        }
+        return objectRow;
+      default:
+        throw new Error("shape");
+    }
+  }
+  function getTableRowAsArray(table, rowIndex, target, copy2) {
+    switch (table.shape) {
+      case "array-row-table":
+        return copy2 ? Array.from(table.data[rowIndex]) : table.data[rowIndex];
+      case "object-row-table":
+      case "geojson-row-table":
+        if (table.schema) {
+          const arrayRow2 = target || [];
+          for (let i = 0; i < table.schema.fields.length; i++) {
+            arrayRow2[i] = table.data[rowIndex][table.schema.fields[i].name];
+          }
+          return arrayRow2;
+        }
+        return Object.values(table.data[rowIndex]);
+      case "columnar-table":
+        if (table.schema) {
+          const arrayRow2 = target || [];
+          for (let i = 0; i < table.schema.fields.length; i++) {
+            arrayRow2[i] = table.data[table.schema.fields[i].name][rowIndex];
+          }
+          return arrayRow2;
+        } else {
+          const arrayRow2 = target || [];
+          let i = 0;
+          for (const column of Object.values(table.data)) {
+            arrayRow2[i] = column[rowIndex];
+            i++;
+          }
+          return arrayRow2;
+        }
+      case "arrow-table":
+        const arrayRow = target || [];
+        const row = table.data.get(rowIndex);
+        const schema = table.data.schema;
+        for (let i = 0; i < schema.fields.length; i++) {
+          arrayRow[i] = row?.[schema.fields[i].name];
+        }
+        return arrayRow;
+      default:
+        throw new Error("shape");
+    }
+  }
+  function* makeRowIterator(table, shape) {
+    switch (shape) {
+      case "array-row-table":
+        yield* makeArrayRowIterator(table);
+        break;
+      case "object-row-table":
+        yield* makeObjectRowIterator(table);
+        break;
+      default:
+        throw new Error(`Unknown row type ${shape}`);
+    }
+  }
+  function* makeArrayRowIterator(table, target = []) {
+    const length = getTableLength(table);
+    for (let rowIndex = 0; rowIndex < length; rowIndex++) {
+      yield getTableRowAsArray(table, rowIndex, target);
+    }
+  }
+  function* makeObjectRowIterator(table, target = {}) {
+    const length = getTableLength(table);
+    for (let rowIndex = 0; rowIndex < length; rowIndex++) {
+      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") {
+    if (value instanceof Date) {
+      return "date-millisecond";
+    }
+    if (value instanceof Number) {
+      return defaultNumberType;
+    }
+    if (typeof value === "string") {
+      return "utf8";
+    }
+    if (value === null || value === "undefined") {
+      return "null";
+    }
+    return "null";
+  }
+  function getDataTypeFromArray(array) {
+    let type = getDataTypeFromTypedArray(array);
+    if (type !== "null") {
+      return { type, nullable: false };
+    }
+    if (array.length > 0) {
+      type = getDataTypeFromValue(array[0]);
+      return { type, nullable: true };
+    }
+    return { type: "null", nullable: true };
+  }
+  function getDataTypeFromTypedArray(array) {
+    switch (array.constructor) {
+      case Int8Array:
+        return "int8";
+      case Uint8Array:
+      case Uint8ClampedArray:
+        return "uint8";
+      case Int16Array:
+        return "int16";
+      case Uint16Array:
+        return "uint16";
+      case Int32Array:
+        return "int32";
+      case Uint32Array:
+        return "uint32";
+      case Float32Array:
+        return "float32";
+      case Float64Array:
+        return "float64";
+      default:
+        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) {
+    switch (table.shape) {
+      case "array-row-table":
+      case "object-row-table":
+        return deduceSchemaFromRows(table.data);
+      case "columnar-table":
+        return deduceSchemaFromColumns(table.data);
+      case "arrow-table":
+      default:
+        throw new Error("Deduce schema");
+    }
+  }
+  function deduceSchemaFromColumns(columnarTable) {
+    const fields = [];
+    for (const [columnName, column] of Object.entries(columnarTable)) {
+      const field = deduceFieldFromColumn(column, columnName);
+      fields.push(field);
+    }
+    return { fields, metadata: {} };
+  }
+  function deduceSchemaFromRows(rowTable) {
+    if (!rowTable.length) {
+      throw new Error("deduce from empty table");
+    }
+    const fields = [];
+    const row0 = rowTable[0];
+    for (const [columnName, value] of Object.entries(row0)) {
+      fields.push(deduceFieldFromValue(value, columnName));
+    }
+    return { fields, metadata: {} };
+  }
+  function deduceFieldFromColumn(column, name) {
+    if (ArrayBuffer.isView(column)) {
+      const type = getDataTypeFromArray(column);
+      return {
+        name,
+        type: type.type || "null",
+        nullable: type.nullable
+      };
+    }
+    if (Array.isArray(column) && column.length > 0) {
+      const value = column[0];
+      const type = getDataTypeFromValue(value);
+      return {
+        name,
+        type,
+        nullable: true
+      };
+    }
+    throw new Error("empty table");
+  }
+  function deduceFieldFromValue(value, name) {
+    const type = getDataTypeFromValue(value);
+    return {
+      name,
+      type,
+      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 };
+        break;
+      case "object-row-table":
+        table = { shape: "object-row-table", data };
+        break;
+      case "columnar-table":
+        table = { shape: "columnar-table", data };
+        break;
+      default:
+        throw new Error("table");
+    }
+    const schema = deduceTableSchema(table);
+    return { ...table, schema };
+  }
+  function getTableShapeFromData(data) {
+    if (Array.isArray(data)) {
+      if (data.length === 0) {
+        throw new Error("cannot deduce type of empty table");
+      }
+      const firstRow = data[0];
+      if (Array.isArray(firstRow)) {
+        return "array-row-table";
+      }
+      if (firstRow && typeof firstRow === "object") {
+        return "object-row-table";
+      }
+    }
+    if (data && typeof data === "object") {
+      return "columnar-table";
+    }
+    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) {
+    try {
+      const json = JSON.parse(jsonText);
+      if (options.json?.table) {
+        const data = getFirstArray(json) || json;
+        return makeTableFromData(data);
+      }
+      return json;
+    } catch (error) {
+      throw new Error("JSONLoader: failed to parse JSON");
+    }
+  }
+  function getFirstArray(json) {
+    if (Array.isArray(json)) {
+      return json;
+    }
+    if (json && typeof json === "object") {
+      for (const value of Object.values(json)) {
+        const array = getFirstArray(value);
+        if (array) {
+          return array;
+        }
+      }
+    }
+    return null;
+  }
+  var init_parse_json = __esm({
+    "src/lib/parsers/parse-json.ts"() {
+      init_src();
     }
   });
 
@@ -484,6 +802,34 @@
     }
   });
 
+  // ../../node_modules/@babel/runtime/helpers/esm/typeof.js
+  var init_typeof = __esm({
+    "../../node_modules/@babel/runtime/helpers/esm/typeof.js"() {
+    }
+  });
+
+  // ../../node_modules/@babel/runtime/helpers/esm/toPrimitive.js
+  var init_toPrimitive = __esm({
+    "../../node_modules/@babel/runtime/helpers/esm/toPrimitive.js"() {
+      init_typeof();
+    }
+  });
+
+  // ../../node_modules/@babel/runtime/helpers/esm/toPropertyKey.js
+  var init_toPropertyKey = __esm({
+    "../../node_modules/@babel/runtime/helpers/esm/toPropertyKey.js"() {
+      init_typeof();
+      init_toPrimitive();
+    }
+  });
+
+  // ../../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"() {
@@ -1057,10 +1403,10 @@ Char: ${this.c}`;
     }
   });
 
-  // src/lib/parser/json-parser.ts
+  // src/lib/json-parser/json-parser.ts
   var JSONParser;
   var init_json_parser = __esm({
-    "src/lib/parser/json-parser.ts"() {
+    "src/lib/json-parser/json-parser.ts"() {
       init_clarinet();
       init_jsonpath();
       JSONParser = class {
@@ -1152,10 +1498,10 @@ Char: ${this.c}`;
     }
   });
 
-  // src/lib/parser/streaming-json-parser.ts
+  // src/lib/json-parser/streaming-json-parser.ts
   var StreamingJSONParser;
   var init_streaming_json_parser = __esm({
-    "src/lib/parser/streaming-json-parser.ts"() {
+    "src/lib/json-parser/streaming-json-parser.ts"() {
       init_json_parser();
       init_jsonpath();
       StreamingJSONParser = class extends JSONParser {
@@ -1227,7 +1573,7 @@ Char: ${this.c}`;
     }
   });
 
-  // src/lib/parse-json-in-batches.ts
+  // src/lib/parsers/parse-json-in-batches.ts
   async function* parseJSONInBatches(binaryAsyncIterator, options) {
     const asyncIterator = makeTextDecoderIterator(binaryAsyncIterator);
     const { metadata } = options;
@@ -1302,7 +1648,7 @@ Char: ${this.c}`;
     return batch.container;
   }
   var init_parse_json_in_batches = __esm({
-    "src/lib/parse-json-in-batches.ts"() {
+    "src/lib/parsers/parse-json-in-batches.ts"() {
       init_src();
       init_src2();
       init_streaming_json_parser();
@@ -1352,23 +1698,25 @@ Char: ${this.c}`;
     }
   });
 
-  // src/lib/parse-ndjson.ts
+  // src/lib/parsers/parse-ndjson.ts
   function parseNDJSONSync(ndjsonText) {
     const lines = ndjsonText.trim().split("\n");
-    return lines.map((line, counter) => {
+    const parsedLines = lines.map((line, counter) => {
       try {
         return JSON.parse(line);
       } catch (error) {
         throw new Error(`NDJSONLoader: failed to parse JSON on line ${counter + 1}`);
       }
     });
+    return makeTableFromData(parsedLines);
   }
   var init_parse_ndjson = __esm({
-    "src/lib/parse-ndjson.ts"() {
+    "src/lib/parsers/parse-ndjson.ts"() {
+      init_src();
     }
   });
 
-  // src/lib/parse-ndjson-in-batches.ts
+  // src/lib/parsers/parse-ndjson-in-batches.ts
   async function* parseNDJSONInBatches(binaryAsyncIterator, options) {
     const textIterator = makeTextDecoderIterator(binaryAsyncIterator);
     const lineIterator = makeLineIterator(textIterator);
@@ -1398,22 +1746,13 @@ Char: ${this.c}`;
     }
   }
   var init_parse_ndjson_in_batches = __esm({
-    "src/lib/parse-ndjson-in-batches.ts"() {
+    "src/lib/parsers/parse-ndjson-in-batches.ts"() {
       init_src();
       init_src2();
     }
   });
 
   // src/ndjson-loader.ts
-  async function parse2(arrayBuffer) {
-    return parseTextSync2(new TextDecoder().decode(arrayBuffer));
-  }
-  function parseTextSync2(text) {
-    return parseNDJSONSync(text);
-  }
-  function parseInBatches2(asyncIterator, options) {
-    return parseNDJSONInBatches(asyncIterator, options);
-  }
   var VERSION2, NDJSONLoader;
   var init_ndjson_loader = __esm({
     "src/ndjson-loader.ts"() {
@@ -1425,18 +1764,58 @@ Char: ${this.c}`;
         id: "ndjson",
         module: "json",
         version: VERSION2,
-        extensions: ["ndjson"],
-        mimeTypes: ["application/x-ndjson"],
+        extensions: ["ndjson", "jsonl"],
+        mimeTypes: [
+          "application/x-ndjson",
+          "application/jsonlines",
+          "application/json-seq"
+        ],
         category: "table",
         text: true,
-        parse: parse2,
-        parseTextSync: parseTextSync2,
-        parseInBatches: parseInBatches2,
+        parse: async (arrayBuffer) => parseNDJSONSync(new TextDecoder().decode(arrayBuffer)),
+        parseTextSync: parseNDJSONSync,
+        parseInBatches: parseNDJSONInBatches,
         options: {}
       };
     }
   });
 
+  // src/lib/encoders/json-encoder.ts
+  function encodeTableAsJSON(table, options = {}) {
+    const shape = options.shape || "object-row-table";
+    const strings = [];
+    const rowIterator = makeRowIterator(table, shape);
+    for (const row of rowIterator) {
+      strings.push(JSON.stringify(row));
+    }
+    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,
+        encodeText: (table, options) => encodeTableAsJSON(table, options)
+      };
+    }
+  });
+
   // ../../node_modules/@math.gl/polygon/dist/esm/polygon-utils.js
   function getPolygonSignedArea(points, options = {}) {
     const {
@@ -1459,16 +1838,16 @@ Char: ${this.c}`;
   // ../../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(data, holeIndices, dim, areas) {
-    dim = dim || 2;
+  function earcut(positions, holeIndices, dim = 2, areas) {
     const hasHoles = holeIndices && holeIndices.length;
-    const outerLen = hasHoles ? holeIndices[0] * dim : data.length;
-    let outerNode = linkedList(data, 0, outerLen, dim, true, areas && areas[0]);
+    const outerLen = hasHoles ? holeIndices[0] * dim : positions.length;
+    let outerNode = linkedList(positions, 0, outerLen, dim, true, areas && areas[0]);
     const triangles = [];
     if (!outerNode || outerNode.next === outerNode.prev)
       return triangles;
@@ -1480,13 +1859,13 @@ Char: ${this.c}`;
     let x;
     let y;
     if (hasHoles)
-      outerNode = eliminateHoles(data, holeIndices, outerNode, dim, areas);
-    if (data.length > 80 * dim) {
-      minX = maxX = data[0];
-      minY = maxY = data[1];
+      outerNode = eliminateHoles(positions, holeIndices, outerNode, dim, areas);
+    if (positions.length > 80 * dim) {
+      minX = maxX = positions[0];
+      minY = maxY = positions[1];
       for (let i = dim; i < outerLen; i += dim) {
-        x = data[i];
-        y = data[i + 1];
+        x = positions[i];
+        y = positions[i + 1];
         if (x < minX)
           minX = x;
         if (y < minY)
@@ -2438,22 +2817,23 @@ Char: ${this.c}`;
   });
 
   // src/geojson-loader.ts
-  async function parse3(arrayBuffer, options) {
-    return parseTextSync3(new TextDecoder().decode(arrayBuffer), options);
+  async function parse2(arrayBuffer, options) {
+    return parseTextSync2(new TextDecoder().decode(arrayBuffer), options);
   }
-  function parseTextSync3(text, options) {
+  function parseTextSync2(text, options) {
     options = { ...DEFAULT_GEOJSON_LOADER_OPTIONS, ...options };
     options.json = { ...DEFAULT_GEOJSON_LOADER_OPTIONS.geojson, ...options.geojson };
     options.gis = options.gis || {};
-    const json = parseJSONSync(text, options);
+    const table = parseJSONSync(text, options);
+    table.shape = "geojson-row-table";
     switch (options.gis.format) {
       case "binary":
-        return geojsonToBinary(json);
+        return geojsonToBinary(table.data);
       default:
-        return json;
+        return table;
     }
   }
-  function parseInBatches3(asyncIterator, options) {
+  function parseInBatches2(asyncIterator, options) {
     options = { ...DEFAULT_GEOJSON_LOADER_OPTIONS, ...options };
     options.json = { ...DEFAULT_GEOJSON_LOADER_OPTIONS.geojson, ...options.geojson };
     const geojsonIterator = parseJSONInBatches(asyncIterator, options);
@@ -2502,9 +2882,176 @@ Char: ${this.c}`;
       };
       GeoJSONLoader = {
         ...GeoJSONWorkerLoader,
-        parse: parse3,
-        parseTextSync: parseTextSync3,
-        parseInBatches: parseInBatches3
+        parse: parse2,
+        parseTextSync: parseTextSync2,
+        parseInBatches: parseInBatches2
+      };
+    }
+  });
+
+  // src/lib/encoders/encode-utils.ts
+  function detectGeometryColumnIndex(table) {
+    const geometryIndex = table.schema?.fields.findIndex((field) => field.name === "geometry") ?? -1;
+    if (geometryIndex > -1) {
+      return geometryIndex;
+    }
+    if (getTableLength(table) > 0) {
+      const row = getTableRowAsArray(table, 0);
+      for (let columnIndex = 0; columnIndex < getTableNumCols(table); columnIndex++) {
+        const value = row?.[columnIndex];
+        if (value && typeof value === "object") {
+          return columnIndex;
+        }
+      }
+    }
+    throw new Error("Failed to detect geometry column");
+  }
+  function getRowPropertyObject(table, row, excludeColumnIndices = []) {
+    const properties = {};
+    for (let columnIndex = 0; columnIndex < getTableNumCols(table); ++columnIndex) {
+      const columnName = table.schema?.fields[columnIndex].name;
+      if (columnName && !excludeColumnIndices.includes(columnIndex)) {
+        properties[columnName] = row[columnName];
+      }
+    }
+    return properties;
+  }
+  var init_encode_utils = __esm({
+    "src/lib/encoders/encode-utils.ts"() {
+      init_src();
+    }
+  });
+
+  // src/lib/encoders/utf8-encoder.ts
+  var Utf8ArrayBufferEncoder;
+  var init_utf8_encoder = __esm({
+    "src/lib/encoders/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;
+        }
+      };
+    }
+  });
+
+  // src/lib/encoders/geojson-encoder.ts
+  async function* encodeTableAsGeojsonInBatches(batchIterator, 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');
+    }
+    utf8Encoder.push("[");
+    let geometryColumn = options.geojson.geometryColumn;
+    let isFirstLine = true;
+    for await (const batch of batchIterator) {
+      const { table, start, end = getTableLength(batch.table) - start } = batch;
+      if (!geometryColumn) {
+        geometryColumn = geometryColumn || detectGeometryColumnIndex(table);
+      }
+      for (let rowIndex = start; rowIndex < end; ++rowIndex) {
+        if (!isFirstLine) {
+          utf8Encoder.push(",");
+        }
+        utf8Encoder.push("\n");
+        isFirstLine = false;
+        encodeRow(table, rowIndex, geometryColumn, utf8Encoder);
+        if (utf8Encoder.isFull()) {
+          yield utf8Encoder.getArrayBufferBatch();
+        }
+      }
+      const arrayBufferBatch = utf8Encoder.getArrayBufferBatch();
+      if (arrayBufferBatch.byteLength > 0) {
+        yield arrayBufferBatch;
+      }
+    }
+    utf8Encoder.push("\n");
+    utf8Encoder.push("]\n");
+    if (!options.geojson.featureArray) {
+      utf8Encoder.push("}");
+    }
+    yield utf8Encoder.getArrayBufferBatch();
+  }
+  function encodeRow(table, rowIndex, geometryColumnIndex, utf8Encoder) {
+    const row = getTableRowAsObject(table, rowIndex);
+    if (!row)
+      return;
+    const featureWithProperties = getFeatureFromRow(table, row, geometryColumnIndex);
+    const featureString = JSON.stringify(featureWithProperties);
+    utf8Encoder.push(featureString);
+  }
+  function getFeatureFromRow(table, row, geometryColumnIndex) {
+    const properties = getRowPropertyObject(table, row, [geometryColumnIndex]);
+    const columnName = table.schema?.fields[geometryColumnIndex].name;
+    let featureOrGeometry = columnName && row[columnName];
+    if (!featureOrGeometry) {
+      return { type: "Feature", geometry: null, properties };
+    }
+    if (typeof featureOrGeometry === "string") {
+      try {
+        featureOrGeometry = JSON.parse(featureOrGeometry);
+      } catch (err) {
+        throw new Error("Invalid string geometry");
+      }
+    }
+    if (typeof featureOrGeometry !== "object" || typeof featureOrGeometry?.type !== "string") {
+      throw new Error("invalid geometry column value");
+    }
+    if (featureOrGeometry?.type === "Feature") {
+      return { ...featureOrGeometry, properties };
+    }
+    return { type: "Feature", geometry: featureOrGeometry, properties };
+  }
+  var init_geojson_encoder = __esm({
+    "src/lib/encoders/geojson-encoder.ts"() {
+      init_src();
+      init_src();
+      init_encode_utils();
+      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)
       };
     }
   });
@@ -2513,10 +3060,12 @@ Char: ${this.c}`;
   var src_exports = {};
   __export(src_exports, {
     JSONLoader: () => JSONLoader,
+    JSONWriter: () => JSONWriter,
     NDJSONLoader: () => NDJSONLoader,
     _ClarinetParser: () => ClarinetParser,
     _GeoJSONLoader: () => GeoJSONLoader,
     _GeoJSONWorkerLoader: () => GeoJSONWorkerLoader,
+    _GeoJSONWriter: () => GeoJSONWriter,
     _JSONPath: () => JSONPath,
     _rebuildJsonObject: () => rebuildJsonObject
   });
@@ -2524,7 +3073,9 @@ Char: ${this.c}`;
     "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();