@codexo/exojs-tilemap 0.15.3 → 0.16.0

package/README.md

@@ -11,9 +11,10 @@ parse their format and hand this runtime fully-resolved tiles.
 npm install @codexo/exojs @codexo/exojs-tilemap
 ```
 
-`@codexo/exojs` is a peer dependency. Most users load Tiled maps and get this package
-transitively through `@codexo/exojs-tiled` — install it directly only for procedural or
-custom-format maps.
+`@codexo/exojs` is a peer dependency, so install it explicitly. This package is itself a peer of
+the format adapters (`@codexo/exojs-tiled`, `@codexo/exojs-ldtk`) rather than something they pull
+in transitively — install it whether you use an adapter or build procedural / custom-format maps
+directly.
 
 ## What this package provides
 
@@ -26,6 +27,23 @@ custom-format maps.
 - `ResolvedTile` / `TileTransform` — value-typed tile references with `flipX` / `flipY` /
   `diagonal` orientation.
 
+**Worlds and level lifetime** — format-neutral, driven by whichever adapter loaded the data:
+
+- `MapWorld` / `MapLevel` — where levels sit: stable id, world bounds, neighbour graph,
+  externality. Metadata only; no tiles, no textures.
+- `MapWorldRuntime` — explicit `loadLevel` / `unloadLevel`, one child `LoaderScope` per level,
+  at most one live level per id. No camera policy: the game decides what to load.
+- `MapLevelRuntime` — one loaded level's map, scope and spawn session, with a single
+  `destroy()` that tears all three down in a safe order.
+
+**Map object spawning**:
+
+- `MapObjectSpawner` — a local (never global) dispatch table from object class to a factory.
+  Deterministic order, atomic rollback, `AbortSignal` cancellation.
+- `MapObjectDescriptor` — the format-neutral view of one authored object handed to a factory.
+- `MapSpawnSession` — owns what one spawn produced; constant-time lookup by stable source id,
+  reverse-order teardown.
+
 **Scene / rendering (`@advanced`)**:
 
 - `TileMapNode` — convenience root that renders a whole `TileMap`.
@@ -39,20 +57,13 @@ custom-format maps.
 ## Usage — procedural map
 
 ```ts
-import { Application, Texture, TextureRegion } from '@codexo/exojs';
-import {
-  TileLayer,
-  TileMap,
-  TileMapNode,
-  TileSet,
-  tilemapExtension,
-  TILE_TRANSFORM_IDENTITY,
-} from '@codexo/exojs-tilemap';
+import { Application, TextureRegion } from '@codexo/exojs';
+import { TileLayer, TileMap, TileMapNode, TileSet, tilemapExtension, TILE_TRANSFORM_IDENTITY } from '@codexo/exojs-tilemap';
 
 const app = new Application({ extensions: [tilemapExtension] /* canvas, … */ });
 
 // Tileset over a Loader-owned atlas texture (the runtime never destroys it).
-const atlas = await app.loader.load(Texture, 'tiles.png');
+const atlas = await app.loader.load('tiles.png');
 const terrain = new TileSet({
   name: 'terrain',
   texture: new TextureRegion(atlas, { x: 0, y: 0, width: atlas.width, height: atlas.height }),
@@ -83,13 +94,13 @@ const map = new TileMap({
 });
 
 // Render the whole map.
-app.scene.root.addChild(new TileMapNode(map));
+app.scenes.root.addChild(new TileMapNode(map));
 ```
 
 ### Interleaving actors between layers — `TileMapView`
 
 `TileMapNode` owns **only** the map's layer nodes and renders them back-to-front — use it when
-nothing renders between layers. To draw application actors *between* tile layers, create a
+nothing renders between layers. To draw application actors _between_ tile layers, create a
 `TileMapView`: it generates one `TileLayerNode` per map layer (stable identity, map document
 order) and groups them into named `TileMapBand`s that you parent yourself, as siblings of your
 own actor containers:
@@ -104,7 +115,7 @@ const view = map.createView({
 
 worldRoot.addChild(
   view.band('ground'),
-  actors,            // app-owned actor container — drawn between ground and roof
+  actors, // app-owned actor container — drawn between ground and roof
   view.band('roof'),
 );
 ```
@@ -130,18 +141,11 @@ Actors are application-owned siblings. `TileMapView` never adopts or destroys ac
 - After layers are structurally added to or removed from the map, call `view.refreshLayers()`:
   unchanged layer nodes keep their identity and bands keep their placement in your scene graph.
 
-## `/register` convenience entry
-
-```ts
-// Side effect: registers tilemapExtension in the global ExtensionRegistry.
-import '@codexo/exojs-tilemap/register';
-```
-
 ## Renderer model
 
 - **Chunk-first.** A `TileLayerNode` is a container of per-chunk `TileChunkNode` drawables (one
   per non-empty loaded chunk). The renderer batches tiles by `(shader, tileset texture)` and
-  issues one instanced draw per batch — draw calls scale with *visible chunks × layers*, not
+  issues one instanced draw per batch — draw calls scale with _visible chunks × layers_, not
   total tile count.
 - **Revision-cached geometry.** Each chunk's quad geometry is built once and cached against the
   source chunk's `revision`. Unchanged chunks never rebuild; a camera pan rebuilds nothing —
@@ -161,6 +165,9 @@ import '@codexo/exojs-tilemap/register';
 ## Ownership & lifecycle
 
 - Tileset **textures are Loader-owned**. The runtime and renderer never destroy them.
+- A `MapWorldRuntime` owns the scope it creates under the one you give it, plus one child scope
+  per loaded level - never the scope you passed in. A `MapLevelRuntime` owns the `TileMap` its
+  provider returned, its spawn session, and its scope; `destroy()` releases them in that order.
 - `TileMapNode` / `TileMapView` / `TileMapBand` / `TileLayerNode` reference — but never own —
   the `TileMap`. Destroying a map node, view, or band frees only the tile nodes it generated
   (detaching them from their application parents) and their cached geometry; application actors,
@@ -174,8 +181,8 @@ import '@codexo/exojs-tilemap/register';
 ## Core compatibility
 
 | `@codexo/exojs-tilemap` | `@codexo/exojs` |
-|---|---|
-| 0.x | matching `0.x` |
+| ----------------------- | --------------- |
+| 0.x                     | matching `0.x`  |
 
 ## Links
 

package/dist/esm/ChunkSource.d.ts

@@ -0,0 +1,33 @@
+/**
+ * A chunk payload ready to install into a {@link import('./TileLayer').TileLayer}
+ * via {@link import('./TileLayer').TileLayer._adoptChunk} - the same shape
+ * {@link import('./TileChunk').TileChunk}'s constructor accepts as its
+ * `source` parameter, named and exported so provider authors have a type to
+ * import instead of matching an inline shape.
+ * @advanced
+ */
+export interface ChunkPayload {
+    readonly width: number;
+    readonly height: number;
+    readonly tiles: Uint32Array;
+}
+/**
+ * Supplies chunk data for one {@link import('./TileLayer').TileLayer} on
+ * demand, keyed by signed chunk coordinates - the abstraction a
+ * {@link import('./ChunkStreamer').ChunkStreamer} drives to implement chunk
+ * streaming, and the seam a format adapter or a procedural generator
+ * implements.
+ *
+ * `getChunk` may return synchronously (e.g. slicing already-parsed source
+ * data) or a `Promise` (e.g. an expensive procedural-generation algorithm,
+ * plausibly off the main thread) - {@link import('./ChunkStreamer').ChunkStreamer}
+ * installs a synchronous result in the same tick it was requested, with
+ * zero pop-in. Returning `null` (synchronously or via a resolved `Promise`)
+ * means "no data for this coordinate" - e.g. outside a finite provider's
+ * authored extent, even though the layer itself may be unbounded.
+ * @advanced
+ */
+export interface ChunkSource {
+    getChunk(cx: number, cy: number): ChunkPayload | null | Promise<ChunkPayload | null>;
+}
+//# sourceMappingURL=ChunkSource.d.ts.map

package/dist/esm/ChunkSource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChunkSource.d.ts","sourceRoot":"","sources":["../../src/ChunkSource.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI,GAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAAC;CACtF"}

package/dist/esm/ChunkStreamer.d.ts

@@ -0,0 +1,98 @@
+import { type View } from '@codexo/exojs';
+import type { ChunkSource } from './ChunkSource';
+import type { TileLayer } from './TileLayer';
+/**
+ * Options for a {@link ChunkStreamer}. All optional.
+ * @advanced
+ */
+export interface ChunkStreamerOptions {
+    /**
+     * Chunks within this many chunk-units (Chebyshev distance to the visible
+     * chunk range) of the view are loaded. Default `1`.
+     */
+    readonly loadRadius?: number;
+    /**
+     * Own-resident chunks beyond this many chunk-units of the view are
+     * evicted. Must be `>= loadRadius` - the gap between the two is
+     * deliberate hysteresis that prevents load/unload thrashing when the
+     * view sits near a chunk boundary. Default `2`.
+     */
+    readonly unloadRadius?: number;
+    /**
+     * Maximum number of new chunk loads issued per {@link ChunkStreamer.update}
+     * call, after the very first call (which loads the entire initial wanted
+     * set unbudgeted, so the starting view never pops in). Default `8`.
+     */
+    readonly maxChunkLoadsPerFrame?: number;
+}
+/**
+ * Drives {@link TileLayer._adoptChunk}/{@link TileLayer._evictChunk} calls
+ * from a {@link View}'s position: chunks near the view are requested from a
+ * {@link ChunkSource} and installed; chunks that scroll far enough away are
+ * evicted. Works on both unbounded and bounded layers (a bounded-but-large
+ * layer still benefits from not keeping every chunk resident at once) - for
+ * a bounded layer, the wanted range is clamped to {@link TileLayer.chunkRange}.
+ *
+ * Touches only the {@link TileLayer} data layer -
+ * {@link import('./TileLayerNode').TileLayerNode} reacts to
+ * `_adoptChunk`/`_evictChunk` on its own via a structural listener, so this
+ * class has no rendering dependency and no reference to any scene node.
+ *
+ * Tracks its own resident set (chunks *this instance* has loaded), never
+ * touching chunks that predate its attachment or were installed by another
+ * source.
+ *
+ * Tick it from your update loop, like {@link import('./TileAnimator').TileAnimator}:
+ *
+ * ```ts
+ * const streamer = new ChunkStreamer(layer, mySource, view);
+ * scene.systems.add({ update: () => streamer.update() });
+ * ```
+ *
+ * @advanced
+ */
+export declare class ChunkStreamer {
+    private readonly _layer;
+    private readonly _source;
+    private readonly _view;
+    private readonly _loadRadius;
+    private readonly _unloadRadius;
+    private readonly _maxChunkLoadsPerFrame;
+    private readonly _resident;
+    private readonly _inFlight;
+    private _requestCounter;
+    private _primed;
+    private _destroyed;
+    constructor(layer: TileLayer, source: ChunkSource, view: View, options?: ChunkStreamerOptions);
+    /** Number of chunks this instance currently has resident in the layer. */
+    get residentCount(): number;
+    /**
+     * Recompute the wanted chunk set from the view's current position; evict
+     * own-resident chunks that fell outside `unloadRadius`, then request
+     * chunks newly inside `loadRadius`. The very first call loads the entire
+     * initial wanted set unbudgeted; every later call is capped at
+     * {@link ChunkStreamerOptions.maxChunkLoadsPerFrame}. No-op once
+     * {@link destroy}ed.
+     */
+    update(): void;
+    /**
+     * Evict every chunk this instance has loaded and stop responding to
+     * {@link update}. Does not affect chunks predating attachment or
+     * installed by another source. Idempotent.
+     */
+    destroy(): void;
+    private _computeCoreRange;
+    private _rangeDistance;
+    private _unload;
+    private _request;
+    /**
+     * Ignore-on-resolve: only the `_destroyed` and in-flight-token checks
+     * guard installation - a chunk that scrolled out of the wanted set while
+     * its request was in flight is still installed if it resolves (installing
+     * it is cheap and self-correcting: the next {@link update} call's unload
+     * pass evicts it again if it's genuinely no longer wanted). There is no
+     * edit-persistence to protect, so discarding is never destructive.
+     */
+    private _onResolved;
+}
+//# sourceMappingURL=ChunkStreamer.d.ts.map

package/dist/esm/ChunkStreamer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChunkStreamer.d.ts","sourceRoot":"","sources":["../../src/ChunkStreamer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,IAAI,EAAE,MAAM,eAAe,CAAC;AAElD,OAAO,KAAK,EAAgB,WAAW,EAAE,MAAM,eAAe,CAAC;AAC/D,OAAO,KAAK,EAAc,SAAS,EAAE,MAAM,aAAa,CAAC;AAGzD;;;GAGG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;OAGG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B;;;;;OAKG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B;;;;OAIG;IACH,QAAQ,CAAC,qBAAqB,CAAC,EAAE,MAAM,CAAC;CACzC;AAWD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAY;IACnC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAc;IACtC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAO;IAC7B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IACvC,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAS;IAEhD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAmE;IAC7F,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA6B;IACvD,OAAO,CAAC,eAAe,CAAK;IAC5B,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,UAAU,CAAS;gBAER,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,CAAC,EAAE,oBAAoB;IAapG,0EAA0E;IAC1E,IAAW,aAAa,IAAI,MAAM,CAEjC;IAED;;;;;;;OAOG;IACI,MAAM,IAAI,IAAI;IA4CrB;;;;OAIG;IACI,OAAO,IAAI,IAAI;IAWtB,OAAO,CAAC,iBAAiB;IA6BzB,OAAO,CAAC,cAAc;IAMtB,OAAO,CAAC,OAAO;IASf,OAAO,CAAC,QAAQ;IAqChB;;;;;;;OAOG;IACH,OAAO,CAAC,WAAW;CAUpB"}

package/dist/esm/ChunkStreamer.js

@@ -0,0 +1,201 @@
+import { tileToChunkCoord } from "./types.js";
+import { logger } from "@codexo/exojs";
+
+//#region src/ChunkStreamer.ts
+const DEFAULT_LOAD_RADIUS = 1;
+const DEFAULT_UNLOAD_RADIUS = 2;
+const DEFAULT_MAX_CHUNK_LOADS_PER_FRAME = 8;
+const chunkKey = (cx, cy) => `${cx},${cy}`;
+const isThenable = (value) => value !== null && typeof value === "object" && typeof value.then === "function";
+/**
+* Drives {@link TileLayer._adoptChunk}/{@link TileLayer._evictChunk} calls
+* from a {@link View}'s position: chunks near the view are requested from a
+* {@link ChunkSource} and installed; chunks that scroll far enough away are
+* evicted. Works on both unbounded and bounded layers (a bounded-but-large
+* layer still benefits from not keeping every chunk resident at once) - for
+* a bounded layer, the wanted range is clamped to {@link TileLayer.chunkRange}.
+*
+* Touches only the {@link TileLayer} data layer -
+* {@link import('./TileLayerNode').TileLayerNode} reacts to
+* `_adoptChunk`/`_evictChunk` on its own via a structural listener, so this
+* class has no rendering dependency and no reference to any scene node.
+*
+* Tracks its own resident set (chunks *this instance* has loaded), never
+* touching chunks that predate its attachment or were installed by another
+* source.
+*
+* Tick it from your update loop, like {@link import('./TileAnimator').TileAnimator}:
+*
+* ```ts
+* const streamer = new ChunkStreamer(layer, mySource, view);
+* scene.systems.add({ update: () => streamer.update() });
+* ```
+*
+* @advanced
+*/
+var ChunkStreamer = class {
+	_layer;
+	_source;
+	_view;
+	_loadRadius;
+	_unloadRadius;
+	_maxChunkLoadsPerFrame;
+	_resident = /* @__PURE__ */ new Map();
+	_inFlight = /* @__PURE__ */ new Map();
+	_requestCounter = 0;
+	_primed = false;
+	_destroyed = false;
+	constructor(layer, source, view, options) {
+		this._layer = layer;
+		this._source = source;
+		this._view = view;
+		this._loadRadius = options?.loadRadius ?? DEFAULT_LOAD_RADIUS;
+		this._unloadRadius = options?.unloadRadius ?? DEFAULT_UNLOAD_RADIUS;
+		this._maxChunkLoadsPerFrame = options?.maxChunkLoadsPerFrame ?? DEFAULT_MAX_CHUNK_LOADS_PER_FRAME;
+		if (this._unloadRadius < this._loadRadius) throw new Error(`ChunkStreamer unloadRadius (${this._unloadRadius}) must be >= loadRadius (${this._loadRadius}).`);
+	}
+	/** Number of chunks this instance currently has resident in the layer. */
+	get residentCount() {
+		return this._resident.size;
+	}
+	/**
+	* Recompute the wanted chunk set from the view's current position; evict
+	* own-resident chunks that fell outside `unloadRadius`, then request
+	* chunks newly inside `loadRadius`. The very first call loads the entire
+	* initial wanted set unbudgeted; every later call is capped at
+	* {@link ChunkStreamerOptions.maxChunkLoadsPerFrame}. No-op once
+	* {@link destroy}ed.
+	*/
+	update() {
+		if (this._destroyed) return;
+		const core = this._computeCoreRange();
+		this._unload(core);
+		const range = this._layer.chunkRange();
+		let minCx = core.minCx - this._loadRadius;
+		let minCy = core.minCy - this._loadRadius;
+		let maxCx = core.maxCx + this._loadRadius;
+		let maxCy = core.maxCy + this._loadRadius;
+		if (range !== null) {
+			minCx = Math.max(minCx, range.minCx);
+			minCy = Math.max(minCy, range.minCy);
+			maxCx = Math.min(maxCx, range.maxCx);
+			maxCy = Math.min(maxCy, range.maxCy);
+		}
+		const toLoad = [];
+		for (let cy = minCy; cy <= maxCy; cy++) for (let cx = minCx; cx <= maxCx; cx++) {
+			const key = chunkKey(cx, cy);
+			if (this._resident.has(key) || this._inFlight.has(key)) continue;
+			toLoad.push({
+				cx,
+				cy
+			});
+		}
+		if (!this._primed) {
+			this._primed = true;
+			for (const { cx, cy } of toLoad) this._request(cx, cy);
+			return;
+		}
+		toLoad.sort((a, b) => this._rangeDistance(a.cx, a.cy, core) - this._rangeDistance(b.cx, b.cy, core));
+		const budget = Math.min(this._maxChunkLoadsPerFrame, toLoad.length);
+		for (const { cx, cy } of toLoad.slice(0, budget)) this._request(cx, cy);
+	}
+	/**
+	* Evict every chunk this instance has loaded and stop responding to
+	* {@link update}. Does not affect chunks predating attachment or
+	* installed by another source. Idempotent.
+	*/
+	destroy() {
+		if (this._destroyed) return;
+		this._destroyed = true;
+		for (const { cx, cy } of this._resident.values()) this._layer._evictChunk(cx, cy);
+		this._resident.clear();
+		this._inFlight.clear();
+	}
+	_computeCoreRange() {
+		const layer = this._layer;
+		const view = this._view;
+		const bounds = view.getBounds();
+		const centerX = view.center.x;
+		const centerY = view.center.y;
+		const shiftX = centerX * (1 - layer.parallaxX);
+		const shiftY = centerY * (1 - layer.parallaxY);
+		const scale = layer.parallaxScale;
+		const layerLeft = layer.offsetX + (bounds.left - shiftX - layer.offsetX) / scale;
+		const layerTop = layer.offsetY + (bounds.top - shiftY - layer.offsetY) / scale;
+		const layerRight = layer.offsetX + (bounds.right - shiftX - layer.offsetX) / scale;
+		const layerBottom = layer.offsetY + (bounds.bottom - shiftY - layer.offsetY) / scale;
+		const topLeftTile = layer.pixelToTile(layerLeft, layerTop);
+		const bottomRightTile = layer.pixelToTile(layerRight, layerBottom);
+		const topLeftChunk = tileToChunkCoord(topLeftTile.tx, topLeftTile.ty, layer.chunkWidth, layer.chunkHeight);
+		const bottomRightChunk = tileToChunkCoord(bottomRightTile.tx, bottomRightTile.ty, layer.chunkWidth, layer.chunkHeight);
+		return {
+			minCx: topLeftChunk.cx,
+			minCy: topLeftChunk.cy,
+			maxCx: bottomRightChunk.cx,
+			maxCy: bottomRightChunk.cy
+		};
+	}
+	_rangeDistance(cx, cy, range) {
+		const dx = Math.max(range.minCx - cx, 0, cx - range.maxCx);
+		const dy = Math.max(range.minCy - cy, 0, cy - range.maxCy);
+		return Math.max(dx, dy);
+	}
+	_unload(core) {
+		for (const [key, { cx, cy }] of this._resident) if (this._rangeDistance(cx, cy, core) > this._unloadRadius) {
+			this._layer._evictChunk(cx, cy);
+			this._resident.delete(key);
+		}
+	}
+	_request(cx, cy) {
+		const key = chunkKey(cx, cy);
+		const token = ++this._requestCounter;
+		this._inFlight.set(key, token);
+		let result;
+		try {
+			result = this._source.getChunk(cx, cy);
+		} catch (error) {
+			this._inFlight.delete(key);
+			logger.warn(`ChunkStreamer: source.getChunk(${cx}, ${cy}) threw synchronously.`, {
+				source: "ChunkStreamer",
+				error: error instanceof Error ? error : new Error(String(error))
+			});
+			return;
+		}
+		if (isThenable(result)) {
+			result.then((payload) => {
+				this._onResolved(key, cx, cy, token, payload);
+			}, (error) => {
+				this._inFlight.delete(key);
+				logger.warn(`ChunkStreamer: source.getChunk(${cx}, ${cy}) rejected.`, {
+					source: "ChunkStreamer",
+					error: error instanceof Error ? error : new Error(String(error))
+				});
+			});
+			return;
+		}
+		this._onResolved(key, cx, cy, token, result);
+	}
+	/**
+	* Ignore-on-resolve: only the `_destroyed` and in-flight-token checks
+	* guard installation - a chunk that scrolled out of the wanted set while
+	* its request was in flight is still installed if it resolves (installing
+	* it is cheap and self-correcting: the next {@link update} call's unload
+	* pass evicts it again if it's genuinely no longer wanted). There is no
+	* edit-persistence to protect, so discarding is never destructive.
+	*/
+	_onResolved(key, cx, cy, token, payload) {
+		if (this._destroyed) return;
+		if (this._inFlight.get(key) !== token) return;
+		this._inFlight.delete(key);
+		if (payload === null) return;
+		this._layer._adoptChunk(cx, cy, payload);
+		this._resident.set(key, {
+			cx,
+			cy
+		});
+	}
+};
+
+//#endregion
+export { ChunkStreamer };
+//# sourceMappingURL=ChunkStreamer.js.map

package/dist/esm/ChunkStreamer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChunkStreamer.js","names":[],"sources":["../../src/ChunkStreamer.ts"],"sourcesContent":["import { logger, type View } from '@codexo/exojs';\n\nimport type { ChunkPayload, ChunkSource } from './ChunkSource';\nimport type { ChunkRange, TileLayer } from './TileLayer';\nimport { tileToChunkCoord } from './types';\n\n/**\n * Options for a {@link ChunkStreamer}. All optional.\n * @advanced\n */\nexport interface ChunkStreamerOptions {\n  /**\n   * Chunks within this many chunk-units (Chebyshev distance to the visible\n   * chunk range) of the view are loaded. Default `1`.\n   */\n  readonly loadRadius?: number;\n  /**\n   * Own-resident chunks beyond this many chunk-units of the view are\n   * evicted. Must be `>= loadRadius` - the gap between the two is\n   * deliberate hysteresis that prevents load/unload thrashing when the\n   * view sits near a chunk boundary. Default `2`.\n   */\n  readonly unloadRadius?: number;\n  /**\n   * Maximum number of new chunk loads issued per {@link ChunkStreamer.update}\n   * call, after the very first call (which loads the entire initial wanted\n   * set unbudgeted, so the starting view never pops in). Default `8`.\n   */\n  readonly maxChunkLoadsPerFrame?: number;\n}\n\nconst DEFAULT_LOAD_RADIUS = 1;\nconst DEFAULT_UNLOAD_RADIUS = 2;\nconst DEFAULT_MAX_CHUNK_LOADS_PER_FRAME = 8;\n\nconst chunkKey = (cx: number, cy: number): string => `${cx},${cy}`;\n\nconst isThenable = (value: unknown): value is Promise<ChunkPayload | null> =>\n  value !== null && typeof value === 'object' && typeof (value as { then?: unknown }).then === 'function';\n\n/**\n * Drives {@link TileLayer._adoptChunk}/{@link TileLayer._evictChunk} calls\n * from a {@link View}'s position: chunks near the view are requested from a\n * {@link ChunkSource} and installed; chunks that scroll far enough away are\n * evicted. Works on both unbounded and bounded layers (a bounded-but-large\n * layer still benefits from not keeping every chunk resident at once) - for\n * a bounded layer, the wanted range is clamped to {@link TileLayer.chunkRange}.\n *\n * Touches only the {@link TileLayer} data layer -\n * {@link import('./TileLayerNode').TileLayerNode} reacts to\n * `_adoptChunk`/`_evictChunk` on its own via a structural listener, so this\n * class has no rendering dependency and no reference to any scene node.\n *\n * Tracks its own resident set (chunks *this instance* has loaded), never\n * touching chunks that predate its attachment or were installed by another\n * source.\n *\n * Tick it from your update loop, like {@link import('./TileAnimator').TileAnimator}:\n *\n * ```ts\n * const streamer = new ChunkStreamer(layer, mySource, view);\n * scene.systems.add({ update: () => streamer.update() });\n * ```\n *\n * @advanced\n */\nexport class ChunkStreamer {\n  private readonly _layer: TileLayer;\n  private readonly _source: ChunkSource;\n  private readonly _view: View;\n  private readonly _loadRadius: number;\n  private readonly _unloadRadius: number;\n  private readonly _maxChunkLoadsPerFrame: number;\n\n  private readonly _resident = new Map<string, { readonly cx: number; readonly cy: number }>();\n  private readonly _inFlight = new Map<string, number>();\n  private _requestCounter = 0;\n  private _primed = false;\n  private _destroyed = false;\n\n  public constructor(layer: TileLayer, source: ChunkSource, view: View, options?: ChunkStreamerOptions) {\n    this._layer = layer;\n    this._source = source;\n    this._view = view;\n    this._loadRadius = options?.loadRadius ?? DEFAULT_LOAD_RADIUS;\n    this._unloadRadius = options?.unloadRadius ?? DEFAULT_UNLOAD_RADIUS;\n    this._maxChunkLoadsPerFrame = options?.maxChunkLoadsPerFrame ?? DEFAULT_MAX_CHUNK_LOADS_PER_FRAME;\n\n    if (this._unloadRadius < this._loadRadius) {\n      throw new Error(`ChunkStreamer unloadRadius (${this._unloadRadius}) must be >= loadRadius (${this._loadRadius}).`);\n    }\n  }\n\n  /** Number of chunks this instance currently has resident in the layer. */\n  public get residentCount(): number {\n    return this._resident.size;\n  }\n\n  /**\n   * Recompute the wanted chunk set from the view's current position; evict\n   * own-resident chunks that fell outside `unloadRadius`, then request\n   * chunks newly inside `loadRadius`. The very first call loads the entire\n   * initial wanted set unbudgeted; every later call is capped at\n   * {@link ChunkStreamerOptions.maxChunkLoadsPerFrame}. No-op once\n   * {@link destroy}ed.\n   */\n  public update(): void {\n    if (this._destroyed) return;\n\n    const core = this._computeCoreRange();\n\n    this._unload(core);\n\n    const range = this._layer.chunkRange();\n    let minCx = core.minCx - this._loadRadius;\n    let minCy = core.minCy - this._loadRadius;\n    let maxCx = core.maxCx + this._loadRadius;\n    let maxCy = core.maxCy + this._loadRadius;\n    if (range !== null) {\n      minCx = Math.max(minCx, range.minCx);\n      minCy = Math.max(minCy, range.minCy);\n      maxCx = Math.min(maxCx, range.maxCx);\n      maxCy = Math.min(maxCy, range.maxCy);\n    }\n\n    const toLoad: Array<{ cx: number; cy: number }> = [];\n    for (let cy = minCy; cy <= maxCy; cy++) {\n      for (let cx = minCx; cx <= maxCx; cx++) {\n        const key = chunkKey(cx, cy);\n        if (this._resident.has(key) || this._inFlight.has(key)) continue;\n        toLoad.push({ cx, cy });\n      }\n    }\n\n    if (!this._primed) {\n      this._primed = true;\n      for (const { cx, cy } of toLoad) {\n        this._request(cx, cy);\n      }\n      return;\n    }\n\n    toLoad.sort((a, b) => this._rangeDistance(a.cx, a.cy, core) - this._rangeDistance(b.cx, b.cy, core));\n\n    const budget = Math.min(this._maxChunkLoadsPerFrame, toLoad.length);\n    for (const { cx, cy } of toLoad.slice(0, budget)) {\n      this._request(cx, cy);\n    }\n  }\n\n  /**\n   * Evict every chunk this instance has loaded and stop responding to\n   * {@link update}. Does not affect chunks predating attachment or\n   * installed by another source. Idempotent.\n   */\n  public destroy(): void {\n    if (this._destroyed) return;\n    this._destroyed = true;\n\n    for (const { cx, cy } of this._resident.values()) {\n      this._layer._evictChunk(cx, cy);\n    }\n    this._resident.clear();\n    this._inFlight.clear();\n  }\n\n  private _computeCoreRange(): ChunkRange {\n    const layer = this._layer;\n    const view = this._view;\n    const bounds = view.getBounds();\n    const centerX = view.center.x;\n    const centerY = view.center.y;\n\n    const shiftX = centerX * (1 - layer.parallaxX);\n    const shiftY = centerY * (1 - layer.parallaxY);\n    const scale = layer.parallaxScale;\n\n    const layerLeft = layer.offsetX + (bounds.left - shiftX - layer.offsetX) / scale;\n    const layerTop = layer.offsetY + (bounds.top - shiftY - layer.offsetY) / scale;\n    const layerRight = layer.offsetX + (bounds.right - shiftX - layer.offsetX) / scale;\n    const layerBottom = layer.offsetY + (bounds.bottom - shiftY - layer.offsetY) / scale;\n    const topLeftTile = layer.pixelToTile(layerLeft, layerTop);\n    const bottomRightTile = layer.pixelToTile(layerRight, layerBottom);\n\n    const topLeftChunk = tileToChunkCoord(topLeftTile.tx, topLeftTile.ty, layer.chunkWidth, layer.chunkHeight);\n    const bottomRightChunk = tileToChunkCoord(bottomRightTile.tx, bottomRightTile.ty, layer.chunkWidth, layer.chunkHeight);\n\n    return {\n      minCx: topLeftChunk.cx,\n      minCy: topLeftChunk.cy,\n      maxCx: bottomRightChunk.cx,\n      maxCy: bottomRightChunk.cy,\n    };\n  }\n\n  private _rangeDistance(cx: number, cy: number, range: ChunkRange): number {\n    const dx = Math.max(range.minCx - cx, 0, cx - range.maxCx);\n    const dy = Math.max(range.minCy - cy, 0, cy - range.maxCy);\n    return Math.max(dx, dy);\n  }\n\n  private _unload(core: ChunkRange): void {\n    for (const [key, { cx, cy }] of this._resident) {\n      if (this._rangeDistance(cx, cy, core) > this._unloadRadius) {\n        this._layer._evictChunk(cx, cy);\n        this._resident.delete(key);\n      }\n    }\n  }\n\n  private _request(cx: number, cy: number): void {\n    const key = chunkKey(cx, cy);\n    const token = ++this._requestCounter;\n    this._inFlight.set(key, token);\n\n    let result: ChunkPayload | null | Promise<ChunkPayload | null>;\n    try {\n      result = this._source.getChunk(cx, cy);\n    } catch (error) {\n      this._inFlight.delete(key);\n      logger.warn(`ChunkStreamer: source.getChunk(${cx}, ${cy}) threw synchronously.`, {\n        source: 'ChunkStreamer',\n        error: error instanceof Error ? error : new Error(String(error)),\n      });\n\n      return;\n    }\n\n    if (isThenable(result)) {\n      result.then(\n        payload => {\n          this._onResolved(key, cx, cy, token, payload);\n        },\n        (error: unknown) => {\n          this._inFlight.delete(key);\n          logger.warn(`ChunkStreamer: source.getChunk(${cx}, ${cy}) rejected.`, {\n            source: 'ChunkStreamer',\n            error: error instanceof Error ? error : new Error(String(error)),\n          });\n        },\n      );\n      return;\n    }\n\n    this._onResolved(key, cx, cy, token, result);\n  }\n\n  /**\n   * Ignore-on-resolve: only the `_destroyed` and in-flight-token checks\n   * guard installation - a chunk that scrolled out of the wanted set while\n   * its request was in flight is still installed if it resolves (installing\n   * it is cheap and self-correcting: the next {@link update} call's unload\n   * pass evicts it again if it's genuinely no longer wanted). There is no\n   * edit-persistence to protect, so discarding is never destructive.\n   */\n  private _onResolved(key: string, cx: number, cy: number, token: number, payload: ChunkPayload | null): void {\n    if (this._destroyed) return;\n    if (this._inFlight.get(key) !== token) return;\n    this._inFlight.delete(key);\n\n    if (payload === null) return;\n\n    this._layer._adoptChunk(cx, cy, payload);\n    this._resident.set(key, { cx, cy });\n  }\n}\n"],"mappings":";;;;AA+BA,MAAM,sBAAsB;AAC5B,MAAM,wBAAwB;AAC9B,MAAM,oCAAoC;AAE1C,MAAM,YAAY,IAAY,OAAuB,GAAG,GAAG,GAAG;AAE9D,MAAM,cAAc,UAClB,UAAU,QAAQ,OAAO,UAAU,YAAY,OAAQ,MAA6B,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4B/F,IAAa,gBAAb,MAA2B;CACzB,AAAiB;CACjB,AAAiB;CACjB,AAAiB;CACjB,AAAiB;CACjB,AAAiB;CACjB,AAAiB;CAEjB,AAAiB,4BAAY,IAAI,IAA0D;CAC3F,AAAiB,4BAAY,IAAI,IAAoB;CACrD,AAAQ,kBAAkB;CAC1B,AAAQ,UAAU;CAClB,AAAQ,aAAa;CAErB,AAAO,YAAY,OAAkB,QAAqB,MAAY,SAAgC;EACpG,KAAK,SAAS;EACd,KAAK,UAAU;EACf,KAAK,QAAQ;EACb,KAAK,cAAc,SAAS,cAAc;EAC1C,KAAK,gBAAgB,SAAS,gBAAgB;EAC9C,KAAK,yBAAyB,SAAS,yBAAyB;EAEhE,IAAI,KAAK,gBAAgB,KAAK,aAC5B,MAAM,IAAI,MAAM,+BAA+B,KAAK,cAAc,2BAA2B,KAAK,YAAY,GAAG;CAErH;;CAGA,IAAW,gBAAwB;EACjC,OAAO,KAAK,UAAU;CACxB;;;;;;;;;CAUA,AAAO,SAAe;EACpB,IAAI,KAAK,YAAY;EAErB,MAAM,OAAO,KAAK,kBAAkB;EAEpC,KAAK,QAAQ,IAAI;EAEjB,MAAM,QAAQ,KAAK,OAAO,WAAW;EACrC,IAAI,QAAQ,KAAK,QAAQ,KAAK;EAC9B,IAAI,QAAQ,KAAK,QAAQ,KAAK;EAC9B,IAAI,QAAQ,KAAK,QAAQ,KAAK;EAC9B,IAAI,QAAQ,KAAK,QAAQ,KAAK;EAC9B,IAAI,UAAU,MAAM;GAClB,QAAQ,KAAK,IAAI,OAAO,MAAM,KAAK;GACnC,QAAQ,KAAK,IAAI,OAAO,MAAM,KAAK;GACnC,QAAQ,KAAK,IAAI,OAAO,MAAM,KAAK;GACnC,QAAQ,KAAK,IAAI,OAAO,MAAM,KAAK;EACrC;EAEA,MAAM,SAA4C,CAAC;EACnD,KAAK,IAAI,KAAK,OAAO,MAAM,OAAO,MAChC,KAAK,IAAI,KAAK,OAAO,MAAM,OAAO,MAAM;GACtC,MAAM,MAAM,SAAS,IAAI,EAAE;GAC3B,IAAI,KAAK,UAAU,IAAI,GAAG,KAAK,KAAK,UAAU,IAAI,GAAG,GAAG;GACxD,OAAO,KAAK;IAAE;IAAI;GAAG,CAAC;EACxB;EAGF,IAAI,CAAC,KAAK,SAAS;GACjB,KAAK,UAAU;GACf,KAAK,MAAM,EAAE,IAAI,QAAQ,QACvB,KAAK,SAAS,IAAI,EAAE;GAEtB;EACF;EAEA,OAAO,MAAM,GAAG,MAAM,KAAK,eAAe,EAAE,IAAI,EAAE,IAAI,IAAI,IAAI,KAAK,eAAe,EAAE,IAAI,EAAE,IAAI,IAAI,CAAC;EAEnG,MAAM,SAAS,KAAK,IAAI,KAAK,wBAAwB,OAAO,MAAM;EAClE,KAAK,MAAM,EAAE,IAAI,QAAQ,OAAO,MAAM,GAAG,MAAM,GAC7C,KAAK,SAAS,IAAI,EAAE;CAExB;;;;;;CAOA,AAAO,UAAgB;EACrB,IAAI,KAAK,YAAY;EACrB,KAAK,aAAa;EAElB,KAAK,MAAM,EAAE,IAAI,QAAQ,KAAK,UAAU,OAAO,GAC7C,KAAK,OAAO,YAAY,IAAI,EAAE;EAEhC,KAAK,UAAU,MAAM;EACrB,KAAK,UAAU,MAAM;CACvB;CAEA,AAAQ,oBAAgC;EACtC,MAAM,QAAQ,KAAK;EACnB,MAAM,OAAO,KAAK;EAClB,MAAM,SAAS,KAAK,UAAU;EAC9B,MAAM,UAAU,KAAK,OAAO;EAC5B,MAAM,UAAU,KAAK,OAAO;EAE5B,MAAM,SAAS,WAAW,IAAI,MAAM;EACpC,MAAM,SAAS,WAAW,IAAI,MAAM;EACpC,MAAM,QAAQ,MAAM;EAEpB,MAAM,YAAY,MAAM,WAAW,OAAO,OAAO,SAAS,MAAM,WAAW;EAC3E,MAAM,WAAW,MAAM,WAAW,OAAO,MAAM,SAAS,MAAM,WAAW;EACzE,MAAM,aAAa,MAAM,WAAW,OAAO,QAAQ,SAAS,MAAM,WAAW;EAC7E,MAAM,cAAc,MAAM,WAAW,OAAO,SAAS,SAAS,MAAM,WAAW;EAC/E,MAAM,cAAc,MAAM,YAAY,WAAW,QAAQ;EACzD,MAAM,kBAAkB,MAAM,YAAY,YAAY,WAAW;EAEjE,MAAM,eAAe,iBAAiB,YAAY,IAAI,YAAY,IAAI,MAAM,YAAY,MAAM,WAAW;EACzG,MAAM,mBAAmB,iBAAiB,gBAAgB,IAAI,gBAAgB,IAAI,MAAM,YAAY,MAAM,WAAW;EAErH,OAAO;GACL,OAAO,aAAa;GACpB,OAAO,aAAa;GACpB,OAAO,iBAAiB;GACxB,OAAO,iBAAiB;EAC1B;CACF;CAEA,AAAQ,eAAe,IAAY,IAAY,OAA2B;EACxE,MAAM,KAAK,KAAK,IAAI,MAAM,QAAQ,IAAI,GAAG,KAAK,MAAM,KAAK;EACzD,MAAM,KAAK,KAAK,IAAI,MAAM,QAAQ,IAAI,GAAG,KAAK,MAAM,KAAK;EACzD,OAAO,KAAK,IAAI,IAAI,EAAE;CACxB;CAEA,AAAQ,QAAQ,MAAwB;EACtC,KAAK,MAAM,CAAC,KAAK,EAAE,IAAI,SAAS,KAAK,WACnC,IAAI,KAAK,eAAe,IAAI,IAAI,IAAI,IAAI,KAAK,eAAe;GAC1D,KAAK,OAAO,YAAY,IAAI,EAAE;GAC9B,KAAK,UAAU,OAAO,GAAG;EAC3B;CAEJ;CAEA,AAAQ,SAAS,IAAY,IAAkB;EAC7C,MAAM,MAAM,SAAS,IAAI,EAAE;EAC3B,MAAM,QAAQ,EAAE,KAAK;EACrB,KAAK,UAAU,IAAI,KAAK,KAAK;EAE7B,IAAI;EACJ,IAAI;GACF,SAAS,KAAK,QAAQ,SAAS,IAAI,EAAE;EACvC,SAAS,OAAO;GACd,KAAK,UAAU,OAAO,GAAG;GACzB,OAAO,KAAK,kCAAkC,GAAG,IAAI,GAAG,yBAAyB;IAC/E,QAAQ;IACR,OAAO,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,KAAK,CAAC;GACjE,CAAC;GAED;EACF;EAEA,IAAI,WAAW,MAAM,GAAG;GACtB,OAAO,MACL,YAAW;IACT,KAAK,YAAY,KAAK,IAAI,IAAI,OAAO,OAAO;GAC9C,IACC,UAAmB;IAClB,KAAK,UAAU,OAAO,GAAG;IACzB,OAAO,KAAK,kCAAkC,GAAG,IAAI,GAAG,cAAc;KACpE,QAAQ;KACR,OAAO,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,KAAK,CAAC;IACjE,CAAC;GACH,CACF;GACA;EACF;EAEA,KAAK,YAAY,KAAK,IAAI,IAAI,OAAO,MAAM;CAC7C;;;;;;;;;CAUA,AAAQ,YAAY,KAAa,IAAY,IAAY,OAAe,SAAoC;EAC1G,IAAI,KAAK,YAAY;EACrB,IAAI,KAAK,UAAU,IAAI,GAAG,MAAM,OAAO;EACvC,KAAK,UAAU,OAAO,GAAG;EAEzB,IAAI,YAAY,MAAM;EAEtB,KAAK,OAAO,YAAY,IAAI,IAAI,OAAO;EACvC,KAAK,UAAU,IAAI,KAAK;GAAE;GAAI;EAAG,CAAC;CACpC;AACF"}

package/dist/esm/ImageLayer.d.ts

@@ -24,6 +24,8 @@ export interface ImageLayerOptions {
     readonly parallaxX?: number;
     /** Vertical parallax factor. Default `1`. */
     readonly parallaxY?: number;
+    /** Uniform parallax scale around the layer origin. Default `1`. */
+    readonly parallaxScale?: number;
     /** Tint colour as `0xRRGGBB`, or `null`. Default `null`. */
     readonly tintColor?: number | null;
     /** Whether the image repeats horizontally. Default `false`. */
@@ -35,9 +37,12 @@ export interface ImageLayerOptions {
 }
 /**
  * A data-only image layer: a single image (texture + resolved URL) placed as a
- * background or foreground layer. Image layers are not rendered by the tile
- * renderer — they are exposed as data for a renderer or follow-up scene node to
- * consume.
+ * background or foreground layer. The layer itself holds no scene-graph state -
+ * it is rendered by an {@link import('./ImageLayerNode').ImageLayerNode}, which
+ * {@link import('./TileMapNode').TileMapNode} and
+ * {@link import('./TileMapView').TileMapView} generate and interleave with tile
+ * layers by the map's combined document order
+ * ({@link import('./TileMap').TileMap.renderableLayers}).
  *
  * Parallax, opacity, tint, offset, and repeat flags are carried from the
  * source Tiled map.
@@ -69,6 +74,8 @@ export declare class ImageLayer {
     readonly parallaxX: number;
     /** Vertical parallax factor. */
     readonly parallaxY: number;
+    /** Uniform scale applied around the layer origin during parallax rendering. */
+    readonly parallaxScale: number;
     /** Tint colour as `0xRRGGBB`, or `null`. */
     readonly tintColor: number | null;
     /** Whether the image repeats horizontally. */
@@ -79,3 +86,4 @@ export declare class ImageLayer {
     readonly properties: TileProperties;
     constructor(options: ImageLayerOptions);
 }
+//# sourceMappingURL=ImageLayer.d.ts.map

package/dist/esm/ImageLayer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ImageLayer.d.ts","sourceRoot":"","sources":["../../src/ImageLayer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAE7C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C,sDAAsD;AACtD,MAAM,WAAW,iBAAiB;IAChC,wCAAwC;IACxC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,kBAAkB;IAClB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,0BAA0B;IAC1B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,0BAA0B;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,8DAA8D;IAC9D,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IAClC,oDAAoD;IACpD,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC3B,8CAA8C;IAC9C,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,yCAAyC;IACzC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,yCAAyC;IACzC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,+CAA+C;IAC/C,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,6CAA6C;IAC7C,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,mEAAmE;IACnE,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,4DAA4D;IAC5D,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,+DAA+D;IAC/D,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC3B,6DAA6D;IAC7D,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC3B,4CAA4C;IAC5C,QAAQ,CAAC,UAAU,CAAC,EAAE,cAAc,CAAC;CACtC;AAED;;;;;;;;;;;;;GAaG;AACH,qBAAa,UAAU;IACrB,+BAA+B;IAC/B,SAAgB,IAAI,EAAG,OAAO,CAAU;IAExC,wCAAwC;IACxC,SAAgB,EAAE,EAAE,MAAM,CAAC;IAC3B,kBAAkB;IAClB,SAAgB,IAAI,EAAE,MAAM,CAAC;IAC7B,0BAA0B;IAC1B,SAAgB,KAAK,EAAE,MAAM,CAAC;IAC9B,uCAAuC;IACvC,SAAgB,KAAK,EAAE,MAAM,CAAC;IAC9B,8DAA8D;IAC9D,SAAgB,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;IACxC,oCAAoC;IACpC,SAAgB,OAAO,EAAE,OAAO,CAAC;IACjC,iCAAiC;IACjC,SAAgB,OAAO,EAAE,MAAM,CAAC;IAChC,4BAA4B;IAC5B,SAAgB,OAAO,EAAE,MAAM,CAAC;IAChC,4BAA4B;IAC5B,SAAgB,OAAO,EAAE,MAAM,CAAC;IAChC,kCAAkC;IAClC,SAAgB,SAAS,EAAE,MAAM,CAAC;IAClC,gCAAgC;IAChC,SAAgB,SAAS,EAAE,MAAM,CAAC;IAClC,+EAA+E;IAC/E,SAAgB,aAAa,EAAE,MAAM,CAAC;IACtC,4CAA4C;IAC5C,SAAgB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzC,8CAA8C;IAC9C,SAAgB,OAAO,EAAE,OAAO,CAAC;IACjC,4CAA4C;IAC5C,SAAgB,OAAO,EAAE,OAAO,CAAC;IACjC,kCAAkC;IAClC,SAAgB,UAAU,EAAE,cAAc,CAAC;gBAExB,OAAO,EAAE,iBAAiB;CAqB9C"}