@osmix/pbf 0.0.2 → 0.0.4

package/src/pbf-to-blobs.ts

@@ -7,9 +7,28 @@ import {
 } 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.
+ * Create a stateful parser that extracts compressed blobs from raw PBF bytes.
+ *
+ * OSM PBF files consist of length-prefixed blobs. This function returns a generator
+ * that accumulates incoming byte chunks and yields complete compressed blobs as they
+ * become available. The caller is responsible for decompression.
+ *
+ * The first yielded blob contains the file header; subsequent blobs contain primitive data.
+ *
+ * @returns A generator function that accepts byte chunks and yields compressed blob payloads.
+ *
+ * @example
+ * ```ts
+ * import { createOsmPbfBlobGenerator } from "@osmix/pbf"
+ *
+ * const generateBlobs = createOsmPbfBlobGenerator()
+ *
+ * for await (const chunk of stream) {
+ *   for (const compressedBlob of generateBlobs(chunk)) {
+ *     // Decompress and parse blob...
+ *   }
+ * }
+ * ```
  */
 export function createOsmPbfBlobGenerator() {
 	let pbf: Pbf = new Pbf(new Uint8Array(0))
@@ -19,6 +38,8 @@ export function createOsmPbfBlobGenerator() {
 
 	/**
 	 * Feed the parser with the next chunk of bytes and yield any complete compressed blobs.
+	 * @param chunk - Raw bytes from the PBF file.
+	 * @yields Compressed blob payloads (zlib-compressed protobuf data).
 	 */
 	return function* nextChunk(chunk: Uint8Array) {
 		const currentBuffer: Uint8Array = pbf.buf.slice(pbf.pos)

package/src/pbf-to-blocks.ts

@@ -13,11 +13,37 @@ import {
 	webDecompress,
 } from "./utils"
 
+/** Number of bytes used to encode the BlobHeader length prefix (big-endian uint32). */
 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.
+ * Parse an OSM PBF file from various input sources.
+ *
+ * Accepts `ArrayBuffer`, `Uint8Array`, `ReadableStream<Uint8Array>`, or async generators.
+ * Returns the file header and a lazy async generator of primitive blocks for on-demand parsing.
+ *
+ * @param data - PBF bytes as buffer, stream, or async iterable.
+ * @returns Object with `header` (file metadata) and `blocks` (async generator of primitive blocks).
+ * @throws If the header block is missing or malformed.
+ *
+ * @example
+ * ```ts
+ * import { readOsmPbf } from "@osmix/pbf"
+ *
+ * // From a file stream
+ * const { header, blocks } = await readOsmPbf(Bun.file('./monaco.pbf').stream())
+ *
+ * // From a fetch response
+ * const response = await fetch('/data/monaco.pbf')
+ * const { header, blocks } = await readOsmPbf(response.body!)
+ *
+ * // Iterate blocks lazily
+ * for await (const block of blocks) {
+ *   for (const group of block.primitivegroup) {
+ *     console.log(group.dense?.id.length ?? 0, "dense nodes")
+ *   }
+ * }
+ * ```
  */
 export async function readOsmPbf(
 	data: AsyncGeneratorValue<Uint8Array<ArrayBufferLike>>,
@@ -43,8 +69,24 @@ export async function readOsmPbf(
 }
 
 /**
- * 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.
+ * Web `TransformStream` that decodes raw PBF byte chunks into OSM header and data blocks.
+ *
+ * The first blob in an OSM PBF file is always the header block; subsequent blobs
+ * contain primitive data (nodes, ways, relations). This stream handles the framing,
+ * decompression, and protobuf decoding automatically.
+ *
+ * @example
+ * ```ts
+ * import { OsmPbfBytesToBlocksTransformStream } from "@osmix/pbf"
+ *
+ * const response = await fetch('/data/monaco.pbf')
+ * const blocksStream = response.body!
+ *   .pipeThrough(new OsmPbfBytesToBlocksTransformStream())
+ *
+ * const reader = blocksStream.getReader()
+ * const { value: header } = await reader.read() // First read yields header
+ * // Subsequent reads yield primitive blocks
+ * ```
  */
 export class OsmPbfBytesToBlocksTransformStream extends TransformStream<
 	Uint8Array<ArrayBufferLike>,

package/src/utils.ts

@@ -38,30 +38,12 @@ export async function* toAsyncGenerator<T>(
 	}
 }
 
-/**
- * Returns true when executing inside the Bun runtime.
- */
-export function isBun(): boolean {
-	return "Bun" in globalThis
-}
-
 /**
  * Web decompression stream
  */
 export async function webDecompress(
 	data: Uint8Array<ArrayBuffer>,
 ): Promise<Uint8Array<ArrayBuffer>> {
-	if (isBun()) {
-		// @ts-ignore Only used in Bun runtime.
-		const { inflate } = await import("node:zlib")
-		const result = await new Promise<Uint8Array>((resolve, reject) => {
-			inflate(data, (error: unknown, result: Uint8Array) => {
-				if (error) reject(error)
-				else resolve(new Uint8Array(result))
-			})
-		})
-		return result as unknown as Uint8Array<ArrayBuffer>
-	}
 	return transformBytes(data, new DecompressionStream("deflate"))
 }
 
@@ -71,17 +53,6 @@ export async function webDecompress(
 export async function webCompress(
 	data: Uint8Array<ArrayBuffer>,
 ): Promise<Uint8Array<ArrayBuffer>> {
-	if (isBun()) {
-		// @ts-ignore Only used in Bun runtime.
-		const { deflate } = await import("node:zlib")
-		const result = await new Promise<Uint8Array>((resolve, reject) => {
-			deflate(data, (error: unknown, result: Uint8Array) => {
-				if (error) reject(error)
-				else resolve(new Uint8Array(result))
-			})
-		})
-		return result as unknown as Uint8Array<ArrayBuffer>
-	}
 	return transformBytes(data, new CompressionStream("deflate"))
 }
 

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

@@ -1,4 +1,4 @@
-import { assert, describe, it } from "vitest"
+import { describe, expect, it } from "bun:test"
 import { osmPbfBlobsToBlocksGenerator } from "../src/blobs-to-blocks"
 import { createOsmPbfBlobGenerator } from "../src/pbf-to-blobs"
 import {
@@ -25,32 +25,38 @@ describe("osmPbfBlobsToBlocksGenerator", () => {
 		)
 
 		const { value: headerBlock, done } = await generator.next()
-		assert.isFalse(done)
+		expect(done).toBe(false)
 		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)
-		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: block, done: blockDone } = await generator.next()
-		assert.isFalse(blockDone)
+		expect(blockDone).toBe(false)
 		if (!isPrimitiveBlock(block)) {
-			assert.fail("Expected primitive block")
+			throw new Error("Expected primitive block")
 		}
-		assert.lengthOf(block.primitivegroup, primitiveBlock.primitivegroup.length)
+		expect(block.primitivegroup).toHaveLength(
+			primitiveBlock.primitivegroup.length,
+		)
 		const group = block.primitivegroup[0]
-		assert.exists(primitiveBlock.primitivegroup[0])
-		assert.exists(group?.dense)
-		assert.exists(group?.ways?.[0])
-		assert.lengthOf(group.ways, primitiveBlock.primitivegroup[0].ways.length)
-		assert.deepEqual(
-			group.ways[0].refs,
+		expect(primitiveBlock.primitivegroup[0]).toBeDefined()
+		expect(group?.dense).toBeDefined()
+		expect(group?.ways?.[0]).toBeDefined()
+		if (!group) throw new Error("group is undefined")
+		if (!primitiveBlock.primitivegroup[0])
+			throw new Error("primitiveBlock.primitivegroup[0] is undefined")
+		expect(group.ways).toHaveLength(
+			primitiveBlock.primitivegroup[0].ways.length,
+		)
+		expect(group.ways[0]?.refs).toEqual(
 			primitiveBlock.primitivegroup[0]?.ways?.[0]?.refs,
 		)
 
 		const final = await generator.next()
-		assert.isTrue(final.done)
+		expect(final.done).toBe(true)
 	})
 
 	it("accepts synchronous generators", async () => {
@@ -64,10 +70,10 @@ describe("osmPbfBlobsToBlocksGenerator", () => {
 		)
 
 		const header = await generator.next()
-		assert.isFalse(header.done)
+		expect(header.done).toBe(false)
 		const block = await generator.next()
-		assert.isFalse(block.done)
+		expect(block.done).toBe(false)
 		const final = await generator.next()
-		assert.isTrue(final.done)
+		expect(final.done).toBe(true)
 	})
 })

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/tsconfig.build.json

@@ -0,0 +1,5 @@
+{
+	"$schema": "https://json.schemastore.org/tsconfig",
+	"extends": "./tsconfig.json",
+	"include": ["src"]
+}

package/dist/test/utils.bun.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=utils.bun.test.d.ts.map

package/dist/test/utils.bun.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.bun.test.d.ts","sourceRoot":"","sources":["../../test/utils.bun.test.ts"],"names":[],"mappings":""}