@loaders.gl/arrow 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, {
     ArrowLoader: () => ArrowLoader,
     ArrowWorkerLoader: () => ArrowWorkerLoader,
     ArrowWriter: () => ArrowWriter,
@@ -54,15 +75,16 @@ var __exports__ = (() => {
     triangulateOnWorker: () => triangulateOnWorker,
     updateBoundsFromGeoArrowSamples: () => updateBoundsFromGeoArrowSamples
   });
+  __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)) {
@@ -158,12 +180,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) {
@@ -223,6 +245,7 @@ var __exports__ = (() => {
         batchType: "data",
         data: rows,
         length: this.length,
+        // @ts-expect-error we should infer a schema
         schema: this.schema,
         cursor: this.cursor
       };
@@ -232,10 +255,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();
     }
@@ -276,6 +299,7 @@ var __exports__ = (() => {
       };
       return batch;
     }
+    // HELPERS
     _reallocateColumns() {
       if (this.length < this.allocated) {
         return;
@@ -315,20 +339,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) {
@@ -339,6 +360,7 @@ var __exports__ = (() => {
       }
       return false;
     }
+    /** @deprecated Use addArrayRow or addObjectRow */
     addRow(row) {
       if (this.limitReached()) {
         return;
@@ -352,6 +374,7 @@ var __exports__ = (() => {
         this.addObjectRow(row);
       }
     }
+    /** Add one row to the batch */
     addArrayRow(row) {
       if (!this.aggregator) {
         const TableBatchType = this._getTableBatchType();
@@ -359,6 +382,7 @@ var __exports__ = (() => {
       }
       this.aggregator.addArrayRow(row);
     }
+    /** Add one row to the batch */
     addObjectRow(row) {
       if (!this.aggregator) {
         const TableBatchType = this._getTableBatchType();
@@ -366,6 +390,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;
@@ -381,6 +406,7 @@ var __exports__ = (() => {
     getFinalBatch(options) {
       return this._getBatch(options);
     }
+    // INTERNAL
     _estimateRowMB(row) {
       return Array.isArray(row) ? row.length * 8 : Object.keys(row).length * 8;
     }
@@ -402,6 +428,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;
@@ -469,7 +498,9 @@ var __exports__ = (() => {
         return column[rowIndex];
       case "arrow-table":
         const arrowTable = table.data;
-        const arrowColumnIndex = arrowTable.schema.fields.findIndex((field) => field.name === columnName);
+        const arrowColumnIndex = arrowTable.schema.fields.findIndex(
+          (field) => field.name === columnName
+        );
         return arrowTable.getChildAt(arrowColumnIndex)?.get(rowIndex);
       default:
         throw new Error("todo");
@@ -602,22 +633,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) {
@@ -687,10 +709,7 @@ var __exports__ = (() => {
       const field = deduceFieldFromColumn(column, columnName);
       fields.push(field);
     }
-    return {
-      fields,
-      metadata: {}
-    };
+    return { fields, metadata: {} };
   }
   function deduceSchemaFromRows(rowTable) {
     if (!rowTable.length) {
@@ -701,10 +720,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)) {
@@ -713,6 +729,7 @@ var __exports__ = (() => {
         name,
         type: type.type || "null",
         nullable: type.nullable
+        // metadata: {}
       };
     }
     if (Array.isArray(column) && column.length > 0) {
@@ -722,6 +739,7 @@ var __exports__ = (() => {
         name,
         type,
         nullable: true
+        // metadata: {},
       };
     }
     throw new Error("empty table");
@@ -732,6 +750,7 @@ var __exports__ = (() => {
       name,
       type,
       nullable: true
+      // metadata: {}
     };
   }
 
@@ -767,10 +786,7 @@ var __exports__ = (() => {
     const schema = table.schema || deduceTableSchema(table);
     const fields = table.schema?.fields || [];
     if (table.shape === "columnar-table") {
-      return {
-        ...table,
-        schema
-      };
+      return { ...table, schema };
     }
     const length = getTableLength(table);
     const columns = {};
@@ -12678,12 +12694,13 @@ return true;`);
       if (batch) {
         this.arrowSchema = this.arrowSchema || getArrowSchema(batch.schema);
         const arrowVectors = getArrowVectors(this.arrowSchema, batch.data);
-        const recordBatch = new RecordBatch2(this.arrowSchema, makeData({
-          type: new Struct(this.arrowSchema.fields),
-          children: arrowVectors.map(({
-            data
-          }) => data[0])
-        }));
+        const recordBatch = new RecordBatch2(
+          this.arrowSchema,
+          makeData({
+            type: new Struct(this.arrowSchema.fields),
+            children: arrowVectors.map(({ data }) => data[0])
+          })
+        );
         return {
           shape: "arrow-table",
           batchType: "data",
@@ -12749,11 +12766,11 @@ return true;`);
   }
 
   // src/types.ts
-  var VECTOR_TYPES = function(VECTOR_TYPES2) {
+  var VECTOR_TYPES = /* @__PURE__ */ ((VECTOR_TYPES2) => {
     VECTOR_TYPES2[VECTOR_TYPES2["FLOAT"] = 0] = "FLOAT";
     VECTOR_TYPES2[VECTOR_TYPES2["DATE"] = 1] = "DATE";
     return VECTOR_TYPES2;
-  }({});
+  })(VECTOR_TYPES || {});
 
   // src/tables/convert-arrow-to-columnar-table.ts
   function convertArrowToColumnarTable(table) {
@@ -12779,7 +12796,10 @@ return true;`);
     };
   }
   function deserializeArrowSchema(schema) {
-    return new Schema2(schema.fields.map((field) => deserializeArrowField(field)), deserializeArrowMetadata(schema.metadata));
+    return new Schema2(
+      schema.fields.map((field) => deserializeArrowField(field)),
+      deserializeArrowMetadata(schema.metadata)
+    );
   }
   function serializeArrowMetadata(arrowMetadata) {
     return Object.fromEntries(arrowMetadata);
@@ -12796,7 +12816,12 @@ return true;`);
     };
   }
   function deserializeArrowField(field) {
-    return new Field2(field.name, deserializeArrowType(field.type), field.nullable, deserializeArrowMetadata(field.metadata));
+    return new Field2(
+      field.name,
+      deserializeArrowType(field.type),
+      field.nullable,
+      deserializeArrowMetadata(field.metadata)
+    );
   }
   function serializeArrowType(arrowType) {
     switch (arrowType.constructor) {
@@ -13079,15 +13104,20 @@ return true;`);
   }
 
   // src/arrow-loader.ts
-  var VERSION = true ? "4.2.0-alpha.4" : "latest";
+  var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
   var ArrowWorkerLoader = {
     name: "Apache Arrow",
     id: "arrow",
     module: "arrow",
     version: VERSION,
+    // worker: true,
     category: "table",
     extensions: ["arrow", "feather"],
-    mimeTypes: ["application/vnd.apache.arrow.file", "application/vnd.apache.arrow.stream", "application/octet-stream"],
+    mimeTypes: [
+      "application/vnd.apache.arrow.file",
+      "application/vnd.apache.arrow.stream",
+      "application/octet-stream"
+    ],
     binary: true,
     tests: ["ARROW"],
     options: {
@@ -13116,23 +13146,27 @@ return true;`);
   }
   function createVector(array, type) {
     switch (type) {
-      case VECTOR_TYPES.DATE:
+      case 1 /* DATE */:
         return vectorFromArray(array);
-      case VECTOR_TYPES.FLOAT:
+      case 0 /* FLOAT */:
       default:
         return vectorFromArray(array);
     }
   }
 
   // src/arrow-writer.ts
-  var VERSION2 = true ? "4.2.0-alpha.4" : "latest";
+  var VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
   var ArrowWriter = {
     name: "Apache Arrow",
     id: "arrow",
     module: "arrow",
     version: VERSION2,
     extensions: ["arrow", "feather"],
-    mimeTypes: ["application/vnd.apache.arrow.file", "application/vnd.apache.arrow.stream", "application/octet-stream"],
+    mimeTypes: [
+      "application/vnd.apache.arrow.file",
+      "application/vnd.apache.arrow.stream",
+      "application/octet-stream"
+    ],
     binary: true,
     options: {},
     encode: async function encodeArrow(data, options) {
@@ -13144,7 +13178,16 @@ return true;`);
   };
 
   // ../gis/src/lib/geo/geoarrow-metadata.ts
-  var GEOARROW_ENCODINGS = ["geoarrow.multipolygon", "geoarrow.polygon", "geoarrow.multilinestring", "geoarrow.linestring", "geoarrow.multipoint", "geoarrow.point", "geoarrow.wkb", "geoarrow.wkt"];
+  var GEOARROW_ENCODINGS = [
+    "geoarrow.multipolygon",
+    "geoarrow.polygon",
+    "geoarrow.multilinestring",
+    "geoarrow.linestring",
+    "geoarrow.multipoint",
+    "geoarrow.point",
+    "geoarrow.wkb",
+    "geoarrow.wkt"
+  ];
   var GEOARROW_COLUMN_METADATA_ENCODING = "ARROW:extension:name";
   var GEOARROW_COLUMN_METADATA_METADATA = "ARROW:extension:metadata";
   function getGeometryColumnsFromSchema(schema) {
@@ -13760,11 +13803,11 @@ return true;`);
     }
   }
   function polygonToGeoJson(data, startIndex = -Infinity, endIndex = Infinity) {
-    const {
-      positions
-    } = data;
+    const { positions } = data;
     const polygonIndices = data.polygonIndices.value.filter((x) => x >= startIndex && x <= endIndex);
-    const primitivePolygonIndices = data.primitivePolygonIndices.value.filter((x) => x >= startIndex && x <= endIndex);
+    const primitivePolygonIndices = data.primitivePolygonIndices.value.filter(
+      (x) => x >= startIndex && x <= endIndex
+    );
     const multi = polygonIndices.length > 2;
     if (!multi) {
       const coordinates2 = [];
@@ -13774,62 +13817,44 @@ return true;`);
         const ringCoordinates = ringToGeoJson(positions, startRingIndex, endRingIndex);
         coordinates2.push(ringCoordinates);
       }
-      return {
-        type: "Polygon",
-        coordinates: coordinates2
-      };
+      return { type: "Polygon", coordinates: coordinates2 };
     }
     const coordinates = [];
     for (let i = 0; i < polygonIndices.length - 1; i++) {
       const startPolygonIndex = polygonIndices[i];
       const endPolygonIndex = polygonIndices[i + 1];
-      const polygonCoordinates = polygonToGeoJson(data, startPolygonIndex, endPolygonIndex).coordinates;
+      const polygonCoordinates = polygonToGeoJson(
+        data,
+        startPolygonIndex,
+        endPolygonIndex
+      ).coordinates;
       coordinates.push(polygonCoordinates);
     }
-    return {
-      type: "MultiPolygon",
-      coordinates
-    };
+    return { type: "MultiPolygon", coordinates };
   }
   function lineStringToGeoJson(data, startIndex = -Infinity, endIndex = Infinity) {
-    const {
-      positions
-    } = data;
+    const { positions } = data;
     const pathIndices = data.pathIndices.value.filter((x) => x >= startIndex && x <= endIndex);
     const multi = pathIndices.length > 2;
     if (!multi) {
       const coordinates2 = ringToGeoJson(positions, pathIndices[0], pathIndices[1]);
-      return {
-        type: "LineString",
-        coordinates: coordinates2
-      };
+      return { type: "LineString", coordinates: coordinates2 };
     }
     const coordinates = [];
     for (let i = 0; i < pathIndices.length - 1; i++) {
       const ringCoordinates = ringToGeoJson(positions, pathIndices[i], pathIndices[i + 1]);
       coordinates.push(ringCoordinates);
     }
-    return {
-      type: "MultiLineString",
-      coordinates
-    };
+    return { type: "MultiLineString", coordinates };
   }
   function pointToGeoJson(data, startIndex, endIndex) {
-    const {
-      positions
-    } = data;
+    const { positions } = data;
     const coordinates = ringToGeoJson(positions, startIndex, endIndex);
     const multi = coordinates.length > 1;
     if (multi) {
-      return {
-        type: "MultiPoint",
-        coordinates
-      };
+      return { type: "MultiPoint", coordinates };
     }
-    return {
-      type: "Point",
-      coordinates: coordinates[0]
-    };
+    return { type: "Point", coordinates: coordinates[0] };
   }
   function ringToGeoJson(positions, startIndex, endIndex) {
     startIndex = startIndex || 0;
@@ -13860,11 +13885,7 @@ return true;`);
       const feature = parseGeometryFromArrow(arrowGeometry, encoding);
       if (feature) {
         const properties = propertiesTable.get(row)?.toJSON() || {};
-        features.push({
-          type: "Feature",
-          geometry: feature,
-          properties
-        });
+        features.push({ type: "Feature", geometry: feature, properties });
       }
     }
     return {
@@ -13877,9 +13898,7 @@ return true;`);
 
   // src/parsers/parse-geoarrow-sync.ts
   function parseGeoArrowSync(arrayBuffer, options) {
-    const table = parseArrowSync(arrayBuffer, {
-      shape: "arrow-table"
-    });
+    const table = parseArrowSync(arrayBuffer, { shape: "arrow-table" });
     switch (options?.shape) {
       case "geojson-table":
         return convertArrowToGeoJSONTable(table);
@@ -13939,28 +13958,13 @@ return true;`);
   }
 
   // src/geoarrow/convert-geoarrow-to-binary-geometry.ts
-  var BinaryGeometryType = function(BinaryGeometryType2) {
-    BinaryGeometryType2["points"] = "points";
-    BinaryGeometryType2["lines"] = "lines";
-    BinaryGeometryType2["polygons"] = "polygons";
-    return BinaryGeometryType2;
-  }(BinaryGeometryType || {});
   function getBinaryGeometryTemplate() {
     return {
-      globalFeatureIds: {
-        value: new Uint32Array(0),
-        size: 1
-      },
-      positions: {
-        value: new Float32Array(0),
-        size: 2
-      },
+      globalFeatureIds: { value: new Uint32Array(0), size: 1 },
+      positions: { value: new Float32Array(0), size: 2 },
       properties: [],
       numericProps: {},
-      featureIds: {
-        value: new Uint32Array(0),
-        size: 1
-      }
+      featureIds: { value: new Uint32Array(0), size: 1 }
     };
   }
   function getBinaryGeometriesFromArrow(geoColumn, geoEncoding, options) {
@@ -13974,30 +13978,19 @@ return true;`);
     let globalFeatureIdOffset = options?.chunkOffset || 0;
     const binaryGeometries = [];
     chunks.forEach((chunk) => {
-      const {
-        featureIds,
-        flatCoordinateArray,
-        nDim,
-        geomOffset,
-        triangles
-      } = getBinaryGeometriesFromChunk(chunk, geoEncoding, options);
+      const { featureIds, flatCoordinateArray, nDim, geomOffset, triangles } = getBinaryGeometriesFromChunk(chunk, geoEncoding, options);
       const globalFeatureIds = new Uint32Array(featureIds.length);
       for (let i = 0; i < featureIds.length; i++) {
         globalFeatureIds[i] = featureIds[i] + globalFeatureIdOffset;
       }
       const binaryContent = {
-        globalFeatureIds: {
-          value: globalFeatureIds,
-          size: 1
-        },
+        globalFeatureIds: { value: globalFeatureIds, size: 1 },
         positions: {
           value: flatCoordinateArray,
           size: nDim
         },
-        featureIds: {
-          value: featureIds,
-          size: 1
-        },
+        featureIds: { value: featureIds, size: 1 },
+        // eslint-disable-next-line no-loop-func
         properties: [...Array(chunk.length).keys()].map((i) => ({
           index: i + globalFeatureIdOffset
         }))
@@ -14014,16 +14007,14 @@ return true;`);
           type: "LineString",
           ...getBinaryGeometryTemplate(),
           ...featureTypes.line ? binaryContent : {},
-          pathIndices: {
-            value: featureTypes.line ? geomOffset : new Uint16Array(0),
-            size: 1
-          }
+          pathIndices: { value: featureTypes.line ? geomOffset : new Uint16Array(0), size: 1 }
         },
         polygons: {
           type: "Polygon",
           ...getBinaryGeometryTemplate(),
           ...featureTypes.polygon ? binaryContent : {},
           polygonIndices: {
+            // use geomOffset as polygonIndices same as primitivePolygonIndices since we are using earcut to get triangule indices
             value: featureTypes.polygon ? geomOffset : new Uint16Array(0),
             size: 1
           },
@@ -14031,12 +14022,7 @@ return true;`);
             value: featureTypes.polygon ? geomOffset : new Uint16Array(0),
             size: 1
           },
-          ...triangles ? {
-            triangles: {
-              value: triangles,
-              size: 1
-            }
-          } : {}
+          ...triangles ? { triangles: { value: triangles, size: 1 } } : {}
         }
       });
       bounds = updateBoundsFromGeoArrowSamples(flatCoordinateArray, nDim, bounds);
@@ -14045,9 +14031,7 @@ return true;`);
       binaryGeometries,
       bounds,
       featureTypes,
-      ...options?.calculateMeanCenters ? {
-        meanCenters: getMeanCentersFromBinaryGeometries(binaryGeometries)
-      } : {}
+      ...options?.calculateMeanCenters ? { meanCenters: getMeanCentersFromBinaryGeometries(binaryGeometries) } : {}
     };
   }
   function getMeanCentersFromBinaryGeometries(binaryGeometries) {
@@ -14055,11 +14039,11 @@ return true;`);
     binaryGeometries.forEach((binaryGeometry) => {
       let binaryGeometryType = null;
       if (binaryGeometry.points && binaryGeometry.points.positions.value.length > 0) {
-        binaryGeometryType = BinaryGeometryType.points;
+        binaryGeometryType = "points" /* points */;
       } else if (binaryGeometry.lines && binaryGeometry.lines.positions.value.length > 0) {
-        binaryGeometryType = BinaryGeometryType.lines;
+        binaryGeometryType = "lines" /* lines */;
       } else if (binaryGeometry.polygons && binaryGeometry.polygons.positions.value.length > 0) {
-        binaryGeometryType = BinaryGeometryType.polygons;
+        binaryGeometryType = "polygons" /* polygons */;
       }
       const binaryContent = binaryGeometryType ? binaryGeometry[binaryGeometryType] : null;
       if (binaryContent && binaryGeometryType !== null) {
@@ -14067,7 +14051,13 @@ return true;`);
         const flatCoordinateArray = binaryContent.positions.value;
         const nDim = binaryContent.positions.size;
         const primitivePolygonIndices = binaryContent.type === "Polygon" ? binaryContent.primitivePolygonIndices?.value : void 0;
-        const meanCenters = getMeanCentersFromGeometry(featureIds, flatCoordinateArray, nDim, binaryGeometryType, primitivePolygonIndices);
+        const meanCenters = getMeanCentersFromGeometry(
+          featureIds,
+          flatCoordinateArray,
+          nDim,
+          binaryGeometryType,
+          primitivePolygonIndices
+        );
         meanCenters.forEach((center) => {
           globalMeanCenters.push(center);
         });
@@ -14086,7 +14076,7 @@ return true;`);
       const center = [0, 0];
       let vertexCountInFeature = 0;
       while (vertexIndex < vertexCount && featureIds[coordIdx] === featureId) {
-        if (geometryType === BinaryGeometryType.polygons && primitivePolygonIndices?.[primitiveIdx] === coordIdx) {
+        if (geometryType === "polygons" /* polygons */ && primitivePolygonIndices?.[primitiveIdx] === coordIdx) {
           vertexIndex += nDim;
           primitiveIdx++;
         } else {
@@ -14133,7 +14123,11 @@ return true;`);
           }
           primitiveIndex++;
         }
-        const triangleIndices = earcut(slicedFlatCoords, holeIndices.length > 0 ? holeIndices : void 0, nDim);
+        const triangleIndices = earcut(
+          slicedFlatCoords,
+          holeIndices.length > 0 ? holeIndices : void 0,
+          nDim
+        );
         if (triangleIndices.length === 0) {
           throw Error("earcut failed e.g. invalid polygon");
         }
@@ -14181,9 +14175,7 @@ return true;`);
       flatCoordinateArray,
       geomOffset,
       geometryIndicies,
-      ...options?.triangulate && triangles ? {
-        triangles
-      } : {}
+      ...options?.triangulate && triangles ? { triangles } : {}
     };
   }
   function getBinaryLinesFromChunk(chunk, geoEncoding) {
@@ -14257,12 +14249,21 @@ return true;`);
   }
 
   // ../wkt/src/lib/utils/version.ts
-  var VERSION3 = true ? "4.2.0-alpha.4" : "latest";
+  var VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
 
   // ../wkt/src/lib/parse-wkt.ts
   var numberRegexp = /[-+]?([0-9]*\.[0-9]+|[0-9]+)([eE][-+]?[0-9]+)?/;
   var tuples = new RegExp("^" + numberRegexp.source + "(\\s" + numberRegexp.source + "){1,}");
-  var WKT_MAGIC_STRINGS = ["POINT(", "LINESTRING(", "POLYGON(", "MULTIPOINT(", "MULTILINESTRING(", "MULTIPOLYGON(", "GEOMETRYCOLLECTION("];
+  var WKT_MAGIC_STRINGS = [
+    "POINT(",
+    "LINESTRING(",
+    "POLYGON(",
+    "MULTIPOINT(",
+    "MULTILINESTRING(",
+    "MULTIPOLYGON(",
+    "GEOMETRYCOLLECTION("
+    // We only support this "geojson" subset of the OGC simple features standard
+  ];
   function isWKT(input) {
     return WKT_MAGIC_STRINGS.some((magicString) => input.startsWith(magicString));
   }
@@ -14273,11 +14274,7 @@ return true;`);
     const parts = input.split(";");
     let _ = parts.pop();
     const srid = (parts.shift() || "").split("=").pop();
-    const state = {
-      parts,
-      _,
-      i: 0
-    };
+    const state = { parts, _, i: 0 };
     const geometry = parseGeometry(state);
     return options?.wkt?.crs ? addCRS(geometry, srid) : geometry;
   }
@@ -14364,7 +14361,9 @@ return true;`);
     }
     white(state);
     return {
+      // @ts-ignore
       type: "MultiLineString",
+      // @ts-expect-error
       coordinates: c
     };
   }
@@ -14378,7 +14377,9 @@ return true;`);
       return null;
     }
     return {
+      // @ts-ignore
       type: "Polygon",
+      // @ts-expect-error
       coordinates: c
     };
   }
@@ -14393,6 +14394,7 @@ return true;`);
     }
     return {
       type: "MultiPolygon",
+      // @ts-expect-error
       coordinates: c
     };
   }
@@ -14521,16 +14523,6 @@ return true;`);
   var EWKB_FLAG_M = 1073741824;
   var EWKB_FLAG_SRID = 536870912;
   var MAX_SRID = 1e4;
-  var WKBGeometryType = function(WKBGeometryType2) {
-    WKBGeometryType2[WKBGeometryType2["Point"] = 1] = "Point";
-    WKBGeometryType2[WKBGeometryType2["LineString"] = 2] = "LineString";
-    WKBGeometryType2[WKBGeometryType2["Polygon"] = 3] = "Polygon";
-    WKBGeometryType2[WKBGeometryType2["MultiPoint"] = 4] = "MultiPoint";
-    WKBGeometryType2[WKBGeometryType2["MultiLineString"] = 5] = "MultiLineString";
-    WKBGeometryType2[WKBGeometryType2["MultiPolygon"] = 6] = "MultiPolygon";
-    WKBGeometryType2[WKBGeometryType2["GeometryCollection"] = 7] = "GeometryCollection";
-    return WKBGeometryType2;
-  }({});
   function isWKB(arrayBuffer) {
     const dataView = new DataView(arrayBuffer);
     let byteOffset = 0;
@@ -14641,31 +14633,27 @@ return true;`);
   function parseWKBToBinary(arrayBuffer, options) {
     const dataView = new DataView(arrayBuffer);
     const wkbHeader = parseWKBHeader(dataView);
-    const {
-      geometryType,
-      dimensions,
-      littleEndian
-    } = wkbHeader;
+    const { geometryType, dimensions, littleEndian } = wkbHeader;
     const offset = wkbHeader.byteOffset;
     switch (geometryType) {
-      case WKBGeometryType.Point:
+      case 1 /* Point */:
         const point = parsePoint2(dataView, offset, dimensions, littleEndian);
         return point.geometry;
-      case WKBGeometryType.LineString:
+      case 2 /* LineString */:
         const line = parseLineString2(dataView, offset, dimensions, littleEndian);
         return line.geometry;
-      case WKBGeometryType.Polygon:
+      case 3 /* Polygon */:
         const polygon = parsePolygon2(dataView, offset, dimensions, littleEndian);
         return polygon.geometry;
-      case WKBGeometryType.MultiPoint:
+      case 4 /* MultiPoint */:
         const multiPoint = parseMultiPoint2(dataView, offset, dimensions, littleEndian);
         multiPoint.type = "Point";
         return multiPoint;
-      case WKBGeometryType.MultiLineString:
+      case 5 /* MultiLineString */:
         const multiLine = parseMultiLineString2(dataView, offset, dimensions, littleEndian);
         multiLine.type = "LineString";
         return multiLine;
-      case WKBGeometryType.MultiPolygon:
+      case 6 /* MultiPolygon */:
         const multiPolygon = parseMultiPolygon2(dataView, offset, dimensions, littleEndian);
         multiPolygon.type = "Polygon";
         return multiPolygon;
@@ -14680,13 +14668,7 @@ return true;`);
       offset += 8;
     }
     return {
-      geometry: {
-        type: "Point",
-        positions: {
-          value: positions,
-          size: dimension
-        }
-      },
+      geometry: { type: "Point", positions: { value: positions, size: dimension } },
       offset
     };
   }
@@ -14705,14 +14687,8 @@ return true;`);
     return {
       geometry: {
         type: "LineString",
-        positions: {
-          value: positions,
-          size: dimension
-        },
-        pathIndices: {
-          value: new Uint16Array(pathIndices),
-          size: 1
-        }
+        positions: { value: positions, size: dimension },
+        pathIndices: { value: new Uint16Array(pathIndices), size: 1 }
       },
       offset
     };
@@ -14724,9 +14700,7 @@ return true;`);
     const rings = [];
     for (let i = 0; i < nRings; i++) {
       const parsed = parseLineString2(dataView, offset, dimension, littleEndian);
-      const {
-        positions
-      } = parsed.geometry;
+      const { positions } = parsed.geometry;
       offset = parsed.offset;
       rings.push(positions.value);
     }
@@ -14740,18 +14714,12 @@ return true;`);
     return {
       geometry: {
         type: "Polygon",
-        positions: {
-          value: concatenatedPositions,
-          size: dimension
-        },
+        positions: { value: concatenatedPositions, size: dimension },
         polygonIndices: {
           value: new Uint16Array(polygonIndices),
           size: 1
         },
-        primitivePolygonIndices: {
-          value: new Uint16Array(primitivePolygonIndices),
-          size: 1
-        }
+        primitivePolygonIndices: { value: new Uint16Array(primitivePolygonIndices), size: 1 }
       },
       offset
     };
@@ -14812,10 +14780,7 @@ return true;`);
     const concatenatedPositions = new Float64Array(concatTypedArrays(positions).buffer);
     return {
       type: "Point",
-      positions: {
-        value: concatenatedPositions,
-        size: dimension
-      }
+      positions: { value: concatenatedPositions, size: dimension }
     };
   }
   function concatenateBinaryLineGeometries(binaryLineGeometries, dimension) {
@@ -14825,24 +14790,15 @@ return true;`);
     pathIndices.unshift(0);
     return {
       type: "LineString",
-      positions: {
-        value: concatenatedPositions,
-        size: dimension
-      },
-      pathIndices: {
-        value: new Uint16Array(pathIndices),
-        size: 1
-      }
+      positions: { value: concatenatedPositions, size: dimension },
+      pathIndices: { value: new Uint16Array(pathIndices), size: 1 }
     };
   }
   function concatenateBinaryPolygonGeometries(binaryPolygonGeometries, dimension) {
     const polygons = [];
     const primitivePolygons = [];
     for (const binaryPolygon of binaryPolygonGeometries) {
-      const {
-        positions,
-        primitivePolygonIndices: primitivePolygonIndices2
-      } = binaryPolygon;
+      const { positions, primitivePolygonIndices: primitivePolygonIndices2 } = binaryPolygon;
       polygons.push(positions.value);
       primitivePolygons.push(primitivePolygonIndices2.value);
     }
@@ -14851,22 +14807,15 @@ return true;`);
     polygonIndices.unshift(0);
     const primitivePolygonIndices = [0];
     for (const primitivePolygon of primitivePolygons) {
-      primitivePolygonIndices.push(...primitivePolygon.filter((x) => x > 0).map((x) => x + primitivePolygonIndices[primitivePolygonIndices.length - 1]));
+      primitivePolygonIndices.push(
+        ...primitivePolygon.filter((x) => x > 0).map((x) => x + primitivePolygonIndices[primitivePolygonIndices.length - 1])
+      );
     }
     return {
       type: "Polygon",
-      positions: {
-        value: concatenatedPositions,
-        size: dimension
-      },
-      polygonIndices: {
-        value: new Uint16Array(polygonIndices),
-        size: 1
-      },
-      primitivePolygonIndices: {
-        value: new Uint16Array(primitivePolygonIndices),
-        size: 1
-      }
+      positions: { value: concatenatedPositions, size: dimension },
+      polygonIndices: { value: new Uint16Array(polygonIndices), size: 1 },
+      primitivePolygonIndices: { value: new Uint16Array(primitivePolygonIndices), size: 1 }
     };
   }
   function concatTypedArrays(arrays) {
@@ -14896,10 +14845,12 @@ return true;`);
     category: "geometry",
     extensions: ["wkb"],
     mimeTypes: [],
+    // TODO can we define static, serializable tests, eg. some binary strings?
     tests: [isWKB],
     options: {
       wkb: {
         shape: "binary-geometry"
+        // 'geojson-geometry'
       }
     }
   };
@@ -14948,7 +14899,10 @@ return true;`);
     return geometry;
   }
   function arrowWKBToFeature(arrowCellValue) {
-    const arrayBuffer = arrowCellValue.buffer.slice(arrowCellValue.byteOffset, arrowCellValue.byteOffset + arrowCellValue.byteLength);
+    const arrayBuffer = arrowCellValue.buffer.slice(
+      arrowCellValue.byteOffset,
+      arrowCellValue.byteOffset + arrowCellValue.byteLength
+    );
     const binaryGeometry = WKBLoader.parseSync?.(arrayBuffer);
     const geometry = binaryToGeometry(binaryGeometry);
     return geometry;
@@ -15072,7 +15026,17 @@ return true;`);
       [BufferType.VALIDITY]: cloneBuffer(data.buffers[BufferType.VALIDITY], force),
       [BufferType.TYPE]: cloneBuffer(data.buffers[BufferType.TYPE], force)
     };
-    return new Data(data.type, data.offset, data.length, data._nullCount, clonedBuffers, clonedChildren, clonedDictionary);
+    return new Data(
+      data.type,
+      data.offset,
+      data.length,
+      // @ts-expect-error _nullCount is protected. We're using it here to mimic
+      // `Data.clone`
+      data._nullCount,
+      clonedBuffers,
+      clonedChildren,
+      clonedDictionary
+    );
   }
   function isTypedArraySliced(arr) {
     return !(arr.byteOffset === 0 && arr.byteLength === arr.buffer.byteLength);
@@ -15092,11 +15056,13 @@ return true;`);
   function getVersion() {
     if (!globalThis._loadersgl_?.version) {
       globalThis._loadersgl_ = globalThis._loadersgl_ || {};
-      if (false) {
-        console.warn("loaders.gl: The __VERSION__ variable is not injected using babel plugin. Latest unstable workers would be fetched from the CDN.");
+      if (typeof __VERSION__ === "undefined") {
+        console.warn(
+          "loaders.gl: The __VERSION__ variable is not injected using babel plugin. Latest unstable workers would be fetched from the CDN."
+        );
         globalThis._loadersgl_.version = NPM_TAG;
       } else {
-        globalThis._loadersgl_.version = "4.2.0-alpha.4";
+        globalThis._loadersgl_.version = __VERSION__;
       }
     }
     return globalThis._loadersgl_.version;
@@ -15121,19 +15087,22 @@ return true;`);
   var window_ = globals.window || globals.self || globals.global || {};
   var global_ = globals.global || globals.self || globals.window || {};
   var document_ = globals.document || {};
-  var isBrowser = typeof process !== "object" || String(process) !== "[object process]" || process.browser;
+  var isBrowser = (
+    // @ts-ignore process.browser
+    typeof process !== "object" || String(process) !== "[object process]" || process.browser
+  );
   var isMobile = typeof window !== "undefined" && typeof window.orientation !== "undefined";
   var matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
   var nodeVersion = matches && parseFloat(matches[1]) || 0;
 
   // ../worker-utils/src/lib/worker-farm/worker-job.ts
   var WorkerJob = class {
-    isRunning = true;
-    _resolve = () => {
-    };
-    _reject = () => {
-    };
     constructor(jobName, workerThread) {
+      this.isRunning = true;
+      this._resolve = () => {
+      };
+      this._reject = () => {
+      };
       this.name = jobName;
       this.workerThread = workerThread;
       this.result = new Promise((resolve, reject) => {
@@ -15141,18 +15110,29 @@ return true;`);
         this._reject = reject;
       });
     }
+    /**
+     * Send a message to the job's worker thread
+     * @param data any data structure, ideally consisting mostly of transferrable objects
+     */
     postMessage(type, payload) {
       this.workerThread.postMessage({
         source: "loaders.gl",
+        // Lets worker ignore unrelated messages
         type,
         payload
       });
     }
+    /**
+     * Call to resolve the `result` Promise with the supplied value
+     */
     done(value) {
       assert(this.isRunning);
       this.isRunning = false;
       this._resolve(value);
     }
+    /**
+     * Call to reject the `result` Promise with the supplied error
+     */
     error(error) {
       assert(this.isRunning);
       this.isRunning = false;
@@ -15192,9 +15172,7 @@ return true;`);
     return getLoadableWorkerURLFromSource(workerSource);
   }
   function getLoadableWorkerURLFromSource(workerSource) {
-    const blob = new Blob([workerSource], {
-      type: "application/javascript"
-    });
+    const blob = new Blob([workerSource], { type: "application/javascript" });
     return URL.createObjectURL(blob);
   }
   function buildScriptSource(workerUrl) {
@@ -15261,17 +15239,10 @@ return true;`);
   var NOOP = () => {
   };
   var WorkerThread = class {
-    terminated = false;
-    _loadableURL = "";
-    static isSupported() {
-      return typeof Worker !== "undefined" && isBrowser || typeof NodeWorker !== "undefined" && !isBrowser;
-    }
     constructor(props) {
-      const {
-        name,
-        source,
-        url
-      } = props;
+      this.terminated = false;
+      this._loadableURL = "";
+      const { name, source, url } = props;
       assert(source || url);
       this.name = name;
       this.source = source;
@@ -15280,6 +15251,14 @@ return true;`);
       this.onError = (error) => console.log(error);
       this.worker = isBrowser ? this._createBrowserWorker() : this._createNodeWorker();
     }
+    /** Checks if workers are supported on this platform */
+    static isSupported() {
+      return typeof Worker !== "undefined" && isBrowser || typeof NodeWorker !== "undefined" && !isBrowser;
+    }
+    /**
+     * Terminate this worker thread
+     * @note Can free up significant memory
+     */
     destroy() {
       this.onMessage = NOOP;
       this.onError = NOOP;
@@ -15289,10 +15268,20 @@ return true;`);
     get isRunning() {
       return Boolean(this.onMessage);
     }
+    /**
+     * Send a message to this worker thread
+     * @param data any data structure, ideally consisting mostly of transferrable objects
+     * @param transferList If not supplied, calculated automatically by traversing data
+     */
     postMessage(data, transferList) {
       transferList = transferList || getTransferList(data);
       this.worker.postMessage(data, transferList);
     }
+    // PRIVATE
+    /**
+     * Generate a standard Error from an ErrorEvent
+     * @param event
+     */
     _getErrorFromErrorEvent(event) {
       let message = "Failed to load ";
       message += `worker ${this.name} from ${this.url}. `;
@@ -15304,14 +15293,12 @@ return true;`);
       }
       return new Error(message);
     }
+    /**
+     * Creates a worker thread on the browser
+     */
     _createBrowserWorker() {
-      this._loadableURL = getLoadableWorkerURL({
-        source: this.source,
-        url: this.url
-      });
-      const worker = new Worker(this._loadableURL, {
-        name: this.name
-      });
+      this._loadableURL = getLoadableWorkerURL({ source: this.source, url: this.url });
+      const worker = new Worker(this._loadableURL, { name: this.name });
       worker.onmessage = (event) => {
         if (!event.data) {
           this.onError(new Error("No data received"));
@@ -15326,18 +15313,18 @@ return true;`);
       worker.onmessageerror = (event) => console.error(event);
       return worker;
     }
+    /**
+     * Creates a worker thread in node.js
+     * @todo https://nodejs.org/api/async_hooks.html#async-resource-worker-pool
+     */
     _createNodeWorker() {
       let worker;
       if (this.url) {
         const absolute = this.url.includes(":/") || this.url.startsWith("/");
         const url = absolute ? this.url : `./${this.url}`;
-        worker = new NodeWorker(url, {
-          eval: false
-        });
+        worker = new NodeWorker(url, { eval: false });
       } else if (this.source) {
-        worker = new NodeWorker(this.source, {
-          eval: true
-        });
+        worker = new NodeWorker(this.source, { eval: true });
       } else {
         throw new Error("no worker");
       }
@@ -15355,34 +15342,40 @@ return true;`);
 
   // ../worker-utils/src/lib/worker-farm/worker-pool.ts
   var WorkerPool = class {
-    name = "unnamed";
-    maxConcurrency = 1;
-    maxMobileConcurrency = 1;
-    onDebug = () => {
-    };
-    reuseWorkers = true;
-    props = {};
-    jobQueue = [];
-    idleQueue = [];
-    count = 0;
-    isDestroyed = false;
-    static isSupported() {
-      return WorkerThread.isSupported();
-    }
+    /**
+     * @param processor - worker function
+     * @param maxConcurrency - max count of workers
+     */
     constructor(props) {
+      this.name = "unnamed";
+      this.maxConcurrency = 1;
+      this.maxMobileConcurrency = 1;
+      this.onDebug = () => {
+      };
+      this.reuseWorkers = true;
+      this.props = {};
+      this.jobQueue = [];
+      this.idleQueue = [];
+      this.count = 0;
+      this.isDestroyed = false;
       this.source = props.source;
       this.url = props.url;
       this.setProps(props);
     }
+    /** Checks if workers are supported on this platform */
+    static isSupported() {
+      return WorkerThread.isSupported();
+    }
+    /**
+     * Terminates all workers in the pool
+     * @note Can free up significant memory
+     */
     destroy() {
       this.idleQueue.forEach((worker) => worker.destroy());
       this.isDestroyed = true;
     }
     setProps(props) {
-      this.props = {
-        ...this.props,
-        ...props
-      };
+      this.props = { ...this.props, ...props };
       if (props.name !== void 0) {
         this.name = props.name;
       }
@@ -15401,17 +15394,17 @@ return true;`);
     }
     async startJob(name, onMessage2 = (job, type, data) => job.done(data), onError = (job, error) => job.error(error)) {
       const startPromise = new Promise((onStart) => {
-        this.jobQueue.push({
-          name,
-          onMessage: onMessage2,
-          onError,
-          onStart
-        });
+        this.jobQueue.push({ name, onMessage: onMessage2, onError, onStart });
         return this;
       });
       this._startQueuedJob();
       return await startPromise;
     }
+    // PRIVATE
+    /**
+     * Starts first queued job if worker is available or can be created
+     * Called when job is started and whenever a worker returns to the idleQueue
+     */
     async _startQueuedJob() {
       if (!this.jobQueue.length) {
         return;
@@ -15441,8 +15434,23 @@ return true;`);
         }
       }
     }
+    /**
+     * Returns a worker to the idle queue
+     * Destroys the worker if
+     *  - pool is destroyed
+     *  - if this pool doesn't reuse workers
+     *  - if maxConcurrency has been lowered
+     * @param worker
+     */
     returnWorkerToQueue(worker) {
-      const shouldDestroyWorker = !isBrowser || this.isDestroyed || !this.reuseWorkers || this.count > this._getMaxConcurrency();
+      const shouldDestroyWorker = (
+        // Workers on Node.js prevent the process from exiting.
+        // Until we figure out how to close them before exit, we always destroy them
+        !isBrowser || // If the pool is destroyed, there is no reason to keep the worker around
+        this.isDestroyed || // If the app has disabled worker reuse, any completed workers should be destroyed
+        !this.reuseWorkers || // If concurrency has been lowered, this worker might be surplus to requirements
+        this.count > this._getMaxConcurrency()
+      );
       if (shouldDestroyWorker) {
         worker.destroy();
         this.count--;
@@ -15453,6 +15461,9 @@ return true;`);
         this._startQueuedJob();
       }
     }
+    /**
+     * Returns idle worker or creates new worker if maxConcurrency has not been reached
+     */
     _getAvailableWorker() {
       if (this.idleQueue.length > 0) {
         return this.idleQueue.shift() || null;
@@ -15460,11 +15471,7 @@ return true;`);
       if (this.count < this._getMaxConcurrency()) {
         this.count++;
         const name = `${this.name.toLowerCase()} (#${this.count} of ${this.maxConcurrency})`;
-        return new WorkerThread({
-          name,
-          source: this.source,
-          url: this.url
-        });
+        return new WorkerThread({ name, source: this.source, url: this.url });
       }
       return null;
     }
@@ -15482,43 +15489,54 @@ return true;`);
     }
   };
   var WorkerFarm = class {
-    workerPools = /* @__PURE__ */ new Map();
+    /** get global instance with WorkerFarm.getWorkerFarm() */
+    constructor(props) {
+      this.workerPools = /* @__PURE__ */ new Map();
+      this.props = { ...DEFAULT_PROPS };
+      this.setProps(props);
+      this.workerPools = /* @__PURE__ */ new Map();
+    }
+    /** Checks if workers are supported on this platform */
     static isSupported() {
       return WorkerThread.isSupported();
     }
+    /** Get the singleton instance of the global worker farm */
     static getWorkerFarm(props = {}) {
       WorkerFarm._workerFarm = WorkerFarm._workerFarm || new WorkerFarm({});
       WorkerFarm._workerFarm.setProps(props);
       return WorkerFarm._workerFarm;
     }
-    constructor(props) {
-      this.props = {
-        ...DEFAULT_PROPS
-      };
-      this.setProps(props);
-      this.workerPools = /* @__PURE__ */ new Map();
-    }
+    /**
+     * Terminate all workers in the farm
+     * @note Can free up significant memory
+     */
     destroy() {
       for (const workerPool of this.workerPools.values()) {
         workerPool.destroy();
       }
       this.workerPools = /* @__PURE__ */ new Map();
     }
+    /**
+     * Set props used when initializing worker pools
+     * @param props
+     */
     setProps(props) {
-      this.props = {
-        ...this.props,
-        ...props
-      };
+      this.props = { ...this.props, ...props };
       for (const workerPool of this.workerPools.values()) {
         workerPool.setProps(this._getWorkerPoolProps());
       }
     }
+    /**
+     * Returns a worker pool for the specified worker
+     * @param options - only used first time for a specific worker name
+     * @param options.name - the name of the worker - used to identify worker pool
+     * @param options.url -
+     * @param options.source -
+     * @example
+     *   const job = WorkerFarm.getWorkerFarm().getWorkerPool({name, url}).startJob(...);
+     */
     getWorkerPool(options) {
-      const {
-        name,
-        source,
-        url
-      } = options;
+      const { name, source, url } = options;
       let workerPool = this.workerPools.get(name);
       if (!workerPool) {
         workerPool = new WorkerPool({
@@ -15576,24 +15594,20 @@ return true;`);
   async function processOnWorker(worker, data, options = {}, context = {}) {
     const name = getWorkerName(worker);
     const workerFarm = WorkerFarm.getWorkerFarm(options);
-    const {
-      source
-    } = options;
-    const workerPoolProps = {
-      name,
-      source
-    };
+    const { source } = options;
+    const workerPoolProps = { name, source };
     if (!source) {
       workerPoolProps.url = getWorkerURL(worker, options);
     }
     const workerPool = workerFarm.getWorkerPool(workerPoolProps);
     const jobName = options.jobName || worker.name;
-    const job = await workerPool.startJob(jobName, onMessage.bind(null, context));
+    const job = await workerPool.startJob(
+      jobName,
+      // eslint-disable-next-line
+      onMessage.bind(null, context)
+    );
     const transferableOptions = getTransferListForWriter(options);
-    job.postMessage("process", {
-      input: data,
-      options: transferableOptions
-    });
+    job.postMessage("process", { input: data, options: transferableOptions });
     const result = await job.result;
     return result.result;
   }
@@ -15606,30 +15620,17 @@ return true;`);
         job.error(new Error(payload.error));
         break;
       case "process":
-        const {
-          id,
-          input,
-          options
-        } = payload;
+        const { id, input, options } = payload;
         try {
           if (!context.process) {
-            job.postMessage("error", {
-              id,
-              error: "Worker not set up to process on main thread"
-            });
+            job.postMessage("error", { id, error: "Worker not set up to process on main thread" });
             return;
           }
           const result = await context.process(input, options);
-          job.postMessage("done", {
-            id,
-            result
-          });
+          job.postMessage("done", { id, result });
         } catch (error) {
           const message = error instanceof Error ? error.message : "unknown error";
-          job.postMessage("error", {
-            id,
-            error: message
-          });
+          job.postMessage("error", { id, error: message });
         }
         break;
       default:
@@ -15638,7 +15639,7 @@ return true;`);
   }
 
   // src/triangulate-on-worker.ts
-  var VERSION5 = true ? "4.2.0-alpha.4" : "latest";
+  var VERSION5 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
   var TriangulationWorker = {
     id: "triangulation",
     name: "Triangulate",
@@ -15647,21 +15648,15 @@ return true;`);
     options: {}
   };
   function triangulateOnWorker(data, options = {}) {
-    return processOnWorker(TriangulationWorker, {
-      ...data,
-      operation: "triangulate"
-    }, options);
+    return processOnWorker(TriangulationWorker, { ...data, operation: "triangulate" }, options);
   }
   function parseGeoArrowOnWorker(data, options = {}) {
-    return processOnWorker(TriangulationWorker, {
-      ...data,
-      operation: "parse-geoarrow"
-    }, options);
+    return processOnWorker(TriangulationWorker, { ...data, operation: "parse-geoarrow" }, options);
   }
 
   // src/index.ts
   TableBatchBuilder.ArrowBatch = ArrowTableBatchAggregator;
-  return __toCommonJS(src_exports);
+  return __toCommonJS(bundle_exports);
 })();
       return __exports__;
       });