leaflet-city-mapper 0.0.9 → 0.1.1

package/src/mvt/groupMvtPolygons.js

@@ -1,25 +1,35 @@
-import { finiteMvtCoordinate } from './finiteMvtCoordinate.js';
-
-export function groupMvtPolygons(rings) {
-  const polygons = /* alloc */ [];
-  let polygon, exteriorSign, ring, area, i;
-  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');
-    }
-    area = 0;
-    for (i = 1; i < ring.length; i++) {
-      if (!finiteMvtCoordinate(ring[i]) || !finiteMvtCoordinate(ring[i - 1])) {
-        throw /* alloc */ new Error('Invalid MVT ring coordinate');
-      }
-      area += ring[i - 1][0] * ring[i][1] - ring[i][0] * ring[i - 1][1];
-    }
-    if (!polygon || area && Math.sign(area) === exteriorSign) {
-      polygon = /* alloc */ [];
-      polygons.push(polygon);
-      exteriorSign = Math.sign(area);
-    }
-    polygon.push(ring);
-  }
-  return polygons;
-}
+import { finiteMvtCoordinate } from './finiteMvtCoordinate.js';
+
+/**
+ * Group closed MVT rings into polygons according to exterior winding.
+ *
+ * @param {Array} rings Closed tile-coordinate rings.
+ *
+ * @returns {Array} Polygons containing exterior and following hole rings.
+ *
+ * @throws {Error} If a ring is not closed or is too short.
+ * @throws {Error} If a ring coordinate is non-finite.
+ */
+export function groupMvtPolygons(rings) {
+  const polygons = /* alloc */ [];
+  let polygon, exteriorSign, ring, area, i;
+  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');
+    }
+    area = 0;
+    for (i = 1; i < ring.length; i++) {
+      if (!finiteMvtCoordinate(ring[i]) || !finiteMvtCoordinate(ring[i - 1])) {
+        throw /* alloc */ new Error('Invalid MVT ring coordinate');
+      }
+      area += ring[i - 1][0] * ring[i][1] - ring[i][0] * ring[i - 1][1];
+    }
+    if (!polygon || area && Math.sign(area) === exteriorSign) {
+      polygon = /* alloc */ [];
+      polygons.push(polygon);
+      exteriorSign = Math.sign(area);
+    }
+    polygon.push(ring);
+  }
+  return polygons;
+}

package/src/mvt/isMvtFallbackError.js

@@ -1,6 +1,13 @@
-export function isMvtFallbackError(error) {
-  return error.message === 'Polygon triangulation area mismatch' ||
-    error.message === 'Degenerate polygon ring' ||
-    error.message === 'Unable to triangulate polygon: invalid or self-intersecting rings' ||
-    error.message === 'Unable to connect polygon hole';
-}
+/**
+ * Identify triangulation failures eligible for MVT tessellation fallback.
+ *
+ * @param {Error} error Triangulation error.
+ *
+ * @returns {boolean} Whether fallback is allowed.
+ */
+export function isMvtFallbackError(error) {
+  return error.message === 'Polygon triangulation area mismatch' ||
+    error.message === 'Degenerate polygon ring' ||
+    error.message === 'Unable to triangulate polygon: invalid or self-intersecting rings' ||
+    error.message === 'Unable to connect polygon hole';
+}

package/src/mvt/mergeMvtActiveEdges.js

@@ -1,9 +1,18 @@
-export function mergeMvtActiveEdges(active, sorted, left, mid, right) {
-  let i = left, j = mid, k = left;
-  while (i < mid && j < right) {
-    if (active[j].x < active[i].x) sorted[k++] = active[j++];
-    else sorted[k++] = active[i++];
-  }
-  while (i < mid) sorted[k++] = active[i++];
-  while (j < right) sorted[k++] = active[j++];
-}
+/**
+ * Stably merge two sorted active-edge ranges into a destination array.
+ *
+ * @param {Array<Object>} active Source active edges.
+ * @param {Array<Object>} sorted Destination array.
+ * @param {number} left Start of the first range.
+ * @param {number} mid Boundary between ranges.
+ * @param {number} right Exclusive end of the second range.
+ */
+export function mergeMvtActiveEdges(active, sorted, left, mid, right) {
+  let i = left, j = mid, k = left;
+  while (i < mid && j < right) {
+    if (active[j].x < active[i].x) sorted[k++] = active[j++];
+    else sorted[k++] = active[i++];
+  }
+  while (i < mid) sorted[k++] = active[i++];
+  while (j < right) sorted[k++] = active[j++];
+}

package/src/mvt/mvtEdgeX.js

@@ -1,4 +1,12 @@
-export function mvtEdgeX(edge, y) {
-  return edge[0][0] + (y - edge[0][1]) *
-    (edge[1][0] - edge[0][0]) / (edge[1][1] - edge[0][1]);
-}
+/**
+ * Interpolate an edge's x coordinate at a given y.
+ *
+ * @param {Array<Array<number>>} edge Non-horizontal edge endpoints.
+ * @param {number} y Vertical coordinate.
+ *
+ * @returns {number} Interpolated x coordinate.
+ */
+export function mvtEdgeX(edge, y) {
+  return edge[0][0] + (y - edge[0][1]) *
+    (edge[1][0] - edge[0][0]) / (edge[1][1] - edge[0][1]);
+}

package/src/mvt/mvtPathsVertices.js

@@ -1,8 +1,15 @@
-export function mvtPathsVertices(paths) {
-  const vertices = /* alloc */ [];
-  let path, point;
-  for (path of paths) {
-    for (point of path) vertices.push(point);
-  }
-  return vertices;
-}
+/**
+ * Flatten polygon paths into a vertex array.
+ *
+ * @param {Array<Array<Object>>} paths Polygon paths.
+ *
+ * @returns {Array<Object>} Flattened vertices.
+ */
+export function mvtPathsVertices(paths) {
+  const vertices = /* alloc */ [];
+  let path, point;
+  for (path of paths) {
+    for (point of path) vertices.push(point);
+  }
+  return vertices;
+}

package/src/mvt/mvtPolygonPaths.js

@@ -1,12 +1,19 @@
-export function mvtPolygonPaths(rings) {
-  const paths = /* alloc */ [];
-  let ring, i, path;
-  for (ring of rings) {
-    path = /* alloc */ [];
-    for (i = 0; i < ring.length - 1; i++) {
-      path.push(/* alloc */ { x: ring[i][0], y: ring[i][1] });
-    }
-    paths.push(path);
-  }
-  return paths;
-}
+/**
+ * Convert closed coordinate rings to point-object paths without duplicate closing vertices.
+ *
+ * @param {Array} rings Closed tile-coordinate rings.
+ *
+ * @returns {Array<Array<Object>>} Polygon point paths.
+ */
+export function mvtPolygonPaths(rings) {
+  const paths = /* alloc */ [];
+  let ring, i, path;
+  for (ring of rings) {
+    path = /* alloc */ [];
+    for (i = 0; i < ring.length - 1; i++) {
+      path.push(/* alloc */ { x: ring[i][0], y: ring[i][1] });
+    }
+    paths.push(path);
+  }
+  return paths;
+}

package/src/mvt/numericMvtValue.js

@@ -1,4 +1,11 @@
-export function numericMvtValue(value) {
-  return value >= BigInt(Number.MIN_SAFE_INTEGER) && value <= BigInt(Number.MAX_SAFE_INTEGER)
-    ? Number(value) : value.toString();
-}
+/**
+ * Convert an MVT integer to a number when safe, otherwise to a decimal string.
+ *
+ * @param {bigint} value Integer value.
+ *
+ * @returns {number|string} Safely represented integer.
+ */
+export function numericMvtValue(value) {
+  return value >= BigInt(Number.MIN_SAFE_INTEGER) && value <= BigInt(Number.MAX_SAFE_INTEGER)
+    ? Number(value) : value.toString();
+}

package/src/mvt/readMvtFeature.js

@@ -1,34 +1,46 @@
-import { expectMvtWire } from './expectMvtWire.js';
-import { numericMvtValue } from './numericMvtValue.js';
-import { readMvtField } from './readMvtField.js';
-import { readMvtGeometry } from './readMvtGeometry.js';
-import { readMvtInteger } from './readMvtInteger.js';
-import { readMvtNumber } from './readMvtNumber.js';
-import { readMvtNumbers } from './readMvtNumbers.js';
-import { skipMvtField } from './skipMvtField.js';
-
-export function readMvtFeature(reader, keys, values) {
-  let id, type = 0, field, wire, i = 0;
-  const tags = /* alloc */ [], commands = /* alloc */ [];
-  while (reader.pos < reader.bytes.length) {
-    [field, wire] = readMvtField(reader);
-    if (field === 1) {
-      expectMvtWire(wire, 0);
-      id = numericMvtValue(readMvtInteger(reader));
-    } else if (field === 2) readMvtNumbers(reader, wire, tags);
-    else if (field === 3) {
-      expectMvtWire(wire, 0);
-      type = readMvtNumber(reader);
-    } else if (field === 4) readMvtNumbers(reader, wire, commands);
-    else skipMvtField(reader, wire);
-  }
-  if (tags.length % 2 || type > 3) throw /* alloc */ new Error('Invalid MVT feature');
-  const properties = Object.create(null);
-  for (; i < tags.length; i += 2) {
-    if (tags[i] >= keys.length || tags[i + 1] >= values.length) {
-      throw /* alloc */ new Error('Invalid MVT property index');
-    }
-    properties[keys[tags[i]]] = values[tags[i + 1]];
-  }
-  return /* alloc */ { id, type, properties, geometry: type ? readMvtGeometry(commands, type) : /* alloc */ [] };
-}
+import { expectMvtWire } from './expectMvtWire.js';
+import { numericMvtValue } from './numericMvtValue.js';
+import { readMvtField } from './readMvtField.js';
+import { readMvtGeometry } from './readMvtGeometry.js';
+import { readMvtInteger } from './readMvtInteger.js';
+import { readMvtNumber } from './readMvtNumber.js';
+import { readMvtNumbers } from './readMvtNumbers.js';
+import { skipMvtField } from './skipMvtField.js';
+
+/**
+ * Decode an MVT feature's ID, property tags and geometry.
+ *
+ * @param {Object} reader Feature message reader.
+ * @param {Array<string>} keys Layer property keys.
+ * @param {Array} values Layer property values.
+ *
+ * @returns {Object} Decoded feature.
+ *
+ * @throws {Error} If feature tags or geometry type are invalid.
+ * @throws {Error} If a property index is outside the layer tables.
+ */
+export function readMvtFeature(reader, keys, values) {
+  let id, type = 0, field, wire, i = 0;
+  const tags = /* alloc */ [], commands = /* alloc */ [];
+  while (reader.pos < reader.bytes.length) {
+    [field, wire] = readMvtField(reader);
+    if (field === 1) {
+      expectMvtWire(wire, 0);
+      id = numericMvtValue(readMvtInteger(reader));
+    } else if (field === 2) readMvtNumbers(reader, wire, tags);
+    else if (field === 3) {
+      expectMvtWire(wire, 0);
+      type = readMvtNumber(reader);
+    } else if (field === 4) readMvtNumbers(reader, wire, commands);
+    else skipMvtField(reader, wire);
+  }
+  if (tags.length % 2 || type > 3) throw /* alloc */ new Error('Invalid MVT feature');
+  const properties = Object.create(null);
+  for (; i < tags.length; i += 2) {
+    if (tags[i] >= keys.length || tags[i + 1] >= values.length) {
+      throw /* alloc */ new Error('Invalid MVT property index');
+    }
+    properties[keys[tags[i]]] = values[tags[i + 1]];
+  }
+  return /* alloc */ { id, type, properties, geometry: type ? readMvtGeometry(commands, type) : /* alloc */ [] };
+}

package/src/mvt/readMvtField.js

@@ -1,8 +1,17 @@
-import { readMvtNumber } from './readMvtNumber.js';
-
-export function readMvtField(reader) {
-  const tag = readMvtNumber(reader);
-  const field = Math.floor(tag / 8), wire = tag % 8;
-  if (!field || field > 536870911) throw /* alloc */ new Error('Invalid MVT field number');
-  return /* alloc */ [field, wire];
-}
+import { readMvtNumber } from './readMvtNumber.js';
+
+/**
+ * Read a protobuf field tag and split its field number and wire type.
+ *
+ * @param {Object} reader MVT byte reader.
+ *
+ * @returns {Array<number>} Field number and wire type.
+ *
+ * @throws {Error} If the field number is invalid.
+ */
+export function readMvtField(reader) {
+  const tag = readMvtNumber(reader);
+  const field = Math.floor(tag / 8), wire = tag % 8;
+  if (!field || field > 536870911) throw /* alloc */ new Error('Invalid MVT field number');
+  return /* alloc */ [field, wire];
+}

package/src/mvt/readMvtGeometry.js

@@ -1,29 +1,42 @@
-import { finishMvtPath } from './finishMvtPath.js';
-import { appendMvtCoordinates } from './appendMvtCoordinates.js';
-import { beginMvtPath } from './beginMvtPath.js';
-import { closeMvtPath } from './closeMvtPath.js';
-
-export function readMvtGeometry(commands, type) {
-  const paths = /* alloc */ [];
-  const state = /* alloc */ { x: 0, y: 0, path: null, closed: false, index: 0 };
-  let command, id, count;
-  while (state.index < commands.length) {
-    command = commands[state.index++];
-    id = command % 8;
-    count = Math.floor(command / 8);
-    if (!count || command > 0xffffffff) throw /* alloc */ new Error('Invalid MVT geometry command');
-    if (id === 7) {
-      closeMvtPath(state, type, count);
-      continue;
-    }
-    if (id !== 1 && id !== 2 || count > Math.floor((commands.length - state.index) / 2)) {
-      throw /* alloc */ new Error('Invalid MVT geometry parameters');
-    }
-    if (id === 1) beginMvtPath(state, paths, type, count);
-    else if (type === 1 || !state.path || state.closed) throw /* alloc */ new Error('Invalid MVT LineTo');
-    appendMvtCoordinates(commands, state, count);
-  }
-  finishMvtPath(state.path, type, state.closed);
-  if (!paths.length) throw /* alloc */ new Error('Empty MVT geometry');
-  return paths;
-}
+import { finishMvtPath } from './finishMvtPath.js';
+import { appendMvtCoordinates } from './appendMvtCoordinates.js';
+import { beginMvtPath } from './beginMvtPath.js';
+import { closeMvtPath } from './closeMvtPath.js';
+
+/**
+ * Decode MVT geometry commands into tile-coordinate paths.
+ *
+ * @param {Array<number>} commands Geometry command integers.
+ * @param {number} type MVT geometry type.
+ *
+ * @returns {Array} Decoded paths.
+ *
+ * @throws {Error} If a command or count is invalid.
+ * @throws {Error} If geometry command parameters are invalid or truncated.
+ * @throws {Error} If a LineTo is invalid for the current path.
+ * @throws {Error} If no geometry path was decoded.
+ */
+export function readMvtGeometry(commands, type) {
+  const paths = /* alloc */ [];
+  const state = /* alloc */ { x: 0, y: 0, path: null, closed: false, index: 0 };
+  let command, id, count;
+  while (state.index < commands.length) {
+    command = commands[state.index++];
+    id = command % 8;
+    count = Math.floor(command / 8);
+    if (!count || command > 0xffffffff) throw /* alloc */ new Error('Invalid MVT geometry command');
+    if (id === 7) {
+      closeMvtPath(state, type, count);
+      continue;
+    }
+    if (id !== 1 && id !== 2 || count > Math.floor((commands.length - state.index) / 2)) {
+      throw /* alloc */ new Error('Invalid MVT geometry parameters');
+    }
+    if (id === 1) beginMvtPath(state, paths, type, count);
+    else if (type === 1 || !state.path || state.closed) throw /* alloc */ new Error('Invalid MVT LineTo');
+    appendMvtCoordinates(commands, state, count);
+  }
+  finishMvtPath(state.path, type, state.closed);
+  if (!paths.length) throw /* alloc */ new Error('Empty MVT geometry');
+  return paths;
+}

package/src/mvt/readMvtInteger.js

@@ -1,12 +1,22 @@
-import { takeMvtBytes } from './takeMvtBytes.js';
-
-export function readMvtInteger(reader) {
-  let value = 0n, i = 0, byte;
-  for (; i < 10; i++) {
-    byte = reader.bytes[takeMvtBytes(reader, 1)];
-    if (i === 9 && byte > 1) throw /* alloc */ new Error('Invalid MVT varint');
-    value |= BigInt(byte & 127) << BigInt(i * 7);
-    if (byte < 128) return value;
-  }
-  throw /* alloc */ new Error('Invalid MVT varint');
-}
+import { takeMvtBytes } from './takeMvtBytes.js';
+
+/**
+ * Read an unsigned protobuf varint as a bigint.
+ *
+ * @param {Object} reader MVT byte reader.
+ *
+ * @returns {bigint} Decoded integer.
+ *
+ * @throws {Error} If the tenth byte exceeds the 64-bit range.
+ * @throws {Error} If the varint does not terminate within ten bytes.
+ */
+export function readMvtInteger(reader) {
+  let value = 0n, i = 0, byte;
+  for (; i < 10; i++) {
+    byte = reader.bytes[takeMvtBytes(reader, 1)];
+    if (i === 9 && byte > 1) throw /* alloc */ new Error('Invalid MVT varint');
+    value |= BigInt(byte & 127) << BigInt(i * 7);
+    if (byte < 128) return value;
+  }
+  throw /* alloc */ new Error('Invalid MVT varint');
+}

package/src/mvt/readMvtKnownValue.js

@@ -1,21 +1,30 @@
-import { expectMvtWire } from './expectMvtWire.js';
-import { numericMvtValue } from './numericMvtValue.js';
-import { readMvtInteger } from './readMvtInteger.js';
-import { readMvtString } from './readMvtString.js';
-import { takeMvtBytes } from './takeMvtBytes.js';
-
-export function readMvtKnownValue(reader, field, wire) {
-  let offset, integer;
-  if (field === 1) return readMvtString(reader, wire);
-  if (field === 2 || field === 3) {
-    expectMvtWire(wire, field === 2 ? 5 : 1);
-    offset = takeMvtBytes(reader, field === 2 ? 4 : 8);
-    return field === 2 ? reader.view.getFloat32(offset, true) : reader.view.getFloat64(offset, true);
-  }
-  expectMvtWire(wire, 0);
-  integer = readMvtInteger(reader);
-  if (field === 4) return numericMvtValue(BigInt.asIntN(64, integer));
-  if (field === 5) return numericMvtValue(integer);
-  if (field === 6) return numericMvtValue((integer >> 1n) ^ -(integer & 1n));
-  return integer !== 0n;
-}
+import { expectMvtWire } from './expectMvtWire.js';
+import { numericMvtValue } from './numericMvtValue.js';
+import { readMvtInteger } from './readMvtInteger.js';
+import { readMvtString } from './readMvtString.js';
+import { takeMvtBytes } from './takeMvtBytes.js';
+
+/**
+ * Decode a known MVT value field according to its protobuf type.
+ *
+ * @param {Object} reader MVT byte reader.
+ * @param {number} field Value field number.
+ * @param {number} wire Protobuf wire type.
+ *
+ * @returns {string|number|boolean} Decoded value.
+ */
+export function readMvtKnownValue(reader, field, wire) {
+  let offset, integer;
+  if (field === 1) return readMvtString(reader, wire);
+  if (field === 2 || field === 3) {
+    expectMvtWire(wire, field === 2 ? 5 : 1);
+    offset = takeMvtBytes(reader, field === 2 ? 4 : 8);
+    return field === 2 ? reader.view.getFloat32(offset, true) : reader.view.getFloat64(offset, true);
+  }
+  expectMvtWire(wire, 0);
+  integer = readMvtInteger(reader);
+  if (field === 4) return numericMvtValue(BigInt.asIntN(64, integer));
+  if (field === 5) return numericMvtValue(integer);
+  if (field === 6) return numericMvtValue((integer >> 1n) ^ -(integer & 1n));
+  return integer !== 0n;
+}

package/src/mvt/readMvtLayer.js

@@ -1,31 +1,40 @@
-import { expectMvtWire } from './expectMvtWire.js';
-import { readMvtFeature } from './readMvtFeature.js';
-import { readMvtField } from './readMvtField.js';
-import { readMvtMessage } from './readMvtMessage.js';
-import { readMvtNumber } from './readMvtNumber.js';
-import { readMvtString } from './readMvtString.js';
-import { readMvtValue } from './readMvtValue.js';
-import { skipMvtField } from './skipMvtField.js';
-
-export function readMvtLayer(reader) {
-  let name, version, extent = 4096, field, wire, value, i = 0;
-  const keys = /* alloc */ [], values = /* alloc */ [], features = /* alloc */ [];
-  while (reader.pos < reader.bytes.length) {
-    [field, wire] = readMvtField(reader);
-    if (field === 1) name = readMvtString(reader, wire);
-    else if (field === 2) features.push(readMvtMessage(reader, wire));
-    else if (field === 3) keys.push(readMvtString(reader, wire));
-    else if (field === 4) values.push(readMvtValue(readMvtMessage(reader, wire)));
-    else if (field === 5 || field === 15) {
-      expectMvtWire(wire, 0);
-      value = readMvtNumber(reader);
-      if (field === 5) extent = value;
-      else version = value;
-    } else skipMvtField(reader, wire);
-  }
-  if (!name || !/* alloc */ [1, 2].includes(version) || !extent || extent > 0xffffffff) {
-    throw /* alloc */ new Error('Invalid MVT layer metadata');
-  }
-  for (; i < features.length; i++) features[i] = readMvtFeature(features[i], keys, values);
-  return /* alloc */ { name, extent, features };
-}
+import { expectMvtWire } from './expectMvtWire.js';
+import { readMvtFeature } from './readMvtFeature.js';
+import { readMvtField } from './readMvtField.js';
+import { readMvtMessage } from './readMvtMessage.js';
+import { readMvtNumber } from './readMvtNumber.js';
+import { readMvtString } from './readMvtString.js';
+import { readMvtValue } from './readMvtValue.js';
+import { skipMvtField } from './skipMvtField.js';
+
+/**
+ * Decode an MVT layer and resolve its features against property tables.
+ *
+ * @param {Object} reader Layer message reader.
+ *
+ * @returns {Object} Layer name, extent and features.
+ *
+ * @throws {Error} If layer name, version or extent is invalid.
+ */
+export function readMvtLayer(reader) {
+  let name, version, extent = 4096, field, wire, value, i = 0;
+  const keys = /* alloc */ [], values = /* alloc */ [], features = /* alloc */ [];
+  while (reader.pos < reader.bytes.length) {
+    [field, wire] = readMvtField(reader);
+    if (field === 1) name = readMvtString(reader, wire);
+    else if (field === 2) features.push(readMvtMessage(reader, wire));
+    else if (field === 3) keys.push(readMvtString(reader, wire));
+    else if (field === 4) values.push(readMvtValue(readMvtMessage(reader, wire)));
+    else if (field === 5 || field === 15) {
+      expectMvtWire(wire, 0);
+      value = readMvtNumber(reader);
+      if (field === 5) extent = value;
+      else version = value;
+    } else skipMvtField(reader, wire);
+  }
+  if (!name || !/* alloc */ [1, 2].includes(version) || !extent || extent > 0xffffffff) {
+    throw /* alloc */ new Error('Invalid MVT layer metadata');
+  }
+  for (; i < features.length; i++) features[i] = readMvtFeature(features[i], keys, values);
+  return /* alloc */ { name, extent, features };
+}

package/src/mvt/readMvtMessage.js

@@ -1,10 +1,18 @@
-import { createMvtReader } from './createMvtReader.js';
-import { expectMvtWire } from './expectMvtWire.js';
-import { readMvtNumber } from './readMvtNumber.js';
-import { takeMvtBytes } from './takeMvtBytes.js';
-
-export function readMvtMessage(reader, wire) {
-  expectMvtWire(wire, 2);
-  const size = readMvtNumber(reader), start = takeMvtBytes(reader, size);
-  return createMvtReader(reader.bytes.subarray(start, start + size));
-}
+import { createMvtReader } from './createMvtReader.js';
+import { expectMvtWire } from './expectMvtWire.js';
+import { readMvtNumber } from './readMvtNumber.js';
+import { takeMvtBytes } from './takeMvtBytes.js';
+
+/**
+ * Read a length-delimited protobuf message into a bounded reader.
+ *
+ * @param {Object} reader Parent MVT byte reader.
+ * @param {number} wire Protobuf wire type.
+ *
+ * @returns {Object} Reader for the message bytes.
+ */
+export function readMvtMessage(reader, wire) {
+  expectMvtWire(wire, 2);
+  const size = readMvtNumber(reader), start = takeMvtBytes(reader, size);
+  return createMvtReader(reader.bytes.subarray(start, start + size));
+}

package/src/mvt/readMvtNumber.js

@@ -1,9 +1,18 @@
-import { readMvtInteger } from './readMvtInteger.js';
-
-export function readMvtNumber(reader) {
-  const value = readMvtInteger(reader);
-  if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
-    throw /* alloc */ new Error('MVT integer exceeds safe range');
-  }
-  return Number(value);
-}
+import { readMvtInteger } from './readMvtInteger.js';
+
+/**
+ * Read a protobuf varint as a safe JavaScript number.
+ *
+ * @param {Object} reader MVT byte reader.
+ *
+ * @returns {number} Decoded integer.
+ *
+ * @throws {Error} If the integer exceeds the safe numeric range.
+ */
+export function readMvtNumber(reader) {
+  const value = readMvtInteger(reader);
+  if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw /* alloc */ new Error('MVT integer exceeds safe range');
+  }
+  return Number(value);
+}