mudlet-map-renderer 2.0.0 → 2.2.0

package/dist/flushSceneShapes-Duhi0OQv.js

@@ -0,0 +1,2937 @@
+import e from "konva";
+//#region src/utils/color.ts
+function t(e) {
+	let t, n, r, i = e.match(/(\d+)\s*,\s*(\d+)\s*,\s*(\d+)/);
+	if (i) t = parseInt(i[1]) / 255, n = parseInt(i[2]) / 255, r = parseInt(i[3]) / 255;
+	else if (e.startsWith("#") && e.length >= 7) t = parseInt(e.slice(1, 3), 16) / 255, n = parseInt(e.slice(3, 5), 16) / 255, r = parseInt(e.slice(5, 7), 16) / 255;
+	else return .5;
+	return (Math.max(t, n, r) + Math.min(t, n, r)) / 2;
+}
+function n(e, t) {
+	let n, r, i, a = e.match(/(\d+)\s*,\s*(\d+)\s*,\s*(\d+)/);
+	if (a) n = parseInt(a[1]), r = parseInt(a[2]), i = parseInt(a[3]);
+	else if (e.startsWith("#") && e.length >= 7) n = parseInt(e.slice(1, 3), 16), r = parseInt(e.slice(3, 5), 16), i = parseInt(e.slice(5, 7), 16);
+	else return e;
+	return n = Math.round(n * (1 - t)), r = Math.round(r * (1 - t)), i = Math.round(i * (1 - t)), `rgb(${n}, ${r}, ${i})`;
+}
+function r(e, t) {
+	let n, r, i, a = e.match(/(\d+)\s*,\s*(\d+)\s*,\s*(\d+)/);
+	if (a) n = parseInt(a[1]), r = parseInt(a[2]), i = parseInt(a[3]);
+	else if (e.startsWith("#") && e.length >= 7) n = parseInt(e.slice(1, 3), 16), r = parseInt(e.slice(3, 5), 16), i = parseInt(e.slice(5, 7), 16);
+	else return e;
+	return n = Math.min(255, Math.round(n + (255 - n) * t)), r = Math.min(255, Math.round(r + (255 - r) * t)), i = Math.min(255, Math.round(i + (255 - i) * t)), `rgb(${n}, ${r}, ${i})`;
+}
+var i = {
+	black: [
+		0,
+		0,
+		0
+	],
+	white: [
+		255,
+		255,
+		255
+	],
+	red: [
+		255,
+		0,
+		0
+	],
+	green: [
+		0,
+		128,
+		0
+	],
+	lime: [
+		0,
+		255,
+		0
+	],
+	blue: [
+		0,
+		0,
+		255
+	],
+	yellow: [
+		255,
+		255,
+		0
+	],
+	cyan: [
+		0,
+		255,
+		255
+	],
+	aqua: [
+		0,
+		255,
+		255
+	],
+	magenta: [
+		255,
+		0,
+		255
+	],
+	fuchsia: [
+		255,
+		0,
+		255
+	],
+	silver: [
+		192,
+		192,
+		192
+	],
+	gray: [
+		128,
+		128,
+		128
+	],
+	grey: [
+		128,
+		128,
+		128
+	],
+	maroon: [
+		128,
+		0,
+		0
+	],
+	olive: [
+		128,
+		128,
+		0
+	],
+	purple: [
+		128,
+		0,
+		128
+	],
+	teal: [
+		0,
+		128,
+		128
+	],
+	navy: [
+		0,
+		0,
+		128
+	],
+	orange: [
+		255,
+		165,
+		0
+	],
+	pink: [
+		255,
+		192,
+		203
+	],
+	gold: [
+		255,
+		215,
+		0
+	],
+	brown: [
+		165,
+		42,
+		42
+	],
+	violet: [
+		238,
+		130,
+		238
+	],
+	indigo: [
+		75,
+		0,
+		130
+	],
+	transparent: [
+		0,
+		0,
+		0
+	]
+};
+function a(e, t) {
+	let n = e.trim();
+	if (n.startsWith("#")) {
+		let r, i, a;
+		if (n.length === 4) r = parseInt(n[1] + n[1], 16), i = parseInt(n[2] + n[2], 16), a = parseInt(n[3] + n[3], 16);
+		else if (n.length >= 7) r = parseInt(n.slice(1, 3), 16), i = parseInt(n.slice(3, 5), 16), a = parseInt(n.slice(5, 7), 16);
+		else return e;
+		return Number.isNaN(r) || Number.isNaN(i) || Number.isNaN(a) ? e : `rgba(${r}, ${i}, ${a}, ${t})`;
+	}
+	let r = n.match(/^rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*([\d.]+)\s*)?\)$/i);
+	if (r) return `rgba(${parseInt(r[1], 10)}, ${parseInt(r[2], 10)}, ${parseInt(r[3], 10)}, ${r[4] === void 0 ? t : parseFloat(r[4]) * t})`;
+	let a = i[n.toLowerCase()];
+	return a ? `rgba(${a[0]}, ${a[1]}, ${a[2]}, ${t})` : e;
+}
+//#endregion
+//#region src/TypedEventEmitter.ts
+var o = class {
+	constructor(e) {
+		this.listeners = /* @__PURE__ */ new Map(), this.container = e;
+	}
+	on(e, t) {
+		let n = this.listeners.get(e);
+		n || (n = /* @__PURE__ */ new Set(), this.listeners.set(e, n)), n.add(t);
+	}
+	off(e, t) {
+		this.listeners.get(e)?.delete(t);
+	}
+	removeAllListeners() {
+		this.listeners.clear();
+	}
+	emit(e, t) {
+		this.listeners.get(e)?.forEach((e) => e(t)), this.container && this.container.dispatchEvent(new CustomEvent(e, { detail: t }));
+	}
+}, s = {
+	isVisible: () => !0,
+	getVersion: () => 0
+};
+function c(e, t, n, r) {
+	let i = e.isVisible(n), a = e.isVisible(r);
+	return i && a ? "full" : i || a ? "stub" : "hidden";
+}
+function l(e) {
+	return e < .5 ? 2 * e * e : -1 + (4 - 2 * e) * e;
+}
+var u = class e extends o {
+	constructor(e, t) {
+		super(), this.zoom = 1, this.minZoom = .05, this.position = {
+			x: 0,
+			y: 0
+		}, this.centerOnResize = !0, this.dragging = !1, this.dragStart = {
+			x: 0,
+			y: 0
+		}, this.positionAtDragStart = {
+			x: 0,
+			y: 0
+		}, this.batchDepth = 0, this.batchDirty = !1, this.width = e, this.height = t;
+	}
+	getScale() {
+		return 75 * this.zoom;
+	}
+	setZoom(e) {
+		let t = Math.max(this.minZoom, e);
+		return this.zoom === t ? !1 : (this.zoom = t, this.notify(), !0);
+	}
+	zoomToCenter(e) {
+		let t = Math.max(this.minZoom, e);
+		if (this.zoom === t) return !1;
+		let n = this.getScale(), r = this.width / 2, i = this.height / 2, a = {
+			x: (r - this.position.x) / n,
+			y: (i - this.position.y) / n
+		};
+		this.zoom = t;
+		let o = this.getScale();
+		return this.position = {
+			x: r - a.x * o,
+			y: i - a.y * o
+		}, this.notify(), !0;
+	}
+	zoomToPoint(e, t, n) {
+		let r = this.getScale(), i = {
+			x: (t - this.position.x) / r,
+			y: (n - this.position.y) / r
+		}, a = Math.max(this.minZoom, e);
+		if (this.zoom === a) return !1;
+		this.zoom = a;
+		let o = this.getScale();
+		return this.position = {
+			x: t - i.x * o,
+			y: n - i.y * o
+		}, this.notify(), !0;
+	}
+	getViewportBounds() {
+		let e = this.getScale();
+		return {
+			minX: (0 - this.position.x) / e,
+			maxX: (this.width - this.position.x) / e,
+			minY: (0 - this.position.y) / e,
+			maxY: (this.height - this.position.y) / e
+		};
+	}
+	getCullingViewport(e) {
+		if (!e) return this.getViewportBounds();
+		let t = this.getScale(), n = this.position;
+		return {
+			minX: (e.x - n.x) / t,
+			maxX: (e.x + e.width - n.x) / t,
+			minY: (e.y - n.y) / t,
+			maxY: (e.y + e.height - n.y) / t
+		};
+	}
+	static forMapBounds(t, n, r, i) {
+		let a = new e((n - t) * 75, (i - r) * 75);
+		return a.zoom = 1, a.position = {
+			x: -t * 75,
+			y: -r * 75
+		}, a;
+	}
+	static forRenderCamera(t, n, r, i, a) {
+		let o = new e(t, n);
+		return o.zoom = r / 75, o.position = {
+			x: i,
+			y: a
+		}, o;
+	}
+	clientToMapPoint(e, t, n) {
+		let r = e - (n?.left ?? 0), i = t - (n?.top ?? 0), a = this.getScale();
+		return a ? {
+			x: (r - this.position.x) / a,
+			y: (i - this.position.y) / a
+		} : null;
+	}
+	panToMapPoint(e, t) {
+		let n = this.getScale();
+		this.position = {
+			x: this.width / 2 - e * n,
+			y: this.height / 2 - t * n
+		}, this.notify();
+	}
+	panToMapPointAnimated(e, t, n) {
+		if (n) {
+			this.panToMapPoint(e, t);
+			return;
+		}
+		let r = { ...this.position }, i = this.getScale(), a = {
+			x: this.width / 2 - e * i,
+			y: this.height / 2 - t * i
+		};
+		this.animate(200, (e) => {
+			this.position = {
+				x: r.x + (a.x - r.x) * e,
+				y: r.y + (a.y - r.y) * e
+			};
+		});
+	}
+	computeFitZoom(e, t, n, r, i) {
+		let a = t - e, o = r - n;
+		if (a <= 0 || o <= 0) return this.zoom;
+		let s = i?.top ?? 0, c = i?.right ?? 0, l = i?.bottom ?? 0, u = i?.left ?? 0, d = Math.max(1, this.width - u - c), f = Math.max(1, this.height - s - l), p = d / ((a + 4) * 75), m = f / ((o + 4) * 75);
+		return Math.min(p, m);
+	}
+	fitToMapBounds(e, t, n, r, i) {
+		let a = t - e, o = r - n;
+		if (a <= 0 || o <= 0) return;
+		let s = i?.top ?? 0, c = i?.left ?? 0, l = Math.max(1, this.width - c - (i?.right ?? 0)), u = Math.max(1, this.height - s - (i?.bottom ?? 0));
+		this.zoom = this.computeFitZoom(e, t, n, r, i), this.minZoom = this.zoom;
+		let d = this.getScale(), f = (e + t) / 2, p = (n + r) / 2;
+		this.position = {
+			x: c + l / 2 - f * d,
+			y: s + u / 2 - p * d
+		}, this.notify();
+	}
+	setSize(e, t) {
+		this.width = e, this.height = t, this.notify();
+	}
+	startDrag(e, t) {
+		this.cancelAnimation(), this.dragging = !0, this.dragStart = {
+			x: e,
+			y: t
+		}, this.positionAtDragStart = { ...this.position };
+	}
+	updateDrag(e, t) {
+		this.dragging && (this.position = {
+			x: this.positionAtDragStart.x + (e - this.dragStart.x),
+			y: this.positionAtDragStart.y + (t - this.dragStart.y)
+		}, this.notify());
+	}
+	endDrag() {
+		this.dragging = !1;
+	}
+	isDragging() {
+		return this.dragging;
+	}
+	animate(e, t) {
+		this.cancelAnimation();
+		let n = performance.now(), r = typeof requestAnimationFrame < "u" ? requestAnimationFrame : (e) => setTimeout(() => e(performance.now()), 16), i = (a) => {
+			let o = a - n, s = Math.min(o / e, 1);
+			t(l(s)), this.notify(), s < 1 ? this.animationId = r(i) : this.animationId = void 0;
+		};
+		this.animationId = r(i);
+	}
+	cancelAnimation() {
+		this.animationId !== void 0 && ((typeof cancelAnimationFrame < "u" ? cancelAnimationFrame : (e) => clearTimeout(e))(this.animationId), this.animationId = void 0);
+	}
+	isAnimating() {
+		return this.animationId !== void 0;
+	}
+	batch(e) {
+		this.batchDepth++;
+		try {
+			return e();
+		} finally {
+			this.batchDepth--, this.batchDepth === 0 && this.batchDirty && (this.batchDirty = !1, this.emit("change", void 0));
+		}
+	}
+	notify() {
+		if (this.batchDepth > 0) {
+			this.batchDirty = !0;
+			return;
+		}
+		this.emit("change", void 0);
+	}
+}, d = (e, t) => ({
+	x: e,
+	y: t
+}), f = class {
+	constructor(e, t) {
+		this.settings = e, this.onCullingNeeded = t, this.cullingScheduled = !1, this.coordinateTransform = d;
+	}
+	setCoordinateTransform(e) {
+		this.coordinateTransform = e;
+	}
+	getCoordinateTransform() {
+		return this.coordinateTransform;
+	}
+	scheduleCulling() {
+		if (this.cullingScheduled) return;
+		this.cullingScheduled = !0;
+		let e = () => {
+			this.cullingScheduled = !1, this.onCullingNeeded();
+		};
+		typeof requestAnimationFrame < "u" ? requestAnimationFrame(e) : e();
+	}
+	updateCulling() {
+		this.onCullingNeeded();
+	}
+}, p = [
+	"north",
+	"south",
+	"east",
+	"west",
+	"northeast",
+	"northwest",
+	"southeast",
+	"southwest"
+], m = {
+	n: "north",
+	s: "south",
+	e: "east",
+	w: "west",
+	ne: "northeast",
+	nw: "northwest",
+	se: "southeast",
+	sw: "southwest"
+}, h = {
+	north: "n",
+	south: "s",
+	east: "e",
+	west: "w",
+	northeast: "ne",
+	northwest: "nw",
+	southeast: "se",
+	southwest: "sw",
+	up: "u",
+	down: "d",
+	in: "i",
+	out: "o"
+}, g = {
+	north: {
+		x: 0,
+		y: -1
+	},
+	south: {
+		x: 0,
+		y: 1
+	},
+	east: {
+		x: 1,
+		y: 0
+	},
+	west: {
+		x: -1,
+		y: 0
+	},
+	northeast: {
+		x: 1,
+		y: -1
+	},
+	northwest: {
+		x: -1,
+		y: -1
+	},
+	southeast: {
+		x: 1,
+		y: 1
+	},
+	southwest: {
+		x: -1,
+		y: 1
+	}
+}, _ = [
+	"north",
+	"south",
+	"east",
+	"west",
+	"northeast",
+	"northwest",
+	"southeast",
+	"southwest"
+], v = {
+	north: "south",
+	south: "north",
+	east: "west",
+	west: "east",
+	northeast: "southwest",
+	northwest: "southeast",
+	southeast: "northwest",
+	southwest: "northeast"
+};
+function y(e) {
+	return e ? Object.prototype.hasOwnProperty.call(g, e) : !1;
+}
+function b(e, t, n, r = 1) {
+	if (!y(n)) return {
+		x: e,
+		y: t
+	};
+	let i = g[n];
+	return {
+		x: e + i.x * r,
+		y: t + i.y * r
+	};
+}
+function x(e, t, n, r = 1, i = 0) {
+	if (!y(n)) return {
+		x: e,
+		y: t
+	};
+	let a = g[n];
+	if (!(a.x !== 0 && a.y !== 0) || i <= 0) return b(e, t, n, r);
+	let o = r - i + i / Math.SQRT2;
+	return {
+		x: e + a.x * o,
+		y: t + a.y * o
+	};
+}
+function S(e, t, n, r = 1) {
+	if (!y(n)) return {
+		x: e,
+		y: t
+	};
+	let i = g[n], a = Math.atan2(i.y, i.x);
+	return {
+		x: e + Math.cos(a) * r,
+		y: t + Math.sin(a) * r
+	};
+}
+//#endregion
+//#region src/ExitRenderer.ts
+var C = {
+	OPEN_DOOR: "rgb(10, 155, 10)",
+	CLOSED_DOOR: "rgb(226, 205, 59)",
+	LOCKED_DOOR: "rgb(155, 10, 10)",
+	ONE_WAY_FILL: "rgb(155, 10, 10)"
+};
+function w(e) {
+	switch (e) {
+		case 1: return C.OPEN_DOOR;
+		case 2: return C.CLOSED_DOOR;
+		default: return C.LOCKED_DOOR;
+	}
+}
+var T = class {
+	constructor(e, t) {
+		this.mapReader = e, this.settings = t;
+	}
+	getRoomEdgePoint(e, t, n, r) {
+		let i = r - (this.settings.borders ? this.settings.lineWidth / 2 : 0);
+		return this.settings.roomShape === "circle" ? S(e, t, n, i) : this.settings.roomShape === "roundedRectangle" ? x(e, t, n, i, this.settings.roomSize * .2) : b(e, t, n, i);
+	}
+	renderData(e, t) {
+		return this.renderDataWithColor(e, this.settings.lineColor, t);
+	}
+	renderDataWithColor(e, t, n) {
+		let r = e.aDir && p.includes(e.aDir), i = e.bDir && p.includes(e.bDir);
+		if (r && i) return this.renderTwoWayExitData(e, t, n);
+		if (r || i) {
+			let n = r ? "a" : "b";
+			return this.renderOneWayExitData(e, t, n);
+		}
+	}
+	renderTwoWayExitData(e, t, n) {
+		let r = this.mapReader.getRoom(e.a), i = this.mapReader.getRoom(e.b);
+		if (!r || !i || !e.aDir || !e.bDir || r.customLines[h[e.aDir]] && i.customLines[h[e.bDir]] || r.z !== i.z && (n !== i.z && r.customLines[h[e.aDir]] || n !== r.z && i.customLines[h[e.bDir]])) return;
+		let a = this.getRoomEdgePoint(r.x, r.y, e.aDir, this.settings.roomSize / 2), o = this.getRoomEdgePoint(i.x, i.y, e.bDir, this.settings.roomSize / 2), s = [
+			a.x,
+			a.y,
+			o.x,
+			o.y
+		], c = [{
+			points: s,
+			stroke: t,
+			strokeWidth: this.settings.lineWidth
+		}], l = [], u = r.doors[h[e.aDir]] ?? i.doors[h[e.bDir]];
+		if (u) {
+			let e = s[0] + (s[2] - s[0]) / 2, t = s[1] + (s[3] - s[1]) / 2;
+			l.push({
+				x: e - this.settings.roomSize / 4,
+				y: t - this.settings.roomSize / 4,
+				width: this.settings.roomSize / 2,
+				height: this.settings.roomSize / 2,
+				stroke: w(u),
+				strokeWidth: this.settings.lineWidth
+			});
+		}
+		let d = Math.min(s[0], s[2]), f = Math.max(s[0], s[2]), p = Math.min(s[1], s[3]), m = Math.max(s[1], s[3]), g = (r.z === i.z ? void 0 : r.z === n ? i.id : r.id) ?? (r.area === i.area ? void 0 : i.id), _ = g === void 0 ? {} : {
+			from: {
+				x: r.x,
+				y: r.y
+			},
+			tip: {
+				x: o.x,
+				y: o.y
+			},
+			arrowColor: this.mapReader.getColorValue(i.env)
+		};
+		return {
+			lines: c,
+			arrows: [],
+			doors: l,
+			bounds: {
+				x: d,
+				y: p,
+				width: f - d,
+				height: m - p
+			},
+			targetRoomId: g,
+			..._
+		};
+	}
+	renderOneWayExitData(e, t, n) {
+		let r = n === "a" || !n && e.aDir, i = r ? this.mapReader.getRoom(e.a) : this.mapReader.getRoom(e.b), a = r ? this.mapReader.getRoom(e.b) : this.mapReader.getRoom(e.a), o = r ? e.aDir : e.bDir;
+		if (!o || !i || !a || !p.includes(o) || i.customLines[h[o] || o]) return;
+		if (i.area != a.area && o) {
+			let e = this.mapReader.getColorValue(a.env), t = this.getRoomEdgePoint(i.x, i.y, o, this.settings.roomSize / 2), n = b(i.x, i.y, o, this.settings.roomSize * 1.5), r = e;
+			return {
+				lines: [],
+				arrows: [{
+					points: [
+						t.x,
+						t.y,
+						n.x,
+						n.y
+					],
+					pointerLength: .3,
+					pointerWidth: .3,
+					strokeWidth: this.settings.lineWidth * 1.4,
+					stroke: r,
+					fill: r
+				}],
+				doors: [],
+				bounds: {
+					x: Math.min(t.x, n.x),
+					y: Math.min(t.y, n.y),
+					width: Math.abs(n.x - t.x),
+					height: Math.abs(n.y - t.y)
+				},
+				targetRoomId: a.id,
+				from: {
+					x: i.x,
+					y: i.y
+				},
+				tip: {
+					x: n.x,
+					y: n.y
+				},
+				arrowColor: r
+			};
+		}
+		let s = a.area !== i.area || a.z !== i.z, c = {
+			x: a.x,
+			y: a.y
+		};
+		s && (c = b(i.x, i.y, o, this.settings.roomSize / 2));
+		let l = b(i.x, i.y, o, .3), u = l.x - (l.x - c.x) / 2, d = l.y - (l.y - c.y) / 2, f = this.getRoomEdgePoint(i.x, i.y, o, this.settings.roomSize / 2), m = [
+			f.x,
+			f.y,
+			c.x,
+			c.y
+		], g = [
+			f.x,
+			c.x,
+			u
+		], _ = [
+			f.y,
+			c.y,
+			d
+		], v = Math.min(...g), y = Math.max(...g), x = Math.min(..._), S = Math.max(..._);
+		return {
+			lines: [{
+				points: m,
+				stroke: t,
+				strokeWidth: this.settings.lineWidth,
+				dash: [.1, .05]
+			}],
+			arrows: [{
+				points: [
+					m[0],
+					m[1],
+					u,
+					d
+				],
+				pointerLength: .5,
+				pointerWidth: .35,
+				strokeWidth: this.settings.lineWidth * 1.4,
+				stroke: t,
+				fill: C.ONE_WAY_FILL,
+				dash: [.1, .05]
+			}],
+			doors: [],
+			bounds: {
+				x: v,
+				y: x,
+				width: y - v,
+				height: S - x
+			},
+			...s ? { targetRoomId: a.id } : {}
+		};
+	}
+	getInnerExitAreaTargets(e) {
+		let t = [
+			"up",
+			"down",
+			"in",
+			"out"
+		], n = this.settings.roomSize, r = [];
+		for (let i of t) {
+			let t = e.exits[i];
+			if (t === void 0) continue;
+			let a = this.mapReader.getRoom(t);
+			!a || a.area === e.area || r.push({
+				bounds: {
+					x: e.x - n / 4,
+					y: e.y - n / 4,
+					width: n / 2,
+					height: n / 2
+				},
+				targetRoomId: t,
+				from: {
+					x: e.x,
+					y: e.y
+				},
+				tip: {
+					x: e.x,
+					y: e.y
+				},
+				arrowColor: this.mapReader.getColorValue(a.env)
+			});
+		}
+		return r;
+	}
+	getSpecialExitAreaTargets(e) {
+		let t = [], n = {
+			u: "up",
+			d: "down",
+			i: "in",
+			o: "out"
+		};
+		for (let [r, i] of Object.entries(e.customLines)) {
+			let a = e.specialExits[r];
+			if (a === void 0) {
+				let t = m[r] ?? n[r];
+				t && (a = e.exits[t] ?? e.specialExits[t]);
+			}
+			if (a === void 0 && (a = e.exits[r] ?? e.specialExits[r]), a === void 0) continue;
+			let o = this.mapReader.getRoom(a);
+			if (!o || o.area === e.area && o.z === e.z) continue;
+			let s = [e.x, e.y];
+			i.points.reduce((e, t) => (e.push(t.x, -t.y), e), s);
+			let c = Infinity, l = Infinity, u = -Infinity, d = -Infinity;
+			for (let e = 0; e < s.length; e += 2) c = Math.min(c, s[e]), u = Math.max(u, s[e]), l = Math.min(l, s[e + 1]), d = Math.max(d, s[e + 1]);
+			let f = s.length - 2, p = {
+				x: s[f],
+				y: s[f + 1]
+			};
+			t.push({
+				bounds: {
+					x: c,
+					y: l,
+					width: u - c,
+					height: d - l
+				},
+				targetRoomId: a,
+				from: {
+					x: e.x,
+					y: e.y
+				},
+				tip: p,
+				arrowColor: this.mapReader.getColorValue(o.env)
+			});
+		}
+		return t;
+	}
+}, E = {
+	1: "north",
+	2: "northeast",
+	3: "northwest",
+	4: "east",
+	5: "west",
+	6: "south",
+	7: "southeast",
+	8: "southwest",
+	9: "up",
+	10: "down",
+	11: "in",
+	12: "out"
+};
+function D(e, t, n, r, i) {
+	return e.roomShape === "circle" ? S(t, n, r, i) : e.roomShape === "roundedRectangle" ? x(t, n, r, i, e.roomSize * .2) : b(t, n, r, i);
+}
+function O(e, t, n) {
+	let r = [];
+	for (let i of e.stubs) {
+		let a = E[i];
+		if (!a) continue;
+		let o = D(t, e.x, e.y, a, t.roomSize / 2), s = b(e.x, e.y, a, t.roomSize / 2 + .5);
+		r.push({
+			roomId: e.id,
+			direction: a,
+			x1: o.x,
+			y1: o.y,
+			x2: s.x,
+			y2: s.y,
+			stroke: n ?? t.lineColor,
+			strokeWidth: t.lineWidth
+		});
+	}
+	return r;
+}
+//#endregion
+//#region src/scene/SpecialExitStyle.ts
+var k = {
+	1: "rgb(10, 155, 10)",
+	2: "rgb(226, 205, 59)",
+	3: "rgb(155, 10, 10)"
+};
+function A(e, t, n) {
+	let r = [];
+	for (let [i, a] of Object.entries(e.customLines)) {
+		let o = [e.x, e.y];
+		for (let e of a.points) o.push(e.x, -e.y);
+		let s = n ?? `rgb(${a.attributes.color.r}, ${a.attributes.color.g}, ${a.attributes.color.b})`, c;
+		a.attributes.style === "dot line" ? c = [.05, .05] : a.attributes.style === "dash line" ? c = [.4, .2] : a.attributes.style === "dash dot line" ? c = [
+			.4,
+			.15,
+			.05,
+			.15
+		] : a.attributes.style === "dash dot dot line" && (c = [
+			.4,
+			.15,
+			.05,
+			.15,
+			.05,
+			.15
+		]);
+		let l = {
+			points: o,
+			stroke: s,
+			strokeWidth: t.lineWidth,
+			dash: c
+		}, u;
+		if (a.attributes.arrow && o.length >= 4) {
+			let e = o.length - 2, n = o[e], r = o[e + 1], i = o[e - 2], a = o[e - 1], c = Math.atan2(r - a, n - i), l = .3, d = .1;
+			u = {
+				tipX: n,
+				tipY: r,
+				x1: n - l * Math.cos(c - Math.atan2(d, l)),
+				y1: r - l * Math.sin(c - Math.atan2(d, l)),
+				x2: n - l * Math.cos(c + Math.atan2(d, l)),
+				y2: r - l * Math.sin(c + Math.atan2(d, l)),
+				fill: s,
+				stroke: s,
+				strokeWidth: t.lineWidth
+			};
+		}
+		let d, f = e.doors[i];
+		if (f && o.length >= 4) {
+			let e = o[0] + (o[2] - o[0]) / 2, n = o[1] + (o[3] - o[1]) / 2, r = t.roomSize / 2;
+			d = {
+				x: e - r / 2,
+				y: n - r / 2,
+				width: r,
+				height: r,
+				stroke: k[f] ?? k[3],
+				strokeWidth: t.lineWidth
+			};
+		}
+		r.push({
+			dir: i,
+			line: l,
+			arrow: u,
+			door: d
+		});
+	}
+	return r;
+}
+//#endregion
+//#region src/utils/textMeasure.ts
+var j = 72, M = 200, N = 120, P = /* @__PURE__ */ new Map(), F = null;
+function I() {
+	return F || (F = e.Util.createCanvasElement(), F.width = M, F.height = M), F;
+}
+function ee(e, t) {
+	let n = `${e}::${t}`, r = P.get(n);
+	if (r !== void 0) return r;
+	let i = I().getContext("2d", { willReadFrequently: !0 }), a = `bold ${j}px ${t}`;
+	i.clearRect(0, 0, M, M), i.font = a, i.textBaseline = "alphabetic", i.textAlign = "center", i.fillStyle = "#ffffff", i.fillText(e, M / 2, N);
+	let { data: o } = i.getImageData(0, 0, M, M), s = M, c = -1;
+	for (let e = 0; e < M; e++) for (let t = 0; t < M; t++) o[(e * M + t) * 4 + 3] > 16 && (e < s && (s = e), e > c && (c = e));
+	if (c === -1) {
+		let e = {
+			baselineRatio: .35,
+			konvaCorrectionRatio: 0
+		};
+		return P.set(n, e), e;
+	}
+	let l = (N - s - Math.max(0, c - N)) / 2 / j, u = i.measureText("M"), d = {
+		baselineRatio: l,
+		konvaCorrectionRatio: ((u.fontBoundingBoxAscent ?? u.actualBoundingBoxAscent ?? 0) - (u.fontBoundingBoxDescent ?? u.actualBoundingBoxDescent ?? 0)) / 2 / j - l
+	};
+	return P.set(n, d), d;
+}
+//#endregion
+//#region src/scene/RoomStyle.ts
+function te(e, t, i, a) {
+	let o = t.getColorValue(e.env), s = i.coloredMode ? n(o, .5) : i.frameMode ? i.backgroundColor : o, c = i.coloredMode ? r(o, .1) : o;
+	return {
+		fillColor: s,
+		strokeColor: a ? i.frameMode || i.coloredMode ? c : a : i.frameMode || i.coloredMode ? c : i.lineColor,
+		borderWidth: i.borders ? i.lineWidth : 0,
+		symbolColor: e.userData?.["system.fallback_symbol_color"] ?? (i.frameMode || i.coloredMode ? c : t.getSymbolColor(e.env)),
+		envColor: o
+	};
+}
+function ne(e, t) {
+	if (!t.emboss) return null;
+	let i = t.roomSize, a = t.borders ? t.lineWidth / 2 : 0, o = t.lineWidth, s = r(e, .35), c = n(e, .45);
+	if (t.roomShape === "circle") {
+		let e = i / 2, t = i / 2, n = i / 2 - a, r = [];
+		for (let i = 0; i <= 48; i++) {
+			let a = i / 48 * 360 * Math.PI / 180;
+			r.push(e + Math.cos(a) * n, t + Math.sin(a) * n);
+		}
+		let l = [];
+		for (let r = 0; r <= 19; r++) {
+			let i = (200 + r / 19 * 140) * Math.PI / 180;
+			l.push(e + Math.cos(i) * n, t + Math.sin(i) * n);
+		}
+		return {
+			shadow: {
+				points: r,
+				stroke: c,
+				strokeWidth: o,
+				lineCap: "round",
+				lineJoin: "round"
+			},
+			highlight: {
+				points: l,
+				stroke: s,
+				strokeWidth: o,
+				lineCap: "round",
+				lineJoin: "round"
+			}
+		};
+	}
+	if (t.roomShape === "roundedRectangle") {
+		let e = (i - a * 2) * .2, t = a, n = a, r = i - a, l = i - a, u = [];
+		for (let n = 0; n <= 10 / 2; n++) {
+			let r = (135 + n / (10 / 2) * 45) * Math.PI / 180;
+			u.push(t + e + Math.cos(r) * e, l - e + Math.sin(r) * e);
+		}
+		for (let r = 1; r <= 10; r++) {
+			let i = (180 + r / 10 * 90) * Math.PI / 180;
+			u.push(t + e + Math.cos(i) * e, n + e + Math.sin(i) * e);
+		}
+		for (let t = 1; t <= 10 / 2; t++) {
+			let i = (270 + t / (10 / 2) * 45) * Math.PI / 180;
+			u.push(r - e + Math.cos(i) * e, n + e + Math.sin(i) * e);
+		}
+		let d = u.slice(), f = [];
+		for (let t = 0; t <= 10 / 2; t++) {
+			let i = (315 + t / (10 / 2) * 45) * Math.PI / 180;
+			f.push(r - e + Math.cos(i) * e, n + e + Math.sin(i) * e);
+		}
+		for (let t = 1; t <= 10; t++) {
+			let n = t / 10 * 90 * Math.PI / 180;
+			f.push(r - e + Math.cos(n) * e, l - e + Math.sin(n) * e);
+		}
+		for (let n = 1; n <= 10 / 2; n++) {
+			let r = (90 + n / (10 / 2) * 45) * Math.PI / 180;
+			f.push(t + e + Math.cos(r) * e, l - e + Math.sin(r) * e);
+		}
+		return {
+			highlight: {
+				points: d,
+				stroke: s,
+				strokeWidth: o,
+				lineCap: "round",
+				lineJoin: "round"
+			},
+			shadow: {
+				points: f,
+				stroke: c,
+				strokeWidth: o,
+				lineCap: "round",
+				lineJoin: "round"
+			}
+		};
+	}
+	return {
+		highlight: {
+			points: [
+				a,
+				i - a,
+				a,
+				a,
+				i - a,
+				a
+			],
+			stroke: s,
+			strokeWidth: o
+		},
+		shadow: {
+			points: [
+				a,
+				i - a,
+				i - a,
+				i - a,
+				i - a,
+				a
+			],
+			stroke: c,
+			strokeWidth: o
+		}
+	};
+}
+//#endregion
+//#region src/scene/elements/RoomLayout.ts
+function L(e, t, r, i) {
+	let { fillColor: a, strokeColor: o, borderWidth: s, symbolColor: c } = te(e, t, r, i.strokeOverride), l = r.roomSize, u = [], d = ne(a, r), f = d ? 0 : s, p = r.coloredMode && f > 0 && i.flatPipeline, m = (e) => r.roomShape === "roundedRectangle" ? Math.max(0, (l - 2 * e) * .2) : 0;
+	if (p) {
+		let e = [n(o, .5), o], t = s * 2;
+		r.roomShape === "circle" ? u.push({
+			type: "circle",
+			cx: l / 2,
+			cy: l / 2,
+			radius: l / 2 - t,
+			paint: { fill: a }
+		}) : u.push({
+			type: "rect",
+			x: t,
+			y: t,
+			width: l - t * 2,
+			height: l - t * 2,
+			cornerRadius: m(t),
+			paint: { fill: a }
+		});
+		for (let t = 0; t < e.length; t++) {
+			let n = s / 2 + t * s;
+			r.roomShape === "circle" ? u.push({
+				type: "circle",
+				cx: l / 2,
+				cy: l / 2,
+				radius: l / 2 - n,
+				paint: {
+					stroke: e[t],
+					strokeWidth: s
+				}
+			}) : u.push({
+				type: "rect",
+				x: n,
+				y: n,
+				width: l - n * 2,
+				height: l - n * 2,
+				cornerRadius: m(n),
+				paint: {
+					stroke: e[t],
+					strokeWidth: s
+				}
+			});
+		}
+	} else r.roomShape === "circle" ? u.push({
+		type: "circle",
+		cx: l / 2,
+		cy: l / 2,
+		radius: l / 2,
+		paint: {
+			fill: a,
+			stroke: f ? o : void 0,
+			strokeWidth: f
+		}
+	}) : u.push({
+		type: "rect",
+		x: 0,
+		y: 0,
+		width: l,
+		height: l,
+		cornerRadius: r.roomShape === "roundedRectangle" ? l * .2 : 0,
+		paint: {
+			fill: a,
+			stroke: f ? o : void 0,
+			strokeWidth: f
+		}
+	});
+	if (d && (u.push({
+		type: "line",
+		points: d.shadow.points,
+		paint: {
+			stroke: d.shadow.stroke,
+			strokeWidth: d.shadow.strokeWidth
+		},
+		lineCap: d.shadow.lineCap,
+		lineJoin: d.shadow.lineJoin
+	}), u.push({
+		type: "line",
+		points: d.highlight.points,
+		paint: {
+			stroke: d.highlight.stroke,
+			strokeWidth: d.highlight.strokeWidth
+		},
+		lineCap: d.highlight.lineCap,
+		lineJoin: d.shadow.lineJoin
+	})), e.roomChar) {
+		let t = l * .75, { baselineRatio: n, konvaCorrectionRatio: i } = ee(e.roomChar, r.fontFamily), a = Math.max(l, e.roomChar.length * t * .8), o = (a - l) / 2;
+		u.push({
+			type: "text",
+			x: -o,
+			y: 0,
+			text: e.roomChar,
+			fontSize: t,
+			fontFamily: r.fontFamily,
+			fontStyle: "bold",
+			fill: c,
+			align: "center",
+			verticalAlign: "middle",
+			width: a,
+			height: l,
+			baselineRatio: n,
+			konvaCorrectionRatio: i
+		});
+	}
+	return {
+		type: "group",
+		x: e.x - l / 2,
+		y: e.y - l / 2,
+		layer: "room",
+		hit: {
+			kind: "room",
+			id: e.id,
+			payload: e
+		},
+		children: u
+	};
+}
+//#endregion
+//#region src/scene/InnerExitStyle.ts
+var re = [
+	"up",
+	"down",
+	"in",
+	"out"
+];
+function ie(e, t, n, r) {
+	let i = r * Math.PI / 180, a = [];
+	for (let r = 0; r < 3; r++) {
+		let o = 2 * Math.PI * r / 3 - Math.PI / 2, s = Math.cos(o) * n * 1.4, c = Math.sin(o) * n * .8, l = s * Math.cos(i) - c * Math.sin(i), u = s * Math.sin(i) + c * Math.cos(i);
+		a.push(e + l, t + u);
+	}
+	return a;
+}
+function ae(e, t, n) {
+	let r = e.userData?.["system.fallback_symbol_color"];
+	return {
+		symbolColor: r ?? (n.frameMode || n.coloredMode ? t.getColorValue(e.env) : t.getSymbolColor(e.env)),
+		symbolFill: r ?? (n.frameMode || n.coloredMode ? t.getColorValue(e.env) : t.getSymbolColor(e.env, .6))
+	};
+}
+var R = {
+	1: "rgb(10, 155, 10)",
+	2: "rgb(226, 205, 59)",
+	3: "rgb(155, 10, 10)"
+};
+function z(e, t, n) {
+	let r = n.roomSize, i = r / 5, a = (e, t, n) => ({
+		cx: e,
+		cy: t,
+		vertices: ie(e, t, i, n)
+	});
+	switch (t) {
+		case "up": {
+			let t = b(e.x, e.y, "south", r / 4);
+			return [a(t.x, t.y, 0)];
+		}
+		case "down": {
+			let t = b(e.x, e.y, "north", r / 4);
+			return [a(t.x, t.y, 180)];
+		}
+		case "in": {
+			let t = b(e.x, e.y, "west", r / 4), n = b(e.x, e.y, "east", r / 4);
+			return [a(t.x, t.y, 90), a(n.x, n.y, -90)];
+		}
+		case "out": {
+			let t = b(e.x, e.y, "west", r / 4), n = b(e.x, e.y, "east", r / 4);
+			return [a(t.x, t.y, -90), a(n.x, n.y, 90)];
+		}
+		default: return [];
+	}
+}
+function oe(e, t, n) {
+	let r = [], { symbolColor: i, symbolFill: a } = ae(e, t, n);
+	for (let t of re) {
+		if (!e.exits[t]) continue;
+		let o = e.doors[t], s = o === void 0 ? i : R[o] ?? R[3];
+		for (let i of z(e, t, n)) r.push({
+			cx: i.cx,
+			cy: i.cy,
+			vertices: i.vertices,
+			fill: a,
+			stroke: s,
+			strokeWidth: n.lineWidth
+		});
+	}
+	return { triangles: r };
+}
+//#endregion
+//#region src/scene/elements/ExitLayout.ts
+function B(e, t, n) {
+	let r = n.roomSize, i = e.x - r / 2, a = e.y - r / 2, { triangles: o } = oe(e, t, n);
+	return o.map((e) => {
+		let t = Array(e.vertices.length);
+		for (let n = 0; n < e.vertices.length; n += 2) t[n] = e.vertices[n] - i, t[n + 1] = e.vertices[n + 1] - a;
+		return {
+			type: "polygon",
+			vertices: t,
+			paint: {
+				fill: e.fill,
+				stroke: e.stroke,
+				strokeWidth: e.strokeWidth
+			}
+		};
+	});
+}
+function V(e, t) {
+	let n = [];
+	for (let t of e.lines) n.push({
+		type: "line",
+		points: t.points,
+		paint: {
+			stroke: t.stroke,
+			strokeWidth: t.strokeWidth,
+			dash: t.dash
+		}
+	});
+	for (let t of e.arrows) se(n, t);
+	for (let t of e.doors) n.push({
+		type: "rect",
+		x: t.x,
+		y: t.y,
+		width: t.width,
+		height: t.height,
+		paint: {
+			stroke: t.stroke,
+			strokeWidth: t.strokeWidth
+		}
+	});
+	return {
+		type: "group",
+		x: 0,
+		y: 0,
+		layer: "link",
+		...t ? { hit: t } : {},
+		children: n
+	};
+}
+function se(e, t) {
+	e.push({
+		type: "line",
+		points: t.points,
+		paint: {
+			stroke: t.stroke,
+			strokeWidth: t.strokeWidth,
+			dash: t.dash
+		}
+	});
+	let n = t.points.length - 2, r = t.points[n], i = t.points[n + 1], a = t.points[n - 2], o = t.points[n - 1], s = Math.atan2(i - o, r - a), c = t.pointerLength, l = t.pointerWidth / 2, u = r - c * Math.cos(s - Math.atan2(l, c)), d = i - c * Math.sin(s - Math.atan2(l, c)), f = r - c * Math.cos(s + Math.atan2(l, c)), p = i - c * Math.sin(s + Math.atan2(l, c));
+	e.push({
+		type: "polygon",
+		vertices: [
+			r,
+			i,
+			u,
+			d,
+			f,
+			p
+		],
+		paint: {
+			fill: t.fill,
+			stroke: t.stroke,
+			strokeWidth: t.strokeWidth
+		}
+	});
+}
+//#endregion
+//#region src/scene/elements/SpecialExitLayout.ts
+function H(e, t) {
+	let n = [];
+	if (n.push({
+		type: "line",
+		points: e.line.points,
+		paint: {
+			stroke: e.line.stroke,
+			strokeWidth: e.line.strokeWidth,
+			dash: e.line.dash
+		}
+	}), e.arrow) {
+		let t = e.arrow;
+		n.push({
+			type: "polygon",
+			vertices: [
+				t.tipX,
+				t.tipY,
+				t.x1,
+				t.y1,
+				t.x2,
+				t.y2
+			],
+			paint: {
+				fill: t.fill,
+				stroke: t.stroke,
+				strokeWidth: t.strokeWidth
+			}
+		});
+	}
+	if (e.door) {
+		let t = e.door;
+		n.push({
+			type: "rect",
+			x: t.x,
+			y: t.y,
+			width: t.width,
+			height: t.height,
+			paint: {
+				stroke: t.stroke,
+				strokeWidth: t.strokeWidth
+			}
+		});
+	}
+	return {
+		type: "group",
+		x: 0,
+		y: 0,
+		layer: "link",
+		hit: {
+			kind: "specialExit",
+			id: `${t}:${e.dir}`,
+			payload: {
+				roomId: t,
+				exitName: e.dir
+			}
+		},
+		children: n
+	};
+}
+//#endregion
+//#region src/scene/elements/StubLayout.ts
+function U(e) {
+	return {
+		type: "group",
+		x: 0,
+		y: 0,
+		layer: "link",
+		hit: {
+			kind: "stub",
+			id: `${e.roomId}:${e.direction}`,
+			payload: e
+		},
+		children: [{
+			type: "line",
+			points: [
+				e.x1,
+				e.y1,
+				e.x2,
+				e.y2
+			],
+			paint: {
+				stroke: e.stroke,
+				strokeWidth: e.strokeWidth
+			}
+		}]
+	};
+}
+//#endregion
+//#region src/scene/elements/LabelLayout.ts
+function W(e) {
+	let t = (e?.alpha ?? 255) / 255, n = (e) => Math.min(255, Math.max(0, e ?? 0));
+	return `rgba(${n(e?.r)}, ${n(e?.g)}, ${n(e?.b)}, ${t})`;
+}
+function ce(e, t) {
+	if (t.labelRenderMode === "none") return null;
+	let n = e.X, r = -e.Y, i = !!e.noScaling, a = i ? n : 0, o = i ? r : 0, s = i ? 0 : n, c = i ? 0 : r;
+	if (t.labelRenderMode === "image" && e.pixMap) return {
+		type: "group",
+		x: a,
+		y: o,
+		layer: e.showOnTop ? "top" : "link",
+		noScale: i,
+		hit: {
+			kind: "label",
+			payload: e
+		},
+		children: [{
+			type: "image",
+			x: s,
+			y: c,
+			width: e.Width,
+			height: e.Height,
+			src: `data:image/png;base64,${e.pixMap}`
+		}]
+	};
+	let l = [];
+	if ((e.BgColor?.alpha ?? 0) > 0 && !t.transparentLabels && l.push({
+		type: "rect",
+		x: s,
+		y: c,
+		width: e.Width,
+		height: e.Height,
+		paint: { fill: W(e.BgColor) }
+	}), e.Text) {
+		let t = Math.min(.75, e.Width / Math.max(e.Text.length / 2, 1)), n = Math.max(.1, Math.min(t, Math.max(e.Height * .9, .1)));
+		l.push({
+			type: "text",
+			x: s,
+			y: c,
+			width: e.Width,
+			height: e.Height,
+			text: e.Text,
+			fontSize: n,
+			fill: W(e.FgColor),
+			align: "center",
+			verticalAlign: "middle"
+		});
+	}
+	return {
+		type: "group",
+		x: a,
+		y: o,
+		layer: e.showOnTop ? "top" : "link",
+		noScale: i,
+		hit: {
+			kind: "label",
+			payload: e
+		},
+		children: l
+	};
+}
+//#endregion
+//#region src/ScenePipeline.ts
+function le(e, t) {
+	let n = G(e);
+	return n ? `rgba(${n.r}, ${n.g}, ${n.b}, ${t})` : e;
+}
+function G(e) {
+	let t = e.match(/(\d+)\s*,\s*(\d+)\s*,\s*(\d+)/);
+	if (t) return {
+		r: +t[1],
+		g: +t[2],
+		b: +t[3]
+	};
+	if (e.startsWith("#") && e.length >= 7) return {
+		r: parseInt(e.slice(1, 3), 16),
+		g: parseInt(e.slice(3, 5), 16),
+		b: parseInt(e.slice(5, 7), 16)
+	};
+}
+function ue(e, t, n) {
+	let r = G(e), i = G(t);
+	return !r || !i ? e : `rgb(${Math.round(r.r * n + i.r * (1 - n))}, ${Math.round(r.g * n + i.g * (1 - n))}, ${Math.round(r.b * n + i.b * (1 - n))})`;
+}
+function de(e, t) {
+	let n = t * t, r = [];
+	outer: for (let t of e) {
+		for (let e of r) for (let r of e) {
+			let i = t.tip.x - r.tip.x, a = t.tip.y - r.tip.y;
+			if (i * i + a * a <= n) {
+				e.push(t);
+				continue outer;
+			}
+		}
+		r.push([t]);
+	}
+	return r;
+}
+var fe = class {
+	constructor(e, t) {
+		this.linkShapes = [], this.roomShapes = [], this.topLabelShapes = [], this.labelShapeRefs = [], this.specialExitShapeRefs = [], this.stubShapeRefs = [], this.areaExitLabelShapeRefs = [], this.mapReader = e, this.settings = t, this.exitRenderer = new T(e, t);
+	}
+	buildScene(e, t, n, r = s) {
+		this.linkShapes = [], this.roomShapes = [], this.topLabelShapes = [], this.labelShapeRefs = [], this.specialExitShapeRefs = [], this.stubShapeRefs = [], this.areaExitLabelShapeRefs = [], this.renderLabels(t.getLabels(), e.getAreaId());
+		let i = this.renderLinkExits(e.getLinkExits(n), n, r), a = (t.getRooms() ?? []).filter((e) => r.isVisible(e)), o = this.renderRooms(a, n);
+		this.renderAreaName(e, t);
+		let c = [...i.areaExitHitZones, ...o.areaExitHitZones], l = this.renderAreaExitLabels(c, e.getAreaId(), a, i.standaloneExitShapeRefs.map((e) => e.bounds));
+		c.push(...l);
+		let u = [
+			...this.linkShapes,
+			...this.roomShapes,
+			...this.topLabelShapes
+		];
+		return {
+			roomShapeRefs: o.roomShapeRefs,
+			standaloneExitShapeRefs: i.standaloneExitShapeRefs,
+			labelShapeRefs: this.labelShapeRefs,
+			specialExitShapeRefs: this.specialExitShapeRefs,
+			stubShapeRefs: this.stubShapeRefs,
+			areaExitLabelShapeRefs: this.areaExitLabelShapeRefs,
+			areaExitHitZones: c,
+			drawnExits: i.drawnExits,
+			drawnSpecialExits: o.drawnSpecialExits,
+			drawnStubs: o.drawnStubs,
+			hitShapes: u,
+			sceneShapes: {
+				grid: [],
+				link: this.linkShapes,
+				room: this.roomShapes,
+				topLabel: this.topLabelShapes
+			}
+		};
+	}
+	getEffectiveBounds(e, t) {
+		return this.settings.uniformLevelSize ? e.getFullBounds() : t.getBounds();
+	}
+	renderRooms(e, t) {
+		let n = /* @__PURE__ */ new Map(), r = [], i = [], a = [], o = [];
+		e.forEach((e) => {
+			let t = L(e, this.mapReader, this.settings, { flatPipeline: !0 });
+			t.children.push(...B(e, this.mapReader, this.settings));
+			for (let t of A(e, this.settings)) {
+				let n = H(t, e.id);
+				this.linkShapes.push(n);
+				let r = t.line.points, a = Infinity, o = Infinity, s = -Infinity, c = -Infinity;
+				for (let e = 0; e < r.length; e += 2) r[e] < a && (a = r[e]), r[e] > s && (s = r[e]), r[e + 1] < o && (o = r[e + 1]), r[e + 1] > c && (c = r[e + 1]);
+				let l = {
+					x: a,
+					y: o,
+					width: s - a,
+					height: c - o
+				};
+				i.push({
+					roomId: e.id,
+					exitName: t.dir,
+					points: r,
+					stroke: t.line.stroke,
+					strokeWidth: t.line.strokeWidth,
+					dash: t.line.dash,
+					hasArrow: !!t.arrow,
+					arrowTip: t.arrow ? {
+						x: t.arrow.tipX,
+						y: t.arrow.tipY
+					} : void 0,
+					bounds: l
+				}), this.specialExitShapeRefs.push({
+					shape: n,
+					bounds: l
+				});
+			}
+			this.exitRenderer.getSpecialExitAreaTargets(e).forEach((e) => {
+				r.push({
+					bounds: e.bounds,
+					targetRoomId: e.targetRoomId,
+					from: e.from,
+					tip: e.tip,
+					arrowColor: e.arrowColor
+				});
+			}), this.exitRenderer.getInnerExitAreaTargets(e).forEach((e) => {
+				r.push({
+					bounds: e.bounds,
+					targetRoomId: e.targetRoomId,
+					from: e.from,
+					tip: e.tip,
+					arrowColor: e.arrowColor
+				});
+			});
+			for (let t of O(e, this.settings)) {
+				let e = U(t);
+				this.linkShapes.push(e), a.push({
+					roomId: t.roomId,
+					direction: t.direction,
+					x1: t.x1,
+					y1: t.y1,
+					x2: t.x2,
+					y2: t.y2,
+					stroke: t.stroke,
+					strokeWidth: t.strokeWidth
+				}), this.stubShapeRefs.push({
+					shape: e,
+					bounds: {
+						x: Math.min(t.x1, t.x2),
+						y: Math.min(t.y1, t.y2),
+						width: Math.abs(t.x2 - t.x1),
+						height: Math.abs(t.y2 - t.y1)
+					}
+				});
+			}
+			o.push([e, t]), n.set(e.id, {
+				room: e,
+				shape: t
+			});
+		});
+		for (let [, e] of o) this.roomShapes.push(e);
+		return {
+			roomShapeRefs: n,
+			areaExitHitZones: r,
+			drawnSpecialExits: i,
+			drawnStubs: a
+		};
+	}
+	renderLinkExits(e, t, n) {
+		let r = [], i = [], a = [];
+		return e.forEach((e) => {
+			let o = this.mapReader.getRoom(e.a), s = this.mapReader.getRoom(e.b);
+			if (!o || !s) return;
+			let l = n.getExitTreatment ? n.getExitTreatment(e, o, s) : c(n, e, o, s);
+			if (l === "hidden") return;
+			if (l === "stub") {
+				let t = this.buildLensStub(e, o, s, n);
+				t && this.emitLensStub(t);
+				return;
+			}
+			let u = this.exitRenderer.renderData(e, t);
+			if (!u) return;
+			let d = V(u, {
+				kind: "exit",
+				id: `${e.a}:${e.b}:${e.aDir ?? ""}:${e.bDir ?? ""}`,
+				payload: {
+					a: e.a,
+					b: e.b,
+					aDir: e.aDir,
+					bDir: e.bDir,
+					kind: e.kind ?? "exit"
+				}
+			});
+			this.linkShapes.push(d), r.push({
+				shape: d,
+				bounds: u.bounds,
+				targetRoomId: u.targetRoomId
+			}), a.push({
+				a: e.a,
+				b: e.b,
+				aDir: e.aDir,
+				bDir: e.bDir,
+				kind: e.kind ?? "exit",
+				zIndex: e.zIndex,
+				data: u
+			}), u.targetRoomId !== void 0 && i.push({
+				bounds: u.bounds,
+				targetRoomId: u.targetRoomId,
+				from: u.from,
+				tip: u.tip,
+				arrowColor: u.arrowColor
+			});
+		}), {
+			standaloneExitShapeRefs: r,
+			areaExitHitZones: i,
+			drawnExits: a
+		};
+	}
+	buildLensStub(e, t, n, r) {
+		let i = r.isVisible(t);
+		if (i === r.isVisible(n)) return;
+		let a = i ? t : n, o = i ? e.aDir : e.bDir;
+		if (!o || !p.includes(o) || a.customLines[h[o]]) return;
+		let s = this.settings.roomSize, c = this.getRoomEdgePoint(a.x, a.y, o, s / 2), l = b(a.x, a.y, o, s / 2 + .5);
+		return {
+			roomId: a.id,
+			direction: o,
+			x1: c.x,
+			y1: c.y,
+			x2: l.x,
+			y2: l.y,
+			stroke: this.settings.lineColor,
+			strokeWidth: this.settings.lineWidth
+		};
+	}
+	emitLensStub(e) {
+		let t = U(e);
+		this.linkShapes.push(t), this.stubShapeRefs.push({
+			shape: t,
+			bounds: {
+				x: Math.min(e.x1, e.x2),
+				y: Math.min(e.y1, e.y2),
+				width: Math.abs(e.x2 - e.x1),
+				height: Math.abs(e.y2 - e.y1)
+			}
+		});
+	}
+	getRoomEdgePoint(e, t, n, r) {
+		return this.settings.roomShape === "circle" ? S(e, t, n, r) : this.settings.roomShape === "roundedRectangle" ? x(e, t, n, r, this.settings.roomSize * .2) : b(e, t, n, r);
+	}
+	buildExitShape(e) {
+		return V(e);
+	}
+	renderLabels(e, t) {
+		for (let n of e) {
+			let e = ce(n, this.settings);
+			e && (e.hit = {
+				kind: "label",
+				id: n.labelId,
+				payload: {
+					label: n,
+					areaId: t
+				}
+			}, n.showOnTop ? this.topLabelShapes.push(e) : this.linkShapes.push(e), n.noScaling || this.labelShapeRefs.push({
+				shape: e,
+				bounds: {
+					x: n.X,
+					y: -n.Y,
+					width: n.Width,
+					height: n.Height
+				}
+			}));
+		}
+	}
+	renderAreaExitLabels(e, n, r, i) {
+		let a = [];
+		if (!this.settings.areaExitLabels || e.length === 0) return a;
+		let o = /* @__PURE__ */ new Map();
+		for (let t of e) {
+			if (!t.tip || !t.from) continue;
+			let e = this.mapReader.getRoom(t.targetRoomId);
+			if (!e || e.area === n) continue;
+			let r = t.tip.x - t.from.x, i = t.tip.y - t.from.y, a = Math.hypot(r, i) || 1, s = {
+				tip: t.tip,
+				dir: {
+					x: r / a,
+					y: i / a
+				},
+				color: t.arrowColor ?? "white",
+				bounds: t.bounds,
+				targetRoomId: t.targetRoomId
+			}, c = o.get(e.area);
+			c ? c.push(s) : o.set(e.area, [s]);
+		}
+		let s = this.settings.areaExitLabelFontSize, c = s * .6, l = s * .333, u = s * .55, d = s * 1.1, f = s * .6, p = .35, m = s * .1, h = this.settings.roomSize, g = r.map((e) => ({
+			x: e.x - h / 2,
+			y: e.y - h / 2,
+			width: h,
+			height: h
+		})), _ = e.map((e) => e.bounds), v = (e, t, n) => {
+			let r = Math.max(0, Math.max(e.x, t.x) - Math.min(e.x + e.w, t.x + t.w)), i = Math.max(0, Math.max(e.y, t.y) - Math.min(e.y + e.h, t.y + t.h));
+			return Math.hypot(r, i) <= n;
+		}, y = (e, t, n, r, i) => {
+			for (let a of i) if (e < a.x + a.width && e + n > a.x && t < a.y + a.height && t + r > a.y) return !0;
+			return !1;
+		}, b = [
+			[0, 1],
+			[0, -1],
+			[1, 0],
+			[-1, 0],
+			[.707, .707],
+			[-.707, .707],
+			[.707, -.707],
+			[-.707, -.707]
+		], x = (e, t, n) => {
+			let r = t.length * u + c * 2, a = d + l * 2, o = 0, s = 0, f = 0, p = 0, m = Infinity, h = -Infinity, v = Infinity, x = -Infinity, S = /* @__PURE__ */ new Map();
+			for (let t of e) o += t.tip.x, s += t.tip.y, f += t.dir.x, p += t.dir.y, t.tip.x < m && (m = t.tip.x), t.tip.x > h && (h = t.tip.x), t.tip.y < v && (v = t.tip.y), t.tip.y > x && (x = t.tip.y), S.set(t.color, (S.get(t.color) ?? 0) + 1);
+			let C = e.length, w = Math.hypot(f, p), T = w > 0 ? f / w : 0, E = w > 0 ? p / w : 0, D = 0;
+			for (let t = 0; t < e.length; t++) for (let n = t + 1; n < e.length; n++) {
+				let r = e[t].tip.x - e[n].tip.x, i = e[t].tip.y - e[n].tip.y, a = Math.hypot(r, i);
+				a > D && (D = a);
+			}
+			let O = D > 3, k = w / C >= .4, A = n?.x ?? (O ? (m + h) / 2 : o / C), j = n?.y ?? (O ? (v + x) / 2 : s / C), M = "white", N = 0;
+			for (let [e, t] of S) t > N && (M = e, N = t);
+			let P = g.concat(_).concat(i), F = (e, t, n = 0) => .5 + n + Math.abs(e) * r / 2 + Math.abs(t) * a / 2, I = [];
+			if (k) {
+				let e = F(T, E);
+				I.push({
+					x: A + T * e,
+					y: j + E * e
+				});
+			}
+			I.push({
+				x: A,
+				y: j
+			});
+			for (let e of [
+				0,
+				.6,
+				1.4
+			]) for (let [t, n] of b) {
+				let r = F(t, n, e);
+				I.push({
+					x: A + t * r,
+					y: j + n * r
+				});
+			}
+			for (let t of I) {
+				let n = t.x - r / 2, i = t.y - a / 2;
+				if (!y(n, i, r, a, P)) return {
+					cluster: e,
+					boxX: n,
+					boxY: i,
+					boxW: r,
+					boxH: a,
+					color: M
+				};
+			}
+		};
+		for (let [e, n] of o) {
+			let r = this.mapReader.getArea(e)?.getAreaName() || `Area ${e}`, i = de(n, 10).map((e) => x(e, r)).filter((e) => e !== void 0), o = !0;
+			for (; o && i.length > 1;) {
+				o = !1;
+				outer: for (let e = 0; e < i.length; e++) for (let t = e + 1; t < i.length; t++) {
+					let n = {
+						x: i[e].boxX,
+						y: i[e].boxY,
+						w: i[e].boxW,
+						h: i[e].boxH
+					}, a = {
+						x: i[t].boxX,
+						y: i[t].boxY,
+						w: i[t].boxW,
+						h: i[t].boxH
+					};
+					if (v(n, a, 2)) {
+						let s = [...i[e].cluster, ...i[t].cluster], c = x(s, r, {
+							x: (n.x + n.w / 2 + a.x + a.w / 2) / 2,
+							y: (n.y + n.h / 2 + a.y + a.h / 2) / 2
+						}) ?? x(s, r);
+						c ? (i[e] = c, i.splice(t, 1)) : (i.splice(t, 1), i.splice(e, 1)), o = !0;
+						break outer;
+					}
+				}
+			}
+			for (let e of i) {
+				let n = le(e.color, p), i = t(ue(e.color, this.settings.backgroundColor, p)) > .55 ? "#000" : "#fff", o = {
+					type: "group",
+					x: 0,
+					y: 0,
+					layer: "room",
+					hit: {
+						kind: "areaExit",
+						id: e.cluster[0].targetRoomId,
+						payload: { targetRoomId: e.cluster[0].targetRoomId }
+					},
+					children: [{
+						type: "rect",
+						x: e.boxX,
+						y: e.boxY,
+						width: e.boxW,
+						height: e.boxH,
+						cornerRadius: f,
+						paint: {
+							fill: n,
+							stroke: e.color,
+							strokeWidth: m
+						}
+					}, {
+						type: "text",
+						x: e.boxX + c,
+						y: e.boxY + l,
+						width: e.boxW - c * 2,
+						height: e.boxH - l * 2,
+						text: r,
+						fontSize: s,
+						fontFamily: this.settings.fontFamily,
+						fill: i,
+						align: "center",
+						verticalAlign: "middle"
+					}]
+				}, u = {
+					x: e.boxX,
+					y: e.boxY,
+					width: e.boxW,
+					height: e.boxH
+				};
+				this.roomShapes.push(o), this.areaExitLabelShapeRefs.push({
+					shape: o,
+					bounds: u
+				}), a.push({
+					bounds: u,
+					targetRoomId: e.cluster[0].targetRoomId
+				});
+			}
+		}
+		return a;
+	}
+	renderAreaName(e, t) {
+		if (!this.settings.areaName) return;
+		let n = e.getAreaName();
+		if (!n) return;
+		let r = this.getEffectiveBounds(e, t), i = {
+			type: "group",
+			x: 0,
+			y: 0,
+			layer: "room",
+			children: [{
+				type: "text",
+				x: r.minX - 3.5,
+				y: r.minY - 4.5,
+				text: n,
+				fontSize: 2.5,
+				fontFamily: this.settings.fontFamily,
+				fill: this.settings.lineColor
+			}]
+		};
+		this.roomShapes.push(i);
+	}
+}, pe = class {
+	setCursor(e) {
+		this.container.dataset.editorCursor || (this.container.style.cursor = e);
+	}
+	constructor(e, t, n, r, i) {
+		this.cleanupFns = [], this.destroyed = !1, this.container = e, this.camera = t, this.state = n, this.hitTest = r, this.events = i, this.initViewportEvents(), this.initMapEvents();
+	}
+	destroy() {
+		if (!this.destroyed) {
+			this.destroyed = !0;
+			for (let e of this.cleanupFns) e();
+			this.cleanupFns.length = 0;
+		}
+	}
+	listen(e, t, n, r) {
+		e.addEventListener(t, n, r), this.cleanupFns.push(() => e.removeEventListener(t, n, r));
+	}
+	initViewportEvents() {
+		let e = this.container, t = this.camera, n = 1.1, r = () => {
+			t.batch(() => {
+				if (t.setSize(e.clientWidth, e.clientHeight), t.centerOnResize && this.state.positionRoomId) {
+					let e = this.state.mapReader.getRoom(this.state.positionRoomId);
+					e && t.panToMapPoint(e.x, e.y);
+				}
+			});
+		};
+		typeof window < "u" && this.listen(window, "resize", r), this.listen(e, "resize", r);
+		let i = !1, a;
+		this.listen(e, "pointerdown", (n) => {
+			if (n.button !== 0 || n.pointerType === "touch") return;
+			i = !0, a = n.pointerId, e.setPointerCapture(n.pointerId);
+			let r = e.getBoundingClientRect();
+			t.startDrag(n.clientX - r.left, n.clientY - r.top);
+		}), this.listen(e, "pointermove", (n) => {
+			if (!i || n.pointerId !== a) return;
+			let r = e.getBoundingClientRect();
+			t.updateDrag(n.clientX - r.left, n.clientY - r.top), this.events.emit("pan", t.getViewportBounds());
+		}), this.listen(e, "pointerup", (e) => {
+			e.pointerId === a && (i = !1, a = void 0, t.endDrag(), this.events.emit("pan", t.getViewportBounds()));
+		}), this.listen(e, "pointercancel", (e) => {
+			e.pointerId === a && (i = !1, a = void 0, t.endDrag());
+		});
+		let o;
+		this.listen(e, "touchstart", (n) => {
+			if (n.touches.length === 1) {
+				let r = n.touches[0];
+				o = r.identifier;
+				let i = e.getBoundingClientRect();
+				t.startDrag(r.clientX - i.left, r.clientY - i.top);
+			} else t.isDragging() && t.endDrag(), o = void 0;
+		}, { passive: !0 }), this.listen(e, "touchmove", (n) => {
+			let r = n.touches;
+			if (r.length >= 2) {
+				n.preventDefault(), t.isDragging() && t.endDrag(), o = void 0;
+				let i = e.getBoundingClientRect(), a = {
+					x: r[0].clientX - i.left,
+					y: r[0].clientY - i.top
+				}, s = {
+					x: r[1].clientX - i.left,
+					y: r[1].clientY - i.top
+				};
+				this.handlePinch(a, s);
+				return;
+			}
+			if (r.length === 1 && o === r[0].identifier) {
+				let n = r[0], i = e.getBoundingClientRect();
+				t.updateDrag(n.clientX - i.left, n.clientY - i.top), this.events.emit("pan", t.getViewportBounds());
+			}
+		}), this.listen(e, "touchend", (n) => {
+			if (this.lastPinchDistance = void 0, n.touches.length === 0) t.isDragging() && (t.endDrag(), this.events.emit("pan", t.getViewportBounds())), o = void 0;
+			else if (n.touches.length === 1) {
+				let r = n.touches[0];
+				o = r.identifier;
+				let i = e.getBoundingClientRect();
+				t.startDrag(r.clientX - i.left, r.clientY - i.top);
+			}
+		}, { passive: !0 }), this.listen(e, "touchcancel", () => {
+			this.lastPinchDistance = void 0, t.isDragging() && t.endDrag(), o = void 0;
+		}, { passive: !0 }), this.listen(e, "wheel", (r) => {
+			r.preventDefault();
+			let i = e.getBoundingClientRect(), a = r.clientX - i.left, o = r.clientY - i.top, s = r.deltaY > 0 ? -1 : 1;
+			r.ctrlKey && (s = -s);
+			let c = s > 0 ? t.zoom * n : t.zoom / n;
+			t.zoomToPoint(c, a, o) && (this.events.emit("zoom", { zoom: t.zoom }), this.events.emit("pan", t.getViewportBounds()));
+		}, { passive: !1 });
+	}
+	handlePinch(e, t) {
+		let n = Math.hypot(e.x - t.x, e.y - t.y);
+		if (this.lastPinchDistance === void 0 || this.lastPinchDistance === 0 || n === 0) {
+			this.lastPinchDistance = n;
+			return;
+		}
+		let r = (e.x + t.x) / 2, i = (e.y + t.y) / 2, a = this.camera.zoom * (n / this.lastPinchDistance);
+		this.camera.zoomToPoint(a, r, i) && (this.events.emit("zoom", { zoom: this.camera.zoom }), this.events.emit("pan", this.camera.getViewportBounds())), this.lastPinchDistance = n;
+	}
+	initMapEvents() {
+		let e = this.container, t = null;
+		this.listen(e, "mousemove", (e) => {
+			let n = this.pickAtClientPoint(e.clientX, e.clientY)?.kind ?? null;
+			n !== t && (t = n, this.setCursor(n === "room" || n === "areaExit" ? "pointer" : "auto"));
+		}), this.listen(e, "mouseleave", () => {
+			t = null, this.setCursor("auto");
+		});
+		let n = null;
+		this.listen(e, "mousedown", (e) => {
+			e.button === 0 && (n = {
+				x: e.clientX,
+				y: e.clientY
+			});
+		}), this.listen(e, "mouseup", (e) => {
+			if (e.button !== 0 || !n) return;
+			let t = e.clientX - n.x, r = e.clientY - n.y;
+			if (n = null, t * t + r * r > 25) return;
+			let i = this.pickAtClientPoint(e.clientX, e.clientY);
+			if (i?.kind === "room") {
+				this.emitRoomClickEvent(i.id, e.clientX, e.clientY);
+				return;
+			}
+			if (i?.kind === "areaExit") {
+				let t = i.payload?.targetRoomId ?? i.id;
+				this.emitAreaExitClickEvent(t, e.clientX, e.clientY);
+				return;
+			}
+			this.emitMapClickEvent();
+		}), this.listen(e, "contextmenu", (e) => {
+			let t = this.pickAtClientPoint(e.clientX, e.clientY);
+			t?.kind === "room" && (e.preventDefault(), this.emitRoomContextEvent(t.id, e.clientX, e.clientY));
+		});
+		let r, i, a = () => {
+			r !== void 0 && (window.clearTimeout(r), r = void 0), i = void 0;
+		};
+		this.listen(e, "touchstart", (e) => {
+			if (a(), e.touches.length > 1) return;
+			let t = e.touches[0];
+			t && this.pickAtClientPoint(t.clientX, t.clientY)?.kind === "room" && (i = {
+				clientX: t.clientX,
+				clientY: t.clientY
+			}, r = window.setTimeout(() => {
+				if (i) {
+					let e = this.pickAtClientPoint(i.clientX, i.clientY);
+					e?.kind === "room" && this.emitRoomContextEvent(e.id, i.clientX, i.clientY);
+				}
+				a();
+			}, 500));
+		}, { passive: !0 }), this.listen(e, "touchend", () => a(), { passive: !0 }), this.listen(e, "touchcancel", () => a(), { passive: !0 }), this.listen(e, "touchmove", (e) => {
+			if (!i) return;
+			let t = e.touches[0];
+			if (!t) {
+				a();
+				return;
+			}
+			let n = t.clientX - i.clientX, r = t.clientY - i.clientY;
+			n * n + r * r > 100 && a();
+		}, { passive: !0 });
+	}
+	pickAtClientPoint(e, t) {
+		let n = this.hitTest.clientToMapPoint(e, t);
+		return n ? this.hitTest.pickAtPoint(n.x, n.y) : null;
+	}
+	emitRoomClickEvent(e, t, n) {
+		let r = this.container.getBoundingClientRect();
+		this.events.emit("roomclick", {
+			roomId: e,
+			position: {
+				x: t - r.left,
+				y: n - r.top
+			}
+		});
+	}
+	emitRoomContextEvent(e, t, n) {
+		let r = this.container.getBoundingClientRect();
+		this.events.emit("roomcontextmenu", {
+			roomId: e,
+			position: {
+				x: t - r.left,
+				y: n - r.top
+			}
+		});
+	}
+	emitAreaExitClickEvent(e, t, n) {
+		let r = this.container.getBoundingClientRect();
+		this.events.emit("areaexitclick", {
+			targetRoomId: e,
+			position: {
+				x: t - r.left,
+				y: n - r.top
+			}
+		});
+	}
+	emitMapClickEvent() {
+		this.events.emit("mapclick", void 0);
+	}
+}, K = [
+	"up",
+	"down",
+	"in",
+	"out"
+];
+function q(e, t, n, r, i) {
+	return e.roomShape === "circle" ? S(t, n, r, i) : e.roomShape === "roundedRectangle" ? x(t, n, r, i, e.roomSize * .2) : b(t, n, r, i);
+}
+function me(e, t, n) {
+	for (let [e, r] of Object.entries(t.exits)) if (r === n.id) {
+		let r = e;
+		if (K.includes(r)) {
+			let e = h[r];
+			return {
+				type: "inner",
+				fromDir: r,
+				customLineKey: t.customLines[e] ? e : t.customLines[r] ? r : void 0,
+				fromRoom: t,
+				toRoom: n
+			};
+		}
+		let i = h[r];
+		return t.customLines[i] ? {
+			type: "special",
+			fromDir: r,
+			customLineKey: i,
+			fromRoom: t,
+			toRoom: n
+		} : t.customLines[r] ? {
+			type: "special",
+			fromDir: r,
+			customLineKey: r,
+			fromRoom: t,
+			toRoom: n
+		} : {
+			type: "regular",
+			fromDir: r,
+			toDir: he(n, t.id),
+			fromRoom: t,
+			toRoom: n
+		};
+	}
+	for (let [e, r] of Object.entries(t.specialExits)) if (r === n.id) return t.customLines[e] ? {
+		type: "special",
+		customLineKey: e,
+		fromRoom: t,
+		toRoom: n
+	} : {
+		type: "inner",
+		fromRoom: t,
+		toRoom: n
+	};
+	for (let [e, r] of Object.entries(n.exits)) if (r === t.id) {
+		let r = e;
+		if (K.includes(r)) {
+			let e = h[r];
+			return {
+				type: "inner",
+				toDir: r,
+				customLineKey: n.customLines[e] ? e : n.customLines[r] ? r : void 0,
+				fromRoom: t,
+				toRoom: n
+			};
+		}
+		let i = h[r];
+		return n.customLines[i] ? {
+			type: "special",
+			toDir: r,
+			customLineKey: i,
+			fromRoom: t,
+			toRoom: n
+		} : n.customLines[r] ? {
+			type: "special",
+			toDir: r,
+			customLineKey: r,
+			fromRoom: t,
+			toRoom: n
+		} : {
+			type: "regular",
+			toDir: r,
+			fromRoom: t,
+			toRoom: n
+		};
+	}
+	for (let [e, r] of Object.entries(n.specialExits)) if (r === t.id) return n.customLines[e] ? {
+		type: "special",
+		customLineKey: e,
+		fromRoom: t,
+		toRoom: n
+	} : {
+		type: "inner",
+		fromRoom: t,
+		toRoom: n
+	};
+	return {
+		type: "none",
+		fromRoom: t,
+		toRoom: n
+	};
+}
+function he(e, t) {
+	for (let [n, r] of Object.entries(e.exits)) if (r === t) return n;
+}
+function J(e, t, n) {
+	return e ? e.area === t && e.z === n : !1;
+}
+function ge(e, t) {
+	for (let [n, r] of Object.entries(e.exits)) if (r === t.id) return { direction: n };
+	for (let [n, r] of Object.entries(e.specialExits)) if (r === t.id) return;
+}
+function _e(e, t) {
+	for (let n of _) if (e.exits[n] === t.id) return n;
+	for (let n of _) if (t.exits[n] === e.id) return v[n];
+}
+function ve(e, t, n) {
+	let { fromRoom: r, toRoom: i, fromDir: a, toDir: o } = t;
+	if (n.length === 0 && n.push(r.x, r.y), a && p.includes(a)) {
+		let t = q(e, r.x, r.y, a, e.roomSize / 2);
+		n.push(t.x, t.y);
+	}
+	if (o && p.includes(o)) {
+		let t = q(e, i.x, i.y, o, e.roomSize / 2);
+		n.push(t.x, t.y);
+	}
+	n.push(i.x, i.y);
+}
+function ye(e, t) {
+	let { fromRoom: n, toRoom: r, customLineKey: i } = e, a = n, o;
+	i && (o = n.customLines[i], o || (o = r.customLines[i], a = r)), t.length === 0 && t.push(a.x, a.y), o && o.points.forEach((e) => {
+		t.push(e.x, -e.y);
+	}), t.push(r.x, r.y);
+}
+function Y(e, t, n, r, i) {
+	let a = [], o = [], s = [], c = n.map((t) => e.getRoom(t)).filter((e) => e !== void 0), l = [], u = () => {
+		l.length >= 4 && a.push({ points: [...l] }), l = [];
+	}, d = (e) => {
+		let { fromRoom: t, toRoom: n, fromDir: r, toDir: i, customLineKey: a } = e;
+		if (a) {
+			let e = t, r = t.customLines[a];
+			if (r || (r = n.customLines[a], e = n), r) {
+				let t = [e.x, e.y];
+				r.points.forEach((e) => {
+					t.push(e.x, -e.y);
+				}), s.push({ points: t });
+			}
+		}
+		r && K.includes(r) && o.push({
+			room: t,
+			direction: r
+		}), i && K.includes(i) && o.push({
+			room: n,
+			direction: i
+		});
+	};
+	for (let n = 0; n < c.length - 1; n++) {
+		let a = c[n], s = c[n + 1], f = J(a, r, i), m = J(s, r, i);
+		if (!f && !m) {
+			u();
+			continue;
+		}
+		if (f && m) {
+			let n = me(e, a, s);
+			switch (n.type) {
+				case "regular":
+					ve(t, n, l);
+					break;
+				case "special":
+					ye(n, l);
+					break;
+				case "inner":
+					u(), d(n);
+					break;
+				case "none":
+					l.length === 0 && l.push(a.x, a.y), l.push(s.x, s.y);
+					break;
+			}
+		} else {
+			let e = f ? a : s, n = f ? s : a, r = ge(e, n);
+			if (r) {
+				if (K.includes(r.direction)) u(), o.push({
+					room: e,
+					direction: r.direction
+				});
+				else if (p.includes(r.direction)) {
+					l.length === 0 && l.push(e.x, e.y);
+					let n = q(t, e.x, e.y, r.direction, t.roomSize / 2), i = b(e.x, e.y, r.direction, t.roomSize);
+					l.push(n.x, n.y, i.x, i.y), u();
+				}
+			} else {
+				let r = _e(e, n);
+				if (r) {
+					l.length === 0 && l.push(e.x, e.y);
+					let n = q(t, e.x, e.y, r, t.roomSize / 2), i = b(e.x, e.y, r, t.roomSize);
+					l.push(n.x, n.y, i.x, i.y), u();
+				}
+			}
+		}
+	}
+	return u(), {
+		segments: a,
+		innerMarkers: o,
+		customLines: s
+	};
+}
+//#endregion
+//#region src/scene/OverlayStyle.ts
+function be(e, t) {
+	let n = e.shape ?? "match";
+	return n === "match" ? (e.matchRoomShape ?? !0) && t !== "circle" ? t === "roundedRectangle" ? "roundedRectangle" : "rectangle" : "circle" : n;
+}
+function X(e, t, n) {
+	let r = n.highlight, i = n.roomSize, a = r.sizeFactor, o = be(r, n.roomShape), s = Array.isArray(t) ? t.length > 0 ? [...t] : ["#ffffff"] : [t];
+	return {
+		shape: o === "circle" ? "circle" : "rect",
+		cx: e.x,
+		cy: e.y,
+		size: i / 2 * a,
+		cornerRadius: o === "roundedRectangle" ? i * a * .2 : 0,
+		colors: s,
+		strokeAlpha: r.strokeAlpha,
+		strokeWidth: r.strokeWidth,
+		fillAlpha: r.fillAlpha,
+		dash: r.dash,
+		dashEnabled: r.dashEnabled
+	};
+}
+function xe(e, t) {
+	let n = t.playerMarker, r = t.roomSize * n.sizeFactor, i = n.matchRoomShape && t.roomShape !== "circle";
+	return {
+		shape: i ? "rect" : "circle",
+		cx: e.x,
+		cy: e.y,
+		size: r / 2,
+		cornerRadius: i && t.roomShape === "roundedRectangle" ? r * .2 : 0,
+		strokeColor: n.strokeColor,
+		strokeWidth: n.strokeWidth,
+		strokeAlpha: n.strokeAlpha,
+		fillColor: n.fillColor,
+		fillAlpha: n.fillAlpha,
+		dash: n.dash,
+		dashEnabled: n.dashEnabled
+	};
+}
+function Z(e, t, n, r, i, a) {
+	let o = Y(e, t, n, i, a), s = t.lineWidth, c = [];
+	for (let e of o.segments) e.points.length >= 4 && c.push({ points: e.points });
+	for (let e of o.customLines) e.points.length >= 4 && c.push({ points: e.points });
+	let l = [];
+	for (let e of o.innerMarkers) for (let n of z(e.room, e.direction, t)) l.push({ vertices: n.vertices });
+	return {
+		segments: c,
+		triangles: l,
+		color: r,
+		outlineWidth: s * 8,
+		lineWidth: s * 4
+	};
+}
+//#endregion
+//#region src/scene/elements/OverlayLayout.ts
+function Se(e) {
+	if (e.colors.length > 1) return Ce(e);
+	let t = e.colors[0], n = a(t, e.strokeAlpha), r = e.fillAlpha > 0 ? a(t, e.fillAlpha) : void 0;
+	if (e.shape === "circle") return {
+		type: "circle",
+		cx: e.cx,
+		cy: e.cy,
+		radius: e.size,
+		paint: {
+			fill: r,
+			stroke: n,
+			strokeWidth: e.strokeWidth,
+			dash: e.dash,
+			dashEnabled: e.dashEnabled
+		},
+		layer: "overlay"
+	};
+	if (e.cornerRadius > 0) return {
+		type: "rect",
+		x: e.cx - e.size,
+		y: e.cy - e.size,
+		width: e.size * 2,
+		height: e.size * 2,
+		cornerRadius: e.cornerRadius,
+		paint: {
+			fill: r,
+			stroke: n,
+			strokeWidth: e.strokeWidth,
+			dash: e.dash,
+			dashEnabled: e.dashEnabled
+		},
+		layer: "overlay"
+	};
+	let i = e.cx - e.size, o = e.cy - e.size, s = e.cx + e.size, c = e.cy + e.size, l = [
+		[
+			i,
+			o,
+			s,
+			o
+		],
+		[
+			s,
+			o,
+			s,
+			c
+		],
+		[
+			s,
+			c,
+			i,
+			c
+		],
+		[
+			i,
+			c,
+			i,
+			o
+		]
+	], u = [];
+	r && u.push({
+		type: "rect",
+		x: i,
+		y: o,
+		width: e.size * 2,
+		height: e.size * 2,
+		cornerRadius: e.cornerRadius,
+		paint: { fill: r },
+		layer: "overlay"
+	});
+	for (let t of l) u.push({
+		type: "line",
+		points: t,
+		paint: {
+			stroke: n,
+			strokeWidth: e.strokeWidth,
+			dash: e.dash,
+			dashEnabled: e.dashEnabled
+		},
+		lineCap: "butt",
+		layer: "overlay"
+	});
+	return {
+		type: "group",
+		x: 0,
+		y: 0,
+		children: u,
+		layer: "overlay"
+	};
+}
+function Ce(e) {
+	let t = e.colors.length, n = Math.PI * 2 / t, r = -Math.PI / 2, i = [];
+	for (let o = 0; o < t; o++) {
+		let t = e.colors[o], s = a(t, e.strokeAlpha), c = e.fillAlpha > 0 ? a(t, e.fillAlpha) : void 0, l = r + o * n, u = Te(e, l, l + n);
+		if (c) {
+			let t = [e.cx, e.cy];
+			for (let [e, n] of u) t.push(e, n);
+			i.push({
+				type: "polygon",
+				vertices: t,
+				paint: { fill: c },
+				layer: "overlay"
+			});
+		}
+		let d = [];
+		for (let [e, t] of u) d.push(e, t);
+		i.push({
+			type: "line",
+			points: d,
+			paint: {
+				stroke: s,
+				strokeWidth: e.strokeWidth,
+				dash: e.dash,
+				dashEnabled: e.dashEnabled
+			},
+			lineCap: "butt",
+			layer: "overlay"
+		});
+	}
+	return {
+		type: "group",
+		x: 0,
+		y: 0,
+		children: i,
+		layer: "overlay"
+	};
+}
+function we(e, t) {
+	let n = Math.cos(t), r = Math.sin(t);
+	if (e.shape === "circle") return [e.cx + e.size * n, e.cy + e.size * r];
+	let i = e.size, a = Math.max(Math.abs(n), Math.abs(r)), o = i / a * n, s = i / a * r, c = Math.min(e.cornerRadius, i), l = i - c;
+	if (c > 0 && Math.abs(o) > l && Math.abs(s) > l) {
+		let t = Math.sign(o) * l, i = Math.sign(s) * l, a = t * n + i * r, u = t * t + i * i, d = a + Math.sqrt(Math.max(0, a * a - (u - c * c)));
+		return [e.cx + d * n, e.cy + d * r];
+	}
+	return [e.cx + o, e.cy + s];
+}
+function Te(e, t, n) {
+	let r = [t], i = e.shape !== "circle" && e.cornerRadius > 0;
+	if (e.shape === "circle" || i) {
+		let e = i ? Math.PI / 36 : Math.PI / 18, a = Math.max(1, Math.ceil((n - t) / e));
+		for (let e = 1; e < a; e++) r.push(t + (n - t) * e / a);
+	} else {
+		let e = Math.PI / 2, i = Math.PI / 4, a = Math.ceil((t - i) / e), o = Math.floor((n - i) / e);
+		for (let s = a; s <= o; s++) {
+			let a = i + s * e;
+			a > t + 1e-9 && a < n - 1e-9 && r.push(a);
+		}
+	}
+	return r.push(n), r.sort((e, t) => e - t), r.map((t) => we(e, t));
+}
+function Ee(e) {
+	let t = a(e.strokeColor, e.strokeAlpha), n = e.fillAlpha > 0 ? a(e.fillColor, e.fillAlpha) : void 0;
+	return e.shape === "circle" ? {
+		type: "circle",
+		cx: e.cx,
+		cy: e.cy,
+		radius: e.size,
+		paint: {
+			fill: n,
+			stroke: t,
+			strokeWidth: e.strokeWidth,
+			dash: e.dash,
+			dashEnabled: e.dashEnabled
+		},
+		layer: "overlay"
+	} : {
+		type: "rect",
+		x: e.cx - e.size,
+		y: e.cy - e.size,
+		width: e.size * 2,
+		height: e.size * 2,
+		cornerRadius: e.cornerRadius,
+		paint: {
+			fill: n,
+			stroke: t,
+			strokeWidth: e.strokeWidth,
+			dash: e.dash,
+			dashEnabled: e.dashEnabled
+		},
+		layer: "overlay"
+	};
+}
+function De(e) {
+	let t = [];
+	for (let n of e.segments) t.push({
+		type: "line",
+		points: n.points,
+		paint: {
+			stroke: "black",
+			strokeWidth: e.outlineWidth,
+			alpha: .8
+		},
+		lineCap: "round",
+		lineJoin: "round",
+		layer: "overlay"
+	}), t.push({
+		type: "line",
+		points: n.points,
+		paint: {
+			stroke: e.color,
+			strokeWidth: e.lineWidth,
+			alpha: .8
+		},
+		lineCap: "round",
+		lineJoin: "round",
+		layer: "overlay"
+	});
+	for (let n of e.triangles) t.push({
+		type: "polygon",
+		vertices: n.vertices,
+		paint: {
+			fill: e.color,
+			stroke: "black",
+			strokeWidth: e.outlineWidth / 4
+		},
+		layer: "overlay"
+	});
+	return t;
+}
+//#endregion
+//#region src/hit/HitTester.ts
+var Oe = {
+	areaExit: 110,
+	room: 100,
+	label: 80,
+	specialExit: 60,
+	exit: 40,
+	stub: 20
+}, ke = {
+	room: .3,
+	areaExit: 1,
+	label: 1,
+	specialExit: .5,
+	exit: .35,
+	stub: .3
+}, Ae = (e, t) => ({
+	x: e,
+	y: t
+}), je = class {
+	constructor() {
+		this.entries = [], this.bucketSize = 5, this.roomSize = 1, this.spatialIndex = /* @__PURE__ */ new Map(), this.transform = Ae;
+	}
+	build(e, t, n, r) {
+		this.clear(), this.roomSize = t, this.bucketSize = Math.max(t * 10, 5), this.transform = n ?? Ae, this.layerOffset = r, this.collectHitShapes(e, 0, 0);
+	}
+	clear() {
+		this.entries = [], this.spatialIndex.clear();
+	}
+	pick(e, t) {
+		let n = null, r = Infinity, i = Infinity, a = -Infinity;
+		return this.forEachCandidate(e, t, (o, s) => {
+			let c = e - o.cx, l = t - o.cy, u = c * c + l * l;
+			(o.priority > a || o.priority === a && s < r || o.priority === a && s === r && u < i) && (n = o, r = s, i = u, a = o.priority);
+		}), n ? this.toResult(n, r) : null;
+	}
+	pickAll(e, t) {
+		let n = [];
+		return this.forEachCandidate(e, t, (e, t) => {
+			n.push({
+				entry: e,
+				dist: t
+			});
+		}), n.sort((e, t) => t.entry.priority - e.entry.priority || e.dist - t.dist), n.map((e) => this.toResult(e.entry, e.dist));
+	}
+	pickInRect(e, t, n, r, i) {
+		let a = Math.min(e, n), o = Math.max(e, n), s = Math.min(t, r), c = Math.max(t, r), l = [];
+		for (let e of this.entries) i && !i.includes(e.info.kind) || e.cx < a || e.cx > o || e.cy < s || e.cy > c || l.push(this.toResult(e, 0));
+		return l.sort((e, t) => t.priority - e.priority), l;
+	}
+	findRoomAtPoint(e, t) {
+		let n = this.pick(e, t);
+		return !n || n.kind !== "room" ? null : n.payload ?? null;
+	}
+	debugEntries() {
+		return this.entries.map((e) => ({
+			kind: e.info.kind,
+			geoms: e.geoms,
+			marginRadius: e.margin * this.roomSize,
+			minX: e.rMinX,
+			maxX: e.rMaxX,
+			minY: e.rMinY,
+			maxY: e.rMaxY
+		}));
+	}
+	forEachCandidate(e, t, n) {
+		let r = Math.floor(e / this.bucketSize), i = Math.floor(t / this.bucketSize), a = /* @__PURE__ */ new Set();
+		for (let o = -1; o <= 1; o++) for (let s = -1; s <= 1; s++) {
+			let c = this.spatialIndex.get(ze(r + o, i + s));
+			if (c) for (let r of c) {
+				if (a.has(r)) continue;
+				a.add(r);
+				let i = r.margin * this.roomSize;
+				if (e < r.rMinX - i || e > r.rMaxX + i || t < r.rMinY - i || t > r.rMaxY + i) continue;
+				let o = Pe(r, e, t);
+				o > i || n(r, o);
+			}
+		}
+	}
+	toResult(e, t) {
+		return {
+			kind: e.info.kind,
+			id: e.info.id,
+			payload: e.info.payload,
+			distance: t,
+			priority: e.priority,
+			centerX: e.cx,
+			centerY: e.cy
+		};
+	}
+	collectHitShapes(e, t, n) {
+		for (let r of e) {
+			if (r.hit) {
+				let e = [], i = Me();
+				Ne(r, t, n, this.entryTransform(r.layer), e, i), e.length > 0 && i.minX <= i.maxX && this.indexEntry(i, e, r.hit);
+			}
+			r.type === "group" && this.collectHitShapes(r.children, t + r.x, n + r.y);
+		}
+	}
+	entryTransform(e) {
+		let t = this.layerOffset?.(e);
+		if (!t || t.x === 0 && t.y === 0) return this.transform;
+		let n = this.transform;
+		return (e, r) => {
+			let i = n(e, r);
+			return {
+				x: i.x + t.x,
+				y: i.y + t.y
+			};
+		};
+	}
+	indexEntry(e, t, n) {
+		let r = n.margin ?? ke[n.kind] ?? 1, i = n.priority ?? Oe[n.kind] ?? 50, a = (e.minX + e.maxX) / 2, o = (e.minY + e.maxY) / 2, s = {
+			info: n,
+			margin: r,
+			priority: i,
+			rMinX: e.minX,
+			rMaxX: e.maxX,
+			rMinY: e.minY,
+			rMaxY: e.maxY,
+			cx: a,
+			cy: o,
+			geoms: t
+		};
+		this.entries.push(s);
+		let c = this.bucketSize, l = Math.floor(e.minX / c), u = Math.floor(e.maxX / c), d = Math.floor(e.minY / c), f = Math.floor(e.maxY / c);
+		for (let e = l; e <= u; e++) for (let t = d; t <= f; t++) {
+			let n = ze(e, t), r = this.spatialIndex.get(n);
+			r || (r = [], this.spatialIndex.set(n, r)), r.push(s);
+		}
+	}
+};
+function Me() {
+	return {
+		minX: Infinity,
+		minY: Infinity,
+		maxX: -Infinity,
+		maxY: -Infinity
+	};
+}
+function Q(e, t, n) {
+	t < e.minX && (e.minX = t), t > e.maxX && (e.maxX = t), n < e.minY && (e.minY = n), n > e.maxY && (e.maxY = n);
+}
+function Ne(e, t, n, r, i, a) {
+	if (e.type === "group") {
+		for (let o of e.children) o.hit || $(o, t + e.x, n + e.y, r, i, a);
+		return;
+	}
+	$(e, t, n, r, i, a);
+}
+function $(e, t, n, r, i, a) {
+	switch (e.type) {
+		case "rect":
+		case "image": {
+			let o = r(t + e.x, n + e.y), s = r(t + e.x + e.width, n + e.y), c = r(t + e.x + e.width, n + e.y + e.height), l = r(t + e.x, n + e.y + e.height), u = [
+				o.x,
+				o.y,
+				s.x,
+				s.y,
+				c.x,
+				c.y,
+				l.x,
+				l.y
+			];
+			i.push({
+				type: "polyline",
+				pts: u,
+				closed: !0
+			});
+			for (let e = 0; e < u.length; e += 2) Q(a, u[e], u[e + 1]);
+			return;
+		}
+		case "text": {
+			let o = e.width ?? 0, s = e.height ?? 0;
+			if (o === 0 || s === 0) {
+				let i = r(t + e.x, n + e.y);
+				Q(a, i.x, i.y);
+				return;
+			}
+			let c = r(t + e.x, n + e.y), l = r(t + e.x + o, n + e.y), u = r(t + e.x + o, n + e.y + s), d = r(t + e.x, n + e.y + s), f = [
+				c.x,
+				c.y,
+				l.x,
+				l.y,
+				u.x,
+				u.y,
+				d.x,
+				d.y
+			];
+			i.push({
+				type: "polyline",
+				pts: f,
+				closed: !0
+			});
+			for (let e = 0; e < f.length; e += 2) Q(a, f[e], f[e + 1]);
+			return;
+		}
+		case "circle": {
+			let o = r(t + e.cx, n + e.cy);
+			i.push({
+				type: "circle",
+				cx: o.x,
+				cy: o.y,
+				r: e.radius
+			}), Q(a, o.x - e.radius, o.y - e.radius), Q(a, o.x + e.radius, o.y + e.radius);
+			return;
+		}
+		case "line": {
+			let o = [];
+			for (let i = 0; i < e.points.length; i += 2) {
+				let s = r(t + e.points[i], n + e.points[i + 1]);
+				o.push(s.x, s.y), Q(a, s.x, s.y);
+			}
+			o.length >= 2 && i.push({
+				type: "polyline",
+				pts: o,
+				closed: !1
+			});
+			return;
+		}
+		case "polygon": {
+			let o = [];
+			for (let i = 0; i < e.vertices.length; i += 2) {
+				let s = r(t + e.vertices[i], n + e.vertices[i + 1]);
+				o.push(s.x, s.y), Q(a, s.x, s.y);
+			}
+			o.length >= 2 && i.push({
+				type: "polyline",
+				pts: o,
+				closed: !0
+			});
+			return;
+		}
+		case "group":
+			for (let o of e.children) o.hit || $(o, t + e.x, n + e.y, r, i, a);
+			return;
+	}
+}
+function Pe(e, t, n) {
+	let r = Infinity;
+	for (let i of e.geoms) {
+		let e = Fe(i, t, n);
+		if (e < r && (r = e), r === 0) return 0;
+	}
+	return r;
+}
+function Fe(e, t, n) {
+	if (e.type === "circle") {
+		let r = t - e.cx, i = n - e.cy;
+		return Math.max(0, Math.hypot(r, i) - e.r);
+	}
+	return e.closed && Re(e.pts, t, n) ? 0 : Ie(e.pts, t, n, e.closed);
+}
+function Ie(e, t, n, r) {
+	let i = e.length / 2;
+	if (i < 2) return i === 1 ? Math.hypot(t - e[0], n - e[1]) : Infinity;
+	let a = Infinity, o = r ? i : i - 1;
+	for (let r = 0; r < o; r++) {
+		let o = r * 2, s = (r + 1) % i * 2, c = Le(t, n, e[o], e[o + 1], e[s], e[s + 1]);
+		c < a && (a = c);
+	}
+	return a;
+}
+function Le(e, t, n, r, i, a) {
+	let o = i - n, s = a - r, c = o * o + s * s, l = c === 0 ? 0 : ((e - n) * o + (t - r) * s) / c;
+	l < 0 ? l = 0 : l > 1 && (l = 1);
+	let u = n + l * o, d = r + l * s;
+	return Math.hypot(e - u, t - d);
+}
+function Re(e, t, n) {
+	let r = !1, i = e.length / 2;
+	for (let a = 0, o = i - 1; a < i; o = a++) {
+		let i = e[a * 2], s = e[a * 2 + 1], c = e[o * 2], l = e[o * 2 + 1], u = l - s || 1e-12;
+		s > n != l > n && t < (c - i) * (n - s) / u + i && (r = !r);
+	}
+	return r;
+}
+function ze(e, t) {
+	return e * 1000003 + t;
+}
+//#endregion
+//#region src/style/Style.ts
+var Be = { transform: (e) => e };
+function Ve(...e) {
+	return e.length === 0 ? Be : e.length === 1 ? e[0] : {
+		transform(t, n) {
+			let r = [t];
+			for (let t of e) {
+				let e = [];
+				for (let i of r) {
+					let r = t.transform(i, n);
+					Array.isArray(r) ? e.push(...r) : e.push(r);
+				}
+				r = e;
+			}
+			return r;
+		},
+		worldToScene(t, n) {
+			let r = {
+				x: t,
+				y: n
+			};
+			for (let t of e) t.worldToScene && (r = t.worldToScene(r.x, r.y));
+			return r;
+		},
+		sceneToWorld(t, n) {
+			let r = {
+				x: t,
+				y: n
+			};
+			for (let t = e.length - 1; t >= 0; t--) {
+				let n = e[t];
+				n.sceneToWorld && (r = n.sceneToWorld(r.x, r.y));
+			}
+			return r;
+		},
+		sceneLayerOffset(t) {
+			let n = 0, r = 0;
+			for (let i of e) {
+				if (!i.sceneLayerOffset) continue;
+				let e = i.sceneLayerOffset(t);
+				n += e.x, r += e.y;
+			}
+			return {
+				x: n,
+				y: r
+			};
+		}
+	};
+}
+//#endregion
+//#region src/style/applyStyle.ts
+function He(e, t, n) {
+	let r = [];
+	for (let i of e) {
+		let e = Ue(i, t, n);
+		Array.isArray(e) ? r.push(...e) : r.push(e);
+	}
+	return r;
+}
+function Ue(e, t, n) {
+	if (e.type === "group") {
+		let r = [];
+		for (let i of e.children) {
+			let e = Ue(i, t, n);
+			Array.isArray(e) ? r.push(...e) : r.push(e);
+		}
+		return t.transform({
+			...e,
+			children: r
+		}, n);
+	}
+	return t.transform(e, n);
+}
+//#endregion
+//#region src/export/flushSceneShapes.ts
+function We(e, t, n) {
+	n(e.grid), n(e.link), n(e.room), n(Ge(t.state, t.overlays));
+	for (let e of t.sceneOverlays) {
+		let r = e.render(t.state, t.viewportBounds);
+		r && n(Array.isArray(r) ? r : [r], e.sceneSpace);
+	}
+	n(e.topLabel);
+}
+function Ge(e, t) {
+	let n = e.getOverlaysForArea(t);
+	if (!n) return [];
+	let r = e.settings, i = [];
+	if (n.paths) for (let t of n.paths) {
+		let n = Z(e.mapReader, r, t.locations, t.color, e.currentArea, e.currentZIndex);
+		i.push(...De(n));
+	}
+	if (n.highlights) for (let t of n.highlights) {
+		let n = e.mapReader.getRoom(t.roomId);
+		n && i.push(Se(X(n, t.color, r)));
+	}
+	if (n.position) {
+		let t = e.mapReader.getRoom(n.position.roomId);
+		t && i.push(Ee(xe(t, r)));
+	}
+	return i;
+}
+//#endregion
+export { t as A, _ as C, s as D, u as E, a as M, r as N, c as O, v as S, d as T, H as _, Be as a, A as b, De as c, Z as d, xe as f, U as g, fe as h, Ve as i, n as j, o as k, Ee as l, pe as m, We as n, je as o, Y as p, He as r, Se as s, Ge as t, X as u, B as v, f as w, O as x, L as y };
+
+//# sourceMappingURL=flushSceneShapes-Duhi0OQv.js.map