leaflet-city-mapper 0.0.8 → 0.1.0

package/src/models/prepareModel.js

@@ -2,6 +2,16 @@ import { decodeModel } from './decodeModel.js';
 import { loadModelResources } from './loadModelResources.js';
 import { prepareModelGeometry } from './prepareModelGeometry.js';
 
+/**
+ * Fetch a static model and prepare its images and geometry for transfer from a worker.
+ *
+ * @param {string} url Model URL.
+ *
+ * @returns {Promise<Object>} Prepared description, images and transferables.
+ *
+ * @throws {Error} If the model response is not successful.
+ * @throws {Error} If the glTF scene is missing.
+ */
 export async function prepareModel(url) {
   const response = await fetch(url);
   if (!response.ok) throw /* alloc */ new Error(`Unable to load model: HTTP ${response.status}`);

package/src/models/prepareModelGeometry.js

@@ -1,6 +1,16 @@
 import { geometryEmpty } from '../globals/geometryEmpty.js';
 import { prepareModelPrimitive } from './prepareModelPrimitive.js';
 
+/**
+ * Prepare geometry for meshes reachable from the scene and collect their buffers.
+ *
+ * @param {Object} description Decoded glTF document with loaded buffers.
+ * @param {Object} scene glTF scene containing root node indices.
+ *
+ * @returns {Array<ArrayBuffer>} Unique geometry buffers to transfer.
+ *
+ * @throws {Error} If a referenced node is invalid.
+ */
 export function prepareModelGeometry(description, scene) {
   const pending = scene.nodes.slice(), visited = /* alloc */ new Set();
   const meshes = /* alloc */ new Set(), transfers = /* alloc */ new Set();

package/src/models/prepareModelPrimitive.js

@@ -2,6 +2,14 @@ import { readModelAttributes } from './readModelAttributes.js';
 import { readModelIndices } from './readModelIndices.js';
 import { vertexNormals } from '../geometry/vertexNormals.js';
 
+/**
+ * Decode primitive attributes and indices, generating normals when absent.
+ *
+ * @param {Object} description Decoded glTF document with loaded buffers.
+ * @param {Object} primitive glTF mesh primitive to prepare.
+ *
+ * @returns {Object} Prepared attributes, also stored on the primitive.
+ */
 export function prepareModelPrimitive(description, primitive) {
   const { attributes, vertexCount } = readModelAttributes(description, primitive);
   readModelIndices(description, primitive, attributes, vertexCount);

package/src/models/readAccessor.js

@@ -1,13 +1,19 @@
 import { types } from '../globals/types.js';
 import { sizes } from '../globals/sizes.js';
-
-
 import { readAccessorValues } from './readAccessorValues.js';
 import { readSparseAccessor } from './readSparseAccessor.js';
 import { normalizeAccessor } from './normalizeAccessor.js';
 
-/** Decode packed, interleaved, normalized or sparse glTF accessor data. */
-
+/**
+ * Decode packed, interleaved, normalized or sparse glTF accessor data.
+ *
+ * @param {Object} description Decoded glTF document with loaded buffers.
+ * @param {number} index Accessor index.
+ *
+ * @returns {Object} Component data and size, plus original integer data when applicable.
+ *
+ * @throws {Error} If the accessor component type, shape or count is invalid.
+ */
 export function readAccessor(description, index) {
   const spec = description.accessors[index], Type = types[spec.componentType], size = sizes[spec.type];
   if (!Type || !size || !Number.isInteger(spec.count) || spec.count < 0) {

package/src/models/readAccessorValue.js

@@ -1,3 +1,12 @@
+/**
+ * Read one glTF accessor component from a data view using little-endian byte order.
+ *
+ * @param {DataView} input View containing the component.
+ * @param {TypedArrayConstructor} Type Component array constructor.
+ * @param {number} at Byte offset in the view.
+ *
+ * @returns {number} Decoded component.
+ */
 export function readAccessorValue(input, Type, at) {
   return Type === Int8Array ? input.getInt8(at) :
     Type === Uint8Array ? input.getUint8(at) :

package/src/models/readAccessorValues.js

@@ -1,5 +1,22 @@
 import { readAccessorValue } from './readAccessorValue.js';
 
+/**
+ * Copy packed or strided accessor components into an output array, optionally at sparse indices.
+ *
+ * @param {Object} description Decoded glTF document with loaded buffers.
+ * @param {TypedArrayConstructor} Type Component array constructor.
+ * @param {number} size Components per element.
+ * @param {TypedArray} data Destination array.
+ * @param {number} accessorCount Number of elements in the destination accessor.
+ * @param {TypedArray|null} indices Sparse destination indices, or null for sequential output.
+ * @param {number} viewIndex Index of the source buffer view.
+ * @param {number} offset Byte offset within the buffer view.
+ * @param {number} count Number of source elements.
+ * @param {number} stride Byte stride between source elements, or zero for packed data.
+ *
+ * @throws {Error} If data falls outside the buffer view.
+ * @throws {Error} If a sparse index is invalid.
+ */
 export function readAccessorValues(description, Type, size, data, accessorCount, indices, viewIndex, offset, count, stride) {
   const view = description.bufferViews[viewIndex], bytes = Type.BYTES_PER_ELEMENT;
   const buffer = description.buffers[view.buffer].binary;

package/src/models/readModelAttributes.js

@@ -1,6 +1,18 @@
 import { geometrySemantics } from '../globals/geometrySemantics.js';
 import { readAccessor } from './readAccessor.js';
 
+/**
+ * Read supported primitive attributes and validate their vertex counts.
+ *
+ * @param {Object} description Decoded glTF document.
+ * @param {Object} primitive glTF mesh primitive.
+ *
+ * @returns {Object} Attribute map and vertex count.
+ *
+ * @throws {Error} If positions are missing.
+ * @throws {Error} If the position size or vertex count is invalid.
+ * @throws {Error} If attribute vertex counts differ.
+ */
 export function readModelAttributes(description, primitive) {
   const attributes = /* alloc */ {};
   let semantic, name;

package/src/models/readModelIndices.js

@@ -1,5 +1,17 @@
 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);

package/src/models/readSparseAccessor.js

@@ -1,6 +1,18 @@
 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) {

package/src/models/releaseModelResources.js

@@ -1,3 +1,8 @@
+/**
+ * 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) {

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,5 +1,11 @@
 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++) {

package/src/mvt/appendMvtBandTriangles.js

@@ -1,6 +1,17 @@
 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;

package/src/mvt/appendMvtCoordinates.js

@@ -1,3 +1,12 @@
+/**
+ * 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++) {

package/src/mvt/appendMvtPolygonTriangles.js

@@ -2,6 +2,16 @@ 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 {

package/src/mvt/beginMvtPath.js

@@ -1,5 +1,15 @@
 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');

package/src/mvt/closeMvtPath.js

@@ -1,3 +1,12 @@
+/**
+ * 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');

package/src/mvt/collectMvtEdges.js

@@ -1,5 +1,15 @@
 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) {

package/src/mvt/createMvtReader.js

@@ -1,3 +1,10 @@
+/**
+ * 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,

package/src/mvt/decodeVectorTile.js

@@ -8,6 +8,13 @@ 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)) {

package/src/mvt/expectMvtWire.js

@@ -1,3 +1,11 @@
+/**
+ * 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,3 +1,12 @@
+/**
+ * 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,3 +1,10 @@
+/**
+ * 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++) {

package/src/mvt/groupMvtPolygons.js

@@ -1,5 +1,15 @@
 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;

package/src/mvt/isMvtFallbackError.js

@@ -1,3 +1,10 @@
+/**
+ * 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' ||

package/src/mvt/mergeMvtActiveEdges.js

@@ -1,3 +1,12 @@
+/**
+ * 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) {

package/src/mvt/mvtEdgeX.js

@@ -1,3 +1,11 @@
+/**
+ * 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,3 +1,10 @@
+/**
+ * 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;

package/src/mvt/mvtPolygonPaths.js

@@ -1,3 +1,10 @@
+/**
+ * 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;

package/src/mvt/numericMvtValue.js

@@ -1,3 +1,10 @@
+/**
+ * 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

@@ -7,6 +7,18 @@ 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 */ [];

package/src/mvt/readMvtField.js

@@ -1,5 +1,14 @@
 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;

package/src/mvt/readMvtGeometry.js

@@ -3,6 +3,19 @@ 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 };

package/src/mvt/readMvtInteger.js

@@ -1,5 +1,15 @@
 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++) {

package/src/mvt/readMvtKnownValue.js

@@ -4,6 +4,15 @@ 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);

package/src/mvt/readMvtLayer.js

@@ -7,6 +7,15 @@ 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 */ [];

package/src/mvt/readMvtMessage.js

@@ -3,6 +3,14 @@ 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);

package/src/mvt/readMvtNumber.js

@@ -1,5 +1,14 @@
 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)) {

package/src/mvt/readMvtNumbers.js

@@ -1,6 +1,13 @@
 import { readMvtMessage } from './readMvtMessage.js';
 import { readMvtNumber } from './readMvtNumber.js';
 
+/**
+ * Append packed or unpacked protobuf integers to a destination array.
+ *
+ * @param {Object} reader MVT byte reader.
+ * @param {number} wire Protobuf wire type.
+ * @param {Array<number>} target Destination array.
+ */
 export function readMvtNumbers(reader, wire, target) {
   let packed;
   if (wire === 0) target.push(readMvtNumber(reader));

package/src/mvt/readMvtString.js

@@ -1,6 +1,14 @@
 import { mvtTextDecoder } from '../globals/mvtTextDecoder.js';
 import { readMvtMessage } from './readMvtMessage.js';
 
+/**
+ * Decode a length-delimited UTF-8 string.
+ *
+ * @param {Object} reader MVT byte reader.
+ * @param {number} wire Protobuf wire type.
+ *
+ * @returns {string} Decoded string.
+ */
 export function readMvtString(reader, wire) {
   return mvtTextDecoder.decode(readMvtMessage(reader, wire).bytes);
 }