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

package/dist/index.cjs

@@ -5,6 +5,7 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -26,23 +27,82 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
 
 // dist/index.js
 var dist_exports = {};
 __export(dist_exports, {
-  GeoJSONTiler: () => GeoJSONTiler,
   MVTLoader: () => MVTLoader,
   MVTSource: () => MVTSource,
   MVTWorkerLoader: () => MVTWorkerLoader,
+  TableTileSource: () => TableTileSource,
   TileJSONLoader: () => TileJSONLoader
 });
 module.exports = __toCommonJS(dist_exports);
 
 // dist/lib/parse-mvt.js
 var import_gis = require("@loaders.gl/gis");
+var import_loader_utils = require("@loaders.gl/loader-utils");
 var import_pbf = __toESM(require("pbf"), 1);
 
-// dist/helpers/mapbox-util-functions.js
+// dist/lib/utils/geometry-utils.js
+var import_polygon = require("@math.gl/polygon");
+function signedArea(ring) {
+  let sum = 0;
+  for (let i = 0, j = ring.length - 1, p1, p2; i < ring.length; j = i++) {
+    p1 = ring[i];
+    p2 = ring[j];
+    sum += (p2[0] - p1[0]) * (p1[1] + p2[1]);
+  }
+  return sum;
+}
+function convertToLocalCoordinates(coordinates, extent) {
+  if (Array.isArray(coordinates[0])) {
+    for (const subcoords of coordinates) {
+      convertToLocalCoordinates(subcoords, extent);
+    }
+    return;
+  }
+  const p = coordinates;
+  p[0] /= extent;
+  p[1] /= extent;
+}
+function convertToLocalCoordinatesFlat(data, extent) {
+  for (let i = 0, il = data.length; i < il; ++i) {
+    data[i] /= extent;
+  }
+}
+function projectToLngLat(line, tileIndex, extent) {
+  if (typeof line[0][0] !== "number") {
+    for (const point of line) {
+      projectToLngLat(point, tileIndex, extent);
+    }
+    return;
+  }
+  const size = extent * Math.pow(2, tileIndex.z);
+  const x0 = extent * tileIndex.x;
+  const y0 = extent * tileIndex.y;
+  for (let j = 0; j < line.length; j++) {
+    const p = line[j];
+    p[0] = (p[0] + x0) * 360 / size - 180;
+    const y2 = 180 - (p[1] + y0) * 360 / size;
+    p[1] = 360 / Math.PI * Math.atan(Math.exp(y2 * Math.PI / 180)) - 90;
+  }
+}
+function projectToLngLatFlat(data, tileIndex, extent) {
+  const { x, y, z } = tileIndex;
+  const size = extent * Math.pow(2, z);
+  const x0 = extent * x;
+  const y0 = extent * y;
+  for (let j = 0, jl = data.length; j < jl; j += 2) {
+    data[j] = (data[j] + x0) * 360 / size - 180;
+    const y2 = 180 - (data[j + 1] + y0) * 360 / size;
+    data[j + 1] = 360 / Math.PI * Math.atan(Math.exp(y2 * Math.PI / 180)) - 90;
+  }
+}
 function classifyRings(rings) {
   const len = rings.length;
   if (len <= 1)
@@ -50,8 +110,8 @@ function classifyRings(rings) {
   const polygons = [];
   let polygon;
   let ccw;
-  for (let i2 = 0; i2 < len; i2++) {
-    const area = signedArea(rings[i2]);
+  for (let i = 0; i < len; i++) {
+    const area = signedArea(rings[i]);
     if (area === 0)
       continue;
     if (ccw === void 0)
@@ -59,294 +119,15 @@ function classifyRings(rings) {
     if (ccw === area < 0) {
       if (polygon)
         polygons.push(polygon);
-      polygon = [rings[i2]];
+      polygon = [rings[i]];
     } else if (polygon)
-      polygon.push(rings[i2]);
+      polygon.push(rings[i]);
   }
   if (polygon)
     polygons.push(polygon);
   return polygons;
 }
-function signedArea(ring) {
-  let sum = 0;
-  for (let i2 = 0, j = ring.length - 1, p1, p2; i2 < ring.length; j = i2++) {
-    p1 = ring[i2];
-    p2 = ring[j];
-    sum += (p2[0] - p1[0]) * (p1[1] + p2[1]);
-  }
-  return sum;
-}
-function readFeature(tag, feature, pbf) {
-  if (feature && pbf) {
-    if (tag === 1)
-      feature.id = pbf.readVarint();
-    else if (tag === 2)
-      readTag(pbf, feature);
-    else if (tag === 3)
-      feature.type = pbf.readVarint();
-    else if (tag === 4)
-      feature._geometry = pbf.pos;
-  }
-}
-function readTag(pbf, feature) {
-  const end = pbf.readVarint() + pbf.pos;
-  while (pbf.pos < end) {
-    const key = feature._keys[pbf.readVarint()];
-    const value = feature._values[pbf.readVarint()];
-    feature.properties[key] = value;
-  }
-}
-
-// dist/lib/mapbox-vector-tile/vector-tile-feature.js
-var VectorTileFeature = class {
-  properties;
-  extent;
-  type;
-  id;
-  _pbf;
-  _geometry;
-  _keys;
-  _values;
-  static get types() {
-    return ["Unknown", "Point", "LineString", "Polygon"];
-  }
-  constructor(pbf, end, extent, keys, values) {
-    this.properties = {};
-    this.extent = extent;
-    this.type = 0;
-    this.id = null;
-    this._pbf = pbf;
-    this._geometry = -1;
-    this._keys = keys;
-    this._values = values;
-    pbf.readFields(readFeature, this, end);
-  }
-  // eslint-disable-next-line complexity, max-statements
-  loadGeometry() {
-    const pbf = this._pbf;
-    pbf.pos = this._geometry;
-    const end = pbf.readVarint() + pbf.pos;
-    let cmd2 = 1;
-    let length2 = 0;
-    let x2 = 0;
-    let y2 = 0;
-    const lines = [];
-    let line;
-    while (pbf.pos < end) {
-      if (length2 <= 0) {
-        const cmdLen2 = pbf.readVarint();
-        cmd2 = cmdLen2 & 7;
-        length2 = cmdLen2 >> 3;
-      }
-      length2--;
-      if (cmd2 === 1 || cmd2 === 2) {
-        x2 += pbf.readSVarint();
-        y2 += pbf.readSVarint();
-        if (cmd2 === 1) {
-          if (line)
-            lines.push(line);
-          line = [];
-        }
-        if (line)
-          line.push([x2, y2]);
-      } else if (cmd2 === 7) {
-        if (line) {
-          line.push(line[0].slice());
-        }
-      } else {
-        throw new Error(`unknown command ${cmd2}`);
-      }
-    }
-    if (line)
-      lines.push(line);
-    return lines;
-  }
-  // eslint-disable-next-line max-statements
-  bbox() {
-    const pbf = this._pbf;
-    pbf.pos = this._geometry;
-    const end = pbf.readVarint() + pbf.pos;
-    let cmd2 = 1;
-    let length2 = 0;
-    let x2 = 0;
-    let y2 = 0;
-    let x1 = Infinity;
-    let x22 = -Infinity;
-    let y1 = Infinity;
-    let y22 = -Infinity;
-    while (pbf.pos < end) {
-      if (length2 <= 0) {
-        const cmdLen2 = pbf.readVarint();
-        cmd2 = cmdLen2 & 7;
-        length2 = cmdLen2 >> 3;
-      }
-      length2--;
-      if (cmd2 === 1 || cmd2 === 2) {
-        x2 += pbf.readSVarint();
-        y2 += pbf.readSVarint();
-        if (x2 < x1)
-          x1 = x2;
-        if (x2 > x22)
-          x22 = x2;
-        if (y2 < y1)
-          y1 = y2;
-        if (y2 > y22)
-          y22 = y2;
-      } else if (cmd2 !== 7) {
-        throw new Error(`unknown command ${cmd2}`);
-      }
-    }
-    return [x1, y1, x22, y22];
-  }
-  _toGeoJSON(transform) {
-    let coords = this.loadGeometry();
-    let type = VectorTileFeature.types[this.type];
-    let i2;
-    let j;
-    switch (this.type) {
-      case 1:
-        const points = [];
-        for (i2 = 0; i2 < coords.length; i2++) {
-          points[i2] = coords[i2][0];
-        }
-        coords = points;
-        transform(coords, this);
-        break;
-      case 2:
-        for (i2 = 0; i2 < coords.length; i2++) {
-          transform(coords[i2], this);
-        }
-        break;
-      case 3:
-        coords = classifyRings(coords);
-        for (i2 = 0; i2 < coords.length; i2++) {
-          for (j = 0; j < coords[i2].length; j++) {
-            transform(coords[i2][j], this);
-          }
-        }
-        break;
-    }
-    if (coords.length === 1) {
-      coords = coords[0];
-    } else {
-      type = `Multi${type}`;
-    }
-    const result = {
-      type: "Feature",
-      geometry: {
-        type,
-        coordinates: coords
-      },
-      properties: this.properties
-    };
-    if (this.id !== null) {
-      result.id = this.id;
-    }
-    return result;
-  }
-  toGeoJSON(options) {
-    if (typeof options === "function") {
-      return this._toGeoJSON(options);
-    }
-    const { x: x2, y: y2, z } = options;
-    const size = this.extent * Math.pow(2, z);
-    const x0 = this.extent * x2;
-    const y0 = this.extent * y2;
-    function project2(line) {
-      for (let j = 0; j < line.length; j++) {
-        const p = line[j];
-        p[0] = (p[0] + x0) * 360 / size - 180;
-        const y22 = 180 - (p[1] + y0) * 360 / size;
-        p[1] = 360 / Math.PI * Math.atan(Math.exp(y22 * Math.PI / 180)) - 90;
-      }
-    }
-    return this._toGeoJSON(project2);
-  }
-};
-
-// dist/lib/mapbox-vector-tile/vector-tile-layer.js
-var VectorTileLayer = class {
-  version;
-  name;
-  extent;
-  length;
-  _pbf;
-  _keys;
-  _values;
-  _features;
-  constructor(pbf, end) {
-    this.version = 1;
-    this.name = "";
-    this.extent = 4096;
-    this.length = 0;
-    this._pbf = pbf;
-    this._keys = [];
-    this._values = [];
-    this._features = [];
-    pbf.readFields(readLayer, this, end);
-    this.length = this._features.length;
-  }
-  /**
-   * return feature `i` from this layer as a `VectorTileFeature`
-   * @param index
-   * @returns feature
-   */
-  feature(i2) {
-    if (i2 < 0 || i2 >= this._features.length) {
-      throw new Error("feature index out of bounds");
-    }
-    this._pbf.pos = this._features[i2];
-    const end = this._pbf.readVarint() + this._pbf.pos;
-    return new VectorTileFeature(this._pbf, end, this.extent, this._keys, this._values);
-  }
-};
-function readLayer(tag, layer, pbf) {
-  if (layer && pbf) {
-    if (tag === 15)
-      layer.version = pbf.readVarint();
-    else if (tag === 1)
-      layer.name = pbf.readString();
-    else if (tag === 5)
-      layer.extent = pbf.readVarint();
-    else if (tag === 2)
-      layer._features.push(pbf.pos);
-    else if (tag === 3)
-      layer._keys.push(pbf.readString());
-    else if (tag === 4)
-      layer._values.push(readValueMessage(pbf));
-  }
-}
-function readValueMessage(pbf) {
-  let value = null;
-  const end = pbf.readVarint() + pbf.pos;
-  while (pbf.pos < end) {
-    const tag = pbf.readVarint() >> 3;
-    value = tag === 1 ? pbf.readString() : tag === 2 ? pbf.readFloat() : tag === 3 ? pbf.readDouble() : tag === 4 ? pbf.readVarint64() : tag === 5 ? pbf.readVarint() : tag === 6 ? pbf.readSVarint() : tag === 7 ? pbf.readBoolean() : null;
-  }
-  return value;
-}
-
-// dist/lib/mapbox-vector-tile/vector-tile.js
-var VectorTile = class {
-  layers;
-  constructor(pbf, end) {
-    this.layers = pbf.readFields(readTile, {}, end);
-  }
-};
-function readTile(tag, layers, pbf) {
-  if (tag === 3) {
-    if (pbf) {
-      const layer = new VectorTileLayer(pbf, pbf.readVarint() + pbf.pos);
-      if (layer.length && layers) {
-        layers[layer.name] = layer;
-      }
-    }
-  }
-}
-
-// dist/helpers/binary-util-functions.js
-var import_polygon = require("@math.gl/polygon");
-function classifyRings2(geom) {
+function classifyRingsFlat(geom) {
   const len = geom.indices.length;
   const type = "Polygon";
   if (len <= 1) {
@@ -363,9 +144,9 @@ function classifyRings2(geom) {
   let polygon = [];
   let ccw;
   let offset = 0;
-  for (let endIndex, i2 = 0, startIndex; i2 < len; i2++) {
-    startIndex = geom.indices[i2] - offset;
-    endIndex = geom.indices[i2 + 1] - offset || geom.data.length;
+  for (let endIndex, i = 0, startIndex; i < len; i++) {
+    startIndex = geom.indices[i] - offset;
+    endIndex = geom.indices[i + 1] - offset || geom.data.length;
     const shape = geom.data.slice(startIndex, endIndex);
     const area = (0, import_polygon.getPolygonSignedArea)(shape);
     if (area === 0) {
@@ -395,43 +176,9 @@ function classifyRings2(geom) {
     polygons.push(polygon);
   return { type, areas, indices: polygons, data: geom.data };
 }
-function project(data, x0, y0, size) {
-  for (let j = 0, jl = data.length; j < jl; j += 2) {
-    data[j] = (data[j] + x0) * 360 / size - 180;
-    const y2 = 180 - (data[j + 1] + y0) * 360 / size;
-    data[j + 1] = 360 / Math.PI * Math.atan(Math.exp(y2 * Math.PI / 180)) - 90;
-  }
-}
-function readFeature2(tag, feature, pbf) {
-  if (feature && pbf) {
-    if (tag === 1)
-      feature.id = pbf.readVarint();
-    else if (tag === 2)
-      readTag2(pbf, feature);
-    else if (tag === 3)
-      feature.type = pbf.readVarint();
-    else if (tag === 4)
-      feature._geometry = pbf.pos;
-  }
-}
-function readTag2(pbf, feature) {
-  const end = pbf.readVarint() + pbf.pos;
-  while (pbf.pos < end) {
-    const key = feature._keys[pbf.readVarint()];
-    const value = feature._values[pbf.readVarint()];
-    feature.properties[key] = value;
-  }
-}
 
-// dist/lib/binary-vector-tile/vector-tile-feature.js
-var endPos;
-var cmd;
-var cmdLen;
-var length;
-var x;
-var y;
-var i;
-var BinaryVectorTileFeature = class {
+// dist/lib/vector-tile/vector-tile-feature.js
+var VectorTileFeature = class {
   properties;
   extent;
   type;
@@ -452,23 +199,48 @@ var BinaryVectorTileFeature = class {
     this._keys = keys;
     this._values = values;
     this._geometryInfo = geometryInfo;
-    pbf.readFields(readFeature2, this, end);
+    pbf.readFields(readFeature, this, end);
   }
-  // eslint-disable-next-line complexity, max-statements
-  loadGeometry() {
+  toGeoJSONFeature(coordinates, tileIndex) {
+    const coords = this.loadGeometry();
+    switch (coordinates) {
+      case "wgs84":
+        return _toGeoJSONFeature(this, coords, (line) => projectToLngLat(line, tileIndex, this.extent));
+      default:
+        return _toGeoJSONFeature(this, coords, convertToLocalCoordinates);
+    }
+  }
+  /**
+   *
+   * @param options
+   * @returns
+   */
+  toBinaryFeature(coordinates, tileIndex) {
+    const geom = this.loadFlatGeometry();
+    switch (coordinates) {
+      case "wgs84":
+        return this._toBinaryCoordinates(geom, (coords) => projectToLngLatFlat(coords, tileIndex, this.extent));
+      default:
+        return this._toBinaryCoordinates(geom, convertToLocalCoordinatesFlat);
+    }
+  }
+  /** Read a bounding box from the feature */
+  // eslint-disable-next-line max-statements
+  bbox() {
     const pbf = this._pbf;
     pbf.pos = this._geometry;
-    endPos = pbf.readVarint() + pbf.pos;
-    cmd = 1;
-    length = 0;
-    x = 0;
-    y = 0;
-    i = 0;
-    const indices = [];
-    const data = [];
-    while (pbf.pos < endPos) {
+    const end = pbf.readVarint() + pbf.pos;
+    let cmd = 1;
+    let length = 0;
+    let x = 0;
+    let y = 0;
+    let x1 = Infinity;
+    let x2 = -Infinity;
+    let y1 = Infinity;
+    let y2 = -Infinity;
+    while (pbf.pos < end) {
       if (length <= 0) {
-        cmdLen = pbf.readVarint();
+        const cmdLen = pbf.readVarint();
         cmd = cmdLen & 7;
         length = cmdLen >> 3;
       }
@@ -476,32 +248,29 @@ var BinaryVectorTileFeature = class {
       if (cmd === 1 || cmd === 2) {
         x += pbf.readSVarint();
         y += pbf.readSVarint();
-        if (cmd === 1) {
-          indices.push(i);
-        }
-        data.push(x, y);
-        i += 2;
-      } else if (cmd === 7) {
-        if (i > 0) {
-          const start = indices[indices.length - 1];
-          data.push(data[start], data[start + 1]);
-          i += 2;
-        }
-      } else {
+        if (x < x1)
+          x1 = x;
+        if (x > x2)
+          x2 = x;
+        if (y < y1)
+          y1 = y;
+        if (y > y2)
+          y2 = y;
+      } else if (cmd !== 7) {
         throw new Error(`unknown command ${cmd}`);
       }
     }
-    return { data, indices };
+    return [x1, y1, x2, y2];
   }
+  // BINARY HELPERS
   /**
    *
    * @param transform
    * @returns result
    */
-  _toBinaryCoordinates(transform) {
-    const geom = this.loadGeometry();
+  _toBinaryCoordinates(geom, transform) {
     let geometry;
-    transform(geom.data, this);
+    transform(geom.data, this.extent);
     const coordLength = 2;
     switch (this.type) {
       case 1:
@@ -516,7 +285,7 @@ var BinaryVectorTileFeature = class {
         geometry = { type: "LineString", ...geom };
         break;
       case 3:
-        geometry = classifyRings2(geom);
+        geometry = classifyRingsFlat(geom);
         this._geometryInfo.polygonFeaturesCount++;
         this._geometryInfo.polygonObjectsCount += geometry.indices.length;
         for (const indices of geometry.indices) {
@@ -533,20 +302,188 @@ var BinaryVectorTileFeature = class {
     }
     return result;
   }
-  toBinaryCoordinates(options) {
-    if (typeof options === "function") {
-      return this._toBinaryCoordinates(options);
+  // GEOJSON HELPER
+  // eslint-disable-next-line complexity, max-statements
+  loadGeometry() {
+    const pbf = this._pbf;
+    pbf.pos = this._geometry;
+    const end = pbf.readVarint() + pbf.pos;
+    let cmd = 1;
+    let length = 0;
+    let x = 0;
+    let y = 0;
+    const lines = [];
+    let line;
+    while (pbf.pos < end) {
+      if (length <= 0) {
+        const cmdLen = pbf.readVarint();
+        cmd = cmdLen & 7;
+        length = cmdLen >> 3;
+      }
+      length--;
+      switch (cmd) {
+        case 1:
+        case 2:
+          x += pbf.readSVarint();
+          y += pbf.readSVarint();
+          if (cmd === 1) {
+            if (line)
+              lines.push(line);
+            line = [];
+          }
+          if (line)
+            line.push([x, y]);
+          break;
+        case 7:
+          if (line) {
+            line.push(line[0].slice());
+          }
+          break;
+        default:
+          throw new Error(`unknown command ${cmd}`);
+      }
+    }
+    if (line)
+      lines.push(line);
+    return lines;
+  }
+  /**
+   * Expands the protobuf data to an intermediate Flat GeoJSON
+   * data format, which maps closely to the binary data buffers.
+   * It is similar to GeoJSON, but rather than storing the coordinates
+   * in multidimensional arrays, we have a 1D `data` with all the
+   * coordinates, and then index into this using the `indices`
+   * parameter, e.g.
+   *
+   * geometry: {
+   *   type: 'Point', data: [1,2], indices: [0]
+   * }
+   * geometry: {
+   *   type: 'LineString', data: [1,2,3,4,...], indices: [0]
+   * }
+   * geometry: {
+   *   type: 'Polygon', data: [1,2,3,4,...], indices: [[0, 2]]
+   * }
+   * Thus the indices member lets us look up the relevant range
+   * from the data array.
+   * The Multi* versions of the above types share the same data
+   * structure, just with multiple elements in the indices array
+   */
+  // eslint-disable-next-line complexity, max-statements
+  loadFlatGeometry() {
+    const pbf = this._pbf;
+    pbf.pos = this._geometry;
+    const endPos = pbf.readVarint() + pbf.pos;
+    let cmd = 1;
+    let cmdLen;
+    let length = 0;
+    let x = 0;
+    let y = 0;
+    let i = 0;
+    const indices = [];
+    const data = [];
+    while (pbf.pos < endPos) {
+      if (length <= 0) {
+        cmdLen = pbf.readVarint();
+        cmd = cmdLen & 7;
+        length = cmdLen >> 3;
+      }
+      length--;
+      if (cmd === 1 || cmd === 2) {
+        x += pbf.readSVarint();
+        y += pbf.readSVarint();
+        if (cmd === 1) {
+          indices.push(i);
+        }
+        data.push(x, y);
+        i += 2;
+      } else if (cmd === 7) {
+        if (i > 0) {
+          const start = indices[indices.length - 1];
+          data.push(data[start], data[start + 1]);
+          i += 2;
+        }
+      } else {
+        throw new Error(`unknown command ${cmd}`);
+      }
     }
-    const { x: x2, y: y2, z } = options;
-    const size = this.extent * Math.pow(2, z);
-    const x0 = this.extent * x2;
-    const y0 = this.extent * y2;
-    return this._toBinaryCoordinates((data) => project(data, x0, y0, size));
+    return { data, indices };
   }
 };
+__publicField(VectorTileFeature, "types", ["Unknown", "Point", "LineString", "Polygon"]);
+function _toGeoJSONFeature(vtFeature, coords, transform) {
+  let type = VectorTileFeature.types[vtFeature.type];
+  let i;
+  let j;
+  let coordinates;
+  switch (vtFeature.type) {
+    case 1:
+      const points = [];
+      for (i = 0; i < coords.length; i++) {
+        points[i] = coords[i][0];
+      }
+      coordinates = points;
+      transform(coordinates, vtFeature.extent);
+      break;
+    case 2:
+      coordinates = coords;
+      for (i = 0; i < coordinates.length; i++) {
+        transform(coordinates[i], vtFeature.extent);
+      }
+      break;
+    case 3:
+      coordinates = classifyRings(coords);
+      for (i = 0; i < coordinates.length; i++) {
+        for (j = 0; j < coordinates[i].length; j++) {
+          transform(coordinates[i][j], vtFeature.extent);
+        }
+      }
+      break;
+    default:
+      throw new Error("illegal vector tile type");
+  }
+  if (coordinates.length === 1) {
+    coordinates = coordinates[0];
+  } else {
+    type = `Multi${type}`;
+  }
+  const result = {
+    type: "Feature",
+    geometry: {
+      type,
+      coordinates
+    },
+    properties: vtFeature.properties
+  };
+  if (vtFeature.id !== null) {
+    result.properties ||= {};
+    result.properties.id = vtFeature.id;
+  }
+  return result;
+}
+function readFeature(tag, feature, pbf) {
+  if (feature && pbf) {
+    if (tag === 1)
+      feature.id = pbf.readVarint();
+    else if (tag === 2)
+      readTag(pbf, feature);
+    else if (tag === 3)
+      feature.type = pbf.readVarint();
+    else if (tag === 4)
+      feature._geometry = pbf.pos;
+  }
+}
+function readTag(pbf, feature) {
+  const end = pbf.readVarint() + pbf.pos;
+  while (pbf.pos < end) {
+    const key = feature._keys[pbf.readVarint()];
+    const value = feature._values[pbf.readVarint()];
+    feature.properties[key] = value;
+  }
+}
 
-// dist/lib/binary-vector-tile/vector-tile-layer.js
-var BinaryVectorTileLayer = class {
+// dist/lib/vector-tile/vector-tile-layer.js
+var VectorTileLayer = class {
   version;
   name;
   extent;
@@ -564,26 +501,39 @@ var BinaryVectorTileLayer = class {
     this._keys = [];
     this._values = [];
     this._features = [];
-    pbf.readFields(readLayer2, this, end);
+    pbf.readFields(readLayer, this, end);
     this.length = this._features.length;
   }
   /**
-   * return feature `i` from this layer as a `BinaryVectorTileFeature`
+   * return feature `i` from this layer as a `VectorTileFeature`
+   * @param index
+   * @returns feature
+   */
+  getGeoJSONFeature(i) {
+    if (i < 0 || i >= this._features.length) {
+      throw new Error("feature index out of bounds");
+    }
+    this._pbf.pos = this._features[i];
+    const end = this._pbf.readVarint() + this._pbf.pos;
+    return new VectorTileFeature(this._pbf, end, this.extent, this._keys, this._values);
+  }
+  /**
+   * return binary feature `i` from this layer as a `VectorTileFeature`
    *
    * @param index
    * @param geometryInfo
-   * @returns {BinaryVectorTileFeature}
+   * @returns binary feature
    */
-  feature(i2, geometryInfo) {
-    if (i2 < 0 || i2 >= this._features.length) {
+  getBinaryFeature(i, geometryInfo) {
+    if (i < 0 || i >= this._features.length) {
       throw new Error("feature index out of bounds");
     }
-    this._pbf.pos = this._features[i2];
+    this._pbf.pos = this._features[i];
     const end = this._pbf.readVarint() + this._pbf.pos;
-    return new BinaryVectorTileFeature(this._pbf, end, this.extent, this._keys, this._values, geometryInfo);
+    return new VectorTileFeature(this._pbf, end, this.extent, this._keys, this._values, geometryInfo);
   }
 };
-function readLayer2(tag, layer, pbf) {
+function readLayer(tag, layer, pbf) {
   if (layer && pbf) {
     if (tag === 15)
       layer.version = pbf.readVarint();
@@ -596,10 +546,10 @@ function readLayer2(tag, layer, pbf) {
     else if (tag === 3)
       layer._keys.push(pbf.readString());
     else if (tag === 4)
-      layer._values.push(readValueMessage2(pbf));
+      layer._values.push(readValueMessage(pbf));
   }
 }
-function readValueMessage2(pbf) {
+function readValueMessage(pbf) {
   let value = null;
   const end = pbf.readVarint() + pbf.pos;
   while (pbf.pos < end) {
@@ -609,17 +559,17 @@ function readValueMessage2(pbf) {
   return value;
 }
 
-// dist/lib/binary-vector-tile/vector-tile.js
-var BinaryVectorTile = class {
+// dist/lib/vector-tile/vector-tile.js
+var VectorTile = class {
   layers;
   constructor(pbf, end) {
-    this.layers = pbf.readFields(readTile2, {}, end);
+    this.layers = pbf.readFields(readTile, {}, end);
   }
 };
-function readTile2(tag, layers, pbf) {
+function readTile(tag, layers, pbf) {
   if (tag === 3) {
     if (pbf) {
-      const layer = new BinaryVectorTileLayer(pbf, pbf.readVarint() + pbf.pos);
+      const layer = new VectorTileLayer(pbf, pbf.readVarint() + pbf.pos);
       if (layer.length && layers) {
         layers[layer.name] = layer;
       }
@@ -630,7 +580,7 @@ function readTile2(tag, layers, pbf) {
 // dist/lib/parse-mvt.js
 function parseMVT(arrayBuffer, options) {
   var _a, _b;
-  const mvtOptions = normalizeOptions(options);
+  const mvtOptions = checkOptions(options);
   const shape = ((_a = options == null ? void 0 : options.gis) == null ? void 0 : _a.format) || ((_b = options == null ? void 0 : options.mvt) == null ? void 0 : _b.shape) || (options == null ? void 0 : options.shape);
   switch (shape) {
     case "columnar-table":
@@ -676,15 +626,15 @@ function parseToFlatGeoJson(arrayBuffer, options) {
   if (arrayBuffer.byteLength <= 0) {
     return [features, geometryInfo];
   }
-  const tile = new BinaryVectorTile(new import_pbf.default(arrayBuffer));
+  const tile = new VectorTile(new import_pbf.default(arrayBuffer));
   const selectedLayers = options && Array.isArray(options.layers) ? options.layers : Object.keys(tile.layers);
   selectedLayers.forEach((layerName) => {
     const vectorTileLayer = tile.layers[layerName];
     if (!vectorTileLayer) {
       return;
     }
-    for (let i2 = 0; i2 < vectorTileLayer.length; i2++) {
-      const vectorTileFeature = vectorTileLayer.feature(i2, geometryInfo);
+    for (let i = 0; i < vectorTileLayer.length; i++) {
+      const vectorTileFeature = vectorTileLayer.getBinaryFeature(i, geometryInfo);
       const decodedFeature = getDecodedFeatureBinary(vectorTileFeature, options, layerName);
       features.push(decodedFeature);
     }
@@ -703,64 +653,45 @@ function parseToGeojsonFeatures(arrayBuffer, options) {
     if (!vectorTileLayer) {
       return;
     }
-    for (let i2 = 0; i2 < vectorTileLayer.length; i2++) {
-      const vectorTileFeature = vectorTileLayer.feature(i2);
+    for (let i = 0; i < vectorTileLayer.length; i++) {
+      const vectorTileFeature = vectorTileLayer.getGeoJSONFeature(i);
       const decodedFeature = getDecodedFeature(vectorTileFeature, options, layerName);
       features.push(decodedFeature);
     }
   });
   return features;
 }
-function normalizeOptions(options) {
+function checkOptions(options) {
   var _a;
   if (!(options == null ? void 0 : options.mvt)) {
     throw new Error("mvt options required");
   }
-  const wgs84Coordinates = ((_a = options.mvt) == null ? void 0 : _a.coordinates) === "wgs84";
-  const { tileIndex } = options.mvt;
-  const hasTileIndex = tileIndex && Number.isFinite(tileIndex.x) && Number.isFinite(tileIndex.y) && Number.isFinite(tileIndex.z);
-  if (wgs84Coordinates && !hasTileIndex) {
+  if (((_a = options.mvt) == null ? void 0 : _a.coordinates) === "wgs84" && !options.mvt.tileIndex) {
     throw new Error("MVT Loader: WGS84 coordinates need tileIndex property");
   }
+  if (options.gis) {
+    import_loader_utils.log.warn('MVTLoader: "options.gis" is deprecated, use "options.mvt.shape" instead')();
+  }
   return options.mvt;
 }
 function getDecodedFeature(feature, options, layerName) {
-  const decodedFeature = feature.toGeoJSON(
-    // @ts-expect-error What is going on here?
-    options.coordinates === "wgs84" ? options.tileIndex : transformToLocalCoordinates
-  );
+  const decodedFeature = feature.toGeoJSONFeature(options.coordinates || "local", options.tileIndex);
   if (options.layerProperty) {
+    decodedFeature.properties ||= {};
     decodedFeature.properties[options.layerProperty] = layerName;
   }
   return decodedFeature;
 }
 function getDecodedFeatureBinary(feature, options, layerName) {
-  const decodedFeature = feature.toBinaryCoordinates(
-    // @ts-expect-error
-    options.coordinates === "wgs84" ? options.tileIndex : transformToLocalCoordinatesBinary
-  );
+  const decodedFeature = feature.toBinaryFeature(options.coordinates || "local", options.tileIndex);
   if (options.layerProperty && decodedFeature.properties) {
     decodedFeature.properties[options.layerProperty] = layerName;
   }
   return decodedFeature;
 }
-function transformToLocalCoordinates(line, feature) {
-  const { extent } = feature;
-  for (let i2 = 0; i2 < line.length; i2++) {
-    const p = line[i2];
-    p[0] /= extent;
-    p[1] /= extent;
-  }
-}
-function transformToLocalCoordinatesBinary(data, feature) {
-  const { extent } = feature;
-  for (let i2 = 0, il = data.length; i2 < il; ++i2) {
-    data[i2] /= extent;
-  }
-}
 
 // dist/mvt-loader.js
-var VERSION = true ? "4.2.0" : "latest";
+var VERSION = true ? "4.3.0-alpha.1" : "latest";
 var MVTWorkerLoader = {
   dataType: null,
   batchType: null,
@@ -784,7 +715,7 @@ var MVTWorkerLoader = {
       coordinates: "local",
       layerProperty: "layerName",
       layers: void 0,
-      tileIndex: null
+      tileIndex: void 0
     }
   }
 };
@@ -796,7 +727,7 @@ var MVTLoader = {
 };
 
 // dist/lib/parse-tilejson.js
-var isObject = (x2) => x2 !== null && typeof x2 === "object";
+var isObject = (x) => x !== null && typeof x === "object";
 function parseTileJSON(jsonMetadata, options) {
   var _a;
   if (!jsonMetadata || !isObject(jsonMetadata)) {
@@ -1002,7 +933,7 @@ function attributeTypeToFieldType(aType) {
 }
 
 // dist/tilejson-loader.js
-var VERSION2 = true ? "4.2.0" : "latest";
+var VERSION2 = true ? "4.3.0-alpha.1" : "latest";
 var TileJSONLoader = {
   dataType: null,
   batchType: null,
@@ -1033,10 +964,10 @@ var TileJSONLoader = {
 };
 
 // dist/mvt-source.js
-var import_loader_utils = require("@loaders.gl/loader-utils");
+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_utils.DataSource {
+var MVTSource = class extends import_loader_utils2.DataSource {
   props;
   url;
   metadataUrl = null;
@@ -1048,7 +979,7 @@ var MVTSource = class extends import_loader_utils.DataSource {
   constructor(props) {
     super(props);
     this.props = props;
-    this.url = (0, import_loader_utils.resolvePath)(props.url);
+    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.data = this.url;
@@ -1082,9 +1013,9 @@ var MVTSource = class extends import_loader_utils.DataSource {
   getTileMIMEType() {
     return this.mimeType;
   }
-  async getTile(tileParams) {
-    const { x: x2, y: y2, zoom: z } = tileParams;
-    const tileUrl = this.getTileURL(x2, y2, z);
+  async getTile(parameters) {
+    const { x, y, z } = parameters;
+    const tileUrl = this.getTileURL(x, y, z);
     const response = await this.fetch(tileUrl);
     if (!response.ok) {
       return null;
@@ -1094,9 +1025,9 @@ var MVTSource = class extends import_loader_utils.DataSource {
   }
   // Tile Source interface implementation: deck.gl compatible API
   // TODO - currently only handles image tiles, not vector tiles
-  async getTileData(tileParams) {
-    const { x: x2, y: y2, z } = tileParams.index;
-    const arrayBuffer = await this.getTile({ x: x2, y: y2, zoom: z, layers: [] });
+  async getTileData(parameters) {
+    const { x, y, z } = parameters.index;
+    const arrayBuffer = await this.getTile({ x, y, z, layers: [] });
     if (arrayBuffer === null) {
       return null;
     }
@@ -1104,7 +1035,7 @@ var MVTSource = class extends import_loader_utils.DataSource {
     this.mimeType = this.mimeType || (imageMetadata == null ? void 0 : imageMetadata.mimeType) || "application/vnd.mapbox-vector-tile";
     switch (this.mimeType) {
       case "application/vnd.mapbox-vector-tile":
-        return await this._parseVectorTile(arrayBuffer, { x: x2, y: y2, zoom: z, layers: [] });
+        return await this._parseVectorTile(arrayBuffer, { x, y, z, layers: [] });
       default:
         return await this._parseImageTile(arrayBuffer);
     }
@@ -1128,7 +1059,7 @@ var MVTSource = class extends import_loader_utils.DataSource {
       shape: "geojson-table",
       mvt: {
         coordinates: "wgs84",
-        tileIndex: { x: tileParams.x, y: tileParams.y, z: tileParams.zoom },
+        tileIndex: { x: tileParams.x, y: tileParams.y, z: tileParams.z },
         ...(_a = this.loadOptions) == null ? void 0 : _a.mvt
       },
       ...this.loadOptions
@@ -1138,14 +1069,14 @@ var MVTSource = class extends import_loader_utils.DataSource {
   getMetadataUrl() {
     return this.metadataUrl;
   }
-  getTileURL(x2, y2, z) {
+  getTileURL(x, y, z) {
     switch (this.schema) {
       case "xyz":
-        return `${this.url}/${x2}/${y2}/${z}${this.extension}`;
+        return `${this.url}/${x}/${y}/${z}${this.extension}`;
       case "tms":
-        return `${this.url}/${z}/${x2}/${y2}${this.extension}`;
+        return `${this.url}/${z}/${x}/${y}${this.extension}`;
       case "template":
-        return getURLFromTemplate(this.url, x2, y2, z, "0");
+        return getURLFromTemplate(this.url, x, y, z, "0");
       default:
         throw new Error(this.schema);
     }
@@ -1157,17 +1088,17 @@ function isURLTemplate(s) {
 var xRegex = new RegExp("{x}", "g");
 var yRegex = new RegExp("{y}", "g");
 var zRegex = new RegExp("{z}", "g");
-function getURLFromTemplate(template, x2, y2, z, id = "0") {
+function getURLFromTemplate(template, x, y, z, id = "0") {
   if (Array.isArray(template)) {
-    const i2 = stringHash(id) % template.length;
-    template = template[i2];
+    const i = stringHash(id) % template.length;
+    template = template[i];
   }
   let url = template;
-  url = url.replace(xRegex, String(x2));
-  url = url.replace(yRegex, String(y2));
+  url = url.replace(xRegex, String(x));
+  url = url.replace(yRegex, String(y));
   url = url.replace(zRegex, String(z));
-  if (Number.isInteger(y2) && Number.isInteger(z)) {
-    url = url.replace(/\{-y\}/g, String(Math.pow(2, z) - y2 - 1));
+  if (Number.isInteger(y) && Number.isInteger(z)) {
+    url = url.replace(/\{-y\}/g, String(Math.pow(2, z) - y - 1));
   }
   return url;
 }
@@ -1175,7 +1106,12 @@ function stringHash(s) {
   return Math.abs(s.split("").reduce((a, b) => (a << 5) - a + b.charCodeAt(0) | 0, 0));
 }
 
-// dist/lib/geojson-tiler/simplify.js
+// 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/simplify.js
 function simplify(coords, first, last, sqTolerance) {
   let maxSqDist = sqTolerance;
   const mid = last - first >> 1;
@@ -1185,15 +1121,15 @@ function simplify(coords, first, last, sqTolerance) {
   const ay = coords[first + 1];
   const bx = coords[last];
   const by = coords[last + 1];
-  for (let i2 = first + 3; i2 < last; i2 += 3) {
-    const d = getSqSegDist(coords[i2], coords[i2 + 1], ax, ay, bx, by);
+  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 = i2;
+      index = i;
       maxSqDist = d;
     } else if (d === maxSqDist) {
-      const posToMid = Math.abs(i2 - mid);
+      const posToMid = Math.abs(i - mid);
       if (posToMid < minPosToMid) {
-        index = i2;
+        index = i;
         minPosToMid = posToMid;
       }
     }
@@ -1206,25 +1142,25 @@ function simplify(coords, first, last, sqTolerance) {
       simplify(coords, index, last, sqTolerance);
   }
 }
-function getSqSegDist(px, py, x2, y2, bx, by) {
-  let dx = bx - x2;
-  let dy = by - y2;
+function getSqSegDist(px, py, x, y, bx, by) {
+  let dx = bx - x;
+  let dy = by - y;
   if (dx !== 0 || dy !== 0) {
-    const t = ((px - x2) * dx + (py - y2) * dy) / (dx * dx + dy * dy);
+    const t = ((px - x) * dx + (py - y) * dy) / (dx * dx + dy * dy);
     if (t > 1) {
-      x2 = bx;
-      y2 = by;
+      x = bx;
+      y = by;
     } else if (t > 0) {
-      x2 += dx * t;
-      y2 += dy * t;
+      x += dx * t;
+      y += dy * t;
     }
   }
-  dx = px - x2;
-  dy = py - y2;
+  dx = px - x;
+  dy = py - y;
   return dx * dx + dy * dy;
 }
 
-// dist/lib/geojson-tiler/feature.js
+// dist/lib/vector-tiler/feature.js
 function createFeature(id, type, geom, tags) {
   const feature = {
     // eslint-disable-next-line
@@ -1253,20 +1189,20 @@ function createFeature(id, type, geom, tags) {
   return feature;
 }
 function calcLineBBox(feature, geom) {
-  for (let i2 = 0; i2 < geom.length; i2 += 3) {
-    feature.minX = Math.min(feature.minX, geom[i2]);
-    feature.minY = Math.min(feature.minY, geom[i2 + 1]);
-    feature.maxX = Math.max(feature.maxX, geom[i2]);
-    feature.maxY = Math.max(feature.maxY, geom[i2 + 1]);
+  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/geojson-tiler/convert.js
+// dist/lib/vector-tiler/convert.js
 function convert(data, options) {
   const features = [];
   if (data.type === "FeatureCollection") {
-    for (let i2 = 0; i2 < data.features.length; i2++) {
-      convertFeature(features, data.features[i2], options, i2);
+    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);
@@ -1337,18 +1273,18 @@ function convertLine(ring, out, tolerance, isPolygon) {
   let x0, y0;
   let size = 0;
   for (let j = 0; j < ring.length; j++) {
-    const x2 = projectX(ring[j][0]);
-    const y2 = projectY(ring[j][1]);
-    out.push(x2, y2, 0);
+    const x = projectX(ring[j][0]);
+    const y = projectY(ring[j][1]);
+    out.push(x, y, 0);
     if (j > 0) {
       if (isPolygon) {
-        size += (x0 * y2 - x2 * y0) / 2;
+        size += (x0 * y - x * y0) / 2;
       } else {
-        size += Math.sqrt(Math.pow(x2 - x0, 2) + Math.pow(y2 - y0, 2));
+        size += Math.sqrt(Math.pow(x - x0, 2) + Math.pow(y - y0, 2));
       }
     }
-    x0 = x2;
-    y0 = y2;
+    x0 = x;
+    y0 = y;
   }
   const last = out.length - 3;
   out[2] = 1;
@@ -1359,22 +1295,22 @@ function convertLine(ring, out, tolerance, isPolygon) {
   out.end = out.size;
 }
 function convertLines(rings, out, tolerance, isPolygon) {
-  for (let i2 = 0; i2 < rings.length; i2++) {
+  for (let i = 0; i < rings.length; i++) {
     const geom = [];
-    convertLine(rings[i2], geom, tolerance, isPolygon);
+    convertLine(rings[i], geom, tolerance, isPolygon);
     out.push(geom);
   }
 }
-function projectX(x2) {
-  return x2 / 360 + 0.5;
+function projectX(x) {
+  return x / 360 + 0.5;
 }
-function projectY(y2) {
-  const sin = Math.sin(y2 * Math.PI / 180);
-  const y22 = 0.5 - 0.25 * Math.log((1 + sin) / (1 - sin)) / Math.PI;
-  return y22 < 0 ? 0 : y22 > 1 ? 1 : y22;
+function projectY(y) {
+  const sin = Math.sin(y * Math.PI / 180);
+  const y2 = 0.5 - 0.25 * Math.log((1 + sin) / (1 - sin)) / Math.PI;
+  return y2 < 0 ? 0 : y2 > 1 ? 1 : y2;
 }
 
-// dist/lib/geojson-tiler/clip.js
+// dist/lib/vector-tiler/clip.js
 function clip(features, scale, k1, k2, axis, minAll, maxAll, options) {
   k1 /= scale;
   k2 /= scale;
@@ -1437,10 +1373,10 @@ function clip(features, scale, k1, k2, axis, minAll, maxAll, options) {
   return clipped.length ? clipped : null;
 }
 function clipPoints(geom, newGeom, k1, k2, axis) {
-  for (let i2 = 0; i2 < geom.length; i2 += 3) {
-    const a = geom[i2 + axis];
+  for (let i = 0; i < geom.length; i += 3) {
+    const a = geom[i + axis];
     if (a >= k1 && a <= k2) {
-      addPoint(newGeom, geom[i2], geom[i2 + 1], geom[i2 + 2]);
+      addPoint(newGeom, geom[i], geom[i + 1], geom[i + 2]);
     }
   }
 }
@@ -1450,12 +1386,12 @@ function clipLine(geom, newGeom, k1, k2, axis, isPolygon, trackMetrics) {
   let len = geom.start;
   let segLen;
   let t;
-  for (let i2 = 0; i2 < geom.length - 3; i2 += 3) {
-    const ax2 = geom[i2];
-    const ay2 = geom[i2 + 1];
-    const az2 = geom[i2 + 2];
-    const bx = geom[i2 + 3];
-    const by = geom[i2 + 4];
+  for (let i = 0; i < geom.length - 3; i += 3) {
+    const ax2 = geom[i];
+    const ay2 = geom[i + 1];
+    const az2 = geom[i + 2];
+    const bx = geom[i + 3];
+    const by = geom[i + 4];
     const a2 = axis === 0 ? ax2 : ay2;
     const b = axis === 0 ? bx : by;
     let exited = false;
@@ -1525,21 +1461,21 @@ function clipLines(geom, newGeom, k1, k2, axis, isPolygon) {
     clipLine(line, newGeom, k1, k2, axis, isPolygon, false);
   }
 }
-function addPoint(out, x2, y2, z) {
-  out.push(x2, y2, z);
+function addPoint(out, x, y, z) {
+  out.push(x, y, z);
 }
-function intersectX(out, ax, ay, bx, by, x2) {
-  const t = (x2 - ax) / (bx - ax);
-  addPoint(out, x2, ay + (by - ay) * t, 1);
+function intersectX(out, ax, ay, bx, by, x) {
+  const t = (x - ax) / (bx - ax);
+  addPoint(out, x, ay + (by - ay) * t, 1);
   return t;
 }
-function intersectY(out, ax, ay, bx, by, y2) {
-  const t = (y2 - ay) / (by - ay);
-  addPoint(out, ax + (bx - ax) * t, y2, 1);
+function intersectY(out, ax, ay, bx, by, y) {
+  const t = (y - ay) / (by - ay);
+  addPoint(out, ax + (bx - ax) * t, y, 1);
   return t;
 }
 
-// dist/lib/geojson-tiler/wrap.js
+// dist/lib/vector-tiler/wrap.js
 function wrap(features, options) {
   const buffer = options.buffer / options.extent;
   let merged = features;
@@ -1558,8 +1494,8 @@ function wrap(features, options) {
 }
 function shiftFeatureCoords(features, offset) {
   const newFeatures = [];
-  for (let i2 = 0; i2 < features.length; i2++) {
-    const feature = features[i2];
+  for (let i = 0; i < features.length; i++) {
+    const feature = features[i];
     const type = feature.type;
     let newGeometry;
     if (type === "Point" || type === "MultiPoint" || type === "LineString") {
@@ -1590,13 +1526,13 @@ function shiftCoords(points, offset) {
     newPoints.start = points.start;
     newPoints.end = points.end;
   }
-  for (let i2 = 0; i2 < points.length; i2 += 3) {
-    newPoints.push(points[i2] + offset, points[i2 + 1], points[i2 + 2]);
+  for (let i = 0; i < points.length; i += 3) {
+    newPoints.push(points[i] + offset, points[i + 1], points[i + 2]);
   }
   return newPoints;
 }
 
-// dist/lib/geojson-tiler/transform.js
+// dist/lib/vector-tiler/transform.js
 function transformTile(tile, extent) {
   if (tile.transformed) {
     return tile;
@@ -1625,11 +1561,11 @@ function transformTile(tile, extent) {
   tile.transformed = true;
   return tile;
 }
-function transformPoint(x2, y2, extent, z2, tx, ty) {
-  return [Math.round(extent * (x2 * z2 - tx)), Math.round(extent * (y2 * z2 - ty))];
+function transformPoint(x, y, extent, z2, tx, ty) {
+  return [Math.round(extent * (x * z2 - tx)), Math.round(extent * (y * z2 - ty))];
 }
 
-// dist/lib/geojson-tiler/tile.js
+// 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 = {
@@ -1661,22 +1597,22 @@ function addFeature(tile, feature, tolerance, options) {
   tile.maxX = Math.max(tile.maxX, feature.maxX);
   tile.maxY = Math.max(tile.maxY, feature.maxY);
   if (type === "Point" || type === "MultiPoint") {
-    for (let i2 = 0; i2 < geom.length; i2 += 3) {
-      simplified.push(geom[i2], geom[i2 + 1]);
+    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 i2 = 0; i2 < geom.length; i2++) {
-      addLine(simplified, geom[i2], tile, tolerance, type === "Polygon", i2 === 0);
+    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 i2 = 0; i2 < polygon.length; i2++) {
-        addLine(simplified, polygon[i2], tile, tolerance, true, i2 === 0);
+      for (let i = 0; i < polygon.length; i++) {
+        addLine(simplified, polygon[i], tile, tolerance, true, i === 0);
       }
     }
   }
@@ -1707,10 +1643,10 @@ function addLine(result, geom, tile, tolerance, isPolygon, isOuter) {
     return;
   }
   const ring = [];
-  for (let i2 = 0; i2 < geom.length; i2 += 3) {
-    if (tolerance === 0 || geom[i2 + 2] > sqTolerance) {
+  for (let i = 0; i < geom.length; i += 3) {
+    if (tolerance === 0 || geom[i + 2] > sqTolerance) {
       tile.numSimplified++;
-      ring.push(geom[i2], geom[i2 + 1]);
+      ring.push(geom[i], geom[i + 1]);
     }
     tile.numPoints++;
   }
@@ -1720,106 +1656,147 @@ function addLine(result, geom, tile, tolerance, isPolygon, isOuter) {
 }
 function rewind(ring, clockwise) {
   let area = 0;
-  for (let i2 = 0, j = ring.length - 2; i2 < ring.length; j = i2, i2 += 2) {
-    area += (ring[i2] - ring[j]) * (ring[i2 + 1] + ring[j + 1]);
+  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 i2 = 0, len = ring.length; i2 < len / 2; i2 += 2) {
-      const x2 = ring[i2];
-      const y2 = ring[i2 + 1];
-      ring[i2] = ring[len - 2 - i2];
-      ring[i2 + 1] = ring[len - 1 - i2];
-      ring[len - 2 - i2] = x2;
-      ring[len - 1 - i2] = y2;
+    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/geojson-tiler/geojson-tiler.js
-var DEFAULT_OPTIONS = {
-  maxZoom: 14,
-  // max zoom to preserve detail on
-  indexMaxZoom: 5,
-  // max zoom in the tile index
-  indexMaxPoints: 1e5,
-  // max number of points per tile in the tile index
-  tolerance: 3,
-  // simplification tolerance (higher means simpler)
-  extent: 4096,
-  // tile extent
-  buffer: 64,
-  // tile buffer on each side
-  lineMetrics: false,
-  // whether to calculate line metrics
-  // @ts-expect-error Ensures all these required params have defaults
-  promoteId: void 0,
-  // name of a feature property to be promoted to feature.id
-  generateId: false,
-  // whether to generate feature ids. Cannot be used with promoteId
-  debug: 0
-  // logging level (0, 1 or 2)
-};
-var GeoJSONTiler = class {
-  options;
-  // tiles and tileCoords are part of the public API
+// dist/table-tile-source.js
+var _TableTileSource = class {
+  /** Stats for this TableTileSource */
+  stats = new import_stats.Stats({
+    id: "table-tile-source",
+    stats: [new import_stats.Stat("tiles", "count"), new import_stats.Stat("features", "count")]
+  });
+  /** MIME type of the tiles emitted by this tile source */
+  mimeType = "application/vnd.mapbox-vector-tile";
+  localCoordinates = true;
+  /** The props that this tile source was created with */
+  props;
+  /* Schema of the data */
+  schema = null;
+  /** Map of generated tiles, indexed by stringified tile coordinates */
   tiles = {};
+  /** Array of tile coordinates */
   tileCoords = [];
-  stats = {};
-  total = 0;
-  constructor(data, options) {
-    this.options = { ...DEFAULT_OPTIONS, ...options };
-    options = this.options;
-    const debug = options.debug;
-    if (debug)
-      console.time("preprocess data");
-    if (this.options.maxZoom < 0 || this.options.maxZoom > 24) {
+  /** Input data has loaded, initial top-level tiling is done, sync methods can now be called */
+  ready;
+  /** Metadata for the tile source (generated TileJSON/tilestats */
+  metadata;
+  constructor(table, props) {
+    this.props = { ..._TableTileSource.defaultProps, ...props };
+    this.getTileData = this.getTileData.bind(this);
+    this.ready = this.initializeTilesAsync(table);
+    this.metadata = this.getMetadata();
+  }
+  async initializeTilesAsync(tablePromise) {
+    const table = await tablePromise;
+    this.schema = (0, import_schema.deduceTableSchema)(table);
+    this.createRootTiles(table);
+  }
+  async getMetadata() {
+    await this.ready;
+    return { schema: this.schema, minZoom: 0, maxZoom: this.props.maxZoom };
+  }
+  async getSchema() {
+    await this.ready;
+    return this.schema;
+  }
+  /**
+   * Get a tile at the specified index
+   * @param tileIndex z, x, y of tile
+   * @returns
+   */
+  async getVectorTile(tileIndex) {
+    await this.ready;
+    const table = this.getTileSync(tileIndex);
+    import_loader_utils3.log.info(2, "getVectorTile", tileIndex, table)();
+    return table;
+  }
+  async getTile(tileIndex) {
+    await this.ready;
+    return this.getTileSync(tileIndex);
+  }
+  async getTileData(tileParams) {
+    const { x, y, z } = tileParams.index;
+    const tile = await this.getVectorTile({ x, y, z });
+    return (tile == null ? void 0 : tile.features) || [];
+  }
+  // Implementation
+  /**
+   * Synchronously request a tile
+   * @note Application must await `source.ready` before calling sync methods.
+   */
+  getTileSync(tileIndex) {
+    const rawTile = this.getRawTile(tileIndex);
+    if (!rawTile) {
+      return null;
+    }
+    return convertToGeoJSONTable(rawTile, {
+      coordinates: this.props.coordinates,
+      tileIndex,
+      extent: this.props.extent
+    });
+  }
+  /**
+   * Create the initial tiles
+   * @note the tiles stores all the features together with additional data
+   */
+  createRootTiles(table) {
+    if (this.props.maxZoom < 0 || this.props.maxZoom > 24) {
       throw new Error("maxZoom should be in the 0-24 range");
     }
-    if (options.promoteId && this.options.generateId) {
+    if (this.props.promoteId && this.props.generateId) {
       throw new Error("promoteId and generateId cannot be used together.");
     }
-    let features = convert(data, options);
-    if (debug) {
-      console.timeEnd("preprocess data");
-      console.log("index: maxZoom: %d, maxPoints: %d", options.indexMaxZoom, options.indexMaxPoints);
-      console.time("generate tiles");
-    }
-    features = wrap(features, this.options);
-    if (features.length) {
-      this.splitTile(features, 0, 0, 0);
-    }
-    if (debug) {
-      if (features.length) {
-        console.log("features: %d, points: %d", this.tiles[0].numFeatures, this.tiles[0].numPoints);
-      }
-      console.timeEnd("generate tiles");
-      console.log("tiles generated:", this.total, JSON.stringify(this.stats));
+    import_loader_utils3.log.log(1, "TableTileSource creating root tiles", this.props)();
+    import_loader_utils3.log.time(1, "preprocess table")();
+    let features = convert(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")();
+      return;
     }
+    this.splitTile(features, 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)();
   }
   /**
-   * Get a tile at the specified index
-   * @param z
-   * @param x
-   * @param y
-   * @returns
+   * Return geojsonvt-style "half formed" vector tile
+   * @note Application must await `source.ready` before calling sync methods.
    */
   // eslint-disable-next-line complexity, max-statements
-  getTile(z, x2, y2) {
-    const { extent, debug } = this.options;
+  getRawTile(tileIndex) {
+    const { z, y } = tileIndex;
+    let { x } = tileIndex;
+    const { extent } = this.props;
     if (z < 0 || z > 24) {
       return null;
     }
     const z2 = 1 << z;
-    x2 = x2 + z2 & z2 - 1;
-    const id = toID(z, x2, y2);
+    x = x + z2 & z2 - 1;
+    const id = toID(z, x, y);
     if (this.tiles[id]) {
       return transformTile(this.tiles[id], extent);
     }
-    if (debug > 1)
-      console.log("drilling down to z%d-%d-%d", z, x2, y2);
+    import_loader_utils3.log.log(import_loader_utils3.log, "drilling down to z%d-%d-%d", z, x, y)();
     let z0 = z;
-    let x0 = x2;
-    let y0 = y2;
+    let x0 = x;
+    let y0 = y;
     let parent;
     while (!parent && z0 > 0) {
       z0--;
@@ -1830,14 +1807,10 @@ var GeoJSONTiler = class {
     if (!parent || !parent.source) {
       return null;
     }
-    if (debug > 1) {
-      console.log("found parent tile z%d-%d-%d", z0, x0, y0);
-      console.time("drilling down");
-    }
-    this.splitTile(parent.source, z0, x0, y0, z, x2, y2);
-    if (debug > 1) {
-      console.timeEnd("drilling down");
-    }
+    import_loader_utils3.log.log(1, "found parent tile z%d-%d-%d", z0, x0, y0)();
+    import_loader_utils3.log.time(1, "drilling down")();
+    this.splitTile(parent.source, z0, x0, y0, z, x, y);
+    import_loader_utils3.log.timeEnd(1, "drilling down")();
     return this.tiles[id] ? transformTile(this.tiles[id], extent) : null;
   }
   /**
@@ -1846,54 +1819,53 @@ var GeoJSONTiler = class {
    * @param cz, cx, and cy are the coordinates of the target tile
    *
    * If no target tile is specified, splitting stops when we reach the maximum
-   * zoom or the number of points is low as specified in the options.
+   * zoom or the number of points is low as specified in the props.
    */
   // eslint-disable-next-line max-params, max-statements, complexity
-  splitTile(features, z, x2, y2, cz, cx, cy) {
-    const stack = [features, z, x2, y2];
-    const options = this.options;
-    const debug = options.debug;
+  splitTile(features, z, x, y, cz, cx, cy) {
+    const stack = [features, z, x, y];
     while (stack.length) {
-      y2 = stack.pop();
-      x2 = stack.pop();
+      y = stack.pop();
+      x = stack.pop();
       z = stack.pop();
       features = stack.pop();
       const z2 = 1 << z;
-      const id = toID(z, x2, y2);
+      const id = toID(z, x, y);
       let tile = this.tiles[id];
       if (!tile) {
-        if (debug > 1) {
-          console.time("creation");
-        }
-        tile = this.tiles[id] = createTile(features, z, x2, y2, options);
-        this.tileCoords.push({ z, x: x2, y: y2 });
-        if (debug) {
-          if (debug > 1) {
-            console.log("tile z%d-%d-%d (features: %d, points: %d, simplified: %d)", z, x2, y2, tile.numFeatures, tile.numPoints, tile.numSimplified);
-            console.timeEnd("creation");
-          }
-          const key = `z${z}`;
-          this.stats[key] = (this.stats[key] || 0) + 1;
-          this.total++;
-        }
+        import_loader_utils3.log.time(2, "tile creation")();
+        tile = this.tiles[id] = createTile(features, 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.incrementCount();
+        stat = _TableTileSource.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;
       if (cz === void 0) {
-        if (z === options.indexMaxZoom || tile.numPoints <= options.indexMaxPoints)
+        if (z === this.props.indexMaxZoom || tile.numPoints <= this.props.maxPointsPerTile) {
           continue;
-      } else if (z === options.maxZoom || z === cz) {
+        }
+      } else if (z === this.props.maxZoom || z === cz) {
         continue;
       } else if (cz !== void 0) {
         const zoomSteps = cz - z;
-        if (x2 !== cx >> zoomSteps || y2 !== cy >> zoomSteps)
+        if (x !== cx >> zoomSteps || y !== cy >> zoomSteps) {
           continue;
+        }
       }
       tile.source = null;
       if (features.length === 0)
         continue;
-      if (debug > 1)
-        console.time("clipping");
-      const k1 = 0.5 * options.buffer / options.extent;
+      import_loader_utils3.log.time(2, "clipping tile")();
+      const k1 = 0.5 * this.props.buffer / this.props.extent;
       const k2 = 0.5 - k1;
       const k3 = 0.5 + k1;
       const k4 = 1 + k1;
@@ -1901,29 +1873,130 @@ var GeoJSONTiler = class {
       let bl = null;
       let tr = null;
       let br = null;
-      let left = clip(features, z2, x2 - k1, x2 + k3, 0, tile.minX, tile.maxX, options);
-      let right = clip(features, z2, x2 + k2, x2 + k4, 0, tile.minX, tile.maxX, options);
+      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;
       if (left) {
-        tl = clip(left, z2, y2 - k1, y2 + k3, 1, tile.minY, tile.maxY, options);
-        bl = clip(left, z2, y2 + k2, y2 + k4, 1, tile.minY, tile.maxY, options);
+        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);
         left = null;
       }
       if (right) {
-        tr = clip(right, z2, y2 - k1, y2 + k3, 1, tile.minY, tile.maxY, options);
-        br = clip(right, z2, y2 + k2, y2 + k4, 1, tile.minY, tile.maxY, options);
+        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);
         right = null;
       }
-      if (debug > 1)
-        console.timeEnd("clipping");
-      stack.push(tl || [], z + 1, x2 * 2, y2 * 2);
-      stack.push(bl || [], z + 1, x2 * 2, y2 * 2 + 1);
-      stack.push(tr || [], z + 1, x2 * 2 + 1, y2 * 2);
-      stack.push(br || [], z + 1, x2 * 2 + 1, y2 * 2 + 1);
+      import_loader_utils3.log.timeEnd(2, "clipping tile")();
+      stack.push(tl || [], z + 1, x * 2, y * 2);
+      stack.push(bl || [], z + 1, x * 2, y * 2 + 1);
+      stack.push(tr || [], z + 1, x * 2 + 1, y * 2);
+      stack.push(br || [], z + 1, x * 2 + 1, y * 2 + 1);
     }
   }
 };
-function toID(z, x2, y2) {
-  return ((1 << z) * y2 + x2) * 32 + z;
+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({
+  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