@osmix/vt 0.0.1

package/CHANGELOG.md

@@ -0,0 +1,10 @@
+# @osmix/vt
+
+## 0.0.1
+
+### Patch Changes
+
+- Initial release
+- Updated dependencies
+  - @osmix/json@0.0.1
+  - @osmix/shared@0.0.1

package/README.md

@@ -0,0 +1,95 @@
+# @osmix/vt
+
+`@osmix/vt` converts Osmix binary overlays (typed-array node and way payloads) into Mapbox Vector Tiles. It also ships a lightweight tile index with LRU caching so workers or web apps can request tiles on demand without re-projecting data for every request.
+
+## Installation
+
+```sh
+npm install @osmix/vt
+```
+
+## Usage
+
+### Encode a single vector tile from an Osmix dataset
+
+```ts
+import { Osmix } from "@osmix/core"
+import { OsmixVtEncoder } from "@osmix/vt"
+
+// Load or build an Osmix dataset (indexed nodes/ways/relations)
+const osm = await Osmix.fromPbf(fetch("/fixtures/monaco.pbf").then((r) => r.arrayBuffer()))
+
+// Create an encoder. Defaults: extent=4096, buffer=64px
+const encoder = new OsmixVtEncoder(osm)
+
+// XYZ tile tuple: [x, y, z]
+const tile: [number, number, number] = [9372, 12535, 15]
+
+// Returns an ArrayBuffer containing an MVT PBF for two layers:
+// "@osmix:<id>:ways" and "@osmix:<id>:nodes"
+const pbfBuffer = encoder.getTile(tile)
+
+// Persist or send somewhere
+await Deno.writeFile("tile.mvt", new Uint8Array(pbfBuffer))
+```
+
+### Custom bounding box and projection
+
+If you already have a WGS84 bbox and a lon/lat → tile-pixel projection, you can render directly:
+
+```ts
+import { OsmixVtEncoder, projectToTile } from "@osmix/vt"
+
+const encoder = new OsmixVtEncoder(osm, 4096, 64)
+const bbox: [number, number, number, number] = [-73.99, 40.73, -73.98, 40.74]
+const proj = projectToTile([9372, 12535, 15], 4096)
+
+const pbf = encoder.getTileForBbox(bbox, proj)
+```
+
+### Displaying in a browser (manual Blob URL)
+
+Most viewers expect tile URLs. For quick inspection, you can create a Blob URL for a single tile:
+
+```ts
+const buf = encoder.getTile([9372, 12535, 15])
+const url = URL.createObjectURL(new Blob([buf], { type: "application/x-protobuf" }))
+// Use `url` anywhere a single MVT URL is accepted (debug tooling, downloads, etc.)
+```
+
+For full map integration, serve tiles from a handler that calls `getTile([x,y,z])` and returns the bytes. MapLibre/Mapbox GL can then point a `vector` source at `https://your-host/tiles/{z}/{x}/{y}.mvt`.
+
+## What gets encoded
+
+- Ways become LINE features; AREA-like ways (per `wayIsArea`) become POLYGON features.
+- Nodes with tags become POINT features. Untagged nodes are skipped.
+- Each feature includes properties `{ type: "node" | "way", ...tags }` and `id`.
+- Two layers are emitted per tile: `@osmix:<datasetId>:ways` and `@osmix:<datasetId>:nodes`.
+
+## API overview
+
+- `class OsmixVtEncoder(osmix: Osmix, extent=4096, buffer=64)`
+  - `getTile(tile: [x, y, z]): ArrayBuffer` – Encodes a tile using internal bbox/projection.
+  - `getTileForBbox(bbox, proj): ArrayBuffer` – Encode for a WGS84 bbox with a lon/lat → tile-pixel projector.
+  - Internals expose generators for `nodeFeatures` and `wayFeatures` if you need to post-process.
+- `projectToTile(tile: [x, y, z], extent=4096): (lonLat) => [x, y]` – Helper to build a projector matching the encoder.
+- Types (from `src/types.ts`):
+  - `VtSimpleFeature` – `{ id, type, properties, geometry }`
+  - `VtPbfLayer` – `{ name, version, extent, features }`
+
+## Environment and limitations
+
+- Designed for modern runtimes (Node 20+, Bun, browser workers). Uses typed arrays throughout.
+- Polygon handling currently assumes a single outer ring; holes/multi-polygons (relations) are not encoded in v0.0.1.
+- Ways are clipped to tile bounds; nodes outside the tile are omitted.
+- Extent defaults to 4096; set a larger extent if you need higher precision.
+
+### Tags and metadata
+
+- Feature properties include the OSM tags available in the source dataset. Styling keys can be derived at ingestion time; for very large tag sets consider pre-filtering to a stable subset to keep tile size reasonable.
+
+## See also
+
+- `@osmix/core` – In-memory index used to source node/way geometry.
+- `@osmix/json` – Supplies `wayIsArea` heuristics and entity types used by the encoder.
+- `@osmix/raster` – If you prefer raster previews or a protocol helper for MapLibre.

package/package.json

@@ -0,0 +1,50 @@
+{
+	"$schema": "https://json.schemastore.org/package",
+	"name": "@osmix/vt",
+	"type": "module",
+	"version": "0.0.1",
+	"description": "Encode Osmix binary overlay tiles directly into Mapbox Vector Tiles",
+	"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": {
+		"build": "tsc",
+		"test": "vitest",
+		"typecheck": "tsc --noEmit"
+	},
+	"dependencies": {
+		"@osmix/shared": "workspace:*",
+		"@osmix/json": "workspace:*",
+		"pbf": "catalog:"
+	},
+	"devDependencies": {
+		"@mapbox/vector-tile": "^2.0.4",
+		"@osmix/core": "workspace:*",
+		"typescript": "catalog:",
+		"vitest": "catalog:"
+	}
+}

package/src/encode.test.ts

@@ -0,0 +1,104 @@
+import { VectorTile } from "@mapbox/vector-tile"
+import { Osmix } from "@osmix/core"
+import SphericalMercatorTile from "@osmix/shared/spherical-mercator"
+import type { GeoBbox2D, Tile } from "@osmix/shared/types"
+import Protobuf from "pbf"
+import { assert, describe, expect, it } from "vitest"
+import { OsmixVtEncoder } from "./encode"
+
+const osm = new Osmix()
+osm.nodes.addNode({
+	id: 1,
+	lat: 40,
+	lon: -74,
+	tags: {
+		name: "Test Node",
+	},
+})
+
+// Add nodes for way
+osm.nodes.addNode({
+	id: 2,
+	lat: 40.72,
+	lon: -74.01,
+})
+
+osm.nodes.addNode({
+	id: 3,
+	lat: 40.715,
+	lon: -74.005,
+})
+
+osm.nodes.addNode({
+	id: 4,
+	lat: 40.7122,
+	lon: -74.001,
+})
+
+osm.ways.addWay({
+	id: 5,
+	refs: [1, 2],
+})
+osm.buildIndexes()
+osm.buildSpatialIndexes()
+
+const WAY_LAYER_ID = `@osmix:${osm.id}:ways`
+const NODE_LAYER_ID = `@osmix:${osm.id}:nodes`
+
+function decodeTile(data: ArrayBuffer) {
+	const tile = new VectorTile(new Protobuf(data))
+	return tile.layers
+}
+
+const extent = 4096
+const merc = new SphericalMercatorTile({ size: extent })
+
+function pointToTile(lon: number, lat: number, z: number): Tile {
+	const [px, py] = merc.px([lon, lat], z)
+	const x = Math.floor(px / extent)
+	const y = Math.floor(py / extent)
+	return [x, y, z]
+}
+function bboxToTile(bbox: GeoBbox2D, z = 8): Tile {
+	const [minX, minY, maxX, maxY] = bbox
+	const centerLon = (minX + maxX) / 2
+	const centerLat = (minY + maxY) / 2
+	return pointToTile(centerLon, centerLat, z)
+}
+
+describe("OsmixVtEncoder", () => {
+	it("encodes nodes and ways with expected metadata", () => {
+		const bbox = osm.bbox()
+		const tile = bboxToTile(bbox)
+		const encoder = new OsmixVtEncoder(osm)
+		const result = encoder.getTile(tile)
+
+		expect(result.byteLength).toBeGreaterThan(0)
+
+		const layers = decodeTile(result)
+		assert.isDefined(layers[NODE_LAYER_ID])
+		expect(layers[NODE_LAYER_ID].length).toBe(1)
+		assert.isDefined(layers[WAY_LAYER_ID])
+		expect(layers[WAY_LAYER_ID].length).toBe(1)
+
+		const features = [
+			layers[NODE_LAYER_ID].feature(0),
+			layers[WAY_LAYER_ID].feature(0),
+		]
+
+		const node = features.find(
+			(feature) => feature.properties["type"] === "node",
+		)
+		expect(node?.id).toBe(1)
+		expect(node?.type).toBe(1)
+		const nodeGeom = node?.loadGeometry()
+		expect(nodeGeom?.[0]?.[0]?.x).toBeTypeOf("number")
+		expect(nodeGeom?.[0]?.[0]?.y).toBeTypeOf("number")
+
+		const way = features.find((feature) => feature.properties["type"] === "way")
+		expect(way?.id).toBe(5)
+		expect(way?.type).toBe(2)
+		const wayGeom = way?.loadGeometry()
+		expect(wayGeom?.[0]?.length).toBeGreaterThanOrEqual(2)
+	})
+})

package/src/encode.ts

@@ -0,0 +1,240 @@
+import type { Osmix } from "@osmix/core"
+import { wayIsArea } from "@osmix/json"
+import { clipPolygon, clipPolyline } from "@osmix/shared/lineclip"
+import SphericalMercatorTile from "@osmix/shared/spherical-mercator"
+import type { GeoBbox2D, LonLat, Tile, XY } from "@osmix/shared/types"
+import type {
+	VtSimpleFeature,
+	VtSimpleFeatureGeometry,
+	VtSimpleFeatureType,
+} from "./types"
+import writeVtPbf from "./write-vt-pbf"
+
+const DEFAULT_EXTENT = 4096
+const DEFAULT_BUFFER = 64
+
+const SF_TYPE: VtSimpleFeatureType = {
+	POINT: 1,
+	LINE: 2,
+	POLYGON: 3,
+}
+
+const clamp = (value: number, min: number, max: number) =>
+	Math.min(Math.max(value, min), max)
+
+function dedupePoints(points: XY[]): XY[] {
+	if (points.length < 2) return points
+	const result: XY[] = []
+	let lastPoint: XY = [Number.NaN, Number.NaN]
+	for (const point of points) {
+		if (point[0] === lastPoint[0] && point[1] === lastPoint[1]) continue
+		result.push(point)
+		lastPoint = point
+	}
+	return result
+}
+
+export function projectToTile(
+	tile: Tile,
+	extent = DEFAULT_EXTENT,
+): (ll: LonLat) => XY {
+	const sm = new SphericalMercatorTile({ size: extent, tile })
+	return (lonLat) => sm.llToTilePx(lonLat)
+}
+
+export class OsmixVtEncoder {
+	private readonly nodeLayerName: string
+	private readonly wayLayerName: string
+	private readonly osmix: Osmix
+	private readonly extent: number
+	private readonly extentBbox: [number, number, number, number]
+
+	constructor(osmix: Osmix, extent = DEFAULT_EXTENT, buffer = DEFAULT_BUFFER) {
+		this.osmix = osmix
+
+		const min = -buffer
+		const max = extent + buffer
+		this.extent = extent
+		this.extentBbox = [min, min, max, max]
+
+		const layerName = `@osmix:${osmix.id}`
+		this.nodeLayerName = `${layerName}:nodes`
+		this.wayLayerName = `${layerName}:ways`
+	}
+
+	getTile(tile: Tile): ArrayBuffer {
+		const sm = new SphericalMercatorTile({ size: this.extent, tile })
+		// const proj = projectToTile(tile, this.extent)
+		const bbox = sm.bbox(tile[0], tile[1], tile[2]) as GeoBbox2D
+		return this.getTileForBbox(bbox, (ll) => sm.llToTilePx(ll))
+	}
+
+	getTileForBbox(bbox: GeoBbox2D, proj: (ll: LonLat) => XY): ArrayBuffer {
+		const layer = writeVtPbf([
+			{
+				name: this.wayLayerName,
+				version: 2,
+				extent: this.extent,
+				features: this.wayFeatures(bbox, proj),
+			},
+			{
+				name: this.nodeLayerName,
+				version: 2,
+				extent: this.extent,
+				features: this.nodeFeatures(bbox, proj),
+			},
+		])
+		return layer
+	}
+
+	*nodeFeatures(
+		bbox: GeoBbox2D,
+		proj: (ll: LonLat) => XY,
+	): Generator<VtSimpleFeature> {
+		const nodeIndexes = this.osmix.nodes.withinBbox(bbox)
+		for (let i = 0; i < nodeIndexes.length; i++) {
+			const nodeIndex = nodeIndexes[i]
+			if (nodeIndex === undefined) continue
+			const tags = this.osmix.nodes.tags.getTags(nodeIndex)
+			if (!tags || Object.keys(tags).length === 0) continue
+			const id = this.osmix.nodes.ids.at(nodeIndex)
+			const ll = this.osmix.nodes.getNodeLonLat({ index: nodeIndex })
+			yield {
+				id,
+				type: SF_TYPE.POINT,
+				properties: { type: "node", ...tags },
+				geometry: [[proj(ll)]],
+			}
+		}
+	}
+
+	*wayFeatures(
+		bbox: GeoBbox2D,
+		proj: (ll: LonLat) => XY,
+	): Generator<VtSimpleFeature> {
+		const wayIndexes = this.osmix.ways.intersects(bbox)
+		for (let i = 0; i < wayIndexes.length; i++) {
+			const wayIndex = wayIndexes[i]
+			if (wayIndex === undefined) continue
+			const id = this.osmix.ways.ids.at(wayIndex)
+			const tags = this.osmix.ways.tags.getTags(wayIndex)
+			const count = this.osmix.ways.refCount.at(wayIndex)
+			const start = this.osmix.ways.refStart.at(wayIndex)
+			const points: XY[] = new Array(count)
+			for (let i = 0; i < count; i++) {
+				const ref = this.osmix.ways.refs.at(start + i)
+				const ll = this.osmix.nodes.getNodeLonLat({ id: ref })
+				points[i] = proj(ll)
+			}
+			const isArea = wayIsArea({ id, refs: new Array(count).fill(0), tags })
+			const geometry: VtSimpleFeatureGeometry = []
+			if (isArea) {
+				// 1. clip polygon in tile coords
+				const clippedPoly = this.clipProjectedPolygon(points)
+				// clipProjectedPolygon currently returns XY[], not XY[][]
+				// i.e. assumes single ring. We'll treat it as one ring.
+
+				// 2. round/clamp, dedupe, close, orient
+				const processedRing = this.processClippedPolygonRing(clippedPoly)
+
+				// TODO handle MultiPolygons with holes
+
+				if (processedRing.length > 0) {
+					geometry.push(processedRing)
+				}
+			} else {
+				const clippedSegmentsRaw = this.clipProjectedPolyline(points)
+				for (const segment of clippedSegmentsRaw) {
+					const rounded = segment.map((xy) => this.clampAndRoundPoint(xy))
+					const deduped = dedupePoints(rounded)
+					if (deduped.length >= 2) {
+						geometry.push(deduped)
+					}
+				}
+			}
+			if (geometry.length === 0) continue
+			yield {
+				id,
+				type: isArea ? SF_TYPE.POLYGON : SF_TYPE.LINE,
+				properties: { type: "way", ...tags },
+				geometry,
+			}
+		}
+	}
+
+	clipProjectedPolyline(points: XY[]): XY[][] {
+		return clipPolyline(points, this.extentBbox)
+	}
+
+	clipProjectedPolygon(points: XY[]): XY[] {
+		return clipPolygon(points, this.extentBbox)
+	}
+
+	processClippedPolygonRing(rawRing: XY[]): XY[] {
+		// 1. round & clamp EVERY point
+		const snapped = rawRing.map((xy) => this.clampAndRoundPoint(xy))
+
+		// 2. clean (dedupe + close + min length)
+		const cleaned = cleanRing(snapped)
+		if (cleaned.length === 0) return []
+
+		// 3. enforce clockwise for outer ring
+		const oriented = ensureClockwise(cleaned)
+
+		return oriented
+	}
+
+	clampAndRoundPoint(xy: XY): XY {
+		const clampedX = Math.round(
+			clamp(xy[0], this.extentBbox[0], this.extentBbox[2]),
+		)
+		const clampedY = Math.round(
+			clamp(xy[1], this.extentBbox[1], this.extentBbox[3]),
+		)
+		return [clampedX, clampedY] as XY
+	}
+}
+
+function closeRing(ring: XY[]): XY[] {
+	const first = ring[0]
+	const last = ring[ring.length - 1]
+	if (first === undefined || last === undefined) return ring
+	if (first[0] !== last[0] || first[1] !== last[1]) {
+		return [...ring, first]
+	}
+	return ring
+}
+
+// Signed area via shoelace formula.
+// Positive area => CCW, Negative => CW.
+function ringArea(ring: XY[]): number {
+	let sum = 0
+	for (let i = 0; i < ring.length - 1; i++) {
+		const [x1, y1] = ring[i]!
+		const [x2, y2] = ring[i + 1]!
+		sum += x1 * y2 - x2 * y1
+	}
+	return sum / 2
+}
+
+function ensureClockwise(ring: XY[]): XY[] {
+	return ringArea(ring) < 0 ? ring : [...ring].reverse()
+}
+
+/**
+ * TODO handle MultiPolygons with holes
+ *
+function _ensureCounterClockwise(ring: XY[]): XY[] {
+	return ringArea(ring) > 0 ? ring : [...ring].reverse()
+}
+*/
+
+// Remove consecutive duplicates *after* rounding
+function cleanRing(ring: XY[]): XY[] {
+	const deduped = dedupePoints(ring)
+	// After dedupe, we still must ensure closure, and a polygon
+	// ring needs at least 4 coords (A,B,C,A).
+	const closed = closeRing(deduped)
+	if (closed.length < 4) return []
+	return closed
+}

package/src/index.ts

@@ -0,0 +1 @@
+export { OsmixVtEncoder } from "./encode"

package/src/types.ts

@@ -0,0 +1,30 @@
+import type { OsmEntityType, OsmTags } from "@osmix/json"
+import type { XY } from "@osmix/shared/types"
+
+export type VtSimpleFeatureGeometry = XY[][]
+
+export type VtSimpleFeatureProperties = {
+	sourceId?: string
+	type: OsmEntityType
+	tileKey?: string
+} & OsmTags
+
+export type VtSimpleFeatureType = {
+	POINT: 1
+	LINE: 2
+	POLYGON: 3
+}
+
+export interface VtSimpleFeature {
+	id: number
+	type: VtSimpleFeatureType[keyof VtSimpleFeatureType]
+	properties: VtSimpleFeatureProperties
+	geometry: VtSimpleFeatureGeometry
+}
+
+export type VtPbfLayer = {
+	name: string
+	version: number
+	extent: number
+	features: Generator<VtSimpleFeature>
+}

package/src/write-vt-pbf.ts

@@ -0,0 +1,148 @@
+import Pbf from "pbf"
+import type { VtPbfLayer, VtSimpleFeature } from "./types"
+
+type VtLayerContext = {
+	feature: VtSimpleFeature
+	keys: string[]
+	values: unknown[]
+	keycache: Record<string, number>
+	valuecache: Record<string, number>
+}
+
+/**
+ * Write Vector Tile Layers to a PBF buffer
+ */
+export default function writeVtPbf(layers: VtPbfLayer[]) {
+	const pbf = new Pbf()
+	for (const layer of layers) {
+		pbf.writeMessage(3, writeLayer, layer)
+	}
+	return pbf.finish().buffer as ArrayBuffer
+}
+
+function writeLayer(layer: VtPbfLayer, pbf: Pbf) {
+	pbf.writeVarintField(15, layer.version ?? 1)
+	pbf.writeStringField(1, layer.name ?? "")
+	pbf.writeVarintField(5, layer.extent ?? 4096)
+
+	let context: VtLayerContext | undefined
+	for (const feature of layer.features) {
+		if (!context) {
+			context = {
+				feature,
+				keys: [] as string[],
+				values: [],
+				keycache: {},
+				valuecache: {},
+			}
+		} else {
+			context.feature = feature
+		}
+		pbf.writeMessage(2, writeFeature, context)
+	}
+
+	if (!context) return
+	context.keys.forEach((key) => {
+		pbf.writeStringField(3, key)
+	})
+
+	context.values.forEach((value) => {
+		pbf.writeMessage(4, writeValue, value)
+	})
+}
+
+function writeFeature(ctx: VtLayerContext, pbf: Pbf) {
+	if (ctx.feature.id !== undefined) {
+		pbf.writeVarintField(1, ctx.feature.id)
+	}
+
+	pbf.writeMessage(2, writeProperties, ctx)
+	pbf.writeVarintField(3, ctx.feature.type)
+	pbf.writeMessage(4, writeGeometry, ctx.feature)
+}
+
+function writeProperties(ctx: VtLayerContext, pbf: Pbf) {
+	Object.entries(ctx.feature.properties).forEach(([key, value]) => {
+		let keyIndex = ctx.keycache[key]
+		if (value === null) return // don't encode null value properties
+
+		if (typeof keyIndex === "undefined") {
+			ctx.keys.push(key)
+			keyIndex = ctx.keys.length - 1
+			ctx.keycache[key] = keyIndex
+		}
+		pbf.writeVarint(keyIndex)
+
+		const type = typeof value
+		const valueStr =
+			type !== "string" && type !== "boolean" && type !== "number"
+				? JSON.stringify(value)
+				: value
+		const valueKey = `${type}:${valueStr}`
+		let valueIndex = ctx.valuecache[valueKey]
+		if (typeof valueIndex === "undefined") {
+			ctx.values.push(value)
+			valueIndex = ctx.values.length - 1
+			ctx.valuecache[valueKey] = valueIndex
+		}
+		pbf.writeVarint(valueIndex)
+	})
+}
+
+function command(cmd: number, length: number) {
+	return (length << 3) + (cmd & 0x7)
+}
+
+function zigzag(num: number) {
+	return (num << 1) ^ (num >> 31)
+}
+
+function writeGeometry(feature: VtSimpleFeature, pbf: Pbf) {
+	const type = feature.type
+	let x = 0
+	let y = 0
+	feature.geometry.forEach((ring) => {
+		let count = 1
+		if (type === 1) {
+			count = ring.length
+		}
+		pbf.writeVarint(command(1, count)) // moveto
+		// do not write polygon closing path as lineto
+		const lineCount = type === 3 ? ring.length - 1 : ring.length
+		ring.forEach((xy, i) => {
+			if (i >= lineCount) return
+			if (i === 1 && type !== 1) {
+				pbf.writeVarint(command(2, lineCount - 1)) // lineto
+			}
+			const dx = xy[0] - x
+			const dy = xy[1] - y
+			pbf.writeVarint(zigzag(dx))
+			pbf.writeVarint(zigzag(dy))
+			x += dx
+			y += dy
+		})
+		if (type === 3) {
+			pbf.writeVarint(command(7, 1)) // closepath
+		}
+	})
+}
+
+function writeValue(value: unknown, pbf: Pbf) {
+	if (typeof value === "string") {
+		pbf.writeStringField(1, value)
+	} else if (typeof value === "boolean") {
+		pbf.writeBooleanField(7, value)
+	} else if (typeof value === "number") {
+		if (!Number.isFinite(value)) {
+			pbf.writeDoubleField(3, value)
+		} else if (value % 1 !== 0) {
+			pbf.writeDoubleField(3, value)
+		} else if (!Number.isSafeInteger(value)) {
+			pbf.writeDoubleField(3, value)
+		} else if (value < 0) {
+			pbf.writeSVarintField(6, value)
+		} else {
+			pbf.writeVarintField(5, value)
+		}
+	}
+}

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"],
+	"compilerOptions": {
+		"outDir": "./dist"
+	}
+}