@loaders.gl/mvt 4.3.0-alpha.2 → 4.3.0-alpha.4

package/dist/dist.dev.js

@@ -801,6 +801,293 @@ var __exports__ = (() => {
   });
   __reExport(bundle_exports, __toESM(require_core(), 1));
 
+  // src/lib/get-schemas-from-tilejson.ts
+  function getSchemaFromTileJSONLayer(layer) {
+    const fields = [];
+    if (layer.fields) {
+      for (const field of layer.fields) {
+        fields.push({
+          name: field.name,
+          type: getDataTypeFromTileJSONField(field),
+          metadata: getMetadataFromTileJSONField(field)
+        });
+      }
+    }
+    return {
+      metadata: getMetadataFromTileJSONLayer(layer),
+      fields
+    };
+  }
+  function getMetadataFromTileJSONLayer(layer) {
+    const metadata = {};
+    for (const [key, value] of Object.entries(layer)) {
+      if (key !== "fields" && value) {
+        metadata[key] = JSON.stringify(value);
+      }
+    }
+    return metadata;
+  }
+  function getDataTypeFromTileJSONField(field) {
+    switch (field.type.toLowerCase()) {
+      case "float32":
+        return "float32";
+      case "number":
+      case "float64":
+        return "float64";
+      case "string":
+      case "utf8":
+        return "utf8";
+      case "boolean":
+        return "bool";
+      default:
+        return "null";
+    }
+  }
+  function getMetadataFromTileJSONField(field) {
+    const metadata = {};
+    for (const [key, value] of Object.entries(field)) {
+      if (key !== "name" && value) {
+        metadata[key] = JSON.stringify(value);
+      }
+    }
+    return metadata;
+  }
+
+  // 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 || layer.fields || [];
+      const mergedLayer = {
+        ...layer,
+        ...tilestatsLayer,
+        fields
+      };
+      mergedLayer.schema = getSchemaFromTileJSONLayer(mergedLayer);
+      return mergedLayer;
+    });
+  }
+  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) {
@@ -886,12 +1173,12 @@ var __exports__ = (() => {
     }
     return { fields, metadata: {} };
   }
-  function deduceSchemaFromGeoJSON(features) {
-    if (!features.length) {
+  function deduceSchemaFromGeoJSON(features2) {
+    if (!features2.length) {
       throw new Error("deduce from empty table");
     }
     const fields = [];
-    const row0 = features[0].properties || {};
+    const row0 = features2[0].properties || {};
     for (const [columnName, value] of Object.entries(row0)) {
       fields.push(deduceFieldFromValue(value, columnName));
     }
@@ -1489,11 +1776,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
@@ -1505,9 +1792,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];
@@ -1517,7 +1804,7 @@ var __exports__ = (() => {
     }
     return propArrayTypes;
   }
-  function fillArrays(features, geometryInfo, options) {
+  function fillArrays(features2, geometryInfo, options) {
     const {
       pointPositionsCount,
       pointFeaturesCount,
@@ -1532,8 +1819,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),
@@ -1588,7 +1875,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) {
@@ -1832,7 +2119,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
@@ -2017,7 +2304,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);
@@ -2220,7 +2507,7 @@ var __exports__ = (() => {
       return noop;
     }
   };
-  _defineProperty(Log, "VERSION", VERSION);
+  _defineProperty(Log, "VERSION", VERSION2);
   function normalizeLogLevel(logLevel) {
     if (!logLevel) {
       return 0;
@@ -2330,8 +2617,8 @@ 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 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 || {};
@@ -2429,7 +2716,7 @@ var __exports__ = (() => {
     p[1] /= extent;
   }
   function convertToLocalCoordinatesFlat(data, extent) {
-    for (let i = 0, il = data.length; i < il; ++i) {
+    for (let i = 0; i < data.length; ++i) {
       data[i] /= extent;
     }
   }
@@ -2981,7 +3268,7 @@ var __exports__ = (() => {
     return binaryData;
   }
   function parseToFlatGeoJson(arrayBuffer, options) {
-    const features = [];
+    const features2 = [];
     const geometryInfo = {
       coordLength: 2,
       pointPositionsCount: 0,
@@ -2995,7 +3282,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);
@@ -3007,16 +3294,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) => {
@@ -3027,10 +3314,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) {
@@ -3064,14 +3351,14 @@ var __exports__ = (() => {
   }
 
   // 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: [
@@ -3099,241 +3386,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";
 
@@ -3743,7 +3795,27 @@ var __exports__ = (() => {
   };
 
   // src/mvt-source.ts
-  var MVTSource = class extends DataSource {
+  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;
@@ -3752,12 +3824,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();
@@ -4073,35 +4145,314 @@ var __exports__ = (() => {
     }
   };
 
-  // src/lib/vector-tiler/simplify.ts
-  function simplify(coords, first, last, sqTolerance) {
-    let maxSqDist = sqTolerance;
-    const mid = last - first >> 1;
-    let minPosToMid = last - first;
-    let index;
-    const ax = coords[first];
-    const ay = coords[first + 1];
-    const bx = coords[last];
-    const by = coords[last + 1];
-    for (let i = first + 3; i < last; i += 3) {
-      const d = getSqSegDist(coords[i], coords[i + 1], ax, ay, bx, by);
-      if (d > maxSqDist) {
-        index = i;
-        maxSqDist = d;
-      } else if (d === maxSqDist) {
-        const posToMid = Math.abs(i - mid);
-        if (posToMid < minPosToMid) {
-          index = i;
+  // 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;
+  }
+  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]);
+    }
+  }
+
+  // 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;
+    let index;
+    const ax = coords[first];
+    const ay = coords[first + 1];
+    const bx = coords[last];
+    const by = coords[last + 1];
+    for (let i = first + 3; i < last; i += 3) {
+      const d = getSqSegDist(coords[i], coords[i + 1], ax, ay, bx, by);
+      if (d > maxSqDist) {
+        index = i;
+        maxSqDist = d;
+      } else if (d === maxSqDist) {
+        const posToMid = Math.abs(i - mid);
+        if (posToMid < minPosToMid) {
+          index = i;
           minPosToMid = posToMid;
         }
       }
     }
     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) {
@@ -4122,58 +4473,25 @@ var __exports__ = (() => {
     return dx * dx + dy * dy;
   }
 
-  // src/lib/vector-tiler/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/vector-tiler/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;
     }
@@ -4187,51 +4505,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);
@@ -4255,7 +4579,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;
@@ -4277,17 +4601,17 @@ var __exports__ = (() => {
     return y2 < 0 ? 0 : y2 > 1 ? 1 : y2;
   }
 
-  // src/lib/vector-tiler/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;
@@ -4319,7 +4643,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;
         }
@@ -4334,7 +4658,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;
@@ -4442,14 +4766,14 @@ var __exports__ = (() => {
     return t;
   }
 
-  // src/lib/vector-tiler/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);
       }
@@ -4459,30 +4783,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;
   }
@@ -4499,148 +4832,47 @@ var __exports__ = (() => {
     return newPoints;
   }
 
-  // src/lib/vector-tiler/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/vector-tiler/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]);
+  // 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
       }
-      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]);
+    },
+    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);
     }
-    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;
-      }
+    // @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);
   }
-
-  // src/table-tile-source.ts
-  var _TableTileSource = class {
-    /** Stats for this TableTileSource */
+  var _DynamicVectorTileSource = class {
+    /** Stats for this DynamicVectorTileSource */
     stats = new Stats({
       id: "table-tile-source",
       stats: [new Stat("tiles", "count"), new Stat("features", "count")]
@@ -4649,6 +4881,7 @@ var __exports__ = (() => {
     mimeType = "application/vnd.mapbox-vector-tile";
     localCoordinates = true;
     /** The props that this tile source was created with */
+    // @ts-expect-error
     props;
     /* Schema of the data */
     schema = null;
@@ -4661,7 +4894,7 @@ var __exports__ = (() => {
     /** Metadata for the tile source (generated TileJSON/tilestats */
     metadata;
     constructor(table, props) {
-      this.props = { ..._TableTileSource.defaultProps, ...props };
+      this.props = { ...TableTileSource.options.table, ...props?.table };
       this.getTileData = this.getTileData.bind(this);
       this.ready = this.initializeTilesAsync(table);
       this.metadata = this.getMetadata();
@@ -4705,11 +4938,11 @@ 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, {
+      return convertTileToGeoJSON(protoTile, {
         coordinates: this.props.coordinates,
         tileIndex,
         extent: this.props.extent
@@ -4726,28 +4959,32 @@ var __exports__ = (() => {
       if (this.props.promoteId && this.props.generateId) {
         throw new Error("promoteId and generateId cannot be used together.");
       }
-      log.log(1, "TableTileSource creating root tiles", this.props)();
+      log.log(1, "DynamicVectorTileSource creating root tiles", this.props)();
       log.time(1, "preprocess table")();
-      let features = convert(table, this.props);
+      let features2 = convertFeaturesToProtoFeature(table, this.props);
       log.timeEnd(1, "preprocess table")();
       log.time(1, "generate tiles")();
-      features = wrap(features, this.props);
-      if (features.length === 0) {
-        log.log(1, "TableTileSource: no features generated")();
+      features2 = wrapFeatures(features2, this.props);
+      if (features2.length === 0) {
+        log.log(1, "DynamicVectorTileSource: no features generated")();
         return;
       }
-      this.splitTile(features, 0, 0, 0);
+      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, `TableTileSource: tiles generated: ${this.stats.get("total").count}`, this.stats)();
+      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 } = this.props;
@@ -4771,12 +5008,12 @@ var __exports__ = (() => {
         y0 = y0 >> 1;
         parent = this.tiles[toID(z0, x0, y0)];
       }
-      if (!parent || !parent.source) {
+      if (!parent || !parent.sourceFeatures) {
         return null;
       }
       log.log(1, "found parent tile z%d-%d-%d", z0, x0, y0)();
       log.time(1, "drilling down")();
-      this.splitTile(parent.source, z0, x0, y0, z, x, y);
+      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;
     }
@@ -4789,28 +5026,28 @@ var __exports__ = (() => {
      * 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];
+    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) {
           log.time(2, "tile creation")();
-          tile = this.tiles[id] = createTile(features, z, x, y, this.props);
+          tile = this.tiles[id] = createProtoTile(features2, z, x, y, this.props);
           this.tileCoords.push({ z, x, y });
           const key = `z${z}`;
           let stat = this.stats.get(key, "count");
           stat.incrementCount();
           stat = this.stats.get("total");
           stat.incrementCount();
-          stat = _TableTileSource.stats.get(key, "count");
+          stat = _DynamicVectorTileSource.stats.get(key, "count");
           stat.incrementCount();
-          stat = _TableTileSource.stats.get("total");
+          stat = _DynamicVectorTileSource.stats.get("total");
           stat.incrementCount();
           log.log(
             2,
@@ -4824,7 +5061,7 @@ var __exports__ = (() => {
           )();
           log.timeEnd(2, "tile creation")();
         }
-        tile.source = features;
+        tile.sourceFeatures = features2;
         if (cz === void 0) {
           if (z === this.props.indexMaxZoom || tile.numPoints <= this.props.maxPointsPerTile) {
             continue;
@@ -4837,8 +5074,8 @@ var __exports__ = (() => {
             continue;
           }
         }
-        tile.source = null;
-        if (features.length === 0)
+        tile.sourceFeatures = null;
+        if (features2.length === 0)
           continue;
         log.time(2, "clipping tile")();
         const k1 = 0.5 * this.props.buffer / this.props.extent;
@@ -4849,17 +5086,17 @@ 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, this.props);
-        let right = clip(features, z2, x + k2, x + k4, 0, tile.minX, tile.maxX, this.props);
-        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, this.props);
-          bl = clip(left, z2, y + k2, y + k4, 1, tile.minY, tile.maxY, this.props);
+          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, this.props);
-          br = clip(right, z2, y + k2, y + k4, 1, tile.minY, tile.maxY, this.props);
+          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;
         }
         log.timeEnd(2, "clipping tile")();
@@ -4870,111 +5107,15 @@ var __exports__ = (() => {
       }
     }
   };
-  var TableTileSource = _TableTileSource;
-  __publicField(TableTileSource, "defaultProps", {
-    coordinates: "wgs84",
-    // coordinates in tile coordinates or lng/lat
-    maxZoom: 14,
-    // max zoom to preserve detail on
-    indexMaxZoom: 5,
-    // max zoom in the tile index
-    maxPointsPerTile: 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)
-  });
-  /** Global stats for all TableTileSources */
-  __publicField(TableTileSource, "stats", new Stats({
+  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, props) {
-    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;
-      }
-      switch (props.coordinates) {
-        case "EPSG:4326":
-        case "wgs84":
-          projectToLngLat(coordinates, props.tileIndex, props.extent);
-          break;
-        case "local":
-          convertToLocalCoordinates(coordinates, props.extent);
-          break;
-        default:
-          throw new Error(`Unsupported CRS ${props.coordinates}`);
-      }
-      const feature = {
-        type: "Feature",
-        geometry: {
-          type,
-          coordinates
-        },
-        properties: rawFeature.tags || {},
-        id: rawFeature.id
-      };
-      features.push(feature);
-    }
-    if (features.length === 0) {
-      return null;
-    }
-    const table = {
-      shape: "geojson-table",
-      type: "FeatureCollection",
-      features
-    };
-    return table;
-  }
   return __toCommonJS(bundle_exports);
 })();
 /*! Bundled license information: