@loaders.gl/parquet 5.0.0-alpha.4 → 5.0.0-alpha.6

package/dist/index.cjs

@@ -73,7 +73,7 @@ var init_parquet_loader_base = __esm({
     "use strict";
     init_parquet_format();
     init_parquet_loader_options();
-    VERSION = true ? "5.0.0-alpha.4" : "latest";
+    VERSION = true ? "5.0.0-alpha.6" : "latest";
     PARQUET_LOADER_BASE = {
       ...ParquetFormat,
       dataType: null,
@@ -497,6 +497,10 @@ var init_worker_thread = __esm({
       name;
       source;
       url;
+      /** Lazily resolves the classic worker URL used as a fallback. */
+      getUrl;
+      /** Creates a browser Worker directly. */
+      loadWorker;
       terminated = false;
       worker;
       onMessage;
@@ -507,11 +511,13 @@ var init_worker_thread = __esm({
         return typeof Worker !== "undefined" && isBrowser2 || typeof NodeWorker !== "undefined" && !isBrowser2;
       }
       constructor(props) {
-        const { name, source, url } = props;
-        assert(source || url);
+        const { name, source, url, getUrl, loadWorker } = props;
+        assert(source || url || getUrl || loadWorker);
         this.name = name;
         this.source = source;
         this.url = url;
+        this.getUrl = getUrl;
+        this.loadWorker = loadWorker;
         this.onMessage = NOOP;
         this.onError = (error) => console.log(error);
         this.worker = isBrowser2 ? this._createBrowserWorker() : this._createNodeWorker();
@@ -557,7 +563,7 @@ var init_worker_thread = __esm({
        */
       _getErrorFromErrorEvent(event) {
         let message = "Failed to load ";
-        message += `worker ${this.name} from ${this.url}. `;
+        message += `worker ${this.name} from ${this.url || "built-in worker factory"}. `;
         if (event.message) {
           message += `${event.message} in `;
         }
@@ -570,8 +576,26 @@ var init_worker_thread = __esm({
        * Creates a worker thread on the browser
        */
       _createBrowserWorker() {
-        this._loadableURL = getLoadableWorkerURL({ source: this.source, url: this.url });
+        var _a;
+        if (this.loadWorker) {
+          try {
+            const worker2 = this.loadWorker();
+            if (worker2) {
+              return this._initializeBrowserWorker(worker2);
+            }
+          } catch (error) {
+            if (!this.source && !this.url && !this.getUrl) {
+              throw error;
+            }
+          }
+        }
+        const url = this.url || ((_a = this.getUrl) == null ? void 0 : _a.call(this));
+        this._loadableURL = getLoadableWorkerURL({ source: this.source, url });
         const worker = new Worker(this._loadableURL, { name: this.name });
+        return this._initializeBrowserWorker(worker);
+      }
+      /** Attaches protocol handlers to a browser worker. */
+      _initializeBrowserWorker(worker) {
         worker.onmessage = (event) => {
           if (!event.data) {
             this.onError(new Error("No data received"));
@@ -630,6 +654,10 @@ var init_worker_pool = __esm({
       source;
       // | Function;
       url;
+      /** Lazily resolves a classic worker fallback URL. */
+      getUrl;
+      /** Creates a browser Worker directly. */
+      loadWorker;
       maxConcurrency = 1;
       maxMobileConcurrency = 1;
       onDebug = () => {
@@ -651,6 +679,8 @@ var init_worker_pool = __esm({
       constructor(props) {
         this.source = props.source;
         this.url = props.url;
+        this.getUrl = props.getUrl;
+        this.loadWorker = props.loadWorker;
         this.setProps(props);
       }
       /**
@@ -760,7 +790,13 @@ var init_worker_pool = __esm({
         if (this.count < this._getMaxConcurrency()) {
           this.count++;
           const name = `${this.name.toLowerCase()} (#${this.count} of ${this.maxConcurrency})`;
-          return new WorkerThread({ name, source: this.source, url: this.url });
+          return new WorkerThread({
+            name,
+            source: this.source,
+            url: this.url,
+            getUrl: this.getUrl,
+            loadWorker: this.loadWorker
+          });
         }
         return null;
       }
@@ -772,7 +808,22 @@ var init_worker_pool = __esm({
 });
 
 // ../worker-utils/src/lib/worker-farm/worker-farm.ts
-var DEFAULT_PROPS, WorkerFarm;
+function getWorkerPoolKey(options) {
+  const { name, source, url, urlKey, loadWorker } = options;
+  const sourceKey = source ? `source:${source}` : "";
+  const urlKeyPart = url || urlKey ? `url:${url || urlKey}` : "";
+  const loadWorkerKey = loadWorker ? `loadWorker:${getLoadWorkerId(loadWorker)}` : "";
+  return [name, sourceKey, urlKeyPart, loadWorkerKey].filter(Boolean).join("|");
+}
+function getLoadWorkerId(loadWorker) {
+  let loadWorkerId = loadWorkerIds.get(loadWorker);
+  if (!loadWorkerId) {
+    loadWorkerId = nextLoadWorkerId++;
+    loadWorkerIds.set(loadWorker, loadWorkerId);
+  }
+  return loadWorkerId;
+}
+var DEFAULT_PROPS, loadWorkerIds, nextLoadWorkerId, WorkerFarm;
 var init_worker_farm = __esm({
   "../worker-utils/src/lib/worker-farm/worker-farm.ts"() {
     "use strict";
@@ -785,6 +836,8 @@ var init_worker_farm = __esm({
       onDebug: () => {
       }
     };
+    loadWorkerIds = /* @__PURE__ */ new WeakMap();
+    nextLoadWorkerId = 1;
     WorkerFarm = class _WorkerFarm {
       props;
       workerPools = /* @__PURE__ */ new Map();
@@ -828,24 +881,28 @@ var init_worker_farm = __esm({
       }
       /**
        * 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 -
+       * @param options Worker target used to identify and initialize the pool.
+       * @param options.name Worker name used as the base pool identity.
+       * @param options.url Worker script URL.
+       * @param options.source Inline worker source.
+       * @param options.loadWorker Built-in browser worker factory.
        * @example
        *   const job = WorkerFarm.getWorkerFarm().getWorkerPool({name, url}).startJob(...);
        */
       getWorkerPool(options) {
-        const { name, source, url } = options;
-        let workerPool = this.workerPools.get(name);
+        const { name, source, url, getUrl, loadWorker } = options;
+        const workerPoolKey = getWorkerPoolKey(options);
+        let workerPool = this.workerPools.get(workerPoolKey);
         if (!workerPool) {
           workerPool = new WorkerPool({
             name,
             source,
-            url
+            url,
+            getUrl,
+            loadWorker
           });
           workerPool.setProps(this._getWorkerPoolProps());
-          this.workerPools.set(name, workerPool);
+          this.workerPools.set(workerPoolKey, workerPool);
         }
         return workerPool;
       }
@@ -866,35 +923,42 @@ function getWorkerName(worker) {
   const warning = worker.version !== VERSION3 ? ` (worker-utils@${VERSION3})` : "";
   return `${worker.name}@${worker.version}${warning}`;
 }
-function getWorkerURL(worker, options = {}) {
+function getCustomWorkerURL(worker, options = {}) {
   var _a;
   const workerOptions = options[worker.id] || {};
-  const workerFile = isBrowser2 ? `${worker.id}-worker.js` : worker.workerNode || `${worker.id}-worker-node.js`;
+  const workerFile = isBrowser2 ? worker.workerFile || `${worker.id}-worker.js` : worker.workerNode || `${worker.id}-worker-node.js`;
   let url = workerOptions.workerUrl;
-  if (!url && typeof worker.worker === "string") {
-    url = worker.worker;
-  }
   if (!url && worker.id === "compression") {
     url = options.workerUrl;
   }
   const workerType = options._workerType || ((_a = options == null ? void 0 : options.core) == null ? void 0 : _a._workerType);
-  if (workerType === "test") {
+  if (!url && workerType === "test") {
     if (isBrowser2) {
       url = `modules/${worker.module}/dist/${workerFile}`;
     } else {
       url = `modules/${worker.module}/src/workers/${worker.id}-worker-node.ts`;
     }
   }
-  if (!url) {
-    let version2 = worker.version;
-    if (version2 === "latest") {
-      version2 = NPM_TAG;
-    }
-    const versionTag = version2 ? `@${version2}` : "";
-    url = `https://unpkg.com/@loaders.gl/${worker.module}${versionTag}/dist/${workerFile}`;
+  return url || null;
+}
+function getWorkerURL(worker, options = {}) {
+  const customWorkerUrl = getCustomWorkerURL(worker, options);
+  const descriptorWorkerUrl = typeof worker.worker === "string" ? worker.worker : null;
+  const url = customWorkerUrl || descriptorWorkerUrl || getDefaultWorkerURL(worker, true);
+  assert(url);
+  return url;
+}
+function getDefaultWorkerURL(worker, warn = false) {
+  const workerFile = isBrowser2 ? worker.workerFile || `${worker.id}-worker.js` : worker.workerNode || `${worker.id}-worker-node.js`;
+  let version2 = worker.version;
+  if (version2 === "latest") {
+    version2 = NPM_TAG;
+  }
+  const versionTag = version2 ? `@${version2}` : "";
+  const url = `https://unpkg.com/@loaders.gl/${worker.module}${versionTag}/dist/${workerFile}`;
+  if (warn) {
     warnIfUsingNpmTagFallback(worker, url);
   }
-  assert(url);
   return url;
 }
 function warnIfUsingNpmTagFallback(worker, url) {
@@ -928,19 +992,16 @@ function canProcessOnWorker(worker, options) {
     return false;
   }
   const workerOptions = options == null ? void 0 : options[worker.id];
-  return Boolean((worker.worker || (workerOptions == null ? void 0 : workerOptions.workerUrl)) && (options == null ? void 0 : options.worker));
+  return Boolean(
+    (worker.worker || worker.loadWorker || (workerOptions == null ? void 0 : workerOptions.workerUrl)) && (options == null ? void 0 : options.worker)
+  );
 }
 async function processOnWorker(worker, data, options = {}, context = {}, jobContext = {}) {
   var _a, _b, _c;
   throwIfAborted(options.signal);
   const name = getWorkerName(worker);
   const workerFarm = WorkerFarm.getWorkerFarm(options);
-  const { source } = options;
-  const workerPoolProps = { name, source };
-  if (!source) {
-    workerPoolProps.url = getWorkerURL(worker, options);
-  }
-  const workerPool = workerFarm.getWorkerPool(workerPoolProps);
+  const workerPool = workerFarm.getWorkerPool(getWorkerPoolTarget(worker, options, name));
   const jobName = options.jobName || worker.name;
   const job = await workerPool.startJob(
     jobName,
@@ -983,6 +1044,24 @@ function createAbortError2(message) {
   error.name = "AbortError";
   return error;
 }
+function getWorkerPoolTarget(worker, options, name) {
+  if (options.source) {
+    return { name, source: options.source };
+  }
+  const customWorkerUrl = getCustomWorkerURL(worker, options);
+  if (customWorkerUrl) {
+    return { name, url: customWorkerUrl };
+  }
+  if (isBrowser2 && worker.loadWorker) {
+    return {
+      name,
+      loadWorker: worker.loadWorker,
+      getUrl: () => getWorkerURL(worker, options),
+      urlKey: getDefaultWorkerURL(worker)
+    };
+  }
+  return { name, url: getWorkerURL(worker, options) };
+}
 async function onMessage(context, job, type, payload) {
   switch (type) {
     case "done":
@@ -1015,6 +1094,7 @@ var init_process_on_worker = __esm({
     init_worker_farm();
     init_get_worker_url();
     init_get_transfer_list();
+    init_globals2();
   }
 });
 
@@ -1048,7 +1128,7 @@ async function parseWithWorker(loader, data, options, context, parseOnMainThread
   const result = await processOnWorker(
     loader,
     data,
-    { ...getWorkerOptions(options), signal: workerSignal },
+    { ...getWorkerOptions(options, loader), signal: workerSignal },
     {
       process: async (input, processOptions, _workerContext, parseContext) => {
         if (!parseOnMainThread) {
@@ -1081,12 +1161,19 @@ function callParseOnMainThread(parseOnMainThread, input, options, context) {
   }
   return parseOnMainThread(input, void 0, options, context);
 }
-function getWorkerOptions(options = {}) {
+function getWorkerOptions(options = {}, loader) {
   const serializedOptions = JSON.parse(JSON.stringify(options));
-  return {
+  const workerOptions = {
     ...serializedOptions.core,
     ...serializedOptions
   };
+  if (workerOptions.worker === "auto") {
+    workerOptions.worker = true;
+  }
+  if (loader) {
+    workerOptions._workerLoaderId = loader.id;
+  }
+  return workerOptions;
 }
 function getSerializableLoaderContext(context) {
   if (!context) {
@@ -3089,6 +3176,12 @@ function serializeArrowType(arrowType) {
         type: "list",
         children: [serializeArrowField(listField)]
       };
+    case arrow.LargeList:
+      const largeListType = arrowType;
+      return {
+        type: "large-list",
+        children: [serializeArrowField(largeListType.valueField)]
+      };
     case arrow.FixedSizeList:
       const fixedSizeList = arrowType;
       return {
@@ -3102,6 +3195,15 @@ function serializeArrowType(arrowType) {
         type: "struct",
         children: structType.children.map((arrowField) => serializeArrowField(arrowField))
       };
+    case arrow.SparseUnion:
+    case arrow.DenseUnion:
+      const unionType = arrowType;
+      return {
+        type: unionType instanceof arrow.DenseUnion ? "dense-union" : "sparse-union",
+        typeIds: unionType.typeIds,
+        children: unionType.children.map((arrowField) => serializeArrowField(arrowField)),
+        typeIdToChildIndex: { ...unionType.typeIdToChildIndex }
+      };
     case arrow.Dictionary:
       const dictionaryType = arrowType;
       return {
@@ -3130,6 +3232,10 @@ function deserializeArrowType(dataType, options) {
         const field = deserializeArrowField(dataType.children[0], options);
         return new arrow.List(field);
       }
+      case "large-list": {
+        const field = deserializeArrowField(dataType.children[0], options);
+        return new arrow.LargeList(field);
+      }
       case "fixed-size-list": {
         const child = deserializeArrowField(dataType.children[0], options);
         return new arrow.FixedSizeList(dataType.listSize, child);
@@ -3142,6 +3248,13 @@ function deserializeArrowType(dataType, options) {
         );
         return new arrow.Struct(children);
       }
+      case "sparse-union":
+      case "dense-union": {
+        const children = dataType.children.map(
+          (arrowField) => deserializeArrowField(arrowField, options)
+        );
+        return dataType.type === "dense-union" ? new arrow.DenseUnion(dataType.typeIds, children) : new arrow.SparseUnion(dataType.typeIds, children);
+      }
       case "dictionary": {
         return new arrow.Dictionary(
           deserializeArrowType(dataType.dictionary, options),
@@ -3845,625 +3958,7 @@ var init_deprecated = __esm({
   }
 });
 
-// ../schema-utils/src/index.ts
-var init_src3 = __esm({
-  "../schema-utils/src/index.ts"() {
-    "use strict";
-    init_convert_arrow_schema();
-    init_deduce_table_schema();
-    init_deprecated();
-    init_table_accessors();
-  }
-});
-
-// src/lib/parsers/convert-parquet-tables.ts
-function convertArrowTableToObjectRows(arrowTable) {
-  return convertArrowToTable2(arrowTable.data, "object-row-table");
-}
-function convertArrowBatchToObjectRows(batch) {
-  const objectRowTable = convertArrowToTable2(batch.data, "object-row-table");
-  return {
-    batchType: batch.batchType,
-    shape: objectRowTable.shape,
-    schema: objectRowTable.schema,
-    data: objectRowTable.data,
-    length: batch.length
-  };
-}
-var init_convert_parquet_tables = __esm({
-  "src/lib/parsers/convert-parquet-tables.ts"() {
-    "use strict";
-    init_src3();
-  }
-});
-
-// ../gis/src/lib/geometry-converters/wkb/helpers/wkb-types.ts
-var EWKB_FLAG_Z, EWKB_FLAG_M, EWKB_FLAG_SRID, WKT_MAGIC_STRINGS, textEncoder, WKT_MAGIC_BYTES;
-var init_wkb_types = __esm({
-  "../gis/src/lib/geometry-converters/wkb/helpers/wkb-types.ts"() {
-    "use strict";
-    EWKB_FLAG_Z = 2147483648;
-    EWKB_FLAG_M = 1073741824;
-    EWKB_FLAG_SRID = 536870912;
-    WKT_MAGIC_STRINGS = [
-      "POINT(",
-      "LINESTRING(",
-      "POLYGON(",
-      "MULTIPOINT(",
-      "MULTILINESTRING(",
-      "MULTIPOLYGON(",
-      "GEOMETRYCOLLECTION("
-    ];
-    textEncoder = new TextEncoder();
-    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;
-  }
-  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
-  });
-  wkbHeader.byteOffset = (target == null ? void 0 : target.byteOffset) ?? 0;
-  if (isWKT(dataView.buffer)) {
-    throw new Error("WKB: Cannot parse WKT data");
-  }
-  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 ewkbZ = geometryCode & EWKB_FLAG_Z;
-  const ewkbM = geometryCode & EWKB_FLAG_M;
-  const ewkbSRID = geometryCode & EWKB_FLAG_SRID;
-  if (!ewkbZ && !ewkbM && !ewkbSRID) {
-    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}`);
-    }
-  }
-  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";
-  }
-  if (ewkbSRID) {
-    wkbHeader.variant = "ewkb";
-    wkbHeader.srid = dataView.getUint32(wkbHeader.byteOffset, wkbHeader.littleEndian);
-    wkbHeader.byteOffset += 4;
-  }
-  return wkbHeader;
-}
-var init_parse_wkb_header = __esm({
-  "../gis/src/lib/geometry-converters/wkb/helpers/parse-wkb-header.ts"() {
-    "use strict";
-    init_wkb_types();
-  }
-});
-
-// ../gis/src/lib/geometry-converters/wkb/convert-wkb-to-geometry.ts
-function convertWKBToGeometry(arrayBuffer) {
-  const dataView = new DataView(arrayBuffer);
-  return parseWKBGeometry(dataView, 0).geometry;
-}
-function parseWKBGeometry(dataView, byteOffset) {
-  const wkbHeader = parseWKBHeader(dataView, { byteOffset });
-  return parseWKBGeometryBody(dataView, wkbHeader.byteOffset, wkbHeader);
-}
-function parseWKBGeometryBody(dataView, byteOffset, wkbHeader) {
-  const { geometryType, dimensions, littleEndian } = wkbHeader;
-  switch (geometryType) {
-    case 1 /* Point */:
-      return parsePointGeometry(dataView, byteOffset, dimensions, littleEndian);
-    case 2 /* LineString */:
-      return parseLineStringGeometry(dataView, byteOffset, dimensions, littleEndian);
-    case 3 /* Polygon */:
-      return parsePolygonGeometry(dataView, byteOffset, dimensions, littleEndian);
-    case 4 /* MultiPoint */:
-      return parseMultiPointGeometry(dataView, byteOffset, littleEndian);
-    case 5 /* MultiLineString */:
-      return parseMultiLineStringGeometry(dataView, byteOffset, littleEndian);
-    case 6 /* MultiPolygon */:
-      return parseMultiPolygonGeometry(dataView, byteOffset, littleEndian);
-    case 7 /* GeometryCollection */:
-      return parseGeometryCollectionGeometry(dataView, byteOffset, littleEndian);
-    default:
-      throw new Error(`WKB: Unsupported geometry type: ${geometryType}`);
-  }
-}
-function parsePosition(dataView, byteOffset, dimensions, littleEndian) {
-  const position = [];
-  for (let coordinateIndex = 0; coordinateIndex < dimensions; coordinateIndex++) {
-    position.push(dataView.getFloat64(byteOffset, littleEndian));
-    byteOffset += 8;
-  }
-  return { position, byteOffset };
-}
-function parseCoordinateSequence(dataView, byteOffset, dimensions, littleEndian) {
-  const pointCount = dataView.getUint32(byteOffset, littleEndian);
-  byteOffset += 4;
-  const coordinates = [];
-  for (let pointIndex = 0; pointIndex < pointCount; pointIndex++) {
-    const parsedPosition = parsePosition(dataView, byteOffset, dimensions, littleEndian);
-    coordinates.push(parsedPosition.position);
-    byteOffset = parsedPosition.byteOffset;
-  }
-  return { coordinates, byteOffset };
-}
-function parsePointGeometry(dataView, byteOffset, dimensions, littleEndian) {
-  const parsedPosition = parsePosition(dataView, byteOffset, dimensions, littleEndian);
-  return {
-    geometry: { type: "Point", coordinates: parsedPosition.position },
-    byteOffset: parsedPosition.byteOffset
-  };
-}
-function parseLineStringGeometry(dataView, byteOffset, dimensions, littleEndian) {
-  const parsedCoordinates = parseCoordinateSequence(dataView, byteOffset, dimensions, littleEndian);
-  return {
-    geometry: { type: "LineString", coordinates: parsedCoordinates.coordinates },
-    byteOffset: parsedCoordinates.byteOffset
-  };
-}
-function parsePolygonGeometry(dataView, byteOffset, dimensions, littleEndian) {
-  const ringCount = dataView.getUint32(byteOffset, littleEndian);
-  byteOffset += 4;
-  const coordinates = [];
-  for (let ringIndex = 0; ringIndex < ringCount; ringIndex++) {
-    const parsedRing = parseCoordinateSequence(dataView, byteOffset, dimensions, littleEndian);
-    coordinates.push(parsedRing.coordinates);
-    byteOffset = parsedRing.byteOffset;
-  }
-  return {
-    geometry: { type: "Polygon", coordinates },
-    byteOffset
-  };
-}
-function parseMultiPointGeometry(dataView, byteOffset, littleEndian) {
-  const geometryCount = dataView.getUint32(byteOffset, littleEndian);
-  byteOffset += 4;
-  const coordinates = [];
-  for (let geometryIndex = 0; geometryIndex < geometryCount; geometryIndex++) {
-    const parsedGeometry = parseWKBGeometry(dataView, byteOffset);
-    if (parsedGeometry.geometry.type !== "Point") {
-      throw new Error("WKB: Inner geometries of MultiPoint not of type Point");
-    }
-    coordinates.push(parsedGeometry.geometry.coordinates);
-    byteOffset = parsedGeometry.byteOffset;
-  }
-  return {
-    geometry: { type: "MultiPoint", coordinates },
-    byteOffset
-  };
-}
-function parseMultiLineStringGeometry(dataView, byteOffset, littleEndian) {
-  const geometryCount = dataView.getUint32(byteOffset, littleEndian);
-  byteOffset += 4;
-  const coordinates = [];
-  for (let geometryIndex = 0; geometryIndex < geometryCount; geometryIndex++) {
-    const parsedGeometry = parseWKBGeometry(dataView, byteOffset);
-    if (parsedGeometry.geometry.type !== "LineString") {
-      throw new Error("WKB: Inner geometries of MultiLineString not of type LineString");
-    }
-    coordinates.push(parsedGeometry.geometry.coordinates);
-    byteOffset = parsedGeometry.byteOffset;
-  }
-  return {
-    geometry: { type: "MultiLineString", coordinates },
-    byteOffset
-  };
-}
-function parseMultiPolygonGeometry(dataView, byteOffset, littleEndian) {
-  const geometryCount = dataView.getUint32(byteOffset, littleEndian);
-  byteOffset += 4;
-  const coordinates = [];
-  for (let geometryIndex = 0; geometryIndex < geometryCount; geometryIndex++) {
-    const parsedGeometry = parseWKBGeometry(dataView, byteOffset);
-    if (parsedGeometry.geometry.type !== "Polygon") {
-      throw new Error("WKB: Inner geometries of MultiPolygon not of type Polygon");
-    }
-    coordinates.push(parsedGeometry.geometry.coordinates);
-    byteOffset = parsedGeometry.byteOffset;
-  }
-  return {
-    geometry: { type: "MultiPolygon", coordinates },
-    byteOffset
-  };
-}
-function parseGeometryCollectionGeometry(dataView, byteOffset, littleEndian) {
-  const geometryCount = dataView.getUint32(byteOffset, littleEndian);
-  byteOffset += 4;
-  const geometries = [];
-  for (let geometryIndex = 0; geometryIndex < geometryCount; geometryIndex++) {
-    const parsedGeometry = parseWKBGeometry(dataView, byteOffset);
-    geometries.push(parsedGeometry.geometry);
-    byteOffset = parsedGeometry.byteOffset;
-  }
-  return {
-    geometry: { type: "GeometryCollection", geometries },
-    byteOffset
-  };
-}
-var init_convert_wkb_to_geometry = __esm({
-  "../gis/src/lib/geometry-converters/wkb/convert-wkb-to-geometry.ts"() {
-    "use strict";
-    init_parse_wkb_header();
-  }
-});
-
-// ../gis/src/lib/geometry-converters/wkb/convert-wkt-to-geometry.ts
-function convertWKTToGeometry(input, options) {
-  var _a;
-  const parts = input.split(";");
-  let _ = parts.pop();
-  const srid = (parts.shift() || "").split("=").pop();
-  const state = { parts, _, i: 0 };
-  const geometry = parseGeometry(state);
-  return ((_a = options == null ? void 0 : options.wkt) == null ? void 0 : _a.crs) ? addCRS(geometry, srid) : geometry;
-}
-function parseGeometry(state) {
-  return parsePoint(state) || parseLineString(state) || parsePolygon(state) || parseMultiPoint(state) || parseMultiLineString(state) || parseMultiPolygon(state) || parseGeometryCollection(state);
-}
-function addCRS(obj, srid) {
-  if (obj && (srid == null ? void 0 : srid.match(/\d+/))) {
-    const crs = {
-      type: "name",
-      properties: {
-        name: "urn:ogc:def:crs:EPSG::" + srid
-      }
-    };
-    obj.crs = crs;
-  }
-  return obj;
-}
-function parsePoint(state) {
-  if (!$(/^(POINT(\sz)?)/i, state)) {
-    return null;
-  }
-  white(state);
-  if (!$(/^(\()/, state)) {
-    return null;
-  }
-  const c = coords(state);
-  if (!c) {
-    return null;
-  }
-  white(state);
-  if (!$(/^(\))/, state)) {
-    return null;
-  }
-  return {
-    type: "Point",
-    coordinates: c[0]
-  };
-}
-function parseMultiPoint(state) {
-  var _a, _b;
-  if (!$(/^(MULTIPOINT)/i, state)) {
-    return null;
-  }
-  white(state);
-  const newCoordsFormat = (_b = state._) == null ? void 0 : _b.substring(((_a = state._) == null ? void 0 : _a.indexOf("(")) + 1, state._.length - 1).replace(/\(/g, "").replace(/\)/g, "");
-  state._ = "MULTIPOINT (" + newCoordsFormat + ")";
-  const c = multicoords(state);
-  if (!c) {
-    return null;
-  }
-  white(state);
-  return {
-    type: "MultiPoint",
-    coordinates: c
-  };
-}
-function parseLineString(state) {
-  if (!$(/^(LINESTRING(\sz)?)/i, state)) {
-    return null;
-  }
-  white(state);
-  if (!$(/^(\()/, state)) {
-    return null;
-  }
-  const c = coords(state);
-  if (!c) {
-    return null;
-  }
-  if (!$(/^(\))/, state)) {
-    return null;
-  }
-  return {
-    type: "LineString",
-    coordinates: c
-  };
-}
-function parseMultiLineString(state) {
-  if (!$(/^(MULTILINESTRING)/i, state)) return null;
-  white(state);
-  const c = multicoords(state);
-  if (!c) {
-    return null;
-  }
-  white(state);
-  return {
-    // @ts-ignore
-    type: "MultiLineString",
-    // @ts-expect-error
-    coordinates: c
-  };
-}
-function parsePolygon(state) {
-  if (!$(/^(POLYGON(\sz)?)/i, state)) {
-    return null;
-  }
-  white(state);
-  const c = multicoords(state);
-  if (!c) {
-    return null;
-  }
-  return {
-    // @ts-ignore
-    type: "Polygon",
-    // @ts-expect-error
-    coordinates: c
-  };
-}
-function parseMultiPolygon(state) {
-  if (!$(/^(MULTIPOLYGON)/i, state)) {
-    return null;
-  }
-  white(state);
-  const c = multicoords(state);
-  if (!c) {
-    return null;
-  }
-  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;
-  }
-  geometry = parseGeometry(state);
-  while (geometry) {
-    geometries.push(geometry);
-    white(state);
-    $(/^(,)/, state);
-    white(state);
-    geometry = parseGeometry(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;
-  elem = $(/^(\()/, state) || $(/^(\))/, state) || $(/^(,)/, state) || $(tuples, state);
-  while (elem) {
-    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(Number.isNaN)) {
-      Array.prototype.push.apply(pointer, elem.split(/\s/g).map(parseFloat));
-    } else {
-      return null;
-    }
-    white(state);
-    elem = $(/^(\()/, state) || $(/^(\))/, state) || $(/^(,)/, state) || $(tuples, state);
-  }
-  if (depth !== 0) return null;
-  return rings;
-}
-function coords(state) {
-  const list = [];
-  let item;
-  let pt;
-  pt = $(tuples, state) || $(/^(,)/, state);
-  while (pt) {
-    if (pt === ",") {
-      list.push(item);
-      item = [];
-    } else if (!pt.split(/\s/g).some(Number.isNaN)) {
-      if (!item) item = [];
-      Array.prototype.push.apply(item, pt.split(/\s/g).map(parseFloat));
-    }
-    white(state);
-    pt = $(tuples, state) || $(/^(,)/, state);
-  }
-  if (item) list.push(item);
-  else return null;
-  return list.length ? list : null;
-}
-function $(regexp, state) {
-  var _a;
-  const match = (_a = state._) == null ? void 0 : _a.substring(state.i).match(regexp);
-  if (!match) return null;
-  else {
-    state.i += match[0].length;
-    return match[0];
-  }
-}
-function white(state) {
-  $(/^\s*/, state);
-}
-var numberRegexp, tuples;
-var init_convert_wkt_to_geometry = __esm({
-  "../gis/src/lib/geometry-converters/wkb/convert-wkt-to-geometry.ts"() {
-    "use strict";
-    numberRegexp = /[-+]?([0-9]*\.[0-9]+|[0-9]+)([eE][-+]?[0-9]+)?/;
-    tuples = new RegExp("^" + numberRegexp.source + "(\\s" + numberRegexp.source + "){1,}");
-  }
-});
-
-// ../gis/src/lib/geometry-converters/wkb/get-wkb-geometry-statistics.ts
-function getWKBGeometryStatistics(input) {
-  const dataView = getDataView(input);
-  const bounds = {};
-  const parsedGeometry = scanGeometry(dataView, 0, bounds);
-  if (parsedGeometry.byteOffset !== dataView.byteLength) {
-    throw new Error("WKB: Unexpected trailing bytes after geometry");
-  }
-  return {
-    geometryType: getISOTypeCode(parsedGeometry.header),
-    bbox: createBoundingBox(bounds)
-  };
-}
-function scanGeometry(dataView, byteOffset, bounds) {
-  const header = parseWKBHeader(dataView, { byteOffset });
-  byteOffset = header.byteOffset;
-  switch (header.geometryType) {
-    case 1 /* Point */:
-      byteOffset = scanPosition(dataView, byteOffset, header, bounds);
-      break;
-    case 2 /* LineString */:
-      byteOffset = scanCoordinateSequence(dataView, byteOffset, header, bounds);
-      break;
-    case 3 /* Polygon */: {
-      const ringCount = dataView.getUint32(byteOffset, header.littleEndian);
-      byteOffset += 4;
-      for (let ringIndex = 0; ringIndex < ringCount; ringIndex++) {
-        byteOffset = scanCoordinateSequence(dataView, byteOffset, header, bounds);
-      }
-      break;
-    }
-    case 4 /* MultiPoint */:
-    case 5 /* MultiLineString */:
-    case 6 /* MultiPolygon */:
-    case 7 /* GeometryCollection */: {
-      const geometryCount = dataView.getUint32(byteOffset, header.littleEndian);
-      byteOffset += 4;
-      for (let geometryIndex = 0; geometryIndex < geometryCount; geometryIndex++) {
-        byteOffset = scanGeometry(dataView, byteOffset, bounds).byteOffset;
-      }
-      break;
-    }
-    default:
-      throw new Error(`WKB: Unsupported geometry type: ${header.geometryType}`);
-  }
-  return { byteOffset, header };
-}
-function scanCoordinateSequence(dataView, byteOffset, header, bounds) {
-  const pointCount = dataView.getUint32(byteOffset, header.littleEndian);
-  byteOffset += 4;
-  for (let pointIndex = 0; pointIndex < pointCount; pointIndex++) {
-    byteOffset = scanPosition(dataView, byteOffset, header, bounds);
-  }
-  return byteOffset;
-}
-function scanPosition(dataView, byteOffset, header, bounds) {
-  const coordinates = new Array(header.dimensions);
-  for (let coordinateIndex = 0; coordinateIndex < header.dimensions; coordinateIndex++) {
-    coordinates[coordinateIndex] = dataView.getFloat64(byteOffset, header.littleEndian);
-    byteOffset += 8;
-  }
-  updateBounds(bounds, "x", coordinates[0]);
-  updateBounds(bounds, "y", coordinates[1]);
-  if (header.coordinates === "xyz" || header.coordinates === "xyzm") {
-    updateBounds(bounds, "z", coordinates[2]);
-  }
-  if (header.coordinates === "xym") updateBounds(bounds, "m", coordinates[2]);
-  if (header.coordinates === "xyzm") updateBounds(bounds, "m", coordinates[3]);
-  return byteOffset;
-}
-function updateBounds(bounds, dimension, value) {
-  if (!Number.isFinite(value)) return;
-  const minimumKey = `${dimension}min`;
-  const maximumKey = `${dimension}max`;
-  bounds[minimumKey] = bounds[minimumKey] === void 0 ? value : Math.min(bounds[minimumKey], value);
-  bounds[maximumKey] = bounds[maximumKey] === void 0 ? value : Math.max(bounds[maximumKey], value);
-}
-function createBoundingBox(bounds) {
-  if (bounds.xmin === void 0 || bounds.xmax === void 0 || bounds.ymin === void 0 || bounds.ymax === void 0) {
-    return void 0;
-  }
-  return bounds;
-}
-function getISOTypeCode(header) {
-  const dimensionOffset = header.coordinates === "xyz" ? 1e3 : header.coordinates === "xym" ? 2e3 : header.coordinates === "xyzm" ? 3e3 : 0;
-  return header.geometryType + dimensionOffset;
-}
-function getDataView(input) {
-  return ArrayBuffer.isView(input) ? new DataView(input.buffer, input.byteOffset, input.byteLength) : new DataView(input);
-}
-var init_get_wkb_geometry_statistics = __esm({
-  "../gis/src/lib/geometry-converters/wkb/get-wkb-geometry-statistics.ts"() {
-    "use strict";
-    init_parse_wkb_header();
-  }
-});
-
-// ../gis/src/lib/geoarrow/metadata-utils.ts
+// ../schema/src/metadata.ts
 function getMetadataValue(metadata, key) {
   return metadata instanceof Map ? metadata.get(key) || null : metadata[key] || null;
 }
@@ -4474,13 +3969,6 @@ function setMetadataValue(metadata, key, value) {
     metadata[key] = value;
   }
 }
-var init_metadata_utils = __esm({
-  "../gis/src/lib/geoarrow/metadata-utils.ts"() {
-    "use strict";
-  }
-});
-
-// ../gis/src/lib/geoarrow/geoparquet-metadata.ts
 function getGeoMetadata(metadata) {
   if (!metadata) {
     return null;
@@ -4491,7 +3979,7 @@ function getGeoMetadata(metadata) {
     return null;
   }
   for (const column of Object.values(geoMetadata.columns || {})) {
-    if (column.encoding) {
+    if (column && typeof column === "object" && typeof column.encoding === "string") {
       column.encoding = column.encoding.toLowerCase();
     }
   }
@@ -4505,12 +3993,12 @@ function unpackGeoMetadata(metadata) {
   if (!geoMetadata) {
     return;
   }
-  const { version: version2, primary_column, columns } = geoMetadata;
+  const { version: version2, primary_column: primaryColumn, columns } = geoMetadata;
   if (version2) {
     setMetadataValue(metadata, "geo.version", version2);
   }
-  if (primary_column) {
-    setMetadataValue(metadata, "geo.primary_column", primary_column);
+  if (primaryColumn) {
+    setMetadataValue(metadata, "geo.primary_column", primaryColumn);
   }
   setMetadataValue(metadata, "geo.columns", Object.keys(columns || {}).join(","));
 }
@@ -4531,85 +4019,54 @@ function parseJSONStringMetadata(stringifiedMetadata) {
   }
   try {
     const metadata = JSON.parse(stringifiedMetadata);
-    if (!metadata || typeof metadata !== "object") {
-      return null;
-    }
-    return metadata;
+    return metadata && typeof metadata === "object" ? metadata : null;
   } catch {
     return null;
   }
 }
-var init_geoparquet_metadata = __esm({
-  "../gis/src/lib/geoarrow/geoparquet-metadata.ts"() {
+var init_metadata = __esm({
+  "../schema/src/metadata.ts"() {
     "use strict";
-    init_metadata_utils();
   }
 });
 
-// ../gis/src/lib/table-converters/convert-wkb-table-to-geojson.ts
-function convertWKBTableToGeoJSON(table, schema) {
-  var _a;
-  const geoMetadata = getGeoMetadata(schema.metadata);
-  const primaryColumn = geoMetadata == null ? void 0 : geoMetadata.primary_column;
-  if (!primaryColumn) {
-    throw new Error("no geometry column");
-  }
-  const columnMetadata = (_a = geoMetadata.columns) == null ? void 0 : _a[primaryColumn];
-  if (!columnMetadata) {
-    throw new Error(`missing metadata for geometry column "${primaryColumn}"`);
-  }
-  const features = [];
-  const length = getTableLength(table);
-  for (let rowIndex = 0; rowIndex < length; rowIndex++) {
-    const row = getTableRowAsObject(table, rowIndex);
-    const geometry = parseGeometry2(row[primaryColumn], columnMetadata);
-    delete row[primaryColumn];
-    features.push({ type: "Feature", geometry, properties: row });
-  }
-  return { shape: "geojson-table", schema, type: "FeatureCollection", features };
-}
-function parseGeometry2(geometry, columnMetadata) {
-  var _a;
-  switch ((_a = columnMetadata.encoding) == null ? void 0 : _a.toLowerCase()) {
-    case "wkt":
-      return convertWKTToGeometry(geometry) || null;
-    case "wkb":
-    default: {
-      const arrayBuffer = ArrayBuffer.isView(geometry) ? geometry.buffer.slice(geometry.byteOffset, geometry.byteOffset + geometry.byteLength) : geometry;
-      return convertWKBToGeometry(arrayBuffer);
-    }
-  }
-}
-var init_convert_wkb_table_to_geojson = __esm({
-  "../gis/src/lib/table-converters/convert-wkb-table-to-geojson.ts"() {
+// ../schema/src/index.ts
+var init_src3 = __esm({
+  "../schema/src/index.ts"() {
     "use strict";
-    init_src3();
-    init_geoparquet_metadata();
-    init_convert_wkb_to_geometry();
-    init_convert_wkt_to_geometry();
+    init_metadata();
   }
 });
 
-// ../gis/src/deprecated.ts
-var convertWKBTableToGeoJSON2;
-var init_deprecated2 = __esm({
-  "../gis/src/deprecated.ts"() {
+// ../schema-utils/src/index.ts
+var init_src4 = __esm({
+  "../schema-utils/src/index.ts"() {
     "use strict";
-    init_convert_wkb_table_to_geojson();
-    convertWKBTableToGeoJSON2 = ((...args) => convertWKBTableToGeoJSON(
-      ...args
-    ));
+    init_convert_arrow_schema();
+    init_deduce_table_schema();
+    init_deprecated();
+    init_table_accessors();
   }
 });
 
-// ../gis/src/index.ts
-var init_src4 = __esm({
-  "../gis/src/index.ts"() {
+// src/lib/parsers/convert-parquet-tables.ts
+function convertArrowTableToObjectRows(arrowTable) {
+  return convertArrowToTable2(arrowTable.data, "object-row-table");
+}
+function convertArrowBatchToObjectRows(batch) {
+  const objectRowTable = convertArrowToTable2(batch.data, "object-row-table");
+  return {
+    batchType: batch.batchType,
+    shape: objectRowTable.shape,
+    schema: objectRowTable.schema,
+    data: objectRowTable.data,
+    length: batch.length
+  };
+}
+var init_convert_parquet_tables = __esm({
+  "src/lib/parsers/convert-parquet-tables.ts"() {
     "use strict";
-    init_get_wkb_geometry_statistics();
-    init_metadata_utils();
-    init_geoparquet_metadata();
-    init_deprecated2();
+    init_src4();
   }
 });
 
@@ -4657,6 +4114,10 @@ var init_geospatial_metadata_zod_schema = __esm({
       encoding: import_zod.z.enum([
         "WKB",
         "wkb",
+        "GEOMETRY",
+        "geometry",
+        "GEOGRAPHY",
+        "geography",
         "point",
         "linestring",
         "polygon",
@@ -4694,10 +4155,11 @@ var init_geospatial_metadata_zod_schema = __esm({
     }).superRefine((metadata, context) => {
       if (!metadata.version.startsWith("2.")) return;
       for (const [columnName, column] of Object.entries(metadata.columns)) {
-        if (column.encoding.toUpperCase() !== "WKB") {
+        const encoding = column.encoding.toUpperCase();
+        if (encoding !== "WKB" && encoding !== "GEOMETRY" && encoding !== "GEOGRAPHY") {
           context.addIssue({
             code: "custom",
-            message: "GeoParquet 2.x geometry columns must use WKB encoding",
+            message: "GeoParquet 2.x geometry columns must use WKB, GEOMETRY, or GEOGRAPHY encoding",
             path: ["columns", columnName, "encoding"]
           });
         }
@@ -4812,10 +4274,11 @@ function getGeoArrowMetadataFromGeoParquetField(field, columnMetadata) {
   if (!extensionName) {
     return null;
   }
-  if (normalizedEncoding === "wkb" && field.type !== "binary") {
+  const isBinaryGeospatialEncoding = normalizedEncoding === "wkb" || normalizedEncoding === "geometry" || normalizedEncoding === "geography";
+  if (isBinaryGeospatialEncoding && !isBinaryFieldType(field.type)) {
     return null;
   }
-  if (normalizedEncoding !== "wkb" && (field.type === "binary" || field.type === "utf8")) {
+  if (!isBinaryGeospatialEncoding && (isBinaryFieldType(field.type) || isStringFieldType(field.type))) {
     return null;
   }
   const extensionMetadata = {};
@@ -4829,8 +4292,22 @@ function getGeoArrowMetadataFromGeoParquetField(field, columnMetadata) {
   if (columnMetadata.edges && columnMetadata.edges !== "planar") {
     extensionMetadata.edges = columnMetadata.edges;
   }
+  if (normalizedEncoding === "geography" && !extensionMetadata.edges) {
+    extensionMetadata.edges = "spherical";
+  }
+  for (const [metadataKey, metadataValue] of Object.entries(columnMetadata)) {
+    if (metadataValue !== void 0 && metadataValue !== null && !["encoding", "geometry_types", "crs", "edges"].includes(metadataKey)) {
+      extensionMetadata[metadataKey] = metadataValue;
+    }
+  }
   return Object.keys(extensionMetadata).length > 0 ? { extensionName, extensionMetadata } : { extensionName };
 }
+function isBinaryFieldType(fieldType) {
+  return typeof fieldType === "string" && (fieldType === "binary" || fieldType === "binary-view");
+}
+function isStringFieldType(fieldType) {
+  return typeof fieldType === "string" && (fieldType === "utf8" || fieldType === "utf8-view");
+}
 function getMetadataEntries(metadata) {
   if (metadata instanceof Map) {
     return [...metadata.entries()];
@@ -4856,12 +4333,14 @@ var init_geospatial_metadata = __esm({
   "src/lib/geo/geospatial-metadata.ts"() {
     "use strict";
     arrow4 = __toESM(require("apache-arrow"), 1);
-    init_src4();
     init_src3();
+    init_src4();
     GEOARROW_EXTENSION_NAME_KEY = "ARROW:extension:name";
     GEOARROW_EXTENSION_METADATA_KEY = "ARROW:extension:metadata";
     GEOPARQUET_TO_GEOARROW_ENCODINGS = {
       wkb: "geoarrow.wkb",
+      geometry: "geoarrow.wkb",
+      geography: "geoarrow.wkb",
       point: "geoarrow.point",
       linestring: "geoarrow.linestring",
       polygon: "geoarrow.polygon",
@@ -6206,13 +5685,518 @@ var init_arrow_table_transport = __esm({
   "../arrow/src/lib/utils/arrow-table-transport.ts"() {
     "use strict";
     arrow8 = __toESM(require("apache-arrow"), 1);
-    init_src3();
+    init_src4();
     init_split_arrow_buffers();
   }
 });
 
-// ../arrow/src/index.ts
+// ../gis/src/lib/geometry-converters/wkb/convert-wkb-to-geometry.ts
+function convertWKBToGeometry(arrayBuffer) {
+  const geometry = (0, import_wkb.parseWKB)(new Uint8Array(arrayBuffer)).geometry;
+  return normalizeEmptyPoints(geometry);
+}
+function normalizeEmptyPoints(geometry) {
+  if (geometry.type === "Point") {
+    return geometry.coordinates.length > 0 && geometry.coordinates.every(Number.isNaN) ? { ...geometry, coordinates: [] } : geometry;
+  }
+  if (geometry.type === "MultiPoint") {
+    const coordinates = geometry.coordinates.map(
+      (coordinate) => coordinate.length > 0 && coordinate.every(Number.isNaN) ? [] : coordinate
+    );
+    return coordinates.some((coordinate, index) => coordinate !== geometry.coordinates[index]) ? { ...geometry, coordinates } : geometry;
+  }
+  if (geometry.type === "GeometryCollection") {
+    const geometries = geometry.geometries.map(normalizeEmptyPoints);
+    return geometries.some((child, index) => child !== geometry.geometries[index]) ? { ...geometry, geometries } : geometry;
+  }
+  return geometry;
+}
+var import_wkb;
+var init_convert_wkb_to_geometry = __esm({
+  "../gis/src/lib/geometry-converters/wkb/convert-wkb-to-geometry.ts"() {
+    "use strict";
+    import_wkb = require("@math.gl/wkb");
+  }
+});
+
+// ../gis/src/lib/geometry-converters/wkb/convert-wkt-to-geometry.ts
+function getWKTDimension(input) {
+  var _a;
+  const match = input.trim().match(
+    /^(?:POINT|LINESTRING|POLYGON|MULTIPOINT|MULTILINESTRING|MULTIPOLYGON|GEOMETRYCOLLECTION)(?:\s+(ZM|Z|M))?(?:\s|\()/i
+  );
+  if (!match) return null;
+  const dimensionToken = (_a = match[1]) == null ? void 0 : _a.toUpperCase();
+  return dimensionToken === "Z" ? "xyz" : dimensionToken === "M" ? "xym" : dimensionToken === "ZM" ? "xyzm" : "xy";
+}
+function convertWKTToGeometry(input, options) {
+  var _a, _b;
+  const parts = input.split(";");
+  let _ = parts.pop();
+  const srid = (parts.shift() || "").split("=").pop();
+  const state = { parts, _, i: 0 };
+  const geometry = parseGeometry(state);
+  white(state);
+  if (!geometry || state.i !== ((_a = state._) == null ? void 0 : _a.length)) {
+    return null;
+  }
+  return ((_b = options == null ? void 0 : options.wkt) == null ? void 0 : _b.crs) ? addCRS(geometry, srid) : geometry;
+}
+function parseGeometry(state) {
+  var _a;
+  const startIndex = state.i;
+  const geometry = parsePoint(state) || parseLineString(state) || parsePolygon(state) || parseMultiPoint(state) || parseMultiLineString(state) || parseMultiPolygon(state) || parseGeometryCollection(state);
+  if (geometry) {
+    const geometryText = ((_a = state._) == null ? void 0 : _a.substring(startIndex, state.i)) || "";
+    const dimension = getWKTDimension(geometryText);
+    const hasExplicitDimension = /\s+(?:ZM|Z|M)\s*(?:\(|EMPTY\b)/i.test(geometryText);
+    if (!hasValidCoordinateArity(geometry, hasExplicitDimension ? dimension : null)) {
+      return null;
+    }
+    if (hasExplicitDimension && dimension && dimension !== "xy") {
+      Object.defineProperty(geometry, "__geoarrowDimension", {
+        configurable: true,
+        enumerable: false,
+        value: dimension
+      });
+    }
+  }
+  return geometry;
+}
+function hasValidCoordinateArity(geometry, dimension) {
+  const coordinateSize = dimension === null ? null : dimension === "xy" ? 2 : dimension === "xyzm" ? 4 : 3;
+  let inferredCoordinateSize = null;
+  const isValidCoordinate = (coordinate) => {
+    if (!Array.isArray(coordinate)) return false;
+    if (coordinate.length === 0) return true;
+    if (!coordinate.every((value) => typeof value === "number" && Number.isFinite(value))) {
+      return false;
+    }
+    if (coordinateSize !== null) return coordinate.length === coordinateSize;
+    if (coordinate.length < 2 || coordinate.length > 4) return false;
+    if (inferredCoordinateSize === null) inferredCoordinateSize = coordinate.length;
+    return coordinate.length === inferredCoordinateSize;
+  };
+  const isValidCoordinateList = (coordinates) => Array.isArray(coordinates) && coordinates.every(isValidCoordinate);
+  const isValidRingList = (rings) => Array.isArray(rings) && rings.every(isValidCoordinateList);
+  switch (geometry.type) {
+    case "Point":
+      return isValidCoordinate(geometry.coordinates);
+    case "LineString":
+      return isValidCoordinateList(geometry.coordinates);
+    case "Polygon":
+      return isValidRingList(geometry.coordinates);
+    case "MultiPoint":
+      return isValidCoordinateList(geometry.coordinates);
+    case "MultiLineString":
+      return isValidRingList(geometry.coordinates);
+    case "MultiPolygon":
+      return Array.isArray(geometry.coordinates) && geometry.coordinates.every(isValidRingList);
+    case "GeometryCollection":
+      return true;
+    default:
+      return false;
+  }
+}
+function addCRS(obj, srid) {
+  if (obj && (srid == null ? void 0 : srid.match(/\d+/))) {
+    const crs = {
+      type: "name",
+      properties: {
+        name: "urn:ogc:def:crs:EPSG::" + srid
+      }
+    };
+    obj.crs = crs;
+  }
+  return obj;
+}
+function parsePoint(state) {
+  if (!$(/^(POINT(?:\s+(?:ZM|Z|M))?)/i, state)) {
+    return null;
+  }
+  white(state);
+  if ($(/^(EMPTY)\b/i, state)) {
+    return { type: "Point", coordinates: [] };
+  }
+  if (!$(/^(\()/, state)) {
+    return null;
+  }
+  const c = coords(state);
+  if (!c) {
+    return null;
+  }
+  white(state);
+  if (!$(/^(\))/, state)) {
+    return null;
+  }
+  return {
+    type: "Point",
+    coordinates: c[0]
+  };
+}
+function parseMultiPoint(state) {
+  var _a;
+  if (!$(/^(MULTIPOINT(?:\s+(?:ZM|Z|M))?)/i, state)) {
+    return null;
+  }
+  white(state);
+  if ($(/^(EMPTY)\b/i, state)) {
+    return { type: "MultiPoint", coordinates: [] };
+  }
+  if (!$(/^(\()/, state)) {
+    return null;
+  }
+  const coordinates = [];
+  white(state);
+  const isParenthesized = (_a = state._) == null ? void 0 : _a.substring(state.i).startsWith("(");
+  if (isParenthesized) {
+    while (true) {
+      if (!$(/^(\()/, state)) return null;
+      const coordinate = coords(state);
+      if (!coordinate || coordinate.length !== 1 || !$(/^(\))/, state)) return null;
+      coordinates.push(coordinate[0]);
+      white(state);
+      if (!$(/^(,)/, state)) break;
+      white(state);
+    }
+  } else {
+    const coordinateList = coords(state);
+    if (!coordinateList) return null;
+    coordinates.push(...coordinateList);
+  }
+  white(state);
+  if (!$(/^(\))/, state)) return null;
+  return {
+    type: "MultiPoint",
+    coordinates
+  };
+}
+function parseLineString(state) {
+  if (!$(/^(LINESTRING(?:\s+(?:ZM|Z|M))?)/i, state)) {
+    return null;
+  }
+  white(state);
+  if ($(/^(EMPTY)\b/i, state)) {
+    return { type: "LineString", coordinates: [] };
+  }
+  if (!$(/^(\()/, state)) {
+    return null;
+  }
+  const c = coords(state);
+  if (!c) {
+    return null;
+  }
+  if (!$(/^(\))/, state)) {
+    return null;
+  }
+  return {
+    type: "LineString",
+    coordinates: c
+  };
+}
+function parseMultiLineString(state) {
+  if (!$(/^(MULTILINESTRING(?:\s+(?:ZM|Z|M))?)/i, state)) return null;
+  white(state);
+  if ($(/^(EMPTY)\b/i, state)) {
+    return { type: "MultiLineString", coordinates: [] };
+  }
+  const c = multicoords(state);
+  if (!c) {
+    return null;
+  }
+  white(state);
+  return {
+    // @ts-ignore
+    type: "MultiLineString",
+    // @ts-expect-error
+    coordinates: c
+  };
+}
+function parsePolygon(state) {
+  if (!$(/^(POLYGON(?:\s+(?:ZM|Z|M))?)/i, state)) {
+    return null;
+  }
+  white(state);
+  if ($(/^(EMPTY)\b/i, state)) {
+    return { type: "Polygon", coordinates: [] };
+  }
+  const c = multicoords(state);
+  if (!c) {
+    return null;
+  }
+  return {
+    // @ts-ignore
+    type: "Polygon",
+    // @ts-expect-error
+    coordinates: c
+  };
+}
+function parseMultiPolygon(state) {
+  if (!$(/^(MULTIPOLYGON(?:\s+(?:ZM|Z|M))?)/i, state)) {
+    return null;
+  }
+  white(state);
+  if ($(/^(EMPTY)\b/i, state)) {
+    return { type: "MultiPolygon", coordinates: [] };
+  }
+  const c = multicoords(state);
+  if (!c) {
+    return null;
+  }
+  return {
+    type: "MultiPolygon",
+    // @ts-expect-error
+    coordinates: c
+  };
+}
+function parseGeometryCollection(state) {
+  const geometries = [];
+  let geometry;
+  if (!$(/^(GEOMETRYCOLLECTION(?:\s+(?:ZM|Z|M))?)/i, state)) {
+    return null;
+  }
+  white(state);
+  if ($(/^(EMPTY)\b/i, state)) {
+    return { type: "GeometryCollection", geometries: [] };
+  }
+  if (!$(/^(\()/, state)) {
+    return null;
+  }
+  geometry = parseGeometry(state);
+  while (geometry) {
+    geometries.push(geometry);
+    white(state);
+    $(/^(,)/, state);
+    white(state);
+    geometry = parseGeometry(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;
+  elem = $(/^(\()/, state) || $(/^(\))/, state) || $(/^(,)/, state) || $(tuples, state);
+  while (elem) {
+    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(Number.isNaN)) {
+      Array.prototype.push.apply(pointer, elem.split(/\s/g).map(parseFloat));
+    } else {
+      return null;
+    }
+    white(state);
+    elem = $(/^(\()/, state) || $(/^(\))/, state) || $(/^(,)/, state) || $(tuples, state);
+  }
+  if (depth !== 0) return null;
+  return rings;
+}
+function coords(state) {
+  const list = [];
+  let item;
+  let pt;
+  pt = $(tuples, state) || $(/^(,)/, state);
+  while (pt) {
+    if (pt === ",") {
+      list.push(item);
+      item = [];
+    } else if (!pt.split(/\s/g).some(Number.isNaN)) {
+      if (!item) item = [];
+      Array.prototype.push.apply(item, pt.split(/\s/g).map(parseFloat));
+    }
+    white(state);
+    pt = $(tuples, state) || $(/^(,)/, state);
+  }
+  if (item) list.push(item);
+  else return null;
+  return list.length ? list : null;
+}
+function $(regexp, state) {
+  var _a;
+  const match = (_a = state._) == null ? void 0 : _a.substring(state.i).match(regexp);
+  if (!match) return null;
+  else {
+    state.i += match[0].length;
+    return match[0];
+  }
+}
+function white(state) {
+  $(/^\s*/, state);
+}
+var numberRegexp, tuples;
+var init_convert_wkt_to_geometry = __esm({
+  "../gis/src/lib/geometry-converters/wkb/convert-wkt-to-geometry.ts"() {
+    "use strict";
+    numberRegexp = /[-+]?([0-9]*\.[0-9]+|[0-9]+)([eE][-+]?[0-9]+)?/;
+    tuples = new RegExp("^" + numberRegexp.source + "(\\s" + numberRegexp.source + "){1,}");
+  }
+});
+
+// ../gis/src/lib/geometry-converters/wkb/get-wkb-geometry-statistics.ts
+function getWKBGeometryStatistics(input) {
+  const statistics = (0, import_wkb2.scanWKB)(input);
+  return {
+    geometryType: getGeometryTypeCode(statistics.header.geometryType) + getDimensionOffset(statistics.header.dimension),
+    ...statistics.bounds ? { bbox: { ...statistics.bounds } } : {}
+  };
+}
+function getGeometryTypeCode(geometryType) {
+  return [
+    "Point",
+    "LineString",
+    "Polygon",
+    "MultiPoint",
+    "MultiLineString",
+    "MultiPolygon",
+    "GeometryCollection"
+  ].indexOf(geometryType) + 1;
+}
+function getDimensionOffset(dimension) {
+  return dimension === "xyz" ? 1e3 : dimension === "xym" ? 2e3 : dimension === "xyzm" ? 3e3 : 0;
+}
+var import_wkb2;
+var init_get_wkb_geometry_statistics = __esm({
+  "../gis/src/lib/geometry-converters/wkb/get-wkb-geometry-statistics.ts"() {
+    "use strict";
+    import_wkb2 = require("@math.gl/wkb");
+  }
+});
+
+// ../gis/src/lib/geoarrow/metadata-utils.ts
+var init_metadata_utils = __esm({
+  "../gis/src/lib/geoarrow/metadata-utils.ts"() {
+    "use strict";
+    init_src3();
+  }
+});
+
+// ../gis/src/lib/geoarrow/geoparquet-metadata.ts
+function getGeoMetadata2(metadata) {
+  if (!metadata) {
+    return null;
+  }
+  const stringifiedGeoMetadata = getMetadataValue(metadata, "geo");
+  const geoMetadata = stringifiedGeoMetadata && parseJSONStringMetadata2(stringifiedGeoMetadata);
+  if (!geoMetadata) {
+    return null;
+  }
+  for (const column of Object.values(geoMetadata.columns || {})) {
+    if (column.encoding) {
+      column.encoding = column.encoding.toLowerCase();
+    }
+  }
+  return geoMetadata;
+}
+function parseJSONStringMetadata2(stringifiedMetadata) {
+  if (!stringifiedMetadata) {
+    return null;
+  }
+  try {
+    const metadata = JSON.parse(stringifiedMetadata);
+    if (!metadata || typeof metadata !== "object") {
+      return null;
+    }
+    return metadata;
+  } catch {
+    return null;
+  }
+}
+var init_geoparquet_metadata = __esm({
+  "../gis/src/lib/geoarrow/geoparquet-metadata.ts"() {
+    "use strict";
+    init_metadata_utils();
+  }
+});
+
+// ../gis/src/lib/table-converters/convert-wkb-table-to-geojson.ts
+function convertWKBTableToGeoJSON(table, schema) {
+  var _a;
+  const geoMetadata = getGeoMetadata2(schema.metadata);
+  const primaryColumn = geoMetadata == null ? void 0 : geoMetadata.primary_column;
+  if (!primaryColumn) {
+    throw new Error("no geometry column");
+  }
+  const columnMetadata = (_a = geoMetadata.columns) == null ? void 0 : _a[primaryColumn];
+  if (!columnMetadata) {
+    throw new Error(`missing metadata for geometry column "${primaryColumn}"`);
+  }
+  const features = [];
+  const length = getTableLength(table);
+  for (let rowIndex = 0; rowIndex < length; rowIndex++) {
+    const row = getTableRowAsObject(table, rowIndex);
+    const geometry = parseGeometry2(row[primaryColumn], columnMetadata);
+    delete row[primaryColumn];
+    features.push({ type: "Feature", geometry, properties: row });
+  }
+  return { shape: "geojson-table", schema, type: "FeatureCollection", features };
+}
+function parseGeometry2(geometry, columnMetadata) {
+  var _a;
+  switch ((_a = columnMetadata.encoding) == null ? void 0 : _a.toLowerCase()) {
+    case "wkt":
+      return convertWKTToGeometry(geometry) || null;
+    case "wkb":
+    default: {
+      const arrayBuffer = ArrayBuffer.isView(geometry) ? geometry.buffer.slice(geometry.byteOffset, geometry.byteOffset + geometry.byteLength) : geometry;
+      return convertWKBToGeometry(arrayBuffer);
+    }
+  }
+}
+var init_convert_wkb_table_to_geojson = __esm({
+  "../gis/src/lib/table-converters/convert-wkb-table-to-geojson.ts"() {
+    "use strict";
+    init_src4();
+    init_geoparquet_metadata();
+    init_convert_wkb_to_geometry();
+    init_convert_wkt_to_geometry();
+  }
+});
+
+// ../gis/src/deprecated.ts
+var convertWKBTableToGeoJSON2;
+var init_deprecated2 = __esm({
+  "../gis/src/deprecated.ts"() {
+    "use strict";
+    init_convert_wkb_table_to_geojson();
+    convertWKBTableToGeoJSON2 = ((...args) => convertWKBTableToGeoJSON(
+      ...args
+    ));
+  }
+});
+
+// ../gis/src/index.ts
 var init_src5 = __esm({
+  "../gis/src/index.ts"() {
+    "use strict";
+    init_get_wkb_geometry_statistics();
+    init_geoparquet_metadata();
+    init_deprecated2();
+  }
+});
+
+// ../arrow/src/index.ts
+var init_src6 = __esm({
   "../arrow/src/index.ts"() {
     "use strict";
     init_indexed_arrow_table();
@@ -6251,7 +6235,7 @@ function isSerializedArrowTable(value) {
 var init_parquet_worker_transport = __esm({
   "src/lib/parquet-worker-transport.ts"() {
     "use strict";
-    init_src5();
+    init_src6();
   }
 });
 
@@ -6596,10 +6580,11 @@ function getGeoArrowMetadataFromGeoParquetField2(field, columnMetadata) {
   if (!extensionName) {
     return null;
   }
-  if (normalizedEncoding === "wkb" && field.type !== "binary") {
+  const isBinaryGeospatialEncoding = normalizedEncoding === "wkb" || normalizedEncoding === "geometry" || normalizedEncoding === "geography";
+  if (isBinaryGeospatialEncoding && !isBinaryFieldType2(field.type)) {
     return null;
   }
-  if (normalizedEncoding !== "wkb" && (field.type === "binary" || field.type === "utf8")) {
+  if (!isBinaryGeospatialEncoding && (isBinaryFieldType2(field.type) || isStringFieldType2(field.type))) {
     return null;
   }
   const extensionMetadata = {};
@@ -6613,6 +6598,14 @@ function getGeoArrowMetadataFromGeoParquetField2(field, columnMetadata) {
   if (columnMetadata.edges && columnMetadata.edges !== "planar") {
     extensionMetadata.edges = columnMetadata.edges;
   }
+  if (normalizedEncoding === "geography" && !extensionMetadata.edges) {
+    extensionMetadata.edges = "spherical";
+  }
+  for (const [metadataKey, metadataValue] of Object.entries(columnMetadata)) {
+    if (metadataValue !== void 0 && metadataValue !== null && !["encoding", "geometry_types", "crs", "edges"].includes(metadataKey)) {
+      extensionMetadata[metadataKey] = metadataValue;
+    }
+  }
   return Object.keys(extensionMetadata).length > 0 ? { extensionName, extensionMetadata } : { extensionName };
 }
 function isValidGeoParquetMetadata(geoMetadata) {
@@ -6628,6 +6621,7 @@ function synthesizeGeoParquetColumnMetadata(geometryMetadata) {
     encoding,
     geometry_types: geometryTypes
   };
+  const preservedMetadata = preserveUnknownGeoParquetColumnMetadata(geometryMetadata);
   if (geometryMetadata.crs === void 0) {
     columnMetadata.crs = null;
   } else if (typeof geometryMetadata.crs === "object") {
@@ -6638,7 +6632,7 @@ function synthesizeGeoParquetColumnMetadata(geometryMetadata) {
   if (geometryMetadata.edges) {
     columnMetadata.edges = geometryMetadata.edges;
   }
-  return columnMetadata;
+  return { ...preservedMetadata, ...columnMetadata };
 }
 function isDefaultCRS84Identifier(crs) {
   const normalizedCRS = crs.toUpperCase();
@@ -6652,7 +6646,7 @@ function pickValidOptionalGeoParquetColumnMetadata(columnMetadata) {
   if (!columnMetadata) {
     return {};
   }
-  const nextColumnMetadata = {};
+  const nextColumnMetadata = preserveUnknownGeoParquetColumnMetadata(columnMetadata);
   if (columnMetadata.orientation === "counterclockwise") {
     nextColumnMetadata.orientation = columnMetadata.orientation;
   }
@@ -6667,6 +6661,33 @@ function pickValidOptionalGeoParquetColumnMetadata(columnMetadata) {
   }
   return nextColumnMetadata;
 }
+function preserveUnknownGeoParquetColumnMetadata(columnMetadata) {
+  if (!columnMetadata) {
+    return {};
+  }
+  const preservedMetadata = {};
+  for (const [metadataKey, metadataValue] of Object.entries(columnMetadata)) {
+    if (metadataValue !== void 0 && ![
+      "encoding",
+      "geometry_types",
+      "crs",
+      "edges",
+      "orientation",
+      "bbox",
+      "epoch",
+      "covering"
+    ].includes(metadataKey)) {
+      preservedMetadata[metadataKey] = metadataValue;
+    }
+  }
+  return preservedMetadata;
+}
+function isBinaryFieldType2(fieldType) {
+  return typeof fieldType === "string" && (fieldType === "binary" || fieldType === "binary-view");
+}
+function isStringFieldType2(fieldType) {
+  return typeof fieldType === "string" && (fieldType === "utf8" || fieldType === "utf8-view");
+}
 function isValidBBox(bbox) {
   if (!Array.isArray(bbox) || ![4, 6, 8].includes(bbox.length)) {
     return false;
@@ -6696,9 +6717,9 @@ var init_geospatial_metadata2 = __esm({
   "dist/lib/geo/geospatial-metadata.js"() {
     "use strict";
     arrow9 = __toESM(require("apache-arrow"), 1);
-    init_src4();
-    init_geospatial_metadata_zod_schema();
     init_src3();
+    init_geospatial_metadata_zod_schema();
+    init_src4();
     GEOARROW_EXTENSION_NAME_KEY2 = "ARROW:extension:name";
     GEOARROW_EXTENSION_METADATA_KEY2 = "ARROW:extension:metadata";
     GEOPARQUET_VERSION = "1.1.0";
@@ -6717,6 +6738,8 @@ var init_geospatial_metadata2 = __esm({
     ];
     GEOPARQUET_TO_GEOARROW_ENCODINGS2 = {
       wkb: "geoarrow.wkb",
+      geometry: "geoarrow.wkb",
+      geography: "geoarrow.wkb",
       point: "geoarrow.point",
       linestring: "geoarrow.linestring",
       polygon: "geoarrow.polygon",
@@ -7030,7 +7053,7 @@ function convertArrowBatchToObjectRows2(batch) {
 var init_convert_parquet_tables2 = __esm({
   "dist/lib/parsers/convert-parquet-tables.js"() {
     "use strict";
-    init_src3();
+    init_src4();
   }
 });
 
@@ -7075,8 +7098,8 @@ function convertGeoParquetArrowBatch(batch) {
 var init_parse_geoparquet_to_geojson = __esm({
   "dist/lib/parsers/parse-geoparquet-to-geojson.js"() {
     "use strict";
+    init_src5();
     init_src4();
-    init_src3();
     init_parse_parquet_tables();
   }
 });
@@ -7135,7 +7158,7 @@ function isSerializedArrowTable2(value) {
 var init_parquet_worker_transport2 = __esm({
   "dist/lib/parquet-worker-transport.js"() {
     "use strict";
-    init_src5();
+    init_src6();
   }
 });
 
@@ -7255,7 +7278,7 @@ var init_geoparquet_loader = __esm({
     "use strict";
     init_parquet_format();
     init_parquet_loader_options();
-    VERSION5 = true ? "5.0.0-alpha.4" : "latest";
+    VERSION5 = true ? "5.0.0-alpha.6" : "latest";
     GeoParquetLoader = {
       ...ParquetFormat,
       dataType: null,
@@ -7321,26 +7344,26 @@ function encodeUtf8(text) {
 function decodeString(binary, start = 0, end = binary.length) {
   return decodeUtf8(binary.subarray(start, end));
 }
-function getDataView2(binary) {
+function getDataView(binary) {
   return new DataView(binary.buffer, binary.byteOffset, binary.byteLength);
 }
 function readInt32LE(binary, offset) {
-  return getDataView2(binary).getInt32(offset, true);
+  return getDataView(binary).getInt32(offset, true);
 }
 function readUInt32LE(binary, offset) {
-  return getDataView2(binary).getUint32(offset, true);
+  return getDataView(binary).getUint32(offset, true);
 }
 function readInt64LE(binary, offset) {
-  return getDataView2(binary).getBigInt64(offset, true);
+  return getDataView(binary).getBigInt64(offset, true);
 }
 function readUInt64LE(binary, offset) {
-  return getDataView2(binary).getBigUint64(offset, true);
+  return getDataView(binary).getBigUint64(offset, true);
 }
 function readFloatLE(binary, offset) {
-  return getDataView2(binary).getFloat32(offset, true);
+  return getDataView(binary).getFloat32(offset, true);
 }
 function readDoubleLE(binary, offset) {
-  return getDataView2(binary).getFloat64(offset, true);
+  return getDataView(binary).getFloat64(offset, true);
 }
 function concatUint8Arrays(chunks) {
   let byteLength = 0;
@@ -7356,19 +7379,19 @@ function concatUint8Arrays(chunks) {
   return result;
 }
 function writeInt32LE(binary, value, offset) {
-  getDataView2(binary).setInt32(offset, value, true);
+  getDataView(binary).setInt32(offset, value, true);
 }
 function writeUInt32LE(binary, value, offset) {
-  getDataView2(binary).setUint32(offset, value, true);
+  getDataView(binary).setUint32(offset, value, true);
 }
 function writeInt64LE(binary, value, offset) {
-  getDataView2(binary).setBigInt64(offset, BigInt(value), true);
+  getDataView(binary).setBigInt64(offset, BigInt(value), true);
 }
 function writeFloatLE(binary, value, offset) {
-  getDataView2(binary).setFloat32(offset, value, true);
+  getDataView(binary).setFloat32(offset, value, true);
 }
 function writeDoubleLE(binary, value, offset) {
-  getDataView2(binary).setFloat64(offset, value, true);
+  getDataView(binary).setFloat64(offset, value, true);
 }
 var TEXT_DECODER, TEXT_ENCODER;
 var init_binary_utils = __esm({
@@ -12874,7 +12897,7 @@ var init_default_codecs = __esm({
 });
 
 // ../compression/src/index.ts
-var init_src6 = __esm({
+var init_src7 = __esm({
   "../compression/src/index.ts"() {
     "use strict";
     init_compression();
@@ -12987,7 +13010,7 @@ var PARQUET_COMPRESSION_METHODS, ParquetSnappyDecompressor;
 var init_compression2 = __esm({
   "src/parquetjs/compression.ts"() {
     "use strict";
-    init_src6();
+    init_src7();
     init_snappy_decompressor_hysnappy();
     init_src2();
     init_binary_utils();
@@ -13151,7 +13174,7 @@ var init_parse_bson = __esm({
 });
 
 // ../bson/src/index.ts
-var init_src7 = __esm({
+var init_src8 = __esm({
   "../bson/src/index.ts"() {
     "use strict";
     init_bson_writer();
@@ -13560,7 +13583,7 @@ var PARQUET_LOGICAL_TYPES, kMillisPerDay;
 var init_types = __esm({
   "src/parquetjs/schema/types.ts"() {
     "use strict";
-    init_src7();
+    init_src8();
     init_binary_utils();
     PARQUET_LOGICAL_TYPES = {
       BOOLEAN: {
@@ -23288,7 +23311,7 @@ async function getSchemaFromParquetReader(reader) {
 var init_get_parquet_schema = __esm({
   "src/lib/parsers/get-parquet-schema.ts"() {
     "use strict";
-    init_src4();
+    init_src3();
     init_convert_schema_from_parquet();
     init_geospatial_metadata();
   }
@@ -24699,7 +24722,7 @@ var init_parse_parquet_to_arrow_js = __esm({
   "src/lib/parsers/parse-parquet-to-arrow-js.ts"() {
     "use strict";
     arrow12 = __toESM(require("apache-arrow"), 1);
-    init_src3();
+    init_src4();
     init_compression2();
     init_parquet_reader();
     init_shred();
@@ -24950,7 +24973,7 @@ function doLongitudeIntervalsIntersect(firstWest, firstEast, secondWest, secondE
 var init_geoparquet_covering = __esm({
   "src/lib/geo/geoparquet-covering.ts"() {
     "use strict";
-    init_src4();
+    init_src3();
   }
 });
 
@@ -25963,7 +25986,7 @@ function resolveParquetSourceWorkerUrl() {
   }
 }
 function getParquetSourceWorkerFile() {
-  return "./parquet-source-worker.js";
+  return "../dist/parquet-source-worker.js";
 }
 var import_meta5, PARQUET_SOURCE_WORKER_URL;
 var init_parquet_source_worker_url = __esm({
@@ -27029,10 +27052,10 @@ var _preloadParquetSourceLoader, _createMetadataDataSource, ParquetSourceLoaderB
 var init_parquet_source_loader = __esm({
   "src/parquet-source-loader.ts"() {
     "use strict";
-    init_src5();
+    init_src6();
     init_src2();
-    init_src3();
     init_src4();
+    init_src5();
     init_get_parquet_schema();
     init_geoparquet_covering();
     init_parquet_bloom_filter();
@@ -27215,7 +27238,7 @@ var init_parquet_source_loader = __esm({
           );
           const projectedColumns = normalizeColumns(readOptions.columns, initialization.schema);
           const predicateColumns = physicalPlan.predicate ? getParquetPredicateColumns(physicalPlan.predicate) : [];
-          const geoMetadata = readOptions.bbox ? getGeoMetadata(initialization.schema.metadata) : void 0;
+          const geoMetadata = readOptions.bbox ? getGeoMetadata2(initialization.schema.metadata) : void 0;
           const geometryColumn = readOptions.bbox ? readOptions.geometryColumn || (geoMetadata == null ? void 0 : geoMetadata.primary_column) : void 0;
           const filterColumns = [
             .../* @__PURE__ */ new Set([...predicateColumns, ...geometryColumn ? [geometryColumn] : []])
@@ -28077,7 +28100,7 @@ init_geoparquet_loader();
 
 // dist/parquet-js-loader-types.js
 init_parquet_format();
-var VERSION8 = true ? "5.0.0-alpha.4" : "latest";
+var VERSION8 = true ? "5.0.0-alpha.6" : "latest";
 var DEFAULT_PARQUET_JS_OPTIONS3 = {
   columns: void 0,
   preserveBinary: false,
@@ -28104,7 +28127,7 @@ var ParquetJSLoader2 = {
 
 // dist/parquet-source-loader-types.js
 init_parquet_format();
-var VERSION10 = true ? "5.0.0-alpha.4" : "latest";
+var VERSION10 = true ? "5.0.0-alpha.6" : "latest";
 async function preloadParquetSourceLoader2() {
   const { ParquetSourceLoaderWithParser: ParquetSourceLoaderWithParser2 } = await Promise.resolve().then(() => (init_parquet_source_loader(), parquet_source_loader_exports));
   return ParquetSourceLoaderWithParser2;
@@ -28204,7 +28227,7 @@ var PARQUET_SOURCE_CAPABILITIES2 = Object.freeze({
 });
 
 // dist/parquet-writer.js
-init_src3();
+init_src4();
 
 // dist/lib/encoders/encode-arrow-to-parquet.js
 var arrow13 = __toESM(require("apache-arrow"), 1);
@@ -28228,7 +28251,7 @@ init_normalize_parquet_options2();
 init_parquet_format();
 
 // dist/lib/constants.js
-var VERSION11 = true ? "5.0.0-alpha.4" : "latest";
+var VERSION11 = true ? "5.0.0-alpha.6" : "latest";
 var PARQUET_MAGIC2 = "PAR1";
 var PARQUET_MAGIC_ENCRYPTED2 = "PARE";
 var PARQUET_RDLVL_TYPE2 = "INT32";
@@ -28251,11 +28274,11 @@ var ParquetWriter = {
 };
 
 // dist/parquet-js-writer.js
-init_src3();
+init_src4();
 init_normalize_parquet_options2();
 
 // dist/lib/encoders/encode-table-to-parquet-js.js
-init_src4();
+init_src3();
 
 // dist/parquetjs/utils/binary-utils.js
 var TEXT_DECODER2 = new TextDecoder();
@@ -28285,26 +28308,26 @@ function encodeUtf82(text) {
 function decodeString2(binary, start = 0, end = binary.length) {
   return decodeUtf82(binary.subarray(start, end));
 }
-function getDataView3(binary) {
+function getDataView2(binary) {
   return new DataView(binary.buffer, binary.byteOffset, binary.byteLength);
 }
 function readInt32LE2(binary, offset) {
-  return getDataView3(binary).getInt32(offset, true);
+  return getDataView2(binary).getInt32(offset, true);
 }
 function readUInt32LE2(binary, offset) {
-  return getDataView3(binary).getUint32(offset, true);
+  return getDataView2(binary).getUint32(offset, true);
 }
 function readInt64LE2(binary, offset) {
-  return getDataView3(binary).getBigInt64(offset, true);
+  return getDataView2(binary).getBigInt64(offset, true);
 }
 function readUInt64LE2(binary, offset) {
-  return getDataView3(binary).getBigUint64(offset, true);
+  return getDataView2(binary).getBigUint64(offset, true);
 }
 function readFloatLE2(binary, offset) {
-  return getDataView3(binary).getFloat32(offset, true);
+  return getDataView2(binary).getFloat32(offset, true);
 }
 function readDoubleLE2(binary, offset) {
-  return getDataView3(binary).getFloat64(offset, true);
+  return getDataView2(binary).getFloat64(offset, true);
 }
 function concatUint8Arrays2(chunks) {
   let byteLength = 0;
@@ -28320,23 +28343,23 @@ function concatUint8Arrays2(chunks) {
   return result;
 }
 function writeInt32LE2(binary, value, offset) {
-  getDataView3(binary).setInt32(offset, value, true);
+  getDataView2(binary).setInt32(offset, value, true);
 }
 function writeUInt32LE2(binary, value, offset) {
-  getDataView3(binary).setUint32(offset, value, true);
+  getDataView2(binary).setUint32(offset, value, true);
 }
 function writeInt64LE2(binary, value, offset) {
-  getDataView3(binary).setBigInt64(offset, BigInt(value), true);
+  getDataView2(binary).setBigInt64(offset, BigInt(value), true);
 }
 function writeFloatLE2(binary, value, offset) {
-  getDataView3(binary).setFloat32(offset, value, true);
+  getDataView2(binary).setFloat32(offset, value, true);
 }
 function writeDoubleLE2(binary, value, offset) {
-  getDataView3(binary).setFloat64(offset, value, true);
+  getDataView2(binary).setFloat64(offset, value, true);
 }
 
 // dist/parquetjs/encoder/parquet-encoder.js
-init_src4();
+init_src5();
 
 // dist/parquetjs/codecs/declare.js
 function reserveParquetByteArrayOutput2(output, additionalByteLength) {
@@ -30230,7 +30253,7 @@ var PARQUET_CODECS2 = {
 };
 
 // dist/parquetjs/compression.js
-init_src6();
+init_src7();
 init_snappy_decompressor_hysnappy();
 init_src2();
 var PARQUET_COMPRESSION_METHODS2 = {
@@ -30350,7 +30373,7 @@ function createParquetDecompressor2(method) {
 }
 
 // dist/parquetjs/schema/types.js
-init_src7();
+init_src8();
 var PARQUET_LOGICAL_TYPES2 = {
   BOOLEAN: {
     primitiveType: "BOOLEAN",
@@ -39091,7 +39114,7 @@ function formatDataType(dataType) {
 
 // dist/parquet-js-writer.js
 init_parquet_format();
-var VERSION12 = true ? "5.0.0-alpha.4" : "latest";
+var VERSION12 = true ? "5.0.0-alpha.6" : "latest";
 var DEFAULT_PARQUET_JS_OPTIONS4 = {};
 var ParquetJSWriter = {
   ...ParquetFormat,