mudlet-map-renderer 2.5.1 → 2.6.0

package/README.md

@@ -186,6 +186,74 @@ For large maps, spatial culling hides off-screen rooms for better performance:
 renderer.setCullingMode('indexed');
 ```
 
+### Big maps (LOD + skeleton reader)
+
+Very dense planes (tens of thousands to millions of rooms on one z-level)
+can't be drawn as one vector scene. Two core features combine to handle them:
+
+**Raster LOD overview** (`settings.lodEnabled`, works with any reader): when
+the current plane holds more rooms than `settings.lodRoomBudget` (default
+16 000) *and* the zoom is far enough out that a viewport could exceed that
+budget, the vector scene is replaced by a pixel overview — one filled box per
+room, painted on an underlay below the grid. Zooming in switches back to full
+vector detail. The switch is zoom-based (pan-invariant, no mid-pan flips) and
+reported through the `lod` renderer event
+(`{mode: 'vector' | 'roomsOnly' | 'raster', planeRoomCount, visibleEstimate, hitTestActive}`).
+Position marker, highlights, paths and overlays stay visible in both `raster`
+and `roomsOnly` modes.
+
+Between `settings.lodExitBudget` (default `12 000`) and `lodRoomBudget`, a
+third tier — `roomsOnly` — drops exit lines while rooms keep rendering as
+real vector shapes (env colour, border, shape): a bridge between full detail
+and the flat raster pixels. Exit pairing and exit-line shape building are
+typically the single largest share of a dense rebuild's cost (exit count
+often runs ~2x room count in a well-connected area), so this tier buys back
+most of that cost while still showing actual room geometry. Set
+`lodExitBudget` above `lodRoomBudget` (or to `Infinity`) to disable this tier
+and jump straight from full vector to raster.
+
+Above `settings.lodHitTestBudget` (default `10 000` rooms, same unit as
+`lodRoomBudget`) the scene still renders at full vector detail (with or
+without exits) but the hit-test index is skipped, so clicks/hover stop
+resolving to a room until you zoom in a bit further — rebuilding that index
+is a real cost on a large scene, and precise pointer picking rarely matters
+that zoomed out. Rebuild-on-pan also pads the viewport generously (50% per
+side): panning inside that padding is free, so it buys a lot more distance
+between rebuilds without making any single rebuild bigger — the LOD decision
+compensates for the padding so the actual room count at each tier's flip
+stays pinned near its configured budget regardless.
+
+**`SkeletonMapReader`** (`mudlet-map-renderer/bigmap`): an `IMapReader` over a
+compact typed-array `MapSkeleton` instead of a room object graph. Planes
+materialise only the rooms inside the current viewport; the interactive
+backend detects this (`ViewportDataSource`) and pushes padded camera bounds
+before every build, rebuilding on pan only when the camera leaves the padding.
+
+```ts
+import { MapRenderer, createSettings } from 'mudlet-map-renderer';
+import { buildSkeleton, SkeletonMapReader } from 'mudlet-map-renderer/bigmap';
+
+// Eager path: the map parses fine, it's the rendering that chokes.
+const reader = new SkeletonMapReader(buildSkeleton(mapData, colors));
+const settings = { ...createSettings(), lodEnabled: true };
+const renderer = new MapRenderer(reader, settings, container);
+renderer.on('lod', ({ mode, visibleEstimate }) => console.log(mode, visibleEstimate));
+```
+
+For maps too large to parse eagerly (hundreds of MB), produce the
+`MapSkeleton` out-of-process — e.g. a Web Worker that streams the binary map
+and transfers the typed arrays zero-copy. `demo/streaming/` is a reference
+implementation. `MapSkeleton` is a stable seam: coordinates are raw Mudlet map
+space (the reader converts once at construction), bulk rooms live in parallel
+`Int32Array` columns, and only rooms with visual detail (symbols, custom
+lines, special exits…) are materialised in full.
+
+Notes: exports through a viewport-narrowed reader only contain the applied
+viewport (call `reader.setViewport(...)` with larger bounds first if you need
+everything); `lodEnabled` is currently a no-op for the OffscreenCanvas
+backend; decorator styles with coordinate transforms (e.g. isometric) are not
+applied to the raster overview.
+
 ### OffscreenCanvas rendering (Web Worker)
 
 For large maps, an opt-in backend moves per-frame rasterisation into a Web

package/dist/Area-MLM4Xe0E.js

@@ -0,0 +1,157 @@
+//#region src/reader/Plane.ts
+var e = class {
+	constructor(e, t) {
+		this.rooms = [], this.labels = [], this.rooms = e, this.labels = t, this.bounds = this.createBounds();
+	}
+	getRooms() {
+		return this.rooms;
+	}
+	getLabels() {
+		return this.labels;
+	}
+	getBounds() {
+		return this.bounds;
+	}
+	createBounds() {
+		let e = this.rooms.reduce((e, t) => ({
+			minX: Math.min(e.minX, t.x),
+			maxX: Math.max(e.maxX, t.x),
+			minY: Math.min(e.minY, t.y),
+			maxY: Math.max(e.maxY, t.y)
+		}), {
+			minX: Infinity,
+			maxX: -Infinity,
+			minY: Infinity,
+			maxY: -Infinity
+		});
+		for (let t of this.labels) {
+			let n = t.X, r = -t.Y;
+			e.minX = Math.min(e.minX, n), e.maxX = Math.max(e.maxX, n + t.Width), e.minY = Math.min(e.minY, r), e.maxY = Math.max(e.maxY, r + t.Height);
+		}
+		return e;
+	}
+}, t = {
+	north: "south",
+	south: "north",
+	east: "west",
+	west: "east",
+	northeast: "southwest",
+	southwest: "northeast",
+	northwest: "southeast",
+	southeast: "northwest",
+	up: "down",
+	down: "up",
+	in: "out",
+	out: "in"
+};
+function n(e) {
+	let n = /* @__PURE__ */ new Map();
+	e.forEach((e) => {
+		Object.entries(e.exits).forEach(([t, r]) => {
+			if (e.id === r) return;
+			let i = `${Math.min(e.id, r)}-${Math.max(e.id, r)}`;
+			n.has(i) || n.set(i, []), n.get(i).push({
+				origin: e.id,
+				target: r,
+				z: e.z,
+				dir: t
+			});
+		});
+	});
+	let r = /* @__PURE__ */ new Map();
+	for (let [e, i] of n) {
+		let [n, a] = e.split("-"), o = parseInt(n), s = parseInt(a), c = i.filter((e) => e.origin === o), l = i.filter((e) => e.origin === s), u = /* @__PURE__ */ new Set();
+		for (let n of c) {
+			let i = -1;
+			for (let e = 0; e < l.length; e++) if (!u.has(e) && l[e].dir === t[n.dir]) {
+				i = e;
+				break;
+			}
+			if (i !== -1) {
+				u.add(i);
+				let t = l[i];
+				r.set(`${e}-${n.dir}`, {
+					a: o,
+					b: s,
+					aDir: n.dir,
+					bDir: t.dir,
+					zIndex: [n.z, t.z]
+				});
+			} else r.set(`${e}-a:${n.dir}`, {
+				a: o,
+				b: s,
+				aDir: n.dir,
+				zIndex: [n.z]
+			});
+		}
+		for (let t = 0; t < l.length; t++) if (!u.has(t)) {
+			let n = l[t];
+			r.set(`${e}-b:${n.dir}`, {
+				a: o,
+				b: s,
+				bDir: n.dir,
+				zIndex: [n.z]
+			});
+		}
+	}
+	return r;
+}
+var r = class {
+	constructor(e) {
+		this.planes = {}, this.exits = /* @__PURE__ */ new Map(), this.version = 0, this.area = e, this.planes = this.createPlanes(), this.createExits();
+	}
+	getAreaName() {
+		return this.area.areaName;
+	}
+	getAreaId() {
+		return parseInt(this.area.areaId);
+	}
+	getVersion() {
+		return this.version;
+	}
+	markDirty() {
+		this.version++;
+	}
+	getPlane(e) {
+		return this.planes[e];
+	}
+	getPlanes() {
+		return Object.values(this.planes);
+	}
+	getZLevels() {
+		return Object.keys(this.planes).map(Number).sort((e, t) => e - t);
+	}
+	getRooms() {
+		return this.area.rooms;
+	}
+	getFullBounds() {
+		return this.getPlanes().reduce((e, t) => {
+			let n = t.getBounds();
+			return {
+				minX: Math.min(e.minX, n.minX),
+				maxX: Math.max(e.maxX, n.maxX),
+				minY: Math.min(e.minY, n.minY),
+				maxY: Math.max(e.maxY, n.maxY)
+			};
+		}, {
+			minX: Infinity,
+			maxX: -Infinity,
+			minY: Infinity,
+			maxY: -Infinity
+		});
+	}
+	getLinkExits(e) {
+		return Array.from(this.exits.values()).filter((t) => t.zIndex.includes(e));
+	}
+	createPlanes() {
+		let t = this.area.rooms.reduce((e, t) => (e[t.z] || (e[t.z] = []), e[t.z].push(t), e), {});
+		return Object.entries(t).reduce((t, [n, r]) => (t[+n] = new e(r, this.area.labels.filter((e) => e.Z === +n)), t), {});
+	}
+	createExits() {
+		this.exits = n(this.area.rooms);
+	}
+};
+//#endregion
+export { n, e as r, r as t };
+
+//# sourceMappingURL=Area-MLM4Xe0E.js.map

package/dist/Area-MLM4Xe0E.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Area-MLM4Xe0E.js","names":[],"sources":["../src/reader/Plane.ts","../src/reader/Area.ts"],"sourcesContent":["/**\n * Public, renderer-facing surface of a z-level slice of an area.\n *\n * The renderer (and other library consumers) only depend on this interface;\n * the concrete {@link Plane} class is one implementation of it. Downstream\n * apps that want to drive the renderer from their own data model can hand it\n * any `IPlane`-shaped object (typically returned from an {@link IArea}).\n */\nexport interface IPlane {\n    getRooms(): MapData.Room[];\n    getLabels(): MapData.Label[];\n    getBounds(): { minX: number; maxX: number; minY: number; maxY: number };\n}\n\nexport default class Plane implements IPlane {\n\n    private readonly bounds: { minX: number, maxX: number, minY: number, maxY: number }\n    private readonly rooms: MapData.Room[] = [];\n    private readonly labels: MapData.Label[] = [];\n\n    constructor(rooms: MapData.Room[], labels: MapData.Label[]) {\n        this.rooms = rooms;\n        this.labels = labels;\n        this.bounds = this.createBounds();\n    }\n\n    getRooms() {\n        return this.rooms;\n    }\n\n    getLabels() {\n        return this.labels;\n    }\n\n    getBounds() {\n        return this.bounds;\n    }\n\n    private createBounds() {\n        const b = this.rooms.reduce(\n            (acc, r) => ({\n                minX: Math.min(acc.minX, r.x),\n                maxX: Math.max(acc.maxX, r.x),\n                minY: Math.min(acc.minY, r.y),\n                maxY: Math.max(acc.maxY, r.y),\n            }),\n            {\n                minX: Number.POSITIVE_INFINITY,\n                maxX: Number.NEGATIVE_INFINITY,\n                minY: Number.POSITIVE_INFINITY,\n                maxY: Number.NEGATIVE_INFINITY,\n            }\n        );\n        for (const label of this.labels) {\n            const lx = label.X;\n            const ly = -label.Y;\n            b.minX = Math.min(b.minX, lx);\n            b.maxX = Math.max(b.maxX, lx + label.Width);\n            b.minY = Math.min(b.minY, ly);\n            b.maxY = Math.max(b.maxY, ly + label.Height);\n        }\n        return b;\n    }\n\n}\n","import Plane, {IPlane} from \"./Plane\";\n\nimport IExit from \"./Exit\";\n\nconst oppositeDir: Partial<Record<MapData.direction, MapData.direction>> = {\n    \"north\": \"south\", \"south\": \"north\",\n    \"east\": \"west\", \"west\": \"east\",\n    \"northeast\": \"southwest\", \"southwest\": \"northeast\",\n    \"northwest\": \"southeast\", \"southeast\": \"northwest\",\n    \"up\": \"down\", \"down\": \"up\",\n    \"in\": \"out\", \"out\": \"in\",\n};\n\n/**\n * Pair each room's half-exits into bidirectional {@link IExit}s (or one-way\n * fallbacks when a room's neighbour doesn't exit back). Exposed standalone so\n * callers with an already-filtered room list (e.g. a viewport-narrowed set)\n * can pair exits directly, without constructing a full {@link Area}.\n */\nexport function pairLinkExits(rooms: MapData.Room[]): Map<string, IExit> {\n    type HalfExit = { origin: number, target: number, z: number, dir: MapData.direction };\n    const halfExitsByPair = new Map<string, HalfExit[]>();\n\n    rooms.forEach(room => {\n        Object.entries(room.exits).forEach(([direction, targetRoomId]) => {\n            if (room.id === targetRoomId) return;\n            const a = Math.min(room.id, targetRoomId);\n            const b = Math.max(room.id, targetRoomId);\n            const key = `${a}-${b}`;\n            if (!halfExitsByPair.has(key)) halfExitsByPair.set(key, []);\n            halfExitsByPair.get(key)!.push({\n                origin: room.id, target: targetRoomId, z: room.z, dir: direction as MapData.direction\n            });\n        });\n    });\n\n    const exits = new Map<string, IExit>();\n    for (const [pairKey, halves] of halfExitsByPair) {\n        const [aStr, bStr] = pairKey.split('-');\n        const a = parseInt(aStr), b = parseInt(bStr);\n\n        const aSide = halves.filter(h => h.origin === a);\n        const bSide = halves.filter(h => h.origin === b);\n\n        const usedB = new Set<number>();\n\n        for (const aHalf of aSide) {\n            let bestIdx = -1;\n            for (let i = 0; i < bSide.length; i++) {\n                if (usedB.has(i)) continue;\n                if (bSide[i].dir === oppositeDir[aHalf.dir]) {\n                    bestIdx = i;\n                    break;\n                }\n            }\n\n            if (bestIdx !== -1) {\n                usedB.add(bestIdx);\n                const bHalf = bSide[bestIdx];\n                exits.set(`${pairKey}-${aHalf.dir}`, {\n                    a, b, aDir: aHalf.dir, bDir: bHalf.dir, zIndex: [aHalf.z, bHalf.z]\n                });\n            } else {\n                exits.set(`${pairKey}-a:${aHalf.dir}`, {\n                    a, b, aDir: aHalf.dir, zIndex: [aHalf.z]\n                });\n            }\n        }\n\n        for (let i = 0; i < bSide.length; i++) {\n            if (!usedB.has(i)) {\n                const bHalf = bSide[i];\n                exits.set(`${pairKey}-b:${bHalf.dir}`, {\n                    a, b, bDir: bHalf.dir, zIndex: [bHalf.z]\n                });\n            }\n        }\n    }\n    return exits;\n}\n\n/**\n * Public, renderer-facing surface of an area. The renderer never inspects\n * private state of {@link Area}; it talks to this interface only. Custom data\n * models (e.g. an app that owns its own room store) can satisfy `IArea` and\n * hand the result to {@link MapRenderer} without subclassing.\n *\n * Mutability lives on the concrete implementation: {@link Area.markDirty} is\n * `protected`, kept off the public interface. Consumers signal \"redraw me\" by\n * bumping {@link getVersion}; the renderer reads the version to decide\n * whether to rebuild.\n */\nexport interface IArea {\n    getAreaName(): string;\n    getAreaId(): number;\n    /**\n     * Monotonically increasing version. The renderer compares the value it\n     * cached on the last build against the current value to decide whether\n     * the area needs a rebuild.\n     */\n    getVersion(): number;\n    getPlane(zIndex: number): IPlane;\n    getPlanes(): IPlane[];\n    getZLevels(): number[];\n    getRooms(): MapData.Room[];\n    getFullBounds(): { minX: number; maxX: number; minY: number; maxY: number };\n    /**\n     * Inter-room exits drawn on the given z-level. Each exit is bidirectional\n     * with optional one-way fallback; see {@link IExit}.\n     */\n    getLinkExits(zIndex: number): IExit[];\n}\n\nexport default class Area implements IArea {\n\n    private readonly planes: Record<number, Plane> = {};\n    private readonly area: MapData.Area;\n    private exits: Map<string, IExit> = new Map();\n    private version = 0;\n\n    constructor(area: MapData.Area) {\n        this.area = area;\n        this.planes = this.createPlanes();\n        this.createExits();\n    }\n\n    getAreaName() {\n        return this.area.areaName\n    }\n\n    getAreaId() {\n        return parseInt(this.area.areaId)\n    }\n\n    getVersion() {\n        return this.version;\n    }\n\n    protected markDirty() {\n        this.version++;\n    }\n\n    getPlane(zIndex: number) {\n        return this.planes[zIndex];\n    }\n\n    getPlanes() {\n        return Object.values(this.planes);\n    }\n\n    getZLevels(): number[] {\n        return Object.keys(this.planes).map(Number).sort((a, b) => a - b);\n    }\n\n    getRooms() {\n        return this.area.rooms\n    }\n\n    getFullBounds(): { minX: number; maxX: number; minY: number; maxY: number } {\n        return this.getPlanes().reduce(\n            (acc, plane) => {\n                const b = plane.getBounds();\n                return {\n                    minX: Math.min(acc.minX, b.minX),\n                    maxX: Math.max(acc.maxX, b.maxX),\n                    minY: Math.min(acc.minY, b.minY),\n                    maxY: Math.max(acc.maxY, b.maxY),\n                };\n            },\n            { minX: Infinity, maxX: -Infinity, minY: Infinity, maxY: -Infinity }\n        );\n    }\n\n    getLinkExits(zIndex: number) {\n        return Array.from(this.exits.values()).filter(e => e.zIndex.includes(zIndex));\n    }\n\n    private createPlanes() {\n        const grouped = this.area.rooms.reduce<Record<number, MapData.Room[]>>((acc, room) => {\n            if (!acc[room.z]) {\n                acc[room.z] = [];\n            }\n            // @ts-ignore\n            acc[room.z].push(room);\n            return acc;\n        }, {});\n        return Object.entries(grouped).reduce(\n            (acc, [z, rooms]) => {\n                acc[+z] = new Plane(rooms, this.area.labels.filter(label => label.Z === +z));\n                return acc;\n            },\n            {} as Record<number, Plane>\n        );\n    }\n\n    private createExits() {\n        this.exits = pairLinkExits(this.area.rooms);\n    }\n\n}"],"mappings":"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"}

package/dist/MapReader-BeVNpm6y.js

@@ -0,0 +1,77 @@
+import { t as e } from "./Area-MLM4Xe0E.js";
+//#region src/reader/MapReader.ts
+var t = {
+	rgb: [
+		114,
+		1,
+		0
+	],
+	rgbValue: "rgb(114, 1, 0)",
+	symbolColor: [
+		225,
+		225,
+		225
+	],
+	symbolColorValue: "rgb(225,225,225)"
+};
+function n(e) {
+	let t = e[0] / 255, n = e[1] / 255, r = e[2] / 255;
+	return (Math.max(t, n, r) + Math.min(t, n, r)) / 2;
+}
+var r = class {
+	constructor(t, r) {
+		this.rooms = {}, this.areas = {}, this.colors = {}, t.forEach((t) => {
+			let n = {
+				...t,
+				rooms: t.rooms.map((e) => ({
+					...e,
+					y: -e.y
+				}))
+			};
+			n.rooms.forEach((e) => {
+				this.rooms[e.id] = e;
+			});
+			let r = parseInt(t.areaId);
+			this.areas[r] = new e(n);
+		}), this.colors = r.reduce((e, t) => ({
+			...e,
+			[t.envId]: {
+				rgb: t.colors,
+				rgbValue: `rgb(${t.colors.join(",")})`,
+				symbolColor: n(t.colors) > .41 ? [
+					25,
+					25,
+					25
+				] : [
+					225,
+					255,
+					255
+				],
+				symbolColorValue: n(t.colors) > .41 ? "rgb(25,25,25)" : "rgb(225,255,255)"
+			}
+		}), {});
+	}
+	getArea(e) {
+		return this.areas[e];
+	}
+	getAreas() {
+		return Object.values(this.areas);
+	}
+	getRooms() {
+		return Object.values(this.rooms);
+	}
+	getRoom(e) {
+		return this.rooms[e];
+	}
+	getColorValue(e) {
+		return this.colors[e]?.rgbValue ?? t.rgbValue;
+	}
+	getSymbolColor(e, n) {
+		let r = this.colors[e]?.symbolColor ?? t.symbolColor, i = Math.min(Math.max(n ?? 1, 0), 1), a = r.join(",");
+		return i == 1 ? `rgba(${a})` : `rgba(${a}, ${i})`;
+	}
+};
+//#endregion
+export { r as t };
+
+//# sourceMappingURL=MapReader-BeVNpm6y.js.map

package/dist/MapReader-BeVNpm6y.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MapReader-BeVNpm6y.js","names":[],"sources":["../src/reader/MapReader.ts"],"sourcesContent":["import Area, {IArea} from \"./Area\";\n\n/**\n * Public, renderer-facing surface for map data. Everything the renderer\n * (and other library consumers) call on `MapReader` is on this interface —\n * private state and internal helpers are not.\n *\n * Downstream apps with their own room/area store can implement `IMapReader`\n * directly (no need to subclass {@link MapReader}) and hand the result to\n * {@link MapRenderer}. Visibility filtering (exploration, scope overlays,\n * etc.) lives on the renderer's lens — it is intentionally not on this\n * interface.\n */\nexport interface IMapReader {\n    getArea(areaId: number): IArea;\n    getAreas(): IArea[];\n    getRooms(): MapData.Room[];\n    getRoom(roomId: number): MapData.Room;\n    /** Returns the env's `rgb(r,g,b)` string, or a default colour if the env id is unknown. */\n    getColorValue(envId: number): string;\n    /** Returns a contrasting symbol colour for the env, optionally with the given alpha. */\n    getSymbolColor(envId: number, opacity?: number): string;\n}\n\ninterface Color {\n    rgb: number[];\n    rgbValue: string;\n    symbolColor: number[];\n    symbolColorValue: string,\n}\n\nconst defaultColor: Color = {\n    rgb: [114, 1, 0],\n    rgbValue: 'rgb(114, 1, 0)',\n    symbolColor: [225, 225, 225],\n    symbolColorValue: 'rgb(225,225,225)'\n}\n\nfunction calculateLuminance(rgb: number[]) {\n    const rn = rgb[0] / 255;\n    const gn = rgb[1] / 255;\n    const bn = rgb[2] / 255;\n\n    const max = Math.max(rn, gn, bn);\n    const min = Math.min(rn, gn, bn);\n\n    return (max + min) / 2;\n}\n\nexport default class MapReader implements IMapReader {\n\n    private rooms: Record<number, MapData.Room> = {};\n    private areas: Record<number, Area> = {};\n    private colors: Record<number, Color> = {};\n\n    constructor(map: MapData.Map, envs: MapData.Env[]) {\n        map.forEach(area => {\n            const clonedArea: MapData.Area = {\n                ...area,\n                rooms: area.rooms.map(room => ({ ...room, y: -room.y })),\n            };\n            clonedArea.rooms.forEach(room => {\n                this.rooms[room.id] = room;\n            });\n            const areaId = parseInt(area.areaId);\n            this.areas[areaId] = new Area(clonedArea);\n        })\n        this.colors = envs.reduce((acc, c) => ({\n            ...acc,\n            [c.envId]: {\n                rgb: c.colors,\n                rgbValue: `rgb(${c.colors.join(',')})`,\n                symbolColor: calculateLuminance(c.colors) > 0.41 ? [25, 25, 25] : [225, 255, 255],\n                symbolColorValue: calculateLuminance(c.colors) > 0.41 ? 'rgb(25,25,25)' : 'rgb(225,255,255)'\n            }\n        }), {});\n    }\n\n    getArea(areaId: number) {\n        return this.areas[areaId];\n    }\n\n    getAreas() {\n        return Object.values(this.areas);\n    }\n\n    getRooms() {\n        return Object.values(this.rooms);\n    }\n\n    getRoom(roomId: number) {\n        return this.rooms[roomId];\n    }\n\n    getColorValue(envId: number): string {\n        return this.colors[envId]?.rgbValue ?? defaultColor.rgbValue;\n    }\n\n    getSymbolColor(envId: number, opacity?: number): string {\n        const color = this.colors[envId]?.symbolColor ?? defaultColor.symbolColor;\n        const normalizedOpacity = Math.min(Math.max(opacity ?? 1, 0), 1);\n        const value = color.join(',');\n        if (normalizedOpacity != 1) {\n            return `rgba(${value}, ${normalizedOpacity})`;\n        }\n        return `rgba(${value})`;\n    }\n\n}\n"],"mappings":";;AA+BA,IAAM,IAAsB;CACxB,KAAK;EAAC;EAAK;EAAG;EAAE;CAChB,UAAU;CACV,aAAa;EAAC;EAAK;EAAK;EAAI;CAC5B,kBAAkB;CACrB;AAED,SAAS,EAAmB,GAAe;CACvC,IAAM,IAAK,EAAI,KAAK,KACd,IAAK,EAAI,KAAK,KACd,IAAK,EAAI,KAAK;AAKpB,SAHY,KAAK,IAAI,GAAI,GAAI,EAAG,GACpB,KAAK,IAAI,GAAI,GAAI,EAAG,IAEX;;AAGzB,IAAqB,IAArB,MAAqD;CAMjD,YAAY,GAAkB,GAAqB;AAY/C,eAhB0C,EAAE,eACV,EAAE,gBACA,EAAE,EAGtC,EAAI,SAAQ,MAAQ;GAChB,IAAM,IAA2B;IAC7B,GAAG;IACH,OAAO,EAAK,MAAM,KAAI,OAAS;KAAE,GAAG;KAAM,GAAG,CAAC,EAAK;KAAG,EAAE;IAC3D;AACD,KAAW,MAAM,SAAQ,MAAQ;AAC7B,SAAK,MAAM,EAAK,MAAM;KACxB;GACF,IAAM,IAAS,SAAS,EAAK,OAAO;AACpC,QAAK,MAAM,KAAU,IAAI,EAAK,EAAW;IAC3C,EACF,KAAK,SAAS,EAAK,QAAQ,GAAK,OAAO;GACnC,GAAG;IACF,EAAE,QAAQ;IACP,KAAK,EAAE;IACP,UAAU,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;IACpC,aAAa,EAAmB,EAAE,OAAO,GAAG,MAAO;KAAC;KAAI;KAAI;KAAG,GAAG;KAAC;KAAK;KAAK;KAAI;IACjF,kBAAkB,EAAmB,EAAE,OAAO,GAAG,MAAO,kBAAkB;IAC7E;GACJ,GAAG,EAAE,CAAC;;CAGX,QAAQ,GAAgB;AACpB,SAAO,KAAK,MAAM;;CAGtB,WAAW;AACP,SAAO,OAAO,OAAO,KAAK,MAAM;;CAGpC,WAAW;AACP,SAAO,OAAO,OAAO,KAAK,MAAM;;CAGpC,QAAQ,GAAgB;AACpB,SAAO,KAAK,MAAM;;CAGtB,cAAc,GAAuB;AACjC,SAAO,KAAK,OAAO,IAAQ,YAAY,EAAa;;CAGxD,eAAe,GAAe,GAA0B;EACpD,IAAM,IAAQ,KAAK,OAAO,IAAQ,eAAe,EAAa,aACxD,IAAoB,KAAK,IAAI,KAAK,IAAI,KAAW,GAAG,EAAE,EAAE,EAAE,EAC1D,IAAQ,EAAM,KAAK,IAAI;AAI7B,SAHI,KAAqB,IAGlB,QAAQ,EAAM,KAFV,QAAQ,EAAM,IAAI,EAAkB"}

package/dist/SkeletonMapReader-B6PzEWGP.js

@@ -0,0 +1,340 @@
+import { n as e } from "./Area-MLM4Xe0E.js";
+//#region src/bigmap/Skeleton.ts
+var t = [
+	"north",
+	"northeast",
+	"east",
+	"southeast",
+	"south",
+	"southwest",
+	"west",
+	"northwest",
+	"up",
+	"down",
+	"in",
+	"out"
+];
+//#endregion
+//#region src/bigmap/PlaneIndex.ts
+function n(e, t, n) {
+	let r = [], i = Infinity, a = -Infinity, o = Infinity, s = -Infinity;
+	for (let c = 0; c < e.count; c++) {
+		if (e.area[c] !== t || e.z[c] !== n) continue;
+		r.push(c);
+		let l = e.x[c], u = e.y[c];
+		l < i && (i = l), l > a && (a = l), u < o && (o = u), u > s && (s = u);
+	}
+	let c = Int32Array.from(r);
+	if (c.length === 0) return {
+		indices: c,
+		minX: 0,
+		minY: 0,
+		cs: 1,
+		cols: 1,
+		rows: 1,
+		cellStart: new Int32Array(2),
+		order: c,
+		bounds: {
+			minX: 0,
+			maxX: 0,
+			minY: 0,
+			maxY: 0
+		}
+	};
+	let l = Math.max(a - i, s - o, 1), u = Math.max(1, Math.ceil(l / 128)), d = Math.floor((a - i) / u) + 1, f = Math.floor((s - o) / u) + 1, p = (t) => Math.floor((e.y[t] - o) / u) * d + Math.floor((e.x[t] - i) / u), m = new Int32Array(d * f);
+	for (let e = 0; e < c.length; e++) m[p(c[e])]++;
+	let h = new Int32Array(d * f + 1);
+	for (let e = 0; e < d * f; e++) h[e + 1] = h[e] + m[e];
+	let g = h.slice(0, d * f), _ = new Int32Array(c.length);
+	for (let e = 0; e < c.length; e++) {
+		let t = c[e], n = p(t);
+		_[g[n]++] = t;
+	}
+	return {
+		indices: c,
+		minX: i,
+		minY: o,
+		cs: u,
+		cols: d,
+		rows: f,
+		cellStart: h,
+		order: _,
+		bounds: {
+			minX: i,
+			maxX: a,
+			minY: o,
+			maxY: s
+		}
+	};
+}
+function r(e, t) {
+	let n = Math.max(0, Math.floor((t.minX - e.minX) / e.cs)), r = Math.min(e.cols - 1, Math.floor((t.maxX - e.minX) / e.cs)), i = Math.max(0, Math.floor((t.minY - e.minY) / e.cs)), a = Math.min(e.rows - 1, Math.floor((t.maxY - e.minY) / e.cs));
+	return r < n || a < i ? null : {
+		cx0: n,
+		cx1: r,
+		cy0: i,
+		cy1: a
+	};
+}
+function i(e, t, n, i) {
+	let a = r(t, n);
+	if (!a) return;
+	let { cols: o, cellStart: s, order: c } = t;
+	for (let t = a.cy0; t <= a.cy1; t++) {
+		let r = t * o;
+		for (let t = a.cx0; t <= a.cx1; t++) {
+			let a = r + t;
+			for (let t = s[a]; t < s[a + 1]; t++) {
+				let r = c[t];
+				e.x[r] >= n.minX && e.x[r] <= n.maxX && e.y[r] >= n.minY && e.y[r] <= n.maxY && i(r);
+			}
+		}
+	}
+}
+function a(e, t) {
+	let n = r(e, t);
+	if (!n) return 0;
+	let i = 0;
+	for (let t = n.cy0; t <= n.cy1; t++) {
+		let r = t * e.cols;
+		for (let t = n.cx0; t <= n.cx1; t++) {
+			let n = r + t;
+			i += e.cellStart[n + 1] - e.cellStart[n];
+		}
+	}
+	return i;
+}
+//#endregion
+//#region src/bigmap/SkeletonMapReader.ts
+var o = {
+	minX: -Infinity,
+	maxX: Infinity,
+	minY: -Infinity,
+	maxY: Infinity
+};
+function s(e, t, n) {
+	let r = (1 - Math.abs(2 * n - 1)) * t, i = r * (1 - Math.abs(e / 60 % 2 - 1)), a = n - r / 2, o = 0, s = 0, c = 0;
+	return e < 60 ? [o, s, c] = [
+		r,
+		i,
+		0
+	] : e < 120 ? [o, s, c] = [
+		i,
+		r,
+		0
+	] : e < 180 ? [o, s, c] = [
+		0,
+		r,
+		i
+	] : e < 240 ? [o, s, c] = [
+		0,
+		i,
+		r
+	] : e < 300 ? [o, s, c] = [
+		i,
+		0,
+		r
+	] : [o, s, c] = [
+		r,
+		0,
+		i
+	], [
+		Math.round((o + a) * 255),
+		Math.round((s + a) * 255),
+		Math.round((c + a) * 255)
+	];
+}
+var c = class {
+	constructor(e) {
+		this.viewportAware = !0, this.viewport = o, this.version = 0, this.planeCache = /* @__PURE__ */ new Map(), this.areaCache = /* @__PURE__ */ new Map(), this.rgbCache = /* @__PURE__ */ new Map(), this.visibleCache = /* @__PURE__ */ new Map(), this.detail = /* @__PURE__ */ new Map(), this.userDataMap = /* @__PURE__ */ new Map(), this.sk = e;
+		let t = e.y;
+		for (let n = 0; n < e.count; n++) t[n] = -t[n];
+		for (let t of e.userData ?? []) this.userDataMap.set(t.id, t.data);
+		for (let t of e.detailRooms ?? []) t.y = -t.y, this.isGrid(t.area) && (t.exits = {}, t.stubs = []), this.detail.set(t.id, t);
+	}
+	skeleton() {
+		return this.sk;
+	}
+	setViewport(e) {
+		let t = this.viewport;
+		e.minX === t.minX && e.maxX === t.maxX && e.minY === t.minY && e.maxY === t.maxY || (this.viewport = { ...e }, this.visibleCache.clear(), this.version++);
+	}
+	getViewport() {
+		return this.viewport;
+	}
+	getPlaneRoomCount(e, t) {
+		return this.planeIndex(e, t).indices.length;
+	}
+	estimateVisibleCount(e, t, n) {
+		return a(this.planeIndex(e, t), n);
+	}
+	forEachInBounds(e, t, n, r) {
+		let a = this.sk;
+		i(a, this.planeIndex(e, t), n, (e) => r(a.x[e], a.y[e], a.env[e]));
+	}
+	getArea(e) {
+		let t = this.areaCache.get(e);
+		return t || (t = new l(e, this), this.areaCache.set(e, t)), t;
+	}
+	getAreas() {
+		return [...new Set(Array.from(this.sk.area))].map((e) => this.getArea(e));
+	}
+	getRooms() {
+		return [];
+	}
+	getRoom(e) {
+		let t = this.detail.get(e);
+		if (t) return t;
+		if (!this.idIndex) {
+			this.idIndex = /* @__PURE__ */ new Map();
+			for (let e = 0; e < this.sk.count; e++) this.idIndex.set(this.sk.id[e], e);
+		}
+		let n = this.idIndex.get(e);
+		return n === void 0 ? void 0 : this.makeRoom(n);
+	}
+	getColorValue(e) {
+		let [t, n, r] = this.rgb(e);
+		return `rgb(${t},${n},${r})`;
+	}
+	getSymbolColor(e, t) {
+		let [n, r, i] = this.rgb(e), a = (Math.max(n, r, i) + Math.min(n, r, i)) / 2 / 255 > .41 ? "25,25,25" : "225,255,255", o = Math.min(Math.max(t ?? 1, 0), 1);
+		return o === 1 ? `rgba(${a})` : `rgba(${a}, ${o})`;
+	}
+	getReaderVersion() {
+		return this.version;
+	}
+	labelsFor(e, t) {
+		return (this.sk.labels ?? []).filter((n) => n.areaId === e && n.Z === t);
+	}
+	isGrid(e) {
+		return !!this.sk.areaGridMode[e];
+	}
+	rgb(e) {
+		let t = this.rgbCache.get(e);
+		if (!t) {
+			let n = this.sk.customEnvColors[e];
+			t = n ? [
+				n.r,
+				n.g,
+				n.b
+			] : s((e * 2654435761 >>> 0) % 360, .5, .55), this.rgbCache.set(e, t);
+		}
+		return t;
+	}
+	makeRoom(e) {
+		let n = this.sk, r = this.detail.get(n.id[e]);
+		if (r) return r;
+		let i = {};
+		if (!this.isGrid(n.area[e])) {
+			let r = e * 12;
+			for (let e = 0; e < 12; e++) {
+				let a = n.exits[r + e];
+				a !== -1 && (i[t[e]] = a);
+			}
+		}
+		return {
+			id: n.id[e],
+			area: n.area[e],
+			x: n.x[e],
+			y: n.y[e],
+			z: n.z[e],
+			areaId: String(n.area[e]),
+			weight: 1,
+			roomChar: "",
+			name: n.names?.[e] ?? "",
+			userData: this.userDataMap.get(n.id[e]) ?? {},
+			customLines: {},
+			stubs: [],
+			hash: "",
+			env: n.env[e],
+			exits: i,
+			doors: {},
+			specialExits: {}
+		};
+	}
+	planeIndex(e, t) {
+		let r = `${e}:${t}`, i = this.planeCache.get(r);
+		return i || (i = n(this.sk, e, t), this.planeCache.set(r, i)), i;
+	}
+	visibleRooms(e, t) {
+		let n = `${e}:${t}`, r = this.visibleCache.get(n);
+		if (!r) {
+			let a = [];
+			i(this.sk, this.planeIndex(e, t), this.viewport, (e) => a.push(this.makeRoom(e))), r = a, this.visibleCache.set(n, r);
+		}
+		return r;
+	}
+}, l = class {
+	constructor(e, t) {
+		this.areaId = e, this.reader = t, this.planeCache = /* @__PURE__ */ new Map();
+	}
+	getAreaName() {
+		return this.reader.skeleton().areaNames[this.areaId] ?? `#${this.areaId}`;
+	}
+	getAreaId() {
+		return this.areaId;
+	}
+	getVersion() {
+		return this.reader.getReaderVersion();
+	}
+	getPlane(e) {
+		let t = this.planeCache.get(e);
+		return t || (t = new u(this.areaId, e, this.reader), this.planeCache.set(e, t)), t;
+	}
+	getPlanes() {
+		return this.getZLevels().map((e) => this.getPlane(e));
+	}
+	getZLevels() {
+		let e = this.reader.skeleton(), t = /* @__PURE__ */ new Set();
+		for (let n = 0; n < e.count; n++) e.area[n] === this.areaId && t.add(e.z[n]);
+		return [...t].sort((e, t) => e - t);
+	}
+	getRooms() {
+		return [];
+	}
+	getFullBounds() {
+		let e = this.getZLevels(), t = {
+			minX: Infinity,
+			maxX: -Infinity,
+			minY: Infinity,
+			maxY: -Infinity
+		};
+		for (let n of e) {
+			let e = this.reader.planeIndex(this.areaId, n).bounds;
+			t = {
+				minX: Math.min(t.minX, e.minX),
+				maxX: Math.max(t.maxX, e.maxX),
+				minY: Math.min(t.minY, e.minY),
+				maxY: Math.max(t.maxY, e.maxY)
+			};
+		}
+		return t;
+	}
+	getLinkExits(t) {
+		if (this.reader.isGrid(this.areaId)) return [];
+		let n = this.reader.visibleRooms(this.areaId, t);
+		return n.length === 0 ? [] : Array.from(e(n).values()).filter((e) => e.zIndex.includes(t));
+	}
+}, u = class {
+	constructor(e, t, n) {
+		this.areaId = e, this.z = t, this.reader = n;
+	}
+	getRooms() {
+		return this.reader.visibleRooms(this.areaId, this.z);
+	}
+	getLabels() {
+		return this.reader.labelsFor(this.areaId, this.z);
+	}
+	getBounds() {
+		let e = { ...this.reader.planeIndex(this.areaId, this.z).bounds };
+		for (let t of this.reader.labelsFor(this.areaId, this.z)) {
+			let n = t.X, r = -t.Y;
+			e.minX = Math.min(e.minX, n), e.maxX = Math.max(e.maxX, n + t.Width), e.minY = Math.min(e.minY, r), e.maxY = Math.max(e.maxY, r + t.Height);
+		}
+		return e;
+	}
+};
+//#endregion
+export { t as a, i, n, a as r, c as t };
+
+//# sourceMappingURL=SkeletonMapReader-B6PzEWGP.js.map