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

package/dist/index.cjs

@@ -35,14 +35,251 @@ var __publicField = (obj, key, value) => {
 // dist/index.js
 var dist_exports = {};
 __export(dist_exports, {
-  GeoJSONTileSource: () => GeoJSONTileSource,
   MVTLoader: () => MVTLoader,
   MVTSource: () => MVTSource,
   MVTWorkerLoader: () => MVTWorkerLoader,
+  TableTileSource: () => TableTileSource,
   TileJSONLoader: () => TileJSONLoader
 });
 module.exports = __toCommonJS(dist_exports);
 
+// dist/lib/parse-tilejson.js
+var isObject = (x) => x !== null && typeof x === "object";
+function parseTileJSON(jsonMetadata, options) {
+  var _a;
+  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 == null ? void 0 : 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 || ((_a = tileJSON.metaJson) == null ? void 0 : _a.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 == null ? void 0 : 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) {
+  var _a;
+  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 = (_a = field.values) == null ? void 0 : _a.slice(0, options.maxValues);
+  }
+  return field;
+}
+function attributeTypeToFieldType(aType) {
+  const type = aType.toLowerCase();
+  if (!type || !attrTypeMap[type]) {
+  }
+  return attrTypeMap[type] || { type: "string" };
+}
+
+// dist/tilejson-loader.js
+var VERSION = true ? "4.3.0-alpha.2" : "latest";
+var TileJSONLoader = {
+  dataType: null,
+  batchType: null,
+  name: "TileJSON",
+  id: "tilejson",
+  module: "pmtiles",
+  version: VERSION,
+  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 == null ? void 0 : options.tilejson };
+    return parseTileJSON(json, tilejsonOptions);
+  },
+  parseTextSync: (text, options) => {
+    const json = JSON.parse(text);
+    const tilejsonOptions = { ...TileJSONLoader.options.tilejson, ...options == null ? void 0 : options.tilejson };
+    return parseTileJSON(json, tilejsonOptions);
+  }
+};
+
 // dist/lib/parse-mvt.js
 var import_gis = require("@loaders.gl/gis");
 var import_loader_utils = require("@loaders.gl/loader-utils");
@@ -59,6 +296,39 @@ function signedArea(ring) {
   }
   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 i = 0; i < data.length; ++i) {
+    data[i] /= 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, y, z } = tileIndex;
   const size = extent * Math.pow(2, z);
@@ -168,37 +438,30 @@ var VectorTileFeature = class {
     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, y, z } = options;
-    const size = this.extent * Math.pow(2, z);
-    const x0 = this.extent * x;
-    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;
@@ -242,10 +505,9 @@ var VectorTileFeature = class {
    * @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:
@@ -322,6 +584,28 @@ var VectorTileFeature = class {
       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;
@@ -364,7 +648,7 @@ var VectorTileFeature = class {
   }
 };
 __publicField(VectorTileFeature, "types", ["Unknown", "Point", "LineString", "Polygon"]);
-function _toGeoJSON(vtFeature, coords, transform) {
+function _toGeoJSONFeature(vtFeature, coords, transform) {
   let type = VectorTileFeature.types[vtFeature.type];
   let i;
   let j;
@@ -376,19 +660,19 @@ function _toGeoJSON(vtFeature, coords, transform) {
         points[i] = coords[i][0];
       }
       coordinates = points;
-      transform(coordinates, vtFeature);
+      transform(coordinates, vtFeature.extent);
       break;
     case 2:
       coordinates = coords;
       for (i = 0; i < coordinates.length; i++) {
-        transform(coordinates[i], vtFeature);
+        transform(coordinates[i], vtFeature.extent);
       }
       break;
     case 3:
       coordinates = classifyRings(coords);
       for (i = 0; i < coordinates.length; i++) {
         for (j = 0; j < coordinates[i].length; j++) {
-          transform(coordinates[i][j], vtFeature);
+          transform(coordinates[i][j], vtFeature.extent);
         }
       }
       break;
@@ -409,7 +693,8 @@ function _toGeoJSON(vtFeature, coords, transform) {
     properties: vtFeature.properties
   };
   if (vtFeature.id !== null) {
-    result.id = vtFeature.id;
+    result.properties ||= {};
+    result.properties.id = vtFeature.id;
   }
   return result;
 }
@@ -562,7 +847,7 @@ function parseToBinary(arrayBuffer, options) {
   return binaryData;
 }
 function parseToFlatGeoJson(arrayBuffer, options) {
-  const features = [];
+  const features2 = [];
   const geometryInfo = {
     coordLength: 2,
     pointPositionsCount: 0,
@@ -576,7 +861,7 @@ function parseToFlatGeoJson(arrayBuffer, options) {
     polygonFeaturesCount: 0
   };
   if (arrayBuffer.byteLength <= 0) {
-    return [features, geometryInfo];
+    return [features2, geometryInfo];
   }
   const tile = new VectorTile(new import_pbf.default(arrayBuffer));
   const selectedLayers = options && Array.isArray(options.layers) ? options.layers : Object.keys(tile.layers);
@@ -588,16 +873,16 @@ function parseToFlatGeoJson(arrayBuffer, options) {
     for (let i = 0; i < vectorTileLayer.length; i++) {
       const vectorTileFeature = vectorTileLayer.getBinaryFeature(i, geometryInfo);
       const decodedFeature = getDecodedFeatureBinary(vectorTileFeature, options, layerName);
-      features.push(decodedFeature);
+      features2.push(decodedFeature);
     }
   });
-  return [features, geometryInfo];
+  return [features2, geometryInfo];
 }
 function parseToGeojsonFeatures(arrayBuffer, options) {
   if (arrayBuffer.byteLength <= 0) {
     return [];
   }
-  const features = [];
+  const features2 = [];
   const tile = new VectorTile(new import_pbf.default(arrayBuffer));
   const selectedLayers = Array.isArray(options.layers) ? options.layers : Object.keys(tile.layers);
   selectedLayers.forEach((layerName) => {
@@ -608,10 +893,10 @@ function parseToGeojsonFeatures(arrayBuffer, options) {
     for (let i = 0; i < vectorTileLayer.length; i++) {
       const vectorTileFeature = vectorTileLayer.getGeoJSONFeature(i);
       const decodedFeature = getDecodedFeature(vectorTileFeature, options, layerName);
-      features.push(decodedFeature);
+      features2.push(decodedFeature);
     }
   });
-  return features;
+  return features2;
 }
 function checkOptions(options) {
   var _a;
@@ -627,10 +912,7 @@ function checkOptions(options) {
   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 ||= {};
     decodedFeature.properties[options.layerProperty] = layerName;
@@ -638,39 +920,22 @@ function getDecodedFeature(feature, options, layerName) {
   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 i = 0; i < line.length; i++) {
-    const p = line[i];
-    p[0] /= extent;
-    p[1] /= extent;
-  }
-}
-function transformToLocalCoordinatesBinary(data, feature) {
-  const { extent } = feature;
-  for (let i = 0, il = data.length; i < il; ++i) {
-    data[i] /= extent;
-  }
-}
 
 // dist/mvt-loader.js
-var VERSION = true ? "4.2.0" : "latest";
+var VERSION2 = true ? "4.3.0-alpha.2" : "latest";
 var MVTWorkerLoader = {
   dataType: null,
   batchType: null,
   name: "Mapbox Vector Tile",
   id: "mvt",
   module: "mvt",
-  version: VERSION,
+  version: VERSION2,
   // Note: ArcGIS uses '.pbf' extension and 'application/octet-stream'
   extensions: ["mvt", "pbf"],
   mimeTypes: [
@@ -698,248 +963,31 @@ var MVTLoader = {
   binary: true
 };
 
-// dist/lib/parse-tilejson.js
-var isObject = (x) => x !== null && typeof x === "object";
-function parseTileJSON(jsonMetadata, options) {
-  var _a;
-  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 == null ? void 0 : 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 || ((_a = tileJSON.metaJson) == null ? void 0 : _a.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 == null ? void 0 : 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) {
-  var _a;
-  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 = (_a = field.values) == null ? void 0 : _a.slice(0, options.maxValues);
-  }
-  return field;
-}
-function attributeTypeToFieldType(aType) {
-  const type = aType.toLowerCase();
-  if (!type || !attrTypeMap[type]) {
-  }
-  return attrTypeMap[type] || { type: "string" };
-}
-
-// dist/tilejson-loader.js
-var VERSION2 = true ? "4.2.0" : "latest";
-var TileJSONLoader = {
-  dataType: null,
-  batchType: null,
-  name: "TileJSON",
-  id: "tilejson",
-  module: "pmtiles",
-  version: VERSION2,
-  worker: true,
-  extensions: ["json"],
-  mimeTypes: ["application/json"],
-  text: true,
+// dist/mvt-source.js
+var import_loader_utils2 = require("@loaders.gl/loader-utils");
+var import_images = require("@loaders.gl/images");
+var import_mvt = require("@loaders.gl/mvt");
+var MVTSource = {
+  name: "MVT",
+  id: "mvt",
+  module: "mvt",
+  version: "0.0.0",
+  extensions: ["mvt"],
+  mimeTypes: ["application/octet-stream"],
   options: {
-    tilejson: {
-      maxValues: void 0
+    mvt: {
+      // TODO - add options here
     }
   },
-  parse: async (arrayBuffer, options) => {
-    const jsonString = new TextDecoder().decode(arrayBuffer);
-    const json = JSON.parse(jsonString);
-    const tilejsonOptions = { ...TileJSONLoader.options.tilejson, ...options == null ? void 0 : options.tilejson };
-    return parseTileJSON(json, tilejsonOptions);
-  },
-  parseTextSync: (text, options) => {
-    const json = JSON.parse(text);
-    const tilejsonOptions = { ...TileJSONLoader.options.tilejson, ...options == null ? void 0 : options.tilejson };
-    return parseTileJSON(json, tilejsonOptions);
+  type: "mvt",
+  fromUrl: true,
+  fromBlob: false,
+  testURL: (url) => true,
+  createDataSource(url, props) {
+    return new MVTTileSource(url, props);
   }
 };
-
-// dist/mvt-source.js
-var import_loader_utils2 = require("@loaders.gl/loader-utils");
-var import_images = require("@loaders.gl/images");
-var import_mvt = require("@loaders.gl/mvt");
-var MVTSource = class extends import_loader_utils2.DataSource {
+var MVTTileSource = class extends import_loader_utils2.DataSource {
   props;
   url;
   metadataUrl = null;
@@ -948,12 +996,13 @@ var MVTSource = class extends import_loader_utils2.DataSource {
   metadata;
   extension;
   mimeType = null;
-  constructor(props) {
+  constructor(url, props) {
+    var _a, _b;
     super(props);
     this.props = props;
-    this.url = (0, import_loader_utils2.resolvePath)(props.url);
-    this.metadataUrl = props.metadataUrl === void 0 ? `${this.url}/tilejson.json` : props.metadataUrl;
-    this.extension = props.extension || ".png";
+    this.url = (0, import_loader_utils2.resolvePath)(url);
+    this.metadataUrl = ((_a = props.mvt) == null ? void 0 : _a.metadataUrl) || `${this.url}/tilejson.json`;
+    this.extension = ((_b = props.mvt) == null ? void 0 : _b.extension) || ".png";
     this.data = this.url;
     this.getTileData = this.getTileData.bind(this);
     this.metadata = this.getMetadata();
@@ -985,8 +1034,8 @@ var MVTSource = class extends import_loader_utils2.DataSource {
   getTileMIMEType() {
     return this.mimeType;
   }
-  async getTile(tileParams) {
-    const { x, y, z } = tileParams;
+  async getTile(parameters) {
+    const { x, y, z } = parameters;
     const tileUrl = this.getTileURL(x, y, z);
     const response = await this.fetch(tileUrl);
     if (!response.ok) {
@@ -997,8 +1046,8 @@ var MVTSource = class extends import_loader_utils2.DataSource {
   }
   // Tile Source interface implementation: deck.gl compatible API
   // TODO - currently only handles image tiles, not vector tiles
-  async getTileData(tileParams) {
-    const { x, y, z } = tileParams.index;
+  async getTileData(parameters) {
+    const { x, y, z } = parameters.index;
     const arrayBuffer = await this.getTile({ x, y, z, layers: [] });
     if (arrayBuffer === null) {
       return null;
@@ -1053,33 +1102,317 @@ var MVTSource = class extends import_loader_utils2.DataSource {
         throw new Error(this.schema);
     }
   }
-};
-function isURLTemplate(s) {
-  return /(?=.*{z})(?=.*{x})(?=.*({y}|{-y}))|(?=.*{x})(?=.*({y}|{-y})(?=.*{z}))/.test(s);
+};
+function isURLTemplate(s) {
+  return /(?=.*{z})(?=.*{x})(?=.*({y}|{-y}))|(?=.*{x})(?=.*({y}|{-y})(?=.*{z}))/.test(s);
+}
+var xRegex = new RegExp("{x}", "g");
+var yRegex = new RegExp("{y}", "g");
+var zRegex = new RegExp("{z}", "g");
+function getURLFromTemplate(template, x, y, z, id = "0") {
+  if (Array.isArray(template)) {
+    const i = stringHash(id) % template.length;
+    template = template[i];
+  }
+  let url = template;
+  url = url.replace(xRegex, String(x));
+  url = url.replace(yRegex, String(y));
+  url = url.replace(zRegex, String(z));
+  if (Number.isInteger(y) && Number.isInteger(z)) {
+    url = url.replace(/\{-y\}/g, String(Math.pow(2, z) - y - 1));
+  }
+  return url;
+}
+function stringHash(s) {
+  return Math.abs(s.split("").reduce((a, b) => (a << 5) - a + b.charCodeAt(0) | 0, 0));
+}
+
+// dist/table-tile-source.js
+var import_loader_utils3 = require("@loaders.gl/loader-utils");
+var import_schema = require("@loaders.gl/schema");
+var import_stats = require("@probe.gl/stats");
+
+// dist/lib/vector-tiler/proto-tile.js
+function createProtoTile(features2, z, tx, ty, options) {
+  const tolerance = z === options.maxZoom ? 0 : options.tolerance / ((1 << z) * options.extent);
+  const tile = {
+    protoFeatures: [],
+    sourceFeatures: null,
+    numPoints: 0,
+    numSimplified: 0,
+    numFeatures: features2.length,
+    x: tx,
+    y: ty,
+    z,
+    transformed: false,
+    minX: 2,
+    minY: 1,
+    maxX: -1,
+    maxY: 0
+  };
+  for (const feature of features2) {
+    addProtoFeature(tile, feature, tolerance, options);
+  }
+  return tile;
+}
+function addProtoFeature(tile, feature, tolerance, options) {
+  const geometry = feature.geometry;
+  const type = feature.type;
+  const simplifiedGeometry = [];
+  tile.minX = Math.min(tile.minX, feature.minX);
+  tile.minY = Math.min(tile.minY, feature.minY);
+  tile.maxX = Math.max(tile.maxX, feature.maxX);
+  tile.maxY = Math.max(tile.maxY, feature.maxY);
+  let simplifiedType;
+  switch (type) {
+    case "Point":
+    case "MultiPoint":
+      simplifiedType = 1;
+      for (let i = 0; i < geometry.length; i += 3) {
+        simplifiedGeometry.push(geometry[i], geometry[i + 1]);
+        tile.numPoints++;
+        tile.numSimplified++;
+      }
+      break;
+    case "LineString":
+      simplifiedType = 2;
+      addProtoLine(simplifiedGeometry, geometry, tile, tolerance, false, false);
+      break;
+    case "MultiLineString":
+      simplifiedType = 2;
+      for (let i = 0; i < geometry.length; i++) {
+        addProtoLine(simplifiedGeometry, geometry[i], tile, tolerance, false, i === 0);
+      }
+      break;
+    case "Polygon":
+      simplifiedType = 3;
+      for (let i = 0; i < geometry.length; i++) {
+        addProtoLine(simplifiedGeometry, geometry[i], tile, tolerance, true, i === 0);
+      }
+      break;
+    case "MultiPolygon":
+      simplifiedType = 3;
+      for (let k = 0; k < geometry.length; k++) {
+        const polygon = geometry[k];
+        for (let i = 0; i < polygon.length; i++) {
+          addProtoLine(simplifiedGeometry, polygon[i], tile, tolerance, true, i === 0);
+        }
+      }
+      break;
+    default:
+      throw new Error(`Unknown geometry type: ${type}`);
+  }
+  if (simplifiedGeometry.length) {
+    let tags = feature.tags || null;
+    if (type === "LineString" && options.lineMetrics) {
+      tags = {};
+      for (const key in feature.tags) {
+        tags[key] = feature.tags[key];
+      }
+      tags.mapbox_clip_start = geometry.start / geometry.size;
+      tags.mapbox_clip_end = geometry.end / geometry.size;
+    }
+    const tileFeature = {
+      geometry: simplifiedGeometry,
+      simplifiedType,
+      // @ts-expect-error
+      tags
+    };
+    if (feature.id !== null) {
+      tileFeature.id = feature.id;
+    }
+    tile.protoFeatures.push(tileFeature);
+  }
+}
+function addProtoLine(result, geometry, tile, tolerance, isPolygon, isOuter) {
+  const sqTolerance = tolerance * tolerance;
+  if (tolerance > 0 && geometry.size < (isPolygon ? sqTolerance : tolerance)) {
+    tile.numPoints += geometry.length / 3;
+    return;
+  }
+  const ring = [];
+  for (let i = 0; i < geometry.length; i += 3) {
+    if (tolerance === 0 || geometry[i + 2] > sqTolerance) {
+      tile.numSimplified++;
+      ring.push(geometry[i], geometry[i + 1]);
+    }
+    tile.numPoints++;
+  }
+  if (isPolygon)
+    rewind(ring, isOuter);
+  result.push(ring);
+}
+function rewind(ring, clockwise) {
+  let area = 0;
+  for (let i = 0, j = ring.length - 2; i < ring.length; j = i, i += 2) {
+    area += (ring[i] - ring[j]) * (ring[i + 1] + ring[j + 1]);
+  }
+  if (area > 0 === clockwise) {
+    for (let i = 0, len = ring.length; i < len / 2; i += 2) {
+      const x = ring[i];
+      const y = ring[i + 1];
+      ring[i] = ring[len - 2 - i];
+      ring[i + 1] = ring[len - 1 - i];
+      ring[len - 2 - i] = x;
+      ring[len - 1 - i] = y;
+    }
+  }
+}
+
+// dist/lib/vector-tiler/transform-tile.js
+function transformTile(protoTile, extent) {
+  if (protoTile.transformed) {
+    return protoTile;
+  }
+  const z2 = 1 << protoTile.z;
+  const tx = protoTile.x;
+  const ty = protoTile.y;
+  for (const protoFeature of protoTile.protoFeatures) {
+    const geom = protoFeature.geometry;
+    const simplifiedType = protoFeature.simplifiedType;
+    protoFeature.geometry = [];
+    if (simplifiedType === 1) {
+      for (let j = 0; j < geom.length; j += 2) {
+        protoFeature.geometry.push(transformPoint(geom[j], geom[j + 1], extent, z2, tx, ty));
+      }
+    } else {
+      for (let j = 0; j < geom.length; j++) {
+        const ring = [];
+        for (let k = 0; k < geom[j].length; k += 2) {
+          ring.push(transformPoint(geom[j][k], geom[j][k + 1], extent, z2, tx, ty));
+        }
+        protoFeature.geometry.push(ring);
+      }
+    }
+  }
+  protoTile.transformed = true;
+  return protoTile;
+}
+function transformPoint(x, y, extent, z2, tx, ty) {
+  return [Math.round(extent * (x * z2 - tx)), Math.round(extent * (y * z2 - ty))];
+}
+
+// dist/lib/vector-tiler/tile-to-geojson.js
+function convertTileToGeoJSON(protoTile, props) {
+  const features2 = [];
+  for (const rawFeature of protoTile.protoFeatures) {
+    if (!rawFeature || !rawFeature.geometry) {
+      continue;
+    }
+    let type;
+    let coordinates;
+    switch (rawFeature.simplifiedType) {
+      case 1:
+        if (rawFeature.geometry.length === 1) {
+          type = "Point";
+          coordinates = rawFeature.geometry[0];
+        } else {
+          type = "MultiPoint";
+          coordinates = rawFeature.geometry;
+        }
+        break;
+      case 2:
+        if (rawFeature.geometry.length === 1) {
+          type = "LineString";
+          coordinates = rawFeature.geometry[0];
+        } else {
+          type = "MultiLineString";
+          coordinates = rawFeature.geometry;
+        }
+        break;
+      case 3:
+        if (rawFeature.geometry.length > 1) {
+          type = "MultiPolygon";
+          coordinates = [rawFeature.geometry];
+        } else {
+          type = "Polygon";
+          coordinates = rawFeature.geometry;
+        }
+        break;
+      default:
+        throw new Error(`${rawFeature.simplifiedType}is not a valid simplified type`);
+    }
+    switch (props.coordinates) {
+      case "EPSG:4326":
+      case "wgs84":
+        projectToLngLat(coordinates, props.tileIndex, props.extent);
+        break;
+      default:
+        convertToLocalCoordinates(coordinates, props.extent);
+        break;
+    }
+    const feature = {
+      type: "Feature",
+      geometry: {
+        type,
+        coordinates
+      },
+      properties: rawFeature.tags || {},
+      id: rawFeature.id
+    };
+    features2.push(feature);
+  }
+  if (features2.length === 0) {
+    return null;
+  }
+  const table = {
+    shape: "geojson-table",
+    type: "FeatureCollection",
+    features: features2
+  };
+  return table;
+}
+
+// dist/lib/vector-tiler/features/proto-feature.js
+function createProtoFeature(id, type, geometry, tags) {
+  const feature = {
+    // eslint-disable-next-line
+    id: id == null ? null : id,
+    type,
+    simplifiedType: void 0,
+    // TODO
+    geometry,
+    tags,
+    minX: Infinity,
+    minY: Infinity,
+    maxX: -Infinity,
+    maxY: -Infinity
+  };
+  switch (type) {
+    case "Point":
+    case "MultiPoint":
+    case "LineString":
+      calcLineBBox(feature, geometry);
+      break;
+    case "MultiLineString":
+      for (const line of geometry) {
+        calcLineBBox(feature, line);
+      }
+      break;
+    case "Polygon":
+      calcLineBBox(feature, geometry[0]);
+      break;
+    case "MultiPolygon":
+      for (const polygon of geometry) {
+        calcLineBBox(feature, polygon[0]);
+      }
+      break;
+    default:
+      throw new Error(String(type));
+  }
+  return feature;
 }
-var xRegex = new RegExp("{x}", "g");
-var yRegex = new RegExp("{y}", "g");
-var zRegex = new RegExp("{z}", "g");
-function getURLFromTemplate(template, x, y, z, id = "0") {
-  if (Array.isArray(template)) {
-    const i = stringHash(id) % template.length;
-    template = template[i];
-  }
-  let url = template;
-  url = url.replace(xRegex, String(x));
-  url = url.replace(yRegex, String(y));
-  url = url.replace(zRegex, String(z));
-  if (Number.isInteger(y) && Number.isInteger(z)) {
-    url = url.replace(/\{-y\}/g, String(Math.pow(2, z) - y - 1));
+function calcLineBBox(feature, geometry) {
+  for (let i = 0; i < geometry.length; i += 3) {
+    feature.minX = Math.min(feature.minX, geometry[i]);
+    feature.minY = Math.min(feature.minY, geometry[i + 1]);
+    feature.maxX = Math.max(feature.maxX, geometry[i]);
+    feature.maxY = Math.max(feature.maxY, geometry[i + 1]);
   }
-  return url;
-}
-function stringHash(s) {
-  return Math.abs(s.split("").reduce((a, b) => (a << 5) - a + b.charCodeAt(0) | 0, 0));
 }
 
-// dist/lib/geojsonvt/simplify.js
-function simplify(coords, first, last, sqTolerance) {
+// dist/lib/vector-tiler/features/simplify-path.js
+function simplifyPath(coords, first, last, sqTolerance) {
   let maxSqDist = sqTolerance;
   const mid = last - first >> 1;
   let minPosToMid = last - first;
@@ -1103,10 +1436,10 @@ function simplify(coords, first, last, sqTolerance) {
   }
   if (maxSqDist > sqTolerance) {
     if (index - first > 3)
-      simplify(coords, first, index, sqTolerance);
+      simplifyPath(coords, first, index, sqTolerance);
     coords[index + 2] = maxSqDist;
     if (last - index > 3)
-      simplify(coords, index, last, sqTolerance);
+      simplifyPath(coords, index, last, sqTolerance);
   }
 }
 function getSqSegDist(px, py, x, y, bx, by) {
@@ -1127,58 +1460,25 @@ function getSqSegDist(px, py, x, y, bx, by) {
   return dx * dx + dy * dy;
 }
 
-// dist/lib/geojsonvt/feature.js
-function createFeature(id, type, geom, tags) {
-  const feature = {
-    // eslint-disable-next-line
-    id: id == null ? null : id,
-    type,
-    geometry: geom,
-    tags,
-    minX: Infinity,
-    minY: Infinity,
-    maxX: -Infinity,
-    maxY: -Infinity
-  };
-  if (type === "Point" || type === "MultiPoint" || type === "LineString") {
-    calcLineBBox(feature, geom);
-  } else if (type === "Polygon") {
-    calcLineBBox(feature, geom[0]);
-  } else if (type === "MultiLineString") {
-    for (const line of geom) {
-      calcLineBBox(feature, line);
-    }
-  } else if (type === "MultiPolygon") {
-    for (const polygon of geom) {
-      calcLineBBox(feature, polygon[0]);
-    }
-  }
-  return feature;
-}
-function calcLineBBox(feature, geom) {
-  for (let i = 0; i < geom.length; i += 3) {
-    feature.minX = Math.min(feature.minX, geom[i]);
-    feature.minY = Math.min(feature.minY, geom[i + 1]);
-    feature.maxX = Math.max(feature.maxX, geom[i]);
-    feature.maxY = Math.max(feature.maxY, geom[i + 1]);
-  }
-}
-
-// dist/lib/geojsonvt/convert.js
-function convert(data, options) {
-  const features = [];
-  if (data.type === "FeatureCollection") {
-    for (let i = 0; i < data.features.length; i++) {
-      convertFeature(features, data.features[i], options, i);
-    }
-  } else if (data.type === "Feature") {
-    convertFeature(features, data, options);
-  } else {
-    convertFeature(features, { geometry: data }, options);
+// dist/lib/vector-tiler/features/convert-feature.js
+function convertFeaturesToProtoFeature(data, options) {
+  const protoFeatures = [];
+  switch (data.type) {
+    case "FeatureCollection":
+      let i = 0;
+      for (const feature of data.features) {
+        protoFeatures.push(convertFeature(feature, options, i++));
+      }
+      break;
+    case "Feature":
+      protoFeatures.push(convertFeature(data, options));
+      break;
+    default:
+      protoFeatures.push(convertFeature({ geometry: data }, options));
   }
-  return features;
+  return protoFeatures;
 }
-function convertFeature(features, geojson, options, index) {
+function convertFeature(geojson, options, index) {
   if (!geojson.geometry) {
     return;
   }
@@ -1192,46 +1492,52 @@ function convertFeature(features, geojson, options, index) {
   } else if (options.generateId) {
     id = index || 0;
   }
-  if (type === "Point") {
-    convertPoint(coords, geometry);
-  } else if (type === "MultiPoint") {
-    for (const p of coords) {
-      convertPoint(p, geometry);
-    }
-  } else if (type === "LineString") {
-    convertLine(coords, geometry, tolerance, false);
-  } else if (type === "MultiLineString") {
-    if (options.lineMetrics) {
-      for (const line of coords) {
-        geometry = [];
-        convertLine(line, geometry, tolerance, false);
-        features.push(createFeature(id, "LineString", geometry, geojson.properties));
+  switch (type) {
+    case "Point":
+      convertPoint(coords, geometry);
+      break;
+    case "MultiPoint":
+      for (const p of coords) {
+        convertPoint(p, geometry);
       }
-      return;
-    } else {
-      convertLines(coords, geometry, tolerance, false);
-    }
-  } else if (type === "Polygon") {
-    convertLines(coords, geometry, tolerance, true);
-  } else if (type === "MultiPolygon") {
-    for (const polygon of coords) {
-      const newPolygon = [];
-      convertLines(polygon, newPolygon, tolerance, true);
-      geometry.push(newPolygon);
-    }
-  } else if (type === "GeometryCollection") {
-    for (const singleGeometry of geojson.geometry.geometries) {
-      convertFeature(features, {
-        id,
-        geometry: singleGeometry,
-        properties: geojson.properties
-      }, options, index);
-    }
-    return;
-  } else {
-    throw new Error("Input data is not a valid GeoJSON object.");
+      break;
+    case "LineString":
+      convertLine(coords, geometry, tolerance, false);
+      break;
+    case "MultiLineString":
+      if (options.lineMetrics) {
+        for (const line of coords) {
+          geometry = [];
+          convertLine(line, geometry, tolerance, false);
+          features.push(createProtoFeature(id, "LineString", geometry, geojson.properties));
+        }
+        return;
+        convertLines(coords, geometry, tolerance, false);
+      }
+      break;
+    case "Polygon":
+      convertLines(coords, geometry, tolerance, true);
+      break;
+    case "MultiPolygon":
+      for (const polygon of coords) {
+        const newPolygon = [];
+        convertLines(polygon, newPolygon, tolerance, true);
+        geometry.push(newPolygon);
+      }
+      break;
+    case "GeometryCollection":
+      for (const singleGeometry of geojson.geometry.geometries) {
+        convertFeature(features, {
+          id,
+          geometry: singleGeometry,
+          properties: geojson.properties
+        }, options, index);
+      }
+      break;
+    default:
+      throw new Error("Input data is not a valid GeoJSON object.");
   }
-  features.push(createFeature(id, type, geometry, geojson.properties));
+  return createProtoFeature(id, type, geometry, geojson.properties);
 }
 function convertPoint(coords, out) {
   out.push(projectX(coords[0]), projectY(coords[1]), 0);
@@ -1255,7 +1561,7 @@ function convertLine(ring, out, tolerance, isPolygon) {
   }
   const last = out.length - 3;
   out[2] = 1;
-  simplify(out, 0, last, tolerance);
+  simplifyPath(out, 0, last, tolerance);
   out[last + 2] = 1;
   out.size = Math.abs(size);
   out.start = 0;
@@ -1277,17 +1583,17 @@ function projectY(y) {
   return y2 < 0 ? 0 : y2 > 1 ? 1 : y2;
 }
 
-// dist/lib/geojsonvt/clip.js
-function clip(features, scale, k1, k2, axis, minAll, maxAll, options) {
+// dist/lib/vector-tiler/features/clip-features.js
+function clipFeatures(features2, scale, k1, k2, axis, minAll, maxAll, options) {
   k1 /= scale;
   k2 /= scale;
   if (minAll >= k1 && maxAll < k2) {
-    return features;
+    return features2;
   } else if (maxAll < k1 || minAll >= k2) {
     return null;
   }
   const clipped = [];
-  for (const feature of features) {
+  for (const feature of features2) {
     const geometry = feature.geometry;
     let type = feature.type;
     const min = axis === 0 ? feature.minX : feature.minY;
@@ -1319,7 +1625,7 @@ function clip(features, scale, k1, k2, axis, minAll, maxAll, options) {
     if (newGeometry.length) {
       if (options.lineMetrics && type === "LineString") {
         for (const line of newGeometry) {
-          clipped.push(createFeature(feature.id, type, line, feature.tags));
+          clipped.push(createProtoFeature(feature.id, type, line, feature.tags));
         }
         continue;
       }
@@ -1334,7 +1640,7 @@ function clip(features, scale, k1, k2, axis, minAll, maxAll, options) {
       if (type === "Point" || type === "MultiPoint") {
         type = newGeometry.length === 3 ? "Point" : "MultiPoint";
       }
-      clipped.push(createFeature(feature.id, type, newGeometry, feature.tags));
+      clipped.push(createProtoFeature(feature.id, type, newGeometry, feature.tags));
     }
   }
   return clipped.length ? clipped : null;
@@ -1442,14 +1748,14 @@ function intersectY(out, ax, ay, bx, by, y) {
   return t;
 }
 
-// dist/lib/geojsonvt/wrap.js
-function wrap(features, options) {
+// dist/lib/vector-tiler/features/wrap-features.js
+function wrapFeatures(features2, options) {
   const buffer = options.buffer / options.extent;
-  let merged = features;
-  const left = clip(features, 1, -1 - buffer, buffer, 0, -1, 2, options);
-  const right = clip(features, 1, 1 - buffer, 2 + buffer, 0, -1, 2, options);
+  let merged = features2;
+  const left = clipFeatures(features2, 1, -1 - buffer, buffer, 0, -1, 2, options);
+  const right = clipFeatures(features2, 1, 1 - buffer, 2 + buffer, 0, -1, 2, options);
   if (left || right) {
-    merged = clip(features, 1, -buffer, 1 + buffer, 0, -1, 2, options) || [];
+    merged = clipFeatures(features2, 1, -buffer, 1 + buffer, 0, -1, 2, options) || [];
     if (left) {
       merged = shiftFeatureCoords(left, 1).concat(merged);
     }
@@ -1459,30 +1765,39 @@ function wrap(features, options) {
   }
   return merged;
 }
-function shiftFeatureCoords(features, offset) {
+function shiftFeatureCoords(features2, offset) {
   const newFeatures = [];
-  for (let i = 0; i < features.length; i++) {
-    const feature = features[i];
+  for (let i = 0; i < features2.length; i++) {
+    const feature = features2[i];
     const type = feature.type;
     let newGeometry;
-    if (type === "Point" || type === "MultiPoint" || type === "LineString") {
-      newGeometry = shiftCoords(feature.geometry, offset);
-    } else if (type === "MultiLineString" || type === "Polygon") {
-      newGeometry = [];
-      for (const line of feature.geometry) {
-        newGeometry.push(shiftCoords(line, offset));
-      }
-    } else if (type === "MultiPolygon") {
-      newGeometry = [];
-      for (const polygon of feature.geometry) {
-        const newPolygon = [];
-        for (const line of polygon) {
-          newPolygon.push(shiftCoords(line, offset));
+    switch (type) {
+      case "Point":
+      case "MultiPoint":
+      case "LineString":
+        newGeometry = shiftCoords(feature.geometry, offset);
+        break;
+      case "MultiLineString":
+      case "Polygon":
+        newGeometry = [];
+        for (const line of feature.geometry) {
+          newGeometry.push(shiftCoords(line, offset));
         }
-        newGeometry.push(newPolygon);
-      }
+        break;
+      case "MultiPolygon":
+        newGeometry = [];
+        for (const polygon of feature.geometry) {
+          const newPolygon = [];
+          for (const line of polygon) {
+            newPolygon.push(shiftCoords(line, offset));
+          }
+          newGeometry.push(newPolygon);
+        }
+        break;
+      default:
+        throw new Error(String(type));
     }
-    newFeatures.push(createFeature(feature.id, type, newGeometry, feature.tags));
+    newFeatures.push(createProtoFeature(feature.id, type, newGeometry, feature.tags));
   }
   return newFeatures;
 }
@@ -1499,196 +1814,86 @@ function shiftCoords(points, offset) {
   return newPoints;
 }
 
-// dist/lib/geojsonvt/transform.js
-function transformTile(tile, extent) {
-  if (tile.transformed) {
-    return tile;
-  }
-  const z2 = 1 << tile.z;
-  const tx = tile.x;
-  const ty = tile.y;
-  for (const feature of tile.features) {
-    const geom = feature.geometry;
-    const type = feature.type;
-    feature.geometry = [];
-    if (type === 1) {
-      for (let j = 0; j < geom.length; j += 2) {
-        feature.geometry.push(transformPoint(geom[j], geom[j + 1], extent, z2, tx, ty));
-      }
-    } else {
-      for (let j = 0; j < geom.length; j++) {
-        const ring = [];
-        for (let k = 0; k < geom[j].length; k += 2) {
-          ring.push(transformPoint(geom[j][k], geom[j][k + 1], extent, z2, tx, ty));
-        }
-        feature.geometry.push(ring);
-      }
-    }
-  }
-  tile.transformed = true;
-  return tile;
-}
-function transformPoint(x, y, extent, z2, tx, ty) {
-  return [Math.round(extent * (x * z2 - tx)), Math.round(extent * (y * z2 - ty))];
-}
-
-// dist/lib/geojsonvt/tile.js
-function createTile(features, z, tx, ty, options) {
-  const tolerance = z === options.maxZoom ? 0 : options.tolerance / ((1 << z) * options.extent);
-  const tile = {
-    features: [],
-    numPoints: 0,
-    numSimplified: 0,
-    numFeatures: features.length,
-    source: null,
-    x: tx,
-    y: ty,
-    z,
-    transformed: false,
-    minX: 2,
-    minY: 1,
-    maxX: -1,
-    maxY: 0
-  };
-  for (const feature of features) {
-    addFeature(tile, feature, tolerance, options);
-  }
-  return tile;
-}
-function addFeature(tile, feature, tolerance, options) {
-  const geom = feature.geometry;
-  const type = feature.type;
-  const simplified = [];
-  tile.minX = Math.min(tile.minX, feature.minX);
-  tile.minY = Math.min(tile.minY, feature.minY);
-  tile.maxX = Math.max(tile.maxX, feature.maxX);
-  tile.maxY = Math.max(tile.maxY, feature.maxY);
-  if (type === "Point" || type === "MultiPoint") {
-    for (let i = 0; i < geom.length; i += 3) {
-      simplified.push(geom[i], geom[i + 1]);
-      tile.numPoints++;
-      tile.numSimplified++;
-    }
-  } else if (type === "LineString") {
-    addLine(simplified, geom, tile, tolerance, false, false);
-  } else if (type === "MultiLineString" || type === "Polygon") {
-    for (let i = 0; i < geom.length; i++) {
-      addLine(simplified, geom[i], tile, tolerance, type === "Polygon", i === 0);
-    }
-  } else if (type === "MultiPolygon") {
-    for (let k = 0; k < geom.length; k++) {
-      const polygon = geom[k];
-      for (let i = 0; i < polygon.length; i++) {
-        addLine(simplified, polygon[i], tile, tolerance, true, i === 0);
-      }
-    }
-  }
-  if (simplified.length) {
-    let tags = feature.tags || null;
-    if (type === "LineString" && options.lineMetrics) {
-      tags = {};
-      for (const key in feature.tags)
-        tags[key] = feature.tags[key];
-      tags.mapbox_clip_start = geom.start / geom.size;
-      tags.mapbox_clip_end = geom.end / geom.size;
-    }
-    const tileFeature = {
-      geometry: simplified,
-      type: type === "Polygon" || type === "MultiPolygon" ? 3 : type === "LineString" || type === "MultiLineString" ? 2 : 1,
-      tags
-    };
-    if (feature.id !== null) {
-      tileFeature.id = feature.id;
-    }
-    tile.features.push(tileFeature);
-  }
-}
-function addLine(result, geom, tile, tolerance, isPolygon, isOuter) {
-  const sqTolerance = tolerance * tolerance;
-  if (tolerance > 0 && geom.size < (isPolygon ? sqTolerance : tolerance)) {
-    tile.numPoints += geom.length / 3;
-    return;
-  }
-  const ring = [];
-  for (let i = 0; i < geom.length; i += 3) {
-    if (tolerance === 0 || geom[i + 2] > sqTolerance) {
-      tile.numSimplified++;
-      ring.push(geom[i], geom[i + 1]);
-    }
-    tile.numPoints++;
-  }
-  if (isPolygon)
-    rewind(ring, isOuter);
-  result.push(ring);
-}
-function rewind(ring, clockwise) {
-  let area = 0;
-  for (let i = 0, j = ring.length - 2; i < ring.length; j = i, i += 2) {
-    area += (ring[i] - ring[j]) * (ring[i + 1] + ring[j + 1]);
-  }
-  if (area > 0 === clockwise) {
-    for (let i = 0, len = ring.length; i < len / 2; i += 2) {
-      const x = ring[i];
-      const y = ring[i + 1];
-      ring[i] = ring[len - 2 - i];
-      ring[i + 1] = ring[len - 1 - i];
-      ring[len - 2 - i] = x;
-      ring[len - 1 - i] = y;
+// dist/table-tile-source.js
+var TableTileSource = {
+  name: "TableTiler",
+  id: "table-tiler",
+  version: "0.0.0",
+  extensions: ["mvt"],
+  mimeTypes: ["application/octet-stream"],
+  options: {
+    table: {
+      coordinates: "local",
+      promoteId: void 0,
+      maxZoom: 14,
+      indexMaxZoom: 5,
+      maxPointsPerTile: 1e4,
+      tolerance: 3,
+      extent: 4096,
+      buffer: 64,
+      generateId: void 0
     }
+  },
+  type: "table",
+  testURL: (url) => url.endsWith(".geojson"),
+  createDataSource(url, options) {
+    var _a, _b;
+    const needsLoading = typeof url === "string" || url instanceof Blob;
+    const loader = (_b = (_a = options == null ? void 0 : options.table) == null ? void 0 : _a.loaders) == null ? void 0 : _b[0];
+    const tablePromise = needsLoading ? loadTable(url, loader) : url;
+    return new DynamicVectorTileSource(tablePromise, options);
   }
-}
-
-// dist/geojson-tile-source.js
-var _GeoJSONTileSource = class {
+  // @ts-expect-error
+};
+async function loadTable(url, loader) {
+  if (typeof url === "string") {
+    const response = await fetch(url);
+    const data2 = await response.arrayBuffer();
+    return await loader.parse(data2);
+  }
+  const data = await url.arrayBuffer();
+  return await loader.parse(data);
+}
+var _DynamicVectorTileSource = class {
+  /** Stats for this DynamicVectorTileSource */
+  stats = new import_stats.Stats({
+    id: "table-tile-source",
+    stats: [new import_stats.Stat("tiles", "count"), new import_stats.Stat("features", "count")]
+  });
+  /** MIME type of the tiles emitted by this tile source */
   mimeType = "application/vnd.mapbox-vector-tile";
-  options;
-  // tiles and tileCoords are part of the public API
+  localCoordinates = true;
+  /** The props that this tile source was created with */
+  // @ts-expect-error
+  props;
+  /* Schema of the data */
+  schema = null;
+  /** Map of generated tiles, indexed by stringified tile coordinates */
   tiles = {};
+  /** Array of tile coordinates */
   tileCoords = [];
-  stats = {};
-  total = 0;
-  /** Sync methods can be called: the input data promise has been resolved and initial top-level tiling is done */
+  /** Input data has loaded, initial top-level tiling is done, sync methods can now be called */
   ready;
-  constructor(data, options) {
-    this.options = { ..._GeoJSONTileSource.defaultOptions, ...options };
+  /** Metadata for the tile source (generated TileJSON/tilestats */
+  metadata;
+  constructor(table, props) {
+    this.props = { ...TableTileSource.options.table, ...props == null ? void 0 : props.table };
     this.getTileData = this.getTileData.bind(this);
-    this.ready = this.initializeTilesAsync(data);
-  }
-  async initializeTilesAsync(dataPromise) {
-    const data = await dataPromise;
-    this.initializeTilesSync(data);
-  }
-  initializeTilesSync(data) {
-    const options = this.options;
-    const debug = options.debug;
-    if (debug)
-      console.time("preprocess data");
-    if (this.options.maxZoom < 0 || this.options.maxZoom > 24) {
-      throw new Error("maxZoom should be in the 0-24 range");
-    }
-    if (options.promoteId && this.options.generateId) {
-      throw new Error("promoteId and generateId cannot be used together.");
-    }
-    let features = convert(data, options);
-    if (debug) {
-      console.timeEnd("preprocess data");
-      console.log("index: maxZoom: %d, maxPoints: %d", options.indexMaxZoom, options.indexMaxPoints);
-      console.time("generate tiles");
-    }
-    features = wrap(features, this.options);
-    if (features.length) {
-      this.splitTile(features, 0, 0, 0);
-    }
-    if (debug) {
-      if (features.length) {
-        console.log("features: %d, points: %d", this.tiles[0].numFeatures, this.tiles[0].numPoints);
-      }
-      console.timeEnd("generate tiles");
-      console.log("tiles generated:", this.total, JSON.stringify(this.stats));
-    }
+    this.ready = this.initializeTilesAsync(table);
+    this.metadata = this.getMetadata();
+  }
+  async initializeTilesAsync(tablePromise) {
+    const table = await tablePromise;
+    this.schema = (0, import_schema.deduceTableSchema)(table);
+    this.createRootTiles(table);
   }
   async getMetadata() {
-    return {};
+    await this.ready;
+    return { schema: this.schema, minZoom: 0, maxZoom: this.props.maxZoom };
+  }
+  async getSchema() {
+    await this.ready;
+    return this.schema;
   }
   /**
    * Get a tile at the specified index
@@ -1698,6 +1903,7 @@ var _GeoJSONTileSource = class {
   async getVectorTile(tileIndex) {
     await this.ready;
     const table = this.getTileSync(tileIndex);
+    import_loader_utils3.log.info(2, "getVectorTile", tileIndex, table)();
     return table;
   }
   async getTile(tileIndex) {
@@ -1706,7 +1912,8 @@ var _GeoJSONTileSource = class {
   }
   async getTileData(tileParams) {
     const { x, y, z } = tileParams.index;
-    return await this.getVectorTile({ x, y, z });
+    const tile = await this.getVectorTile({ x, y, z });
+    return (tile == null ? void 0 : tile.features) || [];
   }
   // Implementation
   /**
@@ -1714,21 +1921,52 @@ var _GeoJSONTileSource = class {
    * @note Application must await `source.ready` before calling sync methods.
    */
   getTileSync(tileIndex) {
-    const rawTile = this.getRawTile(tileIndex);
-    if (!rawTile) {
+    const protoTile = this.getProtoTile(tileIndex);
+    if (!protoTile) {
       return null;
     }
-    return convertToGeoJSONTable(rawTile, this.options.extent);
+    return convertTileToGeoJSON(protoTile, {
+      coordinates: this.props.coordinates,
+      tileIndex,
+      extent: this.props.extent
+    });
+  }
+  /**
+   * Create the initial tiles
+   * @note the tiles stores all the features together with additional data
+   */
+  createRootTiles(table) {
+    if (this.props.maxZoom < 0 || this.props.maxZoom > 24) {
+      throw new Error("maxZoom should be in the 0-24 range");
+    }
+    if (this.props.promoteId && this.props.generateId) {
+      throw new Error("promoteId and generateId cannot be used together.");
+    }
+    import_loader_utils3.log.log(1, "DynamicVectorTileSource creating root tiles", this.props)();
+    import_loader_utils3.log.time(1, "preprocess table")();
+    let features2 = convertFeaturesToProtoFeature(table, this.props);
+    import_loader_utils3.log.timeEnd(1, "preprocess table")();
+    import_loader_utils3.log.time(1, "generate tiles")();
+    features2 = wrapFeatures(features2, this.props);
+    if (features2.length === 0) {
+      import_loader_utils3.log.log(1, "DynamicVectorTileSource: no features generated")();
+      return;
+    }
+    this.splitTile(features2, 0, 0, 0);
+    const rootTile = this.tiles[0];
+    import_loader_utils3.log.log(1, `root tile features: ${rootTile.numFeatures}, points: ${rootTile.numPoints}`)();
+    import_loader_utils3.log.timeEnd(1, "generate tiles")();
+    import_loader_utils3.log.log(1, `DynamicVectorTileSource: tiles generated: ${this.stats.get("total").count}`, this.stats)();
   }
   /**
    * Return geojsonvt-style "half formed" vector tile
    * @note Application must await `source.ready` before calling sync methods.
    */
   // eslint-disable-next-line complexity, max-statements
-  getRawTile(tileIndex) {
+  getProtoTile(tileIndex) {
     const { z, y } = tileIndex;
     let { x } = tileIndex;
-    const { extent, debug } = this.options;
+    const { extent } = this.props;
     if (z < 0 || z > 24) {
       return null;
     }
@@ -1738,8 +1976,7 @@ var _GeoJSONTileSource = class {
     if (this.tiles[id]) {
       return transformTile(this.tiles[id], extent);
     }
-    if (debug > 1)
-      console.log("drilling down to z%d-%d-%d", z, x, y);
+    import_loader_utils3.log.log(import_loader_utils3.log, "drilling down to z%d-%d-%d", z, x, y)();
     let z0 = z;
     let x0 = x;
     let y0 = y;
@@ -1750,17 +1987,13 @@ var _GeoJSONTileSource = class {
       y0 = y0 >> 1;
       parent = this.tiles[toID(z0, x0, y0)];
     }
-    if (!parent || !parent.source) {
+    if (!parent || !parent.sourceFeatures) {
       return null;
     }
-    if (debug > 1) {
-      console.log("found parent tile z%d-%d-%d", z0, x0, y0);
-      console.time("drilling down");
-    }
-    this.splitTile(parent.source, z0, x0, y0, z, x, y);
-    if (debug > 1) {
-      console.timeEnd("drilling down");
-    }
+    import_loader_utils3.log.log(1, "found parent tile z%d-%d-%d", z0, x0, y0)();
+    import_loader_utils3.log.time(1, "drilling down")();
+    this.splitTile(parent.sourceFeatures, z0, x0, y0, z, x, y);
+    import_loader_utils3.log.timeEnd(1, "drilling down")();
     return this.tiles[id] ? transformTile(this.tiles[id], extent) : null;
   }
   /**
@@ -1769,54 +2002,53 @@ var _GeoJSONTileSource = class {
    * @param cz, cx, and cy are the coordinates of the target tile
    *
    * If no target tile is specified, splitting stops when we reach the maximum
-   * zoom or the number of points is low as specified in the options.
+   * zoom or the number of points is low as specified in the props.
    */
   // eslint-disable-next-line max-params, max-statements, complexity
-  splitTile(features, z, x, y, cz, cx, cy) {
-    const stack = [features, z, x, y];
-    const options = this.options;
-    const debug = options.debug;
+  splitTile(features2, z, x, y, cz, cx, cy) {
+    const stack = [features2, z, x, y];
     while (stack.length) {
       y = stack.pop();
       x = stack.pop();
       z = stack.pop();
-      features = stack.pop();
+      features2 = stack.pop();
       const z2 = 1 << z;
       const id = toID(z, x, y);
       let tile = this.tiles[id];
       if (!tile) {
-        if (debug > 1) {
-          console.time("creation");
-        }
-        tile = this.tiles[id] = createTile(features, z, x, y, options);
+        import_loader_utils3.log.time(2, "tile creation")();
+        tile = this.tiles[id] = createProtoTile(features2, z, x, y, this.props);
         this.tileCoords.push({ z, x, y });
-        if (debug) {
-          if (debug > 1) {
-            console.log("tile z%d-%d-%d (features: %d, points: %d, simplified: %d)", z, x, y, tile.numFeatures, tile.numPoints, tile.numSimplified);
-            console.timeEnd("creation");
-          }
-          const key = `z${z}`;
-          this.stats[key] = (this.stats[key] || 0) + 1;
-          this.total++;
-        }
+        const key = `z${z}`;
+        let stat = this.stats.get(key, "count");
+        stat.incrementCount();
+        stat = this.stats.get("total");
+        stat.incrementCount();
+        stat = _DynamicVectorTileSource.stats.get(key, "count");
+        stat.incrementCount();
+        stat = _DynamicVectorTileSource.stats.get("total");
+        stat.incrementCount();
+        import_loader_utils3.log.log(2, "tile z%d-%d-%d (features: %d, points: %d, simplified: %d)", z, x, y, tile.numFeatures, tile.numPoints, tile.numSimplified)();
+        import_loader_utils3.log.timeEnd(2, "tile creation")();
       }
-      tile.source = features;
+      tile.sourceFeatures = features2;
       if (cz === void 0) {
-        if (z === options.indexMaxZoom || tile.numPoints <= options.indexMaxPoints)
+        if (z === this.props.indexMaxZoom || tile.numPoints <= this.props.maxPointsPerTile) {
           continue;
-      } else if (z === options.maxZoom || z === cz) {
+        }
+      } else if (z === this.props.maxZoom || z === cz) {
         continue;
       } else if (cz !== void 0) {
         const zoomSteps = cz - z;
-        if (x !== cx >> zoomSteps || y !== cy >> zoomSteps)
+        if (x !== cx >> zoomSteps || y !== cy >> zoomSteps) {
           continue;
+        }
       }
-      tile.source = null;
-      if (features.length === 0)
+      tile.sourceFeatures = null;
+      if (features2.length === 0)
         continue;
-      if (debug > 1)
-        console.time("clipping");
-      const k1 = 0.5 * options.buffer / options.extent;
+      import_loader_utils3.log.time(2, "clipping tile")();
+      const k1 = 0.5 * this.props.buffer / this.props.extent;
       const k2 = 0.5 - k1;
       const k3 = 0.5 + k1;
       const k4 = 1 + k1;
@@ -1824,21 +2056,20 @@ var _GeoJSONTileSource = class {
       let bl = null;
       let tr = null;
       let br = null;
-      let left = clip(features, z2, x - k1, x + k3, 0, tile.minX, tile.maxX, options);
-      let right = clip(features, z2, x + k2, x + k4, 0, tile.minX, tile.maxX, options);
-      features = null;
+      let left = clipFeatures(features2, z2, x - k1, x + k3, 0, tile.minX, tile.maxX, this.props);
+      let right = clipFeatures(features2, z2, x + k2, x + k4, 0, tile.minX, tile.maxX, this.props);
+      features2 = null;
       if (left) {
-        tl = clip(left, z2, y - k1, y + k3, 1, tile.minY, tile.maxY, options);
-        bl = clip(left, z2, y + k2, y + k4, 1, tile.minY, tile.maxY, options);
+        tl = clipFeatures(left, z2, y - k1, y + k3, 1, tile.minY, tile.maxY, this.props);
+        bl = clipFeatures(left, z2, y + k2, y + k4, 1, tile.minY, tile.maxY, this.props);
         left = null;
       }
       if (right) {
-        tr = clip(right, z2, y - k1, y + k3, 1, tile.minY, tile.maxY, options);
-        br = clip(right, z2, y + k2, y + k4, 1, tile.minY, tile.maxY, options);
+        tr = clipFeatures(right, z2, y - k1, y + k3, 1, tile.minY, tile.maxY, this.props);
+        br = clipFeatures(right, z2, y + k2, y + k4, 1, tile.minY, tile.maxY, this.props);
         right = null;
       }
-      if (debug > 1)
-        console.timeEnd("clipping");
+      import_loader_utils3.log.timeEnd(2, "clipping tile")();
       stack.push(tl || [], z + 1, x * 2, y * 2);
       stack.push(bl || [], z + 1, x * 2, y * 2 + 1);
       stack.push(tr || [], z + 1, x * 2 + 1, y * 2);
@@ -1846,94 +2077,13 @@ var _GeoJSONTileSource = class {
     }
   }
 };
-var GeoJSONTileSource = _GeoJSONTileSource;
-__publicField(GeoJSONTileSource, "defaultOptions", {
-  maxZoom: 14,
-  // max zoom to preserve detail on
-  indexMaxZoom: 5,
-  // max zoom in the tile index
-  indexMaxPoints: 1e5,
-  // max number of points per tile in the tile index
-  tolerance: 3,
-  // simplification tolerance (higher means simpler)
-  extent: 4096,
-  // tile extent
-  buffer: 64,
-  // tile buffer on each side
-  lineMetrics: false,
-  // whether to calculate line metrics
-  // @ts-expect-error
-  promoteId: void 0,
-  // name of a feature property to be promoted to feature.id
-  generateId: false,
-  // whether to generate feature ids. Cannot be used with promoteId
-  debug: 0
-  // logging level (0, 1 or 2)
-});
+var DynamicVectorTileSource = _DynamicVectorTileSource;
+/** Global stats for all DynamicVectorTileSources */
+__publicField(DynamicVectorTileSource, "stats", new import_stats.Stats({
+  id: "table-tile-source-all",
+  stats: [new import_stats.Stat("count", "tiles"), new import_stats.Stat("count", "features")]
+}));
 function toID(z, x, y) {
   return ((1 << z) * y + x) * 32 + z;
 }
-function convertToGeoJSONTable(vtTile, extent) {
-  const features = [];
-  for (const rawFeature of vtTile.features) {
-    if (!rawFeature || !rawFeature.geometry) {
-      continue;
-    }
-    let type;
-    let coordinates;
-    switch (rawFeature.type) {
-      case 1:
-        if (rawFeature.geometry.length === 1) {
-          type = "Point";
-          coordinates = rawFeature.geometry[0];
-        } else {
-          type = "MultiPoint";
-          coordinates = rawFeature.geometry;
-        }
-        break;
-      case 2:
-        if (rawFeature.geometry.length === 1) {
-          type = "LineString";
-          coordinates = rawFeature.geometry[0];
-        } else {
-          type = "MultiLineString";
-          coordinates = rawFeature.geometry;
-        }
-        break;
-      case 3:
-        if (rawFeature.geometry.length > 1) {
-          type = "MultiPolygon";
-          coordinates = [rawFeature.geometry];
-        } else {
-          type = "Polygon";
-          coordinates = rawFeature.geometry;
-        }
-        break;
-      default:
-        continue;
-    }
-    coordinates = toLngLat(coordinates, extent);
-    const feature = {
-      type: "Feature",
-      geometry: {
-        type,
-        coordinates
-      },
-      properties: rawFeature.tags || {}
-    };
-    features.push(feature);
-  }
-  const table = {
-    shape: "geojson-table",
-    type: "FeatureCollection",
-    features
-  };
-  return table;
-}
-function toLngLat(coords, extent) {
-  if (Array.isArray(coords[0])) {
-    return coords.map((c) => toLngLat(c, extent));
-  }
-  return [coords[0] / extent, coords[1] / extent];
-}
 //# sourceMappingURL=index.cjs.map