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

package/dist/hudi.cjs

@@ -424,6 +424,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;
@@ -434,11 +438,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();
@@ -484,7 +490,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 `;
         }
@@ -497,8 +503,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"));
@@ -557,6 +581,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 = () => {
@@ -578,6 +606,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);
       }
       /**
@@ -687,7 +717,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;
       }
@@ -699,7 +735,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";
@@ -712,6 +763,8 @@ var init_worker_farm = __esm({
       onDebug: () => {
       }
     };
+    loadWorkerIds = /* @__PURE__ */ new WeakMap();
+    nextLoadWorkerId = 1;
     WorkerFarm = class _WorkerFarm {
       props;
       workerPools = /* @__PURE__ */ new Map();
@@ -755,24 +808,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;
       }
@@ -793,35 +850,42 @@ function getWorkerName(worker) {
   const warning = worker.version !== VERSION2 ? ` (worker-utils@${VERSION2})` : "";
   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) {
@@ -855,19 +919,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,
@@ -910,6 +971,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":
@@ -942,6 +1021,7 @@ var init_process_on_worker = __esm({
     init_worker_farm();
     init_get_worker_url();
     init_get_transfer_list();
+    init_globals2();
   }
 });
 
@@ -975,7 +1055,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) {
@@ -1008,12 +1088,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) {
@@ -3135,6 +3222,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 {
@@ -3148,6 +3241,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 {
@@ -3176,6 +3278,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);
@@ -3188,6 +3294,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),
@@ -3825,8 +3938,85 @@ var init_deprecated = __esm({
   }
 });
 
-// ../schema-utils/src/index.ts
+// ../schema/src/metadata.ts
+function getMetadataValue(metadata, key) {
+  return metadata instanceof Map ? metadata.get(key) || null : metadata[key] || null;
+}
+function setMetadataValue(metadata, key, value) {
+  if (metadata instanceof Map) {
+    metadata.set(key, value);
+  } else {
+    metadata[key] = value;
+  }
+}
+function getGeoMetadata(metadata) {
+  if (!metadata) {
+    return null;
+  }
+  const stringifiedGeoMetadata = getMetadataValue(metadata, "geo");
+  const geoMetadata = stringifiedGeoMetadata && parseJSONStringMetadata(stringifiedGeoMetadata);
+  if (!geoMetadata) {
+    return null;
+  }
+  for (const column of Object.values(geoMetadata.columns || {})) {
+    if (column && typeof column === "object" && typeof column.encoding === "string") {
+      column.encoding = column.encoding.toLowerCase();
+    }
+  }
+  return geoMetadata;
+}
+function unpackGeoMetadata(metadata) {
+  const geoMetadata = getGeoMetadata(metadata);
+  if (!geoMetadata) {
+    return;
+  }
+  const { version: version2, primary_column: primaryColumn, columns } = geoMetadata;
+  if (version2) {
+    setMetadataValue(metadata, "geo.version", version2);
+  }
+  if (primaryColumn) {
+    setMetadataValue(metadata, "geo.primary_column", primaryColumn);
+  }
+  setMetadataValue(metadata, "geo.columns", Object.keys(columns || {}).join(","));
+}
+function unpackJSONStringMetadata(metadata, metadataKey) {
+  const stringifiedMetadata = getMetadataValue(metadata, metadataKey);
+  const json = stringifiedMetadata && parseJSONStringMetadata(stringifiedMetadata);
+  for (const [key, value] of Object.entries(json || {})) {
+    setMetadataValue(
+      metadata,
+      `${metadataKey}.${key}`,
+      typeof value === "string" ? value : JSON.stringify(value)
+    );
+  }
+}
+function parseJSONStringMetadata(stringifiedMetadata) {
+  if (!stringifiedMetadata) {
+    return null;
+  }
+  try {
+    const metadata = JSON.parse(stringifiedMetadata);
+    return metadata && typeof metadata === "object" ? metadata : null;
+  } catch {
+    return null;
+  }
+}
+var init_metadata = __esm({
+  "../schema/src/metadata.ts"() {
+    "use strict";
+  }
+});
+
+// ../schema/src/index.ts
 var init_src3 = __esm({
+  "../schema/src/index.ts"() {
+    "use strict";
+    init_metadata();
+  }
+});
+
+// ../schema-utils/src/index.ts
+var init_src4 = __esm({
   "../schema-utils/src/index.ts"() {
     "use strict";
     init_convert_arrow_schema();
@@ -4815,35 +5005,26 @@ var init_arrow_table_transport = __esm({
   "../arrow/src/lib/utils/arrow-table-transport.ts"() {
     "use strict";
     arrow6 = __toESM(require("apache-arrow"), 1);
-    init_src3();
+    init_src4();
     init_split_arrow_buffers();
   }
 });
 
 // ../gis/src/lib/geoarrow/metadata-utils.ts
-function getMetadataValue(metadata, key) {
-  return metadata instanceof Map ? metadata.get(key) || null : metadata[key] || null;
-}
-function setMetadataValue(metadata, key, value) {
-  if (metadata instanceof Map) {
-    metadata.set(key, value);
-  } else {
-    metadata[key] = value;
-  }
-}
 var init_metadata_utils = __esm({
   "../gis/src/lib/geoarrow/metadata-utils.ts"() {
     "use strict";
+    init_src3();
   }
 });
 
 // ../gis/src/lib/geoarrow/geoparquet-metadata.ts
-function getGeoMetadata(metadata) {
+function getGeoMetadata2(metadata) {
   if (!metadata) {
     return null;
   }
   const stringifiedGeoMetadata = getMetadataValue(metadata, "geo");
-  const geoMetadata = stringifiedGeoMetadata && parseJSONStringMetadata(stringifiedGeoMetadata);
+  const geoMetadata = stringifiedGeoMetadata && parseJSONStringMetadata2(stringifiedGeoMetadata);
   if (!geoMetadata) {
     return null;
   }
@@ -4854,32 +5035,7 @@ function getGeoMetadata(metadata) {
   }
   return geoMetadata;
 }
-function unpackGeoMetadata(metadata) {
-  const geoMetadata = getGeoMetadata(metadata);
-  if (!geoMetadata) {
-    return;
-  }
-  const { version: version2, primary_column, columns } = geoMetadata;
-  if (version2) {
-    setMetadataValue(metadata, "geo.version", version2);
-  }
-  if (primary_column) {
-    setMetadataValue(metadata, "geo.primary_column", primary_column);
-  }
-  setMetadataValue(metadata, "geo.columns", Object.keys(columns || {}).join(","));
-}
-function unpackJSONStringMetadata(metadata, metadataKey) {
-  const stringifiedMetadata = getMetadataValue(metadata, metadataKey);
-  const json = stringifiedMetadata && parseJSONStringMetadata(stringifiedMetadata);
-  for (const [key, value] of Object.entries(json || {})) {
-    setMetadataValue(
-      metadata,
-      `${metadataKey}.${key}`,
-      typeof value === "string" ? value : JSON.stringify(value)
-    );
-  }
-}
-function parseJSONStringMetadata(stringifiedMetadata) {
+function parseJSONStringMetadata2(stringifiedMetadata) {
   if (!stringifiedMetadata) {
     return null;
   }
@@ -4901,16 +5057,15 @@ var init_geoparquet_metadata = __esm({
 });
 
 // ../gis/src/index.ts
-var init_src4 = __esm({
+var init_src5 = __esm({
   "../gis/src/index.ts"() {
     "use strict";
-    init_metadata_utils();
     init_geoparquet_metadata();
   }
 });
 
 // ../arrow/src/index.ts
-var init_src5 = __esm({
+var init_src6 = __esm({
   "../arrow/src/index.ts"() {
     "use strict";
     init_indexed_arrow_table();
@@ -5154,10 +5309,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 = {};
@@ -5171,18 +5327,34 @@ 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");
+}
 var arrow7, GEOARROW_EXTENSION_NAME_KEY, GEOARROW_EXTENSION_METADATA_KEY, GEOPARQUET_TO_GEOARROW_ENCODINGS;
 var init_geospatial_metadata = __esm({
   "../parquet/src/lib/geo/geospatial-metadata.ts"() {
     "use strict";
     arrow7 = __toESM(require("apache-arrow"), 1);
-    init_src4();
+    init_src3();
     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",
@@ -5208,7 +5380,7 @@ async function getSchemaFromParquetReader(reader) {
 var init_get_parquet_schema = __esm({
   "../parquet/src/lib/parsers/get-parquet-schema.ts"() {
     "use strict";
-    init_src4();
+    init_src3();
     init_convert_schema_from_parquet();
     init_geospatial_metadata();
   }
@@ -5320,7 +5492,7 @@ function doLongitudeIntervalsIntersect(firstWest, firstEast, secondWest, secondE
 var init_geoparquet_covering = __esm({
   "../parquet/src/lib/geo/geoparquet-covering.ts"() {
     "use strict";
-    init_src4();
+    init_src3();
   }
 });
 
@@ -12044,7 +12216,7 @@ var init_parse_bson = __esm({
 });
 
 // ../bson/src/index.ts
-var init_src6 = __esm({
+var init_src7 = __esm({
   "../bson/src/index.ts"() {
     "use strict";
     init_bson_writer();
@@ -12453,7 +12625,7 @@ var PARQUET_LOGICAL_TYPES, kMillisPerDay;
 var init_types = __esm({
   "../parquet/src/parquetjs/schema/types.ts"() {
     "use strict";
-    init_src6();
+    init_src7();
     init_binary_utils();
     PARQUET_LOGICAL_TYPES = {
       BOOLEAN: {
@@ -13164,7 +13336,7 @@ function resolveParquetSourceWorkerUrl() {
   }
 }
 function getParquetSourceWorkerFile() {
-  return "./parquet-source-worker.js";
+  return "../dist/parquet-source-worker.js";
 }
 var import_meta, PARQUET_SOURCE_WORKER_URL;
 var init_parquet_source_worker_url = __esm({
@@ -16474,7 +16646,7 @@ var init_default_codecs = __esm({
 });
 
 // ../compression/src/index.ts
-var init_src7 = __esm({
+var init_src8 = __esm({
   "../compression/src/index.ts"() {
     "use strict";
     init_compression();
@@ -16587,7 +16759,7 @@ var PARQUET_COMPRESSION_METHODS, ParquetSnappyDecompressor;
 var init_compression2 = __esm({
   "../parquet/src/parquetjs/compression.ts"() {
     "use strict";
-    init_src7();
+    init_src8();
     init_snappy_decompressor_hysnappy();
     init_src2();
     init_binary_utils();
@@ -22749,10 +22921,10 @@ var _preloadParquetSourceLoader, _createMetadataDataSource, ParquetSourceLoaderB
 var init_parquet_source_loader = __esm({
   "../parquet/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();
@@ -22935,7 +23107,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] : []])