@arcadekit/render-three 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Lucas Thevenet
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,73 @@
-# Temporary Holding Version
+# @arcadekit/render-three
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Three.js drawing for arcadekit games. `Stage` is a renderer, scene and camera that fill an element and resize with it; its `"pixel"` camera (`PixelCamera`) looks straight down and keeps sprite pixels whole. `loadSpriteSheet` loads an Aseprite sheet (PNG and JSON) as an Effect, `InstancedSprites` draws many sprites from one sheet in one draw call, and `frameAt` picks a tag's frame at a time.
+
+Part of [arcadekit](https://github.com/lucasthevenet/arcadekit#readme). Needs the DOM and WebGL.
+
+## Install
+
+```bash
+pnpm add @arcadekit/render-three three effect
+pnpm add -D @types/three
+```
+
+Peer dependencies: `three` (^0.187) and `effect` (~4.1). `@types/three` (^0.187, an optional peer) gives Three.js its types.
+
+## Example
+
+A view that draws every enemy with its tag's animation, following the hero (a cut-down version of the genres' views). The app loads the sheet with `loadSpriteSheet("/sprites/game.json")` and owns it: the view never frees it.
+
+```ts
+import { InstancedSprites, Stage, frameAt } from "@arcadekit/render-three";
+import type { SpriteSheet } from "@arcadekit/render-three";
+
+interface World {
+  readonly heroX: number;
+  readonly heroZ: number;
+  readonly enemies: {
+    readonly count: number;
+    readonly x: Float32Array;
+    readonly z: Float32Array;
+  };
+}
+
+export class WorldView {
+  private readonly stage: Stage<"pixel">;
+  private readonly enemies: InstancedSprites;
+  private readonly sheet: SpriteSheet;
+
+  constructor(container: HTMLElement, sheet: SpriteSheet) {
+    this.sheet = sheet;
+    this.stage = new Stage(container, {
+      camera: "pixel",
+      pixelsPerUnit: 16,
+      background: "#17151f",
+    });
+    this.enemies = new InstancedSprites(sheet, {
+      capacity: 1000,
+      unitsPerPixel: 1 / 16,
+    });
+    this.stage.scene.add(this.enemies.mesh);
+  }
+
+  render(world: World | null, timeSeconds: number): void {
+    const walk = this.sheet.data.tags.get("slime/move");
+    if (world !== null && walk !== undefined) {
+      const frame = frameAt(this.sheet.data, walk, timeSeconds);
+      for (let i = 0; i < world.enemies.count; i++) {
+        this.enemies.set(i, world.enemies.x[i]!, world.enemies.z[i]!, frame);
+      }
+      this.enemies.commit(world.enemies.count);
+      this.stage.camera.follow(world.heroX, world.heroZ);
+    }
+    this.stage.render();
+  }
+
+  dispose(): void {
+    // Frees everything in the scene except the sheet's texture, which the app frees.
+    this.stage.dispose();
+  }
+}
+```
+
+See [ADR-0015](https://github.com/lucasthevenet/arcadekit/blob/main/docs/adr/0015-pixel-art-sprites-loaded-by-the-app.md) (pixel-art sprites loaded by the app).

package/dist/index.d.ts

@@ -0,0 +1,374 @@
+import * as THREE from "three";
+import { Data, Effect } from "effect";
+/** Keeps the camera at a fixed offset from a target on the ground plane, looking at it. Top-down and isometric games. */
+export declare const followTarget: (camera: THREE.Camera, target: {
+  readonly x: number;
+  readonly z: number;
+}, offset: {
+  readonly x: number;
+  readonly y: number;
+  readonly z: number;
+}) => void;
+/**
+ * Circles the camera around a point on the ground plane at a fixed height, looking at it.
+ * `angle` is in radians; 0 puts the camera on the point's +z side. Menu backdrops and
+ * showcase views.
+ */
+export declare const orbitAround: (camera: THREE.Camera, center: {
+  readonly x: number;
+  readonly z: number;
+}, options: {
+  readonly radius: number;
+  readonly height: number;
+  readonly angle: number;
+}) => void;
+/** A rectangle on the ground plane (y = 0), in world units. */
+interface GroundBounds {
+  readonly minX: number;
+  readonly maxX: number;
+  readonly minZ: number;
+  readonly maxZ: number;
+}
+interface FitCameraOptions {
+  /** World units of space left around the bounds on every side. Defaults to 0. */
+  readonly margin?: number;
+  /**
+   * How far the camera sits back (toward +z) from straight overhead, as a fraction of its
+   * height. 0 looks straight down. Defaults to 0.
+   */
+  readonly tilt?: number;
+}
+/**
+ * Places a camera above a rectangle on the ground plane, looking at its center, so that all of
+ * it shows at the camera's current aspect ratio. Board, puzzle and arena games. Call it every
+ * frame (it allocates nothing), or at least after each resize.
+ *
+ * A perspective camera keeps its field of view and moves back far enough. An orthographic
+ * camera (`Stage` with `camera: "orthographic"`) changes its frustum to fit instead.
+ * With a tilt, the fit is still worked out as if looking straight down. That leaves an
+ * orthographic camera a little extra room. It does not hold for a perspective camera: a small
+ * tilt (below the tangent of half its field of view) can push the near edge of the bounds off
+ * the screen, so give it more margin.
+ */
+export declare const fitCamera: (camera: THREE.PerspectiveCamera | THREE.OrthographicCamera, bounds: GroundBounds, options?: FitCameraOptions) => void;
+declare const SpriteSheetErrorBase: ReturnType<typeof Data.TaggedError<"SpriteSheetError">>;
+/** A sprite sheet that couldn't be fetched, decoded or checked. `file` is the JSON or image that failed. */
+export declare class SpriteSheetError extends SpriteSheetErrorBase<{
+  readonly file: string;
+  readonly message: string;
+  readonly cause?: unknown;
+}> {}
+/** How a tag's frames play: Aseprite's tag directions. */
+type SpriteTagDirection = "forward" | "reverse" | "pingpong" | "pingpong_reverse";
+/** One frame of a sheet. Every size and offset is in sprite pixels. */
+interface SpriteFrame {
+  /** Aseprite's `filename`, or the frame's key in the "hash" form. */
+  readonly name: string;
+  /** Where the frame's pixels are in the image, from its top-left corner. */
+  readonly x: number;
+  readonly y: number;
+  readonly width: number;
+  readonly height: number;
+  /** Where those pixels sit in the untrimmed frame. 0, 0 unless the export trimmed it. */
+  readonly offsetX: number;
+  readonly offsetY: number;
+  /** The untrimmed frame's size: what an anchor is a fraction of. */
+  readonly sourceWidth: number;
+  readonly sourceHeight: number;
+  /** How long the frame shows in an animation, in seconds (Aseprite writes ms). */
+  readonly duration: number;
+}
+/** A named run of frames: one animation, such as "slime/move". */
+interface SpriteTag {
+  readonly name: string;
+  /** First and last frame index, both included. */
+  readonly from: number;
+  readonly to: number;
+  readonly direction: SpriteTagDirection;
+  /** One whole loop, in seconds. A pingpong loop plays the middle frames twice. */
+  readonly duration: number;
+}
+/** A parsed sheet: its frames in order, a lookup by frame name, and its tags by name. */
+interface SpriteSheetData {
+  /** `meta.image` as written: the image's path relative to the JSON. */
+  readonly image: string;
+  /** The image's size in pixels (`meta.size`). */
+  readonly width: number;
+  readonly height: number;
+  readonly frames: readonly SpriteFrame[];
+  /** Frame index by name. If two frames share a name, the first wins. */
+  readonly frameByName: ReadonlyMap<string, number>;
+  readonly tags: ReadonlyMap<string, SpriteTag>;
+}
+/**
+ * Parses an Aseprite JSON export (frames as an array or a hash) and checks it: every frame
+ * inside the image, every tag inside the frames, no two tags with one name. `file` names the
+ * JSON in the error. Rotated frames (a TexturePacker option) aren't supported. A tag's
+ * `repeat` is ignored: animations loop.
+ */
+export declare const decodeSpriteSheet: (file: string, json: unknown) => Effect.Effect<SpriteSheetData, SpriteSheetError>;
+/**
+ * The frame index (into `sheet.frames`) a tag shows `seconds` into its animation, looping,
+ * from each frame's duration and the tag's direction. Allocates nothing: call it per sprite
+ * per frame. Negative times count back from the end of a loop.
+ */
+export declare const frameAt: (sheet: SpriteSheetData, tag: SpriteTag, seconds: number) => number;
+/**
+ * A sprite sheet ready to draw: its frames and tags, and its image as a texture.
+ * The app loads it and owns it: views draw from it but never free it (`disposeObject` and
+ * `Stage.dispose` skip its texture). The app calls `dispose` when it no longer needs it.
+ */
+interface SpriteSheet {
+  readonly data: SpriteSheetData;
+  /** Nearest filtering, no mipmaps, sRGB, `flipY` off: row 0 of the image is v = 0. */
+  readonly texture: THREE.Texture;
+  readonly dispose: () => void;
+}
+/**
+ * Makes a sheet from parsed data and an image that's already in memory, such as a canvas the
+ * art was painted on. `loadSpriteSheet` uses it after fetching both files.
+ */
+export declare const makeSpriteSheet: (data: SpriteSheetData, image: TexImageSource) => SpriteSheet;
+/**
+ * Loads an Aseprite sheet: fetches the JSON at `jsonUrl`, then the image its `meta.image`
+ * names, relative to the JSON. Fails with a `SpriteSheetError` naming the file when either
+ * can't be fetched, the JSON is invalid, or the image's size isn't `meta.size`.
+ */
+export declare const loadSpriteSheet: (jsonUrl: string) => Effect.Effect<SpriteSheet, SpriteSheetError>;
+interface InstancedSpritesOptions {
+  /** The most sprites it can draw at once. Fixed. */
+  readonly capacity: number;
+  /** World units per sprite pixel: 1/16 draws a 16 px sprite one unit wide. Defaults to 1/16. */
+  readonly unitsPerPixel?: number;
+  /**
+   * The point of a frame a sprite's position marks, as a fraction of the frame's untrimmed size
+   * from its top-left corner, rounded to a whole pixel. Defaults to the middle, (0.5, 0.5); a
+   * character standing on its feet wants about (0.5, 0.9).
+   */
+  readonly anchor?: {
+    readonly x: number;
+    readonly y: number;
+  };
+  /**
+   * Layer added to every sprite's own layer. A higher layer draws over a lower one whatever
+   * their positions: ground marks below characters, characters below projectiles. Use whole
+   * numbers; layer 0 and up draw above anything at y = 0, such as a ground mesh. Defaults to 0.
+   */
+  readonly layer?: number;
+  /**
+   * Blend partly transparent pixels, for soft shadows and markers. Off by default: pixel art
+   * draws opaque, with pixels below `alphaTest` cut out, and sorts by depth. A transparent batch
+   * doesn't write depth, so its own sprites overlap in index order.
+   */
+  readonly transparent?: boolean;
+  /** Pixels with less alpha (after the sprite's own alpha) aren't drawn. Defaults to 0.5, or 0.01 when transparent. */
+  readonly alphaTest?: number;
+  /** Rounds each sprite's position to whole sprite pixels, so the art never shimmers. Defaults to true. */
+  readonly snap?: boolean;
+  /**
+   * How far from z = 0, in world units, depth still orders sprites within a layer: beyond it,
+   * sprites tie. Defaults to 256.
+   */
+  readonly sortRange?: number;
+}
+/**
+ * Draws up to `capacity` sprites from one sheet in a single draw call, as quads on the ground
+ * plane facing a straight-down camera (`PixelCamera`). Each sprite has a position, a frame,
+ * a horizontal flip, a tint, a flash toward white, an alpha, a lift and a layer. Within a layer
+ * a sprite lower on screen (larger z) draws in front.
+ *
+ * Each frame, call `set` for every sprite to draw (it resets that sprite's look), then the
+ * other setters for those that need them, then `commit(count)`. Nothing allocates per frame.
+ * Add `mesh` to the scene. `dispose` (or `disposeObject`) frees its own geometry, material and
+ * frame table, never the sheet's texture: the sheet's owner frees that.
+ */
+export declare class InstancedSprites {
+  readonly mesh: THREE.Mesh<THREE.InstancedBufferGeometry, THREE.ShaderMaterial>;
+  readonly capacity: number;
+  readonly sheet: SpriteSheet;
+  private readonly frameCount;
+  private readonly place;
+  private readonly frame;
+  private readonly tint;
+  private readonly frameTable;
+  constructor(sheet: SpriteSheet, options: InstancedSpritesOptions);
+  /**
+   * Places sprite `index` with its feet (its anchor) at (x, z) on the ground, showing frame
+   * `frame` (an index into `sheet.data.frames`, as `frameAt` gives), mirrored if `flipX`.
+   * Resets its tint, alpha, flash, lift and layer. A frame outside the sheet draws frame 0.
+   */
+  set(index: number, x: number, z: number, frame: number, flipX?: boolean): void;
+  /** Multiplies sprite `index`'s colors by `color` (white leaves them), and sets its alpha. */
+  setTint(index: number, color: THREE.Color, alpha?: number): void;
+  /** Sets sprite `index`'s alpha (0 to 1) and keeps its tint. Opaque sprites hide below `alphaTest`. */
+  setAlpha(index: number, alpha: number): void;
+  /** Blends sprite `index` toward white: 0 is its own colors, 1 a white silhouette. A hit flash. */
+  setFlash(index: number, amount: number): void;
+  /**
+   * Draws sprite `index` `lift` world units up the screen, as if floating: a bat. Its depth
+   * stays where its feet are, so it sorts with the things standing near it.
+   */
+  setLift(index: number, lift: number): void;
+  /** Puts sprite `index` in another layer, added to the batch's own. See `InstancedSpritesOptions.layer`. */
+  setLayer(index: number, layer: number): void;
+  /** Shows the first `count` sprites and uploads them. */
+  commit(count: number): void;
+  /** Removes the mesh and frees its geometry, material and frame table. Never the sheet. */
+  dispose(): void;
+}
+/**
+ * Draws up to `capacity` copies of one mesh in a single draw call.
+ * Call `set` (and optionally `setColor`) for the instances that changed, then `commit(count)`
+ * to show the first `count` instances and upload the changes.
+ */
+export declare class MeshInstances {
+  readonly mesh: THREE.InstancedMesh;
+  readonly capacity: number;
+  private readonly matrix;
+  constructor(geometry: THREE.BufferGeometry, material: THREE.Material, capacity: number);
+  /**
+   * Places instance `index` at (x, y, z) with a uniform `scale` and a rotation around the vertical axis.
+   * For a fixed tilt every instance shares (a flat ring lying on the floor), rotate the geometry once instead.
+   */
+  set(index: number, x: number, y: number, z: number, scale?: number, rotationY?: number): void;
+  setColor(index: number, color: THREE.Color): void;
+  /** Shows the first `count` instances and uploads this frame's changes. */
+  commit(count: number): void;
+  dispose(): void;
+}
+/**
+ * Screen pixels per sprite pixel that best shows `viewHeight` world units on a drawing buffer
+ * `bufferHeight` pixels tall: the nearest whole number, at least 1.
+ */
+export declare const pixelScale: (bufferHeight: number, viewHeight: number, pixelsPerUnit: number) => number;
+/**
+ * The largest whole number of screen pixels per sprite pixel at which a `width` x `depth` world
+ * unit area fits a `bufferWidth` x `bufferHeight` drawing buffer, at least 1 (a buffer too
+ * small for the area at 1 crops it).
+ */
+export declare const fitPixelScale: (bufferWidth: number, bufferHeight: number, width: number, depth: number, pixelsPerUnit: number) => number;
+/**
+ * Rounds a world position to the nearest pixel edge, at `pixelsPerUnit` pixels per world unit:
+ * sprite pixels with the sheet's density, or screen pixels with the camera's.
+ */
+export declare const snapToPixel: (value: number, pixelsPerUnit: number) => number;
+/**
+ * The frustum for a `bufferWidth` x `bufferHeight` drawing buffer at `pixelsPerWorldUnit`
+ * screen pixels per world unit, around a camera at the origin. An odd size gets its spare
+ * pixel on the right or bottom, so the camera's position stays on a screen pixel's corner.
+ */
+export declare const pixelFrustum: (bufferWidth: number, bufferHeight: number, pixelsPerWorldUnit: number) => {
+  readonly left: number;
+  readonly right: number;
+  readonly top: number;
+  readonly bottom: number;
+};
+interface PixelCameraOptions {
+  /** Sprite pixels per world unit: 16 draws a 16 px enemy one unit wide. Defaults to 16. */
+  readonly pixelsPerUnit?: number;
+  /**
+   * About how many world units of ground to show top to bottom. The camera picks the whole
+   * number of screen pixels per sprite pixel that comes nearest. Defaults to 20.
+   */
+  readonly viewHeight?: number;
+}
+/**
+ * An orthographic camera looking straight down at the ground plane (y = 0), with +x to the
+ * right and +z down the screen, so a larger z is lower on screen. It keeps sprite pixels whole:
+ * `pixelScale` screen pixels per sprite pixel, a whole number, and a position on whole screen
+ * pixels. Give it the drawing buffer's size with `setBufferSize` (a `Stage` made with
+ * `camera: "pixel"` does, on every resize), then `follow` a point or `fit` an area each frame.
+ * Don't move it with `fitCamera` or `lookAt`: they undo the snapping.
+ */
+export declare class PixelCamera extends THREE.OrthographicCamera {
+  readonly isPixelCamera = true;
+  private pixelsPerUnitValue;
+  private viewHeightValue;
+  private screenScale;
+  private bufferWidth;
+  private bufferHeight;
+  private targetX;
+  private targetZ;
+  /** Set by `fit`, cleared by `follow`. */
+  private fitted;
+  constructor(options?: PixelCameraOptions);
+  /** Sprite pixels per world unit. */
+  get pixelsPerUnit(): number;
+  /** Screen pixels per sprite pixel: a whole number, at least 1. */
+  get pixelScale(): number;
+  /** Screen (drawing buffer) pixels per world unit. */
+  get screenPixelsPerUnit(): number;
+  /** The ground height to aim for, in world units. Takes effect at once. */
+  setViewHeight(viewHeight: number): void;
+  /** The drawing buffer's size in pixels (`renderer.getDrawingBufferSize`), not CSS pixels. */
+  setBufferSize(width: number, height: number): void;
+  /** Centres the view on a ground point, snapped to the nearest screen pixel. Survivors' hero. */
+  follow(x: number, z: number): void;
+  /**
+   * Shows all of an area plus `margin` world units around it, at the largest whole pixel scale
+   * that fits, centred on it. It keeps fitting on resize until the next `follow`. A puzzle board.
+   */
+  fit(bounds: GroundBounds, margin?: number): void;
+  private update;
+}
+/** Which camera a Stage builds. */
+type StageCameraKind = "perspective" | "orthographic" | "pixel";
+/** The camera type for a kind: what `Stage.camera` is. */
+type StageCamera<K extends StageCameraKind> = K extends "pixel" ? PixelCamera : K extends "orthographic" ? THREE.OrthographicCamera : THREE.PerspectiveCamera;
+interface StageOptions<K extends StageCameraKind = "perspective"> {
+  /**
+   * "perspective" (the default) for a 3D world seen from a point. "orthographic" for a flat
+   * board, where sizes shouldn't shrink with distance; place it with `fitCamera`. "pixel" for
+   * pixel art seen straight down (a `PixelCamera`); the stage keeps it told the drawing buffer's size.
+   */
+  readonly camera?: K;
+  /**
+   * Height of an orthographic camera's view, in world units, until `fitCamera` changes it.
+   * Defaults to 10. For a pixel camera, the height it aims for (defaults to 20).
+   */
+  readonly viewHeight?: number;
+  /** Pixel camera only: sprite pixels per world unit. Defaults to 16. */
+  readonly pixelsPerUnit?: number;
+  readonly background?: THREE.ColorRepresentation;
+}
+/**
+ * A renderer, scene and camera that fill a container element and resize with it.
+ * The camera is perspective unless `camera: "orthographic"` or `"pixel"` is passed; on resize, an
+ * orthographic camera keeps its view height and widens or narrows to the new aspect ratio, and a
+ * pixel camera picks its pixel scale again. The pixel ratio is read again on every resize, and
+ * a pixel stage sizes its drawing buffer to the canvas's exact device pixels, where the others
+ * cap the ratio at 2 (see `drawingBuffer`). The camera is public: change its fields (a
+ * perspective camera's `fov`, `near` and `far`) and call `updateProjectionMatrix()`. So is the
+ * scene: set `stage.scene.fog` for fog.
+ * `dispose()` frees every GPU resource in the scene, except kept textures (see `keepTexture`),
+ * and removes the canvas.
+ */
+export declare class Stage<K extends StageCameraKind = "perspective"> {
+  readonly renderer: THREE.WebGLRenderer;
+  readonly scene: THREE.Scene;
+  readonly camera: StageCamera<K>;
+  private readonly container;
+  private readonly resizeObserver;
+  constructor(container: HTMLElement, options?: StageOptions<K>);
+  render(): void;
+  dispose(): void;
+  private resize;
+}
+/**
+ * Marks a texture that something outside the scene owns, such as a sprite sheet the app
+ * loaded: `disposeObject` and `Stage.dispose` leave it alone, and its owner disposes it.
+ * Returns the texture.
+ */
+export declare const keepTexture: <T extends THREE.Texture>(texture: T) => T;
+/** Whether `keepTexture` marked this texture. */
+export declare const isKeptTexture: (texture: THREE.Texture) => boolean;
+/**
+ * Frees the geometries, materials and textures of `root` and everything under it: the textures
+ * a material holds (its maps, and a shader material's texture uniforms) and, for a scene, its
+ * background and environment. Textures marked with `keepTexture` are skipped.
+ * `Stage.dispose` calls it on the whole scene. A view that removes an object from the
+ * scene calls it on that object, which `Stage.dispose` no longer reaches.
+ */
+export declare const disposeObject: (root: THREE.Object3D) => void;
+export type { FitCameraOptions, GroundBounds, InstancedSpritesOptions, PixelCameraOptions, SpriteFrame, SpriteSheet, SpriteSheetData, SpriteTag, SpriteTagDirection, StageCamera, StageCameraKind, StageOptions };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/camera.ts","../src/sprite-sheet.ts","../src/sprite-loader.ts","../src/instanced-sprites.ts","../src/mesh-instances.ts","../src/pixel-camera.ts","../src/stage.ts"],"mappings":";;;qBAMa,eACX,QAAQ,MAAM,QACd;WAAmB;WAAoB;GACvC;WAAmB;WAAoB;WAAoB;;;;;;;qBAWhD,cACX,QAAQ,MAAM,QACd;WAAmB;WAAoB;GACvC;WACW;WACA;WACA;;;UAYI;WACN;WACA;WACA;WACA;;UAGM;;WAEN;;;;;WAKA;;;;;;;;;;;;;;qBAeE,YACX,QAAQ,MAAM,oBAAoB,MAAM,oBACxC,QAAQ,cACR,UAAS;cChEL,sBAAsB,kBACnB,KAAK;;qBAID,yBAAyB;WAC3B;WACA;WACA;;;KAIC;;UAOK;;WAEN;;WAEA;WACA;WACA;WACA;;WAEA;WACA;;WAEA;WACA;;WAEA;;;UAIM;WACN;;WAEA;WACA;WACA,WAAW;;WAEX;;;UAIM;;WAEN;;WAEA;WACA;WACA,iBAAiB;;WAEjB,aAAa;WACb,MAAM,oBAAoB;;;;;;;;qBAqDxB,oBACX,cACA,kBACC,OAAO,OAAO,iBAAiB;;;;;;qBAyKrB,UACX,OAAO,iBACP,KAAK,WACL;;;;;;UCxRe;WACN,MAAM;;WAEN,SAAS,MAAM;WACf;;;;;;qBAOE,kBACX,MAAM,iBACN,OAAO,mBACN;;;;;;qBA4BU,kBACX,oBACC,OAAO,OAAO,aAAa;UCoBb;;WAEN;;WAEA;;;;;;WAMA;aAAoB;aAAoB;;;;;;;WAMxC;;;;;;WAMA;;WAEA;;WAEA;;;;;WAKA;;;;;;;;;;;;;qBAcE;WACF,MAAM,MAAM,KACnB,MAAM,yBACN,MAAM;WAEC;WACA,OAAO;mBACC;mBACA;mBACA;mBACA;mBACA;EAEjB,YAAY,OAAO,aAAa,SAAS;;;;;;EAqDzC,IAAI,eAAe,WAAW,WAAW,eAAe;;EAQxD,QAAQ,eAAe,OAAO,MAAM,OAAO;;EAK3C,SAAS,eAAe;;EAKxB,SAAS,eAAe;;;;;EAQxB,QAAQ,eAAe;;EAKvB,SAAS,eAAe;;EAKxB,OAAO;;EAWP;;;;;;;qBCjOW;WACF,MAAM,MAAM;WACZ;mBACQ;EAEjB,YACE,UAAU,MAAM,gBAChB,UAAU,MAAM,UAChB;;;;;EAgBF,IACE,eACA,WACA,WACA,WACA,gBACA;EAcF,SAAS,eAAe,OAAO,MAAM;;EAKrC,OAAO;EAQP;;;;;;qBCpDW,aACX,sBACA,oBACA;;;;;;qBASW,gBACX,qBACA,sBACA,eACA,eACA;;;;;qBAgBW,cAAe,eAAe;;;;;;qBAQ9B,eACX,qBACA,sBACA;WAES;WACA;WACA;WACA;;UAYM;;WAEN;;;;;WAKA;;;;;;;;;;qBAWE,oBAAoB,MAAM;WAC5B;UACD;UACA;UACA;UACA;UACA;UACA;UACA;;UAEA;EAER,YAAY,UAAS;;MAUjB;;MAKA;;MAKA;;EAKJ,cAAc;;EAMd,cAAc,eAAe;;EAO7B,OAAO,WAAW;;;;;EAWlB,IAAI,QAAQ,cAAc;UAYlB;;;KCjKE;;KAGA,YAAY,UAAU,mBAAmB,oBACjD,cACA,2BACE,MAAM,qBACN,MAAM;UAEK,aAAa,UAAU;;;;;;WAM7B,SAAS;;;;;WAKT;;WAEA;WACA,aAAa,MAAM;;;;;;;;;;;;;;qBA0BjB,MAAM,UAAU;WAClB,UAAU,MAAM;WAChB,OAAO,MAAM;WACb,QAAQ,YAAY;mBACZ;mBACA;EAEjB,YAAY,WAAW,aAAa,UAAS,aAAa;EA8D1D;EAIA;UAOQ;;;;;;;qBAyEG,cAAe,UAAU,MAAM,SAAS,SAAS,MAAI;;qBAMrD,gBAAiB,SAAS,MAAM;;;;;;;;qBAUhC,gBAAiB,MAAM,MAAM"}