@osmix/pbf 0.0.1

package/dist/proto/osmformat.js

@@ -0,0 +1,458 @@
+/**
+ * Reads an `OsmPbfHeaderBlock` message from the provided Pbf reader.
+ */
+export function readHeaderBlock(pbf, end) {
+    return pbf.readFields(readHeaderBlockField, {
+        required_features: [],
+        optional_features: [],
+    }, end);
+}
+/**
+ * Populates header block fields based on the protobuf tag encountered.
+ */
+function readHeaderBlockField(tag, obj, pbf) {
+    if (tag === 1)
+        obj.bbox = readHeaderBBox(pbf, pbf.readVarint() + pbf.pos);
+    else if (tag === 4)
+        obj.required_features.push(pbf.readString());
+    else if (tag === 5)
+        obj.optional_features.push(pbf.readString());
+    else if (tag === 16)
+        obj.writingprogram = pbf.readString();
+    else if (tag === 17)
+        obj.source = pbf.readString();
+    else if (tag === 32)
+        obj.osmosis_replication_timestamp = pbf.readVarint(true);
+    else if (tag === 33) {
+        obj.osmosis_replication_sequence_number = pbf.readVarint(true);
+    }
+    else if (tag === 34)
+        obj.osmosis_replication_base_url = pbf.readString();
+}
+/**
+ * Serializes an `OsmPbfHeaderBlock` message into the Pbf writer.
+ */
+export function writeHeaderBlock(obj, pbf) {
+    if (obj.bbox)
+        pbf.writeMessage(1, writeHeaderBBox, obj.bbox);
+    if (obj.required_features) {
+        for (const item of obj.required_features)
+            pbf.writeStringField(4, item);
+    }
+    if (obj.optional_features) {
+        for (const item of obj.optional_features)
+            pbf.writeStringField(5, item);
+    }
+    if (obj.writingprogram)
+        pbf.writeStringField(16, obj.writingprogram);
+    if (obj.source)
+        pbf.writeStringField(17, obj.source);
+    if (obj.osmosis_replication_timestamp) {
+        pbf.writeVarintField(32, obj.osmosis_replication_timestamp);
+    }
+    if (obj.osmosis_replication_sequence_number) {
+        pbf.writeVarintField(33, obj.osmosis_replication_sequence_number);
+    }
+    if (obj.osmosis_replication_base_url) {
+        pbf.writeStringField(34, obj.osmosis_replication_base_url);
+    }
+}
+/**
+ * Reads a header bounding box and converts nanodegrees to degrees.
+ */
+function readHeaderBBox(pbf, end) {
+    return pbf.readFields(readHeaderBBoxField, { left: 0, right: 0, top: 0, bottom: 0 }, end);
+}
+/**
+ * Populates bounding box properties while converting from nanodegrees.
+ */
+function readHeaderBBoxField(tag, obj, pbf) {
+    if (tag === 1)
+        obj.left = pbf.readSVarint() / 1e9;
+    else if (tag === 2)
+        obj.right = pbf.readSVarint() / 1e9;
+    else if (tag === 3)
+        obj.top = pbf.readSVarint() / 1e9;
+    else if (tag === 4)
+        obj.bottom = pbf.readSVarint() / 1e9;
+}
+/**
+ * Serializes a header bounding box, converting degrees back to nanodegrees.
+ */
+function writeHeaderBBox(obj, pbf) {
+    if (obj.left)
+        pbf.writeSVarintField(1, obj.left * 1e9);
+    if (obj.right)
+        pbf.writeSVarintField(2, obj.right * 1e9);
+    if (obj.top)
+        pbf.writeSVarintField(3, obj.top * 1e9);
+    if (obj.bottom)
+        pbf.writeSVarintField(4, obj.bottom * 1e9);
+}
+/**
+ * Reads a primitive block containing string tables and primitive groups.
+ */
+export function readPrimitiveBlock(pbf, end) {
+    return pbf.readFields(readPrimitiveBlockField, {
+        stringtable: [],
+        primitivegroup: [],
+    }, end);
+}
+/**
+ * Populates primitive block fields based on protobuf tags.
+ */
+function readPrimitiveBlockField(tag, obj, pbf) {
+    if (tag === 1) {
+        obj.stringtable = readStringTable(pbf, pbf.readVarint() + pbf.pos);
+    }
+    else if (tag === 2) {
+        obj.primitivegroup.push(readPrimitiveGroup(pbf, pbf.readVarint() + pbf.pos));
+    }
+    else if (tag === 17) {
+        obj.granularity = pbf.readVarint(true);
+        obj.granularity = !obj.granularity ? 1e7 : 1e9 / obj.granularity;
+    }
+    else if (tag === 19)
+        obj.lat_offset = pbf.readVarint(true) * 1e-9;
+    else if (tag === 20)
+        obj.lon_offset = pbf.readVarint(true) * 1e-9;
+    else if (tag === 18)
+        obj.date_granularity = pbf.readVarint(true) ?? 1000;
+}
+/**
+ * Serializes a primitive block including its string table and primitive groups.
+ */
+export function writePrimitiveBlock(obj, pbf) {
+    if (obj.stringtable)
+        pbf.writeMessage(1, writeStringTable, obj.stringtable);
+    if (obj.primitivegroup) {
+        for (const item of obj.primitivegroup) {
+            pbf.writeMessage(2, writePrimitiveGroup, item);
+        }
+    }
+    if (obj.granularity != null && obj.granularity !== 1e7) {
+        console.error("writeGranularity", obj.granularity);
+        pbf.writeVarintField(17, 1e9 / obj.granularity);
+    }
+    if (obj.lat_offset)
+        pbf.writeVarintField(19, obj.lat_offset / 1e-9);
+    if (obj.lon_offset)
+        pbf.writeVarintField(20, obj.lon_offset / 1e-9);
+    if (obj.date_granularity != null && obj.date_granularity !== 1000) {
+        pbf.writeVarintField(18, obj.date_granularity);
+    }
+}
+/**
+ * Reads a primitive group with collections of primitives.
+ */
+function readPrimitiveGroup(pbf, end) {
+    return pbf.readFields(readPrimitiveGroupField, { nodes: [], ways: [], relations: [] }, end);
+}
+/**
+ * Populates primitive group collections from protobuf data.
+ */
+function readPrimitiveGroupField(tag, obj, pbf) {
+    if (tag === 1)
+        obj.nodes.push(readNode(pbf, pbf.readVarint() + pbf.pos));
+    else if (tag === 2) {
+        obj.dense = readDenseNodes(pbf, pbf.readVarint() + pbf.pos);
+    }
+    else if (tag === 3)
+        obj.ways.push(readWay(pbf, pbf.readVarint() + pbf.pos));
+    else if (tag === 4) {
+        obj.relations.push(readRelation(pbf, pbf.readVarint() + pbf.pos));
+    }
+}
+/**
+ * Serializes a primitive group to protobuf.
+ */
+function writePrimitiveGroup(obj, pbf) {
+    if (obj.nodes) {
+        for (const item of obj.nodes)
+            pbf.writeMessage(1, writeNode, item);
+    }
+    if (obj.dense)
+        pbf.writeMessage(2, writeDenseNodes, obj.dense);
+    if (obj.ways) {
+        for (const item of obj.ways)
+            pbf.writeMessage(3, writeWay, item);
+    }
+    if (obj.relations) {
+        for (const item of obj.relations)
+            pbf.writeMessage(4, writeRelation, item);
+    }
+}
+/**
+ * Reads the shared string table for a primitive block.
+ */
+function readStringTable(pbf, end) {
+    return pbf.readFields(readStringTableField, [], end);
+}
+/**
+ * Appends string table entries as they are encountered.
+ */
+function readStringTableField(tag, obj, pbf) {
+    if (tag === 1)
+        obj.push(pbf.readBytes());
+}
+/**
+ * Serializes string table entries.
+ */
+function writeStringTable(obj, pbf) {
+    if (obj) {
+        for (const item of obj)
+            pbf.writeBytesField(1, item);
+    }
+}
+/**
+ * Reads metadata describing a single primitive.
+ */
+function readInfo(pbf, end) {
+    return pbf.readFields(readInfoField, {}, end);
+}
+/**
+ * Populates primitive metadata fields.
+ */
+function readInfoField(tag, obj, pbf) {
+    if (tag === 1)
+        obj.version = pbf.readVarint(true);
+    else if (tag === 2)
+        obj.timestamp = pbf.readVarint(true);
+    else if (tag === 3)
+        obj.changeset = pbf.readVarint(true);
+    else if (tag === 4)
+        obj.uid = pbf.readVarint(true);
+    else if (tag === 5)
+        obj.user_sid = pbf.readVarint();
+    else if (tag === 6)
+        obj.visible = pbf.readBoolean();
+}
+/**
+ * Serializes primitive metadata fields.
+ */
+function writeInfo(obj, pbf) {
+    if (obj.version != null && obj.version !== -1) {
+        pbf.writeVarintField(1, obj.version);
+    }
+    if (obj.timestamp)
+        pbf.writeVarintField(2, obj.timestamp);
+    if (obj.changeset)
+        pbf.writeVarintField(3, obj.changeset);
+    if (obj.uid)
+        pbf.writeVarintField(4, obj.uid);
+    if (obj.user_sid)
+        pbf.writeVarintField(5, obj.user_sid);
+    if (obj.visible)
+        pbf.writeBooleanField(6, obj.visible);
+}
+/**
+ * Reads dense node metadata collections.
+ */
+function readDenseInfo(pbf, end) {
+    return pbf.readFields(readDenseInfoField, {
+        version: [],
+        timestamp: [],
+        changeset: [],
+        uid: [],
+        user_sid: [],
+        visible: [],
+    }, end);
+}
+/**
+ * Populates dense node metadata arrays from packed fields.
+ */
+function readDenseInfoField(tag, obj, pbf) {
+    if (tag === 1)
+        pbf.readPackedVarint(obj.version, true);
+    else if (tag === 2)
+        pbf.readPackedSVarint(obj.timestamp);
+    else if (tag === 3)
+        pbf.readPackedSVarint(obj.changeset);
+    else if (tag === 4)
+        pbf.readPackedSVarint(obj.uid);
+    else if (tag === 5)
+        pbf.readPackedSVarint(obj.user_sid);
+    else if (tag === 6)
+        pbf.readPackedBoolean(obj.visible);
+}
+/**
+ * Serializes dense node metadata arrays.
+ */
+function writeDenseInfo(obj, pbf) {
+    if (obj.version)
+        pbf.writePackedVarint(1, obj.version);
+    if (obj.timestamp)
+        pbf.writePackedSVarint(2, obj.timestamp);
+    if (obj.changeset)
+        pbf.writePackedSVarint(3, obj.changeset);
+    if (obj.uid)
+        pbf.writePackedSVarint(4, obj.uid);
+    if (obj.user_sid)
+        pbf.writePackedSVarint(5, obj.user_sid);
+    if (obj.visible)
+        pbf.writePackedBoolean(6, obj.visible);
+}
+/**
+ * Reads a node primitive from the protobuf stream.
+ */
+function readNode(pbf, end) {
+    return pbf.readFields(readNodeField, { id: 0, keys: [], vals: [], lat: 0, lon: 0 }, end);
+}
+/**
+ * Populates node fields based on protobuf tags.
+ */
+function readNodeField(tag, obj, pbf) {
+    if (tag === 1)
+        obj.id = pbf.readSVarint();
+    else if (tag === 2)
+        pbf.readPackedVarint(obj.keys);
+    else if (tag === 3)
+        pbf.readPackedVarint(obj.vals);
+    else if (tag === 4)
+        obj.info = readInfo(pbf, pbf.readVarint() + pbf.pos);
+    else if (tag === 8)
+        obj.lat = pbf.readSVarint();
+    else if (tag === 9)
+        obj.lon = pbf.readSVarint();
+}
+/**
+ * Serializes a node primitive to protobuf.
+ */
+function writeNode(obj, pbf) {
+    if (obj.id)
+        pbf.writeSVarintField(1, obj.id);
+    if (obj.keys)
+        pbf.writePackedVarint(2, obj.keys);
+    if (obj.vals)
+        pbf.writePackedVarint(3, obj.vals);
+    if (obj.info)
+        pbf.writeMessage(4, writeInfo, obj.info);
+    if (obj.lat)
+        pbf.writeSVarintField(8, obj.lat);
+    if (obj.lon)
+        pbf.writeSVarintField(9, obj.lon);
+}
+/**
+ * Reads dense node collections from the protobuf stream.
+ */
+function readDenseNodes(pbf, end) {
+    return pbf.readFields(readDenseNodesField, { id: [], lat: [], lon: [], keys_vals: [] }, end);
+}
+/**
+ * Populates dense node arrays using packed encoding.
+ */
+function readDenseNodesField(tag, obj, pbf) {
+    if (tag === 1)
+        pbf.readPackedSVarint(obj.id);
+    else if (tag === 5) {
+        obj.denseinfo = readDenseInfo(pbf, pbf.readVarint() + pbf.pos);
+    }
+    else if (tag === 8)
+        pbf.readPackedSVarint(obj.lat);
+    else if (tag === 9)
+        pbf.readPackedSVarint(obj.lon);
+    else if (tag === 10)
+        pbf.readPackedVarint(obj.keys_vals, true);
+}
+/**
+ * Serializes dense node collections back to protobuf.
+ */
+function writeDenseNodes(obj, pbf) {
+    if (obj.id)
+        pbf.writePackedSVarint(1, obj.id);
+    if (obj.denseinfo)
+        pbf.writeMessage(5, writeDenseInfo, obj.denseinfo);
+    if (obj.lat)
+        pbf.writePackedSVarint(8, obj.lat);
+    if (obj.lon)
+        pbf.writePackedSVarint(9, obj.lon);
+    if (obj.keys_vals)
+        pbf.writePackedVarint(10, obj.keys_vals);
+}
+/**
+ * Reads a way primitive from the protobuf stream.
+ */
+function readWay(pbf, end) {
+    return pbf.readFields(readWayField, { id: 0, keys: [], vals: [], refs: [], lat: [], lon: [] }, end);
+}
+/**
+ * Populates way fields based on protobuf tags.
+ */
+function readWayField(tag, obj, pbf) {
+    if (tag === 1)
+        obj.id = pbf.readVarint(true);
+    else if (tag === 2)
+        pbf.readPackedVarint(obj.keys);
+    else if (tag === 3)
+        pbf.readPackedVarint(obj.vals);
+    else if (tag === 4)
+        obj.info = readInfo(pbf, pbf.readVarint() + pbf.pos);
+    else if (tag === 8)
+        pbf.readPackedSVarint(obj.refs);
+}
+/**
+ * Serializes a way primitive to protobuf.
+ */
+function writeWay(obj, pbf) {
+    if (obj.id)
+        pbf.writeVarintField(1, obj.id);
+    if (obj.keys)
+        pbf.writePackedVarint(2, obj.keys);
+    if (obj.vals)
+        pbf.writePackedVarint(3, obj.vals);
+    if (obj.info)
+        pbf.writeMessage(4, writeInfo, obj.info);
+    if (obj.refs)
+        pbf.writePackedSVarint(8, obj.refs);
+}
+/**
+ * Reads a relation primitive from the protobuf stream.
+ */
+function readRelation(pbf, end) {
+    return pbf.readFields(readRelationField, {
+        id: 0,
+        keys: [],
+        vals: [],
+        roles_sid: [],
+        memids: [],
+        types: [],
+    }, end);
+}
+/**
+ * Populates relation fields based on protobuf tags.
+ */
+function readRelationField(tag, obj, pbf) {
+    if (tag === 1)
+        obj.id = pbf.readVarint(true);
+    else if (tag === 2)
+        pbf.readPackedVarint(obj.keys);
+    else if (tag === 3)
+        pbf.readPackedVarint(obj.vals);
+    else if (tag === 4)
+        obj.info = readInfo(pbf, pbf.readVarint() + pbf.pos);
+    else if (tag === 8)
+        pbf.readPackedVarint(obj.roles_sid, true);
+    else if (tag === 9)
+        pbf.readPackedSVarint(obj.memids);
+    else if (tag === 10)
+        pbf.readPackedVarint(obj.types);
+}
+/**
+ * Serializes a relation primitive to protobuf.
+ */
+function writeRelation(obj, pbf) {
+    if (obj.id)
+        pbf.writeVarintField(1, obj.id);
+    if (obj.keys)
+        pbf.writePackedVarint(2, obj.keys);
+    if (obj.vals)
+        pbf.writePackedVarint(3, obj.vals);
+    if (obj.info)
+        pbf.writeMessage(4, writeInfo, obj.info);
+    if (obj.roles_sid)
+        pbf.writePackedVarint(8, obj.roles_sid);
+    if (obj.memids)
+        pbf.writePackedSVarint(9, obj.memids);
+    if (obj.types)
+        pbf.writePackedVarint(10, obj.types);
+}

package/dist/spec.d.ts

@@ -0,0 +1,5 @@
+export declare const RECOMMENDED_HEADER_SIZE_BYTES: number;
+export declare const MAX_HEADER_SIZE_BYTES: number;
+export declare const RECOMMENDED_BLOB_SIZE_BYTES: number;
+export declare const MAX_BLOB_SIZE_BYTES: number;
+export declare const MAX_ENTITIES_PER_BLOCK = 8000;

package/dist/spec.js

@@ -0,0 +1,9 @@
+// Recommended and maximum header and blob sizes as defined by the OSM PBF specification
+// Header: 32 KiB and 64 KiB
+export const RECOMMENDED_HEADER_SIZE_BYTES = 32 * 1024;
+export const MAX_HEADER_SIZE_BYTES = 64 * 1024;
+// Blob: 16 MiB and 32 MiB
+export const RECOMMENDED_BLOB_SIZE_BYTES = 16 * 1024 * 1024;
+export const MAX_BLOB_SIZE_BYTES = 32 * 1024 * 1024;
+// Recommended maximum number of entities per block
+export const MAX_ENTITIES_PER_BLOCK = 8_000;

package/dist/utils.d.ts

@@ -0,0 +1,27 @@
+export type AsyncGeneratorValue<T> = T | ReadableStream<T> | AsyncGenerator<T> | Promise<T> | Promise<ReadableStream<T>> | Promise<AsyncGenerator<T>>;
+/**
+ * Normalizes values, streams, and iterables into a unified async generator interface.
+ */
+export declare function toAsyncGenerator<T>(v: AsyncGeneratorValue<T>): AsyncGenerator<T>;
+/**
+ * Returns true when executing inside the Bun runtime.
+ */
+export declare function isBun(): boolean;
+/**
+ * Decompresses binary data using runtime-native APIs.
+ * Falls back to Node zlib when running under Bun to match OSM PBF expectations.
+ */
+export declare function decompress(data: Uint8Array): Promise<Uint8Array>;
+/**
+ * Compresses binary data using runtime-native APIs.
+ * Falls back to Node zlib when running under Bun to match OSM PBF expectations.
+ */
+export declare function compress(data: Uint8Array): Promise<Uint8Array>;
+/**
+ * Concatenates multiple `Uint8Array` segments into a contiguous array.
+ */
+export declare function concatUint8(...parts: Uint8Array[]): Uint8Array;
+/**
+ * Encodes a 32-bit big-endian unsigned integer as a four-byte buffer.
+ */
+export declare function uint32BE(n: number): Uint8Array;

package/dist/utils.js

@@ -0,0 +1,92 @@
+import { streamToBytes } from "@osmix/shared/stream-to-bytes";
+/**
+ * Normalizes values, streams, and iterables into a unified async generator interface.
+ */
+export async function* toAsyncGenerator(v) {
+    if (v instanceof Promise)
+        return toAsyncGenerator(await v);
+    if (v == null)
+        throw Error("Value is null");
+    if (v instanceof ReadableStream) {
+        const reader = v.getReader();
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            yield value;
+        }
+        reader.releaseLock();
+    }
+    else if (ArrayBuffer.isView(v) || v instanceof ArrayBuffer) {
+        // Treat ArrayBuffer and TypedArrays (like Uint8Array, Buffer) as single values
+        yield v;
+    }
+    else if (typeof v === "object" &&
+        (Symbol.asyncIterator in v || Symbol.iterator in v)) {
+        return v;
+    }
+    else {
+        yield v;
+    }
+}
+/**
+ * Returns true when executing inside the Bun runtime.
+ */
+export function isBun() {
+    return "Bun" in globalThis;
+}
+/**
+ * Decompresses binary data using runtime-native APIs.
+ * Falls back to Node zlib when running under Bun to match OSM PBF expectations.
+ */
+export async function decompress(data) {
+    // Check if we're in Bun runtime - use Node.js zlib for proper OSM PBF zlib format support
+    if (isBun()) {
+        const { inflateSync } = await import("node:zlib");
+        return new Uint8Array(inflateSync(data));
+    }
+    // Fallback to standard Web API
+    const decompressedStream = new Blob([data])
+        .stream()
+        .pipeThrough(new DecompressionStream("deflate"));
+    return streamToBytes(decompressedStream);
+}
+/**
+ * Compresses binary data using runtime-native APIs.
+ * Falls back to Node zlib when running under Bun to match OSM PBF expectations.
+ */
+export async function compress(data) {
+    // Check if we're in Bun runtime - use Node.js zlib for proper OSM PBF zlib format support
+    if (isBun()) {
+        const { deflateSync } = await import("node:zlib");
+        return new Uint8Array(deflateSync(data));
+    }
+    // Fallback to standard Web API
+    const stream = new CompressionStream("deflate");
+    const compressedStream = new Blob([data]).stream().pipeThrough(stream);
+    return streamToBytes(compressedStream);
+}
+/**
+ * Concatenates multiple `Uint8Array` segments into a contiguous array.
+ */
+export function concatUint8(...parts) {
+    const total = parts.reduce((n, p) => n + p.length, 0);
+    const out = new Uint8Array(total);
+    let offset = 0;
+    for (const p of parts) {
+        out.set(p, offset);
+        offset += p.length;
+    }
+    return out;
+}
+/**
+ * Encodes a 32-bit big-endian unsigned integer as a four-byte buffer.
+ */
+export function uint32BE(n) {
+    const out = new Uint8Array(4);
+    out[0] = (n >>> 24) & 0xff;
+    out[1] = (n >>> 16) & 0xff;
+    out[2] = (n >>> 8) & 0xff;
+    out[3] = n & 0xff;
+    return out;
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+	"$schema": "https://json.schemastore.org/package",
+	"name": "@osmix/pbf",
+	"description": "A low level, modern, runtime agnostic OSM PBF parser and writer written in TypeScript.",
+	"version": "0.0.1",
+	"type": "module",
+	"main": "./src/index.ts",
+	"publishConfig": {
+		"access": "public",
+		"main": "./dist/index.js",
+		"types": "./dist/index.d.ts",
+		"exports": {
+			".": {
+				"import": "./dist/index.js",
+				"types": "./dist/index.d.ts"
+			}
+		},
+		"files": [
+			"dist",
+			"README.md",
+			"LICENSE"
+		]
+	},
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/conveyal/osmix.git"
+	},
+	"homepage": "https://github.com/conveyal/osmix#readme",
+	"bugs": {
+		"url": "https://github.com/conveyal/osmix/issues"
+	},
+	"sideEffects": false,
+	"scripts": {
+		"bench": "vitest bench",
+		"build": "tsc",
+		"test": "vitest",
+		"typecheck": "tsc --noEmit"
+	},
+	"devDependencies": {
+		"@osmix/shared": "workspace:*",
+		"@types/node": "catalog:",
+		"typescript": "catalog:",
+		"vitest": "catalog:"
+	},
+	"dependencies": {
+		"pbf": "catalog:"
+	}
+}

package/src/blobs-to-blocks.ts

@@ -0,0 +1,28 @@
+import Pbf from "pbf"
+import { readHeaderBlock, readPrimitiveBlock } from "./proto/osmformat"
+import { webDecompress } from "./utils"
+
+/**
+ * Decompresses raw OSM PBF blobs and yields typed header and primitive blocks.
+ * Expects the first blob to contain the file header and streams the rest as data blocks.
+ */
+export async function* osmPbfBlobsToBlocksGenerator(
+	blobs:
+		| AsyncGenerator<Uint8Array<ArrayBuffer>>
+		| Generator<Uint8Array<ArrayBuffer>>,
+	decompress: (
+		data: Uint8Array<ArrayBuffer>,
+	) => Promise<Uint8Array<ArrayBuffer>> = webDecompress,
+) {
+	let headerRead = false
+	for await (const blob of blobs) {
+		const decompressedBlob = await decompress(blob)
+		const pbf = new Pbf(decompressedBlob)
+		if (!headerRead) {
+			headerRead = true
+			yield readHeaderBlock(pbf)
+		} else {
+			yield readPrimitiveBlock(pbf)
+		}
+	}
+}