osm2geojson-lite 2.0.1 → 2.1.0

package/dist/index.mjs

@@ -1,8 +1,4 @@
-//#region \0rolldown/runtime.js
-var __esmMin = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
-//#endregion
-//#region src/utils.ts
+// src/utils.ts
 function purgeProps(obj, blacklist) {
 	if (obj) {
 		const rs = Object.assign({}, obj);
@@ -37,11 +33,56 @@ function getFirstFromMap(m, k) {
 	return null;
 }
 function isRing(a) {
-	return a.length > 3 && coordsToKey(first(a)) === coordsToKey(last(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;
-	const m = a.reduce((maxxIdx, v, idx) => a[maxxIdx][xIdx || 0] > v[xIdx || 0] ? maxxIdx : idx, 0);
+	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];
@@ -52,242 +93,152 @@ function ringDirection(a, xIdx, 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;
-	for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) if ((polygon[i][xIdx] <= pt[xIdx] && pt[xIdx] < polygon[j][xIdx] || polygon[j][xIdx] <= pt[xIdx] && pt[xIdx] < polygon[i][xIdx]) && pt[yIdx] < (polygon[j][yIdx] - polygon[i][yIdx]) * (pt[xIdx] - polygon[i][xIdx]) / (polygon[j][xIdx] - polygon[i][xIdx]) + polygon[i][yIdx]) result = !result;
+	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;
 }
-function strArrayArrayToFloat(el) {
-	return el.map(strArrayToFloat);
-}
-function strArrayToFloat(el) {
-	return el.map(parseFloat);
-}
-var init_utils = __esmMin((() => {}));
-//#endregion
-//#region src/xmlparser.ts
-function conditioned(evt) {
-	return evt.match(/^(.+?)\[(.+?)\]>$/g) !== null;
-}
-function parseEvent(evt) {
-	const match = /^(.+?)\[(.+?)\]>$/g.exec(evt);
-	if (match) return {
-		evt: match[1] + ">",
-		exp: match[2]
-	};
-	return { evt };
-}
-function genConditionFunc(cond) {
-	const body = "return " + cond.replace(/(\$.+?)(?=[=!.])/g, "node.$&") + ";";
-	return new Function("node", body);
-}
-var XmlParser;
-var init_xmlparser = __esmMin((() => {
-	XmlParser = class {
-		constructor(opts) {
-			this.queryParent = false;
-			this.progressive = false;
-			this.parentMap = /* @__PURE__ */ new WeakMap();
-			if (opts) {
-				this.queryParent = opts.queryParent ? true : false;
-				this.progressive = opts.progressive;
-				if (this.queryParent) this.parentMap = /* @__PURE__ */ new WeakMap();
-			}
-			this.evtListeners = {};
-		}
-		parse(xml, parent, dir) {
-			dir = dir ? dir + "." : "";
-			const nodeRegEx = /<([^ >\/]+)(.*?)>/gm;
-			const nodes = [];
-			let nodeMatch = nodeRegEx.exec(xml);
-			while (nodeMatch) {
-				const tag = nodeMatch[1];
-				const node = { $tag: tag };
-				const fullTag = dir + tag;
-				const attrText = nodeMatch[2].trim();
-				let closed = false;
-				if (attrText.endsWith("/") || tag.startsWith("?") || tag.startsWith("!")) closed = true;
-				const attRegEx1 = /([^ ]+?)="(.+?)"/g;
-				const attRegEx2 = /([^ ]+?)='(.+?)'/g;
-				let attMatch = attRegEx1.exec(attrText);
-				let hasAttrs = false;
-				while (attMatch) {
-					hasAttrs = true;
-					node[attMatch[1]] = attMatch[2];
-					attMatch = attRegEx1.exec(attrText);
-				}
-				if (!hasAttrs) {
-					attMatch = attRegEx2.exec(attrText);
-					while (attMatch) {
-						hasAttrs = true;
-						node[attMatch[1]] = attMatch[2];
-						attMatch = attRegEx2.exec(attrText);
-					}
-				}
-				if (!hasAttrs && attrText !== "") node.text = attrText;
-				if (this.progressive) this.emit(`<${fullTag}>`, node, parent);
-				if (!closed) {
-					const innerRegEx = new RegExp(`([^]+?)<\/${tag}>`, "g");
-					innerRegEx.lastIndex = nodeRegEx.lastIndex;
-					const innerMatch = innerRegEx.exec(xml);
-					if (innerMatch && innerMatch[1]) {
-						nodeRegEx.lastIndex = innerRegEx.lastIndex;
-						const innerNodes = this.parse(innerMatch[1], node, fullTag);
-						if (innerNodes.length > 0) node.$innerNodes = innerNodes;
-						else node.$innerText = innerMatch[1];
-					}
-				}
-				if (this.queryParent && parent) this.parentMap.set(node, parent);
-				if (this.progressive) this.emit(`</${fullTag}>`, node, parent);
-				nodes.push(node);
-				nodeMatch = nodeRegEx.exec(xml);
-			}
-			return nodes;
-		}
-		getParent(node) {
-			if (this.queryParent) return this.parentMap.get(node);
-			return null;
-		}
-		addListener(evt, func) {
-			if (conditioned(evt)) {
-				const ev = parseEvent(evt);
-				if (ev.exp) func.condition = genConditionFunc(ev.exp);
-				evt = ev.evt;
+// 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]
 			}
-			this.$addListener(evt, func);
-		}
-		removeListener(evt, func) {
-			if (conditioned(evt)) evt = parseEvent(evt).evt;
-			this.$removeListener(evt, func);
-		}
-		on(evt, func) {
-			this.addListener(evt, func);
-		}
-		off(evt, func) {
-			this.removeListener(evt, func);
-		}
-		$addListener(evt, func) {
-			const funcs = this.evtListeners[evt];
-			if (funcs) funcs.push(func);
-			else this.evtListeners[evt] = [func];
-		}
-		$removeListener(evt, func) {
-			const funcs = this.evtListeners[evt];
-			let idx = -1;
-			if (funcs) idx = funcs.indexOf(func);
-			if (idx >= 0) funcs.splice(idx, 1);
-		}
-		emit(evt, ...args) {
-			const funcs = this.evtListeners[evt];
-			if (funcs) for (const func of funcs) if (func.condition) {
-				if (func.condition.apply(null, args) === true) func.apply(null, args);
-			} else func.apply(null, args);
-		}
-	};
-}));
-//#endregion
-//#region src/osm-object.ts
-var OsmObject;
-var init_osm_object = __esmMin((() => {
-	OsmObject = class {
-		constructor(type, id, refElems) {
-			this.type = type;
-			this.id = id;
-			this.refElems = refElems;
-			this.tags = {};
-			this.props = { id: this.getCompositeId() };
-			this.refCount = 0;
-			this.hasTag = false;
-			if (refElems) 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() {
-			return Object.assign(this.props, this.tags);
-		}
-	};
-}));
-//#endregion
-//#region src/node.ts
-var Node;
-var init_node = __esmMin((() => {
-	init_osm_object();
-	init_utils();
-	Node = class extends OsmObject {
-		constructor(id, refElems) {
-			super("node", id, refElems);
-		}
-		setLatLng(latLng) {
-			this.latLng = latLng;
-		}
-		toFeatureArray() {
-			if (this.latLng) return [{
-				type: "Feature",
-				id: this.getCompositeId(),
-				properties: this.getProps(),
-				geometry: {
-					type: "Point",
-					coordinates: strArrayToFloat([this.latLng.lon, this.latLng.lat])
-				}
-			}];
-			return [];
-		}
-		getLatLng() {
-			return this.latLng;
-		}
-	};
-}));
-//#endregion
-//#region src/late-binder.ts
-var LateBinder;
-var init_late_binder = __esmMin((() => {
-	LateBinder = class {
-		constructor(container, valueFunc, ctx, args) {
-			this.container = container;
-			this.valueFunc = valueFunc;
-			this.ctx = ctx;
-			this.args = args;
-		}
-		bind() {
-			const v = this.valueFunc.apply(this.ctx, this.args);
-			const idx = this.container.indexOf(this);
-			if (idx < 0) return;
-			const args = [idx, 1];
-			if (v) args.push(v);
-			Array.prototype.splice.apply(this.container, args);
-		}
-	};
-}));
-//#endregion
-//#region src/polytags.json
-init_xmlparser();
-init_node();
-init_late_binder();
-var polytags_default = {
-	building: {},
-	highway: { "whitelist": [
+		}];
+		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: { "blacklist": [
+	natural: { "exclude": [
 		"coastline",
 		"cliff",
 		"ridge",
@@ -295,7 +246,7 @@ var polytags_default = {
 		"tree_row"
 	] },
 	landuse: {},
-	waterway: { "whitelist": [
+	waterway: { "include": [
 		"riverbank",
 		"dock",
 		"boatyard",
@@ -303,7 +254,7 @@ var polytags_default = {
 	] },
 	amenity: {},
 	leisure: {},
-	barrier: { "whitelist": [
+	barrier: { "include": [
 		"city_wall",
 		"ditch",
 		"hedge",
@@ -311,481 +262,1124 @@ var polytags_default = {
 		"wall",
 		"spikes"
 	] },
-	railway: { "whitelist": [
+	railway: { "include": [
 		"station",
 		"turntable",
 		"roundhouse",
 		"platform"
 	] },
-	area: {},
 	boundary: {},
-	man_made: { "blacklist": [
+	man_made: { "exclude": [
 		"cutline",
 		"embankment",
 		"pipeline"
 	] },
-	power: { "whitelist": [
+	power: { "include": [
 		"plant",
 		"substation",
 		"generator",
 		"transformer"
 	] },
+	"piste:type": { "include": ["downhill"] },
 	place: {},
 	shop: {},
-	aeroway: { "blacklist": ["taxiway"] },
+	aeroway: { "exclude": ["taxiway"] },
 	tourism: {},
 	historic: {},
 	public_transport: {},
 	office: {},
-	"building:part": {},
+	"building:part": { "ignore": ["no"] },
 	military: {},
 	ruins: {},
 	"area:highway": {},
 	craft: {},
 	golf: {},
-	indoor: {}
+	indoor: { "ignore": ["yes", "no"] },
+	area: { "exclude": ["no"] }
 };
-//#endregion
-//#region src/way.ts
-var Way;
-var init_way = __esmMin((() => {
-	init_osm_object();
-	init_utils();
-	Way = class extends OsmObject {
-		constructor(id, refElems) {
-			super("way", id, refElems);
-			this.latLngArray = [];
-			this.isPolygon = false;
-		}
-		addLatLng(latLng) {
-			this.latLngArray.push(latLng);
-		}
-		setLatLngArray(latLngArray) {
-			this.latLngArray = latLngArray;
-		}
-		addNodeRef(ref) {
-			const binder = new LateBinder(this.latLngArray, (id) => {
-				const node = this.refElems.get(`node/${id}`);
-				if (node) {
-					node.refCount++;
-					return node.getLatLng();
+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
 				}
-			}, this, [ref]);
-			this.latLngArray.push(binder);
-			this.refElems.addBinder(binder);
-		}
-		addTags(tags) {
-			super.addTags(tags);
-			for (const [k, v] of Object.entries(tags)) this.analyzeTag(k, v);
-		}
-		addTag(k, v) {
-			super.addTag(k, v);
-			this.analyzeTag(k, v);
-		}
-		toCoordsArray() {
-			return this.latLngArray.map((latLng) => [latLng.lon, latLng.lat]);
-		}
-		toFeatureArray() {
-			let coordsArrayString = this.toCoordsArray();
-			if (coordsArrayString.length > 1) {
-				const coordsArray = strArrayArrayToFloat(coordsArrayString);
-				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]
 				};
-				if (this.isPolygon && isRing(coordsArray)) {
-					if (ringDirection(coordsArray) !== "counterclockwise") coordsArray.reverse();
-					feature.geometry = {
-						type: "Polygon",
-						coordinates: [coordsArray]
-					};
-					return [feature];
-				}
-				return [feature];
-			}
-			return [];
-		}
-		analyzeTag(k, v) {
-			const o = polytags_default[k];
-			if (o) {
-				this.isPolygon = true;
-				if (o.whitelist) this.isPolygon = o.whitelist.indexOf(v) >= 0 ? true : false;
-				else if (o.blacklist) this.isPolygon = o.blacklist.indexOf(v) >= 0 ? false : true;
 			}
+			return [feature];
 		}
-	};
-}));
-//#endregion
-//#region src/way-collection.ts
-var WayCollection;
-var init_way_collection = __esmMin((() => {
-	init_utils();
-	WayCollection = class extends Array {
-		constructor() {
-			super();
-			this.firstMap = {};
-			this.lastMap = {};
-		}
-		addWay(way) {
-			const w = way.toCoordsArray();
-			if (w.length > 0) {
-				this.push(w);
-				addToMap(this.firstMap, coordsToKey(first(w)), w);
-				addToMap(this.lastMap, coordsToKey(last(w)), w);
+		if (this.bounds) return [{
+			type: "Feature",
+			id: this.getCompositeId(),
+			properties: this.getProps(),
+			geometry: {
+				type: "Polygon",
+				coordinates: [boundsToRing(this.bounds)]
 			}
-		}
-		mergeWays() {
-			const strings = [];
-			let way = this.shift();
-			while (way) {
-				removeFromMap(this.firstMap, coordsToKey(first(way)), way);
-				removeFromMap(this.lastMap, coordsToKey(last(way)), way);
-				let current = way;
-				let next;
-				do {
-					let nextWay = this.getNextWay(current);
-					next = nextWay.next;
-					let mergeType = nextWay.mergeType;
-					if (!next) continue;
-					this.splice(this.indexOf(next), 1);
-					removeFromMap(this.firstMap, coordsToKey(first(next)), next);
-					removeFromMap(this.lastMap, coordsToKey(last(next)), next);
-					switch (mergeType) {
-						case 0:
-							current = current.concat(next.slice(1));
-							break;
-						case 1:
-							next.reverse();
-							current = current.concat(next.slice(1));
-							break;
-						case 2:
-							current.reverse();
-							current = current.concat(next.slice(1));
-							break;
-						case 3:
-							current = next.concat(current.slice(1));
-							current.reverse();
-							break;
-					}
-				} while (next);
-				strings.push(strArrayArrayToFloat(current));
-				way = this.shift();
+		}];
+		if (this.center) return [{
+			type: "Feature",
+			id: this.getCompositeId(),
+			properties: this.getProps(),
+			geometry: {
+				type: "Point",
+				coordinates: [+this.center.lon, +this.center.lat]
 			}
-			return strings;
-		}
-		/**
-		* Try to find the next way to add to the current way.
-		* It first tries the next way in the array, and if this doesn't work, try any other way.
-		*/
-		getNextWay(current) {
-			const lastKey = coordsToKey(last(current));
-			const firstKey = coordsToKey(first(current));
-			let next = this.length > 0 ? this[0] : null;
-			if (next) {
-				const nextFirstKey = coordsToKey(first(next));
-				const nextLastKey = coordsToKey(last(next));
-				if (lastKey === nextFirstKey) return {
-					next,
-					mergeType: 0
-				};
-				if (lastKey === nextLastKey) return {
-					next,
-					mergeType: 1
-				};
-				if (firstKey === nextFirstKey) return {
-					next,
-					mergeType: 2
-				};
-				if (firstKey === nextLastKey) return {
-					next,
-					mergeType: 3
-				};
+		}];
+		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]);
+				}
 			}
-			next = getFirstFromMap(this.firstMap, lastKey);
-			if (next) return {
+			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
 			};
-			next = getFirstFromMap(this.lastMap, lastKey);
-			return {
+			if (tailKey === nextLastKey) return {
 				next,
 				mergeType: 1
 			};
+			if (headKey === nextFirstKey) return {
+				next,
+				mergeType: 2
+			};
+			if (headKey === nextLastKey) return {
+				next,
+				mergeType: 3
+			};
 		}
-		toRings(direction) {
-			const strings = this.mergeWays();
-			const rings = [];
-			let str = strings.shift();
-			while (str) {
-				if (isRing(str)) {
-					if (ringDirection(str) !== direction) str.reverse();
-					rings.push(str);
-				}
-				str = strings.shift();
+		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;
 		}
-	};
-}));
-//#endregion
-//#region src/relation.ts
-var Relation;
-var init_relation = __esmMin((() => {
-	init_osm_object();
-	init_way();
-	init_way_collection();
-	init_late_binder();
-	init_utils();
-	Relation = class extends OsmObject {
-		constructor(id, refElems) {
-			super("relation", id, refElems);
-			this.relations = [];
-			this.nodes = [];
-			this.bounds = void 0;
-			this.ways = [];
-			this.roles = [];
-		}
-		setBounds(bounds) {
-			this.bounds = bounds;
-		}
-		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;
+		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.relations.push(binder);
+					this.ways.push(binder);
+					this.roles.push(member.role);
 					this.refElems.addBinder(binder);
-					break;
-				case "way":
-					if (!member.role) member.role = "";
-					if (member.geometry) {
-						const way = new Way(member.ref, this.refElems);
-						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);
-						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, [member.ref]);
-						this.ways.push(binder);
-						this.roles.push(member.role);
-						this.refElems.addBinder(binder);
-					}
-					break;
-				case "node":
-					let node = null;
-					if (member.lat && member.lon) {
-						node = new Node(member.ref, this.refElems);
-						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, [member.ref]);
-						this.nodes.push(binder);
-						this.refElems.addBinder(binder);
-					}
-					break;
-			}
-		}
-		constructStringGeometry(ws) {
-			const strings = ws ? ws.mergeWays() : [];
-			if (strings.length === 0) return null;
-			return {
-				type: "MultiLineString",
-				coordinates: strings
-			};
+				}
+				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);
+				}
 		}
-		constructPolygonGeometry(ows, iws) {
-			const outerRings = ows ? ows.toRings("counterclockwise") : [];
-			const innerRings = iws ? iws.toRings("clockwise") : [];
-			if (outerRings.length > 0) {
-				const compositPolyons = [];
-				let ring;
-				for (ring of outerRings) compositPolyons.push([ring]);
-				ring = innerRings.shift();
-				while (ring) {
-					for (const idx in outerRings) if (pointInsidePolygon(first(ring), outerRings[idx])) {
+	}
+	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;
 					}
-					ring = innerRings.shift();
 				}
-				if (compositPolyons.length === 1) return {
-					type: "Polygon",
-					coordinates: compositPolyons[0]
-				};
-				return {
-					type: "MultiPolygon",
-					coordinates: compositPolyons
-				};
 			}
-			return null;
-		}
-		collectAllWaysForRelation(relation, relationToWaysMap) {
-			const ways = [...relation.ways];
-			const roles = [...relation.roles];
-			if (relation.relations.length === 0) {
-				relationToWaysMap.set(relation.id, {
-					ways,
-					roles
+			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
 				});
-				return {
-					ways,
-					roles
-				};
+				if (frame.tags) node.addTags(frame.tags);
 			}
-			for (const subRelation of relation.relations) {
-				if (!subRelation) continue;
-				if (!relationToWaysMap.has(subRelation.id)) this.collectAllWaysForRelation(subRelation, relationToWaysMap);
-				const entry = relationToWaysMap.get(subRelation.id);
-				for (let i = 0; i < entry.ways.length; i++) {
-					ways.push(entry.ways[i]);
-					roles.push(entry.roles[i]);
-				}
+			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);
 			}
-			relationToWaysMap.set(relation.id, {
-				ways,
-				roles
-			});
-			return {
-				ways,
-				roles
+			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;
 		}
-		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
+		case 5:
+			if (parent && (parent.kind === 1 || parent.kind === 2 || parent.kind === 3)) parent.derived.geometry = {
+				type: "Polygon",
+				coordinates: [frame.lineCoords]
 			};
-			if (!this.bounds) delete templateFeature.bbox;
-			if (this.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);
+			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;
 				}
-				let feature = Object.assign({}, templateFeature);
-				let geometry = this.constructPolygonGeometry(outerWayCollection, innerWayCollection);
-				if (geometry) {
-					feature.geometry = geometry;
-					polygonFeatures.push(feature);
+				break;
+			case "way":
+				if (isRoot(topKind)) {
+					kind = 2;
+					attrMode = 1;
 				}
-			} else {
-				const wayCollection = new WayCollection();
-				for (let way of waysAndRoles.ways) wayCollection.addWay(way);
-				let geometry = this.constructStringGeometry(wayCollection);
-				if (geometry) {
-					let feature = Object.assign({}, templateFeature);
-					feature.geometry = geometry;
-					stringFeatures.push(feature);
+				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;
 				}
 			}
-			for (let node of this.nodes) pointFeatures = pointFeatures.concat(node.toFeatureArray());
-			return [
-				...polygonFeatures,
-				...stringFeatures,
-				...pointFeatures
-			];
+			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;
+			}
 		}
-	};
-}));
-//#endregion
-//#region src/ref-elements.ts
-var RefElements;
-var init_ref_elements = __esmMin((() => {
-	RefElements = class extends Map {
-		constructor() {
-			super();
-			this.binders = [];
+		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;
 		}
-		add(k, v) {
-			this.set(k, v);
+		if (attrMode === 3) {
+			if (parent && k) {
+				const tags = parent.tags || (parent.tags = {});
+				tags[k] = v;
+			}
+			if (!selfClose) stack.push({ kind: 7 });
+			continue;
 		}
-		addBinder(binder) {
-			this.binders.push(binder);
+		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;
 		}
-		bindAll() {
-			this.binders.forEach((binder) => binder.bind());
+		if (attrMode === 6) {
+			if (parent) parent.center = {
+				lat,
+				lon
+			};
+			if (!selfClose) stack.push({ kind: 7 });
+			continue;
 		}
-	};
-}));
-//#endregion
-//#region src/index.ts
-var require_src = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	init_utils();
-	init_node();
-	init_way();
-	init_relation();
-	init_ref_elements();
-	function parseOptions(options) {
-		if (!options) return {
-			completeFeature: false,
-			renderTagged: false,
-			excludeWay: true
-		};
-		let excludeWay = options.excludeWay === void 0 || options.excludeWay;
-		return {
-			completeFeature: options.completeFeature ? true : false,
-			renderTagged: options.renderTagged ? true : false,
-			excludeWay
-		};
+		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);
 	}
-	function detectFormat(o) {
-		if (o.elements) return "json";
+}
+// 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) switch (elem.type) {
+	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);
@@ -809,7 +1403,14 @@ var require_src = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 					"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);
@@ -820,6 +1421,7 @@ var require_src = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 					parseFloat(elem.bounds.maxlat)
 				]);
 				if (elem.tags) relation.addTags(elem.tags);
+				if (elem.center) relation.setCenter(elem.center);
 				relation.addProps(purgeProps(elem, [
 					"id",
 					"type",
@@ -828,97 +1430,40 @@ var require_src = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 					"members"
 				]));
 				if (elem.members) for (const member of elem.members) relation.addMember(member);
-			default: break;
 		}
 	}
-	function analyzeFeaturesFromXml(osm, refElements) {
-		const xmlParser = new XmlParser({ progressive: true });
-		xmlParser.on("</osm.node>", (node) => {
-			const nd = new Node(node.id, refElements);
-			for (const [k, v] of Object.entries(node)) if (!k.startsWith("$") && [
-				"id",
-				"lon",
-				"lat"
-			].indexOf(k) < 0) nd.addProp(k, v);
-			nd.setLatLng(node);
-			if (node.$innerNodes) {
-				for (const ind of node.$innerNodes) if (ind.$tag === "tag") nd.addTag(ind.k, ind.v);
-			}
-		});
-		xmlParser.on("</osm.way>", (node) => {
-			const way = new Way(node.id, refElements);
-			for (const [k, v] of Object.entries(node)) if (!k.startsWith("$") && ["id"].indexOf(k) < 0) way.addProp(k, v);
-			if (node.$innerNodes) {
-				for (const ind of node.$innerNodes) if (ind.$tag === "nd") {
-					if (ind.lon && ind.lat) way.addLatLng(ind);
-					else if (ind.ref) way.addNodeRef(ind.ref);
-				} else if (ind.$tag === "tag") way.addTag(ind.k, ind.v);
-			}
-		});
-		xmlParser.on("<osm.relation>", (node) => new Relation(node.id, refElements));
-		xmlParser.on("</osm.relation.member>", (node, parent) => {
-			const relation = refElements.get(`relation/${parent?.id}`);
-			const member = {
-				type: node.type,
-				role: node.role ? node.role : "",
-				ref: node.ref
-			};
-			if (node.lat && node.lon) {
-				member.lat = node.lat, member.lon = node.lon, member.tags = {};
-				for (const [k, v] of Object.entries(node)) if (!k.startsWith("$") && [
-					"type",
-					"lat",
-					"lon"
-				].indexOf(k) < 0) member[k] = v;
-			}
-			if (node.$innerNodes) {
-				const geometry = [];
-				const nodes = [];
-				for (const ind of node.$innerNodes) if (ind.lat && ind.lon) geometry.push(ind);
-				else if (ind.ref) nodes.push(ind.ref);
-				if (geometry.length > 0) member.geometry = geometry;
-				else if (nodes.length > 0) member.nodes = nodes;
-			}
-			relation.addMember(member);
-		});
-		xmlParser.on("</osm.relation.bounds>", (node, parent) => {
-			refElements.get(`relation/${parent?.id}`).setBounds([
-				parseFloat(node.minlon),
-				parseFloat(node.minlat),
-				parseFloat(node.maxlon),
-				parseFloat(node.maxlat)
-			]);
-		});
-		xmlParser.on("</osm.relation.tag>", (node, parent) => {
-			refElements.get(`relation/${parent?.id}`).addTag(node.k, node.v);
-		});
-		xmlParser.parse(osm);
-	}
-	function osm2geojson(osm, opts) {
-		let { completeFeature, renderTagged, excludeWay } = parseOptions(opts);
-		let format = detectFormat(osm);
-		const refElements = new RefElements();
-		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();
-		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;
-			featureArray = featureArray.concat(features);
-		}
-		return {
-			type: "FeatureCollection",
-			features: featureArray
-		};
+}
+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";
 	}
-	module.exports = osm2geojson;
-}));
-//#endregion
-export default require_src();
+	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
+	};
+}
+export { osm2geojson as default };