@osmix/pbf 0.0.2 → 0.0.3

package/test/pbf-to-blobs.test.ts

@@ -1,5 +1,5 @@
+import { describe, expect, it } from "bun:test"
 import Pbf from "pbf"
-import { assert, describe, it } from "vitest"
 import { osmPbfBlobsToBlocksGenerator } from "../src/blobs-to-blocks"
 import { createOsmPbfBlobGenerator } from "../src/pbf-to-blobs"
 import { writeBlob, writeBlobHeader } from "../src/proto/fileformat"
@@ -30,7 +30,7 @@ describe("createOsmPbfBlobGenerator", () => {
 			for (const blob of generate(fileBytes.slice(offset))) yielded.push(blob)
 		}
 
-		assert.equal(yielded.length, 2)
+		expect(yielded.length).toBe(2)
 
 		const blocks = osmPbfBlobsToBlocksGenerator(
 			(async function* () {
@@ -38,29 +38,35 @@ describe("createOsmPbfBlobGenerator", () => {
 			})(),
 		)
 		const { value: headerBlock, done } = await blocks.next()
-		assert.isFalse(done)
+		expect(done).toBe(false)
 		if (!isHeaderBlock(headerBlock)) {
-			assert.fail("Expected first block to be a header")
+			throw new Error("Expected first block to be a header")
 		}
-		assert.deepEqual(headerBlock.bbox, header.bbox)
-		assert.deepEqual(headerBlock.required_features, header.required_features)
-		assert.deepEqual(headerBlock.optional_features, header.optional_features)
+		expect(headerBlock.bbox).toEqual(header.bbox)
+		expect(headerBlock.required_features).toEqual(header.required_features)
+		expect(headerBlock.optional_features).toEqual(header.optional_features)
 
 		const { value: primitive } = await blocks.next()
 		if (!isPrimitiveBlock(primitive)) {
-			assert.fail("Expected primitive block after header")
+			throw new Error("Expected primitive block after header")
 		}
-		assert.lengthOf(
-			primitive.primitivegroup,
+		expect(primitive.primitivegroup).toHaveLength(
 			primitiveBlock.primitivegroup.length,
 		)
-		assert.exists(primitive.primitivegroup[0])
-		assert.exists(primitiveBlock.primitivegroup[0])
+		expect(primitive.primitivegroup[0]).toBeDefined()
+		expect(primitiveBlock.primitivegroup[0]).toBeDefined()
+		if (!primitive.primitivegroup[0])
+			throw new Error("primitive.primitivegroup[0] is undefined")
+		if (!primitiveBlock.primitivegroup[0])
+			throw new Error("primitiveBlock.primitivegroup[0] is undefined")
 		const dense = primitive.primitivegroup[0].dense
-		assert.exists(dense)
-		assert.deepEqual(dense?.id, primitiveBlock.primitivegroup[0].dense?.id)
-		assert.deepEqual(dense?.lat, primitiveBlock.primitivegroup[0].dense?.lat)
-		assert.deepEqual(dense?.lon, primitiveBlock.primitivegroup[0].dense?.lon)
+		expect(dense).toBeDefined()
+		if (!dense) throw new Error("dense is undefined")
+		if (!primitiveBlock.primitivegroup[0]?.dense)
+			throw new Error("primitiveBlock.primitivegroup[0].dense is undefined")
+		expect(dense.id).toEqual(primitiveBlock.primitivegroup[0].dense.id)
+		expect(dense.lat).toEqual(primitiveBlock.primitivegroup[0].dense.lat)
+		expect(dense.lon).toEqual(primitiveBlock.primitivegroup[0].dense.lon)
 	})
 
 	it("throws when a blob omits zlib data", () => {
@@ -80,6 +86,6 @@ describe("createOsmPbfBlobGenerator", () => {
 		const chunk = concatUint8(uint32BE(blobHeader.byteLength), blobHeader, blob)
 		const generate = createOsmPbfBlobGenerator()
 		const iterator = generate(chunk)
-		assert.throws(() => iterator.next(), /Blob has no zlib data/)
+		expect(() => iterator.next()).toThrow(/Blob has no zlib data/)
 	})
 })

package/test/read.bench.ts

@@ -1,9 +1,13 @@
+import { beforeAll, describe, expect } from "bun:test"
 import {
 	getFixtureFile,
 	getFixtureFileReadStream,
 	PBFs,
 } from "@osmix/shared/test/fixtures"
-import { assert, beforeAll, bench, describe } from "vitest"
+
+// @ts-expect-error - bench is available at runtime but not in types
+const { bench } = globalThis as { bench: typeof import("bun:test").test }
+
 import {
 	OsmPbfBytesToBlocksTransformStream,
 	readOsmPbf,
@@ -35,8 +39,8 @@ describe.each(Object.entries(PBFs))("%s", (_name, pbf) => {
 				}),
 			)
 
-		assert.equal(count.nodes, pbf.nodes)
-		assert.equal(count.ways, pbf.ways)
-		assert.equal(count.relations, pbf.relations)
+		expect(count.nodes).toBe(pbf.nodes)
+		expect(count.ways).toBe(pbf.ways)
+		expect(count.relations).toBe(pbf.relations)
 	})
 })

package/test/read.test.ts

@@ -1,9 +1,9 @@
+import { beforeAll, describe, expect, it } from "bun:test"
 import {
 	getFixtureFile,
 	getFixtureFileReadStream,
 	PBFs,
 } from "@osmix/shared/test/fixtures"
-import { assert, beforeAll, describe, it } from "vitest"
 import {
 	OsmPbfBytesToBlocksTransformStream,
 	readOsmPbf,
@@ -25,15 +25,15 @@ describe("read", () => {
 							if ("primitivegroup" in block) {
 								for (const group of block.primitivegroup) onGroup(group)
 							} else {
-								assert.deepEqual(block.bbox, pbf.bbox)
+								expect(block.bbox).toEqual(pbf.bbox)
 							}
 						},
 					}),
 				)
 
-			assert.equal(count.nodes, pbf.nodes)
-			assert.equal(count.ways, pbf.ways)
-			assert.equal(count.relations, pbf.relations)
+			expect(count.nodes).toBe(pbf.nodes)
+			expect(count.ways).toBe(pbf.ways)
+			expect(count.relations).toBe(pbf.relations)
 		})
 
 		it("from buffer", async () => {

package/test/streams.test.ts

@@ -1,4 +1,4 @@
-import { assert, describe, expect, it } from "vitest"
+import { describe, expect, it } from "bun:test"
 import { OsmBlocksToPbfBytesTransformStream } from "../src/blocks-to-pbf"
 import { OsmPbfBytesToBlocksTransformStream } from "../src/pbf-to-blocks"
 import { concatUint8 } from "../src/utils"
@@ -46,13 +46,13 @@ describe("transform streams", () => {
 			}),
 		)
 
-		assert.deepEqual(concatUint8(...chunks), fileBytes)
+		expect(concatUint8(...chunks)).toEqual(fileBytes)
 	})
 
 	it("parses streamed bytes back into header and primitive blocks", async () => {
 		const { header, primitiveBlock, fileBytes } =
 			await createSamplePbfFileBytes()
-		assert.exists(primitiveBlock.primitivegroup[0])
+		expect(primitiveBlock.primitivegroup[0]).toBeDefined()
 		const blocks: unknown[] = []
 
 		const input = new ReadableStream({
@@ -71,22 +71,31 @@ describe("transform streams", () => {
 			}),
 		)
 
-		assert.equal(blocks.length, 2)
+		expect(blocks.length).toBe(2)
 		const headerBlock = blocks[0]
 		if (!isHeaderBlock(headerBlock)) {
-			assert.fail("Expected header block")
+			throw new Error("Expected header block")
 		}
-		assert.deepEqual(headerBlock.bbox, header.bbox)
-		assert.deepEqual(headerBlock.required_features, header.required_features)
+		expect(headerBlock.bbox).toEqual(header.bbox)
+		expect(headerBlock.required_features).toEqual(header.required_features)
 		const block = blocks[1]
 		if (!isPrimitiveBlock(block)) {
-			assert.fail("Expected primitive block")
+			throw new Error("Expected primitive block")
 		}
-		assert.lengthOf(block.primitivegroup, primitiveBlock.primitivegroup.length)
-		assert.exists(block.primitivegroup)
-		assert.exists(block.primitivegroup[0])
+		expect(block.primitivegroup).toHaveLength(
+			primitiveBlock.primitivegroup.length,
+		)
+		expect(block.primitivegroup).toBeDefined()
+		expect(block.primitivegroup[0]).toBeDefined()
+		if (!block.primitivegroup[0])
+			throw new Error("block.primitivegroup[0] is undefined")
+		if (!primitiveBlock.primitivegroup[0])
+			throw new Error("primitiveBlock.primitivegroup[0] is undefined")
 		const dense = block.primitivegroup[0].dense
-		assert.exists(dense)
-		assert.deepEqual(dense.id, primitiveBlock.primitivegroup[0].dense?.id)
+		expect(dense).toBeDefined()
+		if (!dense) throw new Error("dense is undefined")
+		if (!primitiveBlock.primitivegroup[0]?.dense)
+			throw new Error("primitiveBlock.primitivegroup[0].dense is undefined")
+		expect(dense.id).toEqual(primitiveBlock.primitivegroup[0].dense.id)
 	})
 })

package/test/utils.test.ts

@@ -1,4 +1,4 @@
-import { assert, describe, expect, it } from "vitest"
+import { describe, expect, it } from "bun:test"
 import {
 	concatUint8,
 	toAsyncGenerator,
@@ -11,9 +11,9 @@ describe("utils", () => {
 	it("wraps values into an async generator", async () => {
 		const generator = toAsyncGenerator(3)
 		const first = await generator.next()
-		assert.deepEqual(first, { value: 3, done: false })
+		expect(first).toEqual({ value: 3, done: false })
 		const done = await generator.next()
-		assert.deepEqual(done, { value: undefined, done: true })
+		expect(done).toEqual({ value: undefined, done: true })
 	})
 
 	it("consumes readable streams", async () => {
@@ -26,7 +26,7 @@ describe("utils", () => {
 		})
 		const values: number[] = []
 		for await (const value of toAsyncGenerator(stream)) values.push(value)
-		assert.deepEqual(values, [1, 2])
+		expect(values).toEqual([1, 2])
 	})
 
 	it("throws on nullish inputs", async () => {
@@ -39,18 +39,18 @@ describe("utils", () => {
 	it("concatenates Uint8Array segments", () => {
 		const a = Uint8Array.of(1, 2)
 		const b = Uint8Array.of(3)
-		assert.deepEqual(concatUint8(a, b), Uint8Array.of(1, 2, 3))
+		expect(concatUint8(a, b)).toEqual(Uint8Array.of(1, 2, 3))
 	})
 
 	it("encodes big-endian 32-bit integers", () => {
-		assert.deepEqual(uint32BE(0x01020304), Uint8Array.of(1, 2, 3, 4))
+		expect(uint32BE(0x01020304)).toEqual(Uint8Array.of(1, 2, 3, 4))
 	})
 
 	it("compresses and decompresses data", async () => {
 		const input = new TextEncoder().encode("osmix") as Uint8Array<ArrayBuffer>
 		const compressed = await webCompress(input)
-		assert.notDeepEqual(compressed, input)
+		expect(compressed).not.toEqual(input)
 		const decompressed = await webDecompress(compressed)
-		assert.deepEqual(decompressed, input)
+		expect(decompressed).toEqual(input)
 	})
 })

package/test/utils.ts

@@ -1,5 +1,5 @@
+import { expect } from "bun:test"
 import type { PbfFixture } from "@osmix/shared/test/fixtures"
-import { assert } from "vitest"
 import type {
 	OsmPbfBlock,
 	OsmPbfGroup,
@@ -13,18 +13,18 @@ export async function testOsmPbfReader(
 	},
 	pbf: PbfFixture,
 ) {
-	assert.deepEqual(osm.header.bbox, pbf.bbox)
+	expect(osm.header.bbox).toEqual(pbf.bbox)
 
 	const { onGroup, count } = createOsmEntityCounter()
 	for await (const block of osm.blocks)
 		for (const group of block.primitivegroup) onGroup(group)
 
-	assert.equal(count.nodes, pbf.nodes)
-	assert.equal(count.ways, pbf.ways)
-	assert.equal(count.relations, pbf.relations)
-	assert.equal(count.node0, pbf.node0.id)
-	assert.equal(count.way0, pbf.way0)
-	assert.equal(count.relation0, pbf.relation0)
+	expect(count.nodes).toBe(pbf.nodes)
+	expect(count.ways).toBe(pbf.ways)
+	expect(count.relations).toBe(pbf.relations)
+	expect(count.node0).toBe(pbf.node0.id)
+	expect(count.way0).toBe(pbf.way0)
+	expect(count.relation0).toBe(pbf.relation0)
 
 	return count
 }

package/test/write.test.ts

@@ -1,3 +1,4 @@
+import { describe, expect, it } from "bun:test"
 import { unlink } from "node:fs/promises"
 import {
 	getFixtureFile,
@@ -6,7 +7,6 @@ import {
 	getFixturePath,
 	PBFs,
 } from "@osmix/shared/test/fixtures"
-import { assert, describe, it } from "vitest"
 import {
 	OsmBlocksToPbfBytesTransformStream,
 	osmBlockToPbfBlobBytes,
@@ -53,15 +53,20 @@ describe("write", () => {
 			}
 
 			// Re-parse the new PBF and test
-			assert.exists(data.buffer)
-			// TODO: assert.equal(stream.buffer.byteLength, fileData.byteLength)
+			expect(data.buffer).toBeDefined()
+			// Note: We don't assert byte-level equality because the written PBF may have
+			// different compression, block ordering, or encoding than the original file.
+			// Semantic equivalence (verified by parsing and comparing entities) is more meaningful.
 			const osm2 = await readOsmPbf(data)
 
-			assert.deepEqual(osm.header, osm2.header)
+			expect(osm.header).toEqual(osm2.header)
 			const entities = await testOsmPbfReader(osm2, pbf)
-			assert.equal(entities.node0, node0)
-			assert.equal(entities.way0, way0)
-			assert.equal(entities.relation0, relation0)
+			if (node0 === null || way0 === null || relation0 === null) {
+				throw new Error("Expected node0, way0, and relation0 to be set")
+			}
+			expect(entities.node0).toBe(node0)
+			expect(entities.way0).toBe(way0)
+			expect(entities.relation0).toBe(relation0)
 		})
 
 		it("to file", async () => {
@@ -77,7 +82,7 @@ describe("write", () => {
 			const testFileData = await getFixtureFile(pbf.url)
 			const testOsm = await readOsmPbf(testFileData)
 
-			assert.deepEqual(testOsm.header.bbox, pbf.bbox)
+			expect(testOsm.header.bbox).toEqual(pbf.bbox)
 			await testOsmPbfReader(testOsm, pbf)
 
 			await unlink(getFixturePath(testFileName))

package/dist/blobs-to-blocks.d.ts

@@ -1,5 +0,0 @@
-/**
- * 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 declare function osmPbfBlobsToBlocksGenerator(blobs: AsyncGenerator<Uint8Array<ArrayBuffer>> | Generator<Uint8Array<ArrayBuffer>>): AsyncGenerator<import(".").OsmPbfHeaderBlock | import(".").OsmPbfBlock, void, unknown>;

package/dist/blobs-to-blocks.js

@@ -1,21 +0,0 @@
-import Pbf from "pbf";
-import { readHeaderBlock, readPrimitiveBlock } from "./proto/osmformat";
-import { decompress } 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) {
-    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);
-        }
-    }
-}

package/dist/blocks-to-pbf.d.ts

@@ -1,16 +0,0 @@
-import type { OsmPbfBlock, OsmPbfHeaderBlock } from "./proto/osmformat";
-/**
- * Serializes a header or primitive block into a spec-compliant compressed blob.
- * Automatically sets the blob type, compresses the payload, and enforces size guardrails.
- * @param block - Parsed header or primitive block to encode.
- * @returns BlobHeader length prefix + Blob bytes as a single Uint8Array.
- */
-export declare function osmBlockToPbfBlobBytes(block: OsmPbfBlock | OsmPbfHeaderBlock): Promise<Uint8Array<ArrayBufferLike>>;
-/**
- * Web `TransformStream` that converts OSM header/data blocks into PBF byte chunks.
- * Throws if the header is not the first block and reuses `osmBlockToPbfBlobBytes` for encoding.
- */
-export declare class OsmBlocksToPbfBytesTransformStream extends TransformStream<OsmPbfHeaderBlock | OsmPbfBlock, Uint8Array> {
-    headerEnqueued: boolean;
-    constructor();
-}

package/dist/blocks-to-pbf.js

@@ -1,73 +0,0 @@
-import Pbf from "pbf";
-import { writeBlob, writeBlobHeader } from "./proto/fileformat";
-import { writeHeaderBlock, writePrimitiveBlock } from "./proto/osmformat";
-import { MAX_BLOB_SIZE_BYTES, MAX_HEADER_SIZE_BYTES, RECOMMENDED_BLOB_SIZE_BYTES, RECOMMENDED_HEADER_SIZE_BYTES, } from "./spec";
-import { compress, concatUint8, uint32BE } from "./utils";
-/**
- * Serializes a header or primitive block into a spec-compliant compressed blob.
- * Automatically sets the blob type, compresses the payload, and enforces size guardrails.
- * @param block - Parsed header or primitive block to encode.
- * @returns BlobHeader length prefix + Blob bytes as a single Uint8Array.
- */
-export async function osmBlockToPbfBlobBytes(block) {
-    const contentPbf = new Pbf();
-    let type;
-    if ("primitivegroup" in block) {
-        type = "OSMData";
-        writePrimitiveBlock(block, contentPbf);
-    }
-    else {
-        type = "OSMHeader";
-        writeHeaderBlock(block, contentPbf);
-    }
-    const contentData = contentPbf.finish();
-    const raw_size = contentData.length;
-    const compressedBuffer = await compress(contentData);
-    const blobPbf = new Pbf();
-    writeBlob({
-        raw_size,
-        zlib_data: compressedBuffer,
-    }, blobPbf);
-    const blob = blobPbf.finish();
-    const blobHeaderPbf = new Pbf();
-    writeBlobHeader({
-        type,
-        datasize: blob.length,
-    }, blobHeaderPbf);
-    const blobHeader = blobHeaderPbf.finish();
-    const blobHeaderSize = uint32BE(blobHeader.byteLength);
-    // Check the BlobHeader and Blob sizes, log error if over the recommended size, throw error if over the maximum size
-    if (blobHeader.byteLength > RECOMMENDED_HEADER_SIZE_BYTES) {
-        const sizeKiB = (blobHeader.byteLength / 1024).toFixed(2);
-        if (blobHeader.byteLength > MAX_HEADER_SIZE_BYTES) {
-            throw new Error(`BlobHeader is ${sizeKiB} KiB, the maximum size is 64KiB`);
-        }
-        console.warn(`BlobHeader is ${sizeKiB} KiB, the recommended size is 32KiB`);
-    }
-    if (blob.byteLength > RECOMMENDED_BLOB_SIZE_BYTES) {
-        const sizeMiB = (blob.byteLength / 1024 / 1024).toFixed(2);
-        if (blob.byteLength > MAX_BLOB_SIZE_BYTES) {
-            throw new Error(`Blob is ${sizeMiB} MiB, the maximum size is 32MiB`);
-        }
-        console.warn(`Blob is ${sizeMiB} MiB, the recommended size is 16MiB`);
-    }
-    return concatUint8(blobHeaderSize, blobHeader, blob);
-}
-/**
- * Web `TransformStream` that converts OSM header/data blocks into PBF byte chunks.
- * Throws if the header is not the first block and reuses `osmBlockToPbfBlobBytes` for encoding.
- */
-export class OsmBlocksToPbfBytesTransformStream extends TransformStream {
-    headerEnqueued = false;
-    constructor() {
-        super({
-            transform: async (block, controller) => {
-                if ("primitivegroup" in block && !this.headerEnqueued) {
-                    throw Error("Header first in ReadableStream of blocks.");
-                }
-                this.headerEnqueued = true;
-                controller.enqueue(await osmBlockToPbfBlobBytes(block));
-            },
-        });
-    }
-}

package/dist/index.d.ts

@@ -1,8 +0,0 @@
-export * from "./blobs-to-blocks";
-export * from "./blocks-to-pbf";
-export * from "./pbf-to-blobs";
-export * from "./pbf-to-blocks";
-export * from "./proto/fileformat";
-export * from "./proto/osmformat";
-export * from "./spec";
-export * from "./utils";

package/dist/index.js

@@ -1,8 +0,0 @@
-export * from "./blobs-to-blocks";
-export * from "./blocks-to-pbf";
-export * from "./pbf-to-blobs";
-export * from "./pbf-to-blocks";
-export * from "./proto/fileformat";
-export * from "./proto/osmformat";
-export * from "./spec";
-export * from "./utils";

package/dist/pbf-to-blobs.d.ts

@@ -1,6 +0,0 @@
-/**
- * Creates a stateful parser that slices incoming bytes into compressed OSM PBF blobs.
- * Works with buffers, iterables, or streams and yields `Uint8Array` payloads ready to decompress.
- * The first blob represents the file header; subsequent blobs hold primitive data.
- */
-export declare function createOsmPbfBlobGenerator(): (chunk: Uint8Array) => Generator<Uint8Array<ArrayBuffer>, void, unknown>;

package/dist/pbf-to-blobs.js

@@ -1,48 +0,0 @@
-import Pbf from "pbf";
-import { HEADER_LENGTH_BYTES } from "./pbf-to-blocks";
-import { readBlob, readBlobHeader, } from "./proto/fileformat";
-/**
- * Creates a stateful parser that slices incoming bytes into compressed OSM PBF blobs.
- * Works with buffers, iterables, or streams and yields `Uint8Array` payloads ready to decompress.
- * The first blob represents the file header; subsequent blobs hold primitive data.
- */
-export function createOsmPbfBlobGenerator() {
-    let pbf = new Pbf(new Uint8Array(0));
-    let state = "header-length";
-    let bytesNeeded = HEADER_LENGTH_BYTES;
-    let blobHeader = null;
-    /**
-     * Feed the parser with the next chunk of bytes and yield any complete compressed blobs.
-     */
-    return function* nextChunk(chunk) {
-        const currentBuffer = pbf.buf.slice(pbf.pos);
-        const tmpBuffer = new Uint8Array(currentBuffer.buffer.byteLength + chunk.byteLength);
-        tmpBuffer.set(currentBuffer.subarray(0));
-        tmpBuffer.set(new Uint8Array(chunk), currentBuffer.byteLength);
-        pbf = new Pbf(tmpBuffer);
-        while (pbf.pos + bytesNeeded <= pbf.length) {
-            if (state === "header-length") {
-                const dataView = new DataView(pbf.buf.buffer);
-                bytesNeeded = dataView.getInt32(pbf.pos, false); // network byte order
-                pbf.pos += HEADER_LENGTH_BYTES;
-                state = "header";
-            }
-            else if (state === "header") {
-                blobHeader = readBlobHeader(pbf, pbf.pos + bytesNeeded);
-                bytesNeeded = blobHeader.datasize;
-                state = "blob";
-            }
-            else if (state === "blob") {
-                if (blobHeader == null)
-                    throw Error("Blob header has not been read");
-                const blob = readBlob(pbf, pbf.pos + bytesNeeded);
-                if (blob.zlib_data === undefined || blob.zlib_data.length === 0)
-                    throw Error("Blob has no zlib data. Format is unsupported.");
-                yield blob.zlib_data;
-                state = "header-length";
-                bytesNeeded = HEADER_LENGTH_BYTES;
-                blobHeader = null;
-            }
-        }
-    };
-}

package/dist/pbf-to-blocks.d.ts

@@ -1,20 +0,0 @@
-import { type OsmPbfBlock, type OsmPbfHeaderBlock } from "./proto/osmformat";
-import { type AsyncGeneratorValue } from "./utils";
-export declare const HEADER_LENGTH_BYTES = 4;
-/**
- * Parses OSM PBF bytes from buffers, streams, or generators into header + block iterators.
- * Returns the decoded header and a lazy async generator of primitive blocks.
- */
-export declare function readOsmPbf(data: AsyncGeneratorValue<ArrayBufferLike>): Promise<{
-    header: OsmPbfHeaderBlock;
-    blocks: AsyncGenerator<OsmPbfBlock>;
-}>;
-/**
- * Web `TransformStream` that turns raw PBF byte chunks into OSM header/data blocks.
- * Assumes the first decoded blob carries the header and emits it before any primitive blocks.
- */
-export declare class OsmPbfBytesToBlocksTransformStream extends TransformStream<ArrayBufferLike, OsmPbfHeaderBlock | OsmPbfBlock> {
-    generateBlobsFromChunk: (chunk: Uint8Array) => Generator<Uint8Array<ArrayBuffer>, void, unknown>;
-    header: OsmPbfHeaderBlock | null;
-    constructor();
-}

package/dist/pbf-to-blocks.js

@@ -1,53 +0,0 @@
-import Pbf from "pbf";
-import { osmPbfBlobsToBlocksGenerator } from "./blobs-to-blocks";
-import { createOsmPbfBlobGenerator } from "./pbf-to-blobs";
-import { readHeaderBlock, readPrimitiveBlock, } from "./proto/osmformat";
-import { decompress, toAsyncGenerator } from "./utils";
-export const HEADER_LENGTH_BYTES = 4;
-/**
- * Parses OSM PBF bytes from buffers, streams, or generators into header + block iterators.
- * Returns the decoded header and a lazy async generator of primitive blocks.
- */
-export async function readOsmPbf(data) {
-    const generateBlobsFromChunk = createOsmPbfBlobGenerator();
-    const blocks = osmPbfBlobsToBlocksGenerator((async function* () {
-        for await (const chunk of toAsyncGenerator(data)) {
-            for await (const blob of generateBlobsFromChunk(new Uint8Array(chunk))) {
-                yield blob;
-            }
-        }
-    })());
-    const header = (await blocks.next()).value;
-    if (header == null || !("required_features" in header)) {
-        throw Error("OSM PBF header block not found");
-    }
-    return {
-        header,
-        blocks: blocks,
-    };
-}
-/**
- * Web `TransformStream` that turns raw PBF byte chunks into OSM header/data blocks.
- * Assumes the first decoded blob carries the header and emits it before any primitive blocks.
- */
-export class OsmPbfBytesToBlocksTransformStream extends TransformStream {
-    generateBlobsFromChunk = createOsmPbfBlobGenerator();
-    header = null;
-    constructor() {
-        super({
-            transform: async (bytesChunk, controller) => {
-                for await (const rawBlobs of this.generateBlobsFromChunk(new Uint8Array(bytesChunk))) {
-                    const decompressed = await decompress(rawBlobs);
-                    const pbf = new Pbf(decompressed);
-                    if (this.header == null) {
-                        this.header = readHeaderBlock(pbf);
-                        controller.enqueue(this.header);
-                    }
-                    else {
-                        controller.enqueue(readPrimitiveBlock(pbf));
-                    }
-                }
-            },
-        });
-    }
-}

package/dist/proto/fileformat.d.ts

@@ -1,26 +0,0 @@
-import type Pbf from "pbf";
-export type OsmPbfBlob = {
-    raw_size?: number;
-    raw?: Uint8Array;
-    zlib_data?: Uint8Array;
-};
-export type OsmPbfBlobHeader = {
-    type: "OSMHeader" | "OSMData";
-    datasize: number;
-};
-/**
- * Reads an `OsmPbfBlob` message from the current position in the Pbf reader.
- */
-export declare function readBlob(pbf: Pbf, end?: number): OsmPbfBlob;
-/**
- * Writes an `OsmPbfBlob` message to the provided Pbf writer.
- */
-export declare function writeBlob(obj: OsmPbfBlob, pbf: Pbf): void;
-/**
- * Reads an `OsmPbfBlobHeader` from the current position in the Pbf reader.
- */
-export declare function readBlobHeader(pbf: Pbf, end?: number): OsmPbfBlobHeader;
-/**
- * Writes an `OsmPbfBlobHeader` message to the provided Pbf writer.
- */
-export declare function writeBlobHeader(obj: OsmPbfBlobHeader, pbf: Pbf): void;