@loaders.gl/arrow 4.4.0-alpha.1 → 4.4.0-alpha.9

package/dist/dist.dev.js

@@ -12842,1647 +12842,1698 @@ return true;`);
     };
   }
 
-  // src/lib/parsers/parse-arrow.ts
-  function parseArrowSync(arrayBuffer, options) {
-    const shape = options?.shape || "arrow-table";
-    const arrowTable = tableFromIPC([new Uint8Array(arrayBuffer)]);
-    return convertArrowToTable(arrowTable, shape);
-  }
-  function parseArrowInBatches(asyncIterator, options) {
-    async function* makeArrowAsyncIterator() {
-      const readers = RecordBatchReader.readAll(asyncIterator);
-      for await (const reader of readers) {
-        for await (const recordBatch of reader) {
-          if (options?.arrow?.batchDebounceMs !== void 0 && options?.arrow?.batchDebounceMs > 0) {
-            await new Promise((resolve) => setTimeout(resolve, options.arrow?.batchDebounceMs || 0));
-          }
-          const arrowTabledBatch = {
-            shape: "arrow-table",
-            batchType: "data",
-            data: new Table([recordBatch]),
-            length: recordBatch.data.length
-          };
-          yield arrowTabledBatch;
-        }
-        break;
+  // ../loader-utils/src/lib/javascript-utils/is-type.ts
+  var isSharedArrayBuffer = (value) => typeof SharedArrayBuffer !== "undefined" && value instanceof SharedArrayBuffer;
+
+  // ../worker-utils/src/lib/npm-tag.ts
+  var NPM_TAG = "beta";
+
+  // ../worker-utils/src/lib/env-utils/version.ts
+  var warningIssued = false;
+  function getVersion() {
+    if (!globalThis._loadersgl_?.version) {
+      globalThis._loadersgl_ = globalThis._loadersgl_ || {};
+      if (typeof __VERSION__ === "undefined" && !warningIssued) {
+        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;
+        warningIssued = true;
+      } else {
+        globalThis._loadersgl_.version = __VERSION__;
       }
     }
-    return makeArrowAsyncIterator();
+    return globalThis._loadersgl_.version;
   }
+  var VERSION2 = getVersion();
 
-  // src/arrow-loader.ts
-  var ArrowLoader = {
-    ...ArrowWorkerLoader,
-    parse: async (arraybuffer, options) => parseArrowSync(arraybuffer, options?.arrow),
-    parseSync: (arraybuffer, options) => parseArrowSync(arraybuffer, options?.arrow),
-    parseInBatches: parseArrowInBatches
+  // ../worker-utils/src/lib/env-utils/assert.ts
+  function assert(condition, message) {
+    if (!condition) {
+      throw new Error(message || "loaders.gl assertion failed.");
+    }
+  }
+
+  // ../worker-utils/src/lib/env-utils/globals.ts
+  var globals = {
+    self: typeof self !== "undefined" && self,
+    window: typeof window !== "undefined" && window,
+    global: typeof global !== "undefined" && global,
+    document: typeof document !== "undefined" && document
   };
+  var self_ = globals.self || globals.window || globals.global || {};
+  var window_ = globals.window || globals.self || globals.global || {};
+  var global_ = globals.global || globals.self || globals.window || {};
+  var document_ = globals.document || {};
+  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;
 
-  // src/lib/encoders/encode-arrow.ts
-  function encodeArrowSync(data) {
-    const vectors = {};
-    for (const arrayData of data) {
-      const arrayVector = createVector(arrayData.array, arrayData.type);
-      vectors[arrayData.name] = arrayVector;
+  // ../worker-utils/src/lib/worker-farm/worker-job.ts
+  var WorkerJob = class {
+    name;
+    workerThread;
+    isRunning = true;
+    /** Promise that resolves when Job is done */
+    result;
+    _resolve = () => {
+    };
+    _reject = () => {
+    };
+    constructor(jobName, workerThread) {
+      this.name = jobName;
+      this.workerThread = workerThread;
+      this.result = new Promise((resolve, reject) => {
+        this._resolve = resolve;
+        this._reject = reject;
+      });
     }
-    const table = new Table(vectors);
-    const arrowBuffer = tableToIPC(table);
-    return arrowBuffer;
-  }
-  function createVector(array, type) {
-    switch (type) {
-      case 1 /* DATE */:
-        return vectorFromArray(array);
-      case 0 /* FLOAT */:
-      default:
-        return vectorFromArray(array);
+    /**
+     * 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
+      });
     }
-  }
-
-  // src/arrow-writer.ts
-  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"
-    ],
-    binary: true,
-    options: {},
-    encode: async function encodeArrow(data, options) {
-      return encodeArrowSync(data);
-    },
-    encodeSync(data, options) {
-      return encodeArrowSync(data);
+    /**
+     * 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;
+      this._reject(error);
     }
   };
 
-  // src/exports/geoarrow-loader.ts
-  var GeoArrowWorkerLoader = {
-    ...ArrowWorkerLoader,
-    options: {
-      arrow: {
-        shape: "arrow-table"
-      }
+  // ../worker-utils/src/lib/node/worker_threads-browser.ts
+  var NodeWorker = class {
+    terminate() {
     }
   };
 
-  // ../geoarrow/src/metadata/metadata-utils.ts
-  function getMetadataValue(metadata, key) {
-    return metadata instanceof Map ? metadata.get(key) || null : metadata[key] || null;
-  }
-
-  // ../geoarrow/src/metadata/geoarrow-metadata.ts
-  var GEOARROW_ENCODINGS = [
-    "geoarrow.multipolygon",
-    "geoarrow.polygon",
-    "geoarrow.multilinestring",
-    "geoarrow.linestring",
-    "geoarrow.multipoint",
-    "geoarrow.point",
-    "geoarrow.wkb",
-    "geoarrow.wkt"
-  ];
-  var GEOARROW_ENCODING = "ARROW:extension:name";
-  var GEOARROW_METADATA = "ARROW:extension:metadata";
-  function getGeometryColumnsFromSchema(schema) {
-    const geometryColumns = {};
-    for (const field of schema.fields || []) {
-      const metadata = getGeometryMetadataForField(field?.metadata || {});
-      if (metadata) {
-        geometryColumns[field.name] = metadata;
+  // ../worker-utils/src/lib/worker-utils/get-loadable-worker-url.ts
+  var workerURLCache = /* @__PURE__ */ new Map();
+  function getLoadableWorkerURL(props) {
+    assert(props.source && !props.url || !props.source && props.url);
+    let workerURL = workerURLCache.get(props.source || props.url);
+    if (!workerURL) {
+      if (props.url) {
+        workerURL = getLoadableWorkerURLFromURL(props.url);
+        workerURLCache.set(props.url, workerURL);
+      }
+      if (props.source) {
+        workerURL = getLoadableWorkerURLFromSource(props.source);
+        workerURLCache.set(props.source, workerURL);
       }
     }
-    return geometryColumns;
+    assert(workerURL);
+    return workerURL;
   }
-  function getGeometryMetadataForField(fieldMetadata) {
-    let metadata = null;
-    let geoEncoding = getMetadataValue(fieldMetadata, GEOARROW_ENCODING);
-    if (geoEncoding) {
-      geoEncoding = geoEncoding.toLowerCase();
-      if (geoEncoding === "wkb") {
-        geoEncoding = "geoarrow.wkb";
-      }
-      if (geoEncoding === "wkt") {
-        geoEncoding = "geoarrow.wkt";
-      }
-      if (!GEOARROW_ENCODINGS.includes(geoEncoding)) {
-        console.warn(`Invalid GeoArrow encoding: ${geoEncoding}`);
-      } else {
-        metadata ||= {};
-        metadata.encoding = geoEncoding;
-      }
+  function getLoadableWorkerURLFromURL(url) {
+    if (!url.startsWith("http")) {
+      return url;
     }
-    const columnMetadata = getMetadataValue(fieldMetadata, GEOARROW_METADATA);
-    if (columnMetadata) {
-      try {
-        metadata = JSON.parse(columnMetadata);
-      } catch (error) {
-        console.warn("Failed to parse GeoArrow metadata", error);
+    const workerSource = buildScriptSource(url);
+    return getLoadableWorkerURLFromSource(workerSource);
+  }
+  function getLoadableWorkerURLFromSource(workerSource) {
+    const blob = new Blob([workerSource], { type: "application/javascript" });
+    return URL.createObjectURL(blob);
+  }
+  function buildScriptSource(workerUrl) {
+    return `try {
+  importScripts('${workerUrl}');
+} catch (error) {
+  console.error(error);
+  throw error;
+}`;
+  }
+
+  // ../worker-utils/src/lib/worker-utils/get-transfer-list.ts
+  function getTransferList(object, recursive = true, transfers) {
+    const transfersSet = transfers || /* @__PURE__ */ new Set();
+    if (!object) {
+    } else if (isTransferable(object)) {
+      transfersSet.add(object);
+    } else if (isTransferable(object.buffer)) {
+      transfersSet.add(object.buffer);
+    } else if (ArrayBuffer.isView(object)) {
+    } else if (recursive && typeof object === "object") {
+      for (const key in object) {
+        getTransferList(object[key], recursive, transfersSet);
       }
     }
-    return metadata || null;
+    return transfers === void 0 ? Array.from(transfersSet) : [];
   }
-
-  // ../gis/src/lib/geometry-converters/convert-binary-geometry-to-geojson.ts
-  function convertBinaryGeometryToGeometry(data, startIndex, endIndex) {
-    switch (data.type) {
-      case "Point":
-        return pointToGeoJson(data, startIndex, endIndex);
-      case "LineString":
-        return lineStringToGeoJson(data, startIndex, endIndex);
-      case "Polygon":
-        return polygonToGeoJson(data, startIndex, endIndex);
-      default:
-        const unexpectedInput = data;
-        throw new Error(`Unsupported geometry type: ${unexpectedInput?.type}`);
+  function isTransferable(object) {
+    if (!object) {
+      return false;
     }
-  }
-  function polygonToGeoJson(data, startIndex = -Infinity, endIndex = Infinity) {
-    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 multi = polygonIndices.length > 2;
-    if (!multi) {
-      const coordinates2 = [];
-      for (let i = 0; i < primitivePolygonIndices.length - 1; i++) {
-        const startRingIndex = primitivePolygonIndices[i];
-        const endRingIndex = primitivePolygonIndices[i + 1];
-        const ringCoordinates = ringToGeoJson(positions, startRingIndex, endRingIndex);
-        coordinates2.push(ringCoordinates);
-      }
-      return { type: "Polygon", coordinates: coordinates2 };
+    if (object instanceof ArrayBuffer) {
+      return true;
     }
-    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;
-      coordinates.push(polygonCoordinates);
+    if (typeof MessagePort !== "undefined" && object instanceof MessagePort) {
+      return true;
     }
-    return { type: "MultiPolygon", coordinates };
-  }
-  function lineStringToGeoJson(data, startIndex = -Infinity, endIndex = Infinity) {
-    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 };
+    if (typeof ImageBitmap !== "undefined" && object instanceof ImageBitmap) {
+      return true;
     }
-    const coordinates = [];
-    for (let i = 0; i < pathIndices.length - 1; i++) {
-      const ringCoordinates = ringToGeoJson(positions, pathIndices[i], pathIndices[i + 1]);
-      coordinates.push(ringCoordinates);
+    if (typeof OffscreenCanvas !== "undefined" && object instanceof OffscreenCanvas) {
+      return true;
     }
-    return { type: "MultiLineString", coordinates };
+    return false;
   }
-  function pointToGeoJson(data, startIndex, endIndex) {
-    const { positions } = data;
-    const coordinates = ringToGeoJson(positions, startIndex, endIndex);
-    const multi = coordinates.length > 1;
-    if (multi) {
-      return { type: "MultiPoint", coordinates };
+  function getTransferListForWriter(object) {
+    if (object === null) {
+      return {};
     }
-    return { type: "Point", coordinates: coordinates[0] };
-  }
-  function ringToGeoJson(positions, startIndex, endIndex) {
-    startIndex = startIndex || 0;
-    endIndex = endIndex || positions.value.length / positions.size;
-    const ringCoordinates = [];
-    for (let j = startIndex; j < endIndex; j++) {
-      const coord = Array();
-      for (let k = j * positions.size; k < (j + 1) * positions.size; k++) {
-        coord.push(Number(positions.value[k]));
+    const clone = Object.assign({}, object);
+    Object.keys(clone).forEach((key) => {
+      if (typeof object[key] === "object" && !ArrayBuffer.isView(object[key]) && !(object[key] instanceof Array)) {
+        clone[key] = getTransferListForWriter(object[key]);
+      } else if (typeof clone[key] === "function" || clone[key] instanceof RegExp) {
+        clone[key] = {};
+      } else {
+        clone[key] = object[key];
       }
-      ringCoordinates.push(coord);
-    }
-    return ringCoordinates;
+    });
+    return clone;
   }
 
-  // ../gis/src/lib/utils/concat-typed-arrays.ts
-  function concatTypedArrays(arrays) {
-    let byteLength = 0;
-    for (let i = 0; i < arrays.length; ++i) {
-      byteLength += arrays[i].byteLength;
+  // ../worker-utils/src/lib/worker-farm/worker-thread.ts
+  var NOOP = () => {
+  };
+  var WorkerThread = class {
+    name;
+    source;
+    url;
+    terminated = false;
+    worker;
+    onMessage;
+    onError;
+    _loadableURL = "";
+    /** Checks if workers are supported on this platform */
+    static isSupported() {
+      return typeof Worker !== "undefined" && isBrowser || typeof NodeWorker !== "undefined" && !isBrowser;
     }
-    const buffer = new Uint8Array(byteLength);
-    let byteOffset = 0;
-    for (let i = 0; i < arrays.length; ++i) {
-      const data = new Uint8Array(arrays[i].buffer);
-      byteLength = data.length;
-      for (let j = 0; j < byteLength; ++j) {
-        buffer[byteOffset++] = data[j];
-      }
+    constructor(props) {
+      const { name, source, url } = props;
+      assert(source || url);
+      this.name = name;
+      this.source = source;
+      this.url = url;
+      this.onMessage = NOOP;
+      this.onError = (error) => console.log(error);
+      this.worker = isBrowser ? this._createBrowserWorker() : this._createNodeWorker();
     }
-    return buffer;
-  }
-
-  // ../gis/src/lib/binary-geometry-api/concat-binary-geometry.ts
-  function concatenateBinaryPointGeometries(binaryPointGeometries, dimension) {
-    const positions = binaryPointGeometries.map((geometry) => geometry.positions.value);
-    const concatenatedPositions = new Float64Array(concatTypedArrays(positions).buffer);
-    return {
-      type: "Point",
-      positions: { value: concatenatedPositions, size: dimension }
-    };
-  }
-  function concatenateBinaryLineGeometries(binaryLineGeometries, dimension) {
-    const lines = binaryLineGeometries.map((geometry) => geometry.positions.value);
-    const concatenatedPositions = new Float64Array(concatTypedArrays(lines).buffer);
-    const pathIndices = lines.map((line) => line.length / dimension).map(cumulativeSum(0));
-    pathIndices.unshift(0);
-    return {
-      type: "LineString",
-      positions: { value: concatenatedPositions, size: dimension },
-      pathIndices: { value: new Uint32Array(pathIndices), size: 1 }
-    };
-  }
-  function concatenateBinaryPolygonGeometries(binaryPolygonGeometries, dimension) {
-    const polygons = [];
-    const primitivePolygons = [];
-    for (const binaryPolygon of binaryPolygonGeometries) {
-      const { positions, primitivePolygonIndices: primitivePolygonIndices2 } = binaryPolygon;
-      polygons.push(positions.value);
-      primitivePolygons.push(primitivePolygonIndices2.value);
+    /**
+     * Terminate this worker thread
+     * @note Can free up significant memory
+     */
+    destroy() {
+      this.onMessage = NOOP;
+      this.onError = NOOP;
+      this.worker.terminate();
+      this.terminated = true;
     }
-    const concatenatedPositions = new Float64Array(concatTypedArrays(polygons).buffer);
-    const polygonIndices = polygons.map((p) => p.length / dimension).map(cumulativeSum(0));
-    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])
-      );
+    get isRunning() {
+      return Boolean(this.onMessage);
     }
-    return {
-      type: "Polygon",
-      positions: { value: concatenatedPositions, size: dimension },
-      polygonIndices: { value: new Uint32Array(polygonIndices), size: 1 },
-      primitivePolygonIndices: { value: new Uint32Array(primitivePolygonIndices), size: 1 }
-    };
-  }
-  var cumulativeSum = (sum) => (value) => sum += value;
-
-  // ../gis/src/lib/geometry-converters/wkb/helpers/wkb-types.ts
-  var EWKB_FLAG_Z = 2147483648;
-  var EWKB_FLAG_M = 1073741824;
-  var EWKB_FLAG_SRID = 536870912;
-  var WKT_MAGIC_STRINGS = [
-    "POINT(",
-    "LINESTRING(",
-    "POLYGON(",
-    "MULTIPOINT(",
-    "MULTILINESTRING(",
-    "MULTIPOLYGON(",
-    "GEOMETRYCOLLECTION("
-  ];
-  var textEncoder = new TextEncoder();
-  var WKT_MAGIC_BYTES = WKT_MAGIC_STRINGS.map((string) => textEncoder.encode(string));
-
-  // ../gis/src/lib/geometry-converters/wkb/helpers/parse-wkb-header.ts
-  function isWKT(input) {
-    return getWKTGeometryType(input) !== null;
-  }
-  function getWKTGeometryType(input) {
-    if (typeof input === "string") {
-      const index2 = WKT_MAGIC_STRINGS.findIndex((magicString) => input.startsWith(magicString));
-      return index2 >= 0 ? index2 + 1 : null;
+    /**
+     * 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);
     }
-    const inputArray = new Uint8Array(input);
-    const index = WKT_MAGIC_BYTES.findIndex(
-      (magicBytes) => magicBytes.every((value, index2) => value === inputArray[index2])
-    );
-    return index >= 0 ? index + 1 : null;
-  }
-  function parseWKBHeader(dataView, target) {
-    const wkbHeader = Object.assign(target || {}, {
-      type: "wkb",
-      variant: "wkb",
-      geometryType: 1,
-      dimensions: 2,
-      coordinates: "xy",
-      littleEndian: true,
-      byteOffset: 0
-    });
-    if (isWKT(dataView.buffer)) {
-      throw new Error("WKB: Cannot parse WKT data");
+    // PRIVATE
+    /**
+     * Generate a standard Error from an ErrorEvent
+     * @param event
+     */
+    _getErrorFromErrorEvent(event) {
+      let message = "Failed to load ";
+      message += `worker ${this.name} from ${this.url}. `;
+      if (event.message) {
+        message += `${event.message} in `;
+      }
+      if (event.lineno) {
+        message += `:${event.lineno}:${event.colno}`;
+      }
+      return new Error(message);
     }
-    wkbHeader.littleEndian = dataView.getUint8(wkbHeader.byteOffset) === 1;
-    wkbHeader.byteOffset++;
-    const geometryCode = dataView.getUint32(wkbHeader.byteOffset, wkbHeader.littleEndian);
-    wkbHeader.byteOffset += 4;
-    wkbHeader.geometryType = geometryCode & 7;
-    const isoType = (geometryCode - wkbHeader.geometryType) / 1e3;
-    switch (isoType) {
-      case 0:
-        break;
-      case 1:
-        wkbHeader.variant = "iso-wkb";
-        wkbHeader.dimensions = 3;
-        wkbHeader.coordinates = "xyz";
-        break;
-      case 2:
-        wkbHeader.variant = "iso-wkb";
-        wkbHeader.dimensions = 3;
-        wkbHeader.coordinates = "xym";
-        break;
-      case 3:
-        wkbHeader.variant = "iso-wkb";
-        wkbHeader.dimensions = 4;
-        wkbHeader.coordinates = "xyzm";
-        break;
-      default:
-        throw new Error(`WKB: Unsupported iso-wkb type: ${isoType}`);
-    }
-    const ewkbZ = geometryCode & EWKB_FLAG_Z;
-    const ewkbM = geometryCode & EWKB_FLAG_M;
-    const ewkbSRID = geometryCode & EWKB_FLAG_SRID;
-    if (ewkbZ && ewkbM) {
-      wkbHeader.variant = "ewkb";
-      wkbHeader.dimensions = 4;
-      wkbHeader.coordinates = "xyzm";
-    } else if (ewkbZ) {
-      wkbHeader.variant = "ewkb";
-      wkbHeader.dimensions = 3;
-      wkbHeader.coordinates = "xyz";
-    } else if (ewkbM) {
-      wkbHeader.variant = "ewkb";
-      wkbHeader.dimensions = 3;
-      wkbHeader.coordinates = "xym";
+    /**
+     * 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 });
+      worker.onmessage = (event) => {
+        if (!event.data) {
+          this.onError(new Error("No data received"));
+        } else {
+          this.onMessage(event.data);
+        }
+      };
+      worker.onerror = (error) => {
+        this.onError(this._getErrorFromErrorEvent(error));
+        this.terminated = true;
+      };
+      worker.onmessageerror = (event) => console.error(event);
+      return worker;
     }
-    if (ewkbSRID) {
-      wkbHeader.variant = "ewkb";
-      wkbHeader.srid = dataView.getUint32(wkbHeader.byteOffset, wkbHeader.littleEndian);
-      wkbHeader.byteOffset += 4;
+    /**
+     * 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}`;
+        const type = this.url.endsWith(".ts") || this.url.endsWith(".mjs") ? "module" : "commonjs";
+        worker = new NodeWorker(url, { eval: false, type });
+      } else if (this.source) {
+        worker = new NodeWorker(this.source, { eval: true });
+      } else {
+        throw new Error("no worker");
+      }
+      worker.on("message", (data) => {
+        this.onMessage(data);
+      });
+      worker.on("error", (error) => {
+        this.onError(error);
+      });
+      worker.on("exit", (code) => {
+      });
+      return worker;
     }
-    return wkbHeader;
-  }
+  };
 
-  // ../gis/src/lib/geometry-converters/wkb/convert-wkb-to-binary-geometry.ts
-  function convertWKBToBinaryGeometry(arrayBuffer) {
-    const dataView = new DataView(arrayBuffer);
-    const wkbHeader = parseWKBHeader(dataView);
-    const { geometryType, dimensions, littleEndian } = wkbHeader;
-    const offset = wkbHeader.byteOffset;
-    switch (geometryType) {
-      case 1 /* Point */:
-        const point = parsePoint(dataView, offset, dimensions, littleEndian);
-        return point.geometry;
-      case 2 /* LineString */:
-        const line = parseLineString(dataView, offset, dimensions, littleEndian);
-        return line.geometry;
-      case 3 /* Polygon */:
-        const polygon = parsePolygon(dataView, offset, dimensions, littleEndian);
-        return polygon.geometry;
-      case 4 /* MultiPoint */:
-        const multiPoint = parseMultiPoint(dataView, offset, dimensions, littleEndian);
-        multiPoint.type = "Point";
-        return multiPoint;
-      case 5 /* MultiLineString */:
-        const multiLine = parseMultiLineString(dataView, offset, dimensions, littleEndian);
-        multiLine.type = "LineString";
-        return multiLine;
-      case 6 /* MultiPolygon */:
-        const multiPolygon = parseMultiPolygon(dataView, offset, dimensions, littleEndian);
-        multiPolygon.type = "Polygon";
-        return multiPolygon;
-      default:
-        throw new Error(`WKB: Unsupported geometry type: ${geometryType}`);
-    }
-  }
-  function parsePoint(dataView, offset, dimension, littleEndian) {
-    const positions = new Float64Array(dimension);
-    for (let i = 0; i < dimension; i++) {
-      positions[i] = dataView.getFloat64(offset, littleEndian);
-      offset += 8;
-    }
-    return {
-      geometry: { type: "Point", positions: { value: positions, size: dimension } },
-      offset
+  // ../worker-utils/src/lib/worker-farm/worker-pool.ts
+  var WorkerPool = class {
+    name = "unnamed";
+    source;
+    // | Function;
+    url;
+    maxConcurrency = 1;
+    maxMobileConcurrency = 1;
+    onDebug = () => {
     };
-  }
-  function parseLineString(dataView, offset, dimension, littleEndian) {
-    const nPoints = dataView.getUint32(offset, littleEndian);
-    offset += 4;
-    const positions = new Float64Array(nPoints * dimension);
-    for (let i = 0; i < nPoints * dimension; i++) {
-      positions[i] = dataView.getFloat64(offset, littleEndian);
-      offset += 8;
-    }
-    const pathIndices = [0];
-    if (nPoints > 0) {
-      pathIndices.push(nPoints);
+    reuseWorkers = true;
+    props = {};
+    jobQueue = [];
+    idleQueue = [];
+    count = 0;
+    isDestroyed = false;
+    /** Checks if workers are supported on this platform */
+    static isSupported() {
+      return WorkerThread.isSupported();
     }
-    return {
-      geometry: {
-        type: "LineString",
-        positions: { value: positions, size: dimension },
-        pathIndices: { value: new Uint32Array(pathIndices), size: 1 }
-      },
-      offset
-    };
-  }
-  var cumulativeSum2 = (sum) => (value) => sum += value;
-  function parsePolygon(dataView, offset, dimension, littleEndian) {
-    const nRings = dataView.getUint32(offset, littleEndian);
-    offset += 4;
-    const rings = [];
-    for (let i = 0; i < nRings; i++) {
-      const parsed = parseLineString(dataView, offset, dimension, littleEndian);
-      const { positions } = parsed.geometry;
-      offset = parsed.offset;
-      rings.push(positions.value);
+    /**
+     * @param processor - worker function
+     * @param maxConcurrency - max count of workers
+     */
+    constructor(props) {
+      this.source = props.source;
+      this.url = props.url;
+      this.setProps(props);
     }
-    const concatenatedPositions = new Float64Array(concatTypedArrays(rings).buffer);
-    const polygonIndices = [0];
-    if (concatenatedPositions.length > 0) {
-      polygonIndices.push(concatenatedPositions.length / dimension);
+    /**
+     * Terminates all workers in the pool
+     * @note Can free up significant memory
+     */
+    destroy() {
+      this.idleQueue.forEach((worker) => worker.destroy());
+      this.isDestroyed = true;
     }
-    const primitivePolygonIndices = rings.map((l) => l.length / dimension).map(cumulativeSum2(0));
-    primitivePolygonIndices.unshift(0);
-    return {
-      geometry: {
-        type: "Polygon",
-        positions: { value: concatenatedPositions, size: dimension },
-        polygonIndices: {
-          value: new Uint32Array(polygonIndices),
-          size: 1
-        },
-        primitivePolygonIndices: { value: new Uint32Array(primitivePolygonIndices), size: 1 }
-      },
-      offset
-    };
-  }
-  function parseMultiPoint(dataView, offset, dimension, littleEndian) {
-    const nPoints = dataView.getUint32(offset, littleEndian);
-    offset += 4;
-    const binaryPointGeometries = [];
-    for (let i = 0; i < nPoints; i++) {
-      const littleEndianPoint = dataView.getUint8(offset) === 1;
-      offset++;
-      if (dataView.getUint32(offset, littleEndianPoint) % 1e3 !== 1) {
-        throw new Error("WKB: Inner geometries of MultiPoint not of type Point");
+    setProps(props) {
+      this.props = { ...this.props, ...props };
+      if (props.name !== void 0) {
+        this.name = props.name;
       }
-      offset += 4;
-      const parsed = parsePoint(dataView, offset, dimension, littleEndianPoint);
-      offset = parsed.offset;
-      binaryPointGeometries.push(parsed.geometry);
-    }
-    return concatenateBinaryPointGeometries(binaryPointGeometries, dimension);
-  }
-  function parseMultiLineString(dataView, offset, dimension, littleEndian) {
-    const nLines = dataView.getUint32(offset, littleEndian);
-    offset += 4;
-    const binaryLineGeometries = [];
-    for (let i = 0; i < nLines; i++) {
-      const littleEndianLine = dataView.getUint8(offset) === 1;
-      offset++;
-      if (dataView.getUint32(offset, littleEndianLine) % 1e3 !== 2) {
-        throw new Error("WKB: Inner geometries of MultiLineString not of type LineString");
+      if (props.maxConcurrency !== void 0) {
+        this.maxConcurrency = props.maxConcurrency;
       }
-      offset += 4;
-      const parsed = parseLineString(dataView, offset, dimension, littleEndianLine);
-      offset = parsed.offset;
-      binaryLineGeometries.push(parsed.geometry);
-    }
-    return concatenateBinaryLineGeometries(binaryLineGeometries, dimension);
-  }
-  function parseMultiPolygon(dataView, offset, dimension, littleEndian) {
-    const nPolygons = dataView.getUint32(offset, littleEndian);
-    offset += 4;
-    const binaryPolygonGeometries = [];
-    for (let i = 0; i < nPolygons; i++) {
-      const littleEndianPolygon = dataView.getUint8(offset) === 1;
-      offset++;
-      if (dataView.getUint32(offset, littleEndianPolygon) % 1e3 !== 3) {
-        throw new Error("WKB: Inner geometries of MultiPolygon not of type Polygon");
+      if (props.maxMobileConcurrency !== void 0) {
+        this.maxMobileConcurrency = props.maxMobileConcurrency;
+      }
+      if (props.reuseWorkers !== void 0) {
+        this.reuseWorkers = props.reuseWorkers;
+      }
+      if (props.onDebug !== void 0) {
+        this.onDebug = props.onDebug;
       }
-      offset += 4;
-      const parsed = parsePolygon(dataView, offset, dimension, littleEndianPolygon);
-      offset = parsed.offset;
-      binaryPolygonGeometries.push(parsed.geometry);
     }
-    return concatenateBinaryPolygonGeometries(binaryPolygonGeometries, dimension);
-  }
-
-  // ../gis/src/lib/geometry-converters/wkb/convert-wkb-to-geometry.ts
-  function convertWKBToGeometry(arrayBuffer) {
-    const binaryGeometry = convertWKBToBinaryGeometry(arrayBuffer);
-    return convertBinaryGeometryToGeometry(binaryGeometry);
-  }
-
-  // ../gis/src/lib/geometry-converters/wkb/convert-wkt-to-geometry.ts
-  var numberRegexp = /[-+]?([0-9]*\.[0-9]+|[0-9]+)([eE][-+]?[0-9]+)?/;
-  var tuples = new RegExp("^" + numberRegexp.source + "(\\s" + numberRegexp.source + "){1,}");
-  function convertWKTToGeometry(input, options) {
-    const parts = input.split(";");
-    let _ = parts.pop();
-    const srid = (parts.shift() || "").split("=").pop();
-    const state = { parts, _, i: 0 };
-    const geometry = parseGeometry(state);
-    return options?.wkt?.crs ? addCRS(geometry, srid) : geometry;
-  }
-  function parseGeometry(state) {
-    return parsePoint2(state) || parseLineString2(state) || parsePolygon2(state) || parseMultiPoint2(state) || parseMultiLineString2(state) || parseMultiPolygon2(state) || parseGeometryCollection(state);
-  }
-  function addCRS(obj, srid) {
-    if (obj && srid?.match(/\d+/)) {
-      const crs = {
-        type: "name",
-        properties: {
-          name: "urn:ogc:def:crs:EPSG::" + srid
+    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 });
+        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;
+      }
+      const workerThread = this._getAvailableWorker();
+      if (!workerThread) {
+        return;
+      }
+      const queuedJob = this.jobQueue.shift();
+      if (queuedJob) {
+        this.onDebug({
+          message: "Starting job",
+          name: queuedJob.name,
+          workerThread,
+          backlog: this.jobQueue.length
+        });
+        const job = new WorkerJob(queuedJob.name, workerThread);
+        workerThread.onMessage = (data) => queuedJob.onMessage(job, data.type, data.payload);
+        workerThread.onError = (error) => queuedJob.onError(job, error);
+        queuedJob.onStart(job);
+        try {
+          await job.result;
+        } catch (error) {
+          console.error(`Worker exception: ${error}`);
+        } finally {
+          this.returnWorkerToQueue(workerThread);
         }
-      };
-      obj.crs = crs;
+      }
+    }
+    /**
+     * 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 = (
+        // 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--;
+      } else {
+        this.idleQueue.push(worker);
+      }
+      if (!this.isDestroyed) {
+        this._startQueuedJob();
+      }
     }
-    return obj;
-  }
-  function parsePoint2(state) {
-    if (!$(/^(POINT(\sz)?)/i, state)) {
+    /**
+     * Returns idle worker or creates new worker if maxConcurrency has not been reached
+     */
+    _getAvailableWorker() {
+      if (this.idleQueue.length > 0) {
+        return this.idleQueue.shift() || null;
+      }
+      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 null;
     }
-    white(state);
-    if (!$(/^(\()/, state)) {
-      return null;
+    _getMaxConcurrency() {
+      return isMobile ? this.maxMobileConcurrency : this.maxConcurrency;
     }
-    const c = coords(state);
-    if (!c) {
-      return null;
+  };
+
+  // ../worker-utils/src/lib/worker-farm/worker-farm.ts
+  var DEFAULT_PROPS = {
+    maxConcurrency: 3,
+    maxMobileConcurrency: 1,
+    reuseWorkers: true,
+    onDebug: () => {
     }
-    white(state);
-    if (!$(/^(\))/, state)) {
-      return null;
+  };
+  var _WorkerFarm = class {
+    props;
+    workerPools = /* @__PURE__ */ new Map();
+    /** Checks if workers are supported on this platform */
+    static isSupported() {
+      return WorkerThread.isSupported();
     }
-    return {
-      type: "Point",
-      coordinates: c[0]
-    };
-  }
-  function parseMultiPoint2(state) {
-    if (!$(/^(MULTIPOINT)/i, state)) {
-      return null;
+    /** 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;
     }
-    white(state);
-    const newCoordsFormat = state._?.substring(state._?.indexOf("(") + 1, state._.length - 1).replace(/\(/g, "").replace(/\)/g, "");
-    state._ = "MULTIPOINT (" + newCoordsFormat + ")";
-    const c = multicoords(state);
-    if (!c) {
-      return null;
+    /** get global instance with WorkerFarm.getWorkerFarm() */
+    constructor(props) {
+      this.props = { ...DEFAULT_PROPS };
+      this.setProps(props);
+      this.workerPools = /* @__PURE__ */ new Map();
     }
-    white(state);
-    return {
-      type: "MultiPoint",
-      coordinates: c
-    };
-  }
-  function parseLineString2(state) {
-    if (!$(/^(LINESTRING(\sz)?)/i, state)) {
-      return null;
+    /**
+     * 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();
     }
-    white(state);
-    if (!$(/^(\()/, state)) {
-      return null;
+    /**
+     * Set props used when initializing worker pools
+     * @param props
+     */
+    setProps(props) {
+      this.props = { ...this.props, ...props };
+      for (const workerPool of this.workerPools.values()) {
+        workerPool.setProps(this._getWorkerPoolProps());
+      }
     }
-    const c = coords(state);
-    if (!c) {
-      return null;
+    /**
+     * 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;
+      let workerPool = this.workerPools.get(name);
+      if (!workerPool) {
+        workerPool = new WorkerPool({
+          name,
+          source,
+          url
+        });
+        workerPool.setProps(this._getWorkerPoolProps());
+        this.workerPools.set(name, workerPool);
+      }
+      return workerPool;
     }
-    if (!$(/^(\))/, state)) {
-      return null;
+    _getWorkerPoolProps() {
+      return {
+        maxConcurrency: this.props.maxConcurrency,
+        maxMobileConcurrency: this.props.maxMobileConcurrency,
+        reuseWorkers: this.props.reuseWorkers,
+        onDebug: this.props.onDebug
+      };
     }
-    return {
-      type: "LineString",
-      coordinates: c
-    };
+  };
+  var WorkerFarm = _WorkerFarm;
+  // singleton
+  __publicField(WorkerFarm, "_workerFarm");
+
+  // ../worker-utils/src/lib/worker-api/get-worker-url.ts
+  function getWorkerName(worker) {
+    const warning = worker.version !== VERSION2 ? ` (worker-utils@${VERSION2})` : "";
+    return `${worker.name}@${worker.version}${warning}`;
   }
-  function parseMultiLineString2(state) {
-    if (!$(/^(MULTILINESTRING)/i, state))
-      return null;
-    white(state);
-    const c = multicoords(state);
-    if (!c) {
-      return null;
+  function getWorkerURL(worker, options = {}) {
+    const workerOptions = options[worker.id] || {};
+    const workerFile = isBrowser ? `${worker.id}-worker.js` : `${worker.id}-worker-node.js`;
+    let url = workerOptions.workerUrl;
+    if (!url && worker.id === "compression") {
+      url = options.workerUrl;
     }
-    white(state);
-    return {
-      // @ts-ignore
-      type: "MultiLineString",
-      // @ts-expect-error
-      coordinates: c
-    };
-  }
-  function parsePolygon2(state) {
-    if (!$(/^(POLYGON(\sz)?)/i, state)) {
-      return null;
+    const workerType = options._workerType || options?.core?._workerType;
+    if (workerType === "test") {
+      if (isBrowser) {
+        url = `modules/${worker.module}/dist/${workerFile}`;
+      } else {
+        url = `modules/${worker.module}/src/workers/${worker.id}-worker-node.ts`;
+      }
     }
-    white(state);
-    const c = multicoords(state);
-    if (!c) {
-      return null;
+    if (!url) {
+      let version = worker.version;
+      if (version === "latest") {
+        version = NPM_TAG;
+      }
+      const versionTag = version ? `@${version}` : "";
+      url = `https://unpkg.com/@loaders.gl/${worker.module}${versionTag}/dist/${workerFile}`;
     }
-    return {
-      // @ts-ignore
-      type: "Polygon",
-      // @ts-expect-error
-      coordinates: c
-    };
+    assert(url);
+    return url;
   }
-  function parseMultiPolygon2(state) {
-    if (!$(/^(MULTIPOLYGON)/i, state)) {
-      return null;
+
+  // ../worker-utils/src/lib/worker-api/process-on-worker.ts
+  async function processOnWorker(worker, data, options = {}, context = {}) {
+    const name = getWorkerName(worker);
+    const workerFarm = WorkerFarm.getWorkerFarm(options);
+    const { source } = options;
+    const workerPoolProps = { name, source };
+    if (!source) {
+      workerPoolProps.url = getWorkerURL(worker, options);
     }
-    white(state);
-    const c = multicoords(state);
-    if (!c) {
-      return null;
+    const workerPool = workerFarm.getWorkerPool(workerPoolProps);
+    const jobName = options.jobName || worker.name;
+    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 });
+    const result = await job.result;
+    return result.result;
+  }
+  async function onMessage(context, job, type, payload) {
+    switch (type) {
+      case "done":
+        job.done(payload);
+        break;
+      case "error":
+        job.error(new Error(payload.error));
+        break;
+      case "process":
+        const { id, input, options } = payload;
+        try {
+          if (!context.process) {
+            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 });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "unknown error";
+          job.postMessage("error", { id, error: message });
+        }
+        break;
+      default:
+        console.warn(`process-on-worker: unknown message ${type}`);
     }
-    return {
-      type: "MultiPolygon",
-      // @ts-expect-error
-      coordinates: c
-    };
   }
-  function parseGeometryCollection(state) {
-    const geometries = [];
-    let geometry;
-    if (!$(/^(GEOMETRYCOLLECTION)/i, state)) {
-      return null;
-    }
-    white(state);
-    if (!$(/^(\()/, state)) {
-      return null;
+
+  // ../loader-utils/src/lib/iterators/async-iteration.ts
+  async function* toArrayBufferIterator(asyncIterator) {
+    for await (const chunk of asyncIterator) {
+      yield copyToArrayBuffer(chunk);
     }
-    while (geometry = parseGeometry(state)) {
-      geometries.push(geometry);
-      white(state);
-      $(/^(,)/, state);
-      white(state);
+  }
+  function copyToArrayBuffer(chunk) {
+    if (chunk instanceof ArrayBuffer) {
+      return chunk;
     }
-    if (!$(/^(\))/, state)) {
-      return null;
+    if (ArrayBuffer.isView(chunk)) {
+      const { buffer, byteOffset, byteLength } = chunk;
+      return copyFromBuffer(buffer, byteOffset, byteLength);
     }
-    return {
-      type: "GeometryCollection",
-      geometries
-    };
+    return copyFromBuffer(chunk);
   }
-  function multicoords(state) {
-    white(state);
-    let depth = 0;
-    const rings = [];
-    const stack = [rings];
-    let pointer = rings;
-    let elem;
-    while (elem = $(/^(\()/, state) || $(/^(\))/, state) || $(/^(,)/, state) || $(tuples, state)) {
-      if (elem === "(") {
-        stack.push(pointer);
-        pointer = [];
-        stack[stack.length - 1].push(pointer);
-        depth++;
-      } else if (elem === ")") {
-        if (pointer.length === 0)
-          return null;
-        pointer = stack.pop();
-        if (!pointer)
-          return null;
-        depth--;
-        if (depth === 0)
-          break;
-      } else if (elem === ",") {
-        pointer = [];
-        stack[stack.length - 1].push(pointer);
-      } else if (!elem.split(/\s/g).some(isNaN)) {
-        Array.prototype.push.apply(pointer, elem.split(/\s/g).map(parseFloat));
-      } else {
-        return null;
-      }
-      white(state);
-    }
-    if (depth !== 0)
-      return null;
-    return rings;
+  function copyFromBuffer(buffer, byteOffset = 0, byteLength = buffer.byteLength - byteOffset) {
+    const view = new Uint8Array(buffer, byteOffset, byteLength);
+    const copy = new Uint8Array(view.length);
+    copy.set(view);
+    return copy.buffer;
   }
-  function coords(state) {
-    const list = [];
-    let item;
-    let pt;
-    while (pt = $(tuples, state) || $(/^(,)/, state)) {
-      if (pt === ",") {
-        list.push(item);
-        item = [];
-      } else if (!pt.split(/\s/g).some(isNaN)) {
-        if (!item)
-          item = [];
-        Array.prototype.push.apply(item, pt.split(/\s/g).map(parseFloat));
-      }
-      white(state);
+
+  // ../loader-utils/src/lib/binary-utils/memory-conversion-utils.ts
+  function ensureArrayBuffer(bufferSource) {
+    if (bufferSource instanceof ArrayBuffer) {
+      return bufferSource;
     }
-    if (item)
-      list.push(item);
-    else
-      return null;
-    return list.length ? list : null;
-  }
-  function $(regexp, state) {
-    const match = state._?.substring(state.i).match(regexp);
-    if (!match)
-      return null;
-    else {
-      state.i += match[0].length;
-      return match[0];
+    if (isSharedArrayBuffer(bufferSource)) {
+      return copyToArrayBuffer2(bufferSource);
+    }
+    const { buffer, byteOffset, byteLength } = bufferSource;
+    if (buffer instanceof ArrayBuffer && byteOffset === 0 && byteLength === buffer.byteLength) {
+      return buffer;
     }
+    return copyToArrayBuffer2(buffer, byteOffset, byteLength);
   }
-  function white(state) {
-    $(/^\s*/, state);
+  function copyToArrayBuffer2(buffer, byteOffset = 0, byteLength = buffer.byteLength - byteOffset) {
+    const view = new Uint8Array(buffer, byteOffset, byteLength);
+    const copy = new Uint8Array(view.length);
+    copy.set(view);
+    return copy.buffer;
   }
 
-  // ../gis/src/lib/geometry-converters/convert-geoarrow-to-geojson.ts
-  function convertGeoArrowGeometryToGeoJSON(arrowCellValue, encoding) {
-    encoding = encoding?.toLowerCase();
-    if (!encoding || !arrowCellValue) {
-      return null;
-    }
-    switch (encoding) {
-      case "geoarrow.multipolygon":
-        return arrowMultiPolygonToGeometry(arrowCellValue);
-      case "geoarrow.polygon":
-        return arrowPolygonToGeometry(arrowCellValue);
-      case "geoarrow.multipoint":
-        return arrowMultiPointToGeometry(arrowCellValue);
-      case "geoarrow.point":
-        return arrowPointToGeometry(arrowCellValue);
-      case "geoarrow.multilinestring":
-        return arrowMultiLineStringToGeometry(arrowCellValue);
-      case "geoarrow.linestring":
-        return arrowLineStringToGeometry(arrowCellValue);
-      case "geoarrow.wkb":
-        return arrowWKBToGeometry(arrowCellValue);
-      case "geoarrow.wkt":
-        return arrowWKTToGeometry(arrowCellValue);
-      default: {
-        throw Error(`GeoArrow encoding not supported ${encoding}`);
+  // src/lib/parsers/parse-arrow.ts
+  function parseArrowSync(arrayBuffer, options) {
+    const shape = options?.shape || "arrow-table";
+    const arrowTable = tableFromIPC([new Uint8Array(arrayBuffer)]);
+    return convertArrowToTable(arrowTable, shape);
+  }
+  function parseArrowInBatches(asyncIterator, options) {
+    async function* makeArrowAsyncIterator() {
+      const readers = RecordBatchReader.readAll(toArrayBufferIterator(asyncIterator));
+      for await (const reader of readers) {
+        for await (const recordBatch of reader) {
+          if (options?.arrow?.batchDebounceMs !== void 0 && options?.arrow?.batchDebounceMs > 0) {
+            await new Promise((resolve) => setTimeout(resolve, options.arrow?.batchDebounceMs || 0));
+          }
+          const arrowTabledBatch = {
+            shape: "arrow-table",
+            batchType: "data",
+            data: new Table([recordBatch]),
+            length: recordBatch.data.length
+          };
+          yield arrowTabledBatch;
+        }
+        break;
       }
     }
+    return makeArrowAsyncIterator();
   }
-  function arrowWKBToGeometry(arrowCellValue) {
-    const arrayBuffer = arrowCellValue.buffer.slice(
-      arrowCellValue.byteOffset,
-      arrowCellValue.byteOffset + arrowCellValue.byteLength
-    );
-    return convertWKBToGeometry(arrayBuffer);
+
+  // src/arrow-loader.ts
+  var ArrowLoader = {
+    ...ArrowWorkerLoader,
+    parse: async (arraybuffer, options) => parseArrowSync(arraybuffer, options?.arrow),
+    parseSync: (arraybuffer, options) => parseArrowSync(arraybuffer, options?.arrow),
+    parseInBatches: parseArrowInBatches
+  };
+
+  // src/lib/encoders/encode-arrow.ts
+  function encodeArrowSync(data) {
+    const vectors = {};
+    for (const arrayData of data) {
+      const arrayVector = createVector(arrayData.array, arrayData.type);
+      vectors[arrayData.name] = arrayVector;
+    }
+    const table = new Table(vectors);
+    const arrowBuffer = tableToIPC(table);
+    return ensureArrayBuffer(arrowBuffer);
   }
-  function arrowWKTToGeometry(arrowCellValue) {
-    const string = arrowCellValue;
-    return convertWKTToGeometry(string);
+  function createVector(array, type) {
+    switch (type) {
+      case 1 /* DATE */:
+        return vectorFromArray(array);
+      case 0 /* FLOAT */:
+      default:
+        return vectorFromArray(array);
+    }
   }
-  function arrowMultiPolygonToGeometry(arrowMultiPolygon) {
-    const multiPolygon = [];
-    for (let m = 0; m < arrowMultiPolygon.length; m++) {
-      const arrowPolygon = arrowMultiPolygon.get(m);
-      const polygon = [];
-      for (let i = 0; arrowPolygon && i < arrowPolygon?.length; i++) {
-        const arrowRing = arrowPolygon?.get(i);
-        const ring = [];
-        for (let j = 0; arrowRing && j < arrowRing.length; j++) {
-          const arrowCoord = arrowRing.get(j);
-          const coord = Array.from(arrowCoord);
-          ring.push(coord);
-        }
-        polygon.push(ring);
+
+  // src/arrow-writer.ts
+  var VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var ArrowWriter = {
+    name: "Apache Arrow",
+    id: "arrow",
+    module: "arrow",
+    version: VERSION3,
+    extensions: ["arrow", "feather"],
+    mimeTypes: [
+      "application/vnd.apache.arrow.file",
+      "application/vnd.apache.arrow.stream",
+      "application/octet-stream"
+    ],
+    binary: true,
+    options: {},
+    encode: async function encodeArrow(data, options) {
+      return encodeArrowSync(data);
+    },
+    encodeSync(data, options) {
+      return encodeArrowSync(data);
+    }
+  };
+
+  // src/exports/geoarrow-loader.ts
+  var GeoArrowWorkerLoader = {
+    ...ArrowWorkerLoader,
+    options: {
+      arrow: {
+        shape: "arrow-table"
       }
-      multiPolygon.push(polygon);
     }
-    const geometry = {
-      type: "MultiPolygon",
-      coordinates: multiPolygon
-    };
-    return geometry;
+  };
+
+  // ../geoarrow/src/metadata/metadata-utils.ts
+  function getMetadataValue(metadata, key) {
+    return metadata instanceof Map ? metadata.get(key) || null : metadata[key] || null;
   }
-  function arrowPolygonToGeometry(arrowPolygon) {
-    const polygon = [];
-    for (let i = 0; arrowPolygon && i < arrowPolygon.length; i++) {
-      const arrowRing = arrowPolygon.get(i);
-      const ring = [];
-      for (let j = 0; arrowRing && j < arrowRing.length; j++) {
-        const arrowCoord = arrowRing.get(j);
-        const coords2 = Array.from(arrowCoord);
-        ring.push(coords2);
+
+  // ../geoarrow/src/metadata/geoarrow-metadata.ts
+  var GEOARROW_ENCODINGS = [
+    "geoarrow.multipolygon",
+    "geoarrow.polygon",
+    "geoarrow.multilinestring",
+    "geoarrow.linestring",
+    "geoarrow.multipoint",
+    "geoarrow.point",
+    "geoarrow.wkb",
+    "geoarrow.wkt"
+  ];
+  var GEOARROW_ENCODING = "ARROW:extension:name";
+  var GEOARROW_METADATA = "ARROW:extension:metadata";
+  function getGeometryColumnsFromSchema(schema) {
+    const geometryColumns = {};
+    for (const field of schema.fields || []) {
+      const metadata = getGeometryMetadataForField(field?.metadata || {});
+      if (metadata) {
+        geometryColumns[field.name] = metadata;
       }
-      polygon.push(ring);
     }
-    const geometry = {
-      type: "Polygon",
-      coordinates: polygon
-    };
-    return geometry;
+    return geometryColumns;
   }
-  function arrowMultiPointToGeometry(arrowMultiPoint) {
-    const multiPoint = [];
-    for (let i = 0; arrowMultiPoint && i < arrowMultiPoint.length; i++) {
-      const arrowPoint = arrowMultiPoint.get(i);
-      if (arrowPoint) {
-        const coord = Array.from(arrowPoint);
-        multiPoint.push(coord);
+  function getGeometryMetadataForField(fieldMetadata) {
+    let metadata = null;
+    let geoEncoding = getMetadataValue(fieldMetadata, GEOARROW_ENCODING);
+    if (geoEncoding) {
+      geoEncoding = geoEncoding.toLowerCase();
+      if (geoEncoding === "wkb") {
+        geoEncoding = "geoarrow.wkb";
       }
-    }
-    return {
-      type: "MultiPoint",
-      coordinates: multiPoint
-    };
-  }
-  function arrowPointToGeometry(arrowPoint) {
-    const point = Array.from(arrowPoint);
-    return {
-      type: "Point",
-      coordinates: point
-    };
-  }
-  function arrowMultiLineStringToGeometry(arrowMultiLineString) {
-    const multiLineString = [];
-    for (let i = 0; arrowMultiLineString && i < arrowMultiLineString.length; i++) {
-      const arrowLineString = arrowMultiLineString.get(i);
-      const lineString = [];
-      for (let j = 0; arrowLineString && j < arrowLineString.length; j++) {
-        const arrowCoord = arrowLineString.get(j);
-        if (arrowCoord) {
-          const coords2 = Array.from(arrowCoord);
-          lineString.push(coords2);
-        }
+      if (geoEncoding === "wkt") {
+        geoEncoding = "geoarrow.wkt";
+      }
+      if (!GEOARROW_ENCODINGS.includes(geoEncoding)) {
+        console.warn(`Invalid GeoArrow encoding: ${geoEncoding}`);
+      } else {
+        metadata ||= {};
+        metadata.encoding = geoEncoding;
       }
-      multiLineString.push(lineString);
     }
-    return {
-      type: "MultiLineString",
-      coordinates: multiLineString
-    };
-  }
-  function arrowLineStringToGeometry(arrowLineString) {
-    const lineString = [];
-    for (let i = 0; arrowLineString && i < arrowLineString.length; i++) {
-      const arrowCoord = arrowLineString.get(i);
-      if (arrowCoord) {
-        const coords2 = Array.from(arrowCoord);
-        lineString.push(coords2);
+    const columnMetadata = getMetadataValue(fieldMetadata, GEOARROW_METADATA);
+    if (columnMetadata) {
+      try {
+        metadata = JSON.parse(columnMetadata);
+      } catch (error) {
+        console.warn("Failed to parse GeoArrow metadata", error);
       }
     }
-    return {
-      type: "LineString",
-      coordinates: lineString
-    };
+    return metadata || null;
   }
 
-  // ../gis/src/lib/table-converters/convert-geoarrow-table.ts
-  function convertGeoArrowToTable(arrowTable, shape) {
-    switch (shape) {
-      case "arrow-table":
-        return convertArrowToArrowTable2(arrowTable);
-      case "array-row-table":
-        return convertArrowToArrayRowTable2(arrowTable);
-      case "object-row-table":
-        return convertArrowToObjectRowTable2(arrowTable);
-      case "columnar-table":
-        return convertArrowToColumnarTable2(arrowTable);
-      case "geojson-table":
-        return convertArrowToGeoJSONTable2(arrowTable);
+  // ../gis/src/lib/geometry-converters/convert-binary-geometry-to-geojson.ts
+  function convertBinaryGeometryToGeometry(data, startIndex, endIndex) {
+    switch (data.type) {
+      case "Point":
+        return pointToGeoJson(data, startIndex, endIndex);
+      case "LineString":
+        return lineStringToGeoJson(data, startIndex, endIndex);
+      case "Polygon":
+        return polygonToGeoJson(data, startIndex, endIndex);
       default:
-        throw new Error(shape);
-    }
-  }
-  function convertArrowToArrowTable2(arrowTable) {
-    return {
-      shape: "arrow-table",
-      schema: convertArrowToSchema(arrowTable.schema),
-      data: arrowTable
-    };
-  }
-  function convertArrowToArrayRowTable2(arrowTable) {
-    const columnarTable = convertArrowToColumnarTable2(arrowTable);
-    return convertTable(columnarTable, "array-row-table");
-  }
-  function convertArrowToObjectRowTable2(arrowTable) {
-    const columnarTable = convertArrowToColumnarTable2(arrowTable);
-    return convertTable(columnarTable, "object-row-table");
-  }
-  function convertArrowToColumnarTable2(arrowTable) {
-    const columns = {};
-    for (const field of arrowTable.schema.fields) {
-      const arrowColumn = arrowTable.getChild(field.name);
-      const values = arrowColumn?.toArray();
-      columns[field.name] = values;
+        const unexpectedInput = data;
+        throw new Error(`Unsupported geometry type: ${unexpectedInput?.type}`);
     }
-    const schema = convertArrowToSchema(arrowTable.schema);
-    return {
-      shape: "columnar-table",
-      schema,
-      data: columns
-    };
   }
-  function convertArrowToGeoJSONTable2(arrowTable) {
-    const schema = convertArrowToSchema(arrowTable.schema);
-    const geometryColumns = getGeometryColumnsFromSchema(schema);
-    const encoding = geometryColumns.geometry.encoding;
-    const features = [];
-    const propertyColumnNames = arrowTable.schema.fields.map((field) => field.name).filter((name) => !(name in geometryColumns));
-    const propertiesTable = arrowTable.select(propertyColumnNames);
-    const arrowGeometryColumn = arrowTable.getChild("geometry");
-    for (let row = 0; row < arrowTable.numRows; row++) {
-      const arrowGeometry = arrowGeometryColumn?.get(row);
-      const feature = convertGeoArrowGeometryToGeoJSON(arrowGeometry, encoding);
-      if (feature) {
-        const properties = propertiesTable.get(row)?.toJSON() || {};
-        features.push({ type: "Feature", geometry: feature, properties });
+  function polygonToGeoJson(data, startIndex = -Infinity, endIndex = Infinity) {
+    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 multi = polygonIndices.length > 2;
+    if (!multi) {
+      const coordinates2 = [];
+      for (let i = 0; i < primitivePolygonIndices.length - 1; i++) {
+        const startRingIndex = primitivePolygonIndices[i];
+        const endRingIndex = primitivePolygonIndices[i + 1];
+        const ringCoordinates = ringToGeoJson(positions, startRingIndex, endRingIndex);
+        coordinates2.push(ringCoordinates);
       }
+      return { type: "Polygon", coordinates: coordinates2 };
     }
-    return {
-      shape: "geojson-table",
-      type: "FeatureCollection",
-      schema,
-      features
-    };
-  }
-
-  // src/lib/parsers/parse-geoarrow.ts
-  function parseGeoArrowSync(arrayBuffer, options) {
-    const table = parseArrowSync(arrayBuffer, { shape: "arrow-table" });
-    switch (options?.shape) {
-      case "geojson-table":
-        return convertGeoArrowToTable(table.data, "geojson-table");
-      default:
-        return table;
+    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;
+      coordinates.push(polygonCoordinates);
     }
+    return { type: "MultiPolygon", coordinates };
   }
-  function parseGeoArrowInBatches(asyncIterator) {
-    return parseArrowInBatches(asyncIterator);
-  }
-
-  // src/geoarrow-loader.ts
-  var GeoArrowLoader = {
-    ...GeoArrowWorkerLoader,
-    parse: async (arraybuffer, options) => parseGeoArrowSync(arraybuffer, options?.arrow),
-    parseSync: (arraybuffer, options) => parseGeoArrowSync(arraybuffer, options?.arrow),
-    parseInBatches: parseGeoArrowInBatches
-  };
-
-  // src/workers/hard-clone.ts
-  function hardClone(data, force = false) {
-    if ("data" in data) {
-      return new Vector(data.data.map((data2) => hardClone(data2, force)));
-    }
-    const clonedChildren = [];
-    for (const childData of data.children) {
-      clonedChildren.push(hardClone(childData, force));
+  function lineStringToGeoJson(data, startIndex = -Infinity, endIndex = Infinity) {
+    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 };
     }
-    let clonedDictionary;
-    if (data.dictionary !== void 0) {
-      clonedDictionary = hardClone(data.dictionary, force);
+    const coordinates = [];
+    for (let i = 0; i < pathIndices.length - 1; i++) {
+      const ringCoordinates = ringToGeoJson(positions, pathIndices[i], pathIndices[i + 1]);
+      coordinates.push(ringCoordinates);
     }
-    const clonedBuffers = {
-      [BufferType.OFFSET]: cloneBuffer(data.buffers[BufferType.OFFSET], force),
-      [BufferType.DATA]: cloneBuffer(data.buffers[BufferType.DATA], force),
-      [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,
-      // @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);
+    return { type: "MultiLineString", coordinates };
   }
-  function cloneBuffer(arr, force) {
-    if (arr === void 0) {
-      return arr;
-    }
-    if (!force && !isTypedArraySliced(arr)) {
-      return arr;
+  function pointToGeoJson(data, startIndex, endIndex) {
+    const { positions } = data;
+    const coordinates = ringToGeoJson(positions, startIndex, endIndex);
+    const multi = coordinates.length > 1;
+    if (multi) {
+      return { type: "MultiPoint", coordinates };
     }
-    return arr.slice();
+    return { type: "Point", coordinates: coordinates[0] };
   }
-
-  // ../worker-utils/src/lib/npm-tag.ts
-  var NPM_TAG = "beta";
-
-  // ../worker-utils/src/lib/env-utils/version.ts
-  function getVersion() {
-    if (!globalThis._loadersgl_?.version) {
-      globalThis._loadersgl_ = globalThis._loadersgl_ || {};
-      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 = __VERSION__;
+  function ringToGeoJson(positions, startIndex, endIndex) {
+    startIndex = startIndex || 0;
+    endIndex = endIndex || positions.value.length / positions.size;
+    const ringCoordinates = [];
+    for (let j = startIndex; j < endIndex; j++) {
+      const coord = Array();
+      for (let k = j * positions.size; k < (j + 1) * positions.size; k++) {
+        coord.push(Number(positions.value[k]));
       }
+      ringCoordinates.push(coord);
     }
-    return globalThis._loadersgl_.version;
+    return ringCoordinates;
   }
-  var VERSION3 = getVersion();
 
-  // ../worker-utils/src/lib/env-utils/assert.ts
-  function assert(condition, message) {
-    if (!condition) {
-      throw new Error(message || "loaders.gl assertion failed.");
+  // ../gis/src/lib/utils/concat-typed-arrays.ts
+  function concatTypedArrays(arrays) {
+    let byteLength = 0;
+    for (let i = 0; i < arrays.length; ++i) {
+      byteLength += arrays[i].byteLength;
+    }
+    const buffer = new Uint8Array(byteLength);
+    let byteOffset = 0;
+    for (let i = 0; i < arrays.length; ++i) {
+      const data = new Uint8Array(arrays[i].buffer);
+      byteLength = data.length;
+      for (let j = 0; j < byteLength; ++j) {
+        buffer[byteOffset++] = data[j];
+      }
     }
+    return buffer;
   }
 
-  // ../worker-utils/src/lib/env-utils/globals.ts
-  var globals = {
-    self: typeof self !== "undefined" && self,
-    window: typeof window !== "undefined" && window,
-    global: typeof global !== "undefined" && global,
-    document: typeof document !== "undefined" && document
-  };
-  var self_ = globals.self || globals.window || globals.global || {};
-  var window_ = globals.window || globals.self || globals.global || {};
-  var global_ = globals.global || globals.self || globals.window || {};
-  var document_ = globals.document || {};
-  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 {
-    name;
-    workerThread;
-    isRunning = true;
-    /** Promise that resolves when Job is done */
-    result;
-    _resolve = () => {
+  // ../gis/src/lib/binary-geometry-api/concat-binary-geometry.ts
+  function concatenateBinaryPointGeometries(binaryPointGeometries, dimension) {
+    const positions = binaryPointGeometries.map((geometry) => geometry.positions.value);
+    const concatenatedPositions = new Float64Array(concatTypedArrays(positions).buffer);
+    return {
+      type: "Point",
+      positions: { value: concatenatedPositions, size: dimension }
     };
-    _reject = () => {
+  }
+  function concatenateBinaryLineGeometries(binaryLineGeometries, dimension) {
+    const lines = binaryLineGeometries.map((geometry) => geometry.positions.value);
+    const concatenatedPositions = new Float64Array(concatTypedArrays(lines).buffer);
+    const pathIndices = lines.map((line) => line.length / dimension).map(cumulativeSum(0));
+    pathIndices.unshift(0);
+    return {
+      type: "LineString",
+      positions: { value: concatenatedPositions, size: dimension },
+      pathIndices: { value: new Uint32Array(pathIndices), size: 1 }
     };
-    constructor(jobName, workerThread) {
-      this.name = jobName;
-      this.workerThread = workerThread;
-      this.result = new Promise((resolve, reject) => {
-        this._resolve = resolve;
-        this._reject = reject;
-      });
+  }
+  function concatenateBinaryPolygonGeometries(binaryPolygonGeometries, dimension) {
+    const polygons = [];
+    const primitivePolygons = [];
+    for (const binaryPolygon of binaryPolygonGeometries) {
+      const { positions, primitivePolygonIndices: primitivePolygonIndices2 } = binaryPolygon;
+      polygons.push(positions.value);
+      primitivePolygons.push(primitivePolygonIndices2.value);
     }
-    /**
-     * 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
-      });
+    const concatenatedPositions = new Float64Array(concatTypedArrays(polygons).buffer);
+    const polygonIndices = polygons.map((p) => p.length / dimension).map(cumulativeSum(0));
+    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])
+      );
     }
-    /**
-     * Call to resolve the `result` Promise with the supplied value
-     */
-    done(value) {
-      assert(this.isRunning);
-      this.isRunning = false;
-      this._resolve(value);
+    return {
+      type: "Polygon",
+      positions: { value: concatenatedPositions, size: dimension },
+      polygonIndices: { value: new Uint32Array(polygonIndices), size: 1 },
+      primitivePolygonIndices: { value: new Uint32Array(primitivePolygonIndices), size: 1 }
+    };
+  }
+  var cumulativeSum = (sum) => (value) => sum += value;
+
+  // ../gis/src/lib/geometry-converters/wkb/helpers/wkb-types.ts
+  var EWKB_FLAG_Z = 2147483648;
+  var EWKB_FLAG_M = 1073741824;
+  var EWKB_FLAG_SRID = 536870912;
+  var WKT_MAGIC_STRINGS = [
+    "POINT(",
+    "LINESTRING(",
+    "POLYGON(",
+    "MULTIPOINT(",
+    "MULTILINESTRING(",
+    "MULTIPOLYGON(",
+    "GEOMETRYCOLLECTION("
+  ];
+  var textEncoder = new TextEncoder();
+  var WKT_MAGIC_BYTES = WKT_MAGIC_STRINGS.map((string) => textEncoder.encode(string));
+
+  // ../gis/src/lib/geometry-converters/wkb/helpers/parse-wkb-header.ts
+  function isWKT(input) {
+    return getWKTGeometryType(input) !== null;
+  }
+  function getWKTGeometryType(input) {
+    if (typeof input === "string") {
+      const index2 = WKT_MAGIC_STRINGS.findIndex((magicString) => input.startsWith(magicString));
+      return index2 >= 0 ? index2 + 1 : null;
     }
-    /**
-     * Call to reject the `result` Promise with the supplied error
-     */
-    error(error) {
-      assert(this.isRunning);
-      this.isRunning = false;
-      this._reject(error);
+    const inputArray = new Uint8Array(input);
+    const index = WKT_MAGIC_BYTES.findIndex(
+      (magicBytes) => magicBytes.every((value, index2) => value === inputArray[index2])
+    );
+    return index >= 0 ? index + 1 : null;
+  }
+  function parseWKBHeader(dataView, target) {
+    const wkbHeader = Object.assign(target || {}, {
+      type: "wkb",
+      variant: "wkb",
+      geometryType: 1,
+      dimensions: 2,
+      coordinates: "xy",
+      littleEndian: true,
+      byteOffset: 0
+    });
+    if (isWKT(dataView.buffer)) {
+      throw new Error("WKB: Cannot parse WKT data");
     }
-  };
-
-  // ../worker-utils/src/lib/node/worker_threads-browser.ts
-  var NodeWorker = class {
-    terminate() {
+    wkbHeader.littleEndian = dataView.getUint8(wkbHeader.byteOffset) === 1;
+    wkbHeader.byteOffset++;
+    const geometryCode = dataView.getUint32(wkbHeader.byteOffset, wkbHeader.littleEndian);
+    wkbHeader.byteOffset += 4;
+    wkbHeader.geometryType = geometryCode & 7;
+    const isoType = (geometryCode - wkbHeader.geometryType) / 1e3;
+    switch (isoType) {
+      case 0:
+        break;
+      case 1:
+        wkbHeader.variant = "iso-wkb";
+        wkbHeader.dimensions = 3;
+        wkbHeader.coordinates = "xyz";
+        break;
+      case 2:
+        wkbHeader.variant = "iso-wkb";
+        wkbHeader.dimensions = 3;
+        wkbHeader.coordinates = "xym";
+        break;
+      case 3:
+        wkbHeader.variant = "iso-wkb";
+        wkbHeader.dimensions = 4;
+        wkbHeader.coordinates = "xyzm";
+        break;
+      default:
+        throw new Error(`WKB: Unsupported iso-wkb type: ${isoType}`);
     }
-  };
-
-  // ../worker-utils/src/lib/worker-utils/get-loadable-worker-url.ts
-  var workerURLCache = /* @__PURE__ */ new Map();
-  function getLoadableWorkerURL(props) {
-    assert(props.source && !props.url || !props.source && props.url);
-    let workerURL = workerURLCache.get(props.source || props.url);
-    if (!workerURL) {
-      if (props.url) {
-        workerURL = getLoadableWorkerURLFromURL(props.url);
-        workerURLCache.set(props.url, workerURL);
-      }
-      if (props.source) {
-        workerURL = getLoadableWorkerURLFromSource(props.source);
-        workerURLCache.set(props.source, workerURL);
-      }
+    const ewkbZ = geometryCode & EWKB_FLAG_Z;
+    const ewkbM = geometryCode & EWKB_FLAG_M;
+    const ewkbSRID = geometryCode & EWKB_FLAG_SRID;
+    if (ewkbZ && ewkbM) {
+      wkbHeader.variant = "ewkb";
+      wkbHeader.dimensions = 4;
+      wkbHeader.coordinates = "xyzm";
+    } else if (ewkbZ) {
+      wkbHeader.variant = "ewkb";
+      wkbHeader.dimensions = 3;
+      wkbHeader.coordinates = "xyz";
+    } else if (ewkbM) {
+      wkbHeader.variant = "ewkb";
+      wkbHeader.dimensions = 3;
+      wkbHeader.coordinates = "xym";
     }
-    assert(workerURL);
-    return workerURL;
-  }
-  function getLoadableWorkerURLFromURL(url) {
-    if (!url.startsWith("http")) {
-      return url;
+    if (ewkbSRID) {
+      wkbHeader.variant = "ewkb";
+      wkbHeader.srid = dataView.getUint32(wkbHeader.byteOffset, wkbHeader.littleEndian);
+      wkbHeader.byteOffset += 4;
     }
-    const workerSource = buildScriptSource(url);
-    return getLoadableWorkerURLFromSource(workerSource);
-  }
-  function getLoadableWorkerURLFromSource(workerSource) {
-    const blob = new Blob([workerSource], { type: "application/javascript" });
-    return URL.createObjectURL(blob);
-  }
-  function buildScriptSource(workerUrl) {
-    return `try {
-  importScripts('${workerUrl}');
-} catch (error) {
-  console.error(error);
-  throw error;
-}`;
+    return wkbHeader;
   }
 
-  // ../worker-utils/src/lib/worker-utils/get-transfer-list.ts
-  function getTransferList(object, recursive = true, transfers) {
-    const transfersSet = transfers || /* @__PURE__ */ new Set();
-    if (!object) {
-    } else if (isTransferable(object)) {
-      transfersSet.add(object);
-    } else if (isTransferable(object.buffer)) {
-      transfersSet.add(object.buffer);
-    } else if (ArrayBuffer.isView(object)) {
-    } else if (recursive && typeof object === "object") {
-      for (const key in object) {
-        getTransferList(object[key], recursive, transfersSet);
-      }
+  // ../gis/src/lib/geometry-converters/wkb/convert-wkb-to-binary-geometry.ts
+  function convertWKBToBinaryGeometry(arrayBuffer) {
+    const dataView = new DataView(arrayBuffer);
+    const wkbHeader = parseWKBHeader(dataView);
+    const { geometryType, dimensions, littleEndian } = wkbHeader;
+    const offset = wkbHeader.byteOffset;
+    switch (geometryType) {
+      case 1 /* Point */:
+        const point = parsePoint(dataView, offset, dimensions, littleEndian);
+        return point.geometry;
+      case 2 /* LineString */:
+        const line = parseLineString(dataView, offset, dimensions, littleEndian);
+        return line.geometry;
+      case 3 /* Polygon */:
+        const polygon = parsePolygon(dataView, offset, dimensions, littleEndian);
+        return polygon.geometry;
+      case 4 /* MultiPoint */:
+        const multiPoint = parseMultiPoint(dataView, offset, dimensions, littleEndian);
+        multiPoint.type = "Point";
+        return multiPoint;
+      case 5 /* MultiLineString */:
+        const multiLine = parseMultiLineString(dataView, offset, dimensions, littleEndian);
+        multiLine.type = "LineString";
+        return multiLine;
+      case 6 /* MultiPolygon */:
+        const multiPolygon = parseMultiPolygon(dataView, offset, dimensions, littleEndian);
+        multiPolygon.type = "Polygon";
+        return multiPolygon;
+      default:
+        throw new Error(`WKB: Unsupported geometry type: ${geometryType}`);
     }
-    return transfers === void 0 ? Array.from(transfersSet) : [];
   }
-  function isTransferable(object) {
-    if (!object) {
-      return false;
+  function parsePoint(dataView, offset, dimension, littleEndian) {
+    const positions = new Float64Array(dimension);
+    for (let i = 0; i < dimension; i++) {
+      positions[i] = dataView.getFloat64(offset, littleEndian);
+      offset += 8;
     }
-    if (object instanceof ArrayBuffer) {
-      return true;
+    return {
+      geometry: { type: "Point", positions: { value: positions, size: dimension } },
+      offset
+    };
+  }
+  function parseLineString(dataView, offset, dimension, littleEndian) {
+    const nPoints = dataView.getUint32(offset, littleEndian);
+    offset += 4;
+    const positions = new Float64Array(nPoints * dimension);
+    for (let i = 0; i < nPoints * dimension; i++) {
+      positions[i] = dataView.getFloat64(offset, littleEndian);
+      offset += 8;
     }
-    if (typeof MessagePort !== "undefined" && object instanceof MessagePort) {
-      return true;
+    const pathIndices = [0];
+    if (nPoints > 0) {
+      pathIndices.push(nPoints);
     }
-    if (typeof ImageBitmap !== "undefined" && object instanceof ImageBitmap) {
-      return true;
+    return {
+      geometry: {
+        type: "LineString",
+        positions: { value: positions, size: dimension },
+        pathIndices: { value: new Uint32Array(pathIndices), size: 1 }
+      },
+      offset
+    };
+  }
+  var cumulativeSum2 = (sum) => (value) => sum += value;
+  function parsePolygon(dataView, offset, dimension, littleEndian) {
+    const nRings = dataView.getUint32(offset, littleEndian);
+    offset += 4;
+    const rings = [];
+    for (let i = 0; i < nRings; i++) {
+      const parsed = parseLineString(dataView, offset, dimension, littleEndian);
+      const { positions } = parsed.geometry;
+      offset = parsed.offset;
+      rings.push(positions.value);
     }
-    if (typeof OffscreenCanvas !== "undefined" && object instanceof OffscreenCanvas) {
-      return true;
+    const concatenatedPositions = new Float64Array(concatTypedArrays(rings).buffer);
+    const polygonIndices = [0];
+    if (concatenatedPositions.length > 0) {
+      polygonIndices.push(concatenatedPositions.length / dimension);
     }
-    return false;
+    const primitivePolygonIndices = rings.map((l) => l.length / dimension).map(cumulativeSum2(0));
+    primitivePolygonIndices.unshift(0);
+    return {
+      geometry: {
+        type: "Polygon",
+        positions: { value: concatenatedPositions, size: dimension },
+        polygonIndices: {
+          value: new Uint32Array(polygonIndices),
+          size: 1
+        },
+        primitivePolygonIndices: { value: new Uint32Array(primitivePolygonIndices), size: 1 }
+      },
+      offset
+    };
   }
-  function getTransferListForWriter(object) {
-    if (object === null) {
-      return {};
+  function parseMultiPoint(dataView, offset, dimension, littleEndian) {
+    const nPoints = dataView.getUint32(offset, littleEndian);
+    offset += 4;
+    const binaryPointGeometries = [];
+    for (let i = 0; i < nPoints; i++) {
+      const littleEndianPoint = dataView.getUint8(offset) === 1;
+      offset++;
+      if (dataView.getUint32(offset, littleEndianPoint) % 1e3 !== 1) {
+        throw new Error("WKB: Inner geometries of MultiPoint not of type Point");
+      }
+      offset += 4;
+      const parsed = parsePoint(dataView, offset, dimension, littleEndianPoint);
+      offset = parsed.offset;
+      binaryPointGeometries.push(parsed.geometry);
     }
-    const clone = Object.assign({}, object);
-    Object.keys(clone).forEach((key) => {
-      if (typeof object[key] === "object" && !ArrayBuffer.isView(object[key]) && !(object[key] instanceof Array)) {
-        clone[key] = getTransferListForWriter(object[key]);
-      } else if (typeof clone[key] === "function" || clone[key] instanceof RegExp) {
-        clone[key] = {};
-      } else {
-        clone[key] = object[key];
+    return concatenateBinaryPointGeometries(binaryPointGeometries, dimension);
+  }
+  function parseMultiLineString(dataView, offset, dimension, littleEndian) {
+    const nLines = dataView.getUint32(offset, littleEndian);
+    offset += 4;
+    const binaryLineGeometries = [];
+    for (let i = 0; i < nLines; i++) {
+      const littleEndianLine = dataView.getUint8(offset) === 1;
+      offset++;
+      if (dataView.getUint32(offset, littleEndianLine) % 1e3 !== 2) {
+        throw new Error("WKB: Inner geometries of MultiLineString not of type LineString");
       }
-    });
-    return clone;
+      offset += 4;
+      const parsed = parseLineString(dataView, offset, dimension, littleEndianLine);
+      offset = parsed.offset;
+      binaryLineGeometries.push(parsed.geometry);
+    }
+    return concatenateBinaryLineGeometries(binaryLineGeometries, dimension);
+  }
+  function parseMultiPolygon(dataView, offset, dimension, littleEndian) {
+    const nPolygons = dataView.getUint32(offset, littleEndian);
+    offset += 4;
+    const binaryPolygonGeometries = [];
+    for (let i = 0; i < nPolygons; i++) {
+      const littleEndianPolygon = dataView.getUint8(offset) === 1;
+      offset++;
+      if (dataView.getUint32(offset, littleEndianPolygon) % 1e3 !== 3) {
+        throw new Error("WKB: Inner geometries of MultiPolygon not of type Polygon");
+      }
+      offset += 4;
+      const parsed = parsePolygon(dataView, offset, dimension, littleEndianPolygon);
+      offset = parsed.offset;
+      binaryPolygonGeometries.push(parsed.geometry);
+    }
+    return concatenateBinaryPolygonGeometries(binaryPolygonGeometries, dimension);
   }
 
-  // ../worker-utils/src/lib/worker-farm/worker-thread.ts
-  var NOOP = () => {
-  };
-  var WorkerThread = class {
-    name;
-    source;
-    url;
-    terminated = false;
-    worker;
-    onMessage;
-    onError;
-    _loadableURL = "";
-    /** Checks if workers are supported on this platform */
-    static isSupported() {
-      return typeof Worker !== "undefined" && isBrowser || typeof NodeWorker !== "undefined" && !isBrowser;
+  // ../gis/src/lib/geometry-converters/wkb/convert-wkb-to-geometry.ts
+  function convertWKBToGeometry(arrayBuffer) {
+    const binaryGeometry = convertWKBToBinaryGeometry(arrayBuffer);
+    return convertBinaryGeometryToGeometry(binaryGeometry);
+  }
+
+  // ../gis/src/lib/geometry-converters/wkb/convert-wkt-to-geometry.ts
+  var numberRegexp = /[-+]?([0-9]*\.[0-9]+|[0-9]+)([eE][-+]?[0-9]+)?/;
+  var tuples = new RegExp("^" + numberRegexp.source + "(\\s" + numberRegexp.source + "){1,}");
+  function convertWKTToGeometry(input, options) {
+    const parts = input.split(";");
+    let _ = parts.pop();
+    const srid = (parts.shift() || "").split("=").pop();
+    const state = { parts, _, i: 0 };
+    const geometry = parseGeometry(state);
+    return options?.wkt?.crs ? addCRS(geometry, srid) : geometry;
+  }
+  function parseGeometry(state) {
+    return parsePoint2(state) || parseLineString2(state) || parsePolygon2(state) || parseMultiPoint2(state) || parseMultiLineString2(state) || parseMultiPolygon2(state) || parseGeometryCollection(state);
+  }
+  function addCRS(obj, srid) {
+    if (obj && srid?.match(/\d+/)) {
+      const crs = {
+        type: "name",
+        properties: {
+          name: "urn:ogc:def:crs:EPSG::" + srid
+        }
+      };
+      obj.crs = crs;
+    }
+    return obj;
+  }
+  function parsePoint2(state) {
+    if (!$(/^(POINT(\sz)?)/i, state)) {
+      return null;
+    }
+    white(state);
+    if (!$(/^(\()/, state)) {
+      return null;
+    }
+    const c = coords(state);
+    if (!c) {
+      return null;
     }
-    constructor(props) {
-      const { name, source, url } = props;
-      assert(source || url);
-      this.name = name;
-      this.source = source;
-      this.url = url;
-      this.onMessage = NOOP;
-      this.onError = (error) => console.log(error);
-      this.worker = isBrowser ? this._createBrowserWorker() : this._createNodeWorker();
+    white(state);
+    if (!$(/^(\))/, state)) {
+      return null;
     }
-    /**
-     * Terminate this worker thread
-     * @note Can free up significant memory
-     */
-    destroy() {
-      this.onMessage = NOOP;
-      this.onError = NOOP;
-      this.worker.terminate();
-      this.terminated = true;
+    return {
+      type: "Point",
+      coordinates: c[0]
+    };
+  }
+  function parseMultiPoint2(state) {
+    if (!$(/^(MULTIPOINT)/i, state)) {
+      return null;
     }
-    get isRunning() {
-      return Boolean(this.onMessage);
+    white(state);
+    const newCoordsFormat = state._?.substring(state._?.indexOf("(") + 1, state._.length - 1).replace(/\(/g, "").replace(/\)/g, "");
+    state._ = "MULTIPOINT (" + newCoordsFormat + ")";
+    const c = multicoords(state);
+    if (!c) {
+      return null;
     }
-    /**
-     * 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);
+    white(state);
+    return {
+      type: "MultiPoint",
+      coordinates: c
+    };
+  }
+  function parseLineString2(state) {
+    if (!$(/^(LINESTRING(\sz)?)/i, state)) {
+      return null;
     }
-    // PRIVATE
-    /**
-     * Generate a standard Error from an ErrorEvent
-     * @param event
-     */
-    _getErrorFromErrorEvent(event) {
-      let message = "Failed to load ";
-      message += `worker ${this.name} from ${this.url}. `;
-      if (event.message) {
-        message += `${event.message} in `;
-      }
-      if (event.lineno) {
-        message += `:${event.lineno}:${event.colno}`;
-      }
-      return new Error(message);
+    white(state);
+    if (!$(/^(\()/, state)) {
+      return null;
     }
-    /**
-     * 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 });
-      worker.onmessage = (event) => {
-        if (!event.data) {
-          this.onError(new Error("No data received"));
-        } else {
-          this.onMessage(event.data);
-        }
-      };
-      worker.onerror = (error) => {
-        this.onError(this._getErrorFromErrorEvent(error));
-        this.terminated = true;
-      };
-      worker.onmessageerror = (event) => console.error(event);
-      return worker;
+    const c = coords(state);
+    if (!c) {
+      return null;
     }
-    /**
-     * 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 });
-      } else if (this.source) {
-        worker = new NodeWorker(this.source, { eval: true });
-      } else {
-        throw new Error("no worker");
-      }
-      worker.on("message", (data) => {
-        this.onMessage(data);
-      });
-      worker.on("error", (error) => {
-        this.onError(error);
-      });
-      worker.on("exit", (code) => {
-      });
-      return worker;
+    if (!$(/^(\))/, state)) {
+      return null;
     }
-  };
-
-  // ../worker-utils/src/lib/worker-farm/worker-pool.ts
-  var WorkerPool = class {
-    name = "unnamed";
-    source;
-    // | Function;
-    url;
-    maxConcurrency = 1;
-    maxMobileConcurrency = 1;
-    onDebug = () => {
+    return {
+      type: "LineString",
+      coordinates: c
     };
-    reuseWorkers = true;
-    props = {};
-    jobQueue = [];
-    idleQueue = [];
-    count = 0;
-    isDestroyed = false;
-    /** Checks if workers are supported on this platform */
-    static isSupported() {
-      return WorkerThread.isSupported();
+  }
+  function parseMultiLineString2(state) {
+    if (!$(/^(MULTILINESTRING)/i, state))
+      return null;
+    white(state);
+    const c = multicoords(state);
+    if (!c) {
+      return null;
     }
-    /**
-     * @param processor - worker function
-     * @param maxConcurrency - max count of workers
-     */
-    constructor(props) {
-      this.source = props.source;
-      this.url = props.url;
-      this.setProps(props);
+    white(state);
+    return {
+      // @ts-ignore
+      type: "MultiLineString",
+      // @ts-expect-error
+      coordinates: c
+    };
+  }
+  function parsePolygon2(state) {
+    if (!$(/^(POLYGON(\sz)?)/i, state)) {
+      return null;
     }
-    /**
-     * Terminates all workers in the pool
-     * @note Can free up significant memory
-     */
-    destroy() {
-      this.idleQueue.forEach((worker) => worker.destroy());
-      this.isDestroyed = true;
+    white(state);
+    const c = multicoords(state);
+    if (!c) {
+      return null;
     }
-    setProps(props) {
-      this.props = { ...this.props, ...props };
-      if (props.name !== void 0) {
-        this.name = props.name;
-      }
-      if (props.maxConcurrency !== void 0) {
-        this.maxConcurrency = props.maxConcurrency;
-      }
-      if (props.maxMobileConcurrency !== void 0) {
-        this.maxMobileConcurrency = props.maxMobileConcurrency;
-      }
-      if (props.reuseWorkers !== void 0) {
-        this.reuseWorkers = props.reuseWorkers;
-      }
-      if (props.onDebug !== void 0) {
-        this.onDebug = props.onDebug;
-      }
+    return {
+      // @ts-ignore
+      type: "Polygon",
+      // @ts-expect-error
+      coordinates: c
+    };
+  }
+  function parseMultiPolygon2(state) {
+    if (!$(/^(MULTIPOLYGON)/i, state)) {
+      return null;
     }
-    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 });
-        return this;
-      });
-      this._startQueuedJob();
-      return await startPromise;
+    white(state);
+    const c = multicoords(state);
+    if (!c) {
+      return null;
     }
-    // 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;
-      }
-      const workerThread = this._getAvailableWorker();
-      if (!workerThread) {
-        return;
-      }
-      const queuedJob = this.jobQueue.shift();
-      if (queuedJob) {
-        this.onDebug({
-          message: "Starting job",
-          name: queuedJob.name,
-          workerThread,
-          backlog: this.jobQueue.length
-        });
-        const job = new WorkerJob(queuedJob.name, workerThread);
-        workerThread.onMessage = (data) => queuedJob.onMessage(job, data.type, data.payload);
-        workerThread.onError = (error) => queuedJob.onError(job, error);
-        queuedJob.onStart(job);
-        try {
-          await job.result;
-        } catch (error) {
-          console.error(`Worker exception: ${error}`);
-        } finally {
-          this.returnWorkerToQueue(workerThread);
-        }
-      }
+    return {
+      type: "MultiPolygon",
+      // @ts-expect-error
+      coordinates: c
+    };
+  }
+  function parseGeometryCollection(state) {
+    const geometries = [];
+    let geometry;
+    if (!$(/^(GEOMETRYCOLLECTION)/i, state)) {
+      return null;
     }
-    /**
-     * 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 = (
-        // 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--;
+    white(state);
+    if (!$(/^(\()/, state)) {
+      return null;
+    }
+    while (geometry = parseGeometry(state)) {
+      geometries.push(geometry);
+      white(state);
+      $(/^(,)/, state);
+      white(state);
+    }
+    if (!$(/^(\))/, state)) {
+      return null;
+    }
+    return {
+      type: "GeometryCollection",
+      geometries
+    };
+  }
+  function multicoords(state) {
+    white(state);
+    let depth = 0;
+    const rings = [];
+    const stack = [rings];
+    let pointer = rings;
+    let elem;
+    while (elem = $(/^(\()/, state) || $(/^(\))/, state) || $(/^(,)/, state) || $(tuples, state)) {
+      if (elem === "(") {
+        stack.push(pointer);
+        pointer = [];
+        stack[stack.length - 1].push(pointer);
+        depth++;
+      } else if (elem === ")") {
+        if (pointer.length === 0)
+          return null;
+        pointer = stack.pop();
+        if (!pointer)
+          return null;
+        depth--;
+        if (depth === 0)
+          break;
+      } else if (elem === ",") {
+        pointer = [];
+        stack[stack.length - 1].push(pointer);
+      } else if (!elem.split(/\s/g).some(isNaN)) {
+        Array.prototype.push.apply(pointer, elem.split(/\s/g).map(parseFloat));
       } else {
-        this.idleQueue.push(worker);
-      }
-      if (!this.isDestroyed) {
-        this._startQueuedJob();
+        return null;
       }
+      white(state);
     }
-    /**
-     * Returns idle worker or creates new worker if maxConcurrency has not been reached
-     */
-    _getAvailableWorker() {
-      if (this.idleQueue.length > 0) {
-        return this.idleQueue.shift() || null;
-      }
-      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 });
-      }
+    if (depth !== 0)
       return null;
+    return rings;
+  }
+  function coords(state) {
+    const list = [];
+    let item;
+    let pt;
+    while (pt = $(tuples, state) || $(/^(,)/, state)) {
+      if (pt === ",") {
+        list.push(item);
+        item = [];
+      } else if (!pt.split(/\s/g).some(isNaN)) {
+        if (!item)
+          item = [];
+        Array.prototype.push.apply(item, pt.split(/\s/g).map(parseFloat));
+      }
+      white(state);
     }
-    _getMaxConcurrency() {
-      return isMobile ? this.maxMobileConcurrency : this.maxConcurrency;
+    if (item)
+      list.push(item);
+    else
+      return null;
+    return list.length ? list : null;
+  }
+  function $(regexp, state) {
+    const match = state._?.substring(state.i).match(regexp);
+    if (!match)
+      return null;
+    else {
+      state.i += match[0].length;
+      return match[0];
     }
-  };
+  }
+  function white(state) {
+    $(/^\s*/, state);
+  }
 
-  // ../worker-utils/src/lib/worker-farm/worker-farm.ts
-  var DEFAULT_PROPS = {
-    maxConcurrency: 3,
-    maxMobileConcurrency: 1,
-    reuseWorkers: true,
-    onDebug: () => {
+  // ../gis/src/lib/geometry-converters/convert-geoarrow-to-geojson.ts
+  function convertGeoArrowGeometryToGeoJSON(arrowCellValue, encoding) {
+    encoding = encoding?.toLowerCase();
+    if (!encoding || !arrowCellValue) {
+      return null;
     }
-  };
-  var _WorkerFarm = class {
-    props;
-    workerPools = /* @__PURE__ */ new Map();
-    /** Checks if workers are supported on this platform */
-    static isSupported() {
-      return WorkerThread.isSupported();
+    switch (encoding) {
+      case "geoarrow.multipolygon":
+        return arrowMultiPolygonToGeometry(arrowCellValue);
+      case "geoarrow.polygon":
+        return arrowPolygonToGeometry(arrowCellValue);
+      case "geoarrow.multipoint":
+        return arrowMultiPointToGeometry(arrowCellValue);
+      case "geoarrow.point":
+        return arrowPointToGeometry(arrowCellValue);
+      case "geoarrow.multilinestring":
+        return arrowMultiLineStringToGeometry(arrowCellValue);
+      case "geoarrow.linestring":
+        return arrowLineStringToGeometry(arrowCellValue);
+      case "geoarrow.wkb":
+        return arrowWKBToGeometry(arrowCellValue);
+      case "geoarrow.wkt":
+        return arrowWKTToGeometry(arrowCellValue);
+      default: {
+        throw Error(`GeoArrow encoding not supported ${encoding}`);
+      }
     }
-    /** 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;
+  }
+  function arrowWKBToGeometry(arrowCellValue) {
+    const arrayBuffer = arrowCellValue.buffer.slice(
+      arrowCellValue.byteOffset,
+      arrowCellValue.byteOffset + arrowCellValue.byteLength
+    );
+    return convertWKBToGeometry(arrayBuffer);
+  }
+  function arrowWKTToGeometry(arrowCellValue) {
+    const string = arrowCellValue;
+    return convertWKTToGeometry(string);
+  }
+  function arrowMultiPolygonToGeometry(arrowMultiPolygon) {
+    const multiPolygon = [];
+    for (let m = 0; m < arrowMultiPolygon.length; m++) {
+      const arrowPolygon = arrowMultiPolygon.get(m);
+      const polygon = [];
+      for (let i = 0; arrowPolygon && i < arrowPolygon?.length; i++) {
+        const arrowRing = arrowPolygon?.get(i);
+        const ring = [];
+        for (let j = 0; arrowRing && j < arrowRing.length; j++) {
+          const arrowCoord = arrowRing.get(j);
+          const coord = Array.from(arrowCoord);
+          ring.push(coord);
+        }
+        polygon.push(ring);
+      }
+      multiPolygon.push(polygon);
     }
-    /** get global instance with WorkerFarm.getWorkerFarm() */
-    constructor(props) {
-      this.props = { ...DEFAULT_PROPS };
-      this.setProps(props);
-      this.workerPools = /* @__PURE__ */ new Map();
+    const geometry = {
+      type: "MultiPolygon",
+      coordinates: multiPolygon
+    };
+    return geometry;
+  }
+  function arrowPolygonToGeometry(arrowPolygon) {
+    const polygon = [];
+    for (let i = 0; arrowPolygon && i < arrowPolygon.length; i++) {
+      const arrowRing = arrowPolygon.get(i);
+      const ring = [];
+      for (let j = 0; arrowRing && j < arrowRing.length; j++) {
+        const arrowCoord = arrowRing.get(j);
+        const coords2 = Array.from(arrowCoord);
+        ring.push(coords2);
+      }
+      polygon.push(ring);
     }
-    /**
-     * Terminate all workers in the farm
-     * @note Can free up significant memory
-     */
-    destroy() {
-      for (const workerPool of this.workerPools.values()) {
-        workerPool.destroy();
+    const geometry = {
+      type: "Polygon",
+      coordinates: polygon
+    };
+    return geometry;
+  }
+  function arrowMultiPointToGeometry(arrowMultiPoint) {
+    const multiPoint = [];
+    for (let i = 0; arrowMultiPoint && i < arrowMultiPoint.length; i++) {
+      const arrowPoint = arrowMultiPoint.get(i);
+      if (arrowPoint) {
+        const coord = Array.from(arrowPoint);
+        multiPoint.push(coord);
       }
-      this.workerPools = /* @__PURE__ */ new Map();
     }
-    /**
-     * Set props used when initializing worker pools
-     * @param props
-     */
-    setProps(props) {
-      this.props = { ...this.props, ...props };
-      for (const workerPool of this.workerPools.values()) {
-        workerPool.setProps(this._getWorkerPoolProps());
+    return {
+      type: "MultiPoint",
+      coordinates: multiPoint
+    };
+  }
+  function arrowPointToGeometry(arrowPoint) {
+    const point = Array.from(arrowPoint);
+    return {
+      type: "Point",
+      coordinates: point
+    };
+  }
+  function arrowMultiLineStringToGeometry(arrowMultiLineString) {
+    const multiLineString = [];
+    for (let i = 0; arrowMultiLineString && i < arrowMultiLineString.length; i++) {
+      const arrowLineString = arrowMultiLineString.get(i);
+      const lineString = [];
+      for (let j = 0; arrowLineString && j < arrowLineString.length; j++) {
+        const arrowCoord = arrowLineString.get(j);
+        if (arrowCoord) {
+          const coords2 = Array.from(arrowCoord);
+          lineString.push(coords2);
+        }
       }
+      multiLineString.push(lineString);
     }
-    /**
-     * 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;
-      let workerPool = this.workerPools.get(name);
-      if (!workerPool) {
-        workerPool = new WorkerPool({
-          name,
-          source,
-          url
-        });
-        workerPool.setProps(this._getWorkerPoolProps());
-        this.workerPools.set(name, workerPool);
+    return {
+      type: "MultiLineString",
+      coordinates: multiLineString
+    };
+  }
+  function arrowLineStringToGeometry(arrowLineString) {
+    const lineString = [];
+    for (let i = 0; arrowLineString && i < arrowLineString.length; i++) {
+      const arrowCoord = arrowLineString.get(i);
+      if (arrowCoord) {
+        const coords2 = Array.from(arrowCoord);
+        lineString.push(coords2);
       }
-      return workerPool;
-    }
-    _getWorkerPoolProps() {
-      return {
-        maxConcurrency: this.props.maxConcurrency,
-        maxMobileConcurrency: this.props.maxMobileConcurrency,
-        reuseWorkers: this.props.reuseWorkers,
-        onDebug: this.props.onDebug
-      };
     }
-  };
-  var WorkerFarm = _WorkerFarm;
-  // singleton
-  __publicField(WorkerFarm, "_workerFarm");
+    return {
+      type: "LineString",
+      coordinates: lineString
+    };
+  }
 
-  // ../worker-utils/src/lib/worker-api/get-worker-url.ts
-  function getWorkerName(worker) {
-    const warning = worker.version !== VERSION3 ? ` (worker-utils@${VERSION3})` : "";
-    return `${worker.name}@${worker.version}${warning}`;
+  // ../gis/src/lib/table-converters/convert-geoarrow-table.ts
+  function convertGeoArrowToTable(arrowTable, shape) {
+    switch (shape) {
+      case "arrow-table":
+        return convertArrowToArrowTable2(arrowTable);
+      case "array-row-table":
+        return convertArrowToArrayRowTable2(arrowTable);
+      case "object-row-table":
+        return convertArrowToObjectRowTable2(arrowTable);
+      case "columnar-table":
+        return convertArrowToColumnarTable2(arrowTable);
+      case "geojson-table":
+        return convertArrowToGeoJSONTable2(arrowTable);
+      default:
+        throw new Error(shape);
+    }
   }
-  function getWorkerURL(worker, options = {}) {
-    const workerOptions = options[worker.id] || {};
-    const workerFile = isBrowser ? `${worker.id}-worker.js` : `${worker.id}-worker-node.js`;
-    let url = workerOptions.workerUrl;
-    if (!url && worker.id === "compression") {
-      url = options.workerUrl;
+  function convertArrowToArrowTable2(arrowTable) {
+    return {
+      shape: "arrow-table",
+      schema: convertArrowToSchema(arrowTable.schema),
+      data: arrowTable
+    };
+  }
+  function convertArrowToArrayRowTable2(arrowTable) {
+    const columnarTable = convertArrowToColumnarTable2(arrowTable);
+    return convertTable(columnarTable, "array-row-table");
+  }
+  function convertArrowToObjectRowTable2(arrowTable) {
+    const columnarTable = convertArrowToColumnarTable2(arrowTable);
+    return convertTable(columnarTable, "object-row-table");
+  }
+  function convertArrowToColumnarTable2(arrowTable) {
+    const columns = {};
+    for (const field of arrowTable.schema.fields) {
+      const arrowColumn = arrowTable.getChild(field.name);
+      const values = arrowColumn?.toArray();
+      columns[field.name] = values;
     }
-    if (options._workerType === "test") {
-      if (isBrowser) {
-        url = `modules/${worker.module}/dist/${workerFile}`;
-      } else {
-        url = `modules/${worker.module}/src/workers/${worker.id}-worker-node.ts`;
+    const schema = convertArrowToSchema(arrowTable.schema);
+    return {
+      shape: "columnar-table",
+      schema,
+      data: columns
+    };
+  }
+  function convertArrowToGeoJSONTable2(arrowTable) {
+    const schema = convertArrowToSchema(arrowTable.schema);
+    const geometryColumns = getGeometryColumnsFromSchema(schema);
+    const encoding = geometryColumns.geometry.encoding;
+    const features = [];
+    const propertyColumnNames = arrowTable.schema.fields.map((field) => field.name).filter((name) => !(name in geometryColumns));
+    const propertiesTable = arrowTable.select(propertyColumnNames);
+    const arrowGeometryColumn = arrowTable.getChild("geometry");
+    for (let row = 0; row < arrowTable.numRows; row++) {
+      const arrowGeometry = arrowGeometryColumn?.get(row);
+      const feature = convertGeoArrowGeometryToGeoJSON(arrowGeometry, encoding);
+      if (feature) {
+        const properties = propertiesTable.get(row)?.toJSON() || {};
+        features.push({ type: "Feature", geometry: feature, properties });
       }
     }
-    if (!url) {
-      let version = worker.version;
-      if (version === "latest") {
-        version = NPM_TAG;
-      }
-      const versionTag = version ? `@${version}` : "";
-      url = `https://unpkg.com/@loaders.gl/${worker.module}${versionTag}/dist/${workerFile}`;
+    return {
+      shape: "geojson-table",
+      type: "FeatureCollection",
+      schema,
+      features
+    };
+  }
+
+  // src/lib/parsers/parse-geoarrow.ts
+  function parseGeoArrowSync(arrayBuffer, options) {
+    const table = parseArrowSync(arrayBuffer, { shape: "arrow-table" });
+    switch (options?.shape) {
+      case "geojson-table":
+        return convertGeoArrowToTable(table.data, "geojson-table");
+      default:
+        return table;
     }
-    assert(url);
-    return url;
+  }
+  function parseGeoArrowInBatches(asyncIterator) {
+    return parseArrowInBatches(asyncIterator);
   }
 
-  // ../worker-utils/src/lib/worker-api/process-on-worker.ts
-  async function processOnWorker(worker, data, options = {}, context = {}) {
-    const name = getWorkerName(worker);
-    const workerFarm = WorkerFarm.getWorkerFarm(options);
-    const { source } = options;
-    const workerPoolProps = { name, source };
-    if (!source) {
-      workerPoolProps.url = getWorkerURL(worker, options);
+  // src/geoarrow-loader.ts
+  var GeoArrowLoader = {
+    ...GeoArrowWorkerLoader,
+    parse: async (arraybuffer, options) => parseGeoArrowSync(arraybuffer, options?.arrow),
+    parseSync: (arraybuffer, options) => parseGeoArrowSync(arraybuffer, options?.arrow),
+    parseInBatches: parseGeoArrowInBatches
+  };
+
+  // src/workers/hard-clone.ts
+  function hardClone(data, force = false) {
+    if ("data" in data) {
+      return new Vector(data.data.map((data2) => hardClone(data2, force)));
     }
-    const workerPool = workerFarm.getWorkerPool(workerPoolProps);
-    const jobName = options.jobName || worker.name;
-    const job = await workerPool.startJob(
-      jobName,
-      // eslint-disable-next-line
-      onMessage.bind(null, context)
+    const clonedChildren = [];
+    for (const childData of data.children) {
+      clonedChildren.push(hardClone(childData, force));
+    }
+    let clonedDictionary;
+    if (data.dictionary !== void 0) {
+      clonedDictionary = hardClone(data.dictionary, force);
+    }
+    const clonedBuffers = {
+      [BufferType.OFFSET]: cloneBuffer(data.buffers[BufferType.OFFSET], force),
+      [BufferType.DATA]: cloneBuffer(data.buffers[BufferType.DATA], force),
+      [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,
+      // @ts-expect-error _nullCount is protected. We're using it here to mimic
+      // `Data.clone`
+      data._nullCount,
+      clonedBuffers,
+      clonedChildren,
+      clonedDictionary
     );
-    const transferableOptions = getTransferListForWriter(options);
-    job.postMessage("process", { input: data, options: transferableOptions });
-    const result = await job.result;
-    return result.result;
   }
-  async function onMessage(context, job, type, payload) {
-    switch (type) {
-      case "done":
-        job.done(payload);
-        break;
-      case "error":
-        job.error(new Error(payload.error));
-        break;
-      case "process":
-        const { id, input, options } = payload;
-        try {
-          if (!context.process) {
-            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 });
-        } catch (error) {
-          const message = error instanceof Error ? error.message : "unknown error";
-          job.postMessage("error", { id, error: message });
-        }
-        break;
-      default:
-        console.warn(`process-on-worker: unknown message ${type}`);
+  function isTypedArraySliced(arr) {
+    return !(arr.byteOffset === 0 && arr.byteLength === arr.buffer.byteLength);
+  }
+  function cloneBuffer(arr, force) {
+    if (arr === void 0) {
+      return arr;
     }
+    if (!force && !isTypedArraySliced(arr)) {
+      return arr;
+    }
+    return arr.slice();
   }
 
   // src/triangulate-on-worker.ts