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

package/dist/index.cjs

@@ -43,6 +43,295 @@ __export(dist_exports, {
 });
 module.exports = __toCommonJS(dist_exports);
 
+// dist/lib/get-schemas-from-tilejson.js
+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;
+}
+
+// dist/lib/parse-tilejson.js
+var isObject = (x) => x !== null && typeof x === "object";
+function parseTileJSON(jsonMetadata, options) {
+  var _a;
+  if (!jsonMetadata || !isObject(jsonMetadata)) {
+    return null;
+  }
+  let tileJSON = {
+    name: jsonMetadata.name || "",
+    description: jsonMetadata.description || ""
+  };
+  if (typeof jsonMetadata.generator === "string") {
+    tileJSON.generator = jsonMetadata.generator;
+  }
+  if (typeof jsonMetadata.generator_options === "string") {
+    tileJSON.generatorOptions = jsonMetadata.generator_options;
+  }
+  tileJSON.boundingBox = parseBounds(jsonMetadata.bounds) || parseBounds(jsonMetadata.antimeridian_adjusted_bounds);
+  tileJSON.center = parseCenter(jsonMetadata.center);
+  tileJSON.maxZoom = safeParseFloat(jsonMetadata.maxzoom);
+  tileJSON.minZoom = safeParseFloat(jsonMetadata.minzoom);
+  if (typeof (jsonMetadata == null ? void 0 : jsonMetadata.json) === "string") {
+    try {
+      tileJSON.metaJson = JSON.parse(jsonMetadata.json);
+    } catch (error) {
+      console.warn("Failed to parse tilejson.json field", error);
+    }
+  }
+  const tilestats = jsonMetadata.tilestats || ((_a = tileJSON.metaJson) == null ? void 0 : _a.tilestats);
+  const tileStatsLayers = parseTilestatsLayers(tilestats, options);
+  const tileJSONlayers = parseTileJSONLayers(jsonMetadata.vector_layers);
+  const layers = mergeLayers(tileJSONlayers, tileStatsLayers);
+  tileJSON = {
+    ...tileJSON,
+    layers
+  };
+  if (tileJSON.maxZoom === null && layers.length > 0) {
+    tileJSON.maxZoom = layers[0].maxZoom || null;
+  }
+  if (tileJSON.minZoom === null && layers.length > 0) {
+    tileJSON.minZoom = layers[0].minZoom || null;
+  }
+  return tileJSON;
+}
+function parseTileJSONLayers(layers) {
+  if (!Array.isArray(layers)) {
+    return [];
+  }
+  return layers.map((layer) => parseTileJSONLayer(layer));
+}
+function parseTileJSONLayer(layer) {
+  const fields = Object.entries(layer.fields || []).map(([key, datatype]) => ({
+    name: key,
+    ...attributeTypeToFieldType(String(datatype))
+  }));
+  const layer2 = { ...layer };
+  delete layer2.fields;
+  return {
+    name: layer.id || "",
+    ...layer2,
+    fields
+  };
+}
+function parseTilestatsLayers(tilestats, options) {
+  if (isObject(tilestats) && Array.isArray(tilestats.layers)) {
+    return tilestats.layers.map((layer) => parseTilestatsForLayer(layer, options));
+  }
+  return [];
+}
+function parseTilestatsForLayer(layer, options) {
+  const fields = [];
+  const indexedAttributes = {};
+  const attributes = layer.attributes || [];
+  for (const attribute of attributes) {
+    const name = attribute.attribute;
+    if (typeof name === "string") {
+      if (name.split("|").length > 1) {
+        const fname = name.split("|")[0];
+        indexedAttributes[fname] = indexedAttributes[fname] || [];
+        indexedAttributes[fname].push(attribute);
+        console.warn("ignoring tilestats indexed field", fname);
+      } else if (!fields[name]) {
+        fields.push(attributeToField(attribute, options));
+      } else {
+      }
+    }
+  }
+  return {
+    name: layer.layer || "",
+    dominantGeometry: layer.geometry,
+    fields
+  };
+}
+function mergeLayers(layers, tilestatsLayers) {
+  return layers.map((layer) => {
+    const tilestatsLayer = tilestatsLayers.find((tsLayer) => tsLayer.name === layer.name);
+    const fields = (tilestatsLayer == null ? void 0 : tilestatsLayer.fields) || 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) {
+  var _a;
+  const fieldTypes = attributeTypeToFieldType(attribute.type);
+  const field = {
+    name: attribute.attribute,
+    // what happens if attribute type is string...
+    // filterProps: getFilterProps(fieldTypes.type, attribute),
+    ...fieldTypes
+  };
+  if (typeof attribute.min === "number") {
+    field.min = attribute.min;
+  }
+  if (typeof attribute.max === "number") {
+    field.max = attribute.max;
+  }
+  if (typeof attribute.count === "number") {
+    field.uniqueValueCount = attribute.count;
+  }
+  if (attribute.values) {
+    field.values = attribute.values;
+  }
+  if (field.values && typeof options.maxValues === "number") {
+    field.values = (_a = field.values) == null ? void 0 : _a.slice(0, options.maxValues);
+  }
+  return field;
+}
+function attributeTypeToFieldType(aType) {
+  const type = aType.toLowerCase();
+  if (!type || !attrTypeMap[type]) {
+  }
+  return attrTypeMap[type] || { type: "string" };
+}
+
+// dist/tilejson-loader.js
+var VERSION = true ? "4.3.0-alpha.3" : "latest";
+var TileJSONLoader = {
+  dataType: null,
+  batchType: null,
+  name: "TileJSON",
+  id: "tilejson",
+  module: "pmtiles",
+  version: VERSION,
+  worker: true,
+  extensions: ["json"],
+  mimeTypes: ["application/json"],
+  text: true,
+  options: {
+    tilejson: {
+      maxValues: void 0
+    }
+  },
+  parse: async (arrayBuffer, options) => {
+    const jsonString = new TextDecoder().decode(arrayBuffer);
+    const json = JSON.parse(jsonString);
+    const tilejsonOptions = { ...TileJSONLoader.options.tilejson, ...options == null ? void 0 : options.tilejson };
+    return parseTileJSON(json, tilejsonOptions);
+  },
+  parseTextSync: (text, options) => {
+    const json = JSON.parse(text);
+    const tilejsonOptions = { ...TileJSONLoader.options.tilejson, ...options == null ? void 0 : options.tilejson };
+    return parseTileJSON(json, tilejsonOptions);
+  }
+};
+
 // dist/lib/parse-mvt.js
 var import_gis = require("@loaders.gl/gis");
 var import_loader_utils = require("@loaders.gl/loader-utils");
@@ -71,7 +360,7 @@ function convertToLocalCoordinates(coordinates, extent) {
   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;
   }
 }
@@ -610,7 +899,7 @@ function parseToBinary(arrayBuffer, options) {
   return binaryData;
 }
 function parseToFlatGeoJson(arrayBuffer, options) {
-  const features = [];
+  const features2 = [];
   const geometryInfo = {
     coordLength: 2,
     pointPositionsCount: 0,
@@ -624,7 +913,7 @@ function parseToFlatGeoJson(arrayBuffer, options) {
     polygonFeaturesCount: 0
   };
   if (arrayBuffer.byteLength <= 0) {
-    return [features, geometryInfo];
+    return [features2, geometryInfo];
   }
   const tile = new VectorTile(new import_pbf.default(arrayBuffer));
   const selectedLayers = options && Array.isArray(options.layers) ? options.layers : Object.keys(tile.layers);
@@ -636,16 +925,16 @@ function parseToFlatGeoJson(arrayBuffer, options) {
     for (let i = 0; i < vectorTileLayer.length; i++) {
       const vectorTileFeature = vectorTileLayer.getBinaryFeature(i, geometryInfo);
       const decodedFeature = getDecodedFeatureBinary(vectorTileFeature, options, layerName);
-      features.push(decodedFeature);
+      features2.push(decodedFeature);
     }
   });
-  return [features, geometryInfo];
+  return [features2, geometryInfo];
 }
 function parseToGeojsonFeatures(arrayBuffer, options) {
   if (arrayBuffer.byteLength <= 0) {
     return [];
   }
-  const features = [];
+  const features2 = [];
   const tile = new VectorTile(new import_pbf.default(arrayBuffer));
   const selectedLayers = Array.isArray(options.layers) ? options.layers : Object.keys(tile.layers);
   selectedLayers.forEach((layerName) => {
@@ -656,10 +945,10 @@ function parseToGeojsonFeatures(arrayBuffer, options) {
     for (let i = 0; i < vectorTileLayer.length; i++) {
       const vectorTileFeature = vectorTileLayer.getGeoJSONFeature(i);
       const decodedFeature = getDecodedFeature(vectorTileFeature, options, layerName);
-      features.push(decodedFeature);
+      features2.push(decodedFeature);
     }
   });
-  return features;
+  return features2;
 }
 function checkOptions(options) {
   var _a;
@@ -691,14 +980,14 @@ function getDecodedFeatureBinary(feature, options, layerName) {
 }
 
 // dist/mvt-loader.js
-var VERSION = true ? "4.3.0-alpha.1" : "latest";
+var VERSION2 = true ? "4.3.0-alpha.3" : "latest";
 var MVTWorkerLoader = {
   dataType: null,
   batchType: null,
   name: "Mapbox Vector Tile",
   id: "mvt",
   module: "mvt",
-  version: VERSION,
+  version: VERSION2,
   // Note: ArcGIS uses '.pbf' extension and 'application/octet-stream'
   extensions: ["mvt", "pbf"],
   mimeTypes: [
@@ -726,248 +1015,31 @@ var MVTLoader = {
   binary: true
 };
 
-// dist/lib/parse-tilejson.js
-var isObject = (x) => x !== null && typeof x === "object";
-function parseTileJSON(jsonMetadata, options) {
-  var _a;
-  if (!jsonMetadata || !isObject(jsonMetadata)) {
-    return null;
-  }
-  let tileJSON = {
-    name: jsonMetadata.name || "",
-    description: jsonMetadata.description || ""
-  };
-  if (typeof jsonMetadata.generator === "string") {
-    tileJSON.generator = jsonMetadata.generator;
-  }
-  if (typeof jsonMetadata.generator_options === "string") {
-    tileJSON.generatorOptions = jsonMetadata.generator_options;
-  }
-  tileJSON.boundingBox = parseBounds(jsonMetadata.bounds) || parseBounds(jsonMetadata.antimeridian_adjusted_bounds);
-  tileJSON.center = parseCenter(jsonMetadata.center);
-  tileJSON.maxZoom = safeParseFloat(jsonMetadata.maxzoom);
-  tileJSON.minZoom = safeParseFloat(jsonMetadata.minzoom);
-  if (typeof (jsonMetadata == null ? void 0 : jsonMetadata.json) === "string") {
-    try {
-      tileJSON.metaJson = JSON.parse(jsonMetadata.json);
-    } catch (error) {
-      console.warn("Failed to parse tilejson.json field", error);
-    }
-  }
-  const tilestats = jsonMetadata.tilestats || ((_a = tileJSON.metaJson) == null ? void 0 : _a.tilestats);
-  const tileStatsLayers = parseTilestatsLayers(tilestats, options);
-  const tileJSONlayers = parseTileJSONLayers(jsonMetadata.vector_layers);
-  const layers = mergeLayers(tileJSONlayers, tileStatsLayers);
-  tileJSON = {
-    ...tileJSON,
-    layers
-  };
-  if (tileJSON.maxZoom === null && layers.length > 0) {
-    tileJSON.maxZoom = layers[0].maxZoom || null;
-  }
-  if (tileJSON.minZoom === null && layers.length > 0) {
-    tileJSON.minZoom = layers[0].minZoom || null;
-  }
-  return tileJSON;
-}
-function parseTileJSONLayers(layers) {
-  if (!Array.isArray(layers)) {
-    return [];
-  }
-  return layers.map((layer) => parseTileJSONLayer(layer));
-}
-function parseTileJSONLayer(layer) {
-  const fields = Object.entries(layer.fields || []).map(([key, datatype]) => ({
-    name: key,
-    ...attributeTypeToFieldType(String(datatype))
-  }));
-  const layer2 = { ...layer };
-  delete layer2.fields;
-  return {
-    name: layer.id || "",
-    ...layer2,
-    fields
-  };
-}
-function parseTilestatsLayers(tilestats, options) {
-  if (isObject(tilestats) && Array.isArray(tilestats.layers)) {
-    return tilestats.layers.map((layer) => parseTilestatsForLayer(layer, options));
-  }
-  return [];
-}
-function parseTilestatsForLayer(layer, options) {
-  const fields = [];
-  const indexedAttributes = {};
-  const attributes = layer.attributes || [];
-  for (const attribute of attributes) {
-    const name = attribute.attribute;
-    if (typeof name === "string") {
-      if (name.split("|").length > 1) {
-        const fname = name.split("|")[0];
-        indexedAttributes[fname] = indexedAttributes[fname] || [];
-        indexedAttributes[fname].push(attribute);
-        console.warn("ignoring tilestats indexed field", fname);
-      } else if (!fields[name]) {
-        fields.push(attributeToField(attribute, options));
-      } else {
-      }
-    }
-  }
-  return {
-    name: layer.layer || "",
-    dominantGeometry: layer.geometry,
-    fields
-  };
-}
-function mergeLayers(layers, tilestatsLayers) {
-  return layers.map((layer) => {
-    const tilestatsLayer = tilestatsLayers.find((tsLayer) => tsLayer.name === layer.name);
-    const fields = (tilestatsLayer == null ? void 0 : tilestatsLayer.fields) || [];
-    const layer2 = { ...layer };
-    delete layer2.fields;
-    return {
-      ...layer2,
-      ...tilestatsLayer,
-      fields
-    };
-  });
-}
-function parseBounds(bounds) {
-  const result = fromArrayOrString(bounds);
-  if (Array.isArray(result) && result.length === 4 && [result[0], result[2]].every(isLng) && [result[1], result[3]].every(isLat)) {
-    return [
-      [result[0], result[1]],
-      [result[2], result[3]]
-    ];
-  }
-  return void 0;
-}
-function parseCenter(center) {
-  const result = fromArrayOrString(center);
-  if (Array.isArray(result) && result.length === 3 && isLng(result[0]) && isLat(result[1]) && isZoom(result[2])) {
-    return result;
-  }
-  return null;
-}
-function safeParseFloat(input) {
-  const result = typeof input === "string" ? parseFloat(input) : typeof input === "number" ? input : null;
-  return result === null || isNaN(result) ? null : result;
-}
-function isLat(num) {
-  return Number.isFinite(num) && num <= 90 && num >= -90;
-}
-function isLng(num) {
-  return Number.isFinite(num) && num <= 180 && num >= -180;
-}
-function isZoom(num) {
-  return Number.isFinite(num) && num >= 0 && num <= 22;
-}
-function fromArrayOrString(data) {
-  if (typeof data === "string") {
-    return data.split(",").map(parseFloat);
-  } else if (Array.isArray(data)) {
-    return data;
-  }
-  return null;
-}
-var attrTypeMap = {
-  number: {
-    type: "float32"
-  },
-  numeric: {
-    type: "float32"
-  },
-  string: {
-    type: "utf8"
-  },
-  vachar: {
-    type: "utf8"
-  },
-  float: {
-    type: "float32"
-  },
-  int: {
-    type: "int32"
-  },
-  int4: {
-    type: "int32"
-  },
-  boolean: {
-    type: "boolean"
-  },
-  bool: {
-    type: "boolean"
-  }
-};
-function attributeToField(attribute = {}, options) {
-  var _a;
-  const fieldTypes = attributeTypeToFieldType(attribute.type);
-  const field = {
-    name: attribute.attribute,
-    // what happens if attribute type is string...
-    // filterProps: getFilterProps(fieldTypes.type, attribute),
-    ...fieldTypes
-  };
-  if (typeof attribute.min === "number") {
-    field.min = attribute.min;
-  }
-  if (typeof attribute.max === "number") {
-    field.max = attribute.max;
-  }
-  if (typeof attribute.count === "number") {
-    field.uniqueValueCount = attribute.count;
-  }
-  if (attribute.values) {
-    field.values = attribute.values;
-  }
-  if (field.values && typeof options.maxValues === "number") {
-    field.values = (_a = field.values) == null ? void 0 : _a.slice(0, options.maxValues);
-  }
-  return field;
-}
-function attributeTypeToFieldType(aType) {
-  const type = aType.toLowerCase();
-  if (!type || !attrTypeMap[type]) {
-  }
-  return attrTypeMap[type] || { type: "string" };
-}
-
-// dist/tilejson-loader.js
-var VERSION2 = true ? "4.3.0-alpha.1" : "latest";
-var TileJSONLoader = {
-  dataType: null,
-  batchType: null,
-  name: "TileJSON",
-  id: "tilejson",
-  module: "pmtiles",
-  version: VERSION2,
-  worker: true,
-  extensions: ["json"],
-  mimeTypes: ["application/json"],
-  text: true,
+// dist/mvt-source.js
+var import_loader_utils2 = require("@loaders.gl/loader-utils");
+var import_images = require("@loaders.gl/images");
+var import_mvt = require("@loaders.gl/mvt");
+var MVTSource = {
+  name: "MVT",
+  id: "mvt",
+  module: "mvt",
+  version: "0.0.0",
+  extensions: ["mvt"],
+  mimeTypes: ["application/octet-stream"],
   options: {
-    tilejson: {
-      maxValues: void 0
+    mvt: {
+      // TODO - add options here
     }
   },
-  parse: async (arrayBuffer, options) => {
-    const jsonString = new TextDecoder().decode(arrayBuffer);
-    const json = JSON.parse(jsonString);
-    const tilejsonOptions = { ...TileJSONLoader.options.tilejson, ...options == null ? void 0 : options.tilejson };
-    return parseTileJSON(json, tilejsonOptions);
-  },
-  parseTextSync: (text, options) => {
-    const json = JSON.parse(text);
-    const tilejsonOptions = { ...TileJSONLoader.options.tilejson, ...options == null ? void 0 : options.tilejson };
-    return parseTileJSON(json, tilejsonOptions);
+  type: "mvt",
+  fromUrl: true,
+  fromBlob: false,
+  testURL: (url) => true,
+  createDataSource(url, props) {
+    return new MVTTileSource(url, props);
   }
 };
-
-// dist/mvt-source.js
-var import_loader_utils2 = require("@loaders.gl/loader-utils");
-var import_images = require("@loaders.gl/images");
-var import_mvt = require("@loaders.gl/mvt");
-var MVTSource = class extends import_loader_utils2.DataSource {
+var MVTTileSource = class extends import_loader_utils2.DataSource {
   props;
   url;
   metadataUrl = null;
@@ -976,12 +1048,13 @@ var MVTSource = class extends import_loader_utils2.DataSource {
   metadata;
   extension;
   mimeType = null;
-  constructor(props) {
+  constructor(url, props) {
+    var _a, _b;
     super(props);
     this.props = props;
-    this.url = (0, import_loader_utils2.resolvePath)(props.url);
-    this.metadataUrl = props.metadataUrl === void 0 ? `${this.url}/tilejson.json` : props.metadataUrl;
-    this.extension = props.extension || ".png";
+    this.url = (0, import_loader_utils2.resolvePath)(url);
+    this.metadataUrl = ((_a = props.mvt) == null ? void 0 : _a.metadataUrl) || `${this.url}/tilejson.json`;
+    this.extension = ((_b = props.mvt) == null ? void 0 : _b.extension) || ".png";
     this.data = this.url;
     this.getTileData = this.getTileData.bind(this);
     this.metadata = this.getMetadata();
@@ -1093,26 +1166,305 @@ function getURLFromTemplate(template, x, y, z, id = "0") {
     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));
+  let url = template;
+  url = url.replace(xRegex, String(x));
+  url = url.replace(yRegex, String(y));
+  url = url.replace(zRegex, String(z));
+  if (Number.isInteger(y) && Number.isInteger(z)) {
+    url = url.replace(/\{-y\}/g, String(Math.pow(2, z) - y - 1));
+  }
+  return url;
+}
+function stringHash(s) {
+  return Math.abs(s.split("").reduce((a, b) => (a << 5) - a + b.charCodeAt(0) | 0, 0));
+}
+
+// dist/table-tile-source.js
+var import_loader_utils3 = require("@loaders.gl/loader-utils");
+var import_schema = require("@loaders.gl/schema");
+var import_stats = require("@probe.gl/stats");
+
+// dist/lib/vector-tiler/proto-tile.js
+function createProtoTile(features2, z, tx, ty, options) {
+  const tolerance = z === options.maxZoom ? 0 : options.tolerance / ((1 << z) * options.extent);
+  const tile = {
+    protoFeatures: [],
+    sourceFeatures: null,
+    numPoints: 0,
+    numSimplified: 0,
+    numFeatures: features2.length,
+    x: tx,
+    y: ty,
+    z,
+    transformed: false,
+    minX: 2,
+    minY: 1,
+    maxX: -1,
+    maxY: 0
+  };
+  for (const feature of features2) {
+    addProtoFeature(tile, feature, tolerance, options);
+  }
+  return tile;
+}
+function addProtoFeature(tile, feature, tolerance, options) {
+  const geometry = feature.geometry;
+  const type = feature.type;
+  const simplifiedGeometry = [];
+  tile.minX = Math.min(tile.minX, feature.minX);
+  tile.minY = Math.min(tile.minY, feature.minY);
+  tile.maxX = Math.max(tile.maxX, feature.maxX);
+  tile.maxY = Math.max(tile.maxY, feature.maxY);
+  let simplifiedType;
+  switch (type) {
+    case "Point":
+    case "MultiPoint":
+      simplifiedType = 1;
+      for (let i = 0; i < geometry.length; i += 3) {
+        simplifiedGeometry.push(geometry[i], geometry[i + 1]);
+        tile.numPoints++;
+        tile.numSimplified++;
+      }
+      break;
+    case "LineString":
+      simplifiedType = 2;
+      addProtoLine(simplifiedGeometry, geometry, tile, tolerance, false, false);
+      break;
+    case "MultiLineString":
+      simplifiedType = 2;
+      for (let i = 0; i < geometry.length; i++) {
+        addProtoLine(simplifiedGeometry, geometry[i], tile, tolerance, false, i === 0);
+      }
+      break;
+    case "Polygon":
+      simplifiedType = 3;
+      for (let i = 0; i < geometry.length; i++) {
+        addProtoLine(simplifiedGeometry, geometry[i], tile, tolerance, true, i === 0);
+      }
+      break;
+    case "MultiPolygon":
+      simplifiedType = 3;
+      for (let k = 0; k < geometry.length; k++) {
+        const polygon = geometry[k];
+        for (let i = 0; i < polygon.length; i++) {
+          addProtoLine(simplifiedGeometry, polygon[i], tile, tolerance, true, i === 0);
+        }
+      }
+      break;
+    default:
+      throw new Error(`Unknown geometry type: ${type}`);
+  }
+  if (simplifiedGeometry.length) {
+    let tags = feature.tags || null;
+    if (type === "LineString" && options.lineMetrics) {
+      tags = {};
+      for (const key in feature.tags) {
+        tags[key] = feature.tags[key];
+      }
+      tags.mapbox_clip_start = geometry.start / geometry.size;
+      tags.mapbox_clip_end = geometry.end / geometry.size;
+    }
+    const tileFeature = {
+      geometry: simplifiedGeometry,
+      simplifiedType,
+      // @ts-expect-error
+      tags
+    };
+    if (feature.id !== null) {
+      tileFeature.id = feature.id;
+    }
+    tile.protoFeatures.push(tileFeature);
+  }
+}
+function addProtoLine(result, geometry, tile, tolerance, isPolygon, isOuter) {
+  const sqTolerance = tolerance * tolerance;
+  if (tolerance > 0 && geometry.size < (isPolygon ? sqTolerance : tolerance)) {
+    tile.numPoints += geometry.length / 3;
+    return;
+  }
+  const ring = [];
+  for (let i = 0; i < geometry.length; i += 3) {
+    if (tolerance === 0 || geometry[i + 2] > sqTolerance) {
+      tile.numSimplified++;
+      ring.push(geometry[i], geometry[i + 1]);
+    }
+    tile.numPoints++;
+  }
+  if (isPolygon)
+    rewind(ring, isOuter);
+  result.push(ring);
+}
+function rewind(ring, clockwise) {
+  let area = 0;
+  for (let i = 0, j = ring.length - 2; i < ring.length; j = i, i += 2) {
+    area += (ring[i] - ring[j]) * (ring[i + 1] + ring[j + 1]);
+  }
+  if (area > 0 === clockwise) {
+    for (let i = 0, len = ring.length; i < len / 2; i += 2) {
+      const x = ring[i];
+      const y = ring[i + 1];
+      ring[i] = ring[len - 2 - i];
+      ring[i + 1] = ring[len - 1 - i];
+      ring[len - 2 - i] = x;
+      ring[len - 1 - i] = y;
+    }
+  }
+}
+
+// dist/lib/vector-tiler/transform-tile.js
+function transformTile(protoTile, extent) {
+  if (protoTile.transformed) {
+    return protoTile;
+  }
+  const z2 = 1 << protoTile.z;
+  const tx = protoTile.x;
+  const ty = protoTile.y;
+  for (const protoFeature of protoTile.protoFeatures) {
+    const geom = protoFeature.geometry;
+    const simplifiedType = protoFeature.simplifiedType;
+    protoFeature.geometry = [];
+    if (simplifiedType === 1) {
+      for (let j = 0; j < geom.length; j += 2) {
+        protoFeature.geometry.push(transformPoint(geom[j], geom[j + 1], extent, z2, tx, ty));
+      }
+    } else {
+      for (let j = 0; j < geom.length; j++) {
+        const ring = [];
+        for (let k = 0; k < geom[j].length; k += 2) {
+          ring.push(transformPoint(geom[j][k], geom[j][k + 1], extent, z2, tx, ty));
+        }
+        protoFeature.geometry.push(ring);
+      }
+    }
+  }
+  protoTile.transformed = true;
+  return protoTile;
+}
+function transformPoint(x, y, extent, z2, tx, ty) {
+  return [Math.round(extent * (x * z2 - tx)), Math.round(extent * (y * z2 - ty))];
+}
+
+// dist/lib/vector-tiler/tile-to-geojson.js
+function convertTileToGeoJSON(protoTile, props) {
+  const features2 = [];
+  for (const rawFeature of protoTile.protoFeatures) {
+    if (!rawFeature || !rawFeature.geometry) {
+      continue;
+    }
+    let type;
+    let coordinates;
+    switch (rawFeature.simplifiedType) {
+      case 1:
+        if (rawFeature.geometry.length === 1) {
+          type = "Point";
+          coordinates = rawFeature.geometry[0];
+        } else {
+          type = "MultiPoint";
+          coordinates = rawFeature.geometry;
+        }
+        break;
+      case 2:
+        if (rawFeature.geometry.length === 1) {
+          type = "LineString";
+          coordinates = rawFeature.geometry[0];
+        } else {
+          type = "MultiLineString";
+          coordinates = rawFeature.geometry;
+        }
+        break;
+      case 3:
+        if (rawFeature.geometry.length > 1) {
+          type = "MultiPolygon";
+          coordinates = [rawFeature.geometry];
+        } else {
+          type = "Polygon";
+          coordinates = rawFeature.geometry;
+        }
+        break;
+      default:
+        throw new Error(`${rawFeature.simplifiedType}is not a valid simplified type`);
+    }
+    switch (props.coordinates) {
+      case "EPSG:4326":
+      case "wgs84":
+        projectToLngLat(coordinates, props.tileIndex, props.extent);
+        break;
+      default:
+        convertToLocalCoordinates(coordinates, props.extent);
+        break;
+    }
+    const feature = {
+      type: "Feature",
+      geometry: {
+        type,
+        coordinates
+      },
+      properties: rawFeature.tags || {},
+      id: rawFeature.id
+    };
+    features2.push(feature);
+  }
+  if (features2.length === 0) {
+    return null;
   }
-  return url;
-}
-function stringHash(s) {
-  return Math.abs(s.split("").reduce((a, b) => (a << 5) - a + b.charCodeAt(0) | 0, 0));
+  const table = {
+    shape: "geojson-table",
+    type: "FeatureCollection",
+    features: features2
+  };
+  return table;
 }
 
-// dist/table-tile-source.js
-var import_loader_utils3 = require("@loaders.gl/loader-utils");
-var import_schema = require("@loaders.gl/schema");
-var import_stats = require("@probe.gl/stats");
+// dist/lib/vector-tiler/features/proto-feature.js
+function createProtoFeature(id, type, geometry, tags) {
+  const feature = {
+    // eslint-disable-next-line
+    id: id == null ? null : id,
+    type,
+    simplifiedType: void 0,
+    // TODO
+    geometry,
+    tags,
+    minX: Infinity,
+    minY: Infinity,
+    maxX: -Infinity,
+    maxY: -Infinity
+  };
+  switch (type) {
+    case "Point":
+    case "MultiPoint":
+    case "LineString":
+      calcLineBBox(feature, geometry);
+      break;
+    case "MultiLineString":
+      for (const line of geometry) {
+        calcLineBBox(feature, line);
+      }
+      break;
+    case "Polygon":
+      calcLineBBox(feature, geometry[0]);
+      break;
+    case "MultiPolygon":
+      for (const polygon of geometry) {
+        calcLineBBox(feature, polygon[0]);
+      }
+      break;
+    default:
+      throw new Error(String(type));
+  }
+  return feature;
+}
+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]);
+  }
+}
 
-// dist/lib/vector-tiler/simplify.js
-function simplify(coords, first, last, sqTolerance) {
+// dist/lib/vector-tiler/features/simplify-path.js
+function simplifyPath(coords, first, last, sqTolerance) {
   let maxSqDist = sqTolerance;
   const mid = last - first >> 1;
   let minPosToMid = last - first;
@@ -1136,10 +1488,10 @@ function simplify(coords, first, last, sqTolerance) {
   }
   if (maxSqDist > sqTolerance) {
     if (index - first > 3)
-      simplify(coords, first, index, sqTolerance);
+      simplifyPath(coords, first, index, sqTolerance);
     coords[index + 2] = maxSqDist;
     if (last - index > 3)
-      simplify(coords, index, last, sqTolerance);
+      simplifyPath(coords, index, last, sqTolerance);
   }
 }
 function getSqSegDist(px, py, x, y, bx, by) {
@@ -1160,58 +1512,25 @@ function getSqSegDist(px, py, x, y, bx, by) {
   return dx * dx + dy * dy;
 }
 
-// dist/lib/vector-tiler/feature.js
-function createFeature(id, type, geom, tags) {
-  const feature = {
-    // eslint-disable-next-line
-    id: id == null ? null : id,
-    type,
-    geometry: geom,
-    tags,
-    minX: Infinity,
-    minY: Infinity,
-    maxX: -Infinity,
-    maxY: -Infinity
-  };
-  if (type === "Point" || type === "MultiPoint" || type === "LineString") {
-    calcLineBBox(feature, geom);
-  } else if (type === "Polygon") {
-    calcLineBBox(feature, geom[0]);
-  } else if (type === "MultiLineString") {
-    for (const line of geom) {
-      calcLineBBox(feature, line);
-    }
-  } else if (type === "MultiPolygon") {
-    for (const polygon of geom) {
-      calcLineBBox(feature, polygon[0]);
-    }
-  }
-  return feature;
-}
-function calcLineBBox(feature, geom) {
-  for (let i = 0; i < geom.length; i += 3) {
-    feature.minX = Math.min(feature.minX, geom[i]);
-    feature.minY = Math.min(feature.minY, geom[i + 1]);
-    feature.maxX = Math.max(feature.maxX, geom[i]);
-    feature.maxY = Math.max(feature.maxY, geom[i + 1]);
-  }
-}
-
-// dist/lib/vector-tiler/convert.js
-function convert(data, options) {
-  const features = [];
-  if (data.type === "FeatureCollection") {
-    for (let i = 0; i < data.features.length; i++) {
-      convertFeature(features, data.features[i], options, i);
-    }
-  } else if (data.type === "Feature") {
-    convertFeature(features, data, options);
-  } else {
-    convertFeature(features, { geometry: data }, options);
+// dist/lib/vector-tiler/features/convert-feature.js
+function convertFeaturesToProtoFeature(data, options) {
+  const protoFeatures = [];
+  switch (data.type) {
+    case "FeatureCollection":
+      let i = 0;
+      for (const feature of data.features) {
+        protoFeatures.push(convertFeature(feature, options, i++));
+      }
+      break;
+    case "Feature":
+      protoFeatures.push(convertFeature(data, options));
+      break;
+    default:
+      protoFeatures.push(convertFeature({ geometry: data }, options));
   }
-  return features;
+  return protoFeatures;
 }
-function convertFeature(features, geojson, options, index) {
+function convertFeature(geojson, options, index) {
   if (!geojson.geometry) {
     return;
   }
@@ -1225,46 +1544,52 @@ function convertFeature(features, geojson, options, index) {
   } else if (options.generateId) {
     id = index || 0;
   }
-  if (type === "Point") {
-    convertPoint(coords, geometry);
-  } else if (type === "MultiPoint") {
-    for (const p of coords) {
-      convertPoint(p, geometry);
-    }
-  } else if (type === "LineString") {
-    convertLine(coords, geometry, tolerance, false);
-  } else if (type === "MultiLineString") {
-    if (options.lineMetrics) {
-      for (const line of coords) {
-        geometry = [];
-        convertLine(line, geometry, tolerance, false);
-        features.push(createFeature(id, "LineString", geometry, geojson.properties));
+  switch (type) {
+    case "Point":
+      convertPoint(coords, geometry);
+      break;
+    case "MultiPoint":
+      for (const p of coords) {
+        convertPoint(p, geometry);
       }
-      return;
-    } else {
-      convertLines(coords, geometry, tolerance, false);
-    }
-  } else if (type === "Polygon") {
-    convertLines(coords, geometry, tolerance, true);
-  } else if (type === "MultiPolygon") {
-    for (const polygon of coords) {
-      const newPolygon = [];
-      convertLines(polygon, newPolygon, tolerance, true);
-      geometry.push(newPolygon);
-    }
-  } else if (type === "GeometryCollection") {
-    for (const singleGeometry of geojson.geometry.geometries) {
-      convertFeature(features, {
-        id,
-        geometry: singleGeometry,
-        properties: geojson.properties
-      }, options, index);
-    }
-    return;
-  } else {
-    throw new Error("Input data is not a valid GeoJSON object.");
+      break;
+    case "LineString":
+      convertLine(coords, geometry, tolerance, false);
+      break;
+    case "MultiLineString":
+      if (options.lineMetrics) {
+        for (const line of coords) {
+          geometry = [];
+          convertLine(line, geometry, tolerance, false);
+          features.push(createProtoFeature(id, "LineString", geometry, geojson.properties));
+        }
+        return;
+        convertLines(coords, geometry, tolerance, false);
+      }
+      break;
+    case "Polygon":
+      convertLines(coords, geometry, tolerance, true);
+      break;
+    case "MultiPolygon":
+      for (const polygon of coords) {
+        const newPolygon = [];
+        convertLines(polygon, newPolygon, tolerance, true);
+        geometry.push(newPolygon);
+      }
+      break;
+    case "GeometryCollection":
+      for (const singleGeometry of geojson.geometry.geometries) {
+        convertFeature(features, {
+          id,
+          geometry: singleGeometry,
+          properties: geojson.properties
+        }, options, index);
+      }
+      break;
+    default:
+      throw new Error("Input data is not a valid GeoJSON object.");
   }
-  features.push(createFeature(id, type, geometry, geojson.properties));
+  return createProtoFeature(id, type, geometry, geojson.properties);
 }
 function convertPoint(coords, out) {
   out.push(projectX(coords[0]), projectY(coords[1]), 0);
@@ -1288,7 +1613,7 @@ function convertLine(ring, out, tolerance, isPolygon) {
   }
   const last = out.length - 3;
   out[2] = 1;
-  simplify(out, 0, last, tolerance);
+  simplifyPath(out, 0, last, tolerance);
   out[last + 2] = 1;
   out.size = Math.abs(size);
   out.start = 0;
@@ -1310,17 +1635,17 @@ function projectY(y) {
   return y2 < 0 ? 0 : y2 > 1 ? 1 : y2;
 }
 
-// dist/lib/vector-tiler/clip.js
-function clip(features, scale, k1, k2, axis, minAll, maxAll, options) {
+// dist/lib/vector-tiler/features/clip-features.js
+function clipFeatures(features2, scale, k1, k2, axis, minAll, maxAll, options) {
   k1 /= scale;
   k2 /= scale;
   if (minAll >= k1 && maxAll < k2) {
-    return features;
+    return features2;
   } else if (maxAll < k1 || minAll >= k2) {
     return null;
   }
   const clipped = [];
-  for (const feature of features) {
+  for (const feature of features2) {
     const geometry = feature.geometry;
     let type = feature.type;
     const min = axis === 0 ? feature.minX : feature.minY;
@@ -1352,7 +1677,7 @@ function clip(features, scale, k1, k2, axis, minAll, maxAll, options) {
     if (newGeometry.length) {
       if (options.lineMetrics && type === "LineString") {
         for (const line of newGeometry) {
-          clipped.push(createFeature(feature.id, type, line, feature.tags));
+          clipped.push(createProtoFeature(feature.id, type, line, feature.tags));
         }
         continue;
       }
@@ -1367,7 +1692,7 @@ function clip(features, scale, k1, k2, axis, minAll, maxAll, options) {
       if (type === "Point" || type === "MultiPoint") {
         type = newGeometry.length === 3 ? "Point" : "MultiPoint";
       }
-      clipped.push(createFeature(feature.id, type, newGeometry, feature.tags));
+      clipped.push(createProtoFeature(feature.id, type, newGeometry, feature.tags));
     }
   }
   return clipped.length ? clipped : null;
@@ -1475,14 +1800,14 @@ function intersectY(out, ax, ay, bx, by, y) {
   return t;
 }
 
-// dist/lib/vector-tiler/wrap.js
-function wrap(features, options) {
+// dist/lib/vector-tiler/features/wrap-features.js
+function wrapFeatures(features2, options) {
   const buffer = options.buffer / options.extent;
-  let merged = features;
-  const left = clip(features, 1, -1 - buffer, buffer, 0, -1, 2, options);
-  const right = clip(features, 1, 1 - buffer, 2 + buffer, 0, -1, 2, options);
+  let merged = features2;
+  const left = clipFeatures(features2, 1, -1 - buffer, buffer, 0, -1, 2, options);
+  const right = clipFeatures(features2, 1, 1 - buffer, 2 + buffer, 0, -1, 2, options);
   if (left || right) {
-    merged = clip(features, 1, -buffer, 1 + buffer, 0, -1, 2, options) || [];
+    merged = clipFeatures(features2, 1, -buffer, 1 + buffer, 0, -1, 2, options) || [];
     if (left) {
       merged = shiftFeatureCoords(left, 1).concat(merged);
     }
@@ -1492,30 +1817,39 @@ function wrap(features, options) {
   }
   return merged;
 }
-function shiftFeatureCoords(features, offset) {
+function shiftFeatureCoords(features2, offset) {
   const newFeatures = [];
-  for (let i = 0; i < features.length; i++) {
-    const feature = features[i];
+  for (let i = 0; i < features2.length; i++) {
+    const feature = features2[i];
     const type = feature.type;
     let newGeometry;
-    if (type === "Point" || type === "MultiPoint" || type === "LineString") {
-      newGeometry = shiftCoords(feature.geometry, offset);
-    } else if (type === "MultiLineString" || type === "Polygon") {
-      newGeometry = [];
-      for (const line of feature.geometry) {
-        newGeometry.push(shiftCoords(line, offset));
-      }
-    } else if (type === "MultiPolygon") {
-      newGeometry = [];
-      for (const polygon of feature.geometry) {
-        const newPolygon = [];
-        for (const line of polygon) {
-          newPolygon.push(shiftCoords(line, offset));
+    switch (type) {
+      case "Point":
+      case "MultiPoint":
+      case "LineString":
+        newGeometry = shiftCoords(feature.geometry, offset);
+        break;
+      case "MultiLineString":
+      case "Polygon":
+        newGeometry = [];
+        for (const line of feature.geometry) {
+          newGeometry.push(shiftCoords(line, offset));
         }
-        newGeometry.push(newPolygon);
-      }
+        break;
+      case "MultiPolygon":
+        newGeometry = [];
+        for (const polygon of feature.geometry) {
+          const newPolygon = [];
+          for (const line of polygon) {
+            newPolygon.push(shiftCoords(line, offset));
+          }
+          newGeometry.push(newPolygon);
+        }
+        break;
+      default:
+        throw new Error(String(type));
     }
-    newFeatures.push(createFeature(feature.id, type, newGeometry, feature.tags));
+    newFeatures.push(createProtoFeature(feature.id, type, newGeometry, feature.tags));
   }
   return newFeatures;
 }
@@ -1532,148 +1866,48 @@ function shiftCoords(points, offset) {
   return newPoints;
 }
 
-// dist/lib/vector-tiler/transform.js
-function transformTile(tile, extent) {
-  if (tile.transformed) {
-    return tile;
-  }
-  const z2 = 1 << tile.z;
-  const tx = tile.x;
-  const ty = tile.y;
-  for (const feature of tile.features) {
-    const geom = feature.geometry;
-    const type = feature.type;
-    feature.geometry = [];
-    if (type === 1) {
-      for (let j = 0; j < geom.length; j += 2) {
-        feature.geometry.push(transformPoint(geom[j], geom[j + 1], extent, z2, tx, ty));
-      }
-    } else {
-      for (let j = 0; j < geom.length; j++) {
-        const ring = [];
-        for (let k = 0; k < geom[j].length; k += 2) {
-          ring.push(transformPoint(geom[j][k], geom[j][k + 1], extent, z2, tx, ty));
-        }
-        feature.geometry.push(ring);
-      }
-    }
-  }
-  tile.transformed = true;
-  return tile;
-}
-function transformPoint(x, y, extent, z2, tx, ty) {
-  return [Math.round(extent * (x * z2 - tx)), Math.round(extent * (y * z2 - ty))];
-}
-
-// dist/lib/vector-tiler/tile.js
-function createTile(features, z, tx, ty, options) {
-  const tolerance = z === options.maxZoom ? 0 : options.tolerance / ((1 << z) * options.extent);
-  const tile = {
-    features: [],
-    numPoints: 0,
-    numSimplified: 0,
-    numFeatures: features.length,
-    source: null,
-    x: tx,
-    y: ty,
-    z,
-    transformed: false,
-    minX: 2,
-    minY: 1,
-    maxX: -1,
-    maxY: 0
-  };
-  for (const feature of features) {
-    addFeature(tile, feature, tolerance, options);
-  }
-  return tile;
-}
-function addFeature(tile, feature, tolerance, options) {
-  const geom = feature.geometry;
-  const type = feature.type;
-  const simplified = [];
-  tile.minX = Math.min(tile.minX, feature.minX);
-  tile.minY = Math.min(tile.minY, feature.minY);
-  tile.maxX = Math.max(tile.maxX, feature.maxX);
-  tile.maxY = Math.max(tile.maxY, feature.maxY);
-  if (type === "Point" || type === "MultiPoint") {
-    for (let i = 0; i < geom.length; i += 3) {
-      simplified.push(geom[i], geom[i + 1]);
-      tile.numPoints++;
-      tile.numSimplified++;
-    }
-  } else if (type === "LineString") {
-    addLine(simplified, geom, tile, tolerance, false, false);
-  } else if (type === "MultiLineString" || type === "Polygon") {
-    for (let i = 0; i < geom.length; i++) {
-      addLine(simplified, geom[i], tile, tolerance, type === "Polygon", i === 0);
-    }
-  } else if (type === "MultiPolygon") {
-    for (let k = 0; k < geom.length; k++) {
-      const polygon = geom[k];
-      for (let i = 0; i < polygon.length; i++) {
-        addLine(simplified, polygon[i], tile, tolerance, true, i === 0);
-      }
-    }
-  }
-  if (simplified.length) {
-    let tags = feature.tags || null;
-    if (type === "LineString" && options.lineMetrics) {
-      tags = {};
-      for (const key in feature.tags)
-        tags[key] = feature.tags[key];
-      tags.mapbox_clip_start = geom.start / geom.size;
-      tags.mapbox_clip_end = geom.end / geom.size;
-    }
-    const tileFeature = {
-      geometry: simplified,
-      type: type === "Polygon" || type === "MultiPolygon" ? 3 : type === "LineString" || type === "MultiLineString" ? 2 : 1,
-      tags
-    };
-    if (feature.id !== null) {
-      tileFeature.id = feature.id;
-    }
-    tile.features.push(tileFeature);
-  }
-}
-function addLine(result, geom, tile, tolerance, isPolygon, isOuter) {
-  const sqTolerance = tolerance * tolerance;
-  if (tolerance > 0 && geom.size < (isPolygon ? sqTolerance : tolerance)) {
-    tile.numPoints += geom.length / 3;
-    return;
-  }
-  const ring = [];
-  for (let i = 0; i < geom.length; i += 3) {
-    if (tolerance === 0 || geom[i + 2] > sqTolerance) {
-      tile.numSimplified++;
-      ring.push(geom[i], geom[i + 1]);
+// dist/table-tile-source.js
+var TableTileSource = {
+  name: "TableTiler",
+  id: "table-tiler",
+  version: "0.0.0",
+  extensions: ["mvt"],
+  mimeTypes: ["application/octet-stream"],
+  options: {
+    table: {
+      coordinates: "local",
+      promoteId: void 0,
+      maxZoom: 14,
+      indexMaxZoom: 5,
+      maxPointsPerTile: 1e4,
+      tolerance: 3,
+      extent: 4096,
+      buffer: 64,
+      generateId: void 0
     }
-    tile.numPoints++;
-  }
-  if (isPolygon)
-    rewind(ring, isOuter);
-  result.push(ring);
-}
-function rewind(ring, clockwise) {
-  let area = 0;
-  for (let i = 0, j = ring.length - 2; i < ring.length; j = i, i += 2) {
-    area += (ring[i] - ring[j]) * (ring[i + 1] + ring[j + 1]);
+  },
+  type: "table",
+  testURL: (url) => url.endsWith(".geojson"),
+  createDataSource(url, options) {
+    var _a, _b;
+    const needsLoading = typeof url === "string" || url instanceof Blob;
+    const loader = (_b = (_a = options == null ? void 0 : options.table) == null ? void 0 : _a.loaders) == null ? void 0 : _b[0];
+    const tablePromise = needsLoading ? loadTable(url, loader) : url;
+    return new DynamicVectorTileSource(tablePromise, options);
   }
-  if (area > 0 === clockwise) {
-    for (let i = 0, len = ring.length; i < len / 2; i += 2) {
-      const x = ring[i];
-      const y = ring[i + 1];
-      ring[i] = ring[len - 2 - i];
-      ring[i + 1] = ring[len - 1 - i];
-      ring[len - 2 - i] = x;
-      ring[len - 1 - i] = y;
-    }
+  // @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);
 }
-
-// dist/table-tile-source.js
-var _TableTileSource = class {
-  /** Stats for this TableTileSource */
+var _DynamicVectorTileSource = class {
+  /** Stats for this DynamicVectorTileSource */
   stats = new import_stats.Stats({
     id: "table-tile-source",
     stats: [new import_stats.Stat("tiles", "count"), new import_stats.Stat("features", "count")]
@@ -1682,6 +1916,7 @@ var _TableTileSource = class {
   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;
@@ -1694,7 +1929,7 @@ var _TableTileSource = class {
   /** Metadata for the tile source (generated TileJSON/tilestats */
   metadata;
   constructor(table, props) {
-    this.props = { ..._TableTileSource.defaultProps, ...props };
+    this.props = { ...TableTileSource.options.table, ...props == null ? void 0 : props.table };
     this.getTileData = this.getTileData.bind(this);
     this.ready = this.initializeTilesAsync(table);
     this.metadata = this.getMetadata();
@@ -1738,11 +1973,11 @@ var _TableTileSource = class {
    * @note Application must await `source.ready` before calling sync methods.
    */
   getTileSync(tileIndex) {
-    const rawTile = this.getRawTile(tileIndex);
-    if (!rawTile) {
+    const protoTile = this.getProtoTile(tileIndex);
+    if (!protoTile) {
       return null;
     }
-    return convertToGeoJSONTable(rawTile, {
+    return convertTileToGeoJSON(protoTile, {
       coordinates: this.props.coordinates,
       tileIndex,
       extent: this.props.extent
@@ -1759,28 +1994,28 @@ var _TableTileSource = class {
     if (this.props.promoteId && this.props.generateId) {
       throw new Error("promoteId and generateId cannot be used together.");
     }
-    import_loader_utils3.log.log(1, "TableTileSource creating root tiles", this.props)();
+    import_loader_utils3.log.log(1, "DynamicVectorTileSource creating root tiles", this.props)();
     import_loader_utils3.log.time(1, "preprocess table")();
-    let features = convert(table, this.props);
+    let features2 = convertFeaturesToProtoFeature(table, this.props);
     import_loader_utils3.log.timeEnd(1, "preprocess table")();
     import_loader_utils3.log.time(1, "generate tiles")();
-    features = wrap(features, this.props);
-    if (features.length === 0) {
-      import_loader_utils3.log.log(1, "TableTileSource: no features generated")();
+    features2 = wrapFeatures(features2, this.props);
+    if (features2.length === 0) {
+      import_loader_utils3.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];
     import_loader_utils3.log.log(1, `root tile features: ${rootTile.numFeatures}, points: ${rootTile.numPoints}`)();
     import_loader_utils3.log.timeEnd(1, "generate tiles")();
-    import_loader_utils3.log.log(1, `TableTileSource: tiles generated: ${this.stats.get("total").count}`, this.stats)();
+    import_loader_utils3.log.log(1, `DynamicVectorTileSource: tiles generated: ${this.stats.get("total").count}`, this.stats)();
   }
   /**
    * Return geojsonvt-style "half formed" vector tile
    * @note Application must await `source.ready` before calling sync methods.
    */
   // eslint-disable-next-line complexity, max-statements
-  getRawTile(tileIndex) {
+  getProtoTile(tileIndex) {
     const { z, y } = tileIndex;
     let { x } = tileIndex;
     const { extent } = this.props;
@@ -1804,12 +2039,12 @@ var _TableTileSource = class {
       y0 = y0 >> 1;
       parent = this.tiles[toID(z0, x0, y0)];
     }
-    if (!parent || !parent.source) {
+    if (!parent || !parent.sourceFeatures) {
       return null;
     }
     import_loader_utils3.log.log(1, "found parent tile z%d-%d-%d", z0, x0, y0)();
     import_loader_utils3.log.time(1, "drilling down")();
-    this.splitTile(parent.source, z0, x0, y0, z, x, y);
+    this.splitTile(parent.sourceFeatures, z0, x0, y0, z, x, y);
     import_loader_utils3.log.timeEnd(1, "drilling down")();
     return this.tiles[id] ? transformTile(this.tiles[id], extent) : null;
   }
@@ -1822,33 +2057,33 @@ var _TableTileSource = class {
    * 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) {
         import_loader_utils3.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();
         import_loader_utils3.log.log(2, "tile z%d-%d-%d (features: %d, points: %d, simplified: %d)", z, x, y, tile.numFeatures, tile.numPoints, tile.numSimplified)();
         import_loader_utils3.log.timeEnd(2, "tile creation")();
       }
-      tile.source = features;
+      tile.sourceFeatures = features2;
       if (cz === void 0) {
         if (z === this.props.indexMaxZoom || tile.numPoints <= this.props.maxPointsPerTile) {
           continue;
@@ -1861,8 +2096,8 @@ var _TableTileSource = class {
           continue;
         }
       }
-      tile.source = null;
-      if (features.length === 0)
+      tile.sourceFeatures = null;
+      if (features2.length === 0)
         continue;
       import_loader_utils3.log.time(2, "clipping tile")();
       const k1 = 0.5 * this.props.buffer / this.props.extent;
@@ -1873,17 +2108,17 @@ var _TableTileSource = class {
       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;
       }
       import_loader_utils3.log.timeEnd(2, "clipping tile")();
@@ -1894,109 +2129,13 @@ var _TableTileSource = class {
     }
   }
 };
-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 import_stats.Stats({
+var DynamicVectorTileSource = _DynamicVectorTileSource;
+/** Global stats for all DynamicVectorTileSources */
+__publicField(DynamicVectorTileSource, "stats", new import_stats.Stats({
   id: "table-tile-source-all",
   stats: [new import_stats.Stat("count", "tiles"), new import_stats.Stat("count", "features")]
 }));
 function toID(z, x, y) {
   return ((1 << z) * y + x) * 32 + z;
 }
-function convertToGeoJSONTable(vtTile, 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;
-}
 //# sourceMappingURL=index.cjs.map