@loaders.gl/pmtiles 4.3.0-alpha.1 → 4.3.0-alpha.3

package/dist/dist.dev.js

@@ -793,7 +793,8 @@ var __exports__ = (() => {
   // bundle.ts
   var bundle_exports = {};
   __export(bundle_exports, {
-    PMTilesSource: () => PMTilesSource
+    PMTilesSource: () => PMTilesSource,
+    PMTilesTileSource: () => PMTilesTileSource
   });
   __reExport(bundle_exports, __toESM(require_core(), 1));
 
@@ -1399,7 +1400,16 @@ var __exports__ = (() => {
   // ../loader-utils/src/lib/log-utils/log.ts
   var VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
   var version = VERSION2[0] >= "0" && VERSION2[0] <= "9" ? `v${VERSION2}` : "";
-  var log = new Log({ id: `loaders.gl ${version}` });
+  function createLog() {
+    const log2 = new Log({ id: "loaders.gl" });
+    globalThis.loaders = globalThis.loaders || {};
+    globalThis.loaders.log = log2;
+    globalThis.loaders.version = version;
+    globalThis.probe = globalThis.probe || {};
+    globalThis.probe.loaders = log2;
+    return log2;
+  }
+  var log = createLog();
 
   // ../loader-utils/src/lib/path-utils/file-aliases.ts
   var pathPrefix = "";
@@ -1870,6 +1880,241 @@ var __exports__ = (() => {
     options: DEFAULT_IMAGE_LOADER_OPTIONS
   };
 
+  // ../mvt/src/lib/parse-tilejson.ts
+  var isObject = (x2) => x2 !== null && typeof x2 === "object";
+  function parseTileJSON(jsonMetadata, options) {
+    if (!jsonMetadata || !isObject(jsonMetadata)) {
+      return null;
+    }
+    let tileJSON = {
+      name: jsonMetadata.name || "",
+      description: jsonMetadata.description || ""
+    };
+    if (typeof jsonMetadata.generator === "string") {
+      tileJSON.generator = jsonMetadata.generator;
+    }
+    if (typeof jsonMetadata.generator_options === "string") {
+      tileJSON.generatorOptions = jsonMetadata.generator_options;
+    }
+    tileJSON.boundingBox = parseBounds(jsonMetadata.bounds) || parseBounds(jsonMetadata.antimeridian_adjusted_bounds);
+    tileJSON.center = parseCenter(jsonMetadata.center);
+    tileJSON.maxZoom = safeParseFloat(jsonMetadata.maxzoom);
+    tileJSON.minZoom = safeParseFloat(jsonMetadata.minzoom);
+    if (typeof jsonMetadata?.json === "string") {
+      try {
+        tileJSON.metaJson = JSON.parse(jsonMetadata.json);
+      } catch (error) {
+        console.warn("Failed to parse tilejson.json field", error);
+      }
+    }
+    const tilestats = jsonMetadata.tilestats || tileJSON.metaJson?.tilestats;
+    const tileStatsLayers = parseTilestatsLayers(tilestats, options);
+    const tileJSONlayers = parseTileJSONLayers(jsonMetadata.vector_layers);
+    const layers = mergeLayers(tileJSONlayers, tileStatsLayers);
+    tileJSON = {
+      ...tileJSON,
+      layers
+    };
+    if (tileJSON.maxZoom === null && layers.length > 0) {
+      tileJSON.maxZoom = layers[0].maxZoom || null;
+    }
+    if (tileJSON.minZoom === null && layers.length > 0) {
+      tileJSON.minZoom = layers[0].minZoom || null;
+    }
+    return tileJSON;
+  }
+  function parseTileJSONLayers(layers) {
+    if (!Array.isArray(layers)) {
+      return [];
+    }
+    return layers.map((layer) => parseTileJSONLayer(layer));
+  }
+  function parseTileJSONLayer(layer) {
+    const fields = Object.entries(layer.fields || []).map(([key, datatype]) => ({
+      name: key,
+      ...attributeTypeToFieldType(String(datatype))
+    }));
+    const layer2 = { ...layer };
+    delete layer2.fields;
+    return {
+      name: layer.id || "",
+      ...layer2,
+      fields
+    };
+  }
+  function parseTilestatsLayers(tilestats, options) {
+    if (isObject(tilestats) && Array.isArray(tilestats.layers)) {
+      return tilestats.layers.map((layer) => parseTilestatsForLayer(layer, options));
+    }
+    return [];
+  }
+  function parseTilestatsForLayer(layer, options) {
+    const fields = [];
+    const indexedAttributes = {};
+    const attributes = layer.attributes || [];
+    for (const attribute of attributes) {
+      const name = attribute.attribute;
+      if (typeof name === "string") {
+        if (name.split("|").length > 1) {
+          const fname = name.split("|")[0];
+          indexedAttributes[fname] = indexedAttributes[fname] || [];
+          indexedAttributes[fname].push(attribute);
+          console.warn("ignoring tilestats indexed field", fname);
+        } else if (!fields[name]) {
+          fields.push(attributeToField(attribute, options));
+        } else {
+        }
+      }
+    }
+    return {
+      name: layer.layer || "",
+      dominantGeometry: layer.geometry,
+      fields
+    };
+  }
+  function mergeLayers(layers, tilestatsLayers) {
+    return layers.map((layer) => {
+      const tilestatsLayer = tilestatsLayers.find((tsLayer) => tsLayer.name === layer.name);
+      const fields = tilestatsLayer?.fields || [];
+      const layer2 = { ...layer };
+      delete layer2.fields;
+      return {
+        ...layer2,
+        ...tilestatsLayer,
+        fields
+      };
+    });
+  }
+  function parseBounds(bounds) {
+    const result = fromArrayOrString(bounds);
+    if (Array.isArray(result) && result.length === 4 && [result[0], result[2]].every(isLng) && [result[1], result[3]].every(isLat)) {
+      return [
+        [result[0], result[1]],
+        [result[2], result[3]]
+      ];
+    }
+    return void 0;
+  }
+  function parseCenter(center) {
+    const result = fromArrayOrString(center);
+    if (Array.isArray(result) && result.length === 3 && isLng(result[0]) && isLat(result[1]) && isZoom(result[2])) {
+      return result;
+    }
+    return null;
+  }
+  function safeParseFloat(input) {
+    const result = typeof input === "string" ? parseFloat(input) : typeof input === "number" ? input : null;
+    return result === null || isNaN(result) ? null : result;
+  }
+  function isLat(num) {
+    return Number.isFinite(num) && num <= 90 && num >= -90;
+  }
+  function isLng(num) {
+    return Number.isFinite(num) && num <= 180 && num >= -180;
+  }
+  function isZoom(num) {
+    return Number.isFinite(num) && num >= 0 && num <= 22;
+  }
+  function fromArrayOrString(data) {
+    if (typeof data === "string") {
+      return data.split(",").map(parseFloat);
+    } else if (Array.isArray(data)) {
+      return data;
+    }
+    return null;
+  }
+  var attrTypeMap = {
+    number: {
+      type: "float32"
+    },
+    numeric: {
+      type: "float32"
+    },
+    string: {
+      type: "utf8"
+    },
+    vachar: {
+      type: "utf8"
+    },
+    float: {
+      type: "float32"
+    },
+    int: {
+      type: "int32"
+    },
+    int4: {
+      type: "int32"
+    },
+    boolean: {
+      type: "boolean"
+    },
+    bool: {
+      type: "boolean"
+    }
+  };
+  function attributeToField(attribute = {}, options) {
+    const fieldTypes = attributeTypeToFieldType(attribute.type);
+    const field = {
+      name: attribute.attribute,
+      // what happens if attribute type is string...
+      // filterProps: getFilterProps(fieldTypes.type, attribute),
+      ...fieldTypes
+    };
+    if (typeof attribute.min === "number") {
+      field.min = attribute.min;
+    }
+    if (typeof attribute.max === "number") {
+      field.max = attribute.max;
+    }
+    if (typeof attribute.count === "number") {
+      field.uniqueValueCount = attribute.count;
+    }
+    if (attribute.values) {
+      field.values = attribute.values;
+    }
+    if (field.values && typeof options.maxValues === "number") {
+      field.values = field.values?.slice(0, options.maxValues);
+    }
+    return field;
+  }
+  function attributeTypeToFieldType(aType) {
+    const type = aType.toLowerCase();
+    if (!type || !attrTypeMap[type]) {
+    }
+    return attrTypeMap[type] || { type: "string" };
+  }
+
+  // ../mvt/src/tilejson-loader.ts
+  var VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var TileJSONLoader = {
+    dataType: null,
+    batchType: null,
+    name: "TileJSON",
+    id: "tilejson",
+    module: "pmtiles",
+    version: VERSION4,
+    worker: true,
+    extensions: ["json"],
+    mimeTypes: ["application/json"],
+    text: true,
+    options: {
+      tilejson: {
+        maxValues: void 0
+      }
+    },
+    parse: async (arrayBuffer, options) => {
+      const jsonString = new TextDecoder().decode(arrayBuffer);
+      const json = JSON.parse(jsonString);
+      const tilejsonOptions = { ...TileJSONLoader.options.tilejson, ...options?.tilejson };
+      return parseTileJSON(json, tilejsonOptions);
+    },
+    parseTextSync: (text, options) => {
+      const json = JSON.parse(text);
+      const tilejsonOptions = { ...TileJSONLoader.options.tilejson, ...options?.tilejson };
+      return parseTileJSON(json, tilejsonOptions);
+    }
+  };
+
   // ../../node_modules/@math.gl/polygon/dist/polygon-utils.js
   var DimIndex = {
     x: 0,
@@ -2684,6 +2929,39 @@ var __exports__ = (() => {
     }
     return sum;
   }
+  function convertToLocalCoordinates(coordinates, extent) {
+    if (Array.isArray(coordinates[0])) {
+      for (const subcoords of coordinates) {
+        convertToLocalCoordinates(subcoords, extent);
+      }
+      return;
+    }
+    const p = coordinates;
+    p[0] /= extent;
+    p[1] /= extent;
+  }
+  function convertToLocalCoordinatesFlat(data, extent) {
+    for (let i2 = 0; i2 < data.length; ++i2) {
+      data[i2] /= extent;
+    }
+  }
+  function projectToLngLat(line, tileIndex, extent) {
+    if (typeof line[0][0] !== "number") {
+      for (const point of line) {
+        projectToLngLat(point, tileIndex, extent);
+      }
+      return;
+    }
+    const size = extent * Math.pow(2, tileIndex.z);
+    const x0 = extent * tileIndex.x;
+    const y0 = extent * tileIndex.y;
+    for (let j = 0; j < line.length; j++) {
+      const p = line[j];
+      p[0] = (p[0] + x0) * 360 / size - 180;
+      const y2 = 180 - (p[1] + y0) * 360 / size;
+      p[1] = 360 / Math.PI * Math.atan(Math.exp(y2 * Math.PI / 180)) - 90;
+    }
+  }
   function projectToLngLatFlat(data, tileIndex, extent) {
     const { x: x2, y, z } = tileIndex;
     const size = extent * Math.pow(2, z);
@@ -2793,39 +3071,37 @@ var __exports__ = (() => {
       this._geometryInfo = geometryInfo;
       pbf.readFields(readFeature, this, end);
     }
-    toGeoJSON(options) {
+    toGeoJSONFeature(coordinates, tileIndex) {
       const coords = this.loadGeometry();
-      if (typeof options === "function") {
-        return _toGeoJSON(this, coords, options);
-      }
-      const { x: x2, y, z } = options;
-      const size = this.extent * Math.pow(2, z);
-      const x0 = this.extent * x2;
-      const y0 = this.extent * y;
-      function project(line) {
-        for (let j = 0; j < line.length; j++) {
-          const p = line[j];
-          p[0] = (p[0] + x0) * 360 / size - 180;
-          const y2 = 180 - (p[1] + y0) * 360 / size;
-          p[1] = 360 / Math.PI * Math.atan(Math.exp(y2 * Math.PI / 180)) - 90;
-        }
+      switch (coordinates) {
+        case "wgs84":
+          return _toGeoJSONFeature(
+            this,
+            coords,
+            (line) => projectToLngLat(line, tileIndex, this.extent)
+          );
+        default:
+          return _toGeoJSONFeature(this, coords, convertToLocalCoordinates);
       }
-      return _toGeoJSON(this, coords, project);
     }
     /**
      *
      * @param options
      * @returns
      */
-    toBinaryCoordinates(options) {
-      if (typeof options === "function") {
-        return this._toBinaryCoordinates(options);
+    toBinaryFeature(coordinates, tileIndex) {
+      const geom = this.loadFlatGeometry();
+      switch (coordinates) {
+        case "wgs84":
+          return this._toBinaryCoordinates(
+            geom,
+            (coords) => projectToLngLatFlat(coords, tileIndex, this.extent)
+          );
+        default:
+          return this._toBinaryCoordinates(geom, convertToLocalCoordinatesFlat);
       }
-      const tileIndex = options;
-      return this._toBinaryCoordinates(
-        (data) => projectToLngLatFlat(data, tileIndex, this.extent)
-      );
     }
+    /** Read a bounding box from the feature */
     // eslint-disable-next-line max-statements
     bbox() {
       const pbf = this._pbf;
@@ -2869,10 +3145,9 @@ var __exports__ = (() => {
      * @param transform
      * @returns result
      */
-    _toBinaryCoordinates(transform) {
-      const geom = this.loadFlatGeometry();
+    _toBinaryCoordinates(geom, transform) {
       let geometry;
-      transform(geom.data, this);
+      transform(geom.data, this.extent);
       const coordLength = 2;
       switch (this.type) {
         case 1:
@@ -2949,6 +3224,28 @@ var __exports__ = (() => {
         lines.push(line);
       return lines;
     }
+    /**
+     * Expands the protobuf data to an intermediate Flat GeoJSON
+     * data format, which maps closely to the binary data buffers.
+     * It is similar to GeoJSON, but rather than storing the coordinates
+     * in multidimensional arrays, we have a 1D `data` with all the
+     * coordinates, and then index into this using the `indices`
+     * parameter, e.g.
+     *
+     * geometry: {
+     *   type: 'Point', data: [1,2], indices: [0]
+     * }
+     * geometry: {
+     *   type: 'LineString', data: [1,2,3,4,...], indices: [0]
+     * }
+     * geometry: {
+     *   type: 'Polygon', data: [1,2,3,4,...], indices: [[0, 2]]
+     * }
+     * Thus the indices member lets us look up the relevant range
+     * from the data array.
+     * The Multi* versions of the above types share the same data
+     * structure, just with multiple elements in the indices array
+     */
     // eslint-disable-next-line complexity, max-statements
     loadFlatGeometry() {
       const pbf = this._pbf;
@@ -2991,7 +3288,7 @@ var __exports__ = (() => {
     }
   };
   __publicField(VectorTileFeature, "types", ["Unknown", "Point", "LineString", "Polygon"]);
-  function _toGeoJSON(vtFeature, coords, transform) {
+  function _toGeoJSONFeature(vtFeature, coords, transform) {
     let type = VectorTileFeature.types[vtFeature.type];
     let i2;
     let j;
@@ -3003,19 +3300,19 @@ var __exports__ = (() => {
           points[i2] = coords[i2][0];
         }
         coordinates = points;
-        transform(coordinates, vtFeature);
+        transform(coordinates, vtFeature.extent);
         break;
       case 2:
         coordinates = coords;
         for (i2 = 0; i2 < coordinates.length; i2++) {
-          transform(coordinates[i2], vtFeature);
+          transform(coordinates[i2], vtFeature.extent);
         }
         break;
       case 3:
         coordinates = classifyRings(coords);
         for (i2 = 0; i2 < coordinates.length; i2++) {
           for (j = 0; j < coordinates[i2].length; j++) {
-            transform(coordinates[i2][j], vtFeature);
+            transform(coordinates[i2][j], vtFeature.extent);
           }
         }
         break;
@@ -3036,7 +3333,8 @@ var __exports__ = (() => {
       properties: vtFeature.properties
     };
     if (vtFeature.id !== null) {
-      result.id = vtFeature.id;
+      result.properties ||= {};
+      result.properties.id = vtFeature.id;
     }
     return result;
   }
@@ -3259,9 +3557,9 @@ var __exports__ = (() => {
     return options.mvt;
   }
   function getDecodedFeature(feature, options, layerName) {
-    const decodedFeature = feature.toGeoJSON(
-      // @ts-expect-error What is going on here?
-      options.coordinates === "wgs84" ? options.tileIndex : transformToLocalCoordinates
+    const decodedFeature = feature.toGeoJSONFeature(
+      options.coordinates || "local",
+      options.tileIndex
     );
     if (options.layerProperty) {
       decodedFeature.properties ||= {};
@@ -3270,39 +3568,22 @@ var __exports__ = (() => {
     return decodedFeature;
   }
   function getDecodedFeatureBinary(feature, options, layerName) {
-    const decodedFeature = feature.toBinaryCoordinates(
-      // @ts-expect-error
-      options.coordinates === "wgs84" ? options.tileIndex : transformToLocalCoordinatesBinary
-    );
+    const decodedFeature = feature.toBinaryFeature(options.coordinates || "local", options.tileIndex);
     if (options.layerProperty && decodedFeature.properties) {
       decodedFeature.properties[options.layerProperty] = layerName;
     }
     return decodedFeature;
   }
-  function transformToLocalCoordinates(line, feature) {
-    const { extent } = feature;
-    for (let i2 = 0; i2 < line.length; i2++) {
-      const p = line[i2];
-      p[0] /= extent;
-      p[1] /= extent;
-    }
-  }
-  function transformToLocalCoordinatesBinary(data, feature) {
-    const { extent } = feature;
-    for (let i2 = 0, il = data.length; i2 < il; ++i2) {
-      data[i2] /= extent;
-    }
-  }
 
   // ../mvt/src/mvt-loader.ts
-  var VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var VERSION5 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
   var MVTWorkerLoader = {
     dataType: null,
     batchType: null,
     name: "Mapbox Vector Tile",
     id: "mvt",
     module: "mvt",
-    version: VERSION4,
+    version: VERSION5,
     // Note: ArcGIS uses '.pbf' extension and 'application/octet-stream'
     extensions: ["mvt", "pbf"],
     mimeTypes: [
@@ -3330,241 +3611,6 @@ var __exports__ = (() => {
     binary: true
   };
 
-  // ../mvt/src/lib/parse-tilejson.ts
-  var isObject = (x2) => x2 !== null && typeof x2 === "object";
-  function parseTileJSON(jsonMetadata, options) {
-    if (!jsonMetadata || !isObject(jsonMetadata)) {
-      return null;
-    }
-    let tileJSON = {
-      name: jsonMetadata.name || "",
-      description: jsonMetadata.description || ""
-    };
-    if (typeof jsonMetadata.generator === "string") {
-      tileJSON.generator = jsonMetadata.generator;
-    }
-    if (typeof jsonMetadata.generator_options === "string") {
-      tileJSON.generatorOptions = jsonMetadata.generator_options;
-    }
-    tileJSON.boundingBox = parseBounds(jsonMetadata.bounds) || parseBounds(jsonMetadata.antimeridian_adjusted_bounds);
-    tileJSON.center = parseCenter(jsonMetadata.center);
-    tileJSON.maxZoom = safeParseFloat(jsonMetadata.maxzoom);
-    tileJSON.minZoom = safeParseFloat(jsonMetadata.minzoom);
-    if (typeof jsonMetadata?.json === "string") {
-      try {
-        tileJSON.metaJson = JSON.parse(jsonMetadata.json);
-      } catch (error) {
-        console.warn("Failed to parse tilejson.json field", error);
-      }
-    }
-    const tilestats = jsonMetadata.tilestats || tileJSON.metaJson?.tilestats;
-    const tileStatsLayers = parseTilestatsLayers(tilestats, options);
-    const tileJSONlayers = parseTileJSONLayers(jsonMetadata.vector_layers);
-    const layers = mergeLayers(tileJSONlayers, tileStatsLayers);
-    tileJSON = {
-      ...tileJSON,
-      layers
-    };
-    if (tileJSON.maxZoom === null && layers.length > 0) {
-      tileJSON.maxZoom = layers[0].maxZoom || null;
-    }
-    if (tileJSON.minZoom === null && layers.length > 0) {
-      tileJSON.minZoom = layers[0].minZoom || null;
-    }
-    return tileJSON;
-  }
-  function parseTileJSONLayers(layers) {
-    if (!Array.isArray(layers)) {
-      return [];
-    }
-    return layers.map((layer) => parseTileJSONLayer(layer));
-  }
-  function parseTileJSONLayer(layer) {
-    const fields = Object.entries(layer.fields || []).map(([key, datatype]) => ({
-      name: key,
-      ...attributeTypeToFieldType(String(datatype))
-    }));
-    const layer2 = { ...layer };
-    delete layer2.fields;
-    return {
-      name: layer.id || "",
-      ...layer2,
-      fields
-    };
-  }
-  function parseTilestatsLayers(tilestats, options) {
-    if (isObject(tilestats) && Array.isArray(tilestats.layers)) {
-      return tilestats.layers.map((layer) => parseTilestatsForLayer(layer, options));
-    }
-    return [];
-  }
-  function parseTilestatsForLayer(layer, options) {
-    const fields = [];
-    const indexedAttributes = {};
-    const attributes = layer.attributes || [];
-    for (const attribute of attributes) {
-      const name = attribute.attribute;
-      if (typeof name === "string") {
-        if (name.split("|").length > 1) {
-          const fname = name.split("|")[0];
-          indexedAttributes[fname] = indexedAttributes[fname] || [];
-          indexedAttributes[fname].push(attribute);
-          console.warn("ignoring tilestats indexed field", fname);
-        } else if (!fields[name]) {
-          fields.push(attributeToField(attribute, options));
-        } else {
-        }
-      }
-    }
-    return {
-      name: layer.layer || "",
-      dominantGeometry: layer.geometry,
-      fields
-    };
-  }
-  function mergeLayers(layers, tilestatsLayers) {
-    return layers.map((layer) => {
-      const tilestatsLayer = tilestatsLayers.find((tsLayer) => tsLayer.name === layer.name);
-      const fields = tilestatsLayer?.fields || [];
-      const layer2 = { ...layer };
-      delete layer2.fields;
-      return {
-        ...layer2,
-        ...tilestatsLayer,
-        fields
-      };
-    });
-  }
-  function parseBounds(bounds) {
-    const result = fromArrayOrString(bounds);
-    if (Array.isArray(result) && result.length === 4 && [result[0], result[2]].every(isLng) && [result[1], result[3]].every(isLat)) {
-      return [
-        [result[0], result[1]],
-        [result[2], result[3]]
-      ];
-    }
-    return void 0;
-  }
-  function parseCenter(center) {
-    const result = fromArrayOrString(center);
-    if (Array.isArray(result) && result.length === 3 && isLng(result[0]) && isLat(result[1]) && isZoom(result[2])) {
-      return result;
-    }
-    return null;
-  }
-  function safeParseFloat(input) {
-    const result = typeof input === "string" ? parseFloat(input) : typeof input === "number" ? input : null;
-    return result === null || isNaN(result) ? null : result;
-  }
-  function isLat(num) {
-    return Number.isFinite(num) && num <= 90 && num >= -90;
-  }
-  function isLng(num) {
-    return Number.isFinite(num) && num <= 180 && num >= -180;
-  }
-  function isZoom(num) {
-    return Number.isFinite(num) && num >= 0 && num <= 22;
-  }
-  function fromArrayOrString(data) {
-    if (typeof data === "string") {
-      return data.split(",").map(parseFloat);
-    } else if (Array.isArray(data)) {
-      return data;
-    }
-    return null;
-  }
-  var attrTypeMap = {
-    number: {
-      type: "float32"
-    },
-    numeric: {
-      type: "float32"
-    },
-    string: {
-      type: "utf8"
-    },
-    vachar: {
-      type: "utf8"
-    },
-    float: {
-      type: "float32"
-    },
-    int: {
-      type: "int32"
-    },
-    int4: {
-      type: "int32"
-    },
-    boolean: {
-      type: "boolean"
-    },
-    bool: {
-      type: "boolean"
-    }
-  };
-  function attributeToField(attribute = {}, options) {
-    const fieldTypes = attributeTypeToFieldType(attribute.type);
-    const field = {
-      name: attribute.attribute,
-      // what happens if attribute type is string...
-      // filterProps: getFilterProps(fieldTypes.type, attribute),
-      ...fieldTypes
-    };
-    if (typeof attribute.min === "number") {
-      field.min = attribute.min;
-    }
-    if (typeof attribute.max === "number") {
-      field.max = attribute.max;
-    }
-    if (typeof attribute.count === "number") {
-      field.uniqueValueCount = attribute.count;
-    }
-    if (attribute.values) {
-      field.values = attribute.values;
-    }
-    if (field.values && typeof options.maxValues === "number") {
-      field.values = field.values?.slice(0, options.maxValues);
-    }
-    return field;
-  }
-  function attributeTypeToFieldType(aType) {
-    const type = aType.toLowerCase();
-    if (!type || !attrTypeMap[type]) {
-    }
-    return attrTypeMap[type] || { type: "string" };
-  }
-
-  // ../mvt/src/tilejson-loader.ts
-  var VERSION5 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
-  var TileJSONLoader = {
-    dataType: null,
-    batchType: null,
-    name: "TileJSON",
-    id: "tilejson",
-    module: "pmtiles",
-    version: VERSION5,
-    worker: true,
-    extensions: ["json"],
-    mimeTypes: ["application/json"],
-    text: true,
-    options: {
-      tilejson: {
-        maxValues: void 0
-      }
-    },
-    parse: async (arrayBuffer, options) => {
-      const jsonString = new TextDecoder().decode(arrayBuffer);
-      const json = JSON.parse(jsonString);
-      const tilejsonOptions = { ...TileJSONLoader.options.tilejson, ...options?.tilejson };
-      return parseTileJSON(json, tilejsonOptions);
-    },
-    parseTextSync: (text, options) => {
-      const json = JSON.parse(text);
-      const tilejsonOptions = { ...TileJSONLoader.options.tilejson, ...options?.tilejson };
-      return parseTileJSON(json, tilejsonOptions);
-    }
-  };
-
   // ../../node_modules/pmtiles/dist/index.js
   var dist_exports = {};
   __export(dist_exports, {
@@ -5280,21 +5326,39 @@ var __exports__ = (() => {
 
   // src/pmtiles-source.ts
   var { PMTiles: PMTiles2 } = dist_exports;
-  var PMTilesSource = class extends DataSource {
+  var VERSION6 = "1.0.0";
+  var PMTilesSource = {
+    name: "PMTiles",
+    id: "pmtiles",
+    module: "pmtiles",
+    version: VERSION6,
+    extensions: ["pmtiles"],
+    mimeTypes: ["application/octet-stream"],
+    options: { url: void 0, pmtiles: {} },
+    type: "pmtiles",
+    fromUrl: true,
+    fromBlob: true,
+    testURL: (url) => url.endsWith(".pmtiles"),
+    createDataSource: (url, props) => new PMTilesTileSource(url, props)
+  };
+  var PMTilesTileSource = class extends DataSource {
     data;
     props;
     mimeType = null;
     pmtiles;
     metadata;
-    constructor(props) {
+    constructor(data, props) {
       super(props);
       this.props = props;
-      const url = typeof props.url === "string" ? resolvePath(props.url) : new BlobSource(props.url, "pmtiles");
+      const url = typeof data === "string" ? resolvePath(data) : new BlobSource(data, "pmtiles");
       this.data = props.url;
       this.pmtiles = new PMTiles2(url);
       this.getTileData = this.getTileData.bind(this);
       this.metadata = this.getMetadata();
     }
+    async getSchema() {
+      return { fields: [], metadata: {} };
+    }
     async getMetadata() {
       const pmtilesHeader = await this.pmtiles.getHeader();
       const pmtilesMetadata = await this.pmtiles.getMetadata();