leaflet-city-mapper 0.0.9 → 0.1.1

package/src/models/readModelIndices.js

@@ -1,16 +1,28 @@
-import { readAccessor } from './readAccessor.js';
-
-export function readModelIndices(description, primitive, attributes, vertexCount) {
-  if (primitive.indices !== undefined) {
-    const index = readAccessor(description, primitive.indices);
-    attributes.index = /* alloc */ { size: 1, data: index.indices };
-    if (!(index.indices instanceof Uint8Array || index.indices instanceof Uint16Array ||
-      index.indices instanceof Uint32Array) || index.size !== 1 || index.indices.length % 3) {
-      throw /* alloc */ new Error('Invalid glTF triangle indices');
-    }
-    let value;
-    for (value of index.indices) if (value >= vertexCount) throw /* alloc */ new Error('Invalid glTF triangle indices');
-  } else if (vertexCount % 3) {
-    throw /* alloc */ new Error('Incomplete glTF triangle');
-  }
-}
+import { readAccessor } from './readAccessor.js';
+
+/**
+ * Read and validate triangle indices, or validate an unindexed triangle list.
+ *
+ * @param {Object} description Decoded glTF document.
+ * @param {Object} primitive glTF mesh primitive.
+ * @param {Object} attributes Destination attribute map.
+ * @param {number} vertexCount Number of vertices.
+ *
+ * @throws {Error} If the index type, size or count is invalid.
+ * @throws {Error} If an index is outside the vertex range.
+ * @throws {Error} If the unindexed triangle list is incomplete.
+ */
+export function readModelIndices(description, primitive, attributes, vertexCount) {
+  if (primitive.indices !== undefined) {
+    const index = readAccessor(description, primitive.indices);
+    attributes.index = /* alloc */ { size: 1, data: index.indices };
+    if (!(index.indices instanceof Uint8Array || index.indices instanceof Uint16Array ||
+      index.indices instanceof Uint32Array) || index.size !== 1 || index.indices.length % 3) {
+      throw /* alloc */ new Error('Invalid glTF triangle indices');
+    }
+    let value;
+    for (value of index.indices) if (value >= vertexCount) throw /* alloc */ new Error('Invalid glTF triangle indices');
+  } else if (vertexCount % 3) {
+    throw /* alloc */ new Error('Incomplete glTF triangle');
+  }
+}

package/src/models/readSparseAccessor.js

@@ -1,19 +1,31 @@
-import { types } from '../globals/types.js';
-import { readAccessorValues } from './readAccessorValues.js';
-
-export function readSparseAccessor(description, spec, Type, size, data) {
-  const sparse = spec.sparse, Index = types[sparse.indices.componentType];
-  if (Index !== Uint8Array && Index !== Uint16Array && Index !== Uint32Array) {
-    throw /* alloc */ new Error('Invalid sparse glTF indices');
-  }
-  const view = description.bufferViews[sparse.indices.bufferView];
-  const offset = (view.byteOffset || 0) + (sparse.indices.byteOffset || 0);
-  if (sparse.count > spec.count ||
-    (sparse.indices.byteOffset || 0) + sparse.count * Index.BYTES_PER_ELEMENT > view.byteLength) {
-    throw /* alloc */ new Error('Invalid sparse glTF indices');
-  }
-  const indices = /* alloc */ new Index(description.buffers[view.buffer].binary.slice(
-    offset, offset + sparse.count * Index.BYTES_PER_ELEMENT));
-  readAccessorValues(description, Type, size, data, spec.count, indices, sparse.values.bufferView,
-    sparse.values.byteOffset || 0, sparse.count, 0);
-}
+import { types } from '../globals/types.js';
+import { readAccessorValues } from './readAccessorValues.js';
+
+/**
+ * Apply sparse glTF accessor values to an existing component array.
+ *
+ * @param {Object} description Decoded glTF document with loaded buffers.
+ * @param {Object} spec glTF accessor specification.
+ * @param {TypedArrayConstructor} Type Component array constructor.
+ * @param {number} size Components per element.
+ * @param {TypedArray} data Destination array to update.
+ *
+ * @throws {Error} If the sparse index type is invalid.
+ * @throws {Error} If the sparse index count or range is invalid.
+ */
+export function readSparseAccessor(description, spec, Type, size, data) {
+  const sparse = spec.sparse, Index = types[sparse.indices.componentType];
+  if (Index !== Uint8Array && Index !== Uint16Array && Index !== Uint32Array) {
+    throw /* alloc */ new Error('Invalid sparse glTF indices');
+  }
+  const view = description.bufferViews[sparse.indices.bufferView];
+  const offset = (view.byteOffset || 0) + (sparse.indices.byteOffset || 0);
+  if (sparse.count > spec.count ||
+    (sparse.indices.byteOffset || 0) + sparse.count * Index.BYTES_PER_ELEMENT > view.byteLength) {
+    throw /* alloc */ new Error('Invalid sparse glTF indices');
+  }
+  const indices = /* alloc */ new Index(description.buffers[view.buffer].binary.slice(
+    offset, offset + sparse.count * Index.BYTES_PER_ELEMENT));
+  readAccessorValues(description, Type, size, data, spec.count, indices, sparse.values.bufferView,
+    sparse.values.byteOffset || 0, sparse.count, 0);
+}

package/src/models/releaseModelResources.js

@@ -1,10 +1,15 @@
-export function releaseModelResources(context) {
-  let resource, attribute;
-  for (resource of context.resources) {
-    if (resource.attributes) {
-      for (attribute of Object.values(resource.attributes)) attribute.buffer.destroy();
-    } else {
-      resource.pipelineCache.clear();
-    }
-  }
-}
+/**
+ * Destroy geometry buffers and clear pipeline caches tracked by a model context.
+ *
+ * @param {Object} context Model context containing allocated resources.
+ */
+export function releaseModelResources(context) {
+  let resource, attribute;
+  for (resource of context.resources) {
+    if (resource.attributes) {
+      for (attribute of Object.values(resource.attributes)) attribute.buffer.destroy();
+    } else {
+      resource.pipelineCache.clear();
+    }
+  }
+}

package/src/mvt/README.md

@@ -0,0 +1,28 @@
+# Mapbox Vector Tiles
+
+[Source guide](../README.md) | [Project README](../../README.md)
+
+Decodes uncompressed MVT/PBF data into tile-local layers and provides polygon
+ring triangulation. Large integer values are preserved as decimal strings.
+
+## Tile-space decoding
+
+```mermaid
+flowchart LR
+  Bytes["Uncompressed MVT bytes"] --> PBF["Read PBF fields / layers"]
+  PBF --> Features["Tile-local features"]
+  Features --> Rings["Group polygon rings"]
+  Rings --> Triangulate["Shared triangulator"]
+  Triangulate -->|"recognized failure"| Fallback["Even-odd tessellation"]
+  Features --> Presentation["Style + project + display"]
+```
+
+Duplicate layer names are rejected. Integers outside JavaScript's safe range
+are decimal strings, including possible IDs and properties. Presentation
+belongs to [vector-tiles](../vector-tiles/README.md).
+
+- [decodeVectorTile.js](./decodeVectorTile.js): decode a tile.
+- [readMvtLayer.js](./readMvtLayer.js): read a layer from the PBF stream.
+- [triangulateVectorRings.js](./triangulateVectorRings.js): tessellate polygon rings.
+
+Related: [vector-tiles](../vector-tiles/README.md), [vector-style](../vector-style/README.md).

package/src/mvt/addMvtCrossings.js

@@ -1,17 +1,23 @@
-import { mvtEdgeX } from './mvtEdgeX.js';
-
-export function addMvtCrossings(edges, levels) {
-  let i = 0, j, a, b, top, bottom, start, end;
-  for (; i < edges.length; i++) {
-    a = edges[i];
-    for (j = i + 1; j < edges.length; j++) {
-      b = edges[j];
-      top = Math.max(a[0][1], b[0][1]);
-      bottom = Math.min(a[1][1], b[1][1]);
-      if (top >= bottom) continue;
-      start = mvtEdgeX(a, top) - mvtEdgeX(b, top);
-      end = mvtEdgeX(a, bottom) - mvtEdgeX(b, bottom);
-      if (start * end < 0) levels.add(top + (bottom - top) * start / (start - end));
-    }
-  }
-}
+import { mvtEdgeX } from './mvtEdgeX.js';
+
+/**
+ * Add vertical levels where non-horizontal polygon edges cross.
+ *
+ * @param {Array} edges Ordered edge endpoints.
+ * @param {Set<number>} levels Destination set of vertical levels.
+ */
+export function addMvtCrossings(edges, levels) {
+  let i = 0, j, a, b, top, bottom, start, end;
+  for (; i < edges.length; i++) {
+    a = edges[i];
+    for (j = i + 1; j < edges.length; j++) {
+      b = edges[j];
+      top = Math.max(a[0][1], b[0][1]);
+      bottom = Math.min(a[1][1], b[1][1]);
+      if (top >= bottom) continue;
+      start = mvtEdgeX(a, top) - mvtEdgeX(b, top);
+      end = mvtEdgeX(a, bottom) - mvtEdgeX(b, bottom);
+      if (start * end < 0) levels.add(top + (bottom - top) * start / (start - end));
+    }
+  }
+}

package/src/mvt/appendMvtBandTriangles.js

@@ -1,31 +1,42 @@
-import { mvtEdgeX } from './mvtEdgeX.js';
-import { sortMvtActiveEdges } from './sortMvtActiveEdges.js';
-
-export function appendMvtBandTriangles(edges, top, bottom, triangles) {
-  const mid = (top + bottom) / 2, active = /* alloc */ [];
-  let edge, i = 0, leftTop, leftBottom, rightTop, rightBottom;
-  for (edge of edges) {
-    if (edge[0][1] < mid && edge[1][1] > mid) {
-      active.push(/* alloc */ { edge, x: mvtEdgeX(edge, mid) });
-    }
-  }
-  sortMvtActiveEdges(active);
-  if (active.length % 2) throw /* alloc */ new Error('Unbalanced MVT polygon edges');
-  for (; i < active.length; i += 2) {
-    leftTop = mvtEdgeX(active[i].edge, top);
-    leftBottom = mvtEdgeX(active[i].edge, bottom);
-    rightTop = mvtEdgeX(active[i + 1].edge, top);
-    rightBottom = mvtEdgeX(active[i + 1].edge, bottom);
-    if (rightTop < leftTop - 1e-8 || rightBottom < leftBottom - 1e-8) {
-      throw /* alloc */ new Error('Crossing MVT polygon edges');
-    }
-    if ((rightTop - leftTop) * (bottom - top) > 1e-6) {
-      triangles.push(/* alloc */ [/* alloc */ [leftTop, top], /* alloc */ [rightTop, top],
-        /* alloc */ [leftBottom, bottom]]);
-    }
-    if ((rightBottom - leftBottom) * (bottom - top) > 1e-6) {
-      triangles.push(/* alloc */ [/* alloc */ [rightTop, top], /* alloc */ [rightBottom, bottom],
-        /* alloc */ [leftBottom, bottom]]);
-    }
-  }
-}
+import { mvtEdgeX } from './mvtEdgeX.js';
+import { sortMvtActiveEdges } from './sortMvtActiveEdges.js';
+
+/**
+ * Tessellate one vertical band using even-odd pairs of polygon edges.
+ *
+ * @param {Array} edges Polygon edges ordered by endpoint y.
+ * @param {number} top Band's upper y.
+ * @param {number} bottom Band's lower y.
+ * @param {Array} triangles Destination triangles.
+ *
+ * @throws {Error} If the band has an odd number of active edges.
+ * @throws {Error} If paired edges cross inside the band.
+ */
+export function appendMvtBandTriangles(edges, top, bottom, triangles) {
+  const mid = (top + bottom) / 2, active = /* alloc */ [];
+  let edge, i = 0, leftTop, leftBottom, rightTop, rightBottom;
+  for (edge of edges) {
+    if (edge[0][1] < mid && edge[1][1] > mid) {
+      active.push(/* alloc */ { edge, x: mvtEdgeX(edge, mid) });
+    }
+  }
+  sortMvtActiveEdges(active);
+  if (active.length % 2) throw /* alloc */ new Error('Unbalanced MVT polygon edges');
+  for (; i < active.length; i += 2) {
+    leftTop = mvtEdgeX(active[i].edge, top);
+    leftBottom = mvtEdgeX(active[i].edge, bottom);
+    rightTop = mvtEdgeX(active[i + 1].edge, top);
+    rightBottom = mvtEdgeX(active[i + 1].edge, bottom);
+    if (rightTop < leftTop - 1e-8 || rightBottom < leftBottom - 1e-8) {
+      throw /* alloc */ new Error('Crossing MVT polygon edges');
+    }
+    if ((rightTop - leftTop) * (bottom - top) > 1e-6) {
+      triangles.push(/* alloc */ [/* alloc */ [leftTop, top], /* alloc */ [rightTop, top],
+        /* alloc */ [leftBottom, bottom]]);
+    }
+    if ((rightBottom - leftBottom) * (bottom - top) > 1e-6) {
+      triangles.push(/* alloc */ [/* alloc */ [rightTop, top], /* alloc */ [rightBottom, bottom],
+        /* alloc */ [leftBottom, bottom]]);
+    }
+  }
+}

package/src/mvt/appendMvtCoordinates.js

@@ -1,11 +1,20 @@
-export function appendMvtCoordinates(commands, state, count) {
-  let i = 0, dx, dy;
-  for (; i < count; i++) {
-    dx = commands[state.index++];
-    dy = commands[state.index++];
-    if (dx > 0xffffffff || dy > 0xffffffff) throw /* alloc */ new Error('Invalid MVT coordinate');
-    state.x += dx % 2 ? -(dx + 1) / 2 : dx / 2;
-    state.y += dy % 2 ? -(dy + 1) / 2 : dy / 2;
-    state.path.push(/* alloc */ [state.x, state.y]);
-  }
-}
+/**
+ * Decode delta-encoded MVT coordinates into the current path.
+ *
+ * @param {Array<number>} commands Geometry command integers.
+ * @param {Object} state Mutable cursor, coordinate and path state.
+ * @param {number} count Number of coordinate pairs.
+ *
+ * @throws {Error} If a coordinate integer exceeds the MVT 32-bit range.
+ */
+export function appendMvtCoordinates(commands, state, count) {
+  let i = 0, dx, dy;
+  for (; i < count; i++) {
+    dx = commands[state.index++];
+    dy = commands[state.index++];
+    if (dx > 0xffffffff || dy > 0xffffffff) throw /* alloc */ new Error('Invalid MVT coordinate');
+    state.x += dx % 2 ? -(dx + 1) / 2 : dx / 2;
+    state.y += dy % 2 ? -(dy + 1) / 2 : dy / 2;
+    state.path.push(/* alloc */ [state.x, state.y]);
+  }
+}

package/src/mvt/appendMvtPolygonTriangles.js

@@ -1,19 +1,29 @@
-import { tessellateVectorRings } from './tessellateVectorRings.js';
-import { triangulate } from '../triangulation/triangulate.js';
-import { isMvtFallbackError } from './isMvtFallbackError.js';
-
-export function appendMvtPolygonTriangles(rings, paths, vertices, triangles) {
-  let indices, index, triangle, points, i = 0;
-  try {
-    indices = triangulate(paths[0], paths.slice(1));
-    for (triangle of indices) {
-      points = /* alloc */ [];
-      for (index of triangle) points.push(/* alloc */ [vertices[index].x, vertices[index].y]);
-      triangles.push(points);
-    }
-  } catch (error) {
-    if (!isMvtFallbackError(error)) throw error;
-    indices = tessellateVectorRings(rings);
-    for (; i < indices.length; i++) triangles.push(indices[i]);
-  }
-}
+import { tessellateVectorRings } from './tessellateVectorRings.js';
+import { triangulate } from '../triangulation/triangulate.js';
+import { isMvtFallbackError } from './isMvtFallbackError.js';
+
+/**
+ * Triangulate a polygon, falling back to even-odd tessellation for recognized errors.
+ *
+ * @param {Array} rings Closed tile-coordinate rings.
+ * @param {Array} paths Rings converted to point objects.
+ * @param {Array} vertices Flattened path vertices.
+ * @param {Array} triangles Destination triangle coordinates.
+ *
+ * @throws {Error} If triangulation fails with an error not eligible for fallback.
+ */
+export function appendMvtPolygonTriangles(rings, paths, vertices, triangles) {
+  let indices, index, triangle, points, i = 0;
+  try {
+    indices = triangulate(paths[0], paths.slice(1));
+    for (triangle of indices) {
+      points = /* alloc */ [];
+      for (index of triangle) points.push(/* alloc */ [vertices[index].x, vertices[index].y]);
+      triangles.push(points);
+    }
+  } catch (error) {
+    if (!isMvtFallbackError(error)) throw error;
+    indices = tessellateVectorRings(rings);
+    for (; i < indices.length; i++) triangles.push(indices[i]);
+  }
+}

package/src/mvt/beginMvtPath.js

@@ -1,9 +1,19 @@
-import { finishMvtPath } from './finishMvtPath.js';
-
-export function beginMvtPath(state, paths, type, count) {
-  finishMvtPath(state.path, type, state.closed);
-  if (type !== 1 && count !== 1) throw /* alloc */ new Error('Invalid MVT MoveTo');
-  state.path = /* alloc */ [];
-  paths.push(state.path);
-  state.closed = false;
-}
+import { finishMvtPath } from './finishMvtPath.js';
+
+/**
+ * Finish the previous geometry path and begin a new MoveTo path.
+ *
+ * @param {Object} state Mutable geometry decoding state.
+ * @param {Array} paths Destination paths.
+ * @param {number} type MVT geometry type.
+ * @param {number} count MoveTo coordinate count.
+ *
+ * @throws {Error} If a non-point MoveTo count is not one.
+ */
+export function beginMvtPath(state, paths, type, count) {
+  finishMvtPath(state.path, type, state.closed);
+  if (type !== 1 && count !== 1) throw /* alloc */ new Error('Invalid MVT MoveTo');
+  state.path = /* alloc */ [];
+  paths.push(state.path);
+  state.closed = false;
+}

package/src/mvt/closeMvtPath.js

@@ -1,7 +1,16 @@
-export function closeMvtPath(state, type, count) {
-  if (type !== 3 || count !== 1 || !state.path || state.closed || state.path.length < 3) {
-    throw /* alloc */ new Error('Invalid MVT ClosePath');
-  }
-  state.path.push(/* alloc */ [...state.path[0]]);
-  state.closed = true;
-}
+/**
+ * Close a valid polygon path by repeating its first point.
+ *
+ * @param {Object} state Mutable geometry decoding state.
+ * @param {number} type MVT geometry type.
+ * @param {number} count ClosePath command count.
+ *
+ * @throws {Error} If the close command or path is invalid.
+ */
+export function closeMvtPath(state, type, count) {
+  if (type !== 3 || count !== 1 || !state.path || state.closed || state.path.length < 3) {
+    throw /* alloc */ new Error('Invalid MVT ClosePath');
+  }
+  state.path.push(/* alloc */ [...state.path[0]]);
+  state.closed = true;
+}

package/src/mvt/collectMvtEdges.js

@@ -1,19 +1,29 @@
-import { finiteMvtCoordinate } from './finiteMvtCoordinate.js';
-
-export function collectMvtEdges(rings, edges, levels) {
-  let ring, i, a, b;
-  for (ring of rings) {
-    if (ring.length < 4 || ring[0][0] !== ring.at(-1)[0] || ring[0][1] !== ring.at(-1)[1]) {
-      throw /* alloc */ new Error('MVT tessellation requires closed rings');
-    }
-    for (i = 1; i < ring.length; i++) {
-      a = ring[i - 1];
-      b = ring[i];
-      if (!finiteMvtCoordinate(a) || !finiteMvtCoordinate(b)) {
-        throw /* alloc */ new Error('Invalid MVT ring coordinate');
-      }
-      levels.add(a[1]);
-      if (a[1] !== b[1]) edges.push(/* alloc */ [a[1] < b[1] ? a : b, a[1] < b[1] ? b : a]);
-    }
-  }
-}
+import { finiteMvtCoordinate } from './finiteMvtCoordinate.js';
+
+/**
+ * Collect non-horizontal edges and vertical levels from closed MVT rings.
+ *
+ * @param {Array} rings Closed polygon rings.
+ * @param {Array} edges Destination edges.
+ * @param {Set<number>} levels Destination vertical levels.
+ *
+ * @throws {Error} If a ring is not closed or is too short.
+ * @throws {Error} If a ring coordinate is non-finite.
+ */
+export function collectMvtEdges(rings, edges, levels) {
+  let ring, i, a, b;
+  for (ring of rings) {
+    if (ring.length < 4 || ring[0][0] !== ring.at(-1)[0] || ring[0][1] !== ring.at(-1)[1]) {
+      throw /* alloc */ new Error('MVT tessellation requires closed rings');
+    }
+    for (i = 1; i < ring.length; i++) {
+      a = ring[i - 1];
+      b = ring[i];
+      if (!finiteMvtCoordinate(a) || !finiteMvtCoordinate(b)) {
+        throw /* alloc */ new Error('Invalid MVT ring coordinate');
+      }
+      levels.add(a[1]);
+      if (a[1] !== b[1]) edges.push(/* alloc */ [a[1] < b[1] ? a : b, a[1] < b[1] ? b : a]);
+    }
+  }
+}

package/src/mvt/createMvtReader.js

@@ -1,7 +1,14 @@
-export function createMvtReader(bytes) {
-  return /* alloc */ {
-    bytes,
-    view: /* alloc */ new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength),
-    pos: 0,
-  };
-}
+/**
+ * Create a protobuf reader over the supplied tile bytes.
+ *
+ * @param {Uint8Array} bytes Input bytes.
+ *
+ * @returns {Object} Reader with a data view and cursor.
+ */
+export function createMvtReader(bytes) {
+  return /* alloc */ {
+    bytes,
+    view: /* alloc */ new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength),
+    pos: 0,
+  };
+}

package/src/mvt/decodeVectorTile.js

@@ -1,32 +1,39 @@
-import { createMvtReader } from './createMvtReader.js';
-import { readMvtField } from './readMvtField.js';
-import { readMvtLayer } from './readMvtLayer.js';
-import { readMvtMessage } from './readMvtMessage.js';
-import { skipMvtField } from './skipMvtField.js';
-
-/**
- * Decode an uncompressed MVT ArrayBuffer/Uint8Array into tile-local layers.
- * Feature types: 0 unknown, 1 points, 2 lines, 3 polygon rings (including holes).
- * Integers outside JavaScript's safe range are returned as decimal strings.
- */
-export function decodeVectorTile(buffer) {
-  if (!(buffer instanceof ArrayBuffer) && !(buffer instanceof Uint8Array)) {
-    throw /* alloc */ new TypeError('MVT input must be an ArrayBuffer or Uint8Array');
-  }
-  const bytes = buffer instanceof Uint8Array ? buffer : /* alloc */ new Uint8Array(buffer);
-  const reader = createMvtReader(bytes);
-  const layers = /* alloc */ [], names = /* alloc */ new Set();
-  let field, wire, layer;
-  while (reader.pos < reader.bytes.length) {
-    [field, wire] = readMvtField(reader);
-    if (field !== 3) {
-      skipMvtField(reader, wire);
-      continue;
-    }
-    layer = readMvtLayer(readMvtMessage(reader, wire));
-    if (names.has(layer.name)) throw /* alloc */ new Error('Duplicate MVT layer name');
-    names.add(layer.name);
-    layers.push(layer);
-  }
-  return layers;
-}
+import { createMvtReader } from './createMvtReader.js';
+import { readMvtField } from './readMvtField.js';
+import { readMvtLayer } from './readMvtLayer.js';
+import { readMvtMessage } from './readMvtMessage.js';
+import { skipMvtField } from './skipMvtField.js';
+
+/**
+ * Decode an uncompressed MVT ArrayBuffer/Uint8Array into tile-local layers.
+ * Feature types: 0 unknown, 1 points, 2 lines, 3 polygon rings (including holes).
+ * Integers outside JavaScript's safe range are returned as decimal strings.
+ *
+ * @param {ArrayBuffer|Uint8Array} buffer Uncompressed tile data.
+ *
+ * @returns {Array<Object>} Decoded tile layers.
+ *
+ * @throws {TypeError} If the input is not a supported byte buffer.
+ * @throws {Error} If layer names are duplicated.
+ */
+export function decodeVectorTile(buffer) {
+  if (!(buffer instanceof ArrayBuffer) && !(buffer instanceof Uint8Array)) {
+    throw /* alloc */ new TypeError('MVT input must be an ArrayBuffer or Uint8Array');
+  }
+  const bytes = buffer instanceof Uint8Array ? buffer : /* alloc */ new Uint8Array(buffer);
+  const reader = createMvtReader(bytes);
+  const layers = /* alloc */ [], names = /* alloc */ new Set();
+  let field, wire, layer;
+  while (reader.pos < reader.bytes.length) {
+    [field, wire] = readMvtField(reader);
+    if (field !== 3) {
+      skipMvtField(reader, wire);
+      continue;
+    }
+    layer = readMvtLayer(readMvtMessage(reader, wire));
+    if (names.has(layer.name)) throw /* alloc */ new Error('Duplicate MVT layer name');
+    names.add(layer.name);
+    layers.push(layer);
+  }
+  return layers;
+}

package/src/mvt/expectMvtWire.js

@@ -1,3 +1,11 @@
-export function expectMvtWire(wire, expected) {
-  if (wire !== expected) throw /* alloc */ new Error('Invalid MVT wire type');
-}
+/**
+ * Validate the protobuf wire type for an MVT field.
+ *
+ * @param {number} wire Actual wire type.
+ * @param {number} expected Expected wire type.
+ *
+ * @throws {Error} If the types differ.
+ */
+export function expectMvtWire(wire, expected) {
+  if (wire !== expected) throw /* alloc */ new Error('Invalid MVT wire type');
+}

package/src/mvt/finishMvtPath.js

@@ -1,5 +1,14 @@
-export function finishMvtPath(path, type, closed) {
-  if (path && (type === 2 && path.length < 2 || type === 3 && !closed)) {
-    throw /* alloc */ new Error('Incomplete MVT geometry');
-  }
-}
+/**
+ * Validate a completed MVT line or polygon path.
+ *
+ * @param {Array|null} path Current path, if any.
+ * @param {number} type MVT geometry type.
+ * @param {boolean} closed Whether the polygon path is closed.
+ *
+ * @throws {Error} If a line is too short or a polygon path is open.
+ */
+export function finishMvtPath(path, type, closed) {
+  if (path && (type === 2 && path.length < 2 || type === 3 && !closed)) {
+    throw /* alloc */ new Error('Incomplete MVT geometry');
+  }
+}

package/src/mvt/finiteMvtCoordinate.js

@@ -1,7 +1,14 @@
-export function finiteMvtCoordinate(point) {
-  let i = 0;
-  for (; i < point.length; i++) {
-    if (!Number.isFinite(point[i])) return false;
-  }
-  return true;
-}
+/**
+ * Check every component of a tile coordinate for finiteness.
+ *
+ * @param {Array<number>} point Tile coordinate.
+ *
+ * @returns {boolean} Whether all components are finite.
+ */
+export function finiteMvtCoordinate(point) {
+  let i = 0;
+  for (; i < point.length; i++) {
+    if (!Number.isFinite(point[i])) return false;
+  }
+  return true;
+}