@osmix/pbf 0.0.7 → 0.0.8

package/CHANGELOG.md

@@ -0,0 +1,49 @@
+# @osmix/pbf
+
+## 0.0.8
+
+### Patch Changes
+
+- 2a634cb: Fix publishing
+
+## 0.0.7
+
+### Patch Changes
+
+- 3c8ee95: Fix and simplify package exports
+
+## 0.0.6
+
+### Patch Changes
+
+- f32e4ee: General cleanup
+
+## 0.0.5
+
+### Patch Changes
+
+- f468db5: Fix publishing (2)
+
+## 0.0.4
+
+### Patch Changes
+
+- 68d6bd8: Fix publishing for packages.
+
+## 0.0.3
+
+### Patch Changes
+
+- d001d9a: Refactor to align around new main external API
+
+## 0.0.2
+
+### Patch Changes
+
+- 33d9c12: Modify types to take Uint8Array<ArrayBufferLike> for compatiblity
+
+## 0.0.1
+
+### Patch Changes
+
+- Initial release

package/package.json

@@ -1,51 +1,28 @@
 {
-	"$schema": "https://json.schemastore.org/package",
+	"$schema": "https://json.schemastore.org/package.json",
 	"name": "@osmix/pbf",
 	"description": "A low level, modern, runtime agnostic OSM PBF parser and writer written in TypeScript.",
-	"version": "0.0.7",
+	"version": "0.0.8",
 	"type": "module",
-	"publishConfig": {
-		"access": "public"
-	},
 	"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,
+	"main": "./dist/index.js",
 	"scripts": {
 		"bench": "bun test --bench",
 		"build": "tsc -p tsconfig.build.json",
-		"prepare": "bun run build",
-		"release": "bun publish",
 		"test": "bun test",
 		"typecheck": "tsgo --noEmit"
 	},
 	"devDependencies": {
-		"@osmix/shared": "workspace:*",
-		"@types/bun": "catalog:",
-		"typescript": "catalog:"
+		"@osmix/shared": "0.0.12",
+		"@types/bun": "^1.3.9",
+		"typescript": "^5.9.0"
 	},
 	"dependencies": {
-		"pbf": "catalog:"
-	},
-	"types": "./dist/index.d.ts",
-	"exports": {
-		".": {
-			"types": "./src/index.ts",
-			"bun": "./src/index.ts",
-			"development|production": "./src/index.ts",
-			"default": "./dist/index.js"
-		}
+		"pbf": "^4.0.1"
 	},
-	"files": [
-		"dist",
-		"src",
-		"README.md",
-		"LICENSE"
-	]
-}
+	"types": "./dist/index.d.ts"
+}

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

@@ -0,0 +1,79 @@
+import { describe, expect, it } from "bun:test"
+import { osmPbfBlobsToBlocksGenerator } from "../src/blobs-to-blocks"
+import { createOsmPbfBlobGenerator } from "../src/pbf-to-blobs"
+import {
+	createSamplePbfFileBytes,
+	isHeaderBlock,
+	isPrimitiveBlock,
+} from "./helpers"
+
+describe("osmPbfBlobsToBlocksGenerator", () => {
+	it("consumes asynchronous blob sources", async () => {
+		const { header, primitiveBlock, fileBytes } =
+			await createSamplePbfFileBytes()
+		const collectBlobs = createOsmPbfBlobGenerator()
+		const blobs: Uint8Array<ArrayBuffer>[] = []
+		for (const blob of collectBlobs(fileBytes)) blobs.push(blob)
+
+		const generator = osmPbfBlobsToBlocksGenerator(
+			(async function* () {
+				for (const blob of blobs) {
+					await Promise.resolve()
+					yield blob
+				}
+			})(),
+		)
+
+		const { value: headerBlock, done } = await generator.next()
+		expect(done).toBe(false)
+		if (!isHeaderBlock(headerBlock)) {
+			throw new Error("Expected header block")
+		}
+		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()
+		expect(blockDone).toBe(false)
+		if (!isPrimitiveBlock(block)) {
+			throw new Error("Expected primitive block")
+		}
+		expect(block.primitivegroup).toHaveLength(
+			primitiveBlock.primitivegroup.length,
+		)
+		const group = block.primitivegroup[0]
+		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()
+		expect(final.done).toBe(true)
+	})
+
+	it("accepts synchronous generators", async () => {
+		const { fileBytes } = await createSamplePbfFileBytes()
+		const collectBlobs = createOsmPbfBlobGenerator()
+		const blobs = [...collectBlobs(fileBytes)]
+		const generator = osmPbfBlobsToBlocksGenerator(
+			(function* () {
+				for (const blob of blobs) yield blob
+			})(),
+		)
+
+		const header = await generator.next()
+		expect(header.done).toBe(false)
+		const block = await generator.next()
+		expect(block.done).toBe(false)
+		const final = await generator.next()
+		expect(final.done).toBe(true)
+	})
+})

package/test/helpers.ts

@@ -0,0 +1,66 @@
+import { osmBlockToPbfBlobBytes } from "../src/blocks-to-pbf"
+import type { OsmPbfBlock, OsmPbfHeaderBlock } from "../src/proto/osmformat"
+import { concatUint8 } from "../src/utils"
+
+const encoder = new TextEncoder()
+
+export function createSampleHeader(): OsmPbfHeaderBlock {
+	return {
+		bbox: { left: 0, right: 1, top: 1, bottom: 0 },
+		required_features: ["OsmSchema-V0.6"],
+		optional_features: ["DenseNodes"],
+		writingprogram: "osmix-tests",
+	}
+}
+
+export function createSamplePrimitiveBlock(): OsmPbfBlock {
+	return {
+		stringtable: [
+			encoder.encode(""),
+			encoder.encode("name"),
+			encoder.encode("value"),
+		],
+		primitivegroup: [
+			{
+				nodes: [],
+				dense: {
+					id: [1, 2],
+					lat: [1_000, 500],
+					lon: [1_500, 600],
+					keys_vals: [1, 2, 0],
+				},
+				ways: [
+					{
+						id: 10,
+						keys: [1],
+						vals: [2],
+						refs: [1, 1, 0],
+					},
+				],
+				relations: [],
+			},
+		],
+	} as const
+}
+
+export async function createSamplePbfFileBytes() {
+	const header = createSampleHeader()
+	const primitiveBlock = createSamplePrimitiveBlock()
+	const headerBytes = await osmBlockToPbfBlobBytes(header)
+	const primitiveBytes = await osmBlockToPbfBlobBytes(primitiveBlock)
+	return {
+		header,
+		primitiveBlock,
+		fileBytes: concatUint8(headerBytes, primitiveBytes),
+	}
+}
+
+export function isHeaderBlock(value: unknown): value is OsmPbfHeaderBlock {
+	return (
+		typeof value === "object" && value != null && "required_features" in value
+	)
+}
+
+export function isPrimitiveBlock(value: unknown): value is OsmPbfBlock {
+	return typeof value === "object" && value != null && "primitivegroup" in value
+}

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

@@ -0,0 +1,91 @@
+import { describe, expect, it } from "bun:test"
+import Pbf from "pbf"
+import { osmPbfBlobsToBlocksGenerator } from "../src/blobs-to-blocks"
+import { createOsmPbfBlobGenerator } from "../src/pbf-to-blobs"
+import { writeBlob, writeBlobHeader } from "../src/proto/fileformat"
+import { writeHeaderBlock } from "../src/proto/osmformat"
+import { concatUint8, uint32BE } from "../src/utils"
+import {
+	createSampleHeader,
+	createSamplePbfFileBytes,
+	isHeaderBlock,
+	isPrimitiveBlock,
+} from "./helpers"
+
+describe("createOsmPbfBlobGenerator", () => {
+	it("yields compressed blobs across fragmented chunks", async () => {
+		const { header, primitiveBlock, fileBytes } =
+			await createSamplePbfFileBytes()
+		const generate = createOsmPbfBlobGenerator()
+		const yielded: Uint8Array<ArrayBuffer>[] = []
+
+		let offset = 0
+		const chunkSizes = [1, 9]
+		for (const size of chunkSizes) {
+			const chunk = fileBytes.slice(offset, offset + size)
+			offset += size
+			for (const blob of generate(chunk)) yielded.push(blob)
+		}
+		if (offset < fileBytes.length) {
+			for (const blob of generate(fileBytes.slice(offset))) yielded.push(blob)
+		}
+
+		expect(yielded.length).toBe(2)
+
+		const blocks = osmPbfBlobsToBlocksGenerator(
+			(async function* () {
+				for (const blob of yielded) yield blob
+			})(),
+		)
+		const { value: headerBlock, done } = await blocks.next()
+		expect(done).toBe(false)
+		if (!isHeaderBlock(headerBlock)) {
+			throw new Error("Expected first block to be a header")
+		}
+		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)) {
+			throw new Error("Expected primitive block after header")
+		}
+		expect(primitive.primitivegroup).toHaveLength(
+			primitiveBlock.primitivegroup.length,
+		)
+		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
+		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", () => {
+		const headerBlock = createSampleHeader()
+		const headerPbf = new Pbf()
+		writeHeaderBlock(headerBlock, headerPbf)
+		const headerContent = headerPbf.finish()
+
+		const blobPbf = new Pbf()
+		writeBlob({ raw_size: headerContent.length, raw: headerContent }, blobPbf)
+		const blob = blobPbf.finish()
+
+		const blobHeaderPbf = new Pbf()
+		writeBlobHeader({ type: "OSMHeader", datasize: blob.length }, blobHeaderPbf)
+		const blobHeader = blobHeaderPbf.finish()
+
+		const chunk = concatUint8(uint32BE(blobHeader.byteLength), blobHeader, blob)
+		const generate = createOsmPbfBlobGenerator()
+		const iterator = generate(chunk)
+		expect(() => iterator.next()).toThrow(/Blob has no zlib data/)
+	})
+})

package/test/read.bench.ts

@@ -0,0 +1,46 @@
+import { beforeAll, describe, expect } from "bun:test"
+import {
+	getFixtureFile,
+	getFixtureFileReadStream,
+	PBFs,
+} from "@osmix/shared/fixtures"
+
+// @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,
+} from "../src/pbf-to-blocks"
+import { createOsmEntityCounter, testOsmPbfReader } from "../src/utils"
+
+describe.each(Object.entries(PBFs))("%s", (_name, pbf) => {
+	beforeAll(() => getFixtureFile(pbf.url))
+
+	bench("parse with generators", async () => {
+		const file = await getFixtureFile(pbf.url)
+		const osm = await readOsmPbf(file)
+
+		await testOsmPbfReader(osm, pbf)
+	})
+
+	bench("parse streaming", async () => {
+		const { onGroup, count } = createOsmEntityCounter()
+
+		await getFixtureFileReadStream(pbf.url)
+			.pipeThrough(new OsmPbfBytesToBlocksTransformStream())
+			.pipeTo(
+				new WritableStream({
+					write: (block) => {
+						if ("primitivegroup" in block) {
+							for (const group of block.primitivegroup) onGroup(group)
+						}
+					},
+				}),
+			)
+
+		expect(count.nodes).toBe(pbf.nodes)
+		expect(count.ways).toBe(pbf.ways)
+		expect(count.relations).toBe(pbf.relations)
+	})
+})

package/test/read.test.ts

@@ -0,0 +1,45 @@
+import { beforeAll, describe, expect, it } from "bun:test"
+import {
+	getFixtureFile,
+	getFixtureFileReadStream,
+	PBFs,
+} from "@osmix/shared/fixtures"
+import {
+	OsmPbfBytesToBlocksTransformStream,
+	readOsmPbf,
+} from "../src/pbf-to-blocks"
+import { createOsmEntityCounter, testOsmPbfReader } from "../src/utils"
+
+describe("read", () => {
+	describe.each(Object.entries(PBFs))("%s", async (_name, pbf) => {
+		beforeAll(() => getFixtureFile(pbf.url))
+
+		it("from stream", async () => {
+			const { onGroup, count } = createOsmEntityCounter()
+
+			await getFixtureFileReadStream(pbf.url)
+				.pipeThrough(new OsmPbfBytesToBlocksTransformStream())
+				.pipeTo(
+					new WritableStream({
+						write: (block) => {
+							if ("primitivegroup" in block) {
+								for (const group of block.primitivegroup) onGroup(group)
+							} else {
+								expect(block.bbox).toEqual(pbf.bbox)
+							}
+						},
+					}),
+				)
+
+			expect(count.nodes).toBe(pbf.nodes)
+			expect(count.ways).toBe(pbf.ways)
+			expect(count.relations).toBe(pbf.relations)
+		})
+
+		it("from buffer", async () => {
+			const fileData = await getFixtureFile(pbf.url)
+			const osm = await readOsmPbf(fileData)
+			await testOsmPbfReader(osm, pbf)
+		})
+	})
+})

package/test/streams.test.ts

@@ -0,0 +1,101 @@
+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"
+import {
+	createSamplePbfFileBytes,
+	createSamplePrimitiveBlock,
+	isHeaderBlock,
+	isPrimitiveBlock,
+} from "./helpers"
+
+describe("transform streams", () => {
+	it("requires the header to be written before data blocks", async () => {
+		const input = new ReadableStream({
+			start(controller) {
+				controller.enqueue(createSamplePrimitiveBlock())
+				controller.close()
+			},
+		})
+
+		await expect(
+			input
+				.pipeThrough(new OsmBlocksToPbfBytesTransformStream())
+				.pipeTo(new WritableStream()),
+		).rejects.toThrow("Header first in ReadableStream of blocks.")
+	})
+
+	it("serialises blocks into the expected PBF byte sequence", async () => {
+		const { header, primitiveBlock, fileBytes } =
+			await createSamplePbfFileBytes()
+		const chunks: Uint8Array[] = []
+
+		const input = new ReadableStream({
+			start(controller) {
+				controller.enqueue(header)
+				controller.enqueue(primitiveBlock)
+				controller.close()
+			},
+		})
+
+		await input.pipeThrough(new OsmBlocksToPbfBytesTransformStream()).pipeTo(
+			new WritableStream<Uint8Array>({
+				write(chunk) {
+					chunks.push(chunk)
+				},
+			}),
+		)
+
+		expect(concatUint8(...chunks)).toEqual(fileBytes)
+	})
+
+	it("parses streamed bytes back into header and primitive blocks", async () => {
+		const { header, primitiveBlock, fileBytes } =
+			await createSamplePbfFileBytes()
+		expect(primitiveBlock.primitivegroup[0]).toBeDefined()
+		const blocks: unknown[] = []
+
+		const input = new ReadableStream({
+			start(controller) {
+				controller.enqueue(fileBytes.slice(0, 7).buffer)
+				controller.enqueue(fileBytes.slice(7).buffer)
+				controller.close()
+			},
+		})
+
+		await input.pipeThrough(new OsmPbfBytesToBlocksTransformStream()).pipeTo(
+			new WritableStream({
+				write(chunk) {
+					blocks.push(chunk)
+				},
+			}),
+		)
+
+		expect(blocks.length).toBe(2)
+		const headerBlock = blocks[0]
+		if (!isHeaderBlock(headerBlock)) {
+			throw new Error("Expected header block")
+		}
+		expect(headerBlock.bbox).toEqual(header.bbox)
+		expect(headerBlock.required_features).toEqual(header.required_features)
+		const block = blocks[1]
+		if (!isPrimitiveBlock(block)) {
+			throw new Error("Expected primitive block")
+		}
+		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
+		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

@@ -0,0 +1,56 @@
+import { describe, expect, it } from "bun:test"
+import {
+	concatUint8,
+	toAsyncGenerator,
+	uint32BE,
+	webCompress,
+	webDecompress,
+} from "../src/utils"
+
+describe("utils", () => {
+	it("wraps values into an async generator", async () => {
+		const generator = toAsyncGenerator(3)
+		const first = await generator.next()
+		expect(first).toEqual({ value: 3, done: false })
+		const done = await generator.next()
+		expect(done).toEqual({ value: undefined, done: true })
+	})
+
+	it("consumes readable streams", async () => {
+		const stream = new ReadableStream<number>({
+			start(controller) {
+				controller.enqueue(1)
+				controller.enqueue(2)
+				controller.close()
+			},
+		})
+		const values: number[] = []
+		for await (const value of toAsyncGenerator(stream)) values.push(value)
+		expect(values).toEqual([1, 2])
+	})
+
+	it("throws on nullish inputs", async () => {
+		const invalidInput = null as unknown as never
+		await expect(toAsyncGenerator(invalidInput).next()).rejects.toThrow(
+			"Value is null",
+		)
+	})
+
+	it("concatenates Uint8Array segments", () => {
+		const a = Uint8Array.of(1, 2)
+		const b = Uint8Array.of(3)
+		expect(concatUint8(a, b)).toEqual(Uint8Array.of(1, 2, 3))
+	})
+
+	it("encodes big-endian 32-bit integers", () => {
+		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)
+		expect(compressed).not.toEqual(input)
+		const decompressed = await webDecompress(compressed)
+		expect(decompressed).toEqual(input)
+	})
+})

package/test/write.test.ts

@@ -0,0 +1,91 @@
+import { describe, expect, it } from "bun:test"
+import { unlink } from "node:fs/promises"
+import {
+	getFixtureFile,
+	getFixtureFileReadStream,
+	getFixtureFileWriteStream,
+	getFixturePath,
+	PBFs,
+} from "@osmix/shared/fixtures"
+import {
+	OsmBlocksToPbfBytesTransformStream,
+	osmBlockToPbfBlobBytes,
+} from "../src/blocks-to-pbf"
+import {
+	OsmPbfBytesToBlocksTransformStream,
+	readOsmPbf,
+} from "../src/pbf-to-blocks"
+import { testOsmPbfReader } from "../src/utils"
+
+describe("write", () => {
+	describe.each(Object.entries(PBFs))("%s", (name, pbf) => {
+		it("to buffer", async () => {
+			const fileData = await getFixtureFile(pbf.url)
+			const osm = await readOsmPbf(fileData)
+
+			let node0: number | null = null
+			let way0: number | null = null
+			let relation0: number | null = null
+
+			// Write the PBF to an array buffer
+			let data = new Uint8Array(0)
+			const write = (chunk: Uint8Array) => {
+				const newData = new Uint8Array(data.length + chunk.length)
+				newData.set(data)
+				newData.set(chunk, data.length)
+				data = newData
+			}
+
+			write(await osmBlockToPbfBlobBytes(osm.header))
+			for await (const block of osm.blocks) {
+				for (const group of block.primitivegroup) {
+					if (node0 == null && group.dense?.id?.[0] != null) {
+						node0 = group.dense.id[0]
+					}
+					if (way0 == null && group.ways?.[0]?.id != null) {
+						way0 = group.ways[0].id
+					}
+					if (relation0 == null && group.relations?.[0]?.id != null) {
+						relation0 = group.relations[0].id
+					}
+				}
+				write(await osmBlockToPbfBlobBytes(block))
+			}
+
+			// Re-parse the new PBF and test
+			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)
+
+			expect(osm.header).toEqual(osm2.header)
+			const entities = await testOsmPbfReader(osm2, pbf)
+			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 () => {
+			const testFileName = `${name}-write-test.pbf`
+			const fileStream = getFixtureFileReadStream(pbf.url)
+
+			const fileWriteStream = getFixtureFileWriteStream(testFileName)
+			await fileStream
+				.pipeThrough(new OsmPbfBytesToBlocksTransformStream())
+				.pipeThrough(new OsmBlocksToPbfBytesTransformStream())
+				.pipeTo(fileWriteStream)
+
+			const testFileData = await getFixtureFile(pbf.url)
+			const testOsm = await readOsmPbf(testFileData)
+
+			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/tsconfig.json

@@ -0,0 +1,9 @@
+{
+	"$schema": "https://json.schemastore.org/tsconfig",
+	"extends": "@osmix/shared/tsconfig/base.json",
+	"exclude": ["node_modules", "dist"],
+	"include": ["src", "test"],
+	"compilerOptions": {
+		"outDir": "./dist"
+	}
+}