osm2geojson-lite 1.2.0 → 2.1.0

package/dist/cli.mjs

@@ -0,0 +1,1504 @@
+#!/usr/bin/env node
+import { parseArgs } from "node:util";
+import { readFile, writeFile } from "node:fs/promises";
+// src/utils.ts
+function purgeProps(obj, blacklist) {
+	if (obj) {
+		const rs = Object.assign({}, obj);
+		if (blacklist) for (const prop of blacklist) delete rs[prop];
+		return rs;
+	}
+	return {};
+}
+function first(a) {
+	return a[0];
+}
+function last(a) {
+	return a[a.length - 1];
+}
+function coordsToKey(a) {
+	return a.join(",");
+}
+function addToMap(m, k, v) {
+	const a = m[k];
+	if (a) a.push(v);
+	else m[k] = [v];
+}
+function removeFromMap(m, k, v) {
+	const a = m[k];
+	let idx = -1;
+	if (a) idx = a.indexOf(v);
+	if (idx >= 0) a.splice(idx, 1);
+}
+function getFirstFromMap(m, k) {
+	const a = m[k];
+	if (a && a.length > 0) return a[0];
+	return null;
+}
+function isRing(a) {
+	if (a.length <= 3) return false;
+	const firstPoint = a[0];
+	const lastPoint = a[a.length - 1];
+	return firstPoint[0] === lastPoint[0] && firstPoint[1] === lastPoint[1];
+}
+/**
+* Build the closed rectangle used by Overpass `out bb` responses when an
+* element carries only a bounding box.
+* @param bounds `[minlon, minlat, maxlon, maxlat]`
+*/
+function boundsToRing(bounds) {
+	const [minLon, minLat, maxLon, maxLat] = bounds;
+	return [
+		[minLon, minLat],
+		[maxLon, minLat],
+		[maxLon, maxLat],
+		[minLon, maxLat],
+		[minLon, minLat]
+	];
+}
+/**
+* Bounds produced by `ringDirection` while it already scans the ring. Polygon
+* assembly needs both, so reusing that pass avoids a second full scan on
+* relation-heavy data.
+*/
+const ringBoundsCache = /* @__PURE__ */ new WeakMap();
+function ringDirection(a, xIdx, yIdx) {
+	xIdx = xIdx || 0, yIdx = yIdx || 1;
+	let m = 0;
+	let maxX = a[0][xIdx];
+	let minX = maxX;
+	let minY = a[0][yIdx];
+	let maxY = minY;
+	for (let idx = 1; idx < a.length; idx++) {
+		const point = a[idx];
+		const x = point[xIdx];
+		const y = point[yIdx];
+		if (x >= maxX) {
+			maxX = x;
+			m = idx;
+		} else if (x < minX) minX = x;
+		if (y < minY) minY = y;
+		else if (y > maxY) maxY = y;
+	}
+	if (xIdx === 0 && yIdx === 1) ringBoundsCache.set(a, {
+		minX,
+		maxX,
+		minY,
+		maxY
+	});
+	const l = m <= 0 ? a.length - 2 : m - 1;
+	const r = m >= a.length - 1 ? 1 : m + 1;
+	const xa = a[l][xIdx];
+	const xb = a[m][xIdx];
+	const xc = a[r][xIdx];
+	const ya = a[l][yIdx];
+	const yb = a[m][yIdx];
+	const yc = a[r][yIdx];
+	return (xb - xa) * (yc - ya) - (xc - xa) * (yb - ya) < 0 ? "clockwise" : "counterclockwise";
+}
+function ringBounds(ring) {
+	const cached = ringBoundsCache.get(ring);
+	if (cached) return cached;
+	let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
+	for (let i = 0; i < ring.length; i++) {
+		const point = ring[i];
+		const x = point[0];
+		const y = point[1];
+		if (x < minX) minX = x;
+		if (x > maxX) maxX = x;
+		if (y < minY) minY = y;
+		if (y > maxY) maxY = y;
+	}
+	const bounds = {
+		minX,
+		maxX,
+		minY,
+		maxY
+	};
+	ringBoundsCache.set(ring, bounds);
+	return bounds;
+}
+function pointInsidePolygon(pt, polygon, xIdx, yIdx) {
+	xIdx = xIdx || 0, yIdx = yIdx || 1;
+	const px = pt[xIdx];
+	const py = pt[yIdx];
+	let result = false;
+	let xj = polygon[polygon.length - 1][xIdx];
+	let yj = polygon[polygon.length - 1][yIdx];
+	for (let i = 0; i < polygon.length; i++) {
+		const point = polygon[i];
+		const xi = point[xIdx];
+		const yi = point[yIdx];
+		if ((xi <= px && px < xj || xj <= px && px < xi) && py < (yj - yi) * (px - xi) / (xj - xi) + yi) result = !result;
+		xj = xi;
+		yj = yi;
+	}
+	return result;
+}
+// src/osm-object.ts
+var OsmObject = class {
+	constructor(type, id, refElems, register = true) {
+		this.type = type;
+		this.id = id;
+		this.refElems = refElems;
+		this.tags = {};
+		this.props = { id: this.getCompositeId() };
+		this.refCount = 0;
+		this.hasTag = false;
+		this.tainted = false;
+		if (refElems && register) refElems.add(this.getCompositeId(), this);
+	}
+	addTags(tags) {
+		this.tags = Object.assign(this.tags, tags);
+		this.hasTag = true;
+	}
+	addTag(k, v) {
+		this.tags[k] = v;
+		this.hasTag = true;
+	}
+	addProp(k, v) {
+		this.props[k] = v;
+	}
+	addProps(props) {
+		this.props = Object.assign(this.props, props);
+	}
+	getCompositeId() {
+		return `${this.type}/${this.id}`;
+	}
+	getProps() {
+		const props = Object.assign({}, this.props, this.tags);
+		if (this.tainted && this.refElems && this.refElems.reportTainted) props["@tainted"] = true;
+		return props;
+	}
+};
+// src/node.ts
+var Node = class extends OsmObject {
+	constructor(id, refElems, register = true) {
+		super("node", id, refElems, register);
+	}
+	setLatLng(latLng) {
+		this.latLng = latLng;
+	}
+	toFeatureArray() {
+		if (this.latLng) return [{
+			type: "Feature",
+			id: this.getCompositeId(),
+			properties: this.getProps(),
+			geometry: {
+				type: "Point",
+				coordinates: [+this.latLng.lon, +this.latLng.lat]
+			}
+		}];
+		return [];
+	}
+	getLatLng() {
+		return this.latLng;
+	}
+};
+// src/output.ts
+/**
+* A pre-built geometry carried by Overpass derived responses (`out geom`,
+* `convert`, `make`, `local`) or by equivalent XML output.
+*/
+var Output = class extends OsmObject {
+	constructor(type, id, refElems) {
+		super(type, id, refElems);
+	}
+	setGeometry(geometry) {
+		this.geometry = geometry;
+	}
+	toFeatureArray() {
+		if (!this.geometry) return [];
+		return [{
+			type: "Feature",
+			id: this.getCompositeId(),
+			properties: this.getProps(),
+			geometry: this.geometry
+		}];
+	}
+};
+// src/late-binder.ts
+var LateBinder = class {
+	constructor(container, valueFunc, ctx, args) {
+		this.container = container;
+		this.valueFunc = valueFunc;
+		this.ctx = ctx;
+		this.args = args;
+	}
+	resolve() {
+		return this.valueFunc.apply(this.ctx, this.args);
+	}
+	getContainer() {
+		return this.container;
+	}
+};
+// src/way.ts
+const defaultPolygonRules = {
+	building: { "ignore": ["no"] },
+	highway: { "include": [
+		"services",
+		"rest_area",
+		"escape",
+		"elevator"
+	] },
+	natural: { "exclude": [
+		"coastline",
+		"cliff",
+		"ridge",
+		"arete",
+		"tree_row"
+	] },
+	landuse: {},
+	waterway: { "include": [
+		"riverbank",
+		"dock",
+		"boatyard",
+		"dam"
+	] },
+	amenity: {},
+	leisure: {},
+	barrier: { "include": [
+		"city_wall",
+		"ditch",
+		"hedge",
+		"retaining_wall",
+		"wall",
+		"spikes"
+	] },
+	railway: { "include": [
+		"station",
+		"turntable",
+		"roundhouse",
+		"platform"
+	] },
+	boundary: {},
+	man_made: { "exclude": [
+		"cutline",
+		"embankment",
+		"pipeline"
+	] },
+	power: { "include": [
+		"plant",
+		"substation",
+		"generator",
+		"transformer"
+	] },
+	"piste:type": { "include": ["downhill"] },
+	place: {},
+	shop: {},
+	aeroway: { "exclude": ["taxiway"] },
+	tourism: {},
+	historic: {},
+	public_transport: {},
+	office: {},
+	"building:part": { "ignore": ["no"] },
+	military: {},
+	ruins: {},
+	"area:highway": {},
+	craft: {},
+	golf: {},
+	indoor: { "ignore": ["yes", "no"] },
+	area: { "exclude": ["no"] }
+};
+var Way = class extends OsmObject {
+	constructor(id, refElems, register = true) {
+		super("way", id, refElems, register);
+		this.latLngArray = [];
+		this.center = null;
+		this.bounds = null;
+	}
+	addLatLng(latLng) {
+		this.latLngArray.push(latLng);
+	}
+	setLatLngArray(latLngArray) {
+		this.latLngArray = latLngArray;
+	}
+	setCenter(center) {
+		this.center = center;
+	}
+	setBounds(bounds) {
+		this.bounds = bounds;
+	}
+	getBounds() {
+		return this.bounds;
+	}
+	addNodeRef(ref) {
+		const binder = new LateBinder(this.latLngArray, (id) => {
+			const node = this.refElems.get(`node/${id}`);
+			if (node) {
+				node.refCount++;
+				return node.getLatLng();
+			}
+			this.tainted = true;
+		}, this, [ref]);
+		this.latLngArray.push(binder);
+		this.refElems.addBinder(binder);
+	}
+	/**
+	* Coordinates are normalised to numbers in a single pass here. Previously
+	* the strings were joined for map keys and parsed again during output, so
+	* every coordinate was converted twice and several intermediate arrays
+	* were allocated.
+	*/
+	toCoordsArray() {
+		const source = this.latLngArray;
+		const coords = new Array(source.length);
+		for (let i = 0; i < source.length; i++) {
+			const latLng = source[i];
+			coords[i] = [+latLng.lon, +latLng.lat];
+		}
+		return coords;
+	}
+	toFeatureArray() {
+		const coordsArray = this.toCoordsArray();
+		if (coordsArray.length > 1) {
+			const feature = {
+				type: "Feature",
+				id: this.getCompositeId(),
+				properties: this.getProps(),
+				geometry: {
+					type: "LineString",
+					coordinates: coordsArray
+				}
+			};
+			if (isRing(coordsArray) && this.isPolygon()) {
+				if (ringDirection(coordsArray) !== "counterclockwise") coordsArray.reverse();
+				feature.geometry = {
+					type: "Polygon",
+					coordinates: [coordsArray]
+				};
+			}
+			return [feature];
+		}
+		if (this.bounds) return [{
+			type: "Feature",
+			id: this.getCompositeId(),
+			properties: this.getProps(),
+			geometry: {
+				type: "Polygon",
+				coordinates: [boundsToRing(this.bounds)]
+			}
+		}];
+		if (this.center) return [{
+			type: "Feature",
+			id: this.getCompositeId(),
+			properties: this.getProps(),
+			geometry: {
+				type: "Point",
+				coordinates: [+this.center.lon, +this.center.lat]
+			}
+		}];
+		return [];
+	}
+	/**
+	* Polygon detection is order-independent: a closed way is an area when at
+	* least one polygon tag applies, while tags such as `building=no` or
+	* `area=no` explicitly opt out.
+	*/
+	isPolygon() {
+		const polygonRules = this.refElems && this.refElems.polygonTags || defaultPolygonRules;
+		let area = false;
+		for (const key in polygonRules) {
+			const value = this.tags[key];
+			if (!value) continue;
+			const rule = polygonRules[key];
+			if (rule.ignore && rule.ignore.indexOf(value) >= 0) continue;
+			area = true;
+			if (rule.include) area = rule.include.indexOf(value) >= 0;
+			else if (rule.exclude) area = rule.exclude.indexOf(value) < 0;
+			else if (rule.whitelist) area = rule.whitelist.indexOf(value) >= 0;
+			else if (rule.blacklist) area = rule.blacklist.indexOf(value) < 0;
+		}
+		return area;
+	}
+};
+// src/way-collection.ts
+/**
+* A growable point sequence with O(1) reverse and amortised O(1) append.
+*
+* `left` is stored in reverse order, so the logical sequence is
+* `reverse(left) + right`. Reversing therefore only swaps the two arrays and
+* appending always targets `right`. This lets the line/ring stitcher grow a
+* path without repeatedly copying the accumulated coordinates.
+*/
+var PointDeque = class {
+	constructor(first, firstKey, lastKey) {
+		this.left = [];
+		this.right = first.slice();
+		this.headKey = firstKey;
+		this.tailKey = lastKey;
+	}
+	reverse() {
+		const tmp = this.left;
+		this.left = this.right;
+		this.right = tmp;
+		const key = this.headKey;
+		this.headKey = this.tailKey;
+		this.tailKey = key;
+	}
+	/** Append a segment, dropping its first point (the shared joint). */
+	append(segment, segmentLastKey) {
+		for (let i = 1; i < segment.length; i++) this.right.push(segment[i]);
+		this.tailKey = segmentLastKey;
+	}
+	flatten() {
+		const result = new Array(this.left.length + this.right.length);
+		let at = 0;
+		for (let i = this.left.length - 1; i >= 0; i--) result[at++] = this.left[i];
+		for (let i = 0; i < this.right.length; i++) result[at++] = this.right[i];
+		return result;
+	}
+};
+/**
+* A collection of way coordinate arrays that can be stitched back into lines
+* or rings.
+*
+* The previous implementation extended `Array` and relied on `shift()` plus
+* `splice(indexOf(...))` while merging, which is O(n^2) for relations made of
+* many ways. This version keeps a cursor over a fixed array and marks consumed
+* entries, so merging is linear apart from the small per-coordinate-end maps.
+*/
+var WayCollection = class {
+	constructor() {
+		this.ways = [];
+		this.firstKeys = [];
+		this.lastKeys = [];
+		this.firstMap = {};
+		this.lastMap = {};
+		this.used = [];
+		this.indexByWay = /* @__PURE__ */ new Map();
+		this.head = 0;
+	}
+	addWay(way) {
+		let w = way.toCoordsArray();
+		if (w.length === 0) {
+			const bounds = way.getBounds();
+			if (bounds) w = boundsToRing(bounds);
+		}
+		if (w.length > 0) {
+			const index = this.ways.length;
+			const firstKey = coordsToKey(first(w));
+			const lastKey = coordsToKey(last(w));
+			this.ways.push(w);
+			this.firstKeys.push(firstKey);
+			this.lastKeys.push(lastKey);
+			this.used.push(false);
+			this.indexByWay.set(w, index);
+			addToMap(this.firstMap, firstKey, w);
+			addToMap(this.lastMap, lastKey, w);
+		}
+	}
+	mergeWays() {
+		const strings = [];
+		let index = this.firstUnused();
+		while (index >= 0) {
+			const way = this.ways[index];
+			this.consume(index);
+			const deque = new PointDeque(way, this.firstKeys[index], this.lastKeys[index]);
+			for (;;) {
+				const found = this.getNextWay(deque.headKey, deque.tailKey);
+				const next = found.next;
+				if (!next) break;
+				const nextIndex = this.indexByWay.get(next);
+				if (nextIndex === void 0) break;
+				this.consume(nextIndex);
+				switch (found.mergeType) {
+					case 0:
+						deque.append(next, this.lastKeys[nextIndex]);
+						break;
+					case 1:
+						next.reverse();
+						deque.append(next, this.firstKeys[nextIndex]);
+						break;
+					case 2:
+						deque.reverse();
+						deque.append(next, this.lastKeys[nextIndex]);
+						break;
+					case 3:
+						next.reverse();
+						deque.reverse();
+						deque.append(next, this.firstKeys[nextIndex]);
+				}
+			}
+			strings.push(deque.flatten());
+			index = this.firstUnused();
+		}
+		return strings;
+	}
+	firstUnused() {
+		while (this.head < this.ways.length && this.used[this.head]) this.head++;
+		return this.head < this.ways.length ? this.head : -1;
+	}
+	consume(index) {
+		this.used[index] = true;
+		const way = this.ways[index];
+		removeFromMap(this.firstMap, this.firstKeys[index], way);
+		removeFromMap(this.lastMap, this.lastKeys[index], way);
+	}
+	/**
+	* Try to find the next way to add to the current way.
+	* It first tries the next unused way in the array, and if this doesn't work,
+	* tries any other way through the endpoint maps.
+	*/
+	getNextWay(headKey, tailKey) {
+		const candidateIndex = this.firstUnused();
+		const next = candidateIndex >= 0 ? this.ways[candidateIndex] : null;
+		if (next) {
+			const nextFirstKey = this.firstKeys[candidateIndex];
+			const nextLastKey = this.lastKeys[candidateIndex];
+			if (tailKey === nextFirstKey) return {
+				next,
+				mergeType: 0
+			};
+			if (tailKey === nextLastKey) return {
+				next,
+				mergeType: 1
+			};
+			if (headKey === nextFirstKey) return {
+				next,
+				mergeType: 2
+			};
+			if (headKey === nextLastKey) return {
+				next,
+				mergeType: 3
+			};
+		}
+		const fromFirst = getFirstFromMap(this.firstMap, tailKey);
+		if (fromFirst) return {
+			next: fromFirst,
+			mergeType: 0
+		};
+		return {
+			next: getFirstFromMap(this.lastMap, tailKey),
+			mergeType: 1
+		};
+	}
+	toRings(direction) {
+		const strings = this.mergeWays();
+		const rings = [];
+		for (let i = 0; i < strings.length; i++) {
+			const str = strings[i];
+			if (isRing(str)) {
+				if (ringDirection(str) !== direction) str.reverse();
+				rings.push(str);
+			}
+		}
+		return rings;
+	}
+};
+// src/relation.ts
+var Relation = class Relation extends OsmObject {
+	constructor(id, refElems, register = true) {
+		super("relation", id, refElems, register);
+		this.relations = [];
+		this.nodes = [];
+		this.bounds = void 0;
+		this.center = null;
+		this.ways = [];
+		this.roles = [];
+	}
+	setBounds(bounds) {
+		this.bounds = bounds;
+	}
+	setCenter(center) {
+		this.center = center;
+	}
+	addMember(member) {
+		switch (member.type) {
+			case "relation":
+				let binder = new LateBinder(this.relations, (id) => {
+					const relation = this.refElems.get(`relation/${id}`);
+					if (relation) {
+						relation.refCount++;
+						return relation;
+					}
+					this.tainted = true;
+					return new Relation(id, this.refElems, false);
+				}, this, [member.ref]);
+				this.relations.push(binder);
+				this.refElems.addBinder(binder);
+				break;
+			case "way":
+				if (!member.role) member.role = "";
+				if (member.geometry) {
+					const way = new Way(member.ref, this.refElems, false);
+					way.setLatLngArray(member.geometry);
+					way.refCount++;
+					this.ways.push(way);
+					this.roles.push(member.role);
+				} else if (member.nodes) {
+					const way = new Way(member.ref, this.refElems, false);
+					for (const nid of member.nodes) way.addNodeRef(nid);
+					way.refCount++;
+					this.ways.push(way);
+					this.roles.push(member.role);
+				} else {
+					let binder = new LateBinder(this.ways, (nid) => {
+						const way = this.refElems.get(`way/${nid}`);
+						if (way) {
+							way.refCount++;
+							return way;
+						}
+						this.tainted = true;
+						return new Way(nid, this.refElems, false);
+					}, this, [member.ref]);
+					this.ways.push(binder);
+					this.roles.push(member.role);
+					this.refElems.addBinder(binder);
+				}
+				break;
+			case "node":
+				let node = null;
+				if (member.lat !== void 0 && member.lon !== void 0) {
+					node = new Node(member.ref, this.refElems, false);
+					node.setLatLng({
+						lon: member.lon,
+						lat: member.lat
+					});
+					if (member.tags) node.addTags(member.tags);
+					for (const [k, v] of Object.entries(member)) if ([
+						"id",
+						"type",
+						"lat",
+						"lon"
+					].indexOf(k) < 0) node.addProp(k, v);
+					node.refCount++;
+					this.nodes.push(node);
+				} else {
+					let binder = new LateBinder(this.nodes, (id) => {
+						const nn = this.refElems.get(`node/${id}`);
+						if (nn) {
+							nn.refCount++;
+							return nn;
+						}
+						this.tainted = true;
+					}, this, [member.ref]);
+					this.nodes.push(binder);
+					this.refElems.addBinder(binder);
+				}
+		}
+	}
+	constructStringGeometry(ws) {
+		const strings = ws ? ws.mergeWays() : [];
+		if (strings.length === 0) return null;
+		return {
+			type: "MultiLineString",
+			coordinates: strings
+		};
+	}
+	constructPolygonGeometry(ows, iws) {
+		const outerRings = ows ? ows.toRings("counterclockwise") : [];
+		const innerRings = iws ? iws.toRings("clockwise") : [];
+		if (outerRings.length > 0) {
+			const compositPolyons = [];
+			const outerBounds = [];
+			for (const ring of outerRings) compositPolyons.push([ring]);
+			if (innerRings.length > 0) for (const ring of outerRings) outerBounds.push(ringBounds(ring));
+			for (let i = 0; i < innerRings.length; i++) {
+				const ring = innerRings[i];
+				const pt = first(ring);
+				for (let idx = 0; idx < outerRings.length; idx++) {
+					const b = outerBounds[idx];
+					if (pt[0] < b.minX || pt[0] > b.maxX || pt[1] < b.minY || pt[1] > b.maxY) continue;
+					if (pointInsidePolygon(pt, outerRings[idx])) {
+						compositPolyons[idx].push(ring);
+						break;
+					}
+				}
+			}
+			if (compositPolyons.length === 1) return {
+				type: "Polygon",
+				coordinates: compositPolyons[0]
+			};
+			return {
+				type: "MultiPolygon",
+				coordinates: compositPolyons
+			};
+		}
+		return null;
+	}
+	/**
+	* Flatten a relation and its sub-relations into a single way/role list.
+	* Duplicate way references (a common cause of duplicated rings) are removed
+	* while preserving the first occurrence and its role.
+	*/
+	collectAllWaysForRelation(relation, relationToWaysMap) {
+		const cached = relationToWaysMap.get(relation.id);
+		if (cached) return cached;
+		const ways = [];
+		const roles = [];
+		const seen = /* @__PURE__ */ new Set();
+		const addDirect = (way, role) => {
+			if (!way) {
+				relation.tainted = true;
+				return;
+			}
+			const key = way.getCompositeId() + "\n" + role;
+			if (seen.has(key)) return;
+			seen.add(key);
+			ways.push(way);
+			roles.push(role);
+		};
+		for (let i = 0; i < relation.ways.length; i++) addDirect(relation.ways[i], relation.roles[i]);
+		const seenRelations = /* @__PURE__ */ new Set();
+		for (const subRelation of relation.relations) {
+			if (!subRelation) {
+				relation.tainted = true;
+				continue;
+			}
+			const id = subRelation.getCompositeId();
+			if (seenRelations.has(id)) continue;
+			seenRelations.add(id);
+			const entry = this.collectAllWaysForRelation(subRelation, relationToWaysMap);
+			for (let i = 0; i < entry.ways.length; i++) {
+				ways.push(entry.ways[i]);
+				roles.push(entry.roles[i]);
+			}
+		}
+		const result = {
+			ways,
+			roles
+		};
+		relationToWaysMap.set(relation.id, result);
+		return result;
+	}
+	toFeatureArray() {
+		const polygonFeatures = [];
+		const stringFeatures = [];
+		let pointFeatures = [];
+		const relationToWaysMap = /* @__PURE__ */ new Map();
+		const waysAndRoles = this.collectAllWaysForRelation(this, relationToWaysMap);
+		let templateFeature = {
+			type: "Feature",
+			id: this.getCompositeId(),
+			bbox: this.bounds,
+			properties: this.getProps(),
+			geometry: null
+		};
+		if (!this.bounds) delete templateFeature.bbox;
+		let hasGeometry = false;
+		if (waysAndRoles.roles.some((r) => r === "outer")) {
+			const outerWayCollection = new WayCollection();
+			const innerWayCollection = new WayCollection();
+			for (let i = 0; i < waysAndRoles.ways.length; i++) {
+				const way = waysAndRoles.ways[i];
+				const role = waysAndRoles.roles[i];
+				if (role === "outer") outerWayCollection.addWay(way);
+				else if (role === "inner") innerWayCollection.addWay(way);
+			}
+			const geometry = this.constructPolygonGeometry(outerWayCollection, innerWayCollection);
+			if (geometry) {
+				const feature = Object.assign({}, templateFeature);
+				feature.geometry = geometry;
+				polygonFeatures.push(feature);
+				hasGeometry = true;
+			}
+		} else {
+			const wayCollection = new WayCollection();
+			for (const way of waysAndRoles.ways) wayCollection.addWay(way);
+			const geometry = this.constructStringGeometry(wayCollection);
+			if (geometry) {
+				const feature = Object.assign({}, templateFeature);
+				feature.geometry = geometry;
+				stringFeatures.push(feature);
+				hasGeometry = true;
+			}
+		}
+		if (!hasGeometry && this.bounds) {
+			const feature = Object.assign({}, templateFeature);
+			feature.geometry = {
+				type: "Polygon",
+				coordinates: [boundsToRing(this.bounds)]
+			};
+			polygonFeatures.push(feature);
+			hasGeometry = true;
+		}
+		if (!hasGeometry && this.center) {
+			const feature = Object.assign({}, templateFeature);
+			feature.geometry = {
+				type: "Point",
+				coordinates: [+this.center.lon, +this.center.lat]
+			};
+			pointFeatures.push(feature);
+		}
+		for (const node of this.nodes) pointFeatures = pointFeatures.concat(node.toFeatureArray());
+		return [
+			...polygonFeatures,
+			...stringFeatures,
+			...pointFeatures
+		];
+	}
+};
+// src/xmlparser.ts
+const XML_ENTITY = /&(#x[0-9a-fA-F]+|#[0-9]+|amp|lt|gt|quot|apos);/g;
+/**
+* Decode the XML entities that occur in OSM data. The cheap `indexOf` check
+* keeps the common case (no entities) allocation-free.
+*/
+function decodeEntities(value) {
+	if (value.indexOf("&") < 0) return value;
+	return value.replace(XML_ENTITY, (match, entity) => {
+		switch (entity) {
+			case "amp": return "&";
+			case "lt": return "<";
+			case "gt": return ">";
+			case "quot": return "\"";
+			case "apos": return "'";
+		}
+		if (entity.charCodeAt(0) === 35) {
+			const code = entity.charCodeAt(1) === 120 || entity.charCodeAt(1) === 88 ? parseInt(entity.slice(2), 16) : parseInt(entity.slice(1), 10);
+			if (Number.isFinite(code) && code >= 0 && code <= 1114111) return String.fromCodePoint(code);
+		}
+		return match;
+	});
+}
+// src/osm-xml.ts
+const GT = 62;
+const SLASH = 47;
+const BANG = 33;
+const QUESTION = 63;
+const EQUALS = 61;
+const DQUOTE = 34;
+const SQUOTE = 39;
+const SPACE = 32;
+const TAB = 9;
+const LF = 10;
+const CR = 13;
+function isSpace(c) {
+	return c === SPACE || c === TAB || c === LF || c === CR;
+}
+function newDerived() {
+	return {
+		lineCoords: [],
+		geometries: []
+	};
+}
+function buildDerivedGeometry(derived) {
+	if (derived.lineCoords.length > 0) return {
+		type: "LineString",
+		coordinates: derived.lineCoords
+	};
+	if (derived.geometries.length > 0) return {
+		type: "GeometryCollection",
+		geometries: derived.geometries
+	};
+	return derived.geometry;
+}
+function addNodeProps(node, attrs) {
+	for (const k in attrs) if (k !== "id" && k !== "lon" && k !== "lat") node.addProp(k, attrs[k]);
+}
+function addWayProps(way, attrs) {
+	for (const k in attrs) if (k !== "id") way.addProp(k, attrs[k]);
+}
+function addDerivedProps(output, attrs) {
+	for (const k in attrs) if (k !== "id" && k !== "type") output.addProp(k, attrs[k]);
+}
+function isRoot(kind) {
+	return kind === 0 || kind === 7;
+}
+function finish(frame, parent, refElements) {
+	switch (frame.kind) {
+		case 1: {
+			const attrs = frame.attrs;
+			if (frame.hasDerived) {
+				const output = new Output("node", frame.id, refElements);
+				addDerivedProps(output, attrs);
+				if (frame.tags) output.addTags(frame.tags);
+				const geometry = buildDerivedGeometry(frame.derived);
+				if (geometry) output.setGeometry(geometry);
+			} else {
+				const node = new Node(frame.id, refElements);
+				addNodeProps(node, attrs);
+				node.setLatLng({
+					lat: attrs.lat,
+					lon: attrs.lon
+				});
+				if (frame.tags) node.addTags(frame.tags);
+			}
+			return;
+		}
+		case 2: {
+			const way = frame.way;
+			if (frame.hasDerived) {
+				const output = new Output("way", frame.id, refElements);
+				addDerivedProps(output, frame.attrs);
+				if (frame.tags) output.addTags(frame.tags);
+				const geometry = buildDerivedGeometry(frame.derived);
+				if (geometry) output.setGeometry(geometry);
+			} else {
+				refElements.add(way.getCompositeId(), way);
+				addWayProps(way, frame.attrs);
+				if (frame.tags) way.addTags(frame.tags);
+				if (frame.center) way.setCenter(frame.center);
+				if (frame.bounds && !frame.hasNd) way.setBounds(frame.bounds);
+			}
+			return;
+		}
+		case 3: {
+			const relation = frame.relation;
+			if (frame.hasDerived) {
+				const output = new Output("relation", frame.id, refElements);
+				addDerivedProps(output, frame.attrs);
+				if (frame.tags) output.addTags(frame.tags);
+				const geometry = buildDerivedGeometry(frame.derived);
+				if (geometry) output.setGeometry(geometry);
+			} else {
+				if (frame.tags) relation.addTags(frame.tags);
+				if (frame.center) relation.setCenter(frame.center);
+			}
+			return;
+		}
+		case 4: {
+			const attrs = frame.attrs;
+			const member = {
+				type: attrs.type,
+				role: attrs.role ? attrs.role : "",
+				ref: attrs.ref
+			};
+			if (attrs.lat && attrs.lon) {
+				member.lat = attrs.lat;
+				member.lon = attrs.lon;
+				member.tags = {};
+				for (const k in attrs) if (k !== "type" && k !== "lat" && k !== "lon") member[k] = attrs[k];
+			}
+			if (frame.member.geometry.length > 0) member.geometry = frame.member.geometry;
+			else if (frame.member.nodes.length > 0) member.nodes = frame.member.nodes;
+			if (parent && parent.kind === 3 && parent.relation) parent.relation.addMember(member);
+			return;
+		}
+		case 5:
+			if (parent && (parent.kind === 1 || parent.kind === 2 || parent.kind === 3)) parent.derived.geometry = {
+				type: "Polygon",
+				coordinates: [frame.lineCoords]
+			};
+			return;
+		case 6:
+			if (parent && (parent.kind === 1 || parent.kind === 2 || parent.kind === 3)) {
+				const derived = parent.derived;
+				const points = frame.groupPoints;
+				for (let i = 0; i < points.length; i++) derived.geometries.push(points[i]);
+				const coords = frame.groupCoords;
+				if (coords.length > 0) derived.geometries.push({
+					type: "LineString",
+					coordinates: coords
+				});
+			}
+			return;
+	}
+}
+/**
+* Parse OSM/Overpass XML directly into `RefElements`.
+*/
+function parseOsmXml(xml, refElements) {
+	const len = xml.length;
+	const stack = [];
+	let i = 0;
+	while (i < len) {
+		const lt = xml.indexOf("<", i);
+		if (lt < 0) break;
+		i = lt + 1;
+		const c = xml.charCodeAt(i);
+		if (c === SLASH) {
+			const gt = xml.indexOf(">", i);
+			if (gt < 0) break;
+			i = gt + 1;
+			const frame = stack.pop();
+			if (frame) finish(frame, stack.length ? stack[stack.length - 1] : void 0, refElements);
+			continue;
+		}
+		if (c === QUESTION) {
+			const gt = xml.indexOf(">", i);
+			i = gt < 0 ? len : gt + 1;
+			continue;
+		}
+		if (c === BANG) {
+			if (xml.charCodeAt(i + 1) === 45 && xml.charCodeAt(i + 2) === 45) {
+				const end = xml.indexOf("-->", i + 3);
+				i = end < 0 ? len : end + 3;
+			} else {
+				const gt = xml.indexOf(">", i);
+				i = gt < 0 ? len : gt + 1;
+			}
+			continue;
+		}
+		let j = i;
+		while (j < len) {
+			const ch = xml.charCodeAt(j);
+			if (isSpace(ch) || ch === SLASH || ch === GT) break;
+			j++;
+		}
+		const tag = xml.slice(i, j);
+		const topKind = stack.length ? stack[stack.length - 1].kind : 0;
+		let kind = 7;
+		let attrMode = 0;
+		switch (tag) {
+			case "node":
+				if (isRoot(topKind)) {
+					kind = 1;
+					attrMode = 1;
+				}
+				break;
+			case "way":
+				if (isRoot(topKind)) {
+					kind = 2;
+					attrMode = 1;
+				}
+				break;
+			case "relation":
+				if (isRoot(topKind)) {
+					kind = 3;
+					attrMode = 1;
+				}
+				break;
+			case "osm":
+				kind = 0;
+				break;
+			case "member":
+				if (topKind === 3) {
+					kind = 4;
+					attrMode = 4;
+				}
+				break;
+			case "nd":
+				if (topKind === 2 || topKind === 4) attrMode = 2;
+				break;
+			case "tag":
+				if (topKind === 1 || topKind === 2 || topKind === 3) attrMode = 3;
+				break;
+			case "bounds":
+				if (topKind === 3 || topKind === 2) attrMode = 5;
+				break;
+			case "center":
+				if (topKind === 2 || topKind === 3) attrMode = 6;
+				break;
+			case "point":
+				if (topKind === 1 || topKind === 2 || topKind === 3 || topKind === 6) attrMode = 7;
+				break;
+			case "vertex":
+				if (topKind === 2 || topKind === 3 || topKind === 6 || topKind === 5) attrMode = 7;
+				break;
+			case "linestring":
+				if (topKind === 1 || topKind === 2 || topKind === 3) kind = 5;
+				break;
+			case "group": if (topKind === 1 || topKind === 2 || topKind === 3) kind = 6;
+		}
+		const attrs = attrMode === 1 || attrMode === 4 ? {} : void 0;
+		let ref = "", lat = "", lon = "", k = "", v = "";
+		let minlat = "", minlon = "", maxlat = "", maxlon = "";
+		let selfClose = false;
+		while (j < len) {
+			let ch = xml.charCodeAt(j);
+			while (isSpace(ch)) ch = xml.charCodeAt(++j);
+			if (ch === GT) {
+				j++;
+				break;
+			}
+			if (ch === SLASH) {
+				selfClose = true;
+				j++;
+				continue;
+			}
+			const nameStart = j;
+			while (j < len) {
+				ch = xml.charCodeAt(j);
+				if (ch === EQUALS || isSpace(ch) || ch === GT || ch === SLASH) break;
+				j++;
+			}
+			const attrName = xml.slice(nameStart, j);
+			while (isSpace(xml.charCodeAt(j))) j++;
+			let value = "";
+			if (xml.charCodeAt(j) === EQUALS) {
+				j++;
+				while (isSpace(xml.charCodeAt(j))) j++;
+				const q = xml.charCodeAt(j);
+				if (q === DQUOTE || q === SQUOTE) {
+					j++;
+					let valEnd = xml.indexOf(q === DQUOTE ? "\"" : "'", j);
+					if (valEnd < 0) valEnd = len;
+					value = xml.slice(j, valEnd);
+					if (value.indexOf("&") >= 0) value = decodeEntities(value);
+					j = valEnd + 1;
+				}
+			}
+			switch (attrMode) {
+				case 1:
+				case 4:
+					attrs[attrName] = value;
+					break;
+				case 2:
+					if (attrName === "ref") ref = value;
+					else if (attrName === "lat") lat = value;
+					else if (attrName === "lon") lon = value;
+					break;
+				case 3:
+					if (attrName === "k") k = value;
+					else if (attrName === "v") v = value;
+					break;
+				case 5:
+					if (attrName === "minlat") minlat = value;
+					else if (attrName === "minlon") minlon = value;
+					else if (attrName === "maxlat") maxlat = value;
+					else if (attrName === "maxlon") maxlon = value;
+					break;
+				case 6:
+				case 7: if (attrName === "lat") lat = value;
+				else if (attrName === "lon") lon = value;
+			}
+		}
+		i = j;
+		const parent = stack.length ? stack[stack.length - 1] : void 0;
+		if (attrMode === 2) {
+			if (parent) {
+				if (parent.kind === 2 && parent.way) {
+					parent.hasNd = true;
+					if (lat && lon) parent.way.addLatLng({
+						lat,
+						lon
+					});
+					else if (ref) parent.way.addNodeRef(ref);
+				} else if (parent.kind === 4 && parent.member) {
+					if (lat && lon) parent.member.geometry.push({
+						lat,
+						lon
+					});
+					else if (ref) parent.member.nodes.push(ref);
+				}
+			}
+			if (!selfClose) stack.push({ kind: 7 });
+			continue;
+		}
+		if (attrMode === 3) {
+			if (parent && k) {
+				const tags = parent.tags || (parent.tags = {});
+				tags[k] = v;
+			}
+			if (!selfClose) stack.push({ kind: 7 });
+			continue;
+		}
+		if (attrMode === 5) {
+			if (parent) {
+				const bounds = [
+					parseFloat(minlon),
+					parseFloat(minlat),
+					parseFloat(maxlon),
+					parseFloat(maxlat)
+				];
+				if (parent.kind === 3 && parent.relation) parent.relation.setBounds(bounds);
+				else if (parent.kind === 2) parent.bounds = bounds;
+			}
+			if (!selfClose) stack.push({ kind: 7 });
+			continue;
+		}
+		if (attrMode === 6) {
+			if (parent) parent.center = {
+				lat,
+				lon
+			};
+			if (!selfClose) stack.push({ kind: 7 });
+			continue;
+		}
+		if (attrMode === 7) {
+			if (parent) {
+				const x = +lon;
+				const y = +lat;
+				switch (parent.kind) {
+					case 1:
+					case 2:
+					case 3:
+						parent.hasDerived = true;
+						if (tag === "point") parent.derived.geometry = {
+							type: "Point",
+							coordinates: [x, y]
+						};
+						else parent.derived.lineCoords.push([x, y]);
+						break;
+					case 6:
+						if (tag === "point") parent.groupPoints.push({
+							type: "Point",
+							coordinates: [x, y]
+						});
+						else parent.groupCoords.push([x, y]);
+						break;
+					case 5: parent.lineCoords.push([x, y]);
+				}
+			}
+			if (!selfClose) stack.push({ kind: 7 });
+			continue;
+		}
+		let frame;
+		switch (kind) {
+			case 1:
+				frame = {
+					kind,
+					id: attrs.id,
+					attrs,
+					derived: newDerived(),
+					hasDerived: false
+				};
+				break;
+			case 2:
+				frame = {
+					kind,
+					id: attrs.id,
+					attrs,
+					way: new Way(attrs.id, refElements, false),
+					derived: newDerived(),
+					hasDerived: false
+				};
+				break;
+			case 3:
+				frame = {
+					kind,
+					id: attrs.id,
+					attrs,
+					relation: new Relation(attrs.id, refElements),
+					derived: newDerived(),
+					hasDerived: false
+				};
+				break;
+			case 4:
+				frame = {
+					kind,
+					attrs,
+					member: {
+						geometry: [],
+						nodes: []
+					}
+				};
+				break;
+			case 5:
+				if (parent && (parent.kind === 1 || parent.kind === 2 || parent.kind === 3)) parent.hasDerived = true;
+				frame = {
+					kind,
+					lineCoords: []
+				};
+				break;
+			case 6:
+				if (parent && (parent.kind === 1 || parent.kind === 2 || parent.kind === 3)) parent.hasDerived = true;
+				frame = {
+					kind,
+					groupPoints: [],
+					groupCoords: []
+				};
+				break;
+			case 0:
+			case 7: frame = { kind };
+		}
+		if (selfClose) {
+			if (frame) finish(frame, parent, refElements);
+		} else if (frame) stack.push(frame);
+	}
+}
+// src/ref-elements.ts
+var RefElements = class extends Map {
+	constructor() {
+		super();
+		this.binders = [];
+		this.reportTainted = false;
+		this.polygonTags = void 0;
+	}
+	add(k, v) {
+		this.set(k, v);
+	}
+	addBinder(binder) {
+		this.binders.push(binder);
+	}
+	/**
+	* Resolve every deferred reference in one pass per container.
+	*
+	* The previous implementation removed each binder with `indexOf` + `splice`,
+	* which is O(n^2) for containers such as a way's node list. Grouping by
+	* container and compacting once keeps insertion order and makes binding
+	* linear in the number of binders.
+	*/
+	bindAll() {
+		if (this.binders.length === 0) return;
+		const groups = /* @__PURE__ */ new Map();
+		for (const binder of this.binders) {
+			const container = binder.getContainer();
+			const list = groups.get(container);
+			if (list) list.push(binder);
+			else groups.set(container, [binder]);
+		}
+		for (const [container, binders] of groups) {
+			const bindersInContainer = new Set(binders);
+			const resolved = /* @__PURE__ */ new Map();
+			for (const binder of binders) resolved.set(binder, binder.resolve());
+			let write = 0;
+			for (let read = 0; read < container.length; read++) {
+				const item = container[read];
+				if (bindersInContainer.has(item)) {
+					const value = resolved.get(item);
+					if (value !== void 0) container[write++] = value;
+				} else container[write++] = item;
+			}
+			container.length = write;
+		}
+		this.binders = [];
+	}
+};
+// src/index.ts
+function parseOptions(options) {
+	if (!options) return {
+		completeFeature: false,
+		renderTagged: false,
+		excludeWay: true,
+		elementId: void 0,
+		tainted: false,
+		polygonTags: void 0
+	};
+	let excludeWay = options.excludeWay === void 0 || options.excludeWay;
+	let completeFeature = options.completeFeature ? true : false;
+	let renderTagged = options.renderTagged ? true : false;
+	let tainted = options.tainted ? true : false;
+	return {
+		completeFeature,
+		renderTagged,
+		excludeWay,
+		elementId: options.elementId,
+		tainted,
+		polygonTags: options.polygonTags
+	};
+}
+function detectFormat(o) {
+	if (o && typeof o === "object" && o.elements) return "json";
+	if (typeof o === "string") {
+		if (o.indexOf("<osm") >= 0) return "xml";
+		if (o.trim().startsWith("{")) return "json-raw";
+	}
+	return "invalid";
+}
+function analyzeFeaturesFromJson(osm, refElements) {
+	for (const elem of osm.elements) {
+		if (elem.geometry && typeof elem.geometry === "object" && elem.geometry.type) {
+			const output = new Output(elem.type, elem.id, refElements);
+			if (elem.tags) output.addTags(elem.tags);
+			output.addProps(purgeProps(elem, [
+				"id",
+				"type",
+				"tags",
+				"geometry"
+			]));
+			output.setGeometry(elem.geometry);
+			continue;
+		}
+		switch (elem.type) {
+			case "node":
+				const node = new Node(elem.id, refElements);
+				if (elem.tags) node.addTags(elem.tags);
+				node.addProps(purgeProps(elem, [
+					"id",
+					"type",
+					"tags",
+					"lat",
+					"lon"
+				]));
+				node.setLatLng(elem);
+				break;
+			case "way":
+				const way = new Way(elem.id, refElements);
+				if (elem.tags) way.addTags(elem.tags);
+				way.addProps(purgeProps(elem, [
+					"id",
+					"type",
+					"tags",
+					"nodes",
+					"geometry"
+				]));
+				if (elem.geometry) way.setLatLngArray(elem.geometry);
+				else if (elem.center) way.setCenter(elem.center);
+				else if (elem.nodes) for (const n of elem.nodes) way.addNodeRef(n);
+				else if (elem.bounds) way.setBounds([
+					parseFloat(elem.bounds.minlon),
+					parseFloat(elem.bounds.minlat),
+					parseFloat(elem.bounds.maxlon),
+					parseFloat(elem.bounds.maxlat)
+				]);
+				break;
+			case "relation":
+				const relation = new Relation(elem.id, refElements);
+				if (elem.bounds) relation.setBounds([
+					parseFloat(elem.bounds.minlon),
+					parseFloat(elem.bounds.minlat),
+					parseFloat(elem.bounds.maxlon),
+					parseFloat(elem.bounds.maxlat)
+				]);
+				if (elem.tags) relation.addTags(elem.tags);
+				if (elem.center) relation.setCenter(elem.center);
+				relation.addProps(purgeProps(elem, [
+					"id",
+					"type",
+					"tags",
+					"bounds",
+					"members"
+				]));
+				if (elem.members) for (const member of elem.members) relation.addMember(member);
+		}
+	}
+}
+function analyzeFeaturesFromXml(osm, refElements) {
+	parseOsmXml(osm, refElements);
+}
+function osm2geojson(osm, opts) {
+	let { completeFeature, renderTagged, excludeWay, elementId, tainted, polygonTags } = parseOptions(opts);
+	let format = detectFormat(osm);
+	const refElements = new RefElements();
+	refElements.reportTainted = tainted;
+	refElements.polygonTags = polygonTags;
+	let featureArray = [];
+	if (format === "json-raw") {
+		osm = JSON.parse(osm);
+		if (osm.elements) format = "json";
+		else format = "invalid";
+	}
+	if (format === "json") analyzeFeaturesFromJson(osm, refElements);
+	else if (format === "xml") analyzeFeaturesFromXml(osm, refElements);
+	refElements.bindAll();
+	if (elementId) {
+		const element = refElements.get(elementId);
+		return element ? element.toFeatureArray()[0] : void 0;
+	}
+	for (const v of refElements.values()) {
+		if (v.refCount > 0 && (!v.hasTag || !renderTagged || v instanceof Way && excludeWay)) continue;
+		const features = v.toFeatureArray();
+		if (v instanceof Relation && !completeFeature && features.length > 0) return features[0].geometry;
+		for (const feature of features) featureArray.push(feature);
+	}
+	return {
+		type: "FeatureCollection",
+		features: featureArray
+	};
+}
+// src/cli.ts
+function printHelp() {
+	process.stdout.write([
+		"Convert OpenStreetMap XML or JSON data to GeoJSON.",
+		"",
+		"Usage:",
+		"  npx osm2geojson-lite INPUT_FILE OUTPUT_FILE",
+		"  npx osm2geojson-lite < INPUT_FILE > OUTPUT_FILE",
+		""
+	].join("\n"));
+}
+async function main(positionals) {
+	const [inputFile = "/dev/stdin", outputFile = "/dev/stdout"] = positionals;
+	const geojson = osm2geojson(await readFile(inputFile, "utf-8"), {
+		completeFeature: true,
+		renderTagged: true
+	});
+	const geoJsonData = JSON.stringify(geojson);
+	await writeFile(outputFile, `${geoJsonData}\n`);
+}
+const { values, positionals } = parseArgs({
+	args: process.argv.slice(2),
+	allowPositionals: true,
+	options: { help: {
+		short: "h",
+		type: "boolean"
+	} }
+});
+if (values.help) printHelp();
+else main(positionals).catch((err) => {
+	process.stderr.write(`${err.stack}\n`);
+	process.exit(1);
+});