@phaserjs/phaser-editor-layout 1.0.0

package/README.md

@@ -0,0 +1,304 @@
+# @phaserjs/phaser-editor-layout
+
+A small **responsive layout runtime for Phaser 3**: anchor game objects to zones and
+device safe areas, and have them re-flow automatically when the screen resizes or the
+device orientation changes.
+
+It is the runtime counterpart to Phaser Editor's responsive layout system — the same
+resolver runs in the editor's live preview and in your game, so what you see in the
+editor is what you get at run time. It also works perfectly well as a standalone library
+without the editor.
+
+> **Phaser version.** This targets **Phaser 3** (`^3.60.0`). A Phaser 4 build will
+> follow; the API is intended to carry over unchanged.
+
+## Install
+
+```bash
+npm install @phaserjs/phaser-editor-layout
+```
+
+`phaser` is a peer dependency — the library uses whatever Phaser 3 build your project
+already has.
+
+## Concepts
+
+- **Scene plugin (`this.layout`).** The library is a Phaser *Scene Plugin*, reached as
+  `this.layout`, exactly like `this.physics`. It keeps the set of laid-out objects and
+  re-resolves them when the screen changes.
+- **`obj.layoutData`.** Per-object layout state lives on the object as `obj.layoutData`
+  (cf. `obj.body` for physics). Its anchor properties are split into variants
+  (`base` / `portrait` / `landscape`); you configure layout by setting plain fields on
+  them.
+- **Zones.** A zone is a screen-relative rectangle defined by margins from each screen
+  edge (also split into `base` / `portrait` / `landscape`). The built-ins are `screen`
+  (full bounds) and `safeArea` (insets supplied by the host). Make your own with
+  `createZone(...)`.
+- **Anchors.** Per axis you pick an edge (`left`/`center`/`right`, `top`/`center`/
+  `bottom`, or `none`) plus a pixel offset. The object's matching edge/center is aligned
+  to the target's, then nudged by the offset.
+- **Variants.** Both zones and layout data carry a `base` plus `portrait` / `landscape`
+  overrides. The active variant (see `this.layout.variant`) selects which overrides
+  apply on top of `base`, so one object can lay out differently per orientation.
+
+## Quick start
+
+### 1. Register the plugin
+
+```ts
+import Phaser from "phaser";
+import { LayoutPlugin } from "@phaserjs/phaser-editor-layout";
+
+new Phaser.Game({
+    type: Phaser.AUTO,
+    scale: {
+        mode: Phaser.Scale.RESIZE, // so the layout follows the window/orientation
+        width: 1080,
+        height: 1920,
+    },
+    plugins: {
+        scene: [
+            { key: "LayoutPlugin", plugin: LayoutPlugin, mapping: "layout" },
+        ],
+    },
+    scene: [MainScene],
+});
+```
+
+The `mapping: "layout"` makes the plugin available as `this.layout` in every scene, and
+the bundled TypeScript types make `this.layout` and `obj.layoutData` strongly typed.
+
+### 2. Anchor objects in a scene
+
+```ts
+export class MainScene extends Phaser.Scene {
+
+    create() {
+        // Built-in zones are always available: this.layout.screen and this.layout.safeArea.
+        // Make a custom zone: createZone(top, right, bottom, left).
+        const reelsZone = this.layout.createZone(360, 90, 470, 90);
+
+        // Top-centered logo, anchored to the safe area. Configure the `base` variant.
+        const logo = this.add.image(0, 0, "logo");
+        const logoData = this.layout.add(logo);
+        logoData.base.targetType = "safeArea";
+        logoData.base.horizontalAnchor = "center";
+        logoData.base.verticalAnchor = "top";
+        logoData.base.verticalOffset = 24;
+
+        // Bottom-right button, 40px in from the safe-area corner.
+        const hud = this.add.image(0, 0, "hud");
+        const hudData = this.layout.add(hud);
+        hudData.base.targetType = "safeArea";
+        hudData.base.horizontalAnchor = "right";
+        hudData.base.horizontalOffset = -40;
+        hudData.base.verticalAnchor = "bottom";
+        hudData.base.verticalOffset = -40;
+
+        // Centered in a custom zone — "custom" is the one target that needs targetZone.
+        const reels = this.add.image(0, 0, "reels");
+        const reelsData = this.layout.add(reels);
+        reelsData.base.targetType = "custom";
+        reelsData.base.targetZone = reelsZone;
+        reelsData.base.horizontalAnchor = "center";
+        reelsData.base.verticalAnchor = "center";
+    }
+}
+```
+
+`add()` returns the object's `AnchorLayoutData`; you can also configure it via
+`logo.layoutData!`. Setting only `base` (as above) means the object lays out the same in
+every orientation — see [Variants & orientation](#variants--orientation) to vary it.
+
+### 3. Feed the device safe area (optional)
+
+The safe area is unknown at author time, so the host supplies it. On the web that's the
+CSS `env(safe-area-inset-*)` values; in a native wrapper it's a device plugin. Set the
+`safeArea` margins and re-resolve:
+
+```ts
+this.layout.safeArea.base.marginTop = insets.top;
+this.layout.safeArea.base.marginRight = insets.right;
+this.layout.safeArea.base.marginBottom = insets.bottom;
+this.layout.safeArea.base.marginLeft = insets.left;
+this.layout.refresh();
+```
+
+## Anchoring inside a prefab (Parent Bounds)
+
+A prefab is a `GameObject` (e.g. a `Container`), not a `Scene`, so it reaches the plugin
+through `this.scene.layout`. Use `targetType: "parent"` to lay children out against the
+prefab's own bounds:
+
+```ts
+export class CollectorPrefab extends Phaser.GameObjects.Container {
+
+    constructor(scene: Phaser.Scene, x: number, y: number) {
+        super(scene, x, y);
+        this.setSize(300, 260); // containers have no intrinsic size
+
+        const coinIcon = scene.add.image(0, 0, "coin");
+        this.add(coinIcon);
+
+        const icon = scene.layout.add(coinIcon);
+        icon.base.targetType = "parent"; // resolves against this container's bounds
+        icon.base.horizontalAnchor = "left";
+        icon.base.horizontalOffset = 20;
+        icon.base.verticalAnchor = "center";
+    }
+}
+```
+
+## Variants & orientation
+
+Both `obj.layoutData` and every zone carry three variants — `base`, `portrait`,
+`landscape`. `base` is the baseline; `portrait` / `landscape` hold only the fields that
+differ. The resolver uses `active[prop] ?? base[prop]`, where the active variant is
+`this.layout.variant`.
+
+Pick the active variant in one of two ways (default is manual, `"base"`):
+
+```ts
+// Manual:
+this.layout.setVariant("portrait");
+
+// Or orientation-driven — follows the screen on every resize:
+this.layout.autoVariant(true);
+```
+
+Author once, and rotating re-flows automatically:
+
+```ts
+// Safe area: notch on top in portrait, on the left in landscape.
+this.layout.safeArea.portrait.marginTop = 120;
+this.layout.safeArea.landscape.marginLeft = 120;
+
+// A button: bottom-center in portrait, right-center in landscape.
+const data = this.layout.add(button);
+data.base.targetType = "safeArea";
+data.portrait.horizontalAnchor = "center";
+data.portrait.verticalAnchor = "bottom";
+data.portrait.verticalOffset = -40;
+data.landscape.horizontalAnchor = "right";
+data.landscape.horizontalOffset = -40;
+data.landscape.verticalAnchor = "center";
+
+this.layout.autoVariant(true);
+```
+
+See the `mobile-orientation` example for the full picture.
+
+## When does layout resolve?
+
+- **Automatically** once after the scene's `create`, and on every `scale` `resize`
+  (window resize, orientation change, etc.).
+- **Manually** via `this.layout.refresh()` after you mutate `obj.layoutData` or the
+  `safeArea` margins at run time. There is no setter to hook — fields are set directly —
+  so an explicit `refresh()` is how changes take effect immediately.
+
+`refresh()` always runs a full, ordered pass (parents before children), so a child
+anchored to its parent always sees the parent's resolved position. The pass is just
+arithmetic over the registered objects, so it is cheap.
+
+## Reacting to layout
+
+The plugin fires `layoutupdate` after each pass:
+
+```ts
+import { LAYOUT_UPDATE_EVENT } from "@phaserjs/phaser-editor-layout";
+
+this.layout.on(LAYOUT_UPDATE_EVENT, () => {
+    // reposition non-layout decorations, redraw overlays, etc.
+});
+```
+
+`this.layout.on/once/off` delegate to the plugin's `events` emitter
+(`this.layout.events`).
+
+## API
+
+### `this.layout` (`LayoutPlugin`)
+
+| Member | Description |
+| --- | --- |
+| `safeArea: LayoutZone` | Screen inset by the device safe-area insets. Set `safeArea.base.margin*` (or per-variant) from the host. |
+| `screen: LayoutZone` | The full screen bounds. |
+| `variant: VariantName` | The active variant (`"base" \| "portrait" \| "landscape"`). Defaults to `"base"`. |
+| `add(obj): AnchorLayoutData` | Enable layout for `obj`: attaches a default `obj.layoutData`, registers it, and returns the data to configure. |
+| `remove(obj): void` | Stop laying out `obj` and clear its `layoutData`. |
+| `createZone(top?, right?, bottom?, left?): LayoutZone` | Create a custom screen-relative zone (sets its `base` margins). Assign it to `data.<variant>.targetZone` with `targetType: "custom"`. |
+| `setVariant(variant): void` | Manually set the active variant (turns off auto) and re-resolve. |
+| `autoVariant(enabled?): void` | Follow the screen orientation on every resize (`portrait` / `landscape`); disabling resets to `"base"`. |
+| `get orientation()` | The screen's current orientation (`"portrait"` if `height > width`, else `"landscape"`). |
+| `refresh(): void` | Re-resolve every enabled object now (full, ordered pass). |
+| `events: Phaser.Events.EventEmitter` | Emits `layoutupdate` after each pass. |
+| `on/once/off(...)` | Delegates to `events`. |
+
+### `AnchorLayoutData` (`obj.layoutData`)
+
+| Field | Type | Description |
+| --- | --- | --- |
+| `enabled` | `boolean` | When `false`, the object keeps its raw `x`/`y` and is skipped ("Absolute" mode). |
+| `base` | `AnchorProps` | Baseline anchor properties; the resolver falls back here for unset variant fields. |
+| `portrait` | `AnchorProps` | Overrides applied when `variant === "portrait"`. |
+| `landscape` | `AnchorProps` | Overrides applied when `variant === "landscape"`. |
+
+Defaults from `add(obj)`: `enabled: true`, `base` = `{ targetType: "screen", anchors
+"none", zero offsets }`, empty `portrait` / `landscape` — i.e. inert until you choose
+anchors.
+
+### `AnchorProps` (`data.base` / `data.portrait` / `data.landscape`)
+
+All fields optional; on `portrait` / `landscape` an unset field inherits from `base`.
+
+| Field | Type | Description |
+| --- | --- | --- |
+| `targetType` | `"screen" \| "safeArea" \| "parent" \| "custom"` | What to anchor to: the screen, the device safe area, the object's parent-container bounds, or a custom zone. |
+| `targetZone` | `LayoutZone?` | The zone to anchor to when `targetType === "custom"`. |
+| `horizontalAnchor` | `"left" \| "center" \| "right" \| "none"` | Horizontal anchor edge. `none` keeps the current `x`. |
+| `horizontalOffset` | `number` | Pixel offset applied after the horizontal anchor. |
+| `verticalAnchor` | `"top" \| "center" \| "bottom" \| "none"` | Vertical anchor edge. `none` keeps the current `y`. |
+| `verticalOffset` | `number` | Pixel offset applied after the vertical anchor. |
+
+### `LayoutZone`
+
+| Member | Description |
+| --- | --- |
+| `base: { marginTop, marginRight, marginBottom, marginLeft }` | Baseline insets from each screen edge, in pixels. |
+| `portrait / landscape` | Partial margin overrides for those variants; unset sides inherit `base`. |
+| `getRect(out?): Phaser.Geom.Rectangle` | The effective rect at the current screen size and active variant. Pass `out` to avoid allocations. |
+
+## Resolution semantics
+
+Given the target rect `t` and the object size `w`×`h` (its `displayWidth` /
+`displayHeight`), each axis aligns the object's edge/center to the target's, accounting
+for the object's `origin`:
+
+- `left` / `top` → align the object's left/top edge to `t.left`/`t.top` + offset.
+- `right` / `bottom` → align its right/bottom edge to `t.right`/`t.bottom` + offset.
+- `center` → align its center to the target's center + offset.
+- `none` → leave that axis unchanged.
+
+For centered-origin objects (`origin = 0.5`) this reduces to the familiar
+`x = t.left + offset + w / 2` form.
+
+The properties used (`targetType`, anchors, offsets) and the zone rect `t` are first
+resolved for the active variant as `active[prop] ?? base[prop]`, so portrait/landscape
+overrides and per-variant zone margins both feed into the same alignment math.
+
+## Notes & current limitations
+
+- **Default camera assumed.** Zones are computed in screen pixels, treated as world
+  coordinates. Objects on a scrolled/zoomed camera are not yet special-cased.
+- **Parent Bounds geometry.** With `targetType: "parent"`, the parent container's rect
+  is taken as `(0, 0, parent.width, parent.height)` in its local space, so call
+  `setSize(...)` on the container. Children are aligned within that rect; parent
+  rotation is not specially handled.
+- **No stretch (v1).** Each axis anchors a single edge, so "fill width minus margins" is
+  not expressible yet.
+- **Serialization is out of scope here.** This package is the *runtime*; the editor owns
+  how layout data and zone references are stored in `.scene` files.
+
+## License
+
+MIT

package/dist/LayoutPlugin.d.ts

@@ -0,0 +1,147 @@
+import Phaser from "phaser";
+import { LayoutZone } from "./LayoutZone";
+import type { AnchorLayoutData, VariantName } from "./types";
+/** Event fired by the plugin after each resolution pass. */
+export declare const LAYOUT_UPDATE_EVENT = "layoutupdate";
+/**
+ * Scene plugin that resolves responsive anchors and zones at run time.
+ *
+ * Reached as `this.layout` (like `this.physics`) once registered with
+ * `mapping: "layout"`. Per-object layout state lives on the object as
+ * `obj.layoutData`; the plugin keeps the set of enabled objects so it can
+ * re-resolve them when the screen changes.
+ *
+ * Register it in the game config:
+ *
+ * ```ts
+ * plugins: {
+ *     scene: [
+ *         { key: "LayoutPlugin", plugin: LayoutPlugin, mapping: "layout" }
+ *     ]
+ * }
+ * ```
+ */
+export declare class LayoutPlugin extends Phaser.Plugins.ScenePlugin {
+    /** Screen inset by the device safe-area insets. The host sets `safeArea.margin*`. */
+    readonly safeArea: LayoutZone;
+    /** The full screen bounds (0,0 .. width,height). */
+    readonly screen: LayoutZone;
+    /**
+     * Event emitter that fires {@link LAYOUT_UPDATE_EVENT} after each resolution pass.
+     * Use `this.layout.events.on("layoutupdate", ...)` — or the `on`/`once`/`off`
+     * delegates on the plugin itself.
+     */
+    readonly events: Phaser.Events.EventEmitter;
+    /**
+     * The active layout variant. `"base"` applies only the baseline; `"portrait"` /
+     * `"landscape"` apply their overrides on top of base. Defaults to `"base"`. Change
+     * it with {@link setVariant} (manual) or {@link autoVariant} (orientation-driven).
+     */
+    variant: VariantName;
+    private readonly _scene;
+    private _auto;
+    private _designSize;
+    private readonly _objects;
+    private readonly _rect;
+    private readonly _mat;
+    private readonly _p1;
+    private readonly _p2;
+    constructor(scene: Phaser.Scene, pluginManager: Phaser.Plugins.PluginManager, pluginKey: string);
+    boot(): void;
+    /**
+     * The injected design size, or `null` when resolution follows the live scene size
+     * (`scale.gameSize`). Read by zones (the plugin is their {@link LayoutZone} provider).
+     */
+    get designSize(): {
+        width: number;
+        height: number;
+    } | null;
+    /**
+     * Resolve against a fixed design size (e.g. 1080×1920) instead of the live canvas
+     * size, then re-resolve. Hosts that author/preview layouts at a target resolution
+     * (the editor) use this; games typically leave it unset and follow `scale.gameSize`.
+     */
+    setDesignSize(width: number, height: number): void;
+    /** Clear the injected design size and fall back to the live scene size, then re-resolve. */
+    clearDesignSize(): void;
+    /** The effective size used for resolution: the injected design size, or the live game size. */
+    private _size;
+    /** The screen's current orientation, derived from the effective design size. */
+    get orientation(): "portrait" | "landscape";
+    /**
+     * Manually set the active variant and re-resolve. Turns off orientation
+     * auto-detection (see {@link autoVariant}).
+     */
+    setVariant(variant: VariantName): void;
+    /**
+     * Enable (or disable) orientation-driven variant selection. When enabled, the active
+     * variant follows {@link orientation} (`"portrait"` / `"landscape"`) on every resize.
+     * Disabling resets the variant to `"base"`.
+     */
+    autoVariant(enabled?: boolean): void;
+    private _onResize;
+    /**
+     * Enable layout for an object: attaches a default {@link AnchorLayoutData} as
+     * `obj.layoutData` (if it does not have one yet), registers the object for
+     * re-resolution, and returns the data so it can be configured.
+     *
+     * The `base` defaults are inert: `targetType: "screen"`, both anchors `"none"` and
+     * zero offsets, so the object does not move until you choose anchors. `portrait` and
+     * `landscape` start empty (they inherit `base`).
+     */
+    add<T extends Phaser.GameObjects.GameObject>(obj: T): AnchorLayoutData;
+    /** Stop laying out an object and remove its `layoutData`. */
+    remove(obj: Phaser.GameObjects.GameObject): void;
+    private _onObjectDestroy;
+    /**
+     * Create a screen-relative zone. A factory only — the returned zone is not stored
+     * by the plugin; hold the reference and assign it to `data.targetZone`.
+     */
+    createZone(marginTop?: number, marginRight?: number, marginBottom?: number, marginLeft?: number): LayoutZone;
+    /**
+     * Re-resolve every enabled object now. The plugin also runs this automatically on
+     * `scale` `resize` and once after the scene is created, so explicit calls are only
+     * needed after mutating layout data (or the `safeArea` margins) at run time.
+     *
+     * Objects are resolved parent → child so a child anchored to its parent's bounds
+     * sees the parent's already-resolved rect.
+     */
+    refresh(): void;
+    /**
+     * Resolve a specific list of objects once, against the current variant / design size /
+     * zones, **without** registering them for future passes (no {@link add}, no re-resolve
+     * on resize). Hosts that drive resolution themselves — e.g. the editor's live preview —
+     * set each object's `layoutData`, call this, then read back the resolved `x`/`y`.
+     *
+     * Objects are still resolved parent → child, and any object whose `layoutData` is
+     * missing or disabled is skipped.
+     */
+    resolveList(objects: Phaser.GameObjects.GameObject[]): void;
+    private _depth;
+    private _resolve;
+    /** Merge the active variant's overrides over `base` into concrete anchor properties. */
+    private _effective;
+    /** The zone a non-parent target resolves against. */
+    private _zoneFor;
+    /** Resolve against a zone's world rect, converting to parent-local space if nested. */
+    private _resolveAgainstZone;
+    /** Resolve against the object's parent container bounds (local space), or the screen. */
+    private _resolveAgainstParent;
+    /**
+     * Resolve one axis. Aligns the object's edge/center to the target edge/center,
+     * accounting for the object's origin so `"left"`/`"top"` align the left/top edge,
+     * `"center"` the center, and `"right"`/`"bottom"` the right/bottom edge.
+     *
+     * Reduces to the documented `t.left + offset + size / 2` form for centered-origin
+     * objects (`origin = 0.5`).
+     */
+    private _axis;
+    private _sizeX;
+    private _sizeY;
+    on(event: string | symbol, fn: (...args: any[]) => void, context?: any): this;
+    once(event: string | symbol, fn: (...args: any[]) => void, context?: any): this;
+    off(event: string | symbol, fn?: (...args: any[]) => void, context?: any, once?: boolean): this;
+    shutdown(): void;
+    destroy(): void;
+}
+//# sourceMappingURL=LayoutPlugin.d.ts.map

package/dist/LayoutPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LayoutPlugin.d.ts","sourceRoot":"","sources":["../src/LayoutPlugin.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,QAAQ,CAAC;AAC5B,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,KAAK,EAAE,gBAAgB,EAAgC,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3F,4DAA4D;AAC5D,eAAO,MAAM,mBAAmB,iBAAiB,CAAC;AAYlD;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,YAAa,SAAQ,MAAM,CAAC,OAAO,CAAC,WAAW;IAExD,qFAAqF;IACrF,QAAQ,CAAC,QAAQ,EAAE,UAAU,CAAC;IAE9B,oDAAoD;IACpD,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;IAE5B;;;;OAIG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC;IAE5C;;;;OAIG;IACH,OAAO,EAAE,WAAW,CAAU;IAI9B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAe;IAGtC,OAAO,CAAC,KAAK,CAAS;IAGtB,OAAO,CAAC,WAAW,CAAkD;IAErE,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAqC;IAG9D,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAwB;IAC9C,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAgD;IACrE,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAsB;IAC1C,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAsB;gBAGtC,KAAK,EAAE,MAAM,CAAC,KAAK,EACnB,aAAa,EAAE,MAAM,CAAC,OAAO,CAAC,aAAa,EAC3C,SAAS,EAAE,MAAM;IAiBrB,IAAI,IAAI,IAAI;IAaZ;;;OAGG;IACH,IAAI,UAAU,IAAI;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAGzD;IAED;;;;OAIG;IACH,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAMlD,4FAA4F;IAC5F,eAAe,IAAI,IAAI;IAMvB,+FAA+F;IAC/F,OAAO,CAAC,KAAK;IAOb,gFAAgF;IAChF,IAAI,WAAW,IAAI,UAAU,GAAG,WAAW,CAK1C;IAED;;;OAGG;IACH,UAAU,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI;IAOtC;;;;OAIG;IACH,WAAW,CAAC,OAAO,UAAO,GAAG,IAAI;IAOjC,OAAO,CAAC,SAAS;IAYjB;;;;;;;;OAQG;IACH,GAAG,CAAC,CAAC,SAAS,MAAM,CAAC,WAAW,CAAC,UAAU,EAAE,GAAG,EAAE,CAAC,GAAG,gBAAgB;IA6BtE,6DAA6D;IAC7D,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,WAAW,CAAC,UAAU,GAAG,IAAI;IAShD,OAAO,CAAC,gBAAgB;IAOxB;;;OAGG;IACH,UAAU,CACN,SAAS,SAAI,EACb,WAAW,SAAI,EACf,YAAY,SAAI,EAChB,UAAU,SAAI,GACf,UAAU;IAOb;;;;;;;OAOG;IACH,OAAO,IAAI,IAAI;IAwBf;;;;;;;;OAQG;IACH,WAAW,CAAC,OAAO,EAAE,MAAM,CAAC,WAAW,CAAC,UAAU,EAAE,GAAG,IAAI;IAc3D,OAAO,CAAC,MAAM;IAcd,OAAO,CAAC,QAAQ;IAsBhB,wFAAwF;IACxF,OAAO,CAAC,UAAU;IAelB,qDAAqD;IACrD,OAAO,CAAC,QAAQ;IAehB,uFAAuF;IACvF,OAAO,CAAC,mBAAmB;IAoC3B,yFAAyF;IACzF,OAAO,CAAC,qBAAqB;IAmC7B;;;;;;;OAOG;IACH,OAAO,CAAC,KAAK;IA4Bb,OAAO,CAAC,MAAM;IAUd,OAAO,CAAC,MAAM;IAYd,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,EAAE,OAAO,CAAC,EAAE,GAAG,GAAG,IAAI;IAO7E,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,EAAE,OAAO,CAAC,EAAE,GAAG,GAAG,IAAI;IAO/E,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,EAAE,OAAO,CAAC,EAAE,GAAG,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI;IAS/F,QAAQ,IAAI,IAAI;IAYhB,OAAO,IAAI,IAAI;CAQlB"}