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

package/dist/dist.dev.js

@@ -793,14 +793,377 @@ var __exports__ = (() => {
   // bundle.ts
   var bundle_exports = {};
   __export(bundle_exports, {
-    GeoJSONTileSource: () => GeoJSONTileSource,
     MVTLoader: () => MVTLoader,
     MVTSource: () => MVTSource,
     MVTWorkerLoader: () => MVTWorkerLoader,
+    TableTileSource: () => TableTileSource,
     TileJSONLoader: () => TileJSONLoader
   });
   __reExport(bundle_exports, __toESM(require_core(), 1));
 
+  // src/lib/parse-tilejson.ts
+  var isObject = (x) => x !== null && typeof x === "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" };
+  }
+
+  // src/tilejson-loader.ts
+  var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "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?.tilejson };
+      return parseTileJSON(json, tilejsonOptions);
+    },
+    parseTextSync: (text, options) => {
+      const json = JSON.parse(text);
+      const tilejsonOptions = { ...TileJSONLoader.options.tilejson, ...options?.tilejson };
+      return parseTileJSON(json, tilejsonOptions);
+    }
+  };
+
+  // ../schema/src/lib/table/simple-table/data-type.ts
+  function getDataTypeFromValue(value, defaultNumberType = "float32") {
+    if (value instanceof Date) {
+      return "date-millisecond";
+    }
+    if (value instanceof Number) {
+      return defaultNumberType;
+    }
+    if (typeof value === "string") {
+      return "utf8";
+    }
+    if (value === null || value === "undefined") {
+      return "null";
+    }
+    return "null";
+  }
+  function getDataTypeFromArray(array) {
+    let type = getDataTypeFromTypedArray(array);
+    if (type !== "null") {
+      return { type, nullable: false };
+    }
+    if (array.length > 0) {
+      type = getDataTypeFromValue(array[0]);
+      return { type, nullable: true };
+    }
+    return { type: "null", nullable: true };
+  }
+  function getDataTypeFromTypedArray(array) {
+    switch (array.constructor) {
+      case Int8Array:
+        return "int8";
+      case Uint8Array:
+      case Uint8ClampedArray:
+        return "uint8";
+      case Int16Array:
+        return "int16";
+      case Uint16Array:
+        return "uint16";
+      case Int32Array:
+        return "int32";
+      case Uint32Array:
+        return "uint32";
+      case Float32Array:
+        return "float32";
+      case Float64Array:
+        return "float64";
+      default:
+        return "null";
+    }
+  }
+
+  // ../schema/src/lib/table/simple-table/table-schema.ts
+  function deduceTableSchema(table) {
+    switch (table.shape) {
+      case "array-row-table":
+      case "object-row-table":
+        return deduceSchemaFromRows(table.data);
+      case "geojson-table":
+        return deduceSchemaFromGeoJSON(table.features);
+      case "columnar-table":
+        return deduceSchemaFromColumns(table.data);
+      case "arrow-table":
+      default:
+        throw new Error("Deduce schema");
+    }
+  }
+  function deduceSchemaFromColumns(columnarTable) {
+    const fields = [];
+    for (const [columnName, column] of Object.entries(columnarTable)) {
+      const field = deduceFieldFromColumn(column, columnName);
+      fields.push(field);
+    }
+    return { fields, metadata: {} };
+  }
+  function deduceSchemaFromRows(rowTable) {
+    if (!rowTable.length) {
+      throw new Error("deduce from empty table");
+    }
+    const fields = [];
+    const row0 = rowTable[0];
+    for (const [columnName, value] of Object.entries(row0)) {
+      fields.push(deduceFieldFromValue(value, columnName));
+    }
+    return { fields, metadata: {} };
+  }
+  function deduceSchemaFromGeoJSON(features2) {
+    if (!features2.length) {
+      throw new Error("deduce from empty table");
+    }
+    const fields = [];
+    const row0 = features2[0].properties || {};
+    for (const [columnName, value] of Object.entries(row0)) {
+      fields.push(deduceFieldFromValue(value, columnName));
+    }
+    return { fields, metadata: {} };
+  }
+  function deduceFieldFromColumn(column, name) {
+    if (ArrayBuffer.isView(column)) {
+      const type = getDataTypeFromArray(column);
+      return {
+        name,
+        type: type.type || "null",
+        nullable: type.nullable
+        // metadata: {}
+      };
+    }
+    if (Array.isArray(column) && column.length > 0) {
+      const value = column[0];
+      const type = getDataTypeFromValue(value);
+      return {
+        name,
+        type,
+        nullable: true
+        // metadata: {},
+      };
+    }
+    throw new Error("empty table");
+  }
+  function deduceFieldFromValue(value, name) {
+    const type = getDataTypeFromValue(value);
+    return {
+      name,
+      type,
+      nullable: true
+      // metadata: {}
+    };
+  }
+
   // ../../node_modules/@babel/runtime/helpers/esm/typeof.js
   function _typeof(obj) {
     "@babel/helpers - typeof";
@@ -1361,11 +1724,11 @@ var __exports__ = (() => {
   };
 
   // ../gis/src/lib/binary-features/flat-geojson-to-binary.ts
-  function flatGeojsonToBinary(features, geometryInfo, options) {
-    const propArrayTypes = extractNumericPropTypes(features);
+  function flatGeojsonToBinary(features2, geometryInfo, options) {
+    const propArrayTypes = extractNumericPropTypes(features2);
     const numericPropKeys = Object.keys(propArrayTypes).filter((k) => propArrayTypes[k] !== Array);
     return fillArrays(
-      features,
+      features2,
       {
         propArrayTypes,
         ...geometryInfo
@@ -1377,9 +1740,9 @@ var __exports__ = (() => {
       }
     );
   }
-  function extractNumericPropTypes(features) {
+  function extractNumericPropTypes(features2) {
     const propArrayTypes = {};
-    for (const feature of features) {
+    for (const feature of features2) {
       if (feature.properties) {
         for (const key in feature.properties) {
           const val = feature.properties[key];
@@ -1389,7 +1752,7 @@ var __exports__ = (() => {
     }
     return propArrayTypes;
   }
-  function fillArrays(features, geometryInfo, options) {
+  function fillArrays(features2, geometryInfo, options) {
     const {
       pointPositionsCount,
       pointFeaturesCount,
@@ -1404,8 +1767,8 @@ var __exports__ = (() => {
       coordLength
     } = geometryInfo;
     const { numericPropKeys = [], PositionDataType = Float32Array, triangulate = true } = options;
-    const hasGlobalId = features[0] && "id" in features[0];
-    const GlobalFeatureIdsDataType = features.length > 65535 ? Uint32Array : Uint16Array;
+    const hasGlobalId = features2[0] && "id" in features2[0];
+    const GlobalFeatureIdsDataType = features2.length > 65535 ? Uint32Array : Uint16Array;
     const points = {
       type: "Point",
       positions: new PositionDataType(pointPositionsCount * coordLength),
@@ -1460,7 +1823,7 @@ var __exports__ = (() => {
       polygonFeature: 0,
       feature: 0
     };
-    for (const feature of features) {
+    for (const feature of features2) {
       const geometry = feature.geometry;
       const properties = feature.properties || {};
       switch (geometry.type) {
@@ -1704,7 +2067,7 @@ var __exports__ = (() => {
   var navigator_ = globalThis.navigator || {};
 
   // ../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/utils/globals.js
-  var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "untranspiled source";
+  var VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "untranspiled source";
   var isBrowser3 = isBrowser2();
 
   // ../../node_modules/@probe.gl/log/dist/utils/local-storage.js
@@ -1889,7 +2252,7 @@ var __exports__ = (() => {
         id: ""
       };
       _defineProperty(this, "id", void 0);
-      _defineProperty(this, "VERSION", VERSION);
+      _defineProperty(this, "VERSION", VERSION2);
       _defineProperty(this, "_startTs", getHiResTimestamp());
       _defineProperty(this, "_deltaTs", getHiResTimestamp());
       _defineProperty(this, "_storage", void 0);
@@ -2092,7 +2455,7 @@ var __exports__ = (() => {
       return noop;
     }
   };
-  _defineProperty(Log, "VERSION", VERSION);
+  _defineProperty(Log, "VERSION", VERSION2);
   function normalizeLogLevel(logLevel) {
     if (!logLevel) {
       return 0;
@@ -2202,9 +2565,18 @@ 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}` });
+  var VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var version = VERSION3[0] >= "0" && VERSION3[0] <= "9" ? `v${VERSION3}` : "";
+  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 = "";
@@ -2280,6 +2652,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 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);
@@ -2389,39 +2794,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, 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;
@@ -2465,10 +2868,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:
@@ -2545,6 +2947,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;
@@ -2587,7 +3011,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 i;
     let j;
@@ -2599,19 +3023,19 @@ var __exports__ = (() => {
           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;
@@ -2632,7 +3056,8 @@ var __exports__ = (() => {
       properties: vtFeature.properties
     };
     if (vtFeature.id !== null) {
-      result.id = vtFeature.id;
+      result.properties ||= {};
+      result.properties.id = vtFeature.id;
     }
     return result;
   }
@@ -2791,7 +3216,7 @@ var __exports__ = (() => {
     return binaryData;
   }
   function parseToFlatGeoJson(arrayBuffer, options) {
-    const features = [];
+    const features2 = [];
     const geometryInfo = {
       coordLength: 2,
       pointPositionsCount: 0,
@@ -2805,7 +3230,7 @@ var __exports__ = (() => {
       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);
@@ -2817,16 +3242,16 @@ var __exports__ = (() => {
       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) => {
@@ -2837,10 +3262,10 @@ var __exports__ = (() => {
       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) {
     if (!options?.mvt) {
@@ -2855,9 +3280,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 ||= {};
@@ -2866,39 +3291,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 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;
-    }
-  }
 
   // src/mvt-loader.ts
-  var VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
   var MVTWorkerLoader = {
     dataType: null,
     batchType: null,
     name: "Mapbox Vector Tile",
     id: "mvt",
     module: "mvt",
-    version: VERSION3,
+    version: VERSION4,
     // Note: ArcGIS uses '.pbf' extension and 'application/octet-stream'
     extensions: ["mvt", "pbf"],
     mimeTypes: [
@@ -2926,241 +3334,6 @@ var __exports__ = (() => {
     binary: true
   };
 
-  // src/lib/parse-tilejson.ts
-  var isObject = (x) => x !== null && typeof x === "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" };
-  }
-
-  // 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);
-    }
-  };
-
   // ../images/src/lib/utils/version.ts
   var VERSION5 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
 
@@ -3568,9 +3741,29 @@ var __exports__ = (() => {
     tests: [(arrayBuffer) => Boolean(getBinaryImageMetadata(new DataView(arrayBuffer)))],
     options: DEFAULT_IMAGE_LOADER_OPTIONS
   };
-
-  // src/mvt-source.ts
-  var MVTSource = class extends DataSource {
+
+  // src/mvt-source.ts
+  var MVTSource = {
+    name: "MVT",
+    id: "mvt",
+    module: "mvt",
+    version: "0.0.0",
+    extensions: ["mvt"],
+    mimeTypes: ["application/octet-stream"],
+    options: {
+      mvt: {
+        // TODO - add options here
+      }
+    },
+    type: "mvt",
+    fromUrl: true,
+    fromBlob: false,
+    testURL: (url) => true,
+    createDataSource(url, props) {
+      return new MVTTileSource(url, props);
+    }
+  };
+  var MVTTileSource = class extends DataSource {
     props;
     url;
     metadataUrl = null;
@@ -3579,12 +3772,12 @@ var __exports__ = (() => {
     metadata;
     extension;
     mimeType = null;
-    constructor(props) {
+    constructor(url, props) {
       super(props);
       this.props = props;
-      this.url = resolvePath(props.url);
-      this.metadataUrl = props.metadataUrl === void 0 ? `${this.url}/tilejson.json` : props.metadataUrl;
-      this.extension = props.extension || ".png";
+      this.url = resolvePath(url);
+      this.metadataUrl = props.mvt?.metadataUrl || `${this.url}/tilejson.json`;
+      this.extension = props.mvt?.extension || ".png";
       this.data = this.url;
       this.getTileData = this.getTileData.bind(this);
       this.metadata = this.getMetadata();
@@ -3615,8 +3808,8 @@ var __exports__ = (() => {
     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) {
@@ -3627,8 +3820,8 @@ var __exports__ = (() => {
     }
     // 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;
@@ -3682,33 +3875,505 @@ var __exports__ = (() => {
           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));
+  }
+
+  // node_modules/@probe.gl/stats/dist/utils/hi-res-timestamp.js
+  function getHiResTimestamp2() {
+    let timestamp;
+    if (typeof window !== "undefined" && window.performance) {
+      timestamp = window.performance.now();
+    } else if (typeof process !== "undefined" && process.hrtime) {
+      const timeParts = process.hrtime();
+      timestamp = timeParts[0] * 1e3 + timeParts[1] / 1e6;
+    } else {
+      timestamp = Date.now();
+    }
+    return timestamp;
+  }
+
+  // node_modules/@probe.gl/stats/dist/lib/stat.js
+  var Stat = class {
+    constructor(name, type) {
+      this.sampleSize = 1;
+      this.time = 0;
+      this.count = 0;
+      this.samples = 0;
+      this.lastTiming = 0;
+      this.lastSampleTime = 0;
+      this.lastSampleCount = 0;
+      this._count = 0;
+      this._time = 0;
+      this._samples = 0;
+      this._startTime = 0;
+      this._timerPending = false;
+      this.name = name;
+      this.type = type;
+      this.reset();
+    }
+    reset() {
+      this.time = 0;
+      this.count = 0;
+      this.samples = 0;
+      this.lastTiming = 0;
+      this.lastSampleTime = 0;
+      this.lastSampleCount = 0;
+      this._count = 0;
+      this._time = 0;
+      this._samples = 0;
+      this._startTime = 0;
+      this._timerPending = false;
+      return this;
+    }
+    setSampleSize(samples) {
+      this.sampleSize = samples;
+      return this;
+    }
+    /** Call to increment count (+1) */
+    incrementCount() {
+      this.addCount(1);
+      return this;
+    }
+    /** Call to decrement count (-1) */
+    decrementCount() {
+      this.subtractCount(1);
+      return this;
+    }
+    /** Increase count */
+    addCount(value) {
+      this._count += value;
+      this._samples++;
+      this._checkSampling();
+      return this;
+    }
+    /** Decrease count */
+    subtractCount(value) {
+      this._count -= value;
+      this._samples++;
+      this._checkSampling();
+      return this;
+    }
+    /** Add an arbitrary timing and bump the count */
+    addTime(time) {
+      this._time += time;
+      this.lastTiming = time;
+      this._samples++;
+      this._checkSampling();
+      return this;
+    }
+    /** Start a timer */
+    timeStart() {
+      this._startTime = getHiResTimestamp2();
+      this._timerPending = true;
+      return this;
+    }
+    /** End a timer. Adds to time and bumps the timing count. */
+    timeEnd() {
+      if (!this._timerPending) {
+        return this;
+      }
+      this.addTime(getHiResTimestamp2() - this._startTime);
+      this._timerPending = false;
+      this._checkSampling();
+      return this;
+    }
+    getSampleAverageCount() {
+      return this.sampleSize > 0 ? this.lastSampleCount / this.sampleSize : 0;
+    }
+    /** Calculate average time / count for the previous window */
+    getSampleAverageTime() {
+      return this.sampleSize > 0 ? this.lastSampleTime / this.sampleSize : 0;
+    }
+    /** Calculate counts per second for the previous window */
+    getSampleHz() {
+      return this.lastSampleTime > 0 ? this.sampleSize / (this.lastSampleTime / 1e3) : 0;
+    }
+    getAverageCount() {
+      return this.samples > 0 ? this.count / this.samples : 0;
+    }
+    /** Calculate average time / count */
+    getAverageTime() {
+      return this.samples > 0 ? this.time / this.samples : 0;
+    }
+    /** Calculate counts per second */
+    getHz() {
+      return this.time > 0 ? this.samples / (this.time / 1e3) : 0;
+    }
+    _checkSampling() {
+      if (this._samples === this.sampleSize) {
+        this.lastSampleTime = this._time;
+        this.lastSampleCount = this._count;
+        this.count += this._count;
+        this.time += this._time;
+        this.samples += this._samples;
+        this._time = 0;
+        this._count = 0;
+        this._samples = 0;
+      }
+    }
+  };
+
+  // node_modules/@probe.gl/stats/dist/lib/stats.js
+  var Stats = class {
+    constructor(options) {
+      this.stats = {};
+      this.id = options.id;
+      this.stats = {};
+      this._initializeStats(options.stats);
+      Object.seal(this);
+    }
+    /** Acquire a stat. Create if it doesn't exist. */
+    get(name, type = "count") {
+      return this._getOrCreate({ name, type });
+    }
+    get size() {
+      return Object.keys(this.stats).length;
+    }
+    /** Reset all stats */
+    reset() {
+      for (const stat of Object.values(this.stats)) {
+        stat.reset();
+      }
+      return this;
+    }
+    forEach(fn) {
+      for (const stat of Object.values(this.stats)) {
+        fn(stat);
+      }
+    }
+    getTable() {
+      const table = {};
+      this.forEach((stat) => {
+        table[stat.name] = {
+          time: stat.time || 0,
+          count: stat.count || 0,
+          average: stat.getAverageTime() || 0,
+          hz: stat.getHz() || 0
+        };
+      });
+      return table;
+    }
+    _initializeStats(stats = []) {
+      stats.forEach((stat) => this._getOrCreate(stat));
+    }
+    _getOrCreate(stat) {
+      const { name, type } = stat;
+      let result = this.stats[name];
+      if (!result) {
+        if (stat instanceof Stat) {
+          result = stat;
+        } else {
+          result = new Stat(name, type);
+        }
+        this.stats[name] = result;
+      }
+      return result;
+    }
+  };
+
+  // src/lib/vector-tiler/proto-tile.ts
+  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 area2 = 0;
+    for (let i = 0, j = ring.length - 2; i < ring.length; j = i, i += 2) {
+      area2 += (ring[i] - ring[j]) * (ring[i + 1] + ring[j + 1]);
+    }
+    if (area2 > 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;
+      }
+    }
+  }
+
+  // src/lib/vector-tiler/transform-tile.ts
+  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))];
+  }
+
+  // src/lib/vector-tiler/tile-to-geojson.ts
+  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;
+  }
+
+  // src/lib/vector-tiler/features/proto-feature.ts
+  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));
   }
 
-  // src/lib/geojsonvt/simplify.ts
-  function simplify(coords, first, last, sqTolerance) {
+  // src/lib/vector-tiler/features/simplify-path.ts
+  function simplifyPath(coords, first, last, sqTolerance) {
     let maxSqDist = sqTolerance;
     const mid = last - first >> 1;
     let minPosToMid = last - first;
@@ -3732,10 +4397,10 @@ var __exports__ = (() => {
     }
     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) {
@@ -3756,58 +4421,25 @@ var __exports__ = (() => {
     return dx * dx + dy * dy;
   }
 
-  // src/lib/geojsonvt/feature.ts
-  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]);
-    }
-  }
-
-  // src/lib/geojsonvt/convert.ts
-  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);
+  // src/lib/vector-tiler/features/convert-feature.ts
+  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;
     }
@@ -3821,51 +4453,57 @@ var __exports__ = (() => {
     } 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);
@@ -3889,7 +4527,7 @@ var __exports__ = (() => {
     }
     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;
@@ -3911,17 +4549,17 @@ var __exports__ = (() => {
     return y2 < 0 ? 0 : y2 > 1 ? 1 : y2;
   }
 
-  // src/lib/geojsonvt/clip.ts
-  function clip(features, scale, k1, k2, axis, minAll, maxAll, options) {
+  // src/lib/vector-tiler/features/clip-features.ts
+  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;
@@ -3953,7 +4591,7 @@ var __exports__ = (() => {
       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;
         }
@@ -3968,7 +4606,7 @@ var __exports__ = (() => {
         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;
@@ -4076,14 +4714,14 @@ var __exports__ = (() => {
     return t;
   }
 
-  // src/lib/geojsonvt/wrap.ts
-  function wrap(features, options) {
+  // src/lib/vector-tiler/features/wrap-features.ts
+  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);
       }
@@ -4093,30 +4731,39 @@ var __exports__ = (() => {
     }
     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;
   }
@@ -4133,200 +4780,85 @@ var __exports__ = (() => {
     return newPoints;
   }
 
-  // src/lib/geojsonvt/transform.ts
-  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))];
-  }
-
-  // src/lib/geojsonvt/tile.ts
-  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 area2 = 0;
-    for (let i = 0, j = ring.length - 2; i < ring.length; j = i, i += 2) {
-      area2 += (ring[i] - ring[j]) * (ring[i + 1] + ring[j + 1]);
-    }
-    if (area2 > 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;
+  // src/table-tile-source.ts
+  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) {
+      const needsLoading = typeof url === "string" || url instanceof Blob;
+      const loader = options?.table?.loaders?.[0];
+      const tablePromise = needsLoading ? loadTable(url, loader) : url;
+      return new DynamicVectorTileSource(tablePromise, options);
     }
-  }
-
-  // src/geojson-tile-source.ts
-  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 Stats({
+      id: "table-tile-source",
+      stats: [new Stat("tiles", "count"), new 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?.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 = 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
@@ -4336,6 +4868,7 @@ var __exports__ = (() => {
     async getVectorTile(tileIndex) {
       await this.ready;
       const table = this.getTileSync(tileIndex);
+      log.info(2, "getVectorTile", tileIndex, table)();
       return table;
     }
     async getTile(tileIndex) {
@@ -4344,7 +4877,8 @@ var __exports__ = (() => {
     }
     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?.features || [];
     }
     // Implementation
     /**
@@ -4352,21 +4886,56 @@ var __exports__ = (() => {
      * @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.");
+      }
+      log.log(1, "DynamicVectorTileSource creating root tiles", this.props)();
+      log.time(1, "preprocess table")();
+      let features2 = convertFeaturesToProtoFeature(table, this.props);
+      log.timeEnd(1, "preprocess table")();
+      log.time(1, "generate tiles")();
+      features2 = wrapFeatures(features2, this.props);
+      if (features2.length === 0) {
+        log.log(1, "DynamicVectorTileSource: no features generated")();
+        return;
+      }
+      this.splitTile(features2, 0, 0, 0);
+      const rootTile = this.tiles[0];
+      log.log(1, `root tile features: ${rootTile.numFeatures}, points: ${rootTile.numPoints}`)();
+      log.timeEnd(1, "generate tiles")();
+      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;
       }
@@ -4376,8 +4945,7 @@ var __exports__ = (() => {
       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);
+      log.log(log, "drilling down to z%d-%d-%d", z, x, y)();
       let z0 = z;
       let x0 = x;
       let y0 = y;
@@ -4388,17 +4956,13 @@ var __exports__ = (() => {
         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");
-      }
+      log.log(1, "found parent tile z%d-%d-%d", z0, x0, y0)();
+      log.time(1, "drilling down")();
+      this.splitTile(parent.sourceFeatures, z0, x0, y0, z, x, y);
+      log.timeEnd(1, "drilling down")();
       return this.tiles[id] ? transformTile(this.tiles[id], extent) : null;
     }
     /**
@@ -4407,62 +4971,62 @@ var __exports__ = (() => {
      * @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);
+          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();
+          log.log(
+            2,
+            "tile z%d-%d-%d (features: %d, points: %d, simplified: %d)",
+            z,
+            x,
+            y,
+            tile.numFeatures,
+            tile.numPoints,
+            tile.numSimplified
+          )();
+          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;
+        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;
@@ -4470,21 +5034,20 @@ var __exports__ = (() => {
         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");
+        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);
@@ -4492,96 +5055,15 @@ var __exports__ = (() => {
       }
     }
   };
-  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 Stats({
+    id: "table-tile-source-all",
+    stats: [new Stat("count", "tiles"), new 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];
-  }
   return __toCommonJS(bundle_exports);
 })();
 /*! Bundled license information: